@tiny-fish/cli 0.38.1-next.307 → 0.39.0

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 { CURSOR_SKILL_TARGET, OPENCLAW, OPENCLAW_SKILL_INSTALL_ARGS, NATIVE_BY_HARNESS, launchNativeMcpClient, launchOmpWalkthrough, launchOpenClawWalkthrough, openExternalUrl, } from '../lib/connect-clients.js';
+import { CURSOR_SKILL_TARGET, OPENCLAW, openclawSkillInstallArgs, NATIVE_BY_HARNESS, launchNativeMcpClient, launchOmpWalkthrough, 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';
@@ -474,7 +474,7 @@ export async function connectOpenClaw(options) {
         }
         state.stage = 'skill_install';
         errLine('Installing the TinyFish skill in OpenClaw...');
-        const skillInstallResult = spawn.sync('openclaw', OPENCLAW_SKILL_INSTALL_ARGS, captureStdio(options.verbose ?? false));
+        const skillInstallResult = spawn.sync('openclaw', openclawSkillInstallArgs(support.matchedVariant), captureStdio(options.verbose ?? false));
         if (skillInstallResult.error || skillInstallResult.status !== 0) {
             // Built first: its interrupt check must run before any replay.
             const error = spawnStepError('Could not install the TinyFish skill in OpenClaw', skillInstallResult);

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

@@ -1,7 +1,7 @@
 import spawn from 'cross-spawn';
 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[];
+export declare function openclawSkillInstallArgs(ackFlag: string | undefined): string[];
 /** `openclaw skills` has no uninstall; ClawHub removes from the global dir. */
 export declare function openclawSkillUninstall(): {
     command: string;

package/dist/lib/connect-clients.js

@@ -12,14 +12,10 @@ import { HERMES_PLUGIN_VERSION, installHermesPlugin, setHermesWebBackends, } fro
 const HERMES_SEED_TIMEOUT_MS = 120_000;
 const OPENCLAW_SKILL = '@tinyfish/tinyfish';
 // --force makes this an unconditional overwrite, so the same call installs and refreshes.
-export const OPENCLAW_SKILL_INSTALL_ARGS = [
-    'skills',
-    'install',
-    OPENCLAW_SKILL,
-    '--global',
-    '--force',
-    '--acknowledge-clawhub-risk',
-];
+export function openclawSkillInstallArgs(ackFlag) {
+    const ack = ackFlag === undefined ? [] : [ackFlag];
+    return ['skills', 'install', OPENCLAW_SKILL, '--global', '--force', ...ack];
+}
 /** `openclaw skills` has no uninstall; ClawHub removes from the global dir. */
 export function openclawSkillUninstall() {
     return {

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

@@ -92,9 +92,12 @@ export interface SupportedCommand {
     displayName: string;
     supportCheck: HarnessSupportCheck;
 }
+/** Refresh paths need the advertised alternative without connect's version probe. */
+export declare function probeSupportVariant(client: SupportedCommand): string | undefined;
 export declare function requireCommandSupport(client: SupportedCommand): {
     optionalSupported: boolean;
     keyAuthSupported: boolean;
+    matchedVariant?: string;
     harnessVersion?: string;
 };
 export declare function createConnectTelemetry(mcpUrl: string, client: AgentClient, opts?: {

package/dist/lib/connect-runtime.js

@@ -178,23 +178,26 @@ export async function runGuarded(state, telemetry, body) {
         await telemetry.flush();
     }
 }
+function probeTimeoutMs(client) {
+    return client.supportCheck.timeoutMs ?? NON_INTERACTIVE_TIMEOUT_MS;
+}
 function throwProbeFailure(client, result) {
     throwIfInterrupted(result);
     // A hung probe is a timeout, not a missing capability.
     if (result.error?.code === 'ETIMEDOUT') {
-        throw new ConnectStepError(client.supportCheck.unavailableMessage, 'timeout', {
-            cause: result.error,
-        });
+        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 });
     }
     // It ran and exited non-zero, so the version is still answerable.
-    throw new PrerequisiteError(client.supportCheck.unavailableMessage, 'harness_command_unsupported', { cause: result.error, harnessVersion: probeHarnessVersion(client.command) });
+    throw new PrerequisiteError(client.supportCheck.unavailableMessage, 'harness_command_unsupported', { cause: result.error, harnessVersion: probeHarnessVersion(client) });
 }
-export function requireCommandSupport(client) {
+function supportProbeOutput(client) {
     const result = spawn.sync(client.command, client.supportCheck.args, {
         encoding: 'utf8',
         // Agent harnesses export FORCE_COLOR, which makes clients colourise even a piped --help.
         env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1' },
-        timeout: NON_INTERACTIVE_TIMEOUT_MS,
+        timeout: probeTimeoutMs(client),
     });
     // 127 is the shell's not-found code; a wrapper shim with no real binary behind it exits that.
     if (commandNotFound(result.error) || result.status === 127) {
@@ -204,31 +207,63 @@ export function requireCommandSupport(client) {
         throwProbeFailure(client, result);
     }
     // Belt and braces with the colour env: a client that ignores NO_COLOR still has to match.
-    const output = sanitizeLine(`${result.stdout ?? ''}\n${result.stderr ?? ''}`);
-    const listed = (patterns) => patterns.every((pattern) => pattern.test(output));
-    const essential = listed(client.supportCheck.patterns);
-    const optionalSupported = listed(client.supportCheck.optionalPatterns ?? []);
+    return sanitizeLine(`${result.stdout ?? ''}\n${result.stderr ?? ''}`);
+}
+function debugProbeOutput(client, output) {
+    if (!process.env['TINYFISH_DEBUG'])
+        return;
+    errLine(`${client.command} ${client.supportCheck.args.join(' ')} printed:\n${output.trim()}`);
+}
+function requireEssential(client, output) {
+    if (client.supportCheck.patterns.every((pattern) => pattern.test(output)))
+        return;
+    debugProbeOutput(client, output);
+    throw new PrerequisiteError(client.supportCheck.unavailableMessage, 'harness_too_old', {
+        harnessVersion: probeHarnessVersion(client),
+    });
+}
+/** Absence is a fact; an unknown flag means an upstream rename. */
+function resolveVariant(client, output) {
+    const check = client.supportCheck;
+    // Token equality, not a built regex: exact on both edges, and no dynamic RegExp.
+    const listed = new Set(output.split(/[\s,=]+/));
+    const matched = check.variants?.find((flag) => listed.has(flag));
+    if (matched)
+        return matched;
+    const unknown = check.unknownVariant?.exec(output)?.[0];
+    if (unknown === undefined)
+        return undefined;
+    // Unacknowledged policy warnings can block the install; fail before it does.
+    debugProbeOutput(client, output);
+    throw new PrerequisiteError(`${client.displayName} lists \`${unknown}\`, which this TinyFish CLI does not recognise. ` +
+        'Upgrade the TinyFish CLI with `tinyfish upgrade` and retry.', 'harness_too_old', { harnessVersion: probeHarnessVersion(client) });
+}
+/** Refresh paths need the advertised alternative without connect's version probe. */
+export function probeSupportVariant(client) {
+    const output = supportProbeOutput(client);
+    requireEssential(client, output);
+    return resolveVariant(client, output);
+}
+export function requireCommandSupport(client) {
+    const output = supportProbeOutput(client);
+    requireEssential(client, output);
+    const optionalSupported = (client.supportCheck.optionalPatterns ?? []).every((pattern) => pattern.test(output));
     const keyAuthPattern = client.supportCheck.keyAuthPattern;
     const keyAuthSupported = keyAuthPattern ? keyAuthPattern.test(output) : true;
-    if ((!essential || !optionalSupported || !keyAuthSupported) && process.env['TINYFISH_DEBUG']) {
-        errLine(`${client.command} ${client.supportCheck.args.join(' ')} printed:\n${output.trim()}`);
-    }
-    if (!essential) {
-        throw new PrerequisiteError(client.supportCheck.unavailableMessage, 'harness_too_old', {
-            harnessVersion: probeHarnessVersion(client.command),
-        });
-    }
+    if (!optionalSupported || !keyAuthSupported)
+        debugProbeOutput(client, output);
     return {
         optionalSupported,
         keyAuthSupported,
-        harnessVersion: probeHarnessVersion(client.command),
+        matchedVariant: resolveVariant(client, output),
+        harnessVersion: probeHarnessVersion(client),
     };
 }
 /** Best-effort; the server rejects non-printable characters and >32 chars. */
-function probeHarnessVersion(command) {
-    const result = spawn.sync(command, ['--version'], {
+function probeHarnessVersion(client) {
+    const result = spawn.sync(client.command, ['--version'], {
         encoding: 'utf8',
-        timeout: NON_INTERACTIVE_TIMEOUT_MS,
+        timeout: probeTimeoutMs(client),
     });
     if (result.error || result.status !== 0)
         return undefined;

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

@@ -8,6 +8,12 @@ export interface HarnessSupportCheck {
     optionalPatterns?: RegExp[];
     /** Missing → this install cannot take a stored key; fall back to OAuth. */
     keyAuthPattern?: RegExp;
+    /** Ordered alternative flags in one help output; first match wins. */
+    variants?: string[];
+    /** Matches an alternative we do not know; renames fail loudly. */
+    unknownVariant?: RegExp;
+    /** Defaults to NON_INTERACTIVE_TIMEOUT_MS; raise for a slow cold start. */
+    timeoutMs?: number;
     unavailableMessage: string;
 }
 /** One entry per harness: every per-harness fact, and no behaviour. */
@@ -221,6 +227,9 @@ export declare const HARNESS_SPECS: {
         supportCheck: {
             args: string[];
             patterns: RegExp[];
+            variants: string[];
+            unknownVariant: RegExp;
+            timeoutMs: number;
             unavailableMessage: string;
         };
         signInViaCliLogin: true;

package/dist/lib/harness-spec.js

@@ -33,9 +33,8 @@ const GROK_HTTP_UNAVAILABLE_MESSAGE = 'Could not confirm this Grok installation
 const GROK_SIGN_IN_HINT = 'TinyFish is registered in Grok. Open Grok, run `/mcps`, select tinyfish, and press `i` to ' +
     'sign in.';
 const OPENCLAW_SKILL_UNAVAILABLE_MESSAGE = 'Could not confirm this OpenClaw installation supports global skill installation: `openclaw ' +
-    'skills install --help` did not list `--global` and `--acknowledge-clawhub-risk`. Update ' +
-    'OpenClaw and retry, or install manually with `openclaw skills install @tinyfish/tinyfish ' +
-    '--global --acknowledge-clawhub-risk`.' +
+    'skills install --help` did not list `--global`. Update OpenClaw and retry, or install ' +
+    'manually with `openclaw skills install @tinyfish/tinyfish --global`.' +
     SUPPORT_CHECK_DEBUG_HINT;
 const OPENCODE_MCP_ADD_UNAVAILABLE_MESSAGE = 'Could not confirm this OpenCode installation supports one-command MCP setup: `opencode mcp ' +
     'add --help` did not list `--url`. Update OpenCode and retry, or add TinyFish manually with ' +
@@ -202,7 +201,12 @@ export const HARNESS_SPECS = {
         reloadAction: 'restart it',
         supportCheck: {
             args: ['skills', 'install', '--help'],
-            patterns: [/--global(?:\s|$)/, /--acknowledge-clawhub-risk(?:\s|$)/],
+            patterns: [/--global(?:\s|$)/],
+            // Renamed in 2026.8.1; absent before 2026.7, where no trust gate existed.
+            variants: ['--acknowledge-install-policy-warning', '--acknowledge-clawhub-risk'],
+            unknownVariant: /--acknowledge-[a-z-]+/,
+            // 212MB dist; win32 cold starts drove most of the 10s timeouts.
+            timeoutMs: 30_000,
             unavailableMessage: OPENCLAW_SKILL_UNAVAILABLE_MESSAGE,
         },
         signInViaCliLogin: true,

package/dist/lib/skill-install.js

@@ -3,8 +3,8 @@ import spawn from 'cross-spawn';
 import { z } from 'zod';
 import { loadConfig } from './auth.js';
 import { captureStdio, capturedOutput, replay, SKILL_INSTALL_TIMEOUT_MS, STEP_MAX_BUFFER, } from './cli-install.js';
-import { CURSOR_SKILL_TARGET, NATIVE_MCP_CLIENTS, OPENCLAW_SKILL_INSTALL_ARGS, } from './connect-clients.js';
-import { commandNotFound, spawnFailureDetail, spawnStepError, throwIfInterrupted, } from './connect-runtime.js';
+import { CURSOR_SKILL_TARGET, NATIVE_MCP_CLIENTS, OPENCLAW, openclawSkillInstallArgs, } from './connect-clients.js';
+import { ConnectInterruptedError, ConnectStepError, probeSupportVariant, spawnFailureDetail, spawnStepError, throwIfInterrupted, } from './connect-runtime.js';
 import { CLI_AGENT_IDENTITY } from './constants.js';
 import { errLine } from './output.js';
 // Supports Hermes without node:util.styleText, so the installer still runs on Node 20.11.
@@ -128,16 +128,37 @@ export function updateWebSkill({ verbose }) {
         refreshed = reinstallOpenClawSkill(verbose) || refreshed;
     return refreshed;
 }
+/** OpenClaw rejects an unknown ack flag, so never guess. */
+function openclawAckFlag() {
+    try {
+        return { ok: true, flag: probeSupportVariant(OPENCLAW) };
+    }
+    catch (error) {
+        // Ctrl+C during the probe must still abort the upgrade, not skip a step.
+        if (error instanceof ConnectInterruptedError)
+            throw error;
+        // A stale context entry must not fail an otherwise successful upgrade.
+        if (error instanceof ConnectStepError) {
+            const detail = error.failureReason === 'harness_not_installed'
+                ? 'OpenClaw is not on PATH.'
+                : error.message;
+            return { ok: false, reason: `${detail} Its TinyFish skill was left unchanged.` };
+        }
+        return {
+            ok: false,
+            reason: "Could not read OpenClaw's skill installer options, so its TinyFish skill was left unchanged.",
+        };
+    }
+}
 function reinstallOpenClawSkill(verbose) {
     if (verbose)
         errLine('Refreshing the TinyFish skill in OpenClaw...');
-    const result = spawn.sync('openclaw', OPENCLAW_SKILL_INSTALL_ARGS, captureStdio(verbose));
-    // OpenClaw may have been removed since connect; a stale context entry must not fail an
-    // upgrade that otherwise succeeded.
-    if (commandNotFound(result.error)) {
-        errLine('OpenClaw is not on PATH, so its TinyFish skill was left unchanged.');
+    const ack = openclawAckFlag();
+    if (!ack.ok) {
+        errLine(ack.reason);
         return false;
     }
+    const result = spawn.sync('openclaw', openclawSkillInstallArgs(ack.flag), captureStdio(verbose));
     if (result.error || result.status !== 0) {
         throwIfInterrupted(result);
         replay(capturedOutput(result));

package/package.json

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