@jackwener/opencli 1.5.3 → 1.5.4

package/dist/daemon.js

@@ -90,7 +90,20 @@ async function handleRequest(req, res) {
         res.end();
         return;
     }
-    // Require custom header on all HTTP requests.  Browsers cannot attach
+    const url = req.url ?? '/';
+    const pathname = url.split('?')[0];
+    // Health-check endpoint — no X-OpenCLI header required.
+    // Used by the extension to silently probe daemon reachability before
+    // attempting a WebSocket connection (avoids uncatchable ERR_CONNECTION_REFUSED).
+    // Security note: this endpoint is reachable by any client that passes the
+    // origin check above (chrome-extension:// or no Origin header, e.g. curl).
+    // Timing side-channels can reveal daemon presence to local processes, which
+    // is an accepted risk given the daemon is loopback-only and short-lived.
+    if (req.method === 'GET' && pathname === '/ping') {
+        jsonResponse(res, 200, { ok: true });
+        return;
+    }
+    // Require custom header on all other HTTP requests.  Browsers cannot attach
     // custom headers in "simple" requests, and our preflight returns no
     // Access-Control-Allow-Headers, so scripted fetch() from web pages is
     // blocked even if Origin check is somehow bypassed.
@@ -98,8 +111,6 @@ async function handleRequest(req, res) {
         jsonResponse(res, 403, { ok: false, error: 'Forbidden: missing X-OpenCLI header' });
         return;
     }
