@huyuan-ai/cli 1.0.0 → 1.0.2

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

@@ -0,0 +1,297 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { discoverClis, discoverPlugins, ensureUserCliCompatShims, PLUGINS_DIR } from './discovery.js';
+import { executeCommand } from './execution.js';
+import { getRegistry, cli, Strategy } from './registry.js';
+import { clearAllHooks, onAfterExecute } from './hooks.js';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { pathToFileURL } from 'node:url';
+describe('discoverClis', () => {
+    it('handles non-existent directories gracefully', async () => {
+        // Should not throw for missing directories
+        await expect(discoverClis(path.join(os.tmpdir(), 'nonexistent-opencli-test-dir'))).resolves.not.toThrow();
+    });
+    it('imports only CLI command modules during filesystem discovery', async () => {
+        const tempRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-discovery-'));
+        const siteDir = path.join(tempRoot, 'temp-site');
+        const helperPath = path.join(siteDir, 'helper.ts');
+        const commandPath = path.join(siteDir, 'hello.ts');
+        try {
+            await fs.promises.mkdir(siteDir, { recursive: true });
+            await fs.promises.writeFile(helperPath, `
+globalThis.__opencli_helper_loaded__ = true;
+export const helper = true;
+`);
+            await fs.promises.writeFile(commandPath, `
+import { cli, Strategy } from '${pathToFileURL(path.join(process.cwd(), 'src', 'registry.ts')).href}';
+cli({
+  site: 'temp-site',
+  name: 'hello',
+  description: 'hello command',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  func: async () => [{ ok: true }],
+});
+`);
+            delete globalThis.__opencli_helper_loaded__;
+            await discoverClis(tempRoot);
+            expect(globalThis.__opencli_helper_loaded__).toBeUndefined();
+            expect(getRegistry().get('temp-site/hello')).toBeDefined();
+        }
+        finally {
+            delete globalThis.__opencli_helper_loaded__;
+            await fs.promises.rm(tempRoot, { recursive: true, force: true });
+        }
+    });
+    it('falls back to filesystem discovery when the manifest is invalid', async () => {
+        const tempBuildRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-manifest-fallback-'));
+        const distDir = path.join(tempBuildRoot, 'dist');
+        const siteDir = path.join(distDir, 'fallback-site');
+        const commandPath = path.join(siteDir, 'hello.ts');
+        const manifestPath = path.join(tempBuildRoot, 'cli-manifest.json');
+        try {
+            await fs.promises.mkdir(siteDir, { recursive: true });
+            await fs.promises.writeFile(manifestPath, '{ invalid json');
+            await fs.promises.writeFile(commandPath, `
+import { cli, Strategy } from '${pathToFileURL(path.join(process.cwd(), 'src', 'registry.ts')).href}';
+cli({
+  site: 'fallback-site',
+  name: 'hello',
+  description: 'hello command',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  func: async () => [{ ok: true }],
+});
+`);
+            await discoverClis(distDir);
+            expect(getRegistry().get('fallback-site/hello')).toBeDefined();
+        }
+        finally {
+            await fs.promises.rm(tempBuildRoot, { recursive: true, force: true });
+        }
+    });
+    it('loads legacy user TS CLI modules via compatibility shims', async () => {
+        const tempOpencliRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-user-clis-'));
+        const userClisDir = path.join(tempOpencliRoot, 'clis');
+        const siteDir = path.join(userClisDir, 'legacy-site');
+        const commandPath = path.join(siteDir, 'hello.ts');
+        try {
+            await ensureUserCliCompatShims(tempOpencliRoot);
+            await fs.promises.mkdir(siteDir, { recursive: true });
+            await fs.promises.writeFile(commandPath, `
+import { cli, Strategy } from '../../registry';
+import { CommandExecutionError } from '../../errors';
+
+cli({
+  site: 'legacy-site',
+  name: 'hello',
+  description: 'hello command',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  func: async () => [{ ok: true, errorName: new CommandExecutionError('boom').name }],
+});
+`);
+            await discoverClis(userClisDir);
+            const cmd = getRegistry().get('legacy-site/hello');
+            expect(cmd).toBeDefined();
+            await expect(executeCommand(cmd, {})).resolves.toEqual([{ ok: true, errorName: 'CommandExecutionError' }]);
+        }
+        finally {
+            await fs.promises.rm(tempOpencliRoot, { recursive: true, force: true });
+        }
+    });
+});
+describe('discoverPlugins', () => {
+    const testPluginDir = path.join(PLUGINS_DIR, '__test-plugin__');
+    const yamlPath = path.join(testPluginDir, 'greeting.yaml');
+    const symlinkTargetDir = path.join(os.tmpdir(), '__test-plugin-symlink-target__');
+    const symlinkPluginDir = path.join(PLUGINS_DIR, '__test-plugin-symlink__');
+    const brokenSymlinkDir = path.join(PLUGINS_DIR, '__test-plugin-broken__');
+    afterEach(async () => {
+        try {
+            await fs.promises.rm(testPluginDir, { recursive: true });
+        }
+        catch { }
+        try {
+            await fs.promises.rm(symlinkPluginDir, { recursive: true, force: true });
+        }
+        catch { }
+        try {
+            await fs.promises.rm(symlinkTargetDir, { recursive: true, force: true });
+        }
+        catch { }
+        try {
+            await fs.promises.rm(brokenSymlinkDir, { recursive: true, force: true });
+        }
+        catch { }
+    });
+    it('discovers YAML plugins from ~/.opencli/plugins/', async () => {
+        // Create a simple YAML adapter in the plugins directory
+        await fs.promises.mkdir(testPluginDir, { recursive: true });
+        await fs.promises.writeFile(yamlPath, `
+site: __test-plugin__
+name: greeting
+description: Test plugin greeting
+strategy: public
+browser: false
+
+pipeline:
+  - evaluate: "() => [{ message: 'hello from plugin' }]"
+
+columns: [message]
+`);
+        await discoverPlugins();
+        const registry = getRegistry();
+        const cmd = registry.get('__test-plugin__/greeting');
+        expect(cmd).toBeDefined();
+        expect(cmd.site).toBe('__test-plugin__');
+        expect(cmd.name).toBe('greeting');
+        expect(cmd.description).toBe('Test plugin greeting');
+    });
+    it('handles non-existent plugins directory gracefully', async () => {
+        // discoverPlugins should not throw if ~/.opencli/plugins/ does not exist
+        await expect(discoverPlugins()).resolves.not.toThrow();
+    });
+    it('discovers YAML plugins from symlinked plugin directories', async () => {
+        await fs.promises.mkdir(PLUGINS_DIR, { recursive: true });
+        await fs.promises.mkdir(symlinkTargetDir, { recursive: true });
+        await fs.promises.writeFile(path.join(symlinkTargetDir, 'hello.yaml'), `
+site: __test-plugin-symlink__
+name: hello
+description: Test plugin greeting via symlink
+strategy: public
+browser: false
+
+pipeline:
+  - evaluate: "() => [{ message: 'hello from symlink plugin' }]"
+
+columns: [message]
+`);
+        await fs.promises.symlink(symlinkTargetDir, symlinkPluginDir, 'dir');
+        await discoverPlugins();
+        const cmd = getRegistry().get('__test-plugin-symlink__/hello');
+        expect(cmd).toBeDefined();
+        expect(cmd.description).toBe('Test plugin greeting via symlink');
+    });
+    it('skips broken plugin symlinks without throwing', async () => {
+        await fs.promises.mkdir(PLUGINS_DIR, { recursive: true });
+        await fs.promises.symlink(path.join(os.tmpdir(), '__missing-plugin-target__'), brokenSymlinkDir, 'dir');
+        await expect(discoverPlugins()).resolves.not.toThrow();
+        expect(getRegistry().get('__test-plugin-broken__/hello')).toBeUndefined();
+    });
+});
+describe('executeCommand', () => {
+    beforeEach(() => {
+        clearAllHooks();
+        vi.unstubAllEnvs();
+    });
+    it('accepts kebab-case option names after Commander camelCases them', async () => {
+        const cmd = cli({
+            site: 'test-engine',
+            name: 'kebab-arg-test',
+            description: 'test command with kebab-case arg',
+            browser: false,
+            strategy: Strategy.PUBLIC,
+            args: [
+                { name: 'note-id', required: true, help: 'Note ID' },
+            ],
+            func: async (_page, kwargs) => [{ noteId: kwargs['note-id'] }],
+        });
+        const result = await executeCommand(cmd, { 'note-id': 'abc123' });
+        expect(result).toEqual([{ noteId: 'abc123' }]);
+    });
+    it('executes a command with func', async () => {
+        const cmd = cli({
+            site: 'test-engine',
+            name: 'func-test',
+            description: 'test command with func',
+            browser: false,
+            strategy: Strategy.PUBLIC,
+            func: async (_page, kwargs) => {
+                return [{ title: kwargs.query ?? 'default' }];
+            },
+        });
+        const result = await executeCommand(cmd, { query: 'hello' });
+        expect(result).toEqual([{ title: 'hello' }]);
+    });
+    it('executes a command with pipeline', async () => {
+        const cmd = cli({
+            site: 'test-engine',
+            name: 'pipe-test',
+            description: 'test command with pipeline',
+            browser: false,
+            strategy: Strategy.PUBLIC,
+            pipeline: [
+                { evaluate: '() => [{ n: 1 }, { n: 2 }, { n: 3 }]' },
+                { limit: '2' },
+            ],
+        });
+        // Pipeline commands require page for evaluate step, so we'll test the error path
+        await expect(executeCommand(cmd, {})).rejects.toThrow();
+    });
+    it('throws for command with no func or pipeline', async () => {
+        const cmd = cli({
+            site: 'test-engine',
+            name: 'empty-test',
+            description: 'empty command',
+            browser: false,
+        });
+        await expect(executeCommand(cmd, {})).rejects.toThrow('has no func or pipeline');
+    });
+    it('passes debug flag to func', async () => {
+        let receivedDebug = false;
+        const cmd = cli({
+            site: 'test-engine',
+            name: 'debug-test',
+            description: 'debug test',
+            browser: false,
+            func: async (_page, _kwargs, debug) => {
+                receivedDebug = debug ?? false;
+                return [];
+            },
+        });
+        await executeCommand(cmd, {}, true);
+        expect(receivedDebug).toBe(true);
+    });
+    it('fires onAfterExecute even when command execution throws', async () => {
+        const seen = [];
+        onAfterExecute((ctx) => {
+            seen.push({ error: ctx.error, finishedAt: ctx.finishedAt });
+        });
+        const cmd = cli({
+            site: 'test-engine',
+            name: 'failing-test',
+            description: 'failing command',
+            browser: false,
+            strategy: Strategy.PUBLIC,
+            func: async () => {
+                throw new Error('boom');
+            },
+        });
+        await expect(executeCommand(cmd, {})).rejects.toThrow('boom');
+        expect(seen).toHaveLength(1);
+        expect(seen[0].error).toBeInstanceOf(Error);
+        expect(seen[0].error.message).toBe('boom');
+        expect(typeof seen[0].finishedAt).toBe('number');
+    });
+    it('uses launcher for registered Electron apps (chatwise)', async () => {
+        // Mock the launcher to return a fake endpoint (avoids real HTTP/process calls)
+        const launcher = await import('./launcher.js');
+        const spy = vi.spyOn(launcher, 'resolveElectronEndpoint')
+            .mockResolvedValue('http://127.0.0.1:9228');
+        const cmd = cli({
+            site: 'chatwise',
+            name: 'status',
+            description: 'chatwise status',
+            browser: true,
+            strategy: Strategy.PUBLIC,
+            func: async () => [{ ok: true }],
+        });
+        // CDPBridge.connect() will fail (no actual CDP server), but the launcher
+        // should have been called with 'chatwise'.
+        await expect(executeCommand(cmd, {})).rejects.toThrow();
+        expect(spy).toHaveBeenCalledWith('chatwise');
+        spy.mockRestore();
+    });
+});

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

