waitspin 0.1.3 → 0.1.4

package/dist/cli.js

@@ -3,7 +3,7 @@ import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { realpathSync } from "node:fs";
 import { constants as fsConstants } from "node:fs";
-import { access, chmod, cp, mkdir, readFile, rm, writeFile, } from "node:fs/promises";
+import { access, chmod, cp, mkdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 const DEFAULT_BASE_URL = process.env.WAITSPIN_BASE_URL?.trim() || "https://api.waitspin.com";
@@ -15,6 +15,11 @@ const CLAUDE_CODE_BIN_ENV = "WAITSPIN_CLAUDE_CODE_BIN";
 const CLAUDE_CODE_MIN_VERSION = "2.1.97";
 const CLAUDE_CODE_PUBLISHER_TARGET = "claude-code";
 const CLAUDE_CODE_REFRESH_INTERVAL_SECONDS = 5;
+const MIMOCODE_BIN_ENV = "WAITSPIN_MIMOCODE_BIN";
+const MIMOCODE_DEFAULT_BIN = "mimo";
+const OPENCODE_PUBLISHER_TARGET = "opencode";
+const OPENCODE_BIN_ENV = "WAITSPIN_OPENCODE_BIN";
+const OPENCODE_DEFAULT_BIN = "opencode";
 const extensionTargets = {
     vscode: "vscode",
 };
@@ -24,7 +29,7 @@ export function usageText() {
         "  waitspin init --email you@example.com [--code CODE] [--key-profile control|publisher-extension] [--base-url URL]",
         "  waitspin bid create --line TEXT --url https://example.com --price-per-block CENTS --blocks N [--base-url URL] [--api-key KEY]",
         "  waitspin bids list [--base-url URL] [--api-key KEY]",
-        "  waitspin bid checkout CAMPAIGN_ID [--base-url URL] [--api-key KEY]",
+        "  waitspin bid checkout <campaign-id> [--base-url URL] [--api-key KEY]",
         "  waitspin market [--base-url URL]",
         "  waitspin wallet status [--base-url URL] [--api-key KEY]",
         "  waitspin wallet connect [--base-url URL] [--api-key KEY]",
@@ -34,23 +39,22 @@ export function usageText() {
         "  waitspin extension install [--target vscode] [--base-url URL] [--api-key KEY] [--dry-run]",
         "  waitspin extension status [--target vscode]",
         "  waitspin extension uninstall [--target vscode] [--dry-run]",
-        "  waitspin claude-code install [--base-url URL] [--api-key KEY] [--dry-run] [--compose-existing]",
+        "  waitspin install --all [--api-key KEY] [--compose-existing] [--dry-run]",
+        "  waitspin status --all",
+        "  waitspin claude-code install [--api-key KEY] [--compose-existing] [--dry-run]",
         "  waitspin claude-code status",
         "  waitspin claude-code uninstall [--dry-run]",
+        "  waitspin mimocode install [--api-key KEY] [--dry-run]",
+        "  waitspin mimocode status",
+        "  waitspin mimocode uninstall [--dry-run]",
+        "  waitspin opencode install [--api-key KEY] [--dry-run]",
+        "  waitspin opencode status",
+        "  waitspin opencode uninstall [--dry-run]",
         "",
         "Defaults:",
         "  API base: https://api.waitspin.com",
         "  API key: WAITSPIN_API_KEY env var",
-        "  Public install targets: VS Code status-bar fallback, Claude Code statusline",
-        "",
-        "Publisher install targets:",
-        "  VS Code:",
-        "    waitspin extension install --target vscode",
-        "    waitspin extension status --target vscode",
-        "",
-        "  Claude Code:",
-        "    waitspin claude-code install --compose-existing",
-        "    waitspin claude-code status",
+        "  Public publisher targets: status-bar-fallback, claude-code, mimocode, opencode",
     ].join("\n") + "\n");
 }
 function usage(exitCode = 1) {
@@ -90,7 +94,8 @@ function parseArgs(argv) {
             key === "allow-dev-api-base" ||
             key === "allow-dev-extension-assets" ||
             key === "confirm-test-transfer" ||
-            key === "compose-existing") {
+            key === "compose-existing" ||
+            key === "all") {
             flags.set(key, ["true"]);
             continue;
         }
@@ -225,8 +230,25 @@ async function requestJson(input, init) {
     }
     return { status: response.status, body: payload };
 }
