@tiny-fish/cli 0.13.1-next.148 → 0.13.1-next.150

package/dist/commands/connect.js

@@ -1,20 +1,20 @@
 import { randomUUID } from "node:crypto";
 import * as path from "node:path";
 import spawn from "cross-spawn";
-import { CONNECT_SOURCE, loadConfig, persistApiKeyToEnvironment, saveConnectContext, validateKeyFormat, writeConfig, } from "../lib/auth.js";
-import { CLI_VERSION } from "../lib/constants.js";
-import { cursorInstallDeeplink, cursorMcpPath, writeCursorMcpConfig } from "../lib/cursor-config.js";
+import { CONNECT_SOURCE, loadConfig, persistApiKeyToEnvironment, resolvedApiKey, saveConnectContext, validateKeyFormat, writeConfig, } from "../lib/auth.js";
+import { CLI_VERSION, TINYFISH_CLI_PACKAGE } from "../lib/constants.js";
+import { cursorInstallDeeplink, cursorMcpPath, writeCursorMcpConfig, } from "../lib/cursor-config.js";
 import { runConnectAll } from "../lib/connect-all.js";
 import { detectHumanInitiated } from "../lib/harness.js";
-import { captureNotice, emitNotice } from "../lib/notice.js";
+import { emitNotice } from "../lib/notice.js";
 import { errLine } from "../lib/output.js";
-import { telemetryDisabled, telemetryHeaders } from "../lib/setup-telemetry.js";
+import { installSignalGuard } from "../lib/signals.js";
+import { postConnectEvent, telemetryDisabled } from "../lib/setup-telemetry.js";
 import { verifyMcpAuth } from "../lib/verify.js";
 export const DEFAULT_MCP_URL = "https://agent.tinyfish.ai/mcp";
 const NON_INTERACTIVE_TIMEOUT_MS = 10_000;
 const SKILL_INSTALL_TIMEOUT_MS = 120_000;
 const HERMES_SEED_TIMEOUT_MS = 120_000;
-const TELEMETRY_TIMEOUT_MS = 2_000;
 const MCP_LOGIN_UNAVAILABLE_MESSAGE = "This Claude Code installation does not expose `claude mcp login`, which is required for " +
     "one-command MCP authentication. Update Claude Code and retry, or authenticate TinyFish " +
     "manually from /mcp.";
@@ -32,7 +32,7 @@ const OPENCODE_MODEL_NOTE = "Note: TinyFish runs on tool calls, so OpenCode need
     'models (e.g. Nano Banana Pro) will show "No endpoints found that support tool use" — switch ' +
     "OpenCode's model if the walkthrough can't start.";
 const TINYFISH_CLI_NOT_FOUND_MESSAGE = "TinyFish CLI installed but is not available on PATH. Open a new terminal and retry.";
-const TINYFISH_CLI_PACKAGE = "@tiny-fish/cli@latest";
+const TINYFISH_CLI_INSTALL_SPEC = `${TINYFISH_CLI_PACKAGE}@latest`;
 export const UPGRADE_HINT = "Run `tinyfish upgrade` any time to update the CLI and skill.";
 // Supports Hermes without node:util.styleText, so the installer still runs on Node 20.11.
 const SKILLS_CLI_PACKAGE = "skills@1.5.15";
@@ -74,35 +74,20 @@ function settle(state, telemetry, stage, detail) {
     state.settled = true;
     telemetry.track(stage, detail);
 }
