@openclaw/plugin-inspector 0.1.1 → 0.1.3

package/src/mock-sdk-capture-runner.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { mkdtemp, rm, symlink } from "node:fs/promises";
+import { mkdtemp, rm } from "node:fs/promises";
+import { register } from "node:module";
 import os from "node:os";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
@@ -7,12 +8,16 @@ import { createCaptureApi } from "./capture-api.js";
 import { createMockSdkPackage } from "./sdk-mock.js";
 
 const options = JSON.parse(process.argv[2] ?? "{}");
+let activeOutputCapture = null;
 
 try {
   const result = await run(options);
-  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  writeRunnerStdout(`${JSON.stringify(result, null, 2)}\n`);
 } catch (error) {
-  process.stderr.write(`${error.stack ?? error.message}\n`);
+  if (error.failureClass) {
+    writeRunnerStderr(`[plugin-inspector:${error.failureClass}]\n`);
+  }
+  writeRunnerStderr(`${error.stack ?? error.message}\n`);
   process.exitCode = 1;
 }
 
@@ -22,37 +27,79 @@ async function run(options) {
   const workspace = await mkdtemp(path.join(os.tmpdir(), "plugin-inspector-mock-sdk-"));
 
   try {
-    await createMockSdkPackage(workspace);
-    const linkedPluginRoot = path.join(workspace, "plugin");
-    await symlink(pluginRoot, linkedPluginRoot, "junction");
-    const linkedEntrypoint = path.join(linkedPluginRoot, path.relative(pluginRoot, entrypoint));
-    return await captureLinkedEntrypoint(linkedEntrypoint, options);
+    const { loaderPath } = await createMockSdkPackage(workspace, { pluginRoot });
+    register(pathToFileURL(loaderPath));
+    return await captureLinkedEntrypoint(entrypoint, options);
   } finally {
     await rm(workspace, { force: true, recursive: true });
   }
 }
 
 async function captureLinkedEntrypoint(entrypoint, options) {
-  const module = await import(pathToFileURL(entrypoint).href);
+  const outputCapture = installProcessOutputCapture();
+  activeOutputCapture = outputCapture;
+
+  let module;
+  try {
+    module = await import(pathToFileURL(entrypoint).href);
+  } catch (error) {
+    await drainAsyncOutput();
+    throw capturePhaseError(error, "entrypoint-import-error");
+  }
   const register = findRegisterExport(module);
 
   if (!register) {
-    return {
-      status: "no-register-export",
-      entrypoint: options.entrypoint,
-      mockSdk: true,
-      captured: [],
-    };
+    await drainAsyncOutput();
+    return withProcessOutput(
+      {
+        status: "no-register-export",
+        entrypoint: options.entrypoint,
+        mockSdk: true,
+        captured: [],
+      },
+      outputCapture,
+    );
   }
 
   const api = createCaptureApi(options.apiOptions);
-  await register(api);
-  return {
+  try {
+    await register(api);
+  } catch (error) {
+    await drainAsyncOutput();
+    throw capturePhaseError(error, "registration-execution-error");
+  }
+  await drainAsyncOutput();
+
+  const result = {
     status: "captured",
     entrypoint: options.entrypoint,
     mockSdk: true,
     captured: api.getCapturedContracts(),
   };
+  if (options.apiOptions?.retainHandlers === true) {
+    result.retained = api.getRetainedContracts();
+  }
+  return withProcessOutput(result, outputCapture);
+}
+
+function withProcessOutput(result, outputCapture) {
+  const stdout = outputCapture.stdout();
+  const stderr = outputCapture.stderr();
+  if (stdout.length === 0 && stderr.length === 0) {
+    return result;
+  }
+  return {
+    ...result,
+    processOutput: {
+      stdout,
+      stderr,
+    },
+  };
+}
+
+function capturePhaseError(error, failureClass) {
+  error.failureClass = failureClass;
+  return error;
 }
 
 function findRegisterExport(module) {
@@ -67,3 +114,49 @@ function findRegisterExport(module) {
   }
   return null;
 }
+
+function installProcessOutputCapture() {
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+
+  process.stdout.write = (chunk, encoding, callback) => {
+    stdoutChunks.push(Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk));
+    invokeWriteCallback(encoding, callback);
+    return true;
+  };
+  process.stderr.write = (chunk, encoding, callback) => {
+    stderrChunks.push(Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk));
+    invokeWriteCallback(encoding, callback);
+    return true;
+  };
+
+  return {
+    originalStdoutWrite,
+    originalStderrWrite,
+    stdout: () => stdoutChunks.join(""),
+    stderr: () => stderrChunks.join(""),
+  };
+}
+
+function invokeWriteCallback(encoding, callback) {
+  if (typeof encoding === "function") {
+    encoding();
+  } else if (typeof callback === "function") {
+    callback();
+  }
+}
+
+async function drainAsyncOutput() {
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setImmediate(resolve));
+}
+
+function writeRunnerStdout(text) {
+  (activeOutputCapture?.originalStdoutWrite ?? process.stdout.write.bind(process.stdout))(text);
+}
+
+function writeRunnerStderr(text) {
+  (activeOutputCapture?.originalStderrWrite ?? process.stderr.write.bind(process.stderr))(text);
+}

package/src/openclaw-target.js

