@jackwener/opencli 1.4.1 → 1.5.1

package/extension/scripts/package-release.mjs

@@ -0,0 +1,179 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const extensionDir = path.resolve(__dirname, '..');
+const repoRoot = path.resolve(extensionDir, '..');
+
+function parseArgs(argv) {
+  const args = { outDir: path.join(repoRoot, 'extension-package') };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--out' && argv[i + 1]) {
+      const outDir = argv[++i];
+      args.outDir = path.isAbsolute(outDir)
+        ? outDir
+        : path.resolve(process.cwd(), outDir);
+    }
+  }
+  return args;
+}
+
+async function exists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isLocalAsset(ref) {
+  return typeof ref === 'string'
+    && ref.length > 0
+    && !ref.startsWith('http://')
+    && !ref.startsWith('https://')
+    && !ref.startsWith('//')
+    && !ref.startsWith('chrome://')
+    && !ref.startsWith('chrome-extension://')
+    && !ref.startsWith('data:')
+    && !ref.startsWith('#');
+}
+
+function addLocalAsset(files, ref) {
+  if (isLocalAsset(ref)) files.add(ref);
+}
+
+function collectManifestEntrypoints(manifest) {
+  const files = new Set(['manifest.json']);
+
+  addLocalAsset(files, manifest.background?.service_worker);
+  addLocalAsset(files, manifest.action?.default_popup);
+  addLocalAsset(files, manifest.options_page);
+  addLocalAsset(files, manifest.devtools_page);
+  addLocalAsset(files, manifest.side_panel?.default_path);
+
+  for (const ref of Object.values(manifest.icons ?? {})) addLocalAsset(files, ref);
+  for (const ref of Object.values(manifest.action?.default_icon ?? {})) addLocalAsset(files, ref);
+  for (const contentScript of manifest.content_scripts ?? []) {
+    for (const jsFile of contentScript.js ?? []) addLocalAsset(files, jsFile);
+    for (const cssFile of contentScript.css ?? []) addLocalAsset(files, cssFile);
+  }
+  for (const page of manifest.sandbox?.pages ?? []) addLocalAsset(files, page);
+  for (const overridePage of Object.values(manifest.chrome_url_overrides ?? {})) addLocalAsset(files, overridePage);
+  for (const entry of manifest.web_accessible_resources ?? []) {
+    for (const resource of entry.resources ?? []) addLocalAsset(files, resource);
+  }
+  if (manifest.default_locale) files.add('_locales');
+
+  return [...files];
+}
+
+async function collectHtmlDependencies(relativeHtmlPath, files, visited) {
+  if (visited.has(relativeHtmlPath)) return;
+  visited.add(relativeHtmlPath);
+
+  const htmlPath = path.join(extensionDir, relativeHtmlPath);
+  const html = await fs.readFile(htmlPath, 'utf8');
+  const attrRe = /\b(?:src|href)=["']([^"'#?]+(?:\?[^"']*)?)["']/gi;
+
+  for (const match of html.matchAll(attrRe)) {
+    const rawRef = match[1];
+    const cleanRef = rawRef.split('?')[0];
+    if (!isLocalAsset(cleanRef)) continue;
+
+    const resolvedRelativePath = cleanRef.startsWith('/')
+      ? cleanRef.slice(1)
+      : path.posix.normalize(path.posix.join(path.posix.dirname(relativeHtmlPath), cleanRef));
+
+    addLocalAsset(files, resolvedRelativePath);
+    if (resolvedRelativePath.endsWith('.html')) {
+      await collectHtmlDependencies(resolvedRelativePath, files, visited);
+    }
+  }
+}
+
+async function collectManifestAssets(manifest) {
+  const files = new Set(collectManifestEntrypoints(manifest));
+  const htmlPages = [];
+
+  if (manifest.action?.default_popup) {
+    htmlPages.push(manifest.action.default_popup);
+  }
+  if (manifest.options_page) htmlPages.push(manifest.options_page);
+  if (manifest.devtools_page) htmlPages.push(manifest.devtools_page);
+  if (manifest.side_panel?.default_path) htmlPages.push(manifest.side_panel.default_path);
+  for (const page of manifest.sandbox?.pages ?? []) htmlPages.push(page);
+  for (const overridePage of Object.values(manifest.chrome_url_overrides ?? {})) htmlPages.push(overridePage);
+
+  const visited = new Set();
+  for (const htmlPage of htmlPages) {
+    if (isLocalAsset(htmlPage)) {
+      await collectHtmlDependencies(htmlPage, files, visited);
+    }
+  }
+
+  return [...files];
+}
+
+async function copyEntry(relativePath, outDir) {
+  const fromPath = path.join(extensionDir, relativePath);
+  const toPath = path.join(outDir, relativePath);
+  const stats = await fs.stat(fromPath);
+
+  if (stats.isDirectory()) {
+    await fs.cp(fromPath, toPath, { recursive: true });
+    return;
+  }
+
+  await fs.mkdir(path.dirname(toPath), { recursive: true });
+  await fs.copyFile(fromPath, toPath);
+}
+
+async function findMissingEntries(baseDir, entries) {
+  const missingEntries = [];
+  for (const relativePath of entries) {
+    const absolutePath = path.join(baseDir, relativePath);
+    if (!(await exists(absolutePath))) {
+      missingEntries.push(relativePath);
+    }
+  }
+  return missingEntries;
+}
+
+async function main() {
+  const { outDir } = parseArgs(process.argv.slice(2));
+  const manifestPath = path.join(extensionDir, 'manifest.json');
+  const manifest = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+
+  const requiredEntries = await collectManifestAssets(manifest);
+  const missingEntries = await findMissingEntries(extensionDir, requiredEntries);
+
+  if (missingEntries.length > 0) {
+    console.error('Missing files referenced by the extension package:');
+    for (const missingEntry of missingEntries) console.error(`- ${missingEntry}`);
+    process.exit(1);
+  }
+
+  await fs.rm(outDir, { recursive: true, force: true });
+  await fs.mkdir(outDir, { recursive: true });
+
+  for (const relativePath of requiredEntries) {
+    await copyEntry(relativePath, outDir);
+  }
+
+  // Guard against regressions where manifest entry files (e.g. action.default_popup)
+  // are accidentally omitted from the packaged directory.
+  const packagedEntrypoints = collectManifestEntrypoints(manifest);
+  const missingPackagedEntrypoints = await findMissingEntries(outDir, packagedEntrypoints);
+  if (missingPackagedEntrypoints.length > 0) {
+    console.error('Packaged extension is missing files referenced by manifest.json:');
+    for (const missingEntry of missingPackagedEntrypoints) console.error(`- ${missingEntry}`);
+    process.exit(1);
+  }
+
+  console.log(`Extension package prepared at ${path.relative(repoRoot, outDir) || outDir}`);
+}
+
+await main();

