@jackwener/opencli 1.5.3 → 1.5.4

package/src/build-manifest.ts

@@ -14,6 +14,7 @@ import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import yaml from 'js-yaml';
 import { getErrorMessage } from './errors.js';
+import { fullName, getRegistry, type CliCommand } from './registry.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const CLIS_DIR = path.resolve(__dirname, 'clis');
@@ -52,116 +53,50 @@ import { type YamlCliDefinition, parseYamlArgs } from './yaml-schema.js';
 
 import { isRecord } from './utils.js';
 
-
-function extractBalancedBlock(
-  source: string,
-  startIndex: number,
-  openChar: string,
-  closeChar: string,
-): string | null {
-  let depth = 0;
-  let quote: string | null = null;
-  let escaped = false;
-
-  for (let i = startIndex; i < source.length; i++) {
-    const ch = source[i];
-
-    if (quote) {
-      if (escaped) {
-        escaped = false;
-        continue;
-      }
-      if (ch === '\\') {
-        escaped = true;
-        continue;
-      }
-      if (ch === quote) quote = null;
-      continue;
-    }
-
-    if (ch === '"' || ch === '\'' || ch === '`') {
-      quote = ch;
-      continue;
-    }
-
-    if (ch === openChar) {
-      depth++;
-    } else if (ch === closeChar) {
-      depth--;
-      if (depth === 0) {
-        return source.slice(startIndex + 1, i);
-      }
-    }
-  }
-
-  return null;
+const CLI_MODULE_PATTERN = /\bcli\s*\(/;
+
+function toManifestArgs(args: CliCommand['args']): ManifestEntry['args'] {
+  return args.map(arg => ({
+    name: arg.name,
+    type: arg.type ?? 'str',
+    default: arg.default,
+    required: !!arg.required,
+    positional: arg.positional || undefined,
+    help: arg.help ?? '',
+    choices: arg.choices,
+  }));
 }
 
-function extractTsArgsBlock(source: string): string | null {
-  const argsMatch = source.match(/args\s*:/);
-  if (!argsMatch || argsMatch.index === undefined) return null;
-
-  const bracketIndex = source.indexOf('[', argsMatch.index);
-  if (bracketIndex === -1) return null;
-
-  return extractBalancedBlock(source, bracketIndex, '[', ']');
+function toTsModulePath(filePath: string, site: string): string {
+  const baseName = path.basename(filePath, path.extname(filePath));
+  return `${site}/${baseName}.js`;
 }
 
-function parseInlineChoices(body: string): string[] | undefined {
-  const choicesMatch = body.match(/choices\s*:\s*\[([^\]]*)\]/);
-  if (!choicesMatch) return undefined;
-
-  const values = choicesMatch[1]
-    .split(',')
-    .map(s => s.trim().replace(/^['"`]|['"`]$/g, ''))
-    .filter(Boolean);
-
-  return values.length > 0 ? values : undefined;
+function isCliCommandValue(value: unknown, site: string): value is CliCommand {
+  return isRecord(value)
+    && typeof value.site === 'string'
+    && value.site === site
+    && typeof value.name === 'string'
+    && Array.isArray(value.args);
 }
 
-export function parseTsArgsBlock(argsBlock: string): ManifestEntry['args'] {
-  const args: ManifestEntry['args'] = [];
-  let cursor = 0;
-
-  while (cursor < argsBlock.length) {
-    const nameMatch = argsBlock.slice(cursor).match(/\{\s*name\s*:\s*['"`]([^'"`]+)['"`]/);
-    if (!nameMatch || nameMatch.index === undefined) break;
-
-    const objectStart = cursor + nameMatch.index;
-    const body = extractBalancedBlock(argsBlock, objectStart, '{', '}');
-    if (body == null) break;
-
-    const typeMatch = body.match(/type\s*:\s*['"`](\w+)['"`]/);
-    const defaultMatch = body.match(/default\s*:\s*([^,}]+)/);
-    const requiredMatch = body.match(/required\s*:\s*(true|false)/);
-    const helpMatch = body.match(/help\s*:\s*['"`]([^'"`]*)['"`]/);
-    const positionalMatch = body.match(/positional\s*:\s*(true|false)/);
-
-    let defaultVal: unknown = undefined;
-    if (defaultMatch) {
-      const raw = defaultMatch[1].trim();
-      if (raw === 'true') defaultVal = true;
-      else if (raw === 'false') defaultVal = false;
-      else if (/^\d+$/.test(raw)) defaultVal = parseInt(raw, 10);
-      else if (/^\d+\.\d+$/.test(raw)) defaultVal = parseFloat(raw);
-      else defaultVal = raw.replace(/^['"`]|['"`]$/g, '');
-    }
-
-    args.push({
-      name: nameMatch[1],
-      type: typeMatch?.[1] ?? 'str',
-      default: defaultVal,
-      required: requiredMatch?.[1] === 'true',
-      positional: positionalMatch?.[1] === 'true' || undefined,
-      help: helpMatch?.[1] ?? '',
-      choices: parseInlineChoices(body),
-    });
-
-    cursor = objectStart + body.length;
-    if (cursor <= objectStart) break; // safety: prevent infinite loop
-  }
-
-  return args;
+function toManifestEntry(cmd: CliCommand, modulePath: string): ManifestEntry {
+  return {
+    site: cmd.site,
+    name: cmd.name,
+    description: cmd.description ?? '',
+    domain: cmd.domain,
+    strategy: (cmd.strategy ?? 'public').toString().toLowerCase(),
+    browser: cmd.browser ?? true,
+    args: toManifestArgs(cmd.args),
+    columns: cmd.columns,
+    timeout: cmd.timeoutSeconds,
+    deprecated: cmd.deprecated,
+    replacedBy: cmd.replacedBy,
+    type: 'ts',
+    modulePath,
+    navigateBefore: cmd.navigateBefore,
+  };
 }
 
 function scanYaml(filePath: string, site: string): ManifestEntry | null {
@@ -199,83 +134,49 @@ function scanYaml(filePath: string, site: string): ManifestEntry | null {
   }
 }
 
-export function scanTs(filePath: string, site: string): ManifestEntry | null {
-  // TS adapters self-register via cli() at import time.
-  // We statically parse the source to extract metadata for the manifest stub.
-  const baseName = path.basename(filePath, path.extname(filePath));
-  const relativePath = `${site}/${baseName}.js`;
-
+export async function loadTsManifestEntries(
+  filePath: string,
+  site: string,
+  importer: (moduleHref: string) => Promise<unknown> = moduleHref => import(moduleHref),
+): Promise<ManifestEntry[]> {
   try {
     const src = fs.readFileSync(filePath, 'utf-8');
 
     // Helper/test modules should not appear as CLI commands in the manifest.
-    if (!/\bcli\s*\(/.test(src)) return null;
-
-    const entry: ManifestEntry = {
-      site,
-      name: baseName,
-      description: '',
-      strategy: 'cookie',
-      browser: true,
-      args: [],
-      type: 'ts',
-      modulePath: relativePath,
-    };
-
-    // Extract description
-    const descMatch = src.match(/description\s*:\s*['"`]([^'"`]*)['"`]/);
-    if (descMatch) entry.description = descMatch[1];
-
-    // Extract domain
-    const domainMatch = src.match(/domain\s*:\s*['"`]([^'"`]*)['"`]/);
-    if (domainMatch) entry.domain = domainMatch[1];
-
-    // Extract strategy
-    const stratMatch = src.match(/strategy\s*:\s*Strategy\.(\w+)/);
-    if (stratMatch) entry.strategy = stratMatch[1].toLowerCase();
-
-    // Extract browser: false (some adapters bypass browser entirely)
-    const browserMatch = src.match(/browser\s*:\s*(true|false)/);
-    if (browserMatch) entry.browser = browserMatch[1] === 'true';
-    else entry.browser = entry.strategy !== 'public';
-
-    // Extract columns
-    const colMatch = src.match(/columns\s*:\s*\[([^\]]*)\]/);
-    if (colMatch) {
-      entry.columns = colMatch[1].split(',').map(s => s.trim().replace(/^['"`]|['"`]$/g, '')).filter(Boolean);
-    }
-
-    // Extract args array items: { name: '...', ... }
-    const argsBlock = extractTsArgsBlock(src);
-    if (argsBlock) {
-      entry.args = parseTsArgsBlock(argsBlock);
-    }
-
-    // Extract navigateBefore: false / true / 'https://...'
-    const navBoolMatch = src.match(/navigateBefore\s*:\s*(true|false)/);
-    if (navBoolMatch) {
-      entry.navigateBefore = navBoolMatch[1] === 'true';
-    } else {
-      const navStringMatch = src.match(/navigateBefore\s*:\s*['"`]([^'"`]+)['"`]/);
-      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;
+    if (!CLI_MODULE_PATTERN.test(src)) return [];
+
+    const modulePath = toTsModulePath(filePath, site);
+    const registry = getRegistry();
+    const before = new Map(registry.entries());
+    const mod = await importer(pathToFileURL(filePath).href);
+
+    const exportedCommands = Object.values(isRecord(mod) ? mod : {})
+      .filter(value => isCliCommandValue(value, site));
+
+    const runtimeCommands = exportedCommands.length > 0
+      ? exportedCommands
+      : [...registry.entries()]
+        .filter(([key, cmd]) => {
+          if (cmd.site !== site) return false;
+          const previous = before.get(key);
+          return !previous || previous !== cmd;
+        })
+        .map(([, cmd]) => cmd);
+
+    const seen = new Set<string>();
+    return runtimeCommands
+      .filter((cmd) => {
+        const key = fullName(cmd);
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+      })
+      .sort((a, b) => a.name.localeCompare(b.name))
+      .map(cmd => toManifestEntry(cmd, modulePath));
   } catch (err) {
     // If parsing fails, log a warning (matching scanYaml behaviour) and skip the entry.
     process.stderr.write(`Warning: failed to scan ${filePath}: ${getErrorMessage(err)}\n`);
-    return null;
+    return [];
   }
 }
 
@@ -288,7 +189,7 @@ export function shouldReplaceManifestEntry(current: ManifestEntry, next: Manifes
   return current.type === 'yaml' && next.type === 'ts';
 }
 
-export function buildManifest(): ManifestEntry[] {
+export async function buildManifest(): Promise<ManifestEntry[]> {
   const manifest = new Map<string, ManifestEntry>();
 
   if (fs.existsSync(CLIS_DIR)) {
@@ -313,8 +214,8 @@ export function buildManifest(): ManifestEntry[] {
           (file.endsWith('.ts') && !file.endsWith('.d.ts') && !file.endsWith('.test.ts') && file !== 'index.ts') ||
           (file.endsWith('.js') && !file.endsWith('.d.js') && !file.endsWith('.test.js') && file !== 'index.js')
         ) {
-          const entry = scanTs(filePath, site);
-          if (entry) {
+          const entries = await loadTsManifestEntries(filePath, site);
+          for (const entry of entries) {
             const key = `${entry.site}/${entry.name}`;
             const existing = manifest.get(key);
             if (!existing || shouldReplaceManifestEntry(existing, entry)) {
@@ -332,8 +233,8 @@ export function buildManifest(): ManifestEntry[] {
   return [...manifest.values()];
 }
 
-function main(): void {
-  const manifest = buildManifest();
+async function main(): Promise<void> {
+  const manifest = await buildManifest();
   fs.mkdirSync(path.dirname(OUTPUT), { recursive: true });
   fs.writeFileSync(OUTPUT, JSON.stringify(manifest, null, 2));
 
@@ -367,5 +268,5 @@ function main(): void {
 
 const entrypoint = process.argv[1] ? pathToFileURL(path.resolve(process.argv[1])).href : null;
 if (entrypoint === import.meta.url) {
-  main();
+  void main();
 }

package/src/daemon.ts

@@ -102,7 +102,22 @@ async function handleRequest(req: IncomingMessage, res: ServerResponse): Promise
     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.
@@ -111,9 +126,6 @@ async function handleRequest(req: IncomingMessage, res: ServerResponse): Promise
     return;
   }
 
-  const url = req.url ?? '/';
-  const pathname = url.split('?')[0];
-
   if (req.method === 'GET' && pathname === '/status') {
     jsonResponse(res, 200, {
       ok: true,

package/src/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/src/serialization.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+import type { CliCommand } from './registry.js';
+import { Strategy } from './registry.js';
+import { formatRegistryHelpText } from './serialization.js';
+
+describe('formatRegistryHelpText', () => {
+  it('summarizes long choices lists so help text stays readable', () => {
+    const cmd: CliCommand = {
+      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/src/serialization.ts

@@ -62,6 +62,11 @@ export function formatArgSummary(args: Arg[]): string {
     .join(' ');
 }
 
+function summarizeChoices(choices: string[]): string {
+  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: CliCommand): string {
   const lines: string[] = [];
@@ -69,7 +74,7 @@ export function formatRegistryHelpText(cmd: CliCommand): string {
   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: string[] = [];
   meta.push(`Strategy: ${strategyLabel(cmd)}`);