@tonyclaw/agent-inspector 2.0.38 → 2.0.39

package/.output/cli.js

@@ -938,6 +938,11 @@ function parseFlags(argv) {
     skipToolWire: false,
     codexOnly: false,
     skipCodexSkill: false,
+    opencode: false,
+    opencodeOnly: false,
+    opencodeConfig: null,
+    opencodeTransport: "local",
+    opencodeMcpUrl: DEFAULT_MCP_URL,
     uninstall: false,
     status: false,
     json: false,
@@ -967,6 +972,58 @@ function parseFlags(argv) {
       case "--skip-codex-skill":
         flags.skipCodexSkill = true;
         break;
+      case "--opencode":
+        flags.opencode = true;
+        break;
+      case "--opencode-only":
+        flags.opencode = true;
+        flags.opencodeOnly = true;
+        break;
+      case "--opencode-config": {
+        const next = argv[i + 1];
+        if (next === void 0) {
+          process.stderr.write(
+            "agent-inspector onboard: --opencode-config requires a path argument\n"
+          );
+          process.exit(2);
+        }
+        flags.opencodeConfig = next;
+        i++;
+        break;
+      }
+      case "--opencode-transport": {
+        const next = argv[i + 1];
+        if (next === void 0) {
+          process.stderr.write(
+            "agent-inspector onboard: --opencode-transport requires local or remote\n"
+          );
+          process.exit(2);
+        }
+        switch (next) {
+          case "local":
+          case "remote":
+            flags.opencodeTransport = next;
+            break;
+          default:
+            process.stderr.write(
+              `agent-inspector onboard: invalid --opencode-transport: ${next}
+`
+            );
+            process.exit(2);
+        }
+        i++;
+        break;
+      }
+      case "--opencode-mcp-url": {
+        const next = argv[i + 1];
+        if (next === void 0) {
+          process.stderr.write("agent-inspector onboard: --opencode-mcp-url requires a URL\n");
+          process.exit(2);
+        }
+        flags.opencodeMcpUrl = next;
+        i++;
+        break;
+      }
       case "--uninstall":
         flags.uninstall = true;
         break;
@@ -1024,6 +1081,12 @@ Options:
   --skip-tool-wire         Skip the wire-tool phase in the Claude skill body
   --skip-codex-skill       Install only the Claude Code skill and slash command
   --codex-only             Install only the Codex skill
+  --opencode               Also configure OpenCode MCP in opencode.json/jsonc
+  --opencode-only          Configure only OpenCode MCP
+  --opencode-config <path> Override OpenCode config path (default: ~/.config/opencode/opencode.json)
+  --opencode-transport <local|remote>
+                           OpenCode MCP transport to write (default: local)
+  --opencode-mcp-url <url> Agent Inspector MCP endpoint for OpenCode
   --uninstall              Remove generated files whose version matches this package
   --status                 Show installed onboarding file versions and suggested action
   --json                   Emit machine-readable JSON with --status
@@ -1052,6 +1115,356 @@ function resolveTargets(flags) {
 function isObject(value) {
   return typeof value === "object" && value !== null;
 }
+function isOpenCodeEnabled(flags) {
+  return flags.opencode || flags.opencodeOnly;
+}
+function resolveOpenCodeConfigPath(flags) {
+  if (flags.opencodeConfig !== null) {
+    return flags.opencodeConfig;
+  }
+  const configDir = join2(homedir2(), ".config", "opencode");
+  const jsoncPath = join2(configDir, "opencode.jsonc");
+  if (existsSync2(jsoncPath)) {
+    return jsoncPath;
+  }
+  return join2(configDir, "opencode.json");
+}
+function stripJsoncComments(raw) {
+  let result = "";
+  let index = 0;
+  let inString = false;
+  let stringChar = "";
+  while (index < raw.length) {
+    const ch = raw[index];
+    const next = raw[index + 1];
+    if (inString) {
+      if (ch === "\\" && next !== void 0) {
+        result += ch + next;
+        index += 2;
+        continue;
+      }
+      if (ch === stringChar) {
+        inString = false;
+        stringChar = "";
+      }
+      result += ch;
+      index += 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inString = true;
+      stringChar = ch;
+      result += ch;
+      index += 1;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      while (index < raw.length && raw[index] !== "\n") {
+        index += 1;
+      }
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      index += 2;
+      while (index < raw.length - 1 && !(raw[index] === "*" && raw[index + 1] === "/")) {
+        index += 1;
+      }
+      index += 2;
+      continue;
+    }
+    result += ch;
+    index += 1;
+  }
+  return result;
+}
+function readOpenCodeConfig(path) {
+  if (!existsSync2(path)) {
+    return { ok: true, exists: false, config: {} };
+  }
+  try {
+    const raw = readFileSync(path, "utf8");
+    if (raw.trim().length === 0) {
+      return { ok: true, exists: true, config: {} };
+    }
+    const parsed = JSON.parse(stripJsoncComments(raw));
+    if (isObject(parsed)) {
+      return { ok: true, exists: true, config: parsed };
+    }
+    return {
+      ok: false,
+      exists: true,
+      message: "OpenCode config root must be a JSON object"
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      ok: false,
+      exists: true,
+      message
+    };
+  }
+}
+function buildOpenCodeMcpEntry(transport, endpoint) {
+  switch (transport) {
+    case "local":
+      return {
+        type: "local",
+        command: ["agent-inspector-mcp", "stdio", "--url", endpoint],
+        enabled: true
+      };
+    case "remote":
+      return {
+        type: "remote",
+        url: endpoint,
+        enabled: true
+      };
+    default:
+      return {
+        type: "local",
+        command: ["agent-inspector-mcp", "stdio", "--url", endpoint],
+        enabled: true
+      };
+  }
+}
+function stringArrayEquals(value, expected) {
+  if (!Array.isArray(value) || value.length !== expected.length) {
+    return false;
+  }
+  return value.every((item, index) => item === expected[index]);
+}
+function isOpenCodeLocalEntry(value, endpoint, ignoreEnabled) {
+  if (!isObject(value)) {
+    return false;
+  }
+  const enabled = value["enabled"];
+  if (!ignoreEnabled && enabled === false) {
+    return false;
+  }
+  const env = value["environment"];
+  const usesUrlArg = stringArrayEquals(value["command"], [
+    "agent-inspector-mcp",
+    "stdio",
+    "--url",
+    endpoint
+  ]);
+  const usesEnv = stringArrayEquals(value["command"], ["agent-inspector-mcp", "stdio"]) && isObject(env) && env["AGENT_INSPECTOR_MCP_URL"] === endpoint;
+  return value["type"] === "local" && (usesUrlArg || usesEnv);
+}
+function isOpenCodeRemoteEntry(value, endpoint, ignoreEnabled) {
+  if (!isObject(value)) {
+    return false;
+  }
+  const enabled = value["enabled"];
+  if (!ignoreEnabled && enabled === false) {
+    return false;
+  }
+  return value["type"] === "remote" && value["url"] === endpoint;
+}
+function isKnownOpenCodeEntry(value, endpoint, ignoreEnabled) {
+  return isOpenCodeLocalEntry(value, endpoint, ignoreEnabled) || isOpenCodeRemoteEntry(value, endpoint, ignoreEnabled);
+}
+function detectOpenCodeTransport(value) {
+  if (!isObject(value)) {
+    return "unknown";
+  }
+  switch (value["type"]) {
+    case "local":
+      return "local";
+    case "remote":
+      return "remote";
+    default:
+      return "unknown";
+  }
+}
+function openCodeActionForStatus(status) {
+  switch (status.state) {
+    case "missing":
+      return "agent-inspector onboard --opencode-only";
+    case "configured":
+      return "opencode mcp list";
+    case "disabled":
+    case "custom":
+      return "agent-inspector onboard --opencode-only --force";
+    case "invalid":
+      return "fix OpenCode JSON/JSONC, then rerun agent-inspector onboard --opencode-only";
+    default:
+      return "agent-inspector onboard --opencode-only";
+  }
+}
+function makeOpenCodeStatus(path, state, transport, endpoint, detail) {
+  const status = {
+    label: "OpenCode MCP config",
+    path,
+    state,
+    transport,
+    endpoint,
+    action: "agent-inspector onboard --opencode-only",
+    detail
+  };
+  return {
+    ...status,
+    action: openCodeActionForStatus(status)
+  };
+}
+function getOpenCodeEntry(config) {
+  const mcp = config["mcp"];
+  if (!isObject(mcp)) {
+    return void 0;
+  }
+  return mcp["agent-inspector"];
+}
+function buildOpenCodeConfig(config, transport, endpoint) {
+  const schema = typeof config["$schema"] === "string" ? config["$schema"] : "https://opencode.ai/config.json";
+  const nextConfig = {
+    $schema: schema
+  };
+  for (const [key, value] of Object.entries(config)) {
+    if (key !== "$schema" && key !== "mcp") {
+      nextConfig[key] = value;
+    }
+  }
+  const currentMcp = config["mcp"];
+  const nextMcp = isObject(currentMcp) ? { ...currentMcp } : {};
+  nextMcp["agent-inspector"] = buildOpenCodeMcpEntry(transport, endpoint);
+  nextConfig["mcp"] = nextMcp;
+  return nextConfig;
+}
+function formatOpenCodeConfig(config) {
+  return `${JSON.stringify(config, null, 2)}
+`;
+}
+function removeOpenCodeEntry(config) {
+  const nextConfig = {};
+  for (const [key, value] of Object.entries(config)) {
+    if (key !== "mcp") {
+      nextConfig[key] = value;
+    }
+  }
+  const currentMcp = config["mcp"];
+  if (!isObject(currentMcp)) {
+    return nextConfig;
+  }
+  const nextMcp = {};
+  for (const [key, value] of Object.entries(currentMcp)) {
+    if (key !== "agent-inspector") {
+      nextMcp[key] = value;
+    }
+  }
+  if (Object.keys(nextMcp).length > 0) {
+    nextConfig["mcp"] = nextMcp;
+  }
+  return nextConfig;
+}
+function readOpenCodeStatus(flags) {
+  const path = resolveOpenCodeConfigPath(flags);
+  const read = readOpenCodeConfig(path);
+  if (!read.ok) {
+    return makeOpenCodeStatus(path, "invalid", "unknown", flags.opencodeMcpUrl, read.message);
+  }
+  const entry = getOpenCodeEntry(read.config);
+  if (entry === void 0) {
+    const detail = read.exists ? "OpenCode config has no mcp.agent-inspector entry" : "Missing file";
+    return makeOpenCodeStatus(path, "missing", "unknown", flags.opencodeMcpUrl, detail);
+  }
+  const transport = detectOpenCodeTransport(entry);
+  if (isObject(entry) && entry["enabled"] === false) {
+    return makeOpenCodeStatus(
+      path,
+      "disabled",
+      transport,
+      flags.opencodeMcpUrl,
+      "mcp.agent-inspector is present but disabled"
+    );
+  }
+  if (isKnownOpenCodeEntry(entry, flags.opencodeMcpUrl, false)) {
+    return makeOpenCodeStatus(
+      path,
+      "configured",
+      transport,
+      flags.opencodeMcpUrl,
+      "mcp.agent-inspector points at Agent Inspector MCP"
+    );
+  }
+  return makeOpenCodeStatus(
+    path,
+    "custom",
+    transport,
+    flags.opencodeMcpUrl,
+    "mcp.agent-inspector exists but does not match Agent Inspector defaults"
+  );
+}
+function buildOpenCodePlan(flags) {
+  const path = resolveOpenCodeConfigPath(flags);
+  const read = readOpenCodeConfig(path);
+  if (!read.ok) {
+    return {
+      status: makeOpenCodeStatus(path, "invalid", "unknown", flags.opencodeMcpUrl, read.message),
+      body: null,
+      shouldWrite: false,
+      shouldRemove: false,
+      blockedMessage: `OpenCode config is invalid: ${read.message}`
+    };
+  }
+  const status = readOpenCodeStatus(flags);
+  const entry = getOpenCodeEntry(read.config);
+  const nextBody = formatOpenCodeConfig(
+    buildOpenCodeConfig(read.config, flags.opencodeTransport, flags.opencodeMcpUrl)
+  );
+  if (flags.uninstall) {
+    const shouldRemove = entry !== void 0 && isKnownOpenCodeEntry(entry, flags.opencodeMcpUrl, true);
+    const removeBody = shouldRemove ? formatOpenCodeConfig(removeOpenCodeEntry(read.config)) : null;
+    return {
+      status,
+      body: removeBody,
+      shouldWrite: false,
+      shouldRemove,
+      blockedMessage: shouldRemove ? null : "OpenCode mcp.agent-inspector is missing or custom; preserved"
+    };
+  }
+  switch (status.state) {
+    case "configured":
+      return {
+        status,
+        body: nextBody,
+        shouldWrite: flags.force,
+        shouldRemove: false,
+        blockedMessage: null
+      };
+    case "missing":
+      return {
+        status,
+        body: nextBody,
+        shouldWrite: true,
+        shouldRemove: false,
+        blockedMessage: null
+      };
+    case "custom":
+    case "disabled":
+      return {
+        status,
+        body: nextBody,
+        shouldWrite: flags.force,
+        shouldRemove: false,
+        blockedMessage: flags.force ? null : "OpenCode mcp.agent-inspector is custom or disabled; use --force to replace"
+      };
+    case "invalid":
+      return {
+        status,
+        body: null,
+        shouldWrite: false,
+        shouldRemove: false,
+        blockedMessage: "OpenCode config is invalid"
+      };
+    default:
+      return {
+        status,
+        body: null,
+        shouldWrite: false,
+        shouldRemove: false,
+        blockedMessage: "OpenCode config state is unknown"
+      };
+  }
+}
 function buildDetectedSummary() {
   const entries = detectAll();
   const present = entries.filter((e) => e.result.found);
@@ -1230,8 +1643,8 @@ function readGeneratedFileStatus(file, currentVersion) {
   }
 }
 function buildPlannedFiles(flags, targets, version) {
-  const installClaude = !flags.codexOnly;
-  const installCodex = !flags.skipCodexSkill;
+  const installClaude = !flags.codexOnly && !flags.opencodeOnly;
+  const installCodex = !flags.skipCodexSkill && !flags.opencodeOnly;
   const detectedSummary = installClaude ? buildDetectedSummary() : "";
   const claudeSkillBody = installClaude ? renderSkillOnboard({
     version,
@@ -1289,7 +1702,7 @@ function removeEmptyDirectory(path) {
   } catch {
   }
 }
-function runUninstall(plannedFiles, currentVersion, dryRun) {
+function runUninstall(plannedFiles, currentVersion, dryRun, openCodePlan) {
   const enabledFiles = plannedFiles.filter((file) => file.enabled);
   const filesToRemove = enabledFiles.filter((file) => shouldUninstall(file, currentVersion));
   if (dryRun) {
@@ -1301,15 +1714,31 @@ function runUninstall(plannedFiles, currentVersion, dryRun) {
       process.stdout.write(`${file.label}: ${file.path} (${status})
 `);
     }
+    if (openCodePlan !== null) {
+      const status = openCodePlan.shouldRemove ? "matching" : "skipped";
+      process.stdout.write(
+        `${openCodePlan.status.label}: ${openCodePlan.status.path} (${status})
+`
+      );
+      if (openCodePlan.blockedMessage !== null) {
+        process.stdout.write(`  ${openCodePlan.blockedMessage}
+`);
+      }
+    }
     process.stdout.write(`
 No files were removed.
 `);
     return 0;
   }
-  if (filesToRemove.length === 0) {
+  const removeOpenCode = openCodePlan !== null && openCodePlan.shouldRemove;
+  if (filesToRemove.length === 0 && !removeOpenCode) {
     process.stdout.write(
       "agent-inspector onboard: no generated onboarding files match this package version\n"
     );
+    if (openCodePlan !== null && openCodePlan.blockedMessage !== null) {
+      process.stdout.write(`${openCodePlan.blockedMessage}
+`);
+    }
     return 0;
   }
   try {
@@ -1317,6 +1746,12 @@ No files were removed.
       unlinkSync(file.path);
       removeEmptyDirectory(dirname(file.path));
       process.stdout.write(`Removed ${file.label}: ${file.path}
+`);
+    }
+    if (openCodePlan !== null && openCodePlan.shouldRemove && openCodePlan.body !== null) {
+      mkdirSync(dirname(openCodePlan.status.path), { recursive: true });
+      writeFileSync(openCodePlan.status.path, openCodePlan.body, "utf8");
+      process.stdout.write(`Removed OpenCode MCP entry from: ${openCodePlan.status.path}
 `);
     }
   } catch (err) {
@@ -1330,13 +1765,20 @@ No files were removed.
 function formatStatusVersion(status) {
   return status.version ?? "-";
 }
-function summarizeStatusAction(statuses) {
+function summarizeStatusAction(statuses, openCodeStatus) {
   const actionable = statuses.filter(
     (status) => status.state === "missing" || status.state === "outdated"
   );
-  if (actionable.length > 0) {
-    const actions = Array.from(new Set(actionable.map((status) => status.action)));
-    return `Run: ${actions.join(" && ")}`;
+  const actions = actionable.map((status) => status.action);
+  if (openCodeStatus !== null && openCodeStatus.state === "missing") {
+    actions.push(openCodeStatus.action);
+  }
+  if (actions.length > 0) {
+    const uniqueActions = Array.from(new Set(actions));
+    return `Run: ${uniqueActions.join(" && ")}`;
+  }
+  if (openCodeStatus !== null && (openCodeStatus.state === "custom" || openCodeStatus.state === "disabled" || openCodeStatus.state === "invalid")) {
+    return `OpenCode config needs review: ${openCodeStatus.action}`;
   }
   if (statuses.some((status) => status.state === "custom")) {
     return "Custom files are preserved. Use --force only if you want to replace them.";
@@ -1346,16 +1788,17 @@ function summarizeStatusAction(statuses) {
   }
   return "All selected onboarding files are current.";
 }
-function runStatus(plannedFiles, currentVersion, json) {
+function runStatus(plannedFiles, currentVersion, json, openCodeStatus) {
   const enabledFiles = plannedFiles.filter((file) => file.enabled);
   const statuses = enabledFiles.map((file) => readGeneratedFileStatus(file, currentVersion));
-  const summary = summarizeStatusAction(statuses);
+  const summary = summarizeStatusAction(statuses, openCodeStatus);
   if (json) {
     process.stdout.write(
       `${JSON.stringify(
         {
           packageVersion: currentVersion,
           files: statuses,
+          opencodeConfig: openCodeStatus,
           suggestedAction: summary
         },
         null,
@@ -1377,6 +1820,19 @@ function runStatus(plannedFiles, currentVersion, json) {
     process.stdout.write(`  ${status.path}
 `);
     process.stdout.write(`  Action: ${status.action}
+`);
+  }
+  if (openCodeStatus !== null) {
+    process.stdout.write(`${openCodeStatus.label}: ${openCodeStatus.state}`);
+    process.stdout.write(`, transport ${openCodeStatus.transport}
+`);
+    process.stdout.write(`  ${openCodeStatus.path}
+`);
+    process.stdout.write(`  Endpoint: ${openCodeStatus.endpoint}
+`);
+    process.stdout.write(`  Detail: ${openCodeStatus.detail}
+`);
+    process.stdout.write(`  Action: ${openCodeStatus.action}
 `);
   }
   process.stdout.write(`
@@ -1401,19 +1857,21 @@ function runOnboardSync(argv) {
   const version = readPackageVersion();
   const plannedFiles = buildPlannedFiles(flags, targets, version);
   const enabledFiles = plannedFiles.filter((file) => file.enabled);
+  const openCodePlan = isOpenCodeEnabled(flags) ? buildOpenCodePlan(flags) : null;
+  const openCodeStatus = openCodePlan === null ? null : openCodePlan.status;
   if (flags.json && !flags.status) {
     process.stderr.write("agent-inspector onboard: --json is only supported with --status\n");
     return 2;
   }
-  if (enabledFiles.length === 0) {
+  if (enabledFiles.length === 0 && openCodePlan === null) {
     process.stderr.write("agent-inspector onboard: no onboarding target selected\n");
     return 2;
   }
   if (flags.status) {
-    return runStatus(plannedFiles, version, flags.json);
+    return runStatus(plannedFiles, version, flags.json, openCodeStatus);
   }
   if (flags.uninstall) {
-    return runUninstall(plannedFiles, version, flags.dryRun);
+    return runUninstall(plannedFiles, version, flags.dryRun, openCodePlan);
   }
   if (flags.dryRun) {
     process.stdout.write(`agent-inspector onboard --dry-run
@@ -1424,31 +1882,47 @@ function runOnboardSync(argv) {
       process.stdout.write(`${file.label}: ${file.path} (${status})
 `);
     }
+    if (openCodePlan !== null) {
+      process.stdout.write(
+        `${openCodePlan.status.label}: ${openCodePlan.status.path} (${openCodePlan.status.state})
+`
+      );
+      process.stdout.write(`  Transport: ${flags.opencodeTransport}
+`);
+      process.stdout.write(`  Endpoint: ${openCodePlan.status.endpoint}
+`);
+      process.stdout.write(`  Action: ${openCodePlan.status.action}
+`);
+      if (openCodePlan.blockedMessage !== null) {
+        process.stdout.write(`  ${openCodePlan.blockedMessage}
+`);
+      }
+    }
     process.stdout.write(`
 Claude skill headings:
 `);
-    if (!flags.codexOnly) {
+    if (!flags.codexOnly && !flags.opencodeOnly) {
       for (const heading of REQUIRED_PHASE_HEADINGS) {
         process.stdout.write(`  - ${heading}
 `);
       }
     } else {
-      process.stdout.write(`  (disabled by --codex-only)
+      process.stdout.write(`  (disabled by selected targets)
 `);
     }
     process.stdout.write(`
 Codex skill headings:
 `);
-    if (!flags.skipCodexSkill) {
+    if (!flags.skipCodexSkill && !flags.opencodeOnly) {
       for (const heading of REQUIRED_CODEX_PHASE_HEADINGS) {
         process.stdout.write(`  - ${heading}
 `);
       }
     } else {
-      process.stdout.write(`  (disabled by --skip-codex-skill)
+      process.stdout.write(`  (disabled by selected targets)
 `);
     }
-    if (!flags.codexOnly) {
+    if (!flags.codexOnly && !flags.opencodeOnly) {
       process.stdout.write(`
 Detected tools:
 ${buildDetectedSummary()}
@@ -1460,10 +1934,20 @@ No files were written.
     return 0;
   }
   const filesToWrite = plannedFiles.filter((file) => shouldWrite(file, flags.force, version));
-  if (filesToWrite.length === 0) {
+  const shouldWriteOpenCode = openCodePlan !== null && openCodePlan.shouldWrite && openCodePlan.body !== null;
+  if (openCodePlan !== null && openCodePlan.status.state === "invalid") {
+    process.stderr.write(`agent-inspector onboard: ${openCodePlan.blockedMessage ?? "invalid"}
+`);
+    return 1;
+  }
+  if (filesToWrite.length === 0 && !shouldWriteOpenCode) {
     process.stdout.write(
       "agent-inspector onboard: all selected onboarding files are already up to date\n"
     );
+    if (openCodePlan !== null && openCodePlan.blockedMessage !== null) {
+      process.stdout.write(`${openCodePlan.blockedMessage}
+`);
+    }
     process.stdout.write("Re-run with --force to refresh.\n");
     return 0;
   }
@@ -1472,6 +1956,10 @@ No files were written.
       mkdirSync(dirname(file.path), { recursive: true });
       writeFileSync(file.path, file.body, "utf8");
     }
+    if (shouldWriteOpenCode && openCodePlan !== null && openCodePlan.body !== null) {
+      mkdirSync(dirname(openCodePlan.status.path), { recursive: true });
+      writeFileSync(openCodePlan.status.path, openCodePlan.body, "utf8");
+    }
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     process.stderr.write(`agent-inspector onboard: failed to write files: ${msg}
@@ -1482,26 +1970,41 @@ No files were written.
   const toolHint = firstTool !== null ? firstTool.displayName : "no known tool detected";
   for (const file of filesToWrite) {
     process.stdout.write(`Installed/updated ${file.label} to: ${file.path}
+`);
+  }
+  if (shouldWriteOpenCode && openCodePlan !== null) {
+    process.stdout.write(`Installed/updated OpenCode MCP config: ${openCodePlan.status.path}
 `);
   }
   process.stdout.write(`
 Next steps:
 `);
-  if (!flags.codexOnly) {
+  if (!flags.codexOnly && !flags.opencodeOnly) {
     process.stdout.write(`  - Open Claude Code and run: /agent-inspector:onboard
 `);
   }
-  if (!flags.skipCodexSkill) {
+  if (!flags.skipCodexSkill && !flags.opencodeOnly) {
     process.stdout.write(`  - Open Codex and ask to use the agent-inspector-onboard skill
 `);
   }
-  process.stdout.write(`  - Refresh later: agent-inspector onboard --force
+  if (openCodePlan !== null) {
+    process.stdout.write(`  - Verify OpenCode MCP: opencode mcp list
+`);
+  }
+  if (flags.opencodeOnly) {
+    process.stdout.write(
+      `  - Refresh OpenCode later: agent-inspector onboard --opencode-only --force
+`
+    );
+  } else {
+    process.stdout.write(`  - Refresh later: agent-inspector onboard --force
 `);
-  process.stdout.write(`  - Detected primary tool: ${toolHint}
+    process.stdout.write(`  - Detected primary tool: ${toolHint}
 `);
+  }
   return 0;
 }
-var __filename, __dirname, DEFAULT_PORT, SKILL_DIR_NAME, SKILL_FILE_NAME, COMMAND_FILE_NAME, GENERATED_VERSION_PATTERN, FRONTMATTER_PATTERN, SEMVER_PATTERN;
+var __filename, __dirname, DEFAULT_PORT, DEFAULT_MCP_URL, SKILL_DIR_NAME, SKILL_FILE_NAME, COMMAND_FILE_NAME, GENERATED_VERSION_PATTERN, FRONTMATTER_PATTERN, SEMVER_PATTERN;
 var init_onboard = __esm({
   "src/cli/onboard.ts"() {
     "use strict";
@@ -1512,6 +2015,7 @@ var init_onboard = __esm({
     __filename = fileURLToPath(import.meta.url);
     __dirname = dirname(__filename);
     DEFAULT_PORT = 25947;
+    DEFAULT_MCP_URL = `http://localhost:${DEFAULT_PORT}/api/mcp`;
     SKILL_DIR_NAME = "agent-inspector-onboard";
     SKILL_FILE_NAME = "SKILL.md";
     COMMAND_FILE_NAME = process.platform === "win32" ? "agent-inspector-onboard.md" : "agent-inspector:onboard.md";