@jackwener/opencli 0.7.5 → 0.7.8

package/dist/completion.js

@@ -0,0 +1,116 @@
+/**
+ * Shell tab-completion support for opencli.
+ *
+ * Provides:
+ *  - Shell script generators for bash, zsh, and fish
+ *  - Dynamic completion logic that returns candidates for the current cursor position
+ */
+import { getRegistry } from './registry.js';
+import { CliError } from './errors.js';
+// ── Dynamic completion logic ───────────────────────────────────────────────
+/**
+ * Built-in (non-dynamic) top-level commands.
+ */
+const BUILTIN_COMMANDS = [
+    'list',
+    'validate',
+    'verify',
+    'explore',
+    'probe', // alias for explore
+    'synthesize',
+    'generate',
+    'cascade',
+    'doctor',
+    'setup',
+    'completion',
+];
+/**
+ * Return completion candidates given the current command-line words and cursor index.
+ *
+ * @param words  - The argv after 'opencli' (words[0] is the first arg, e.g. site name)
+ * @param cursor - 1-based position of the word being completed (1 = first arg)
+ */
+export function getCompletions(words, cursor) {
+    // cursor === 1 → completing the first argument (site name or built-in command)
+    if (cursor <= 1) {
+        const sites = new Set();
+        for (const [, cmd] of getRegistry()) {
+            sites.add(cmd.site);
+        }
+        return [...BUILTIN_COMMANDS, ...sites].sort();
+    }
+    const site = words[0];
+    // If the first word is a built-in command, no further completion
+    if (BUILTIN_COMMANDS.includes(site)) {
+        return [];
+    }
+    // cursor === 2 → completing the sub-command name under a site
+    if (cursor === 2) {
+        const subcommands = [];
+        for (const [, cmd] of getRegistry()) {
+            if (cmd.site === site) {
+                subcommands.push(cmd.name);
+            }
+        }
+        return subcommands.sort();
+    }
+    // cursor >= 3 → no further completion
+    return [];
+}
+// ── Shell script generators ────────────────────────────────────────────────
+export function bashCompletionScript() {
+    return `# Bash completion for opencli
+# Add to ~/.bashrc:  eval "$(opencli completion bash)"
+_opencli_completions() {
+  local cur words cword
+  _get_comp_words_by_ref -n : cur words cword
+
+  local completions
+  completions=$(opencli --get-completions --cursor "$cword" "\${words[@]:1}" 2>/dev/null)
+
+  COMPREPLY=( $(compgen -W "$completions" -- "$cur") )
+  __ltrim_colon_completions "$cur"
+}
+complete -F _opencli_completions opencli
+`;
+}
+export function zshCompletionScript() {
+    return `# Zsh completion for opencli
+# Add to ~/.zshrc:  eval "$(opencli completion zsh)"
+_opencli() {
+  local -a completions
+  local cword=$((CURRENT - 1))
+  completions=(\${(f)"$(opencli --get-completions --cursor "$cword" "\${words[@]:1}" 2>/dev/null)"})
+  compadd -a completions
+}
+compdef _opencli opencli
+`;
+}
+export function fishCompletionScript() {
+    return `# Fish completion for opencli
+# Add to ~/.config/fish/config.fish:  opencli completion fish | source
+complete -c opencli -f -a '(
+  set -l tokens (commandline -cop)
+  set -l cursor (count (commandline -cop))
+  opencli --get-completions --cursor $cursor $tokens[2..] 2>/dev/null
+)'
+`;
+}
+/**
+ * Print the completion script for the requested shell.
+ */
+export function printCompletionScript(shell) {
+    switch (shell) {
+        case 'bash':
+            process.stdout.write(bashCompletionScript());
+            break;
+        case 'zsh':
+            process.stdout.write(zshCompletionScript());
+            break;
+        case 'fish':
+            process.stdout.write(fishCompletionScript());
+            break;
+        default:
+            throw new CliError('UNSUPPORTED_SHELL', `Unsupported shell: ${shell}. Supported: bash, zsh, fish`);
+    }
+}

package/dist/doctor.js

@@ -4,7 +4,7 @@ import * as path from 'node:path';
 import { createInterface } from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
 import chalk from 'chalk';
