@jackwener/opencli 0.4.0 → 0.4.2

package/dist/clis/bilibili/following.d.ts

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

package/dist/clis/bilibili/following.js

@@ -0,0 +1,41 @@
+import { cli, Strategy } from '../../registry.js';
+import { fetchJson, getSelfUid, resolveUid } from '../../bilibili.js';
+cli({
+    site: 'bilibili',
+    name: 'following',
+    description: '获取 Bilibili 用户的关注列表',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'uid', required: false, help: '目标用户 ID（默认为当前登录用户）' },
+        { name: 'page', type: 'int', required: false, default: 1, help: '页码' },
+        { name: 'limit', type: 'int', required: false, default: 50, help: '每页数量 (最大 50)' },
+    ],
+    columns: ['mid', 'name', 'sign', 'following', 'fans'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new Error('Requires browser');
+        // 1. Resolve UID (default to self)
+        const uid = kwargs.uid
+            ? await resolveUid(page, kwargs.uid)
+            : await getSelfUid(page);
+        const pn = kwargs.page ?? 1;
+        const ps = Math.min(kwargs.limit ?? 50, 50);
+        // 2. Fetch following list (standard Cookie API, no Wbi signing needed)
+        const payload = await fetchJson(page, `https://api.bilibili.com/x/relation/followings?vmid=${uid}&pn=${pn}&ps=${ps}&order=desc`);
+        if (payload.code !== 0) {
+            throw new Error(`获取关注列表失败: ${payload.message} (${payload.code})`);
+        }
+        const list = payload.data?.list || [];
+        if (list.length === 0) {
+            return [{ mid: '-', name: `共 ${payload.data?.total ?? 0} 人关注，当前页无数据`, sign: '', following: '', fans: '' }];
+        }
+        // 3. Map to output
+        return list.map((u) => ({
+            mid: u.mid,
+            name: u.uname,
+            sign: (u.sign || '').slice(0, 40),
+            following: u.attribute === 6 ? '互相关注' : '已关注',
+            fans: u.official_verify?.desc || '',
+        }));
+    },
+});

package/dist/clis/xiaohongshu/search.d.ts

@@ -1,5 +1,8 @@
 /**
- * Xiaohongshu search — trigger search via Pinia store + XHR interception.
- * Inspired by bb-sites/xiaohongshu/search.js but adapted for opencli pipeline.
+ * Xiaohongshu search — DOM-based extraction from search results page.
+ * The previous Pinia store + XHR interception approach broke because
+ * the API now returns empty items. This version navigates directly to
+ * the search results page and extracts data from rendered DOM elements.
+ * Ref: https://github.com/jackwener/opencli/issues/10
  */
 export {};

package/dist/clis/xiaohongshu/search.js

