openclaw/test/scripts/plugin-inventory-module-refs.test.ts

import fs from "node:fs";
import { createRequire } from "node:module";
import path from "node:path";
import { build } from "tsdown";
import { afterEach, expect, it } from "vitest";
import { createPluginInventoryModuleRefsPlugin } from "../../scripts/lib/plugin-inventory-module-refs.mts";
import { buildPluginNpmRuntime } from "../../scripts/lib/plugin-npm-runtime-build.mts";
import {
  createPluginCache,
  retirePluginCache,
  withPluginCache,
} from "../../src/plugins/plugin-cache.js";
import { createPluginManifestRecordFixture } from "../../src/plugins/plugin-metadata.test-support.js";
import { getPluginSetupModuleLoader } from "../../src/plugins/plugin-setup-module.js";
import configs from "../../tsdown.config.ts";
import { useAutoCleanupTempDirTracker } from "../helpers/temp-dir.js";

const temp = useAutoCleanupTempDirTracker(afterEach);
const requireHost = createRequire(import.meta.url);
const sdk = "openclaw/plugin-sdk/channel-entry-contract";

it.each([
  { binding: "alias", origin: "bundled", evaluations: 1 },
  { binding: "namespace", origin: "bundled", evaluations: 1 },
  { binding: "inventory", origin: "bundled", evaluations: 1 },
  { binding: "unrelated", origin: "bundled", evaluations: 0 },
  { binding: "esm", origin: "global", evaluations: 2 },
  { binding: "cjs", origin: "global", evaluations: 2 },
  { binding: "esm", origin: "bundled", evaluations: 1 },
  { binding: "cjs", origin: "bundled", evaluations: 1 },
] as const)(
  "builds only declared SDK companion edges for $binding ($origin)",
  async ({ binding, origin, evaluations }) => {
    const root = temp.make("inventory companion ");
    const write = (name: string, source: string) => {
      const file = path.join(root, name);
      fs.writeFileSync(file, source);
      return file;
    };
    const format = binding === "esm" || binding === "cjs" ? binding : undefined;
    const runtimeExtension = format === "cjs" ? "cjs" : "js";
    write(
      "package.json",
      JSON.stringify({
        type: "module",
        version: "1.0.0",
        openclaw: {
          extensions: ["./companion.ts"],
          setupEntry: "./setup.ts",
          build: { runtimeFormat: format },
        },
      }),
    );
    const event = `inventory:${root}`;
    const companion = write(
      "companion.ts",
      `import process from 'node:process';
    process.on(${JSON.stringify(event)}, () => {});
    export const channelPlugin = { id: 'fixture' };
    export const runtimeSelectedExport = 'retained';`,
    );
    const pluginId = binding === "inventory" ? "openai" : "a2a";
    const entryName = `extensions/${pluginId}/${binding === "inventory" ? "setup-api" : "setup-entry"}`;
    const declaration = binding === "namespace" ? "sdk.defineBundledChannelSetupEntry" : "declare";
    const entry = write(
      "setup.ts",
      `#!/usr/bin/env node
    'use strict';
    const __openclawFileURLToPath = 'first';
    const \\u005f_openclawFileURLToPath_ = 'escaped';
    export const retained = [__openclawFileURLToPath, __openclawFileURLToPath_];
    ${binding === "namespace" ? `import * as sdk from '${sdk}';` : `import { defineBundledChannelSetupEntry as ${binding === "unrelated" ? "imported" : "declare"} } from '${sdk}';`}
    ${binding === "unrelated" ? "function declare(value) { return value; }" : ""}
    export const label = '🦞';
    export const decoy = { specifier: './absent.ts' };
    export default ${declaration}({ importMetaUrl: import.meta.url,
      plugin: { specifier: './companion.js', exportName: 'channelPlugin' } });
  `,
    );
    const outDir = path.join(root, "dist");
    const publicApi = path.join(outDir, `extensions/${pluginId}/api.js`);
    fs.mkdirSync(path.dirname(publicApi), { recursive: true });
    fs.writeFileSync(publicApi, "export const nativeOwner = 'unchanged';\n");
    const nativeBytes = fs.readFileSync(publicApi);
    const template = configs.find(
      (config) =>
        config.name === "openclaw-unified" &&
        typeof config.entry === "object" &&
        !Array.isArray(config.entry) &&
        config.entry?.[entryName],
    );
    expect(template).toBeDefined();
    const bundles = format
      ? []
      : (
          await build({
            ...template,
            config: false,
            clean: false,
            entry: {
              [entryName]: entry,
              ...(binding === "inventory"
                ? { "extensions/openai/capability-catalog": companion }
                : {}),
            },
            outDir,
            dts: false,
            logLevel: "silent",
            plugins: [createPluginInventoryModuleRefsPlugin(root)],
          })
        ).bundles;
    if (format) {
      const plan = await buildPluginNpmRuntime({ packageDir: root, logLevel: "silent" });
      expect(plan?.packageFiles).toContain("dist/**");
    }
    const cache = createPluginCache();
    try {
      if (!format) {
        expect(fs.readFileSync(publicApi)).toEqual(nativeBytes);
      }
      const chunks = bundles.flatMap((bundle) =>
        bundle.chunks.filter((chunk) => chunk.type === "chunk"),
      );
      const privateChunks = chunks.filter((chunk) => chunk.fileName.includes("/.setup/"));
      const setup = path.join(outDir, format ? `setup.${runtimeExtension}` : `${entryName}.js`);
      if (binding === "unrelated") {
        expect(privateChunks).toHaveLength(0);
        return;
      }
      if (format) {
        expect(requireHost(path.join(outDir, `companion.${runtimeExtension}`))).toMatchObject({
          runtimeSelectedExport: "retained",
          channelPlugin: { id: "fixture" },
        });
      } else {
        expect(privateChunks.some((chunk) => chunk.exports.includes("runtimeSelectedExport"))).toBe(
          true,
        );
      }
      const nativeListeners = process.listenerCount(event);
      expect(nativeListeners).toBe(format ? 1 : 0);
      if (binding === "inventory") {
        expect(fs.existsSync(path.join(outDir, "extensions/openai/capability-catalog.js"))).toBe(
          true,
        );
      }
      const rootDir = path.dirname(setup);
      const record = createPluginManifestRecordFixture({
        id: "fixture",
        origin,
        rootDir,
        source: setup,
      });
      withPluginCache(cache, () => {
        const loader = getPluginSetupModuleLoader(record, setup, rootDir);
        const module = loader(setup) as {
          default: { loadSetupPlugin(): { id: string } };
          retained: string[];
        };
        expect(process.listenerCount(event)).toBe(nativeListeners);
        expect(module.retained).toEqual(["first", "escaped"]);
        expect(loader.initialize(() => module.default.loadSetupPlugin()).id).toBe("fixture");
      });
      // Bundled code reuses the public load; installed packages evaluate a captured graph.
      expect(process.listenerCount(event)).toBe(evaluations);
    } finally {
      await retirePluginCache(cache);
      process.removeAllListeners(event);
      for (const bundle of bundles) {
        await bundle[Symbol.asyncDispose]();
      }
    }
  },
);