@huyuan-ai/cli 1.0.0 → 1.0.2

package/vendor/opencli/dist/record.test.js

@@ -0,0 +1,293 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { analyzeRecordedRequests, buildWriteRecordedYaml, createRecordedEntry, generateFullCaptureInterceptorJs, generateRecordedCandidates, } from './record.js';
+import { render } from './pipeline/template.js';
+describe('record request-body capture', () => {
+    it('captures a JSON fetch request body alongside the JSON response body', () => {
+        const entry = createRecordedEntry({
+            url: 'https://api.example.com/tasks',
+            method: 'POST',
+            requestContentType: 'application/json',
+            requestBodyText: '{"title":"Ship #601","priority":"high"}',
+            responseBody: { id: 'task_123', ok: true },
+        });
+        expect(entry).toMatchObject({
+            method: 'POST',
+            requestContentType: 'application/json',
+            requestBody: { title: 'Ship #601', priority: 'high' },
+            responseBody: { id: 'task_123', ok: true },
+        });
+    });
+    it('captures a JSON request body from fetch(Request)', async () => {
+        class MockXMLHttpRequest {
+            open() { }
+            send() { }
+            setRequestHeader() { }
+            addEventListener() { }
+            getResponseHeader() { return null; }
+            responseText = '';
+        }
+        const mockFetch = vi.fn(async () => new Response(JSON.stringify({ id: 'task_123', ok: true }), { headers: { 'content-type': 'application/json' } }));
+        vi.stubGlobal('fetch', mockFetch);
+        vi.stubGlobal('XMLHttpRequest', MockXMLHttpRequest);
+        vi.stubGlobal('window', globalThis);
+        // eslint-disable-next-line no-eval
+        eval(generateFullCaptureInterceptorJs());
+        const request = new Request('https://api.example.com/tasks', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ title: 'Ship #601' }),
+        });
+        await globalThis.fetch(request);
+        const recorded = globalThis.__opencli_record;
+        expect(recorded).toHaveLength(1);
+        expect(recorded?.[0]?.requestBody).toEqual({ title: 'Ship #601' });
+    });
+    it('captures a JSON request body from XHR send()', async () => {
+        class MockXMLHttpRequest {
+            __listeners = {};
+            __rec_url;
+            __rec_method;
+            __rec_request_content_type;
+            responseText = JSON.stringify({ id: 'task_456', ok: true });
+            open(method, url) {
+                this.__rec_method = method;
+                this.__rec_url = url;
+            }
+            send() {
+                for (const listener of this.__listeners.load ?? [])
+                    listener.call(this);
+            }
+            setRequestHeader(name, value) {
+                if (name.toLowerCase() === 'content-type')
+                    this.__rec_request_content_type = value;
+            }
+            addEventListener(event, listener) {
+                this.__listeners[event] ??= [];
+                this.__listeners[event].push(listener);
+            }
+            getResponseHeader(name) {
+                return name.toLowerCase() === 'content-type' ? 'application/json' : null;
+            }
+        }
+        const mockFetch = vi.fn(async () => new Response(JSON.stringify({ ok: true }), { headers: { 'content-type': 'application/json' } }));
+        vi.stubGlobal('fetch', mockFetch);
+        vi.stubGlobal('XMLHttpRequest', MockXMLHttpRequest);
+        vi.stubGlobal('window', globalThis);
+        // eslint-disable-next-line no-eval
+        eval(generateFullCaptureInterceptorJs());
+        const xhr = new XMLHttpRequest();
+        xhr.open('PATCH', 'https://api.example.com/tasks/submit');
+        xhr.setRequestHeader('content-type', 'application/json;charset=utf-8');
+        xhr.send('{"done":true}');
+        const recorded = globalThis.__opencli_record;
+        expect(recorded).toHaveLength(1);
+        expect(recorded?.[0]?.requestBody).toEqual({ done: true });
+    });
+    it('does not interrupt fetch when reading a Request body fails', async () => {
+        class MockXMLHttpRequest {
+            open() { }
+            send() { }
+            setRequestHeader() { }
+            addEventListener() { }
+            getResponseHeader() { return null; }
+            responseText = '';
+        }
+        class BrokenRequest extends Request {
+            clone() {
+                throw new Error('clone failed');
+            }
+        }
+        const mockFetch = vi.fn(async () => new Response(JSON.stringify({ id: 'task_123', ok: true }), { headers: { 'content-type': 'application/json' } }));
+        vi.stubGlobal('fetch', mockFetch);
+        vi.stubGlobal('XMLHttpRequest', MockXMLHttpRequest);
+        vi.stubGlobal('window', globalThis);
+        // eslint-disable-next-line no-eval
+        eval(generateFullCaptureInterceptorJs());
+        const request = new BrokenRequest('https://api.example.com/tasks', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ title: 'Ship #601' }),
+        });
+        await expect(globalThis.fetch(request)).resolves.toBeInstanceOf(Response);
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+    });
+});
+describe('record write candidates', () => {
+    it('keeps a POST request with JSON request body and object response as a write candidate', () => {
+        const result = analyzeRecordedRequests([
+            createRecordedEntry({
+                url: 'https://api.example.com/tasks/create',
+                method: 'POST',
+                requestContentType: 'application/json',
+                requestBodyText: '{"title":"Ship #601"}',
+                responseBody: { id: 'task_123', ok: true },
+            }),
+        ]);
+        expect(result.candidates).toHaveLength(1);
+        expect(result.candidates[0]).toMatchObject({
+            kind: 'write',
+            req: { method: 'POST' },
+        });
+    });
+    it('accepts vendor JSON content types for write candidates', () => {
+        const result = analyzeRecordedRequests([
+            createRecordedEntry({
+                url: 'https://api.example.com/tasks',
+                method: 'POST',
+                requestContentType: 'application/vnd.api+json',
+                requestBodyText: '{"title":"Ship #601"}',
+                responseBody: { id: 'task_123', ok: true },
+            }),
+        ]);
+        expect(result.candidates).toHaveLength(1);
+        expect(result.candidates[0]).toMatchObject({
+            kind: 'write',
+            req: { method: 'POST' },
+        });
+    });
+    it('rejects a POST request that has no usable JSON request body', () => {
+        const result = analyzeRecordedRequests([
+            createRecordedEntry({
+                url: 'https://api.example.com/tasks/create',
+                method: 'POST',
+                requestContentType: 'application/json',
+                requestBodyText: '',
+                responseBody: { id: 'task_123', ok: true },
+            }),
+        ]);
+        expect(result.candidates).toEqual([]);
+    });
+    it('rejects array request and response bodies for first-version write candidates', () => {
+        const result = analyzeRecordedRequests([
+            createRecordedEntry({
+                url: 'https://api.example.com/tasks/batch',
+                method: 'POST',
+                requestContentType: 'application/json',
+                requestBodyText: '[{"title":"Ship #601"}]',
+                responseBody: [{ id: 'task_123' }],
+            }),
+        ]);
+        expect(result.candidates).toEqual([]);
+    });
+    it('generates a write YAML candidate from a replayable JSON write request', () => {
+        const candidates = generateRecordedCandidates('demo', 'https://demo.example.com/app', [
+            createRecordedEntry({
+                url: 'https://api.example.com/tasks/create',
+                method: 'POST',
+                requestContentType: 'application/json',
+                requestBodyText: '{"title":"Ship #601"}',
+                responseBody: { id: 'task_123', ok: true },
+            }),
+        ]);
+        expect(candidates).toHaveLength(1);
+        expect(candidates[0]).toMatchObject({
+            kind: 'write',
+            name: 'create',
+            strategy: 'cookie',
+        });
+        expect(JSON.stringify(candidates[0].yaml)).toContain('Ship #601');
+    });
+    it('builds a write template that replays the recorded JSON body with application/json', () => {
+        const candidate = buildWriteRecordedYaml('demo', 'https://demo.example.com/app', createRecordedEntry({
+            url: 'https://api.example.com/tasks/create',
+            method: 'POST',
+            requestContentType: 'application/json',
+            requestBodyText: '{"title":"Ship #601"}',
+            responseBody: { id: 'task_123', ok: true },
+        }), 'create');
+        expect(candidate.name).toBe('create');
+        expect(JSON.stringify(candidate.yaml)).toContain('method: \\"POST\\"');
+        expect(JSON.stringify(candidate.yaml)).toContain('content-type');
+        expect(JSON.stringify(candidate.yaml)).toContain('Ship #601');
+    });
+});
+describe('record read candidates', () => {
+    it('keeps existing read candidates for array responses', () => {
+        const result = analyzeRecordedRequests([
+            {
+                url: 'https://api.example.com/feed',
+                method: 'GET',
+                status: null,
+                requestContentType: null,
+                responseContentType: 'application/json',
+                requestBody: null,
+                responseBody: { items: [{ title: 'A' }, { title: 'B' }] },
+                contentType: 'application/json',
+                body: { items: [{ title: 'A' }, { title: 'B' }] },
+                capturedAt: 1,
+            },
+        ]);
+        expect(result.candidates).toHaveLength(1);
+        expect(result.candidates[0]).toMatchObject({ kind: 'read' });
+    });
+    it('keeps read YAML generation on the baseline fetch path', () => {
+        const candidates = generateRecordedCandidates('demo', 'https://demo.example.com/app', [
+            createRecordedEntry({
+                url: 'https://api.example.com/search?q=test',
+                method: 'GET',
+                responseBody: { items: [{ title: 'A' }, { title: 'B' }] },
+            }),
+        ]);
+        const yaml = candidates[0].yaml;
+        expect(yaml.pipeline[1]?.evaluate).toContain(`fetch("https://api.example.com/search?q=`);
+        expect(yaml.pipeline[1]?.evaluate).toContain(`{ credentials: 'include' }`);
+        expect(yaml.pipeline[1]?.evaluate).not.toContain('method: "POST"');
+        expect(yaml.pipeline[1]?.evaluate).not.toContain('body: JSON.stringify');
+    });
+    it('renders search and page args into the read YAML fetch URL', () => {
+        const candidates = generateRecordedCandidates('demo', 'https://demo.example.com/app', [
+            createRecordedEntry({
+                url: 'https://api.example.com/search?q=test&page=2',
+                method: 'GET',
+                responseBody: { items: [{ title: 'A' }, { title: 'B' }] },
+            }),
+        ]);
+        const yaml = candidates[0].yaml;
+        const renderedEvaluate = render(yaml.pipeline[1]?.evaluate, {
+            args: { keyword: 'desk', page: 3 },
+        });
+        expect(renderedEvaluate).toContain('https://api.example.com/search?q=desk&page=3');
+    });
+    it('keeps GET and POST candidates separate when they share the same URL pattern', () => {
+        const candidates = generateRecordedCandidates('demo', 'https://demo.example.com/app', [
+            createRecordedEntry({
+                url: 'https://api.example.com/tasks',
+                method: 'GET',
+                responseBody: { items: [{ title: 'A' }, { title: 'B' }] },
+            }),
+            createRecordedEntry({
+                url: 'https://api.example.com/tasks',
+                method: 'POST',
+                requestContentType: 'application/json',
+                requestBodyText: '{"title":"Ship #601"}',
+                responseBody: { id: 'task_123', ok: true },
+            }),
+        ]);
+        expect(candidates).toHaveLength(2);
+        expect(candidates.some((candidate) => candidate.kind === 'read')).toBe(true);
+        expect(candidates.some((candidate) => candidate.kind === 'write')).toBe(true);
+    });
+});
+describe('record noise filtering', () => {
+    it('filters analytics POST noise from write candidates', () => {
+        const result = analyzeRecordedRequests([
+            createRecordedEntry({
+                url: 'https://api.example.com/analytics/event',
+                method: 'POST',
+                requestContentType: 'application/json',
+                requestBodyText: '{"event":"click"}',
+                responseBody: { ok: true, accepted: 1 },
+            }),
+        ]);
+        expect(result.candidates).toEqual([]);
+    });
+});
+afterEach(() => {
+    vi.unstubAllGlobals();
+    Reflect.deleteProperty(globalThis, '__opencli_record');
+    Reflect.deleteProperty(globalThis, '__opencli_record_patched');
+    Reflect.deleteProperty(globalThis, '__opencli_orig_fetch');
+    Reflect.deleteProperty(globalThis, '__opencli_orig_xhr_open');
+    Reflect.deleteProperty(globalThis, '__opencli_orig_xhr_send');
+    Reflect.deleteProperty(globalThis, '__opencli_orig_xhr_set_request_header');
+});

