@tiny-fish/cli 0.31.1-next.269 → 0.31.1-next.272

package/dist/commands/connect.js

@@ -665,13 +665,14 @@ function parseMcpUrlOption(options) {
     }
     return { mcpUrl, attemptId };
 }
-async function connectAllPath(options, mcpUrl) {
+async function connectAllPath(options, mcpUrl, attemptId) {
     if (options.launch) {
         throw new Error('--launch is not supported with --all. Connect a single client to launch it.');
     }
     const exitCode = await runConnectAll({
         apiKey: options.apiKey,
         mcpUrl,
+        attemptId,
         dryRun: options.dryRun ?? false,
         uninstall: options.uninstall ?? false,
         noLaunch: options.skipLaunch === true,
@@ -681,7 +682,7 @@ async function connectAllPath(options, mcpUrl) {
     if (!process.exitCode)
         process.exitCode = exitCode;
 }
-async function connectPickPath(options, mcpUrl) {
+async function connectPickPath(options, mcpUrl, attemptId) {
     if (options.launch) {
         throw new Error('--launch is not supported with --all. Connect a single client to launch it.');
     }
@@ -692,6 +693,7 @@ async function connectPickPath(options, mcpUrl) {
     const exitCode = await runConnectAll({
         apiKey: options.apiKey,
         mcpUrl,
+        attemptId,
         dryRun: false,
         uninstall: false,
         pick: humanInitiated,
@@ -743,14 +745,14 @@ export function registerConnect(program) {
             if (client) {
                 throw new Error('Pass either a client or --all, not both.');
             }
-            await connectAllPath(options, mcpUrl);
+            await connectAllPath(options, mcpUrl, attemptId);
             return;
         }
         if (options.dryRun || options.uninstall || options.skipLaunch) {
             throw new Error('--dry-run, --uninstall and --skip-launch are only supported with --all.');
         }
         if (!client) {
-            await connectPickPath(options, mcpUrl);
+            await connectPickPath(options, mcpUrl, attemptId);
             return;
         }
         await connectSingleClient(client, options, mcpUrl, attemptId);

package/dist/lib/connect-all-auth.d.ts

@@ -0,0 +1,19 @@
+import { type Prompt } from './connect-fallback.js';
+import type { HarnessResultBase, HarnessRunResult } from './connect-all.js';
+export declare const OAUTH_SIGN_IN_TIMEOUT_MS = 90000;
+interface AuthGateOutcome {
+    result?: HarnessRunResult;
+    headlessAuth: boolean;
+    spentBrowserSlot: boolean;
+}
+export declare function mapConnectError(base: HarnessResultBase, e: unknown, oauthBudget: {
+    spent: boolean;
+}, spentBrowserSlot: boolean, fixCommand: string): HarnessRunResult;
+export declare function authGate(base: HarnessResultBase, oauthBudget: {
+    spent: boolean;
+}, fixCommand: string, ctx: {
+    prompt: Prompt | undefined;
+    isTTY: boolean;
+    keyed: boolean;
+}): Promise<AuthGateOutcome>;
+export {};

package/dist/lib/connect-all-auth.js

@@ -0,0 +1,110 @@
+import { HARNESS_CAPABILITIES, NATIVE_BY_HARNESS } from './connect-clients.js';
+import { ConnectInterruptedError, ConnectStepError, SignInTimeoutError, } from './connect-runtime.js';
+import { ALL_HARNESSES, HARNESS_DISPLAY_NAMES as DISPLAY_NAMES, } from './harness-detect.js';
+import { errLine } from './output.js';
+// Must undercut agent tool-call budgets (Claude Code Bash defaults to 120s).
+export const OAUTH_SIGN_IN_TIMEOUT_MS = 90_000;
+// 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',
+]);
+// These failures land before any browser could have opened.
+const NO_BROWSER_REASONS = new Set([
+    ...TOO_OLD_REASONS,
+    'harness_not_installed',
+    'command_not_found',
+]);
+// Derived: these block `connect` on a browser sign-in when keyless.
+const BROWSER_SIGN_IN = new Set(ALL_HARNESSES.filter((harness) => {
+    const native = NATIVE_BY_HARNESS.get(harness);
+    return !!native?.loginArgs || !!native?.oauthInAdd;
+}));
+// Derived: these refuse a keyless install, so no sign-in helps.
+const KEY_REQUIRED = new Set(ALL_HARNESSES.filter((harness) => !!NATIVE_BY_HARNESS.get(harness)?.keyRequired));
+function headlessGate(base, oauthBudget, fixCommand) {
+    const { harness } = base;
+    // A CLI-login sign-in is interactive-only — unboundable headless.
+    if (HARNESS_CAPABILITIES[harness].signInViaCliLogin) {
+        return {
+            result: { ...base, outcome: 'auth_pending', fixCommand },
+            headlessAuth: false,
+            spentBrowserSlot: false,
+        };
+    }
+    let spentBrowserSlot = false;
+    if (BROWSER_SIGN_IN.has(harness)) {
+        // One browser sign-in per run; the rest wait for a re-run.
+        if (oauthBudget.spent) {
+            return {
+                result: { ...base, outcome: 'auth_pending', fixCommand },
+                headlessAuth: false,
+                spentBrowserSlot: false,
+            };
+        }
+        oauthBudget.spent = true;
+        spentBrowserSlot = true;
+        errLine(`${DISPLAY_NAMES[harness]} needs a browser sign-in — finish it when your browser ` +
+            `opens; waiting up to ${OAUTH_SIGN_IN_TIMEOUT_MS / 1000} seconds.`);
+    }
+    return { headlessAuth: true, spentBrowserSlot };
+}
+/** Null: proceed. A result: settle with it. */
+async function awaitSignInPrompt(base, prompt, fixCommand) {
+    errLine(`step: waiting for browser sign-in to TinyFish for ${DISPLAY_NAMES[base.harness]}`);
+    try {
+        await prompt(`Press enter to open the browser and sign in to TinyFish for ${DISPLAY_NAMES[base.harness]}... `);
+        return null;
+    }
+    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.');
+            process.exitCode = 130;
+            return { ...base, outcome: 'interrupted', fixCommand };
+        }
+        return { ...base, outcome: 'no_tty_auth_skip', fixCommand };
+    }
+}
+export function mapConnectError(base, e, oauthBudget, spentBrowserSlot, fixCommand) {
+    if (e instanceof SignInTimeoutError) {
+        return {
+            ...base,
+            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)) {
+        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' };
+    }
+    // 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', errorMessage: e.message, fixCommand };
+    }
+    return {
+        ...base,
+        outcome: 'failed',
+        errorMessage: e instanceof Error ? e.message : String(e),
+        fixCommand,
+    };
+}
+export async function authGate(base, oauthBudget, fixCommand, ctx) {
+    if (!ctx.isTTY && !ctx.keyed) {
+        return headlessGate(base, oauthBudget, fixCommand);
+    }
+    // Key-required harnesses refuse below; offering a browser sign-in would mislead.
+    if (ctx.isTTY && !ctx.keyed && ctx.prompt && !KEY_REQUIRED.has(base.harness)) {
+        const settled = await awaitSignInPrompt(base, ctx.prompt, fixCommand);
+        if (settled)
+            return { result: settled, headlessAuth: false, spentBrowserSlot: false };
+    }
+    return { headlessAuth: false, spentBrowserSlot: false };
+}

package/dist/lib/connect-all-summary.d.ts

@@ -0,0 +1,8 @@
+import type { HarnessRunResult } from './connect-all.js';
+/** A stale config dir is a detection signal with nothing behind it. */
+export declare function actionable(result: HarnessRunResult): boolean;
+/** One line for every harness: seven near-identical paragraphs is what this replaces. */
+export declare function reloadHint(results: HarnessRunResult[]): string | undefined;
+/** Absent and unpicked harnesses are noise once something real happened. */
+export declare function renderSummary(results: HarnessRunResult[], uninstall: boolean): string[];
+export declare function computeExitCode(results: HarnessRunResult[]): number;

package/dist/lib/connect-all-summary.js

@@ -0,0 +1,148 @@
+import { HARNESS_CAPABILITIES } from './connect-clients.js';
+import { finishSetupCommand } from './connect-runtime.js';
+import { HARNESS_COMMANDS, HARNESS_DISPLAY_NAMES as DISPLAY_NAMES, RELOAD_ACTION, } from './harness-detect.js';
+// 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',
+]);
+/** A stale config dir is a detection signal with nothing behind it. */
+export function actionable(result) {
+    return result.detected && result.outcome !== 'stale_config';
+}
+function absentSummaryLine(result, uninstall) {
+    const name = DISPLAY_NAMES[result.harness];
+    const next = uninstall
+        ? 'nothing to remove'
+        : `Install ${name}, then run: tinyfish connect ${result.harness}`;
+    if (result.outcome === 'not_installed') {
+        return `- ${name} — not installed (\`${HARNESS_COMMANDS[result.harness]}\` is on PATH but does not run). ${next}`;
+    }
+    if (!result.detected) {
+        return `- ${name} — not detected (no \`${HARNESS_COMMANDS[result.harness]}\` on PATH, no ${result.configPath}). ${next}`;
+    }
+    return undefined;
+}
+function skippedSummaryLine(result) {
+    const name = DISPLAY_NAMES[result.harness];
+    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') {
+        return `… ${name} — not reached, the run stopped early. Fix: ${result.fixCommand}`;
+    }
+    if (result.outcome === 'dry_run') {
+        return `… ${name} — ${result.fixCommand}`;
+    }
+    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') {
+        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 === 'interrupted') {
+        return `✗ ${name} — interrupted before finishing. Fix: ${result.fixCommand}`;
+    }
+    if (result.outcome === 'harness_too_old') {
+        return `… ${name} — needs a newer ${name}: ${result.errorMessage} Fix, once upgraded: ${result.fixCommand}`;
+    }
+    if (result.outcome === 'failed') {
+        return `✗ ${name} — install failed: ${result.errorMessage}. Fix: ${result.fixCommand}`;
+    }
+    return undefined;
+}
+function uninstallSummaryLine(result) {
+    const name = DISPLAY_NAMES[result.harness];
+    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') {
+        return `… ${name} — no tinyfish entry found, nothing removed`;
+    }
+    if (result.outcome === 'uninstalled') {
+        if (!result.errorMessage)
+            return `✓ ${name} — removed`;
+        // The removal itself worked; the note is advice, not a failed removal.
+        if (!result.removalFailed)
+            return `⚠ ${name} — removed, but ${result.errorMessage}`;
+        return `✗ ${name} — ${result.errorMessage} Fix: ${result.fixCommand}`;
+    }
+    return undefined;
+}
+function installedSummaryLine(result) {
+    const name = DISPLAY_NAMES[result.harness];
+    // The summary is what users read; stderr hints scroll away.
+    if (result.postInstallFailed) {
+        return (`⚠ ${name} — installed, but a finishing step failed. ` +
+            `Fix: ${finishSetupCommand(result.harness)}`);
+    }
+    // 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';
+    if (authDeferred || result.verifyOk === false) {
+        const reason = authDeferred
+            ? '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}`;
+}
+function summaryLine(result, uninstall) {
+    return (absentSummaryLine(result, uninstall) ??
+        skippedSummaryLine(result) ??
+        uninstallSummaryLine(result) ??
+        installedSummaryLine(result));
+}
+/** One line for every harness: seven near-identical paragraphs is what this replaces. */
+export function reloadHint(results) {
+    const byAction = new Map();
+    for (const result of results) {
+        if (!result.installed)
+            continue;
+        const action = RELOAD_ACTION[result.harness];
+        byAction.set(action, [...(byAction.get(action) ?? []), DISPLAY_NAMES[result.harness]]);
+    }
+    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('; ')}.`;
+}
+/** Absent and unpicked harnesses are noise once something real happened. */
+export 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 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(', ')}`);
+    return lines;
+}
+export function computeExitCode(results) {
+    // Flag-independent: uninstall interrupts have no other 130 site.
+    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.removalFailed))
+        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');
+    if (attempted.length === 0)
+        return 0;
+    return attempted.some((r) => r.outcome === 'installed') ? 0 : 1;
+}

