@tiny-fish/cli 0.30.2-next.256 → 0.30.2-next.258

package/dist/lib/connect-all.js

@@ -1,33 +1,37 @@
-import * as readline from "node:readline/promises";
-import spawn from "cross-spawn";
-import { connectClaudeCode, connectCodex, connectCursor, connectGrok, connectHermes, connectOpenClaw, connectOpencode, } from "../commands/connect.js";
-import { clearConnectContext, connectContextState, loadConfig, validatedApiKey, } from "./auth.js";
-import { installTinyFishCli, } from "./cli-install.js";
-import { HARNESS_CAPABILITIES, NATIVE_BY_HARNESS, openclawSkillUninstall, } from "./connect-clients.js";
-import { createStdinPrompt, runCliFallback } from "./connect-fallback.js";
-import { ConnectInterruptedError, ConnectStepError, SignInTimeoutError, finishSetupCommand, spawnRemoval, } from "./connect-runtime.js";
-import { pickHarnesses } from "./connect-picker.js";
-import { commandOnPath, detectInstalledHarnesses, HARNESS_COMMANDS, HARNESS_DISPLAY_NAMES as DISPLAY_NAMES, ALL_HARNESSES, RELOAD_ACTION, } from "./harness-detect.js";
-import { detectHumanInitiated } from "./harness.js";
-import { emitNotice } from "./notice.js";
-import { removeCursorMcpServer, planCursorWrite } from "./cursor-config.js";
-import { errLine, outLine, setErrIndent } from "./output.js";
-import { sendSetupCompleted } from "./setup-telemetry.js";
-import { verifyMcpAuth, verifyMcpHealth } from "./verify.js";
+import * as readline from 'node:readline/promises';
+import spawn from 'cross-spawn';
+import { connectClaudeCode, connectCodex, connectCursor, connectGrok, connectHermes, connectOpenClaw, connectOpencode, } from '../commands/connect.js';
+import { clearConnectContext, connectContextState, loadConfig, validatedApiKey } from './auth.js';
+import { installTinyFishCli, } from './cli-install.js';
+import { HARNESS_CAPABILITIES, NATIVE_BY_HARNESS, openclawSkillUninstall, } from './connect-clients.js';
+import { createStdinPrompt, runCliFallback } from './connect-fallback.js';
+import { ConnectInterruptedError, ConnectStepError, SignInTimeoutError, finishSetupCommand, spawnRemoval, } from './connect-runtime.js';
+import { pickHarnesses } from './connect-picker.js';
+import { commandOnPath, detectInstalledHarnesses, HARNESS_COMMANDS, HARNESS_DISPLAY_NAMES as DISPLAY_NAMES, ALL_HARNESSES, RELOAD_ACTION, } from './harness-detect.js';
+import { detectHumanInitiated } from './harness.js';
+import { emitNotice } from './notice.js';
+import { removeCursorMcpServer, planCursorWrite } from './cursor-config.js';
+import { errLine, outLine, setErrIndent } from './output.js';
+import { sendSetupCompleted } from './setup-telemetry.js';
+import { verifyMcpAuth, verifyMcpHealth } from './verify.js';
 // A probe that exits non-zero is an install so old the subcommand is missing entirely.
 const TOO_OLD_REASONS = new Set([
-    "harness_too_old",
-    "harness_command_unsupported",
+    'harness_too_old',
+    'harness_command_unsupported',
 ]);
 // These failures land before any browser could have opened.
 const NO_BROWSER_REASONS = new Set([
     ...TOO_OLD_REASONS,
-    "harness_not_installed",
-    "command_not_found",
+    'harness_not_installed',
+    'command_not_found',
 ]);
 // Naming a harness the user does not have is the noise PF-3708 cut.
-const HIDDEN_ONCE_SOMETHING_WORKED = new Set(["deselected", "not_detected", "not_installed"]);
-const STEP_INDENT = "  ";
+const HIDDEN_ONCE_SOMETHING_WORKED = new Set([
+    'deselected',
+    'not_detected',
+    'not_installed',
+]);
+const STEP_INDENT = '  ';
 // Must undercut agent tool-call budgets (Claude Code Bash defaults to 120s).
 const OAUTH_SIGN_IN_TIMEOUT_MS = 90_000;
 // Derived: these block `connect` on a browser sign-in when keyless.