-    const url = req.url ?? '/';
-    const pathname = url.split('?')[0];
     if (req.method === 'GET' && pathname === '/status') {
         jsonResponse(res, 200, {
             ok: true,

package/dist/external-clis.yaml

@@ -21,3 +21,19 @@
   tags: [docker, containers, devops]
   install:
     mac: "brew install --cask docker"
+
+- name: lark-cli
+  binary: lark-cli
+  description: "Lark/Feishu CLI — messages, documents, spreadsheets, calendar, tasks and 200+ commands for AI agents"
+  homepage: "https://github.com/larksuite/cli"
+  tags: [lark, feishu, collaboration, productivity, ai-agent]
+  install:
+    default: "npm install -g @larksuite/cli"
+
+- name: vercel
+  binary: vercel
+  description: "Vercel CLI — deploy projects, manage domains, env vars, logs and serverless functions"
+  homepage: "https://vercel.com/docs/cli"
+  tags: [vercel, deployment, serverless, frontend, devops]
+  install:
+    default: "npm install -g vercel"

package/dist/serialization.js

@@ -44,6 +44,11 @@ export function formatArgSummary(args) {
     })
         .join(' ');
 }
+function summarizeChoices(choices) {
+    if (choices.length <= 4)
+        return choices.join(', ');
+    return `${choices.slice(0, 4).join(', ')}, ... (+${choices.length - 4} more)`;
+}
 /** Generate the --help appendix showing registry metadata not exposed by Commander. */
 export function formatRegistryHelpText(cmd) {
     const lines = [];
@@ -51,7 +56,7 @@ export function formatRegistryHelpText(cmd) {
     for (const a of choicesArgs) {
         const prefix = a.positional ? `<${a.name}>` : `--${a.name}`;
         const def = a.default != null ? `  (default: ${a.default})` : '';
-        lines.push(`  ${prefix}: ${a.choices.join(', ')}${def}`);
+        lines.push(`  ${prefix}: ${summarizeChoices(a.choices)}${def}`);
     }
     const meta = [];
     meta.push(`Strategy: ${strategyLabel(cmd)}`);

package/dist/serialization.test.d.ts

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

package/dist/serialization.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { Strategy } from './registry.js';
+import { formatRegistryHelpText } from './serialization.js';
+describe('formatRegistryHelpText', () => {
+    it('summarizes long choices lists so help text stays readable', () => {
+        const cmd = {
+            site: 'demo',
+            name: 'dynamic',
+            description: 'Demo command',
+            strategy: Strategy.PUBLIC,
+            browser: false,
+            args: [
+                {
+                    name: 'field',
+                    help: 'Field to use',
+                    choices: ['all-fields', 'topic', 'title', 'author', 'publication-titles', 'year-published', 'doi'],
+                },
+            ],
+            columns: ['field'],
+        };
+        expect(formatRegistryHelpText(cmd)).toContain('--field: all-fields, topic, title, author, ... (+3 more)');
+    });
+});

package/extension/dist/background.js

@@ -1,6 +1,7 @@
 const DAEMON_PORT = 19825;
 const DAEMON_HOST = "localhost";
 const DAEMON_WS_URL = `ws://${DAEMON_HOST}:${DAEMON_PORT}/ext`;
+const DAEMON_PING_URL = `http://${DAEMON_HOST}:${DAEMON_PORT}/ping`;
 const WS_RECONNECT_BASE_DELAY = 2e3;
 const WS_RECONNECT_MAX_DELAY = 6e4;
 
@@ -149,8 +150,14 @@ console.error = (...args) => {
   _origError(...args);
   forwardLog("error", args);
 };
-function connect() {
+async function connect() {
   if (ws?.readyState === WebSocket.OPEN || ws?.readyState === WebSocket.CONNECTING) return;
+  try {
+    const res = await fetch(DAEMON_PING_URL, { signal: AbortSignal.timeout(1e3) });
+    if (!res.ok) return;
+  } catch {
+    return;
+  }
   try {
     ws = new WebSocket(DAEMON_WS_URL);
   } catch {
@@ -192,7 +199,7 @@ function scheduleReconnect() {
   const delay = Math.min(WS_RECONNECT_BASE_DELAY * Math.pow(2, reconnectAttempts - 1), WS_RECONNECT_MAX_DELAY);
   reconnectTimer = setTimeout(() => {
     reconnectTimer = null;
-    connect();
+    void connect();
   }, delay);
 }
 const automationSessions = /* @__PURE__ */ new Map();
@@ -260,7 +267,7 @@ function initialize() {
   initialized = true;
   chrome.alarms.create("keepalive", { periodInMinutes: 0.4 });
   registerListeners();
-  connect();
+  void connect();
   console.log("[opencli] OpenCLI extension initialized");
 }
 chrome.runtime.onInstalled.addListener(() => {
@@ -270,7 +277,7 @@ chrome.runtime.onStartup.addListener(() => {
   initialize();
 });
 chrome.alarms.onAlarm.addListener((alarm) => {
-  if (alarm.name === "keepalive") connect();
+  if (alarm.name === "keepalive") void connect();
 });
 chrome.runtime.onMessage.addListener((msg, _sender, sendResponse) => {
   if (msg?.type === "getStatus") {

package/extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "OpenCLI",
-  "version": "1.5.3",
+  "version": "1.5.4",
   "description": "Browser automation bridge for the OpenCLI CLI tool. Executes commands in isolated Chrome windows via a local daemon.",
   "permissions": [
     "debugger",
@@ -35,4 +35,4 @@
     "extension_pages": "script-src 'self'; object-src 'self'"
   },
   "homepage_url": "https://github.com/jackwener/opencli"
-}
+}

package/extension/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "opencli-extension",
-  "version": "1.5.3",
+  "version": "1.5.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "opencli-extension",
-      "version": "1.5.3",
+      "version": "1.5.4",
       "devDependencies": {
         "@types/chrome": "^0.0.287",
         "typescript": "^5.7.0",

package/extension/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencli-extension",
-  "version": "1.5.3",
+  "version": "1.5.4",
   "private": true,
   "type": "module",
   "scripts": {

package/extension/src/background.ts

@@ -6,7 +6,7 @@
  */
 
 import type { Command, Result } from './protocol';
-import { DAEMON_WS_URL, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY } from './protocol';
+import { DAEMON_WS_URL, DAEMON_PING_URL, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY } from './protocol';
 import * as executor from './cdp';
 
 let ws: WebSocket | null = null;
@@ -34,9 +34,23 @@ console.error = (...args: unknown[]) => { _origError(...args); forwardLog('error
 
 // ─── WebSocket connection ────────────────────────────────────────────
 
-function connect(): void {
+/**
+ * Probe the daemon via its /ping HTTP endpoint before attempting a WebSocket
+ * connection.  fetch() failures are silently catchable; new WebSocket() is not
+ * — Chrome logs ERR_CONNECTION_REFUSED to the extension error page before any
+ * JS handler can intercept it.  By keeping the probe inside connect() every
+ * call site remains unchanged and the guard can never be accidentally skipped.
+ */
+async function connect(): Promise<void> {
   if (ws?.readyState === WebSocket.OPEN || ws?.readyState === WebSocket.CONNECTING) return;
 
+  try {
+    const res = await fetch(DAEMON_PING_URL, { signal: AbortSignal.timeout(1000) });
+    if (!res.ok) return; // unexpected response — not our daemon
+  } catch {
+    return; // daemon not running — skip WebSocket to avoid console noise
+  }
+
   try {
     ws = new WebSocket(DAEMON_WS_URL);
   } catch {
@@ -90,7 +104,7 @@ function scheduleReconnect(): void {
   const delay = Math.min(WS_RECONNECT_BASE_DELAY * Math.pow(2, reconnectAttempts - 1), WS_RECONNECT_MAX_DELAY);
   reconnectTimer = setTimeout(() => {
     reconnectTimer = null;
-    connect();
+    void connect();
   }, delay);
 }
 
@@ -187,7 +201,7 @@ function initialize(): void {
   initialized = true;
   chrome.alarms.create('keepalive', { periodInMinutes: 0.4 }); // ~24 seconds
   executor.registerListeners();
-  connect();
+  void connect();
   console.log('[opencli] OpenCLI extension initialized');
 }
 
@@ -200,7 +214,7 @@ chrome.runtime.onStartup.addListener(() => {
 });
 
 chrome.alarms.onAlarm.addListener((alarm) => {
-  if (alarm.name === 'keepalive') connect();
+  if (alarm.name === 'keepalive') void connect();
 });
 
 // ─── Popup status API ───────────────────────────────────────────────

package/extension/src/protocol.ts

@@ -49,7 +49,8 @@ export interface Result {
 export const DAEMON_PORT = 19825;
 export const DAEMON_HOST = 'localhost';
 export const DAEMON_WS_URL = `ws://${DAEMON_HOST}:${DAEMON_PORT}/ext`;
-export const DAEMON_HTTP_URL = `http://${DAEMON_HOST}:${DAEMON_PORT}`;
+/** Lightweight health-check endpoint — probed before each WebSocket attempt. */
+export const DAEMON_PING_URL = `http://${DAEMON_HOST}:${DAEMON_PORT}/ping`;
 
 /** Base reconnect delay for extension WebSocket (ms) */
 export const WS_RECONNECT_BASE_DELAY = 2000;

package/package.json

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

package/src/build-manifest.test.ts

@@ -2,69 +2,8 @@ import { afterEach, describe, expect, it } from 'vitest';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
-import { parseTsArgsBlock, scanTs, shouldReplaceManifestEntry } from './build-manifest.js';
-
-describe('parseTsArgsBlock', () => {
-  it('keeps args with nested choices arrays', () => {
-    const args = parseTsArgsBlock(`
-      {
-        name: 'period',
-        type: 'string',
-        default: 'seven',
-        help: 'Stats period: seven or thirty',
-        choices: ['seven', 'thirty'],
-      },
-    `);
-
-    expect(args).toEqual([
-      {
-        name: 'period',
-        type: 'string',
-        default: 'seven',
-        required: false,
-        positional: undefined,
-        help: 'Stats period: seven or thirty',
-        choices: ['seven', 'thirty'],
-      },
-    ]);
-  });
-
-  it('keeps hyphenated arg names from TS adapters', () => {
-    const args = parseTsArgsBlock(`
-      {
-        name: 'tweet-url',
-        help: 'Single tweet URL to download',
-      },
-      {
-        name: 'download-images',
-        type: 'boolean',
-        default: false,
-        help: 'Download images locally',
-      },
-    `);
-
-    expect(args).toEqual([
-      {
-        name: 'tweet-url',
-        type: 'str',
-        default: undefined,
-        required: false,
-        positional: undefined,
-        help: 'Single tweet URL to download',
-        choices: undefined,
-      },
-      {
-        name: 'download-images',
-        type: 'boolean',
-        default: false,
-        required: false,
-        positional: undefined,
-        help: 'Download images locally',
-        choices: undefined,
-      },
-    ]);
-  });
-});
+import { cli, getRegistry, Strategy } from './registry.js';
+import { loadTsManifestEntries, shouldReplaceManifestEntry } from './build-manifest.js';
 
 describe('manifest helper rules', () => {
   const tempDirs: string[] = [];
@@ -127,43 +66,133 @@ describe('manifest helper rules', () => {
     const file = path.join(dir, 'utils.ts');
     fs.writeFileSync(file, `export function helper() { return 'noop'; }`);
 
-    expect(scanTs(file, 'demo')).toBeNull();
+    return expect(loadTsManifestEntries(file, 'demo', async () => ({}))).resolves.toEqual([]);
   });
 
-  it('keeps literal domain and navigateBefore for TS adapters', () => {
-    const file = path.join(process.cwd(), 'src', 'clis', 'xueqiu', 'fund-holdings.ts');
-    const entry = scanTs(file, 'xueqiu');
-
-    expect(entry).toMatchObject({
-      site: 'xueqiu',
-      name: 'fund-holdings',
-      domain: 'danjuanfunds.com',
-      navigateBefore: 'https://danjuanfunds.com/my-money',
-      type: 'ts',
-      modulePath: 'xueqiu/fund-holdings.js',
-    });
+  it('builds TS manifest entries from exported runtime commands', async () => {
+    const site = `manifest-hydrate-${Date.now()}`;
+    const key = `${site}/dynamic`;
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-manifest-'));
+    tempDirs.push(dir);
+    const file = path.join(dir, `${site}.ts`);
+    fs.writeFileSync(file, `export const command = cli({ site: '${site}', name: 'dynamic' });`);
+
+    const entries = await loadTsManifestEntries(file, site, async () => ({
+      command: cli({
+        site,
+        name: 'dynamic',
+        description: 'dynamic command',
+        strategy: Strategy.PUBLIC,
+        browser: false,
+        args: [
+          {
+            name: 'model',
+            required: true,
+            positional: true,
+            help: 'Choose a model',
+            choices: ['auto', 'thinking'],
+            default: '30',
+          },
+        ],
+        domain: 'localhost',
+        navigateBefore: 'https://example.com/session',
+        deprecated: 'legacy command',
+        replacedBy: 'opencli demo new',
+      }),
+    }));
+
+    expect(entries).toEqual([
+      {
+        site,
+        name: 'dynamic',
+        description: 'dynamic command',
+        domain: 'localhost',
+        strategy: 'public',
+        browser: false,
+        args: [
+          {
+            name: 'model',
+            type: 'str',
+            required: true,
+            positional: true,
+            help: 'Choose a model',
+            choices: ['auto', 'thinking'],
+            default: '30',
+          },
+        ],
+        type: 'ts',
+        modulePath: `${site}/${site}.js`,
+        navigateBefore: 'https://example.com/session',
+        deprecated: 'legacy command',
+        replacedBy: 'opencli demo new',
+      },
+    ]);
+
+    getRegistry().delete(key);
   });
 
-  it('captures deprecated metadata for TS adapters', () => {
+  it('falls back to registry delta for side-effect-only cli modules', async () => {
+    const site = `manifest-side-effect-${Date.now()}`;
+    const key = `${site}/legacy`;
     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';
+    const file = path.join(dir, `${site}.ts`);
+    fs.writeFileSync(file, `cli({ site: '${site}', name: 'legacy' });`);
+
+    const entries = await loadTsManifestEntries(file, site, async () => {
       cli({
-        site: 'demo',
+        site,
         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',
+      return {};
     });
+
+    expect(entries).toEqual([
+      {
+        site,
+        name: 'legacy',
+        description: 'legacy command',
+        strategy: 'cookie',
+        browser: true,
+        args: [],
+        type: 'ts',
+        modulePath: `${site}/${site}.js`,
+        deprecated: 'legacy is deprecated',
+        replacedBy: 'opencli demo new',
+      },
+    ]);
+
+    getRegistry().delete(key);
+  });
+
+  it('keeps every command a module exports instead of guessing by site', async () => {
+    const site = `manifest-multi-${Date.now()}`;
+    const screenKey = `${site}/screen`;
+    const statusKey = `${site}/status`;
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-manifest-'));
+    tempDirs.push(dir);
+    const file = path.join(dir, `${site}.ts`);
+    fs.writeFileSync(file, `export const screen = cli({ site: '${site}', name: 'screen' });`);
+
+    const entries = await loadTsManifestEntries(file, site, async () => ({
+      screen: cli({
+        site,
+        name: 'screen',
+        description: 'capture screen',
+      }),
+      status: cli({
+        site,
+        name: 'status',
+        description: 'show status',
+      }),
+    }));
+
+    expect(entries.map(entry => entry.name)).toEqual(['screen', 'status']);
+
+    getRegistry().delete(screenKey);
+    getRegistry().delete(statusKey);
   });
 });