@tiny-fish/cli 0.45.2-next.354 → 0.45.2-next.356

package/dist/commands/onboard.js

@@ -3,7 +3,7 @@ import { getApiKey, saveConfig } from '../lib/auth.js';
 import { fetchContentGet, searchQuery } from '../lib/client.js';
 import { BASE_URL, TINYFISH_API_KEY_VAR } from '../lib/constants.js';
 import { errLine, handleApiError, outLine } from '../lib/output.js';
-import { connectHarness, launchAgent } from './connect.js';
+import { connectHarness, launchAgent } from '../lib/connect-harness.js';
 import { HARNESS_DISPLAY_NAMES } from '../lib/harness-detect.js';
 const EXAMPLE_QUERIES = [
     'What are recent changes in the AI dev stack? Give me the top 5 changes that matter, why they matter, and any action needed.',

package/dist/lib/connect-all.js

@@ -1,7 +1,7 @@
 import * as readline from 'node:readline/promises';
 import { harnessSpec } from './harness-spec.js';
 import spawn from 'cross-spawn';
-import { connectHarness } from '../commands/connect.js';
+import { connectHarness } from './connect-harness.js';
 import { loadConfig, validatedApiKey } from './auth.js';
 import { installTinyFishCli, } from './cli-install.js';
 import { authGate, mapConnectError, OAUTH_SIGN_IN_TIMEOUT_MS } from './connect-all-auth.js';

package/dist/lib/connect-config-file.d.ts

@@ -0,0 +1,76 @@
+import { type ConnectAuthMode } from './connect-runtime.js';
+import { cursorMcpPath, writeCursorMcpConfig } from './cursor-config.js';
+import { ompMcpPath, writeOmpMcpConfig } from './omp-config.js';
+import { piMcpPath, writePiMcpConfig } from './pi-config.js';
+declare function piPostConnectNotes(): string | undefined;
+declare const CONFIG_FILE_HARNESSES: {
+    cursor: {
+        skillTarget: {
+            readonly skillAgent: "cursor";
+            readonly displayName: string;
+        };
+        registeredUrl: () => string | undefined;
+        write: typeof writeCursorMcpConfig;
+        configPath: typeof cursorMcpPath;
+        tryLaunch: typeof launchCursorDeeplink;
+        copy: {
+            verified: string;
+            authFailed: (reason: string) => string;
+            launched: string;
+            reload: string;
+        };
+    };
+    omp: {
+        skillTarget: {
+            displayName: string;
+        };
+        registeredUrl: () => string | undefined;
+        write: typeof writeOmpMcpConfig;
+        configPath: typeof ompMcpPath;
+        tryLaunch: () => false;
+        copy: {
+            verified: string;
+            authFailed: (reason: string) => string;
+            launched: string;
+            reload: string;
+        };
+    };
+    pi: {
+        skillTarget: {
+            skillAgent: "pi";
+            displayName: string;
+        };
+        registeredUrl: () => string | undefined;
+        write: typeof writePiMcpConfig;
+        configPath: typeof piMcpPath;
+        tryLaunch: () => false;
+        postConnectNote: typeof piPostConnectNotes;
+        copy: {
+            verified: string;
+            authFailed: (reason: string) => string;
+            launched: string;
+            reload: string;
+        };
+    };
+};
+/** Writes the harness's MCP config file itself; no `mcp add` exists. */
+export declare function connectConfigFileHarness(harness: keyof typeof CONFIG_FILE_HARNESSES, options: {
+    apiKey?: string;
+    mcpUrl: string;
+    attemptId?: string;
+    verbose?: boolean;
+    authTimeoutMs?: number;
+    onPostInstallFailed?: () => void;
+}): Promise<ConnectAuthMode | undefined>;
+/** Writes mcp.json directly — no `cursor mcp add` exists. */
+export declare function connectCursor(options: {
+    apiKey?: string;
+    mcpUrl: string;
+    attemptId?: string;
+    verbose?: boolean;
+    authTimeoutMs?: number;
+    onPostInstallFailed?: () => void;
+}): Promise<void>;
+/** Best-effort: false when no handler/open fails — caller falls back to reload copy. */
+declare function launchCursorDeeplink(mcpUrl: string): boolean;
+export {};

package/dist/lib/connect-config-file.js

@@ -0,0 +1,241 @@
+import { z } from 'zod';
+import { CONNECT_SOURCE, saveConnectContext, validatedApiKey } from './auth.js';
+import { CURSOR_SKILL_TARGET, openExternalUrl } from './connect-clients.js';
+import { ensureCliAuthenticated } from './connect-auth.js';
+import { installWebSkill } from './skill-install.js';
+import { ConnectStepError, createConnectTelemetry, runGuarded, settle, } from './connect-runtime.js';
+import { cursorInstallDeeplink, cursorMcpPath, readCursorTinyfishEntry, writeCursorMcpConfig, } from './cursor-config.js';
+import { ompMcpPath, readOmpTinyfishEntry, writeOmpMcpConfig } from './omp-config.js';
+import { PI_ADAPTER_INSTALL_COMMAND, piMcpAdapterState, piSkillDirMismatch, piMcpPath, readPiTinyfishEntry, writePiMcpConfig, } from './pi-config.js';
+import { AuthMode, HARNESS_DISPLAY_NAMES } from './harness-detect.js';
+import { detectHumanInitiated } from './harness.js';
+import { errLine } from './output.js';
+import { verifyMcpAuth } from './verify.js';
+import { apiBaseFromMcpUrl } from './mcp-endpoint.js';
+import { finishSetupHint, requireKeylessMcp, trackPostInstallFailure } from './connect-steps.js';
+const PI_RELOAD_COPY = 'TinyFish is configured in pi. Restart pi, then run `/mcp-auth tinyfish` there if it asks you ' +
+    'to sign in.';
+// The skill is the working path either way, so the note must not read as a failure.
+const PI_ADAPTER_DORMANT_NOTE = 'Note: pi has no built-in MCP support, so the entry in its mcp.json stays dormant until you ' +
+    `run \`${PI_ADAPTER_INSTALL_COMMAND}\`. The TinyFish skill works without it.`;
+// Only the dormant case was spoken for, leaving a working MCP install silent.
+const PI_ADAPTER_LIVE_NOTE = 'pi-mcp-adapter is installed, so pi loads the TinyFish MCP tools as well as the skill once ' +
+    'you restart it.';
+function piAdapterNote() {
+    const state = piMcpAdapterState();
+    if (state === 'installed')
+        return PI_ADAPTER_LIVE_NOTE;
+    return state === 'absent' ? PI_ADAPTER_DORMANT_NOTE : undefined;
+}
+// The `skills` CLI writes to the default dir even when pi reads another one.
+function piPostConnectNotes() {
+    const notes = [piAdapterNote()];
+    const skills = piSkillDirMismatch();
+    if (skills) {
+        notes.push(`Note: PI_CODING_AGENT_DIR points pi at ${skills.readFrom}, but the TinyFish skill ` +
+            `installed to ${skills.installedTo}. Copy or symlink it across for pi to load it.`);
+    }
+    const printable = notes.filter(Boolean);
+    return printable.length > 0 ? printable.join('\n') : undefined;
+}
+// Only interactive omp wires the OAuth handler; headless cannot sign in.
+const OMP_KEYLESS_COPY = 'TinyFish is configured in omp. Open omp and sign in to TinyFish when prompted, or run ' +
+    '`/mcp reauth tinyfish` there.';
+const CONFIG_FILE_HARNESSES = {
+    cursor: {
+        skillTarget: CURSOR_SKILL_TARGET,
+        registeredUrl: () => readCursorTinyfishEntry().url,
+        write: writeCursorMcpConfig,
+        configPath: cursorMcpPath,
+        tryLaunch: launchCursorDeeplink,
+        copy: {
+            verified: "TinyFish is connected and verified (health+auth). Reload the Cursor window (or restart cursor-agent) and it's live.",
+            authFailed: (reason) => `TinyFish is configured, but the authenticated check failed (${reason}). ` +
+                'Fix: rotate/re-enter your key with `tinyfish auth login`, then re-run: tinyfish connect cursor',
+            launched: 'Cursor should pop a TinyFish install confirmation — approve it, then sign in when prompted.',
+            reload: 'TinyFish is connected. Reload the Cursor window, then approve/sign in under Settings → MCP.',
+        },
+    },
+    omp: {
+        // No skill exists for omp; installWebSkill returns without one.
+        skillTarget: { displayName: HARNESS_DISPLAY_NAMES.omp },
+        registeredUrl: () => readOmpTinyfishEntry()?.url,
+        write: writeOmpMcpConfig,
+        configPath: ompMcpPath,
+        // No install deeplink exists; the keyless copy carries the sign-in.
+        tryLaunch: () => false,
+        copy: {
+            verified: "TinyFish is connected and verified (health+auth). Restart omp and it's live.",
+            authFailed: (reason) => `TinyFish is configured, but the authenticated check failed (${reason}). ` +
+                'Fix: rotate/re-enter your key with `tinyfish auth login`, then re-run: tinyfish connect omp',
+            launched: OMP_KEYLESS_COPY,
+            reload: OMP_KEYLESS_COPY,
+        },
+    },
+    pi: {
+        skillTarget: { skillAgent: 'pi', displayName: HARNESS_DISPLAY_NAMES.pi },
+        registeredUrl: () => readPiTinyfishEntry().url,
+        write: writePiMcpConfig,
+        configPath: piMcpPath,
+        // No install deeplink exists; the copy carries the restart instead.
+        tryLaunch: () => false,
+        postConnectNote: piPostConnectNotes,
+        copy: {
+            verified: "TinyFish is connected and verified (health+auth). Restart pi and it's live.",
+            authFailed: (reason) => `TinyFish is configured, but the authenticated check failed (${reason}). ` +
+                'Fix: rotate/re-enter your key with `tinyfish auth login`, then re-run: tinyfish connect pi',
+            launched: PI_RELOAD_COPY,
+            reload: PI_RELOAD_COPY,
+        },
+    },
+};
+/** Cosmetic and post-settle: a skill failure must not fail the connection. */
+function installSkillPostSettle(spec, displayName, state, telemetry, options) {
+    if (!spec.skillTarget.skillAgent)
+        return false;
+    state.stage = 'skill_install';
+    try {
+        installWebSkill(spec.skillTarget, { verbose: options.verbose ?? false });
+        telemetry.track('checkpoint', { phase: 'skill_installed' });
+        return false;
+    }
+    catch (error) {
+        trackPostInstallFailure(displayName, state, telemetry, error);
+        return true;
+    }
+}
+/** Prints last: the outro must own the final line. */
+function reportPostInstallFailure(harness, failed, onPostInstallFailed) {
+    if (!failed)
+        return;
+    errLine(finishSetupHint(harness));
+    onPostInstallFailed?.();
+}
+/** Writes the harness's MCP config file itself; no `mcp add` exists. */
+export async function connectConfigFileHarness(harness, options) {
+    const spec = CONFIG_FILE_HARNESSES[harness];
+    const displayName = HARNESS_DISPLAY_NAMES[harness];
+    let fallbackAttemptId;
+    const registeredUrl = spec.registeredUrl();
+    if (registeredUrl) {
+        try {
+            const registered = new URL(registeredUrl);
+            const requested = new URL(options.mcpUrl);
+            const registeredId = registered.searchParams.get('connect_attempt_id');
+            const registeredSource = registered.searchParams.get('source');
+            const registeredClient = registered.searchParams.get('client');
+            for (const key of ['source', 'client', 'connect_attempt_id']) {
+                registered.searchParams.delete(key);
+                requested.searchParams.delete(key);
+            }
+            registered.searchParams.sort();
+            requested.searchParams.sort();
+            if (registered.toString() === requested.toString() &&
+                registeredSource === CONNECT_SOURCE &&
+                registeredClient === harness &&
+                z.uuid().safeParse(registeredId).success) {
+                fallbackAttemptId = registeredId ?? undefined;
+            }
+        }
+        catch {
+            // A hand-edited invalid URL is repaired below with a fresh attempt id.
+        }
+    }
+    const telemetry = createConnectTelemetry(options.mcpUrl, harness, {
+        ...options,
+        fallbackAttemptId,
+    });
+    // Never degraded: no sign-in command to be missing. False, not absent, so a `= false`
+    // filter still catches these harnesses.
+    const state = {
+        stage: 'prerequisite_check',
+        settled: false,
+        harnessDegraded: false,
+    };
+    await runGuarded(state, telemetry, async () => {
+        telemetry.track('started');
+        telemetry.track('checkpoint', { phase: 'prerequisite_ok' });
+        const resolveAuth = async () => {
+            let resolvedKey = validatedApiKey(options.apiKey);
+            const keyless = !resolvedKey && harness === 'omp';
+            if (keyless) {
+                await requireKeylessMcp(options.mcpUrl);
+            }
+            else {
+                state.stage = 'authentication';
+                ensureCliAuthenticated(harness, options.apiKey, {
+                    interactiveLogin: options.authTimeoutMs === undefined,
+                });
+                resolvedKey = validatedApiKey(options.apiKey);
+                telemetry.track('checkpoint', { phase: 'authenticated' });
+                if (!resolvedKey) {
+                    errLine('Ignoring the stored API key: invalid format. Run: tinyfish auth login');
+                }
+            }
+            return { resolvedKey, keyless };
+        };
+        const { resolvedKey, keyless } = await resolveAuth();
+        state.stage = 'registration';
+        errLine(`Adding TinyFish to ${displayName}...`);
+        const mcpUrl = new URL(options.mcpUrl);
+        mcpUrl.searchParams.set('source', CONNECT_SOURCE);
+        mcpUrl.searchParams.set('client', harness);
+        mcpUrl.searchParams.set('connect_attempt_id', telemetry.attemptId);
+        const result = spec.write(mcpUrl.toString(), resolvedKey);
+        if (result.status === 'corrupt_skip') {
+            // The message fallback would leak the config path; tag instead.
+            throw new ConnectStepError(`Could not update ${spec.configPath()}: existing file could not be read or is not valid JSON (${result.error}). ` +
+                `Fix the file, then re-run: tinyfish connect ${harness}`, 'invalid_config', { failureDetail: `${harness}_mcp_json_corrupt` });
+        }
+        if (result.backupPath) {
+            errLine(`Backed up existing ${displayName} MCP config to ${result.backupPath}`);
+        }
+        if (result.repaired) {
+            errLine('Repaired the existing TinyFish entry (updated auth/config to current).');
+        }
+        telemetry.track('checkpoint', { phase: 'registered' });
+        let authMode = keyless ? AuthMode.Keyless : 'deferred';
+        if (resolvedKey)
+            authMode = AuthMode.ApiKey;
+        state.authMode = authMode;
+        if (keyless)
+            saveConnectContext(harness, telemetry.attemptId, AuthMode.Keyless);
+        else
+            saveConnectContext(harness, telemetry.attemptId);
+        settle(state, telemetry, 'completed', { authMode });
+        const postInstallFailed = installSkillPostSettle(spec, displayName, state, telemetry, options);
+        if (keyless) {
+            errLine(`TinyFish keyless Search is connected in ${displayName}.`);
+        }
+        else if (resolvedKey) {
+            // Deeplink would embed the key in a URL (process args, LaunchServices logs) — reload instead.
+            const verify = await verifyMcpAuth(resolvedKey, apiBaseFromMcpUrl(options.mcpUrl));
+            if (verify.ok) {
+                errLine(spec.copy.verified);
+            }
+            else {
+                errLine(spec.copy.authFailed(verify.reason ?? 'unknown'));
+            }
+        }
+        else if (detectHumanInitiated() && spec.tryLaunch(mcpUrl.toString())) {
+            errLine(spec.copy.launched);
+        }
+        else {
+            errLine(spec.copy.reload);
+        }
+        const note = spec.postConnectNote?.();
+        if (note)
+            errLine(note);
+        reportPostInstallFailure(harness, postInstallFailed, options.onPostInstallFailed);
+    });
+    return state.authMode;
+}
+/** Writes mcp.json directly — no `cursor mcp add` exists. */
+export async function connectCursor(options) {
+    await connectConfigFileHarness('cursor', options);
+}
+/** Best-effort: false when no handler/open fails — caller falls back to reload copy. */
+function launchCursorDeeplink(mcpUrl) {
+    const result = openExternalUrl(cursorInstallDeeplink(mcpUrl));
+    return !result.error && result.status === 0;
+}

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

@@ -0,0 +1,4 @@
+import type { AgentClient, ConnectAuthMode } from './connect-runtime.js';
+import { type NativeConnectOptions } from './connect-steps.js';
+export declare function launchAgent(client: AgentClient): Promise<void>;
+export declare function connectHarness(harness: AgentClient, options: NativeConnectOptions): Promise<ConnectAuthMode | undefined>;

package/dist/lib/connect-harness.js

@@ -0,0 +1,76 @@
+import { KEYLESS_ONBOARDING_PROMPT, NATIVE_BY_HARNESS, launchNativeMcpClient, launchOmpWalkthrough, launchPiWalkthrough, launchOpenClawWalkthrough, } from './connect-clients.js';
+import { AuthMode } from './harness-detect.js';
+import { errLine } from './output.js';
+import { connectNativeMcpClient } from './connect-native.js';
+import { connectOpenClaw } from './connect-openclaw.js';
+import { connectConfigFileHarness, connectCursor } from './connect-config-file.js';
+import { finishSetupHint } from './connect-steps.js';
+/** Total over the non-native harnesses: a new one fails to compile until wired here. */
+const LAUNCH_OVERRIDES = {
+    omp: launchOmpWalkthrough,
+    pi: launchPiWalkthrough,
+    openclaw: launchOpenClawWalkthrough,
+    // Cursor has no chat CLI to launch.
+    cursor: () => {
+        throw new Error('Cursor has no launchable walkthrough. Open Cursor and start chatting.');
+    },
+};
+const isNonNative = (harness) => harness in LAUNCH_OVERRIDES;
+export async function launchAgent(client) {
+    if (isNonNative(client))
+        return void (await LAUNCH_OVERRIDES[client]());
+    await launchNativeMcpClient(requireNative(client));
+}
+/** Total over the non-native harnesses; native harnesses use the descriptor engine. */
+const CONNECTOR_OVERRIDES = {
+    openclaw: async (options) => {
+        await connectOpenClaw(options);
+        return undefined;
+    },
+    cursor: async (options) => {
+        await connectCursor(options);
+        // `connect cursor --launch` still connects; it just cannot launch after.
+        if (options.launch) {
+            errLine('Cursor has no launchable walkthrough. Open Cursor and start chatting.');
+        }
+        return undefined;
+    },
+    omp: async (options) => {
+        const authMode = await connectConfigFileHarness('omp', options);
+        if (options.launch) {
+            try {
+                await launchOmpWalkthrough(undefined, authMode === AuthMode.Keyless ? KEYLESS_ONBOARDING_PROMPT : undefined);
+            }
+            catch (error) {
+                // Post-settle, like the native walkthrough step: never fail the connect.
+                errLine(error instanceof Error ? error.message : String(error));
+                errLine(finishSetupHint('omp'));
+            }
+        }
+        return authMode;
+    },
+    pi: async (options) => {
+        await connectConfigFileHarness('pi', options);
+        if (options.launch) {
+            try {
+                await launchPiWalkthrough();
+            }
+            catch (error) {
+                errLine(error instanceof Error ? error.message : String(error));
+                errLine(finishSetupHint('pi'));
+            }
+        }
+        return undefined;
+    },
+};
+function requireNative(harness) {
+    const client = NATIVE_BY_HARNESS.get(harness);
+    if (!client)
+        throw new Error(`No native MCP descriptor for ${harness}`);
+    return client;
+}
+export async function connectHarness(harness, options) {
+    if (isNonNative(harness))
+        return CONNECTOR_OVERRIDES[harness](options);
+    return connectNativeMcpClient(requireNative(harness), options);
+}

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

@@ -0,0 +1,4 @@
+import { type NativeMcpClient } from './connect-clients.js';
+import { type ConnectAuthMode } from './connect-runtime.js';
+import { type NativeConnectOptions } from './connect-steps.js';
+export declare function connectNativeMcpClient(client: NativeMcpClient, options: NativeConnectOptions): Promise<ConnectAuthMode | undefined>;