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

package/dist/lib/connect-fallback.js

@@ -1,21 +1,21 @@
-import * as readline from "node:readline/promises";
-import spawn from "cross-spawn";
-import { resolvedApiKey, validateKeyFormat } from "./auth.js";
-import { installTinyFishCli } from "./cli-install.js";
-import { ensureCliAuthenticated, TINYFISH_CLI_NOT_FOUND_MESSAGE } from "./connect-auth.js";
-import { TINYFISH_API_KEY_VAR } from "./constants.js";
-import { commandNotFound, ConnectInterruptedError, ConnectStepError, throwIfInterrupted, } from "./connect-runtime.js";
-import { errLine, outLine } from "./output.js";
+import * as readline from 'node:readline/promises';
+import spawn from 'cross-spawn';
+import { resolvedApiKey, validateKeyFormat } from './auth.js';
+import { installTinyFishCli } from './cli-install.js';
+import { ensureCliAuthenticated, TINYFISH_CLI_NOT_FOUND_MESSAGE } from './connect-auth.js';
+import { TINYFISH_API_KEY_VAR } from './constants.js';
+import { commandNotFound, ConnectInterruptedError, ConnectStepError, throwIfInterrupted, } from './connect-runtime.js';
+import { errLine, outLine } from './output.js';
 export const SEARCH_RETRY = 'tinyfish search query --pretty -- "<your query>"';
 // Echoes the finale suggestion, so headless rescues rehearse the same task.
 export const DEFAULT_VERIFICATION_QUERY = "today's top Hacker News story";
 // Must undercut agent tool-call budgets (Claude Code Bash defaults to 120s).
 const HEADLESS_VERIFY_TIMEOUT_MS = 90_000;
 // An exported var must be unset, not re-logged-in.
-export const MALFORMED_ENV_KEY_MESSAGE = "TINYFISH_API_KEY is set but malformed; it will override any stored key. Fix or unset it, then re-run.";
-export const MALFORMED_STORED_KEY_MESSAGE = "The stored TinyFish API key is malformed. Run: tinyfish auth login";
+export const MALFORMED_ENV_KEY_MESSAGE = 'TINYFISH_API_KEY is set but malformed; it will override any stored key. Fix or unset it, then re-run.';
+export const MALFORMED_STORED_KEY_MESSAGE = 'The stored TinyFish API key is malformed. Run: tinyfish auth login';
 function searchRetry(query) {
-    if (process.platform === "win32")
+    if (process.platform === 'win32')
         return SEARCH_RETRY;
     return `tinyfish search query --pretty -- '${query.replaceAll("'", "'\\''")}'`;
 }
