@openclaw/plugin-inspector 0.3.4 → 0.3.6

package/src/sdk-mock.js

@@ -254,9 +254,20 @@ export async function createMockSdkPackage(rootDir, options = {}) {
     )}\n`,
     "utf8",
   );
-  await writeFile(path.join(pluginSdkDir, "index.js"), mockSdkSource(), "utf8");
+  const rootExportNames = new Set([
+    ...mockSdkExportNames,
+    ...(imports.bySpecifier.get("openclaw/plugin-sdk") ?? []),
+  ]);
+  await writeFile(path.join(pluginSdkDir, "index.js"), mockSdkSource(rootExportNames), "utf8");
   for (const [subpath, exportNames] of Object.entries(mockSdkSubpathExports)) {
-    await writeFile(path.join(pluginSdkDir, `${subpath}.js`), mockSdkSubpathSource(exportNames), "utf8");
+    const specifier = `openclaw/plugin-sdk/${subpath}`;
+    await writeFile(
+      path.join(pluginSdkDir, `${subpath}.js`),
+      mockSdkSubpathSource(exportNames, imports.bySpecifier.get(specifier) ?? new Set(), {
+        zod: subpath === "zod",
+      }),
+      "utf8",
+    );
   }
   for (const specifier of imports.openclawSdkSpecifiers) {
     if (specifier === "openclaw/plugin-sdk") {
@@ -428,6 +439,9 @@ export async function resolve(specifier, context, nextResolve) {
     const subpath = specifier.slice("openclaw/plugin-sdk/".length);
     return moduleUrl(path.join(pluginSdkDir, \`\${subpath}.js\`));
   }
+  if (externalMap.has(specifier)) {
+    return moduleUrl(externalMap.get(specifier));
+  }
   try {
     return await nextResolve(specifier, context);
   } catch (error) {
@@ -531,6 +545,12 @@ function genericExportStatement(name) {
   if (["createChatChannelPlugin", "createPlugin", "defineChannelPluginEntry", "definePlugin", "definePluginEntry", "defineSetupPluginEntry"].includes(name)) {
     return name === "definePluginEntry" ? "export { definePluginEntry };" : `export const ${name} = definePluginEntry;`;
   }
+  if (name === "defineBundledChannelEntry") {
+    return "export { defineBundledChannelEntry };";
+  }
+  if (name === "defineBundledChannelSetupEntry") {
+    return "export { defineBundledChannelSetupEntry };";
+  }
   if (/^[A-Z].*Schema$/u.test(name)) {
     return `export const ${name} = createSchema();`;
   }
@@ -547,9 +567,41 @@ function genericMockRuntimeSource(options = {}) {
   }
   return typeof entry === "function" ? { register: entry } : entry;
 }
+
+function defineBundledChannelEntry(entry = {}) {
+  return {
+    ...entry,
+    kind: "bundled-channel-entry",
+    register(api) {
+      if (api?.registrationMode === "cli-metadata") {
+        return entry.registerCliMetadata?.(api);
+      }
+      if (api?.registrationMode !== "tool-discovery") {
+        api?.registerChannel?.({
+          id: entry.id,
+          name: entry.name,
+          description: entry.description,
+          plugin: { id: entry.id, name: entry.name },
+        });
+      }
+      entry.registerCliMetadata?.(api);
+      return entry.registerFull?.(api);
+    },
+  };
+}
+
+function defineBundledChannelSetupEntry(entry = {}) {
+  return {
+    ...entry,
+    kind: "bundled-channel-setup-entry",
+  };
+}
 ` : ""}
 function createMockValue(name) {
   function fn(...args) {
+    if (name === "resolvePreferredOpenClawTmpDir") {
+      return process.env.TMPDIR || "/tmp";
+    }
     if (name.startsWith("normalize")) {
       return typeof args[0] === "string" ? args[0] : "";
     }
@@ -728,7 +780,8 @@ function createTypeNamespace() {
 `;
 }
 
-function mockSdkSource() {
+function mockSdkSource(exportNames = mockSdkExportNames) {
+  const dynamicExportNames = [...exportNames].filter((name) => !mockSdkExportNames.includes(name));
   return `function normalizeEntry(entry) {
   return typeof entry === "function" ? { register: entry } : entry;
 }
@@ -1538,15 +1591,20 @@ export const OPENAI_RESPONSES_STREAM_HOOKS = buildProviderStreamFamilyHooks("ope
 export const OPENROUTER_THINKING_STREAM_HOOKS = buildProviderStreamFamilyHooks("openrouter-thinking");
 export const TOOL_STREAM_DEFAULT_ON_HOOKS = buildProviderStreamFamilyHooks("tool-stream-default");
 export const pluginSdkMock = true;
+${dynamicExportNames.map(genericExportStatement).join("\n")}
 
 export default {
-${mockSdkExportNames.map((name) => `  ${name},`).join("\n")}
+${[...exportNames].map((name) => `  ${name},`).join("\n")}
 };
 `;
 }
 
-function mockSdkSubpathSource(exportNames) {
-  return `${exportNames.map((name) => `export { ${name} } from "./index.js";`).join("\n")}
+function mockSdkSubpathSource(staticExportNames, importedExportNames, options = {}) {
+  const staticNames = new Set(staticExportNames);
+  const dynamicNames = [...importedExportNames].filter((name) => !staticNames.has(name));
+  return `${[...staticNames].map((name) => `export { ${name} } from "./index.js";`).join("\n")}
+${dynamicNames.length > 0 ? genericMockRuntimeSource({ includeSdkRuntime: true, zod: options.zod }) : ""}
+${dynamicNames.map(genericExportStatement).join("\n")}
 export { default } from "./index.js";
 `;
 }

package/src/synthetic-probes.js

@@ -1,11 +1,21 @@
 import { renderPaddedMarkdownTable, writeJsonMarkdownArtifacts } from "./artifacts.js";
 
 export const syntheticRegistrationExecutionProfiles = {
+  createChatChannelPlugin: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "channel plugin factory metadata is captured before channel runtime execution",
+  },
   defineChannelPluginEntry: {
     mode: "metadata-only",
     callableProperties: [],
     reason: "entry wrapper metadata is captured before channel runtime execution",
   },
+  defineBundledChannelEntry: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "bundled channel entry metadata is captured before channel runtime execution",
+  },
   definePluginEntry: {
     mode: "metadata-only",
     callableProperties: [],
@@ -21,6 +31,11 @@ export const syntheticRegistrationExecutionProfiles = {
     callableProperties: [],
     reason: "agent harness factories are captured as registration metadata; agent runtime execution remains isolated opt-in",
   },
+  registerAgentEventSubscription: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "agent event subscriptions are captured as registration metadata before agent event dispatch",
+  },
   registerAgentToolResultMiddleware: {
     mode: "metadata-only",
     callableProperties: [],
@@ -64,6 +79,11 @@ export const syntheticRegistrationExecutionProfiles = {
     callableProperties: [],
     reason: "context engine factories are captured as registration metadata; engine startup remains isolated opt-in",
   },
+  registerControlUiDescriptor: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "control UI descriptors are captured as registration metadata before UI composition",
+  },
   registerDetachedTaskRuntime: {
     mode: "metadata-only",
     callableProperties: [],
@@ -151,6 +171,11 @@ export const syntheticRegistrationExecutionProfiles = {
     callableProperties: [],
     reason: "node host commands are captured as registration metadata before host process execution",
   },
+  registerNodeInvokePolicy: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "node invoke policies are captured as registration metadata before host authorization checks",
+  },
   registerProvider: {
     mode: "metadata-only",
     callableProperties: [],
@@ -171,6 +196,11 @@ export const syntheticRegistrationExecutionProfiles = {
     callableProperties: [],
     reason: "reload handlers are captured as registration metadata before runtime reload execution",
   },
+  registerRuntimeLifecycle: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "runtime lifecycle handlers are captured as registration metadata before lifecycle dispatch",
+  },
   registerSecurityAuditCollector: {
     mode: "metadata-only",
     callableProperties: [],
@@ -181,6 +211,16 @@ export const syntheticRegistrationExecutionProfiles = {
     callableProperties: ["start", "stop", "dispose"],
     option: "includeLifecycle",
   },
+  registerSessionExtension: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "session extensions are captured as registration metadata before session runtime execution",
+  },
+  registerSessionSchedulerJob: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "session scheduler jobs are captured as registration metadata before scheduler execution",
+  },
   registerSpeechProvider: {
     mode: "provider-opt-in",
     callableProperties: ["speak", "synthesize", "tts"],
@@ -190,6 +230,11 @@ export const syntheticRegistrationExecutionProfiles = {
     mode: "direct",
     callableProperties: ["run", "handler", "execute"],
   },
+  registerToolMetadata: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "tool metadata descriptors are captured as registration metadata before tool runtime execution",
+  },
   registerTextTransforms: {
     mode: "metadata-only",
     callableProperties: [],
@@ -200,6 +245,11 @@ export const syntheticRegistrationExecutionProfiles = {
     callableProperties: [],
     reason: "video generation providers are captured as registration metadata before provider runtime execution",
   },
+  registerTrustedToolPolicy: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "trusted tool policies are captured as registration metadata before trust-policy enforcement",
+  },
   registerWebFetchProvider: {
     mode: "metadata-only",
     callableProperties: [],
@@ -326,6 +376,7 @@ export const defaultSyntheticHookContexts = {
 };
 
 export const defaultSyntheticRegistrationArguments = {
+  createChatChannelPlugin: [{ base: { id: "fixture-channel" }, outbound: { sendText: "function" } }],
   defineChannelPluginEntry: [{ id: "fixture-channel", setup: "function", receive: "function" }],
   definePluginEntry: [{ id: "fixture-plugin", register: "function" }],
   registerChannel: [{ id: "fixture-channel", send: "function", receive: "function" }],

package/src/workspace-plan.js

@@ -71,6 +71,7 @@ export async function buildWorkspacePlan(options = {}) {
       installStepCount: allSteps.filter((step) => step.kind === "install").length,
       auditStepCount: allSteps.filter((step) => step.kind === "audit").length,
       buildStepCount: allSteps.filter((step) => step.kind === "build").length,
+      pruneDevWorkspaceDependencyStepCount: allSteps.filter((step) => step.kind === "prune-dev-workspace-deps").length,
       artifactStepCount: allSteps.filter((step) => step.kind === "prepare-artifacts").length,
       captureStepCount: allSteps.filter((step) => step.kind === "capture").length,
       syntheticProbeStepCount: allSteps.filter((step) => step.kind === "synthetic-probe").length,
@@ -179,6 +180,7 @@ export function renderWorkspacePlanMarkdown(plan, options = {}) {
         ["Artifact dirs", plan.summary.artifactStepCount],
         ["Install steps", plan.summary.installStepCount],
         ["Audit steps", plan.summary.auditStepCount],
+        ["Prune dev workspace dependency steps", plan.summary.pruneDevWorkspaceDependencyStepCount],
         ["Build steps", plan.summary.buildStepCount],
         ["Capture steps", plan.summary.captureStepCount],
         ["Synthetic probe steps", plan.summary.syntheticProbeStepCount],
@@ -248,6 +250,14 @@ async function buildEntrypointPlan({ fixtureId, entrypoint, packageSummary, pack
   }
 
   if (requiredCapabilities.includes("dependency-install")) {
+    if (hasWorkspaceProtocolDevDependencies(packageJson)) {
+      steps.push({
+        kind: "prune-dev-workspace-deps",
+        command: `node ${helperScript(settings, workspacePath, settings.pruneWorkspaceDevDepsScript, "prune-workspace-dev-deps-cli.js")}`,
+        cwd: workspacePath,
+        reason: "remove workspace: devDependencies from the isolated runtime install; the mock SDK supplies OpenClaw host imports",
+      });
+    }
     steps.push({
       kind: "install",
       command: installCommand(packageManager),
@@ -319,6 +329,7 @@ function workspaceSettings(options) {
     resultsRoot: repoRelative(options.resultsRoot ?? defaultWorkspacePlanOptions.resultsRoot),
     rootDir: path.resolve(options.rootDir ?? process.cwd()),
     syntheticProbeScript: options.syntheticProbeScript ?? defaultWorkspacePlanOptions.syntheticProbeScript,
+    pruneWorkspaceDevDepsScript: options.pruneWorkspaceDevDepsScript,
     workspaceRoot: repoRelative(options.workspaceRoot ?? defaultWorkspacePlanOptions.workspaceRoot),
   };
 }
@@ -377,6 +388,12 @@ function hasHostLinkedOpenClawDependency(packageSummary) {
   ].includes("openclaw");
 }
 
+function hasWorkspaceProtocolDevDependencies(packageJson) {
+  return Object.values(packageJson.devDependencies ?? {}).some(
+    (value) => typeof value === "string" && value.startsWith("workspace:"),
+  );
+}
+
 function detectPackageManager(rootDir, packageDir, packageJson) {
   const declared = typeof packageJson.packageManager === "string" ? packageJson.packageManager.split("@")[0] : null;
   if (declared) {
@@ -458,15 +475,13 @@ function runCommand(packageManager, script) {
 }
 
 function captureCommand(settings, fixtureId, entrypoint, workspacePath) {
-  const loader = entrypoint.blockers.some((blocker) => blocker.code === "ts-loader-required") ? " --import tsx" : "";
   const script = helperScript(settings, workspacePath, settings.captureScript, "capture-cli.js");
-  return `${settings.optInEnv} node${loader} ${script} ${entrypoint.specifier} --mock-sdk --output ${workspaceArtifactPath(settings, fixtureId, entrypoint, workspacePath, "capture")}`;
+  return `${settings.optInEnv} node ${script} ${entrypoint.specifier} --mock-sdk --output ${workspaceArtifactPath(settings, fixtureId, entrypoint, workspacePath, "capture")}`;
 }
 
 function syntheticProbeCommand(settings, fixtureId, entrypoint, workspacePath) {
-  const loader = entrypoint.blockers.some((blocker) => blocker.code === "ts-loader-required") ? " --import tsx" : "";
   const script = helperScript(settings, workspacePath, settings.syntheticProbeScript, "synthetic-probes-cli.js");
-  return `${settings.optInEnv} node${loader} ${script} --entrypoint ${entrypoint.specifier} --mock-sdk --output ${workspaceArtifactPath(settings, fixtureId, entrypoint, workspacePath, "synthetic")}`;
+  return `${settings.optInEnv} node ${script} --entrypoint ${entrypoint.specifier} --mock-sdk --output ${workspaceArtifactPath(settings, fixtureId, entrypoint, workspacePath, "synthetic")}`;
 }
 
 function helperScript(settings, workspacePath, configuredScript, helperFileName) {