package/vendor/opencli/dist/registry-api.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Public API for opencli plugins.
+ *
+ * TS plugins should import from '@jackwener/opencli/registry' which resolves to
+ * this file. It re-exports ONLY the core registration API — no serialization,
+ * no transitive side-effects — to avoid circular dependency deadlocks when
+ * plugins are dynamically imported during discoverPlugins().
+ */
+export { cli, Strategy, getRegistry, fullName, registerCommand } from './registry.js';
+export type { CliCommand, Arg, CliOptions } from './registry.js';
+export type { IPage } from './types.js';
+export { onStartup, onBeforeExecute, onAfterExecute } from './hooks.js';
+export type { HookFn, HookContext, HookName } from './hooks.js';

package/vendor/opencli/dist/registry-api.js

@@ -0,0 +1,10 @@
+/**
+ * Public API for opencli plugins.
+ *
+ * TS plugins should import from '@jackwener/opencli/registry' which resolves to
+ * this file. It re-exports ONLY the core registration API — no serialization,
+ * no transitive side-effects — to avoid circular dependency deadlocks when
+ * plugins are dynamically imported during discoverPlugins().
+ */
+export { cli, Strategy, getRegistry, fullName, registerCommand } from './registry.js';
+export { onStartup, onBeforeExecute, onAfterExecute } from './hooks.js';