package/dist/lib/connect-all-uninstall.d.ts

@@ -0,0 +1,5 @@
+import { type Harness } from './harness-detect.js';
+import type { HarnessRunResult } from './connect-all.js';
+export declare function planText(harness: Harness, mcpUrl: string, apiKey?: string): string;
+export declare function uninstallPlanText(harness: Harness): string;
+export declare function uninstallHarness(harness: Harness, configPath: string, verbose: boolean, binaryOnPath: boolean): HarnessRunResult;

package/dist/lib/connect-all-uninstall.js

@@ -0,0 +1,188 @@
+import { clearConnectContext, connectContextState } from './auth.js';
+import { NATIVE_BY_HARNESS, openclawSkillUninstall } from './connect-clients.js';
+import { ConnectInterruptedError, spawnRemoval } from './connect-runtime.js';
+import { removeCursorMcpServer, planCursorWrite } from './cursor-config.js';
+import { HERMES_KEY_VAR, hermesEnvPath, removeHermesKey, resolveHermesHome } from './hermes-env.js';
+import { HARNESS_DISPLAY_NAMES as DISPLAY_NAMES } from './harness-detect.js';
+import { errLine } from './output.js';
+// 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';
+export function planText(harness, mcpUrl, apiKey) {
+    if (harness === 'cursor')
+        return planCursorWrite(mcpUrl, apiKey);
+    // Only the keyed path seeds the .env; a keyless Hermes install writes nothing.
+    if (harness === 'hermes' && apiKey) {
+        return `would run \`tinyfish connect hermes\` (harness-owned MCP write; the CLI writes ${HERMES_KEY_VAR} to Hermes' .env)`;
+    }
+    return `would run \`tinyfish connect ${harness}\` (harness-owned MCP write; no local file touched by the CLI)`;
+}
+export function uninstallPlanText(harness) {
+    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)`;
+    }
+    // Hermes alone leaves a seeded key behind; `mcp remove` never clears it.
+    const envNote = harness === 'hermes' ? ` and clear ${HERMES_KEY_VAR} from Hermes' .env` : '';
+    return `would run \`${uninstallPointer(harness)}\`${envNote}`;
+}
+/** Undefined: no harness-CLI removal exists (opencode). */
+function uninstallRuns(harness) {
+    if (harness === 'openclaw') {
+        const removal = openclawSkillUninstall();
+        return { command: removal.command, runs: [removal.args], timeoutMs: removal.timeoutMs };
+    }
+    const native = NATIVE_BY_HARNESS.get(harness);
+    if (!native || native.removals.length === 0)
+        return undefined;
+    return { command: native.command, runs: native.removals.map((r) => r.args) };
+}
+/** Derived from the same args the spawn runs, so the advice cannot drift. */
+function uninstallPointer(harness) {
+    const removal = uninstallRuns(harness);
+    if (!removal)
+        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);
+}
+/** `mcp remove` leaves this behind; a stale value gets silently reused. */
+function clearHermesEnvKey() {
+    const home = resolveHermesHome();
+    const retry = 're-run `tinyfish connect --all --uninstall`';
+    if (!home) {
+        return (`could not locate Hermes' home, so ${HERMES_KEY_VAR} may still be set in its .env. ` +
+            `A stale key is reused by the next install: delete that line, or ${retry}.`);
+    }
+    try {
+        removeHermesKey(home);
+        return undefined;
+    }
+    catch (e) {
+        const detail = e instanceof Error ? e.message : String(e);
+        return (`could not clear ${HERMES_KEY_VAR} from ${hermesEnvPath(home)} (${detail}). ` +
+            `A stale key is reused by the next install: delete that line, or ${retry}.`);
+    }
+}
+/** Kept on purpose: the entry survives and still interpolates this variable. */
+function hermesKeyKeptAdvisory() {
+    return (`left ${HERMES_KEY_VAR} in Hermes' .env because the entry was not removed. ` +
+        'Run the command above, then re-run `tinyfish connect --all --uninstall` to clear it.');
+}
+function runRemovalCommands(detection, removal, verbose) {
+    const { harness } = detection;
+    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}`);
+            }
+            // Same binary: a spawn-level failure (ENOENT, EPERM) repeats identically.
+            if (result.error) {
+                return {
+                    ...detection,
+                    outcome: 'uninstalled',
+                    removalFailed: true,
+                    errorMessage: `could not run \`${removal.command} ${args.join(' ')}\` (${result.error.message}) — nothing removed.`,
+                    fixCommand: uninstallPointer(harness),
+                };
+            }
+            // Non-zero is ambiguous (nothing registered vs real failure) — the pointer covers both.
+            if (result.status === 0)
+                removed = true;
+        }
+    }
+    catch (e) {
+        if (e instanceof ConnectInterruptedError) {
+            return {
+                ...detection,
+                outcome: 'interrupted',
+                fixCommand: 'tinyfish connect --all --uninstall',
+            };
+        }
+        throw e;
+    }
+    return { kind: 'continue', removed };
+}
+function uninstallViaCommands(detection, verbose, binaryOnPath) {
+    const { harness } = detection;
+    const removal = uninstallRuns(harness);
+    if (!removal) {
+        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) {
+        return {
+            ...detection,
+            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 ran = runRemovalCommands(detection, removal, verbose);
+    if (!('kind' in ran))
+        return ran;
+    if (ran.removed) {
+        // Kept marker makes doctor emit a registration-lost repair that undoes this.
+        clearConnectContext(harness);
+        return { ...detection, outcome: 'uninstalled' };
+    }
+    if (!connectedBefore)
+        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).',
+        fixCommand: `Retry by hand: ${uninstallPointer(harness)}`,
+    };
+}
+function uninstallCursor(detection) {
+    let result;
+    try {
+        result = removeCursorMcpServer();
+    }
+    catch (e) {
+        result = { status: 'corrupt_skip', error: e instanceof Error ? e.message : String(e) };
+    }
+    if (result.status === 'corrupt_skip') {
+        return {
+            ...detection,
+            outcome: 'uninstalled',
+            removalFailed: true,
+            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',
+        };
+    }
+    if (result.status === 'unchanged') {
+        return { ...detection, outcome: 'uninstall_noop' };
+    }
+    clearConnectContext('cursor');
+    return { ...detection, outcome: 'uninstalled' };
+}
+export function uninstallHarness(harness, configPath, verbose, binaryOnPath) {
+    const detection = { harness, detected: true, configPath, installed: false };
+    const result = harness === 'cursor'
+        ? uninstallCursor(detection)
+        : uninstallViaCommands(detection, verbose, binaryOnPath);
+    if (harness !== 'hermes')
+        return result;
+    // Clearing a key the entry still references would break a working install.
+    const removed = !result.removalFailed &&
+        (result.outcome === 'uninstalled' || result.outcome === 'uninstall_noop');
+    const advisory = removed ? clearHermesEnvKey() : hermesKeyKeptAdvisory();
+    if (!advisory)
+        return result;
+    // Appended, never replacing: an advisory must not hide the removal's message.
+    return {
+        ...result,
+        errorMessage: result.errorMessage ? `${result.errorMessage} ${advisory}` : advisory,
+    };
+}