@@ -1,6 +1,9 @@
 /**
- * Xiaohongshu search — trigger search via Pinia store + XHR interception.
- * Inspired by bb-sites/xiaohongshu/search.js but adapted for opencli pipeline.
+ * Xiaohongshu search — DOM-based extraction from search results page.
+ * The previous Pinia store + XHR interception approach broke because
+ * the API now returns empty items. This version navigates directly to
+ * the search results page and extracts data from rendered DOM elements.
+ * Ref: https://github.com/jackwener/opencli/issues/10
  */
 import { cli, Strategy } from '../../registry.js';
 cli({
@@ -13,54 +16,45 @@ cli({
         { name: 'keyword', required: true, help: 'Search keyword' },
         { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
     ],
-    columns: ['rank', 'title', 'author', 'likes', 'type'],
+    columns: ['rank', 'title', 'author', 'likes'],
     func: async (page, kwargs) => {
-        await page.goto('https://www.xiaohongshu.com');
-        await page.wait(2);
+        const keyword = encodeURIComponent(kwargs.keyword);
+        await page.goto(`https://www.xiaohongshu.com/search_result?keyword=${keyword}&source=web_search_result_notes`);
+        await page.wait(3);
+        // Scroll a couple of times to load more results
+        await page.autoScroll({ times: 2 });
         const data = await page.evaluate(`
-      (async () => {
-        const app = document.querySelector('#app')?.__vue_app__;
-        const pinia = app?.config?.globalProperties?.$pinia;
-        if (!pinia?._s) return {error: 'Page not ready'};
+      (() => {
+        const notes = document.querySelectorAll('section.note-item');
+        const results = [];
+        notes.forEach(el => {
+          // Skip "related searches" sections
+          if (el.classList.contains('query-note-item')) return;
 
-        const searchStore = pinia._s.get('search');
-        if (!searchStore) return {error: 'Search store not found'};
+          const titleEl = el.querySelector('.title, .note-title, a.title');
+          const nameEl = el.querySelector('.name, .author-name, .nick-name');
+          const likesEl = el.querySelector('.count, .like-count, .like-wrapper .count');
+          const linkEl = el.querySelector('a[href*="/explore/"], a[href*="/search_result/"], a[href*="/note/"]');
 
-        let captured = null;
-        const origOpen = XMLHttpRequest.prototype.open;
-        const origSend = XMLHttpRequest.prototype.send;
-        XMLHttpRequest.prototype.open = function(m, u) { this.__url = u; return origOpen.apply(this, arguments); };
-        XMLHttpRequest.prototype.send = function(b) {
-          if (this.__url?.includes('search/notes')) {
-            const x = this;
-            const orig = x.onreadystatechange;
-            x.onreadystatechange = function() { if (x.readyState === 4 && !captured) { try { captured = JSON.parse(x.responseText); } catch {} } if (orig) orig.apply(this, arguments); };
-          }
-          return origSend.apply(this, arguments);
-        };
+          const href = linkEl?.getAttribute('href') || '';
+          const noteId = href.match(/\\/(?:explore|note)\\/([a-f0-9]+)/)?.[1] || '';
 
-        try {
-          searchStore.mutateSearchValue('${kwargs.keyword}');
-          await searchStore.loadMore();
-          await new Promise(r => setTimeout(r, 800));
-        } finally {
-          XMLHttpRequest.prototype.open = origOpen;
-          XMLHttpRequest.prototype.send = origSend;
-        }
-
-        if (!captured?.success) return {error: captured?.msg || 'Search failed'};
-        return (captured.data?.items || []).map(i => ({
-          title: i.note_card?.display_title || '',
-          type: i.note_card?.type || '',
-          url: 'https://www.xiaohongshu.com/explore/' + i.id,
-          author: i.note_card?.user?.nickname || '',
-          likes: i.note_card?.interact_info?.liked_count || '0',
-        }));
+          results.push({
+            title: (titleEl?.textContent || '').trim(),
+            author: (nameEl?.textContent || '').trim(),
+            likes: (likesEl?.textContent || '0').trim(),
+            url: noteId ? 'https://www.xiaohongshu.com/explore/' + noteId : '',
+          });
+        });
+        return results;
       })()
     `);
         if (!Array.isArray(data))
             return [];
-        return data.slice(0, kwargs.limit).map((item, i) => ({
+        return data
+            .filter((item) => item.title)
+            .slice(0, kwargs.limit)
+            .map((item, i) => ({
             rank: i + 1,
             ...item,
         }));

package/dist/engine.d.ts

@@ -1,7 +1,20 @@
 /**
  * CLI discovery: finds YAML/TS CLI definitions and registers them.
+ *
+ * Supports two modes:
+ * 1. FAST PATH (manifest): If a pre-compiled cli-manifest.json exists,
+ *    registers all YAML commands instantly without runtime YAML parsing.
+ *    TS modules are loaded lazily only when their command is executed.
+ * 2. FALLBACK (filesystem scan): Traditional runtime discovery for development.
  */
 import { type CliCommand } from './registry.js';
 import type { IPage } from './types.js';
+/**
+ * Discover and register CLI commands.
+ * Uses pre-compiled manifest when available for instant startup.
+ */
 export declare function discoverClis(...dirs: string[]): Promise<void>;
+/**
+ * Execute a CLI command. Handles lazy-loading of TS modules.
+ */
 export declare function executeCommand(cmd: CliCommand, page: IPage | null, kwargs: Record<string, any>, debug?: boolean): Promise<any>;

package/dist/engine.js

@@ -1,31 +1,110 @@
 /**
  * CLI discovery: finds YAML/TS CLI definitions and registers them.
+ *
+ * Supports two modes:
+ * 1. FAST PATH (manifest): If a pre-compiled cli-manifest.json exists,
+ *    registers all YAML commands instantly without runtime YAML parsing.
+ *    TS modules are loaded lazily only when their command is executed.
+ * 2. FALLBACK (filesystem scan): Traditional runtime discovery for development.
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import yaml from 'js-yaml';
 import { Strategy, registerCommand } from './registry.js';
 import { executePipeline } from './pipeline.js';
+/** Set of TS module paths that have been loaded */
+const _loadedModules = new Set();
+/**
+ * Discover and register CLI commands.
+ * Uses pre-compiled manifest when available for instant startup.
+ */
 export async function discoverClis(...dirs) {
-    const promises = [];
+    // Fast path: try manifest first (production / post-build)
     for (const dir of dirs) {
-        if (!fs.existsSync(dir))
+        const manifestPath = path.resolve(dir, '..', 'cli-manifest.json');
+        if (fs.existsSync(manifestPath)) {
+            loadFromManifest(manifestPath, dir);
+            continue; // Skip filesystem scan for this directory
+        }
+        // Fallback: runtime filesystem scan (development)
+        await discoverClisFromFs(dir);
+    }
+}
+/**
+ * Fast-path: register commands from pre-compiled manifest.
+ * YAML pipelines are inlined — zero YAML parsing at runtime.
+ * TS modules are deferred — loaded lazily on first execution.
+ */
+function loadFromManifest(manifestPath, clisDir) {
+    try {
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+        for (const entry of manifest) {
+            if (entry.type === 'yaml') {
+                // YAML pipelines fully inlined in manifest — register directly
+                const strategy = Strategy[entry.strategy.toUpperCase()] ?? Strategy.COOKIE;
+                const cmd = {
+                    site: entry.site,
+                    name: entry.name,
+                    description: entry.description ?? '',
+                    domain: entry.domain,
+                    strategy,
+                    browser: entry.browser,
+                    args: entry.args ?? [],
+                    columns: entry.columns,
+                    pipeline: entry.pipeline,
+                    timeoutSeconds: entry.timeout,
+                    source: `manifest:${entry.site}/${entry.name}`,
+                };
+                registerCommand(cmd);
+            }
+            else if (entry.type === 'ts' && entry.modulePath) {
+                // TS adapters: register a lightweight stub.
+                // The actual module is loaded lazily on first executeCommand().
+                const strategy = Strategy[(entry.strategy ?? 'cookie').toUpperCase()] ?? Strategy.COOKIE;
+                const modulePath = path.resolve(clisDir, entry.modulePath);
+                const cmd = {
+                    site: entry.site,
+                    name: entry.name,
+                    description: entry.description ?? '',
+                    domain: entry.domain,
+                    strategy,
+                    browser: entry.browser ?? true,
+                    args: entry.args ?? [],
+                    columns: entry.columns,
+                    timeoutSeconds: entry.timeout,
+                    source: modulePath,
+                    // Mark as lazy — executeCommand will load the module before running
+                    _lazy: true,
+                    _modulePath: modulePath,
+                };
+                registerCommand(cmd);
+            }
+        }
+    }
+    catch (err) {
+        process.stderr.write(`Warning: failed to load manifest ${manifestPath}: ${err.message}\n`);
+    }
+}
+/**
+ * Fallback: traditional filesystem scan (used during development with tsx).
+ */
+async function discoverClisFromFs(dir) {
+    if (!fs.existsSync(dir))
+        return;
+    const promises = [];
+    for (const site of fs.readdirSync(dir)) {
+        const siteDir = path.join(dir, site);
+        if (!fs.statSync(siteDir).isDirectory())
             continue;
-        for (const site of fs.readdirSync(dir)) {
-            const siteDir = path.join(dir, site);
-            if (!fs.statSync(siteDir).isDirectory())
-                continue;
-            for (const file of fs.readdirSync(siteDir)) {
-                const filePath = path.join(siteDir, file);
-                if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-                    registerYamlCli(filePath, site);
-                }
-                else if (file.endsWith('.js')) {
-                    // Dynamic import of compiled adapter modules
-                    promises.push(import(`file://${filePath}`).catch((err) => {
-                        process.stderr.write(`Warning: failed to load module ${filePath}: ${err.message}\n`);
-                    }));
-                }
+        for (const file of fs.readdirSync(siteDir)) {
+            const filePath = path.join(siteDir, file);
+            if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+                registerYamlCli(filePath, site);
+            }
+            else if (file.endsWith('.js') && !file.endsWith('.d.js')) {
+                promises.push(import(`file://${filePath}`).catch((err) => {
+                    process.stderr.write(`Warning: failed to load module ${filePath}: ${err.message}\n`);
+                }));
             }
         }
     }
@@ -74,7 +153,33 @@ function registerYamlCli(filePath, defaultSite) {
         process.stderr.write(`Warning: failed to load ${filePath}: ${err.message}\n`);
     }
 }
+/**
+ * Execute a CLI command. Handles lazy-loading of TS modules.
+ */
 export async function executeCommand(cmd, page, kwargs, debug = false) {
+    // Lazy-load TS module on first execution
+    if (cmd._lazy && cmd._modulePath) {
+        const modulePath = cmd._modulePath;
+        if (!_loadedModules.has(modulePath)) {
+            try {
+                await import(`file://${modulePath}`);
+                _loadedModules.add(modulePath);
+            }
+            catch (err) {
+                throw new Error(`Failed to load adapter module ${modulePath}: ${err.message}`);
+            }
+        }
+        // After loading, the module's cli() call will have updated the registry
+        // with the real func/pipeline. Re-fetch the command.
+        const { getRegistry, fullName } = await import('./registry.js');
+        const updated = getRegistry().get(fullName(cmd));
+        if (updated && updated.func) {
+            return updated.func(page, kwargs, debug);
+        }
+        if (updated && updated.pipeline) {
+            return executePipeline(page, updated.pipeline, { args: kwargs, debug });
+        }
+    }
     if (cmd.func) {
         return cmd.func(page, kwargs, debug);
     }

package/dist/pipeline/steps/fetch.js

@@ -44,6 +44,42 @@ async function fetchSingle(page, url, method, queryParams, headers, args, data)
     }
   `);
 }
+/**
+ * Batch fetch: send all URLs into the browser as a single evaluate() call.
+ * This eliminates N-1 cross-process IPC round trips, performing all fetches
+ * inside the V8 engine and returning results as one JSON array.
+ */
+async function fetchBatchInBrowser(page, urls, method, headers, concurrency) {
+    const headersJs = JSON.stringify(headers);
+    const urlsJs = JSON.stringify(urls);
+    return page.evaluate(`
+    async () => {
+      const urls = ${urlsJs};
+      const method = "${method}";
+      const headers = ${headersJs};
+      const concurrency = ${concurrency};
+
+      const results = new Array(urls.length);
+      let idx = 0;
+
+      async function worker() {
+        while (idx < urls.length) {
+          const i = idx++;
+          try {
+            const resp = await fetch(urls[i], { method, headers, credentials: "include" });
+            results[i] = await resp.json();
+          } catch (e) {
+            results[i] = { error: e.message };
+          }
+        }
+      }
+
+      const workers = Array.from({ length: Math.min(concurrency, urls.length) }, () => worker());
+      await Promise.all(workers);
+      return results;
+    }
+  `);
+}
 export async function stepFetch(page, params, data, args) {
     const urlOrObj = typeof params === 'string' ? params : (params?.url ?? '');
     const method = params?.method ?? 'GET';
@@ -53,9 +89,29 @@ export async function stepFetch(page, params, data, args) {
     // Per-item fetch when data is array and URL references item
     if (Array.isArray(data) && urlTemplate.includes('item')) {
         const concurrency = typeof params?.concurrency === 'number' ? params.concurrency : 5;
+        // Render all URLs upfront
+        const renderedHeaders = {};
+        for (const [k, v] of Object.entries(headers))
+            renderedHeaders[k] = String(render(v, { args, data }));
+        const renderedParams = {};
+        for (const [k, v] of Object.entries(queryParams))
+            renderedParams[k] = String(render(v, { args, data }));
+        const urls = data.map((item, index) => {
+            let url = String(render(urlTemplate, { args, data, item, index }));
+            if (Object.keys(renderedParams).length > 0) {
+                const qs = new URLSearchParams(renderedParams).toString();
+                url = `${url}${url.includes('?') ? '&' : '?'}${qs}`;
+            }
+            return url;
+        });
+        // BATCH IPC: if browser is available, batch all fetches into a single evaluate() call
+        if (page !== null) {
+            return fetchBatchInBrowser(page, urls, method.toUpperCase(), renderedHeaders, concurrency);
+        }
+        // Non-browser: use concurrent pool (already optimized)
         return mapConcurrent(data, concurrency, async (item, index) => {
             const itemUrl = String(render(urlTemplate, { args, data, item, index }));
-            return fetchSingle(page, itemUrl, method, queryParams, headers, args, data);
+            return fetchSingle(null, itemUrl, method, queryParams, headers, args, data);
         });
     }
     const url = render(urlOrObj, { args, data });

package/dist/registry.d.ts

@@ -30,6 +30,9 @@ export interface CliCommand {
     pipeline?: any[];
     timeoutSeconds?: number;
     source?: string;
+    /** Internal: lazy-loaded TS module support */
+    _lazy?: boolean;
+    _modulePath?: string;
 }
 export interface CliOptions {
     site: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "publishConfig": {
     "access": "public"
   },
@@ -12,7 +12,8 @@
   },
   "scripts": {
     "dev": "tsx src/main.ts",
-    "build": "tsc && npm run clean-yaml && npm run copy-yaml",
+    "build": "tsc && npm run clean-yaml && npm run copy-yaml && npm run build-manifest",
+    "build-manifest": "node dist/build-manifest.js || true",
     "clean-yaml": "find dist/clis -name '*.yaml' -o -name '*.yml' 2>/dev/null | xargs rm -f",
     "copy-yaml": "find src/clis -name '*.yaml' -o -name '*.yml' | while read f; do d=\"dist/${f#src/}\"; mkdir -p \"$(dirname \"$d\")\"; cp \"$f\" \"$d\"; done",
     "start": "node dist/main.js",

package/src/build-manifest.ts

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+/**
+ * Build-time CLI manifest compiler.
+ *
+ * Scans all YAML/TS CLI definitions and pre-compiles them into a single
+ * manifest.json for instant cold-start registration (no runtime YAML parsing).
+ *
+ * Usage: npx tsx src/build-manifest.ts
+ * Output: dist/cli-manifest.json
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import yaml from 'js-yaml';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CLIS_DIR = path.resolve(__dirname, 'clis');
+const OUTPUT = path.resolve(__dirname, '..', 'dist', 'cli-manifest.json');
+
+interface ManifestEntry {
+  site: string;
+  name: string;
+  description: string;
+  domain?: string;
+  strategy: string;
+  browser: boolean;
+  args: Array<{
+    name: string;
+    type?: string;
+    default?: any;
+    required?: boolean;
+    help?: string;
+    choices?: string[];
+  }>;
+  columns?: string[];
+  pipeline?: any[];
+  timeout?: number;
+  /** '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' */
+  modulePath?: string;
+}
+
+function scanYaml(filePath: string, site: string): ManifestEntry | null {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const def = yaml.load(raw) as any;
+    if (!def || typeof def !== 'object') return null;
+
+    const strategyStr = def.strategy ?? (def.browser === false ? 'public' : 'cookie');
+    const strategy = strategyStr.toUpperCase();
+    const browser = def.browser ?? (strategy !== 'PUBLIC');
+
+    const args: ManifestEntry['args'] = [];
+    if (def.args && typeof def.args === 'object') {
+      for (const [argName, argDef] of Object.entries(def.args as Record<string, any>)) {
+        args.push({
+          name: argName,
+          type: argDef?.type ?? 'str',
+          default: argDef?.default,
+          required: argDef?.required ?? false,
+          help: argDef?.description ?? argDef?.help ?? '',
+          choices: argDef?.choices,
+        });
+      }
+    }
+
+    return {
+      site: def.site ?? site,
+      name: def.name ?? path.basename(filePath, path.extname(filePath)),
+      description: def.description ?? '',
+      domain: def.domain,
+      strategy: strategy.toLowerCase(),
+      browser,
+      args,
+      columns: def.columns,
+      pipeline: def.pipeline,
+      timeout: def.timeout,
+      type: 'yaml',
+    };
+  } catch (err: any) {
+    process.stderr.write(`Warning: failed to parse ${filePath}: ${err.message}\n`);
+    return null;
+  }
+}
+
+function scanTs(filePath: string, site: string): ManifestEntry {
+  // 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`;
+
+  const entry: ManifestEntry = {
+    site,
+    name: baseName,
+    description: '',
+    strategy: 'cookie',
+    browser: true,
+    args: [],
+    type: 'ts',
+    modulePath: relativePath,
+  };
+
+  try {
+    const src = fs.readFileSync(filePath, 'utf-8');
+
+    // 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 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 argsBlockMatch = src.match(/args\s*:\s*\[([\s\S]*?)\]\s*,/);
+    if (argsBlockMatch) {
+      const argsBlock = argsBlockMatch[1];
+      const argRegex = /\{\s*name\s*:\s*['"`](\w+)['"`]([^}]*)\}/g;
+      let m;
+      while ((m = argRegex.exec(argsBlock)) !== null) {
+        const argName = m[1];
+        const body = m[2];
+        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*['"`]([^'"`]*)['"`]/);
+
+        let defaultVal: any = 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, '');
+        }
+
+        entry.args.push({
+          name: argName,
+          type: typeMatch?.[1] ?? 'str',
+          default: defaultVal,
+          required: requiredMatch?.[1] === 'true',
+          help: helpMatch?.[1] ?? '',
+        });
+      }
+    }
+  } catch {
+    // If parsing fails, fall back to empty metadata — module will self-register at runtime
+  }
+
+  return entry;
+}
+
+// Main
+const manifest: ManifestEntry[] = [];
+
+if (fs.existsSync(CLIS_DIR)) {
+  for (const site of fs.readdirSync(CLIS_DIR)) {
+    const siteDir = path.join(CLIS_DIR, site);
+    if (!fs.statSync(siteDir).isDirectory()) continue;
+    for (const file of fs.readdirSync(siteDir)) {
+      const filePath = path.join(siteDir, file);
+      if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+        const entry = scanYaml(filePath, site);
+        if (entry) manifest.push(entry);
+      } else if (
+        (file.endsWith('.ts') && !file.endsWith('.d.ts') && file !== 'index.ts') ||
+        (file.endsWith('.js') && !file.endsWith('.d.js') && file !== 'index.js')
+      ) {
+        manifest.push(scanTs(filePath, site));
+      }
+    }
+  }
+}
+
+// Ensure output directory exists
+fs.mkdirSync(path.dirname(OUTPUT), { recursive: true });
+fs.writeFileSync(OUTPUT, JSON.stringify(manifest, null, 2));
+
+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}`);