-import { PlaywrightMCP, getTokenFingerprint } from './browser.js';
+import { PlaywrightMCP, getTokenFingerprint } from './browser/index.js';
 const PLAYWRIGHT_SERVER_NAME = 'playwright';
 export const PLAYWRIGHT_TOKEN_ENV = 'PLAYWRIGHT_MCP_EXTENSION_TOKEN';
 const PLAYWRIGHT_EXTENSION_ID = 'mmlmfjhmonkocbjadbfplnigmagldckm';
@@ -266,14 +266,14 @@ export function discoverExtensionToken() {
     const platform = os.platform();
     const bases = [];
     if (platform === 'darwin') {
-        bases.push(path.join(home, 'Library', 'Application Support', 'Google', 'Chrome'), path.join(home, 'Library', 'Application Support', 'Google', 'Chrome Canary'), path.join(home, 'Library', 'Application Support', 'Chromium'), path.join(home, 'Library', 'Application Support', 'Microsoft Edge'));
+        bases.push(path.join(home, 'Library', 'Application Support', 'Google', 'Chrome'), path.join(home, 'Library', 'Application Support', 'Google', 'Chrome Dev'), path.join(home, 'Library', 'Application Support', 'Google', 'Chrome Beta'), path.join(home, 'Library', 'Application Support', 'Google', 'Chrome Canary'), path.join(home, 'Library', 'Application Support', 'Chromium'), path.join(home, 'Library', 'Application Support', 'Microsoft Edge'));
     }
     else if (platform === 'linux') {
-        bases.push(path.join(home, '.config', 'google-chrome'), path.join(home, '.config', 'chromium'), path.join(home, '.config', 'microsoft-edge'));
+        bases.push(path.join(home, '.config', 'google-chrome'), path.join(home, '.config', 'google-chrome-unstable'), path.join(home, '.config', 'google-chrome-beta'), path.join(home, '.config', 'chromium'), path.join(home, '.config', 'microsoft-edge'));
     }
     else if (platform === 'win32') {
         const appData = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
-        bases.push(path.join(appData, 'Google', 'Chrome', 'User Data'), path.join(appData, 'Microsoft', 'Edge', 'User Data'));
+        bases.push(path.join(appData, 'Google', 'Chrome', 'User Data'), path.join(appData, 'Google', 'Chrome Dev', 'User Data'), path.join(appData, 'Google', 'Chrome Beta', 'User Data'), path.join(appData, 'Microsoft', 'Edge', 'User Data'));
     }
     const profiles = enumerateProfiles(bases);
     const tokenRe = /([A-Za-z0-9_-]{40,50})/;
@@ -388,14 +388,14 @@ export function checkExtensionInstalled() {
     const platform = os.platform();
     const browserDirs = [];
     if (platform === 'darwin') {
-        browserDirs.push({ name: 'Chrome', base: path.join(home, 'Library', 'Application Support', 'Google', 'Chrome') }, { name: 'Chrome Canary', base: path.join(home, 'Library', 'Application Support', 'Google', 'Chrome Canary') }, { name: 'Chromium', base: path.join(home, 'Library', 'Application Support', 'Chromium') }, { name: 'Edge', base: path.join(home, 'Library', 'Application Support', 'Microsoft Edge') });
+        browserDirs.push({ name: 'Chrome', base: path.join(home, 'Library', 'Application Support', 'Google', 'Chrome') }, { name: 'Chrome Dev', base: path.join(home, 'Library', 'Application Support', 'Google', 'Chrome Dev') }, { name: 'Chrome Beta', base: path.join(home, 'Library', 'Application Support', 'Google', 'Chrome Beta') }, { name: 'Chrome Canary', base: path.join(home, 'Library', 'Application Support', 'Google', 'Chrome Canary') }, { name: 'Chromium', base: path.join(home, 'Library', 'Application Support', 'Chromium') }, { name: 'Edge', base: path.join(home, 'Library', 'Application Support', 'Microsoft Edge') });
     }
     else if (platform === 'linux') {
-        browserDirs.push({ name: 'Chrome', base: path.join(home, '.config', 'google-chrome') }, { name: 'Chromium', base: path.join(home, '.config', 'chromium') }, { name: 'Edge', base: path.join(home, '.config', 'microsoft-edge') });
+        browserDirs.push({ name: 'Chrome', base: path.join(home, '.config', 'google-chrome') }, { name: 'Chrome Dev', base: path.join(home, '.config', 'google-chrome-unstable') }, { name: 'Chrome Beta', base: path.join(home, '.config', 'google-chrome-beta') }, { name: 'Chromium', base: path.join(home, '.config', 'chromium') }, { name: 'Edge', base: path.join(home, '.config', 'microsoft-edge') });
     }
     else if (platform === 'win32') {
         const appData = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
-        browserDirs.push({ name: 'Chrome', base: path.join(appData, 'Google', 'Chrome', 'User Data') }, { name: 'Edge', base: path.join(appData, 'Microsoft', 'Edge', 'User Data') });
+        browserDirs.push({ name: 'Chrome', base: path.join(appData, 'Google', 'Chrome', 'User Data') }, { name: 'Chrome Dev', base: path.join(appData, 'Google', 'Chrome Dev', 'User Data') }, { name: 'Chrome Beta', base: path.join(appData, 'Google', 'Chrome Beta', 'User Data') }, { name: 'Edge', base: path.join(appData, 'Microsoft', 'Edge', 'User Data') });
     }
     const profiles = enumerateProfiles(browserDirs.map(d => d.base));
     const foundBrowsers = [];

package/dist/engine.js

@@ -12,6 +12,8 @@ import * as path from 'node:path';
 import yaml from 'js-yaml';
 import { Strategy, registerCommand } from './registry.js';
 import { executePipeline } from './pipeline.js';
+import { log } from './logger.js';
+import { AdapterLoadError } from './errors.js';
 /** Set of TS module paths that have been loaded */
 const _loadedModules = new Set();
 /**
@@ -81,7 +83,7 @@ function loadFromManifest(manifestPath, clisDir) {
         }
     }
     catch (err) {
-        process.stderr.write(`Warning: failed to load manifest ${manifestPath}: ${err.message}\n`);
+        log.warn(`Failed to load manifest ${manifestPath}: ${err.message}`);
     }
 }
 /**
@@ -103,7 +105,7 @@ async function discoverClisFromFs(dir) {
             else if ((file.endsWith('.js') && !file.endsWith('.d.js')) ||
                 (file.endsWith('.ts') && !file.endsWith('.d.ts') && !file.endsWith('.test.ts'))) {
                 promises.push(import(`file://${filePath}`).catch((err) => {
-                    process.stderr.write(`Warning: failed to load module ${filePath}: ${err.message}\n`);
+                    log.warn(`Failed to load module ${filePath}: ${err.message}`);
                 }));
             }
         }
@@ -150,7 +152,7 @@ function registerYamlCli(filePath, defaultSite) {
         registerCommand(cmd);
     }
     catch (err) {
-        process.stderr.write(`Warning: failed to load ${filePath}: ${err.message}\n`);
+        log.warn(`Failed to load ${filePath}: ${err.message}`);
     }
 }
 /**
@@ -167,7 +169,7 @@ export async function executeCommand(cmd, page, kwargs, debug = false) {
                 _loadedModules.add(modulePath);
             }
             catch (err) {
-                throw new Error(`Failed to load adapter module ${modulePath}: ${err.message}`);
+                throw new AdapterLoadError(`Failed to load adapter module ${modulePath}: ${err.message}`, 'Check that the adapter file exists and has no syntax errors.');
             }
         }
         // After loading, the module's cli() call will have updated the registry

package/dist/errors.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Unified error types for opencli.
+ *
+ * All errors thrown by the framework should extend CliError so that
+ * the top-level handler in main.ts can render consistent, helpful output.
+ */
+export declare class CliError extends Error {
+    /** Machine-readable error code (e.g. 'BROWSER_CONNECT', 'ADAPTER_LOAD') */
+    readonly code: string;
+    /** Human-readable hint on how to fix the problem */
+    readonly hint?: string;
+    constructor(code: string, message: string, hint?: string);
+}
+export declare class BrowserConnectError extends CliError {
+    constructor(message: string, hint?: string);
+}
+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);
+}

