@tiny-fish/cli 0.39.1-next.309 → 0.40.0

package/dist/commands/runs.js

@@ -1,3 +1,4 @@
+import { setTimeout as sleep } from 'node:timers/promises';
 import { RunStatus } from '@tiny-fish/sdk';
 import { getApiKey } from '../lib/auth.js';
 import { cancelRun, getRun, getRunSteps, listRuns } from '../lib/client.js';
@@ -16,6 +17,7 @@ function formatStep(step, index) {
     const meta = [step.status, step.duration].filter(Boolean).join(', ');
     return `${String(index + 1).padStart(2, ' ')}. ${action}${meta ? ` (${meta})` : ''}`;
 }
+const MAX_TIMER_MS = 2 ** 31 - 1;
 function parsePositiveInt(value, flag, defaultMs, minMs = 1) {
     if (value === undefined)
         return defaultMs;
@@ -27,56 +29,24 @@ function parsePositiveInt(value, flag, defaultMs, minMs = 1) {
         process.exit(1);
     }
     const parsed = Number(value);
-    if (parsed < minMs) {
-        err({ error: `Invalid ${flag} "${value}". Must be an integer >= ${minMs}ms.` });
+    // Node timers take a signed 32-bit delay; larger overflows to 1ms or throws.
+    if (parsed < minMs || parsed > MAX_TIMER_MS) {
+        err({
+            error: `Invalid ${flag} "${value}". Must be an integer between ${minMs} and ${MAX_TIMER_MS}ms.`,
+        });
         process.exit(1);
     }
     return parsed;
 }
-function withDeadline(promise, deadline, signal) {
-    return new Promise((resolve, reject) => {
-        const remaining = deadline - Date.now();
-        if (remaining <= 0) {
-            reject(new Error('watch deadline exceeded'));
-            return;
-        }
-        if (signal.aborted) {
-            reject(new Error('watch aborted'));
-            return;
-        }
-        const timer = setTimeout(() => reject(new Error('watch deadline exceeded')), remaining);
-        const onAbort = () => {
-            clearTimeout(timer);
-            reject(new Error('watch aborted'));
-        };
-        signal.addEventListener('abort', onAbort, { once: true });
-        promise.then((v) => {
-            clearTimeout(timer);
-            signal.removeEventListener('abort', onAbort);
-            resolve(v);
-        }, (e) => {
-            clearTimeout(timer);
-            signal.removeEventListener('abort', onAbort);
-            reject(e);
-        });
-    });
-}
-function sleep(ms, signal) {
-    return new Promise((resolve, reject) => {
-        if (signal.aborted) {
-            reject(new Error('aborted'));
-            return;
-        }
-        const timer = setTimeout(() => {
-            signal.removeEventListener('abort', onAbort);
-            resolve();
-        }, ms);
-        const onAbort = () => {
-            clearTimeout(timer);
-            reject(new Error('aborted'));
-        };
-        signal.addEventListener('abort', onAbort, { once: true });
+/** The SDK calls take no signal, so the race is the only cancel. */
+function withSignal(promise, signal) {
+    if (signal.aborted)
+        return Promise.reject(signal.reason);
+    const done = new AbortController();
+    const aborted = new Promise((_, reject) => {
+        signal.addEventListener('abort', () => reject(signal.reason), { signal: done.signal });
     });
+    return Promise.race([promise, aborted]).finally(() => done.abort());
 }
 async function runsListAction(opts) {
     // Validate --status
@@ -193,18 +163,20 @@ async function runsWatchAction(runId, opts) {
     };
     process.once('SIGINT', onSigint);
     const deadline = Date.now() + timeoutMs;
+    const timedOut = AbortSignal.timeout(timeoutMs);
+    const signal = AbortSignal.any([controller.signal, timedOut]);
     const seen = new Set();
     try {
-        const initial = await withDeadline(getRun(runId, apiKey), deadline, controller.signal);
+        const initial = await withSignal(getRun(runId, apiKey), signal);
         if (TERMINAL_STATUSES.includes(initial.status)) {
             err({
                 error: `Run ${runId} is already ${initial.status}; nothing to watch. Use 'tinyfish agent run steps ${runId}' for the trace.`,
             });
             process.exit(1);
         }
-        while (!controller.signal.aborted) {
+        while (!signal.aborted) {
             // One API call per tick — the steps endpoint also returns the run's current status.
-            const tick = await withDeadline(getRunSteps(runId, apiKey), deadline, controller.signal);
+            const tick = await withSignal(getRunSteps(runId, apiKey), signal);
             let nextIndex = seen.size;
             for (const step of tick.steps) {
                 if (seen.has(step.id))
@@ -228,22 +200,16 @@ async function runsWatchAction(runId, opts) {
                 err({ error: `Watch timed out after ${timeoutMs}ms (run still ${tick.status}).` });
                 process.exit(1);
             }
-            try {
-                await sleep(intervalMs, controller.signal);
-            }
-            catch {
-                return; // aborted
-            }
+            await sleep(intervalMs, undefined, { signal });
         }
     }
     catch (e) {
-        if (e instanceof Error && e.message === 'watch deadline exceeded') {
+        if (timedOut.aborted) {
             err({ error: `Watch timed out after ${timeoutMs}ms.` });
             process.exit(1);
         }
-        if (e instanceof Error && e.message === 'watch aborted') {
-            return; // SIGINT handler already triggered process.exit(130)
-        }
+        if (controller.signal.aborted)
+            return; // SIGINT handler already exited 130
         handleApiError(e);
     }
     finally {

package/dist/lib/auth.d.ts

@@ -6,7 +6,7 @@ export declare const CONNECT_SOURCE = "tinyfish_cli";
 export declare const CONNECT_ATTEMPT_ENV = "TINYFISH_CONNECT_ATTEMPT_ID";
 /** Mirrors ConnectAuthMode; duplicated to keep auth.ts free of connect-runtime imports. */
 export type RecordedAuthMode = 'api-key' | 'oauth' | 'deferred';
-export interface ConnectEntry {
+interface ConnectEntry {
     attempt_id: string;
     auth_mode?: RecordedAuthMode;
 }
@@ -43,8 +43,6 @@ interface EnvironmentOptions {
 }
 export declare function persistApiKeyToEnvironment(apiKey: string, options?: EnvironmentOptions): void;
 export declare function clearConfig(): boolean;
-/** The one rule that is ours to enforce: the key becomes an HTTP header, so CR/LF cannot pass. */
-export declare function isHeaderSafe(key: string): boolean;
 export declare function validateKeyFormat(key: string): boolean;
 export declare function maskKey(key: string): string;
 export type KeySource = 'explicit' | 'env' | 'config' | 'none';

package/dist/lib/auth.js

@@ -236,7 +236,7 @@ export function clearConfig() {
     }
 }
 /** The one rule that is ours to enforce: the key becomes an HTTP header, so CR/LF cannot pass. */
-export function isHeaderSafe(key) {
+function isHeaderSafe(key) {
     for (let i = 0; i < key.length; i += 1) {
         if (key.charCodeAt(i) < 0x20)
             return false;

package/dist/lib/claude-config.d.ts

@@ -1,17 +1,13 @@
-export declare function claudeDir(): string;
 export declare function claudeSettingsPath(): string;
 export declare function claudeMdPath(): string;
 export declare const TINYFISH_PERMISSION = "Bash(tinyfish:*)";
 export declare const CLAUDE_MD_MARKER = "<!-- tinyfish-configure-claude -->";
-export declare const CLAUDE_MD_BLOCK = "<!-- tinyfish-configure-claude -->\n## WebSearch or Search\nWhen looking to use Search or WebSearch, always use the TinyFish Web Search tool, run `tinyfish search query \"<query>\"`\nOnly fall back to native Search when you get rate limited by tinyfish (for a minute, then you can try using tinyfish again)\n\n## WebFetch or Fetch\nWhen looking to use Fetch or WebFetch, always use the TinyFish Fetch tool, run `tinyfish fetch content get \"<url>\"`\nOnly fall back to native Fetch when you get rate limited by tinyfish (for a minute, then you can try using tinyfish again)\n<!-- tinyfish-configure-claude -->";
 export declare function readSettingsJson(): Record<string, unknown>;
 export declare function writeSettingsJson(settings: Record<string, unknown>): void;
 export declare function mergeSettings(existing: Record<string, unknown>): Record<string, unknown>;
 export declare function removeFromSettings(existing: Record<string, unknown>): Record<string, unknown>;
 export declare function readClaudeMd(): string;
 export declare function writeClaudeMd(content: string): void;
-export declare function hasMarker(content: string): boolean;
-export declare function hasLegacyBlock(content: string): boolean;
 export declare function mergeClaudeMd(existing: string): {
     content: string;
     replaced: boolean;

package/dist/lib/claude-config.js

@@ -2,7 +2,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 // ─── Path helpers ─────────────────────────────────────────────────────────────
-export function claudeDir() {
+function claudeDir() {
     return path.join(os.homedir(), '.claude');
 }
 export function claudeSettingsPath() {
@@ -40,7 +40,7 @@ const TINYFISH_SUBAGENT_HOOK = {
     ],
 };
 export const CLAUDE_MD_MARKER = '<!-- tinyfish-configure-claude -->';
-export const CLAUDE_MD_BLOCK = `${CLAUDE_MD_MARKER}
+const CLAUDE_MD_BLOCK = `${CLAUDE_MD_MARKER}
 ## WebSearch or Search
 When looking to use Search or WebSearch, always use the TinyFish Web Search tool, run \`tinyfish search query "<query>"\`
 Only fall back to native Search when you get rate limited by tinyfish (for a minute, then you can try using tinyfish again)
@@ -159,10 +159,10 @@ function escapeRegExp(s) {
 }
 const MARKER_REGEX = new RegExp(`${escapeRegExp(CLAUDE_MD_MARKER)}[\\s\\S]*?${escapeRegExp(CLAUDE_MD_MARKER)}`, 'm');
 const LEGACY_REGEX = /## Web(?:Search|Seach) or Search[\s\S]*?(?:tinyfish fetch[^\n]*\n(?:[^\n]*tinyfish[^\n]*\n)*[^\n]*)\n*/m;
-export function hasMarker(content) {
+function hasMarker(content) {
     return content.includes(CLAUDE_MD_MARKER);
 }
-export function hasLegacyBlock(content) {
+function hasLegacyBlock(content) {
     return !content.includes(CLAUDE_MD_MARKER) && LEGACY_REGEX.test(content);
 }
 export function mergeClaudeMd(existing) {

package/dist/lib/cli-install.d.ts

@@ -20,7 +20,6 @@ export type TakeHoistedCliInstall = () => {
     outcome: HoistedCliInstall;
     firstTake: boolean;
 };
-export { HoistedFailureReportedError } from './connect-runtime.js';
 export declare function captureStdio(verbose: boolean): {
     stdio: "inherit";
     timeout: number;

package/dist/lib/cli-install.js

@@ -7,7 +7,6 @@ export const SKILL_INSTALL_TIMEOUT_MS = 120_000;
 const TINYFISH_CLI_INSTALL_SPEC = `${TINYFISH_CLI_PACKAGE}@latest`;
 // spawnSync caps piped output at 1 MiB by default.
 export const STEP_MAX_BUFFER = 10 * 1024 * 1024;
-export { HoistedFailureReportedError } from './connect-runtime.js';
 export function captureStdio(verbose) {
     return verbose
         ? { stdio: 'inherit', timeout: SKILL_INSTALL_TIMEOUT_MS }

package/dist/lib/client.js

@@ -108,6 +108,9 @@ function createSdkClient(apiKey, timeout, baseUrl) {
         ...(timeout !== undefined ? { timeout } : {}),
     });
 }
+function sdk(apiKey, call) {
+    return call(createSdkClient(apiKey)).catch(rethrowSdkError);
+}
 function rethrowSdkError(error) {
     if (error instanceof APIStatusError) {
         throw new ApiError(error.statusCode, error.message);
@@ -136,14 +139,8 @@ const batchGetResponseSchema = z.object({
     data: z.array(runSchema),
     not_found: z.array(z.string()).nullable(),
 });
-const batchCancelResultSchema = z.object({
-    run_id: z.string(),
-    status: z.string(),
-    cancelled_at: z.string().nullable(),
-    message: z.string().nullable(),
-});
 const batchCancelResponseSchema = z.object({
-    results: z.array(batchCancelResultSchema),
+    results: z.array(cancelRunResponseSchema),
     not_found: z.array(z.string()).nullable(),
 });
 const runStepSchema = z.object({
@@ -219,27 +216,21 @@ async function* parseSseStream(stream) {
         reader.releaseLock();
     }
 }
-export async function runSync(req, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post('/v1/automation/run', {
+export function runSync(req, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post('/v1/automation/run', {
             json: req,
         });
         return parseWithSchema(agentRunResponseSchema, response, 'Invalid agent run response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function runAsync(req, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post('/v1/automation/run-async', {
+export function runAsync(req, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post('/v1/automation/run-async', {
             json: req,
         });
         return parseWithSchema(agentRunAsyncResponseSchema, response, 'Invalid async run response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
 export async function* runStream(req, apiKey, signal) {
     let stream = null;
@@ -268,110 +259,75 @@ export async function* runStream(req, apiKey, signal) {
         }
     }
 }
-export async function listRuns(opts, apiKey, timeout, baseUrl) {
-    try {
-        return await createSdkClient(apiKey, timeout, baseUrl).runs.list(opts);
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+export function listRuns(opts, apiKey, timeout, baseUrl) {
+    return createSdkClient(apiKey, timeout, baseUrl).runs.list(opts).catch(rethrowSdkError);
 }
-export async function getRun(runId, apiKey) {
-    try {
-        return await createSdkClient(apiKey).runs.get(runId);
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+export function getRun(runId, apiKey) {
+    return sdk(apiKey, (client) => client.runs.get(runId));
 }
-export async function getRunSteps(runId, apiKey) {
-    try {
+export function getRunSteps(runId, apiKey) {
+    return sdk(apiKey, async (client) => {
         // The public GET /v1/runs/:id route returns the base run payload plus `steps`;
         // the installed SDK runSchema only models the base run, so steps need this local schema.
-        const response = await createSdkClient(apiKey).get(`/v1/runs/${encodeURIComponent(runId)}`, { params: { screenshots: 'none' } });
+        const response = await client.get(`/v1/runs/${encodeURIComponent(runId)}`, {
+            params: { screenshots: 'none' },
+        });
         return parseWithSchema(runStepsResponseSchema, response, 'Invalid run steps response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function searchQuery(params, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).search.query(params);
+export function searchQuery(params, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.search.query(params);
         return searchQueryResponseSchema.parse(response);
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function fetchContentGet(params, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).fetch.getContents(params);
+export function fetchContentGet(params, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.fetch.getContents(params);
         return fetchResponseSchema.parse(response);
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function browserSessionCreate(params, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post('/v1/browser', { json: params });
+export function browserSessionCreate(params, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post('/v1/browser', { json: params });
         return browserSessionSchema.parse(response);
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function cancelRun(runId, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, { json: {} });
+export function cancelRun(runId, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
+            json: {},
+        });
         return parseWithSchema(cancelRunResponseSchema, response, 'Invalid cancel run response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
 // ── Wallet ──────────────────────────────────────────────────────────────────
-export async function getWallet(apiKey) {
-    try {
-        return await createSdkClient(apiKey).wallet.get();
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+export function getWallet(apiKey) {
+    return sdk(apiKey, (client) => client.wallet.get());
 }
-export async function submitBatch(req, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post('/v1/automation/run-batch', {
+export function submitBatch(req, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post('/v1/automation/run-batch', {
             json: req,
         });
         return parseWithSchema(batchRunResponseSchema, response, 'Invalid batch run response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function getBatchRuns(runIds, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post('/v1/runs/batch', {
+export function getBatchRuns(runIds, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post('/v1/runs/batch', {
             json: { run_ids: runIds },
         });
         return parseWithSchema(batchGetResponseSchema, response, 'Invalid batch get response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function cancelBatchRuns(runIds, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post('/v1/runs/batch/cancel', {
+export function cancelBatchRuns(runIds, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post('/v1/runs/batch/cancel', {
             json: { run_ids: runIds },
         });
         return parseWithSchema(batchCancelResponseSchema, response, 'Invalid batch cancel response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
 const profileCreateResponseSchema = z.object({
     id: z.string(),
@@ -384,25 +340,19 @@ const profileUploadResponseSchema = z.object({
     domains_updated: z.array(z.string()),
     domains_failed: z.array(z.string()).optional(),
 });
-export async function profileCreate(name, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post('/v1/profiles', {
+export function profileCreate(name, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post('/v1/profiles', {
             json: { name },
         });
         return parseWithSchema(profileCreateResponseSchema, response, 'Invalid profile create response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function profileUpload(profileId, cookies, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post(`/v1/profiles/${encodeURIComponent(profileId)}/upload`, { json: { cookies } });
+export function profileUpload(profileId, cookies, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post(`/v1/profiles/${encodeURIComponent(profileId)}/upload`, { json: { cookies } });
         return parseWithSchema(profileUploadResponseSchema, response, 'Invalid profile upload response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
 // ── Vault ───────────────────────────────────────────────────────────────────
 // /v1/vault/* returns camelCase fields (unlike the snake_case rest of the API).
@@ -451,52 +401,37 @@ const vaultItemsSyncResponseSchema = z.object({
         removed: z.number(),
     }),
 });
-export async function vaultConnections(apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).get('/v1/vault/connections');
+export function vaultConnections(apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.get('/v1/vault/connections');
         return parseWithSchema(vaultConnectionsListResponseSchema, response, 'Invalid vault connections response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function vaultConnect(req, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post('/v1/vault/connections', {
+export function vaultConnect(req, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post('/v1/vault/connections', {
             json: req,
         });
         return parseWithSchema(vaultConnectResponseSchema, response, 'Invalid vault connect response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function vaultDisconnect(connectionId, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).del(`/v1/vault/connections/${encodeURIComponent(connectionId)}`);
+export function vaultDisconnect(connectionId, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.del(`/v1/vault/connections/${encodeURIComponent(connectionId)}`);
         return parseWithSchema(vaultDisconnectResponseSchema, response, 'Invalid vault disconnect response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function vaultItems(apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).get('/v1/vault/items');
+export function vaultItems(apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.get('/v1/vault/items');
         return parseWithSchema(vaultItemsListResponseSchema, response, 'Invalid vault items response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function vaultSync(apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post('/v1/vault/items/sync', {
+export function vaultSync(apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post('/v1/vault/items/sync', {
             json: {},
         });
         return parseWithSchema(vaultItemsSyncResponseSchema, response, 'Invalid vault sync response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }

package/dist/lib/connect-all-auth.js

@@ -19,7 +19,7 @@ const NO_BROWSER_REASONS = new Set([
 // Derived: these block `connect` on a browser sign-in when keyless.
 const BROWSER_SIGN_IN = new Set(ALL_HARNESSES.filter((harness) => {
     const native = NATIVE_BY_HARNESS.get(harness);
-    return !!native?.loginArgs || !!native?.oauthInAdd;
+    return !!native?.loginArgs;
 }));
 // Derived: these refuse a keyless install, so no sign-in helps.
 const KEY_REQUIRED = new Set(ALL_HARNESSES.filter((harness) => !!NATIVE_BY_HARNESS.get(harness)?.keyRequired));

package/dist/lib/connect-all-summary.js

@@ -9,7 +9,7 @@ const HIDDEN_ONCE_SOMETHING_WORKED = new Set([
 ]);
 /** A stale config dir is a detection signal with nothing behind it. */
 export function actionable(result) {
-    return result.detected && result.outcome !== 'stale_config';
+    return (result.detected && result.outcome !== 'stale_config' && result.outcome !== 'needs_first_run');
 }
 function absentSummaryLine(result, uninstall) {
     const name = DISPLAY_NAMES[result.harness];
@@ -29,6 +29,9 @@ function skippedSummaryLine(result) {
     if (result.outcome === 'stale_config') {
         return `… ${name} — config at ${result.configPath} but no \`${HARNESS_COMMANDS[result.harness]}\` on PATH, skipped. Install ${name}, then run: ${result.fixCommand}`;
     }
+    if (result.outcome === 'needs_first_run') {
+        return `… ${name} — installed but never run, so ${result.configPath} does not exist yet, skipped. Run \`${HARNESS_COMMANDS[result.harness]}\` once, then: ${result.fixCommand}`;
+    }
     if (result.outcome === 'not_reached') {
         return `… ${name} — not reached, the run stopped early. Fix: ${result.fixCommand}`;
     }

package/dist/lib/connect-all-uninstall.js

@@ -3,6 +3,7 @@ import { NATIVE_BY_HARNESS, openclawSkillUninstall } from './connect-clients.js'
 import { ConnectInterruptedError, spawnRemoval } from './connect-runtime.js';
 import { removeCursorMcpServer, planCursorWrite } from './cursor-config.js';
 import { planOmpWrite, removeOmpMcpServer } from './omp-config.js';
+import { piMcpPath, planPiWrite, removePiMcpServer } from './pi-config.js';
 import { HERMES_KEY_VAR, hermesEnvPath, removeHermesKey, resolveHermesHome } from './hermes-env.js';
 import { clearHermesWebBackends, HERMES_PLUGIN_SHA } from './hermes-plugin.js';
 import { HARNESS_DISPLAY_NAMES as DISPLAY_NAMES } from './harness-detect.js';
@@ -14,6 +15,8 @@ export function planText(harness, mcpUrl, apiKey) {
         return planCursorWrite(mcpUrl, apiKey);
     if (harness === 'omp')
         return planOmpWrite(mcpUrl, apiKey);
+    if (harness === 'pi')
+        return planPiWrite(mcpUrl, apiKey);
     // Only the keyed path seeds the .env; a keyless Hermes install writes nothing.
     if (harness === 'hermes' && apiKey) {
         return (`would run \`tinyfish connect hermes\` (harness-owned MCP write; the CLI writes ` +
@@ -29,6 +32,9 @@ export function uninstallPlanText(harness) {
     if (harness === 'omp') {
         return "would remove the tinyfish entry from omp's mcp.json (located via `omp config path`)";
     }
+    if (harness === 'pi') {
+        return `would remove the tinyfish entry from ${piMcpPath()}`;
+    }
     if (!uninstallRuns(harness)) {
         return `would print \`${uninstallPointer(harness)}\` (no removal command exists)`;
     }
@@ -62,7 +68,8 @@ function uninstallPointer(harness) {
 }
 /** `mcp remove` clears neither the key nor the backends we wrote. */
 function clearHermesLocalState() {
-    const home = resolveHermesHome();
+    const resolved = resolveHermesHome();
+    const home = typeof resolved === 'string' ? resolved : undefined;
     const advisories = [clearHermesEnvKey(home), clearHermesBackends(home)].filter((advisory) => advisory !== undefined);
     return advisories.length > 0 ? advisories.join(' ') : undefined;
 }
@@ -186,6 +193,10 @@ const MCP_JSON_UNINSTALLS = {
         remove: removeOmpMcpServer,
         fix: "Fix omp's mcp.json (at `omp config path`) by hand, then re-run: tinyfish connect --all --uninstall",
     },
+    pi: {
+        remove: removePiMcpServer,
+        fix: `Fix ${piMcpPath()} by hand, then re-run: tinyfish connect --all --uninstall`,
+    },
 };
 function uninstallMcpJson(detection, spec) {
     let result;

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

@@ -1,6 +1,6 @@
-import { type Harness } from './harness-detect.js';
+import { type Harness, type HarnessDetection } from './harness-detect.js';
 import { type VerifyDepth } from './verify.js';
-export type Outcome = 'not_detected' | 'not_installed' | 'stale_config' | 'installed' | 'failed' | 'harness_too_old' | 'interrupted' | 'auth_pending' | 'no_tty_auth_skip' | 'uninstalled' | 'uninstall_noop' | 'uninstall_pointer' | 'dry_run' | 'not_reached' | 'deselected';
+export type Outcome = 'not_detected' | 'not_installed' | 'stale_config' | 'needs_first_run' | 'installed' | 'failed' | 'harness_too_old' | 'interrupted' | 'auth_pending' | 'no_tty_auth_skip' | 'uninstalled' | 'uninstall_noop' | 'uninstall_pointer' | 'dry_run' | 'not_reached' | 'deselected';
 export type HarnessResultBase = {
     harness: Harness;
     detected: boolean;
@@ -34,5 +34,7 @@ export interface ConnectAllOptions {
     /** Setup-page id riding in on --url; joins "copied the command" to this run. */
     attemptId?: string;
 }
+/** The harness has never created its dir, so connecting would build one it does not own. */
+export declare function needsFirstRun(detection: HarnessDetection): boolean;
 export declare function runConnectAll(opts: ConnectAllOptions): Promise<number>;
 export declare const FIRST_TASK_PROMPT: string;