@tiny-fish/cli 0.42.1 → 0.45.1-next.352

package/dist/lib/hermes-plugin.js

@@ -6,19 +6,15 @@ import spawn from 'cross-spawn';
 import { z } from 'zod';
 import { capturedOutput, replay, SKILL_INSTALL_TIMEOUT_MS, STEP_MAX_BUFFER, } from './cli-install.js';
 import { commandNotFound, ConnectStepError, spawnStepError, throwIfInterrupted, } from './connect-runtime.js';
-import { HARNESS_PROBE_TIMEOUT_MS } from './constants.js';
+import { HARNESS_PROBE_TIMEOUT_MS, TINYFISH_ACCESS_MODE_HEADER, TINYFISH_KEYLESS_ACCESS_MODE, } from './constants.js';
 import { HERMES_HEADER_TEMPLATE, HERMES_MCP_SERVER_KEY } from './hermes-config.js';
 import { errLine, parseJson } from './output.js';
-// Bump per CLI release.
-export const HERMES_PLUGIN_SHA = '496cd63fefd982bbaa8a85ce78ef2270d700984f';
-// Bump with the SHA; the source is `hermes/plugin.yaml` at that commit.
-export const HERMES_PLUGIN_VERSION = '0.1.0';
-// Manifest `name:`, not the repo subdir; `plugins uninstall` keys on it.
-const PLUGIN_SOURCE = 'tinyfish-io/tinyfish-web-agent-integrations/hermes';
-const PLUGIN_REPO_URL = 'https://github.com/tinyfish-io/tinyfish-web-agent-integrations.git';
-export const HERMES_PLUGIN_MANUAL_INSTALL = `hermes plugins install ${PLUGIN_SOURCE} --ref ${HERMES_PLUGIN_SHA} --enable`;
-// Anchored to --ref: another rejected flag would fail the clone path too.
+// Resolved at connect time, so plugin releases need no CLI release.
+export const HERMES_PLUGIN_PACKAGE = '@tiny-fish/hermes';
+// Anchored to --ref: an older Hermes rejects the flag and needs the plain URL.
 const REF_UNSUPPORTED_PATTERN = /unrecognized arguments:[^\n]*--ref/;
+// Tracks the repo head; npm @latest can trail a merge by one publish run.
+export const HERMES_PLUGIN_MANUAL_INSTALL = 'hermes plugins install tinyfish-io/tinyfish-web-agent-integrations/hermes --enable';
 function installSpawnEnv(home, apiKey) {
     // Hermes' install-time requires_env check reads os.environ, not our .env seed.
     return { ...process.env, HERMES_HOME: home, TINYFISH_API_KEY: apiKey };
@@ -42,42 +38,102 @@ function runGit(args) {
         timeout: SKILL_INSTALL_TIMEOUT_MS,
     });
     if (!result.error && result.status === 0)
-        return;
+        return result;
     if (commandNotFound(result.error)) {
-        throw new ConnectStepError('git is required to stage the pinned plugin; install git and run connect again', 'command_not_found');
+        throw new ConnectStepError('git is required to stage the plugin for Hermes; install git and run connect again', 'command_not_found');
     }
     // Built first: its interrupt check must run before any replay.
     const error = spawnStepError('Could not stage the TinyFish Hermes plugin', result);
     replay(capturedOutput(result));
     throw error;
 }