package/dist/errors.js

@@ -0,0 +1,42 @@
+/**
+ * Unified error types for opencli.
+ *
+ * All errors thrown by the framework should extend CliError so that
+ * the top-level handler in main.ts can render consistent, helpful output.
+ */
+export class CliError extends Error {
+    /** Machine-readable error code (e.g. 'BROWSER_CONNECT', 'ADAPTER_LOAD') */
+    code;
+    /** Human-readable hint on how to fix the problem */
+    hint;
+    constructor(code, message, hint) {
+        super(message);
+        this.name = 'CliError';
+        this.code = code;
+        this.hint = hint;
+    }
+}
+export class BrowserConnectError extends CliError {
+    constructor(message, hint) {
+        super('BROWSER_CONNECT', message, hint);
+        this.name = 'BrowserConnectError';
+    }
+}
+export class AdapterLoadError extends CliError {
+    constructor(message, hint) {
+        super('ADAPTER_LOAD', message, hint);
+        this.name = 'AdapterLoadError';
+    }
+}
+export class CommandExecutionError extends CliError {
+    constructor(message, hint) {
+        super('COMMAND_EXEC', message, hint);
+        this.name = 'CommandExecutionError';
+    }
+}
+export class ConfigError extends CliError {
+    constructor(message, hint) {
+        super('CONFIG', message, hint);
+        this.name = 'ConfigError';
+    }
+}

