@tiny-fish/cli 0.38.1-next.306 → 0.38.1-next.307

package/dist/commands/doctor.js

@@ -1,282 +1,15 @@
-import { apiKeyStatus } from '../lib/auth.js';
 import { CLI_VERSION } from '../lib/constants.js';
+import { checkAuthCall, checkCliVersion, checkConnectivity, checkCredential, checkHermesPlugin, checkRegistration, provesHarnessReach, verifyHarnessKey, } from '../lib/doctor-checks.js';
 import { DOCTOR_COULD_NOT_RUN, DOCTOR_INVALID_INPUT, DOCTOR_SCHEMA_VERSION, doctorReportSchema, exitCodeFor, renderPretty, verdictFor, } from '../lib/doctor-report.js';
 import { applyRepairs, repairsFor } from '../lib/doctor-repairs.js';
 import { couldNotRunPayload, telemetryKey, telemetryPayload } from '../lib/doctor-telemetry.js';
-import { ALL_HARNESSES, AuthMode, Registered } from '../lib/harness-detect.js';
-import { boundedVersion, err, errLine, out, outLine } from '../lib/output.js';
+import { ALL_HARNESSES } from '../lib/harness-detect.js';
+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 { HERMES_PLUGIN_VERSION, hermesWebBackendsOurs, readHermesPluginStatus, } from '../lib/hermes-plugin.js';
-import { DEFAULT_MCP_URL, endpointOf, isDefaultEndpoint } from '../lib/mcp-endpoint.js';
-// A green auth mode with a red auth call proves nothing, so the call's verdict gates the claim.
-function provesHarnessReach(status, keyAuth, healthOk, mcpUrl) {
-    // An endpoint doctor could not reach proves nothing about a harness pointed at it.
-    if (!healthOk)
-        return false;
-    if (pointsElsewhere(status.registeredUrl, mcpUrl))
-        return false;
-    if (status.registered !== Registered.Yes)
-        return false;
-    if (status.connected === true)
-        return true;
-    // Symmetric with registrationVerdict: a harness saying it cannot reach us is decisive.
-    if (status.connected === false)
-        return false;
-    // The harness's own key must have verified; the CLI's verdict says nothing about it.
-    return status.authMode === AuthMode.ApiKey && keyAuth?.ok === true;
-}
-// Reports the version, never judges it: staleness is the server's call via X-TF-Notice.
-function checkCliVersion() {
-    return {
-        id: 'cli-version',
-        title: `CLI ${CLI_VERSION}`,
-        status: 'pass',
-        detail: `${CLI_VERSION}; the server reports staleness via X-TF-Notice`,
-        harness: null,
-        scope: 'info',
-    };
-}
-async function checkConnectivity(mcpUrl) {
-    const health = await verifyMcpHealth(mcpUrl);
-    return {
-        id: 'mcp-connectivity',
-        title: 'MCP endpoint reachable',
-        status: health.ok ? 'pass' : 'fail',
-        detail: health.ok ? mcpUrl : (health.code ?? 'the endpoint is unreachable'),
-        // Harness-scoped: the CLI's own reachability is `cli-auth-call`'s claim.
-        harness: null,
-        scope: 'harness',
-    };
-}
-/** Host alone let `/wrong-path` and plain `http://` through and claim the harness reaches us. */
-function pointsElsewhere(registeredUrl, mcpUrl) {
-    if (!registeredUrl)
-        return undefined;
-    try {
-        const registered = endpointOf(registeredUrl);
-        return registered === endpointOf(mcpUrl) ? undefined : registered;
-    }
-    catch {
-        // An endpoint that will not parse cannot be shown to match, so it does not.
-        return 'an unparseable endpoint';
-    }
-}
-/** Either it reads the CLI's key at runtime or it holds a copy: the CLI's own verdict covers both. */
-function runsOnCliCredential(status) {
-    return status.usesCliKey === true || status.keyMatchesCliKey === true;
-}
-function keyedVerdict(status, keyAuth, cliKeyMissing) {
-    if (!keyAuth) {
-        // Its auth is the CLI credential; a warn would exit 0.
-        if (runsOnCliCredential(status)) {
-            return cliKeyMissing
-                ? {
-                    status: 'fail',
-                    detail: 'registered, but it runs on the CLI credential, which is missing or unusable',
-                }
-                : // Reachable with a key only when `--url` skipped verification.
-                    {
-                        status: 'warn',
-                        detail: 'registered, but its CLI credential was not verified against this endpoint',
-                    };
-        }
-        // A bare warn beside exit 0 reads as a pass.
-        const because = status.keyReason ?? 'the CLI cannot verify a key it does not hold';
-        return { status: 'warn', detail: `registered, but ${because}, so its reach is unproven` };
-    }
-    if (keyAuth.ok) {
-        return {
-            status: 'pass',
-            detail: 'registered, auth mode api-key (key verified against the TinyFish API)',
-        };
-    }
-    if (keyAuth.status === 401) {
-        return { status: 'fail', detail: 'registered, but TinyFish rejects its API key' };
-    }
-    // Only 401 blames the key; connect would loop on the rest.
-    if (keyAuth.status === 403) {
-        return { status: 'warn', detail: 'registered, but its API key is not allowed to list runs' };
-    }
-    return { status: 'warn', detail: 'registered, key could not be verified' };
-}
-function registrationVerdict(status, mcpUrl, keyAuth, cliKeyMissing) {
-    if (!status.detected)
-        return { status: 'skip', detail: 'harness not installed' };
-    if (status.registered === Registered.Unknown) {
-        return { status: 'warn', detail: status.reason ?? 'could not determine registration' };
-    }
-    if (status.registered === Registered.Yes) {
-        // A `tinyfish` entry aimed at a dev server is registered and still cannot reach TinyFish.
-        const elsewhere = pointsElsewhere(status.registeredUrl, mcpUrl);
-        if (elsewhere) {
-            return {
-                status: 'fail',
-                detail: `registered, but points at ${elsewhere} rather than ${endpointOf(mcpUrl)}`,
-            };
-        }
-        // Ordered before the key check: the harness's own verdict wins.
-        if (status.connected === false) {
-            return {
-                status: 'warn',
-                detail: 'registered, but the harness reports it cannot reach TinyFish; sign in again there',
-            };
-        }
-        // Symmetric with provesHarnessReach, which already reads a handshake as decisive.
-        if (status.connected === true) {
-            return { status: 'pass', detail: 'registered, and the harness reports it reaches TinyFish' };
-        }
-        // Widening past api-key would warn every healthy oauth install.
-        if (status.authMode === AuthMode.ApiKey)
-            return keyedVerdict(status, keyAuth, cliKeyMissing);
-        // Recorded, not verified: it never feeds provesHarnessReach.
-        if (status.recordedAuthMode) {
-            return {
-                status: 'pass',
-                detail: `registered, auth mode ${status.recordedAuthMode} ` +
-                    '(recorded at connect; this harness does not report its headers)',
-            };
-        }
-        // A probe that had to explain itself to reach `yes` is the only thing that explains `unknown`.
-        const because = status.reason ? ` (${status.reason})` : '';
-        return { status: 'pass', detail: `registered, auth mode ${status.authMode}${because}` };
-    }
-    // Connected once and now absent is a broken install; never connected is just not set up.
-    return status.connectedBefore
-        ? { status: 'fail', detail: 'connected previously but TinyFish is no longer registered' }
-        : { status: 'warn', detail: 'installed but TinyFish was never connected' };
-}
-function checkRegistration(status, mcpUrl, keyAuth, cliKeyMissing) {
-    return {
-        id: 'harness-registration',
-        title: `${status.harness} registration`,
-        harness: status.harness,
-        scope: 'harness',
-        ...registrationVerdict(status, mcpUrl, keyAuth, cliKeyMissing),
-    };
-}
-function checkCredential() {
-    const resolved = apiKeyStatus();
-    const check = {
-        id: 'cli-credential',
-        title: 'CLI credential',
-        status: 'key' in resolved ? 'pass' : 'fail',
-        detail: 'key' in resolved ? `key present from ${resolved.source}` : resolved.error,
-        harness: null,
-        scope: 'cli',
-    };
-    return 'key' in resolved ? { check, key: resolved.key } : { check };
-}
-function checkAuthCall(auth) {
-    if (!auth) {
-        return {
-            id: 'cli-auth-call',
-            title: 'Authenticated call',
-            status: 'skip',
-            detail: 'no credential to test',
-            harness: null,
-            scope: 'cli',
-        };
-    }
-    return {
-        id: 'cli-auth-call',
-        title: 'Authenticated call',
-        status: auth.ok ? 'pass' : 'fail',
-        detail: auth.ok ? 'listRuns succeeded' : (auth.code ?? 'the authenticated call failed'),
-        harness: null,
-        scope: 'cli',
-    };
-}
-function verifyHarnessKey(status, cliAuth, mcpUrl) {
-    if (!isDefaultEndpoint(mcpUrl))
-        return undefined;
-    // `pointsElsewhere` already fails; a second reason only misleads.
-    if (pointsElsewhere(status.registeredUrl, mcpUrl))
-        return undefined;
-    // 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),
-        // Machine-supplied, so it is bounded here rather than trusted onward.
-        observedVersion: boundedVersion(probe.status.plugin_version ?? ''),
-    };
-}
-function checkHermesPlugin(status) {
-    const base = {
-        id: 'hermes-plugin',
-        title: 'Hermes web plugin',
-        harness: 'hermes',
-        scope: 'harness',
-    };
-    if (!status.detected) {
-        return { check: { ...base, status: 'skip', detail: 'harness not installed' } };
-    }
-    if (status.registered !== Registered.Yes) {
-        return { check: { ...base, status: 'skip', detail: 'TinyFish is not registered in Hermes' } };
-    }
-    const home = resolveHermesHome();
-    if (!home) {
-        return {
-            check: { ...base, status: 'warn', detail: "could not determine Hermes' home directory" },
-        };
-    }
-    const { observedVersion, ...verdict } = hermesPluginVerdict(home);
-    return { check: { ...base, ...verdict }, observedVersion };
-}
+import { verifyMcpAuth } from '../lib/verify.js';
+import { HERMES_PLUGIN_VERSION } from '../lib/hermes-plugin.js';
+import { DEFAULT_MCP_URL } from '../lib/mcp-endpoint.js';
 /** Skips mean no Hermes; stamping those buries the drift share. */
 function hermesPluginVersions(result) {
     if (!result || result.check.status === 'skip')

package/dist/lib/doctor-checks.d.ts

@@ -0,0 +1,18 @@
+import type { DoctorCheck } from './doctor-report.js';
+import type { RegistrationStatus } from './registration-detect.js';
+import { type VerifyResult } from './verify.js';
+export declare function provesHarnessReach(status: RegistrationStatus, keyAuth: VerifyResult | undefined, healthOk: boolean, mcpUrl: string): boolean;
+export declare function checkCliVersion(): DoctorCheck;
+export declare function checkConnectivity(mcpUrl: string): Promise<DoctorCheck>;
+export declare function checkRegistration(status: RegistrationStatus, mcpUrl: string, keyAuth: VerifyResult | undefined, cliKeyMissing: boolean): DoctorCheck;
+export declare function checkCredential(): {
+    check: DoctorCheck;
+    key?: string;
+};
+export declare function checkAuthCall(auth: VerifyResult | undefined): DoctorCheck;
+export declare function verifyHarnessKey(status: RegistrationStatus, cliAuth: Promise<VerifyResult> | undefined, mcpUrl: string): Promise<VerifyResult> | undefined;
+export interface HermesPluginResult {
+    check: DoctorCheck;
+    observedVersion?: string;
+}
+export declare function checkHermesPlugin(status: RegistrationStatus): HermesPluginResult;

package/dist/lib/doctor-checks.js

@@ -0,0 +1,274 @@
+import { apiKeyStatus } from './auth.js';
+import { CLI_VERSION } from './constants.js';
+import { AuthMode, Registered } from './harness-detect.js';
+import { resolveHermesHome } from './hermes-env.js';
+import { hermesWebBackendsOurs, readHermesPluginStatus, } from './hermes-plugin.js';
+import { endpointOf, isDefaultEndpoint } from './mcp-endpoint.js';
+import { boundedVersion } from './output.js';
+import { verifyMcpHealth } from './verify.js';
+// A green auth mode with a red auth call proves nothing, so the call's verdict gates the claim.
+export function provesHarnessReach(status, keyAuth, healthOk, mcpUrl) {
+    // An endpoint doctor could not reach proves nothing about a harness pointed at it.
+    if (!healthOk)
+        return false;
+    if (pointsElsewhere(status.registeredUrl, mcpUrl))
+        return false;
+    if (status.registered !== Registered.Yes)
+        return false;
+    if (status.connected === true)
+        return true;
+    // Symmetric with registrationVerdict: a harness saying it cannot reach us is decisive.
+    if (status.connected === false)
+        return false;
+    // The harness's own key must have verified; the CLI's verdict says nothing about it.
+    return status.authMode === AuthMode.ApiKey && keyAuth?.ok === true;
+}
+// Reports the version, never judges it: staleness is the server's call via X-TF-Notice.
+export function checkCliVersion() {
+    return {
+        id: 'cli-version',
+        title: `CLI ${CLI_VERSION}`,
+        status: 'pass',
+        detail: `${CLI_VERSION}; the server reports staleness via X-TF-Notice`,
+        harness: null,
+        scope: 'info',
+    };
+}
+export async function checkConnectivity(mcpUrl) {
+    const health = await verifyMcpHealth(mcpUrl);
+    return {
+        id: 'mcp-connectivity',
+        title: 'MCP endpoint reachable',
+        status: health.ok ? 'pass' : 'fail',
+        detail: health.ok ? mcpUrl : (health.code ?? 'the endpoint is unreachable'),
+        // Harness-scoped: the CLI's own reachability is `cli-auth-call`'s claim.
+        harness: null,
+        scope: 'harness',
+    };
+}
+/** Host alone let `/wrong-path` and plain `http://` through and claim the harness reaches us. */
+function pointsElsewhere(registeredUrl, mcpUrl) {
+    if (!registeredUrl)
+        return undefined;
+    try {
+        const registered = endpointOf(registeredUrl);
+        return registered === endpointOf(mcpUrl) ? undefined : registered;
+    }
+    catch {
+        // An endpoint that will not parse cannot be shown to match, so it does not.
+        return 'an unparseable endpoint';
+    }
+}
+/** Either it reads the CLI's key at runtime or it holds a copy: the CLI's own verdict covers both. */
+function runsOnCliCredential(status) {
+    return status.usesCliKey === true || status.keyMatchesCliKey === true;
+}
+function keyedVerdict(status, keyAuth, cliKeyMissing) {
+    if (!keyAuth) {
+        // Its auth is the CLI credential; a warn would exit 0.
+        if (runsOnCliCredential(status)) {
+            return cliKeyMissing
+                ? {
+                    status: 'fail',
+                    detail: 'registered, but it runs on the CLI credential, which is missing or unusable',
+                }
+                : // Reachable with a key only when `--url` skipped verification.
+                    {
+                        status: 'warn',
+                        detail: 'registered, but its CLI credential was not verified against this endpoint',
+                    };
+        }
+        // A bare warn beside exit 0 reads as a pass.
+        const because = status.keyReason ?? 'the CLI cannot verify a key it does not hold';
+        return { status: 'warn', detail: `registered, but ${because}, so its reach is unproven` };
+    }
+    if (keyAuth.ok) {
+        return {
+            status: 'pass',
+            detail: 'registered, auth mode api-key (key verified against the TinyFish API)',
+        };
+    }
+    if (keyAuth.status === 401) {
+        return { status: 'fail', detail: 'registered, but TinyFish rejects its API key' };
+    }
+    // Only 401 blames the key; connect would loop on the rest.
+    if (keyAuth.status === 403) {
+        return { status: 'warn', detail: 'registered, but its API key is not allowed to list runs' };
+    }
+    return { status: 'warn', detail: 'registered, key could not be verified' };
+}
+function registrationVerdict(status, mcpUrl, keyAuth, cliKeyMissing) {
+    if (!status.detected)
+        return { status: 'skip', detail: 'harness not installed' };
+    if (status.registered === Registered.Unknown) {
+        return { status: 'warn', detail: status.reason ?? 'could not determine registration' };
+    }
+    if (status.registered === Registered.Yes) {
+        // A `tinyfish` entry aimed at a dev server is registered and still cannot reach TinyFish.
+        const elsewhere = pointsElsewhere(status.registeredUrl, mcpUrl);
+        if (elsewhere) {
+            return {
+                status: 'fail',
+                detail: `registered, but points at ${elsewhere} rather than ${endpointOf(mcpUrl)}`,
+            };
+        }
+        // Ordered before the key check: the harness's own verdict wins.
+        if (status.connected === false) {
+            return {
+                status: 'warn',
+                detail: 'registered, but the harness reports it cannot reach TinyFish; sign in again there',
+            };
+        }
+        // Symmetric with provesHarnessReach, which already reads a handshake as decisive.
+        if (status.connected === true) {
+            return { status: 'pass', detail: 'registered, and the harness reports it reaches TinyFish' };
+        }
+        // Widening past api-key would warn every healthy oauth install.
+        if (status.authMode === AuthMode.ApiKey)
+            return keyedVerdict(status, keyAuth, cliKeyMissing);
+        // Recorded, not verified: it never feeds provesHarnessReach.
+        if (status.recordedAuthMode) {
+            return {
+                status: 'pass',
+                detail: `registered, auth mode ${status.recordedAuthMode} ` +
+                    '(recorded at connect; this harness does not report its headers)',
+            };
+        }
+        // A probe that had to explain itself to reach `yes` is the only thing that explains `unknown`.
+        const because = status.reason ? ` (${status.reason})` : '';
+        return { status: 'pass', detail: `registered, auth mode ${status.authMode}${because}` };
+    }
+    // Connected once and now absent is a broken install; never connected is just not set up.
+    return status.connectedBefore
+        ? { status: 'fail', detail: 'connected previously but TinyFish is no longer registered' }
+        : { status: 'warn', detail: 'installed but TinyFish was never connected' };
+}
+export function checkRegistration(status, mcpUrl, keyAuth, cliKeyMissing) {
+    return {
+        id: 'harness-registration',
+        title: `${status.harness} registration`,
+        harness: status.harness,
+        scope: 'harness',
+        ...registrationVerdict(status, mcpUrl, keyAuth, cliKeyMissing),
+    };
+}
+export function checkCredential() {
+    const resolved = apiKeyStatus();
+    const check = {
+        id: 'cli-credential',
+        title: 'CLI credential',
+        status: 'key' in resolved ? 'pass' : 'fail',
+        detail: 'key' in resolved ? `key present from ${resolved.source}` : resolved.error,
+        harness: null,
+        scope: 'cli',
+    };
+    return 'key' in resolved ? { check, key: resolved.key } : { check };
+}
+export function checkAuthCall(auth) {
+    if (!auth) {
+        return {
+            id: 'cli-auth-call',
+            title: 'Authenticated call',
+            status: 'skip',
+            detail: 'no credential to test',
+            harness: null,
+            scope: 'cli',
+        };
+    }
+    return {
+        id: 'cli-auth-call',
+        title: 'Authenticated call',
+        status: auth.ok ? 'pass' : 'fail',
+        detail: auth.ok ? 'listRuns succeeded' : (auth.code ?? 'the authenticated call failed'),
+        harness: null,
+        scope: 'cli',
+    };
+}
+export function verifyHarnessKey(status, cliAuth, mcpUrl) {
+    if (!isDefaultEndpoint(mcpUrl))
+        return undefined;
+    // `pointsElsewhere` already fails; a second reason only misleads.
+    if (pointsElsewhere(status.registeredUrl, mcpUrl))
+        return undefined;
+    // 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),
+        // Machine-supplied, so it is bounded here rather than trusted onward.
+        observedVersion: boundedVersion(probe.status.plugin_version ?? ''),
+    };
+}
+export function checkHermesPlugin(status) {
+    const base = {
+        id: 'hermes-plugin',
+        title: 'Hermes web plugin',
+        harness: 'hermes',
+        scope: 'harness',
+    };
+    if (!status.detected) {
+        return { check: { ...base, status: 'skip', detail: 'harness not installed' } };
+    }
+    if (status.registered !== Registered.Yes) {
+        return { check: { ...base, status: 'skip', detail: 'TinyFish is not registered in Hermes' } };
+    }
+    const home = resolveHermesHome();
+    if (!home) {
+        return {
+            check: { ...base, status: 'warn', detail: "could not determine Hermes' home directory" },
+        };
+    }
+    const { observedVersion, ...verdict } = hermesPluginVerdict(home);
+    return { check: { ...base, ...verdict }, observedVersion };
+}

package/package.json

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