package/dist/lib/connect-all.d.ts

@@ -1,3 +1,25 @@
+import { type Harness } from './harness-detect.js';
+import { type VerifyDepth } from './verify.js';
+export type Outcome = 'not_detected' | 'not_installed' | 'stale_config' | 'installed' | 'failed' | 'harness_too_old' | 'interrupted' | 'auth_pending' | 'no_tty_auth_skip' | 'uninstalled' | 'uninstall_noop' | 'uninstall_pointer' | 'dry_run' | 'not_reached' | 'deselected';
+export type HarnessResultBase = {
+    harness: Harness;
+    detected: boolean;
+    configPath: string;
+    installed: boolean;
+};
+export interface HarnessRunResult extends HarnessResultBase {
+    outcome: Outcome;
+    fixCommand?: string;
+    errorMessage?: string;
+    verifyDepth?: VerifyDepth;
+    verifyOk?: boolean;
+    verifyReason?: string;
+    keyAuthed?: boolean;
+    /** MCP works, but a finishing step (CLI/skill/auth) failed. */
+    postInstallFailed?: boolean;
+    /** Removal itself failed; an advisory note alone must not exit 1. */
+    removalFailed?: boolean;
+}
 export interface ConnectAllOptions {
     apiKey?: string;
     mcpUrl: string;
@@ -9,6 +31,8 @@ export interface ConnectAllOptions {
     pick?: boolean;
     /** Inherit subprocess stdio instead of replaying it only on failure. */
     verbose?: boolean;
+    /** Setup-page id riding in on --url; joins "copied the command" to this run. */
+    attemptId?: string;
 }
 export declare function runConnectAll(opts: ConnectAllOptions): Promise<number>;
 export declare const FIRST_TASK_PROMPT: string;

package/dist/lib/connect-all.js

@@ -1,51 +1,24 @@
 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 { loadConfig, validatedApiKey } from './auth.js';
 import { installTinyFishCli, } from './cli-install.js';
-import { HARNESS_CAPABILITIES, NATIVE_BY_HARNESS, openclawSkillUninstall, } from './connect-clients.js';
+import { authGate, mapConnectError, OAUTH_SIGN_IN_TIMEOUT_MS } from './connect-all-auth.js';
+import { actionable, computeExitCode, reloadHint, renderSummary } from './connect-all-summary.js';
+import { planText, uninstallHarness, uninstallPlanText } from './connect-all-uninstall.js';
+import { HARNESS_CAPABILITIES, NATIVE_BY_HARNESS } from './connect-clients.js';
 import { createStdinPrompt, runCliFallback } from './connect-fallback.js';
-import { ConnectInterruptedError, ConnectStepError, SignInTimeoutError, finishSetupCommand, spawnRemoval, } from './connect-runtime.js';
+import { ConnectInterruptedError } from './connect-runtime.js';
 import { pickHarnesses } from './connect-picker.js';
-import { HERMES_KEY_VAR, hermesEnvPath, removeHermesKey, resolveHermesHome } from './hermes-env.js';
-import { commandOnPath, detectInstalledHarnesses, HARNESS_COMMANDS, HARNESS_DISPLAY_NAMES as DISPLAY_NAMES, ALL_HARNESSES, RELOAD_ACTION, } from './harness-detect.js';
+import { commandOnPath, detectInstalledHarnesses, HARNESS_COMMANDS, HARNESS_DISPLAY_NAMES as DISPLAY_NAMES, ALL_HARNESSES, } 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 { sendSetupCompleted, sendSetupStarted, } 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',
-]);
-// These failures land before any browser could have opened.
-const NO_BROWSER_REASONS = new Set([
-    ...TOO_OLD_REASONS,
-    '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 = '  ';
-// 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.
-const BROWSER_SIGN_IN = new Set(ALL_HARNESSES.filter((harness) => {
-    const native = NATIVE_BY_HARNESS.get(harness);
-    return !!native?.loginArgs || !!native?.oauthInAdd;
-}));
-// Derived: these refuse a keyless install, so no sign-in helps.
-const KEY_REQUIRED = new Set(ALL_HARNESSES.filter((harness) => !!NATIVE_BY_HARNESS.get(harness)?.keyRequired));
 // 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';
 // A new harness fails to compile until wired here.
 const HARNESS_CONNECTORS = {
     'claude-code': connectClaudeCode,
@@ -104,274 +77,6 @@ async function verifyHarness(harness, mcpUrl, keyed, apiKey) {
         return { depth: 'health+auth', ok: false, reason: 'no stored API key' };
     return verifyMcpAuth(apiKey);
 }
-function planText(harness, mcpUrl, apiKey) {
-    if (harness === 'cursor')
-        return planCursorWrite(mcpUrl, apiKey);
-    // Only the keyed path seeds the .env; a keyless Hermes install writes nothing.
-    if (harness === 'hermes' && apiKey) {
-        return `would run \`tinyfish connect hermes\` (harness-owned MCP write; the CLI writes ${HERMES_KEY_VAR} to Hermes' .env)`;
-    }
-    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 (!uninstallRuns(harness)) {
-        return `would print \`${uninstallPointer(harness)}\` (no removal command exists)`;
-    }
-    // Hermes alone leaves a seeded key behind; `mcp remove` never clears it.
-    const envNote = harness === 'hermes' ? ` and clear ${HERMES_KEY_VAR} from Hermes' .env` : '';
-    return `would run \`${uninstallPointer(harness)}\`${envNote}`;
-}
-/** Undefined: no harness-CLI removal exists (opencode). */
-function uninstallRuns(harness) {
-    if (harness === 'openclaw') {
-        const removal = openclawSkillUninstall();
-        return { command: removal.command, runs: [removal.args], timeoutMs: removal.timeoutMs };
-    }
-    const native = NATIVE_BY_HARNESS.get(harness);
-    if (!native || native.removals.length === 0)
-        return undefined;
-    return { command: native.command, runs: native.removals.map((r) => r.args) };
-}
-/** Derived from the same args the spawn runs, so the advice cannot drift. */
-function uninstallPointer(harness) {
-    const removal = uninstallRuns(harness);
-    if (!removal)
-        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);
-}
-/** `mcp remove` leaves this behind; a stale value gets silently reused. */
-function clearHermesEnvKey() {
-    const home = resolveHermesHome();
-    const retry = 're-run `tinyfish connect --all --uninstall`';
-    if (!home) {
-        return (`could not locate Hermes' home, so ${HERMES_KEY_VAR} may still be set in its .env. ` +
-            `A stale key is reused by the next install: delete that line, or ${retry}.`);
-    }
-    try {
-        removeHermesKey(home);
-        return undefined;
-    }
-    catch (e) {
-        const detail = e instanceof Error ? e.message : String(e);
-        return (`could not clear ${HERMES_KEY_VAR} from ${hermesEnvPath(home)} (${detail}). ` +
-            `A stale key is reused by the next install: delete that line, or ${retry}.`);
-    }
-}
-/** Kept on purpose: the entry survives and still interpolates this variable. */
-function hermesKeyKeptAdvisory() {
-    return (`left ${HERMES_KEY_VAR} in Hermes' .env because the entry was not removed. ` +
-        'Run the command above, then re-run `tinyfish connect --all --uninstall` to clear it.');
-}
-function runRemovalCommands(detection, removal, verbose) {
-    const { harness } = detection;
-    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}`);
-            }
-            // Same binary: a spawn-level failure (ENOENT, EPERM) repeats identically.
-            if (result.error) {
-                return {
-                    ...detection,
-                    outcome: 'uninstalled',
-                    removalFailed: true,
-                    errorMessage: `could not run \`${removal.command} ${args.join(' ')}\` (${result.error.message}) — nothing removed.`,
-                    fixCommand: uninstallPointer(harness),
-                };
-            }
-            // Non-zero is ambiguous (nothing registered vs real failure) — the pointer covers both.
-            if (result.status === 0)
-                removed = true;
-        }
-    }
-    catch (e) {
-        if (e instanceof ConnectInterruptedError) {
-            return {
-                ...detection,
-                outcome: 'interrupted',
-                fixCommand: 'tinyfish connect --all --uninstall',
-            };
-        }
-        throw e;
-    }
-    return { kind: 'continue', removed };
-}
-function uninstallViaCommands(detection, verbose, binaryOnPath) {
-    const { harness } = detection;
-    const removal = uninstallRuns(harness);
-    if (!removal) {
-        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) {
-        return {
-            ...detection,
-            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 ran = runRemovalCommands(detection, removal, verbose);
-    if (!('kind' in ran))
-        return ran;
-    if (ran.removed) {
-        // Kept marker makes doctor emit a registration-lost repair that undoes this.
-        clearConnectContext(harness);
-        return { ...detection, outcome: 'uninstalled' };
-    }
-    if (!connectedBefore)
-        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).',
-        fixCommand: `Retry by hand: ${uninstallPointer(harness)}`,
-    };
-}
-function uninstallCursor(detection) {
-    let result;
-    try {
-        result = removeCursorMcpServer();
-    }
-    catch (e) {
-        result = { status: 'corrupt_skip', error: e instanceof Error ? e.message : String(e) };
-    }
-    if (result.status === 'corrupt_skip') {
-        return {
-            ...detection,
-            outcome: 'uninstalled',
-            removalFailed: true,
-            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',
-        };
-    }
-    if (result.status === 'unchanged') {
-        return { ...detection, outcome: 'uninstall_noop' };
-    }
-    clearConnectContext('cursor');
-    return { ...detection, outcome: 'uninstalled' };
-}
-function removeHarnessRegistration(harness, configPath, verbose, binaryOnPath) {
-    const detection = { harness, detected: true, configPath, installed: false };
-    if (harness === 'cursor')
-        return uninstallCursor(detection);
-    return uninstallViaCommands(detection, verbose, binaryOnPath);
-}
-function uninstallHarness(harness, configPath, verbose, binaryOnPath) {
-    const result = removeHarnessRegistration(harness, configPath, verbose, binaryOnPath);
-    if (harness !== 'hermes')
-        return result;
-    // Clearing a key the entry still references would break a working install.
-    const removed = !result.removalFailed &&
-        (result.outcome === 'uninstalled' || result.outcome === 'uninstall_noop');
-    const advisory = removed ? clearHermesEnvKey() : hermesKeyKeptAdvisory();
-    if (!advisory)
-        return result;
-    // Appended, never replacing: an advisory must not hide the removal's message.
-    return {
-        ...result,
-        errorMessage: result.errorMessage ? `${result.errorMessage} ${advisory}` : advisory,
-    };
-}
-function headlessGate(base, oauthBudget, fixCommand) {
-    const { harness } = base;
-    // A CLI-login sign-in is interactive-only — unboundable headless.
-    if (HARNESS_CAPABILITIES[harness].signInViaCliLogin) {
-        return {
-            result: { ...base, outcome: 'auth_pending', fixCommand },
-            headlessAuth: false,
-            spentBrowserSlot: false,
-        };
-    }
-    let spentBrowserSlot = false;
-    if (BROWSER_SIGN_IN.has(harness)) {
-        // One browser sign-in per run; the rest wait for a re-run.
-        if (oauthBudget.spent) {
-            return {
-                result: { ...base, outcome: 'auth_pending', fixCommand },
-                headlessAuth: false,
-                spentBrowserSlot: false,
-            };
-        }
-        oauthBudget.spent = true;
-        spentBrowserSlot = true;
-        errLine(`${DISPLAY_NAMES[harness]} needs a browser sign-in — finish it when your browser ` +
-            `opens; waiting up to ${OAUTH_SIGN_IN_TIMEOUT_MS / 1000} seconds.`);
-    }
-    return { headlessAuth: true, spentBrowserSlot };
-}
-/** Null: proceed. A result: settle with it. */
-async function awaitSignInPrompt(base, prompt, fixCommand) {
-    errLine(`step: waiting for browser sign-in to TinyFish for ${DISPLAY_NAMES[base.harness]}`);
-    try {
-        await prompt(`Press enter to open the browser and sign in to TinyFish for ${DISPLAY_NAMES[base.harness]}... `);
-        return null;
-    }
-    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.');
-            process.exitCode = 130;
-            return { ...base, outcome: 'interrupted', fixCommand };
-        }
-        return { ...base, outcome: 'no_tty_auth_skip', fixCommand };
-    }
-}
-function mapConnectError(base, e, oauthBudget, spentBrowserSlot, fixCommand) {
-    if (e instanceof SignInTimeoutError) {
-        return {
-            ...base,
-            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)) {
-        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' };
-    }
-    // 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', errorMessage: e.message, fixCommand };
-    }
-    return {
-        ...base,
-        outcome: 'failed',
-        errorMessage: e instanceof Error ? e.message : String(e),
-        fixCommand,
-    };
-}
-async function authGate(base, oauthBudget, fixCommand, ctx) {
-    if (!ctx.isTTY && !ctx.keyed) {
-        return headlessGate(base, oauthBudget, fixCommand);
-    }
-    // Key-required harnesses refuse below; offering a browser sign-in would mislead.
-    if (ctx.isTTY && !ctx.keyed && ctx.prompt && !KEY_REQUIRED.has(base.harness)) {
-        const settled = await awaitSignInPrompt(base, ctx.prompt, fixCommand);
-        if (settled)
-            return { result: settled, headlessAuth: false, spentBrowserSlot: false };
-    }
-    return { headlessAuth: false, spentBrowserSlot: false };
-}
 /** The non-connect settlements: undetected, stale, dry-run, uninstall. */
 function settleWithoutConnect(detection, opts, base) {
     const { harness, configPath } = detection;
@@ -443,122 +148,6 @@ async function processHarness(detection, opts, prompt, oauthBudget, hoistedCliIn
         postInstallFailed,
     };
 }
