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

package/dist/commands/runs.js

@@ -78,227 +78,229 @@ function sleep(ms, signal) {
         signal.addEventListener('abort', onAbort, { once: true });
     });
 }
-export function registerRuns(runCmd) {
-    // ── run list ───────────────────────────────────────────────────────────────
-    runCmd
-        .command('list')
-        .description('List your automation runs')
-        .option('--status <status>', 'Filter by status (PENDING|RUNNING|COMPLETED|FAILED|CANCELLED)')
-        .option('--limit <n>', 'Max number of runs to return (default: 20)')
-        .option('--cursor <cursor>', 'Pagination cursor from a previous response')
-        .option('--pretty', 'Human-readable output')
-        .action(async (opts) => {
-        // Validate --status
-        if (opts.status != null &&
-            !VALID_STATUSES.includes(opts.status)) {
+async function runsListAction(opts) {
+    // Validate --status
+    if (opts.status != null &&
+        !VALID_STATUSES.includes(opts.status)) {
+        err({
+            error: `Invalid --status "${opts.status}". Must be one of: ${VALID_STATUSES.join(', ')}`,
+        });
+        process.exit(1);
+    }
+    // Validate --limit
+    const MAX_LIMIT = 100;
+    let limit;
+    if (opts.limit != null) {
+        limit = parseInt(opts.limit, 10);
+        if (!isFinite(limit) || limit <= 0) {
+            err({ error: `Invalid --limit "${opts.limit}". Must be a positive integer.` });
+            process.exit(1);
+        }
+        if (limit > MAX_LIMIT) {
+            err({ error: `--limit cannot exceed ${MAX_LIMIT}.` });
+            process.exit(1);
+        }
+    }
+    const apiKey = getApiKey();
+    const filter = {
+        status: opts.status,
+        limit,
+        cursor: opts.cursor,
+    };
+    try {
+        const body = await listRuns(filter, apiKey);
+        if (opts.pretty) {
+            if (body.data.length === 0) {
+                outLine('No runs found.');
+                return;
+            }
+            outLine(`${'RUN ID'.padEnd(36)}  ${'STATUS'.padEnd(10)}  ${'CREATED AT'.padEnd(24)}  GOAL`);
+            outLine(`${'-'.repeat(36)}  ${'-'.repeat(10)}  ${'-'.repeat(24)}  ${'-'.repeat(30)}`);
+            for (const run of body.data) {
+                outLine(`${run.run_id.padEnd(36)}  ${run.status.padEnd(10)}  ${run.created_at.padEnd(24)}  ${run.goal}`);
+            }
+            if (body.pagination.has_more) {
+                outLine(`\nNext cursor: ${body.pagination.next_cursor}`);
+            }
+        }
+        else {
+            out(body);
+        }
+    }
+    catch (e) {
+        handleApiError(e);
+    }
+}
+async function runsGetAction(runId, opts) {
+    const apiKey = getApiKey();
+    try {
+        const run = await getRun(runId, apiKey);
+        if (opts.pretty) {
+            outLine(`Run ID:   ${run.run_id}`);
+            outLine(`Status:   ${run.status}`);
+            outLine(`Goal:     ${run.goal}`);
+            outLine(`Created:  ${run.created_at}`);
+            if (run.started_at)
+                outLine(`Started:  ${run.started_at}`);
+            if (run.finished_at)
+                outLine(`Finished: ${run.finished_at}`);
+            outLine(`Steps:    ${run.num_of_steps}`);
+            if (run.result !== null && run.result !== undefined) {
+                outLine(`\nResult:\n${JSON.stringify(run.result, null, 2)}`);
+            }
+            if (run.error)
+                outLine(`\nError: ${run.error.message}`);
+        }
+        else {
+            out(run);
+        }
+    }
+    catch (e) {
+        handleApiError(e);
+    }
+}
+async function runsStepsAction(runId, opts) {
+    const apiKey = getApiKey();
+    try {
+        const result = await getRunSteps(runId, apiKey);
+        if (opts.pretty) {
+            if (result.steps.length === 0) {
+                outLine('No steps found.');
+                return;
+            }
+            outLine(`Run ID: ${result.run_id}`);
+            for (const [index, step] of result.steps.entries()) {
+                outLine(formatStep(step, index));
+                outLine(`    ${step.timestamp}`);
+            }
+        }
+        else {
+            out(result);
+        }
+    }
+    catch (e) {
+        handleApiError(e);
+    }
+}
+async function runsWatchAction(runId, opts) {
+    const apiKey = getApiKey();
+    const timeoutMs = parsePositiveInt(opts.timeout, '--timeout', DEFAULT_WATCH_TIMEOUT_MS);
+    const intervalMs = parsePositiveInt(opts.interval, '--interval', DEFAULT_WATCH_INTERVAL_MS, MIN_WATCH_INTERVAL_MS);
+    const controller = new AbortController();
+    const onSigint = () => {
+        controller.abort();
+        process.exit(130);
+    };
+    process.once('SIGINT', onSigint);
+    const deadline = Date.now() + timeoutMs;
+    const seen = new Set();
+    try {
+        const initial = await withDeadline(getRun(runId, apiKey), deadline, controller.signal);
+        if (TERMINAL_STATUSES.includes(initial.status)) {
             err({
-                error: `Invalid --status "${opts.status}". Must be one of: ${VALID_STATUSES.join(', ')}`,
+                error: `Run ${runId} is already ${initial.status}; nothing to watch. Use 'tinyfish agent run steps ${runId}' for the trace.`,
             });
             process.exit(1);
         }
-        // Validate --limit
-        const MAX_LIMIT = 100;
-        let limit;
-        if (opts.limit != null) {
-            limit = parseInt(opts.limit, 10);
-            if (!isFinite(limit) || limit <= 0) {
-                err({ error: `Invalid --limit "${opts.limit}". Must be a positive integer.` });
-                process.exit(1);
+        while (!controller.signal.aborted) {
+            // One API call per tick — the steps endpoint also returns the run's current status.
+            const tick = await withDeadline(getRunSteps(runId, apiKey), deadline, controller.signal);
+            let nextIndex = seen.size;
+            for (const step of tick.steps) {
+                if (seen.has(step.id))
+                    continue;
+                seen.add(step.id);
+                if (opts.pretty) {
+                    outLine(formatStep(step, nextIndex));
+                    outLine(`    ${step.timestamp}`);
+                }
+                else {
+                    out(step);
+                }
+                nextIndex += 1;
+            }
+            if (TERMINAL_STATUSES.includes(tick.status)) {
+                if (opts.pretty)
+                    outLine(`Run ${tick.status.toLowerCase()}.`);
+                return;
             }
-            if (limit > MAX_LIMIT) {
-                err({ error: `--limit cannot exceed ${MAX_LIMIT}.` });
+            if (Date.now() + intervalMs > deadline) {
+                err({ error: `Watch timed out after ${timeoutMs}ms (run still ${tick.status}).` });
                 process.exit(1);
             }
+            try {
+                await sleep(intervalMs, controller.signal);
+            }
+            catch {
+                return; // aborted
+            }
         }
-        const apiKey = getApiKey();
-        const filter = {
-            status: opts.status,
-            limit,
-            cursor: opts.cursor,
-        };
-        try {
-            const body = await listRuns(filter, apiKey);
-            if (opts.pretty) {
-                if (body.data.length === 0) {
-                    outLine('No runs found.');
-                    return;
-                }
-                outLine(`${'RUN ID'.padEnd(36)}  ${'STATUS'.padEnd(10)}  ${'CREATED AT'.padEnd(24)}  GOAL`);
-                outLine(`${'-'.repeat(36)}  ${'-'.repeat(10)}  ${'-'.repeat(24)}  ${'-'.repeat(30)}`);
-                for (const run of body.data) {
-                    outLine(`${run.run_id.padEnd(36)}  ${run.status.padEnd(10)}  ${run.created_at.padEnd(24)}  ${run.goal}`);
-                }
-                if (body.pagination.has_more) {
-                    outLine(`\nNext cursor: ${body.pagination.next_cursor}`);
-                }
+    }
+    catch (e) {
+        if (e instanceof Error && e.message === 'watch deadline exceeded') {
+            err({ error: `Watch timed out after ${timeoutMs}ms.` });
+            process.exit(1);
+        }
+        if (e instanceof Error && e.message === 'watch aborted') {
+            return; // SIGINT handler already triggered process.exit(130)
+        }
+        handleApiError(e);
+    }
+    finally {
+        process.off('SIGINT', onSigint);
+    }
+}
+async function runsCancelAction(runId, opts) {
+    const apiKey = getApiKey();
+    try {
+        const result = await cancelRun(runId, apiKey);
+        if (opts.pretty) {
+            if (result.status === RunStatus.CANCELLED) {
+                outLine(result.message
+                    ? `Run ${result.run_id} cancelled (${result.message}).`
+                    : `Run ${result.run_id} cancelled.`);
             }
             else {
-                out(body);
+                outLine(`Run ${result.run_id} already finished (${result.status}).`);
             }
         }
-        catch (e) {
-            handleApiError(e);
+        else {
+            out(result);
         }
-    });
-    // ── run get ────────────────────────────────────────────────────────────────
+    }
+    catch (e) {
+        handleApiError(e);
+    }
+}
+export function registerRuns(runCmd) {
+    runCmd
+        .command('list')
+        .description('List your automation runs')
+        .option('--status <status>', 'Filter by status (PENDING|RUNNING|COMPLETED|FAILED|CANCELLED)')
+        .option('--limit <n>', 'Max number of runs to return (default: 20)')
+        .option('--cursor <cursor>', 'Pagination cursor from a previous response')
+        .option('--pretty', 'Human-readable output')
+        .action(runsListAction);
     runCmd
         .command('get <run_id>')
         .description('Get a run by ID')
         .option('--pretty', 'Human-readable output')
-        .action(async (runId, opts) => {
-        const apiKey = getApiKey();
-        try {
-            const run = await getRun(runId, apiKey);
-            if (opts.pretty) {
-                outLine(`Run ID:   ${run.run_id}`);
-                outLine(`Status:   ${run.status}`);
-                outLine(`Goal:     ${run.goal}`);
-                outLine(`Created:  ${run.created_at}`);
-                if (run.started_at)
-                    outLine(`Started:  ${run.started_at}`);
-                if (run.finished_at)
-                    outLine(`Finished: ${run.finished_at}`);
-                outLine(`Steps:    ${run.num_of_steps}`);
-                if (run.result !== null && run.result !== undefined) {
-                    outLine(`\nResult:\n${JSON.stringify(run.result, null, 2)}`);
-                }
-                if (run.error)
-                    outLine(`\nError: ${run.error.message}`);
-            }
-            else {
-                out(run);
-            }
-        }
-        catch (e) {
-            handleApiError(e);
-        }
-    });
+        .action(runsGetAction);
     runCmd
         .command('steps <run_id>')
         .description('Print the step-by-step trace for a run')
         .option('--pretty', 'Human-readable output')
-        .action(async (runId, opts) => {
-        const apiKey = getApiKey();
-        try {
-            const result = await getRunSteps(runId, apiKey);
-            if (opts.pretty) {
-                if (result.steps.length === 0) {
-                    outLine('No steps found.');
-                    return;
-                }
-                outLine(`Run ID: ${result.run_id}`);
-                for (const [index, step] of result.steps.entries()) {
-                    outLine(formatStep(step, index));
-                    outLine(`    ${step.timestamp}`);
-                }
-            }
-            else {
-                out(result);
-            }
-        }
-        catch (e) {
-            handleApiError(e);
-        }
-    });
+        .action(runsStepsAction);
     runCmd
         .command('watch <run_id>')
         .description('Poll a run and print new steps as they arrive (exits when run reaches a terminal status)')
         .option('--pretty', 'Human-readable output')
         .option('--timeout <ms>', `Stop polling after this many milliseconds (default: ${DEFAULT_WATCH_TIMEOUT_MS})`)
         .option('--interval <ms>', `Poll interval (default: ${DEFAULT_WATCH_INTERVAL_MS}, min: ${MIN_WATCH_INTERVAL_MS})`)
-        .action(async (runId, opts) => {
-        const apiKey = getApiKey();
-        const timeoutMs = parsePositiveInt(opts.timeout, '--timeout', DEFAULT_WATCH_TIMEOUT_MS);
-        const intervalMs = parsePositiveInt(opts.interval, '--interval', DEFAULT_WATCH_INTERVAL_MS, MIN_WATCH_INTERVAL_MS);
-        const controller = new AbortController();
-        const onSigint = () => {
-            controller.abort();
-            process.exit(130);
-        };
-        process.once('SIGINT', onSigint);
-        const deadline = Date.now() + timeoutMs;
-        const seen = new Set();
-        try {
-            const initial = await withDeadline(getRun(runId, apiKey), deadline, controller.signal);
-            if (TERMINAL_STATUSES.includes(initial.status)) {
-                err({
-                    error: `Run ${runId} is already ${initial.status}; nothing to watch. Use 'tinyfish agent run steps ${runId}' for the trace.`,
-                });
-                process.exit(1);
-            }
-            while (!controller.signal.aborted) {
-                // One API call per tick — the steps endpoint also returns the run's current status.
-                const tick = await withDeadline(getRunSteps(runId, apiKey), deadline, controller.signal);
-                let nextIndex = seen.size;
-                for (const step of tick.steps) {
-                    if (seen.has(step.id))
-                        continue;
-                    seen.add(step.id);
-                    if (opts.pretty) {
-                        outLine(formatStep(step, nextIndex));
-                        outLine(`    ${step.timestamp}`);
-                    }
-                    else {
-                        out(step);
-                    }
-                    nextIndex += 1;
-                }
-                if (TERMINAL_STATUSES.includes(tick.status)) {
-                    if (opts.pretty)
-                        outLine(`Run ${tick.status.toLowerCase()}.`);
-                    return;
-                }
-                if (Date.now() + intervalMs > deadline) {
-                    err({ error: `Watch timed out after ${timeoutMs}ms (run still ${tick.status}).` });
-                    process.exit(1);
-                }
-                try {
-                    await sleep(intervalMs, controller.signal);
-                }
-                catch {
-                    return; // aborted
-                }
-            }
-        }
-        catch (e) {
-            if (e instanceof Error && e.message === 'watch deadline exceeded') {
-                err({ error: `Watch timed out after ${timeoutMs}ms.` });
-                process.exit(1);
-            }
-            if (e instanceof Error && e.message === 'watch aborted') {
-                return; // SIGINT handler already triggered process.exit(130)
-            }
-            handleApiError(e);
-        }
-        finally {
-            process.off('SIGINT', onSigint);
-        }
-    });
-    // ── run cancel ────────────────────────────────────────────────────────────
+        .action(runsWatchAction);
     runCmd
         .command('cancel <run_id>')
         .description('Cancel a run by ID')
         .option('--pretty', 'Human-readable output')
-        .action(async (runId, opts) => {
-        const apiKey = getApiKey();
-        try {
-            const result = await cancelRun(runId, apiKey);
-            if (opts.pretty) {
-                if (result.status === RunStatus.CANCELLED) {
-                    outLine(result.message
-                        ? `Run ${result.run_id} cancelled (${result.message}).`
-                        : `Run ${result.run_id} cancelled.`);
-                }
-                else {
-                    outLine(`Run ${result.run_id} already finished (${result.status}).`);
-                }
-            }
-            else {
-                out(result);
-            }
-        }
-        catch (e) {
-            handleApiError(e);
-        }
-    });
+        .action(runsCancelAction);
 }

package/dist/lib/auth.js

@@ -179,6 +179,20 @@ export function clearConnectContext(client) {
         errLine(`Warning: could not clear connect context: ${e instanceof Error ? e.message : String(e)}`);
     }
 }
+function resolveProfilePath(shell, platform) {
+    const home = os.homedir();
+    const macBashProfile = ['.bash_profile', '.bash_login', '.profile']
+        .map((name) => path.join(home, name)) // nosemgrep: path-join-resolve-traversal -- fixed filenames under os.homedir()
+        .find((candidate) => fs.existsSync(candidate)) ?? path.join(home, '.bash_profile');
+    if (shell === 'zsh')
+        return path.join(home, '.zshrc');
+    if (shell === 'bash') {
+        return platform === 'darwin' ? macBashProfile : path.join(home, '.bashrc');
+    }
+    if (shell === 'fish')
+        return path.join(home, '.config', 'fish', 'config.fish');
+    return path.join(home, '.profile');
+}
 export function persistApiKeyToEnvironment(apiKey, options = {}) {
     const platform = options.platform ?? process.platform;
     if (platform === 'win32') {
@@ -190,21 +204,9 @@ export function persistApiKeyToEnvironment(apiKey, options = {}) {
         }
         return;
     }
-    const home = os.homedir();
     const shell = path.basename(options.shell ?? process.env['SHELL'] ?? '');
     const fish = shell === 'fish';
-    const macBashProfile = ['.bash_profile', '.bash_login', '.profile']
-        .map((name) => path.join(home, name)) // nosemgrep: path-join-resolve-traversal -- fixed filenames under os.homedir()
-        .find((candidate) => fs.existsSync(candidate)) ?? path.join(home, '.bash_profile');
-    const profile = shell === 'zsh'
-        ? path.join(home, '.zshrc')
-        : shell === 'bash'
-            ? platform === 'darwin'
-                ? macBashProfile
-                : path.join(home, '.bashrc')
-            : fish
-                ? path.join(home, '.config', 'fish', 'config.fish')
-                : path.join(home, '.profile');
+    const profile = resolveProfilePath(shell, platform);
     const quotedKey = `'${apiKey.replaceAll("'", "'\\''")}'`;
     const prefix = fish ? `set -gx ${TINYFISH_API_KEY_VAR} ` : `export ${TINYFISH_API_KEY_VAR}=`;
     const assignment = `${prefix}${quotedKey}`;

package/dist/lib/cli-install.d.ts

@@ -12,6 +12,7 @@ export type HoistedCliInstall = {
     durationMs: number;
 } | {
     ok: false;
+    durationMs: number;
     error: Error;
 };
 /** Every harness reads the outcome; only the first take reports it. */
@@ -19,9 +20,7 @@ export type TakeHoistedCliInstall = () => {
     outcome: HoistedCliInstall;
     firstTake: boolean;
 };
-/** Carried failure an earlier harness already reported. */
-export declare class HoistedFailureReportedError extends Error {
-}
+export { HoistedFailureReportedError } from './connect-runtime.js';
 export declare function captureStdio(verbose: boolean): {
     stdio: "inherit";
     timeout: number;

package/dist/lib/cli-install.js

@@ -7,9 +7,7 @@ export const SKILL_INSTALL_TIMEOUT_MS = 120_000;
 const TINYFISH_CLI_INSTALL_SPEC = `${TINYFISH_CLI_PACKAGE}@latest`;
 // spawnSync caps piped output at 1 MiB by default.
 export const STEP_MAX_BUFFER = 10 * 1024 * 1024;
-/** Carried failure an earlier harness already reported. */
-export class HoistedFailureReportedError extends Error {
-}
+export { HoistedFailureReportedError } from './connect-runtime.js';
 export function captureStdio(verbose) {
     return verbose
         ? { stdio: 'inherit', timeout: SKILL_INSTALL_TIMEOUT_MS }

package/dist/lib/connect-all.js

@@ -7,6 +7,7 @@ import { HARNESS_CAPABILITIES, NATIVE_BY_HARNESS, openclawSkillUninstall, } from
 import { createStdinPrompt, runCliFallback } from './connect-fallback.js';
 import { ConnectInterruptedError, ConnectStepError, SignInTimeoutError, finishSetupCommand, spawnRemoval, } 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 { detectHumanInitiated } from './harness.js';
 import { emitNotice } from './notice.js';
@@ -84,7 +85,11 @@ function runHoistedCliInstall(verbose) {
     catch (error) {
         if (error instanceof ConnectInterruptedError)
             return undefined;
-        return { ok: false, error: error instanceof Error ? error : new Error(String(error)) };
+        return {
+            ok: false,
+            durationMs: Math.max(0, Date.now() - startedAt),
+            error: error instanceof Error ? error : new Error(String(error)),
+        };
     }
 }
 async function verifyHarness(harness, mcpUrl, keyed, apiKey) {
@@ -100,6 +105,10 @@ async function verifyHarness(harness, mcpUrl, keyed, 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) {
@@ -109,7 +118,9 @@ function uninstallPlanText(harness) {
     if (!uninstallRuns(harness)) {
         return `would print \`${uninstallPointer(harness)}\` (no removal command exists)`;
     }
-    return `would run \`${uninstallPointer(harness)}\``;
+    // 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) {
@@ -132,7 +143,46 @@ function uninstallPointer(harness) {
     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 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 removeHarnessRegistration(harness, configPath, verbose, binaryOnPath) {
     const detection = { harness, detected: true, configPath, installed: false };
     if (harness !== 'cursor') {
         const removal = uninstallRuns(harness);
@@ -165,6 +215,7 @@ function uninstallHarness(harness, configPath, verbose, binaryOnPath) {
                     return {
                         ...detection,
                         outcome: 'uninstalled',
+                        removalFailed: true,
                         errorMessage: `could not run \`${removal.command} ${args.join(' ')}\` (${result.error.message}) — nothing removed.`,
                         fixCommand: uninstallPointer(harness),
                     };
@@ -209,6 +260,7 @@ function uninstallHarness(harness, configPath, verbose, binaryOnPath) {
         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',
         };
@@ -377,9 +429,12 @@ function summaryLine(result, uninstall) {
         return `… ${name} — no tinyfish entry found, nothing removed`;
     }
     if (result.outcome === 'uninstalled') {
-        return result.errorMessage
-            ? `✗ ${name} — ${result.errorMessage} Fix: ${result.fixCommand}`
-            : `✓ ${name} — removed`;
+        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}`;
     }
     if (result.outcome === 'interrupted') {
         return `✗ ${name} — interrupted before finishing. Fix: ${result.fixCommand}`;
@@ -457,7 +512,7 @@ function computeExitCode(results) {
     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.removalFailed))
         return 1;
     const detected = results.filter(actionable);
     if (detected.length === 0)

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

@@ -18,6 +18,22 @@ export declare const CURSOR_SKILL_TARGET: {
     readonly skillAgent: "cursor";
     readonly displayName: "Cursor";
 };
+/** The harness reads the key from its own store. */
+export interface SeededInstall {
+    /** Pins the add child at the home the key landed in. */
+    env: typeof process.env;
+    /** Answers prompts `mcp add` still asks once the key is seeded. */
+    stdinInput: string;
+    /** Names the file it wrote, never the value. */
+    note: string;
+    /** Undoes the seed, carrying the value it replaced. */
+    rollback: () => void;
+    /** `mcp add` exits 0 even having saved nothing; the code lies. */
+    confirmRegistered: () => {
+        ok: boolean;
+        detail?: string;
+    };
+}
 export interface NativeMcpClient extends SupportedCommand {
     connectClient: Exclude<AgentClient, 'openclaw'>;
     /** Omitted where the `skills` CLI has no agent for this harness (Grok ships its own plugin). */
@@ -29,6 +45,8 @@ export interface NativeMcpClient extends SupportedCommand {
         /** Which variable the client reads the key from. */
         envVar?: string;
         addArgs: (mcpUrl: string, apiKey: string) => string[];
+        /** Writes into the harness's store, so connect verifies the key first. */
+        seedKey?: (apiKey: string) => SeededInstall;
     };
     /** Shown when a keyless install leaves sign-in to the harness. */
     signInHint?: string;
@@ -61,6 +79,11 @@ export declare const CLAUDE_CODE: NativeMcpClient;
 export declare function openExternalUrl(url: string): ReturnType<typeof spawn.sync>;
 export declare const CODEX: NativeMcpClient;
 export declare const GROK: NativeMcpClient;
+/** `mcp add` exits 0 after saving nothing, or a disabled entry. */
+export declare function hermesRegistrationEnabled(home: string): {
+    ok: boolean;
+    detail?: string;
+};
 export declare const HERMES: NativeMcpClient;
 export declare const OPENCODE: NativeMcpClient;
 /** Every native MCP client. Derive from this, so a new harness cannot be missed. */