@@ -31,6 +31,7 @@ export async function readOpenClawTargetSurface(options = {}) {
   const apiBuilderPath = path.join(resolvedPath, "src/plugins/api-builder.ts");
   const capturedRegistrationPath = path.join(resolvedPath, "src/plugins/captured-registration.ts");
   const manifestTypesPath = path.join(resolvedPath, "src/plugins/manifest.ts");
+  const pluginSdkEntrypointsPath = path.join(resolvedPath, "src/plugin-sdk/entrypoints.ts");
   const packagePath = path.join(resolvedPath, "package.json");
 
   const registrySource = await readFile(registryPath, "utf8");
@@ -48,6 +49,18 @@ export async function readOpenClawTargetSurface(options = {}) {
   const sdkExports = existsSync(packagePath)
     ? parsePluginSdkExports(JSON.parse(await readFile(packagePath, "utf8")))
     : [];
+  const pluginSdkEntrypointsSource = existsSync(pluginSdkEntrypointsPath)
+    ? await readFile(pluginSdkEntrypointsPath, "utf8")
+    : "";
+  const reservedSdkExports = pluginSdkEntrypointsSource
+    ? parsePluginSdkEntrypointSpecifiers(pluginSdkEntrypointsSource, "reservedBundledPluginSdkEntrypoints")
+    : [];
+  const supportedFacadeSdkExports = pluginSdkEntrypointsSource
+    ? parsePluginSdkEntrypointSpecifiers(pluginSdkEntrypointsSource, "supportedBundledFacadeSdkEntrypoints")
+    : [];
+  const publicPluginOwnedSdkExports = pluginSdkEntrypointsSource
+    ? parsePluginSdkEntrypointSpecifiers(pluginSdkEntrypointsSource, "publicPluginOwnedSdkEntrypoints")
+    : [];
 
   return {
     configuredPath: requestedPath,
@@ -69,6 +82,13 @@ export async function readOpenClawTargetSurface(options = {}) {
     packagePath: existsSync(packagePath) ? relativePath(rootDir, packagePath) : null,
     sdkExportCount: sdkExports.length,
     sdkExports,
+    pluginSdkEntrypointsPath: existsSync(pluginSdkEntrypointsPath)
+      ? relativePath(rootDir, pluginSdkEntrypointsPath)
+      : null,
+    reservedSdkExportCount: reservedSdkExports.length,
+    reservedSdkExports,
+    supportedFacadeSdkExports,
+    publicPluginOwnedSdkExports,
     manifestTypesPath: existsSync(manifestTypesPath) ? relativePath(rootDir, manifestTypesPath) : null,
     manifestFieldCount: manifestFields.length,
     manifestFields,
@@ -149,11 +169,18 @@ function emptyTargetSurface({ configuredPath, searchedPaths = undefined, status
     apiRegistrars: [],
     capturedRegistrars: [],
     sdkExports: [],
+    reservedSdkExports: [],
+    supportedFacadeSdkExports: [],
+    publicPluginOwnedSdkExports: [],
     manifestFields: [],
     manifestContractFields: [],
   };
 }
 
+export function parsePluginSdkEntrypointSpecifiers(source, exportName) {
+  return parseExportedStringArray(source, exportName).map((entrypoint) => `openclaw/plugin-sdk/${entrypoint}`).sort();
+}
+
 function parseCapturedRegistrars(source) {
   return unique([...source.matchAll(/^\s*(register[A-Za-z0-9]+)\s*\(/gm)].map((match) => match[1])).sort();
 }

package/src/report.js

@@ -160,6 +160,7 @@ export async function buildCompatibilityReport(options = {}) {
       warningCount: warnings.length,
       suggestionCount: suggestions.length,
       decisionCount: decisions.length,
+      logCount: logs.length,
       issueCount: issues.length,
       p0IssueCount: issues.filter((issue) => issue.severity === "P0").length,
       p1IssueCount: issues.filter((issue) => issue.severity === "P1").length,

package/src/runtime-capture-report.js

@@ -71,13 +71,20 @@ export function renderRuntimeCaptureMarkdown(captureReport, options = {}) {
         result.fixture,
         result.status,
         result.entrypoint,
-        (result.captured ?? []).map((item) => `${item.kind}:${item.name}`).join(", ") || result.error || "-",
+        (result.captured ?? []).map((item) => `${item.kind}:${item.name}`).join(", ") || formatCaptureError(result),
       ]),
       ["Fixture", "Status", "Entrypoint", "Captured"],
     ),
   ].join("\n");
 }
 
+function formatCaptureError(result) {
+  if (!result.error) {
+    return "-";
+  }
+  return result.failureClass ? `${result.failureClass}: ${result.error}` : result.error;
+}
+
 function captureTargets(fixture, rootDir) {
   return fixture.packages.flatMap((packageSummary) => {
     const packageRoot = path.dirname(path.resolve(rootDir, packageSummary.path));
@@ -124,6 +131,9 @@ async function captureTarget(target, options) {
       packagePath: target.packagePath,
       entrypoint: target.entrypoint.relativePath,
       error: error.message,
+      ...(error.failureClass ? { failureClass: error.failureClass } : {}),
+      ...(error.missingExport ? { missingExport: error.missingExport } : {}),
+      ...(error.missingModule ? { missingModule: error.missingModule } : {}),
       captured: [],
     };
   }