package/vendor/opencli/dist/registry.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Core registry: Strategy enum, Arg/CliCommand interfaces, cli() registration.
+ */
+import type { IPage } from './types.js';
+export declare enum Strategy {
+    PUBLIC = "public",
+    COOKIE = "cookie",
+    HEADER = "header",
+    INTERCEPT = "intercept",
+    UI = "ui"
+}
+export interface Arg {
+    name: string;
+    type?: string;
+    default?: unknown;
+    required?: boolean;
+    valueRequired?: boolean;
+    positional?: boolean;
+    help?: string;
+    choices?: string[];
+}
+export interface RequiredEnv {
+    name: string;
+    help?: string;
+}
+export type CommandArgs = Record<string, any>;
+export interface CliCommand {
+    site: string;
+    name: string;
+    aliases?: string[];
+    description: string;
+    domain?: string;
+    strategy?: Strategy;
+    browser?: boolean;
+    args: Arg[];
+    columns?: string[];
+    func?: (page: IPage, kwargs: CommandArgs, debug?: boolean) => Promise<unknown>;
+    pipeline?: Record<string, unknown>[];
+    timeoutSeconds?: number;
+    /** Origin of this command: 'yaml', 'ts', or plugin name. */
+    source?: string;
+    footerExtra?: (kwargs: CommandArgs) => string | undefined;
+    requiredEnv?: RequiredEnv[];
+    validateArgs?: (kwargs: CommandArgs) => void;
+    /** Deprecation note shown in help / execution warnings. */
+    deprecated?: boolean | string;
+    /** Preferred replacement command, if any. */
+    replacedBy?: string;
+    /**
+     * Control pre-navigation for cookie/header context before command execution.
+     *
+     * Browser adapters using COOKIE/HEADER strategy need the page to be on the
+     * target domain so that `fetch(url, { credentials: 'include' })` carries cookies.
+     *
+     * - `undefined` / `true`: navigate to `https://${domain}` (default)
+     * - `false`: skip — adapter handles its own navigation (e.g. boss common.ts)
+     * - `string`: navigate to this specific URL instead of the domain root
+     */
+    navigateBefore?: boolean | string;
+    /** Override the default CLI output format when the user does not pass -f/--format. */
+    defaultFormat?: 'table' | 'plain' | 'json' | 'yaml' | 'yml' | 'md' | 'markdown' | 'csv';
+}
+/** Internal extension for lazy-loaded TS modules (not exposed in public API) */
+export interface InternalCliCommand extends CliCommand {
+    _lazy?: boolean;
+    _modulePath?: string;
+}
+export interface CliOptions extends Partial<Omit<CliCommand, 'args' | 'description'>> {
+    site: string;
+    name: string;
+    description?: string;
+    args?: Arg[];
+}
+declare global {
+    var __opencli_registry__: Map<string, CliCommand> | undefined;
+}
+export declare function cli(opts: CliOptions): CliCommand;
+export declare function getRegistry(): Map<string, CliCommand>;
+export declare function fullName(cmd: CliCommand): string;
+export declare function strategyLabel(cmd: CliCommand): string;
+export declare function registerCommand(cmd: CliCommand): void;