-// Without a parent handler, terminal Ctrl+C kills this process inside spawn.sync
-// before the child result exists — no aborted event, no flush. With one, the parent
-// survives; raw-mode children still surface via throwIfInterrupted, and cooked-mode
-// stages (npm/npx/OAuth waits) land here.
-// 128 + signal number
-const SIGNAL_EXIT_CODES = { SIGHUP: 129, SIGINT: 130, SIGTERM: 143 };
-function installSignalGuard(state, telemetry) {
-    const onSignal = (signal) => {
-        if (state.settled) {
-            process.exit(SIGNAL_EXIT_CODES[signal]);
-        }
+// Raw-mode children still surface via throwIfInterrupted; cooked-mode stages
+// (npm/npx/OAuth waits) land here.
+function installConnectSignalGuard(state, telemetry) {
+    return installSignalGuard(async () => {
+        if (state.settled)
+            return;
         settle(state, telemetry, "aborted", { failedStage: state.stage });
         errLine("Setup interrupted — run the command again to finish.");
-        void telemetry.flush().finally(() => process.exit(SIGNAL_EXIT_CODES[signal]));
-    };
-    const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
-    const handlers = signals.map((s) => {
-        const handler = () => onSignal(s);
-        process.on(s, handler);
-        return [s, handler];
+        await telemetry.flush();
     });
-    return () => {
-        for (const [s, handler] of handlers)
-            process.off(s, handler);
-    };
 }
 /** Shared terminal handling: interrupted → aborted (or completed post-install), else failed. */
 async function runGuarded(state, telemetry, body) {
-    const uninstallSignalGuard = installSignalGuard(state, telemetry);
+    const uninstallSignalGuard = installConnectSignalGuard(state, telemetry);
     try {
         await body();
     }
@@ -267,49 +252,22 @@ const OPENCLAW = {
         unavailableMessage: OPENCLAW_SKILL_UNAVAILABLE_MESSAGE,
     },
 };
-function storedApiKey() {
-    try {
-        return loadConfig().api_key;
-    }
-    catch {
-        return undefined;
-    }
-}
 function createConnectTelemetry(mcpUrl, client, apiKey) {
     const attemptId = randomUUID();
     const endpoint = new URL("/api/cli/connect-event", mcpUrl).toString();
-    const telemetryKey = apiKey || process.env["TINYFISH_API_KEY"] || storedApiKey();
-    const headers = telemetryHeaders(endpoint, telemetryKey);
     const pending = [];
     async function deliver(body) {
+        // Ahead of the key read; postConnectEvent's own opt-out check is too late to skip it.
         if (telemetryDisabled())
             return;
-        // One retry: stale keep-alive sockets eat post-install POSTs. 5xx retries;
-        // 4xx never will (schema mismatch, e.g. new stages hitting an old server).
-        for (let attempt = 0; attempt < 2; attempt++) {
-            try {
-                const response = await fetch(endpoint, {
-                    method: "POST",
-                    headers,
-                    body,
-                    redirect: "error",
-                    signal: AbortSignal.timeout(TELEMETRY_TIMEOUT_MS),
-                });
-                // Before the ok branch so an error response still yields a notice.
-                captureNotice(response.headers);
-                if (response.ok)
-                    return;
-                if (response.status < 500) {
-                    if (process.env["TINYFISH_DEBUG"]) {
-                        errLine(`telemetry rejected: HTTP ${response.status}`);
-                    }
-                    return;
-                }
-            }
-            catch {
-                // best-effort; never blocks setup
-            }
-        }
+        // Resolved per event: `tinyfish auth login` writes the config from a subprocess mid-connect.
+        await postConnectEvent({
+            endpoint,
+            body,
+            attempts: 2,
+            apiKey: resolvedApiKey(apiKey),
+            label: "connect",
+        });
     }
     return {
         attemptId,
@@ -356,7 +314,7 @@ function commandNotFound(error) {
 }
 export function installTinyFishCli() {
     errLine("Installing the TinyFish CLI...");
-    const result = spawn.sync("npm", ["install", "--global", TINYFISH_CLI_PACKAGE], {
+    const result = spawn.sync("npm", ["install", "--global", TINYFISH_CLI_INSTALL_SPEC], {
         stdio: "inherit",
         timeout: SKILL_INSTALL_TIMEOUT_MS,
     });

package/dist/commands/upgrade.d.ts

@@ -1,3 +1,5 @@
 import { Command } from "commander";
 export declare function runUpgrade(): void;
+/** `runUpgrade` plus its outcome telemetry, which must never change what the upgrade does. */
+export declare function runUpgradeCommand(): Promise<void>;
 export declare function registerUpgrade(program: Command): void;

package/dist/commands/upgrade.js

@@ -1,6 +1,12 @@
+import spawn from "cross-spawn";
+import { resolvedApiKey } from "../lib/auth.js";
+import { CLI_VERSION, TINYFISH_CLI_PACKAGE } from "../lib/constants.js";
 import { errLine } from "../lib/output.js";
+import { sendUpgradeCompleted, telemetryDisabled, } from "../lib/setup-telemetry.js";
+import { installSignalGuard, SIGNAL_EXIT_CODES } from "../lib/signals.js";
 import { ConnectInterruptedError, installTinyFishCli, updateWebSkill } from "./connect.js";
-const INTERRUPTED_EXIT_CODE = 130;
+const VERSION_READ_TIMEOUT_MS = 2_000;
+const INTERRUPTED_MESSAGE = "Upgrade interrupted — run `tinyfish upgrade` again to finish.";
 function attempt(label, run) {
     try {
         run();
@@ -30,17 +36,64 @@ export function runUpgrade() {
     catch (error) {
         if (!(error instanceof ConnectInterruptedError))
             throw error;
-        errLine("Upgrade interrupted — run `tinyfish upgrade` again to finish.");
-        process.exitCode = INTERRUPTED_EXIT_CODE;
+        errLine(INTERRUPTED_MESSAGE);
+        process.exitCode = SIGNAL_EXIT_CODES.SIGINT;
         return;
     }
     errLine("TinyFish is up to date. Restart your agent to pick up the refreshed skill.");
 }
+/** The version now on disk. Only the upgrade's own npm call knows what "latest" resolved to. */
+function installedCliVersion() {
+    try {
+        const result = spawn.sync("npm", ["ls", "--global", "--depth=0", "--json", TINYFISH_CLI_PACKAGE], { encoding: "utf8", timeout: VERSION_READ_TIMEOUT_MS });
+        const parsed = JSON.parse(result.stdout ?? "");
+        return parsed.dependencies?.[TINYFISH_CLI_PACKAGE]?.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** `runUpgrade` plus its outcome telemetry, which must never change what the upgrade does. */
+export async function runUpgradeCommand() {
+    let reported = false;
+    // Read on the failed path too: a failed skill refresh still leaves an upgraded CLI, so
+    // `outcome` reports whether every step ran and `to_version` whether the binary moved.
+    const report = async (outcome) => {
+        if (reported)
+            return;
+        reported = true;
+        // Ahead of the version and key reads; an opted-out run does neither.
+        if (telemetryDisabled())
+            return;
+        // Interrupted skips the read — racing the exit. Undercounts; see posthog-events.md.
+        const toVersion = outcome === "interrupted" ? null : installedCliVersion();
+        await sendUpgradeCompleted(CLI_VERSION, toVersion, outcome, resolvedApiKey());
+    };
+    const uninstallSignalGuard = installSignalGuard(async () => {
+        errLine(INTERRUPTED_MESSAGE);
+        await report("interrupted");
+    });
+    let outcome = "updated";
+    try {
+        runUpgrade();
+        if (process.exitCode === SIGNAL_EXIT_CODES.SIGINT)
+            outcome = "interrupted";
+    }
+    catch (error) {
+        outcome = "failed";
+        throw error;
+    }
+    finally {
+        uninstallSignalGuard();
+        // Swallowed: a throw here would replace the upgrade's own error, or fail a good upgrade.
+        await report(outcome).catch(() => { });
+    }
+}
 export function registerUpgrade(program) {
     program
         .command("upgrade")
         .description("Update the TinyFish CLI and the use-tinyfish skill to the latest versions")
-        .action(() => {
-        runUpgrade();
+        .action(async () => {
+        await runUpgradeCommand();
     });
 }

package/dist/lib/auth.d.ts

@@ -22,4 +22,6 @@ export declare function persistApiKeyToEnvironment(apiKey: string, options?: Env
 export declare function clearConfig(): boolean;
 export declare function validateKeyFormat(key: string): boolean;
 export declare function maskKey(key: string): string;
+/** Key for optional paths (telemetry, auth probes) — absent is a valid answer, so never exits. */
+export declare function resolvedApiKey(explicitApiKey?: string): string | undefined;
 export declare function getApiKey(): string;

package/dist/lib/auth.js

@@ -145,11 +145,27 @@ export function maskKey(key) {
         return "***";
     return key.slice(0, 12) + "..." + key.slice(-4);
 }
+/** Key for optional paths (telemetry, auth probes) — absent is a valid answer, so never exits. */
+export function resolvedApiKey(explicitApiKey) {
+    if (explicitApiKey)
+        return explicitApiKey;
+    const envKey = process.env["TINYFISH_API_KEY"];
+    if (envKey)
+        return envKey;
+    try {
+        return loadConfig().api_key;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function getApiKey() {
     const envKey = process.env.TINYFISH_API_KEY;
     if (envKey) {
         if (!validateKeyFormat(envKey)) {
-            err({ error: "TINYFISH_API_KEY has invalid format. Expected sk-tinyfish-... or sk-mino-..." });
+            err({
+                error: "TINYFISH_API_KEY has invalid format. Expected sk-tinyfish-... or sk-mino-...",
+            });
             process.exit(1);
         }
         return envKey;

package/dist/lib/connect-all.js

@@ -1,7 +1,7 @@
 import * as readline from "node:readline/promises";
 import spawn from "cross-spawn";
 import { connectClaudeCode, connectCodex, connectCursor, connectHermes, connectOpenClaw, } from "../commands/connect.js";
-import { loadConfig, validateKeyFormat } from "./auth.js";
+import { resolvedApiKey, validateKeyFormat } from "./auth.js";
 import { detectInstalledHarnesses, FIVE_HARNESSES, } from "./harness-detect.js";
 import { detectHumanInitiated } from "./harness.js";
 import { emitNotice } from "./notice.js";
@@ -29,19 +29,6 @@ const UNINSTALL_POINTERS = {
     hermes: "hermes mcp remove tinyfish",
     openclaw: "openclaw skills uninstall @tinyfish/tinyfish --global",
 };
-function resolvedApiKey(explicitApiKey) {
-    if (explicitApiKey)
-        return explicitApiKey;
-    const envKey = process.env["TINYFISH_API_KEY"];
-    if (envKey)
-        return envKey;
-    try {
-        return loadConfig().api_key;
-    }
-    catch {
-        return undefined;
-    }
-}
 function hasStoredAuth(explicitApiKey) {
     const key = resolvedApiKey(explicitApiKey);
     return !!key && validateKeyFormat(key);
@@ -113,7 +100,9 @@ async function processHarness(detection, opts, prompt) {
     const base = { harness, detected: true, configPath, installed: false };
     // dryRun first: --dry-run --uninstall must plan, never reach removeCursorMcpServer().
     if (opts.dryRun) {
-        const plan = opts.uninstall ? uninstallPlanText(harness) : planText(harness, opts.mcpUrl, resolvedApiKey(opts.apiKey));
+        const plan = opts.uninstall
+            ? uninstallPlanText(harness)
+            : planText(harness, opts.mcpUrl, resolvedApiKey(opts.apiKey));
         return { ...base, outcome: "dry_run", fixCommand: plan };
     }
     if (opts.uninstall)
@@ -296,7 +285,11 @@ export async function runConnectAll(opts) {
     }
     const exitCode = computeExitCode(results);
     const interrupted = results.some((r) => r.outcome === "interrupted");
-    if (exitCode === 0 && !interrupted && !opts.dryRun && !opts.uninstall && results.some((r) => r.installed)) {
+    if (exitCode === 0 &&
+        !interrupted &&
+        !opts.dryRun &&
+        !opts.uninstall &&
+        results.some((r) => r.installed)) {
         outLine("");
         if (isTTY && !opts.noLaunch && (await launchFirstTask(results))) {
             return exitCode;

package/dist/lib/constants.d.ts

@@ -1,4 +1,6 @@
 export declare const CLI_VERSION: string;
+/** Unversioned: the install site appends `@latest`, the version read must not. */
+export declare const TINYFISH_CLI_PACKAGE = "@tiny-fish/cli";
 export declare const BASE_URL: string;
 export declare const API_URL_OVERRIDE: string | undefined;
 /** URL where users can create and manage API keys */

package/dist/lib/constants.js

@@ -2,6 +2,8 @@ import { createRequire } from "module";
 const _require = createRequire(import.meta.url);
 const _pkg = _require("../../package.json");
 export const CLI_VERSION = _pkg.version;
+/** Unversioned: the install site appends `@latest`, the version read must not. */
+export const TINYFISH_CLI_PACKAGE = "@tiny-fish/cli";
 /** Base URL for the TinyFish API. Override with TINYFISH_API_URL for staging/self-hosted. */
 const apiUrlOverride = process.env["TINYFISH_API_URL"]?.trim() || undefined;
 if (apiUrlOverride) {

package/dist/lib/setup-telemetry.d.ts

@@ -8,6 +8,20 @@ export declare function telemetryDisabled(): boolean;
 export declare function isTrustedTelemetryOrigin(endpoint: string): boolean;
 /** SHA-256 lookup key only, and only to trusted origins — the raw key never rides telemetry. */
 export declare function telemetryHeaders(endpoint: string, apiKey?: string): Record<string, string>;
+/**
+ * The one POST to `/api/cli/connect-event`, and the only place its security-relevant
+ * properties live: trusted-origin key gating, `redirect: "error"`, the 2s cap, notice
+ * capture. Never throws. `endpoint` is the caller's — connect and setup target the `--url`
+ * being installed against, upgrade has none and uses BASE_URL.
+ */
+export declare function postConnectEvent(options: {
+    endpoint: string;
+    body: string;
+    /** 2 where a lost event costs a headline metric — stale keep-alive sockets eat post-install POSTs. */
+    attempts: number;
+    label: string;
+    apiKey?: string;
+}): Promise<void>;
 declare const harnessResultSchema: z.ZodObject<{
     harness: z.ZodEnum<{
         openclaw: "openclaw";
@@ -45,6 +59,8 @@ export declare const setupCompletedPayloadSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type SetupCompletedPayload = z.infer<typeof setupCompletedPayloadSchema>;
 export type HarnessResult = z.infer<typeof harnessResultSchema>;
-/** Fire-and-forget, 2s cap; raw keys never ride telemetry. */
+export type UpgradeOutcome = "updated" | "failed" | "interrupted";
+/** `toVersion` is null when the run was interrupted or the installed version could not be read. */
+export declare function sendUpgradeCompleted(fromVersion: string, toVersion: string | null, outcome: UpgradeOutcome, apiKey?: string): Promise<void>;
 export declare function sendSetupCompleted(mcpUrl: string, harnesses: HarnessResult[], apiKey?: string): Promise<void>;
 export {};

package/dist/lib/setup-telemetry.js

@@ -1,10 +1,11 @@
 import { createHash } from "node:crypto";
 import { z } from "zod";
 import { validateKeyFormat } from "./auth.js";
-import { CLI_VERSION } from "./constants.js";
+import { BASE_URL, CLI_VERSION } from "./constants.js";
 import { FIVE_HARNESSES } from "./harness-detect.js";
+import { captureNotice } from "./notice.js";
 import { errLine } from "./output.js";
-const SETUP_TELEMETRY_TIMEOUT_MS = 2_000;
+const CONNECT_EVENT_TIMEOUT_MS = 2_000;
 /**
  * `TINYFISH_NO_TELEMETRY` suppresses ALL CLI-emitted network analytics
  * (setup_completed, connect-event, update check). Any value except `0`/`false`
@@ -43,6 +44,56 @@ export function telemetryHeaders(endpoint, apiKey) {
     }
     return headers;
 }
+/**
+ * The one POST to `/api/cli/connect-event`, and the only place its security-relevant
+ * properties live: trusted-origin key gating, `redirect: "error"`, the 2s cap, notice
+ * capture. Never throws. `endpoint` is the caller's — connect and setup target the `--url`
+ * being installed against, upgrade has none and uses BASE_URL.
+ */
+export async function postConnectEvent(options) {
+    const { endpoint, body, attempts, label, apiKey } = options;
+    if (telemetryDisabled())
+        return;
+    // Swallows its own write failure so callers can treat this function as total.
+    const debug = (line) => {
+        if (!process.env["TINYFISH_DEBUG"])
+            return;
+        try {
+            errLine(`${label} telemetry ${line}`);
+        }
+        catch {
+            // no stderr to report to
+        }
+    };
+    const headers = telemetryHeaders(endpoint, apiKey);
+    const trusted = isTrustedTelemetryOrigin(endpoint);
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        try {
+            const response = await fetch(endpoint, {
+                method: "POST",
+                headers,
+                body,
+                redirect: "error",
+                signal: AbortSignal.timeout(CONNECT_EVENT_TIMEOUT_MS),
+            });
+            // Before the ok branch so a rejected event still yields a notice; gated on origin so a
+            // `--url` host cannot print its own text as a TinyFish advisory.
+            if (trusted)
+                captureNotice(response.headers);
+            if (response.ok)
+                return;
+            // 4xx will reject the same body again (schema mismatch, e.g. new stages on an old server).
+            const willRetry = response.status >= 500 && attempt < attempts - 1;
+            if (!willRetry)
+                debug(`rejected: HTTP ${response.status}`);
+            if (response.status < 500)
+                return;
+        }
+        catch (e) {
+            debug(`failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+}
 const harnessResultSchema = z.object({
     harness: z.enum(FIVE_HARNESSES),
     detected: z.boolean(),
@@ -59,8 +110,23 @@ export const setupCompletedPayloadSchema = z.object({
     }),
     cli_version: z.string(),
 });
-/** Fire-and-forget, 2s cap; raw keys never ride telemetry. */
+/** `toVersion` is null when the run was interrupted or the installed version could not be read. */
+export async function sendUpgradeCompleted(fromVersion, toVersion, outcome, apiKey) {
+    await postConnectEvent({
+        endpoint: new URL("/api/cli/connect-event", BASE_URL).toString(),
+        body: JSON.stringify({
+            event: "upgrade_completed",
+            from_version: fromVersion,
+            to_version: toVersion,
+            outcome,
+        }),
+        attempts: 1,
+        label: "upgrade",
+        apiKey,
+    });
+}
 export async function sendSetupCompleted(mcpUrl, harnesses, apiKey) {
+    // Ahead of the parse so an opt-out run prints no telemetry debug.
     if (telemetryDisabled())
         return;
     let endpoint;
@@ -77,31 +143,5 @@ export async function sendSetupCompleted(mcpUrl, harnesses, apiKey) {
         }
         return;
     }
-    const headers = telemetryHeaders(endpoint, apiKey);
-    // One retry: stale keep-alive sockets eat post-install POSTs, and this is the
-    // headline `--all` metric. 5xx retries; 4xx never will.
-    for (let attempt = 0; attempt < 2; attempt++) {
-        try {
-            const response = await fetch(endpoint, {
-                method: "POST",
-                headers,
-                body,
-                redirect: "error",
-                signal: AbortSignal.timeout(SETUP_TELEMETRY_TIMEOUT_MS),
-            });
-            if (response.ok)
-                return;
-            if (response.status < 500) {
-                if (process.env["TINYFISH_DEBUG"]) {
-                    errLine(`setup telemetry rejected: HTTP ${response.status}`);
-                }
-                return;
-            }
-        }
-        catch (e) {
-            if (process.env["TINYFISH_DEBUG"]) {
-                errLine(`setup telemetry failed: ${e instanceof Error ? e.message : String(e)}`);
-            }
-        }
-    }
+    await postConnectEvent({ endpoint, body, attempts: 2, label: "setup", apiKey });
 }

package/dist/lib/signals.d.ts

@@ -0,0 +1,12 @@
+export declare const SIGNAL_EXIT_CODES: {
+    readonly SIGHUP: 129;
+    readonly SIGINT: 130;
+    readonly SIGTERM: 143;
+};
+export type TerminalSignal = keyof typeof SIGNAL_EXIT_CODES;
+/**
+ * Without a parent handler, terminal Ctrl+C kills this process inside spawn.sync before the
+ * child result exists — no event, no flush. `onSignal` runs at most once; a second signal
+ * exits rather than waiting on it.
+ */
+export declare function installSignalGuard(onSignal: (signal: TerminalSignal) => Promise<void> | void): () => void;

package/dist/lib/signals.js

@@ -0,0 +1,27 @@
+// 128 + signal number
+export const SIGNAL_EXIT_CODES = { SIGHUP: 129, SIGINT: 130, SIGTERM: 143 };
+/**
+ * Without a parent handler, terminal Ctrl+C kills this process inside spawn.sync before the
+ * child result exists — no event, no flush. `onSignal` runs at most once; a second signal
+ * exits rather than waiting on it.
+ */
+export function installSignalGuard(onSignal) {
+    let handling = false;
+    const handlers = ["SIGINT", "SIGTERM", "SIGHUP"].map((signal) => {
+        const handler = () => {
+            const exit = () => process.exit(SIGNAL_EXIT_CODES[signal]);
+            if (handling)
+                return exit();
+            handling = true;
+            void Promise.resolve(onSignal(signal))
+                .catch(() => { })
+                .finally(exit);
+        };
+        process.on(signal, handler);
+        return [signal, handler];
+    });
+    return () => {
+        for (const [signal, handler] of handlers)
+            process.off(signal, handler);
+    };
+}

package/package.json

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