@tiny-fish/cli 0.35.1-next.291 → 0.35.1-next.292

package/dist/commands/connect.d.ts

@@ -23,11 +23,6 @@ export interface NativeConnectOptions {
     /** Targeted connects only: --all keeps its per-harness failed row. */
     fallbackWhenMissing?: boolean;
 }
-export declare function connectClaudeCode(options: NativeConnectOptions): Promise<ConnectAuthMode | undefined>;
-export declare function connectCodex(options: NativeConnectOptions): Promise<ConnectAuthMode | undefined>;
-export declare function connectGrok(options: NativeConnectOptions): Promise<ConnectAuthMode | undefined>;
-export declare function connectHermes(options: NativeConnectOptions): Promise<ConnectAuthMode | undefined>;
-export declare function connectOpencode(options: NativeConnectOptions): Promise<ConnectAuthMode | undefined>;
 export declare function connectOpenClaw(options: {
     apiKey?: string;
     mcpUrl: string;
@@ -50,4 +45,5 @@ export declare function connectCursor(options: {
     verbose?: boolean;
 }): Promise<void>;
 export declare function launchAgent(client: AgentClient): Promise<void>;
+export declare function connectHarness(harness: AgentClient, options: NativeConnectOptions): Promise<ConnectAuthMode | undefined>;
 export declare function registerConnect(program: Command): void;

package/dist/commands/connect.js

@@ -1,6 +1,6 @@
 import spawn from 'cross-spawn';
 import { CONNECT_SOURCE, persistApiKeyToEnvironment, saveConnectContext, validateKeyFormat, validatedApiKey, } from '../lib/auth.js';
-import { CLAUDE_CODE, CODEX, CURSOR_SKILL_TARGET, GROK, HERMES, OPENCLAW, OPENCLAW_SKILL_INSTALL_ARGS, OPENCODE, launchNativeMcpClient, launchOpenClawWalkthrough, openExternalUrl, } from '../lib/connect-clients.js';
+import { CURSOR_SKILL_TARGET, OPENCLAW, OPENCLAW_SKILL_INSTALL_ARGS, NATIVE_BY_HARNESS, launchNativeMcpClient, launchOpenClawWalkthrough, openExternalUrl, } from '../lib/connect-clients.js';
 import { captureStdio, capturedOutput, HoistedFailureReportedError, installTinyFishCli, replay, SKILL_INSTALL_TIMEOUT_MS, STEP_MAX_BUFFER, } from '../lib/cli-install.js';
 import { ensureCliAuthenticated } from '../lib/connect-auth.js';
 import { createStdinPrompt, runCliFallback } from '../lib/connect-fallback.js';
@@ -8,7 +8,7 @@ import { installWebSkill } from '../lib/skill-install.js';
 import { ConnectInterruptedError, ConnectStepError, createConnectTelemetry, finishSetupCommand, requireCommandSupport, runGuarded, settle, SignInTimeoutError, spawnStepError, stageDurationOf, withStageDuration, spawnRemoval, } from '../lib/connect-runtime.js';
 import { cursorInstallDeeplink, cursorMcpPath, readCursorTinyfishEntry, writeCursorMcpConfig, } from '../lib/cursor-config.js';
 import { runConnectAll } from '../lib/connect-all.js';
-import { AuthMode, RELOAD_ACTION } from '../lib/harness-detect.js';
+import { ALL_HARNESSES, AuthMode, RELOAD_ACTION } from '../lib/harness-detect.js';
 import { detectHumanInitiated } from '../lib/harness.js';
 import { TINYFISH_API_KEY_VAR } from '../lib/constants.js';
 import { emitNotice } from '../lib/notice.js';
@@ -442,21 +442,6 @@ function trackPostInstallFailure(displayName, state, telemetry, error) {
     errLine(`The ${displayName} MCP connection succeeded, but a finishing step ` +
         `(${state.stage}) failed: ${error instanceof Error ? error.message : String(error)}`);
 }
-export async function connectClaudeCode(options) {
-    return connectNativeMcpClient(CLAUDE_CODE, options);
-}
-export async function connectCodex(options) {
-    return connectNativeMcpClient(CODEX, options);
-}
-export async function connectGrok(options) {
-    return connectNativeMcpClient(GROK, options);
-}
-export async function connectHermes(options) {
-    return connectNativeMcpClient(HERMES, options);
-}
-export async function connectOpencode(options) {
-    return connectNativeMcpClient(OPENCODE, options);
-}
 export async function connectOpenClaw(options) {
     const telemetry = createConnectTelemetry(options.mcpUrl, 'openclaw', options);
     // Skill install, no MCP server — never degraded, and false keeps it inside a `= false` filter.
@@ -620,38 +605,46 @@ function launchCursorDeeplink(mcpUrl) {
     const result = openExternalUrl(cursorInstallDeeplink(mcpUrl));
     return !result.error && result.status === 0;
 }
-// A new client fails to compile until wired here.
-const AGENT_LAUNCHERS = {
-    'claude-code': () => launchNativeMcpClient(CLAUDE_CODE),
-    codex: () => launchNativeMcpClient(CODEX),
-    grok: () => launchNativeMcpClient(GROK),
-    hermes: () => launchNativeMcpClient(HERMES),
-    opencode: () => launchNativeMcpClient(OPENCODE),
+/** Total over the non-native harnesses: a new one fails to compile until wired here. */
+const LAUNCH_OVERRIDES = {
     openclaw: launchOpenClawWalkthrough,
     // Cursor has no chat CLI to launch.
     cursor: () => {
         throw new Error('Cursor has no launchable walkthrough. Open Cursor and start chatting.');
     },
 };
+const isNonNative = (harness) => harness in LAUNCH_OVERRIDES;
 export async function launchAgent(client) {
-    await AGENT_LAUNCHERS[client]();
-}
-// A new client fails to compile until wired here.
-const CLIENT_CONNECTORS = {
-    'claude-code': connectClaudeCode,
-    codex: connectCodex,
-    grok: connectGrok,
-    hermes: connectHermes,
-    opencode: connectOpencode,
-    openclaw: connectOpenClaw,
-    // `connect cursor --launch` still connects; it just cannot launch after.
+    if (isNonNative(client))
+        return void (await LAUNCH_OVERRIDES[client]());
+    await launchNativeMcpClient(requireNative(client));
+}
+/** Total over the non-native harnesses; native harnesses use the descriptor engine. */
+const CONNECTOR_OVERRIDES = {
+    openclaw: async (options) => {
+        await connectOpenClaw(options);
+        return undefined;
+    },
     cursor: async (options) => {
         await connectCursor(options);
+        // `connect cursor --launch` still connects; it just cannot launch after.
         if (options.launch) {
             errLine('Cursor has no launchable walkthrough. Open Cursor and start chatting.');
         }
+        return undefined;
     },
 };
+function requireNative(harness) {
+    const client = NATIVE_BY_HARNESS.get(harness);
+    if (!client)
+        throw new Error(`No native MCP descriptor for ${harness}`);
+    return client;
+}
+export async function connectHarness(harness, options) {
+    if (isNonNative(harness))
+        return CONNECTOR_OVERRIDES[harness](options);
+    return connectNativeMcpClient(requireNative(harness), options);
+}
 function parseMcpUrlOption(options) {
     let mcpUrl = options.url ?? DEFAULT_MCP_URL;
     if (mcpUrl.startsWith('-')) {
@@ -729,13 +722,10 @@ async function connectSingleClient(client, options, mcpUrl, attemptId) {
         fallbackWhenMissing: true,
         verbose: options.verbose ?? false,
     };
-    const connector = CLIENT_CONNECTORS[client];
-    if (!connector) {
-        throw new Error('Unsupported client: ' +
-            client +
-            '. Supported clients: claude-code, codex, cursor, grok, hermes, openclaw, opencode');
+    if (!ALL_HARNESSES.includes(client)) {
+        throw new Error('Unsupported client: ' + client + '. Supported clients: ' + ALL_HARNESSES.join(', '));
     }
-    await connector(connectOptions);
+    await connectHarness(client, connectOptions);
 }
 export function registerConnect(program) {
     program

package/dist/commands/doctor.js

@@ -11,7 +11,7 @@ import { verifyMcpAuth, verifyMcpHealth } from '../lib/verify.js';
 import { resolveHermesHome } from '../lib/hermes-env.js';
 import { hermesWebBackendsOurs, readHermesPluginStatus, } from '../lib/hermes-plugin.js';
 import { DEFAULT_MCP_URL, endpointOf, isDefaultEndpoint } from '../lib/mcp-endpoint.js';
-import { connectClaudeCode, connectCodex, connectCursor, connectGrok, connectHermes, connectOpenClaw, connectOpencode, } from './connect.js';
+import { connectHarness } from './connect.js';
 // A green auth mode with a red auth call proves nothing, so the call's verdict gates the claim.
 function provesHarnessReach(status, keyAuth, healthOk, mcpUrl) {
     // An endpoint doctor could not reach proves nothing about a harness pointed at it.
@@ -375,21 +375,12 @@ function runAuthLogin() {
         throw new Error(`\`tinyfish auth login\` exited ${result.status ?? 'unknown'}`);
     }
 }
-const CONNECTORS = {
-    'claude-code': (opts) => connectClaudeCode({ ...opts, launch: false }),
-    codex: (opts) => connectCodex({ ...opts, launch: false }),
-    cursor: (opts) => connectCursor(opts),
-    grok: (opts) => connectGrok({ ...opts, launch: false }),
-    hermes: (opts) => connectHermes({ ...opts, launch: false }),
-    openclaw: (opts) => connectOpenClaw({ ...opts, launch: false }),
-    opencode: (opts) => connectOpencode({ ...opts, launch: false }),
-};
 /** Dispatches on `action`, never on a null harness: that conflation made the credential fix a no-op. */
 async function runRepair(repair, mcpUrl) {
     if (repair.action === 'auth-login')
         return runAuthLogin();
     if (repair.harness)
-        await CONNECTORS[repair.harness]({ mcpUrl });
+        await connectHarness(repair.harness, { mcpUrl, launch: false });
 }
 export async function applyRepairs(repairs, options) {
     const interactive = detectHumanInitiated();

package/dist/commands/onboard.js

@@ -3,19 +3,22 @@ import { getApiKey, saveConfig } from '../lib/auth.js';
 import { fetchContentGet, searchQuery } from '../lib/client.js';
 import { BASE_URL, TINYFISH_API_KEY_VAR } from '../lib/constants.js';
 import { errLine, handleApiError, outLine } from '../lib/output.js';
-import { connectClaudeCode, connectCodex, connectHermes, connectOpenClaw, connectOpencode, launchAgent, } from './connect.js';
+import { connectHarness, launchAgent } from './connect.js';
+import { HARNESS_DISPLAY_NAMES } from '../lib/harness-detect.js';
 const EXAMPLE_QUERIES = [
     'What are recent changes in the AI dev stack? Give me the top 5 changes that matter, why they matter, and any action needed.',
     'Find a new-grad software engineering role posted in the last 24 hours and fetch the job description.',
     "Analyse today's market and recommend the best investments for $5,000 with expected returns and risks.",
 ];
-const AGENTS = [
-    { id: 'claude-code', label: 'Claude Code', connect: connectClaudeCode },
-    { id: 'codex', label: 'Codex', connect: connectCodex },
-    { id: 'hermes', label: 'Hermes', connect: connectHermes },
-    { id: 'openclaw', label: 'OpenClaw', connect: connectOpenClaw },
-    { id: 'opencode', label: 'OpenCode', connect: connectOpencode },
+/** Onboarding's own shortlist, not every harness; order is the menu order. */
+const AGENT_IDS = [
+    'claude-code',
+    'codex',
+    'hermes',
+    'openclaw',
+    'opencode',
 ];
+const AGENTS = AGENT_IDS.map((id) => ({ id, label: HARNESS_DISPLAY_NAMES[id] }));
 function cleanFetchedContent(text) {
     const cleaned = text
         .replace(/!\[[^\]]*\]\([^)]+\)/g, '')
@@ -82,16 +85,12 @@ const page = await client.fetch.getContents({ urls: [topUrl], format: "markdown"
 console.log(page.results[0]?.text);`;
 }
 async function connectAgent(id) {
-    const agent = AGENTS.find((candidate) => candidate.id === id);
-    if (!agent)
-        return;
     const mcpUrl = new URL('/mcp', BASE_URL).toString();
-    if (id === 'openclaw') {
-        await connectOpenClaw({ mcpUrl, launch: false, cliInstall: false });
-    }
-    else {
-        await agent.connect({ mcpUrl, launch: false });
-    }
+    await connectHarness(id, {
+        mcpUrl,
+        launch: false,
+        ...(id === 'openclaw' ? { cliInstall: false } : {}),
+    });
 }
 function parseSelectedAgent(value, selected) {
     if (!value.trim())

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

@@ -1,4 +1,5 @@
-import { HARNESS_CAPABILITIES, NATIVE_BY_HARNESS } from './connect-clients.js';
+import { NATIVE_BY_HARNESS } from './connect-clients.js';
+import { harnessSpec } from './harness-spec.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';
@@ -25,7 +26,7 @@ const KEY_REQUIRED = new Set(ALL_HARNESSES.filter((harness) => !!NATIVE_BY_HARNE
 function headlessGate(base, oauthBudget, fixCommand) {
     const { harness } = base;
     // A CLI-login sign-in is interactive-only — unboundable headless.
-    if (HARNESS_CAPABILITIES[harness].signInViaCliLogin) {
+    if (harnessSpec(harness).signInViaCliLogin) {
         return {
             result: { ...base, outcome: 'auth_pending', fixCommand },
             headlessAuth: false,

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

@@ -1,5 +1,5 @@
-import { HARNESS_CAPABILITIES } from './connect-clients.js';
 import { finishSetupCommand } from './connect-runtime.js';
+import { harnessSpec } from './harness-spec.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([
@@ -83,7 +83,7 @@ function installedSummaryLine(result) {
             `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 authDeferred = harnessSpec(result.harness).authDeferredAtInstall && !result.keyAuthed;
     const verifyLabel = result.verifyDepth ? `verified: ${result.verifyDepth}` : 'not verified';
     if (authDeferred || result.verifyOk === false) {
         const reason = authDeferred

package/dist/lib/connect-all.js

@@ -1,12 +1,13 @@
 import * as readline from 'node:readline/promises';
+import { harnessSpec } from './harness-spec.js';
 import spawn from 'cross-spawn';
-import { connectClaudeCode, connectCodex, connectCursor, connectGrok, connectHermes, connectOpenClaw, connectOpencode, } from '../commands/connect.js';
+import { connectHarness } from '../commands/connect.js';
 import { loadConfig, validatedApiKey } from './auth.js';
 import { installTinyFishCli, } from './cli-install.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 { NATIVE_BY_HARNESS } from './connect-clients.js';
 import { createStdinPrompt, runCliFallback } from './connect-fallback.js';
 import { ConnectInterruptedError } from './connect-runtime.js';
 import { pickHarnesses } from './connect-picker.js';
@@ -18,26 +19,9 @@ import { sendSetupCompleted, sendSetupStarted, } from './setup-telemetry.js';
 import { verifyMcpAuth, verifyMcpHealth } from './verify.js';
 const STEP_INDENT = '  ';
 // 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));
-// A new harness fails to compile until wired here.
-const HARNESS_CONNECTORS = {
-    'claude-code': connectClaudeCode,
-    codex: connectCodex,
-    grok: connectGrok,
-    hermes: connectHermes,
-    opencode: connectOpencode,
-    // Without the key the child shells an interactive `tinyfish auth login`.
-    openclaw: async (base) => {
-        await connectOpenClaw(base);
-        return undefined;
-    },
-    cursor: async (base) => {
-        await connectCursor({ apiKey: base.apiKey, mcpUrl: base.mcpUrl, verbose: base.verbose });
-        return undefined;
-    },
-};
+const KEY_AUTH_CAPABLE = new Set(ALL_HARNESSES.filter((harness) => !!NATIVE_BY_HARNESS.get(harness)?.keyAuth || harnessSpec(harness).keyHeldByCli));
 async function runHarnessConnect(harness, opts, extras) {
-    return HARNESS_CONNECTORS[harness]({
+    return connectHarness(harness, {
         apiKey: opts.apiKey,
         mcpUrl: opts.mcpUrl,
         launch: false,
@@ -70,7 +54,7 @@ function runHoistedCliInstall(verbose) {
 async function verifyHarness(harness, mcpUrl, keyed, apiKey) {
     const health = await verifyMcpHealth(mcpUrl);
     // The own-OAuth harnesses are auth-checkable only in key mode (key-authed config).
-    const capable = HARNESS_CAPABILITIES[harness].canVerifyAuth || keyed;
+    const capable = harnessSpec(harness).canVerifyAuth || keyed;
     if (!capable || !health.ok)
         return health;
     if (!apiKey)
@@ -158,9 +142,7 @@ function noWorkOutcome(d, uninstall) {
 }
 /** A config-writing connect needs no binary; every other harness spawns one. */
 function isStaleConfig(detection) {
-    return (detection.detected &&
-        !detection.binaryOnPath &&
-        !HARNESS_CAPABILITIES[detection.harness].cliWritesConfig);
+    return (detection.detected && !detection.binaryOnPath && !harnessSpec(detection.harness).cliWritesConfig);
 }
 async function resolvePick(detections, opts, prompt) {
     let deselected = new Set();
@@ -187,7 +169,7 @@ function hoistCliIfNeeded(detections, opts, willAttempt) {
         !opts.uninstall &&
         detections.some((d) => d.detected &&
             d.binaryOnPath &&
-            !HARNESS_CAPABILITIES[d.harness].cliWritesConfig &&
+            !harnessSpec(d.harness).cliWritesConfig &&
             willAttempt(d.harness));
     if (!cliNeeded)
         return undefined;
@@ -339,7 +321,7 @@ export async function runConnectAll(opts) {
     // Mirrors processHarness's gate: headless, only keyless CLI-login harnesses skip.
     const willAttempt = (harness) => !deselected.has(harness) &&
         (isTTY ||
-            !HARNESS_CAPABILITIES[harness].signInViaCliLogin ||
+            !harnessSpec(harness).signInViaCliLogin ||
             (!!gateKey && KEY_AUTH_CAPABLE.has(harness)));
     const hoisted = hoistCliIfNeeded(detections, opts, willAttempt);
     if (hoisted === 'interrupted') {

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

@@ -1,5 +1,4 @@
 import spawn from 'cross-spawn';
-import { type Harness } from './harness-detect.js';
 import { type AgentClient, type SupportedCommand } from './connect-runtime.js';
 import { type HarnessSpec, type SkillAgent } from './harness-spec.js';
 export declare const OPENCLAW_SKILL_INSTALL_ARGS: readonly string[];
@@ -97,15 +96,7 @@ export declare function hermesRegistrationEnabled(home: string): {
 export declare const NATIVE_MCP_CLIENTS: readonly NativeMcpClient[];
 /** Native descriptor by harness id; Cursor and OpenClaw have none. */
 export declare const NATIVE_BY_HARNESS: Map<"openclaw" | "grok" | "cursor" | "codex" | "hermes" | "opencode" | "claude-code", NativeMcpClient>;
-export declare const CLAUDE_CODE: NativeMcpClient;
-export declare const CODEX: NativeMcpClient;
-export declare const GROK: NativeMcpClient;
-export declare const HERMES: NativeMcpClient;
-export declare const OPENCODE: NativeMcpClient;
 export declare const OPENCLAW: SupportedCommand;
-/** Traits with no native descriptor to live on (Cursor and OpenClaw included). */
-export type HarnessCapabilities = Pick<HarnessSpec, 'signInViaCliLogin' | 'canVerifyAuth' | 'keyHeldByCli' | 'cliWritesConfig' | 'authDeferredAtInstall'>;
-export declare const HARNESS_CAPABILITIES: Record<Harness, HarnessCapabilities>;
 /** "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. */

package/dist/lib/connect-clients.js

@@ -5,7 +5,7 @@ import { harnessConfigPath } from './harness-detect.js';
 import { errLine, sanitizeLine, warnLine } from './output.js';
 import { ConnectStepError, spawnStepError, } from './connect-runtime.js';
 import { TINYFISH_API_KEY_VAR } from './constants.js';
-import { ALL_HARNESSES, HARNESS_SPECS, NATIVE_HARNESSES, harnessSpec, } from './harness-spec.js';
+import { HARNESS_SPECS, NATIVE_HARNESSES, harnessSpec, } from './harness-spec.js';
 import { HERMES_KEY_VAR, captureHermesKeyRestore, hermesEnvPath, resolveHermesHome, writeHermesKey, } from './hermes-env.js';
 import { hermesConfigPath, readHermesEntry } from './hermes-config.js';
 import { installHermesPlugin, setHermesWebBackends } from './hermes-plugin.js';
@@ -254,35 +254,11 @@ function toNativeClient(harness) {
 export const NATIVE_MCP_CLIENTS = NATIVE_HARNESSES.map(toNativeClient);
 /** Native descriptor by harness id; Cursor and OpenClaw have none. */
 export const NATIVE_BY_HARNESS = new Map(NATIVE_MCP_CLIENTS.map((client) => [client.connectClient, client]));
-function nativeClient(harness) {
-    const client = NATIVE_BY_HARNESS.get(harness);
-    if (!client)
-        throw new Error(`${harness} is not a native MCP client`);
-    return client;
-}
-export const CLAUDE_CODE = nativeClient('claude-code');
-export const CODEX = nativeClient('codex');
-export const GROK = nativeClient('grok');
-export const HERMES = nativeClient('hermes');
-export const OPENCODE = nativeClient('opencode');
 export const OPENCLAW = {
     command: HARNESS_SPECS.openclaw.command,
     displayName: HARNESS_SPECS.openclaw.displayName,
     supportCheck: HARNESS_SPECS.openclaw.supportCheck,
 };
-export const HARNESS_CAPABILITIES = Object.fromEntries(ALL_HARNESSES.map((harness) => {
-    const spec = harnessSpec(harness);
-    return [
-        harness,
-        {
-            signInViaCliLogin: spec.signInViaCliLogin,
-            canVerifyAuth: spec.canVerifyAuth,
-            keyHeldByCli: spec.keyHeldByCli,
-            cliWritesConfig: spec.cliWritesConfig,
-            authDeferredAtInstall: spec.authDeferredAtInstall,
-        },
-    ];
-}));
 function printPromptForHandoff(displayName, command, prompt, reason) {
     // "set up", not "connected": sign-in can still be deferred here.
     errLine(`TinyFish is set up in ${displayName}.`);

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

@@ -247,5 +247,9 @@ export declare const HARNESS_SPECS: {
 export type Harness = keyof typeof HARNESS_SPECS;
 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 : K;
+}[Harness];
 /** Native MCP harnesses carry add-generation fields; the rest override connect. */
 export declare const NATIVE_HARNESSES: ("openclaw" | "grok" | "cursor" | "codex" | "hermes" | "opencode" | "claude-code")[];

package/package.json

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