@huyuan-ai/cli 1.0.4 → 1.2.0

package/vendor/opencli/dist/clis/zsxq/search.test.js

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '../../registry.js';
+import { getRegistry } from '@jackwener/opencli/registry';
 import './search.js';
 describe('zsxq search command', () => {
     beforeEach(() => {

package/vendor/opencli/dist/clis/zsxq/topic.js

@@ -1,5 +1,5 @@
-import { cli, Strategy } from '../../registry.js';
-import { CliError } from '../../errors.js';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CliError } from '@jackwener/opencli/errors';
 import { browserJsonRequest, ensureZsxqAuth, ensureZsxqPage, fetchFirstJson, getCommentsFromResponse, getTopicFromResponse, getTopicUrl, summarizeComments, toTopicRow, } from './utils.js';
 cli({
     site: 'zsxq',

package/vendor/opencli/dist/clis/zsxq/topic.test.js

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '../../registry.js';
+import { getRegistry } from '@jackwener/opencli/registry';
 import './topic.js';
 describe('zsxq topic command', () => {
     beforeEach(() => {

package/vendor/opencli/dist/clis/zsxq/topics.js

@@ -1,4 +1,4 @@
-import { cli, Strategy } from '../../registry.js';
+import { cli, Strategy } from '@jackwener/opencli/registry';
 import { getActiveGroupId, ensureZsxqAuth, ensureZsxqPage, fetchFirstJson, getTopicsFromResponse, toTopicRow, } from './utils.js';
 cli({
     site: 'zsxq',

package/vendor/opencli/dist/clis/zsxq/topics.test.js

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '../../registry.js';
+import { getRegistry } from '@jackwener/opencli/registry';
 import './topics.js';
 describe('zsxq topics command', () => {
     beforeEach(() => {

package/vendor/opencli/dist/clis/zsxq/utils.d.ts

@@ -1,4 +1,4 @@
-import type { IPage } from '../../types.js';
+import type { IPage } from '@jackwener/opencli/types';
 export interface ZsxqUser {
     user_id?: number;
     name?: string;

package/vendor/opencli/dist/clis/zsxq/utils.js

@@ -1,4 +1,4 @@
-import { ArgumentError, AuthRequiredError, CliError } from '../../errors.js';
+import { ArgumentError, AuthRequiredError, CliError } from '@jackwener/opencli/errors';
 const SITE_DOMAIN = 'wx.zsxq.com';
 const SITE_URL = 'https://wx.zsxq.com';
 function asRecord(value) {

package/vendor/opencli/dist/{build-manifest.js → src/build-manifest.js}

@@ -15,8 +15,8 @@ import yaml from 'js-yaml';
 import { getErrorMessage } from './errors.js';
 import { fullName, getRegistry } from './registry.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const CLIS_DIR = path.resolve(__dirname, 'clis');
-const OUTPUT = path.resolve(__dirname, '..', 'dist', 'cli-manifest.json');
+const CLIS_DIR = path.resolve(__dirname, '..', 'clis');
+const OUTPUT = path.resolve(__dirname, '..', 'cli-manifest.json');
 import { parseYamlArgs } from './yaml-schema.js';
 import { isRecord } from './utils.js';
 const CLI_MODULE_PATTERN = /\bcli\s*\(/;
@@ -200,14 +200,15 @@ async function main() {
     // entry-point loses its executable permission, causing "Permission denied".
     // See: https://github.com/jackwener/opencli/issues/446
     if (process.platform !== 'win32') {
-        const pkgPath = path.resolve(__dirname, '..', 'package.json');
+        const projectRoot = path.resolve(__dirname, '..', '..');
+        const pkgPath = path.resolve(projectRoot, 'package.json');
         try {
             const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
             const bins = typeof pkg.bin === 'string'
                 ? { [pkg.name ?? 'cli']: pkg.bin }
                 : pkg.bin ?? {};
             for (const binPath of Object.values(bins)) {
-                const abs = path.resolve(__dirname, '..', binPath);
+                const abs = path.resolve(projectRoot, binPath);
                 if (fs.existsSync(abs)) {
                     fs.chmodSync(abs, 0o755);
                     console.log(`✅ Restored executable permission: ${binPath}`);

package/vendor/opencli/dist/{cascade.js → src/cascade.js}

@@ -57,6 +57,12 @@ function buildFetchProbeJs(url, opts) {
     }
   `;
 }
+/** Strategy → fetch probe options mapping for strategies that support probing. */
+const PROBE_OPTIONS = {
+    [Strategy.PUBLIC]: {},
+    [Strategy.COOKIE]: { credentials: true },
+    [Strategy.HEADER]: { credentials: true, extractCsrf: true },
+};
 /**
  * Probe an endpoint with a specific strategy.
  * Returns whether the probe succeeded and basic response info.
@@ -64,37 +70,16 @@ function buildFetchProbeJs(url, opts) {
 export async function probeEndpoint(page, url, strategy, _opts = {}) {
     const result = { strategy, success: false };
     try {
-        switch (strategy) {
-            case Strategy.PUBLIC: {
-                const resp = await page.evaluate(buildFetchProbeJs(url, {}));
-                result.statusCode = resp?.status;
-                result.success = resp?.ok && resp?.hasData;
-                result.hasData = resp?.hasData;
-                result.responsePreview = resp?.preview;
-                break;
-            }
-            case Strategy.COOKIE: {
-                const resp = await page.evaluate(buildFetchProbeJs(url, { credentials: true }));
-                result.statusCode = resp?.status;
-                result.success = resp?.ok && resp?.hasData;
-                result.hasData = resp?.hasData;
-                result.responsePreview = resp?.preview;
-                break;
-            }
-            case Strategy.HEADER: {
-                const resp = await page.evaluate(buildFetchProbeJs(url, { credentials: true, extractCsrf: true }));
-                result.statusCode = resp?.status;
-                result.success = resp?.ok && resp?.hasData;
-                result.hasData = resp?.hasData;
-                result.responsePreview = resp?.preview;
-                break;
-            }
-            case Strategy.INTERCEPT:
-            case Strategy.UI:
-                // These require specific implementation per-site
-                result.success = false;
-                result.error = `Strategy ${strategy} requires site-specific implementation`;
-                break;
+        const opts = PROBE_OPTIONS[strategy];
+        if (opts) {
+            const resp = await page.evaluate(buildFetchProbeJs(url, opts));
+            result.statusCode = resp?.status;
+            result.success = resp?.ok && resp?.hasData;
+            result.hasData = resp?.hasData;
+            result.responsePreview = resp?.preview;
+        }
+        else {
+            result.error = `Strategy ${strategy} requires site-specific implementation`;
         }
     }
     catch (err) {

package/vendor/opencli/dist/src/cli.d.ts

@@ -0,0 +1,22 @@
+/**
+ * CLI entry point: registers built-in commands and wires up Commander.
+ *
+ * Built-in commands are registered inline here (list, validate, explore, etc.).
+ * Dynamic adapter commands are registered via commanderAdapter.ts.
+ */
+import { Command } from 'commander';
+export declare function createProgram(BUILTIN_CLIS: string, USER_CLIS: string): Command;
+export declare function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void;
+export interface OperateVerifyInvocation {
+    binary: string;
+    args: string[];
+    cwd: string;
+    shell?: boolean;
+}
+export declare function findPackageRoot(startFile: string, fileExists?: (path: string) => boolean): string;
+export declare function resolveOperateVerifyInvocation(opts?: {
+    projectRoot?: string;
+    platform?: NodeJS.Platform;
+    fileExists?: (path: string) => boolean;
+    readFile?: (path: string) => string;
+}): OperateVerifyInvocation;

package/vendor/opencli/dist/{cli.js → src/cli.js}

@@ -4,6 +4,9 @@
  * Built-in commands are registered inline here (list, validate, explore, etc.).
  * Dynamic adapter commands are registered via commanderAdapter.ts.
  */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { fullName, getRegistry, strategyLabel } from './registry.js';
@@ -16,6 +19,7 @@ import { loadExternalClis, executeExternalCli, installExternalCli, registerExter
 import { registerAllCommands } from './commanderAdapter.js';
 import { EXIT_CODES, getErrorMessage } from './errors.js';
 import { daemonStatus, daemonStop, daemonRestart } from './commands/daemon.js';
+const CLI_FILE = fileURLToPath(import.meta.url);
 /** Create a browser page for operate commands. Uses 'operate' workspace for session persistence. */
 async function getOperatePage() {
     const { BrowserBridge } = await import('./browser/index.js');
@@ -587,11 +591,9 @@ cli({
                 process.exitCode = EXIT_CODES.USAGE_ERROR;
                 return;
             }
-            const { execSync } = await import('node:child_process');
+            const { execFileSync } = await import('node:child_process');
             const os = await import('node:os');
-            const path = await import('node:path');
             const filePath = path.join(os.homedir(), '.opencli', 'clis', site, `${command}.ts`);
-            const fs = await import('node:fs');
             if (!fs.existsSync(filePath)) {
                 console.error(`Adapter not found: ${filePath}`);
                 console.error(`Run "opencli operate init ${name}" to create it.`);
@@ -604,14 +606,16 @@ cli({
             const adapterSrc = fs.readFileSync(filePath, 'utf-8');
             const hasLimitArg = /['"]limit['"]/.test(adapterSrc);
             const limitFlag = hasLimitArg ? ' --limit 3' : '';
-            const verifyCmd = `node dist/main.js ${site} ${command}${limitFlag}`;
+            const limitArgs = hasLimitArg ? ['--limit', '3'] : [];
+            const invocation = resolveOperateVerifyInvocation();
             try {
-                const output = execSync(verifyCmd, {
-                    cwd: path.join(path.dirname(import.meta.url.replace('file://', '')), '..'),
+                const output = execFileSync(invocation.binary, [...invocation.args, site, command, ...limitArgs], {
+                    cwd: invocation.cwd,
                     timeout: 30000,
                     encoding: 'utf-8',
                     env: process.env,
                     stdio: ['pipe', 'pipe', 'pipe'],
+                    ...(invocation.shell ? { shell: true } : {}),
                 });
                 console.log(`  Executing: opencli ${site} ${command}${limitFlag}\n`);
                 console.log(output);
@@ -915,7 +919,7 @@ cli({
         .description('Start Anthropic-compatible API proxy for Antigravity')
         .option('--port <port>', 'Server port (default: 8082)', '8082')
         .action(async (opts) => {
-        const { startServe } = await import('./clis/antigravity/serve.js');
+        const { startServe } = await import('../clis/antigravity/serve.js');
         await startServe({ port: parseInt(opts.port) });
     });
     // ── Dynamic adapter commands ──────────────────────────────────────────────
@@ -939,7 +943,73 @@ cli({
 export function runCli(BUILTIN_CLIS, USER_CLIS) {
     createProgram(BUILTIN_CLIS, USER_CLIS).parse();
 }
-// ── Helpers ─────────────────────────────────────────────────────────────────
+export function findPackageRoot(startFile, fileExists = fs.existsSync) {
+    let dir = path.dirname(startFile);
+    while (true) {
+        if (fileExists(path.join(dir, 'package.json')))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            throw new Error(`Could not find package.json above ${startFile}`);
+        }
+        dir = parent;
+    }
+}
+function getBuiltEntryCandidates(packageRoot, readFile) {
+    const candidates = [];
+    try {
+        const pkg = JSON.parse(readFile(path.join(packageRoot, 'package.json')));
+        if (typeof pkg.bin === 'string') {
+            candidates.push(path.join(packageRoot, pkg.bin));
+        }
+        else if (pkg.bin && typeof pkg.bin === 'object' && typeof pkg.bin.opencli === 'string') {
+            candidates.push(path.join(packageRoot, pkg.bin.opencli));
+        }
+        if (typeof pkg.main === 'string') {
+            candidates.push(path.join(packageRoot, pkg.main));
+        }
+    }
+    catch {
+        // Fall through to compatibility candidates below.
+    }
+    // Compatibility fallback for partially-built trees or older layouts.
+    candidates.push(path.join(packageRoot, 'dist', 'src', 'main.js'), path.join(packageRoot, 'dist', 'main.js'));
+    return [...new Set(candidates)];
+}
+export function resolveOperateVerifyInvocation(opts = {}) {
+    const platform = opts.platform ?? process.platform;
+    const fileExists = opts.fileExists ?? fs.existsSync;
+    const readFile = opts.readFile ?? ((filePath) => fs.readFileSync(filePath, 'utf-8'));
+    const projectRoot = opts.projectRoot ?? findPackageRoot(CLI_FILE, fileExists);
+    for (const builtEntry of getBuiltEntryCandidates(projectRoot, readFile)) {
+        if (fileExists(builtEntry)) {
+            return {
+                binary: process.execPath,
+                args: [builtEntry],
+                cwd: projectRoot,
+            };
+        }
+    }
+    const sourceEntry = path.join(projectRoot, 'src', 'main.ts');
+    if (!fileExists(sourceEntry)) {
+        throw new Error(`Could not find opencli entrypoint under ${projectRoot}. Expected built entry from package.json or src/main.ts.`);
+    }
+    const localTsxBin = path.join(projectRoot, 'node_modules', '.bin', platform === 'win32' ? 'tsx.cmd' : 'tsx');
+    if (fileExists(localTsxBin)) {
+        return {
+            binary: localTsxBin,
+            args: [sourceEntry],
+            cwd: projectRoot,
+            ...(platform === 'win32' ? { shell: true } : {}),
+        };
+    }
+    return {
+        binary: platform === 'win32' ? 'npx.cmd' : 'npx',
+        args: ['tsx', sourceEntry],
+        cwd: projectRoot,
+        ...(platform === 'win32' ? { shell: true } : {}),
+    };
+}
 /** Infer a workspace-friendly hostname from a URL, with site override. */
 function inferHost(url, site) {
     if (site)

package/vendor/opencli/dist/{cli.test.js → src/cli.test.js}

@@ -1,4 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import * as path from 'node:path';
 const { mockExploreUrl, mockRenderExploreSummary, mockGenerateCliFromUrl, mockRenderGenerateSummary, mockRecordSession, mockRenderRecordSummary, mockCascadeProbe, mockRenderCascadeResult, mockGetBrowserFactory, mockBrowserSession, } = vi.hoisted(() => ({
     mockExploreUrl: vi.fn(),
     mockRenderExploreSummary: vi.fn(),
@@ -31,7 +32,7 @@ vi.mock('./runtime.js', () => ({
     getBrowserFactory: mockGetBrowserFactory,
     browserSession: mockBrowserSession,
 }));
-import { createProgram } from './cli.js';
+import { createProgram, findPackageRoot, resolveOperateVerifyInvocation } from './cli.js';
 describe('built-in browser commands verbose wiring', () => {
     const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
     beforeEach(() => {
@@ -86,3 +87,85 @@ describe('built-in browser commands verbose wiring', () => {
     });
     consoleLogSpy.mockClear();
 });
+describe('resolveOperateVerifyInvocation', () => {
+    it('prefers the built entry declared in package metadata', () => {
+        const projectRoot = path.join('repo-root');
+        const exists = new Set([
+            path.join(projectRoot, 'dist', 'src', 'main.js'),
+        ]);
+        expect(resolveOperateVerifyInvocation({
+            projectRoot,
+            readFile: () => JSON.stringify({ bin: { opencli: 'dist/src/main.js' } }),
+            fileExists: (candidate) => exists.has(candidate),
+        })).toEqual({
+            binary: process.execPath,
+            args: [path.join(projectRoot, 'dist', 'src', 'main.js')],
+            cwd: projectRoot,
+        });
+    });
+    it('falls back to compatibility built-entry candidates when package metadata is unavailable', () => {
+        const projectRoot = path.join('repo-root');
+        const exists = new Set([
+            path.join(projectRoot, 'dist', 'src', 'main.js'),
+        ]);
+        expect(resolveOperateVerifyInvocation({
+            projectRoot,
+            readFile: () => { throw new Error('no package json'); },
+            fileExists: (candidate) => exists.has(candidate),
+        })).toEqual({
+            binary: process.execPath,
+            args: [path.join(projectRoot, 'dist', 'src', 'main.js')],
+            cwd: projectRoot,
+        });
+    });
+    it('falls back to the local tsx binary in source checkouts on Windows', () => {
+        const projectRoot = path.join('repo-root');
+        const exists = new Set([
+            path.join(projectRoot, 'src', 'main.ts'),
+            path.join(projectRoot, 'node_modules', '.bin', 'tsx.cmd'),
+        ]);
+        expect(resolveOperateVerifyInvocation({
+            projectRoot,
+            platform: 'win32',
+            fileExists: (candidate) => exists.has(candidate),
+        })).toEqual({
+            binary: path.join(projectRoot, 'node_modules', '.bin', 'tsx.cmd'),
+            args: [path.join(projectRoot, 'src', 'main.ts')],
+            cwd: projectRoot,
+            shell: true,
+        });
+    });
+    it('falls back to npx tsx when local tsx is unavailable', () => {
+        const projectRoot = path.join('repo-root');
+        const exists = new Set([
+            path.join(projectRoot, 'src', 'main.ts'),
+        ]);
+        expect(resolveOperateVerifyInvocation({
+            projectRoot,
+            platform: 'linux',
+            fileExists: (candidate) => exists.has(candidate),
+        })).toEqual({
+            binary: 'npx',
+            args: ['tsx', path.join(projectRoot, 'src', 'main.ts')],
+            cwd: projectRoot,
+        });
+    });
+});
+describe('findPackageRoot', () => {
+    it('walks up from dist/src to the package root', () => {
+        const packageRoot = path.join('repo-root');
+        const cliFile = path.join(packageRoot, 'dist', 'src', 'cli.js');
+        const exists = new Set([
+            path.join(packageRoot, 'package.json'),
+        ]);
+        expect(findPackageRoot(cliFile, (candidate) => exists.has(candidate))).toBe(packageRoot);
+    });
+    it('walks up from src to the package root', () => {
+        const packageRoot = path.join('repo-root');
+        const cliFile = path.join(packageRoot, 'src', 'cli.ts');
+        const exists = new Set([
+            path.join(packageRoot, 'package.json'),
+        ]);
+        expect(findPackageRoot(cliFile, (candidate) => exists.has(candidate))).toBe(packageRoot);
+    });
+});

package/vendor/opencli/dist/{commanderAdapter.d.ts → src/commanderAdapter.d.ts}

@@ -16,6 +16,7 @@ export declare function normalizeArgValue(argType: string | undefined, value: un
  * Register a single CliCommand as a Commander subcommand.
  */
 export declare function registerCommandToProgram(siteCmd: Command, cmd: CliCommand): void;
+export type GenericErrorKind = 'auth' | 'http' | 'not-found' | 'other';
 /**
  * Register all commands from the registry onto a Commander program.
  */

package/vendor/opencli/dist/{commanderAdapter.js → src/commanderAdapter.js}

@@ -122,42 +122,31 @@ export function registerCommandToProgram(siteCmd, cmd) {
         }
     });
 }
-// ── Exit code resolution ─────────────────────────────────────────────────────
-/**
- * Map any thrown value to a Unix process exit code.
- *
- * - CliError subclasses carry their own exitCode (set in errors.ts).
- * - Generic Error objects are classified by message pattern so that
- *   un-typed auth / not-found errors from adapters still produce
- *   meaningful exit codes for shell scripts.
- */
-function resolveExitCode(err) {
-    if (err instanceof CliError)
-        return err.exitCode;
-    // Pattern-based fallback for untyped errors thrown by third-party adapters.
-    const msg = getErrorMessage(err);
-    const kind = classifyGenericError(msg);
-    if (kind === 'auth')
-        return EXIT_CODES.NOPERM;
-    if (kind === 'not-found')
-        return EXIT_CODES.EMPTY_RESULT;
-    if (kind === 'http')
-        return EXIT_CODES.GENERIC_ERROR; // HTTP 4xx/5xx → generic; renderer shows details
-    return EXIT_CODES.GENERIC_ERROR;
-}
-// ── Error rendering ──────────────────────────────────────────────────────────
+// ── Error classification ─────────────────────────────────────────────────────
 const ISSUES_URL = 'https://github.com/jackwener/opencli/issues';
+const GENERIC_ERROR_MAP = {
+    auth: { icon: '🔒', exitCode: EXIT_CODES.NOPERM, hint: 'Open Chrome or Chromium, log in to the target site, then retry.' },
+    http: { icon: '🌐', exitCode: EXIT_CODES.GENERIC_ERROR, hint: 'Check your login status, or the site may be temporarily unavailable.' },
+    'not-found': { icon: '📭', exitCode: EXIT_CODES.EMPTY_RESULT, hint: 'The resource was not found. The adapter or page structure may have changed.' },
+    other: { icon: '💥', exitCode: EXIT_CODES.GENERIC_ERROR, hint: '' },
+};
 /** Pattern-based classifier for untyped errors thrown by adapters. */
 function classifyGenericError(msg) {
     const m = msg.toLowerCase();
+    let kind = 'other';
     if (/not logged in|login required|please log in|未登录|请先登录|authentication required|cookie expired/.test(m))
-        return 'auth';
-    // Match "HTTP 404", "status: 500", "status 403", bare "404 Not Found", etc.
-    if (/\b(status[: ]+)?[45]\d{2}\b|http[/ ][45]\d{2}/.test(m))
-        return 'http';
-    if (/not found|未找到|could not find|no .+ found/.test(m))
-        return 'not-found';
-    return 'other';
+        kind = 'auth';
+    else if (/\b(status[: ]+)?[45]\d{2}\b|http[/ ][45]\d{2}/.test(m))
+        kind = 'http';
+    else if (/not found|未找到|could not find|no .+ found/.test(m))
+        kind = 'not-found';
+    return { kind, ...GENERIC_ERROR_MAP[kind] };
+}
+// ── Exit code resolution ─────────────────────────────────────────────────────
+function resolveExitCode(err) {
+    if (err instanceof CliError)
+        return err.exitCode;
+    return classifyGenericError(getErrorMessage(err)).exitCode;
 }
 /** Render a status line for BrowserConnectError based on real-time or kind-derived state. */
 function renderBridgeStatus(running, extensionConnected) {
@@ -256,21 +245,12 @@ async function renderError(err, cmdName, verbose) {
     }
     // ── Generic Error from adapters: classify by message pattern ──────────
     const msg = getErrorMessage(err);
-    const kind = classifyGenericError(msg);
-    if (kind === 'auth') {
-        console.error(chalk.red(`🔒 ${msg}`));
-        console.error(chalk.yellow('→ Open Chrome or Chromium, log in to the target site, then retry.'));
-        return;
-    }
-    if (kind === 'http') {
-        console.error(chalk.red(`🌐 ${msg}`));
-        console.error(chalk.yellow('→ Check your login status, or the site may be temporarily unavailable.'));
-        return;
-    }
-    if (kind === 'not-found') {
-        console.error(chalk.red(`📭 ${msg}`));
-        console.error(chalk.yellow('→ The resource was not found. The adapter or page structure may have changed.'));
-        console.error(chalk.dim(`  Report: ${ISSUES_URL}`));
+    const classified = classifyGenericError(msg);
+    if (classified.kind !== 'other') {
+        console.error(chalk.red(`${classified.icon} ${msg}`));
+        console.error(chalk.yellow(`→ ${classified.hint}`));
+        if (classified.kind === 'not-found')
+            console.error(chalk.dim(`  Report: ${ISSUES_URL}`));
         return;
     }
     // ── Unknown error: show stack in verbose mode ─────────────────────────

package/vendor/opencli/dist/src/diagnostic.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 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.
+ */
+import type { IPage } from './types.js';
+import type { InternalCliCommand } from './registry.js';
+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[];
+        consoleErrors: unknown[];
+    };
+    timestamp: string;
+}
+/** 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. */
+export declare function collectDiagnostic(err: unknown, cmd: InternalCliCommand, page: IPage | null): Promise<RepairContext>;
+/** Emit diagnostic JSON to stderr. */
+export declare function emitDiagnostic(ctx: RepairContext): void;

package/vendor/opencli/dist/src/diagnostic.js

@@ -0,0 +1,71 @@
+/**
+ * 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.
+ */
+import * as fs from 'node:fs';
+import { CliError, getErrorMessage } from './errors.js';
+import { fullName } from './registry.js';
+// ── Diagnostic collection ────────────────────────────────────────────────────
+/** Whether diagnostic mode is enabled. */
+export function isDiagnosticEnabled() {
+    return process.env.OPENCLI_DIAGNOSTIC === '1';
+}
+/** Safely collect page diagnostic state. Individual failures are swallowed. */
+async function collectPageState(page) {
+    try {
+        const [url, snapshot, networkRequests, consoleErrors] = await Promise.all([
+            page.getCurrentUrl?.().catch(() => null) ?? Promise.resolve(null),
+            page.snapshot().catch(() => '(snapshot unavailable)'),
+            page.networkRequests().catch(() => []),
+            page.consoleMessages('error').catch(() => []),
+        ]);
+        return { url: url ?? 'unknown', snapshot, networkRequests, consoleErrors };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Read adapter source file content. */
+function readAdapterSource(modulePath) {
+    if (!modulePath)
+        return undefined;
+    try {
+        return fs.readFileSync(modulePath, 'utf-8');
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Build a RepairContext from an error, command metadata, and optional page state. */
+export function buildRepairContext(err, cmd, pageState) {
+    const isCliError = err instanceof CliError;
+    return {
+        error: {
+            code: isCliError ? err.code : 'UNKNOWN',
+            message: getErrorMessage(err),
+            hint: isCliError ? err.hint : undefined,
+            stack: err instanceof Error ? err.stack : undefined,
+        },
+        adapter: {
+            site: cmd.site,
+            command: fullName(cmd),
+            sourcePath: cmd._modulePath,
+            source: readAdapterSource(cmd._modulePath),
+        },
+        page: pageState,
+        timestamp: new Date().toISOString(),
+    };
+}
+/** Collect full diagnostic context including page state. */
+export async function collectDiagnostic(err, cmd, page) {
+    const pageState = page ? await collectPageState(page) : undefined;
+    return buildRepairContext(err, cmd, pageState);
+}
+/** Emit diagnostic JSON to stderr. */
+export function emitDiagnostic(ctx) {
+    const marker = '___OPENCLI_DIAGNOSTIC___';
+    process.stderr.write(`\n${marker}\n${JSON.stringify(ctx)}\n${marker}\n`);
+}

package/vendor/opencli/dist/src/diagnostic.test.d.ts

@@ -0,0 +1 @@
+export {};