@@ -24,14 +24,14 @@ export function createStdinPrompt() {
     let stdinClosed = false;
     return async (question) => {
         if (stdinClosed)
-            throw new Error("stdin is closed");
+            throw new Error('stdin is closed');
         const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
         // Without a close-linked signal, question() never settles on Ctrl+D.
         const closed = new AbortController();
-        rl.on("close", () => closed.abort());
+        rl.on('close', () => closed.abort());
         // Raw mode swallows Ctrl+C here; resurface it as the interrupt.
         let interrupted = false;
-        rl.on("SIGINT", () => {
+        rl.on('SIGINT', () => {
             interrupted = true;
             rl.close();
         });
@@ -40,7 +40,7 @@ export function createStdinPrompt() {
         }
         catch (error) {
             if (interrupted)
-                throw new ConnectInterruptedError("Setup interrupted");
+                throw new ConnectInterruptedError('Setup interrupted');
             stdinClosed = true;
             throw error;
         }
@@ -52,7 +52,7 @@ export function createStdinPrompt() {
 /** Steps print retry lines and return outcomes; only interrupts throw. */
 export async function runCliFallback(opts) {
     const { hooks, prompt } = opts;
-    hooks?.onStepStart?.("cli_install");
+    hooks?.onStepStart?.('cli_install');
     try {
         installTinyFishCli({ verbose: opts.verbose, announce: true });
     }
@@ -61,26 +61,26 @@ export async function runCliFallback(opts) {
             throw error;
         errLine(error instanceof Error ? error.message : String(error));
         outLine(`Retry: ${opts.retryCommand}`);
-        return "cli_install_failed";
+        return 'cli_install_failed';
     }
-    hooks?.onStepDone?.("cli_installed");
-    hooks?.onStepStart?.("authentication");
+    hooks?.onStepDone?.('cli_installed');
+    hooks?.onStepStart?.('authentication');
     // Resolved raw: validatedApiKey collapses a malformed key into "no key".
     const rawKey = resolvedApiKey(opts.apiKey);
     if (rawKey && !validateKeyFormat(rawKey)) {
         // Terminal even in a TTY: login writes config; env shadows it.
         errLine(process.env[TINYFISH_API_KEY_VAR] ? MALFORMED_ENV_KEY_MESSAGE : MALFORMED_STORED_KEY_MESSAGE);
         outLine(`Retry: ${opts.retryCommand}`);
-        return "invalid_credentials";
+        return 'invalid_credentials';
     }
     if (!prompt && !rawKey) {
         outLine(`Retry in a terminal: ${opts.retryCommand}`);
-        return "no_credentials";
+        return 'no_credentials';
     }
     try {
         // Gate-only widening: a config-only key must not re-persist anywhere.
         // Headless has no one to answer a login prompt; never inherit stdio there.
-        ensureCliAuthenticated("cli", opts.apiKey ?? process.env[TINYFISH_API_KEY_VAR], {
+        ensureCliAuthenticated('cli', opts.apiKey ?? process.env[TINYFISH_API_KEY_VAR], {
             interactiveLogin: !!prompt,
         });
     }
@@ -88,49 +88,49 @@ export async function runCliFallback(opts) {
         if (error instanceof ConnectInterruptedError)
             throw error;
         errLine(error instanceof Error ? error.message : String(error));
-        outLine(error instanceof ConnectStepError && error.failureReason === "command_not_found"
-            ? "Retry in a new terminal: tinyfish auth login"
-            : "Retry: tinyfish auth login");
-        return "authentication_failed";
+        outLine(error instanceof ConnectStepError && error.failureReason === 'command_not_found'
+            ? 'Retry in a new terminal: tinyfish auth login'
+            : 'Retry: tinyfish auth login');
+        return 'authentication_failed';
     }
-    hooks?.onStepDone?.("authenticated");
-    hooks?.onStepStart?.("cli_verification");
+    hooks?.onStepDone?.('authenticated');
+    hooks?.onStepStart?.('cli_verification');
     let query;
     if (prompt) {
         try {
-            query = (await prompt("What would you like to search? ")).trim();
+            query = (await prompt('What would you like to search? ')).trim();
         }
         catch (error) {
             if (error instanceof ConnectInterruptedError)
                 throw error;
             outLine(`Retry: ${SEARCH_RETRY}`);
-            return "abandoned";
+            return 'abandoned';
         }
         if (!query) {
             outLine(`Retry: ${SEARCH_RETRY}`);
-            return "abandoned";
+            return 'abandoned';
         }
     }
     else {
         // Headless with a key: a canned query still proves the pipe.
         query = DEFAULT_VERIFICATION_QUERY;
     }
-    const search = spawn.sync("tinyfish", ["search", "query", "--pretty", "--", query], {
-        stdio: "inherit",
-        env: { ...process.env, TF_SETUP_VERIFICATION: "1" },
+    const search = spawn.sync('tinyfish', ['search', 'query', '--pretty', '--', query], {
+        stdio: 'inherit',
+        env: { ...process.env, TF_SETUP_VERIFICATION: '1' },
         // A user-driven search must never be cut off.
         timeout: prompt ? undefined : HEADLESS_VERIFY_TIMEOUT_MS,
     });
     if (commandNotFound(search.error)) {
         errLine(TINYFISH_CLI_NOT_FOUND_MESSAGE);
         outLine(`Retry in a new terminal: ${searchRetry(query)}`);
-        return "verification_failed";
+        return 'verification_failed';
     }
     throwIfInterrupted(search);
     if (search.error || search.status !== 0) {
         outLine(`Retry: ${searchRetry(query)}`);
-        return "verification_failed";
+        return 'verification_failed';
     }
-    hooks?.onStepDone?.("cli_verified");
-    return "cli_verified";
+    hooks?.onStepDone?.('cli_verified');
+    return 'cli_verified';
 }

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

@@ -1,9 +1,9 @@
-import type { Readable } from "node:stream";
-import { type Harness, type HarnessDetection } from "./harness-detect.js";
-export type PickSelection = Harness[] | "cancel";
+import type { Readable } from 'node:stream';
+import { type Harness, type HarnessDetection } from './harness-detect.js';
+export type PickSelection = Harness[] | 'cancel';
 export interface PickResult {
     selection: PickSelection;
-    mode: "pick" | "pick_numeric";
+    mode: 'pick' | 'pick_numeric';
 }
 export type PickerStdin = Readable & {
     setRawMode?: (raw: boolean) => unknown;

package/dist/lib/connect-picker.js

@@ -1,23 +1,23 @@
-import * as readline from "node:readline";
-import { HARNESS_DISPLAY_NAMES } from "./harness-detect.js";
-const KEY_HELP = "  ↑↓ move   space toggle one   a none/all   q cancel";
+import * as readline from 'node:readline';
+import { HARNESS_DISPLAY_NAMES } from './harness-detect.js';
+const KEY_HELP = '  ↑↓ move   space toggle one   a none/all   q cancel';
 function header(count) {
-    return `Found ${count} agent config${count === 1 ? "" : "s"} on this machine.\n\n`;
+    return `Found ${count} agent config${count === 1 ? '' : 's'} on this machine.\n\n`;
 }
 function connectedNote(item) {
-    return item.connectedBefore ? "  (previously connected)" : "";
+    return item.connectedBefore ? '  (previously connected)' : '';
 }
 function enterHint(checkedCount, total) {
     if (checkedCount === 0)
-        return "press enter to cancel";
+        return 'press enter to cancel';
     if (checkedCount === total)
         return `press enter to connect all ${total}`;
     return `press enter to connect ${checkedCount} of ${total}`;
 }
 function frame(items, checked, cursor) {
-    const rows = items.map((item, i) => `  ${i === cursor ? ">" : " "} [${checked[i] ? "x" : " "}] ${item.name}${connectedNote(item)}`);
+    const rows = items.map((item, i) => `  ${i === cursor ? '>' : ' '} [${checked[i] ? 'x' : ' '}] ${item.name}${connectedNote(item)}`);
     const count = checked.filter(Boolean).length;
-    return [...rows, "", `  ${enterHint(count, items.length)}`, KEY_HELP, ""].join("\n");
+    return [...rows, '', `  ${enterHint(count, items.length)}`, KEY_HELP, ''].join('\n');
 }
 async function pickWithKeys(items, stdin, write) {
     const checked = items.map(() => true);
@@ -25,7 +25,7 @@ async function pickWithKeys(items, stdin, write) {
     let painted = 0;
     const paint = () => {
         const text = frame(items, checked, cursor);
-        write((painted > 0 ? `\u001b[${painted}A\u001b[0J` : "") + text);
+        write((painted > 0 ? `\u001b[${painted}A\u001b[0J` : '') + text);
         painted = items.length + 3;
     };
     readline.emitKeypressEvents(stdin);
@@ -38,24 +38,24 @@ async function pickWithKeys(items, stdin, write) {
         return await new Promise((resolve, reject) => {
             onKeypress = (_chunk, key = {}) => {
                 try {
-                    const name = key.name ?? "";
+                    const name = key.name ?? '';
                     // Raw mode eats terminal SIGINT, so Ctrl+C arrives only here.
-                    if ((key.ctrl && (name === "c" || name === "d")) || name === "q" || name === "escape") {
-                        resolve("cancel");
+                    if ((key.ctrl && (name === 'c' || name === 'd')) || name === 'q' || name === 'escape') {
+                        resolve('cancel');
                         return;
                     }
-                    if (name === "return" || name === "enter") {
+                    if (name === 'return' || name === 'enter') {
                         const picked = items.filter((_, i) => checked[i]).map((item) => item.harness);
-                        resolve(picked.length > 0 ? picked : "cancel");
+                        resolve(picked.length > 0 ? picked : 'cancel');
                         return;
                     }
-                    if (name === "up" || name === "k")
+                    if (name === 'up' || name === 'k')
                         cursor = (cursor + items.length - 1) % items.length;
-                    else if (name === "down" || name === "j")
+                    else if (name === 'down' || name === 'j')
                         cursor = (cursor + 1) % items.length;
-                    else if (name === "space")
+                    else if (name === 'space')
                         checked[cursor] = !checked[cursor];
-                    else if (name === "a")
+                    else if (name === 'a')
                         checked.fill(!checked.every(Boolean));
                     paint();
                 }
@@ -63,19 +63,19 @@ async function pickWithKeys(items, stdin, write) {
                     reject(error instanceof Error ? error : new Error(String(error)));
                 }
             };
-            stdin.on("keypress", onKeypress);
+            stdin.on('keypress', onKeypress);
         });
     }
     finally {
         // Restore before any child spawn can inherit raw stdin (PF-3635).
         if (onKeypress)
-            stdin.removeListener("keypress", onKeypress);
+            stdin.removeListener('keypress', onKeypress);
         stdin.setRawMode(false);
         stdin.pause();
     }
 }
 function numberedRows(items) {
-    return (items.map((item, i) => `  [${i + 1}] ${item.name}${connectedNote(item)}`).join("\n") + "\n");
+    return (items.map((item, i) => `  [${i + 1}] ${item.name}${connectedNote(item)}`).join('\n') + '\n');
 }
 function parseSubset(answer, items) {
     const tokens = answer.split(/[\s,]+/).filter(Boolean);
@@ -103,17 +103,17 @@ async function pickWithNumbers(items, prompt, write) {
         }
         catch {
             // Closed stdin: every later question would throw too.
-            return "cancel";
+            return 'cancel';
         }
-        if (answer === "")
+        if (answer === '')
             return items.map((item) => item.harness);
         if (/^[nq]$/i.test(answer))
-            return "cancel";
+            return 'cancel';
         const subset = parseSubset(answer, items);
         if (subset)
             return subset;
     }
-    return "cancel";
+    return 'cancel';
 }
 export async function pickHarnesses(detections, connectedBefore, io = {}) {
     const items = detections
@@ -125,12 +125,12 @@ export async function pickHarnesses(detections, connectedBefore, io = {}) {
     }));
     const stdin = io.stdin ?? process.stdin;
     const write = io.write ?? ((text) => void process.stderr.write(text));
-    if (typeof stdin.setRawMode !== "function") {
+    if (typeof stdin.setRawMode !== 'function') {
         // No prompt means nothing to ask; keep --all semantics.
         const selection = io.prompt
             ? await pickWithNumbers(items, io.prompt, write)
             : items.map((item) => item.harness);
-        return { selection, mode: "pick_numeric" };
+        return { selection, mode: 'pick_numeric' };
     }
-    return { selection: await pickWithKeys(items, stdin, write), mode: "pick" };
+    return { selection: await pickWithKeys(items, stdin, write), mode: 'pick' };
 }

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

@@ -1,13 +1,13 @@
-import { AuthMode } from "./harness-detect.js";
+import { AuthMode } from './harness-detect.js';
 export declare const NON_INTERACTIVE_TIMEOUT_MS = 10000;
-export type AgentClient = "claude-code" | "codex" | "cursor" | "grok" | "hermes" | "openclaw" | "opencode";
-type ConnectStage = "started" | "checkpoint" | "completed" | "failed" | "aborted" | "post_install_failed";
-export type ConnectFailureStage = "prerequisite_check" | "registration_cleanup" | "registration" | "registration_or_authentication" | "client_oauth" | "cli_install" | "skill_install" | "authentication" | "walkthrough_launch" | "cli_verification";
+export type AgentClient = 'claude-code' | 'codex' | 'cursor' | 'grok' | 'hermes' | 'openclaw' | 'opencode';
+type ConnectStage = 'started' | 'checkpoint' | 'completed' | 'failed' | 'aborted' | 'post_install_failed';
+export type ConnectFailureStage = 'prerequisite_check' | 'registration_cleanup' | 'registration' | 'registration_or_authentication' | 'client_oauth' | 'cli_install' | 'skill_install' | 'authentication' | 'walkthrough_launch' | 'cli_verification';
 export declare const CONNECT_FAILURE_REASONS: readonly ["harness_not_installed", "harness_command_unsupported", "harness_too_old", "key_auth_unsupported", "command_not_found", "timeout", "spawn_error", "nonzero_exit", "invalid_config", "user_abandoned", "process_terminated", "unexpected_error"];
 export type ConnectFailureReason = (typeof CONNECT_FAILURE_REASONS)[number];
-export type ConnectAuthMode = Exclude<AuthMode, AuthMode.Unknown> | "deferred";
-export type ConnectCheckpoint = "prerequisite_ok" | "registered" | "oauth_done" | "cli_installed" | "skill_installed" | "authenticated" | "cli_verified" | "walkthrough_launched" | "walkthrough_prompt_printed";
-export type CliFallbackOutcome = "cli_verified" | "cli_install_failed" | "no_credentials" | "invalid_credentials" | "authentication_failed" | "verification_failed" | "abandoned";
+export type ConnectAuthMode = Exclude<AuthMode, AuthMode.Unknown> | 'deferred';
+export type ConnectCheckpoint = 'prerequisite_ok' | 'registered' | 'oauth_done' | 'cli_installed' | 'skill_installed' | 'authenticated' | 'cli_verified' | 'walkthrough_launched' | 'walkthrough_prompt_printed';
+export type CliFallbackOutcome = 'cli_verified' | 'cli_install_failed' | 'no_credentials' | 'invalid_credentials' | 'authentication_failed' | 'verification_failed' | 'abandoned';
 /** Ctrl+C killed a setup child — abandonment, not error. */
 export declare class ConnectInterruptedError extends Error {
 }

package/dist/lib/connect-runtime.js

@@ -1,26 +1,26 @@
-import { randomUUID } from "node:crypto";
-import spawn from "cross-spawn";
-import { CONNECT_ATTEMPT_ENV, isAttemptId, resolvedApiKey, takePendingConnectAttempt, } from "./auth.js";
-import { CLI_VERSION } from "./constants.js";
-import { detectHarness, detectHumanInitiated } from "./harness.js";
-import { errLine, sanitizeLine } from "./output.js";
-import { postConnectEvent, telemetryDisabled } from "./setup-telemetry.js";
-import { installSignalGuard } from "./signals.js";
+import { randomUUID } from 'node:crypto';
+import spawn from 'cross-spawn';
+import { CONNECT_ATTEMPT_ENV, isAttemptId, resolvedApiKey, takePendingConnectAttempt, } from './auth.js';
+import { CLI_VERSION } from './constants.js';
+import { detectHarness, detectHumanInitiated } from './harness.js';
+import { errLine, sanitizeLine } from './output.js';
+import { postConnectEvent, telemetryDisabled } from './setup-telemetry.js';
+import { installSignalGuard } from './signals.js';
 export const NON_INTERACTIVE_TIMEOUT_MS = 10_000;
 // Mirrors the route's Zod enum; tests both sides pin it.
 export const CONNECT_FAILURE_REASONS = [
-    "harness_not_installed",
-    "harness_command_unsupported",
-    "harness_too_old",
-    "key_auth_unsupported",
-    "command_not_found",
-    "timeout",
-    "spawn_error",
-    "nonzero_exit",
-    "invalid_config",
-    "user_abandoned",
-    "process_terminated",
-    "unexpected_error",
+    'harness_not_installed',
+    'harness_command_unsupported',
+    'harness_too_old',
+    'key_auth_unsupported',
+    'command_not_found',
+    'timeout',
+    'spawn_error',
+    'nonzero_exit',
+    'invalid_config',
+    'user_abandoned',
+    'process_terminated',
+    'unexpected_error',
 ];
 /** Ctrl+C killed a setup child — abandonment, not error. */
 export class ConnectInterruptedError extends Error {
@@ -40,25 +40,25 @@ class PrerequisiteError extends ConnectStepError {
 /** A bounded sign-in wait elapsed — unfinished, not broken. */
 export class SignInTimeoutError extends ConnectStepError {
     constructor(message, cause) {
-        super(message, "timeout", { cause });
+        super(message, 'timeout', { cause });
     }
 }
 // A maxBuffer overflow is also killed with SIGTERM, and is a failure too.
-const NOT_INTERRUPTIONS = new Set(["ETIMEDOUT", "ENOBUFS"]);
+const NOT_INTERRUPTIONS = new Set(['ETIMEDOUT', 'ENOBUFS']);
 export function throwIfInterrupted(result) {
     // spawn.sync kills a timed-out child with SIGTERM, so signal alone would misread a slow
     // network as the user walking away. A timeout is a failure and must report as one.
     const code = result.error?.code;
     if (code && NOT_INTERRUPTIONS.has(code))
         return;
-    if (result.signal === "SIGINT") {
-        throw new ConnectInterruptedError("Setup interrupted");
+    if (result.signal === 'SIGINT') {
+        throw new ConnectInterruptedError('Setup interrupted');
     }
 }
 /** Bounded removal spawn shared by install cleanup and --uninstall; Ctrl+C throws. */
 export function spawnRemoval(command, args, timeoutMs = NON_INTERACTIVE_TIMEOUT_MS) {
     const result = spawn.sync(command, [...args], {
-        encoding: "utf8",
+        encoding: 'utf8',
         timeout: timeoutMs,
     });
     throwIfInterrupted(result);
@@ -69,16 +69,16 @@ export function spawnStepError(message, result) {
     throwIfInterrupted(result);
     const code = result.error?.code;
     const reason = !result.error
-        ? "nonzero_exit"
-        : code === "ENOENT"
-            ? "command_not_found"
-            : code === "ETIMEDOUT"
-                ? "timeout"
-                : "spawn_error";
+        ? 'nonzero_exit'
+        : code === 'ENOENT'
+            ? 'command_not_found'
+            : code === 'ETIMEDOUT'
+                ? 'timeout'
+                : 'spawn_error';
     return new ConnectStepError(message, reason, { cause: result.error });
 }
 export function commandNotFound(error) {
-    return error?.code === "ENOENT";
+    return error?.code === 'ENOENT';
 }
 /** One command redoes every post-install step for a client. */
 export function finishSetupCommand(client) {
@@ -96,11 +96,11 @@ export function settle(state, telemetry, stage, detail) {
 function installConnectSignalGuard(state, telemetry) {
     return installSignalGuard(async (signal) => {
         if (!state.settled) {
-            settle(state, telemetry, "aborted", {
+            settle(state, telemetry, 'aborted', {
                 failedStage: state.stage,
-                failureReason: signal === "SIGINT" ? "user_abandoned" : "process_terminated",
+                failureReason: signal === 'SIGINT' ? 'user_abandoned' : 'process_terminated',
             });
-            errLine("Setup interrupted — run the command again to finish.");
+            errLine('Setup interrupted — run the command again to finish.');
         }
         // Settled spans the whole post-install phase; the `completed` POST may still be in flight.
         await telemetry.flush();
@@ -114,22 +114,22 @@ export async function runGuarded(state, telemetry, body) {
     }
     catch (error) {
         if (error instanceof ConnectInterruptedError) {
-            settle(state, telemetry, "aborted", {
+            settle(state, telemetry, 'aborted', {
                 failedStage: state.stage,
-                failureReason: "user_abandoned",
+                failureReason: 'user_abandoned',
             });
-            errLine("Setup interrupted — run the command again to finish.");
+            errLine('Setup interrupted — run the command again to finish.');
             process.exitCode = 130;
             return;
         }
         // An elapsed sign-in wait is abandonment, not breakage.
         if (error instanceof SignInTimeoutError) {
-            settle(state, telemetry, "aborted", { failedStage: state.stage, failureReason: "timeout" });
+            settle(state, telemetry, 'aborted', { failedStage: state.stage, failureReason: 'timeout' });
             throw error;
         }
-        settle(state, telemetry, "failed", {
+        settle(state, telemetry, 'failed', {
             failedStage: state.stage,
-            failureReason: error instanceof ConnectStepError ? error.failureReason : "unexpected_error",
+            failureReason: error instanceof ConnectStepError ? error.failureReason : 'unexpected_error',
             ...(error instanceof ConnectStepError ? { harnessVersion: error.harnessVersion } : {}),
         });
         throw error;
@@ -141,38 +141,38 @@ export async function runGuarded(state, telemetry, body) {
 }
 export function requireCommandSupport(client) {
     const result = spawn.sync(client.command, client.supportCheck.args, {
-        encoding: "utf8",
+        encoding: 'utf8',
         // Agent harnesses export FORCE_COLOR, which makes clients colourise even a piped --help.
-        env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
+        env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1' },
         timeout: NON_INTERACTIVE_TIMEOUT_MS,
     });
     // 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) {
-        throw new PrerequisiteError(`${client.displayName} is not installed or not available on PATH.`, "harness_not_installed", { cause: result.error });
+        throw new PrerequisiteError(`${client.displayName} is not installed or not available on PATH.`, 'harness_not_installed', { cause: result.error });
     }
     if (result.error || result.status !== 0) {
         throwIfInterrupted(result);
         // A hung probe is a timeout, not a missing capability.
-        if (result.error?.code === "ETIMEDOUT") {
-            throw new ConnectStepError(client.supportCheck.unavailableMessage, "timeout", {
+        if (result.error?.code === 'ETIMEDOUT') {
+            throw new ConnectStepError(client.supportCheck.unavailableMessage, '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.command) });
     }
     // 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 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 ?? []);
     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 || !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", {
+        throw new PrerequisiteError(client.supportCheck.unavailableMessage, 'harness_too_old', {
             harnessVersion: probeHarnessVersion(client.command),
         });
     }
@@ -184,16 +184,16 @@ export function requireCommandSupport(client) {
 }
 /** Best-effort; the server rejects non-printable characters and >32 chars. */
 function probeHarnessVersion(command) {
-    const result = spawn.sync(command, ["--version"], {
-        encoding: "utf8",
+    const result = spawn.sync(command, ['--version'], {
+        encoding: 'utf8',
         timeout: NON_INTERACTIVE_TIMEOUT_MS,
     });
     if (result.error || result.status !== 0)
         return undefined;
     // First line only: sanitizeLine keeps newlines, so stripping splices lines.
-    const version = sanitizeLine(result.stdout ?? "")
-        .split("\n")[0]
-        .replace(/[^\x20-\x7E]/g, "")
+    const version = sanitizeLine(result.stdout ?? '')
+        .split('\n')[0]
+        .replace(/[^\x20-\x7E]/g, '')
         .trim();
     return version ? version.slice(0, 32) : undefined;
 }
@@ -215,7 +215,7 @@ export function createConnectTelemetry(mcpUrl, client, opts) {
     // A setup-page id (via --url, the env var, or one parked by login) joins "copied the
     // command" to this install attempt.
     const attemptId = opts?.attemptId ?? seeded ?? opts?.fallbackAttemptId ?? randomUUID();
-    const endpoint = new URL("/api/cli/connect-event", mcpUrl).toString();
+    const endpoint = new URL('/api/cli/connect-event', mcpUrl).toString();
     const pending = [];
     let lastTrackAt;
     let harnessVersion;
@@ -230,7 +230,7 @@ export function createConnectTelemetry(mcpUrl, client, opts) {
             body,
             attempts: 2,
             apiKey: resolvedApiKey(opts?.apiKey),
-            label: "connect",
+            label: 'connect',
         });
     }
     return {
@@ -258,7 +258,7 @@ export function createConnectTelemetry(mcpUrl, client, opts) {
                 phase: detail?.phase,
                 failure_reason: detail?.failureReason,
                 // Terminal rows only: rescue checkpoints stay wire-identical to normal ones.
-                fallback_outcome: stage === "failed" || stage === "aborted" ? fallbackOutcome : undefined,
+                fallback_outcome: stage === 'failed' || stage === 'aborted' ? fallbackOutcome : undefined,
                 harness_version: detail?.harnessVersion ?? harnessVersion,
                 auth_mode: detail?.authMode,
                 harness_degraded: detail?.harnessDegraded,
@@ -269,11 +269,11 @@ export function createConnectTelemetry(mcpUrl, client, opts) {
                 // Same signal the usage events carry, so TTY and headless connects can be split.
                 is_human_initiated: detectHumanInitiated(),
                 // "none", not absent — absent has to keep meaning "CLI too old".
-                calling_harness: detectHarness() ?? "none",
+                calling_harness: detectHarness() ?? 'none',
             })).catch((error) => {
                 // postConnectEvent is total, so this only fires if something inside deliver starts
                 // throwing. Same channel postConnectEvent uses for its own failures.
-                if (!process.env["TINYFISH_DEBUG"])
+                if (!process.env['TINYFISH_DEBUG'])
                     return;
                 errLine(`connect telemetry failed: ${error instanceof Error ? error.message : String(error)}`);
             }));