@jackwener/opencli 1.7.8 → 1.7.10

package/dist/src/registry.d.ts

@@ -25,17 +25,17 @@ export interface RequiredEnv {
     help?: string;
 }
 export type CommandArgs = Record<string, any>;
-export interface CliCommand {
+export type BrowserCommandFunc = (page: IPage, kwargs: CommandArgs, debug?: boolean) => Promise<unknown>;
+export type NonBrowserCommandFunc = (kwargs: CommandArgs, debug?: boolean) => Promise<unknown>;
+interface BaseCliCommand {
     site: string;
     name: string;
     aliases?: string[];
     description: string;
     domain?: string;
     strategy?: Strategy;
-    browser?: boolean;
     args: Arg[];
     columns?: string[];
-    func?: (page: IPage, kwargs: CommandArgs, debug?: boolean) => Promise<unknown>;
     pipeline?: Record<string, unknown>[];
     timeoutSeconds?: number;
     /** Origin of this command: 'yaml', 'ts', or plugin name. */
@@ -66,22 +66,53 @@ export interface CliCommand {
     /** Override the default CLI output format when the user does not pass -f/--format. */
     defaultFormat?: 'table' | 'plain' | 'json' | 'yaml' | 'yml' | 'md' | 'markdown' | 'csv';
 }
+export interface BrowserCliCommand extends BaseCliCommand {
+    /** Browser commands receive an IPage. Omitted means true after normalization. */
+    browser?: true;
+    func?: BrowserCommandFunc;
+}
+export interface NonBrowserCliCommand extends BaseCliCommand {
+    /** Non-browser commands do not receive a page argument. */
+    browser: false;
+    func?: NonBrowserCommandFunc;
+}
+export type CliCommand = BrowserCliCommand | NonBrowserCliCommand;
+type RawCliCommand = BaseCliCommand & {
+    browser?: boolean;
+    func?: BrowserCommandFunc | NonBrowserCommandFunc;
+};
 /** Internal extension for lazy-loaded TS modules (not exposed in public API) */
-export interface InternalCliCommand extends CliCommand {
+export type InternalCliCommand = CliCommand & {
     _lazy?: boolean;
     _modulePath?: string;
-}
-export interface CliOptions extends Partial<Omit<CliCommand, 'args' | 'description'>> {
+};
+type RequiredCliOptions = {
     site: string;
     name: string;
     description?: string;
     args?: Arg[];
-}
+};
+type BrowserStrategy = Exclude<Strategy, Strategy.PUBLIC | Strategy.LOCAL>;
+type BrowserCliOptions = Partial<Omit<BrowserCliCommand, 'args' | 'description' | 'browser' | 'strategy'>> & RequiredCliOptions & ({
+    browser: true;
+    strategy?: Strategy;
+} | {
+    browser?: true;
+    strategy?: BrowserStrategy;
+});
+type NonBrowserCliOptions = Partial<Omit<NonBrowserCliCommand, 'args' | 'description'>> & RequiredCliOptions & ({
+    browser: false;
+} | {
+    strategy: Strategy.PUBLIC | Strategy.LOCAL;
+    browser?: false;
+});
+export type CliOptions = BrowserCliOptions | NonBrowserCliOptions;
 declare global {
     var __opencli_registry__: Map<string, CliCommand> | undefined;
 }
 export declare function cli(opts: CliOptions): CliCommand;
 export declare function getRegistry(): Map<string, CliCommand>;
-export declare function fullName(cmd: CliCommand): string;
+export declare function fullName(cmd: Pick<BaseCliCommand, 'site' | 'name'>): string;
 export declare function strategyLabel(cmd: CliCommand): string;
-export declare function registerCommand(cmd: CliCommand): void;
+export declare function registerCommand(cmd: RawCliCommand): void;
+export {};

package/dist/src/registry.js

@@ -72,7 +72,9 @@ function normalizeCommand(cmd) {
             navigateBefore = true;
         }
     }
-    return { ...cmd, strategy, browser, navigateBefore };
+    return browser
+        ? { ...cmd, strategy, browser: true, navigateBefore }
+        : { ...cmd, strategy, browser: false, navigateBefore };
 }
 export function registerCommand(cmd) {
     const normalized = normalizeCommand(cmd);

package/dist/src/runtime-detect.d.ts

@@ -6,6 +6,7 @@
  * (e.g. logging, diagnostics) without littering runtime sniffing everywhere.
  */
 export type Runtime = 'bun' | 'node';
+export declare const MIN_SUPPORTED_NODE_MAJOR = 21;
 /**
  * Detect the current JavaScript runtime.
  */
@@ -19,3 +20,12 @@ export declare function getRuntimeVersion(): string;
  * Return a combined label like "node v22.13.0" or "bun 1.1.42".
  */
 export declare function getRuntimeLabel(): string;
+/**
+ * Parse a Node.js version string like "v22.13.0" and return its major version.
+ * Returns null for non-Node or malformed inputs.
+ */
+export declare function parseNodeMajor(version: string): number | null;
+/**
+ * Whether the given Node.js version satisfies the current minimum support policy.
+ */
+export declare function isSupportedNodeVersion(version?: string): boolean;

package/dist/src/runtime-detect.js

@@ -5,6 +5,7 @@
  * This module centralises the check so other code can adapt behaviour
  * (e.g. logging, diagnostics) without littering runtime sniffing everywhere.
  */
+export const MIN_SUPPORTED_NODE_MAJOR = 21;
 /**
  * Detect the current JavaScript runtime.
  */
@@ -26,3 +27,21 @@ export function getRuntimeVersion() {
 export function getRuntimeLabel() {
     return `${detectRuntime()} ${getRuntimeVersion()}`;
 }
+/**
+ * Parse a Node.js version string like "v22.13.0" and return its major version.
+ * Returns null for non-Node or malformed inputs.
+ */
+export function parseNodeMajor(version) {
+    const match = /^v?(\d+)\./.exec(String(version).trim());
+    if (!match)
+        return null;
+    const major = Number(match[1]);
+    return Number.isInteger(major) ? major : null;
+}
+/**
+ * Whether the given Node.js version satisfies the current minimum support policy.
+ */
+export function isSupportedNodeVersion(version = process.version) {
+    const major = parseNodeMajor(version);
+    return major !== null && major >= MIN_SUPPORTED_NODE_MAJOR;
+}

package/dist/src/runtime-detect.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { detectRuntime, getRuntimeVersion, getRuntimeLabel } from './runtime-detect.js';
+import { detectRuntime, getRuntimeVersion, getRuntimeLabel, parseNodeMajor, isSupportedNodeVersion, MIN_SUPPORTED_NODE_MAJOR } from './runtime-detect.js';
 describe('runtime-detect', () => {
     it('detectRuntime returns a valid runtime string', () => {
         const rt = detectRuntime();
@@ -24,4 +24,15 @@ describe('runtime-detect', () => {
             expect(rt).toBe('node');
         }
     });
+    it('parses Node major versions from standard version strings', () => {
+        expect(parseNodeMajor('v21.0.0')).toBe(21);
+        expect(parseNodeMajor('22.13.1')).toBe(22);
+        expect(parseNodeMajor('bun-1.2.0')).toBeNull();
+    });
+    it('checks the current minimum supported Node major version', () => {
+        expect(MIN_SUPPORTED_NODE_MAJOR).toBe(21);
+        expect(isSupportedNodeVersion('v20.18.0')).toBe(false);
+        expect(isSupportedNodeVersion('v21.0.0')).toBe(true);
+        expect(isSupportedNodeVersion('v25.0.0')).toBe(true);
+    });
 });

package/dist/src/runtime.d.ts

@@ -27,10 +27,12 @@ export interface IBrowserFactory {
         timeout?: number;
         workspace?: string;
         cdpEndpoint?: string;
+        contextId?: string;
     }): Promise<IPage>;
     close(): Promise<void>;
 }
 export declare function browserSession<T>(BrowserFactory: new () => IBrowserFactory, fn: (page: IPage) => Promise<T>, opts?: {
     workspace?: string;
     cdpEndpoint?: string;
+    contextId?: string;
 }): Promise<T>;

package/dist/src/runtime.js

@@ -53,6 +53,7 @@ export async function browserSession(BrowserFactory, fn, opts = {}) {
             timeout: DEFAULT_BROWSER_CONNECT_TIMEOUT,
             workspace: opts.workspace,
             cdpEndpoint: opts.cdpEndpoint,
+            contextId: opts.contextId,
         });
         return await fn(page);
     }