package/dist/logger.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Unified logging for opencli.
+ *
+ * All framework output (warnings, debug info, errors) should go through
+ * this module so that verbosity levels are respected consistently.
+ */
+export declare const log: {
+    /** Informational message (always shown) */
+    info(msg: string): void;
+    /** Warning (always shown) */
+    warn(msg: string): void;
+    /** Error (always shown) */
+    error(msg: string): void;
+    /** Verbose output (only when OPENCLI_VERBOSE is set or -v flag) */
+    verbose(msg: string): void;
+    /** Debug output (only when DEBUG includes 'opencli') */
+    debug(msg: string): void;
+    /** Step-style debug (for pipeline steps, etc.) */
+    step(stepNum: number, total: number, op: string, preview?: string): void;
+    /** Step result summary */
+    stepResult(summary: string): void;
+};

package/dist/logger.js

@@ -0,0 +1,47 @@
+/**
+ * Unified logging for opencli.
+ *
+ * All framework output (warnings, debug info, errors) should go through
+ * this module so that verbosity levels are respected consistently.
+ */
+import chalk from 'chalk';
+function isVerbose() {
+    return !!process.env.OPENCLI_VERBOSE;
+}
+function isDebug() {
+    return !!process.env.DEBUG?.includes('opencli');
+}
+export const log = {
+    /** Informational message (always shown) */
+    info(msg) {
+        process.stderr.write(`${chalk.blue('ℹ')}  ${msg}\n`);
+    },
+    /** Warning (always shown) */
+    warn(msg) {
+        process.stderr.write(`${chalk.yellow('⚠')}  ${msg}\n`);
+    },
+    /** Error (always shown) */
+    error(msg) {
+        process.stderr.write(`${chalk.red('✖')}  ${msg}\n`);
+    },
+    /** Verbose output (only when OPENCLI_VERBOSE is set or -v flag) */
+    verbose(msg) {
+        if (isVerbose()) {
+            process.stderr.write(`${chalk.dim('[verbose]')} ${msg}\n`);
+        }
+    },
+    /** Debug output (only when DEBUG includes 'opencli') */
+    debug(msg) {
+        if (isDebug()) {
+            process.stderr.write(`${chalk.dim('[debug]')} ${msg}\n`);
+        }
+    },
+    /** Step-style debug (for pipeline steps, etc.) */
+    step(stepNum, total, op, preview = '') {
+        process.stderr.write(`  ${chalk.dim(`[${stepNum}/${total}]`)} ${chalk.bold.cyan(op)}${preview}\n`);
+    },
+    /** Step result summary */
+    stepResult(summary) {
+        process.stderr.write(`       ${chalk.dim(`→ ${summary}`)}\n`);
+    },
+};

