@tiny-fish/cli 0.48.1-next.383 → 0.48.1

package/README.md

@@ -110,8 +110,7 @@ npx -y @tiny-fish/cli@latest connect command-code --api-key sk-tinyfish-...
 ```
 
 Command Code takes an API key only. `cmd mcp add` opens a browser sign-in even when a header is
-passed, so TinyFish registers through `mcp add-json`, which writes `~/.commandcode/mcp.json`
-without an auth probe. Without a key the command refuses rather than falling back to a sign-in.
+passed, so TinyFish writes the entry into `~/.commandcode/mcp.json` itself. Without a key the command refuses rather than falling back to a sign-in.
 
 ### Connect OpenClaw
 

package/dist/lib/config/command-code-config.d.ts

@@ -1,3 +1,10 @@
-import { type McpJsonServerEntry } from './mcp-json-config.js';
+import { type McpJsonServerEntry, type McpJsonWriteResult } from './mcp-json-config.js';
+export declare function commandCodeMcpPath(): string;
 /** Reports the header's shape, never its value. */
 export declare function readCommandCodeTinyfishEntry(): McpJsonServerEntry;
+/** Merges only the `tinyfish` key. */
+export declare function writeCommandCodeMcpConfig(mcpUrl: string, apiKey?: string): McpJsonWriteResult;
+/** Dry-run description of the pending write; touches nothing. */
+export declare function planCommandCodeWrite(mcpUrl: string, apiKey?: string): string;
+/** Removes only the `tinyfish` key. */
+export declare function removeCommandCodeMcpServer(): McpJsonWriteResult;

package/dist/lib/config/command-code-config.js

@@ -1,14 +1,41 @@
 import * as os from 'os';
 import * as path from 'path';
-import { readTinyfishEntry, } from './mcp-json-config.js';
-// Read-only: Command Code writes this file itself, through `cmd mcp add-json --scope user`.
+import { planWrite, readTinyfishEntry, removeServer, writeMcpConfig, } from './mcp-json-config.js';
+// Written directly: `commandcode mcp add-json` mangles the JSON body through the win32 .cmd shim.
 const COMMAND_CODE_TARGET = {
     serverKey: 'tinyfish',
     dir: () => path.join(os.homedir(), '.commandcode'),
     file: () => path.join(os.homedir(), '.commandcode', 'mcp.json'),
     keyHeader: { name: 'Authorization', valuePrefix: 'Bearer ' },
 };
+/** The shape `commandcode mcp add-json --scope user` writes. */
+function commandCodeServerEntry(mcpUrl, apiKey) {
+    return {
+        transport: 'http',
+        enabled: true,
+        url: mcpUrl,
+        ...(apiKey ? { headers: { Authorization: `Bearer ${apiKey}` } } : {}),
+    };
+}
+export function commandCodeMcpPath() {
+    return COMMAND_CODE_TARGET.file();
+}
 /** Reports the header's shape, never its value. */
 export function readCommandCodeTinyfishEntry() {
     return readTinyfishEntry(COMMAND_CODE_TARGET);
 }
+/** Merges only the `tinyfish` key. */
+export function writeCommandCodeMcpConfig(mcpUrl, apiKey) {
+    return writeMcpConfig(COMMAND_CODE_TARGET, mcpUrl, apiKey, commandCodeServerEntry(mcpUrl, apiKey));
+}
+/** Dry-run description of the pending write; touches nothing. */
+export function planCommandCodeWrite(mcpUrl, apiKey) {
+    // Mirrors connect, which refuses rather than write a keyless entry.
+    if (!apiKey)
+        return 'would refuse: Command Code needs a TinyFish API key (run: tinyfish auth login)';
+    return planWrite(COMMAND_CODE_TARGET, mcpUrl, apiKey, commandCodeServerEntry(mcpUrl, apiKey));
+}
+/** Removes only the `tinyfish` key. */
+export function removeCommandCodeMcpServer() {
+    return removeServer(COMMAND_CODE_TARGET);
+}

package/dist/lib/config/connect-config-file.d.ts

@@ -1,9 +1,28 @@
+import { type OnWalkthroughDecided, type WalkthroughOutcome } from '../connect-clients.js';
 import { type ConnectAuthMode } from '../connect-runtime.js';
 import { cursorMcpPath, writeCursorMcpConfig } from './cursor-config.js';
+import { commandCodeMcpPath, writeCommandCodeMcpConfig } from './command-code-config.js';
 import { ompMcpPath, writeOmpMcpConfig } from './omp-config.js';
 import { piMcpAdapterState, type PiAdapterState, piMcpPath, writePiMcpConfig } from './pi-config.js';
 declare function piPostConnectNotes(adapterState?: PiAdapterState): string | undefined;
 declare const CONFIG_FILE_HARNESSES: {
+    'command-code': {
+        skillTarget: {
+            skillAgent: "command-code";
+            displayName: string;
+        };
+        registeredUrl: () => string | undefined;
+        write: typeof writeCommandCodeMcpConfig;
+        configPath: typeof commandCodeMcpPath;
+        tryLaunch: () => false;
+        launchWalkthrough: (onDecided?: OnWalkthroughDecided, prompt?: string) => Promise<WalkthroughOutcome>;
+        copy: {
+            verified: string;
+            authFailed: (reason: string) => string;
+            launched: string;
+            reload: string;
+        };
+    };
     cursor: {
         skillTarget: {
             readonly skillAgent: "cursor";
@@ -28,6 +47,7 @@ declare const CONFIG_FILE_HARNESSES: {
         write: typeof writeOmpMcpConfig;
         configPath: typeof ompMcpPath;
         tryLaunch: () => false;
+        launchWalkthrough: (onDecided?: OnWalkthroughDecided, prompt?: string) => Promise<WalkthroughOutcome>;
         copy: {
             verified: string;
             authFailed: (reason: string) => string;
@@ -44,6 +64,7 @@ declare const CONFIG_FILE_HARNESSES: {
         write: typeof writePiMcpConfig;
         configPath: typeof piMcpPath;
         tryLaunch: () => false;
+        launchWalkthrough: (onDecided?: OnWalkthroughDecided, prompt?: string) => Promise<WalkthroughOutcome>;
         adapterState: typeof piMcpAdapterState;
         postConnectNote: typeof piPostConnectNotes;
         copy: {
@@ -58,6 +79,7 @@ declare const CONFIG_FILE_HARNESSES: {
 export declare function connectConfigFileHarness(harness: keyof typeof CONFIG_FILE_HARNESSES, options: {
     apiKey?: string;
     mcpUrl: string;
+    launch?: boolean;
     attemptId?: string;
     verbose?: boolean;
     authTimeoutMs?: number;

package/dist/lib/config/connect-config-file.js

@@ -1,18 +1,20 @@
 import { z } from 'zod';
 import { CONNECT_SOURCE, saveConnectContext, validatedApiKey } from '../auth.js';
-import { CURSOR_SKILL_TARGET, openExternalUrl } from '../connect-clients.js';
+import { CURSOR_SKILL_TARGET, KEYLESS_ONBOARDING_PROMPT, launchCommandCodeWalkthrough, launchOmpWalkthrough, launchPiWalkthrough, openExternalUrl, } from '../connect-clients.js';
 import { ensureCliAuthenticated } from '../connect-auth.js';
 import { installWebSkill } from '../skill-install.js';
 import { ConnectStepError, createConnectTelemetry, runGuarded, settle, } from '../connect-runtime.js';
 import { cursorInstallDeeplink, cursorMcpPath, readCursorTinyfishEntry, writeCursorMcpConfig, } from './cursor-config.js';
+import { commandCodeMcpPath, readCommandCodeTinyfishEntry, writeCommandCodeMcpConfig, } from './command-code-config.js';
 import { ompMcpPath, readOmpTinyfishEntry, writeOmpMcpConfig } from './omp-config.js';
 import { PI_ADAPTER_INSTALL_COMMAND, piMcpAdapterState, piSkillDirMismatch, piMcpPath, readPiTinyfishEntry, writePiMcpConfig, } from './pi-config.js';
 import { AuthMode, detectInstalledHarnesses, HARNESS_COMMANDS, HARNESS_DISPLAY_NAMES, isStaleConfig, } from '../harness/harness-detect.js';
+import { harnessSpec } from '../harness/harness-spec.js';
 import { detectHumanInitiated } from '../harness.js';
 import { errLine } from '../output.js';
 import { verifyMcpAuth } from '../verify.js';
 import { apiBaseFromMcpUrl } from '../mcp-endpoint.js';
-import { finishSetupHint, requireKeylessMcp, trackPostInstallFailure } from '../connect-steps.js';
+import { finishSetupHint, requireKeylessMcp, trackPostInstallFailure, walkthroughPhase, } from '../connect-steps.js';
 const PI_RELOAD_COPY = 'TinyFish is configured in pi. Restart pi, then run `/mcp-auth tinyfish` there if it asks you ' +
     'to sign in.';
 // The skill is the working path either way, so the note must not read as a failure.
@@ -40,7 +42,23 @@ function piPostConnectNotes(adapterState) {
 // Only interactive omp wires the OAuth handler; headless cannot sign in.
 const OMP_KEYLESS_COPY = 'TinyFish is configured in omp. Open omp and sign in to TinyFish when prompted, or run ' +
     '`/mcp reauth tinyfish` there.';
+const COMMAND_CODE_RELOAD_COPY = 'TinyFish is configured in Command Code. Restart it to load TinyFish.';
 const CONFIG_FILE_HARNESSES = {
+    'command-code': {
+        skillTarget: { skillAgent: 'command-code', displayName: HARNESS_DISPLAY_NAMES['command-code'] },
+        registeredUrl: () => readCommandCodeTinyfishEntry().url,
+        write: writeCommandCodeMcpConfig,
+        configPath: commandCodeMcpPath,
+        tryLaunch: () => false,
+        launchWalkthrough: launchCommandCodeWalkthrough,
+        copy: {
+            verified: "TinyFish is connected and verified (health+auth). Restart Command Code and it's live.",
+            authFailed: (reason) => `TinyFish is configured, but the authenticated check failed (${reason}). ` +
+                'Fix: rotate/re-enter your key with `tinyfish auth login`, then re-run: tinyfish connect command-code',
+            launched: COMMAND_CODE_RELOAD_COPY,
+            reload: COMMAND_CODE_RELOAD_COPY,
+        },
+    },
     cursor: {
         skillTarget: CURSOR_SKILL_TARGET,
         registeredUrl: () => readCursorTinyfishEntry().url,
@@ -63,6 +81,7 @@ const CONFIG_FILE_HARNESSES = {
         configPath: ompMcpPath,
         // No install deeplink exists; the keyless copy carries the sign-in.
         tryLaunch: () => false,
+        launchWalkthrough: launchOmpWalkthrough,
         copy: {
             verified: "TinyFish is connected and verified (health+auth). Restart omp and it's live.",
             authFailed: (reason) => `TinyFish is configured, but the authenticated check failed (${reason}). ` +
@@ -78,6 +97,7 @@ const CONFIG_FILE_HARNESSES = {
         configPath: piMcpPath,
         // No install deeplink exists; the copy carries the restart instead.
         tryLaunch: () => false,
+        launchWalkthrough: launchPiWalkthrough,
         adapterState: piMcpAdapterState,
         postConnectNote: piPostConnectNotes,
         copy: {
@@ -104,6 +124,24 @@ function installSkillPostSettle(spec, displayName, state, telemetry, options) {
         return true;
     }
 }
+/** Post-settle like the native walkthrough: a failed launch never fails the connect. */
+async function launchPostSettle(spec, displayName, keyless, state, telemetry) {
+    if (!spec.launchWalkthrough)
+        return false;
+    state.stage = 'walkthrough_launch';
+    try {
+        await spec.launchWalkthrough(async (outcome) => {
+            telemetry.track('checkpoint', { phase: walkthroughPhase(outcome) });
+            // Flushed pre-block; the session-long handover would strand the delivery.
+            await telemetry.flush();
+        }, keyless ? KEYLESS_ONBOARDING_PROMPT : undefined);
+        return false;
+    }
+    catch (error) {
+        trackPostInstallFailure(displayName, state, telemetry, error);
+        return true;
+    }
+}
 /** Prints last: the outro must own the final line. */
 function reportPostInstallFailure(harness, failed, onPostInstallFailed) {
     if (!failed)
@@ -119,6 +157,10 @@ function requireHarnessInstalled(harness) {
     throw new ConnectStepError(`${HARNESS_DISPLAY_NAMES[harness]} is not installed (no \`${HARNESS_COMMANDS[harness]}\` on PATH). ` +
         `Install it, then re-run: tinyfish connect ${harness}`, 'harness_not_installed');
 }