package/extension/src/background.ts

@@ -51,6 +51,8 @@ function connect(): void {
       clearTimeout(reconnectTimer);
       reconnectTimer = null;
     }
+    // Send version so the daemon can report mismatches to the CLI
+    ws?.send(JSON.stringify({ type: 'hello', version: chrome.runtime.getManifest().version }));
   };
 
   ws.onmessage = async (event) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "1.4.1",
+  "version": "1.5.1",
   "publishConfig": {
     "access": "public"
   },
@@ -19,17 +19,20 @@
   },
   "scripts": {
     "dev": "tsx src/main.ts",
+    "dev:bun": "bun src/main.ts",
     "build": "npm run clean-dist && tsc && npm run clean-yaml && npm run copy-yaml && npm run build-manifest",
     "build-manifest": "node dist/build-manifest.js",
     "clean-dist": "node scripts/clean-dist.cjs",
     "clean-yaml": "node scripts/clean-yaml.cjs",
     "copy-yaml": "node scripts/copy-yaml.cjs",
     "start": "node dist/main.js",
+    "start:bun": "bun dist/main.js",
     "postinstall": "node scripts/postinstall.js || true",
     "typecheck": "tsc --noEmit",
     "lint": "tsc --noEmit",
     "prepublishOnly": "npm run build",
     "test": "vitest run --project unit",
+    "test:bun": "bun vitest run --project unit",
     "test:adapter": "vitest run --project adapter",
     "test:all": "vitest run",
     "test:e2e": "vitest run --project e2e",

package/scripts/postinstall.js

@@ -195,6 +195,16 @@ function main() {
       console.error(`Warning: Could not install shell completion: ${err.message}`);
     }
   }