-// Pre-`--ref` Hermes: stage the pin ourselves, mirroring `--ref` internals.
-function installFromClone(env) {
-    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'tinyfish-hermes-plugin-'));
+function runNpmDownload(tmp) {
+    // --prefix both downloads and extracts, so no tar dependency anywhere.
+    const result = spawn.sync('npm', [
+        'install',
+        `${HERMES_PLUGIN_PACKAGE}@latest`,
+        '--prefix',
+        tmp,
+        // Lifecycle scripts would run arbitrary code with the key in env.
+        '--ignore-scripts',
+        '--no-save',
+        '--no-audit',
+        '--no-fund',
+        '--loglevel=error',
+    ], { encoding: 'utf8', maxBuffer: STEP_MAX_BUFFER, timeout: SKILL_INSTALL_TIMEOUT_MS });
+    if (!result.error && result.status === 0)
+        return;
+    if (commandNotFound(result.error)) {
+        throw new ConnectStepError(`npm is required to download the TinyFish Hermes plugin; to install it yourself run: ${HERMES_PLUGIN_MANUAL_INSTALL}`, 'command_not_found');
+    }
+    // Built first: its interrupt check must run before any replay.
+    const error = spawnStepError(`Could not download ${HERMES_PLUGIN_PACKAGE} from npm; to install it yourself run: ${HERMES_PLUGIN_MANUAL_INSTALL}`, result);
+    replay(capturedOutput(result));
+    throw error;
+}
+function stagedPluginVersion(dir) {
     try {
-        runGit(['clone', '--depth', '1', PLUGIN_REPO_URL, tmp]);
-        runGit(['-C', tmp, 'fetch', '--depth', '1', 'origin', HERMES_PLUGIN_SHA]);
-        runGit(['-C', tmp, 'checkout', '--detach', HERMES_PLUGIN_SHA]);
-        return runPluginInstall([`${pathToFileURL(tmp).href}#hermes`], env);
+        const parsed = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+        const version = parsed.version;
+        return typeof version === 'string' && version ? version : undefined;
     }
-    finally {
-        fs.rmSync(tmp, { recursive: true, force: true });
+    catch {
+        return undefined;
     }
 }
+// Hermes installs plugins only by git clone, so the payload gets a throwaway repo.
+function stagePluginFromNpm(tmp) {
+    runNpmDownload(tmp);
+    const dir = path.join(tmp, 'node_modules', ...HERMES_PLUGIN_PACKAGE.split('/'));
+    // Empty hooksPath: a global hooks dir or init template must not run here.
+    const hooksDir = path.join(tmp, 'git-hooks');
+    fs.mkdirSync(hooksDir);
+    runGit(['-C', dir, 'init', '--quiet']);
+    runGit(['-C', dir, 'add', '-A']);
+    // Inline identity: fresh machines have no git config and commit fails without it.
+    runGit([
+        '-C',
+        dir,
+        '-c',
+        `core.hooksPath=${hooksDir}`,
+        '-c',
+        'user.name=tinyfish-cli',
+        '-c',
+        'user.email=support@tinyfish.io',
+        'commit',
+        '--quiet',
+        // A global commit.gpgSign would summon a signer this commit must not need.
+        '--no-gpg-sign',
+        '-m',
+        'stage @tiny-fish/hermes for install',
+    ]);
+    const sha = String(runGit(['-C', dir, 'rev-parse', 'HEAD']).stdout ?? '').trim();
+    return { dir, sha, version: stagedPluginVersion(dir) };
+}
 export function installHermesPlugin(home, apiKey, { verbose }) {
     errLine('Installing the TinyFish web plugin in Hermes...');
     const env = installSpawnEnv(home, apiKey);
-    // --ref always: a same-source reinstall without it keeps the previous pin.
-    const primary = runPluginInstall([PLUGIN_SOURCE, '--ref', HERMES_PLUGIN_SHA], env);
-    const result = refUnsupported(primary) ? installFromClone(env) : primary;
-    if (result.error || result.status !== 0) {
-        // A declined security scan exits 1 here, and reconnecting repeats it.
-        const error = spawnStepError(`Could not install the TinyFish web plugin in Hermes; to install it yourself run: ${HERMES_PLUGIN_MANUAL_INSTALL}`, result);
-        replay(capturedOutput(result));
-        throw error;
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'tinyfish-hermes-plugin-'));
+    try {
+        const staged = stagePluginFromNpm(tmp);
+        const url = pathToFileURL(staged.dir).href;
+        // --ref: a prior pinned install rejects an unpinned reinstall of the same name.
+        const primary = runPluginInstall([url, '--ref', staged.sha], env);
+        // A pre---ref Hermes never pins, so the plain URL is safe there.
+        const result = refUnsupported(primary) ? runPluginInstall([url], env) : primary;
+        if (result.error || result.status !== 0) {
+            // A declined security scan exits 1 here, and reconnecting repeats it.
+            const error = spawnStepError(`Could not install the TinyFish web plugin in Hermes; to install it yourself run: ${HERMES_PLUGIN_MANUAL_INSTALL}`, result);
+            replay(capturedOutput(result));
+            throw error;
+        }
+        if (verbose)
+            replay(capturedOutput(result));
+        return staged.version;
+    }
+    finally {
+        fs.rmSync(tmp, { recursive: true, force: true });
     }
-    if (verbose)
-        replay(capturedOutput(result));
 }
 function hermesConfig(args, home) {
     return spawn.sync('hermes', ['config', ...args], {
@@ -97,15 +153,15 @@ function configWrite(home, args) {
     throw error;
 }
 /** Absent `enabled` reads as enabled, so never write this field-by-field. */
-export function writeHermesMcpEntry(home, mcpUrl) {
+export function writeHermesMcpEntry(home, mcpUrl, mode = 'api-key') {
     const entry = {
         url: mcpUrl,
-        headers: { Authorization: HERMES_HEADER_TEMPLATE },
+        headers: mode === 'keyless'
+            ? { [TINYFISH_ACCESS_MODE_HEADER]: TINYFISH_KEYLESS_ACCESS_MODE }
+            : { Authorization: HERMES_HEADER_TEMPLATE },
         enabled: true,
     };
-    const result = hermesConfig(['set', `mcp_servers.${HERMES_MCP_SERVER_KEY}`, JSON.stringify(entry)], home);
-    // `config set` exits 0 on a bad key, so only an interrupt is worth raising here.
-    throwIfInterrupted(result);
+    configWrite(home, ['set', `mcp_servers.${HERMES_MCP_SERVER_KEY}`, JSON.stringify(entry)]);
 }
 /** Retracts our row; an absent `enabled` reads as enabled, so a partial one is live. */
 export function removeHermesMcpEntry(home) {

package/dist/lib/mcp-json-config.d.ts

@@ -17,11 +17,13 @@ export interface McpJsonWriteResult {
     repaired?: boolean;
 }
 export declare function buildTinyfishServerEntry(mcpUrl: string, apiKey?: string): Record<string, unknown>;
+export declare function buildTinyfishKeylessServerEntry(mcpUrl: string): Record<string, unknown>;
 /** Dry-run description of the pending write; touches nothing. */
-export declare function planWrite(target: McpJsonTarget, mcpUrl: string, apiKey?: string): string;
+export declare function planWrite(target: McpJsonTarget, mcpUrl: string, apiKey?: string, serverEntry?: Record<string, unknown>): string;
 export interface McpJsonServerEntry {
     present: boolean;
     hasApiKeyHeader: boolean;
+    keyless?: true;
     /** Only ever false: harnesses with a disable toggle write it, the rest omit it. */
     enabled?: false;
     /** Registered endpoint, so a caller can tell "registered" from "registered at the right place". */
@@ -34,6 +36,6 @@ export interface McpJsonServerEntry {
 /** Reports the header's shape, never its value. */
 export declare function readTinyfishEntry(target: McpJsonTarget): McpJsonServerEntry;
 /** Merges only the target's key; skips unreadable/corrupt files rather than clobber. */
-export declare function writeMcpConfig(target: McpJsonTarget, mcpUrl: string, apiKey?: string): McpJsonWriteResult;
+export declare function writeMcpConfig(target: McpJsonTarget, mcpUrl: string, apiKey?: string, serverEntry?: Record<string, unknown>): McpJsonWriteResult;
 /** Removes only the target's key. */
 export declare function removeServer(target: McpJsonTarget): McpJsonWriteResult;

package/dist/lib/mcp-json-config.js

@@ -1,5 +1,6 @@
 import * as fs from 'fs';
 import { matchesCliKey } from './auth.js';
+import { TINYFISH_ACCESS_MODE_HEADER, TINYFISH_KEYLESS_ACCESS_MODE } from './constants.js';
 function isPlainRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
@@ -7,6 +8,9 @@ function isPlainRecord(value) {
 export function buildTinyfishServerEntry(mcpUrl, apiKey) {
     return apiKey ? { url: mcpUrl, headers: { 'X-API-Key': apiKey } } : { url: mcpUrl };
 }
+export function buildTinyfishKeylessServerEntry(mcpUrl) {
+    return { url: mcpUrl, headers: { [TINYFISH_ACCESS_MODE_HEADER]: TINYFISH_KEYLESS_ACCESS_MODE } };
+}
 function parseMcpJson(raw) {
     try {
         const parsed = JSON.parse(raw);
@@ -38,18 +42,21 @@ function readExisting(target) {
     return { raw, parsed: parsed.value };
 }
 /** Dry-run description of the pending write; touches nothing. */
-export function planWrite(target, mcpUrl, apiKey) {
+export function planWrite(target, mcpUrl, apiKey, serverEntry) {
     const existing = readExisting(target);
     const filePath = target.file();
     if ('error' in existing) {
         return `${filePath}: existing file is corrupt (${existing.error}) — would skip and leave it untouched`;
     }
-    const authNote = apiKey
-        ? ' with an API-key header — the key is stored in plaintext in that file (value not shown here)'
-        : '';
+    const authNote = serverEntry
+        ? ` with an ${TINYFISH_ACCESS_MODE_HEADER}: ${TINYFISH_KEYLESS_ACCESS_MODE} header`
+        : apiKey
+            ? ' with an API-key header — the key is stored in plaintext in that file (value not shown here)'
+            : '';
+    const nextEntry = serverEntry ?? buildTinyfishServerEntry(mcpUrl, apiKey);
     const servers = existing.parsed.mcpServers;
     const current = isPlainRecord(servers) ? servers[target.serverKey] : undefined;
-    if (JSON.stringify(current) === JSON.stringify(buildTinyfishServerEntry(mcpUrl, apiKey))) {
+    if (JSON.stringify(current) === JSON.stringify(nextEntry)) {
         return `${filePath}: already has the ${target.serverKey} MCP entry — no change`;
     }
     return existing.raw === undefined
@@ -61,17 +68,21 @@ const ENV_TEMPLATE_VALUE = /^\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-[^}]*)?\}$/;
 /** Reports the header's shape, never its value. */
 export function readTinyfishEntry(target) {
     const existing = readExisting(target);
-    if ('error' in existing)
+    if ('error' in existing) {
         return { present: false, hasApiKeyHeader: false, error: existing.error };
+    }
     const servers = existing.parsed.mcpServers;
     const entry = isPlainRecord(servers) ? servers[target.serverKey] : undefined;
     if (!isPlainRecord(entry))
         return { present: false, hasApiKeyHeader: false };
     const key = readKeyHeader(entry.headers, target.keyHeader);
     const templateVar = key ? ENV_TEMPLATE_VALUE.exec(key.value)?.[1] : undefined;
+    const accessMode = readKeyHeader(entry.headers, { name: TINYFISH_ACCESS_MODE_HEADER })?.value;
+    const keyless = accessMode?.trim().toLowerCase() === TINYFISH_KEYLESS_ACCESS_MODE;
     return {
         present: true,
         hasApiKeyHeader: key !== undefined,
+        ...(keyless ? { keyless: true } : {}),
         ...(entry.enabled === false ? { enabled: false } : {}),
         ...(matchesCliKey(key?.value) ? { keyMatchesCliKey: true } : {}),
         ...(templateVar ? { keyTemplateVar: templateVar } : {}),
@@ -114,19 +125,18 @@ function commitServers(target, existing, servers) {
     return { status: 'written', backupPath };
 }
 /** Merges only the target's key; skips unreadable/corrupt files rather than clobber. */
-export function writeMcpConfig(target, mcpUrl, apiKey) {
+export function writeMcpConfig(target, mcpUrl, apiKey, serverEntry = buildTinyfishServerEntry(mcpUrl, apiKey)) {
     const existing = readExisting(target);
     if ('error' in existing)
         return { status: 'corrupt_skip', error: existing.error };
     const servers = isPlainRecord(existing.parsed.mcpServers)
         ? { ...existing.parsed.mcpServers }
         : {};
-    const nextEntry = buildTinyfishServerEntry(mcpUrl, apiKey);
-    if (JSON.stringify(servers[target.serverKey]) === JSON.stringify(nextEntry)) {
+    if (JSON.stringify(servers[target.serverKey]) === JSON.stringify(serverEntry)) {
         return { status: 'unchanged' };
     }
     const repaired = target.serverKey in servers;
-    servers[target.serverKey] = nextEntry;
+    servers[target.serverKey] = serverEntry;
     return { ...commitServers(target, existing, servers), repaired };
 }
 /** Removes only the target's key. */

package/dist/lib/omp-config.js

@@ -2,7 +2,7 @@ import * as path from 'path';
 import spawn from 'cross-spawn';
 import { ConnectStepError } from './connect-runtime.js';
 import { HARNESS_PROBE_TIMEOUT_MS } from './constants.js';
-import { planWrite, readTinyfishEntry, removeServer, writeMcpConfig, } from './mcp-json-config.js';
+import { buildTinyfishKeylessServerEntry, planWrite, readTinyfishEntry, removeServer, writeMcpConfig, } from './mcp-json-config.js';
 const UNRESOLVED_REASON = '`omp config path` did not report a config directory';
 // Cached: every later read must agree with the write.
 let cachedAgentDir;
@@ -53,14 +53,16 @@ export function readOmpTinyfishEntry() {
 }
 /** Merges only the `tinyfish` key; throws when the dir is unresolved. */
 export function writeOmpMcpConfig(mcpUrl, apiKey) {
-    return writeMcpConfig(requireOmpTarget(), mcpUrl, apiKey);
+    const entry = apiKey ? undefined : buildTinyfishKeylessServerEntry(mcpUrl);
+    return writeMcpConfig(requireOmpTarget(), mcpUrl, apiKey, entry);
 }
 /** Dry-run description of the pending write; touches nothing. */
 export function planOmpWrite(mcpUrl, apiKey) {
     const target = ompMcpTarget();
     if (!target)
         return `${UNRESOLVED_REASON} — connect omp would fail the same way`;
-    return planWrite(target, mcpUrl, apiKey);
+    const entry = apiKey ? undefined : buildTinyfishKeylessServerEntry(mcpUrl);
+    return planWrite(target, mcpUrl, apiKey, entry);
 }
 /** Removes only the `tinyfish` key. */
 export function removeOmpMcpServer() {

package/dist/lib/output.js

@@ -41,6 +41,7 @@ export function errLine(line) {
 }
 const WARN_ON = '\x1b[33m';
 const WARN_OFF = '\x1b[39m';
+const VAULT_RECONNECT_REQUIRED = 'VAULT_RECONNECT_REQUIRED';
 /** Advisory stderr line, yellow on a terminal and plain everywhere else so piped output stays clean. */
 export function warnLine(line) {
     const text = sanitizeLine(line);
@@ -57,9 +58,14 @@ export function handleApiError(e) {
         const payload = { error: e.message, status: e.status };
         if (e.code)
             payload.code = e.code;
-        if (e.status === 401)
+        if (e.code === VAULT_RECONNECT_REQUIRED) {
+            payload.hint =
+                'Reconnect the provider with `tinyfish vault connection add --provider 1password` or `tinyfish vault connection add --provider bitwarden --client-id <client-id>`. Vault secrets are read from TINYFISH_VAULT_TOKEN, TINYFISH_VAULT_CLIENT_SECRET, and TINYFISH_VAULT_MASTER_PASSWORD.';
+        }
+        else if (e.status === 401) {
             payload.hint =
                 '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.js

@@ -326,9 +326,14 @@ function probeOmp() {
         : entry.keyMatchesCliKey
             ? { keyMatchesCliKey: true }
             : {};
+    let authMode = AuthMode.Unknown;
+    if (entry.hasApiKeyHeader)
+        authMode = AuthMode.ApiKey;
+    else if (entry.keyless)
+        authMode = AuthMode.Keyless;
     return {
         registered: Registered.Yes,
-        authMode: entry.hasApiKeyHeader ? AuthMode.ApiKey : AuthMode.Unknown,
+        authMode,
         ...(entry.url ? { registeredUrl: entry.url } : {}),
         ...keyVerdict,
     };
@@ -391,16 +396,19 @@ function probeHermes() {
     if (entry.state === 'absent')
         return NOT_REGISTERED;
     // `mcp add` saves a disabled entry on a failed connect, which connect refuses too.
-    const enabled = entry.state === 'enabled' ? {} : { connected: false };
+    const details = entry.state === 'enabled' ? {} : { connected: false };
+    const registeredUrl = entry.url ? { registeredUrl: entry.url } : {};
     // The .env key is Hermes-wide; the header template ties it here.
     const storedKey = entry.usesKeyHeader ? readHermesKey(home) : undefined;
     if (!storedKey) {
-        return { registered: Registered.Yes, authMode: AuthMode.OAuth, ...enabled };
+        const authMode = entry.keyless ? AuthMode.Keyless : AuthMode.OAuth;
+        return { registered: Registered.Yes, authMode, ...details, ...registeredUrl };
     }
     return {
         registered: Registered.Yes,
         authMode: AuthMode.ApiKey,
-        ...enabled,
+        ...details,
+        ...registeredUrl,
         ...(matchesCliKey(storedKey) ? { keyMatchesCliKey: true } : {}),
     };
 }

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

@@ -163,11 +163,16 @@ declare const doctorCompletedPayloadSchema: z.ZodObject<{
         detected: z.ZodBoolean;
         registered: z.ZodEnum<typeof Registered>;
         auth_mode: z.ZodEnum<typeof AuthMode>;
+        recorded_auth_mode: z.ZodOptional<z.ZodEnum<{
+            keyless: "keyless";
+            "api-key": "api-key";
+            oauth: "oauth";
+            deferred: "deferred";
+        }>>;
         proves_harness_reach: z.ZodBoolean;
     }, z.core.$strip>>;
     duration_ms: z.ZodInt;
     hermes_plugin_version: z.ZodOptional<z.ZodString>;
-    hermes_plugin_expected_version: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 declare const doctorCouldNotRunPayloadSchema: z.ZodObject<{
     outcome: z.ZodLiteral<"could_not_run">;
@@ -266,11 +271,16 @@ declare const doctorPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         detected: z.ZodBoolean;
         registered: z.ZodEnum<typeof Registered>;
         auth_mode: z.ZodEnum<typeof AuthMode>;
+        recorded_auth_mode: z.ZodOptional<z.ZodEnum<{
+            keyless: "keyless";
+            "api-key": "api-key";
+            oauth: "oauth";
+            deferred: "deferred";
+        }>>;
         proves_harness_reach: z.ZodBoolean;
     }, z.core.$strip>>;
     duration_ms: z.ZodInt;
     hermes_plugin_version: z.ZodOptional<z.ZodString>;
-    hermes_plugin_expected_version: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     outcome: z.ZodLiteral<"could_not_run">;
     error_class: z.ZodEnum<{

package/dist/lib/setup-telemetry.js

@@ -265,13 +265,13 @@ const doctorCompletedPayloadSchema = z.object({
         detected: z.boolean(),
         registered: z.enum(Registered),
         auth_mode: z.enum(AuthMode),
+        recorded_auth_mode: z.enum(['api-key', 'keyless', 'oauth', 'deferred']).optional(),
         proves_harness_reach: z.boolean(),
     }))
         .max(16),
     duration_ms: z.int().nonnegative().max(3_600_000),
     /** Bounded here, not on the report: a reject drops only telemetry. */
     hermes_plugin_version: versionSchema.optional(),
-    hermes_plugin_expected_version: versionSchema.optional(),
 });
 // Detection threw, so there is no report to aggregate: enumerated outcome and timing only.
 const doctorCouldNotRunPayloadSchema = z.object({

package/dist/lib/verify.d.ts

@@ -9,6 +9,6 @@ export interface VerifyResult {
     status?: number;
 }
 /** Reachability check. Verify failure is a warning, never install failure. */
-export declare function verifyMcpHealth(mcpUrl: string): Promise<VerifyResult>;
+export declare function verifyMcpHealth(mcpUrl: string, keyless?: boolean): Promise<VerifyResult>;
 /** Authenticated check — where the CLI holds the key (Cursor, OpenClaw, Hermes). */
 export declare function verifyMcpAuth(apiKey: string, apiBaseUrl?: string): Promise<VerifyResult>;

package/dist/lib/verify.js

@@ -1,6 +1,16 @@
 import { listRuns } from './client.js';
+import { TINYFISH_ACCESS_MODE_HEADER, TINYFISH_KEYLESS_ACCESS_MODE } from './constants.js';
 import { ApiError } from './output.js';
+import { z } from 'zod';
 const VERIFY_TIMEOUT_MS = 5_000;
+const keylessInitializeSchema = z.object({
+    jsonrpc: z.literal('2.0'),
+    id: z.literal(1),
+    result: z.object({
+        capabilities: z.object({}),
+        serverInfo: z.object({ name: z.literal('tinyfish') }),
+    }),
+});
 // `fetch` collapses every network fault to "fetch failed" and hides the cause on `e.cause`.
 function networkCode(e) {
     const cause = e?.cause;
@@ -32,24 +42,34 @@ function authCode(e) {
         return 'rate limited';
     return e.status >= 500 ? 'TinyFish returned a server error' : `the API returned HTTP ${e.status}`;
 }
+function failedHealth(reason) {
+    return { depth: 'health', ok: false, reason, code: reason };
+}
 /** Reachability check. Verify failure is a warning, never install failure. */
-export async function verifyMcpHealth(mcpUrl) {
+export async function verifyMcpHealth(mcpUrl, keyless = false) {
     try {
         const response = await fetch(mcpUrl, {
-            method: 'GET',
+            method: keyless ? 'POST' : 'GET',
+            ...(keyless
+                ? {
+                    headers: {
+                        [TINYFISH_ACCESS_MODE_HEADER]: TINYFISH_KEYLESS_ACCESS_MODE,
+                        'Content-Type': 'application/json',
+                        Accept: 'application/json, text/event-stream',
+                    },
+                    body: '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18"}}',
+                }
+                : {}),
             // Redirect (captive portal, typo'd --url) is not healthy.
             redirect: 'error',
             signal: AbortSignal.timeout(VERIFY_TIMEOUT_MS),
         });
         // MCP rejects bare GET with 4xx — still proves endpoint routed.
-        if (response.status >= 500) {
-            return {
-                depth: 'health',
-                ok: false,
-                reason: `endpoint returned HTTP ${response.status}`,
-                code: `the endpoint returned HTTP ${response.status}`,
-            };
+        if (response.status >= 500 || (keyless && response.status !== 200)) {
+            return failedHealth(`endpoint returned HTTP ${response.status}`);
         }
+        if (keyless && !keylessInitializeSchema.safeParse(await response.json()).success)
+            return failedHealth('endpoint returned an invalid MCP initialize response');
         return { depth: 'health', ok: true };
     }
     catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiny-fish/cli",
-  "version": "0.42.1",
+  "version": "0.45.1-next.352",
   "description": "TinyFish CLI — run web automations from your terminal",
   "type": "module",
   "bin": {
@@ -35,7 +35,7 @@
     "format:check": "oxfmt --check ."
   },
   "dependencies": {
-    "@tiny-fish/sdk": "^0.6.0",
+    "@tiny-fish/sdk": "^0.7.0",
     "commander": "^12.0.0",
     "cross-spawn": "^7.0.6",
     "tldts": "^6.1.86",