@jackwener/opencli 1.6.6 → 1.6.8

package/dist/src/cli.d.ts

@@ -5,6 +5,7 @@
  * Dynamic adapter commands are registered via commanderAdapter.ts.
  */
 import { Command } from 'commander';
+import { findPackageRoot } from './package-paths.js';
 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 {
@@ -13,7 +14,7 @@ export interface OperateVerifyInvocation {
     cwd: string;
     shell?: boolean;
 }
-export declare function findPackageRoot(startFile: string, fileExists?: (path: string) => boolean): string;
+export { findPackageRoot };
 export declare function resolveOperateVerifyInvocation(opts?: {
     projectRoot?: string;
     platform?: NodeJS.Platform;

package/dist/src/cli.js

@@ -9,6 +9,7 @@ import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Command } from 'commander';
 import chalk from 'chalk';
+import { findPackageRoot, getBuiltEntryCandidates } from './package-paths.js';
 import { fullName, getRegistry, strategyLabel } from './registry.js';
 import { serializeCommand, formatArgSummary } from './serialization.js';
 import { render as renderOutput } from './output.js';
@@ -268,13 +269,17 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
     const NETWORK_INTERCEPTOR_JS = `(function(){if(window.__opencli_net)return;window.__opencli_net=[];var M=200,B=50000,F=window.fetch;window.fetch=async function(){var r=await F.apply(this,arguments);try{var ct=r.headers.get('content-type')||'';if(ct.includes('json')||ct.includes('text')){var c=r.clone(),t=await c.text();if(window.__opencli_net.length<M){var b=null;if(t.length<=B)try{b=JSON.parse(t)}catch(e){b=t}window.__opencli_net.push({url:r.url||(arguments[0]&&arguments[0].url)||String(arguments[0]),method:(arguments[1]&&arguments[1].method)||'GET',status:r.status,size:t.length,ct:ct,body:b})}}}catch(e){}return r};var X=XMLHttpRequest.prototype,O=X.open,S=X.send;X.open=function(m,u){this._om=m;this._ou=u;return O.apply(this,arguments)};X.send=function(){var x=this;x.addEventListener('load',function(){try{var ct=x.getResponseHeader('content-type')||'';if((ct.includes('json')||ct.includes('text'))&&window.__opencli_net.length<M){var t=x.responseText,b=null;if(t&&t.length<=B)try{b=JSON.parse(t)}catch(e){b=t}window.__opencli_net.push({url:x._ou,method:x._om||'GET',status:x.status,size:t?t.length:0,ct:ct,body:b})}}catch(e){}});return S.apply(this,arguments)}})()`;
     operate.command('open').argument('<url>').description('Open URL in automation window')
         .action(operateAction(async (page, url) => {
+        // Start session-level capture before navigation (catches initial requests)
+        await page.startNetworkCapture?.();
         await page.goto(url);
         await page.wait(2);
-        // Auto-inject network interceptor for API discovery
-        try {
-            await page.evaluate(NETWORK_INTERCEPTOR_JS);
+        // Fallback: also inject JS interceptor for pages without session capture
+        if (!page.startNetworkCapture) {
+            try {
+                await page.evaluate(NETWORK_INTERCEPTOR_JS);
+            }
+            catch { /* non-fatal */ }
         }
-        catch { /* non-fatal */ }
         console.log(`Navigated to: ${await page.getCurrentUrl?.() ?? url}`);
     }));
     operate.command('back').description('Go back in browser history')
@@ -456,17 +461,46 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
         .option('--all', 'Show all requests including static resources')
         .description('Show captured network requests (auto-captured since last open)')
         .action(operateAction(async (page, opts) => {
-        const requests = await page.evaluate(`(function(){
-        var reqs = window.__opencli_net || [];
-        return JSON.stringify(reqs);
-      })()`);
         let items = [];
-        try {
-            items = JSON.parse(requests);
+        if (page.readNetworkCapture) {
+            const raw = await page.readNetworkCapture();
+            // Normalize daemon/CDP capture entries to __opencli_net shape.
+            // Daemon returns: responseStatus, responseContentType, responsePreview
+            // CDP returns the same shape after PR A fix.
+            items = raw.map(e => {
+                const preview = e.responsePreview ?? null;
+                let body = null;
+                if (preview) {
+                    try {
+                        body = JSON.parse(preview);
+                    }
+                    catch {
+                        body = preview;
+                    }
+                }
+                return {
+                    url: e.url || '',
+                    method: e.method || 'GET',
+                    status: e.responseStatus || 0,
+                    size: preview ? preview.length : 0,
+                    ct: e.responseContentType || '',
+                    body,
+                };
+            });
         }
-        catch {
-            console.log('No network data captured. Run "operate open <url>" first.');
-            return;
+        else {
+            // Fallback to JS interceptor data
+            const requests = await page.evaluate(`(function(){
+          var reqs = window.__opencli_net || [];
+          return JSON.stringify(reqs);
+        })()`);
+            try {
+                items = JSON.parse(requests);
+            }
+            catch {
+                console.log('No network data captured. Run "operate open <url>" first.');
+                return;
+            }
         }
         if (items.length === 0) {
             console.log('No requests captured.');
@@ -943,39 +977,7 @@ cli({
 export function runCli(BUILTIN_CLIS, USER_CLIS) {
     createProgram(BUILTIN_CLIS, USER_CLIS).parse();
 }
-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 { findPackageRoot };
 export function resolveOperateVerifyInvocation(opts = {}) {
     const platform = opts.platform ?? process.platform;
     const fileExists = opts.fileExists ?? fs.existsSync;

package/dist/src/commands/daemon.js

@@ -6,15 +6,7 @@
  */
 import chalk from 'chalk';
 import { fetchDaemonStatus, requestDaemonShutdown } from '../browser/daemon-client.js';
-function formatUptime(seconds) {
-    const h = Math.floor(seconds / 3600);
-    const m = Math.floor((seconds % 3600) / 60);
-    if (h > 0)
-        return `${h}h ${m}m`;
-    if (m > 0)
-        return `${m}m`;
-    return `${Math.floor(seconds)}s`;
-}
+import { formatDuration } from '../download/progress.js';
 function formatTimeSince(timestampMs) {
     const seconds = (Date.now() - timestampMs) / 1000;
     if (seconds < 60)
@@ -32,7 +24,7 @@ export async function daemonStatus() {
         return;
     }
     console.log(`Daemon: ${chalk.green('running')} (PID ${status.pid})`);
-    console.log(`Uptime: ${formatUptime(status.uptime)}`);
+    console.log(`Uptime: ${formatDuration(Math.round(status.uptime * 1000))}`);
     console.log(`Extension: ${status.extensionConnected ? chalk.green('connected') : chalk.yellow('disconnected')}`);
     console.log(`Last CLI request: ${formatTimeSince(status.lastCliRequestTime)}`);
     console.log(`Memory: ${status.memoryMB} MB`);

package/dist/src/diagnostic.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 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[];
+        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 YAML/TS and manifest lazy-loaded TS)
+ * 2. cmd._modulePath (set for manifest lazy-loaded TS, points to dist/)
+ *
+ * For dist/ paths, attempt to map back to the original .ts source file.
+ * 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;

package/dist/src/diagnostic.js

@@ -0,0 +1,247 @@
+/**
+ * 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 * as fs from 'node:fs';
+import * as path from 'node:path';
+import { CliError, getErrorMessage } from './errors.js';
+import { fullName } from './registry.js';
+// ── Size budgets ─────────────────────────────────────────────────────────────
+/** Maximum bytes for the entire diagnostic JSON output. */
+export const MAX_DIAGNOSTIC_BYTES = 256 * 1024; // 256 KB
+/** Maximum characters for DOM snapshot. */
+const MAX_SNAPSHOT_CHARS = 100_000;
+/** Maximum characters for adapter source. */
+const MAX_SOURCE_CHARS = 50_000;
+/** Maximum number of network requests to include. */
+const MAX_NETWORK_REQUESTS = 50;
+/** Maximum characters for a single network request body. */
+const MAX_REQUEST_BODY_CHARS = 4_000;
+/** Maximum characters for error stack trace. */
+const MAX_STACK_CHARS = 5_000;
+// ── Sensitive data patterns ──────────────────────────────────────────────────
+const SENSITIVE_HEADERS = new Set([
+    'authorization',
+    'cookie',
+    'set-cookie',
+    'x-csrf-token',
+    'x-xsrf-token',
+    'proxy-authorization',
+    'x-api-key',
+    'x-auth-token',
+]);
+const SENSITIVE_URL_PARAMS = /([?&])(token|key|secret|password|auth|access_token|api_key|session_id|csrf)=[^&]*/gi;
+/** Patterns that match inline secrets in free-text strings (error messages, stack traces, console output, DOM). */
+const SENSITIVE_TEXT_PATTERNS = [
+    // Bearer tokens
+    { pattern: /Bearer\s+[A-Za-z0-9\-._~+/]+=*/gi, replacement: 'Bearer [REDACTED]' },
+    // Generic "token=...", "key=...", etc. in non-URL text
+    { pattern: /(token|secret|password|api_key|apikey|access_token|session_id)[=:]\s*['"]?[A-Za-z0-9\-._~+/]{8,}['"]?/gi, replacement: '$1=[REDACTED]' },
+    // Cookie header values (key=value pairs)
+    { pattern: /(cookie[=:]\s*)[^\n;]{10,}/gi, replacement: '$1[REDACTED]' },
+    // JWT-like tokens (three base64 segments separated by dots)
+    { pattern: /eyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g, replacement: '[REDACTED_JWT]' },
+];
+// ── Redaction helpers ────────────────────────────────────────────────────────
+/** Truncate a string to maxLen, appending a truncation marker. */
+export function truncate(str, maxLen) {
+    if (str.length <= maxLen)
+        return str;
+    return str.slice(0, maxLen) + `\n...[truncated, ${str.length - maxLen} chars omitted]`;
+}
+/** Redact sensitive query parameters from a URL. */
+export function redactUrl(url) {
+    return url.replace(SENSITIVE_URL_PARAMS, '$1$2=[REDACTED]');
+}
+/** Redact inline secrets from free-text strings (error messages, stack traces, console output, DOM). */
+export function redactText(text) {
+    let result = text;
+    for (const { pattern, replacement } of SENSITIVE_TEXT_PATTERNS) {
+        // Reset lastIndex for global regexps
+        pattern.lastIndex = 0;
+        result = result.replace(pattern, replacement);
+    }
+    return result;
+}
+/** Redact sensitive headers from a headers object. */
+function redactHeaders(headers) {
+    if (!headers || typeof headers !== 'object')
+        return headers;
+    const result = {};
+    for (const [key, value] of Object.entries(headers)) {
+        result[key] = SENSITIVE_HEADERS.has(key.toLowerCase()) ? '[REDACTED]' : value;
+    }
+    return result;
+}
+/** Redact sensitive data from a single network request entry. */
+function redactNetworkRequest(req) {
+    if (!req || typeof req !== 'object')
+        return req;
+    const r = req;
+    const redacted = { ...r };
+    // Redact URL
+    if (typeof redacted.url === 'string') {
+        redacted.url = redactUrl(redacted.url);
+    }
+    // Redact headers
+    if (redacted.headers && typeof redacted.headers === 'object') {
+        redacted.headers = redactHeaders(redacted.headers);
+    }
+    if (redacted.requestHeaders && typeof redacted.requestHeaders === 'object') {
+        redacted.requestHeaders = redactHeaders(redacted.requestHeaders);
+    }
+    if (redacted.responseHeaders && typeof redacted.responseHeaders === 'object') {
+        redacted.responseHeaders = redactHeaders(redacted.responseHeaders);
+    }
+    // Truncate response body
+    if (typeof redacted.body === 'string') {
+        redacted.body = truncate(redacted.body, MAX_REQUEST_BODY_CHARS);
+    }
+    return redacted;
+}
+// ── Timeout helper ───────────────────────────────────────────────────────────
+/** Timeout for page state collection (prevents hang when CDP connection is stuck). */
+const PAGE_STATE_TIMEOUT_MS = 5_000;
+function withTimeout(promise, ms, fallback) {
+    return Promise.race([
+        promise,
+        new Promise(resolve => setTimeout(() => resolve(fallback), ms)),
+    ]);
+}
+// ── Source path resolution ───────────────────────────────────────────────────
+/**
+ * Resolve the editable source file path for an adapter.
+ *
+ * Priority:
+ * 1. cmd.source (set for FS-scanned YAML/TS and manifest lazy-loaded TS)
+ * 2. cmd._modulePath (set for manifest lazy-loaded TS, points to dist/)
+ *
+ * For dist/ paths, attempt to map back to the original .ts source file.
+ * Skip manifest: prefixed pseudo-paths (YAML commands inlined in manifest).
+ */
+export function resolveAdapterSourcePath(cmd) {
+    const candidates = [];
+    // cmd.source may be a real file path or 'manifest:site/name'
+    if (cmd.source && !cmd.source.startsWith('manifest:')) {
+        candidates.push(cmd.source);
+    }
+    if (cmd._modulePath) {
+        candidates.push(cmd._modulePath);
+    }
+    for (const candidate of candidates) {
+        // Try to map dist/ compiled JS back to source .ts
+        const sourceTs = mapDistToSource(candidate);
+        if (sourceTs && fs.existsSync(sourceTs))
+            return sourceTs;
+        // Try the candidate directly (YAML files, user clis, etc.)
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return candidates[0]; // Return best guess even if file doesn't exist
+}
+/** Map a dist/clis/xxx.js path back to clis/xxx.ts source. */
+function mapDistToSource(filePath) {
+    // dist/clis/site/command.js → clis/site/command.ts
+    const normalized = filePath.replace(/\\/g, '/');
+    const distClisMatch = normalized.match(/^(.*)\/dist\/clis\/(.+)\.js$/);
+    if (distClisMatch) {
+        return path.join(distClisMatch[1], 'clis', distClisMatch[2] + '.ts');
+    }
+    return null;
+}
+// ── Diagnostic collection ────────────────────────────────────────────────────
+/** Whether diagnostic mode is enabled. */
+export function isDiagnosticEnabled() {
+    return process.env.OPENCLI_DIAGNOSTIC === '1';
+}
+/** Safely collect page diagnostic state with redaction, size caps, and timeout. */
+async function collectPageState(page) {
+    const collect = async () => {
+        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(() => []),
+            ]);
+            const rawUrl = url ?? 'unknown';
+            return {
+                url: redactUrl(rawUrl),
+                snapshot: redactText(truncate(snapshot, MAX_SNAPSHOT_CHARS)),
+                networkRequests: networkRequests
+                    .slice(0, MAX_NETWORK_REQUESTS)
+                    .map(redactNetworkRequest),
+                consoleErrors: consoleErrors
+                    .slice(0, 50)
+                    .map(e => typeof e === 'string' ? redactText(e) : e),
+            };
+        }
+        catch {
+            return undefined;
+        }
+    };
+    return withTimeout(collect(), PAGE_STATE_TIMEOUT_MS, undefined);
+}
+/** Read adapter source file content with size cap. */
+function readAdapterSource(sourcePath) {
+    if (!sourcePath)
+        return undefined;
+    try {
+        const content = fs.readFileSync(sourcePath, 'utf-8');
+        return truncate(content, MAX_SOURCE_CHARS);
+    }
+    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;
+    const sourcePath = resolveAdapterSourcePath(cmd);
+    return {
+        error: {
+            code: isCliError ? err.code : 'UNKNOWN',
+            message: redactText(getErrorMessage(err)),
+            hint: isCliError && err.hint ? redactText(err.hint) : undefined,
+            stack: err instanceof Error ? redactText(truncate(err.stack ?? '', MAX_STACK_CHARS)) : undefined,
+        },
+        adapter: {
+            site: cmd.site,
+            command: fullName(cmd),
+            sourcePath,
+            source: readAdapterSource(sourcePath),
+        },
+        page: pageState,
+        timestamp: new Date().toISOString(),
+    };
+}
+/** Collect full diagnostic context including page state (with timeout). */
+export async function collectDiagnostic(err, cmd, page) {
+    const pageState = page ? await collectPageState(page) : undefined;
+    return buildRepairContext(err, cmd, pageState);
+}
+/** Emit diagnostic JSON to stderr, enforcing total size cap. */
+export function emitDiagnostic(ctx) {
+    const marker = '___OPENCLI_DIAGNOSTIC___';
+    let json = JSON.stringify(ctx);
+    // Enforce total output budget — drop page state (largest section) first if over budget
+    if (json.length > MAX_DIAGNOSTIC_BYTES && ctx.page) {
+        const trimmed = { ...ctx, page: { ...ctx.page, snapshot: '[omitted: over size budget]', networkRequests: [] } };
+        json = JSON.stringify(trimmed);
+    }
+    // If still over budget, drop page entirely
+    if (json.length > MAX_DIAGNOSTIC_BYTES) {
+        const minimal = { ...ctx, page: undefined };
+        json = JSON.stringify(minimal);
+    }
+    process.stderr.write(`\n${marker}\n${json}\n${marker}\n`);
+}

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

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