-function absentSummaryLine(result, uninstall) {
-    const name = DISPLAY_NAMES[result.harness];
-    const next = uninstall
-        ? 'nothing to remove'
-        : `Install ${name}, then run: tinyfish connect ${result.harness}`;
-    if (result.outcome === 'not_installed') {
-        return `- ${name} — not installed (\`${HARNESS_COMMANDS[result.harness]}\` is on PATH but does not run). ${next}`;
-    }
-    if (!result.detected) {
-        return `- ${name} — not detected (no \`${HARNESS_COMMANDS[result.harness]}\` on PATH, no ${result.configPath}). ${next}`;
-    }
-    return undefined;
-}
-function skippedSummaryLine(result) {
-    const name = DISPLAY_NAMES[result.harness];
-    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') {
-        return `… ${name} — not reached, the run stopped early. Fix: ${result.fixCommand}`;
-    }
-    if (result.outcome === 'dry_run') {
-        return `… ${name} — ${result.fixCommand}`;
-    }
-    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') {
-        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 === 'interrupted') {
-        return `✗ ${name} — interrupted before finishing. Fix: ${result.fixCommand}`;
-    }
-    if (result.outcome === 'harness_too_old') {
-        return `… ${name} — needs a newer ${name}: ${result.errorMessage} Fix, once upgraded: ${result.fixCommand}`;
-    }
-    if (result.outcome === 'failed') {
-        return `✗ ${name} — install failed: ${result.errorMessage}. Fix: ${result.fixCommand}`;
-    }
-    return undefined;
-}
-function uninstallSummaryLine(result) {
-    const name = DISPLAY_NAMES[result.harness];
-    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') {
-        return `… ${name} — no tinyfish entry found, nothing removed`;
-    }
-    if (result.outcome === 'uninstalled') {
-        if (!result.errorMessage)
-            return `✓ ${name} — removed`;
-        // The removal itself worked; the note is advice, not a failed removal.
-        if (!result.removalFailed)
-            return `⚠ ${name} — removed, but ${result.errorMessage}`;
-        return `✗ ${name} — ${result.errorMessage} Fix: ${result.fixCommand}`;
-    }
-    return undefined;
-}
-function installedSummaryLine(result) {
-    const name = DISPLAY_NAMES[result.harness];
-    // The summary is what users read; stderr hints scroll away.
-    if (result.postInstallFailed) {
-        return (`⚠ ${name} — installed, but a finishing step failed. ` +
-            `Fix: ${finishSetupCommand(result.harness)}`);
-    }
-    // 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';
-    if (authDeferred || result.verifyOk === false) {
-        const reason = authDeferred
-            ? '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}`;
-}
-function summaryLine(result, uninstall) {
-    return (absentSummaryLine(result, uninstall) ??
-        skippedSummaryLine(result) ??
-        uninstallSummaryLine(result) ??
-        installedSummaryLine(result));
-}
-/** One line for every harness: seven near-identical paragraphs is what this replaces. */
-function reloadHint(results) {
-    const byAction = new Map();
-    for (const result of results) {
-        if (!result.installed)
-            continue;
-        const action = RELOAD_ACTION[result.harness];
-        byAction.set(action, [...(byAction.get(action) ?? []), DISPLAY_NAMES[result.harness]]);
-    }
-    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('; ')}.`;
-}
-/** 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 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(', ')}`);
-    return lines;
-}
 /** The states processHarness settles without work; stepTotal must agree with it. */
 function noWorkOutcome(d, uninstall) {
     if (!d.detected)
@@ -573,29 +162,6 @@ function isStaleConfig(detection) {
         !detection.binaryOnPath &&
         !HARNESS_CAPABILITIES[detection.harness].cliWritesConfig);
 }