package/vendor/opencli/dist/registry.js

@@ -0,0 +1,78 @@
+/**
+ * Core registry: Strategy enum, Arg/CliCommand interfaces, cli() registration.
+ */
+export var Strategy;
+(function (Strategy) {
+    Strategy["PUBLIC"] = "public";
+    Strategy["COOKIE"] = "cookie";
+    Strategy["HEADER"] = "header";
+    Strategy["INTERCEPT"] = "intercept";
+    Strategy["UI"] = "ui";
+})(Strategy || (Strategy = {}));
+const _registry = globalThis.__opencli_registry__ ??= new Map();
+export function cli(opts) {
+    const strategy = opts.strategy ?? (opts.browser === false ? Strategy.PUBLIC : Strategy.COOKIE);
+    const browser = opts.browser ?? (strategy !== Strategy.PUBLIC);
+    const aliases = normalizeAliases(opts.aliases, opts.name);
+    const cmd = {
+        site: opts.site,
+        name: opts.name,
+        aliases,
+        description: opts.description ?? '',
+        domain: opts.domain,
+        strategy,
+        browser,
+        args: opts.args ?? [],
+        columns: opts.columns,
+        func: opts.func,
+        pipeline: opts.pipeline,
+        timeoutSeconds: opts.timeoutSeconds,
+        footerExtra: opts.footerExtra,
+        requiredEnv: opts.requiredEnv,
+        deprecated: opts.deprecated,
+        replacedBy: opts.replacedBy,
+        navigateBefore: opts.navigateBefore,
+        defaultFormat: opts.defaultFormat,
+    };
+    registerCommand(cmd);
+    return cmd;
+}
+export function getRegistry() {
+    return _registry;
+}
+export function fullName(cmd) {
+    return `${cmd.site}/${cmd.name}`;
+}
+export function strategyLabel(cmd) {
+    return cmd.strategy ?? Strategy.PUBLIC;
+}
+export function registerCommand(cmd) {
+    const canonicalKey = fullName(cmd);
+    const existing = _registry.get(canonicalKey);
+    if (existing) {
+        for (const [key, value] of _registry.entries()) {
+            if (value === existing && key !== canonicalKey)
+                _registry.delete(key);
+        }
+    }
+    const aliases = normalizeAliases(cmd.aliases, cmd.name);
+    cmd.aliases = aliases.length > 0 ? aliases : undefined;
+    _registry.set(canonicalKey, cmd);
+    for (const alias of aliases) {
+        _registry.set(`${cmd.site}/${alias}`, cmd);
+    }
+}
+function normalizeAliases(aliases, commandName) {
+    if (!Array.isArray(aliases) || aliases.length === 0)
+        return [];
+    const seen = new Set();
+    const normalized = [];
+    for (const alias of aliases) {
+        const value = typeof alias === 'string' ? alias.trim() : '';
+        if (!value || value === commandName || seen.has(value))
+            continue;
+        seen.add(value);
+        normalized.push(value);
+    }
+    return normalized;
+}