package/dist/src/types.d.ts

@@ -33,19 +33,41 @@ export interface ScreenshotOptions {
     fullPage?: boolean;
     path?: string;
 }
+export interface FetchJsonOptions {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    timeoutMs?: number;
+}
 export interface BrowserSessionInfo {
     workspace?: string;
     connected?: boolean;
+    windowId?: number;
+    preferredTabId?: number | null;
+    owned?: boolean;
+    ownership?: 'owned' | 'borrowed';
+    lifecycle?: 'ephemeral' | 'persistent' | 'pinned';
+    surface?: 'dedicated-container' | 'borrowed-user-tab';
+    contextId?: string;
+    tabCount?: number;
+    idleMsRemaining?: number | null;
     [key: string]: unknown;
 }
 export interface IPage {
     goto(url: string, options?: {
         waitUntil?: 'load' | 'none';
         settleMs?: number;
+        allowBoundNavigation?: boolean;
     }): Promise<void>;
     evaluate(js: string): Promise<any>;
     /** Safely evaluate JS with pre-serialized arguments — prevents injection. */
     evaluateWithArgs?(js: string, args: Record<string, unknown>): Promise<any>;
+    /**
+     * Fetch JSON from inside the browser context, carrying the page's cookies.
+     * This is intentionally narrow: browser-context JSON fetch, not a generic
+     * HTTP client.
+     */
+    fetchJson(url: string, opts?: FetchJsonOptions): Promise<unknown>;
     getCookies(opts?: {
         domain?: string;
         url?: string;

package/dist/src/update-check.d.ts

@@ -7,7 +7,20 @@
  * - Check interval: 24 hours
  * - Notice appears AFTER command output, not before (same as npm/gh/yarn)
  * - Never delays or blocks the CLI command
+ *
+ * Cache is shared between the CLI process (writes latestVersion / latestExtensionVersion
+ * via background fetch) and the daemon process (writes currentExtensionVersion /
+ * extensionLastSeenAt via `recordExtensionVersion` on each hello). Writes use a
+ * read-merge-write pattern so neither side clobbers the other.
  */
+declare const EXTENSION_STALE_MS: number;
+interface UpdateCache {
+    lastCheck?: number;
+    latestVersion?: string;
+    latestExtensionVersion?: string;
+    currentExtensionVersion?: string;
+    extensionLastSeenAt?: number;
+}
 interface GitHubReleaseAsset {
     name: string;
 }
@@ -15,6 +28,17 @@ interface GitHubRelease {
     tag_name: string;
     assets?: GitHubReleaseAsset[];
 }
+interface NoticeInputs {
+    cliVersion: string;
+    cache: UpdateCache | null;
+    now: number;
+}
+interface NoticeLines {
+    cli?: string;
+    extension?: string;
+}
+/** Pure function: derive notice text from cache state. Exported for tests. */
+declare function buildUpdateNotices({ cliVersion, cache, now }: NoticeInputs): NoticeLines;
 /**
  * Register a process exit hook that prints an update notice if a newer
  * version was found on the last background check.
@@ -28,9 +52,15 @@ declare function extractLatestExtensionVersionFromReleases(releases: GitHubRelea
  * Fully non-blocking — never awaited.
  */
 export declare function checkForUpdateBackground(): void;
+/**
+ * Stash the current extension version into the shared cache. Called by the
+ * daemon on each hello handshake. Lets the next CLI process compare against
+ * the latest known release and print an exit notice without any extra I/O.
+ */
+export declare function recordExtensionVersion(version: string): void;
 /**
  * Get the cached latest extension version (if available).
  * Used by `opencli doctor` to report extension updates.
  */
 export declare function getCachedLatestExtensionVersion(): string | undefined;
-export { extractLatestExtensionVersionFromReleases as _extractLatestExtensionVersionFromReleases, };
+export { extractLatestExtensionVersionFromReleases as _extractLatestExtensionVersionFromReleases, buildUpdateNotices as _buildUpdateNotices, EXTENSION_STALE_MS as _EXTENSION_STALE_MS, };

package/dist/src/update-check.js

@@ -7,6 +7,11 @@
  * - Check interval: 24 hours
  * - Notice appears AFTER command output, not before (same as npm/gh/yarn)
  * - Never delays or blocks the CLI command
+ *
+ * Cache is shared between the CLI process (writes latestVersion / latestExtensionVersion
+ * via background fetch) and the daemon process (writes currentExtensionVersion /
+ * extensionLastSeenAt via `recordExtensionVersion` on each hello). Writes use a
+ * read-merge-write pattern so neither side clobbers the other.
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -16,24 +21,25 @@ import { PKG_VERSION } from './version.js';
 const CACHE_DIR = path.join(os.homedir(), '.opencli');
 const CACHE_FILE = path.join(CACHE_DIR, 'update-check.json');
 const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24h
+const EXTENSION_STALE_MS = 7 * 24 * 60 * 60 * 1000; // 7d
 const NPM_REGISTRY_URL = 'https://registry.npmjs.org/@jackwener/opencli/latest';
 const GITHUB_RELEASES_URL = 'https://api.github.com/repos/jackwener/OpenCLI/releases?per_page=20';
-// Read cache once at module load — shared by both exported functions
-const _cache = (() => {
+function readCacheSync() {
     try {
         return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8'));
     }
     catch {
         return null;
     }
-})();
-function writeCache(latestVersion, latestExtensionVersion) {
+}
+// Read cache once at module load — shared by both exported functions
+const _cache = readCacheSync();
+function writeCacheMerge(updates) {
     try {
         fs.mkdirSync(CACHE_DIR, { recursive: true });
-        const data = { lastCheck: Date.now(), latestVersion };
-        if (latestExtensionVersion)
-            data.latestExtensionVersion = latestExtensionVersion;
-        fs.writeFileSync(CACHE_FILE, JSON.stringify(data), 'utf-8');
+        const existing = readCacheSync() ?? {};
+        const merged = { ...existing, ...updates };
+        fs.writeFileSync(CACHE_FILE, JSON.stringify(merged), 'utf-8');
     }
     catch {
         // Best-effort; never fail
@@ -57,6 +63,28 @@ function isNewer(a, b) {
 function isCI() {
     return !!(process.env.CI || process.env.CONTINUOUS_INTEGRATION);
 }
+/** Pure function: derive notice text from cache state. Exported for tests. */
+function buildUpdateNotices({ cliVersion, cache, now }) {
+    if (!cache)
+        return {};
+    const lines = {};
+    if (cache.latestVersion && isNewer(cache.latestVersion, cliVersion)) {
+        lines.cli =
+            styleText('yellow', `\n  Update available: v${cliVersion} → v${cache.latestVersion}\n`) +
+                styleText('dim', `  Run: npm install -g @jackwener/opencli\n`);
+    }
+    const { currentExtensionVersion, latestExtensionVersion, extensionLastSeenAt } = cache;
+    if (currentExtensionVersion &&
+        latestExtensionVersion &&
+        extensionLastSeenAt &&
+        now - extensionLastSeenAt < EXTENSION_STALE_MS &&
+        isNewer(latestExtensionVersion, currentExtensionVersion)) {
+        lines.extension =
+            styleText('yellow', `\n  Extension update available: v${currentExtensionVersion} → v${latestExtensionVersion}\n`) +
+                styleText('dim', `  Download: https://github.com/jackwener/opencli/releases\n`);
+    }
+    return lines;
+}
 /**
  * Register a process exit hook that prints an update notice if a newer
  * version was found on the last background check.
@@ -71,13 +99,15 @@ export function registerUpdateNoticeOnExit() {
     process.on('exit', (code) => {
         if (code !== 0)
             return; // Don't show update notice on error exit
-        if (!_cache)
-            return;
-        if (!isNewer(_cache.latestVersion, PKG_VERSION))
+        const { cli, extension } = buildUpdateNotices({
+            cliVersion: PKG_VERSION,
+            cache: _cache,
+            now: Date.now(),
+        });
+        if (!cli && !extension)
             return;
         try {
-            process.stderr.write(styleText('yellow', `\n  Update available: v${PKG_VERSION} → v${_cache.latestVersion}\n`) +
-                styleText('dim', `  Run: npm install -g @jackwener/opencli\n\n`));
+            process.stderr.write(`${cli ?? ''}${extension ?? ''}\n`);
         }
         catch {
             // Ignore broken pipe (stderr closed before process exits)
@@ -123,7 +153,7 @@ async function fetchLatestExtensionVersion() {
 export function checkForUpdateBackground() {
     if (isCI())
         return;
-    if (_cache && Date.now() - _cache.lastCheck < CHECK_INTERVAL_MS)
+    if (_cache?.lastCheck && Date.now() - _cache.lastCheck < CHECK_INTERVAL_MS)
         return;
     void (async () => {
         try {
@@ -139,7 +169,10 @@ export function checkForUpdateBackground() {
             const data = await res.json();
             if (typeof data.version === 'string') {
                 const extVersion = await fetchLatestExtensionVersion();
-                writeCache(data.version, extVersion);
+                const updates = { lastCheck: Date.now(), latestVersion: data.version };
+                if (extVersion)
+                    updates.latestExtensionVersion = extVersion;
+                writeCacheMerge(updates);
             }
         }
         catch {
@@ -147,6 +180,19 @@ export function checkForUpdateBackground() {
         }
     })();
 }
+/**
+ * Stash the current extension version into the shared cache. Called by the
+ * daemon on each hello handshake. Lets the next CLI process compare against
+ * the latest known release and print an exit notice without any extra I/O.
+ */
+export function recordExtensionVersion(version) {
+    if (typeof version !== 'string' || !version.trim())
+        return;
+    writeCacheMerge({
+        currentExtensionVersion: version.trim(),
+        extensionLastSeenAt: Date.now(),
+    });
+}
 /**
  * Get the cached latest extension version (if available).
  * Used by `opencli doctor` to report extension updates.
@@ -154,4 +200,4 @@ export function checkForUpdateBackground() {
 export function getCachedLatestExtensionVersion() {
     return _cache?.latestExtensionVersion;
 }
-export { extractLatestExtensionVersionFromReleases as _extractLatestExtensionVersionFromReleases, };
+export { extractLatestExtensionVersionFromReleases as _extractLatestExtensionVersionFromReleases, buildUpdateNotices as _buildUpdateNotices, EXTENSION_STALE_MS as _EXTENSION_STALE_MS, };

package/dist/src/update-check.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { _extractLatestExtensionVersionFromReleases as extractLatestExtensionVersionFromReleases } from './update-check.js';
+import { _extractLatestExtensionVersionFromReleases as extractLatestExtensionVersionFromReleases, _buildUpdateNotices as buildUpdateNotices, _EXTENSION_STALE_MS as EXTENSION_STALE_MS, } from './update-check.js';
 describe('extractLatestExtensionVersionFromReleases', () => {
     it('reads the extension version from a versioned asset on a normal CLI release', () => {
         expect(extractLatestExtensionVersionFromReleases([
@@ -29,3 +29,88 @@ describe('extractLatestExtensionVersionFromReleases', () => {
         ])).toBeUndefined();
     });
 });
+describe('buildUpdateNotices', () => {
+    const now = 1_700_000_000_000;
+    it('returns nothing when cache is empty', () => {
+        expect(buildUpdateNotices({ cliVersion: '1.0.0', cache: null, now })).toEqual({});
+    });
+    it('emits a CLI notice when registry version is newer', () => {
+        const lines = buildUpdateNotices({
+            cliVersion: '1.0.0',
+            cache: { lastCheck: now, latestVersion: '1.0.1' },
+            now,
+        });
+        expect(lines.cli).toContain('v1.0.0 → v1.0.1');
+        expect(lines.extension).toBeUndefined();
+    });
+    it('emits an extension notice when current ext is older and cache is fresh', () => {
+        const lines = buildUpdateNotices({
+            cliVersion: '1.0.0',
+            cache: {
+                lastCheck: now,
+                latestVersion: '1.0.0',
+                latestExtensionVersion: '2.1.0',
+                currentExtensionVersion: '2.0.0',
+                extensionLastSeenAt: now - 60_000,
+            },
+            now,
+        });
+        expect(lines.cli).toBeUndefined();
+        expect(lines.extension).toContain('v2.0.0 → v2.1.0');
+    });
+    it('skips the extension notice when lastSeenAt is older than the stale window', () => {
+        const lines = buildUpdateNotices({
+            cliVersion: '1.0.0',
+            cache: {
+                lastCheck: now,
+                latestVersion: '1.0.0',
+                latestExtensionVersion: '2.1.0',
+                currentExtensionVersion: '2.0.0',
+                extensionLastSeenAt: now - EXTENSION_STALE_MS - 1,
+            },
+            now,
+        });
+        expect(lines.extension).toBeUndefined();
+    });
+    it('skips the extension notice when current and latest are equal', () => {
+        const lines = buildUpdateNotices({
+            cliVersion: '1.0.0',
+            cache: {
+                lastCheck: now,
+                latestVersion: '1.0.0',
+                latestExtensionVersion: '2.0.0',
+                currentExtensionVersion: '2.0.0',
+                extensionLastSeenAt: now,
+            },
+            now,
+        });
+        expect(lines.extension).toBeUndefined();
+    });
+    it('does not throw when cache has only daemon-written fields and no latestVersion', () => {
+        const lines = buildUpdateNotices({
+            cliVersion: '1.0.0',
+            cache: {
+                currentExtensionVersion: '2.0.0',
+                extensionLastSeenAt: now,
+            },
+            now,
+        });
+        expect(lines.cli).toBeUndefined();
+        expect(lines.extension).toBeUndefined();
+    });
+    it('emits both notices when both are out of date', () => {
+        const lines = buildUpdateNotices({
+            cliVersion: '1.0.0',
+            cache: {
+                lastCheck: now,
+                latestVersion: '1.1.0',
+                latestExtensionVersion: '2.1.0',
+                currentExtensionVersion: '2.0.0',
+                extensionLastSeenAt: now,
+            },
+            now,
+        });
+        expect(lines.cli).toContain('v1.0.0 → v1.1.0');
+        expect(lines.extension).toContain('v2.0.0 → v2.1.0');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "1.7.8",
+  "version": "1.7.10",
   "publishConfig": {
     "access": "public"
   },

package/dist/src/diagnostic.d.ts

@@ -1,63 +0,0 @@
-/**
- * Structured diagnostic output for AI-driven adapter repair.
- *
- * When OPENCLI_DIAGNOSTIC=1, failed commands emit a JSON RepairContext to stderr
- * containing the error, adapter source, and browser state (DOM snapshot, network
- * requests, console errors). AI Agents consume this to diagnose and fix adapters.
- *
- * Safety boundaries:
- * - Sensitive headers/cookies are redacted before emission
- * - Individual fields are capped to prevent unbounded output
- * - Network response bodies from authenticated requests are stripped
- * - Total output is capped to MAX_DIAGNOSTIC_BYTES
- */
-import type { IPage } from './types.js';
-import type { InternalCliCommand } from './registry.js';
-/** Maximum bytes for the entire diagnostic JSON output. */
-export declare const MAX_DIAGNOSTIC_BYTES: number;
-export interface RepairContext {
-    error: {
-        code: string;
-        message: string;
-        hint?: string;
-        stack?: string;
-    };
-    adapter: {
-        site: string;
-        command: string;
-        sourcePath?: string;
-        source?: string;
-    };
-    page?: {
-        url: string;
-        snapshot: string;
-        networkRequests: unknown[];
-        capturedPayloads?: unknown[];
-        consoleErrors: unknown[];
-    };
-    timestamp: string;
-}
-/** Truncate a string to maxLen, appending a truncation marker. */
-export declare function truncate(str: string, maxLen: number): string;
-/** Redact sensitive query parameters from a URL. */
-export declare function redactUrl(url: string): string;
-/** Redact inline secrets from free-text strings (error messages, stack traces, console output, DOM). */
-export declare function redactText(text: string): string;
-/**
- * Resolve the editable source file path for an adapter.
- *
- * Priority:
- * 1. cmd.source (set for FS-scanned JS and manifest lazy-loaded JS)
- * 2. cmd._modulePath (set for manifest lazy-loaded JS)
- *
- * Skip manifest: prefixed pseudo-paths (YAML commands inlined in manifest).
- */
-export declare function resolveAdapterSourcePath(cmd: InternalCliCommand): string | undefined;
-/** Whether diagnostic mode is enabled. */
-export declare function isDiagnosticEnabled(): boolean;
-/** Build a RepairContext from an error, command metadata, and optional page state. */
-export declare function buildRepairContext(err: unknown, cmd: InternalCliCommand, pageState?: RepairContext['page']): RepairContext;
-/** Collect full diagnostic context including page state (with timeout). */
-export declare function collectDiagnostic(err: unknown, cmd: InternalCliCommand, page: IPage | null): Promise<RepairContext>;
-/** Emit diagnostic JSON to stderr, enforcing total size cap. */
-export declare function emitDiagnostic(ctx: RepairContext): void;