-/** A stale config dir is a detection signal with nothing behind it. */
-function actionable(result) {
-    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'))
-        return 130;
-    // A removal that could not run is a failure, not a silent success.
-    if (results.some((r) => r.removalFailed))
-        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');
-    if (attempted.length === 0)
-        return 0;
-    return attempted.some((r) => r.outcome === 'installed') ? 0 : 1;
-}
 async function resolvePick(detections, opts, prompt) {
     let deselected = new Set();
     let mode = 'all';
@@ -749,6 +315,12 @@ async function finishRun(results, opts, isTTY) {
 }
 export async function runConnectAll(opts) {
     const isTTY = detectHumanInitiated();
+    // Ahead of detection and the hoisted install; either can end the process silently.
+    // Not on the picker path: an explicit cancel is not a setup.
+    if (!opts.uninstall && !opts.dryRun && !opts.pick) {
+        // validatedApiKey falls back to env/config; opts.apiKey alone splits the run's two ends.
+        await sendSetupStarted(opts.mcpUrl, opts.attemptId, validatedApiKey(opts.apiKey));
+    }
     // Open interface holds stdin raw; hermes' input() then wedges.
     const prompt = isTTY ? createStdinPrompt() : undefined;
     const detections = detectInstalledHarnesses();
@@ -806,7 +378,7 @@ export async function runConnectAll(opts) {
             verify_depth: r.verifyDepth ?? null,
             verify_ok: r.verifyOk ?? null,
         }));