package/dist/main.js

@@ -10,14 +10,38 @@ import chalk from 'chalk';
 import { discoverClis, executeCommand } from './engine.js';
 import { fullName, getRegistry, strategyLabel } from './registry.js';
 import { render as renderOutput } from './output.js';
-import { PlaywrightMCP } from './browser.js';
+import { PlaywrightMCP } from './browser/index.js';
 import { browserSession, DEFAULT_BROWSER_COMMAND_TIMEOUT, runWithTimeout } from './runtime.js';
 import { PKG_VERSION } from './version.js';
+import { getCompletions, printCompletionScript } from './completion.js';
+import { CliError } from './errors.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const BUILTIN_CLIS = path.resolve(__dirname, 'clis');
 const USER_CLIS = path.join(os.homedir(), '.opencli', 'clis');
 await discoverClis(BUILTIN_CLIS, USER_CLIS);
+// ── Fast-path: handle --get-completions before commander parses ─────────
+// Usage: opencli --get-completions --cursor <N> [word1 word2 ...]
+const getCompIdx = process.argv.indexOf('--get-completions');
+if (getCompIdx !== -1) {
+    const rest = process.argv.slice(getCompIdx + 1);
+    let cursor;
+    const words = [];
+    for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === '--cursor' && i + 1 < rest.length) {
+            cursor = parseInt(rest[i + 1], 10);
+            i++; // skip the value
+        }
+        else {
+            words.push(rest[i]);
+        }
+    }
+    if (cursor === undefined)
+        cursor = words.length;
+    const candidates = getCompletions(words, cursor);
+    process.stdout.write(candidates.join('\n') + '\n');
+    process.exit(0);
+}
 const program = new Command();
 program.name('opencli').description('Make any website your CLI. Zero setup. AI-powered.').version(PKG_VERSION);
 // ── Built-in commands ──────────────────────────────────────────────────────
@@ -130,6 +154,12 @@ program.command('setup')
     const { runSetup } = await import('./setup.js');
     await runSetup({ cliVersion: PKG_VERSION, token: opts.token });
 });
+program.command('completion')
+    .description('Output shell completion script')
+    .argument('<shell>', 'Shell type: bash, zsh, or fish')
+    .action((shell) => {
+    printCompletionScript(shell);
+});
 // ── Dynamic site commands ──────────────────────────────────────────────────
 const registry = getRegistry();
 const siteGroups = new Map();
