@jackwener/opencli 1.5.2 → 1.5.4

package/dist/browser/dom-helpers.test.js

@@ -0,0 +1,92 @@
+import { describe, it, expect } from 'vitest';
+import { waitForCaptureJs, waitForSelectorJs } from './dom-helpers.js';
+describe('waitForCaptureJs', () => {
+    it('returns a non-empty string', () => {
+        const code = waitForCaptureJs(1000);
+        expect(typeof code).toBe('string');
+        expect(code.length).toBeGreaterThan(0);
+        expect(code).toContain('__opencli_xhr');
+        expect(code).toContain('resolve');
+        expect(code).toContain('reject');
+    });
+    it('resolves "captured" when __opencli_xhr is populated before deadline', async () => {
+        const g = globalThis;
+        g.__opencli_xhr = [];
+        g.window = g; // stub window for Node eval
+        const code = waitForCaptureJs(1000);
+        const promise = eval(code);
+        g.__opencli_xhr.push({ data: 'test' });
+        await expect(promise).resolves.toBe('captured');
+        delete g.__opencli_xhr;
+        delete g.window;
+    });
+    it('rejects when __opencli_xhr stays empty past deadline', async () => {
+        const g = globalThis;
+        g.__opencli_xhr = [];
+        g.window = g;
+        const code = waitForCaptureJs(50); // 50ms timeout
+        const promise = eval(code);
+        await expect(promise).rejects.toThrow('No network capture within 0.05s');
+        delete g.__opencli_xhr;
+        delete g.window;
+    });
+    it('resolves immediately when __opencli_xhr already has data', async () => {
+        const g = globalThis;
+        g.__opencli_xhr = [{ data: 'already here' }];
+        g.window = g;
+        const code = waitForCaptureJs(1000);
+        await expect(eval(code)).resolves.toBe('captured');
+        delete g.__opencli_xhr;
+        delete g.window;
+    });
+});
+describe('waitForSelectorJs', () => {
+    it('returns a non-empty string', () => {
+        const code = waitForSelectorJs('#app', 1000);
+        expect(typeof code).toBe('string');
+        expect(code).toContain('#app');
+        expect(code).toContain('querySelector');
+        expect(code).toContain('MutationObserver');
+    });
+    it('resolves "found" immediately when selector already present', async () => {
+        const g = globalThis;
+        const fakeEl = { tagName: 'DIV' };
+        g.document = { querySelector: (_) => fakeEl };
+        const code = waitForSelectorJs('[data-testid="primaryColumn"]', 1000);
+        await expect(eval(code)).resolves.toBe('found');
+        delete g.document;
+    });
+    it('resolves "found" when selector appears after DOM mutation', async () => {
+        const g = globalThis;
+        let mutationCallback;
+        g.MutationObserver = class {
+            constructor(cb) { mutationCallback = cb; }
+            observe() { }
+            disconnect() { }
+        };
+        let calls = 0;
+        g.document = {
+            querySelector: (_) => (calls++ > 0 ? { tagName: 'DIV' } : null),
+            body: {},
+        };
+        const code = waitForSelectorJs('#app', 1000);
+        const promise = eval(code);
+        mutationCallback(); // simulate DOM mutation
+        await expect(promise).resolves.toBe('found');
+        delete g.document;
+        delete g.MutationObserver;
+    });
+    it('rejects when selector never appears within timeout', async () => {
+        const g = globalThis;
+        g.MutationObserver = class {
+            constructor(_cb) { }
+            observe() { }
+            disconnect() { }
+        };
+        g.document = { querySelector: (_) => null, body: {} };
+        const code = waitForSelectorJs('#missing', 50);
+        await expect(eval(code)).rejects.toThrow('Selector not found: #missing');
+        delete g.document;
+        delete g.MutationObserver;
+    });
+});

package/dist/browser/index.d.ts