@@ -0,0 +1,76 @@
+/**
+ * Unified error types for opencli.
+ *
+ * All errors thrown by the framework should extend CliError so that
+ * the top-level handler in commanderAdapter.ts can render consistent,
+ * helpful output with emoji-coded severity and actionable hints.
+ *
+ * ## Exit codes
+ *
+ * opencli follows Unix conventions (sysexits.h) for process exit codes:
+ *
+ *   0   Success
+ *   1   Generic / unexpected error
+ *   2   Argument / usage error          (ArgumentError)
+ *  66   No input / empty result         (EmptyResultError)
+ *  69   Service unavailable             (BrowserConnectError, AdapterLoadError)
+ *  75   Temporary failure, retry later  (TimeoutError)   EX_TEMPFAIL
+ *  77   Permission denied / auth needed (AuthRequiredError)
+ *  78   Configuration error             (ConfigError)
+ * 130   Interrupted by Ctrl-C           (set by tui.ts SIGINT handler)
+ */
+export declare const EXIT_CODES: {
+    readonly SUCCESS: 0;
+    readonly GENERIC_ERROR: 1;
+    readonly USAGE_ERROR: 2;
+    readonly EMPTY_RESULT: 66;
+    readonly SERVICE_UNAVAIL: 69;
+    readonly TEMPFAIL: 75;
+    readonly NOPERM: 77;
+    readonly CONFIG_ERROR: 78;
+    readonly INTERRUPTED: 130;
+};
+export type ExitCode = typeof EXIT_CODES[keyof typeof EXIT_CODES];
+export declare class CliError extends Error {
+    /** Machine-readable error code (e.g. 'BROWSER_CONNECT', 'AUTH_REQUIRED') */
+    readonly code: string;
+    /** Human-readable hint on how to fix the problem */
+    readonly hint?: string;
+    /** Unix process exit code — defaults to 1 (generic error) */
+    readonly exitCode: ExitCode;
+    constructor(code: string, message: string, hint?: string, exitCode?: ExitCode);
+}
+export type BrowserConnectKind = 'daemon-not-running' | 'extension-not-connected' | 'command-failed' | 'unknown';
+export declare class BrowserConnectError extends CliError {
+    readonly kind: BrowserConnectKind;
+    constructor(message: string, hint?: string, kind?: BrowserConnectKind);
+}
+export declare class AdapterLoadError extends CliError {
+    constructor(message: string, hint?: string);
+}
+export declare class CommandExecutionError extends CliError {
+    constructor(message: string, hint?: string);
+}
+export declare class ConfigError extends CliError {
+    constructor(message: string, hint?: string);
+}
+export declare class AuthRequiredError extends CliError {
+    readonly domain: string;
+    constructor(domain: string, message?: string);
+}
+export declare class TimeoutError extends CliError {
+    constructor(label: string, seconds: number, hint?: string);
+}
+export declare class ArgumentError extends CliError {
+    constructor(message: string, hint?: string);
+}
+export declare class EmptyResultError extends CliError {
+    constructor(command: string, hint?: string);
+}
+export declare class SelectorError extends CliError {
+    constructor(selector: string, hint?: string);
+}
+/** Extract a human-readable message from an unknown caught value. */
+export declare function getErrorMessage(error: unknown): string;
+/** Error code → emoji mapping for CLI output rendering. */
+export declare const ERROR_ICONS: Record<string, string>;

