@jackwener/opencli 1.4.1 → 1.5.1

package/dist/download/index.js

@@ -7,6 +7,8 @@ import * as path from 'node:path';
 import * as https from 'node:https';
 import * as http from 'node:http';
 import * as os from 'node:os';
+import { Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
 import { URL } from 'node:url';
 import { isBinaryInstalled } from '../external.js';
 import { getErrorMessage } from '../errors.js';
@@ -68,65 +70,75 @@ export async function httpDownload(url, destPath, options = {}, redirectCount =
         if (cookies) {
             requestHeaders['Cookie'] = cookies;
         }
-        // Ensure directory exists
-        const dir = path.dirname(destPath);
-        fs.mkdirSync(dir, { recursive: true });
         const tempPath = `${destPath}.tmp`;
-        const file = fs.createWriteStream(tempPath);
-        const request = protocol.get(url, { headers: requestHeaders, timeout }, (response) => {
-            // Handle redirects
-            if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
-                file.close();
-                if (fs.existsSync(tempPath))
-                    fs.unlinkSync(tempPath);
-                if (redirectCount >= maxRedirects) {
-                    resolve({ success: false, size: 0, error: `Too many redirects (> ${maxRedirects})` });
-                    return;
-                }
-                const redirectUrl = resolveRedirectUrl(url, response.headers.location);
-                const originalHost = new URL(url).hostname;
-                const redirectHost = new URL(redirectUrl).hostname;
-                // Do not forward cookies when a redirect crosses host boundaries.
-                const redirectOptions = originalHost === redirectHost
-                    ? options
-                    : { ...options, cookies: undefined, headers: stripCookieHeaders(options.headers) };
-                httpDownload(redirectUrl, destPath, redirectOptions, redirectCount + 1).then(resolve);
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
                 return;
+            settled = true;
+            resolve(result);
+        };
+        const cleanupTempFile = async () => {
+            try {
+                await fs.promises.rm(tempPath, { force: true });
             }
-            if (response.statusCode !== 200) {
-                file.close();
-                if (fs.existsSync(tempPath))
-                    fs.unlinkSync(tempPath);
-                resolve({ success: false, size: 0, error: `HTTP ${response.statusCode}` });
-                return;
+            catch {
+                // Ignore cleanup errors so the original failure is preserved.
             }
-            const totalSize = parseInt(response.headers['content-length'] || '0', 10);
-            let received = 0;
-            response.on('data', (chunk) => {
-                received += chunk.length;
-                if (onProgress)
-                    onProgress(received, totalSize);
-            });
-            response.pipe(file);
-            file.on('finish', () => {
-                file.close();
-                // Rename temp file to final destination
-                fs.renameSync(tempPath, destPath);
-                resolve({ success: true, size: received });
-            });
+        };
+        const request = protocol.get(url, { headers: requestHeaders, timeout }, (response) => {
+            void (async () => {
+                // Handle redirects before creating any file handles.
+                if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+                    response.resume();
+                    if (redirectCount >= maxRedirects) {
+                        finish({ success: false, size: 0, error: `Too many redirects (> ${maxRedirects})` });
+                        return;
+                    }
+                    const redirectUrl = resolveRedirectUrl(url, response.headers.location);
+                    const originalHost = new URL(url).hostname;
+                    const redirectHost = new URL(redirectUrl).hostname;
+                    const redirectOptions = originalHost === redirectHost
+                        ? options
+                        : { ...options, cookies: undefined, headers: stripCookieHeaders(options.headers) };
+                    finish(await httpDownload(redirectUrl, destPath, redirectOptions, redirectCount + 1));
+                    return;
+                }
+                if (response.statusCode !== 200) {
+                    response.resume();
+                    finish({ success: false, size: 0, error: `HTTP ${response.statusCode}` });
+                    return;
+                }
+                const totalSize = parseInt(response.headers['content-length'] || '0', 10);
+                let received = 0;
+                const progressStream = new Transform({
+                    transform(chunk, _encoding, callback) {
+                        received += chunk.length;
+                        if (onProgress)
+                            onProgress(received, totalSize);
+                        callback(null, chunk);
+                    },
+                });
+                try {
+                    await fs.promises.mkdir(path.dirname(destPath), { recursive: true });
+                    await pipeline(response, progressStream, fs.createWriteStream(tempPath));
+                    await fs.promises.rename(tempPath, destPath);
+                    finish({ success: true, size: received });
+                }
+                catch (err) {
+                    await cleanupTempFile();
+                    finish({ success: false, size: 0, error: getErrorMessage(err) });
+                }
+            })();
         });
         request.on('error', (err) => {
-            file.close();
-            if (fs.existsSync(tempPath))
-                fs.unlinkSync(tempPath);
-            resolve({ success: false, size: 0, error: err.message });
+            void (async () => {
+                await cleanupTempFile();
+                finish({ success: false, size: 0, error: err.message });
+            })();
         });
         request.on('timeout', () => {
-            request.destroy();
-            file.close();
-            if (fs.existsSync(tempPath))
-                fs.unlinkSync(tempPath);
-            resolve({ success: false, size: 0, error: 'Timeout' });
+            request.destroy(new Error('Timeout'));
         });
     });
 }