package/vendor/opencli/dist/registry.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for registry.ts: Strategy enum, cli() registration, helpers.
+ */
+export {};

package/vendor/opencli/dist/registry.test.js

@@ -0,0 +1,113 @@
+/**
+ * Tests for registry.ts: Strategy enum, cli() registration, helpers.
+ */
+import { describe, it, expect } from 'vitest';
+import { cli, getRegistry, fullName, strategyLabel, registerCommand, Strategy } from './registry.js';
+describe('cli() registration', () => {
+    it('registers a command and returns it', () => {
+        const cmd = cli({
+            site: 'test-registry',
+            name: 'hello',
+            description: 'A test command',
+            strategy: Strategy.PUBLIC,
+            browser: false,
+        });
+        expect(cmd.site).toBe('test-registry');
+        expect(cmd.name).toBe('hello');
+        expect(cmd.strategy).toBe(Strategy.PUBLIC);
+        expect(cmd.browser).toBe(false);
+        expect(cmd.args).toEqual([]);
+    });
+    it('puts registered command in the registry', () => {
+        cli({
+            site: 'test-registry',
+            name: 'registered',
+            description: 'test',
+        });
+        const registry = getRegistry();
+        expect(registry.has('test-registry/registered')).toBe(true);
+    });
+    it('defaults strategy to COOKIE when browser is true', () => {
+        const cmd = cli({
+            site: 'test-registry',
+            name: 'default-strategy',
+        });
+        expect(cmd.strategy).toBe(Strategy.COOKIE);
+        expect(cmd.browser).toBe(true);
+    });
+    it('defaults strategy to PUBLIC when browser is false', () => {
+        const cmd = cli({
+            site: 'test-registry',
+            name: 'no-browser',
+            browser: false,
+        });
+        expect(cmd.strategy).toBe(Strategy.PUBLIC);
+    });
+    it('overwrites existing command on re-registration', () => {
+        cli({ site: 'test-registry', name: 'overwrite', description: 'v1' });
+        cli({ site: 'test-registry', name: 'overwrite', description: 'v2' });
+        const reg = getRegistry();
+        expect(reg.get('test-registry/overwrite')?.description).toBe('v2');
+    });
+    it('registers aliases as alternate registry keys for the same command', () => {
+        const cmd = cli({
+            site: 'test-registry',
+            name: 'canonical',
+            description: 'test aliases',
+            aliases: ['compat', 'legacy-name'],
+        });
+        const registry = getRegistry();
+        expect(cmd.aliases).toEqual(['compat', 'legacy-name']);
+        expect(registry.get('test-registry/canonical')).toBe(cmd);
+        expect(registry.get('test-registry/compat')).toBe(cmd);
+        expect(registry.get('test-registry/legacy-name')).toBe(cmd);
+    });
+    it('preserves defaultFormat on the registered command', () => {
+        const cmd = cli({
+            site: 'test-registry',
+            name: 'plain-default',
+            description: 'prefers plain output',
+            defaultFormat: 'plain',
+        });
+        expect(cmd.defaultFormat).toBe('plain');
+        expect(getRegistry().get('test-registry/plain-default')?.defaultFormat).toBe('plain');
+    });
+});
+describe('fullName', () => {
+    it('returns site/name', () => {
+        const cmd = {
+            site: 'bilibili', name: 'hot', description: '', args: [],
+        };
+        expect(fullName(cmd)).toBe('bilibili/hot');
+    });
+});
+describe('strategyLabel', () => {
+    it('returns strategy string', () => {
+        const cmd = {
+            site: 'test', name: 'test', description: '', args: [],
+            strategy: Strategy.INTERCEPT,
+        };
+        expect(strategyLabel(cmd)).toBe('intercept');
+    });
+    it('returns public when no strategy set', () => {
+        const cmd = {
+            site: 'test', name: 'test', description: '', args: [],
+        };
+        expect(strategyLabel(cmd)).toBe('public');
+    });
+});
+describe('registerCommand', () => {
+    it('registers a pre-built command', () => {
+        const cmd = {
+            site: 'test-registry',
+            name: 'direct-reg',
+            description: 'directly registered',
+            args: [],
+            strategy: Strategy.HEADER,
+            browser: true,
+        };
+        registerCommand(cmd);
+        const reg = getRegistry();
+        expect(reg.get('test-registry/direct-reg')?.strategy).toBe(Strategy.HEADER);
+    });
+});