@@ -11,15 +11,3 @@ export { isDaemonRunning } from './daemon-client.js';
 export { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
 export { generateStealthJs } from './stealth.js';
 export type { DomSnapshotOptions } from './dom-snapshot.js';
-import { extractTabEntries, diffTabIndexes, appendLimited } from './tabs.js';
-import { isRetryableSettleError } from './page.js';
-import { withTimeoutMs } from '../runtime.js';
-export declare const __test__: {
-    extractTabEntries: typeof extractTabEntries;
-    diffTabIndexes: typeof diffTabIndexes;
-    appendLimited: typeof appendLimited;
-    withTimeoutMs: typeof withTimeoutMs;
-    selectCDPTarget: (targets: import("./cdp.js").CDPTarget[]) => import("./cdp.js").CDPTarget | undefined;
-    scoreCDPTarget: (target: import("./cdp.js").CDPTarget, preferredPattern?: RegExp) => number;
-    isRetryableSettleError: typeof isRetryableSettleError;
-};

package/dist/browser/index.js

@@ -10,16 +10,3 @@ export { CDPBridge } from './cdp.js';
 export { isDaemonRunning } from './daemon-client.js';
 export { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
 export { generateStealthJs } from './stealth.js';
-import { extractTabEntries, diffTabIndexes, appendLimited } from './tabs.js';
-import { __test__ as cdpTest } from './cdp.js';
-import { isRetryableSettleError } from './page.js';
-import { withTimeoutMs } from '../runtime.js';
-export const __test__ = {
-    extractTabEntries,
-    diffTabIndexes,
-    appendLimited,
-    withTimeoutMs,
-    selectCDPTarget: cdpTest.selectCDPTarget,
-    scoreCDPTarget: cdpTest.scoreCDPTarget,
-    isRetryableSettleError,
-};

package/dist/browser/mcp.js

@@ -82,10 +82,11 @@ export class BrowserBridge {
             env: { ...process.env },
         });
         this._daemonProc.unref();
-        // Wait for daemon to be ready AND extension to connect
+        // Wait for daemon to be ready AND extension to connect (exponential backoff)
+        const backoffs = [50, 100, 200, 400, 800, 1500, 3000];
         const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            await new Promise(resolve => setTimeout(resolve, 300));
+        for (let i = 0; Date.now() < deadline; i++) {
+            await new Promise(resolve => setTimeout(resolve, backoffs[Math.min(i, backoffs.length - 1)]));
             if (await isExtensionConnected())
                 return;
         }

package/dist/browser/page.d.ts

@@ -72,4 +72,5 @@ export declare class Page implements IPage {
     }): Promise<void>;
     installInterceptor(pattern: string): Promise<void>;
     getInterceptedRequests(): Promise<unknown[]>;
+    waitForCapture(timeout?: number): Promise<void>;
 }

package/dist/browser/page.js

