@tiny-fish/cli 0.15.1-next.160 → 0.16.0

package/dist/commands/doctor.d.ts

@@ -1,9 +1,17 @@
 import type { Command } from "commander";
-import { type DoctorReport } from "../lib/doctor-report.js";
-import { type FiveHarness } from "../lib/harness-detect.js";
+import { type DoctorRepair, type DoctorReport } from "../lib/doctor-report.js";
+import { type Harness } from "../lib/harness-detect.js";
 export interface DoctorOptions {
     mcpUrl: string;
-    harness?: FiveHarness;
+    harness?: Harness;
+    fix?: boolean;
+    yes?: boolean;
 }
 export declare function runDoctor(options: DoctorOptions): Promise<DoctorReport>;
+export interface RepairOutcome {
+    repair: DoctorRepair;
+    status: "repaired" | "skipped" | "failed";
+    reason?: string;
+}
+export declare function applyRepairs(repairs: DoctorRepair[], options: DoctorOptions): Promise<RepairOutcome[]>;
 export declare function registerDoctor(program: Command): void;

package/dist/commands/doctor.js

@@ -1,11 +1,13 @@
+import spawn from "cross-spawn";
 import { apiKeyStatus } from "../lib/auth.js";
 import { CLI_VERSION } from "../lib/constants.js";
 import { DOCTOR_COULD_NOT_RUN, DOCTOR_SCHEMA_VERSION, doctorReportSchema, exitCodeFor, renderPretty, } from "../lib/doctor-report.js";
-import { FIVE_HARNESSES } from "../lib/harness-detect.js";
+import { ALL_HARNESSES } from "../lib/harness-detect.js";
+import { detectHumanInitiated } from "../lib/harness.js";
 import { err, errLine, out, outLine } from "../lib/output.js";
 import { detectRegistrations } from "../lib/registration-detect.js";
 import { verifyMcpAuth, verifyMcpHealth } from "../lib/verify.js";
-import { DEFAULT_MCP_URL } from "./connect.js";
+import { connectClaudeCode, connectCodex, connectCursor, connectHermes, connectOpenClaw, connectOpencode, DEFAULT_MCP_URL, } from "./connect.js";
 // A green auth mode with a red auth call proves nothing, so the call's verdict gates the claim.
 function provesHarnessReach(status, authCallPassed, healthOk, mcpUrl) {
     // An endpoint doctor could not reach proves nothing about a harness pointed at it.
@@ -68,7 +70,9 @@ function registrationVerdict(status, mcpUrl) {
                 detail: `registered, but points at ${elsewhere} rather than ${endpointOf(mcpUrl)}`,
             };
         }
-        return { status: "pass", detail: `registered, auth mode ${status.authMode}` };
+        // A probe that had to explain itself to reach `yes` is the only thing that explains `unknown`.
+        const because = status.reason ? ` (${status.reason})` : "";
+        return { status: "pass", detail: `registered, auth mode ${status.authMode}${because}` };
     }
     // Connected once and now absent is a broken install; never connected is just not set up.
     return status.connectedBefore
