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

package/dist/lib/notice.d.ts

@@ -1,4 +1,4 @@
-import type { Command } from "commander";
+import type { Command } from 'commander';
 /** Test-only: the capture slot and the once-per-invocation latch are module state. */
 export declare function resetNoticeState(): void;
 /** Records the first notice seen; printing is deferred so it lands at the end of a command. */

package/dist/lib/notice.js

@@ -1,10 +1,10 @@
-import { CLI_VERSION } from "./constants.js";
-import { detectHumanInitiated } from "./harness.js";
-import { err, sanitizeLine, warnLine } from "./output.js";
-const NOTICE_HEADER = "x-tf-notice";
-const LEVEL_HEADER = "x-tf-notice-level";
+import { CLI_VERSION } from './constants.js';
+import { detectHumanInitiated } from './harness.js';
+import { err, sanitizeLine, warnLine } from './output.js';
+const NOTICE_HEADER = 'x-tf-notice';
+const LEVEL_HEADER = 'x-tf-notice-level';
 const MAX_LENGTH = 300;
-const VALID_LEVELS = new Set(["required", "recommended"]);
+const VALID_LEVELS = new Set(['required', 'recommended']);
 let captured;
 let printed = false;
 /** Test-only: the capture slot and the once-per-invocation latch are module state. */