@@ -38,10 +42,10 @@ const BROWSER_SIGN_IN = new Set(ALL_HARNESSES.filter((harness) => {
 // Derived: a native add carries the key, or the CLI holds it itself.
 const KEY_AUTH_CAPABLE = new Set(ALL_HARNESSES.filter((harness) => !!NATIVE_BY_HARNESS.get(harness)?.keyAuth || HARNESS_CAPABILITIES[harness].keyHeldByCli));
 // OpenCode ships no `mcp remove`, so the only removal is editing the config it wrote.
-const OPENCODE_UNINSTALL_POINTER = "remove the tinyfish entry from ~/.config/opencode/opencode.json";
+const OPENCODE_UNINSTALL_POINTER = 'remove the tinyfish entry from ~/.config/opencode/opencode.json';
 // A new harness fails to compile until wired here.
 const HARNESS_CONNECTORS = {
-    "claude-code": connectClaudeCode,
+    'claude-code': connectClaudeCode,
     codex: connectCodex,
     grok: connectGrok,
     hermes: connectHermes,
@@ -90,17 +94,17 @@ async function verifyHarness(harness, mcpUrl, keyed, apiKey) {
     if (!capable || !health.ok)
         return health;
     if (!apiKey)
-        return { depth: "health+auth", ok: false, reason: "no stored API key" };
+        return { depth: 'health+auth', ok: false, reason: 'no stored API key' };
     return verifyMcpAuth(apiKey);
 }
 function planText(harness, mcpUrl, apiKey) {
-    if (harness === "cursor")
+    if (harness === 'cursor')
         return planCursorWrite(mcpUrl, apiKey);
     return `would run \`tinyfish connect ${harness}\` (harness-owned MCP write; no local file touched by the CLI)`;
 }
 function uninstallPlanText(harness) {
-    if (harness === "cursor") {
-        return "would remove the tinyfish entry from ~/.cursor/mcp.json";
+    if (harness === 'cursor') {
+        return 'would remove the tinyfish entry from ~/.cursor/mcp.json';
     }
     if (!uninstallRuns(harness)) {
         return `would print \`${uninstallPointer(harness)}\` (no removal command exists)`;
@@ -109,7 +113,7 @@ function uninstallPlanText(harness) {
 }
 /** Undefined: no harness-CLI removal exists (opencode). */
 function uninstallRuns(harness) {
-    if (harness === "openclaw") {
+    if (harness === 'openclaw') {
         const removal = openclawSkillUninstall();
         return { command: removal.command, runs: [removal.args], timeoutMs: removal.timeoutMs };
     }
@@ -125,43 +129,43 @@ function uninstallPointer(harness) {
         return OPENCODE_UNINSTALL_POINTER;
     // `;` runs every removal but breaks cmd.exe; `&&` is the reverse — see
     // internal-docs/install-command-shell-quirks.md (PS 5.1 stays a known gap).
-    const joiner = process.platform === "win32" ? " && " : " ; ";
-    return removal.runs.map((args) => `${removal.command} ${args.join(" ")}`).join(joiner);
+    const joiner = process.platform === 'win32' ? ' && ' : ' ; ';
+    return removal.runs.map((args) => `${removal.command} ${args.join(' ')}`).join(joiner);
 }
 function uninstallHarness(harness, configPath, verbose, binaryOnPath) {
     const detection = { harness, detected: true, configPath, installed: false };
-    if (harness !== "cursor") {
+    if (harness !== 'cursor') {
         const removal = uninstallRuns(harness);
         if (!removal) {
-            return { ...detection, outcome: "uninstall_pointer", fixCommand: uninstallPointer(harness) };
+            return { ...detection, outcome: 'uninstall_pointer', fixCommand: uninstallPointer(harness) };
         }
         // Stale config: the harness binary is gone, so its removal command cannot run.
         // openclaw is exempt — its removal runs through npx, not the harness binary.
-        if (harness !== "openclaw" && !binaryOnPath) {
+        if (harness !== 'openclaw' && !binaryOnPath) {
             return {
                 ...detection,
-                outcome: "uninstall_pointer",
+                outcome: 'uninstall_pointer',
                 errorMessage: `no \`${removal.command}\` binary on PATH — nothing to run.`,
                 fixCommand: `Reinstall ${DISPLAY_NAMES[harness]} first, then: ${uninstallPointer(harness)}`,
             };
         }
         // Absent marker = never connected here, so a non-zero removal exit is a no-op.
         // Unreadable config cannot prove that, so it keeps the pointer.
-        const connectedBefore = connectContextState(harness) !== "absent";
+        const connectedBefore = connectContextState(harness) !== 'absent';
         let removed = false;
         try {
             for (const args of removal.runs) {
                 const result = spawnRemoval(removal.command, args, removal.timeoutMs);
                 if (result.status !== 0 && verbose) {
                     const details = result.stderr?.trim() || result.error?.message || `exit ${result.status}`;
-                    errLine(`${removal.command} ${args.join(" ")}: ${details}`);
+                    errLine(`${removal.command} ${args.join(' ')}: ${details}`);
                 }
                 // Same binary: a spawn-level failure (ENOENT, EPERM) repeats identically.
                 if (result.error) {
                     return {
                         ...detection,
-                        outcome: "uninstalled",
-                        errorMessage: `could not run \`${removal.command} ${args.join(" ")}\` (${result.error.message}) — nothing removed.`,
+                        outcome: 'uninstalled',
+                        errorMessage: `could not run \`${removal.command} ${args.join(' ')}\` (${result.error.message}) — nothing removed.`,
                         fixCommand: uninstallPointer(harness),
                     };
                 }
@@ -174,8 +178,8 @@ function uninstallHarness(harness, configPath, verbose, binaryOnPath) {
             if (e instanceof ConnectInterruptedError) {
                 return {
                     ...detection,
-                    outcome: "interrupted",
-                    fixCommand: "tinyfish connect --all --uninstall",
+                    outcome: 'interrupted',
+                    fixCommand: 'tinyfish connect --all --uninstall',
                 };
             }
             throw e;
@@ -183,14 +187,14 @@ function uninstallHarness(harness, configPath, verbose, binaryOnPath) {
         if (removed) {
             // Kept marker makes doctor emit a registration-lost repair that undoes this.
             clearConnectContext(harness);
-            return { ...detection, outcome: "uninstalled" };
+            return { ...detection, outcome: 'uninstalled' };
         }
         if (!connectedBefore)
-            return { ...detection, outcome: "uninstall_noop" };
+            return { ...detection, outcome: 'uninstall_noop' };
         return {
             ...detection,
-            outcome: "uninstall_pointer",
-            errorMessage: "could not confirm removal (command exited non-zero; there may have been nothing to remove).",
+            outcome: 'uninstall_pointer',
+            errorMessage: 'could not confirm removal (command exited non-zero; there may have been nothing to remove).',
             fixCommand: `Retry by hand: ${uninstallPointer(harness)}`,
         };
     }
@@ -199,27 +203,27 @@ function uninstallHarness(harness, configPath, verbose, binaryOnPath) {
         result = removeCursorMcpServer();
     }
     catch (e) {
-        result = { status: "corrupt_skip", error: e instanceof Error ? e.message : String(e) };
+        result = { status: 'corrupt_skip', error: e instanceof Error ? e.message : String(e) };
     }
-    if (result.status === "corrupt_skip") {
+    if (result.status === 'corrupt_skip') {
         return {
             ...detection,
-            outcome: "uninstalled",
+            outcome: 'uninstalled',
             errorMessage: `could not update Cursor's mcp.json (${result.error}) — nothing removed.`,
-            fixCommand: "Fix ~/.cursor/mcp.json by hand, then re-run: tinyfish connect --all --uninstall",
+            fixCommand: 'Fix ~/.cursor/mcp.json by hand, then re-run: tinyfish connect --all --uninstall',
         };
     }
-    if (result.status === "unchanged") {
-        return { ...detection, outcome: "uninstall_noop" };
+    if (result.status === 'unchanged') {
+        return { ...detection, outcome: 'uninstall_noop' };
     }
-    clearConnectContext("cursor");
-    return { ...detection, outcome: "uninstalled" };
+    clearConnectContext('cursor');
+    return { ...detection, outcome: 'uninstalled' };
 }
 async function processHarness(detection, opts, prompt, oauthBudget, hoistedCliInstall, deferOutro) {
     const { harness, configPath, detected } = detection;
     const base = { harness, detected, configPath, installed: false };
     const noWork = noWorkOutcome(detection, opts.uninstall);
-    if (noWork === "not_detected")
+    if (noWork === 'not_detected')
         return { ...base, outcome: noWork };
     if (noWork)
         return { ...base, outcome: noWork, fixCommand: `tinyfish connect ${harness}` };
@@ -228,7 +232,7 @@ async function processHarness(detection, opts, prompt, oauthBudget, hoistedCliIn
         const plan = opts.uninstall
             ? uninstallPlanText(harness)
             : planText(harness, opts.mcpUrl, validatedApiKey(opts.apiKey));
-        return { ...base, outcome: "dry_run", fixCommand: plan };
+        return { ...base, outcome: 'dry_run', fixCommand: plan };
     }
     if (opts.uninstall)
         return uninstallHarness(harness, configPath, opts.verbose ?? false, detection.binaryOnPath);
@@ -242,12 +246,12 @@ async function processHarness(detection, opts, prompt, oauthBudget, hoistedCliIn
     if (!isTTY && !keyed) {
         // A CLI-login sign-in is interactive-only — unboundable headless.
         if (HARNESS_CAPABILITIES[harness].signInViaCliLogin) {
-            return { ...base, outcome: "auth_pending", fixCommand };
+            return { ...base, outcome: 'auth_pending', fixCommand };
         }
         if (BROWSER_SIGN_IN.has(harness)) {
             // One browser sign-in per run; the rest wait for a re-run.
             if (oauthBudget.spent)
-                return { ...base, outcome: "auth_pending", fixCommand };
+                return { ...base, outcome: 'auth_pending', fixCommand };
             oauthBudget.spent = true;
             spentBrowserSlot = true;
             errLine(`${DISPLAY_NAMES[harness]} needs a browser sign-in — finish it when your browser ` +
@@ -263,11 +267,11 @@ async function processHarness(detection, opts, prompt, oauthBudget, hoistedCliIn
         catch (error) {
             // Ctrl+C stops the run; Ctrl+D only skips this harness.
             if (error instanceof ConnectInterruptedError) {
-                errLine("Setup interrupted — run the command again to finish.");
+                errLine('Setup interrupted — run the command again to finish.');
                 process.exitCode = 130;
-                return { ...base, outcome: "interrupted", fixCommand };
+                return { ...base, outcome: 'interrupted', fixCommand };
             }
-            return { ...base, outcome: "no_tty_auth_skip", fixCommand };
+            return { ...base, outcome: 'no_tty_auth_skip', fixCommand };
         }
     }
     // runGuarded swallows Ctrl+C and sets exitCode 130 instead of throwing.
@@ -284,45 +288,47 @@ async function processHarness(detection, opts, prompt, oauthBudget, hoistedCliIn
         if (e instanceof SignInTimeoutError) {
             return {
                 ...base,
-                outcome: "auth_pending",
-                errorMessage: "sign-in did not finish in time",
+                outcome: 'auth_pending',
+                errorMessage: 'sign-in did not finish in time',
                 fixCommand,
             };
         }
         // A pre-browser failure must not burn the run's only browser slot.
-        if (spentBrowserSlot && e instanceof ConnectStepError && NO_BROWSER_REASONS.has(e.failureReason)) {
+        if (spentBrowserSlot &&
+            e instanceof ConnectStepError &&
+            NO_BROWSER_REASONS.has(e.failureReason)) {
             oauthBudget.spent = false;
         }
         // Detection saw a name on PATH; the probe proved nothing is behind it.
-        if (e instanceof ConnectStepError && e.failureReason === "harness_not_installed") {
-            return { ...base, detected: false, outcome: "not_installed" };
+        if (e instanceof ConnectStepError && e.failureReason === 'harness_not_installed') {
+            return { ...base, detected: false, outcome: 'not_installed' };
         }
         // Both reasons carry the same "flag not listed" message; the upgrade nudge is in it.
         if (e instanceof ConnectStepError && TOO_OLD_REASONS.has(e.failureReason)) {
             return {
                 ...base,
-                outcome: "harness_too_old",
+                outcome: 'harness_too_old',
                 errorMessage: e.message,
                 fixCommand: `tinyfish connect ${harness}`,
             };
         }
         return {
             ...base,
-            outcome: "failed",
+            outcome: 'failed',
             errorMessage: e instanceof Error ? e.message : String(e),
             fixCommand: `tinyfish connect ${harness}`,
         };
     }
     if (!interruptedBefore && process.exitCode === 130) {
-        return { ...base, outcome: "interrupted", fixCommand: `tinyfish connect ${harness}` };
+        return { ...base, outcome: 'interrupted', fixCommand: `tinyfish connect ${harness}` };
     }
     // The probe, not the flag, decides: a harness that degraded to OAuth is not key-authed.
-    const keyAuthed = authMode ? authMode === "api-key" : keyed;
+    const keyAuthed = authMode ? authMode === 'api-key' : keyed;
     const verify = await verifyHarness(harness, opts.mcpUrl, keyAuthed, apiKey);
     return {
         ...base,
         installed: true,
-        outcome: "installed",
+        outcome: 'installed',
         verifyDepth: verify.depth,
         verifyOk: verify.ok,
         verifyReason: verify.reason,
@@ -332,56 +338,56 @@ async function processHarness(detection, opts, prompt, oauthBudget, hoistedCliIn
 }
 function summaryLine(result, uninstall) {
     const name = DISPLAY_NAMES[result.harness];
-    if (result.outcome === "not_installed") {
+    if (result.outcome === 'not_installed') {
         const next = uninstall
-            ? "nothing to remove"
+            ? 'nothing to remove'
             : `Install ${name}, then run: tinyfish connect ${result.harness}`;
         return `- ${name} — not installed (\`${HARNESS_COMMANDS[result.harness]}\` is on PATH but does not run). ${next}`;
     }
     if (!result.detected) {
         const next = uninstall
-            ? "nothing to remove"
+            ? 'nothing to remove'
             : `Install ${name}, then run: tinyfish connect ${result.harness}`;
         return `- ${name} — not detected (no \`${HARNESS_COMMANDS[result.harness]}\` on PATH, no ${result.configPath}). ${next}`;
     }
-    if (result.outcome === "stale_config") {
+    if (result.outcome === 'stale_config') {
         return `… ${name} — config at ${result.configPath} but no \`${HARNESS_COMMANDS[result.harness]}\` on PATH, skipped. Install ${name}, then run: ${result.fixCommand}`;
     }
-    if (result.outcome === "not_reached") {
+    if (result.outcome === 'not_reached') {
         return `… ${name} — not reached, the run stopped early. Fix: ${result.fixCommand}`;
     }
-    if (result.outcome === "dry_run") {
+    if (result.outcome === 'dry_run') {
         return `… ${name} — ${result.fixCommand}`;
     }
-    if (result.outcome === "no_tty_auth_skip") {
+    if (result.outcome === 'no_tty_auth_skip') {
         return `… ${name} — skipped, no stored credentials and no terminal to sign in. Fix: ${result.fixCommand}`;
     }
-    if (result.outcome === "auth_pending") {
+    if (result.outcome === 'auth_pending') {
         return result.errorMessage
             ? `… ${name} — ${result.errorMessage}. Finish it in a terminal: ${result.fixCommand}`
             : `… ${name} — needs a browser sign-in. Run in a terminal: ${result.fixCommand}`;
     }
-    if (result.outcome === "uninstall_pointer") {
+    if (result.outcome === 'uninstall_pointer') {
         // errorMessage set = a removal was attempted or impossible; absent = no removal command exists.
         return result.errorMessage
             ? `… ${name} — ${result.errorMessage} ${result.fixCommand}`
             : `… ${name} — not removed automatically (config is owned by ${name}). Run: ${result.fixCommand}`;
     }
-    if (result.outcome === "uninstall_noop") {
+    if (result.outcome === 'uninstall_noop') {
         return `… ${name} — no tinyfish entry found, nothing removed`;
     }
-    if (result.outcome === "uninstalled") {
+    if (result.outcome === 'uninstalled') {
         return result.errorMessage
             ? `✗ ${name} — ${result.errorMessage} Fix: ${result.fixCommand}`
             : `✓ ${name} — removed`;
     }
-    if (result.outcome === "interrupted") {
+    if (result.outcome === 'interrupted') {
         return `✗ ${name} — interrupted before finishing. Fix: ${result.fixCommand}`;
     }
-    if (result.outcome === "harness_too_old") {
+    if (result.outcome === 'harness_too_old') {
         return `… ${name} — needs a newer ${name}: ${result.errorMessage} Fix, once upgraded: ${result.fixCommand}`;
     }
-    if (result.outcome === "failed") {
+    if (result.outcome === 'failed') {
         return `✗ ${name} — install failed: ${result.errorMessage}. Fix: ${result.fixCommand}`;
     }
     // The summary is what users read; stderr hints scroll away.
@@ -391,11 +397,11 @@ function summaryLine(result, uninstall) {
     }
     // A keyed install has no sign-in left, so the deferred-auth warning would contradict it.
     const authDeferred = HARNESS_CAPABILITIES[result.harness].authDeferredAtInstall && !result.keyAuthed;
-    const verifyLabel = result.verifyDepth ? `verified: ${result.verifyDepth}` : "not verified";
+    const verifyLabel = result.verifyDepth ? `verified: ${result.verifyDepth}` : 'not verified';
     if (authDeferred || result.verifyOk === false) {
         const reason = authDeferred
-            ? "one step left: sign in when your agent first runs"
-            : `verify warning (${verifyLabel}): ${result.verifyReason ?? "unknown"}`;
+            ? 'one step left: sign in when your agent first runs'
+            : `verify warning (${verifyLabel}): ${result.verifyReason ?? 'unknown'}`;
         return `⚠ ${name} — installed, ${reason}. Fix: run \`/tinyfish:doctor\` in ${name} once it's open.`;
     }
     return `✓ ${name} — installed, ${verifyLabel}`;
@@ -411,29 +417,29 @@ function reloadHint(results) {
     }
     if (byAction.size === 0)
         return undefined;
-    const parts = [...byAction].map(([action, names]) => `${names.join(", ")} — ${action}`);
-    return `TinyFish tools load when a harness starts. If one is already open: ${parts.join("; ")}.`;
+    const parts = [...byAction].map(([action, names]) => `${names.join(', ')} — ${action}`);
+    return `TinyFish tools load when a harness starts. If one is already open: ${parts.join('; ')}.`;
 }
 /** Absent and unpicked harnesses are noise once something real happened. */
 function renderSummary(results, uninstall) {
     if (!results.some(actionable))
         return results.map((r) => summaryLine(r, uninstall));
     // Ids, not display names: they double as the `connect` argument.
-    const skipped = results.filter((r) => r.outcome === "deselected").map((r) => r.harness);
+    const skipped = results.filter((r) => r.outcome === 'deselected').map((r) => r.harness);
     const lines = results
         .filter((r) => !HIDDEN_ONCE_SOMETHING_WORKED.has(r.outcome))
         .map((r) => summaryLine(r, uninstall));
     if (skipped.length === 0)
         return lines;
-    lines.push("", `Skipped (not selected): ${skipped.join(", ")}`);
+    lines.push('', `Skipped (not selected): ${skipped.join(', ')}`);
     return lines;
 }
 /** The states processHarness settles without work; stepTotal must agree with it. */
 function noWorkOutcome(d, uninstall) {
     if (!d.detected)
-        return "not_detected";
+        return 'not_detected';
     if (!uninstall && isStaleConfig(d))
-        return "stale_config";
+        return 'stale_config';
     return undefined;
 }
 /** A config-writing connect needs no binary; every other harness spawns one. */
@@ -444,26 +450,26 @@ function isStaleConfig(detection) {
 }
 /** A stale config dir is a detection signal with nothing behind it. */
 function actionable(result) {
-    return result.detected && result.outcome !== "stale_config";
+    return result.detected && result.outcome !== 'stale_config';
 }
 function computeExitCode(results) {
     // Flag-independent: uninstall interrupts have no other 130 site.
-    if (results.some((r) => r.outcome === "interrupted"))
+    if (results.some((r) => r.outcome === 'interrupted'))
         return 130;
     // A removal that could not run is a failure, not a silent success.
-    if (results.some((r) => r.outcome === "uninstalled" && r.errorMessage))
+    if (results.some((r) => r.outcome === 'uninstalled' && r.errorMessage))
         return 1;
     const detected = results.filter(actionable);
     if (detected.length === 0)
         return 1;
     // Only real install attempts count toward the success/failure denominator.
-    const attempted = detected.filter((r) => r.outcome === "installed" ||
-        r.outcome === "failed" ||
-        r.outcome === "harness_too_old" ||
-        r.outcome === "interrupted");
+    const attempted = detected.filter((r) => r.outcome === 'installed' ||
+        r.outcome === 'failed' ||
+        r.outcome === 'harness_too_old' ||
+        r.outcome === 'interrupted');
     if (attempted.length === 0)
         return 0;
-    return attempted.some((r) => r.outcome === "installed") ? 0 : 1;
+    return attempted.some((r) => r.outcome === 'installed') ? 0 : 1;
 }
 export async function runConnectAll(opts) {
     const isTTY = detectHumanInitiated();
@@ -476,7 +482,7 @@ export async function runConnectAll(opts) {
         detections.sort((a, b) => Number(KEY_AUTH_CAPABLE.has(b.harness)) - Number(KEY_AUTH_CAPABLE.has(a.harness)));
     }
     let deselected = new Set();
-    let mode = "all";
+    let mode = 'all';
     // Before willAttempt/cliNeeded: a cursor-only pick must not hoist the CLI.
     // A stale config dir has no binary to connect, so never offer it as a choice.
     const offerable = detections.filter((d) => d.detected && !isStaleConfig(d));
@@ -484,9 +490,9 @@ export async function runConnectAll(opts) {
         const connected = new Set(Object.keys(loadConfig().connect ?? {}));
         const pick = await pickHarnesses(offerable, connected, { prompt });
         mode = pick.mode;
-        if (pick.selection === "cancel") {
+        if (pick.selection === 'cancel') {
             // Before summary and telemetry: an explicit nothing is not a setup.
-            outLine("Nothing installed. Run: tinyfish connect --all or tinyfish connect <client>");
+            outLine('Nothing installed. Run: tinyfish connect --all or tinyfish connect <client>');
             return 0;
         }
         const chosen = new Set(pick.selection);
@@ -506,10 +512,10 @@ export async function runConnectAll(opts) {
             willAttempt(d.harness));
     let takeHoistedCli;
     if (cliNeeded) {
-        errLine("First: the TinyFish CLI, shared by every harness.");
+        errLine('First: the TinyFish CLI, shared by every harness.');
         const outcome = runHoistedCliInstall(opts.verbose ?? false);
         if (!outcome) {
-            errLine("Setup interrupted — run the command again to finish.");
+            errLine('Setup interrupted — run the command again to finish.');
             return 130;
         }
         let taken = false;
@@ -534,7 +540,7 @@ export async function runConnectAll(opts) {
             results.push({
                 ...detection,
                 installed: false,
-                outcome: "deselected",
+                outcome: 'deselected',
                 fixCommand: `tinyfish connect ${harness}`,
             });
             continue;
@@ -556,18 +562,18 @@ export async function runConnectAll(opts) {
                 detected: detection.detected,
                 configPath: detection.configPath,
                 installed: false,
-                outcome: "failed",
+                outcome: 'failed',
                 errorMessage: e instanceof Error ? e.message : String(e),
                 fixCommand: `tinyfish connect ${harness}`,
             };
         }
         finally {
             // The summary and the outro sit outside any step.
-            setErrIndent("");
+            setErrIndent('');
         }
         results.push(result);
         // Ctrl+C means stop, not continue to the next harness.
-        if (result.outcome === "interrupted")
+        if (result.outcome === 'interrupted')
             break;
     }
     // The interrupt break truncates `results`; pad so the one-row-per-harness schema still parses.
@@ -581,17 +587,17 @@ export async function runConnectAll(opts) {
             detected,
             configPath,
             installed: false,
-            outcome: staleConfig ? "stale_config" : detected ? "not_reached" : "not_detected",
+            outcome: staleConfig ? 'stale_config' : detected ? 'not_reached' : 'not_detected',
             fixCommand: `tinyfish connect ${detection.harness}`,
         });
     }
-    outLine("");
-    outLine("TinyFish setup summary:");
+    outLine('');
+    outLine('TinyFish setup summary:');
     for (const line of renderSummary(results, opts.uninstall))
         outLine(line);
     const reload = opts.uninstall ? undefined : reloadHint(results);
     if (reload) {
-        outLine("");
+        outLine('');
         outLine(reload);
     }
     // Before the launch handover: anything printed after it is never seen.
@@ -604,25 +610,25 @@ export async function runConnectAll(opts) {
                     apiKey: opts.apiKey,
                     verbose: opts.verbose ?? false,
                     prompt,
-                    retryCommand: "npx @tiny-fish/cli connect --all",
+                    retryCommand: 'npx @tiny-fish/cli connect --all',
                 });
-                return outcome === "cli_verified" ? 0 : 1;
+                return outcome === 'cli_verified' ? 0 : 1;
             }
             catch (error) {
                 if (!(error instanceof ConnectInterruptedError))
                     throw error;
-                errLine("Setup interrupted — run the command again to finish.");
+                errLine('Setup interrupted — run the command again to finish.');
                 process.exitCode = 130;
                 return 130;
             }
         }
-        const stale = results.filter((r) => r.outcome === "stale_config");
-        outLine("");
+        const stale = results.filter((r) => r.outcome === 'stale_config');
+        outLine('');
         outLine(stale.length > 0
-            ? `No runnable harness found. Reinstall ${stale.map((r) => DISPLAY_NAMES[r.harness]).join(", ")}, or install one of: ${ALL_HARNESSES.join(", ")}`
-            : "No supported harness found. Install one of: " + ALL_HARNESSES.join(", "));
+            ? `No runnable harness found. Reinstall ${stale.map((r) => DISPLAY_NAMES[r.harness]).join(', ')}, or install one of: ${ALL_HARNESSES.join(', ')}`
+            : 'No supported harness found. Install one of: ' + ALL_HARNESSES.join(', '));
         if (!opts.uninstall)
-            outLine("Then run: npx @tiny-fish/cli connect --all");
+            outLine('Then run: npx @tiny-fish/cli connect --all');
         return 1;
     }
     if (!opts.dryRun && !opts.uninstall) {
@@ -640,13 +646,13 @@ export async function runConnectAll(opts) {
         emitNotice();
     }
     const exitCode = computeExitCode(results);
-    const interrupted = results.some((r) => r.outcome === "interrupted");
+    const interrupted = results.some((r) => r.outcome === 'interrupted');
     if (exitCode === 0 &&
         !interrupted &&
         !opts.dryRun &&
         !opts.uninstall &&
         results.some((r) => r.installed)) {
-        outLine("");
+        outLine('');
         if (isTTY && !opts.noLaunch && (await launchFirstTask(results))) {
             return exitCode;
         }
@@ -654,17 +660,17 @@ export async function runConnectAll(opts) {
     }
     return exitCode;
 }
-export const FIRST_TASK_PROMPT = "My TinyFish setup just finished — verify it with a real run. Use the MCP server named " +
-    "`tinyfish` for every TinyFish tool call; if another TinyFish server is also registered, still " +
+export const FIRST_TASK_PROMPT = 'My TinyFish setup just finished — verify it with a real run. Use the MCP server named ' +
+    '`tinyfish` for every TinyFish tool call; if another TinyFish server is also registered, still ' +
     "use `tinyfish` and do not ask me which. Then use the TinyFish search tool to find today's " +
-    "top Hacker News story, fetch that page with the TinyFish fetch tool, and give me a two-line " +
-    "summary. Show which tools you call. If a tool call comes back blocked or not approved, tell " +
-    "me which tool needs approval and how to grant it, then wait for me instead of abandoning the " +
-    "task.";
+    'top Hacker News story, fetch that page with the TinyFish fetch tool, and give me a two-line ' +
+    'summary. Show which tools you call. If a tool call comes back blocked or not approved, tell ' +
+    'me which tool needs approval and how to grant it, then wait for me instead of abandoning the ' +
+    'task.';
 // Launchable seeded agents, best-first — cursor-agent shares ~/.cursor/mcp.json with the IDE.
 const LAUNCHERS = [
-    { harness: "cursor", args: [FIRST_TASK_PROMPT] },
-    { harness: "claude-code", args: [FIRST_TASK_PROMPT] },
+    { harness: 'cursor', args: [FIRST_TASK_PROMPT] },
+    { harness: 'claude-code', args: [FIRST_TASK_PROMPT] },
 ];
 async function launchFirstTask(results) {
     const candidates = LAUNCHERS.filter((l) => results.some((r) => r.harness === l.harness && r.installed) &&
@@ -674,7 +680,7 @@ async function launchFirstTask(results) {
     // Several installs: ask rather than pick a favorite; plain enter skips.
     let chosen = candidates[0];
     if (candidates.length > 1) {
-        const menu = candidates.map((l, i) => `[${i + 1}] ${DISPLAY_NAMES[l.harness]}`).join("  ");
+        const menu = candidates.map((l, i) => `[${i + 1}] ${DISPLAY_NAMES[l.harness]}`).join('  ');
         const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
         let answer;
         try {
@@ -694,6 +700,6 @@ async function launchFirstTask(results) {
     if (!chosen)
         return false;
     outLine(`Starting ${DISPLAY_NAMES[chosen.harness]} with your first TinyFish task...`);
-    const result = spawn.sync(HARNESS_COMMANDS[chosen.harness], chosen.args, { stdio: "inherit" });
+    const result = spawn.sync(HARNESS_COMMANDS[chosen.harness], chosen.args, { stdio: 'inherit' });
     return !result.error;
 }