@tiny-fish/cli 0.18.1-next.172 → 0.18.1-next.174

package/dist/commands/auth.js

@@ -1,7 +1,7 @@
 import { spawn } from "child_process";
 import * as readline from "readline";
 import { Option } from "commander";
-import { clearConfig, getDashboardUrl, loadConfig, maskKey, saveConfig, validateKeyFormat, } from "../lib/auth.js";
+import { CONNECT_ATTEMPT_ENV, clearConfig, getDashboardUrl, loadConfig, maskKey, savePendingConnectAttempt, saveConfig, validateKeyFormat, } from "../lib/auth.js";
 import { err, errLine, out, outLine } from "../lib/output.js";
 /**
  * Read a key from stdin without echoing it to the terminal.
@@ -66,6 +66,13 @@ async function readKeyFromStdinOrPrompt() {
     }
     return readKeyHidden("Paste your API key: ");
 }
+// Sign-in and the connect that follows are separate copied commands, so a page-minted id
+// handed to this process has to outlive it.
+function parkSeedAttempt() {
+    const seed = process.env[CONNECT_ATTEMPT_ENV];
+    if (seed)
+        savePendingConnectAttempt(seed);
+}
 export function registerAuth(program) {
     const auth = program.command("auth").description("Manage your TinyFish API key");
     auth
@@ -110,6 +117,7 @@ export function registerAuth(program) {
             process.exit(1);
         }
         saveConfig(key);
+        parkSeedAttempt();
         out({ status: "ok", message: "API key saved", key_preview: maskKey(key) });
     });
     auth
@@ -127,6 +135,7 @@ export function registerAuth(program) {
             process.exit(1);
         }
         saveConfig(key);
+        parkSeedAttempt();
         out({ status: "ok", message: "API key saved", key_preview: maskKey(key) });
     });
     auth

package/dist/commands/connect.js

@@ -1,13 +1,14 @@
 import { randomUUID } from "node:crypto";
 import * as path from "node:path";
 import spawn from "cross-spawn";
-import { CONNECT_SOURCE, loadConfig, persistApiKeyToEnvironment, resolvedApiKey, saveConnectContext, validateKeyFormat, validatedApiKey, writeConfig, } from "../lib/auth.js";
+import { CONNECT_ATTEMPT_ENV, CONNECT_SOURCE, isAttemptId, loadConfig, persistApiKeyToEnvironment, resolvedApiKey, saveConnectContext, takePendingConnectAttempt, validateKeyFormat, validatedApiKey, 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 { emitNotice } from "../lib/notice.js";
 import { errLine, sanitizeLine } from "../lib/output.js";
+import { codexOauthCompleted } from "../lib/registration-detect.js";
 import { z } from "zod";
 import { installSignalGuard } from "../lib/signals.js";
 import { postConnectEvent, telemetryDisabled } from "../lib/setup-telemetry.js";
@@ -192,6 +193,9 @@ const CODEX = {
         unavailableMessage: CODEX_OAUTH_RESOURCE_UNAVAILABLE_MESSAGE,
     },
     launchWalkthrough: launchCodexWalkthrough,
+    probeAuthenticated: codexOauthCompleted,
+    // Retry only: running it after a finished inline OAuth is a second browser hop.
+    loginArgs: ["mcp", "login", "tinyfish"],
     removals: [{ args: ["mcp", "remove", "tinyfish"], label: "TinyFish registration from Codex" }],
     addArgs: (mcpUrl, oauthResource) => [
         "mcp",
@@ -287,9 +291,24 @@ const OPENCLAW = {
         unavailableMessage: OPENCLAW_SKILL_UNAVAILABLE_MESSAGE,
     },
 };
+/**
+ * One page-minted id seeds one install attempt, so `tinyfish onboard` connecting three agents
+ * does not report three installs under it. Later connects in the run fall back to a random id.
+ */
+function takeSeedAttemptId() {
+    const fromEnv = process.env[CONNECT_ATTEMPT_ENV];
+    // Both sources are read-and-clear, and the delete lands before any subprocess inherits it.
+    delete process.env[CONNECT_ATTEMPT_ENV];
+    const parked = takePendingConnectAttempt();
+    return fromEnv && isAttemptId(fromEnv) ? fromEnv : parked;
+}
 function createConnectTelemetry(mcpUrl, client, opts) {
-    // A setup-page id (via --url) joins "copied the command" to this install attempt.
-    const attemptId = opts?.attemptId ?? randomUUID();
+    // Consumed even when --url already supplied an id: leaving it behind would let a stale
+    // seed reach the agent this connect launches, or the next connect on this machine.
+    const seeded = takeSeedAttemptId();
+    // 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 ?? randomUUID();
     const endpoint = new URL("/api/cli/connect-event", mcpUrl).toString();
     const pending = [];
     async function deliver(body) {
@@ -612,7 +631,9 @@ async function connectNativeMcpClient(client, options) {
         // Undefining `loginArgs` reuses the deferred-auth path codex/hermes already take.
         const loginDegraded = !!client.loginArgs && !optionalSupported;
         const loginArgs = loginDegraded ? undefined : client.loginArgs;
-        state.stage = loginArgs ? "registration" : "registration_or_authentication";
+        // A probed client authenticates inside `mcp add` too, so a failure there is either.
+        state.stage =
+            loginArgs && !client.probeAuthenticated ? "registration" : "registration_or_authentication";
         errLine(`Adding TinyFish to ${client.displayName}...`);
         const addResult = spawn.sync(client.command, [
             ...client.addArgs(mcpUrl.toString(), options.mcpUrl),
@@ -629,6 +650,11 @@ async function connectNativeMcpClient(client, options) {
             });
         }
         telemetry.track("checkpoint", { phase: "registered" });
+        // Codex runs OAuth inside `mcp add` and exits 0 either way, so the recorded state decides
+        // whether the login step below still runs. Unknown keeps the pre-probe behaviour.
+        const addSignedIn = client.probeAuthenticated?.();
+        if (addSignedIn)
+            telemetry.track("checkpoint", { phase: "oauth_done" });
         const degradedNotes = loginDegraded ? client.degradedAuthNotes : undefined;
         if (useKeyAuth) {
             errLine(degradedNotes?.keyed ?? "Using your stored TinyFish API key — no browser sign-in needed.");
@@ -637,10 +663,13 @@ async function connectNativeMcpClient(client, options) {
             // Printed here, not with the closing line, so a `--launch` run sees it before the handover.
             errLine(degradedNotes.deferred);
         }
-        if (loginArgs && !useKeyAuth) {
+        // A probed client signs in again only when its inline OAuth is known to have been abandoned.
+        const retryLogin = client.probeAuthenticated ? addSignedIn === false : true;
+        const pendingLogin = !useKeyAuth && retryLogin ? loginArgs : undefined;
+        if (pendingLogin) {
             state.stage = "client_oauth";
             errLine("Signing in to TinyFish...");
-            const loginResult = spawn.sync(client.command, loginArgs, {
+            const loginResult = spawn.sync(client.command, pendingLogin, {
                 stdio: "inherit",
             });
             if (loginResult.error || loginResult.status !== 0) {
@@ -653,7 +682,7 @@ async function connectNativeMcpClient(client, options) {
         }
         // Registration/OAuth make MCP work; later steps are cosmetic and must not fail the attempt.
         settle(state, telemetry, "completed");
-        runPostInstallSteps(client, options, state, telemetry, !loginArgs && !useKeyAuth);
+        runPostInstallSteps(client, options, state, telemetry, !useKeyAuth && !addSignedIn && !pendingLogin);
     });
 }
 function connectedLine(client, signInDeferred) {

package/dist/lib/auth.d.ts

@@ -2,14 +2,28 @@ export { DASHBOARD_URL, getDashboardUrl } from "./constants.js";
 export declare function configDir(): string;
 /** Install channel baked onto connect context; the connect flow is always CLI-driven. */
 export declare const CONNECT_SOURCE = "tinyfish_cli";
+export declare const CONNECT_ATTEMPT_ENV = "TINYFISH_CONNECT_ATTEMPT_ID";
 interface ConnectEntry {
     attempt_id: string;
 }
+interface PendingConnectAttempt {
+    id: string;
+    ts: number;
+}
 interface TinyfishConfig {
     api_key?: string;
     connect?: Record<string, ConnectEntry>;
+    pending_connect_attempt?: PendingConnectAttempt;
 }
 export declare function loadConfig(): TinyfishConfig;
+export declare function isAttemptId(value: string): boolean;
+/**
+ * Park a page-minted attempt id for the connect that follows in a later process:
+ * `auth login` and the connect it leads to are separate copied commands.
+ */
+export declare function savePendingConnectAttempt(attemptId: string): void;
+/** Read-and-clear: one parked id seeds one install attempt, expired or not. */
+export declare function takePendingConnectAttempt(): string | undefined;
 /** Throwing variant for callers with their own cleanup (connect's telemetry flush). */
 export declare function writeConfig(apiKey: string): void;
 export declare function saveConfig(apiKey: string): void;

package/dist/lib/auth.js

@@ -15,6 +15,9 @@ function configFile() {
 }
 /** Install channel baked onto connect context; the connect flow is always CLI-driven. */
 export const CONNECT_SOURCE = "tinyfish_cli";
+// An env var, not a flag: released CLIs ignore an unknown one, and the installer's PATH
+// prepend means a copied command can still run a CLI far older than the page that wrote it.
+export const CONNECT_ATTEMPT_ENV = "TINYFISH_CONNECT_ATTEMPT_ID";
 export function loadConfig() {
     try {
         const raw = JSON.parse(fs.readFileSync(configFile(), "utf8"));
@@ -27,6 +30,9 @@ export function loadConfig() {
         const connect = parseConnectMap(obj["connect"]);
         if (connect)
             config.connect = connect;
+        const pending = parsePendingAttempt(obj["pending_connect_attempt"]);
+        if (pending)
+            config.pending_connect_attempt = pending;
         return config;
     }
     catch {
@@ -44,16 +50,63 @@ function parseConnectMap(value) {
     }
     return Object.keys(out).length > 0 ? out : undefined;
 }
-/** Throwing variant for callers with their own cleanup (connect's telemetry flush). */
-export function writeConfig(apiKey) {
-    const dir = configDir();
+function parsePendingAttempt(value) {
+    const entry = value;
+    if (typeof entry?.id !== "string" || typeof entry.ts !== "number")
+        return undefined;
+    return isAttemptId(entry.id) ? { id: entry.id, ts: entry.ts } : undefined;
+}
+export function isAttemptId(value) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+/**
+ * The one read-modify-write of the config file. Every caller goes through it so the
+ * loadConfig whitelist stays the single definition of what survives a write. Throws;
+ * callers own their failure policy, which differs per command.
+ */
+function updateConfig(change) {
     // 0o700: only owner can read/write/execute the directory
-    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-    const existing = loadConfig();
+    fs.mkdirSync(configDir(), { recursive: true, mode: 0o700 });
     // 0o600: only owner can read/write the config file (key is sensitive)
-    fs.writeFileSync(configFile(), JSON.stringify({ ...existing, api_key: apiKey }), {
-        mode: 0o600,
-    });
+    fs.writeFileSync(configFile(), JSON.stringify(change(loadConfig())), { mode: 0o600 });
+}
+/**
+ * Park a page-minted attempt id for the connect that follows in a later process:
+ * `auth login` and the connect it leads to are separate copied commands.
+ */
+export function savePendingConnectAttempt(attemptId) {
+    if (!isAttemptId(attemptId))
+        return;
+    try {
+        updateConfig((config) => ({
+            ...config,
+            pending_connect_attempt: { id: attemptId, ts: Date.now() },
+        }));
+    }
+    catch {
+        // Attribution is never worth failing a sign-in for.
+    }
+}
+// Older than this and the id belongs to some abandoned setup, not the connect running now.
+const PENDING_ATTEMPT_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+/** Read-and-clear: one parked id seeds one install attempt, expired or not. */
+export function takePendingConnectAttempt() {
+    const pending = loadConfig().pending_connect_attempt;
+    if (!pending)
+        return undefined;
+    try {
+        updateConfig(({ pending_connect_attempt: _cleared, ...rest }) => rest);
+    }
+    catch {
+        // An id still on disk would be claimed twice, and a double-counted install is worse
+        // than a missed join.
+        return undefined;
+    }
+    return Date.now() - pending.ts <= PENDING_ATTEMPT_MAX_AGE_MS ? pending.id : undefined;
+}
+/** Throwing variant for callers with their own cleanup (connect's telemetry flush). */
+export function writeConfig(apiKey) {
+    updateConfig((config) => ({ ...config, api_key: apiKey }));
 }
 export function saveConfig(apiKey) {
     try {
@@ -65,12 +118,11 @@ export function saveConfig(apiKey) {
     }
 }
 export function saveConnectContext(client, attemptId) {
-    const dir = configDir();
     try {
-        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-        const existing = loadConfig();
-        const connect = { ...existing.connect, [client]: { attempt_id: attemptId } };
-        fs.writeFileSync(configFile(), JSON.stringify({ ...existing, connect }), { mode: 0o600 });
+        updateConfig((config) => ({
+            ...config,
+            connect: { ...config.connect, [client]: { attempt_id: attemptId } },
+        }));
     }
     catch (e) {
         // Best-effort attribution marker: a write failure must not fail a connect that has
@@ -119,12 +171,12 @@ export function persistApiKeyToEnvironment(apiKey, options = {}) {
     fs.chmodSync(profile, 0o600);
 }
 export function clearConfig() {
-    const config = loadConfig();
-    if (!config.api_key)
+    if (!loadConfig().api_key)
         return false;
-    delete config.api_key;
     try {
-        fs.writeFileSync(configFile(), JSON.stringify(config), { mode: 0o600 });
+        // The parked id goes too: the next person to sign in on this machine is not the one
+        // whose copy minted it.
+        updateConfig(({ api_key: _key, pending_connect_attempt: _attempt, ...rest }) => rest);
         return true;
     }
     catch {

package/dist/lib/connect-all.js

@@ -18,6 +18,7 @@ const DISPLAY_NAMES = {
     opencode: "OpenCode",
 };
 // `codex mcp add` succeeds unauthenticated; OAuth lands at first tool use.
+// TODO(PF-3580): connect now probes Codex sign-in, so this over-warns a signed-in install.
 const AUTH_DEFERRED_AT_INSTALL = new Set(["codex"]);
 // Harnesses that drive their own OAuth at install — a stored TinyFish key says nothing
 // about their session, so it must never unlock a headless run for them.

package/dist/lib/doctor-report.d.ts

@@ -43,8 +43,8 @@ declare const doctorHarnessSchema: z.ZodObject<{
     }>;
     auth_mode: z.ZodEnum<{
         unknown: "unknown";
-        oauth: "oauth";
         "api-key": "api-key";
+        oauth: "oauth";
     }>;
     proves_harness_reach: z.ZodBoolean;
 }, z.core.$strip>;
@@ -105,8 +105,8 @@ export declare const doctorReportSchema: z.ZodObject<{
         }>;
         auth_mode: z.ZodEnum<{
             unknown: "unknown";
-            oauth: "oauth";
             "api-key": "api-key";
+            oauth: "oauth";
         }>;
         proves_harness_reach: z.ZodBoolean;
     }, z.core.$strip>>;

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

@@ -11,5 +11,6 @@ export interface RegistrationStatus {
     registeredUrl?: string;
     reason?: string;
 }
+export declare function codexOauthCompleted(): boolean | undefined;
 /** Never throws; a failed probe is `unknown` with a reason, so no caller can read it as healthy. */
 export declare function detectRegistrations(harnesses?: Harness[]): RegistrationStatus[];

package/dist/lib/registration-detect.js

@@ -129,19 +129,14 @@ function fromMcpGet(command, keyAuthPattern) {
 }
 // `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 probeCodex() {
+function readCodexEntry() {
     const probe = runProbe("codex", ["mcp", "list", "--json"]);
-    if (probe.outcome === "unavailable") {
-        return { registered: "unknown", authMode: "unknown", reason: probe.reason };
-    }
+    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".
     if (probe.exitCode !== 0) {
-        return {
-            registered: "unknown",
-            authMode: "unknown",
-            reason: `\`codex mcp list --json\` exited ${probe.exitCode}`,
-        };
+        return { reason: `\`codex mcp list --json\` exited ${probe.exitCode}` };
     }
     let servers;
     try {
@@ -150,26 +145,35 @@ function probeCodex() {
         servers = JSON.parse(probe.stdout);
     }
     catch {
-        return {
-            registered: "unknown",
-            authMode: "unknown",
-            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 {
-            registered: "unknown",
-            authMode: "unknown",
-            reason: "`codex mcp list --json` returned an unexpected shape",
-        };
-    }
-    const entry = shape.data.find((s) => s.name === "tinyfish");
+    if (!shape.success)
+        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)
+        return undefined;
+    const status = read.entry?.auth_status;
+    if (status === "o_auth")
+        return true;
+    if (status === "not_logged_in")
+        return false;
+    return undefined;
+}
+function probeCodex() {
+    const read = readCodexEntry();
+    if ("reason" in read)
+        return { registered: "unknown", authMode: "unknown", reason: read.reason };
+    const entry = read.entry;
     if (!entry)
         return { registered: "no", authMode: "unknown" };
-    // auth_status is the configured auth type, not whether a login succeeded — exactly auth_mode.
     const codexUrl = entry.transport?.url;
     return {
         registered: "yes",

package/package.json

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