package/vendor/opencli/dist/errors.js

@@ -0,0 +1,119 @@
+/**
+ * Unified error types for opencli.
+ *
+ * All errors thrown by the framework should extend CliError so that
+ * the top-level handler in commanderAdapter.ts can render consistent,
+ * helpful output with emoji-coded severity and actionable hints.
+ *
+ * ## Exit codes
+ *
+ * opencli follows Unix conventions (sysexits.h) for process exit codes:
+ *
+ *   0   Success
+ *   1   Generic / unexpected error
+ *   2   Argument / usage error          (ArgumentError)
+ *  66   No input / empty result         (EmptyResultError)
+ *  69   Service unavailable             (BrowserConnectError, AdapterLoadError)
+ *  75   Temporary failure, retry later  (TimeoutError)   EX_TEMPFAIL
+ *  77   Permission denied / auth needed (AuthRequiredError)
+ *  78   Configuration error             (ConfigError)
+ * 130   Interrupted by Ctrl-C           (set by tui.ts SIGINT handler)
+ */
+// ── Exit code table ──────────────────────────────────────────────────────────
+export const EXIT_CODES = {
+    SUCCESS: 0,
+    GENERIC_ERROR: 1,
+    USAGE_ERROR: 2, // Bad arguments / command misuse
+    EMPTY_RESULT: 66, // No data / not found           (EX_NOINPUT)
+    SERVICE_UNAVAIL: 69, // Daemon / browser unavailable  (EX_UNAVAILABLE)
+    TEMPFAIL: 75, // Timeout — try again later     (EX_TEMPFAIL)
+    NOPERM: 77, // Auth required / permission    (EX_NOPERM)
+    CONFIG_ERROR: 78, // Missing / invalid config      (EX_CONFIG)
+    INTERRUPTED: 130, // Ctrl-C / SIGINT
+};
+// ── Base class ───────────────────────────────────────────────────────────────
+export class CliError extends Error {
+    /** Machine-readable error code (e.g. 'BROWSER_CONNECT', 'AUTH_REQUIRED') */
+    code;
+    /** Human-readable hint on how to fix the problem */
+    hint;
+    /** Unix process exit code — defaults to 1 (generic error) */
+    exitCode;
+    constructor(code, message, hint, exitCode = EXIT_CODES.GENERIC_ERROR) {
+        super(message);
+        this.name = new.target.name;
+        this.code = code;
+        this.hint = hint;
+        this.exitCode = exitCode;
+    }
+}
+export class BrowserConnectError extends CliError {
+    kind;
+    constructor(message, hint, kind = 'unknown') {
+        super('BROWSER_CONNECT', message, hint, EXIT_CODES.SERVICE_UNAVAIL);
+        this.kind = kind;
+    }
+}
+export class AdapterLoadError extends CliError {
+    constructor(message, hint) {
+        super('ADAPTER_LOAD', message, hint, EXIT_CODES.SERVICE_UNAVAIL);
+    }
+}
+export class CommandExecutionError extends CliError {
+    constructor(message, hint) {
+        super('COMMAND_EXEC', message, hint, EXIT_CODES.GENERIC_ERROR);
+    }
+}
+export class ConfigError extends CliError {
+    constructor(message, hint) {
+        super('CONFIG', message, hint, EXIT_CODES.CONFIG_ERROR);
+    }
+}
+export class AuthRequiredError extends CliError {
+    domain;
+    constructor(domain, message) {
+        super('AUTH_REQUIRED', message ?? `Not logged in to ${domain}`, `Please open Chrome or Chromium and log in to https://${domain}`, EXIT_CODES.NOPERM);
+        this.domain = domain;
+    }
+}
+export class TimeoutError extends CliError {
+    constructor(label, seconds, hint) {
+        super('TIMEOUT', `${label} timed out after ${seconds}s`, hint ?? 'Try again, or increase timeout with OPENCLI_BROWSER_COMMAND_TIMEOUT env var', EXIT_CODES.TEMPFAIL);
+    }
+}
+export class ArgumentError extends CliError {
+    constructor(message, hint) {
+        super('ARGUMENT', message, hint, EXIT_CODES.USAGE_ERROR);
+    }
+}
+export class EmptyResultError extends CliError {
+    constructor(command, hint) {
+        super('EMPTY_RESULT', `${command} returned no data`, hint ?? 'The page structure may have changed, or you may need to log in', EXIT_CODES.EMPTY_RESULT);
+    }
+}
+export class SelectorError extends CliError {
+    constructor(selector, hint) {
+        super('SELECTOR', `Could not find element: ${selector}`, hint ?? 'The page UI may have changed. Please report this issue.', EXIT_CODES.GENERIC_ERROR);
+    }
+}
+// ── Utilities ───────────────────────────────────────────────────────────────
+/** Extract a human-readable message from an unknown caught value. */
+export function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Error code → emoji mapping for CLI output rendering. */
+export const ERROR_ICONS = {
+    AUTH_REQUIRED: '🔒',
+    BROWSER_CONNECT: '🔌',
+    TIMEOUT: '⏱ ',
+    ARGUMENT: '❌',
+    EMPTY_RESULT: '📭',
+    SELECTOR: '🔍',
+    COMMAND_EXEC: '💥',
+    ADAPTER_LOAD: '📦',
+    NETWORK: '🌐',
+    API_ERROR: '🚫',
+    RATE_LIMITED: '⏳',
+    PAGE_CHANGED: '🔄',
+    CONFIG: '⚙️ ',
+};

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

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

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

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+import { CliError, BrowserConnectError, AdapterLoadError, CommandExecutionError, ConfigError, AuthRequiredError, TimeoutError, ArgumentError, EmptyResultError, SelectorError, } from './errors.js';
+describe('Error type hierarchy', () => {
+    it('all error types extend CliError', () => {
+        const errors = [
+            new BrowserConnectError('test'),
+            new AdapterLoadError('test'),
+            new CommandExecutionError('test'),
+            new ConfigError('test'),
+            new AuthRequiredError('example.com'),
+            new TimeoutError('test', 30),
+            new ArgumentError('test'),
+            new EmptyResultError('test/cmd'),
+            new SelectorError('.btn'),
+        ];
+        for (const err of errors) {
+            expect(err).toBeInstanceOf(CliError);
+            expect(err).toBeInstanceOf(Error);
+        }
+    });
+    it('AuthRequiredError has correct code, domain, and auto-generated hint', () => {
+        const err = new AuthRequiredError('bilibili.com');
+        expect(err.code).toBe('AUTH_REQUIRED');
+        expect(err.domain).toBe('bilibili.com');
+        expect(err.message).toBe('Not logged in to bilibili.com');
+        expect(err.hint).toContain('https://bilibili.com');
+    });
+    it('AuthRequiredError accepts custom message', () => {
+        const err = new AuthRequiredError('x.com', 'No ct0 cookie found');
+        expect(err.message).toBe('No ct0 cookie found');
+        expect(err.hint).toContain('https://x.com');
+    });
+    it('TimeoutError has correct code and hint', () => {
+        const err = new TimeoutError('bilibili/hot', 60);
+        expect(err.code).toBe('TIMEOUT');
+        expect(err.message).toBe('bilibili/hot timed out after 60s');
+        expect(err.hint).toContain('timeout');
+    });
+    it('ArgumentError has correct code', () => {
+        const err = new ArgumentError('Argument "limit" must be a valid number');
+        expect(err.code).toBe('ARGUMENT');
+    });
+    it('EmptyResultError has default hint', () => {
+        const err = new EmptyResultError('hackernews/top');
+        expect(err.code).toBe('EMPTY_RESULT');
+        expect(err.message).toBe('hackernews/top returned no data');
+        expect(err.hint).toBeTruthy();
+    });
+    it('SelectorError has default hint about page changes', () => {
+        const err = new SelectorError('.submit-btn');
+        expect(err.code).toBe('SELECTOR');
+        expect(err.message).toContain('.submit-btn');
+        expect(err.hint).toContain('report');
+    });
+    it('BrowserConnectError has correct code', () => {
+        const err = new BrowserConnectError('Cannot connect');
+        expect(err.code).toBe('BROWSER_CONNECT');
+    });
+});

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

@@ -0,0 +1,14 @@
+/**
+ * Command execution: validates args, manages browser sessions, runs commands.
+ *
+ * This is the single entry point for executing any CLI command. It handles:
+ * 1. Argument validation and coercion
+ * 2. Browser session lifecycle (if needed)
+ * 3. Domain pre-navigation for cookie/header strategies
+ * 4. Timeout enforcement
+ * 5. Lazy-loading of TS modules from manifest
+ * 6. Lifecycle hooks (onBeforeExecute / onAfterExecute)
+ */
+import { type CliCommand, type Arg, type CommandArgs } from './registry.js';
+export declare function coerceAndValidateArgs(cmdArgs: Arg[], kwargs: CommandArgs): CommandArgs;
+export declare function executeCommand(cmd: CliCommand, rawKwargs: CommandArgs, debug?: boolean): Promise<unknown>;