@huyuan-ai/cli 1.1.0 → 1.2.0

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

@@ -0,0 +1,84 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { buildRepairContext, isDiagnosticEnabled, emitDiagnostic } from './diagnostic.js';
+import { SelectorError, CommandExecutionError } from './errors.js';
+function makeCmd(overrides = {}) {
+    return {
+        site: 'test-site',
+        name: 'test-cmd',
+        description: 'test',
+        args: [],
+        ...overrides,
+    };
+}
+describe('isDiagnosticEnabled', () => {
+    const origEnv = process.env.OPENCLI_DIAGNOSTIC;
+    afterEach(() => {
+        if (origEnv === undefined)
+            delete process.env.OPENCLI_DIAGNOSTIC;
+        else
+            process.env.OPENCLI_DIAGNOSTIC = origEnv;
+    });
+    it('returns false when env not set', () => {
+        delete process.env.OPENCLI_DIAGNOSTIC;
+        expect(isDiagnosticEnabled()).toBe(false);
+    });
+    it('returns true when env is "1"', () => {
+        process.env.OPENCLI_DIAGNOSTIC = '1';
+        expect(isDiagnosticEnabled()).toBe(true);
+    });
+    it('returns false for other values', () => {
+        process.env.OPENCLI_DIAGNOSTIC = 'true';
+        expect(isDiagnosticEnabled()).toBe(false);
+    });
+});
+describe('buildRepairContext', () => {
+    it('captures CliError fields', () => {
+        const err = new SelectorError('.missing-element', 'Element removed');
+        const ctx = buildRepairContext(err, makeCmd());
+        expect(ctx.error.code).toBe('SELECTOR');
+        expect(ctx.error.message).toContain('.missing-element');
+        expect(ctx.error.hint).toBe('Element removed');
+        expect(ctx.error.stack).toBeDefined();
+        expect(ctx.adapter.site).toBe('test-site');
+        expect(ctx.adapter.command).toBe('test-site/test-cmd');
+        expect(ctx.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+    });
+    it('handles non-CliError errors', () => {
+        const err = new TypeError('Cannot read property "x" of undefined');
+        const ctx = buildRepairContext(err, makeCmd());
+        expect(ctx.error.code).toBe('UNKNOWN');
+        expect(ctx.error.message).toContain('Cannot read property');
+        expect(ctx.error.hint).toBeUndefined();
+    });
+    it('includes page state when provided', () => {
+        const pageState = {
+            url: 'https://example.com/page',
+            snapshot: '<div>...</div>',
+            networkRequests: [{ url: '/api/data', status: 200 }],
+            consoleErrors: ['Uncaught TypeError'],
+        };
+        const ctx = buildRepairContext(new CommandExecutionError('boom'), makeCmd(), pageState);
+        expect(ctx.page).toEqual(pageState);
+    });
+    it('omits page when not provided', () => {
+        const ctx = buildRepairContext(new Error('boom'), makeCmd());
+        expect(ctx.page).toBeUndefined();
+    });
+});
+describe('emitDiagnostic', () => {
+    it('writes delimited JSON to stderr', () => {
+        const writeSpy = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
+        const ctx = buildRepairContext(new CommandExecutionError('test error'), makeCmd());
+        emitDiagnostic(ctx);
+        const output = writeSpy.mock.calls.map(c => c[0]).join('');
+        expect(output).toContain('___OPENCLI_DIAGNOSTIC___');
+        expect(output).toContain('"code":"COMMAND_EXEC"');
+        expect(output).toContain('"message":"test error"');
+        // Verify JSON is parseable between markers
+        const match = output.match(/___OPENCLI_DIAGNOSTIC___\n(.*)\n___OPENCLI_DIAGNOSTIC___/);
+        expect(match).toBeTruthy();
+        const parsed = JSON.parse(match[1]);
+        expect(parsed.error.code).toBe('COMMAND_EXEC');
+        writeSpy.mockRestore();
+    });
+});

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

@@ -14,10 +14,19 @@ export declare const USER_CLIS_DIR: string;
 /** Plugins directory: ~/.opencli/plugins/ */
 export declare const PLUGINS_DIR: string;
 /**
- * Create runtime shim files under ~/.opencli so legacy user TS CLIs can keep
- * importing ../../registry(.js) and ../../errors(.js).
+ * Ensure ~/.opencli/node_modules/@jackwener/opencli symlink exists so that
+ * user CLIs in ~/.opencli/clis/ can `import { cli } from '@jackwener/opencli/registry'`.
+ *
+ * This is the sole resolution mechanism — adapters use package exports
+ * (e.g. `@jackwener/opencli/registry`, `@jackwener/opencli/errors`) and
+ * Node.js resolves them through this symlink.
  */
 export declare function ensureUserCliCompatShims(baseDir?: string): Promise<void>;
+/**
+ * First-run fallback: if postinstall was skipped (--ignore-scripts) or failed,
+ * trigger adapter fetch on first CLI invocation when ~/.opencli/clis/ is empty.
+ */
+export declare function ensureUserAdapters(): Promise<void>;
 /**
  * Discover and register CLI commands.
  * Uses pre-compiled manifest when available for instant startup.

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

@@ -31,49 +31,44 @@ function parseStrategy(rawStrategy, fallback = Strategy.COOKIE) {
     return Strategy[key] ?? fallback;
 }
 import { isRecord } from './utils.js';
-function resolveHostRuntimeModulePath(moduleName) {
-    const runtimeDir = path.dirname(fileURLToPath(import.meta.url));
-    for (const ext of ['.js', '.ts']) {
-        const candidate = path.join(runtimeDir, `${moduleName}${ext}`);
-        if (fs.existsSync(candidate))
-            return candidate;
-    }
-    return path.join(runtimeDir, `${moduleName}.js`);
-}
-async function writeCompatShimIfNeeded(filePath, content) {
-    try {
-        const existing = await fs.promises.readFile(filePath, 'utf-8');
-        if (existing === content)
-            return;
-    }
-    catch {
-        // Fall through to write missing shim
+/**
+ * Find the package root (directory containing package.json).
+ * Dev: import.meta.url is in src/ → one level up.
+ * Prod: import.meta.url is in dist/src/ → two levels up.
+ */
+function findPackageRoot() {
+    let dir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+    if (!fs.existsSync(path.join(dir, 'package.json'))) {
+        dir = path.resolve(dir, '..');
     }
-    await fs.promises.writeFile(filePath, content, 'utf-8');
+    return dir;
 }
 /**
- * Create runtime shim files under ~/.opencli so legacy user TS CLIs can keep
- * importing ../../registry(.js) and ../../errors(.js).
+ * Ensure ~/.opencli/node_modules/@jackwener/opencli symlink exists so that
+ * user CLIs in ~/.opencli/clis/ can `import { cli } from '@jackwener/opencli/registry'`.
+ *
+ * This is the sole resolution mechanism — adapters use package exports
+ * (e.g. `@jackwener/opencli/registry`, `@jackwener/opencli/errors`) and
+ * Node.js resolves them through this symlink.
  */
 export async function ensureUserCliCompatShims(baseDir = USER_OPENCLI_DIR) {
     await fs.promises.mkdir(baseDir, { recursive: true });
-    const registryUrl = pathToFileURL(resolveHostRuntimeModulePath('registry-api')).href;
-    const errorsUrl = pathToFileURL(resolveHostRuntimeModulePath('errors')).href;
-    await Promise.all([
-        writeCompatShimIfNeeded(path.join(baseDir, 'registry'), `export * from '${registryUrl}';\n`),
-        writeCompatShimIfNeeded(path.join(baseDir, 'registry.js'), `export * from '${registryUrl}';\n`),
-        writeCompatShimIfNeeded(path.join(baseDir, 'errors'), `export * from '${errorsUrl}';\n`),
-        writeCompatShimIfNeeded(path.join(baseDir, 'errors.js'), `export * from '${errorsUrl}';\n`),
-        writeCompatShimIfNeeded(path.join(baseDir, 'package.json'), `${JSON.stringify({ name: 'opencli-user-runtime', private: true, type: 'module' }, null, 2)}\n`),
-    ]);
-    // Create node_modules/@jackwener/opencli symlink so user TS CLIs can import
-    // from '@jackwener/opencli/registry' (the package export).
-    // This is needed because ~/.opencli/clis/ is outside opencli's node_modules tree.
-    const opencliRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+    // package.json for ESM resolution in ~/.opencli/
+    const pkgJsonPath = path.join(baseDir, 'package.json');
+    const pkgJsonContent = `${JSON.stringify({ name: 'opencli-user-runtime', private: true, type: 'module' }, null, 2)}\n`;
+    try {
+        const existing = await fs.promises.readFile(pkgJsonPath, 'utf-8');
+        if (existing !== pkgJsonContent)
+            await fs.promises.writeFile(pkgJsonPath, pkgJsonContent, 'utf-8');
+    }
+    catch {
+        await fs.promises.writeFile(pkgJsonPath, pkgJsonContent, 'utf-8');
+    }
+    // Create node_modules/@jackwener/opencli symlink pointing to the installed package root.
+    const opencliRoot = findPackageRoot();
     const symlinkDir = path.join(baseDir, 'node_modules', '@jackwener');
     const symlinkPath = path.join(symlinkDir, 'opencli');
     try {
-        // Only recreate if symlink is missing or points to wrong target
         let needsUpdate = true;
         try {
             const existing = await fs.promises.readlink(symlinkPath);
@@ -84,14 +79,53 @@ export async function ensureUserCliCompatShims(baseDir = USER_OPENCLI_DIR) {
         if (needsUpdate) {
             await fs.promises.mkdir(symlinkDir, { recursive: true });
             try {
-                await fs.promises.unlink(symlinkPath);
+                await fs.promises.rm(symlinkPath, { recursive: true, force: true });
             }
             catch { /* doesn't exist */ }
-            await fs.promises.symlink(opencliRoot, symlinkPath, 'dir');
+            const symlinkType = process.platform === 'win32' ? 'junction' : 'dir';
+            await fs.promises.symlink(opencliRoot, symlinkPath, symlinkType);
         }
     }
+    catch (err) {
+        log.warn(`Could not create symlink at ${symlinkPath}: ${getErrorMessage(err)}`);
+    }
+}
+const ADAPTER_MANIFEST_PATH = path.join(USER_OPENCLI_DIR, 'adapter-manifest.json');
+/**
+ * First-run fallback: if postinstall was skipped (--ignore-scripts) or failed,
+ * trigger adapter fetch on first CLI invocation when ~/.opencli/clis/ is empty.
+ */
+export async function ensureUserAdapters() {
+    // If adapter manifest already exists, adapters were fetched — nothing to do
+    try {
+        await fs.promises.access(ADAPTER_MANIFEST_PATH);
+        return;
+    }
     catch {
-        // Non-fatal: npm-linked installs or permission issues may prevent this
+        // No manifest — first run or postinstall was skipped
+    }
+    // Check if clis dir has any content (could be manually populated)
+    try {
+        const entries = await fs.promises.readdir(USER_CLIS_DIR);
+        if (entries.length > 0)
+            return;
+    }
+    catch {
+        // Dir doesn't exist — needs fetch
+    }
+    log.info('First run detected — copying adapters (one-time setup)...');
+    try {
+        const { execFileSync } = await import('node:child_process');
+        const scriptPath = path.join(findPackageRoot(), 'scripts', 'fetch-adapters.js');
+        execFileSync(process.execPath, [scriptPath], {
+            stdio: 'inherit',
+            env: { ...process.env, _OPENCLI_FIRST_RUN: '1' },
+            timeout: 120_000,
+        });
+    }
+    catch (err) {
+        log.warn(`Could not fetch adapters on first run: ${getErrorMessage(err)}`);
+        log.warn('Built-in adapters from the package will be used.');
     }
 }
 /**

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

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

package/vendor/opencli/dist/src/download/index.test.d.ts

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

package/vendor/opencli/dist/src/electron-apps.test.d.ts

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

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

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

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

@@ -71,7 +71,7 @@ cli({
             await fs.promises.rm(tempBuildRoot, { recursive: true, force: true });
         }
     });
-    it('loads legacy user TS CLI modules via compatibility shims', async () => {
+    it('loads user CLI modules via package exports symlink', async () => {
         const tempOpencliRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-user-clis-'));
         const userClisDir = path.join(tempOpencliRoot, 'clis');
         const siteDir = path.join(userClisDir, 'legacy-site');
@@ -80,8 +80,9 @@ cli({
             await ensureUserCliCompatShims(tempOpencliRoot);
             await fs.promises.mkdir(siteDir, { recursive: true });
             await fs.promises.writeFile(commandPath, `
-import { cli, Strategy } from '../../registry';
-import { CommandExecutionError } from '../../errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { htmlToMarkdown } from '@jackwener/opencli/utils';
 
 cli({
   site: 'legacy-site',
@@ -89,13 +90,13 @@ cli({
   description: 'hello command',
   strategy: Strategy.PUBLIC,
   browser: false,
-  func: async () => [{ ok: true, errorName: new CommandExecutionError('boom').name }],
+  func: async () => [{ ok: true, errorName: new CommandExecutionError('boom').name, markdown: htmlToMarkdown('<p>hello</p>') }],
 });
 `);
             await discoverClis(userClisDir);
             const cmd = getRegistry().get('legacy-site/hello');
             expect(cmd).toBeDefined();
-            await expect(executeCommand(cmd, {})).resolves.toEqual([{ ok: true, errorName: 'CommandExecutionError' }]);
+            await expect(executeCommand(cmd, {})).resolves.toEqual([{ ok: true, errorName: 'CommandExecutionError', markdown: 'hello' }]);
         }
         finally {
             await fs.promises.rm(tempOpencliRoot, { recursive: true, force: true });

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

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

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

@@ -13,6 +13,7 @@ import { Strategy, getRegistry, fullName } from './registry.js';
 import { pathToFileURL } from 'node:url';
 import { executePipeline } from './pipeline/index.js';
 import { AdapterLoadError, ArgumentError, BrowserConnectError, CommandExecutionError, getErrorMessage } from './errors.js';
+import { isDiagnosticEnabled, collectDiagnostic, emitDiagnostic } from './diagnostic.js';
 import { shouldUseBrowserSession } from './capabilityRouting.js';
 import { getBrowserFactory, browserSession, runWithTimeout, DEFAULT_BROWSER_COMMAND_TIMEOUT } from './runtime.js';
 import { emitHook } from './hooks.js';
@@ -129,6 +130,7 @@ export async function executeCommand(cmd, rawKwargs, debug = false) {
     };
     await emitHook('onBeforeExecute', hookCtx);
     let result;
+    let diagnosticEmitted = false;
     try {
         if (shouldUseBrowserSession(cmd)) {
             const electron = isElectronApp(cmd.site);
@@ -176,10 +178,22 @@ export async function executeCommand(cmd, rawKwargs, debug = false) {
                             log.debug(`[pre-nav] Failed to navigate to ${preNavUrl}: ${err instanceof Error ? err.message : err}`);
                     }
                 }
-                return runWithTimeout(runCommand(cmd, page, kwargs, debug), {
-                    timeout: cmd.timeoutSeconds ?? DEFAULT_BROWSER_COMMAND_TIMEOUT,
-                    label: fullName(cmd),
-                });
+                try {
+                    return await runWithTimeout(runCommand(cmd, page, kwargs, debug), {
+                        timeout: cmd.timeoutSeconds ?? DEFAULT_BROWSER_COMMAND_TIMEOUT,
+                        label: fullName(cmd),
+                    });
+                }
+                catch (err) {
+                    // Collect diagnostic while page is still alive (before browserSession closes it).
+                    if (isDiagnosticEnabled()) {
+                        const internal = cmd;
+                        const ctx = await collectDiagnostic(err, internal, page);
+                        emitDiagnostic(ctx);
+                        diagnosticEmitted = true;
+                    }
+                    throw err;
+                }
             }, { workspace: `site:${cmd.site}`, cdpEndpoint });
         }
         else {
@@ -198,6 +212,13 @@ export async function executeCommand(cmd, rawKwargs, debug = false) {
         }
     }
     catch (err) {
+        // Emit diagnostic if not already emitted (browser session emits with page state;
+        // this fallback covers non-browser commands and pre-session failures like BrowserConnectError).
+        if (isDiagnosticEnabled() && !diagnosticEmitted) {
+            const internal = cmd;
+            const ctx = await collectDiagnostic(err, internal, null);
+            emitDiagnostic(ctx);
+        }
         hookCtx.error = err;
         hookCtx.finishedAt = Date.now();
         await emitHook('onAfterExecute', hookCtx);

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

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

package/vendor/opencli/dist/src/extension-manifest-regression.test.d.ts

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

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

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

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

@@ -30,6 +30,8 @@ export declare function generateReadInterceptedJs(arrayName?: string): string;
  * - Installs temporarily, restores originals in finally block
  * - Resolves a promise on first capture (for immediate await)
  * - Returns captured data directly
+ *
+ * Reuses the shared DISGUISE_FN for consistent toString() disguising.
  */
 export declare function generateTapInterceptorJs(patternExpr: string): {
     setupVar: string;

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

@@ -127,6 +127,8 @@ export function generateReadInterceptedJs(arrayName = '__opencli_intercepted') {
  * - Installs temporarily, restores originals in finally block
  * - Resolves a promise on first capture (for immediate await)
  * - Returns captured data directly
+ *
+ * Reuses the shared DISGUISE_FN for consistent toString() disguising.
  */
 export function generateTapInterceptorJs(patternExpr) {
     return {
@@ -135,12 +137,7 @@ export function generateTapInterceptorJs(patternExpr) {
       let captureResolve;
       const capturePromise = new Promise(r => { captureResolve = r; });
       const capturePattern = ${patternExpr};
-      function __disguise(fn, name) {
-        const s = 'function ' + name + '() { [native code] }';
-        Object.defineProperty(fn, 'toString', { value: function() { return s; }, writable: true, configurable: true, enumerable: false });
-        try { Object.defineProperty(fn, 'name', { value: name, configurable: true }); } catch {}
-        return fn;
-      }
+      ${DISGUISE_FN}
     `,
         capturedVar: 'captured',
         promiseVar: 'capturePromise',

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

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

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

@@ -7,6 +7,10 @@
 export declare const log: {
     /** Informational message (always shown) */
     info(msg: string): void;
+    /** Lightweight status line for adapter progress updates */
+    status(msg: string): void;
+    /** Positive completion/status line without the heavier info prefix */
+    success(msg: string): void;
     /** Warning (always shown) */
     warn(msg: string): void;
     /** Error (always shown) */

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

@@ -16,6 +16,14 @@ export const log = {
     info(msg) {
         process.stderr.write(`${chalk.blue('ℹ')}  ${msg}\n`);
     },
+    /** Lightweight status line for adapter progress updates */
+    status(msg) {
+        process.stderr.write(`${chalk.dim(msg)}\n`);
+    },
+    /** Positive completion/status line without the heavier info prefix */
+    success(msg) {
+        process.stderr.write(`${chalk.green(msg)}\n`);
+    },
     /** Warning (always shown) */
     warn(msg) {
         process.stderr.write(`${chalk.yellow('⚠')}  ${msg}\n`);

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

@@ -14,7 +14,7 @@ if (process.platform !== 'win32') {
 }
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { discoverClis, discoverPlugins, ensureUserCliCompatShims, USER_CLIS_DIR } from './discovery.js';
+import { discoverClis, discoverPlugins, ensureUserCliCompatShims, ensureUserAdapters, USER_CLIS_DIR } from './discovery.js';
 import { getCompletions } from './completion.js';
 import { runCli } from './cli.js';
 import { emitHook } from './hooks.js';
@@ -24,10 +24,11 @@ import { EXIT_CODES } from './errors.js';
 installNodeNetwork();
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const BUILTIN_CLIS = path.resolve(__dirname, 'clis');
+const BUILTIN_CLIS = path.resolve(__dirname, '..', 'clis');
 const USER_CLIS = USER_CLIS_DIR;
 // Sequential: plugins must run after built-in discovery so they can override built-in commands.
 await ensureUserCliCompatShims();
+await ensureUserAdapters();
 await discoverClis(BUILTIN_CLIS, USER_CLIS);
 await discoverPlugins();
 // Register exit hook: notice appears after command output (same as npm/gh/yarn)

package/vendor/opencli/dist/src/node-network.test.d.ts

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

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

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

package/vendor/opencli/dist/src/package-exports.test.d.ts

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

package/vendor/opencli/dist/src/package-exports.test.js

@@ -0,0 +1,112 @@
+/**
+ * Regression tests for package exports.
+ *
+ * Ensures adapter files use @jackwener/opencli/... package imports
+ * (not fragile relative paths) and that all declared exports resolve
+ * to real files. Prevents regressions like #788 / #791.
+ */
+import { describe, it, expect } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { builtinModules } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import ts from 'typescript';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+const CLIS_DIR = path.join(ROOT, 'clis');
+/** Recursively collect all .ts files in a directory. */
+function collectTsFiles(dir, opts) {
+    const results = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...collectTsFiles(full, opts));
+        }
+        else if (entry.name.endsWith('.ts') && !entry.name.endsWith('.d.ts')) {
+            if (opts?.excludeTests && (entry.name.endsWith('.test.ts') || entry.name === 'test-utils.ts'))
+                continue;
+            results.push(full);
+        }
+    }
+    return results;
+}
+const ALLOWED_BARE_IMPORTS = new Set([
+    '@jackwener/opencli',
+    ...builtinModules.flatMap((name) => name.startsWith('node:')
+        ? [name, name.slice(5)]
+        : [name, `node:${name}`]),
+]);
+function isAllowedImport(specifier) {
+    return specifier.startsWith('./')
+        || specifier.startsWith('../')
+        || specifier.startsWith('/')
+        || specifier.startsWith('@jackwener/opencli/')
+        || ALLOWED_BARE_IMPORTS.has(specifier);
+}
+/** Forbidden relative import patterns that should have been replaced.
+ * Uses (?:\.\./)+ to catch any depth of ../ traversal.
+ * Covers: import/export from, vi.mock(), vi.importActual(). */
+const FORBIDDEN_PATTERNS = [
+    /(?:from|mock|importActual)\s*\(?['"](?:\.\.\/)+src\//,
+    /(?:from|mock|importActual)\s*\(?['"](?:\.\.\/)+browser\//,
+    /(?:from|mock|importActual)\s*\(?['"](?:\.\.\/)+download\//,
+    /(?:from|mock|importActual)\s*\(?['"](?:\.\.\/)+pipeline\//,
+];
+describe('adapter imports use package exports', () => {
+    const adapterFiles = collectTsFiles(CLIS_DIR);
+    const runtimeAdapterFiles = collectTsFiles(CLIS_DIR, { excludeTests: true });
+    it('found adapter files to check', () => {
+        expect(adapterFiles.length).toBeGreaterThan(100);
+    });
+    it('no adapter uses relative imports to src/, browser/, download/, or pipeline/', () => {
+        const violations = [];
+        for (const file of adapterFiles) {
+            const content = fs.readFileSync(file, 'utf-8');
+            for (const pattern of FORBIDDEN_PATTERNS) {
+                if (pattern.test(content)) {
+                    const rel = path.relative(ROOT, file);
+                    const match = content.match(pattern)?.[0];
+                    violations.push(`${rel}: ${match}`);
+                }
+            }
+        }
+        expect(violations).toEqual([]);
+    });
+    it('non-test adapters only import node builtins, relative modules, or opencli public APIs', () => {
+        const violations = [];
+        for (const file of runtimeAdapterFiles) {
+            const source = fs.readFileSync(file, 'utf-8');
+            const module = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+            for (const stmt of module.statements) {
+                if (!ts.isImportDeclaration(stmt) && !ts.isExportDeclaration(stmt))
+                    continue;
+                const specifier = stmt.moduleSpecifier?.getText(module).slice(1, -1);
+                if (specifier && !isAllowedImport(specifier)) {
+                    violations.push({
+                        file: path.relative(ROOT, file),
+                        specifier,
+                    });
+                }
+            }
+        }
+        expect(violations).toEqual([]);
+    });
+});
+describe('package.json exports resolve to real files', () => {
+    const pkgJson = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf-8'));
+    const exports = pkgJson.exports;
+    it('has exports defined', () => {
+        expect(Object.keys(exports).length).toBeGreaterThan(5);
+    });
+    for (const [exportPath, target] of Object.entries(exports)) {
+        it(`export "${exportPath}" → ${target} has a source file`, () => {
+            // Export targets point to dist/ (compiled). Verify the source .ts exists.
+            // dist/src/foo.js → src/foo.ts
+            const sourcePath = target
+                .replace(/^\.\/dist\//, './')
+                .replace(/\.js$/, '.ts');
+            const fullPath = path.join(ROOT, sourcePath);
+            expect(fs.existsSync(fullPath), `Missing source: ${sourcePath}`).toBe(true);
+        });
+    }
+});

package/vendor/opencli/dist/src/pipeline/steps/download.test.d.ts

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

package/vendor/opencli/dist/src/pipeline/steps/fetch.test.d.ts

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

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

@@ -688,7 +688,7 @@ export function renderRecordSummary(result) {
     }
     if (result.candidateCount > 0) {
         lines.push('');
-        lines.push(chalk.dim(`  Copy a candidate to src/clis/${result.site}/ and run: npm run build`));
+        lines.push(chalk.dim(`  Copy a candidate to clis/${result.site}/ and run: npm run build`));
     }
     return lines.join('\n');
 }

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

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

package/vendor/opencli/dist/{registry-api.d.ts → src/registry-api.d.ts}

@@ -7,7 +7,7 @@
  * plugins are dynamically imported during discoverPlugins().
  */
 export { cli, Strategy, getRegistry, fullName, registerCommand } from './registry.js';
-export type { CliCommand, Arg, CliOptions } from './registry.js';
+export type { CliCommand, Arg, CliOptions, CommandArgs } from './registry.js';
 export type { IPage } from './types.js';
 export { onStartup, onBeforeExecute, onAfterExecute } from './hooks.js';
 export type { HookFn, HookContext, HookName } from './hooks.js';

package/vendor/opencli/dist/src/runtime-detect.test.d.ts

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

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

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

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

@@ -22,9 +22,6 @@ export interface SynthesizeCapability {
     itemPath?: string | null;
     recommendedColumns?: string[];
     recommendedArgs?: RecommendedArg[];
-    recommended_args?: RecommendedArg[];
-    recommendedColumnsLegacy?: string[];
-    recommended_columns?: string[];
     storeHint?: StoreHint;
 }
 export interface GeneratedArgDefinition {
@@ -95,7 +92,6 @@ export declare function synthesizeFromExplore(target: string, opts?: {
 export declare function renderSynthesizeSummary(result: SynthesizeResult): string;
 export declare function resolveExploreDir(target: string): string;
 export declare function loadExploreBundle(exploreDir: string): LoadedExploreBundle;
-/** Backward-compatible export for scaffold.ts */
 export declare function buildCandidate(site: string, targetUrl: string, cap: SynthesizeCapability, endpoint: ExploreEndpointArtifact): {
     name: string;
     yaml: CandidateYaml;