+
+  // ── Browser Bridge setup hint ───────────────────────────────────────
+  console.log('');
+  console.log('  \x1b[1mNext step — Browser Bridge setup\x1b[0m');
+  console.log('  Browser commands (bilibili, zhihu, twitter...) require the extension:');
+  console.log('  1. Download: https://github.com/jackwener/opencli/releases');
+  console.log('  2. Open chrome://extensions → enable Developer Mode → Load unpacked');
+  console.log('');
+  console.log('  Then run \x1b[36mopencli doctor\x1b[0m to verify.');
+  console.log('');
 }
 
 main();

package/src/browser/cdp.ts

@@ -12,6 +12,7 @@ import { WebSocket, type RawData } from 'ws';
 import { request as httpRequest } from 'node:http';
 import { request as httpsRequest } from 'node:https';
 import type { BrowserCookie, IPage, ScreenshotOptions, SnapshotOptions, WaitOptions } from '../types.js';
+import type { IBrowserFactory } from '../runtime.js';
 import { wrapForEval } from './utils.js';
 import { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
 import { generateStealthJs } from './stealth.js';
@@ -47,7 +48,7 @@ interface RuntimeEvaluateResult {
 
 const CDP_SEND_TIMEOUT = 30_000;
 
-export class CDPBridge {
+export class CDPBridge implements IBrowserFactory {
   private _ws: WebSocket | null = null;
   private _idCounter = 0;
   private _pending = new Map<number, { resolve: (val: unknown) => void; reject: (err: Error) => void; timer: ReturnType<typeof setTimeout> }>();
@@ -172,6 +173,7 @@ export class CDPBridge {
 
 class CDPPage implements IPage {
   private _pageEnabled = false;
+  private _lastUrl: string | null = null;
   constructor(private bridge: CDPBridge) {}
 
   async goto(url: string, options?: { waitUntil?: 'load' | 'none'; settleMs?: number }): Promise<void> {
@@ -182,6 +184,7 @@ class CDPPage implements IPage {
     const loadPromise = this.bridge.waitForEvent('Page.loadEventFired', 30_000).catch(() => {});
     await this.bridge.send('Page.navigate', { url });
     await loadPromise;
+    this._lastUrl = url;
     if (options?.waitUntil !== 'none') {
       const maxMs = options?.settleMs ?? 1000;
       await this.evaluate(waitForDomStableJs(maxMs, Math.min(500, maxMs)));
@@ -306,6 +309,10 @@ class CDPPage implements IPage {
     return [];
   }
 
+  async getCurrentUrl(): Promise<string | null> {
+    return this._lastUrl;
+  }
+
   async installInterceptor(pattern: string): Promise<void> {
     const { generateInterceptorJs } = await import('../interceptor.js');
     await this.evaluate(generateInterceptorJs(JSON.stringify(pattern), {

package/src/browser/discover.ts

@@ -13,17 +13,22 @@ export { isDaemonRunning };
 /**
  * Check daemon status and return connection info.
  */
-export async function checkDaemonStatus(): Promise<{
+export async function checkDaemonStatus(opts?: { timeout?: number }): Promise<{
   running: boolean;
   extensionConnected: boolean;
+  extensionVersion?: string;
 }> {
   try {
     const port = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts?.timeout ?? 2000);
     const res = await fetch(`http://127.0.0.1:${port}/status`, {
       headers: { 'X-OpenCLI': '1' },
+      signal: controller.signal,
     });
-    const data = await res.json() as { ok: boolean; extensionConnected: boolean };
-    return { running: true, extensionConnected: data.extensionConnected };
+    const data = await res.json() as { ok: boolean; extensionConnected: boolean; extensionVersion?: string };
+    clearTimeout(timer);
+    return { running: true, extensionConnected: data.extensionConnected, extensionVersion: data.extensionVersion };
   } catch {
     return { running: false, extensionConnected: false };
   }

package/src/browser/errors.ts

@@ -5,38 +5,37 @@
  * The daemon architecture has a single failure mode: daemon not reachable or extension not connected.
  */
 
-import { BrowserConnectError } from '../errors.js';
+import { BrowserConnectError, type BrowserConnectKind } from '../errors.js';
 import { DEFAULT_DAEMON_PORT } from '../constants.js';
 
-export type ConnectFailureKind = 'daemon-not-running' | 'extension-not-connected' | 'command-failed' | 'unknown';
+// Re-export so callers don't need to import from two places
+export type ConnectFailureKind = BrowserConnectKind;
 
 export function formatBrowserConnectError(kind: ConnectFailureKind, detail?: string): BrowserConnectError {
   switch (kind) {
     case 'daemon-not-running':
       return new BrowserConnectError(
-        'Cannot connect to opencli daemon.' +
-        (detail ? `\n\n${detail}` : ''),
-        'The daemon should start automatically. If it doesn\'t, try:\n' +
-        '  node dist/daemon.js\n' +
-        `Make sure port ${DEFAULT_DAEMON_PORT} is available.`,
+        'Cannot connect to opencli daemon.' + (detail ? `\n\n${detail}` : ''),
+        `The daemon should auto-start. If it keeps failing, make sure port ${DEFAULT_DAEMON_PORT} is available.`,
+        kind,
       );
     case 'extension-not-connected':
       return new BrowserConnectError(
-        'opencli Browser Bridge extension is not connected.' +
-        (detail ? `\n\n${detail}` : ''),
-        'Please install the extension:\n' +
-        '  1. Download from GitHub Releases\n' +
-        '  2. Open chrome://extensions/ → Enable Developer Mode\n' +
-        '  3. Click "Load unpacked" → select the extension folder\n' +
-        '  4. Make sure Chrome is running',
+        'Browser Bridge extension is not connected.' + (detail ? `\n\n${detail}` : ''),
+        'Install the extension from GitHub Releases, then reload.',
+        kind,
       );
     case 'command-failed':
       return new BrowserConnectError(
         `Browser command failed: ${detail ?? 'unknown error'}`,
+        undefined,
+        kind,
       );
     default:
       return new BrowserConnectError(
         detail ?? 'Failed to connect to browser',
+        undefined,
+        kind,
       );
   }
 }

package/src/browser/mcp.ts

@@ -7,6 +7,7 @@ import { fileURLToPath } from 'node:url';
 import * as path from 'node:path';
 import * as fs from 'node:fs';
 import type { IPage } from '../types.js';
+import type { IBrowserFactory } from '../runtime.js';
 import { Page } from './page.js';
 import { isDaemonRunning, isExtensionConnected } from './daemon-client.js';
 import { DEFAULT_DAEMON_PORT } from '../constants.js';
@@ -18,7 +19,7 @@ export type BrowserBridgeState = 'idle' | 'connecting' | 'connected' | 'closing'
 /**
  * Browser factory: manages daemon lifecycle and provides IPage instances.
  */
-export class BrowserBridge {
+export class BrowserBridge implements IBrowserFactory {
   private _state: BrowserBridgeState = 'idle';
   private _page: Page | null = null;
   private _daemonProc: ChildProcess | null = null;

package/src/browser/page.ts

@@ -36,6 +36,8 @@ export class Page implements IPage {
 
   /** Active tab ID, set after navigate and used in all subsequent commands */
   private _tabId: number | undefined;
+  /** Last navigated URL, tracked in-memory to avoid extra round-trips */
+  private _lastUrl: string | null = null;
 
   /** Helper: spread workspace into command params */
   private _wsOpt(): { workspace: string } {
@@ -55,10 +57,11 @@ export class Page implements IPage {
       url,
       ...this._cmdOpts(),
     }) as { tabId?: number };
-    // Remember the tabId for subsequent exec calls
+    // Remember the tabId and URL for subsequent calls
     if (result?.tabId) {
       this._tabId = result.tabId;
     }
+    this._lastUrl = url;
     // Inject stealth anti-detection patches (guard flag prevents double-injection).
     try {
       await sendCommand('exec', {
@@ -79,6 +82,10 @@ export class Page implements IPage {
     }
   }
 
+  async getCurrentUrl(): Promise<string | null> {
+    return this._lastUrl;
+  }
+
   /** Close the automation window in the extension */
   async closeWindow(): Promise<void> {
     try {
@@ -183,6 +190,22 @@ export class Page implements IPage {
 
   async wait(options: number | WaitOptions): Promise<void> {
     if (typeof options === 'number') {
+      if (options >= 1) {
+        // For waits >= 1s, use DOM-stable check: return early when the page
+        // stops mutating, with the original wait time as the hard cap.
+        // This turns e.g. `page.wait(5)` from a fixed 5s sleep into
+        // "wait until DOM is stable, max 5s" — often completing in <1s.
+        try {
+          const maxMs = options * 1000;
+          await sendCommand('exec', {
+            code: waitForDomStableJs(maxMs, Math.min(500, maxMs)),
+            ...this._cmdOpts(),
+          });
+          return;
+        } catch {
+          // Fallback: fixed sleep (e.g. if page has no DOM yet)
+        }
+      }
       await new Promise(resolve => setTimeout(resolve, options * 1000));
       return;
     }

package/src/build-manifest.test.ts

@@ -143,4 +143,27 @@ describe('manifest helper rules', () => {
       modulePath: 'xueqiu/fund-holdings.js',
     });
   });
+
+  it('captures deprecated metadata for TS adapters', () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-manifest-'));
+    tempDirs.push(dir);
+    const file = path.join(dir, 'legacy.ts');
+    fs.writeFileSync(file, `
+      import { cli } from '../../registry.js';
+      cli({
+        site: 'demo',
+        name: 'legacy',
+        description: 'legacy command',
+        deprecated: 'legacy is deprecated',
+        replacedBy: 'opencli demo new',
+      });
+    `);
+
+    expect(scanTs(file, 'demo')).toMatchObject({
+      site: 'demo',
+      name: 'legacy',
+      deprecated: 'legacy is deprecated',
+      replacedBy: 'opencli demo new',
+    });
+  });
 });

package/src/build-manifest.ts

@@ -38,6 +38,8 @@ export interface ManifestEntry {
   columns?: string[];
   pipeline?: Record<string, unknown>[];
   timeout?: number;
+  deprecated?: boolean | string;
+  replacedBy?: string;
   /** 'yaml' or 'ts' — determines how executeCommand loads the handler */
   type: 'yaml' | 'ts';
   /** Relative path from clis/ dir, e.g. 'bilibili/hot.yaml' or 'bilibili/search.js' */
@@ -46,7 +48,7 @@ export interface ManifestEntry {
   navigateBefore?: boolean | string;
 }
 
-import type { YamlCliDefinition } from './yaml-schema.js';
+import { type YamlCliDefinition, parseYamlArgs } from './yaml-schema.js';
 
 import { isRecord } from './utils.js';
 
@@ -173,20 +175,7 @@ function scanYaml(filePath: string, site: string): ManifestEntry | null {
     const strategy = strategyStr.toUpperCase();
     const browser = cliDef.browser ?? (strategy !== 'PUBLIC');
 
-    const args: ManifestEntry['args'] = [];
-    if (cliDef.args && typeof cliDef.args === 'object') {
-      for (const [argName, argDef] of Object.entries(cliDef.args)) {
-        args.push({
-          name: argName,
-          type: argDef?.type ?? 'str',
-          default: argDef?.default,
-          required: argDef?.required ?? false,
-          positional: argDef?.positional === true || undefined,
-          help: argDef?.description ?? argDef?.help ?? '',
-          choices: argDef?.choices,
-        });
-      }
-    }
+    const args = parseYamlArgs(cliDef.args);
 
     return {
       site: cliDef.site ?? site,
@@ -199,6 +188,8 @@ function scanYaml(filePath: string, site: string): ManifestEntry | null {
       columns: cliDef.columns,
       pipeline: cliDef.pipeline,
       timeout: cliDef.timeout,
+      deprecated: (cliDef as Record<string, unknown>).deprecated as boolean | string | undefined,
+      replacedBy: (cliDef as Record<string, unknown>).replacedBy as string | undefined,
       type: 'yaml',
       navigateBefore: cliDef.navigateBefore,
     };
@@ -269,6 +260,17 @@ export function scanTs(filePath: string, site: string): ManifestEntry | null {
       if (navStringMatch) entry.navigateBefore = navStringMatch[1];
     }
 
+    const deprecatedBoolMatch = src.match(/deprecated\s*:\s*(true|false)/);
+    if (deprecatedBoolMatch) {
+      entry.deprecated = deprecatedBoolMatch[1] === 'true';
+    } else {
+      const deprecatedStringMatch = src.match(/deprecated\s*:\s*['"`]([^'"`]+)['"`]/);
+      if (deprecatedStringMatch) entry.deprecated = deprecatedStringMatch[1];
+    }
+
+    const replacedByMatch = src.match(/replacedBy\s*:\s*['"`]([^'"`]+)['"`]/);
+    if (replacedByMatch) entry.replacedBy = replacedByMatch[1];
+
     return entry;
   } catch (err) {
     // If parsing fails, log a warning (matching scanYaml behaviour) and skip the entry.
@@ -338,6 +340,29 @@ function main(): void {
   const yamlCount = manifest.filter(e => e.type === 'yaml').length;
   const tsCount = manifest.filter(e => e.type === 'ts').length;
   console.log(`✅ Manifest compiled: ${manifest.length} entries (${yamlCount} YAML, ${tsCount} TS) → ${OUTPUT}`);
+
+  // Restore executable permissions on bin entries.
+  // tsc does not preserve the +x bit, so after a clean rebuild the CLI
+  // 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');
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      const bins: Record<string, string> = typeof pkg.bin === 'string'
+        ? { [pkg.name ?? 'cli']: pkg.bin }
+        : pkg.bin ?? {};
+      for (const binPath of Object.values(bins)) {
+        const abs = path.resolve(__dirname, '..', binPath);
+        if (fs.existsSync(abs)) {
+          fs.chmodSync(abs, 0o755);
+          console.log(`✅ Restored executable permission: ${binPath}`);
+        }
+      }
+    } catch {
+      // Best-effort; never break the build for a permission fix.
+    }
+  }
 }
 
 const entrypoint = process.argv[1] ? pathToFileURL(path.resolve(process.argv[1])).href : null;

package/src/capabilityRouting.ts

@@ -1,6 +1,7 @@
 import { Strategy, type CliCommand } from './registry.js';
 
-const BROWSER_ONLY_STEPS = new Set([
+/** Pipeline steps that require a live browser session. */
+export const BROWSER_ONLY_STEPS = new Set([
   'navigate',
   'click',
   'type',