@tiny-fish/cli 0.34.1-next.286 → 0.35.0

package/dist/commands/doctor.js

@@ -8,6 +8,8 @@ import { err, errLine, out, outLine } from '../lib/output.js';
 import { detectRegistrations } from '../lib/registration-detect.js';
 import { sendDoctorCompleted } from '../lib/setup-telemetry.js';
 import { verifyMcpAuth, verifyMcpHealth } from '../lib/verify.js';
+import { resolveHermesHome } from '../lib/hermes-env.js';
+import { hermesWebBackendsOurs, readHermesPluginStatus, } from '../lib/hermes-plugin.js';
 import { DEFAULT_MCP_URL, endpointOf, isDefaultEndpoint } from '../lib/mcp-endpoint.js';
 import { connectClaudeCode, connectCodex, connectCursor, connectGrok, connectHermes, connectOpenClaw, connectOpencode, } from './connect.js';
 // A green auth mode with a red auth call proves nothing, so the call's verdict gates the claim.
@@ -197,6 +199,77 @@ function verifyHarnessKey(status, cliAuth, mcpUrl) {
     // The CLI never holds a harness's key, so only its own credential can be verified.
     return runsOnCliCredential(status) ? cliAuth : undefined;
 }
+// `ok` is backends && key; provider_available re-reads the key through the provider.
+function hermesPluginStatusVerdict(status) {
+    if (status.ok) {
+        return status.provider_available === false
+            ? { status: 'warn', detail: 'plugin configured, but its provider cannot see the key' }
+            : {
+                status: 'pass',
+                detail: `plugin ${status.plugin_version ?? 'installed'}; backends and key configured`,
+            };
+    }
+    if (!status.web_backend_configured) {
+        return {
+            status: 'warn',
+            detail: 'plugin installed but the web backends do not point at tinyfish',
+        };
+    }
+    return {
+        status: 'fail',
+        detail: 'web backends point at tinyfish but no key resolves from ' +
+            'TINYFISH_API_KEY or MCP_TINYFISH_API_KEY',
+    };
+}
+/** An unreadable config cannot prove the backends are ours, so doctor never fails on it. */
+function backendsOurs(home) {
+    try {
+        return hermesWebBackendsOurs(home);
+    }
+    catch {
+        return false;
+    }
+}
+function hermesPluginVerdict(home) {
+    const probe = readHermesPluginStatus(home);
+    if (probe.state === 'not_installed') {
+        // Backends naming an absent provider are broken; never-installed keeps exit 0.
+        return backendsOurs(home)
+            ? {
+                status: 'fail',
+                detail: 'web backends point at tinyfish but the plugin is not installed or not enabled',
+            }
+            : { status: 'warn', detail: 'the TinyFish web plugin is not installed or not enabled' };
+    }
+    if (probe.state === 'unreachable') {
+        return { status: 'warn', detail: '`hermes tinyfish status` did not respond in time' };
+    }
+    if (probe.state === 'unparseable') {
+        return {
+            status: 'warn',
+            detail: '`hermes tinyfish status --json` returned unparseable output',
+        };
+    }
+    return hermesPluginStatusVerdict(probe.status);
+}
+function checkHermesPlugin(status) {
+    const check = {
+        id: 'hermes-plugin',
+        title: 'Hermes web plugin',
+        harness: 'hermes',
+        scope: 'harness',
+    };
+    if (!status.detected)
+        return { ...check, status: 'skip', detail: 'harness not installed' };
+    if (status.registered !== Registered.Yes) {
+        return { ...check, status: 'skip', detail: 'TinyFish is not registered in Hermes' };
+    }
+    const home = resolveHermesHome();
+    if (!home) {
+        return { ...check, status: 'warn', detail: "could not determine Hermes' home directory" };
+    }
+    return { ...check, ...hermesPluginVerdict(home) };
+}
 // Only Cursor's repair is a pure local file write; every other one needs a browser sign-in.
 const UNATTENDED_SAFE = new Set(['cursor']);
 function repairsFor(checks, statuses) {
@@ -219,7 +292,7 @@ function repairsFor(checks, statuses) {
         // A registered entry that still fails earns one too.
         // `connected: false` is the harness's own no; it only warns, so it earns a repair here.
         const brokenRegistration = status.connected === false ||
-            checks.some((c) => c.harness === status.harness && c.status === 'fail');
+            checks.some((c) => c.harness === status.harness && c.id !== 'hermes-plugin' && c.status === 'fail');
         if (!status.detected || (status.registered !== Registered.No && !brokenRegistration))
             continue;
         repairs.push({
@@ -235,6 +308,17 @@ function repairsFor(checks, statuses) {
             unattended_safe: UNATTENDED_SAFE.has(status.harness) && authCallPassed,
         });
     }
+    // connect hermes reinstalls the plugin; a second row would double it.
+    const pluginBroken = checks.some((c) => c.id === 'hermes-plugin' && c.status === 'fail');
+    if (pluginBroken && !repairs.some((repair) => repair.harness === 'hermes')) {
+        repairs.push({
+            for: 'hermes-plugin-broken',
+            action: 'connect',
+            harness: 'hermes',
+            command: 'tinyfish connect hermes',
+            unattended_safe: false,
+        });
+    }
     return repairs;
 }
 export async function runDoctor(options) {
@@ -246,10 +330,12 @@ export async function runDoctor(options) {
         cliAuth,
         Promise.all(statuses.map((status) => verifyHarnessKey(status, cliAuth, options.mcpUrl))),
     ]);
+    const hermesStatus = statuses.find((status) => status.harness === 'hermes');
     const checks = [
         checkCliVersion(),
         connectivity,
         ...statuses.map((status, i) => checkRegistration(status, options.mcpUrl, keyAuths[i], !credential.key)),
+        ...(hermesStatus ? [checkHermesPlugin(hermesStatus)] : []),
         credential.check,
         checkAuthCall(cliAuthResult),
     ];

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

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 import { type InstallOptions } from './cli-install.js';
 export declare const HERMES_PLUGIN_SHA = "496cd63fefd982bbaa8a85ce78ef2270d700984f";
 export declare const HERMES_PLUGIN_NAME = "tinyfish";
@@ -7,3 +8,27 @@ export declare function installHermesPlugin(home: string, apiKey: string, { verb
 export declare function setHermesWebBackends(home: string): void;
 /** Ours-only unsets: a user-chosen backend value survives the uninstall. */
 export declare function clearHermesWebBackends(home: string): void;
+declare const hermesPluginStatusSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    api_key_configured: z.ZodBoolean;
+    api_key_env_var: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    plugin_version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    provider_available: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    web_backend_configured: z.ZodBoolean;
+}, z.core.$loose>;
+export type HermesPluginStatus = z.infer<typeof hermesPluginStatusSchema>;
+export type HermesPluginProbe = {
+    state: 'not_installed';
+} | {
+    state: 'unreachable';
+} | {
+    state: 'unparseable';
+} | {
+    state: 'ok';
+    status: HermesPluginStatus;
+};
+/** `status --json` always exits 0; a non-zero exit means the subcommand is absent. */
+export declare function readHermesPluginStatus(home: string): HermesPluginProbe;
+/** Fallback verdict input when the plugin CLI cannot answer. */
+export declare function hermesWebBackendsOurs(home: string): boolean;
+export {};

package/dist/lib/hermes-plugin.js

@@ -3,6 +3,7 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { pathToFileURL } from 'node:url';
 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';
@@ -117,3 +118,40 @@ export function clearHermesWebBackends(home) {
             configWrite(home, ['unset', key]);
     }
 }
+const hermesPluginStatusSchema = z.looseObject({
+    ok: z.boolean(),
+    api_key_configured: z.boolean(),
+    api_key_env_var: z.string().nullish(),
+    plugin_version: z.string().nullish(),
+    provider_available: z.boolean().nullish(),
+    web_backend_configured: z.boolean(),
+});
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** `status --json` always exits 0; a non-zero exit means the subcommand is absent. */
+export function readHermesPluginStatus(home) {
+    const result = spawn.sync('hermes', ['tinyfish', 'status', '--json'], {
+        encoding: 'utf8',
+        maxBuffer: STEP_MAX_BUFFER,
+        timeout: HARNESS_PROBE_TIMEOUT_MS,
+        env: { ...process.env, HERMES_HOME: home, FORCE_COLOR: '0', NO_COLOR: '1' },
+    });
+    // A timeout also lands in result.error, where "not installed" would be a lie.
+    if (result.error) {
+        return commandNotFound(result.error) ? { state: 'not_installed' } : { state: 'unreachable' };
+    }
+    if (result.status !== 0)
+        return { state: 'not_installed' };
+    const parsed = hermesPluginStatusSchema.safeParse(parseJson(String(result.stdout ?? '')));
+    return parsed.success ? { state: 'ok', status: parsed.data } : { state: 'unparseable' };
+}
+/** Fallback verdict input when the plugin CLI cannot answer. */
+export function hermesWebBackendsOurs(home) {
+    return HERMES_OWNED_BACKEND_KEYS.some((key) => configGet(home, key) === 'tinyfish');
+}

package/package.json

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