+function refuseKeylessInstall(harness) {
+    throw new ConnectStepError(`Connecting ${HARNESS_DISPLAY_NAMES[harness]} needs a TinyFish API key, and TinyFish does not ` +
+        `sign in to it any other way. Run: tinyfish auth login, then re-run: tinyfish connect ${harness}`, 'invalid_config', { failureDetail: 'keyless_install_refused' });
+}
 /** The copy after `completed`: what the user does next depends on the auth path. */
 async function printConnectedCopy(spec, displayName, opts) {
     if (opts.keyless) {
@@ -141,16 +183,13 @@ async function printConnectedCopy(spec, displayName, opts) {
         errLine(spec.copy.reload);
     }
 }
-/** Writes the harness's MCP config file itself; no `mcp add` exists. */
-export async function connectConfigFileHarness(harness, options) {
-    const spec = CONFIG_FILE_HARNESSES[harness];
-    const displayName = HARNESS_DISPLAY_NAMES[harness];
-    let fallbackAttemptId;
+/** A re-run keeps the attempt id already in the entry it is repairing. */
+function reusableAttemptId(spec, harness, mcpUrl) {
     const registeredUrl = spec.registeredUrl();
     if (registeredUrl) {
         try {
             const registered = new URL(registeredUrl);
-            const requested = new URL(options.mcpUrl);
+            const requested = new URL(mcpUrl);
             const registeredId = registered.searchParams.get('connect_attempt_id');
             const registeredSource = registered.searchParams.get('source');
             const registeredClient = registered.searchParams.get('client');
@@ -164,13 +203,20 @@ export async function connectConfigFileHarness(harness, options) {
                 registeredSource === CONNECT_SOURCE &&
                 registeredClient === harness &&
                 z.uuid().safeParse(registeredId).success) {
-                fallbackAttemptId = registeredId ?? undefined;
+                return registeredId ?? undefined;
             }
         }
         catch {
-            // A hand-edited invalid URL is repaired below with a fresh attempt id.
+            // A hand-edited invalid URL gets repaired with a fresh attempt id.
         }
     }
+    return undefined;
+}
+/** Writes the harness's MCP config file itself; no `mcp add` exists. */
+export async function connectConfigFileHarness(harness, options) {
+    const spec = CONFIG_FILE_HARNESSES[harness];
+    const displayName = HARNESS_DISPLAY_NAMES[harness];
+    const fallbackAttemptId = reusableAttemptId(spec, harness, options.mcpUrl);
     const telemetry = createConnectTelemetry(options.mcpUrl, harness, {
         ...options,
         fallbackAttemptId,
@@ -189,6 +235,9 @@ export async function connectConfigFileHarness(harness, options) {
         const resolveAuth = async () => {
             let resolvedKey = validatedApiKey(options.apiKey);
             const keyless = !resolvedKey && harness === 'omp';
+            // Before sign-in, as native refuses: a login here would bypass the refusal.
+            if (!resolvedKey && harnessSpec(harness).keyRequired)
+                refuseKeylessInstall(harness);
             if (keyless) {
                 await requireKeylessMcp(options.mcpUrl);
             }
@@ -245,7 +294,10 @@ export async function connectConfigFileHarness(harness, options) {
         const note = spec.postConnectNote?.(piAdapterState);
         if (note)
             errLine(note);
-        reportPostInstallFailure(harness, postInstallFailed, options.onPostInstallFailed);
+        const launchFailed = options.launch
+            ? await launchPostSettle(spec, displayName, keyless, state, telemetry)
+            : false;
+        reportPostInstallFailure(harness, postInstallFailed || launchFailed, options.onPostInstallFailed);
     });
     return state.authMode;
 }

package/dist/lib/config/mcp-json-config.d.ts

@@ -3,7 +3,7 @@ export interface McpJsonTarget {
     /** Functions so paths resolve at call time. */
     dir(): string;
     file(): string;
-    /** Read-side only; defaults to what the write path emits (Command Code writes its own). */
+    /** Read-side only; defaults to the `X-API-Key` header buildTinyfishServerEntry emits. */
     keyHeader?: {
         name: string;
         valuePrefix?: string;

package/dist/lib/config/mcp-json-config.js

@@ -48,10 +48,10 @@ export function planWrite(target, mcpUrl, apiKey, serverEntry) {
     if ('error' in existing) {
         return `${filePath}: existing file is corrupt (${existing.error}) — would skip and leave it untouched`;
     }
-    const authNote = serverEntry
-        ? ` with an ${TINYFISH_ACCESS_MODE_HEADER}: ${TINYFISH_KEYLESS_ACCESS_MODE} header`
-        : apiKey
-            ? ' with an API-key header — the key is stored in plaintext in that file (value not shown here)'
+    const authNote = apiKey
+        ? ' with an API-key header — the key is stored in plaintext in that file (value not shown here)'
+        : serverEntry
+            ? ` with an ${TINYFISH_ACCESS_MODE_HEADER}: ${TINYFISH_KEYLESS_ACCESS_MODE} header`
             : '';
     const nextEntry = serverEntry ?? buildTinyfishServerEntry(mcpUrl, apiKey);
     const servers = existing.parsed.mcpServers;

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

@@ -22,7 +22,7 @@ const BROWSER_SIGN_IN = new Set(ALL_HARNESSES.filter((harness) => {
     return !!native?.loginArgs;
 }));
 // 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));
+const KEY_REQUIRED = new Set(ALL_HARNESSES.filter((harness) => !!harnessSpec(harness).keyRequired));
 function headlessGate(base, oauthBudget, fixCommand) {
     const { harness } = base;
     // A CLI-login sign-in is interactive-only — unboundable headless.

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

@@ -3,6 +3,7 @@ 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 './config/cursor-config.js';
+import { commandCodeMcpPath, planCommandCodeWrite, removeCommandCodeMcpServer, } from './config/command-code-config.js';
 import { planOmpWrite, removeOmpMcpServer } from './config/omp-config.js';
 import { piMcpPath, planPiWrite, removePiMcpServer } from './config/pi-config.js';
 import { HERMES_KEY_VAR, hermesEnvPath, removeHermesKey, resolveHermesHome } from './hermes-env.js';
@@ -17,6 +18,8 @@ export function planText(harness, mcpUrl, apiKey) {
         return planOmpWrite(mcpUrl, apiKey);
     if (harness === 'pi')
         return planPiWrite(mcpUrl, apiKey);
+    if (harness === 'command-code')
+        return planCommandCodeWrite(mcpUrl, apiKey);
     if (harness === 'hermes' && apiKey) {
         return (`would run \`tinyfish connect hermes\` (harness-owned MCP write; the CLI writes ` +
             `${HERMES_KEY_VAR} to Hermes' .env, installs the tinyfish plugin from npm @latest, ` +
@@ -37,6 +40,9 @@ export function uninstallPlanText(harness) {
     if (harness === 'pi') {
         return `would remove the tinyfish entry from ${piMcpPath()}`;
     }
+    if (harness === 'command-code') {
+        return `would remove the tinyfish entry from ${commandCodeMcpPath()}`;
+    }
     if (!uninstallRuns(harness)) {
         return `would print \`${uninstallPointer(harness)}\` (no removal command exists)`;
     }
@@ -205,6 +211,10 @@ const MCP_JSON_UNINSTALLS = {
         remove: removePiMcpServer,
         fix: `Fix ${piMcpPath()} by hand, then re-run: tinyfish connect --all --uninstall`,
     },
+    'command-code': {
+        remove: removeCommandCodeMcpServer,
+        fix: `Fix ${commandCodeMcpPath()} by hand, then re-run: tinyfish connect --all --uninstall`,
+    },
 };
 function uninstallMcpJson(detection, spec) {
     let result;

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

@@ -109,8 +109,9 @@ export declare const OPENCLAW: SupportedCommand;
 /** "printed" = handed to the user to paste; the walkthrough was never started for them. */
 export type WalkthroughOutcome = 'launched' | 'printed';
 /** Awaited before the handover; track+flush must land pre-block. */
-type OnWalkthroughDecided = (outcome: WalkthroughOutcome) => void | Promise<void>;
+export type OnWalkthroughDecided = (outcome: WalkthroughOutcome) => void | Promise<void>;
 export declare function launchNativeMcpClient(client: NativeMcpClient, onDecided?: OnWalkthroughDecided, prompt?: string): Promise<WalkthroughOutcome>;
-export declare function launchOmpWalkthrough(onDecided?: OnWalkthroughDecided, prompt?: string): Promise<WalkthroughOutcome>;
-export declare function launchPiWalkthrough(onDecided?: OnWalkthroughDecided): Promise<WalkthroughOutcome>;
+export declare const launchOmpWalkthrough: (onDecided?: OnWalkthroughDecided, prompt?: string) => Promise<WalkthroughOutcome>;
+export declare const launchPiWalkthrough: (onDecided?: OnWalkthroughDecided, prompt?: string) => Promise<WalkthroughOutcome>;
+export declare const launchCommandCodeWalkthrough: (onDecided?: OnWalkthroughDecided, prompt?: string) => Promise<WalkthroughOutcome>;
 export declare function launchOpenClawWalkthrough(onDecided?: OnWalkthroughDecided): Promise<WalkthroughOutcome>;

package/dist/lib/connect-clients.js

@@ -228,21 +228,8 @@ function specAddArgs(spec, mcpUrl) {
         ? ['mcp', 'add', ...flags, 'tinyfish', mcpUrl]
         : ['mcp', 'add', 'tinyfish', '--url', mcpUrl, ...flags];
 }
-/** `mcp add` probes the server and runs OAuth; add-json only writes config. */
-function jsonAddArgs(spec, mcpUrl, apiKey) {
-    const { header } = spec;
-    const body = {
-        transport: 'http',
-        url: mcpUrl,
-        ...(header ? { headers: { [header.name]: `${header.valuePrefix ?? ''}${apiKey}` } } : {}),
-    };
-    return ['mcp', 'add-json', ...(spec.keyedAddJsonFlags ?? []), 'tinyfish', JSON.stringify(body)];
-}
 function specKeyAuth(spec) {
     const { header, keyEnvFlag, keyAddFlags } = spec;
-    if (spec.keyedAddJsonFlags) {
-        return { addArgs: (mcpUrl, apiKey) => jsonAddArgs(spec, mcpUrl, apiKey) };
-    }
     if (keyEnvFlag) {
         return {
             envVar: TINYFISH_API_KEY_VAR,
@@ -374,12 +361,10 @@ export async function launchNativeMcpClient(client, onDecided, prompt = DEFAULT_
         : handOverTerminal(client.command, [prompt], client.displayName), onDecided);
 }
 // Via deliverWalkthrough: handOverTerminal alone would wedge a headless --launch.
-export function launchOmpWalkthrough(onDecided, prompt = DEFAULT_ONBOARDING_PROMPT) {
-    return deliverWalkthrough('omp', 'omp', prompt, () => handOverTerminal('omp', [prompt], 'omp'), onDecided);
-}
-export function launchPiWalkthrough(onDecided) {
-    return deliverWalkthrough('Pi', 'pi', DEFAULT_ONBOARDING_PROMPT, () => handOverTerminal('pi', [DEFAULT_ONBOARDING_PROMPT], 'Pi'), onDecided);
-}
+const launchTerminalWalkthrough = (command, displayName) => (onDecided, prompt = DEFAULT_ONBOARDING_PROMPT) => deliverWalkthrough(displayName, command, prompt, () => handOverTerminal(command, [prompt], displayName), onDecided);
+export const launchOmpWalkthrough = launchTerminalWalkthrough('omp', 'omp');
+export const launchPiWalkthrough = launchTerminalWalkthrough('pi', 'Pi');
+export const launchCommandCodeWalkthrough = launchTerminalWalkthrough('commandcode', 'Command Code');
 export function launchOpenClawWalkthrough(onDecided) {
     return deliverWalkthrough('OpenClaw', 'openclaw', OPENCLAW_ONBOARDING_PROMPT, () => handOverTerminal('openclaw', ['chat', '--message', OPENCLAW_ONBOARDING_PROMPT], 'OpenClaw'), onDecided);
 }

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

@@ -1,4 +1,4 @@
 import type { AgentClient, ConnectAuthMode } from './connect-runtime.js';
-import { type NativeConnectOptions } from './connect-steps.js';
+import type { NativeConnectOptions } from './connect-steps.js';
 export declare function launchAgent(client: AgentClient): Promise<void>;
 export declare function connectHarness(harness: AgentClient, options: NativeConnectOptions): Promise<ConnectAuthMode | undefined>;

package/dist/lib/connect-harness.js

@@ -1,14 +1,13 @@
-import { KEYLESS_ONBOARDING_PROMPT, NATIVE_BY_HARNESS, launchNativeMcpClient, launchOmpWalkthrough, launchPiWalkthrough, launchOpenClawWalkthrough, } from './connect-clients.js';
-import { AuthMode } from './harness/harness-detect.js';
+import { NATIVE_BY_HARNESS, launchNativeMcpClient, launchCommandCodeWalkthrough, launchOmpWalkthrough, launchPiWalkthrough, launchOpenClawWalkthrough, } from './connect-clients.js';
 import { errLine } from './output.js';
 import { connectNativeMcpClient } from './connect-native.js';
 import { connectOpenClaw } from './connect-openclaw.js';
 import { connectConfigFileHarness, connectCursor } from './config/connect-config-file.js';
-import { finishSetupHint } from './connect-steps.js';
 /** Total over the non-native harnesses: a new one fails to compile until wired here. */
 const LAUNCH_OVERRIDES = {
-    omp: launchOmpWalkthrough,
-    pi: launchPiWalkthrough,
+    omp: () => launchOmpWalkthrough(),
+    pi: () => launchPiWalkthrough(),
+    'command-code': () => launchCommandCodeWalkthrough(),
     openclaw: launchOpenClawWalkthrough,
     // Cursor has no chat CLI to launch.
     cursor: () => {
@@ -35,31 +34,13 @@ const CONNECTOR_OVERRIDES = {
         }
         return undefined;
     },
-    omp: async (options) => {
-        const authMode = await connectConfigFileHarness('omp', options);
-        if (options.launch) {
-            try {
-                await launchOmpWalkthrough(undefined, authMode === AuthMode.Keyless ? KEYLESS_ONBOARDING_PROMPT : undefined);
-            }
-            catch (error) {
-                // Post-settle, like the native walkthrough step: never fail the connect.
-                errLine(error instanceof Error ? error.message : String(error));
-                errLine(finishSetupHint('omp'));
-            }
-        }
-        return authMode;
-    },
+    omp: (options) => connectConfigFileHarness('omp', options),
     pi: async (options) => {
         await connectConfigFileHarness('pi', options);
-        if (options.launch) {
-            try {
-                await launchPiWalkthrough();
-            }
-            catch (error) {
-                errLine(error instanceof Error ? error.message : String(error));
-                errLine(finishSetupHint('pi'));
-            }
-        }
+        return undefined;
+    },
+    'command-code': async (options) => {
+        await connectConfigFileHarness('command-code', options);
         return undefined;
     },
 };

package/dist/lib/connect-runtime.js

@@ -185,10 +185,14 @@ function throwProbeFailure(client, result) {
     if (result.error?.code === 'ETIMEDOUT') {
         const probe = `${client.command} ${client.supportCheck.args.join(' ')}`;
         throw new ConnectStepError(`${client.displayName} did not respond to \`${probe}\` within ` +
-            `${probeTimeoutMs(client) / 1000}s. Retry.`, 'timeout', { cause: result.error });
+            `${probeTimeoutMs(client) / 1000}s. Retry.`, 'timeout', { cause: result.error, failureDetail: spawnFailureDetail(result) });
     }
     // It ran and exited non-zero, so the version is still answerable.
-    throw new ConnectStepError(client.supportCheck.unavailableMessage, 'harness_command_unsupported', { cause: result.error, harnessVersion: probeHarnessVersion(client) });
+    throw new ConnectStepError(client.supportCheck.unavailableMessage, 'harness_command_unsupported', {
+        cause: result.error,
+        harnessVersion: probeHarnessVersion(client),
+        failureDetail: spawnFailureDetail(result),
+    });
 }
 function supportProbeOutput(client) {
     const result = spawn.sync(client.command, client.supportCheck.args, {

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

@@ -13,4 +13,3 @@ export declare const OPENCODE_MODEL_NOTE: string;
 export declare const KILO_MCP_ADD_UNAVAILABLE_MESSAGE: string;
 export declare const HERMES_RESTART_NOTE = "Restart your Hermes session to pick up TinyFish \u2014 Hermes discovers MCP servers at startup.";
 export declare const CLINE_MCP_ADD_UNAVAILABLE_MESSAGE: string;
-export declare const COMMAND_CODE_ADD_JSON_UNAVAILABLE_MESSAGE: string;

package/dist/lib/harness/harness-messages.js

@@ -53,6 +53,3 @@ export const HERMES_RESTART_NOTE = 'Restart your Hermes session to pick up TinyF
 export const CLINE_MCP_ADD_UNAVAILABLE_MESSAGE = 'Could not confirm this Cline installation supports non-interactive MCP setup: `cline mcp add ' +
     '--help` did not list `--transport` and `--yes`. Update Cline with `cline --update` and retry.' +
     SUPPORT_CHECK_DEBUG_HINT;
-export const COMMAND_CODE_ADD_JSON_UNAVAILABLE_MESSAGE = 'Could not confirm this Command Code installation supports keyed MCP setup: `commandcode mcp ' +
-    '--help` did not list `add-json`. Run `commandcode update` and retry.' +
-    SUPPORT_CHECK_DEBUG_HINT;

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

@@ -44,8 +44,6 @@ export interface HarnessSpec {
     keyEnvFlag?: string;
     /** Keyed adds append these flags; the key itself is seeded elsewhere (Hermes). */
     keyAddFlags?: string[];
-    /** Keyed adds go through `mcp add-json`, which takes the URL and header in its body. */
-    keyedAddJsonFlags?: string[];
     /** No sign-in exists here, so connect refuses a keyless install (Hermes). */
     keyRequired?: true;
     keylessFallback?: true;
@@ -163,23 +161,9 @@ export declare const HARNESS_SPECS: {
         configDir: string;
         reloadAction: string;
         skillAgent: "command-code";
-        supportCheck: {
-            args: string[];
-            patterns: RegExp[];
-            timeoutMs: number;
-            unavailableMessage: string;
-        };
         keyRequired: true;
-        header: {
-            name: string;
-            sep: ": ";
-            valuePrefix: string;
-        };
-        keyedAddJsonFlags: string[];
-        removals: {
-            args: string[];
-            label: string;
-        }[];
+        keyHeldByCli: true;
+        cliWritesConfig: true;
     };
     cursor: {
         command: string;
@@ -325,7 +309,7 @@ export declare const ALL_HARNESSES: readonly Harness[];
 export declare function harnessSpec(harness: Harness): HarnessSpec;
 /** The rest of the union: every one of these must supply a connect and launch override. */
 export type NonNativeHarness = {
-    [K in Harness]: 'urlStyle' extends keyof (typeof HARNESS_SPECS)[K] ? never : 'keyRequired' extends keyof (typeof HARNESS_SPECS)[K] ? never : K;
+    [K in Harness]: 'cliWritesConfig' extends keyof (typeof HARNESS_SPECS)[K] ? K : 'urlStyle' extends keyof (typeof HARNESS_SPECS)[K] ? never : 'keyRequired' extends keyof (typeof HARNESS_SPECS)[K] ? never : K;
 }[Harness];
 /** Native MCP harnesses generate an add; key-only ones generate only the keyed form. */
 export declare const NATIVE_HARNESSES: ("openclaw" | "omp" | "grok" | "cursor" | "codex" | "hermes" | "command-code" | "kilo" | "opencode" | "pi" | "cline" | "claude-code")[];

package/dist/lib/harness/harness-spec.js

@@ -1,7 +1,6 @@
 import { HERMES_PLUGIN_NAME } from '../constants.js';
-import { CLAUDE_CODE_DEFERRED_AUTH_NOTE, CLAUDE_CODE_KEYED_FALLBACK_NOTE, CLINE_MCP_ADD_UNAVAILABLE_MESSAGE, CODEX_DEFERRED_AUTH_NOTE, CODEX_KEYED_FALLBACK_NOTE, CODEX_MCP_URL_UNAVAILABLE_MESSAGE, COMMAND_CODE_ADD_JSON_UNAVAILABLE_MESSAGE, GROK_HTTP_UNAVAILABLE_MESSAGE, GROK_SIGN_IN_HINT, HERMES_OAUTH_UNAVAILABLE_MESSAGE, HERMES_RESTART_NOTE, KILO_MCP_ADD_UNAVAILABLE_MESSAGE, MCP_ADD_UNAVAILABLE_MESSAGE, OPENCLAW_SKILL_UNAVAILABLE_MESSAGE, OPENCODE_MCP_ADD_UNAVAILABLE_MESSAGE, OPENCODE_MODEL_NOTE, } from './harness-messages.js';
+import { CLAUDE_CODE_DEFERRED_AUTH_NOTE, CLAUDE_CODE_KEYED_FALLBACK_NOTE, CLINE_MCP_ADD_UNAVAILABLE_MESSAGE, CODEX_DEFERRED_AUTH_NOTE, CODEX_KEYED_FALLBACK_NOTE, CODEX_MCP_URL_UNAVAILABLE_MESSAGE, GROK_HTTP_UNAVAILABLE_MESSAGE, GROK_SIGN_IN_HINT, HERMES_OAUTH_UNAVAILABLE_MESSAGE, HERMES_RESTART_NOTE, KILO_MCP_ADD_UNAVAILABLE_MESSAGE, MCP_ADD_UNAVAILABLE_MESSAGE, OPENCLAW_SKILL_UNAVAILABLE_MESSAGE, OPENCODE_MCP_ADD_UNAVAILABLE_MESSAGE, OPENCODE_MODEL_NOTE, } from './harness-messages.js';
 const HEADER_FLAG = /(?:^|\s)--header(?:[\s<=]|$)/m;
-const ADD_JSON_COMMAND = /^\s*add-json(?:\s|\[)/m;
 /** One entry per harness; every per-harness list derives from it. */
 export const HARNESS_SPECS = {
     'claude-code': {
@@ -90,25 +89,10 @@ export const HARNESS_SPECS = {
         configDir: '.commandcode',
         reloadAction: 'restart it',
         skillAgent: 'command-code',
-        // add-json is the only command this harness uses, so it is what must exist.
-        supportCheck: {
-            args: ['mcp', '--help'],
-            patterns: [ADD_JSON_COMMAND],
-            // Command Code self-updates inside the probe, which outlasts the default budget.
-            timeoutMs: 30_000,
-            unavailableMessage: COMMAND_CODE_ADD_JSON_UNAVAILABLE_MESSAGE,
-        },
-        // Key-only: `cmd mcp add` runs browser OAuth even when a header is supplied.
+        // `commandcode mcp add` runs browser OAuth even when a header is supplied.
         keyRequired: true,
-        header: { name: 'Authorization', sep: ': ', valuePrefix: 'Bearer ' },
-        // Default scope is `local`, which writes a per-project entry instead of the user's.
-        keyedAddJsonFlags: ['--scope', 'user'],
-        removals: [
-            {
-                args: ['mcp', 'remove', 'tinyfish', '--scope', 'user'],
-                label: 'user TinyFish registration',
-            },
-        ],
+        keyHeldByCli: true,
+        cliWritesConfig: true,
     },
     cursor: {
         command: 'cursor-agent',
@@ -258,5 +242,7 @@ export function harnessSpec(harness) {
 /** Native MCP harnesses generate an add; key-only ones generate only the keyed form. */
 export const NATIVE_HARNESSES = ALL_HARNESSES.filter((harness) => {
     const spec = harnessSpec(harness);
+    if (spec.cliWritesConfig)
+        return false;
     return spec.urlStyle !== undefined || spec.keyRequired === true;
 });

package/package.json

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