@jackwener/opencli 1.7.13 → 1.7.15

package/dist/src/commanderAdapter.js

@@ -12,10 +12,9 @@
 import { log } from './logger.js';
 import yaml from 'js-yaml';
 import { fullName, getRegistry } from './registry.js';
-import { formatRegistryHelpText } from './serialization.js';
 import { render as renderOutput } from './output.js';
 import { executeCommand, prepareCommandArgs } from './execution.js';
-import { commandHelpData, formatSiteCommandDescription, installStructuredHelp, siteHelpData, } from './help.js';
+import { commandHelpData, formatCommandHelpText, formatCommandListTerm, formatSiteCommandDescription, formatSiteHelpText, getRequestedHelpFormat, renderStructuredHelp, siteHelpData, } from './help.js';
 import { CliError, EXIT_CODES, toEnvelope, } from './errors.js';
 /**
  * Register a single CliCommand as a Commander subcommand.
@@ -49,7 +48,16 @@ export function registerCommandToProgram(siteCmd, cmd) {
         .option('-f, --format <fmt>', 'Output format: table, plain, json, yaml, md, csv', 'table')
         .option('--trace <mode>', 'Trace capture: off, on, retain-on-failure', 'off')
         .option('-v, --verbose', 'Debug output', false);
-    installStructuredHelp(subCmd, () => commandHelpData(cmd), () => formatRegistryHelpText(cmd));
+    const originalHelpInformation = subCmd.helpInformation.bind(subCmd);
+    subCmd.helpInformation = ((contextOptions) => {
+        const format = getRequestedHelpFormat();
+        if (format)
+            return renderStructuredHelp(commandHelpData(cmd), format);
+        // Keep a fallback reference so future Commander upgrades still initialize
+        // internal help state before we render the cleaner grouped command help.
+        void originalHelpInformation(contextOptions);
+        return formatCommandHelpText(cmd);
+    });
     subCmd.action(async (...actionArgs) => {
         const actionOpts = actionArgs[positionalArgs.length] ?? {};
         const optionsRecord = typeof actionOpts === 'object' && actionOpts !== null ? actionOpts : {};
@@ -174,7 +182,18 @@ export function registerAllCommands(program, siteGroups) {
         for (const cmd of commands) {
             registerCommandToProgram(siteCmd, cmd);
         }
-        installStructuredHelp(siteCmd, () => siteHelpData(site, commands));
+        const commandTerms = new Map(commands.map(cmd => [cmd.name, formatCommandListTerm(cmd)]));
+        siteCmd.configureHelp({
+            subcommandTerm: command => commandTerms.get(command.name()) ?? command.name(),
+        });
+        const originalSiteHelpInformation = siteCmd.helpInformation.bind(siteCmd);
+        siteCmd.helpInformation = ((contextOptions) => {
+            const format = getRequestedHelpFormat();
+            if (format)
+                return renderStructuredHelp(siteHelpData(site, commands), format);
+            void originalSiteHelpInformation(contextOptions);
+            return formatSiteHelpText(site, commands);
+        });
     }
     return [...commandsBySite.keys()].sort((a, b) => a.localeCompare(b));
 }

package/dist/src/help.d.ts

@@ -1,6 +1,24 @@
 import { Command } from 'commander';
 import type { CliCommand } from './registry.js';
 export type StructuredHelpFormat = 'yaml' | 'json';
+export interface ArgSpec {
+    name: string;
+    required?: true;
+    variadic?: true;
+    help?: string;
+    default?: unknown;
+    choices?: string[];
+}
+export interface OptionSpec {
+    name: string;
+    flags: string;
+    help?: string;
+    takes_value?: 'required' | 'optional';
+    required?: true;
+    default?: unknown;
+    choices?: string[];
+    negate?: true;
+}
 export declare function getRequestedHelpFormat(argv?: readonly string[]): StructuredHelpFormat | undefined;
 export declare function renderStructuredHelp(data: unknown, format: StructuredHelpFormat): string;
 export declare function wrapCommaList(items: readonly string[], opts?: {
@@ -29,8 +47,26 @@ export interface RootAdapterGroups {
     sites: readonly string[];
 }
 export declare function formatRootAdapterHelpText(groups: RootAdapterGroups): string;
+export declare function commanderNamespaceHelpData(namespaceRoot: Command, opts?: {
+    globalCommand?: Command;
+    description?: string;
+}): Record<string, unknown>;
+export declare function commanderCommandHelpData(namespaceRoot: Command, command: Command, opts?: {
+    globalCommand?: Command;
+}): Record<string, unknown>;
+export declare function commanderGroupHelpData(namespaceRoot: Command, groupCommand: Command, opts?: {
+    globalCommand?: Command;
+}): Record<string, unknown>;
+export declare function installCommanderNamespaceStructuredHelp(namespaceRoot: Command, opts?: {
+    globalCommand?: Command;
+    description?: string;
+}): void;
+export declare function formatCommandListTerm(cmd: CliCommand): string;
 export declare function rootHelpData(program: Command, groups: RootAdapterGroups): Record<string, unknown>;
 export declare function siteHelpData(site: string, commands: readonly CliCommand[]): Record<string, unknown>;
 export declare function commandHelpData(cmd: CliCommand): Record<string, unknown>;
+export declare function formatCommonOptionsHelpText(): string;
+export declare function formatSiteHelpText(site: string, commands: readonly CliCommand[]): string;
+export declare function formatCommandHelpText(cmd: CliCommand): string;
 export declare function installStructuredHelp(command: Command, data: () => unknown, textSuffix?: string | (() => string)): void;
 export declare function formatSiteCommandDescription(cmd: CliCommand): string;

package/dist/src/help.js

@@ -1,6 +1,33 @@
 import yaml from 'js-yaml';
 import { fullName } from './registry.js';
 import { formatCommandExample } from './serialization.js';
+const COMMON_OPTIONS = [
+    {
+        flags: '-f, --format <fmt>',
+        name: 'format',
+        help: 'Output format: table, plain, json, yaml, md, csv',
+        default: 'table',
+        choices: ['table', 'plain', 'json', 'yaml', 'md', 'csv'],
+    },
+    {
+        flags: '--trace <mode>',
+        name: 'trace',
+        help: 'Trace capture: off, on, retain-on-failure',
+        default: 'off',
+        choices: ['off', 'on', 'retain-on-failure'],
+    },
+    {
+        flags: '-v, --verbose',
+        name: 'verbose',
+        help: 'Debug output',
+        default: false,
+    },
+    {
+        flags: '-h, --help',
+        name: 'help',
+        help: 'display help for command',
+    },
+];
 function normalizeStructuredHelpFormat(value) {
     const normalized = value?.toLowerCase();
     if (normalized === 'yaml' || normalized === 'yml')
@@ -73,7 +100,7 @@ export function formatRootAdapterHelpText(groups) {
     lines.push(...formatGroupSection('App adapters', groups.apps));
     lines.push(...formatGroupSection('Site adapters', groups.sites));
     lines.push("Run 'opencli list' for full command details, or 'opencli <site> --help' to inspect one site.");
-    lines.push("Agent tip: use 'opencli <site> --help -f yaml' for structured commands, args, access, and examples.");
+    lines.push("Agent tip: use 'opencli <site> --help -f yaml' for all command args/options in one structured response.");
     lines.push('');
     return lines.join('\n');
 }
@@ -89,18 +116,201 @@ function compactArg(arg) {
         ...(arg.help ? { help: arg.help } : {}),
     };
 }
-function compactCommand(cmd, opts = {}) {
+function compactCommonOption(option) {
+    return {
+        name: option.name,
+        flags: option.flags,
+        help: option.help,
+        ...('default' in option ? { default: option.default } : {}),
+        ...('choices' in option ? { choices: option.choices } : {}),
+    };
+}
+function compactCommanderArgument(arg) {
+    return {
+        name: arg.name(),
+        ...(arg.required ? { required: true } : {}),
+        ...(arg.variadic ? { variadic: true } : {}),
+        ...(arg.description ? { help: arg.description } : {}),
+        ...(arg.defaultValue !== undefined ? { default: arg.defaultValue } : {}),
+        ...(arg.argChoices?.length ? { choices: [...arg.argChoices] } : {}),
+    };
+}
+function compactCommanderOption(option) {
+    if (option.hidden)
+        return null;
+    return {
+        name: option.attributeName(),
+        flags: option.flags,
+        ...(option.description ? { help: option.description } : {}),
+        ...(option.required ? { takes_value: 'required' } : {}),
+        ...(option.optional ? { takes_value: 'optional' } : {}),
+        ...(option.mandatory ? { required: true } : {}),
+        ...(option.defaultValue !== undefined ? { default: option.defaultValue } : {}),
+        ...(option.argChoices?.length ? { choices: [...option.argChoices] } : {}),
+        ...(option.negate ? { negate: true } : {}),
+    };
+}
+function compactCommanderOptions(options) {
+    return options
+        .map(compactCommanderOption)
+        .filter((option) => option !== null);
+}
+function commanderPath(command) {
+    const parts = [];
+    let current = command;
+    while (current) {
+        const name = current.name();
+        if (name)
+            parts.push(name);
+        current = current.parent;
+    }
+    return parts.reverse();
+}
+function commandPathFromRoot(namespaceRoot, command) {
+    const rootPath = commanderPath(namespaceRoot);
+    const commandPath = commanderPath(command);
+    return commandPath.slice(rootPath.length);
+}
+function collectLeafCommands(command) {
+    if (command.commands.length === 0)
+        return [command];
+    return command.commands.flatMap(child => collectLeafCommands(child));
+}
+function collectDescendantCommands(command) {
+    return command.commands.flatMap(child => [child, ...collectDescendantCommands(child)]);
+}
+function formatCommanderPositionals(args) {
+    return args
+        .map(arg => {
+        const name = `${arg.name()}${arg.variadic ? '...' : ''}`;
+        return arg.required ? `<${name}>` : `[${name}]`;
+    })
+        .join(' ');
+}
+function formatCommanderUsage(command, opts = {}) {
+    const path = commanderPath(command).join(' ');
+    const positionalText = formatCommanderPositionals(command.registeredArguments);
+    const hasOptions = compactCommanderOptions(command.options).length > 0
+        || (opts.namespaceRoot ? compactCommanderOptions(opts.namespaceRoot.options).length > 0 : false)
+        || (opts.globalCommand ? compactCommanderOptions(opts.globalCommand.options).length > 0 : false);
+    const optionText = hasOptions ? ' [options]' : '';
+    return `${path}${positionalText ? ` ${positionalText}` : ''}${optionText}`;
+}
+function compactCommanderCommand(namespaceRoot, command, opts = {}) {
+    const relativePath = commandPathFromRoot(namespaceRoot, command);
+    return {
+        name: relativePath.join(' '),
+        command: commanderPath(command).join(' '),
+        usage: formatCommanderUsage(command, { namespaceRoot, globalCommand: opts.globalCommand }),
+        description: command.description(),
+        ...(command.aliases().length ? { aliases: command.aliases() } : {}),
+        positionals: command.registeredArguments.map(compactCommanderArgument),
+        command_options: compactCommanderOptions(command.options),
+    };
+}
+export function commanderNamespaceHelpData(namespaceRoot, opts = {}) {
+    const leaves = collectLeafCommands(namespaceRoot)
+        .filter(command => command !== namespaceRoot)
+        .sort((a, b) => commandPathFromRoot(namespaceRoot, a).join(' ').localeCompare(commandPathFromRoot(namespaceRoot, b).join(' ')));
+    return {
+        namespace: namespaceRoot.name(),
+        command: commanderPath(namespaceRoot).join(' '),
+        usage: `${commanderPath(namespaceRoot).join(' ')} <command> [args] [options]`,
+        description: opts.description ?? namespaceRoot.description(),
+        command_count: leaves.length,
+        commands: leaves.map(command => compactCommanderCommand(namespaceRoot, command, opts)),
+        namespace_options: compactCommanderOptions(namespaceRoot.options),
+        ...(opts.globalCommand ? { global_options: compactCommanderOptions(opts.globalCommand.options) } : {}),
+        structured_help: {
+            formats: ['yaml', 'json'],
+            usage: `${commanderPath(namespaceRoot).join(' ')} --help -f yaml`,
+        },
+    };
+}
+export function commanderCommandHelpData(namespaceRoot, command, opts = {}) {
+    return {
+        namespace: namespaceRoot.name(),
+        ...compactCommanderCommand(namespaceRoot, command, opts),
+        namespace_options: compactCommanderOptions(namespaceRoot.options),
+        ...(opts.globalCommand ? { global_options: compactCommanderOptions(opts.globalCommand.options) } : {}),
+        structured_help: {
+            formats: ['yaml', 'json'],
+            usage: `${commanderPath(command).join(' ')} --help -f yaml`,
+        },
+    };
+}
+export function commanderGroupHelpData(namespaceRoot, groupCommand, opts = {}) {
+    const leaves = collectLeafCommands(groupCommand)
+        .filter(command => command !== groupCommand)
+        .sort((a, b) => commandPathFromRoot(namespaceRoot, a).join(' ').localeCompare(commandPathFromRoot(namespaceRoot, b).join(' ')));
+    return {
+        namespace: namespaceRoot.name(),
+        group: commandPathFromRoot(namespaceRoot, groupCommand).join(' '),
+        command: commanderPath(groupCommand).join(' '),
+        usage: `${commanderPath(groupCommand).join(' ')} <command> [args] [options]`,
+        description: groupCommand.description(),
+        command_count: leaves.length,
+        commands: leaves.map(command => compactCommanderCommand(namespaceRoot, command, opts)),
+        namespace_options: compactCommanderOptions(namespaceRoot.options),
+        ...(opts.globalCommand ? { global_options: compactCommanderOptions(opts.globalCommand.options) } : {}),
+        structured_help: {
+            formats: ['yaml', 'json'],
+            usage: `${commanderPath(groupCommand).join(' ')} --help -f yaml`,
+        },
+    };
+}
+export function installCommanderNamespaceStructuredHelp(namespaceRoot, opts = {}) {
+    installStructuredHelp(namespaceRoot, () => commanderNamespaceHelpData(namespaceRoot, opts));
+    for (const command of collectDescendantCommands(namespaceRoot)) {
+        if (command.commands.length > 0) {
+            installStructuredHelp(command, () => commanderGroupHelpData(namespaceRoot, command, opts));
+        }
+        else {
+            installStructuredHelp(command, () => commanderCommandHelpData(namespaceRoot, command, opts));
+        }
+    }
+}
+function positionals(cmd) {
+    return cmd.args.filter(arg => arg.positional);
+}
+function commandOptions(cmd) {
+    return cmd.args.filter(arg => !arg.positional);
+}
+function formatPositionals(args) {
+    return args
+        .map(arg => arg.required ? `<${arg.name}>` : `[${arg.name}]`)
+        .join(' ');
+}
+function formatCommandOptionTerm(arg) {
+    if (arg.required || arg.valueRequired)
+        return `--${arg.name} <value>`;
+    return `--${arg.name} [value]`;
+}
+export function formatCommandListTerm(cmd) {
+    const positionalText = formatPositionals(positionals(cmd));
+    const optionText = commandOptions(cmd).length > 0 ? ' [options]' : '';
+    return `${cmd.name}${positionalText ? ` ${positionalText}` : ''}${optionText}`;
+}
+function formatUsage(cmd) {
+    const positionalText = formatPositionals(positionals(cmd));
+    return `opencli ${cmd.site} ${cmd.name}${positionalText ? ` ${positionalText}` : ''} [options]`;
+}
+function compactCommand(cmd) {
     return {
         name: cmd.name,
         command: `opencli ${cmd.site} ${cmd.name}`,
+        usage: formatUsage(cmd),
         access: cmd.access,
         description: cmd.description,
+        browser: !!cmd.browser,
+        ...(cmd.domain ? { domain: cmd.domain } : {}),
         ...(cmd.aliases?.length ? { aliases: cmd.aliases } : {}),
-        args: cmd.args.map(compactArg),
+        positionals: positionals(cmd).map(compactArg),
+        command_options: commandOptions(cmd).map(compactArg),
         example: formatCommandExample(cmd),
         ...(cmd.browserSession ? { browserSession: cmd.browserSession } : {}),
         ...(cmd.defaultFormat ? { defaultFormat: cmd.defaultFormat } : {}),
-        ...(opts.includeColumns && cmd.columns?.length ? { columns: cmd.columns } : {}),
+        ...(cmd.columns?.length ? { columns: cmd.columns } : {}),
     };
 }
 export function rootHelpData(program, groups) {
@@ -142,6 +352,7 @@ export function siteHelpData(site, commands) {
         site,
         command_count: unique.length,
         commands: unique.map(cmd => compactCommand(cmd)),
+        common_options: COMMON_OPTIONS.map(compactCommonOption),
         next: [
             `opencli ${site} <command> --help -f yaml`,
             `opencli ${site} <command> -f yaml`,
@@ -151,10 +362,95 @@ export function siteHelpData(site, commands) {
 export function commandHelpData(cmd) {
     return {
         site: cmd.site,
-        ...compactCommand(cmd, { includeColumns: true }),
+        ...compactCommand(cmd),
+        common_options: COMMON_OPTIONS.map(compactCommonOption),
         output_formats: ['table', 'plain', 'yaml', 'json', 'md', 'csv'],
     };
 }
+function formatRows(rows) {
+    if (rows.length === 0)
+        return [];
+    const width = Math.min(Math.max(...rows.map(([left]) => left.length)), 34);
+    return rows.map(([left, right]) => `  ${left.padEnd(width + 2)}${right}`);
+}
+function formatArgHelp(arg) {
+    const parts = [];
+    if (arg.help)
+        parts.push(arg.help);
+    if (arg.default !== undefined)
+        parts.push(`default: ${arg.default}`);
+    if (arg.choices?.length)
+        parts.push(`choices: ${arg.choices.join(', ')}`);
+    return parts.join('  ');
+}
+export function formatCommonOptionsHelpText() {
+    const rows = COMMON_OPTIONS.map(option => {
+        const details = [option.help];
+        if ('default' in option)
+            details.push(`default: ${option.default}`);
+        if ('choices' in option)
+            details.push(`choices: ${option.choices.join(', ')}`);
+        return [option.flags, details.join('  ')];
+    });
+    return ['Common options:', ...formatRows(rows)].join('\n');
+}
+export function formatSiteHelpText(site, commands) {
+    const unique = [...new Map(commands.map(cmd => [fullName(cmd), cmd])).values()]
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const lines = [
+        `Usage: opencli ${site} <command> [args] [options]`,
+        '',
+        wrapCommaList(unique.map(cmd => cmd.name), { indent: '' }),
+        '',
+        'Commands:',
+        ...formatRows(unique.map(cmd => [formatCommandListTerm(cmd), formatSiteCommandDescription(cmd)])),
+        '',
+        formatCommonOptionsHelpText(),
+        '',
+        `Agent tip: use 'opencli ${site} --help -f yaml' to get all command args/options in one structured response.`,
+        '',
+    ];
+    return lines.join('\n');
+}
+export function formatCommandHelpText(cmd) {
+    const lines = [
+        `Usage: ${formatUsage(cmd)}`,
+        '',
+        cmd.description,
+        '',
+    ];
+    const positionalRows = positionals(cmd).map(arg => [
+        arg.name,
+        formatArgHelp(arg),
+    ]);
+    if (positionalRows.length) {
+        lines.push('Arguments:', ...formatRows(positionalRows), '');
+    }
+    const optionRows = commandOptions(cmd).map(arg => [
+        formatCommandOptionTerm(arg),
+        formatArgHelp(arg),
+    ]);
+    if (optionRows.length) {
+        lines.push('Command options:', ...formatRows(optionRows), '');
+    }
+    lines.push(formatCommonOptionsHelpText(), '');
+    const meta = [];
+    meta.push(`Access: ${cmd.access}`);
+    meta.push(`Browser: ${cmd.browser ? 'yes' : 'no'}`);
+    if (cmd.domain)
+        meta.push(`Domain: ${cmd.domain}`);
+    if (cmd.defaultFormat)
+        meta.push(`Default format: ${cmd.defaultFormat}`);
+    if (cmd.aliases?.length)
+        meta.push(`Aliases: ${cmd.aliases.join(', ')}`);
+    lines.push(meta.join(' | '));
+    lines.push(`Example: ${formatCommandExample(cmd)}`);
+    if (cmd.columns?.length)
+        lines.push(`Output columns: ${cmd.columns.join(', ')}`);
+    lines.push("Agent tip: use '--help -f yaml' for structured args/options.");
+    lines.push('');
+    return lines.join('\n');
+}
 export function installStructuredHelp(command, data, textSuffix) {
     const original = command.helpInformation.bind(command);
     command.helpInformation = ((contextOptions) => {

package/dist/src/types.d.ts

@@ -20,6 +20,8 @@ export interface SnapshotOptions {
     raw?: boolean;
     viewportExpand?: number;
     maxTextLength?: number;
+    /** Observation backend. `dom` is the stable default; `ax` is an opt-in prototype. */
+    source?: 'dom' | 'ax';
 }
 export interface WaitOptions {
     text?: string;
@@ -27,10 +29,25 @@ export interface WaitOptions {
     time?: number;
     timeout?: number;
 }
+export interface BrowserDownloadWaitResult {
+    downloaded: boolean;
+    id?: number;
+    filename?: string;
+    url?: string;
+    finalUrl?: string;
+    mime?: string;
+    totalBytes?: number;
+    state?: string;
+    danger?: string;
+    error?: string;
+    elapsedMs: number;
+}
 export interface ScreenshotOptions {
     format?: 'png' | 'jpeg';
     quality?: number;
     fullPage?: boolean;
+    /** Overlay current browser-state refs on visible interactive elements. */
+    annotate?: boolean;
     /** Override viewport width in CSS pixels for the screenshot only (cleared after). */
     width?: number;
     /** Override viewport height in CSS pixels for the screenshot only (ignored when fullPage). */
@@ -84,6 +101,69 @@ export interface IPage {
         matches_n: number;
         match_level: 'exact' | 'stable' | 'reidentified';
     }>;
+    dblClick?(ref: string, opts?: {
+        nth?: number;
+        firstOnMulti?: boolean;
+    }): Promise<{
+        matches_n: number;
+        match_level: 'exact' | 'stable' | 'reidentified';
+    }>;
+    hover?(ref: string, opts?: {
+        nth?: number;
+        firstOnMulti?: boolean;
+    }): Promise<{
+        matches_n: number;
+        match_level: 'exact' | 'stable' | 'reidentified';
+    }>;
+    focus?(ref: string, opts?: {
+        nth?: number;
+        firstOnMulti?: boolean;
+    }): Promise<{
+        focused: boolean;
+        matches_n: number;
+        match_level: 'exact' | 'stable' | 'reidentified';
+    }>;
+    setChecked?(ref: string, checked: boolean, opts?: {
+        nth?: number;
+        firstOnMulti?: boolean;
+    }): Promise<{
+        checked: boolean;
+        changed: boolean;
+        matches_n: number;
+        match_level: 'exact' | 'stable' | 'reidentified';
+        kind?: string;
+    }>;
+    uploadFiles?(ref: string, files: string[], opts?: {
+        nth?: number;
+        firstOnMulti?: boolean;
+    }): Promise<{
+        uploaded: boolean;
+        files: number;
+        file_names: string[];
+        target: string;
+        matches_n: number;
+        match_level: 'exact' | 'stable' | 'reidentified';
+        multiple?: boolean;
+        accept?: string;
+    }>;
+    drag?(source: string, target: string, opts?: {
+        from?: {
+            nth?: number;
+            firstOnMulti?: boolean;
+        };
+        to?: {
+            nth?: number;
+            firstOnMulti?: boolean;
+        };
+    }): Promise<{
+        dragged: boolean;
+        source: string;
+        target: string;
+        source_matches_n: number;
+        target_matches_n: number;
+        source_match_level: 'exact' | 'stable' | 'reidentified';
+        target_match_level: 'exact' | 'stable' | 'reidentified';
+    }>;
     typeText(ref: string, text: string, opts?: {
         nth?: number;
         firstOnMulti?: boolean;
@@ -111,6 +191,7 @@ export interface IPage {
     }): Promise<any>;
     getFormState(): Promise<any>;
     wait(options: number | WaitOptions): Promise<void>;
+    waitForDownload?(pattern?: string, timeoutMs?: number): Promise<BrowserDownloadWaitResult>;
     tabs(): Promise<any>;
     closeTab?(target?: number | string): Promise<void>;
     newTab?(url?: string): Promise<string | undefined>;
@@ -126,6 +207,7 @@ export interface IPage {
     getInterceptedRequests(): Promise<any[]>;
     waitForCapture(timeout?: number): Promise<void>;
     screenshot(options?: ScreenshotOptions): Promise<string>;
+    annotatedScreenshot?(options?: ScreenshotOptions): Promise<string>;
     startNetworkCapture?(pattern?: string): Promise<boolean>;
     readNetworkCapture?(): Promise<unknown[]>;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "1.7.13",
+  "version": "1.7.15",
   "publishConfig": {
     "access": "public"
   },