package/vendor/opencli/dist/runtime-detect.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Runtime detection — identify whether opencli is running under Node.js or Bun.
+ *
+ * Bun injects `globalThis.Bun` at startup, making detection trivial.
+ * This module centralises the check so other code can adapt behaviour
+ * (e.g. logging, diagnostics) without littering runtime sniffing everywhere.
+ */
+export type Runtime = 'bun' | 'node';
+/**
+ * Detect the current JavaScript runtime.
+ */
+export declare function detectRuntime(): Runtime;
+/**
+ * Return a human-readable version string for the current runtime.
+ * Examples: "v22.13.0" (Node), "1.1.42" (Bun)
+ */
+export declare function getRuntimeVersion(): string;
+/**
+ * Return a combined label like "node v22.13.0" or "bun 1.1.42".
+ */
+export declare function getRuntimeLabel(): string;

package/vendor/opencli/dist/runtime-detect.js

@@ -0,0 +1,32 @@
+/**
+ * Runtime detection — identify whether opencli is running under Node.js or Bun.
+ *
+ * Bun injects `globalThis.Bun` at startup, making detection trivial.
+ * This module centralises the check so other code can adapt behaviour
+ * (e.g. logging, diagnostics) without littering runtime sniffing everywhere.
+ */
+/**
+ * Detect the current JavaScript runtime.
+ */
+export function detectRuntime() {
+    // Bun always exposes globalThis.Bun (including Bun.version)
+    if (typeof globalThis.Bun !== 'undefined')
+        return 'bun';
+    return 'node';
+}
+/**
+ * Return a human-readable version string for the current runtime.
+ * Examples: "v22.13.0" (Node), "1.1.42" (Bun)
+ */
+export function getRuntimeVersion() {
+    if (detectRuntime() === 'bun') {
+        return globalThis.Bun.version;
+    }
+    return process.version; // e.g. "v22.13.0"
+}
+/**
+ * Return a combined label like "node v22.13.0" or "bun 1.1.42".
+ */
+export function getRuntimeLabel() {
+    return `${detectRuntime()} ${getRuntimeVersion()}`;
+}

package/vendor/opencli/dist/runtime-detect.test.d.ts

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