@@ -199,7 +229,12 @@ for (const [, cmd] of registry) {
             renderOutput(result, { fmt: actionOpts.format, columns: cmd.columns, title: `${cmd.site}/${cmd.name}`, elapsed: (Date.now() - startTime) / 1000, source: fullName(cmd) });
         }
         catch (err) {
-            if (actionOpts.verbose && err.stack) {
+            if (err instanceof CliError) {
+                console.error(chalk.red(`Error [${err.code}]: ${err.message}`));
+                if (err.hint)
+                    console.error(chalk.yellow(`Hint: ${err.hint}`));
+            }
+            else if (actionOpts.verbose && err.stack) {
                 console.error(chalk.red(err.stack));
             }
             else {

package/dist/pipeline/executor.js

@@ -1,12 +1,12 @@
 /**
  * Pipeline executor: runs YAML pipeline steps sequentially.
  */
-import chalk from 'chalk';
 import { stepNavigate, stepClick, stepType, stepWait, stepPress, stepSnapshot, stepEvaluate } from './steps/browser.js';
 import { stepFetch } from './steps/fetch.js';
 import { stepSelect, stepMap, stepFilter, stepSort, stepLimit } from './steps/transform.js';
 import { stepIntercept } from './steps/intercept.js';
 import { stepTap } from './steps/tap.js';
+import { log } from '../logger.js';
 /** Registry of all available step handlers */
 const STEP_HANDLERS = {
     navigate: stepNavigate,
@@ -43,7 +43,7 @@ export async function executePipeline(page, pipeline, ctx = {}) {
             }
             else {
                 if (debug)
-                    process.stderr.write(`  ${chalk.yellow('⚠')}  Unknown step: ${op}\n`);
+                    log.warn(`Unknown step: ${op}`);
             }
             if (debug)
                 debugStepResult(op, data);
@@ -59,24 +59,24 @@ function debugStepStart(stepNum, total, op, params) {
     else if (params && typeof params === 'object' && !Array.isArray(params)) {
         preview = ` (${Object.keys(params).join(', ')})`;
     }
-    process.stderr.write(`  ${chalk.dim(`[${stepNum}/${total}]`)} ${chalk.bold.cyan(op)}${preview}\n`);
+    log.step(stepNum, total, op, preview);
 }
 function debugStepResult(op, data) {
     if (data === null || data === undefined) {
-        process.stderr.write(`       ${chalk.dim('→ (no data)')}\n`);
+        log.stepResult('(no data)');
     }
     else if (Array.isArray(data)) {
-        process.stderr.write(`       ${chalk.dim(`→ ${data.length} items`)}\n`);
+        log.stepResult(`${data.length} items`);
     }
     else if (typeof data === 'object') {
         const keys = Object.keys(data).slice(0, 5);
-        process.stderr.write(`       ${chalk.dim(`→ dict (${keys.join(', ')}${Object.keys(data).length > 5 ? '...' : ''})`)}\n`);
+        log.stepResult(`dict (${keys.join(', ')}${Object.keys(data).length > 5 ? '...' : ''})`);
     }
     else if (typeof data === 'string') {
         const p = data.slice(0, 60).replace(/\n/g, '\\n');
-        process.stderr.write(`       ${chalk.dim(`→ "${p}${data.length > 60 ? '...' : ''}"`)}\n`);
+        log.stepResult(`"${p}${data.length > 60 ? '...' : ''}"`);
     }
     else {
-        process.stderr.write(`       ${chalk.dim(`→ ${typeof data}`)}\n`);
+        log.stepResult(`${typeof data}`);
     }
 }

package/dist/pipeline/steps/browser.d.ts

@@ -3,10 +3,10 @@
  * Browser interaction primitives.
  */
 import type { IPage } from '../../types.js';
-export declare function stepNavigate(page: IPage, params: any, data: any, args: Record<string, any>): Promise<any>;
-export declare function stepClick(page: IPage, params: any, data: any, args: Record<string, any>): Promise<any>;
-export declare function stepType(page: IPage, params: any, data: any, args: Record<string, any>): Promise<any>;
-export declare function stepWait(page: IPage, params: any, data: any, args: Record<string, any>): Promise<any>;
-export declare function stepPress(page: IPage, params: any, data: any, args: Record<string, any>): Promise<any>;
-export declare function stepSnapshot(page: IPage, params: any, _data: any, _args: Record<string, any>): Promise<any>;
-export declare function stepEvaluate(page: IPage, params: any, data: any, args: Record<string, any>): Promise<any>;
+export declare function stepNavigate(page: IPage | null, params: any, data: any, args: Record<string, any>): Promise<any>;
+export declare function stepClick(page: IPage | null, params: any, data: any, args: Record<string, any>): Promise<any>;
+export declare function stepType(page: IPage | null, params: any, data: any, args: Record<string, any>): Promise<any>;
+export declare function stepWait(page: IPage | null, params: any, data: any, args: Record<string, any>): Promise<any>;
+export declare function stepPress(page: IPage | null, params: any, data: any, args: Record<string, any>): Promise<any>;
+export declare function stepSnapshot(page: IPage | null, params: any, _data: any, _args: Record<string, any>): Promise<any>;
+export declare function stepEvaluate(page: IPage | null, params: any, data: any, args: Record<string, any>): Promise<any>;

package/dist/pipeline/steps/intercept.d.ts

@@ -2,4 +2,4 @@
  * Pipeline step: intercept — declarative XHR interception.
  */
 import type { IPage } from '../../types.js';
-export declare function stepIntercept(page: IPage, params: any, data: any, args: Record<string, any>): Promise<any>;
+export declare function stepIntercept(page: IPage | null, params: any, data: any, args: Record<string, any>): Promise<any>;

package/dist/pipeline/steps/tap.d.ts

@@ -9,4 +9,4 @@
  * 5. Returns the captured data (optionally sub-selected)
  */
 import type { IPage } from '../../types.js';
-export declare function stepTap(page: IPage, params: any, data: any, args: Record<string, any>): Promise<any>;
+export declare function stepTap(page: IPage | null, params: any, data: any, args: Record<string, any>): Promise<any>;

package/dist/setup.js

@@ -9,7 +9,7 @@ import chalk from 'chalk';
 import { createInterface } from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
 import { PLAYWRIGHT_TOKEN_ENV, checkExtensionInstalled, checkTokenConnectivity, discoverExtensionToken, fileExists, getDefaultShellRcPath, runBrowserDoctor, shortenPath, toolName, upsertJsonConfigToken, upsertShellToken, upsertTomlConfigToken, writeFileWithMkdir, } from './doctor.js';
-import { getTokenFingerprint } from './browser.js';
+import { getTokenFingerprint } from './browser/index.js';
 import { checkboxPrompt } from './tui.js';
 export async function runSetup(opts = {}) {
     console.log();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "0.7.5",
+  "version": "0.7.8",
   "publishConfig": {
     "access": "public"
   },
@@ -17,9 +17,10 @@
     "dev": "tsx src/main.ts",
     "build": "tsc && npm run clean-yaml && npm run copy-yaml && npm run build-manifest",
     "build-manifest": "node dist/build-manifest.js",
-    "clean-yaml": "node -e \"const{readdirSync:r,rmSync:d,existsSync:e,statSync:s}=require('fs'),p=require('path');function w(dir){if(!e(dir))return;for(const f of r(dir)){const fp=p.join(dir,f);s(fp).isDirectory()?w(fp):/\\.ya?ml$/.test(f)&&d(fp)}}w('dist/clis')\"",
-    "copy-yaml": "node -e \"const{readdirSync:r,copyFileSync:c,mkdirSync:m,existsSync:e,statSync:s}=require('fs'),p=require('path');function w(src,dst){if(!e(src))return;for(const f of r(src)){const sp=p.join(src,f),dp=p.join(dst,f);s(sp).isDirectory()?w(sp,dp):/\\.ya?ml$/.test(f)&&(m(p.dirname(dp),{recursive:!0}),c(sp,dp))}}w('src/clis','dist/clis')\"",
+    "clean-yaml": "node scripts/clean-yaml.cjs",
+    "copy-yaml": "node scripts/copy-yaml.cjs",
     "start": "node dist/main.js",
+    "postinstall": "node scripts/postinstall.js || true",
     "typecheck": "tsc --noEmit",
     "lint": "tsc --noEmit",
     "prepublishOnly": "npm run build",

package/scripts/clean-yaml.cjs

@@ -0,0 +1,19 @@
+/**
+ * Clean YAML files from dist/clis/ before copying fresh ones.
+ */
+const { readdirSync, rmSync, existsSync, statSync } = require('fs');
+const path = require('path');
+
+function walk(dir) {
+  if (!existsSync(dir)) return;
+  for (const f of readdirSync(dir)) {
+    const fp = path.join(dir, f);
+    if (statSync(fp).isDirectory()) {
+      walk(fp);
+    } else if (/\.ya?ml$/.test(f)) {
+      rmSync(fp);
+    }
+  }
+}
+
+walk('dist/clis');

package/scripts/copy-yaml.cjs

@@ -0,0 +1,21 @@
+/**
+ * Copy YAML files from src/clis/ to dist/clis/.
+ */
+const { readdirSync, copyFileSync, mkdirSync, existsSync, statSync } = require('fs');
+const path = require('path');
+
+function walk(src, dst) {
+  if (!existsSync(src)) return;
+  for (const f of readdirSync(src)) {
+    const sp = path.join(src, f);
+    const dp = path.join(dst, f);
+    if (statSync(sp).isDirectory()) {
+      walk(sp, dp);
+    } else if (/\.ya?ml$/.test(f)) {
+      mkdirSync(path.dirname(dp), { recursive: true });
+      copyFileSync(sp, dp);
+    }
+  }
+}
+
+walk('src/clis', 'dist/clis');