@@ -117,6 +121,7 @@ async function checkAuthCall(key) {
 const UNATTENDED_SAFE = new Set(["cursor"]);
 function repairsFor(checks, statuses) {
     const repairs = [];
+    const credentialResolves = checks.some((c) => c.id === "cli-credential" && c.status === "pass");
     for (const status of statuses) {
         // `unknown` earns nothing: running connect off a failed probe contradicts the check's detail.
         // A registered-but-misaimed entry does earn one, since connect rewrites the URL.
@@ -132,7 +137,8 @@ function repairsFor(checks, statuses) {
             action: "connect",
             harness: status.harness,
             command: `tinyfish connect ${status.harness}`,
-            unattended_safe: UNATTENDED_SAFE.has(status.harness),
+            // Without a credential even Cursor's repair shells an interactive `auth login`.
+            unattended_safe: UNATTENDED_SAFE.has(status.harness) && credentialResolves,
         });
     }
     // A revoked-but-well-formed key passes the credential check and fails the call; both need login.
@@ -178,25 +184,108 @@ export async function runDoctor(options) {
     // Nothing to scrub: every string above is authored here or enumerated at its source.
     return doctorReportSchema.parse(body);
 }
+// Shell out rather than import the login flow: `auth login` owns its own browser and prompts.
+// Re-invoke this same entry script, never a global `tinyfish` — under `npx` there is no such
+// binary on PATH, and npx is the install-nothing path doctor exists to serve.
+function runAuthLogin() {
+    const entry = process.argv[1];
+    if (!entry)
+        throw new Error("Could not locate the TinyFish CLI entry point to re-invoke");
+    const result = spawn.sync(process.execPath, [entry, "auth", "login", "--source", "doctor"], {
+        stdio: "inherit",
+    });
+    if (result.error)
+        throw new Error("Could not run `tinyfish auth login`", { cause: result.error });
+    if (result.status !== 0) {
+        throw new Error(`\`tinyfish auth login\` exited ${result.status ?? "unknown"}`);
+    }
+}
+const CONNECTORS = {
+    "claude-code": (opts) => connectClaudeCode({ ...opts, launch: false }),
+    codex: (opts) => connectCodex({ ...opts, launch: false }),
+    cursor: (opts) => connectCursor(opts),
+    hermes: (opts) => connectHermes({ ...opts, launch: false }),
+    openclaw: (opts) => connectOpenClaw({ ...opts, launch: false }),
+    opencode: (opts) => connectOpencode({ ...opts, launch: false }),
+};
+/** Dispatches on `action`, never on a null harness: that conflation made the credential fix a no-op. */
+async function runRepair(repair, mcpUrl) {
+    if (repair.action === "auth-login")
+        return runAuthLogin();
+    if (repair.harness)
+        await CONNECTORS[repair.harness]({ mcpUrl });
+}
+export async function applyRepairs(repairs, options) {
+    const interactive = detectHumanInitiated();
+    const outcomes = [];
+    for (const repair of repairs) {
+        if (!interactive && !options.yes) {
+            outcomes.push({
+                repair,
+                status: "skipped",
+                reason: "no terminal; re-run with --yes to repair unattended",
+            });
+            continue;
+        }
+        if (!interactive && !repair.unattended_safe) {
+            outcomes.push({
+                repair,
+                status: "skipped",
+                reason: "needs a browser sign-in, which has no unattended path",
+            });
+            continue;
+        }
+        try {
+            await runRepair(repair, options.mcpUrl);
+            outcomes.push({ repair, status: "repaired" });
+        }
+        catch (e) {
+            // Connect quotes absolute config paths in its errors, so the raw text stays behind
+            // --debug and the user is told where to find it rather than handed a generic dead end.
+            if (process.env["TINYFISH_DEBUG"]) {
+                errLine(e instanceof Error ? (e.stack ?? e.message) : String(e));
+            }
+            outcomes.push({
+                repair,
+                status: "failed",
+                reason: `\`${repair.command}\` failed; re-run it directly, or --debug for the raw error`,
+            });
+        }
+    }
+    return outcomes;
+}
 export function registerDoctor(program) {
     program
         .command("doctor")
         .description("Diagnose your TinyFish setup")
         .option("--pretty", "Human-readable check list instead of JSON")
-        .option("--harness <name>", `Restrict to one harness (${FIVE_HARNESSES.join(", ")})`)
+        .option("--harness <name>", `Restrict to one harness (${ALL_HARNESSES.join(", ")})`)
         .option("--url <mcpUrl>", "MCP endpoint override")
+        .option("--fix", "Repair what can be repaired by re-running tinyfish connect")
+        .option("--yes", "Allow --fix to run without a terminal (unattended-safe repairs only)")
         .action(async (options) => {
-        if (options.harness && !FIVE_HARNESSES.includes(options.harness)) {
+        if (options.harness && !ALL_HARNESSES.includes(options.harness)) {
             err({ error: `Unknown --harness value: ${options.harness}` });
             process.exitCode = DOCTOR_COULD_NOT_RUN;
             return;
         }
+        const doctorOptions = {
+            mcpUrl: options.url ?? DEFAULT_MCP_URL,
+            fix: Boolean(options.fix),
+            yes: Boolean(options.yes),
+            ...(options.harness ? { harness: options.harness } : {}),
+        };
         let report;
         try {
-            report = await runDoctor({
-                mcpUrl: options.url ?? DEFAULT_MCP_URL,
-                ...(options.harness ? { harness: options.harness } : {}),
-            });
+            report = await runDoctor(doctorOptions);
+            if (doctorOptions.fix && report.repairs.length > 0) {
+                for (const outcome of await applyRepairs(report.repairs, doctorOptions)) {
+                    const reason = outcome.reason ? ` (${outcome.reason})` : "";
+                    errLine(`${outcome.status}: ${outcome.repair.command}${reason}`);
+                }
+                // Re-diagnose so the emitted report describes the machine after repair, not before.
+                report = await runDoctor(doctorOptions);
+            }
         }
         catch (e) {
             // Exit 2 means doctor itself broke, a different claim from "your setup is broken".

package/dist/lib/connect-all.js

@@ -1,8 +1,8 @@
 import * as readline from "node:readline/promises";
 import spawn from "cross-spawn";
-import { connectClaudeCode, connectCodex, connectCursor, connectHermes, connectOpenClaw, } from "../commands/connect.js";
+import { connectClaudeCode, connectCodex, connectCursor, connectHermes, connectOpenClaw, connectOpencode, } from "../commands/connect.js";
 import { validatedApiKey } from "./auth.js";
-import { detectInstalledHarnesses, FIVE_HARNESSES, } from "./harness-detect.js";
+import { detectInstalledHarnesses, ALL_HARNESSES, } from "./harness-detect.js";
 import { detectHumanInitiated } from "./harness.js";
 import { emitNotice } from "./notice.js";
 import { removeCursorMcpServer, planCursorWrite } from "./cursor-config.js";
@@ -15,12 +15,13 @@ const DISPLAY_NAMES = {
     cursor: "Cursor",
     hermes: "Hermes",
     openclaw: "OpenClaw",
+    opencode: "OpenCode",
 };
 // `codex mcp add` succeeds unauthenticated; OAuth lands at first tool use.
 const AUTH_DEFERRED_AT_INSTALL = new Set(["codex"]);
 // Harnesses that drive their own OAuth at install — a stored TinyFish key says nothing
 // about their session, so it must never unlock a headless run for them.
-const HARNESS_OWN_AUTH = new Set(["claude-code", "codex", "hermes"]);
+const HARNESS_OWN_AUTH = new Set(["claude-code", "codex", "hermes", "opencode"]);
 const AUTH_CHECK_CAPABLE = new Set(["cursor", "openclaw"]);
 // Real removal commands — harness id is not the binary name.
 const UNINSTALL_POINTERS = {
@@ -28,6 +29,8 @@ const UNINSTALL_POINTERS = {
     codex: "codex mcp remove tinyfish",
     hermes: "hermes mcp remove tinyfish",
     openclaw: "openclaw skills uninstall @tinyfish/tinyfish --global",
+    // OpenCode ships no `mcp remove`, so the only removal is editing the config it wrote.
+    opencode: "remove the tinyfish entry from ~/.config/opencode/opencode.json",
 };
 async function runHarnessConnect(harness, opts) {
     const base = { apiKey: opts.apiKey, mcpUrl: opts.mcpUrl, launch: false };
@@ -39,6 +42,8 @@ async function runHarnessConnect(harness, opts) {
         return connectHermes(base);
     if (harness === "openclaw")
         return connectOpenClaw({ mcpUrl: opts.mcpUrl, launch: false });
+    if (harness === "opencode")
+        return connectOpencode(base);
     return connectCursor({ apiKey: opts.apiKey, mcpUrl: opts.mcpUrl });
 }
 async function verifyHarness(harness, mcpUrl, apiKey) {
@@ -262,7 +267,7 @@ export async function runConnectAll(opts) {
         outLine(summaryLine(result, opts.uninstall));
     if (results.every((r) => !r.detected)) {
         outLine("");
-        outLine("No supported harness found. Install one of: " + FIVE_HARNESSES.join(", "));
+        outLine("No supported harness found. Install one of: " + ALL_HARNESSES.join(", "));
         if (!opts.uninstall)
             outLine("Then run: npx @tiny-fish/cli connect --all");
         return 1;

package/dist/lib/doctor-report.d.ts

@@ -22,6 +22,7 @@ declare const doctorCheckSchema: z.ZodObject<{
         cursor: "cursor";
         codex: "codex";
         hermes: "hermes";
+        opencode: "opencode";
         "claude-code": "claude-code";
     }>>;
 }, z.core.$strip>;
@@ -31,6 +32,7 @@ declare const doctorHarnessSchema: z.ZodObject<{
         cursor: "cursor";
         codex: "codex";
         hermes: "hermes";
+        opencode: "opencode";
         "claude-code": "claude-code";
     }>;
     detected: z.ZodBoolean;
@@ -57,6 +59,7 @@ declare const doctorRepairSchema: z.ZodObject<{
         cursor: "cursor";
         codex: "codex";
         hermes: "hermes";
+        opencode: "opencode";
         "claude-code": "claude-code";
     }>>;
     command: z.ZodString;
@@ -81,6 +84,7 @@ export declare const doctorReportSchema: z.ZodObject<{
             cursor: "cursor";
             codex: "codex";
             hermes: "hermes";
+            opencode: "opencode";
             "claude-code": "claude-code";
         }>>;
     }, z.core.$strip>>;
@@ -90,6 +94,7 @@ export declare const doctorReportSchema: z.ZodObject<{
             cursor: "cursor";
             codex: "codex";
             hermes: "hermes";
+            opencode: "opencode";
             "claude-code": "claude-code";
         }>;
         detected: z.ZodBoolean;
@@ -116,6 +121,7 @@ export declare const doctorReportSchema: z.ZodObject<{
             cursor: "cursor";
             codex: "codex";
             hermes: "hermes";
+            opencode: "opencode";
             "claude-code": "claude-code";
         }>>;
         command: z.ZodString;

package/dist/lib/doctor-report.js

@@ -1,9 +1,9 @@
 import { z } from "zod";
-import { FIVE_HARNESSES } from "./harness-detect.js";
+import { ALL_HARNESSES } from "./harness-detect.js";
 /** Bumped whenever a consumer could misread the payload; the cookbook skill releases separately. */
 export const DOCTOR_SCHEMA_VERSION = 1;
 const checkStatusSchema = z.enum(["pass", "fail", "warn", "skip"]);
-const harnessSchema = z.enum(FIVE_HARNESSES);
+const harnessSchema = z.enum(ALL_HARNESSES);
 const doctorCheckSchema = z.object({
     id: z.string(),
     title: z.string(),

package/dist/lib/harness-detect.d.ts

@@ -1,10 +1,10 @@
-export declare const FIVE_HARNESSES: readonly ["claude-code", "codex", "cursor", "hermes", "openclaw"];
-export type FiveHarness = (typeof FIVE_HARNESSES)[number];
-export declare function harnessConfigPath(harness: FiveHarness): string;
+export declare const ALL_HARNESSES: readonly ["claude-code", "codex", "cursor", "hermes", "openclaw", "opencode"];
+export type Harness = (typeof ALL_HARNESSES)[number];
+export declare function harnessConfigPath(harness: Harness): string;
 /** For reason strings that name a location; keeps them in sync with the table above. */
-export declare function harnessDisplayPath(harness: FiveHarness): string;
+export declare function harnessDisplayPath(harness: Harness): string;
 export interface HarnessDetection {
-    harness: FiveHarness;
+    harness: Harness;
     detected: boolean;
     configPath: string;
 }

package/dist/lib/harness-detect.js

@@ -1,7 +1,14 @@
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
-export const FIVE_HARNESSES = ["claude-code", "codex", "cursor", "hermes", "openclaw"];
+export const ALL_HARNESSES = [
+    "claude-code",
+    "codex",
+    "cursor",
+    "hermes",
+    "openclaw",
+    "opencode",
+];
 // Presence detection only — dir existence means "installed", nothing more.
 const CONFIG_DIRS = {
     "claude-code": ".claude",
@@ -9,6 +16,7 @@ const CONFIG_DIRS = {
     cursor: ".cursor",
     hermes: ".hermes",
     openclaw: ".openclaw",
+    opencode: ".config/opencode",
 };
 export function harnessConfigPath(harness) {
     return path.join(os.homedir(), CONFIG_DIRS[harness]); // nosemgrep: path-join-resolve-traversal -- fixed dir names under os.homedir()
@@ -18,7 +26,7 @@ export function harnessDisplayPath(harness) {
     return `~/${CONFIG_DIRS[harness]}`;
 }
 export function detectInstalledHarnesses() {
-    return FIVE_HARNESSES.map((harness) => {
+    return ALL_HARNESSES.map((harness) => {
         const configPath = harnessConfigPath(harness);
         let detected;
         try {

package/dist/lib/registration-detect.d.ts

@@ -1,8 +1,8 @@
-import { type FiveHarness } from "./harness-detect.js";
+import { type Harness } from "./harness-detect.js";
 export type Registered = "yes" | "no" | "unknown";
 export type AuthMode = "api-key" | "oauth" | "unknown";
 export interface RegistrationStatus {
-    harness: FiveHarness;
+    harness: Harness;
     detected: boolean;
     registered: Registered;
     authMode: AuthMode;
@@ -12,4 +12,4 @@ export interface RegistrationStatus {
     reason?: string;
 }
 /** Never throws; a failed probe is `unknown` with a reason, so no caller can read it as healthy. */
-export declare function detectRegistrations(harnesses?: FiveHarness[]): RegistrationStatus[];
+export declare function detectRegistrations(harnesses?: Harness[]): RegistrationStatus[];

package/dist/lib/registration-detect.js

@@ -24,6 +24,10 @@ const UNSUPPORTED_SUBCOMMAND = /unknown command|unrecognized subcommand|invalid
 // `claude mcp get` exits 1 for a usage error too, so only this message is evidence of absence.
 const NO_SUCH_SERVER = /no (?:mcp )?server named/i;
 const API_KEY_HEADER = /x-api-key/i;
+// OpenCode colours its list even through a pipe, putting `\x1b[34m` between the line start and
+// the server name, so an unstripped probe reads a registered harness as absent.
+// eslint-disable-next-line no-control-regex
+const ANSI_SGR = /\x1b\[[0-9;]*m/g;
 // The report is pasted in public, so every reason is authored here. A spawn error's own
 // message quotes absolute paths, which is how a home directory reaches the payload.
 function spawnFailureReason(command, code) {
@@ -34,7 +38,13 @@ function spawnFailureReason(command, code) {
     return `could not run \`${command}\``;
 }
 function runProbe(command, args) {
-    const result = spawn.sync(command, args, { encoding: "utf8", timeout: PROBE_TIMEOUT_MS });
+    const result = spawn.sync(command, args, {
+        encoding: "utf8",
+        timeout: PROBE_TIMEOUT_MS,
+        // Belt and braces only: agents export FORCE_COLOR, and `NO_COLOR` does not fully silence
+        // OpenCode, so the strip below stays load-bearing rather than a fallback.
+        env: { ...process.env, NO_COLOR: "1", FORCE_COLOR: "0" },
+    });
     if (result.error) {
         const code = result.error.code;
         // A timeout arrives as ETIMEDOUT here, not only as a signal, so it must be named before
@@ -48,12 +58,36 @@ function runProbe(command, args) {
     if (result.signal) {
         return { outcome: "unavailable", reason: `\`${command}\` was killed by ${result.signal}` };
     }
-    const stdout = result.stdout ?? "";
+    // Both streams, since a colour code inside a JSON payload breaks the parse just as it
+    // breaks an anchored match. Valid JSON never carries a raw ESC byte, so this cannot corrupt it.
+    const stdout = (result.stdout ?? "").replace(ANSI_SGR, "");
     return {
         outcome: "ran",
         exitCode: result.status ?? 1,
         stdout,
-        output: `${stdout}${result.stderr ?? ""}`,
+        output: `${stdout}${(result.stderr ?? "").replace(ANSI_SGR, "")}`,
+    };
+}
+// A plugin registers its server as `plugin:<plugin>:<server>`, which `mcp get tinyfish` misses.
+// The optional prefix must end in `:`, so `not-tinyfish` is not a match.
+const MCP_LIST_TINYFISH_LINE = /^((?:\S*:)?tinyfish):\s+(https?:\S+)/m;
+// A bare substring also matches `not-tinyfish` and any row quoting a tinyfish URL, so the name
+// is required to be the first word on its line, after whatever status glyph the CLI prints.
+const LISTED_AS_TINYFISH = /^[^\w]*tinyfish(?![\w-])/m;
+/** The plugin ships its own MCP server, so a working install can carry no `tinyfish` entry. */
+function fromPluginRegistration(command) {
+    const probe = runProbe(command, ["mcp", "list"]);
+    if (probe.outcome === "unavailable" || probe.exitCode !== 0)
+        return undefined;
+    const match = MCP_LIST_TINYFISH_LINE.exec(probe.output);
+    if (!match)
+        return undefined;
+    // `mcp list` prints no headers, so the credential behind it is unproven, never assumed.
+    return {
+        registered: "yes",
+        authMode: "unknown",
+        registeredUrl: match[2],
+        reason: `registered as ${match[1]}, which \`mcp get tinyfish\` does not resolve`,
     };
 }
 // claude-code only. Codex cannot use this: its `mcp get` exits 0 on a missing server.
@@ -70,6 +104,10 @@ function fromMcpGet(command, keyAuthPattern) {
                 reason: `\`${command} mcp get\` is unsupported by this version`,
             };
         }
+        // Positive evidence from `mcp list` outranks anything inferred from a failed `mcp get`.
+        const plugin = fromPluginRegistration(command);
+        if (plugin)
+            return plugin;
         // A broken CLI also exits nonzero, and reading that as absence earns a spurious repair.
         if (!NO_SUCH_SERVER.test(probe.output)) {
             return {
@@ -162,6 +200,26 @@ function probeCursor() {
         ...(entry.url ? { registeredUrl: entry.url } : {}),
     };
 }
+// Both list commands print this header in every state, including "no servers configured".
+// Exit 0 with output we cannot recognise is not evidence of absence: reporting `no` there would
+// earn a connect repair off a parse failure, which is the bug class this command exists to kill.
+const MCP_LIST_HEADER = /mcp servers/i;
+// OpenCode prints the endpoint on the line under the server row; Hermes truncates its column.
+const OPENCODE_ROW_URL = /^[^\w]*tinyfish(?![\w-]).*\n[^\w]*(https?:\S+)/m;
+function fromMcpList(command, output, registeredMode, urlPattern) {
+    if (LISTED_AS_TINYFISH.test(output)) {
+        const url = urlPattern?.exec(output)?.[1];
+        return { registered: "yes", authMode: registeredMode, ...(url ? { registeredUrl: url } : {}) };
+    }
+    if (!MCP_LIST_HEADER.test(output)) {
+        return {
+            registered: "unknown",
+            authMode: "unknown",
+            reason: `could not interpret \`${command} mcp list\` output`,
+        };
+    }
+    return { registered: "no", authMode: "unknown" };
+}
 // Hermes registers with `--auth oauth` and has no key path today, so mode is fixed.
 function probeHermes() {
     const probe = runProbe("hermes", ["mcp", "list"]);
@@ -175,10 +233,9 @@ function probeHermes() {
             reason: `\`hermes mcp list\` exited ${probe.exitCode}`,
         };
     }
-    return probe.output.includes("tinyfish")
-        ? { registered: "yes", authMode: "oauth" }
-        : { registered: "no", authMode: "unknown" };
+    return fromMcpList("hermes", probe.output, "oauth");
 }
+const SKILL_DIR_IS_TINYFISH = /^(?:@tinyfish[/_-])?tinyfish(?![\w-])/i;
 // OpenClaw installs a skill, not an MCP server; the skill shells the CLI, so auth is the CLI key.
 function probeOpenClaw() {
     const skillsDir = path.join(harnessConfigPath("openclaw"), "skills");
@@ -193,16 +250,33 @@ function probeOpenClaw() {
             reason: `no global skills directory at ${harnessDisplayPath("openclaw")}/skills; OpenClaw layout is unverified`,
         };
     }
-    return entries.some((name) => /tinyfish/i.test(name))
+    // A bare substring also matched a skill merely named `not-tinyfish-thing`.
+    return entries.some((name) => SKILL_DIR_IS_TINYFISH.test(name))
         ? { registered: "yes", authMode: "api-key" }
         : { registered: "no", authMode: "unknown" };
 }
+// Connect registers with `mcp add --url` then `mcp auth`, so there is no key path today.
+function probeOpencode() {
+    const probe = runProbe("opencode", ["mcp", "list"]);
+    if (probe.outcome === "unavailable") {
+        return { registered: "unknown", authMode: "unknown", reason: probe.reason };
+    }
+    if (probe.exitCode !== 0) {
+        return {
+            registered: "unknown",
+            authMode: "unknown",
+            reason: `\`opencode mcp list\` exited ${probe.exitCode}`,
+        };
+    }
+    return fromMcpList("opencode", probe.output, "oauth", OPENCODE_ROW_URL);
+}
 const PROBES = {
     "claude-code": () => fromMcpGet("claude", API_KEY_HEADER),
     codex: probeCodex,
     cursor: probeCursor,
     hermes: probeHermes,
     openclaw: probeOpenClaw,
+    opencode: probeOpencode,
 };
 /** Never throws; a failed probe is `unknown` with a reason, so no caller can read it as healthy. */
 export function detectRegistrations(harnesses) {

package/dist/lib/setup-telemetry.d.ts

@@ -28,6 +28,7 @@ declare const harnessResultSchema: z.ZodObject<{
         cursor: "cursor";
         codex: "codex";
         hermes: "hermes";
+        opencode: "opencode";
         "claude-code": "claude-code";
     }>;
     detected: z.ZodBoolean;
@@ -45,6 +46,7 @@ export declare const setupCompletedPayloadSchema: z.ZodObject<{
             cursor: "cursor";
             codex: "codex";
             hermes: "hermes";
+            opencode: "opencode";
             "claude-code": "claude-code";
         }>;
         detected: z.ZodBoolean;

package/dist/lib/setup-telemetry.js

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { z } from "zod";
 import { validateKeyFormat } from "./auth.js";
 import { BASE_URL, CLI_VERSION } from "./constants.js";
-import { FIVE_HARNESSES } from "./harness-detect.js";
+import { ALL_HARNESSES } from "./harness-detect.js";
 import { captureNotice } from "./notice.js";
 import { errLine } from "./output.js";
 const CONNECT_EVENT_TIMEOUT_MS = 2_000;
@@ -95,7 +95,7 @@ export async function postConnectEvent(options) {
     }
 }
 const harnessResultSchema = z.object({
-    harness: z.enum(FIVE_HARNESSES),
+    harness: z.enum(ALL_HARNESSES),
     detected: z.boolean(),
     installed: z.boolean(),
     verify_depth: z.enum(["health", "health+auth"]).nullable(),
@@ -104,8 +104,8 @@ const harnessResultSchema = z.object({
 export const setupCompletedPayloadSchema = z.object({
     harnesses: z
         .array(harnessResultSchema)
-        .length(FIVE_HARNESSES.length)
-        .refine((results) => new Set(results.map((r) => r.harness)).size === FIVE_HARNESSES.length, {
+        .length(ALL_HARNESSES.length)
+        .refine((results) => new Set(results.map((r) => r.harness)).size === ALL_HARNESSES.length, {
         message: "expected one result per harness",
     }),
     cli_version: z.string(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiny-fish/cli",
-  "version": "0.15.1-next.160",
+  "version": "0.16.0",
   "description": "TinyFish CLI — run web automations from your terminal",
   "type": "module",
   "bin": {
@@ -32,7 +32,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@tiny-fish/sdk": "^0.3.0",
+    "@tiny-fish/sdk": "^0.4.0",
     "chrome-cookies-secure": "^3.0.2",
     "commander": "^12.0.0",
     "cross-spawn": "^7.0.6",