@openclaw/plugin-inspector 0.3.10 → 0.3.12

package/src/sdk-mock.js

@@ -377,6 +377,9 @@ function parseModuleImports(text) {
   ];
   for (const pattern of patterns) {
     for (const match of text.matchAll(pattern)) {
+      if (isTypeOnlyImportOrExport(match[0], match[1] ?? "")) {
+        continue;
+      }
       const specifier = match[2];
       if (specifier) {
         entries.push({ specifier, names: parseNamedImports(match[1] ?? "") });
@@ -389,6 +392,10 @@ function parseModuleImports(text) {
   return entries;
 }
 
+function isTypeOnlyImportOrExport(statement, clause) {
+  return /^\s*import\s+type\b/u.test(statement) || /^\s*export\s+type\b/u.test(statement) || /^\s*type\b/u.test(clause);
+}
+
 function parseNamedImports(clause) {
   const names = new Set();
   const named = /\{([\s\S]*?)\}/.exec(clause)?.[1] ?? clause;
@@ -459,11 +466,22 @@ export async function resolve(specifier, context, nextResolve) {
 export async function load(url, context, nextLoad) {
   if (url.startsWith("file:") && /\\.[cm]?ts$/u.test(fileURLToPath(url))) {
     const rawSource = await readFile(fileURLToPath(url), "utf8");
-    return { format: "module", source: stripTypeScriptTypes(rawSource, { mode: "transform" }), shortCircuit: true };
+    return { format: "module", source: stripPluginTypeScript(rawSource), shortCircuit: true };
   }
   return nextLoad(url, context);
 }
 
+function stripPluginTypeScript(source) {
+  try {
+    return stripTypeScriptTypes(source, { mode: "transform" });
+  } catch (error) {
+    if (error?.code !== "ERR_INVALID_ARG_VALUE") {
+      throw error;
+    }
+    return stripTypeScriptTypes(source, { mode: "strip" });
+  }
+}
+
 function moduleUrl(filePath) {
   return { url: pathToFileURL(filePath).href, shortCircuit: true };
 }
@@ -653,6 +671,24 @@ function resolveExistingSourcePath(target) {
 ` : ""}
 function createMockValue(name) {
   function fn(...args) {
+    if (name === "resolveDefaultAgentDir") {
+      return mockAgentDir();
+    }
+    if (name === "resolveAgentDir") {
+      return mockAgentDir(args[1]);
+    }
+    if (name === "resolveUserPath") {
+      return typeof args[0] === "string" ? args[0] : mockAgentDir();
+    }
+    if (name === "resolveAuthProfileOrder") {
+      return [];
+    }
+    if (name === "resolveWindowsSpawnProgram") {
+      return mockWindowsSpawnProgram(args[0]);
+    }
+    if (name === "materializeWindowsSpawnProgram") {
+      return mockWindowsSpawnInvocation(args[0], args[1]);
+    }
     if (name === "resolvePreferredOpenClawTmpDir") {
       return process.env.TMPDIR || "/tmp";
     }
@@ -689,6 +725,80 @@ function createMockValue(name) {
   });
 }
 
+function mockAgentDir(agentId = "main") {
+  const base = process.env.TMPDIR || process.env.TEMP || process.env.TMP || "/tmp";
+  const safeAgentId = String(agentId || "main").replace(/[^a-zA-Z0-9._-]/g, "-");
+  return base.replace(/[\\/]+$/, "") + "/plugin-inspector-openclaw/agents/" + safeAgentId + "/agent";
+}
+
+function mockWindowsSpawnProgram(params = {}) {
+  return {
+    command: typeof params.command === "string" && params.command.trim() ? params.command : process.execPath,
+    leadingArgv: [],
+    resolution: "mock",
+    packageName: typeof params.packageName === "string" ? params.packageName : undefined,
+  };
+}
+
+function mockWindowsSpawnInvocation(program = {}, argv = []) {
+  const command = typeof program.command === "string" && program.command.trim() ? program.command : process.execPath;
+  if (program.packageName === "@openai/codex") {
+    return {
+      command: process.execPath,
+      argv: ["-e", mockCodexAppServerScript()],
+      resolution: program.resolution ?? "mock",
+      windowsHide: true,
+    };
+  }
+  return {
+    command,
+    argv: [...(Array.isArray(program.leadingArgv) ? program.leadingArgv : []), ...(Array.isArray(argv) ? argv : [])],
+    resolution: program.resolution ?? "mock",
+    shell: program.shell,
+    windowsHide: program.windowsHide,
+  };
+}
+
+function mockCodexAppServerScript() {
+  return [
+    "const readline = require('node:readline');",
+    "const rl = readline.createInterface({ input: process.stdin });",
+    "let idleTimer;",
+    "function scheduleIdleExit() {",
+    "  if (idleTimer) clearTimeout(idleTimer);",
+    "  idleTimer = setTimeout(() => process.exit(0), 1000);",
+    "}",
+    "function write(id, result) { process.stdout.write(JSON.stringify({ id, result }) + String.fromCharCode(10)); }",
+    "rl.on('line', (line) => {",
+    "  let message;",
+    "  try { message = JSON.parse(line); } catch { return; }",
+    "  if (message.id === undefined || message.id === null) return;",
+    "  switch (message.method) {",
+    "    case 'initialize':",
+    "      write(message.id, { userAgent: 'openclaw/999.0.0 (plugin-inspector mock)' });",
+    "      break;",
+    "    case 'model/list':",
+    "      write(message.id, { data: [] });",
+    "      break;",
+    "    case 'thread/list':",
+    "    case 'mcpServerStatus/list':",
+    "    case 'skills/list':",
+    "      write(message.id, { data: [] });",
+    "      break;",
+    "    case 'account/read':",
+    "      write(message.id, null);",
+    "      break;",
+    "    case 'account/rateLimits/read':",
+    "      write(message.id, null);",
+    "      break;",
+    "    default:",
+    "      process.stdout.write(JSON.stringify({ id: message.id, error: { code: -32601, message: 'mock method not implemented' } }) + String.fromCharCode(10));",
+    "  }",
+    "  scheduleIdleExit();",
+    "});",
+  ].join("\\n");
+}
+
 function createZNamespace() {
   const namespace = {
     any: () => createSchema(),
@@ -1665,11 +1775,53 @@ 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.length > 0 ? mockValueRuntimeSource() : ""}
 ${dynamicExportNames.map(genericExportStatement).join("\n")}
 
 export default {
 ${[...exportNames].map((name) => `  ${name},`).join("\n")}
 };
+  `;
+}
+
+function mockValueRuntimeSource() {
+  return `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] : "";
+    }
+    if (name === "jsonResult") {
+      return { type: "json", value: args[0] };
+    }
+    if (name === "readStringParam") {
+      return typeof args[0] === "string" ? args[0] : "";
+    }
+    return createMockValue(name);
+  }
+  return new Proxy(fn, {
+    get(_target, property) {
+      if (property === "then") {
+        return undefined;
+      }
+      if (property === Symbol.toPrimitive) {
+        return () => name;
+      }
+      if (property === "toString") {
+        return () => name;
+      }
+      if (property === "valueOf") {
+        return () => name;
+      }
+      return createMockValue(\`\${name}.\${String(property)}\`);
+    },
+    construct() {
+      return createMockValue(name);
+    },
+  });
+}
 `;
 }
 

package/src/synthetic-entrypoint.js

@@ -0,0 +1,47 @@
+import { rmSync } from "node:fs";
+import { mkdtemp } from "node:fs/promises";
+import { register } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { captureEntrypoint } from "./inspector.js";
+import { createMockSdkPackage } from "./sdk-mock.js";
+import { runCapturedSyntheticProbes } from "./synthetic-probes.js";
+
+export async function runEntrypointSyntheticProbes(entrypoint, options = {}) {
+  const capture = await captureEntrypointForSyntheticProbes(entrypoint, {
+    ...options,
+    apiOptions: {
+      ...(options.apiOptions ?? {}),
+      retainHandlers: true,
+    },
+  });
+  return runCapturedSyntheticProbes(capture, options);
+}
+
+async function captureEntrypointForSyntheticProbes(entrypoint, options) {
+  if (options.mockSdk !== true) {
+    return captureEntrypoint(entrypoint, options);
+  }
+
+  const cwd = options.cwd ?? process.cwd();
+  const resolvedEntrypoint = path.resolve(cwd, entrypoint);
+  const pluginRoot = path.resolve(cwd, options.pluginRoot ?? path.dirname(resolvedEntrypoint));
+  const workspace = await mkdtemp(path.join(os.tmpdir(), "plugin-inspector-synthetic-mock-sdk-"));
+  cleanupTempDirOnExit(workspace);
+  const { loaderPath } = await createMockSdkPackage(workspace, { pluginRoot });
+  register(pathToFileURL(loaderPath));
+
+  return captureEntrypoint(entrypoint, {
+    ...options,
+    cwd,
+    mockSdk: false,
+    pluginRoot,
+  });
+}
+
+function cleanupTempDirOnExit(dir) {
+  process.once("exit", () => {
+    rmSync(dir, { force: true, recursive: true });
+  });
+}

package/src/synthetic-probes-cli.js

@@ -1,12 +1,5 @@
 #!/usr/bin/env node
-import { rmSync } from "node:fs";
-import { mkdtemp } from "node:fs/promises";
-import { register } from "node:module";
-import os from "node:os";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import { captureEntrypoint, runCapturedSyntheticProbes, writeArtifacts } from "./advanced.js";
-import { createMockSdkPackage } from "./sdk-mock.js";
+import { runEntrypointSyntheticProbes, writeArtifacts } from "./advanced.js";
 
 const args = process.argv.slice(2);
 
@@ -33,12 +26,10 @@ async function run(commandArgs) {
     throw new Error("synthetic probes import plugin code; rerun with PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 in an isolated workspace");
   }
 
-  const capture = await captureForSyntheticProbes(entrypoint, {
+  const results = await runEntrypointSyntheticProbes(entrypoint, {
     mockSdk,
     pluginRoot,
     apiOptions: { retainHandlers: true },
-  });
-  const results = await runCapturedSyntheticProbes(capture, {
     includeLifecycle,
     includeChannelRuntime,
     includeProviderCapabilities,
@@ -52,30 +43,6 @@ async function run(commandArgs) {
   }
 }
 
-async function captureForSyntheticProbes(entrypoint, options) {
-  if (options.mockSdk !== true) {
-    return captureEntrypoint(entrypoint, options);
-  }
-
-  const resolvedEntrypoint = path.resolve(process.cwd(), entrypoint);
-  const pluginRoot = path.resolve(process.cwd(), options.pluginRoot ?? path.dirname(resolvedEntrypoint));
-  const workspace = await mkdtemp(path.join(os.tmpdir(), "plugin-inspector-synthetic-mock-sdk-"));
-  cleanupTempDirOnExit(workspace);
-  const { loaderPath } = await createMockSdkPackage(workspace, { pluginRoot });
-  register(pathToFileURL(loaderPath));
-  return captureEntrypoint(entrypoint, {
-    ...options,
-    mockSdk: false,
-    pluginRoot,
-  });
-}
-
-function cleanupTempDirOnExit(dir) {
-  process.once("exit", () => {
-    rmSync(dir, { force: true, recursive: true });
-  });
-}
-
 function readFlag(commandArgs, name) {
   const index = commandArgs.indexOf(name);
   if (index === -1) {

package/src/synthetic-probes.js

@@ -89,6 +89,11 @@ export const syntheticRegistrationExecutionProfiles = {
     callableProperties: [],
     reason: "detached task runtimes are captured as registration metadata before async task execution",
   },
+  registerEmbeddingProvider: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "embedding providers are captured as registration metadata before provider runtime execution",
+  },
   registerGatewayDiscoveryService: {
     mode: "metadata-only",
     callableProperties: [],
@@ -116,11 +121,21 @@ export const syntheticRegistrationExecutionProfiles = {
     callableProperties: [],
     reason: "image generation providers are captured as registration metadata before provider runtime execution",
   },
+  registerHostedMediaResolver: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "hosted media resolvers are captured as registration metadata before media URL resolution",
+  },
   registerMemoryPromptSection: {
     mode: "metadata-only",
     callableProperties: [],
     reason: "memory prompt section renderers are captured as metadata before prompt-runtime execution",
   },
+  registerMeetingNotesSourceProvider: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "meeting notes source providers are captured as registration metadata before source discovery",
+  },
   registerMediaUnderstandingProvider: {
     mode: "metadata-only",
     callableProperties: [],
@@ -161,11 +176,21 @@ export const syntheticRegistrationExecutionProfiles = {
     callableProperties: [],
     reason: "migration providers are captured as registration metadata before migration runtime execution",
   },
+  registerModelCatalogProvider: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "model catalog providers are captured as registration metadata before catalog runtime execution",
+  },
   registerMusicGenerationProvider: {
     mode: "metadata-only",
     callableProperties: [],
     reason: "music generation providers are captured as registration metadata before provider runtime execution",
   },
+  registerNodeCliFeature: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "node CLI features are captured as registration metadata before host CLI integration",
+  },
   registerNodeHostCommand: {
     mode: "metadata-only",
     callableProperties: [],
@@ -206,6 +231,11 @@ export const syntheticRegistrationExecutionProfiles = {
     callableProperties: [],
     reason: "security audit collectors are captured as registration metadata before filesystem or policy scans",
   },
+  registerSessionAction: {
+    mode: "metadata-only",
+    callableProperties: [],
+    reason: "session actions are captured as registration metadata before session runtime execution",
+  },
   registerService: {
     mode: "lifecycle-opt-in",
     callableProperties: ["start", "stop", "dispose"],
@@ -267,12 +297,17 @@ export const defaultSyntheticHookEvents = {
     runId: "run-fixture",
     agentId: "agent-fixture",
     conversationId: "conversation-fixture",
+    success: true,
+    durationMs: 1,
+    error: null,
+    messages: [{ role: "assistant", content: "[redacted fixture output]" }],
     status: "completed",
     transcript: [{ role: "assistant", content: "[redacted fixture output]" }],
   },
   before_agent_start: {
     agentId: "agent-fixture",
     runId: "run-fixture",
+    prompt: "fixture prompt",
     config: { source: "plugin-inspector" },
   },
   before_prompt_build: {
@@ -303,6 +338,18 @@ export const defaultSyntheticHookEvents = {
     model: "gpt-5.4",
     output: { role: "assistant", content: "[redacted fixture output]" },
   },
+  message_received: {
+    from: "fixture-user",
+    content: "fixture inbound message",
+    messageId: "message-fixture",
+  },
+  message_sent: {
+    to: "fixture-user",
+    content: "fixture outbound message",
+    success: true,
+    error: null,
+    messageId: "message-fixture-reply",
+  },
   subagent_delivery_target: {
     childSessionKey: "child-session",
     agentId: "agent-child",
@@ -361,6 +408,18 @@ export const defaultSyntheticHookContexts = {
     agentId: "agent-fixture",
     sessionId: "session-fixture",
   },
+  message_received: {
+    runId: "run-fixture",
+    agentId: "agent-fixture",
+    sessionId: "session-fixture",
+    channelId: "fixture-channel",
+  },
+  message_sent: {
+    runId: "run-fixture",
+    agentId: "agent-fixture",
+    sessionId: "session-fixture",
+    channelId: "fixture-channel",
+  },
   subagent_delivery_target: {
     runId: "run-fixture",
     parentAgentId: "agent-parent",