@tonyclaw/agent-inspector 2.1.7 → 2.1.8

package/src/cli/onboard.ts

@@ -61,8 +61,13 @@ export type OnboardFlags = {
   opencode: boolean;
   opencodeOnly: boolean;
   opencodeConfig: string | null;
-  opencodeTransport: OpenCodeTransport;
+  opencodeTransport: AgentMcpTransport;
   opencodeMcpUrl: string;
+  mimo: boolean;
+  mimoOnly: boolean;
+  mimoConfig: string | null;
+  mimoTransport: AgentMcpTransport;
+  mimoMcpUrl: string;
   uninstall: boolean;
   status: boolean;
   json: boolean;
@@ -70,29 +75,45 @@ export type OnboardFlags = {
   codexSkillDir: string | null;
 };
 
-type OpenCodeTransport = "local" | "remote";
-type OpenCodeStatusTransport = OpenCodeTransport | "unknown";
-type OpenCodeConfigState = "missing" | "configured" | "custom" | "disabled" | "invalid";
+type AgentMcpTransport = "local" | "remote";
+type AgentMcpStatusTransport = AgentMcpTransport | "unknown";
+type AgentMcpConfigState = "missing" | "configured" | "custom" | "disabled" | "invalid";
 
-type OpenCodeConfigStatus = {
-  label: "OpenCode MCP config";
+type AgentMcpConfigTarget = {
+  label: "OpenCode" | "MiMo Code";
+  configLabel: "OpenCode MCP config" | "MiMo Code MCP config";
+  configPath: string;
+  transport: AgentMcpTransport;
+  endpoint: string;
+  setupAction: string;
+  forceAction: string;
+  verifyCommand: string;
+  invalidAction: string;
+  configObjectName: string;
+  defaultSchema: string;
+};
+
+type AgentMcpConfigStatus = {
+  label: "OpenCode MCP config" | "MiMo Code MCP config";
   path: string;
-  state: OpenCodeConfigState;
-  transport: OpenCodeStatusTransport;
+  state: AgentMcpConfigState;
+  transport: AgentMcpStatusTransport;
   endpoint: string;
   action: string;
+  forceAction: string;
+  verifyCommand: string;
   detail: string;
 };
 
-type OpenCodeConfigPlan = {
-  status: OpenCodeConfigStatus;
+type AgentMcpConfigPlan = {
+  status: AgentMcpConfigStatus;
   body: string | null;
   shouldWrite: boolean;
   shouldRemove: boolean;
   blockedMessage: string | null;
 };
 
-type OpenCodeReadResult =
+type AgentConfigReadResult =
   | {
       ok: true;
       exists: boolean;
@@ -171,6 +192,11 @@ function parseFlags(argv: readonly string[]): OnboardFlags {
     opencodeConfig: null,
     opencodeTransport: "local",
     opencodeMcpUrl: DEFAULT_MCP_URL,
+    mimo: false,
+    mimoOnly: false,
+    mimoConfig: null,
+    mimoTransport: "local",
+    mimoMcpUrl: DEFAULT_MCP_URL,
     uninstall: false,
     status: false,
     json: false,
@@ -251,6 +277,53 @@ function parseFlags(argv: readonly string[]): OnboardFlags {
         i++;
         break;
       }
+      case "--mimo":
+        flags.mimo = true;
+        break;
+      case "--mimo-only":
+        flags.mimo = true;
+        flags.mimoOnly = true;
+        break;
+      case "--mimo-config": {
+        const next = argv[i + 1];
+        if (next === undefined) {
+          process.stderr.write("agent-inspector onboard: --mimo-config requires a path argument\n");
+          process.exit(2);
+        }
+        flags.mimoConfig = next;
+        i++;
+        break;
+      }
+      case "--mimo-transport": {
+        const next = argv[i + 1];
+        if (next === undefined) {
+          process.stderr.write(
+            "agent-inspector onboard: --mimo-transport requires local or remote\n",
+          );
+          process.exit(2);
+        }
+        switch (next) {
+          case "local":
+          case "remote":
+            flags.mimoTransport = next;
+            break;
+          default:
+            process.stderr.write(`agent-inspector onboard: invalid --mimo-transport: ${next}\n`);
+            process.exit(2);
+        }
+        i++;
+        break;
+      }
+      case "--mimo-mcp-url": {
+        const next = argv[i + 1];
+        if (next === undefined) {
+          process.stderr.write("agent-inspector onboard: --mimo-mcp-url requires a URL\n");
+          process.exit(2);
+        }
+        flags.mimoMcpUrl = next;
+        i++;
+        break;
+      }
       case "--uninstall":
         flags.uninstall = true;
         break;
@@ -314,6 +387,12 @@ Options:
   --opencode-transport <local|remote>
                            OpenCode MCP transport to write (default: local)
   --opencode-mcp-url <url> Agent Inspector MCP endpoint for OpenCode
+  --mimo                   Also configure MiMo Code MCP in mimocode.json/jsonc
+  --mimo-only              Configure only MiMo Code MCP
+  --mimo-config <path>     Override MiMo config path (default: ~/.config/mimocode/mimocode.jsonc)
+  --mimo-transport <local|remote>
+                           MiMo Code MCP transport to write (default: local)
+  --mimo-mcp-url <url>     Agent Inspector MCP endpoint for MiMo Code
   --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
@@ -349,6 +428,14 @@ function isOpenCodeEnabled(flags: OnboardFlags): boolean {
   return flags.opencode || flags.opencodeOnly;
 }
 
+function isMiMoEnabled(flags: OnboardFlags): boolean {
+  return flags.mimo || flags.mimoOnly;
+}
+
+function hasOnlyAgentMcpTarget(flags: OnboardFlags): boolean {
+  return flags.opencodeOnly || flags.mimoOnly;
+}
+
 function resolveOpenCodeConfigPath(flags: OnboardFlags): string {
   if (flags.opencodeConfig !== null) {
     return flags.opencodeConfig;
@@ -362,6 +449,68 @@ function resolveOpenCodeConfigPath(flags: OnboardFlags): string {
   return join(configDir, "opencode.json");
 }
 
+function resolveMiMoConfigPath(flags: OnboardFlags): string {
+  if (flags.mimoConfig !== null) {
+    return flags.mimoConfig;
+  }
+
+  const configDir = join(homedir(), ".config", "mimocode");
+  const jsoncPath = join(configDir, "mimocode.jsonc");
+  if (existsSync(jsoncPath)) {
+    return jsoncPath;
+  }
+
+  const jsonPath = join(configDir, "mimocode.json");
+  if (existsSync(jsonPath)) {
+    return jsonPath;
+  }
+
+  const legacyDir = join(homedir(), ".mimocode");
+  const legacyJsoncPath = join(legacyDir, "config.jsonc");
+  if (existsSync(legacyJsoncPath)) {
+    return legacyJsoncPath;
+  }
+
+  const legacyJsonPath = join(legacyDir, "config.json");
+  if (existsSync(legacyJsonPath)) {
+    return legacyJsonPath;
+  }
+
+  return jsoncPath;
+}
+
+function openCodeTarget(flags: OnboardFlags): AgentMcpConfigTarget {
+  return {
+    label: "OpenCode",
+    configLabel: "OpenCode MCP config",
+    configPath: resolveOpenCodeConfigPath(flags),
+    transport: flags.opencodeTransport,
+    endpoint: flags.opencodeMcpUrl,
+    setupAction: "agent-inspector onboard --opencode-only",
+    forceAction: "agent-inspector onboard --opencode-only --force",
+    verifyCommand: "opencode mcp list",
+    invalidAction: "fix OpenCode JSON/JSONC, then rerun agent-inspector onboard --opencode-only",
+    configObjectName: "mcp.agent-inspector",
+    defaultSchema: "https://opencode.ai/config.json",
+  };
+}
+
+function miMoTarget(flags: OnboardFlags): AgentMcpConfigTarget {
+  return {
+    label: "MiMo Code",
+    configLabel: "MiMo Code MCP config",
+    configPath: resolveMiMoConfigPath(flags),
+    transport: flags.mimoTransport,
+    endpoint: flags.mimoMcpUrl,
+    setupAction: "agent-inspector onboard --mimo-only",
+    forceAction: "agent-inspector onboard --mimo-only --force",
+    verifyCommand: "mimo mcp list",
+    invalidAction: "fix MiMo Code JSON/JSONC, then rerun agent-inspector onboard --mimo-only",
+    configObjectName: "mcp.agent-inspector",
+    defaultSchema: "https://mimo.xiaomi.com/mimocode/config.json",
+  };
+}
+
 function stripJsoncComments(raw: string): string {
   let result = "";
   let index = 0;
@@ -418,7 +567,7 @@ function stripJsoncComments(raw: string): string {
   return result;
 }
 
-function readOpenCodeConfig(path: string): OpenCodeReadResult {
+function readAgentConfig(path: string, target: AgentMcpConfigTarget): AgentConfigReadResult {
   if (!existsSync(path)) {
     return { ok: true, exists: false, config: {} };
   }
@@ -435,7 +584,7 @@ function readOpenCodeConfig(path: string): OpenCodeReadResult {
     return {
       ok: false,
       exists: true,
-      message: "OpenCode config root must be a JSON object",
+      message: `${target.label} config root must be a JSON object`,
     };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -447,8 +596,8 @@ function readOpenCodeConfig(path: string): OpenCodeReadResult {
   }
 }
 
-function buildOpenCodeMcpEntry(
-  transport: OpenCodeTransport,
+function buildAgentMcpEntry(
+  transport: AgentMcpTransport,
   endpoint: string,
 ): Record<string, unknown> {
   switch (transport) {
@@ -481,7 +630,7 @@ function stringArrayEquals(value: unknown, expected: readonly string[]): boolean
   return value.every((item, index) => item === expected[index]);
 }
 
-function isOpenCodeLocalEntry(value: unknown, endpoint: string, ignoreEnabled: boolean): boolean {
+function isAgentLocalEntry(value: unknown, endpoint: string, ignoreEnabled: boolean): boolean {
   if (!isObject(value)) {
     return false;
   }
@@ -506,7 +655,7 @@ function isOpenCodeLocalEntry(value: unknown, endpoint: string, ignoreEnabled: b
   return value["type"] === "local" && (usesUrlArg || usesEnv);
 }
 
-function isOpenCodeRemoteEntry(value: unknown, endpoint: string, ignoreEnabled: boolean): boolean {
+function isAgentRemoteEntry(value: unknown, endpoint: string, ignoreEnabled: boolean): boolean {
   if (!isObject(value)) {
     return false;
   }
@@ -519,14 +668,14 @@ function isOpenCodeRemoteEntry(value: unknown, endpoint: string, ignoreEnabled:
   return value["type"] === "remote" && value["url"] === endpoint;
 }
 
-function isKnownOpenCodeEntry(value: unknown, endpoint: string, ignoreEnabled: boolean): boolean {
+function isKnownAgentEntry(value: unknown, endpoint: string, ignoreEnabled: boolean): boolean {
   return (
-    isOpenCodeLocalEntry(value, endpoint, ignoreEnabled) ||
-    isOpenCodeRemoteEntry(value, endpoint, ignoreEnabled)
+    isAgentLocalEntry(value, endpoint, ignoreEnabled) ||
+    isAgentRemoteEntry(value, endpoint, ignoreEnabled)
   );
 }
 
-function detectOpenCodeTransport(value: unknown): OpenCodeStatusTransport {
+function detectAgentTransport(value: unknown): AgentMcpStatusTransport {
   if (!isObject(value)) {
     return "unknown";
   }
@@ -541,46 +690,47 @@ function detectOpenCodeTransport(value: unknown): OpenCodeStatusTransport {
   }
 }
 
-function openCodeActionForStatus(status: OpenCodeConfigStatus): string {
+function agentActionForStatus(target: AgentMcpConfigTarget, status: AgentMcpConfigStatus): string {
   switch (status.state) {
     case "missing":
-      return "agent-inspector onboard --opencode-only";
+      return target.setupAction;
     case "configured":
-      return "opencode mcp list";
+      return target.verifyCommand;
     case "disabled":
     case "custom":
-      return "agent-inspector onboard --opencode-only --force";
+      return target.forceAction;
     case "invalid":
-      return "fix OpenCode JSON/JSONC, then rerun agent-inspector onboard --opencode-only";
+      return target.invalidAction;
     default:
-      return "agent-inspector onboard --opencode-only";
+      return target.setupAction;
   }
 }
 
-function makeOpenCodeStatus(
-  path: string,
-  state: OpenCodeConfigState,
-  transport: OpenCodeStatusTransport,
-  endpoint: string,
+function makeAgentStatus(
+  target: AgentMcpConfigTarget,
+  state: AgentMcpConfigState,
+  transport: AgentMcpStatusTransport,
   detail: string,
-): OpenCodeConfigStatus {
-  const status: OpenCodeConfigStatus = {
-    label: "OpenCode MCP config",
-    path,
+): AgentMcpConfigStatus {
+  const status: AgentMcpConfigStatus = {
+    label: target.configLabel,
+    path: target.configPath,
     state,
     transport,
-    endpoint,
-    action: "agent-inspector onboard --opencode-only",
+    endpoint: target.endpoint,
+    action: target.setupAction,
+    forceAction: target.forceAction,
+    verifyCommand: target.verifyCommand,
     detail,
   };
 
   return {
     ...status,
-    action: openCodeActionForStatus(status),
+    action: agentActionForStatus(target, status),
   };
 }
 
-function getOpenCodeEntry(config: Record<string, unknown>): unknown {
+function getAgentEntry(config: Record<string, unknown>): unknown {
   const mcp = config["mcp"];
   if (!isObject(mcp)) {
     return undefined;
@@ -588,13 +738,11 @@ function getOpenCodeEntry(config: Record<string, unknown>): unknown {
   return mcp["agent-inspector"];
 }
 
-function buildOpenCodeConfig(
+function buildAgentConfig(
   config: Record<string, unknown>,
-  transport: OpenCodeTransport,
-  endpoint: string,
+  target: AgentMcpConfigTarget,
 ): Record<string, unknown> {
-  const schema =
-    typeof config["$schema"] === "string" ? config["$schema"] : "https://opencode.ai/config.json";
+  const schema = typeof config["$schema"] === "string" ? config["$schema"] : target.defaultSchema;
   const nextConfig: Record<string, unknown> = {
     $schema: schema,
   };
@@ -607,16 +755,16 @@ function buildOpenCodeConfig(
 
   const currentMcp = config["mcp"];
   const nextMcp: Record<string, unknown> = isObject(currentMcp) ? { ...currentMcp } : {};
-  nextMcp["agent-inspector"] = buildOpenCodeMcpEntry(transport, endpoint);
+  nextMcp["agent-inspector"] = buildAgentMcpEntry(target.transport, target.endpoint);
   nextConfig["mcp"] = nextMcp;
   return nextConfig;
 }
 
-function formatOpenCodeConfig(config: Record<string, unknown>): string {
+function formatAgentConfig(config: Record<string, unknown>): string {
   return `${JSON.stringify(config, null, 2)}\n`;
 }
 
-function removeOpenCodeEntry(config: Record<string, unknown>): Record<string, unknown> {
+function removeAgentEntry(config: Record<string, unknown>): Record<string, unknown> {
   const nextConfig: Record<string, unknown> = {};
   for (const [key, value] of Object.entries(config)) {
     if (key !== "mcp") {
@@ -642,74 +790,70 @@ function removeOpenCodeEntry(config: Record<string, unknown>): Record<string, un
   return nextConfig;
 }
 
-function readOpenCodeStatus(flags: OnboardFlags): OpenCodeConfigStatus {
-  const path = resolveOpenCodeConfigPath(flags);
-  const read = readOpenCodeConfig(path);
+function readAgentStatus(target: AgentMcpConfigTarget): AgentMcpConfigStatus {
+  const read = readAgentConfig(target.configPath, target);
   if (!read.ok) {
-    return makeOpenCodeStatus(path, "invalid", "unknown", flags.opencodeMcpUrl, read.message);
+    return makeAgentStatus(target, "invalid", "unknown", read.message);
   }
 
-  const entry = getOpenCodeEntry(read.config);
+  const entry = getAgentEntry(read.config);
   if (entry === undefined) {
     const detail = read.exists
-      ? "OpenCode config has no mcp.agent-inspector entry"
+      ? `${target.label} config has no ${target.configObjectName}`
       : "Missing file";
-    return makeOpenCodeStatus(path, "missing", "unknown", flags.opencodeMcpUrl, detail);
+    return makeAgentStatus(target, "missing", "unknown", detail);
   }
 
-  const transport = detectOpenCodeTransport(entry);
+  const transport = detectAgentTransport(entry);
   if (isObject(entry) && entry["enabled"] === false) {
-    return makeOpenCodeStatus(
-      path,
+    return makeAgentStatus(
+      target,
       "disabled",
       transport,
-      flags.opencodeMcpUrl,
-      "mcp.agent-inspector is present but disabled",
+      `${target.configObjectName} is present but disabled`,
     );
   }
 
-  if (isKnownOpenCodeEntry(entry, flags.opencodeMcpUrl, false)) {
-    return makeOpenCodeStatus(
-      path,
+  if (isKnownAgentEntry(entry, target.endpoint, false)) {
+    return makeAgentStatus(
+      target,
       "configured",
       transport,
-      flags.opencodeMcpUrl,
-      "mcp.agent-inspector points at Agent Inspector MCP",
+      `${target.configObjectName} points at Agent Inspector MCP`,
     );
   }
 
-  return makeOpenCodeStatus(
-    path,
+  return makeAgentStatus(
+    target,
     "custom",
     transport,
-    flags.opencodeMcpUrl,
-    "mcp.agent-inspector exists but does not match Agent Inspector defaults",
+    `${target.configObjectName} exists but does not match Agent Inspector defaults`,
   );
 }
 
-function buildOpenCodePlan(flags: OnboardFlags): OpenCodeConfigPlan {
-  const path = resolveOpenCodeConfigPath(flags);
-  const read = readOpenCodeConfig(path);
+function buildAgentPlan(
+  target: AgentMcpConfigTarget,
+  uninstall: boolean,
+  force: boolean,
+): AgentMcpConfigPlan {
+  const read = readAgentConfig(target.configPath, target);
   if (!read.ok) {
     return {
-      status: makeOpenCodeStatus(path, "invalid", "unknown", flags.opencodeMcpUrl, read.message),
+      status: makeAgentStatus(target, "invalid", "unknown", read.message),
       body: null,
       shouldWrite: false,
       shouldRemove: false,
-      blockedMessage: `OpenCode config is invalid: ${read.message}`,
+      blockedMessage: `${target.label} config is invalid: ${read.message}`,
     };
   }
 
-  const status = readOpenCodeStatus(flags);
-  const entry = getOpenCodeEntry(read.config);
-  const nextBody = formatOpenCodeConfig(
-    buildOpenCodeConfig(read.config, flags.opencodeTransport, flags.opencodeMcpUrl),
-  );
+  const status = readAgentStatus(target);
+  const entry = getAgentEntry(read.config);
+  const nextBody = formatAgentConfig(buildAgentConfig(read.config, target));
 
-  if (flags.uninstall) {
-    const shouldRemove =
-      entry !== undefined && isKnownOpenCodeEntry(entry, flags.opencodeMcpUrl, true);
-    const removeBody = shouldRemove ? formatOpenCodeConfig(removeOpenCodeEntry(read.config)) : null;
+  if (uninstall) {
+    const shouldRemove = entry !== undefined && isKnownAgentEntry(entry, target.endpoint, true);
+    const removeBody = shouldRemove ? formatAgentConfig(removeAgentEntry(read.config)) : null;
     return {
       status,
       body: removeBody,
@@ -717,7 +861,7 @@ function buildOpenCodePlan(flags: OnboardFlags): OpenCodeConfigPlan {
       shouldRemove,
       blockedMessage: shouldRemove
         ? null
-        : "OpenCode mcp.agent-inspector is missing or custom; preserved",
+        : `${target.label} ${target.configObjectName} is missing or custom; preserved`,
     };
   }
 
@@ -726,7 +870,7 @@ function buildOpenCodePlan(flags: OnboardFlags): OpenCodeConfigPlan {
       return {
         status,
         body: nextBody,
-        shouldWrite: flags.force,
+        shouldWrite: force,
         shouldRemove: false,
         blockedMessage: null,
       };
@@ -743,11 +887,11 @@ function buildOpenCodePlan(flags: OnboardFlags): OpenCodeConfigPlan {
       return {
         status,
         body: nextBody,
-        shouldWrite: flags.force,
+        shouldWrite: force,
         shouldRemove: false,
-        blockedMessage: flags.force
+        blockedMessage: force
           ? null
-          : "OpenCode mcp.agent-inspector is custom or disabled; use --force to replace",
+          : `${target.label} ${target.configObjectName} is custom or disabled; use --force to replace`,
       };
     case "invalid":
       return {
@@ -755,7 +899,7 @@ function buildOpenCodePlan(flags: OnboardFlags): OpenCodeConfigPlan {
         body: null,
         shouldWrite: false,
         shouldRemove: false,
-        blockedMessage: "OpenCode config is invalid",
+        blockedMessage: `${target.label} config is invalid`,
       };
     default:
       return {
@@ -763,7 +907,7 @@ function buildOpenCodePlan(flags: OnboardFlags): OpenCodeConfigPlan {
         body: null,
         shouldWrite: false,
         shouldRemove: false,
-        blockedMessage: "OpenCode config state is unknown",
+        blockedMessage: `${target.label} config state is unknown`,
       };
   }
 }
@@ -973,8 +1117,8 @@ function buildPlannedFiles(
   targets: OnboardTargets,
   version: string,
 ): PlannedFile[] {
-  const installClaude = !flags.codexOnly && !flags.opencodeOnly;
-  const installCodex = !flags.skipCodexSkill && !flags.opencodeOnly;
+  const installClaude = !flags.codexOnly && !hasOnlyAgentMcpTarget(flags);
+  const installCodex = !flags.skipCodexSkill && !hasOnlyAgentMcpTarget(flags);
   const detectedSummary = installClaude ? buildDetectedSummary() : "";
   const claudeSkillBody = installClaude
     ? renderSkillOnboard({
@@ -1050,7 +1194,7 @@ function runUninstall(
   plannedFiles: readonly PlannedFile[],
   currentVersion: string,
   dryRun: boolean,
-  openCodePlan: OpenCodeConfigPlan | null,
+  agentPlans: readonly AgentMcpConfigPlan[],
 ): number {
   const enabledFiles = plannedFiles.filter((file) => file.enabled);
   const filesToRemove = enabledFiles.filter((file) => shouldUninstall(file, currentVersion));
@@ -1061,26 +1205,26 @@ function runUninstall(
       const status = shouldUninstall(file, currentVersion) ? "matching" : "skipped";
       process.stdout.write(`${file.label}: ${file.path} (${status})\n`);
     }
-    if (openCodePlan !== null) {
-      const status = openCodePlan.shouldRemove ? "matching" : "skipped";
-      process.stdout.write(
-        `${openCodePlan.status.label}: ${openCodePlan.status.path} (${status})\n`,
-      );
-      if (openCodePlan.blockedMessage !== null) {
-        process.stdout.write(`  ${openCodePlan.blockedMessage}\n`);
+    for (const plan of agentPlans) {
+      const status = plan.shouldRemove ? "matching" : "skipped";
+      process.stdout.write(`${plan.status.label}: ${plan.status.path} (${status})\n`);
+      if (plan.blockedMessage !== null) {
+        process.stdout.write(`  ${plan.blockedMessage}\n`);
       }
     }
     process.stdout.write(`\nNo files were removed.\n`);
     return 0;
   }
 
-  const removeOpenCode = openCodePlan !== null && openCodePlan.shouldRemove;
-  if (filesToRemove.length === 0 && !removeOpenCode) {
+  const hasAgentConfigToRemove = agentPlans.some((plan) => plan.shouldRemove);
+  if (filesToRemove.length === 0 && !hasAgentConfigToRemove) {
     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}\n`);
+    for (const plan of agentPlans) {
+      if (plan.blockedMessage !== null) {
+        process.stdout.write(`${plan.blockedMessage}\n`);
+      }
     }
     return 0;
   }
@@ -1091,10 +1235,12 @@ function runUninstall(
       removeEmptyDirectory(dirname(file.path));
       process.stdout.write(`Removed ${file.label}: ${file.path}\n`);
     }
-    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}\n`);
+    for (const plan of agentPlans) {
+      if (plan.shouldRemove && plan.body !== null) {
+        mkdirSync(dirname(plan.status.path), { recursive: true });
+        writeFileSync(plan.status.path, plan.body, "utf8");
+        process.stdout.write(`Removed ${plan.status.label} entry from: ${plan.status.path}\n`);
+      }
     }
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -1111,26 +1257,29 @@ function formatStatusVersion(status: GeneratedFileStatus): string {
 
 function summarizeStatusAction(
   statuses: readonly GeneratedFileStatus[],
-  openCodeStatus: OpenCodeConfigStatus | null,
+  agentStatuses: readonly AgentMcpConfigStatus[],
 ): string {
   const actionable = statuses.filter(
     (status) => status.state === "missing" || status.state === "outdated",
   );
   const actions = actionable.map((status) => status.action);
-  if (openCodeStatus !== null && openCodeStatus.state === "missing") {
-    actions.push(openCodeStatus.action);
+  for (const agentStatus of agentStatuses) {
+    if (agentStatus.state === "missing") {
+      actions.push(agentStatus.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}`;
+  for (const agentStatus of agentStatuses) {
+    if (
+      agentStatus.state === "custom" ||
+      agentStatus.state === "disabled" ||
+      agentStatus.state === "invalid"
+    ) {
+      return `${agentStatus.label} needs review: ${agentStatus.action}`;
+    }
   }
   if (statuses.some((status) => status.state === "custom")) {
     return "Custom files are preserved. Use --force only if you want to replace them.";
@@ -1145,11 +1294,15 @@ function runStatus(
   plannedFiles: readonly PlannedFile[],
   currentVersion: string,
   json: boolean,
-  openCodeStatus: OpenCodeConfigStatus | null,
+  agentStatuses: readonly AgentMcpConfigStatus[],
 ): number {
   const enabledFiles = plannedFiles.filter((file) => file.enabled);
   const statuses = enabledFiles.map((file) => readGeneratedFileStatus(file, currentVersion));
-  const summary = summarizeStatusAction(statuses, openCodeStatus);
+  const summary = summarizeStatusAction(statuses, agentStatuses);
+  const opencodeConfig =
+    agentStatuses.find((status) => status.label === "OpenCode MCP config") ?? null;
+  const mimoConfig =
+    agentStatuses.find((status) => status.label === "MiMo Code MCP config") ?? null;
 
   if (json) {
     process.stdout.write(
@@ -1157,7 +1310,8 @@ function runStatus(
         {
           packageVersion: currentVersion,
           files: statuses,
-          opencodeConfig: openCodeStatus,
+          opencodeConfig,
+          mimoConfig,
           suggestedAction: summary,
         },
         null,
@@ -1177,13 +1331,13 @@ function runStatus(
     process.stdout.write(`  Action: ${status.action}\n`);
   }
 
-  if (openCodeStatus !== null) {
-    process.stdout.write(`${openCodeStatus.label}: ${openCodeStatus.state}`);
-    process.stdout.write(`, transport ${openCodeStatus.transport}\n`);
-    process.stdout.write(`  ${openCodeStatus.path}\n`);
-    process.stdout.write(`  Endpoint: ${openCodeStatus.endpoint}\n`);
-    process.stdout.write(`  Detail: ${openCodeStatus.detail}\n`);
-    process.stdout.write(`  Action: ${openCodeStatus.action}\n`);
+  for (const agentStatus of agentStatuses) {
+    process.stdout.write(`${agentStatus.label}: ${agentStatus.state}`);
+    process.stdout.write(`, transport ${agentStatus.transport}\n`);
+    process.stdout.write(`  ${agentStatus.path}\n`);
+    process.stdout.write(`  Endpoint: ${agentStatus.endpoint}\n`);
+    process.stdout.write(`  Detail: ${agentStatus.detail}\n`);
+    process.stdout.write(`  Action: ${agentStatus.action}\n`);
   }
 
   process.stdout.write(`\nSuggested action: ${summary}\n`);
@@ -1208,25 +1362,31 @@ function runOnboardSync(argv: readonly string[]): number {
   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;
+  const agentPlans: AgentMcpConfigPlan[] = [];
+  if (isOpenCodeEnabled(flags)) {
+    agentPlans.push(buildAgentPlan(openCodeTarget(flags), flags.uninstall, flags.force));
+  }
+  if (isMiMoEnabled(flags)) {
+    agentPlans.push(buildAgentPlan(miMoTarget(flags), flags.uninstall, flags.force));
+  }
+  const agentStatuses = agentPlans.map((plan) => plan.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 && openCodePlan === null) {
+  if (enabledFiles.length === 0 && agentPlans.length === 0) {
     process.stderr.write("agent-inspector onboard: no onboarding target selected\n");
     return 2;
   }
 
   if (flags.status) {
-    return runStatus(plannedFiles, version, flags.json, openCodeStatus);
+    return runStatus(plannedFiles, version, flags.json, agentStatuses);
   }
 
   if (flags.uninstall) {
-    return runUninstall(plannedFiles, version, flags.dryRun, openCodePlan);
+    return runUninstall(plannedFiles, version, flags.dryRun, agentPlans);
   }
 
   if (flags.dryRun) {
@@ -1235,19 +1395,17 @@ function runOnboardSync(argv: readonly string[]): number {
       const status = existsSync(file.path) ? "exists" : "missing";
       process.stdout.write(`${file.label}: ${file.path} (${status})\n`);
     }
-    if (openCodePlan !== null) {
-      process.stdout.write(
-        `${openCodePlan.status.label}: ${openCodePlan.status.path} (${openCodePlan.status.state})\n`,
-      );
-      process.stdout.write(`  Transport: ${flags.opencodeTransport}\n`);
-      process.stdout.write(`  Endpoint: ${openCodePlan.status.endpoint}\n`);
-      process.stdout.write(`  Action: ${openCodePlan.status.action}\n`);
-      if (openCodePlan.blockedMessage !== null) {
-        process.stdout.write(`  ${openCodePlan.blockedMessage}\n`);
+    for (const plan of agentPlans) {
+      process.stdout.write(`${plan.status.label}: ${plan.status.path} (${plan.status.state})\n`);
+      process.stdout.write(`  Transport: ${plan.status.transport}\n`);
+      process.stdout.write(`  Endpoint: ${plan.status.endpoint}\n`);
+      process.stdout.write(`  Action: ${plan.status.action}\n`);
+      if (plan.blockedMessage !== null) {
+        process.stdout.write(`  ${plan.blockedMessage}\n`);
       }
     }
     process.stdout.write(`\nClaude skill headings:\n`);
-    if (!flags.codexOnly && !flags.opencodeOnly) {
+    if (!flags.codexOnly && !hasOnlyAgentMcpTarget(flags)) {
       for (const heading of REQUIRED_PHASE_HEADINGS) {
         process.stdout.write(`  - ${heading}\n`);
       }
@@ -1255,14 +1413,14 @@ function runOnboardSync(argv: readonly string[]): number {
       process.stdout.write(`  (disabled by selected targets)\n`);
     }
     process.stdout.write(`\nCodex skill headings:\n`);
-    if (!flags.skipCodexSkill && !flags.opencodeOnly) {
+    if (!flags.skipCodexSkill && !hasOnlyAgentMcpTarget(flags)) {
       for (const heading of REQUIRED_CODEX_PHASE_HEADINGS) {
         process.stdout.write(`  - ${heading}\n`);
       }
     } else {
       process.stdout.write(`  (disabled by selected targets)\n`);
     }
-    if (!flags.codexOnly && !flags.opencodeOnly) {
+    if (!flags.codexOnly && !hasOnlyAgentMcpTarget(flags)) {
       process.stdout.write(`\nDetected tools:\n${buildDetectedSummary()}\n`);
     }
     process.stdout.write(`\nNo files were written.\n`);
@@ -1270,18 +1428,21 @@ function runOnboardSync(argv: readonly string[]): number {
   }
 
   const filesToWrite = plannedFiles.filter((file) => shouldWrite(file, flags.force, version));
-  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"}\n`);
-    return 1;
+  const agentPlansToWrite = agentPlans.filter((plan) => plan.shouldWrite && plan.body !== null);
+  for (const plan of agentPlans) {
+    if (plan.status.state === "invalid") {
+      process.stderr.write(`agent-inspector onboard: ${plan.blockedMessage ?? "invalid"}\n`);
+      return 1;
+    }
   }
-  if (filesToWrite.length === 0 && !shouldWriteOpenCode) {
+  if (filesToWrite.length === 0 && agentPlansToWrite.length === 0) {
     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}\n`);
+    for (const plan of agentPlans) {
+      if (plan.blockedMessage !== null) {
+        process.stdout.write(`${plan.blockedMessage}\n`);
+      }
     }
     process.stdout.write("Re-run with --force to refresh.\n");
     return 0;
@@ -1292,9 +1453,11 @@ function runOnboardSync(argv: readonly string[]): number {
       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");
+    for (const plan of agentPlansToWrite) {
+      if (plan.body !== null) {
+        mkdirSync(dirname(plan.status.path), { recursive: true });
+        writeFileSync(plan.status.path, plan.body, "utf8");
+      }
     }
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -1308,23 +1471,27 @@ function runOnboardSync(argv: readonly string[]): number {
   for (const file of filesToWrite) {
     process.stdout.write(`Installed/updated ${file.label} to: ${file.path}\n`);
   }
-  if (shouldWriteOpenCode && openCodePlan !== null) {
-    process.stdout.write(`Installed/updated OpenCode MCP config: ${openCodePlan.status.path}\n`);
+  for (const plan of agentPlansToWrite) {
+    process.stdout.write(`Installed/updated ${plan.status.label}: ${plan.status.path}\n`);
   }
   process.stdout.write(`\nNext steps:\n`);
-  if (!flags.codexOnly && !flags.opencodeOnly) {
+  if (!flags.codexOnly && !hasOnlyAgentMcpTarget(flags)) {
     process.stdout.write(`  - Open Claude Code and run: /agent-inspector:onboard\n`);
   }
-  if (!flags.skipCodexSkill && !flags.opencodeOnly) {
+  if (!flags.skipCodexSkill && !hasOnlyAgentMcpTarget(flags)) {
     process.stdout.write(`  - Open Codex and ask to use the agent-inspector-onboard skill\n`);
   }
-  if (openCodePlan !== null) {
-    process.stdout.write(`  - Verify OpenCode MCP: opencode mcp list\n`);
-  }
-  if (flags.opencodeOnly) {
-    process.stdout.write(
-      `  - Refresh OpenCode later: agent-inspector onboard --opencode-only --force\n`,
-    );
+  for (const plan of agentPlans) {
+    process.stdout.write(`  - Verify ${plan.status.label}: ${plan.status.verifyCommand}\n`);
+  }
+  if (hasOnlyAgentMcpTarget(flags)) {
+    const refreshActions = agentPlans.map((plan) => plan.status.forceAction);
+    const uniqueRefreshActions = Array.from(new Set(refreshActions));
+    const refresh =
+      uniqueRefreshActions.length > 0
+        ? uniqueRefreshActions.join(" && ")
+        : "agent-inspector onboard --force";
+    process.stdout.write(`  - Refresh selected MCP config later: ${refresh}\n`);
   } else {
     process.stdout.write(`  - Refresh later: agent-inspector onboard --force\n`);
     process.stdout.write(`  - Detected primary tool: ${toolHint}\n`);