@@ -16,9 +16,9 @@ export function resetNoticeState() {
 export function captureNotice(headers) {
     if (captured)
         return;
-    if (typeof headers?.get !== "function")
+    if (typeof headers?.get !== 'function')
         return;
-    const message = sanitizeLine(headers.get(NOTICE_HEADER) ?? "")
+    const message = sanitizeLine(headers.get(NOTICE_HEADER) ?? '')
         .trim()
         .slice(0, MAX_LENGTH);
     if (!message)
@@ -29,7 +29,7 @@ export function captureNotice(headers) {
 }
 /** Built here, not by the server, so nothing it sends can reach an agent's context as instructions. */
 function agentMessage(level) {
-    return level === "required"
+    return level === 'required'
         ? `This TinyFish CLI (${CLI_VERSION}) is below the required minimum. Run: tinyfish upgrade`
         : `A TinyFish CLI update is available (you have ${CLI_VERSION}). Run: tinyfish upgrade`;
 }
@@ -53,7 +53,7 @@ export function suppressNotice() {
 /** postAction covers clean completions, the exit hook covers the process.exit and rejection paths, the latch keeps it to one. */
 export function installNoticeEmit(program) {
     const backstop = () => emitNotice();
-    program.hook("postAction", () => emitNotice());
-    process.once("exit", backstop);
-    return () => process.removeListener("exit", backstop);
+    program.hook('postAction', () => emitNotice());
+    process.once('exit', backstop);
+    return () => process.removeListener('exit', backstop);
 }

package/dist/lib/output.js

@@ -1,4 +1,4 @@
-import { stripVTControlCharacters } from "node:util";
+import { stripVTControlCharacters } from 'node:util';
 export class ApiError extends Error {
     status;
     code;
@@ -6,21 +6,21 @@ export class ApiError extends Error {
         super(message);
         this.status = status;
         this.code = code;
-        this.name = "ApiError";
+        this.name = 'ApiError';
     }
 }
 export function out(data) {
-    process.stdout.write(JSON.stringify(data) + "\n");
+    process.stdout.write(JSON.stringify(data) + '\n');
 }
 /** The only writer for untrusted text: strips ANSI and C0/C1 controls. */
 export function sanitizeLine(text) {
     // eslint-disable-next-line no-control-regex
-    return stripVTControlCharacters(text).replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g, "");
+    return stripVTControlCharacters(text).replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g, '');
 }
 export function outLine(line) {
-    process.stdout.write(sanitizeLine(line) + "\n");
+    process.stdout.write(sanitizeLine(line) + '\n');
 }
-let errIndent = "";
+let errIndent = '';
 /** `connect --all` nests a harness's own lines under its step header. */
 export function setErrIndent(prefix) {
     errIndent = prefix;
@@ -28,20 +28,20 @@ export function setErrIndent(prefix) {
 export function errLine(line) {
     const text = sanitizeLine(line);
     // Per line, not once: a replayed capture carries newlines.
-    process.stderr.write((errIndent ? text.replace(/^(?=.)/gm, errIndent) : text) + "\n");
+    process.stderr.write((errIndent ? text.replace(/^(?=.)/gm, errIndent) : text) + '\n');
 }
-const WARN_ON = "\x1b[33m";
-const WARN_OFF = "\x1b[39m";
+const WARN_ON = '\x1b[33m';
+const WARN_OFF = '\x1b[39m';
 /** Advisory stderr line, yellow on a terminal and plain everywhere else so piped output stays clean. */
 export function warnLine(line) {
     const text = sanitizeLine(line);
-    const colour = Boolean(process.stderr.isTTY) && !process.env["NO_COLOR"];
+    const colour = Boolean(process.stderr.isTTY) && !process.env['NO_COLOR'];
     process.stderr.write(colour ? `${WARN_ON}${text}${WARN_OFF}\n` : `${text}\n`);
 }
 export function err(data) {
-    const payload = typeof data === "string" ? { error: data } : data;
-    const serialized = JSON.stringify(payload) ?? "undefined";
-    process.stderr.write(sanitizeLine(serialized) + "\n");
+    const payload = typeof data === 'string' ? { error: data } : data;
+    const serialized = JSON.stringify(payload) ?? 'undefined';
+    process.stderr.write(sanitizeLine(serialized) + '\n');
 }
 export function handleApiError(e) {
     if (e instanceof ApiError) {
@@ -50,7 +50,7 @@ export function handleApiError(e) {
             payload.code = e.code;
         if (e.status === 401)
             payload.hint =
-                "Clear the TINYFISH_API_KEY environment variable, run `tinyfish auth login`, then try again.";
+                'Clear the TINYFISH_API_KEY environment variable, run `tinyfish auth login`, then try again.';
         err(payload);
     }
     else if (e instanceof Error) {

package/dist/lib/registration-detect.d.ts

@@ -1,6 +1,6 @@
-import { type RecordedAuthMode } from "./auth.js";
-import type { AgentClient } from "./connect-runtime.js";
-import { AuthMode, type Harness, Registered } from "./harness-detect.js";
+import { type RecordedAuthMode } from './auth.js';
+import type { AgentClient } from './connect-runtime.js';
+import { AuthMode, type Harness, Registered } from './harness-detect.js';
 export interface RegistrationStatus {
     harness: Harness;
     detected: boolean;

package/dist/lib/registration-detect.js

@@ -1,13 +1,13 @@
-import * as fs from "fs";
-import * as path from "path";
-import spawn from "cross-spawn";
-import { z } from "zod";
-import { loadConfig, matchesCliKey } from "./auth.js";
-import { NATIVE_BY_HARNESS } from "./connect-clients.js";
-import { HARNESS_PROBE_TIMEOUT_MS } from "./constants.js";
-import { errLine } from "./output.js";
-import { readCursorTinyfishEntry } from "./cursor-config.js";
-import { detectInstalledHarnesses, harnessConfigPath, harnessDisplayPath, AuthMode, Registered, } from "./harness-detect.js";
+import * as fs from 'fs';
+import * as path from 'path';
+import spawn from 'cross-spawn';
+import { z } from 'zod';
+import { loadConfig, matchesCliKey } from './auth.js';
+import { NATIVE_BY_HARNESS } from './connect-clients.js';
+import { HARNESS_PROBE_TIMEOUT_MS } from './constants.js';
+import { errLine } from './output.js';
+import { readCursorTinyfishEntry } from './cursor-config.js';
+import { detectInstalledHarnesses, harnessConfigPath, harnessDisplayPath, AuthMode, Registered, } from './harness-detect.js';
 // A list, verified against codex 0.146. A name-keyed map was accepted here too, but every
 // field is optional, so that arm parsed *any* object-of-objects: a wrapper like
 // `{"servers": {...}}` decoded as one entry named `servers` and reported TinyFish absent.
@@ -33,50 +33,50 @@ const ANSI_SGR = /\x1b\[[0-9;]*m/g;
 // The report is pasted in public, so every reason is authored here. A spawn error's own
 // message quotes absolute paths, which is how a home directory reaches the payload.
 function spawnFailureReason(command, code) {
-    if (code === "ENOENT")
+    if (code === 'ENOENT')
         return `\`${command}\` is not on PATH`;
-    if (code === "EACCES")
+    if (code === 'EACCES')
         return `\`${command}\` is not executable`;
     return `could not run \`${command}\``;
 }
 function runProbe(command, args) {
     const result = spawn.sync(command, args, {
-        encoding: "utf8",
+        encoding: 'utf8',
         timeout: HARNESS_PROBE_TIMEOUT_MS,
         // Belt and braces only: agents export FORCE_COLOR, and `NO_COLOR` does not fully silence
         // OpenCode, so the strip below stays load-bearing rather than a fallback.
-        env: { ...process.env, NO_COLOR: "1", FORCE_COLOR: "0" },
+        env: { ...process.env, NO_COLOR: '1', FORCE_COLOR: '0' },
     });
     if (result.error) {
         const code = result.error.code;
         // A timeout arrives as ETIMEDOUT here, not only as a signal, so it must be named before
         // the generic spawn failure; otherwise a timeout reports "could not run".
-        if (code === "ETIMEDOUT") {
-            return { outcome: "unavailable", reason: `\`${command} ${args.join(" ")}\` timed out` };
+        if (code === 'ETIMEDOUT') {
+            return { outcome: 'unavailable', reason: `\`${command} ${args.join(' ')}\` timed out` };
         }
-        return { outcome: "unavailable", reason: spawnFailureReason(command, code) };
+        return { outcome: 'unavailable', reason: spawnFailureReason(command, code) };
     }
     // Reached only when something else killed the child, so this is a crash, not the timeout.
     if (result.signal) {
-        return { outcome: "unavailable", reason: `\`${command}\` was killed by ${result.signal}` };
+        return { outcome: 'unavailable', reason: `\`${command}\` was killed by ${result.signal}` };
     }
     // Both streams, since a colour code inside a JSON payload breaks the parse just as it
     // breaks an anchored match. Valid JSON never carries a raw ESC byte, so this cannot corrupt it.
-    const stdout = (result.stdout ?? "").replace(ANSI_SGR, "");
+    const stdout = (result.stdout ?? '').replace(ANSI_SGR, '');
     return {
-        outcome: "ran",
+        outcome: 'ran',
         exitCode: result.status ?? 1,
         stdout,
-        output: `${stdout}${(result.stderr ?? "").replace(ANSI_SGR, "")}`,
+        output: `${stdout}${(result.stderr ?? '').replace(ANSI_SGR, '')}`,
     };
 }
 /** Undefined when the probe ran and exited zero. */
 function probeReason(command, args, probe) {
-    if (probe.outcome === "unavailable")
+    if (probe.outcome === 'unavailable')
         return probe.reason;
     if (probe.exitCode === 0)
         return undefined;
-    return `\`${command} ${args.join(" ")}\` exited ${probe.exitCode}`;
+    return `\`${command} ${args.join(' ')}\` exited ${probe.exitCode}`;
 }
 // A plugin registers its server as `plugin:<plugin>:<server>`, which `mcp get tinyfish` misses.
 // The optional prefix must end in `:`, so `not-tinyfish` is not a match.
@@ -99,13 +99,13 @@ function connectionState(status) {
 }
 /** The plugin ships its own MCP server, so a working install can carry no `tinyfish` entry. */
 function fromPluginRegistration(command) {
-    const probe = runProbe(command, ["mcp", "list"]);
-    if (probe.outcome === "unavailable" || probe.exitCode !== 0)
+    const probe = runProbe(command, ['mcp', 'list']);
+    if (probe.outcome === 'unavailable' || probe.exitCode !== 0)
         return undefined;
     const match = MCP_LIST_TINYFISH_LINE.exec(probe.output);
     if (!match)
         return undefined;
-    const connected = connectionState(match[3] ?? "");
+    const connected = connectionState(match[3] ?? '');
     // `mcp list` prints no headers, so the credential behind it is unproven, never assumed.
     return {
         registered: Registered.Yes,
@@ -119,7 +119,7 @@ function fromPluginRegistration(command) {
 function tinyfishServerName(output) {
     const listed = CONFIGURED_SERVERS.exec(output)?.[1];
     return listed
-        ?.split(",")
+        ?.split(',')
         .map((name) => name.trim())
         .find((name) => SERVER_NAMED_TINYFISH.test(name));
 }
@@ -140,8 +140,8 @@ function parseMcpGet(output) {
 }
 // claude-code only. Codex cannot use this: its `mcp get` exits 0 on a missing server.
 function fromMcpGet(command) {
-    const probe = runProbe(command, ["mcp", "get", "tinyfish"]);
-    if (probe.outcome === "unavailable") {
+    const probe = runProbe(command, ['mcp', 'get', 'tinyfish']);
+    if (probe.outcome === 'unavailable') {
         return { registered: Registered.Unknown, authMode: AuthMode.Unknown, reason: probe.reason };
     }
     if (probe.exitCode !== 0) {
@@ -155,8 +155,8 @@ function fromMcpGet(command) {
         // The roster is free; `mcp list` health-checks every server.
         const scoped = tinyfishServerName(probe.output);
         if (scoped) {
-            const rescoped = runProbe(command, ["mcp", "get", scoped]);
-            if (rescoped.outcome === "ran" && rescoped.exitCode === 0) {
+            const rescoped = runProbe(command, ['mcp', 'get', scoped]);
+            if (rescoped.outcome === 'ran' && rescoped.exitCode === 0) {
                 return {
                     ...parseMcpGet(rescoped.output),
                     reason: `registered as ${scoped}`,
@@ -182,13 +182,13 @@ function fromMcpGet(command) {
 // `codex mcp get <missing>` prints an error and exits 0, so presence must never be read from
 // its exit code; `mcp list --json` is the only trustworthy read-back.
 function readCodexEntry() {
-    const args = ["mcp", "list", "--json"];
-    const probe = runProbe("codex", args);
-    if (probe.outcome === "unavailable")
+    const args = ['mcp', 'list', '--json'];
+    const probe = runProbe('codex', args);
+    if (probe.outcome === 'unavailable')
         return { reason: probe.reason };
     // Presence is never inferred from exit code 0, but a nonzero exit means the output cannot
     // be trusted either — that is `unknown`, not "no server".
-    const failure = probeReason("codex", args, probe);
+    const failure = probeReason('codex', args, probe);
     if (failure)
         return { reason: failure };
     let servers;
@@ -198,25 +198,25 @@ function readCodexEntry() {
         servers = JSON.parse(probe.stdout);
     }
     catch {
-        return { reason: "`codex mcp list --json` returned unparseable output" };
+        return { reason: '`codex mcp list --json` returned unparseable output' };
     }
     // A scalar or a wrapper object decodes fine and then silently reports "no server", which
     // would suggest a spurious repair. Anything but a list is unknown.
     const shape = codexListSchema.safeParse(servers);
     if (!shape.success)
-        return { reason: "`codex mcp list --json` returned an unexpected shape" };
-    return { entry: shape.data.find((s) => s.name === "tinyfish") };
+        return { reason: '`codex mcp list --json` returned an unexpected shape' };
+    return { entry: shape.data.find((s) => s.name === 'tinyfish') };
 }
 // `mcp add` exits 0 whether or not its inline OAuth finished, so `not_logged_in` is the only
 // evidence of an abandoned sign-in; every other state, older Codex included, is unknown.
 export function codexOauthCompleted() {
     const read = readCodexEntry();
-    if ("reason" in read)
+    if ('reason' in read)
         return undefined;
     const status = read.entry?.auth_status;
-    if (status === "o_auth")
+    if (status === 'o_auth')
         return true;
-    if (status === "not_logged_in")
+    if (status === 'not_logged_in')
         return false;
     return undefined;
 }
@@ -233,7 +233,7 @@ function declaredKeyEnvVar(harness) {
 /** Codex stores a variable name; resolving it only answers whether it is the CLI's key. */
 function envKeyVerdict(envVar) {
     if (!ENV_VAR_NAME.test(envVar)) {
-        return { keyReason: "its key comes from an unusable variable name" };
+        return { keyReason: 'its key comes from an unusable variable name' };
     }
     if (matchesCliKey(process.env[envVar]))
         return { keyMatchesCliKey: true };
@@ -245,7 +245,7 @@ function envKeyVerdict(envVar) {
 }
 function probeCodex() {
     const read = readCodexEntry();
-    if ("reason" in read)
+    if ('reason' in read)
         return { registered: Registered.Unknown, authMode: AuthMode.Unknown, reason: read.reason };
     const entry = read.entry;
     if (!entry)
@@ -253,14 +253,10 @@ function probeCodex() {
     const codexUrl = entry.transport?.url;
     // Read from this entry: codex emits `bearer_token_env_var` on every HTTP server, so testing
     // the whole payload reports api-key for TinyFish because some other server carries a key.
-    const envVar = entry.auth_status === "o_auth" ? undefined : entry.transport?.bearer_token_env_var;
+    const envVar = entry.auth_status === 'o_auth' ? undefined : entry.transport?.bearer_token_env_var;
     return {
         registered: Registered.Yes,
-        authMode: entry.auth_status === "o_auth"
-            ? AuthMode.OAuth
-            : envVar
-                ? AuthMode.ApiKey
-                : AuthMode.Unknown,
+        authMode: entry.auth_status === 'o_auth' ? AuthMode.OAuth : envVar ? AuthMode.ApiKey : AuthMode.Unknown,
         ...(codexUrl ? { registeredUrl: codexUrl } : {}),
         ...(envVar ? envKeyVerdict(envVar) : {}),
     };
@@ -271,7 +267,7 @@ function probeCursor() {
         return {
             registered: Registered.Unknown,
             authMode: AuthMode.Unknown,
-            reason: "mcp.json exists but could not be read or parsed",
+            reason: 'mcp.json exists but could not be read or parsed',
         };
     }
     if (!entry.present)
@@ -292,7 +288,11 @@ const OPENCODE_ROW_URL = /^[^\w]*tinyfish(?![\w-]).*\n[^\w]*(https?:\S+)/m;
 function fromMcpList(command, output, registeredMode, urlPattern) {
     if (LISTED_AS_TINYFISH.test(output)) {
         const url = urlPattern?.exec(output)?.[1];
-        return { registered: Registered.Yes, authMode: registeredMode, ...(url ? { registeredUrl: url } : {}) };
+        return {
+            registered: Registered.Yes,
+            authMode: registeredMode,
+            ...(url ? { registeredUrl: url } : {}),
+        };
     }
     if (!MCP_LIST_HEADER.test(output)) {
         return {
@@ -305,18 +305,18 @@ function fromMcpList(command, output, registeredMode, urlPattern) {
 }
 // connect only ever writes an OAuth Hermes entry, so `oauth` is a fact, not a detection gap.
 function probeHermes() {
-    const args = ["mcp", "list"];
-    const probe = runProbe("hermes", args);
-    if (probe.outcome !== "ran" || probe.exitCode !== 0) {
-        const reason = probeReason("hermes", args, probe);
+    const args = ['mcp', 'list'];
+    const probe = runProbe('hermes', args);
+    if (probe.outcome !== 'ran' || probe.exitCode !== 0) {
+        const reason = probeReason('hermes', args, probe);
         return { registered: Registered.Unknown, authMode: AuthMode.Unknown, reason };
     }
-    return fromMcpList("hermes", probe.output, AuthMode.OAuth);
+    return fromMcpList('hermes', probe.output, AuthMode.OAuth);
 }
 const SKILL_DIR_IS_TINYFISH = /^(?:@tinyfish[/_-])?tinyfish(?![\w-])/i;
 // OpenClaw installs a skill, not an MCP server; the skill shells the CLI, so auth is the CLI key.
 function probeOpenClaw() {
-    const skillsDir = path.join(harnessConfigPath("openclaw"), "skills");
+    const skillsDir = path.join(harnessConfigPath('openclaw'), 'skills');
     let entries;
     try {
         entries = fs.readdirSync(skillsDir);
@@ -325,7 +325,7 @@ function probeOpenClaw() {
         return {
             registered: Registered.Unknown,
             authMode: AuthMode.Unknown,
-            reason: `no global skills directory at ${harnessDisplayPath("openclaw")}/skills; OpenClaw layout is unverified`,
+            reason: `no global skills directory at ${harnessDisplayPath('openclaw')}/skills; OpenClaw layout is unverified`,
         };
     }
     // A bare substring also matched a skill merely named `not-tinyfish-thing`.
@@ -335,13 +335,13 @@ function probeOpenClaw() {
 }
 // `opencode mcp list` prints no headers, so a key-authed registration is indistinguishable.
 function probeOpencode() {
-    const args = ["mcp", "list"];
-    const probe = runProbe("opencode", args);
-    if (probe.outcome !== "ran" || probe.exitCode !== 0) {
-        const reason = probeReason("opencode", args, probe);
+    const args = ['mcp', 'list'];
+    const probe = runProbe('opencode', args);
+    if (probe.outcome !== 'ran' || probe.exitCode !== 0) {
+        const reason = probeReason('opencode', args, probe);
         return { registered: Registered.Unknown, authMode: AuthMode.Unknown, reason };
     }
-    return fromMcpList("opencode", probe.output, AuthMode.Unknown, OPENCODE_ROW_URL);
+    return fromMcpList('opencode', probe.output, AuthMode.Unknown, OPENCODE_ROW_URL);
 }
 // Verified against grok 0.0.60: a list. Header values stay `unknown`; only names are read.
 const grokEntrySchema = z.looseObject({
@@ -354,8 +354,8 @@ const grokListSchema = z.array(grokEntrySchema);
 const grokPluginSchema = z.array(z.looseObject({ name: z.string().optional() }));
 /** The Grok plugin ships its own MCP server, and `grok mcp list` does not show it. */
 function fromGrokPlugin() {
-    const probe = runProbe("grok", ["plugin", "list", "--json"]);
-    if (probe.outcome === "unavailable" || probe.exitCode !== 0)
+    const probe = runProbe('grok', ['plugin', 'list', '--json']);
+    if (probe.outcome === 'unavailable' || probe.exitCode !== 0)
         return undefined;
     let listed;
     try {
@@ -372,16 +372,16 @@ function fromGrokPlugin() {
         return {
             registered: Registered.Unknown,
             authMode: AuthMode.Unknown,
-            reason: "`grok plugin list --json` returned an unexpected shape",
+            reason: '`grok plugin list --json` returned an unexpected shape',
         };
     }
-    if (!shape.data.some((plugin) => plugin.name === "tinyfish"))
+    if (!shape.data.some((plugin) => plugin.name === 'tinyfish'))
         return undefined;
     // The plugin manifest carries no headers, so its only credential path is the browser sign-in.
     return {
         registered: Registered.Yes,
         authMode: AuthMode.OAuth,
-        reason: "registered by the TinyFish Grok plugin",
+        reason: 'registered by the TinyFish Grok plugin',
     };
 }
 // Grok inherits our env, so a header we wrote round-trips to our own value.
@@ -391,21 +391,21 @@ function grokWroteIt(value, declared) {
 }
 /** The descriptor names the variable; envKeyVerdict owns every wording for it. */
 function grokKeyAuth(headers) {
-    const authorization = Object.entries(headers).find(([name]) => name.toLowerCase() === "authorization");
+    const authorization = Object.entries(headers).find(([name]) => name.toLowerCase() === 'authorization');
     if (!authorization)
         return { authMode: AuthMode.OAuth };
-    const declared = declaredKeyEnvVar("grok");
-    const value = typeof authorization[1] === "string" ? authorization[1] : "";
+    const declared = declaredKeyEnvVar('grok');
+    const value = typeof authorization[1] === 'string' ? authorization[1] : '';
     if (!declared || !grokWroteIt(value, declared)) {
-        return { authMode: AuthMode.ApiKey, keyReason: "it holds a key this CLI cannot verify" };
+        return { authMode: AuthMode.ApiKey, keyReason: 'it holds a key this CLI cannot verify' };
     }
     return { authMode: AuthMode.ApiKey, ...envKeyVerdict(declared) };
 }
 // Grok has no `mcp get`; `mcp list --json` is the only machine-readable view.
 function probeGrok() {
-    const args = ["mcp", "list", "--json"];
-    const probe = runProbe("grok", args);
-    if (probe.outcome === "unavailable") {
+    const args = ['mcp', 'list', '--json'];
+    const probe = runProbe('grok', args);
+    if (probe.outcome === 'unavailable') {
         return { registered: Registered.Unknown, authMode: AuthMode.Unknown, reason: probe.reason };
     }
     if (probe.exitCode !== 0) {
@@ -413,13 +413,13 @@ function probeGrok() {
             return {
                 registered: Registered.Unknown,
                 authMode: AuthMode.Unknown,
-                reason: "this Grok build has no `mcp list --json`",
+                reason: 'this Grok build has no `mcp list --json`',
             };
         }
         return {
             registered: Registered.Unknown,
             authMode: AuthMode.Unknown,
-            reason: probeReason("grok", args, probe),
+            reason: probeReason('grok', args, probe),
         };
     }
     let entries;
@@ -430,10 +430,10 @@ function probeGrok() {
         return {
             registered: Registered.Unknown,
             authMode: AuthMode.Unknown,
-            reason: "`grok mcp list --json` did not return the expected shape",
+            reason: '`grok mcp list --json` did not return the expected shape',
         };
     }
-    const entry = entries.find((server) => server.name === "tinyfish");
+    const entry = entries.find((server) => server.name === 'tinyfish');
     if (!entry)
         return fromGrokPlugin() ?? { registered: Registered.No, authMode: AuthMode.Unknown };
     return {
@@ -443,7 +443,7 @@ function probeGrok() {
     };
 }
 const PROBES = {
-    "claude-code": () => fromMcpGet("claude"),
+    'claude-code': () => fromMcpGet('claude'),
     codex: probeCodex,
     cursor: probeCursor,
     grok: probeGrok,
@@ -474,14 +474,14 @@ export function detectRegistrations(harnesses) {
         catch (e) {
             // An arbitrary throw is the one message we cannot author, so it never ships. Full
             // fidelity stays on stderr behind --debug, which is not the pasted artifact.
-            if (process.env["TINYFISH_DEBUG"]) {
+            if (process.env['TINYFISH_DEBUG']) {
                 errLine(`probe ${detection.harness} threw: ${e instanceof Error ? e.message : String(e)}`);
             }
             return {
                 ...base,
                 registered: Registered.Unknown,
                 authMode: AuthMode.Unknown,
-                reason: "the probe failed unexpectedly",
+                reason: 'the probe failed unexpectedly',
             };
         }
     });

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

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 /**
  * `TINYFISH_NO_TELEMETRY` suppresses ALL CLI-emitted network analytics
  * (setup_completed, connect-event, update check). Any value except `0`/`false`
@@ -68,10 +68,10 @@ export declare const setupCompletedPayloadSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type SetupCompletedPayload = z.infer<typeof setupCompletedPayloadSchema>;
 export type HarnessResult = z.infer<typeof harnessResultSchema>;
-export type SetupMode = NonNullable<SetupCompletedPayload["mode"]>;
-export type UpgradeOutcome = "updated" | "failed" | "interrupted";
+export type SetupMode = NonNullable<SetupCompletedPayload['mode']>;
+export type UpgradeOutcome = 'updated' | 'failed' | 'interrupted';
 /** Step selection; "updated" means every selected step ran. */
-export type UpgradeScope = "both" | "cli" | "skill";
+export type UpgradeScope = 'both' | 'cli' | 'skill';
 /** `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, scope: UpgradeScope, apiKey?: string): Promise<void>;
 export declare function sendSetupCompleted(mcpUrl: string, harnesses: HarnessResult[], apiKey?: string, mode?: SetupMode): Promise<void>;