package/dist/download/index.test.js

@@ -5,11 +5,19 @@ import * as path from 'node:path';
 import { afterEach, describe, expect, it } from 'vitest';
 import { formatCookieHeader, httpDownload, resolveRedirectUrl } from './index.js';
 const servers = [];
+const tempDirs = [];
 afterEach(async () => {
     await Promise.all(servers.map((server) => new Promise((resolve, reject) => {
         server.close((err) => (err ? reject(err) : resolve()));
     })));
     servers.length = 0;
+    for (const dir of tempDirs) {
+        try {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
+    }
+    tempDirs.length = 0;
 });
 async function startServer(handler, hostname = '127.0.0.1') {
     const server = http.createServer(handler);
@@ -21,7 +29,9 @@ async function startServer(handler, hostname = '127.0.0.1') {
     }
     return `http://${hostname}:${address.port}`;
 }
-describe('download helpers', () => {
+// Windows Defender can briefly lock newly-written .tmp files, causing EPERM.
+// Retry once to handle this flakiness.
+describe('download helpers', { retry: process.platform === 'win32' ? 2 : 0 }, () => {
     it('resolves relative redirects against the original URL', () => {
         expect(resolveRedirectUrl('https://example.com/a/file', '/cdn/file.bin')).toBe('https://example.com/cdn/file.bin');
         expect(resolveRedirectUrl('https://example.com/a/file', '../next')).toBe('https://example.com/next');
@@ -38,7 +48,8 @@ describe('download helpers', () => {
             res.setHeader('Location', '/loop');
             res.end();
         });
-        const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-download-'));
+        const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-dl-'));
+        tempDirs.push(tempDir);
         const destPath = path.join(tempDir, 'file.txt');
         const result = await httpDownload(`${baseUrl}/loop`, destPath, { maxRedirects: 2 });
         expect(result).toEqual({
@@ -60,7 +71,8 @@ describe('download helpers', () => {
             res.setHeader('Location', targetUrl);
             res.end();
         });
-        const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-download-'));
+        const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-dl-'));
+        tempDirs.push(tempDir);
         const destPath = path.join(tempDir, 'redirect.txt');
         const result = await httpDownload(`${redirectUrl}/start`, destPath, { cookies: 'sid=abc' });
         expect(result).toEqual({ success: true, size: 2 });
@@ -79,7 +91,8 @@ describe('download helpers', () => {
             res.setHeader('Location', targetUrl);
             res.end();
         });
-        const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-download-'));
+        const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-dl-'));
+        tempDirs.push(tempDir);
         const destPath = path.join(tempDir, 'redirect-header.txt');
         const result = await httpDownload(`${redirectUrl}/start`, destPath, {
             headers: { Cookie: 'sid=header-cookie' },

package/dist/engine.test.js

@@ -75,11 +75,26 @@ cli({
 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
@@ -108,6 +123,33 @@ columns: [message]
         // 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(() => {

package/dist/errors.d.ts

@@ -12,8 +12,10 @@ export declare class CliError extends Error {
     readonly hint?: string;
     constructor(code: string, message: string, hint?: string);
 }
+export type BrowserConnectKind = 'daemon-not-running' | 'extension-not-connected' | 'command-failed' | 'unknown';
 export declare class BrowserConnectError extends CliError {
-    constructor(message: string, hint?: string);
+    readonly kind: BrowserConnectKind;
+    constructor(message: string, hint?: string, kind?: BrowserConnectKind);
 }
 export declare class AdapterLoadError extends CliError {
     constructor(message: string, hint?: string);
@@ -29,7 +31,7 @@ export declare class AuthRequiredError extends CliError {
     constructor(domain: string, message?: string);
 }
 export declare class TimeoutError extends CliError {
-    constructor(label: string, seconds: number);
+    constructor(label: string, seconds: number, hint?: string);
 }
 export declare class ArgumentError extends CliError {
     constructor(message: string, hint?: string);

package/dist/errors.js

@@ -12,74 +12,50 @@ export class CliError extends Error {
     hint;
     constructor(code, message, hint) {
         super(message);
-        this.name = 'CliError';
+        this.name = new.target.name;
         this.code = code;
         this.hint = hint;
     }
 }
-// ── Browser / Connection ────────────────────────────────────────────────────
 export class BrowserConnectError extends CliError {
-    constructor(message, hint) {
+    kind;
+    constructor(message, hint, kind = 'unknown') {
         super('BROWSER_CONNECT', message, hint);
-        this.name = 'BrowserConnectError';
+        this.kind = kind;
     }
 }
-// ── Adapter loading ─────────────────────────────────────────────────────────
 export class AdapterLoadError extends CliError {
-    constructor(message, hint) {
-        super('ADAPTER_LOAD', message, hint);
-        this.name = 'AdapterLoadError';
-    }
+    constructor(message, hint) { super('ADAPTER_LOAD', message, hint); }
 }
-// ── Command execution ───────────────────────────────────────────────────────
 export class CommandExecutionError extends CliError {
-    constructor(message, hint) {
-        super('COMMAND_EXEC', message, hint);
-        this.name = 'CommandExecutionError';
-    }
+    constructor(message, hint) { super('COMMAND_EXEC', message, hint); }
 }
-// ── Configuration ───────────────────────────────────────────────────────────
 export class ConfigError extends CliError {
-    constructor(message, hint) {
-        super('CONFIG', message, hint);
-        this.name = 'ConfigError';
-    }
+    constructor(message, hint) { super('CONFIG', message, hint); }
 }
-// ── Authentication / Login ──────────────────────────────────────────────────
 export class AuthRequiredError extends CliError {
     domain;
     constructor(domain, message) {
         super('AUTH_REQUIRED', message ?? `Not logged in to ${domain}`, `Please open Chrome and log in to https://${domain}`);
-        this.name = 'AuthRequiredError';
         this.domain = domain;
     }
 }
-// ── Timeout ─────────────────────────────────────────────────────────────────
 export class TimeoutError extends CliError {
-    constructor(label, seconds) {
-        super('TIMEOUT', `${label} timed out after ${seconds}s`, 'Try again, or increase timeout with OPENCLI_BROWSER_COMMAND_TIMEOUT env var');
-        this.name = 'TimeoutError';
+    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');
     }
 }
-// ── Argument validation ─────────────────────────────────────────────────────
 export class ArgumentError extends CliError {
-    constructor(message, hint) {
-        super('ARGUMENT', message, hint);
-        this.name = 'ArgumentError';
-    }
+    constructor(message, hint) { super('ARGUMENT', message, hint); }
 }
-// ── Empty result ────────────────────────────────────────────────────────────
 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');
-        this.name = 'EmptyResultError';
     }
 }
-// ── Selector / DOM ──────────────────────────────────────────────────────────
 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.');
-        this.name = 'SelectorError';
     }
 }
 // ── Utilities ───────────────────────────────────────────────────────────
@@ -95,4 +71,11 @@ export const ERROR_ICONS = {
     ARGUMENT: '❌',
     EMPTY_RESULT: '📭',
     SELECTOR: '🔍',
+    COMMAND_EXEC: '💥',
+    ADAPTER_LOAD: '📦',
+    NETWORK: '🌐',
+    API_ERROR: '🚫',
+    RATE_LIMITED: '⏳',
+    PAGE_CHANGED: '🔄',
+    CONFIG: '⚙️ ',
 };

package/dist/execution.d.ts

@@ -9,8 +9,6 @@
  * 5. Lazy-loading of TS modules from manifest
  * 6. Lifecycle hooks (onBeforeExecute / onAfterExecute)
  */
-import { type CliCommand, type Arg } from './registry.js';
-type CommandArgs = Record<string, unknown>;
+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>;
-export {};

package/dist/execution.js

@@ -12,10 +12,13 @@
 import { Strategy, getRegistry, fullName } from './registry.js';
 import { pathToFileURL } from 'node:url';
 import { executePipeline } from './pipeline/index.js';
-import { AdapterLoadError, ArgumentError, CommandExecutionError, getErrorMessage } from './errors.js';
+import { AdapterLoadError, ArgumentError, BrowserConnectError, CommandExecutionError, getErrorMessage } from './errors.js';
 import { shouldUseBrowserSession } from './capabilityRouting.js';
 import { getBrowserFactory, browserSession, runWithTimeout, DEFAULT_BROWSER_COMMAND_TIMEOUT } from './runtime.js';
 import { emitHook } from './hooks.js';
+import { checkDaemonStatus } from './browser/discover.js';
+import { PKG_VERSION } from './version.js';
+import chalk from 'chalk';
 const _loadedModules = new Set();
 export function coerceAndValidateArgs(cmdArgs, kwargs) {
     const result = { ...kwargs };
@@ -107,6 +110,25 @@ function ensureRequiredEnv(cmd) {
         return;
     throw new CommandExecutionError(`Command ${fullName(cmd)} requires environment variable ${missing.name}.`, missing.help ?? `Set ${missing.name} before running ${fullName(cmd)}.`);
 }
+/**
+ * Check if the browser is already on the target domain, avoiding redundant navigation.
+ * Returns true if current page hostname matches the pre-nav URL hostname.
+ */
+async function isAlreadyOnDomain(page, targetUrl) {
+    if (!page.getCurrentUrl)
+        return false;
+    try {
+        const currentUrl = await page.getCurrentUrl();
+        if (!currentUrl)
+            return false;
+        const currentHost = new URL(currentUrl).hostname;
+        const targetHost = new URL(targetUrl).hostname;
+        return currentHost === targetHost;
+    }
+    catch {
+        return false;
+    }
+}
 export async function executeCommand(cmd, rawKwargs, debug = false) {
     let kwargs;
     try {
@@ -126,18 +148,43 @@ export async function executeCommand(cmd, rawKwargs, debug = false) {
     let result;
     try {
         if (shouldUseBrowserSession(cmd)) {
+            // ── Fail-fast: only when daemon is UP but extension is not connected ──
+            // If daemon is not running, let browserSession() handle auto-start as usual.
+            // We only short-circuit when the daemon confirms the extension is missing —
+            // that's a clear setup gap, not a transient startup state.
+            // Use a short timeout: localhost responds in <50ms when running.
+            // 300ms avoids a full 2s wait on cold-start (daemon not yet running).
+            const status = await checkDaemonStatus({ timeout: 300 });
+            if (status.running && !status.extensionConnected) {
+                throw new BrowserConnectError('Browser Bridge extension not connected', 'Install the Browser Bridge:\n' +
+                    '  1. Download: https://github.com/jackwener/opencli/releases\n' +
+                    '  2. chrome://extensions → Developer Mode → Load unpacked\n' +
+                    '  Then run: opencli doctor');
+            }
+            // ── Version mismatch: warn but don't block ──
+            if (status.extensionVersion && status.extensionVersion !== PKG_VERSION) {
+                process.stderr.write(chalk.yellow(`⚠  Extension v${status.extensionVersion} ≠ CLI v${PKG_VERSION} — consider updating the extension.\n`));
+            }
             ensureRequiredEnv(cmd);
             const BrowserFactory = getBrowserFactory();
             result = await browserSession(BrowserFactory, async (page) => {
                 const preNavUrl = resolvePreNav(cmd);
                 if (preNavUrl) {
-                    try {
-                        await page.goto(preNavUrl);
-                        await page.wait(2);
-                    }
-                    catch (err) {
+                    const skip = await isAlreadyOnDomain(page, preNavUrl);
+                    if (skip) {
                         if (debug)
-                            console.error(`[pre-nav] Failed to navigate to ${preNavUrl}: ${err instanceof Error ? err.message : err}`);
+                            console.error(`[pre-nav] Already on target domain, skipping navigation`);
+                    }
+                    else {
+                        try {
+                            // goto() already includes smart DOM-settle detection (waitForDomStable).
+                            // No additional fixed sleep needed.
+                            await page.goto(preNavUrl);
+                        }
+                        catch (err) {
+                            if (debug)
+                                console.error(`[pre-nav] Failed to navigate to ${preNavUrl}: ${err instanceof Error ? err.message : err}`);
+                        }
                     }
                 }
                 return runWithTimeout(runCommand(cmd, page, kwargs, debug), {
@@ -147,7 +194,18 @@ export async function executeCommand(cmd, rawKwargs, debug = false) {
             }, { workspace: `site:${cmd.site}` });
         }
         else {
-            result = await runCommand(cmd, null, kwargs, debug);
+            // Non-browser commands: apply timeout only when explicitly configured.
+            const timeout = cmd.timeoutSeconds;
+            if (timeout !== undefined && timeout > 0) {
+                result = await runWithTimeout(runCommand(cmd, null, kwargs, debug), {
+                    timeout,
+                    label: fullName(cmd),
+                    hint: `Increase the adapter's timeoutSeconds setting (currently ${timeout}s)`,
+                });
+            }
+            else {
+                result = await runCommand(cmd, null, kwargs, debug);
+            }
         }
     }
     catch (err) {

package/dist/execution.test.d.ts

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

package/dist/execution.test.js

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest';
+import { executeCommand } from './execution.js';
+import { TimeoutError } from './errors.js';
+import { cli, Strategy } from './registry.js';
+import { withTimeoutMs } from './runtime.js';
+describe('executeCommand — non-browser timeout', () => {
+    it('applies timeoutSeconds to non-browser commands', async () => {
+        const cmd = cli({
+            site: 'test-execution',
+            name: 'non-browser-timeout',
+            description: 'test non-browser timeout',
+            browser: false,
+            strategy: Strategy.PUBLIC,
+            timeoutSeconds: 0.01,
+            func: () => new Promise(() => { }),
+        });
+        // Sentinel timeout at 200ms — if the inner 10ms timeout fires first,
+        // the error will be a TimeoutError with the command label, not 'sentinel'.
+        const error = await withTimeoutMs(executeCommand(cmd, {}), 200, 'sentinel timeout')
+            .catch((err) => err);
+        expect(error).toBeInstanceOf(TimeoutError);
+        expect(error).toMatchObject({
+            code: 'TIMEOUT',
+            message: 'test-execution/non-browser-timeout timed out after 0.01s',
+        });
+    });
+    it('skips timeout when timeoutSeconds is 0', async () => {
+        const cmd = cli({
+            site: 'test-execution',
+            name: 'non-browser-zero-timeout',
+            description: 'test zero timeout bypasses wrapping',
+            browser: false,
+            strategy: Strategy.PUBLIC,
+            timeoutSeconds: 0,
+            func: () => new Promise(() => { }),
+        });
+        // With timeout guard skipped, the sentinel fires instead.
+        await expect(withTimeoutMs(executeCommand(cmd, {}), 50, 'sentinel timeout')).rejects.toThrow('sentinel timeout');
+    });
+});

package/dist/external.js

@@ -12,7 +12,10 @@ function getUserRegistryPath() {
     const home = os.homedir();
     return path.join(home, '.opencli', 'external-clis.yaml');
 }
+let _cachedExternalClis = null;
 export function loadExternalClis() {
+    if (_cachedExternalClis)
+        return _cachedExternalClis;
     const configs = new Map();
     // 1. Load built-in
     const builtinPath = path.resolve(__dirname, 'external-clis.yaml');
@@ -41,7 +44,8 @@ export function loadExternalClis() {
     catch (err) {
         log.warn(`Failed to parse user external-clis.yaml: ${getErrorMessage(err)}`);
     }
-    return Array.from(configs.values()).sort((a, b) => a.name.localeCompare(b.name));
+    _cachedExternalClis = Array.from(configs.values()).sort((a, b) => a.name.localeCompare(b.name));
+    return _cachedExternalClis;
 }
 export function isBinaryInstalled(binary) {
     try {
@@ -200,5 +204,6 @@ export function registerExternalCli(name, opts) {
     }
     const dump = yaml.dump(items, { indent: 2, sortKeys: true });
     fs.writeFileSync(userPath, dump, 'utf8');
+    _cachedExternalClis = null; // Invalidate cache so next load reflects the change
     console.log(chalk.dim(userPath));
 }

package/dist/hooks.js

@@ -15,6 +15,8 @@ const _hooks = globalThis.__opencli_hooks__ ??= new Map();
 // ── Registration API (used by plugins) ─────────────────────────────────────
 function addHook(name, fn) {
     const list = _hooks.get(name) ?? [];
+    if (list.includes(fn))
+        return;
     list.push(fn);
     _hooks.set(name, list);
 }

package/dist/main.js

@@ -19,12 +19,18 @@ import { discoverClis, discoverPlugins } from './discovery.js';
 import { getCompletions } from './completion.js';
 import { runCli } from './cli.js';
 import { emitHook } from './hooks.js';
+import { registerUpdateNoticeOnExit, checkForUpdateBackground } from './update-check.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');
+// Sequential: plugins must run after built-in discovery so they can override built-in commands.
 await discoverClis(BUILTIN_CLIS, USER_CLIS);
 await discoverPlugins();
+// Register exit hook: notice appears after command output (same as npm/gh/yarn)
+registerUpdateNoticeOnExit();
+// Kick off background fetch for next run (non-blocking)
+checkForUpdateBackground();
 // ── Fast-path: handle --get-completions before commander parses ─────────
 // Usage: opencli --get-completions --cursor <N> [word1 word2 ...]
 const getCompIdx = process.argv.indexOf('--get-completions');

package/dist/output.js

@@ -5,7 +5,11 @@ import chalk from 'chalk';
 import Table from 'cli-table3';
 import yaml from 'js-yaml';
 function normalizeRows(data) {
-    return Array.isArray(data) ? data : [data];
+    if (Array.isArray(data))
+        return data;
+    if (data && typeof data === 'object')
+        return [data];
+    return [{ value: data }];
 }
 function resolveColumns(rows, opts) {
     return opts.columns ?? Object.keys(rows[0] ?? {});

package/dist/pipeline/executor.js

@@ -4,8 +4,7 @@
 import { getStep } from './registry.js';
 import { log } from '../logger.js';
 import { ConfigError } from '../errors.js';
-/** Steps that interact with the browser and may fail transiently */
-const BROWSER_STEPS = new Set(['navigate', 'evaluate', 'click', 'type', 'press', 'wait', 'snapshot']);
+import { BROWSER_ONLY_STEPS } from '../capabilityRouting.js';
 export async function executePipeline(page, pipeline, ctx = {}) {
     const args = ctx.args ?? {};
     const debug = ctx.debug ?? false;
@@ -33,7 +32,7 @@ export async function executePipeline(page, pipeline, ctx = {}) {
     }
     catch (err) {
         // Attempt cleanup: close automation window on pipeline failure
-        if (page && typeof page.closeWindow === 'function') {
+        if (page?.closeWindow) {
             try {
                 await page.closeWindow();
             }
@@ -44,7 +43,7 @@ export async function executePipeline(page, pipeline, ctx = {}) {
     return data;
 }
 async function executeStepWithRetry(handler, page, params, data, args, op, configRetries) {
-    const maxRetries = configRetries ?? (BROWSER_STEPS.has(op) ? 2 : 0);
+    const maxRetries = configRetries ?? (BROWSER_ONLY_STEPS.has(op) ? 2 : 0);
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
         try {
             return await handler(page, params, data, args);