@@ -15,7 +15,7 @@ import { wrapForEval } from './utils.js';
 import { saveBase64ToFile } from '../utils.js';
 import { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
 import { generateStealthJs } from './stealth.js';
-import { clickJs, typeTextJs, pressKeyJs, waitForTextJs, scrollJs, autoScrollJs, networkRequestsJs, waitForDomStableJs, } from './dom-helpers.js';
+import { clickJs, typeTextJs, pressKeyJs, waitForTextJs, waitForCaptureJs, waitForSelectorJs, scrollJs, autoScrollJs, networkRequestsJs, waitForDomStableJs, } from './dom-helpers.js';
 export function isRetryableSettleError(err) {
     const message = err instanceof Error ? err.message : String(err);
     return message.includes('Inspected target navigated or closed')
@@ -219,6 +219,12 @@ export class Page {
             await new Promise(resolve => setTimeout(resolve, options.time * 1000));
             return;
         }
+        if (options.selector) {
+            const timeout = (options.timeout ?? 10) * 1000;
+            const code = waitForSelectorJs(options.selector, timeout);
+            await sendCommand('exec', { code, ...this._cmdOpts() });
+            return;
+        }
         if (options.text) {
             const timeout = (options.timeout ?? 30) * 1000;
             const code = waitForTextJs(options.text, timeout);
@@ -302,5 +308,12 @@ export class Page {
         const result = await this.evaluate(generateReadInterceptedJs('__opencli_xhr'));
         return Array.isArray(result) ? result : [];
     }
+    async waitForCapture(timeout = 10) {
+        const maxMs = timeout * 1000;
+        await sendCommand('exec', {
+            code: waitForCaptureJs(maxMs),
+            ...this._cmdOpts(),
+        });
+    }
 }
 // (End of file)

package/dist/browser.test.js

@@ -1,23 +1,27 @@
 import { describe, it, expect, vi } from 'vitest';
-import { BrowserBridge, __test__, generateStealthJs } from './browser/index.js';
+import { BrowserBridge, generateStealthJs } from './browser/index.js';
+import { extractTabEntries, diffTabIndexes, appendLimited } from './browser/tabs.js';
+import { withTimeoutMs } from './runtime.js';
+import { __test__ as cdpTest } from './browser/cdp.js';
+import { isRetryableSettleError } from './browser/page.js';
 import * as daemonClient from './browser/daemon-client.js';
 describe('browser helpers', () => {
     it('extracts tab entries from string snapshots', () => {
-        const entries = __test__.extractTabEntries('Tab 0 https://example.com\nTab 1 Chrome Extension');
+        const entries = extractTabEntries('Tab 0 https://example.com\nTab 1 Chrome Extension');
         expect(entries).toEqual([
             { index: 0, identity: 'https://example.com' },
             { index: 1, identity: 'Chrome Extension' },
         ]);
     });
     it('extracts tab entries from MCP markdown format', () => {
-        const entries = __test__.extractTabEntries('- 0: (current) [Playwright MCP extension](chrome-extension://abc/connect.html)\n- 1: [知乎 - 首页](https://www.zhihu.com/)');
+        const entries = extractTabEntries('- 0: (current) [Playwright MCP extension](chrome-extension://abc/connect.html)\n- 1: [知乎 - 首页](https://www.zhihu.com/)');
         expect(entries).toEqual([
             { index: 0, identity: '(current) [Playwright MCP extension](chrome-extension://abc/connect.html)' },
             { index: 1, identity: '[知乎 - 首页](https://www.zhihu.com/)' },
         ]);
     });
     it('closes only tabs that were opened during the session', () => {
-        const tabsToClose = __test__.diffTabIndexes(['https://example.com', 'Chrome Extension'], [
+        const tabsToClose = diffTabIndexes(['https://example.com', 'Chrome Extension'], [
             { index: 0, identity: 'https://example.com' },
             { index: 1, identity: 'Chrome Extension' },
             { index: 2, identity: 'https://target.example/page' },
@@ -26,18 +30,18 @@ describe('browser helpers', () => {
         expect(tabsToClose).toEqual([3, 2]);
     });
     it('keeps only the tail of stderr buffers', () => {
-        expect(__test__.appendLimited('12345', '67890', 8)).toBe('34567890');
+        expect(appendLimited('12345', '67890', 8)).toBe('34567890');
     });
     it('times out slow promises', async () => {
-        await expect(__test__.withTimeoutMs(new Promise(() => { }), 10, 'timeout')).rejects.toThrow('timeout');
+        await expect(withTimeoutMs(new Promise(() => { }), 10, 'timeout')).rejects.toThrow('timeout');
     });
     it('retries settle only for target-invalidated errors', () => {
-        expect(__test__.isRetryableSettleError(new Error('{"code":-32000,"message":"Inspected target navigated or closed"}'))).toBe(true);
-        expect(__test__.isRetryableSettleError(new Error('attach failed: target no longer exists'))).toBe(false);
-        expect(__test__.isRetryableSettleError(new Error('malformed exec payload'))).toBe(false);
+        expect(isRetryableSettleError(new Error('{"code":-32000,"message":"Inspected target navigated or closed"}'))).toBe(true);
+        expect(isRetryableSettleError(new Error('attach failed: target no longer exists'))).toBe(false);
+        expect(isRetryableSettleError(new Error('malformed exec payload'))).toBe(false);
     });
     it('prefers the real Electron app target over DevTools and blank pages', () => {
-        const target = __test__.selectCDPTarget([
+        const target = cdpTest.selectCDPTarget([
             {
                 type: 'page',
                 title: 'DevTools - localhost:9224',
@@ -61,7 +65,7 @@ describe('browser helpers', () => {
     });
     it('honors OPENCLI_CDP_TARGET when multiple inspectable targets exist', () => {
         vi.stubEnv('OPENCLI_CDP_TARGET', 'codex');
-        const target = __test__.selectCDPTarget([
+        const target = cdpTest.selectCDPTarget([
             {
                 type: 'app',
                 title: 'Cursor',

package/dist/build-manifest.d.ts

@@ -36,11 +36,10 @@ export interface ManifestEntry {
     /** Pre-navigation control — see CliCommand.navigateBefore */
     navigateBefore?: boolean | string;
 }
-export declare function parseTsArgsBlock(argsBlock: string): ManifestEntry['args'];
-export declare function scanTs(filePath: string, site: string): ManifestEntry | null;
+export declare function loadTsManifestEntries(filePath: string, site: string, importer?: (moduleHref: string) => Promise<unknown>): Promise<ManifestEntry[]>;
 /**
  * When both YAML and TS adapters exist for the same site/name,
  * prefer the TS version (it self-registers and typically has richer logic).
  */
 export declare function shouldReplaceManifestEntry(current: ManifestEntry, next: ManifestEntry): boolean;
-export declare function buildManifest(): ManifestEntry[];
+export declare function buildManifest(): Promise<ManifestEntry[]>;

package/dist/build-manifest.js

@@ -13,109 +13,52 @@ 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 } from './registry.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const CLIS_DIR = path.resolve(__dirname, 'clis');
 const OUTPUT = path.resolve(__dirname, '..', 'dist', 'cli-manifest.json');
 import { parseYamlArgs } from './yaml-schema.js';
 import { isRecord } from './utils.js';
-function extractBalancedBlock(source, startIndex, openChar, closeChar) {
-    let depth = 0;
-    let quote = 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) {
+    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) {
-    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, site) {
+    const baseName = path.basename(filePath, path.extname(filePath));
+    return `${site}/${baseName}.js`;
 }
-function parseInlineChoices(body) {
-    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, site) {
+    return isRecord(value)
+        && typeof value.site === 'string'
+        && value.site === site
+        && typeof value.name === 'string'
+        && Array.isArray(value.args);
 }
-export function parseTsArgsBlock(argsBlock) {
-    const 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 = 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, modulePath) {
+    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, site) {
     try {
@@ -150,82 +93,44 @@ function scanYaml(filePath, site) {
         return null;
     }
 }
-export function scanTs(filePath, site) {
-    // 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, site, importer = moduleHref => import(moduleHref)) {
     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 = {
-            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();
+        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 [];
     }
 }
 /**
@@ -237,7 +142,7 @@ export function shouldReplaceManifestEntry(current, next) {
         return false;
     return current.type === 'yaml' && next.type === 'ts';
 }
-export function buildManifest() {
+export async function buildManifest() {
     const manifest = new Map();
     if (fs.existsSync(CLIS_DIR)) {
         for (const site of fs.readdirSync(CLIS_DIR)) {
@@ -261,8 +166,8 @@ export function buildManifest() {
                 }
                 else if ((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)) {
@@ -278,8 +183,8 @@ export function buildManifest() {
     }
     return [...manifest.values()];
 }
-function main() {
-    const manifest = buildManifest();
+async function main() {
+    const manifest = await buildManifest();
     fs.mkdirSync(path.dirname(OUTPUT), { recursive: true });
     fs.writeFileSync(OUTPUT, JSON.stringify(manifest, null, 2));
     const yamlCount = manifest.filter(e => e.type === 'yaml').length;
@@ -311,5 +216,5 @@ function main() {
 }
 const entrypoint = process.argv[1] ? pathToFileURL(path.resolve(process.argv[1])).href : null;
 if (entrypoint === import.meta.url) {
-    main();
+    void main();
 }