-function printJson(value) {
+let jsonPrinter = (value) => {
     process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+};
+function printJson(value) {
+    jsonPrinter(value);
+}
+async function capturePrintedJson(fn) {
+    const previousPrinter = jsonPrinter;
+    let captured;
+    jsonPrinter = (value) => {
+        captured = value;
+    };
+    try {
+        await fn();
+    }
+    finally {
+        jsonPrinter = previousPrinter;
+    }
+    return captured;
 }
 function keyProfileFromIntendedUse(intendedUse) {
     if (intendedUse === "key_profile:publisher_extension") {
@@ -262,9 +284,9 @@ function nextCommandsForVerifiedKey(input) {
             next: "install_publisher_target",
             next_commands: [
                 "export WAITSPIN_API_KEY='PASTE_KEY_HERE'",
-                "waitspin claude-code install --compose-existing",
-                "waitspin claude-code status",
-                "claude",
+                "waitspin install --all --dry-run --compose-existing",
+                "waitspin install --all --compose-existing",
+                "waitspin status --all",
             ],
             human_message: "Use this publisher-extension key only for publisher install, serve polling, and impressions. Rotate it if it appears in logs.",
         };
@@ -570,6 +592,21 @@ async function registerPublisherInstall(input) {
                 "For developer-local acceptance only, use an explicit loopback API with --allow-dev-api-base.",
             ].join("\n"));
         }
+        if (input.target === OPENCODE_PUBLISHER_TARGET &&
+            error instanceof WaitSpinCliHttpError &&
+            error.status === 400 &&
+            /Invalid input|Validation error/.test(error.message)) {
+            throw new Error([
+                `WaitSpin API rejected target "${OPENCODE_PUBLISHER_TARGET}".`,
+                "Your local CLI supports OpenCode, but the selected API base does not.",
+                "",
+                "For production:",
+                "  deploy the backend target allowlist, then rerun:",
+                `  waitspin ${OPENCODE_PUBLISHER_TARGET} install`,
+                "",
+                "For developer-local acceptance only, use an explicit loopback API with --allow-dev-api-base.",
+            ].join("\n"));
+        }
         throw error;
     }
     if (!body) {
@@ -1158,7 +1195,11 @@ async function withCacheLock(cachePath, callback) {
 
 function cleanLine(value) {
   return String(value || "")
-    .replace(/[\r\n\u0000-\u001F\u007F]/g, " ")
+    .replace(
+      /(?:\u001B\[[0-?]*[ -/]*[@-~]|\u001B\][^\u0007]*(?:\u0007|\u001B\\)|\u001B[P^_][\s\S]*?\u001B\\|\u001B[@-Z\\-_]|\u009B[0-?]*[ -/]*[@-~])/g,
+      " ",
+    )
+    .replace(/[\r\n\u0000-\u001F\u007F-\u009F]/g, " ")
     .replace(/\s+/g, " ")
     .trim()
     .slice(0, 120);
@@ -1653,29 +1694,1227 @@ export async function runClaudeCodeUninstall(flags) {
         ...(settingsWarning ? { settings_warning: settingsWarning } : {}),
     });
 }
-export async function main(argv = process.argv.slice(2)) {
-    const { command, flags, positionals } = parseArgs(argv);
-    if (command === "init") {
-        await runInit(flags);
-        return;
+// --- MiMo Code Publisher Support ---
+const MIMOCODE_PUBLISHER_TARGET = "mimocode";
+function miMoCodeInstallDir() {
+    return path.join(os.homedir(), ".waitspin");
+}
+function miMoCodeStatePath() {
+    return path.join(miMoCodeInstallDir(), "mimocode-statusline.json");
+}
+function miMoCodeCachePath() {
+    return path.join(miMoCodeInstallDir(), "mimocode-statusline-cache.json");
+}
+function miMoCodeRuntimePath() {
+    return path.join(os.homedir(), ".local", "bin", "waitspin-mimocode-runtime");
+}
+function miMoCodeBashrcPath() {
+    return path.join(os.homedir(), ".bashrc");
+}
+const MIMOCODE_BASHRC_MARKER = "# WaitSpin MiMo Code statusline hook";
+const MIMOCODE_BASHRC_END_MARKER = "# End WaitSpin MiMo Code statusline hook";
+function miMoCodeStatuslineRuntimeSource() {
+    return String.raw `#!/usr/bin/env node
+import {
+  mkdir,
+  readFile,
+  rename,
+  rm,
+  stat,
+  writeFile,
+} from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+const FETCH_INTERVAL_MS = 15_000;
+const FETCH_TIMEOUT_MS = 2_500;
+const MAX_ACTIVE_AGE_MS = 60_000;
+const LOCK_RETRY_MS = 40;
+const LOCK_TIMEOUT_MS = 2_000;
+const LOCK_STALE_MS = 10_000;
+
+const STATE_DIR = path.join(os.homedir(), ".waitspin");
+const STATE_FILE = path.join(STATE_DIR, "mimocode-statusline.json");
+const DEFAULT_CACHE_FILE = path.join(STATE_DIR, "mimocode-statusline-cache.json");
+
+async function readJson(filePath, fallback) {
+  try {
+    return JSON.parse(await readFile(filePath, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+async function writeJson(filePath, value) {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  const tmp = filePath + "." + process.pid + ".tmp";
+  await writeFile(tmp, JSON.stringify(value, null, 2) + "\n", {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+  await rename(tmp, filePath);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function acquireCacheLock(cachePath) {
+  await mkdir(path.dirname(cachePath), { recursive: true });
+  const lockPath = cachePath + ".lock";
+  const startedAt = Date.now();
+
+  while (Date.now() - startedAt < LOCK_TIMEOUT_MS) {
+    try {
+      await mkdir(lockPath);
+      return async () => {
+        await rm(lockPath, { recursive: true, force: true });
+      };
+    } catch {
+      try {
+        const lockStat = await stat(lockPath);
+        if (Date.now() - lockStat.mtimeMs > LOCK_STALE_MS) {
+          await rm(lockPath, { recursive: true, force: true });
+          continue;
+        }
+      } catch {
+        // Another process may have released the lock between mkdir/stat.
+      }
+      await sleep(LOCK_RETRY_MS);
     }
-    if (command === "bid" && positionals[0] === "create") {
-        await runBidCreate(flags);
-        return;
+  }
+
+  throw new Error("Timed out waiting for WaitSpin MiMo cache lock.");
+}
+
+async function withCacheLock(cachePath, callback) {
+  const release = await acquireCacheLock(cachePath);
+  try {
+    return await callback();
+  } finally {
+    await release();
+  }
+}
+
+function cleanLine(value) {
+  return String(value || "")
+    .replace(
+      /(?:\u001B\[[0-?]*[ -/]*[@-~]|\u001B\][^\u0007]*(?:\u0007|\u001B\\)|\u001B[P^_][\s\S]*?\u001B\\|\u001B[@-Z\\-_]|\u009B[0-?]*[ -/]*[@-~])/g,
+      " ",
+    )
+    .replace(/[\r\n\u0000-\u001F\u007F-\u009F]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, 120);
+}
+
+async function waitspinFetch(url, init) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+function parseServe(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const creative = payload.creative;
+  if (!creative || typeof creative !== "object") return null;
+  const line = cleanLine(creative.line);
+  if (!line) return null;
+  if (
+    typeof payload.serve_id !== "string" ||
+    typeof payload.serve_receipt !== "string"
+  ) {
+    return null;
+  }
+  const parsedExpiresAt = Date.parse(payload.expires_at || "");
+  return {
+    serveId: payload.serve_id,
+    serveReceipt: payload.serve_receipt,
+    line,
+    shownAt: Date.now(),
+    expiresAtMs: Number.isFinite(parsedExpiresAt)
+      ? parsedExpiresAt
+      : Date.now() + MAX_ACTIVE_AGE_MS,
+    minVisibleMs:
+      typeof payload.min_visible_ms === "number" && payload.min_visible_ms >= 5000
+        ? payload.min_visible_ms
+        : 5000,
+    impressionRecorded: false,
+  };
+}
+
+function serveIsExpired(serve) {
+  return (
+    Date.now() >= (serve.expiresAtMs || 0) ||
+    Date.now() - serve.shownAt > MAX_ACTIVE_AGE_MS
+  );
+}
+
+async function fetchNextServe(state, cache) {
+  const response = await waitspinFetch(state.base_url + "/v1/serve/next", {
+    method: "POST",
+    headers: {
+      Authorization: "Bearer " + state.api_key,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ install_id: state.install_id }),
+  });
+  cache.lastFetchAt = Date.now();
+  if (response.status === 204) {
+    cache.activeServe = null;
+    return;
+  }
+  if (!response.ok) return;
+  const parsed = parseServe(await response.json());
+  if (parsed) cache.activeServe = parsed;
+}
+
+async function recordImpression(state, cache) {
+  const serve = cache.activeServe;
+  if (!serve || serve.impressionRecorded) return;
+  const visibleMs = Date.now() - serve.shownAt;
+  if (visibleMs < serve.minVisibleMs) return;
+  const response = await waitspinFetch(state.base_url + "/v1/events/impression", {
+    method: "POST",
+    headers: {
+      Authorization: "Bearer " + state.api_key,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      serve_id: serve.serveId,
+      serve_receipt: serve.serveReceipt,
+      install_id: state.install_id,
+      visible_ms: Math.max(visibleMs, serve.minVisibleMs),
+    }),
+  });
+  if (response.ok) {
+    serve.impressionRecorded = true;
+  } else if ([400, 404, 409, 410].includes(response.status)) {
+    cache.activeServe = null;
+  }
+}
+
+async function renderSponsorLine(state) {
+  const cachePath = state.cache_path || DEFAULT_CACHE_FILE;
+  return await withCacheLock(cachePath, async () => {
+    const cache = await readJson(cachePath, {});
+    if (cache.activeServe && serveIsExpired(cache.activeServe)) {
+      cache.activeServe = null;
     }
-    if (command === "bids" && positionals[0] === "list") {
-        await runBidsList(flags);
-        return;
+
+    await recordImpression(state, cache);
+
+    const shouldFetchNext = !cache.activeServe
+      ? Date.now() - (cache.lastFetchAt || 0) >= FETCH_INTERVAL_MS
+      : cache.activeServe.impressionRecorded &&
+        Date.now() - (cache.lastFetchAt || 0) >= FETCH_INTERVAL_MS;
+    if (shouldFetchNext) {
+      await fetchNextServe(state, cache);
     }
-    if (command === "bid" && positionals[0] === "checkout") {
-        await runBidCheckout(flags, positionals.slice(1));
-        return;
+
+    await writeJson(cachePath, cache);
+    return cache.activeServe?.line || "";
+  });
+}
+
+async function main() {
+  const state = await readJson(STATE_FILE, null);
+  if (!state?.api_key || !state.install_id || !state.base_url) return;
+
+  try {
+    const line = await renderSponsorLine(state);
+    if (line) process.stdout.write(line);
+  } catch {
+    // Prompt hooks must never interrupt the user's shell.
+  }
+}
+
+main().catch(() => {});
+`;
+}
+function miMoCodeBashHook() {
+    const D = "$";
+    return `${MIMOCODE_BASHRC_MARKER}
+__waitspin_statusline() {
+  local line
+  line=$("$HOME/.local/bin/waitspin-mimocode-runtime" 2>/dev/null)
+  if [ -n "$line" ]; then
+    printf "\\x1b[38;5;245m──\\x1b[0m \\x1b[38;5;220m%s\\x1b[0m \\x1b[38;5;245m──\\x1b[0m" "$line"
+  fi
+}
+
+__waitspin_prompt_command() {
+  local waitspin_previous_status=$?
+  if [ -n "${D}{__WAITSPIN_PREVIOUS_PROMPT_COMMAND:-}" ]; then
+    eval "$__WAITSPIN_PREVIOUS_PROMPT_COMMAND"
+  fi
+  __waitspin_statusline
+  return ${D}waitspin_previous_status
+}
+
+if [ -z "${D}{__WAITSPIN_PROMPT_INSTALLED:-}" ]; then
+  __WAITSPIN_PREVIOUS_PROMPT_COMMAND="${D}{PROMPT_COMMAND:-}"
+  PROMPT_COMMAND="__waitspin_prompt_command"
+  __WAITSPIN_PROMPT_INSTALLED=1
+fi
+${MIMOCODE_BASHRC_END_MARKER}`;
+}
+function readJsonObjectFileSafe(filePath) {
+    return readJsonObjectFile(filePath);
+}
+async function loadMiMoCodeInstallState() {
+    const parsed = await readJsonObjectFileSafe(miMoCodeStatePath());
+    if (!parsed?.install_id || parsed.target !== MIMOCODE_PUBLISHER_TARGET) {
+        return null;
     }
-    if (command === "market") {
-        await runMarket(flags);
-        return;
+    return parsed;
+}
+function redactedMiMoCodeState(state) {
+    if (!state)
+        return null;
+    return {
+        target: state.target,
+        install_id: state.install_id,
+        publisher_id: state.publisher_id,
+        publisher_target: state.publisher_target,
+        registered_at: state.registered_at,
+        base_url: state.base_url,
+        runtime_path: state.runtime_path,
+        cache_path: state.cache_path,
+        state_path: state.state_path,
+        bashrc_path: state.bashrc_path,
+        installed_at: state.installed_at,
+        api_key_present: Boolean(state.api_key),
+    };
+}
+async function writeMiMoCodeRuntime(runtimePath) {
+    await mkdir(path.dirname(runtimePath), { recursive: true });
+    await writeFile(runtimePath, miMoCodeStatuslineRuntimeSource(), {
+        encoding: "utf8",
+        mode: 0o755,
+    });
+    await chmod(runtimePath, 0o755);
+}
+async function writeTextFileAtomic(filePath, value) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    const tmpPath = `${filePath}.waitspin-${process.pid}.tmp`;
+    await writeFile(tmpPath, value, { encoding: "utf8" });
+    await rename(tmpPath, filePath);
+}
+async function addMiMoCodeBashHook(bashrcPath) {
+    try {
+        const content = await readFile(bashrcPath, "utf8").catch(() => "");
+        if (content.includes(MIMOCODE_BASHRC_MARKER)) {
+            return false;
+        }
+        await writeTextFileAtomic(bashrcPath, `${content}${content.endsWith("\n") || !content ? "" : "\n"}${miMoCodeBashHook()}\n`);
+        return true;
     }
-    if (command === "wallet" && positionals[0] === "status") {
+    catch {
+        return false;
+    }
+}
+async function removeMiMoCodeBashHook(bashrcPath) {
+    try {
+        const content = await readFile(bashrcPath, "utf8");
+        if (!content.includes(MIMOCODE_BASHRC_MARKER)) {
+            return false;
+        }
+        const markerIndex = content.indexOf(MIMOCODE_BASHRC_MARKER);
+        const afterMarker = content.slice(markerIndex);
+        const markerEnd = afterMarker.indexOf(MIMOCODE_BASHRC_END_MARKER);
+        const before = content.slice(0, markerIndex);
+        let after;
+        if (markerEnd >= 0) {
+            after = afterMarker.slice(markerEnd + MIMOCODE_BASHRC_END_MARKER.length);
+        }
+        else {
+            const hookEnd = afterMarker.indexOf("\n}\n");
+            if (hookEnd === -1) {
+                return false;
+            }
+            after = afterMarker.slice(hookEnd + 3);
+        }
+        await writeTextFileAtomic(bashrcPath, before + after);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function runMiMoCodeInstall(flags) {
+    const dryRun = booleanFlag(flags, "dry-run");
+    const baseUrl = resolveCredentialedBaseUrl(flags);
+    const statePath = miMoCodeStatePath();
+    const runtimePath = miMoCodeRuntimePath();
+    const cachePath = miMoCodeCachePath();
+    const bashrcPath = miMoCodeBashrcPath();
+    const existingState = await loadMiMoCodeInstallState();
+    const installId = existingState?.install_id || generateInstallId();
+    const summary = {
+        ok: true,
+        target: MIMOCODE_PUBLISHER_TARGET,
+        mode: "shell-hook",
+        install_id: installId,
+        publisher_target: MIMOCODE_PUBLISHER_TARGET,
+        state_path: statePath,
+        runtime_path: runtimePath,
+        cache_path: cachePath,
+        bashrc_path: bashrcPath,
+        note: "Installs WaitSpin through a bash hook that polls the API for sponsored messages.",
+        next: "check_status",
+        next_command: "waitspin mimocode status",
+    };
+    if (dryRun) {
+        const hookExists = await readFile(bashrcPath, "utf8")
+            .then((c) => c.includes(MIMOCODE_BASHRC_MARKER))
+            .catch(() => false);
+        printJson({
+            ...summary,
+            dry_run: true,
+            publisher_registered: false,
+            bashrc_hook_exists: hookExists,
+            would_write: [statePath, runtimePath],
+        });
+        return;
+    }
+    const apiKey = requireApiKey(flags);
+    const registration = await registerPublisherInstall({
+        baseUrl,
+        apiKey,
+        installId,
+        target: MIMOCODE_PUBLISHER_TARGET,
+    });
+    const installedAt = new Date().toISOString();
+    const installState = {
+        target: MIMOCODE_PUBLISHER_TARGET,
+        install_id: registration.install_id,
+        publisher_id: registration.publisher_id,
+        publisher_target: registration.target,
+        registered_at: installedAt,
+        base_url: baseUrl,
+        api_key: apiKey,
+        runtime_path: runtimePath,
+        cache_path: cachePath,
+        state_path: statePath,
+        bashrc_path: bashrcPath,
+        installed_at: installedAt,
+    };
+    try {
+        await writeMiMoCodeRuntime(runtimePath);
+        await writeJsonObjectFile(statePath, installState, 0o600);
+        await addMiMoCodeBashHook(bashrcPath);
+    }
+    catch (error) {
+        if (existingState) {
+            await writeJsonObjectFile(statePath, existingState, 0o600).catch(() => { });
+        }
+        else {
+            await Promise.resolve(rm(statePath, { force: true, recursive: true })).catch(() => { });
+            await Promise.resolve(rm(runtimePath, { force: true, recursive: true })).catch(() => { });
+        }
+        throw error;
+    }
+    printJson({
+        ...summary,
+        ...redactedMiMoCodeState(installState),
+        publisher_registered: true,
+        next: "test_runtime",
+        next_command: "waitspin-mimocode-runtime",
+        acceptance_hint: "Run 'source ~/.bashrc' or restart your shell, then keep the sponsored line visible for at least 5 seconds.",
+    });
+}
+export async function runMiMoCodeStatus() {
+    const state = await loadMiMoCodeInstallState();
+    const runtimePath = state?.runtime_path ?? miMoCodeRuntimePath();
+    const cachePath = state?.cache_path ?? miMoCodeCachePath();
+    const bashrcPath = state?.bashrc_path ?? miMoCodeBashrcPath();
+    const runtimeInstalled = await pathExists(runtimePath);
+    const hookExists = await readFile(bashrcPath, "utf8")
+        .then((c) => c.includes(MIMOCODE_BASHRC_MARKER))
+        .catch(() => false);
+    const installed = Boolean(state && runtimeInstalled);
+    printJson({
+        ok: true,
+        target: MIMOCODE_PUBLISHER_TARGET,
+        mode: "shell-hook",
+        installed,
+        publisher_registered: Boolean(state?.publisher_id),
+        install_id: state?.install_id ?? null,
+        publisher_id: state?.publisher_id ?? null,
+        publisher_target: state?.publisher_target ?? MIMOCODE_PUBLISHER_TARGET,
+        state_path: miMoCodeStatePath(),
+        runtime_path: runtimePath,
+        cache_path: cachePath,
+        bashrc_path: bashrcPath,
+        runtime_installed: runtimeInstalled,
+        bashrc_hook: hookExists,
+        installed_at: state?.installed_at ?? null,
+        ...(installed
+            ? {
+                next: "test_runtime",
+                next_command: "waitspin-mimocode-runtime",
+                acceptance_hint: "Run 'source ~/.bashrc' or restart your shell, then keep the sponsored line visible for at least 5 seconds.",
+            }
+            : {
+                next: "install_mimocode",
+                next_command: "waitspin mimocode install",
+            }),
+    });
+}
+export async function runMiMoCodeUninstall(flags) {
+    const dryRun = booleanFlag(flags, "dry-run");
+    const state = await loadMiMoCodeInstallState();
+    const bashrcPath = state?.bashrc_path ?? miMoCodeBashrcPath();
+    const runtimePath = state?.runtime_path ?? miMoCodeRuntimePath();
+    const cachePath = state?.cache_path ?? miMoCodeCachePath();
+    const declaredRemovePaths = [
+        runtimePath,
+        miMoCodeStatePath(),
+        cachePath,
+    ];
+    if (dryRun) {
+        printJson({
+            ok: true,
+            target: MIMOCODE_PUBLISHER_TARGET,
+            dry_run: true,
+            installed: Boolean(state),
+            would_remove: declaredRemovePaths,
+            bashrc_hook: await readFile(bashrcPath, "utf8")
+                .then((c) => c.includes(MIMOCODE_BASHRC_MARKER))
+                .catch(() => false),
+        });
+        return;
+    }
+    const removePaths = [miMoCodeStatePath()];
+    const skippedUnsafePaths = [];
+    if (state) {
+        try {
+            removePaths.unshift(assertSafeMiMoCodeRuntimePath(state.runtime_path));
+        }
+        catch {
+            skippedUnsafePaths.push(state.runtime_path);
+        }
+        try {
+            removePaths.push(assertSafeMiMoCodeCachePath(cachePath));
+        }
+        catch {
+            skippedUnsafePaths.push(cachePath);
+        }
+    }
+    else {
+        removePaths.push(assertSafeMiMoCodeCachePath(cachePath));
+    }
+    await removeMiMoCodeBashHook(bashrcPath);
+    await Promise.all(removePaths.map((filePath) => rm(filePath, { force: true, recursive: true })));
+    printJson({
+        ok: true,
+        target: MIMOCODE_PUBLISHER_TARGET,
+        uninstalled: true,
+        removed: removePaths,
+        bashrc_hook_removed: true,
+        ...(skippedUnsafePaths.length > 0
+            ? { skipped_unsafe_paths: skippedUnsafePaths }
+            : {}),
+    });
+}
+function assertSafeMiMoCodeRuntimePath(filePath) {
+    const expected = path.resolve(miMoCodeRuntimePath());
+    const resolved = path.resolve(filePath);
+    if (resolved !== expected) {
+        throw new Error("Refusing to manage a MiMo Code runtime path that is not the WaitSpin-managed executable.");
+    }
+    return expected;
+}
+function assertSafeMiMoCodeCachePath(filePath) {
+    const expected = path.resolve(miMoCodeCachePath());
+    const resolved = path.resolve(filePath);
+    if (resolved !== expected) {
+        throw new Error("Refusing to manage a MiMo Code cache path that is not the WaitSpin-managed cache.");
+    }
+    return expected;
+}
+const OPENCODE_TUI_PLUGIN_ENTRY = "./plugins/waitspin-opencode.plugin.tsx";
+function opencodeInstallDir() {
+    return path.join(os.homedir(), ".waitspin");
+}
+function opencodeConfigDir() {
+    return path.join(os.homedir(), ".config", "opencode");
+}
+function opencodeStatePath() {
+    return path.join(opencodeInstallDir(), "opencode-install.json");
+}
+function opencodeRuntimePath() {
+    return path.join(opencodeInstallDir(), "opencode-statusline.mjs");
+}
+function opencodeCachePath() {
+    return path.join(opencodeInstallDir(), "opencode-statusline-cache.json");
+}
+function opencodePluginInstallDir() {
+    return path.join(opencodeConfigDir(), "plugins");
+}
+function opencodePluginDestPath() {
+    return path.join(opencodePluginInstallDir(), "waitspin-opencode.plugin.tsx");
+}
+function opencodeTuiConfigPath() {
+    return path.join(opencodeConfigDir(), "tui.json");
+}
+function opencodePluginAssetName() {
+    return "waitspin-opencode.plugin.tsx";
+}
+async function resolveOpencodeAssetsDir(flags) {
+    const packageRoot = resolveCliPackageRoot();
+    const candidates = [
+        path.join(packageRoot, "assets", "waitspin-opencode"),
+    ];
+    if (allowDevExtensionAssets(flags)) {
+        candidates.push(path.join(packageRoot, "..", "..", "extensions", "waitspin-opencode"));
+    }
+    for (const candidate of candidates) {
+        const resolved = path.resolve(candidate);
+        try {
+            await access(path.join(resolved, "opencode-statusline.mjs"), fsConstants.F_OK);
+            await access(path.join(resolved, opencodePluginAssetName()), fsConstants.F_OK);
+            return resolved;
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error(`WaitSpin OpenCode assets not found. Use a build that ships assets/waitspin-opencode or set ${DEV_EXTENSION_ASSETS_OPT_IN_ENV}=1 / --allow-dev-extension-assets from a trusted checkout.`);
+}
+function assertSafeOpencodeManagedPath(filePath) {
+    const expected = path.resolve(opencodeCachePath());
+    const resolved = path.resolve(filePath);
+    if (resolved !== expected) {
+        throw new Error("Refusing to manage an OpenCode WaitSpin cache path that is not the managed cache.");
+    }
+    return expected;
+}
+function assertSafeOpencodePluginPath(filePath) {
+    const expected = path.resolve(opencodePluginDestPath());
+    const resolved = path.resolve(filePath);
+    if (resolved !== expected) {
+        throw new Error("Refusing to manage an OpenCode plugin path that is not the WaitSpin-managed plugin.");
+    }
+    return expected;
+}
+function assertSafeOpencodeTuiConfigPath(filePath) {
+    const expected = path.resolve(opencodeTuiConfigPath());
+    const resolved = path.resolve(filePath);
+    if (resolved !== expected) {
+        throw new Error("Refusing to manage an OpenCode TUI config path that is not the WaitSpin-managed config.");
+    }
+    return expected;
+}
+function assertSafeOpencodeManagedRuntimePath(filePath) {
+    const expected = path.resolve(opencodeRuntimePath());
+    const resolved = path.resolve(filePath);
+    if (resolved !== expected) {
+        throw new Error("Refusing to manage an OpenCode runtime path that is not the WaitSpin-managed runtime.");
+    }
+    return expected;
+}
+function opencodeTuiPluginEntrySpec(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value) && typeof value[0] === "string")
+        return value[0];
+    return null;
+}
+function isWaitSpinOpencodeTuiPluginEntry(value, tuiConfigPath = opencodeTuiConfigPath()) {
+    const spec = opencodeTuiPluginEntrySpec(value);
+    if (!spec)
+        return false;
+    if (spec === OPENCODE_TUI_PLUGIN_ENTRY)
+        return true;
+    if (path.isAbsolute(spec)) {
+        return path.resolve(spec) === path.resolve(opencodePluginDestPath());
+    }
+    if (spec.startsWith(".")) {
+        return (path.resolve(path.dirname(tuiConfigPath), spec) ===
+            path.resolve(opencodePluginDestPath()));
+    }
+    return false;
+}
+function opencodeConfigWithTuiPluginEntry(input) {
+    const plugin = input.config.plugin;
+    if (plugin !== undefined && !Array.isArray(plugin)) {
+        throw new Error("OpenCode tui.json plugin field must be an array before WaitSpin can manage it.");
+    }
+    const entries = Array.isArray(plugin) ? plugin : [];
+    if (entries.some((entry) => isWaitSpinOpencodeTuiPluginEntry(entry, input.tuiConfigPath))) {
+        return input.config;
+    }
+    return {
+        ...input.config,
+        plugin: [...entries, OPENCODE_TUI_PLUGIN_ENTRY],
+    };
+}
+async function planOpencodeTuiConfigInstall(tuiConfigPath) {
+    const previousConfig = await readJsonObjectFile(tuiConfigPath);
+    const config = previousConfig ?? {};
+    const nextConfig = opencodeConfigWithTuiPluginEntry({
+        config,
+        tuiConfigPath,
+    });
+    return {
+        configPath: tuiConfigPath,
+        previousConfig,
+        nextConfig,
+        changed: JSON.stringify(config) !== JSON.stringify(nextConfig),
+    };
+}
+async function writeOpencodeTuiConfigPlan(plan) {
+    if (!plan.changed)
+        return;
+    await writeJsonObjectFile(plan.configPath, plan.nextConfig);
+}
+async function restoreOpencodeTuiConfigPlan(plan) {
+    if (!plan.changed)
+        return;
+    if (plan.previousConfig) {
+        await writeJsonObjectFile(plan.configPath, plan.previousConfig).catch(() => { });
+        return;
+    }
+    await Promise.resolve(rm(plan.configPath, { force: true })).catch(() => { });
+}
+async function opencodeTuiPluginConfigured(tuiConfigPath) {
+    const config = (await readJsonObjectFile(tuiConfigPath)) ?? {};
+    const plugin = config.plugin;
+    return (Array.isArray(plugin) &&
+        plugin.some((entry) => isWaitSpinOpencodeTuiPluginEntry(entry, tuiConfigPath)));
+}
+async function removeOpencodeTuiPluginEntry(tuiConfigPath) {
+    try {
+        const config = (await readJsonObjectFile(tuiConfigPath)) ?? {};
+        const plugin = config.plugin;
+        if (plugin === undefined) {
+            return { updated: false, configured_before: false, error: null };
+        }
+        if (!Array.isArray(plugin)) {
+            return {
+                updated: false,
+                configured_before: false,
+                error: "invalid_plugin_field",
+            };
+        }
+        const filtered = plugin.filter((entry) => !isWaitSpinOpencodeTuiPluginEntry(entry, tuiConfigPath));
+        if (filtered.length === plugin.length) {
+            return { updated: false, configured_before: false, error: null };
+        }
+        const nextConfig = { ...config };
+        if (filtered.length > 0) {
+            nextConfig.plugin = filtered;
+        }
+        else {
+            delete nextConfig.plugin;
+        }
+        await writeJsonObjectFile(tuiConfigPath, nextConfig);
+        return { updated: true, configured_before: true, error: null };
+    }
+    catch (error) {
+        if (isErrno(error, "ENOENT")) {
+            return { updated: false, configured_before: false, error: null };
+        }
+        return { updated: false, configured_before: false, error: "read_failed" };
+    }
+}
+async function loadOpencodeInstallState() {
+    const parsed = await readJsonObjectFile(opencodeStatePath());
+    if (!parsed?.install_id || parsed.target !== OPENCODE_PUBLISHER_TARGET) {
+        return null;
+    }
+    return parsed;
+}
+function redactedOpencodeState(state) {
+    if (!state)
+        return null;
+    return {
+        target: state.target,
+        install_id: state.install_id,
+        publisher_id: state.publisher_id,
+        publisher_target: state.publisher_target,
+        registered_at: state.registered_at,
+        base_url: state.base_url,
+        runtime_path: state.runtime_path,
+        cache_path: state.cache_path,
+        plugin_path: state.plugin_path,
+        tui_config_path: state.tui_config_path,
+        tui_plugin_entry: state.tui_plugin_entry,
+        installed_at: state.installed_at,
+        api_key_present: Boolean(state.api_key),
+    };
+}
+async function writeOpencodeRuntimeAndPlugin(input) {
+    await mkdir(path.dirname(input.runtimePath), { recursive: true });
+    await mkdir(path.dirname(input.pluginDest), { recursive: true });
+    await cp(path.join(input.sourceDir, "opencode-statusline.mjs"), input.runtimePath, { force: true });
+    const pluginTemplate = await readFile(path.join(input.sourceDir, opencodePluginAssetName()), "utf8");
+    const pluginSource = pluginTemplate
+        .replaceAll('"__WAITSPIN_STATE_PATH__"', JSON.stringify(input.statePath));
+    await writeFile(input.pluginDest, pluginSource, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    await chmod(input.runtimePath, 0o755);
+    await chmod(input.pluginDest, 0o600);
+}
+export async function runOpencodeInstall(flags) {
+    const dryRun = booleanFlag(flags, "dry-run");
+    const baseUrl = resolveCredentialedBaseUrl(flags);
+    const statePath = opencodeStatePath();
+    const runtimePath = opencodeRuntimePath();
+    const cachePath = opencodeCachePath();
+    const pluginDest = opencodePluginDestPath();
+    const tuiConfigPath = opencodeTuiConfigPath();
+    const existingState = await loadOpencodeInstallState();
+    const installId = existingState?.install_id || generateInstallId();
+    const summary = {
+        ok: true,
+        target: OPENCODE_PUBLISHER_TARGET,
+        mode: "tui-plugin-slot",
+        install_id: installId,
+        publisher_target: OPENCODE_PUBLISHER_TARGET,
+        state_path: statePath,
+        runtime_path: runtimePath,
+        cache_path: cachePath,
+        plugin_path: pluginDest,
+        tui_config_path: tuiConfigPath,
+        tui_plugin_entry: OPENCODE_TUI_PLUGIN_ENTRY,
+        note: "Installs WaitSpin through the OpenCode TUI plugin slot (app_bottom).",
+        next: "check_status",
+        next_command: "waitspin opencode status",
+    };
+    if (dryRun) {
+        printJson({
+            ...summary,
+            dry_run: true,
+            publisher_registered: false,
+        });
+        return;
+    }
+    const assetsDir = await resolveOpencodeAssetsDir(flags);
+    const apiKey = requireApiKey(flags);
+    const tuiConfigPlan = await planOpencodeTuiConfigInstall(tuiConfigPath);
+    const registration = await registerPublisherInstall({
+        baseUrl,
+        apiKey,
+        installId,
+        target: OPENCODE_PUBLISHER_TARGET,
+    });
+    const installedAt = new Date().toISOString();
+    const installState = {
+        target: OPENCODE_PUBLISHER_TARGET,
+        install_id: registration.install_id,
+        publisher_id: registration.publisher_id,
+        publisher_target: registration.target,
+        registered_at: installedAt,
+        base_url: baseUrl,
+        api_key: apiKey,
+        runtime_path: runtimePath,
+        cache_path: cachePath,
+        plugin_path: pluginDest,
+        tui_config_path: tuiConfigPath,
+        tui_plugin_entry: OPENCODE_TUI_PLUGIN_ENTRY,
+        installed_at: installedAt,
+    };
+    try {
+        await writeOpencodeRuntimeAndPlugin({
+            sourceDir: assetsDir,
+            runtimePath,
+            pluginDest,
+            statePath,
+        });
+        await writeOpencodeTuiConfigPlan(tuiConfigPlan);
+        await writeJsonObjectFile(statePath, installState, 0o600);
+    }
+    catch (error) {
+        await restoreOpencodeTuiConfigPlan(tuiConfigPlan);
+        if (existingState) {
+            await writeJsonObjectFile(statePath, existingState, 0o600).catch(() => { });
+        }
+        else {
+            await Promise.resolve(rm(statePath, { force: true, recursive: true })).catch(() => { });
+            await Promise.resolve(rm(runtimePath, { force: true, recursive: true })).catch(() => { });
+            await Promise.resolve(rm(pluginDest, { force: true, recursive: true })).catch(() => { });
+        }
+        throw error;
+    }
+    printJson({
+        ...summary,
+        ...redactedOpencodeState(installState),
+        publisher_registered: true,
+        next: "restart_opencode",
+        next_command: "opencode",
+        acceptance_hint: "Restart OpenCode to load the TUI plugin. The sponsored line appears in the app_bottom slot.",
+    });
+}
+export async function runOpencodeStatus() {
+    const state = await loadOpencodeInstallState();
+    const runtimePath = state?.runtime_path ?? opencodeRuntimePath();
+    const cachePath = state?.cache_path ?? opencodeCachePath();
+    const pluginDest = state?.plugin_path ?? opencodePluginDestPath();
+    const tuiConfigPath = state?.tui_config_path ?? opencodeTuiConfigPath();
+    let runtimeInstalled = false;
+    let pluginInstalled = false;
+    let tuiPluginConfigured = false;
+    let tuiConfigError = null;
+    if (state) {
+        runtimeInstalled = await pathExists(assertSafeOpencodeManagedRuntimePath(state.runtime_path));
+        pluginInstalled = await pathExists(assertSafeOpencodePluginPath(state.plugin_path));
+        try {
+            tuiPluginConfigured = await opencodeTuiPluginConfigured(assertSafeOpencodeTuiConfigPath(tuiConfigPath));
+        }
+        catch {
+            tuiConfigError = "invalid_tui_config";
+        }
+    }
+    else {
+        const safeRuntime = assertSafeOpencodeManagedRuntimePath(runtimePath);
+        runtimeInstalled = await pathExists(safeRuntime);
+        const safePlugin = assertSafeOpencodePluginPath(pluginDest);
+        pluginInstalled = await pathExists(safePlugin);
+        try {
+            tuiPluginConfigured = await opencodeTuiPluginConfigured(assertSafeOpencodeTuiConfigPath(tuiConfigPath));
+        }
+        catch {
+            tuiPluginConfigured = false;
+        }
+    }
+    const installed = Boolean(state && runtimeInstalled && pluginInstalled && tuiPluginConfigured);
+    printJson({
+        ok: true,
+        target: OPENCODE_PUBLISHER_TARGET,
+        mode: "tui-plugin-slot",
+        installed,
+        publisher_registered: Boolean(state?.publisher_id),
+        install_id: state?.install_id ?? null,
+        publisher_id: state?.publisher_id ?? null,
+        publisher_target: state?.publisher_target ?? OPENCODE_PUBLISHER_TARGET,
+        state_path: opencodeStatePath(),
+        runtime_path: runtimePath,
+        cache_path: cachePath,
+        plugin_path: pluginDest,
+        tui_config_path: tuiConfigPath,
+        tui_plugin_entry: state?.tui_plugin_entry ?? OPENCODE_TUI_PLUGIN_ENTRY,
+        runtime_installed: runtimeInstalled,
+        plugin_installed: pluginInstalled,
+        tui_plugin_configured: tuiPluginConfigured,
+        tui_config_error: tuiConfigError,
+        installed_at: state?.installed_at ?? null,
+        ...(installed
+            ? {
+                next: "restart_opencode",
+                next_command: "opencode",
+                acceptance_hint: "Restart OpenCode to load the TUI plugin. The sponsored line appears in the app_bottom slot.",
+            }
+            : {
+                next: "install_opencode",
+                next_command: "waitspin opencode install",
+            }),
+    });
+}
+export async function runOpencodeUninstall(flags) {
+    const dryRun = booleanFlag(flags, "dry-run");
+    const state = await loadOpencodeInstallState();
+    const tuiConfigPath = state?.tui_config_path ?? opencodeTuiConfigPath();
+    const declaredRemovePaths = state
+        ? [
+            state.runtime_path,
+            state.cache_path,
+            opencodeStatePath(),
+            state.plugin_path,
+        ]
+        : [opencodeStatePath()];
+    if (dryRun) {
+        printJson({
+            ok: true,
+            target: OPENCODE_PUBLISHER_TARGET,
+            dry_run: true,
+            installed: Boolean(state),
+            would_remove: declaredRemovePaths,
+            would_update: [tuiConfigPath],
+        });
+        return;
+    }
+    const removePaths = [];
+    const skippedUnsafePaths = [];
+    let tuiConfigUpdate = null;
+    if (state) {
+        try {
+            removePaths.push(assertSafeOpencodeManagedRuntimePath(state.runtime_path));
+        }
+        catch {
+            skippedUnsafePaths.push(state.runtime_path);
+        }
+        try {
+            removePaths.push(assertSafeOpencodeManagedPath(state.cache_path));
+        }
+        catch {
+            skippedUnsafePaths.push(state.cache_path);
+        }
+        try {
+            removePaths.push(assertSafeOpencodePluginPath(state.plugin_path));
+        }
+        catch {
+            skippedUnsafePaths.push(state.plugin_path);
+        }
+        try {
+            tuiConfigUpdate = await removeOpencodeTuiPluginEntry(assertSafeOpencodeTuiConfigPath(tuiConfigPath));
+        }
+        catch {
+            skippedUnsafePaths.push(tuiConfigPath);
+        }
+    }
+    removePaths.splice(state ? Math.min(removePaths.length, 2) : 0, 0, opencodeStatePath());
+    await Promise.all(removePaths.map((filePath) => rm(filePath, { force: true, recursive: true })));
+    printJson({
+        ok: true,
+        target: OPENCODE_PUBLISHER_TARGET,
+        uninstalled: true,
+        removed: removePaths,
+        tui_config_updated: tuiConfigUpdate?.updated ?? false,
+        tui_plugin_configured_before: tuiConfigUpdate?.configured_before ?? false,
+        tui_config_error: tuiConfigUpdate?.error ?? null,
+        ...(skippedUnsafePaths.length > 0
+            ? { skipped_unsafe_paths: skippedUnsafePaths }
+            : {}),
+    });
+}
+function cloneFlags(flags) {
+    return new Map(Array.from(flags.entries()).map(([key, values]) => [key, [...values]]));
+}
+function extensionAllFlags(flags) {
+    const next = cloneFlags(flags);
+    next.set("target", ["vscode"]);
+    return next;
+}
+function executableFromEnv(envName, defaultBin) {
+    return process.env[envName]?.trim() || defaultBin;
+}
+async function executableVersion(envName, defaultBin, label) {
+    const binary = executableFromEnv(envName, defaultBin);
+    try {
+        const result = await execFileText(binary, ["--version"], {
+            encoding: "utf8",
+            timeout: 5_000,
+        });
+        return `${result.stdout || result.stderr || label}`.trim();
+    }
+    catch (error) {
+        throw new Error(`${label} was not detected. Install ${label} or set ${envName} to its executable path.`, { cause: error });
+    }
+}
+async function preflightVscode(flags) {
+    return resolveExtensionDir(flags);
+}
+async function preflightClaudeCode() {
+    return assertSupportedClaudeCodeVersion();
+}
+async function preflightMiMoCode() {
+    return executableVersion(MIMOCODE_BIN_ENV, MIMOCODE_DEFAULT_BIN, "MiMo Code");
+}
+async function preflightOpenCode() {
+    return executableVersion(OPENCODE_BIN_ENV, OPENCODE_DEFAULT_BIN, "OpenCode");
+}
+function allInstallTargets() {
+    return [
+        {
+            target: "vscode",
+            command: "waitspin extension install --target vscode",
+            statusCommand: "waitspin extension status --target vscode",
+            preflight: preflightVscode,
+            install: (flags) => runExtensionInstall(extensionAllFlags(flags)),
+            status: (flags) => runExtensionStatus(extensionAllFlags(flags)),
+        },
+        {
+            target: CLAUDE_CODE_PUBLISHER_TARGET,
+            command: "waitspin claude-code install --compose-existing",
+            statusCommand: "waitspin claude-code status",
+            preflight: preflightClaudeCode,
+            install: runClaudeCodeInstall,
+            status: () => runClaudeCodeStatus(),
+        },
+        {
+            target: MIMOCODE_PUBLISHER_TARGET,
+            command: "waitspin mimocode install",
+            statusCommand: "waitspin mimocode status",
+            preflight: preflightMiMoCode,
+            install: runMiMoCodeInstall,
+            status: () => runMiMoCodeStatus(),
+        },
+        {
+            target: OPENCODE_PUBLISHER_TARGET,
+            command: "waitspin opencode install",
+            statusCommand: "waitspin opencode status",
+            preflight: preflightOpenCode,
+            install: runOpencodeInstall,
+            status: () => runOpencodeStatus(),
+        },
+    ];
+}
+function safeErrorMessage(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message
+        .replace(/wts_(?:live|test)__[A-Za-z0-9_-]+/g, "[REDACTED_WAITSPIN_KEY]")
+        .replace(/npm_[A-Za-z0-9_-]+/g, "[REDACTED_NPM_TOKEN]");
+}
+function isNotDetectedError(message) {
+    return /not detected|not found|Unable to run Claude Code|Unsupported Claude Code version|ENOENT|spawn .*ENOENT|package not found/i.test(message);
+}
+function isConflictError(message) {
+    return /statusLine|status line|conflict|override|already has|blocked/i.test(message);
+}
+function objectRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function dryRunConflictReason(result) {
+    const record = objectRecord(result);
+    if (!record.would_fail)
+        return null;
+    const reason = record.settings_blocked_reason ?? record.human_message;
+    return typeof reason === "string" ? reason : "target reported a conflict";
+}
+export async function runInstallAll(flags) {
+    const dryRun = booleanFlag(flags, "dry-run");
+    const installed = [];
+    const wouldInstall = [];
+    const skippedNotDetected = [];
+    const skippedConflict = [];
+    const failedRollback = [];
+    for (const target of allInstallTargets()) {
+        let detail = null;
+        try {
+            detail = await target.preflight(flags);
+        }
+        catch (error) {
+            const reason = safeErrorMessage(error);
+            skippedNotDetected.push({
+                target: target.target,
+                command: target.command,
+                reason,
+            });
+            continue;
+        }
+        try {
+            const result = await capturePrintedJson(() => target.install(flags));
+            const conflictReason = dryRunConflictReason(result);
+            if (conflictReason) {
+                skippedConflict.push({
+                    target: target.target,
+                    command: target.command,
+                    reason: conflictReason,
+                    detail,
+                    result,
+                });
+                continue;
+            }
+            const summary = {
+                target: target.target,
+                command: target.command,
+                detail,
+                result,
+            };
+            if (dryRun) {
+                wouldInstall.push(summary);
+            }
+            else {
+                installed.push(summary);
+            }
+        }
+        catch (error) {
+            const reason = safeErrorMessage(error);
+            const bucket = isConflictError(reason)
+                ? skippedConflict
+                : isNotDetectedError(reason)
+                    ? skippedNotDetected
+                    : failedRollback;
+            bucket.push({
+                target: target.target,
+                command: target.command,
+                reason,
+                detail,
+            });
+        }
+    }
+    printJson({
+        ok: failedRollback.length === 0,
+        command: "install --all",
+        dry_run: dryRun,
+        mode: "detected-targets",
+        installed,
+        would_install: wouldInstall,
+        skipped_not_detected: skippedNotDetected,
+        skipped_conflict: skippedConflict,
+        failed_rollback: failedRollback,
+        next: "check_all_status",
+        next_command: "waitspin status --all",
+        human_message: "Install-all is an advanced agent command. Explicit target commands remain the canonical debug path.",
+    });
+}
+export async function runStatusAll(flags) {
+    const statuses = [];
+    const installed = [];
+    const failedStatus = [];
+    for (const target of allInstallTargets()) {
+        try {
+            const result = await capturePrintedJson(() => target.status(flags));
+            const summary = {
+                target: target.target,
+                command: target.statusCommand,
+                result,
+            };
+            statuses.push(summary);
+            if (objectRecord(result).installed === true) {
+                installed.push(summary);
+            }
+        }
+        catch (error) {
+            failedStatus.push({
+                target: target.target,
+                command: target.statusCommand,
+                reason: safeErrorMessage(error),
+            });
+        }
+    }
+    printJson({
+        ok: failedStatus.length === 0,
+        command: "status --all",
+        installed,
+        statuses,
+        failed_status: failedStatus,
+    });
+}
+export async function main(argv = process.argv.slice(2)) {
+    const { command, flags, positionals } = parseArgs(argv);
+    if (command === "init") {
+        await runInit(flags);
+        return;
+    }
+    if (command === "bid" && positionals[0] === "create") {
+        await runBidCreate(flags);
+        return;
+    }
+    if (command === "bids" && positionals[0] === "list") {
+        await runBidsList(flags);
+        return;
+    }
+    if (command === "bid" && positionals[0] === "checkout") {
+        await runBidCheckout(flags, positionals.slice(1));
+        return;
+    }
+    if (command === "market") {
+        await runMarket(flags);
+        return;
+    }
+    if (command === "wallet" && positionals[0] === "status") {
         await runWalletStatus(flags);
         return;
     }
@@ -1703,6 +2942,14 @@ export async function main(argv = process.argv.slice(2)) {
         await runExtensionUninstall(flags);
         return;
     }
+    if (command === "install" && booleanFlag(flags, "all")) {
+        await runInstallAll(flags);
+        return;
+    }
+    if (command === "status" && booleanFlag(flags, "all")) {
+        await runStatusAll(flags);
+        return;
+    }
     if (command === "claude-code" && positionals[0] === "install") {
         await runClaudeCodeInstall(flags);
         return;
@@ -1715,6 +2962,30 @@ export async function main(argv = process.argv.slice(2)) {
         await runClaudeCodeUninstall(flags);
         return;
     }
+    if (command === "mimocode" && positionals[0] === "install") {
+        await runMiMoCodeInstall(flags);
+        return;
+    }
+    if (command === "mimocode" && positionals[0] === "status") {
+        await runMiMoCodeStatus();
+        return;
+    }
+    if (command === "mimocode" && positionals[0] === "uninstall") {
+        await runMiMoCodeUninstall(flags);
+        return;
+    }
+    if (command === "opencode" && positionals[0] === "install") {
+        await runOpencodeInstall(flags);
+        return;
+    }
+    if (command === "opencode" && positionals[0] === "status") {
+        await runOpencodeStatus();
+        return;
+    }
+    if (command === "opencode" && positionals[0] === "uninstall") {
+        await runOpencodeUninstall(flags);
+        return;
+    }
     usage();
 }
 function isDirectEntrypoint() {