@tiny-fish/cli 0.52.4-next.429 → 0.52.4-next.432

package/dist/lib/connect-native.js

@@ -10,6 +10,7 @@ import { AuthMode, RELOAD_ACTION } from './harness/harness-detect.js';
 import { SIGN_IN_PROBES } from './registration-detect.js';
 import { errLine, warnLine } from './output.js';
 import { verifyMcpAuth } from './verify.js';
+import { dotenvMarkerHead, harnessDotenvPath, writeDotenvKey } from './dotenv-file.js';
 import { apiBaseFromMcpUrl } from './mcp-endpoint.js';
 import { finishSetupHint, requireKeylessMcp, requireSupportOrRescue, runCliInstallStep, trackPostInstallFailure, walkthroughPhase, } from './connect-steps.js';
 function removeExistingRegistration(client, removal, verbose) {
@@ -43,12 +44,35 @@ function exportApiKey(apiKey, displayName, deferOutro) {
     }
     return true;
 }
+/** Best-effort: the profile export still covers terminal launches. */
+function seedHarnessDotenv(client, keyed, deferOutro) {
+    const { envVar } = keyed.spec;
+    const envPath = harnessDotenvPath(client.connectClient);
+    if (!envPath || !envVar)
+        return false;
+    try {
+        // Unlike Hermes, nothing else needs this file group-readable.
+        writeDotenvKey(envPath, envVar, keyed.key, dotenvMarkerHead(client.connectClient), {
+            ownerOnly: true,
+        });
+    }
+    catch (error) {
+        warnLine(`Could not write ${envVar} to ${envPath} (${error instanceof Error ? error.message : String(error)}).`);
+        return false;
+    }
+    const line = `Wrote ${envVar} to ${envPath} — ${client.displayName} reads the key from there.`;
+    (deferOutro ?? errLine)(line);
+    return true;
+}
 function resolveKeyedAdd(client, storedKey, keyAuthSupported, keyAuthOnly, deferOutro) {
     if (!storedKey || !keyAuthSupported || !client.keyAuth)
         return undefined;
     const keyed = { key: storedKey, spec: client.keyAuth };
+    const seededDotenv = seedHarnessDotenv(client, keyed, deferOutro);
     // Before the removals: a failed export must not strand the old registration.
-    if (keyed.spec.envVar && !exportApiKey(keyed.key, client.displayName, deferOutro)) {
+    if (keyed.spec.envVar &&
+        !exportApiKey(keyed.key, client.displayName, deferOutro) &&
+        !seededDotenv) {
         if (keyAuthOnly)
             refuseFailedKeyExport(client);
         errLine(`Signing in to ${client.displayName} instead.`);

package/dist/lib/doctor-checks.js

@@ -116,6 +116,8 @@ function registrationVerdict(status, mcpUrl, keyAuth, cliKeyMissing) {
         }
         // Ordered before the key check: the harness's own verdict wins.
         if (status.connected === false) {
+            if (status.keyReason)
+                return { status: 'warn', detail: `registered, but ${status.keyReason}` };
             return {
                 status: 'warn',
                 detail: 'registered, but the harness reports it cannot reach TinyFish; sign in again there',

package/dist/lib/dotenv-file.d.ts

@@ -0,0 +1,10 @@
+import { type Harness } from './harness/harness-spec.js';
+export declare function harnessDotenvPath(harness: Harness): string | undefined;
+export declare function dotenvMarkerHead(client: string): string;
+export declare function writeDotenvKey(envPath: string, varName: string, key: string, markerHead: string, { ownerOnly }?: {
+    ownerOnly?: boolean;
+}): void;
+export declare function readDotenvKey(envPath: string, varName: string): string | undefined;
+/** Restores the exact line writeDotenvKey replaces, quotes and comment included. */
+export declare function captureDotenvKeyRestore(envPath: string, varName: string, markerHead: string): () => void;
+export declare function removeDotenvKey(envPath: string, varName: string, markerHead: string): boolean;

package/dist/lib/dotenv-file.js

@@ -0,0 +1,124 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { harnessSpec } from './harness/harness-spec.js';
+import { harnessConfigPath } from './harness/harness-detect.js';
+const MARKER_TAIL = '# tinyfish-cli: end';
+// Keys are `sk-tinyfish-<alnum>`; refusing anything else beats shipping unreachable escaping.
+const BARE_SAFE = /^[A-Za-z0-9._\-/:+=]+$/;
+export function harnessDotenvPath(harness) {
+    return harnessSpec(harness).keyDotenv ? path.join(harnessConfigPath(harness), '.env') : undefined;
+}
+export function dotenvMarkerHead(client) {
+    return `# tinyfish-cli: TinyFish MCP key, managed by \`tinyfish connect ${client}\``;
+}
+/** Mirrors Hermes' _env_line_defines_key: load_env() parses the export form too. */
+function definesKey(line, varName) {
+    const stripped = line.trim().replace(/^export\s+/, '');
+    return stripped.startsWith(`${varName}=`);
+}
+// A leading BOM would otherwise ride into the first key's name.
+function readLines(envPath) {
+    if (!fs.existsSync(envPath))
+        return [];
+    const raw = fs.readFileSync(envPath);
+    // A valid UTF-8 .env has no NUL; every wide encoding does.
+    if (raw.includes(0)) {
+        throw new Error(`${envPath} contains NUL bytes, so it is a wide encoding or corrupt; TinyFish can only ` +
+            `edit a UTF-8 .env. Re-save it as UTF-8 and retry.`);
+    }
+    return raw
+        .toString('utf8')
+        .replace(/^\uFEFF/, '')
+        .split(/(?<=\n)/);
+}
+// Hermes preserves the original mode so Docker volume mounts survive (config.py:3921-3929).
+function writeAtomic(envPath, lines, ownerOnly = false) {
+    let mode = 0o600;
+    try {
+        mode = fs.statSync(envPath).mode & 0o777;
+    }
+    catch {
+        // No existing file: 0600 is the right default for credentials.
+    }
+    if (ownerOnly)
+        mode &= 0o700;
+    const tmp = `${envPath}.${randomUUID()}.tmp`;
+    try {
+        fs.writeFileSync(tmp, lines.join(''), { encoding: 'utf8', mode });
+        // open() applies mode through umask; chmod bypasses it, preserving bits.
+        fs.chmodSync(tmp, mode);
+        fs.renameSync(tmp, envPath);
+    }
+    catch (error) {
+        fs.rmSync(tmp, { force: true });
+        throw error;
+    }
+}
+export function writeDotenvKey(envPath, varName, key, markerHead, { ownerOnly = false } = {}) {
+    const clean = key.replace(/[\r\n]/g, '').trim();
+    // An empty key reads as "bad characters" without its own branch.
+    if (!clean)
+        throw new Error(`TinyFish API key is empty; nothing to write to ${envPath}`);
+    if (!BARE_SAFE.test(clean)) {
+        throw new Error('TinyFish API key contains characters that cannot be written to a .env file');
+    }
+    fs.mkdirSync(path.dirname(envPath), { recursive: true });
+    const lines = readLines(envPath);
+    const assignment = `${varName}=${clean}\n`;
+    const index = lines.findIndex((line) => definesKey(line, varName));
+    if (index < 0) {
+        if (lines.length && !lines[lines.length - 1].endsWith('\n'))
+            lines[lines.length - 1] += '\n';
+        lines.push(`${markerHead}\n`, assignment, `${MARKER_TAIL}\n`);
+        writeAtomic(envPath, lines, ownerOnly);
+        return;
+    }
+    lines[index] = assignment;
+    // Dotenv loaders are last-wins; a surviving duplicate would beat this value.
+    writeAtomic(envPath, lines.filter((line, i) => i === index || !definesKey(line, varName)), ownerOnly);
+}
+export function readDotenvKey(envPath, varName) {
+    const line = readLines(envPath).find((l) => definesKey(l, varName));
+    if (!line)
+        return undefined;
+    // We never write quoted values, so a quoted one isn't ours.
+    const raw = line
+        .trim()
+        .replace(/^export\s+/, '')
+        .slice(varName.length + 1)
+        .trim();
+    return BARE_SAFE.test(raw) ? raw : undefined;
+}
+/** Restores the exact line writeDotenvKey replaces, quotes and comment included. */
+export function captureDotenvKeyRestore(envPath, varName, markerHead) {
+    // Raw, not readDotenvKey: its parse drops quoted and comment-trailed values.
+    const previous = readLines(envPath).find((line) => definesKey(line, varName));
+    return () => {
+        if (previous === undefined) {
+            removeDotenvKey(envPath, varName, markerHead);
+            return;
+        }
+        let restored = false;
+        const lines = readLines(envPath).flatMap((line) => {
+            if (!definesKey(line, varName))
+                return [line];
+            if (restored)
+                return [];
+            restored = true;
+            return [previous];
+        });
+        writeAtomic(envPath, restored ? lines : [...lines, previous]);
+    };
+}
+export function removeDotenvKey(envPath, varName, markerHead) {
+    const lines = readLines(envPath);
+    if (!lines.length)
+        return false;
+    const isMarker = (line) => line.trim() === markerHead || line.trim() === MARKER_TAIL;
+    const kept = lines.filter((line) => !definesKey(line, varName) && !isMarker(line));
+    if (kept.length === lines.length)
+        return false;
+    writeAtomic(envPath, kept);
+    return true;
+}

package/dist/lib/harness/harness-detect.js

@@ -5,6 +5,7 @@ import which from 'which';
 import { ALL_HARNESSES, harnessSpec } from './harness-spec.js';
 import { clineConfigDir } from '../config/cline-config.js';
 import { piAgentDir, piBinaryIsPi } from '../config/pi-config.js';
+import { agentHome } from '../skill-paths.js';
 export { ALL_HARNESSES };
 export const HARNESS_DISPLAY_NAMES = Object.fromEntries(ALL_HARNESSES.map((harness) => [harness, harnessSpec(harness).displayName]));
 export const RELOAD_ACTION = Object.fromEntries(ALL_HARNESSES.map((harness) => [harness, harnessSpec(harness).reloadAction]));
@@ -34,9 +35,10 @@ export function commandOnPath(command) {
         return false;
     }
 }
-// PI_CODING_AGENT_DIR and CLINE_DIR move these dirs; a guessed path would be written unread.
+// Env vars move these dirs; a guessed path would go unread.
 const CONFIG_PATH_RESOLVERS = {
     cline: clineConfigDir,
+    codex: () => agentHome('CODEX_HOME', harnessSpec('codex').configDir),
     pi: piAgentDir,
 };
 export function harnessConfigPath(harness) {

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

@@ -48,6 +48,8 @@ export interface HarnessSpec {
     };
     /** Keyed adds append this flag plus the env var name (Codex). */
     keyEnvFlag?: string;
+    /** The harness loads `<config dir>/.env` at launch (Codex). */
+    keyDotenv?: boolean;
     /** Keyed adds append these flags; the key itself is seeded elsewhere (Hermes). */
     keyAddFlags?: string[];
     /** No sign-in exists here, so connect refuses a keyless install (Hermes). */
@@ -156,6 +158,7 @@ export declare const HARNESS_SPECS: {
         };
         urlStyle: "flag";
         keyEnvFlag: string;
+        keyDotenv: true;
         degradedAuthNotes: {
             keyed: string;
             deferred: string;

package/dist/lib/harness/harness-spec.js

@@ -78,6 +78,8 @@ export const HARNESS_SPECS = {
         urlStyle: 'flag',
         // Codex has no `--header`; the MCP server takes a key as `Bearer sk-…`.
         keyEnvFlag: '--bearer-token-env-var',
+        // GUI launches skip the shell profile; unset variable drops the server.
+        keyDotenv: true,
         degradedAuthNotes: { keyed: CODEX_KEYED_FALLBACK_NOTE, deferred: CODEX_DEFERRED_AUTH_NOTE },
         // `--oauth-resource` duplicates the resource Codex discovers; Clerk rejects both.
         // `mcp add` still runs OAuth inline, so `loginArgs` stays a retry.

package/dist/lib/hermes-env.d.ts

@@ -14,6 +14,5 @@ export declare function hermesEnvPath(home: string): string;
 export declare function writeHermesKey(home: string, key: string): void;
 /** Doctor needs this to tell key auth from OAuth. */
 export declare function readHermesKey(home: string): string | undefined;
-/** Restores the exact line writeHermesKey replaces, quotes and comment included. */
 export declare function captureHermesKeyRestore(home: string): () => void;
 export declare function removeHermesKey(home: string): boolean;

package/dist/lib/hermes-env.js

@@ -1,11 +1,10 @@
 import os from 'node:os';
 import path from 'node:path';
-import fs from 'node:fs';
-import { randomUUID } from 'node:crypto';
 import spawn from 'cross-spawn';
 import { HERMES_COLD_START_TIMEOUT_MS } from './constants.js';
 import { throwIfInterrupted } from './connect-runtime.js';
 import { noColourEnv, sanitizeLine } from './output.js';
+import { captureDotenvKeyRestore, dotenvMarkerHead, readDotenvKey, removeDotenvKey, writeDotenvKey, } from './dotenv-file.js';
 // display_hermes_home() abbreviates under $HOME, so the value is not always absolute.
 const HERMES_HOME_LINE = /^\s*hermes_home:\s*(\S.*?)\s*$/m;
 // Consistency, not speed: doctor's second probe timing out would downgrade
@@ -46,125 +45,21 @@ function probeHermesHome() {
     return path.isAbsolute(expanded) ? expanded : { reason: 'relative' };
 }
 export const HERMES_KEY_VAR = 'MCP_TINYFISH_API_KEY';
+const MARKER_HEAD = dotenvMarkerHead('hermes');
 /** Named in every message about the seeded key, so no caller rebuilds the path. */
 export function hermesEnvPath(home) {
     return path.join(home, '.env');
 }
-const MARKER_HEAD = `# tinyfish-cli: TinyFish MCP key, managed by \`tinyfish connect hermes\``;
-const MARKER_TAIL = '# tinyfish-cli: end';
-// Keys are `sk-tinyfish-<alnum>`; refusing anything else beats shipping unreachable escaping.
-const BARE_SAFE = /^[A-Za-z0-9._\-/:+=]+$/;
-/** Mirrors Hermes' _env_line_defines_key: load_env() parses the export form too. */
-function definesKey(line) {
-    const stripped = line.trim().replace(/^export\s+/, '');
-    return stripped.startsWith(`${HERMES_KEY_VAR}=`);
-}
-function isMarker(line) {
-    return line.trim() === MARKER_HEAD || line.trim() === MARKER_TAIL;
-}
-// A leading BOM would otherwise ride into the first key's name.
-function readLines(envPath) {
-    if (!fs.existsSync(envPath))
-        return [];
-    const raw = fs.readFileSync(envPath);
-    // A valid UTF-8 .env has no NUL; every wide encoding does.
-    if (raw.includes(0)) {
-        throw new Error(`${envPath} contains NUL bytes, so it is a wide encoding or corrupt; TinyFish can only ` +
-            `edit a UTF-8 .env. Re-save it as UTF-8 and retry.`);
-    }
-    return raw
-        .toString('utf8')
-        .replace(/^\uFEFF/, '')
-        .split(/(?<=\n)/);
-}
-// Hermes preserves the original mode so Docker volume mounts survive (config.py:3921-3929).
-function writeAtomic(envPath, lines) {
-    let mode = 0o600;
-    try {
-        mode = fs.statSync(envPath).mode & 0o777;
-    }
-    catch {
-        // No existing file: 0600 is the right default for credentials.
-    }
-    const tmp = `${envPath}.${randomUUID()}.tmp`;
-    try {
-        fs.writeFileSync(tmp, lines.join(''), { encoding: 'utf8', mode });
-        // open() applies mode through umask; chmod bypasses it, preserving bits.
-        fs.chmodSync(tmp, mode);
-        fs.renameSync(tmp, envPath);
-    }
-    catch (error) {
-        fs.rmSync(tmp, { force: true });
-        throw error;
-    }
-}
 export function writeHermesKey(home, key) {
-    const clean = key.replace(/[\r\n]/g, '').trim();
-    // An empty key reads as "bad characters" without its own branch.
-    if (!clean)
-        throw new Error("TinyFish API key is empty; nothing to write to Hermes' .env");
-    if (!BARE_SAFE.test(clean)) {
-        throw new Error('TinyFish API key contains characters that cannot be written to a .env file');
-    }
-    const envPath = hermesEnvPath(home);
-    fs.mkdirSync(home, { recursive: true });
-    const lines = readLines(envPath);
-    const assignment = `${HERMES_KEY_VAR}=${clean}\n`;
-    const index = lines.findIndex(definesKey);
-    if (index < 0) {
-        if (lines.length && !lines[lines.length - 1].endsWith('\n'))
-            lines[lines.length - 1] += '\n';
-        lines.push(`${MARKER_HEAD}\n`, assignment, `${MARKER_TAIL}\n`);
-        writeAtomic(envPath, lines);
-        return;
-    }
-    lines[index] = assignment;
-    // load_env() is last-wins; a surviving duplicate would beat this value.
-    writeAtomic(envPath, lines.filter((line, i) => i === index || !definesKey(line)));
+    writeDotenvKey(hermesEnvPath(home), HERMES_KEY_VAR, key, MARKER_HEAD);
 }
 /** Doctor needs this to tell key auth from OAuth. */
 export function readHermesKey(home) {
-    const line = readLines(hermesEnvPath(home)).find(definesKey);
-    if (!line)
-        return undefined;
-    // We never write quoted values, so a quoted one isn't ours.
-    const raw = line
-        .trim()
-        .replace(/^export\s+/, '')
-        .slice(HERMES_KEY_VAR.length + 1)
-        .trim();
-    return BARE_SAFE.test(raw) ? raw : undefined;
+    return readDotenvKey(hermesEnvPath(home), HERMES_KEY_VAR);
 }
-/** Restores the exact line writeHermesKey replaces, quotes and comment included. */
 export function captureHermesKeyRestore(home) {
-    // Raw, not readHermesKey: its parse drops quoted and comment-trailed values.
-    const previous = readLines(hermesEnvPath(home)).find(definesKey);
-    return () => {
-        if (previous === undefined) {
-            removeHermesKey(home);
-            return;
-        }
-        const envPath = hermesEnvPath(home);
-        let restored = false;
-        const lines = readLines(envPath).flatMap((line) => {
-            if (!definesKey(line))
-                return [line];
-            if (restored)
-                return [];
-            restored = true;
-            return [previous];
-        });
-        writeAtomic(envPath, restored ? lines : [...lines, previous]);
-    };
+    return captureDotenvKeyRestore(hermesEnvPath(home), HERMES_KEY_VAR, MARKER_HEAD);
 }
 export function removeHermesKey(home) {
-    const envPath = hermesEnvPath(home);
-    const lines = readLines(envPath);
-    if (!lines.length)
-        return false;
-    const kept = lines.filter((line) => !definesKey(line) && !isMarker(line));
-    if (kept.length === lines.length)
-        return false;
-    writeAtomic(envPath, kept);
-    return true;
+    return removeDotenvKey(hermesEnvPath(home), HERMES_KEY_VAR, MARKER_HEAD);
 }

package/dist/lib/registration-detect.js

@@ -14,6 +14,7 @@ import { readOpencodeStyleEntry } from './config/opencode-config.js';
 import { readPiTinyfishEntry } from './config/pi-config.js';
 import { harnessSpec } from './harness/harness-spec.js';
 import { readHermesKey, resolveHermesHome } from './hermes-env.js';
+import { harnessDotenvPath, readDotenvKey } from './dotenv-file.js';
 import { readHermesEntry } from './config/hermes-config.js';
 import { detectInstalledHarnesses, harnessConfigPath, harnessDisplayPath, AuthMode, Registered, } from './harness/harness-detect.js';
 const NOT_REGISTERED = Object.freeze({
@@ -245,15 +246,30 @@ const ENV_VAR_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function declaredKeyEnvVar(harness) {
     return NATIVE_BY_HARNESS.get(harness)?.keyAuth?.envVar;
 }
+/** An unreadable .env reads as unset, not as a failed probe. */
+function readDotenvKeySafe(dotenvPath, envVar) {
+    try {
+        return readDotenvKey(dotenvPath, envVar);
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Codex stores a variable name; resolving it only answers whether it is the CLI's key. */
-function envKeyVerdict(envVar) {
+function envKeyVerdict(envVar, dotenvPath) {
     if (!ENV_VAR_NAME.test(envVar)) {
         return { keyReason: 'its key comes from an unusable variable name' };
     }
-    if (matchesCliKey(process.env[envVar]))
+    const fromDotenv = dotenvPath ? readDotenvKeySafe(dotenvPath, envVar) : undefined;
+    // GUI launches read only the .env; a shell export masks that.
+    if (dotenvPath && !fromDotenv) {
+        return { connected: false, keyReason: `$${envVar} is not in ${dotenvPath}` };
+    }
+    const value = process.env[envVar] || fromDotenv;
+    if (matchesCliKey(value))
         return { keyMatchesCliKey: true };
     return {
-        keyReason: process.env[envVar]
+        keyReason: value
             ? `$${envVar} holds a key this CLI cannot verify`
             : `$${envVar} is not set here`,
     };
@@ -279,7 +295,7 @@ function probeCodex() {
         // Codex's own verdict: a stale `oauth_resource` strands installs here.
         ...(entry.auth_status === CodexAuthStatus.NotLoggedIn && !envVar ? { connected: false } : {}),
         ...(codexUrl ? { registeredUrl: codexUrl } : {}),
-        ...(envVar ? envKeyVerdict(envVar) : {}),
+        ...(envVar ? envKeyVerdict(envVar, harnessDotenvPath('codex')) : {}),
     };
 }
 // No `cline mcp list`, so the settings file is the only registration evidence.

package/dist/lib/skill-paths.d.ts

@@ -1,4 +1,5 @@
 import type { SkillAgent } from './harness/harness-spec.js';
+export declare function agentHome(override: string, fallback: string): string;
 /** Where skills@1.5.15 wrote skill dirs for this agent. */
 export declare function skillRootDir(agent: SkillAgent): string;
 /** Mirrors skills@1.5.15 getSkillLockPath(); missing the XDG branch strands entries. */

package/dist/lib/skill-paths.js

@@ -1,7 +1,7 @@
 import * as os from 'node:os';
 import * as path from 'node:path';
 // Mirrors skills@1.5.15 exactly: it trims and falls back on empty values.
-function agentHome(override, fallback) {
+export function agentHome(override, fallback) {
     return process.env[override]?.trim() || path.join(os.homedir(), fallback); // nosemgrep: path-join-resolve-traversal -- fixed dir names under os.homedir()
 }
 // `skills` writes here for the universal agents, whose own config dirs it never touches.

package/package.json

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