-        await sendSetupCompleted(opts.mcpUrl, harnessTelemetry, validatedApiKey(opts.apiKey), mode);
+        await sendSetupCompleted(opts.mcpUrl, harnessTelemetry, validatedApiKey(opts.apiKey), mode, opts.attemptId);
         // After the summary and before the launch, which is where the user is reading.
         emitNotice();
     }

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

@@ -40,6 +40,8 @@ declare const harnessResultSchema: z.ZodObject<{
     }>>;
     verify_ok: z.ZodNullable<z.ZodBoolean>;
 }, z.core.$strip>;
+/** First act of a `--all` run; everything upstream of it stays invisible. */
+export declare function sendSetupStarted(mcpUrl: string, attemptId?: string, apiKey?: string): Promise<void>;
 export declare const setupCompletedPayloadSchema: z.ZodObject<{
     harnesses: z.ZodArray<z.ZodObject<{
         harness: z.ZodEnum<{
@@ -65,6 +67,7 @@ export declare const setupCompletedPayloadSchema: z.ZodObject<{
         pick: "pick";
         pick_numeric: "pick_numeric";
     }>>;
+    connect_attempt_id: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;
 export type SetupCompletedPayload = z.infer<typeof setupCompletedPayloadSchema>;
 export type HarnessResult = z.infer<typeof harnessResultSchema>;
@@ -74,7 +77,7 @@ export type UpgradeOutcome = 'updated' | 'failed' | 'interrupted';
 export type UpgradeScope = 'both' | 'cli' | 'skill';
 /** `toVersion` is null when the run was interrupted or the installed version could not be read. */
 export declare function sendUpgradeCompleted(fromVersion: string, toVersion: string | null, outcome: UpgradeOutcome, scope: UpgradeScope, apiKey?: string): Promise<void>;
-export declare function sendSetupCompleted(mcpUrl: string, harnesses: HarnessResult[], apiKey?: string, mode?: SetupMode): Promise<void>;
+export declare function sendSetupCompleted(mcpUrl: string, harnesses: HarnessResult[], apiKey?: string, mode?: SetupMode, attemptId?: string): Promise<void>;
 export declare const DOCTOR_HARNESS_SCOPES: readonly ["all", "claude-code", "codex", "cursor", "grok", "hermes", "openclaw", "opencode"];
 export declare const doctorCompletedPayloadSchema: z.ZodObject<{
     schema_version: z.ZodInt;

package/dist/lib/setup-telemetry.js

@@ -101,6 +101,25 @@ const harnessResultSchema = z.object({
     verify_depth: z.enum(['health', 'health+auth']).nullable(),
     verify_ok: z.boolean().nullable(),
 });
+/** First act of a `--all` run; everything upstream of it stays invisible. */
+export async function sendSetupStarted(mcpUrl, attemptId, apiKey) {
+    if (telemetryDisabled())
+        return;
+    // Route 400s a bad id and postConnectEvent never retries 4xx, losing the whole event.
+    const stamped = attemptId && z.uuid().safeParse(attemptId).success ? attemptId : undefined;
+    await postConnectEvent({
+        endpoint: new URL('/api/cli/connect-event', mcpUrl).toString(),
+        body: JSON.stringify({
+            event: 'setup_started',
+            cli_version: CLI_VERSION,
+            runtime_platform: process.platform,
+            ...(stamped ? { connect_attempt_id: stamped } : {}),
+        }),
+        attempts: 1,
+        label: 'setup',
+        apiKey,
+    });
+}
 export const setupCompletedPayloadSchema = z.object({
     harnesses: z
         .array(harnessResultSchema)
@@ -111,6 +130,7 @@ export const setupCompletedPayloadSchema = z.object({
     cli_version: z.string(),
     // Segments picker runs from --all runs; the server field shipped first.
     mode: z.enum(['all', 'pick', 'pick_numeric']).optional(),
+    connect_attempt_id: z.uuid().optional(),
 });
 /** `toVersion` is null when the run was interrupted or the installed version could not be read. */
 export async function sendUpgradeCompleted(fromVersion, toVersion, outcome, scope, apiKey) {
@@ -128,7 +148,7 @@ export async function sendUpgradeCompleted(fromVersion, toVersion, outcome, scop
         apiKey,
     });
 }
-export async function sendSetupCompleted(mcpUrl, harnesses, apiKey, mode) {
+export async function sendSetupCompleted(mcpUrl, harnesses, apiKey, mode, attemptId) {
     // Ahead of the parse so an opt-out run prints no telemetry debug.
     if (telemetryDisabled())
         return;
@@ -140,6 +160,10 @@ export async function sendSetupCompleted(mcpUrl, harnesses, apiKey, mode) {
             harnesses,
             cli_version: CLI_VERSION,
             ...(mode ? { mode } : {}),
+            // Guarded here, not only at the route: a parse throw drops the whole event, not one field.
+            ...(attemptId && z.uuid().safeParse(attemptId).success
+                ? { connect_attempt_id: attemptId }
+                : {}),
         });
         endpoint = new URL('/api/cli/connect-event', mcpUrl).toString();
         body = JSON.stringify({ event: 'setup_completed', ...payload });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiny-fish/cli",
-  "version": "0.31.1-next.269",
+  "version": "0.31.1-next.272",
   "description": "TinyFish CLI — run web automations from your terminal",
   "type": "module",
   "bin": {