@jackwener/opencli 1.7.2 → 1.7.4

package/dist/src/daemon.js

@@ -23,10 +23,12 @@ import { WebSocketServer, WebSocket } from 'ws';
 import { DEFAULT_DAEMON_PORT } from './constants.js';
 import { EXIT_CODES } from './errors.js';
 import { log } from './logger.js';
+import { PKG_VERSION } from './version.js';
 const PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
 // ─── State ───────────────────────────────────────────────────────────
 let extensionWs = null;
 let extensionVersion = null;
+let extensionCompatRange = null;
 const pending = new Map();
 const LOG_BUFFER_SIZE = 200;
 const logBuffer = [];
@@ -109,8 +111,10 @@ async function handleRequest(req, res) {
             ok: true,
             pid: process.pid,
             uptime,
+            daemonVersion: PKG_VERSION,
             extensionConnected: extensionWs?.readyState === WebSocket.OPEN,
             extensionVersion,
+            extensionCompatRange,
             pending: pending.size,
             memoryMB: Math.round(mem.rss / 1024 / 1024 * 10) / 10,
             port: PORT,
@@ -188,6 +192,7 @@ wss.on('connection', (ws) => {
     log.info('[daemon] Extension connected');
     extensionWs = ws;
     extensionVersion = null; // cleared until hello message arrives
+    extensionCompatRange = null;
     // ── Heartbeat: ping every 15s, close if 2 pongs missed ──
     let missedPongs = 0;
     const heartbeatInterval = setInterval(() => {
@@ -213,6 +218,7 @@ wss.on('connection', (ws) => {
             // Handle hello message from extension (version handshake)
             if (msg.type === 'hello') {
                 extensionVersion = typeof msg.version === 'string' ? msg.version : null;
+                extensionCompatRange = typeof msg.compatRange === 'string' ? msg.compatRange : null;
                 return;
             }
             // Handle log messages from extension
@@ -244,6 +250,7 @@ wss.on('connection', (ws) => {
         if (extensionWs === ws) {
             extensionWs = null;
             extensionVersion = null;
+            extensionCompatRange = null;
             // Reject all pending requests since the extension is gone
             for (const [id, p] of pending) {
                 clearTimeout(p.timer);

package/dist/src/doctor.d.ts

@@ -18,9 +18,11 @@ export type DoctorReport = {
     cliVersion?: string;
     daemonRunning: boolean;
     daemonFlaky?: boolean;
+    daemonVersion?: string;
     extensionConnected: boolean;
     extensionFlaky?: boolean;
     extensionVersion?: string;
+    latestExtensionVersion?: string;
     connectivity?: ConnectivityResult;
     sessions?: Array<{
         workspace: string;

package/dist/src/doctor.js

@@ -9,7 +9,37 @@ import { BrowserBridge } from './browser/index.js';
 import { getDaemonHealth, listSessions } from './browser/daemon-client.js';
 import { getErrorMessage } from './errors.js';
 import { getRuntimeLabel } from './runtime-detect.js';
+import { getCachedLatestExtensionVersion } from './update-check.js';
 const DOCTOR_LIVE_TIMEOUT_SECONDS = 8;
+/** Parse a semver string into [major, minor, patch]. Returns null on invalid input. */
+function parseSemver(v) {
+    const parts = v.replace(/^v/, '').split('-')[0].split('.').map(Number);
+    if (parts.length < 3 || parts.some(isNaN))
+        return null;
+    return [parts[0], parts[1], parts[2]];
+}
+/** Returns true if `a` is strictly newer than `b`. */
+function isNewerVersion(a, b) {
+    const va = parseSemver(a);
+    const vb = parseSemver(b);
+    if (!va || !vb)
+        return false;
+    const cmp = va[0] - vb[0] || va[1] - vb[1] || va[2] - vb[2];
+    return cmp > 0;
+}
+/** Check if version satisfies a simple range like ">=1.7.0". */
+function satisfiesRange(version, range) {
+    const match = range.match(/^(>=?)\s*(\S+)$/);
+    if (!match)
+        return true; // Unknown range format — don't block
+    const [, op, rangeVer] = match;
+    const v = parseSemver(version);
+    const r = parseSemver(rangeVer);
+    if (!v || !r)
+        return true;
+    const cmp = v[0] - r[0] || v[1] - r[1] || v[2] - r[2];
+    return op === '>=' ? cmp >= 0 : cmp > 0;
+}
 /**
  * Test connectivity by attempting a real browser command.
  */
@@ -57,6 +87,7 @@ export async function runBrowserDoctor(opts = {}) {
     const sessions = opts.sessions && health.state === 'ready'
         ? await listSessions()
         : undefined;
+    const extensionVersion = health.status?.extensionVersion;
     const issues = [];
     if (daemonFlaky) {
         issues.push('Daemon connectivity is unstable. The live browser test succeeded, but the daemon was no longer running immediately afterward.\n' +
@@ -70,17 +101,43 @@ export async function runBrowserDoctor(opts = {}) {
             'This usually means the Browser Bridge service worker is reconnecting slowly or Chrome suspended it.');
     }
     else if (daemonRunning && !extensionConnected) {
-        issues.push('Daemon is running but the Chrome/Chromium extension is not connected.\n' +
-            'Please install the opencli Browser Bridge extension:\n' +
-            '  1. Download from https://github.com/jackwener/opencli/releases\n' +
-            '  2. Open chrome://extensions/ → Enable Developer Mode\n' +
-            '  3. Click "Load unpacked" → select the extension folder');
+        const daemonVersion = health.status?.daemonVersion;
+        const isStale = opts.cliVersion && (!daemonVersion || daemonVersion !== opts.cliVersion);
+        if (isStale) {
+            const reason = daemonVersion
+                ? `daemon v${daemonVersion} ≠ CLI v${opts.cliVersion}`
+                : `daemon predates version reporting, CLI is v${opts.cliVersion}`;
+            issues.push(`Stale daemon detected: ${reason}.\n` +
+                'The daemon was started by an older CLI version and may have missed the extension registration.\n' +
+                '  Quick fix: opencli daemon stop && opencli doctor');
+        }
+        else {
+            issues.push('Daemon is running but the Chrome/Chromium extension is not connected.\n' +
+                'If the extension is already installed, try: opencli daemon stop && opencli doctor\n' +
+                'If the extension is not installed:\n' +
+                '  1. Download from https://github.com/jackwener/opencli/releases\n' +
+                '  2. Open chrome://extensions/ → Enable Developer Mode\n' +
+                '  3. Click "Load unpacked" → select the extension folder');
+        }
+    }
+    if (extensionConnected && !extensionVersion) {
+        issues.push('Extension is connected but did not report a version.\n' +
+            '  This usually means an outdated Browser Bridge extension.\n' +
+            '  Reload or reinstall the extension from: https://github.com/jackwener/opencli/releases');
     }
     if (connectivity && !connectivity.ok) {
         issues.push(`Browser connectivity test failed: ${connectivity.error ?? 'unknown'}`);
     }
-    const extensionVersion = health.status?.extensionVersion;
-    if (extensionVersion && opts.cliVersion) {
+    const extensionCompatRange = health.status?.extensionCompatRange;
+    if (extensionVersion && opts.cliVersion && extensionCompatRange) {
+        if (!satisfiesRange(opts.cliVersion, extensionCompatRange)) {
+            issues.push(`CLI version incompatible with extension: extension v${extensionVersion} requires CLI ${extensionCompatRange}, but CLI is v${opts.cliVersion}\n` +
+                '  Update the CLI: npm install -g @jackwener/opencli\n' +
+                '  Or download a compatible extension from: https://github.com/jackwener/opencli/releases');
+        }
+    }
+    else if (extensionVersion && opts.cliVersion) {
+        // Fallback for older extensions that don't send compatRange
         const extMajor = extensionVersion.split('.')[0];
         const cliMajor = opts.cliVersion.split('.')[0];
         if (extMajor !== cliMajor) {
@@ -88,13 +145,21 @@ export async function runBrowserDoctor(opts = {}) {
                 '  Download the latest extension from: https://github.com/jackwener/opencli/releases');
         }
     }
+    // Extension update check (from cached background fetch)
+    const latestExtensionVersion = getCachedLatestExtensionVersion();
+    if (extensionVersion && latestExtensionVersion && isNewerVersion(latestExtensionVersion, extensionVersion)) {
+        issues.push(`Extension update available: v${extensionVersion} → v${latestExtensionVersion}\n` +
+            '  Download from: https://github.com/jackwener/opencli/releases');
+    }
     return {
         cliVersion: opts.cliVersion,
         daemonRunning,
         daemonFlaky,
+        daemonVersion: health.status?.daemonVersion,
         extensionConnected,
         extensionFlaky,
         extensionVersion,
+        latestExtensionVersion,
         connectivity,
         sessions,
         issues,
@@ -108,13 +173,20 @@ export function renderBrowserDoctorReport(report) {
         : report.daemonRunning ? styleText('green', '[OK]') : styleText('red', '[MISSING]');
     const daemonLabel = report.daemonFlaky
         ? 'unstable (running during live check, then stopped)'
-        : report.daemonRunning ? `running on port ${DEFAULT_DAEMON_PORT}` : 'not running';
+        : report.daemonRunning ? `running on port ${DEFAULT_DAEMON_PORT}` + (report.daemonVersion ? ` (v${report.daemonVersion})` : '') : 'not running';
     lines.push(`${daemonIcon} Daemon: ${daemonLabel}`);
     // Extension status
-    const extIcon = report.extensionFlaky
+    const extIcon = report.extensionFlaky || (report.extensionConnected && !report.extensionVersion)
         ? styleText('yellow', '[WARN]')
         : report.extensionConnected ? styleText('green', '[OK]') : styleText('yellow', '[MISSING]');
-    const extVersion = report.extensionVersion ? styleText('dim', ` (v${report.extensionVersion})`) : '';
+    const extUpdateHint = report.extensionVersion && report.latestExtensionVersion && isNewerVersion(report.latestExtensionVersion, report.extensionVersion)
+        ? styleText('yellow', ` → v${report.latestExtensionVersion} available`)
+        : '';
+    const extVersion = !report.extensionConnected
+        ? ''
+        : report.extensionVersion
+            ? styleText('dim', ` (v${report.extensionVersion})`) + extUpdateHint
+            : styleText('dim', ' (version unknown)');
     const extLabel = report.extensionFlaky
         ? 'unstable (connected during live check, then disconnected)'
         : report.extensionConnected ? 'connected' : 'not connected';

package/dist/src/doctor.test.js

@@ -25,10 +25,11 @@ describe('doctor report rendering', () => {
         const text = strip(renderBrowserDoctorReport({
             daemonRunning: true,
             extensionConnected: true,
+            extensionVersion: '1.6.8',
             issues: [],
         }));
         expect(text).toContain('[OK] Daemon: running on port 19825');
-        expect(text).toContain('[OK] Extension: connected');
+        expect(text).toContain('[OK] Extension: connected (v1.6.8)');
         expect(text).toContain('Everything looks good!');
     });
     it('renders MISSING when daemon not running', () => {
@@ -50,6 +51,16 @@ describe('doctor report rendering', () => {
         expect(text).toContain('[OK] Daemon: running on port 19825');
         expect(text).toContain('[MISSING] Extension: not connected');
     });
+    it('renders a warning when the extension version is unknown', () => {
+        const text = strip(renderBrowserDoctorReport({
+            daemonRunning: true,
+            extensionConnected: true,
+            issues: ['Extension is connected but did not report a version.'],
+        }));
+        expect(text).toContain('[WARN] Extension: connected (version unknown)');
+        expect(text).toContain('Extension is connected but did not report a version.');
+        expect(text).not.toContain('Everything looks good!');
+    });
     it('renders connectivity OK when live test succeeds', () => {
         const text = strip(renderBrowserDoctorReport({
             daemonRunning: true,
@@ -90,12 +101,8 @@ describe('doctor report rendering', () => {
         expect(text).toContain('Daemon connectivity is unstable.');
     });
     it('reports daemon not running when no-live and auto-start fails', async () => {
-        // no-live mode: getDaemonHealth called twice (initial check + final status)
-        // Initial: stopped → triggers auto-start attempt
         mockGetDaemonHealth.mockResolvedValueOnce({ state: 'stopped', status: null });
-        // Auto-start fails
         mockConnect.mockRejectedValueOnce(new Error('Could not start daemon'));
-        // Final: still stopped
         mockGetDaemonHealth.mockResolvedValueOnce({ state: 'stopped', status: null });
         const report = await runBrowserDoctor({ live: false });
         expect(report.daemonRunning).toBe(false);
@@ -106,12 +113,10 @@ describe('doctor report rendering', () => {
         ]));
     });
     it('reports flapping when live check succeeds but final status shows extension disconnected', async () => {
-        // Live check succeeds
         mockConnect.mockResolvedValueOnce({
             evaluate: vi.fn().mockResolvedValue(2),
         });
         mockClose.mockResolvedValueOnce(undefined);
-        // After live check, getDaemonHealth shows no-extension
         mockGetDaemonHealth.mockResolvedValueOnce({ state: 'no-extension', status: { extensionConnected: false } });
         const report = await runBrowserDoctor({ live: true });
         expect(report.daemonRunning).toBe(true);
@@ -122,12 +127,10 @@ describe('doctor report rendering', () => {
         ]));
     });
     it('reports daemon flapping when live check succeeds but daemon disappears afterward', async () => {
-        // Live check succeeds
         mockConnect.mockResolvedValueOnce({
             evaluate: vi.fn().mockResolvedValue(2),
         });
         mockClose.mockResolvedValueOnce(undefined);
-        // After live check, getDaemonHealth shows stopped
         mockGetDaemonHealth.mockResolvedValueOnce({ state: 'stopped', status: null });
         const report = await runBrowserDoctor({ live: true });
         expect(report.daemonRunning).toBe(false);
@@ -151,14 +154,27 @@ describe('doctor report rendering', () => {
         expect(timeoutSeen).toBe(8);
     });
     it('skips auto-start in no-live mode when daemon is already running', async () => {
-        // no-live mode but daemon already running (no-extension)
         mockGetDaemonHealth.mockResolvedValueOnce({ state: 'no-extension', status: { extensionConnected: false } });
-        // Final status: same
         mockGetDaemonHealth.mockResolvedValueOnce({ state: 'no-extension', status: { extensionConnected: false } });
         const report = await runBrowserDoctor({ live: false });
-        // Should NOT have tried auto-start since daemon was already running
         expect(mockConnect).not.toHaveBeenCalled();
         expect(report.daemonRunning).toBe(true);
         expect(report.extensionConnected).toBe(false);
     });
+    it('reports an issue when the extension is connected but does not report a version', async () => {
+        const status = {
+            state: 'ready',
+            status: {
+                extensionConnected: true,
+                extensionVersion: undefined,
+            },
+        };
+        mockGetDaemonHealth
+            .mockResolvedValueOnce(status)
+            .mockResolvedValueOnce(status);
+        const report = await runBrowserDoctor({ live: false });
+        expect(report.issues).toEqual(expect.arrayContaining([
+            expect.stringContaining('did not report a version'),
+        ]));
+    });
 });

package/dist/src/electron-apps.js

@@ -22,7 +22,7 @@ export const builtinApps = {
         bundleId: 'dev.antigravity.app',
         displayName: 'Antigravity',
     },
-    chatgpt: { port: 9236, processName: 'ChatGPT', bundleId: 'com.openai.chat', displayName: 'ChatGPT' },
+    'chatgpt-app': { port: 9236, processName: 'ChatGPT', bundleId: 'com.openai.chat', displayName: 'ChatGPT' },
 };
 /** Merge builtin + user-defined apps. User entries are additive only. */
 export function loadApps(userApps) {

package/dist/src/errors.d.ts

@@ -82,6 +82,7 @@ export interface ErrorEnvelope {
         help?: string;
         exitCode: number;
         stack?: string;
+        cause?: string;
     };
 }
 /** Extract a human-readable message from an unknown caught value. */

package/dist/src/errors.js

@@ -106,8 +106,19 @@ export class PluginError extends CliError {
 export function getErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+/** Serialize an error cause chain into a readable string. */
+function serializeCause(cause) {
+    if (cause instanceof Error) {
+        const parts = [cause.message];
+        if (cause.cause)
+            parts.push(`  caused by: ${serializeCause(cause.cause)}`);
+        return parts.join('\n');
+    }
+    return String(cause);
+}
 /** Build an ErrorEnvelope from any caught value. */
 export function toEnvelope(err) {
+    const cause = err instanceof Error && err.cause ? serializeCause(err.cause) : undefined;
     if (err instanceof CliError) {
         return {
             ok: false,
@@ -116,6 +127,7 @@ export function toEnvelope(err) {
                 message: err.message,
                 ...(err.hint ? { help: err.hint } : {}),
                 exitCode: err.exitCode,
+                ...(cause ? { cause } : {}),
             },
         };
     }
@@ -126,6 +138,7 @@ export function toEnvelope(err) {
             code: 'UNKNOWN',
             message: msg,
             exitCode: EXIT_CODES.GENERIC_ERROR,
+            ...(cause ? { cause } : {}),
         },
     };
 }

package/dist/src/execution.js

@@ -11,16 +11,20 @@
  */
 import { getRegistry, fullName } from './registry.js';
 import { pathToFileURL } from 'node:url';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
 import { executePipeline } from './pipeline/index.js';
 import { AdapterLoadError, ArgumentError, CommandExecutionError, getErrorMessage } from './errors.js';
 import { isDiagnosticEnabled, collectDiagnostic, emitDiagnostic } from './diagnostic.js';
 import { shouldUseBrowserSession } from './capabilityRouting.js';
 import { getBrowserFactory, browserSession, runWithTimeout, DEFAULT_BROWSER_COMMAND_TIMEOUT } from './runtime.js';
 import { emitHook } from './hooks.js';
-import { log } from './logger.js';
 import { isElectronApp } from './electron-apps.js';
 import { probeCDP, resolveElectronEndpoint } from './launcher.js';
-const _loadedModules = new Set();
+const _loadedModules = new Map();
+/** Track mtime of loaded user adapter files for hot-reload in daemon mode. */
+const _moduleMtimes = new Map();
+const _userClisDir = `${os.homedir()}/.opencli/clis/`;
 export function coerceAndValidateArgs(cmdArgs, kwargs) {
     const result = { ...kwargs };
     for (const argDef of cmdArgs) {
@@ -67,15 +71,34 @@ async function runCommand(cmd, page, kwargs, debug) {
     const internal = cmd;
     if (internal._lazy && internal._modulePath) {
         const modulePath = internal._modulePath;
-        if (!_loadedModules.has(modulePath)) {
+        // Hot-reload: if a user adapter's file has changed on disk, invalidate cache
+        const isUserAdapter = modulePath.startsWith(_userClisDir);
+        if (isUserAdapter && _loadedModules.has(modulePath)) {
             try {
-                await import(pathToFileURL(modulePath).href);
-                _loadedModules.add(modulePath);
+                const stat = fs.statSync(modulePath);
+                const prevMtime = _moduleMtimes.get(modulePath);
+                if (prevMtime !== undefined && stat.mtimeMs !== prevMtime) {
+                    _loadedModules.delete(modulePath);
+                    _moduleMtimes.delete(modulePath);
+                }
             }
-            catch (err) {
+            catch { /* file may have been deleted; let import below handle it */ }
+        }
+        if (!_loadedModules.has(modulePath)) {
+            const url = pathToFileURL(modulePath).href;
+            const importUrl = _moduleMtimes.has(modulePath) ? `${url}?t=${Date.now()}` : url;
+            const loadPromise = import(importUrl).then(() => {
+                try {
+                    _moduleMtimes.set(modulePath, fs.statSync(modulePath).mtimeMs);
+                }
+                catch { }
+            }, (err) => {
+                _loadedModules.delete(modulePath);
                 throw new AdapterLoadError(`Failed to load adapter module ${modulePath}: ${getErrorMessage(err)}`, 'Check that the adapter file exists and has no syntax errors.');
-            }
+            });
+            _loadedModules.set(modulePath, loadPromise);
         }
+        await _loadedModules.get(modulePath);
         const updated = getRegistry().get(fullName(cmd));
         if (updated?.func) {
             if (!page && updated.browser !== false) {
@@ -159,7 +182,7 @@ export async function executeCommand(cmd, rawKwargs, debug = false, opts = {}) {
                         await page.goto(preNavUrl);
                     }
                     catch (err) {
-                        log.warn(`Pre-navigation to ${preNavUrl} failed: ${err instanceof Error ? err.message : err}`);
+                        throw new CommandExecutionError(`Pre-navigation to ${preNavUrl} failed: ${err instanceof Error ? err.message : err}`, 'Check that the site is reachable and the browser extension is running.');
                     }
                 }
                 try {
@@ -173,13 +196,17 @@ export async function executeCommand(cmd, rawKwargs, debug = false, opts = {}) {
                     return result;
                 }
                 catch (err) {
-                    // Collect diagnostic while page is still alive (before browserSession closes it).
+                    // Collect diagnostic while page is still alive (before closing the window).
                     if (isDiagnosticEnabled()) {
                         const internal = cmd;
                         const ctx = await collectDiagnostic(err, internal, page);
                         emitDiagnostic(ctx);
                         diagnosticEmitted = true;
                     }
+                    // Close the automation window on failure too — without this, the window
+                    // lingers until the extension's idle timer fires (unreliable on Windows
+                    // where MV3 service workers may be suspended before setTimeout triggers).
+                    await page.closeWindow?.().catch(() => { });
                     throw err;
                 }
             }, { workspace: `site:${cmd.site}`, cdpEndpoint });

package/dist/src/execution.test.js

@@ -3,6 +3,8 @@ import { executeCommand, prepareCommandArgs } from './execution.js';
 import { TimeoutError } from './errors.js';
 import { cli, Strategy } from './registry.js';
 import { withTimeoutMs } from './runtime.js';
+import * as runtime from './runtime.js';
+import * as capRouting from './capabilityRouting.js';
 describe('executeCommand — non-browser timeout', () => {
     it('applies timeoutSeconds to non-browser commands', async () => {
         const cmd = cli({
@@ -37,6 +39,27 @@ describe('executeCommand — non-browser timeout', () => {
         // With timeout guard skipped, the sentinel fires instead.
         await expect(withTimeoutMs(executeCommand(cmd, {}), 50, 'sentinel timeout')).rejects.toThrow('sentinel timeout');
     });
+    it('calls closeWindow on browser command failure', async () => {
+        const closeWindow = vi.fn().mockResolvedValue(undefined);
+        const mockPage = { closeWindow };
+        // Mock shouldUseBrowserSession to return true
+        vi.spyOn(capRouting, 'shouldUseBrowserSession').mockReturnValue(true);
+        // Mock browserSession to invoke the callback with our mock page
+        vi.spyOn(runtime, 'browserSession').mockImplementation(async (_Factory, fn) => {
+            return fn(mockPage);
+        });
+        const cmd = cli({
+            site: 'test-execution',
+            name: 'browser-close-on-error',
+            description: 'test closeWindow on failure',
+            browser: true,
+            strategy: Strategy.PUBLIC,
+            func: async () => { throw new Error('adapter failure'); },
+        });
+        await expect(executeCommand(cmd, {})).rejects.toThrow('adapter failure');
+        expect(closeWindow).toHaveBeenCalledTimes(1);
+        vi.restoreAllMocks();
+    });
     it('does not re-run custom validation when args are already prepared', async () => {
         const validateArgs = vi.fn();
         const cmd = {

package/dist/src/external-clis.yaml

@@ -36,8 +36,8 @@
   homepage: "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli"
   tags: [dingtalk, collaboration, productivity, ai-agent]
   install:
-    mac: "curl -fsSL https://raw.githubusercontent.com/DingTalk-Real-AI/dingtalk-workspace-cli/main/scripts/install.sh | sh"
-    linux: "curl -fsSL https://raw.githubusercontent.com/DingTalk-Real-AI/dingtalk-workspace-cli/main/scripts/install.sh | sh"
+    mac: "npm install -g dingtalk-workspace-cli"
+    linux: "npm install -g dingtalk-workspace-cli"
 
 - name: wecom-cli
   binary: wecom-cli

package/dist/src/logger.d.ts

@@ -15,9 +15,9 @@ export declare const log: {
     warn(msg: string): void;
     /** Error (always shown) */
     error(msg: string): void;
-    /** Verbose output (only when OPENCLI_VERBOSE is set or -v flag) */
+    /** Verbose output (shown when -v flag or OPENCLI_VERBOSE is set) */
     verbose(msg: string): void;
-    /** Debug output (only when DEBUG includes 'opencli') */
+    /** Alias for verbose output. */
     debug(msg: string): void;
     /** Step-style debug (for pipeline steps, etc.) */
     step(stepNum: number, total: number, op: string, preview?: string): void;

package/dist/src/logger.js

@@ -8,9 +8,6 @@ import { styleText } from 'node:util';
 function isVerbose() {
     return !!process.env.OPENCLI_VERBOSE;
 }
-function isDebug() {
-    return !!process.env.DEBUG?.includes('opencli');
-}
 export const log = {
     /** Informational message (always shown) */
     info(msg) {
@@ -32,17 +29,15 @@ export const log = {
     error(msg) {
         process.stderr.write(`${styleText('red', '✖')}  ${msg}\n`);
     },
-    /** Verbose output (only when OPENCLI_VERBOSE is set or -v flag) */
+    /** Verbose output (shown when -v flag or OPENCLI_VERBOSE is set) */
     verbose(msg) {
         if (isVerbose()) {
             process.stderr.write(`${styleText('dim', '[verbose]')} ${msg}\n`);
         }
     },
-    /** Debug output (only when DEBUG includes 'opencli') */
+    /** Alias for verbose output. */
     debug(msg) {
-        if (isDebug()) {
-            process.stderr.write(`${styleText('dim', '[debug]')} ${msg}\n`);
-        }
+        this.verbose(msg);
     },
     /** Step-style debug (for pipeline steps, etc.) */
     step(stepNum, total, op, preview = '') {

package/dist/src/output.js

@@ -17,12 +17,8 @@ function resolveColumns(rows, opts) {
 export function render(data, opts = {}) {
     let fmt = opts.fmt ?? 'table';
     // Non-TTY auto-downgrade only when format was NOT explicitly passed by user.
-    // Priority: explicit -f (any value) > OUTPUT env var > TTY auto-detect > table
     if (!opts.fmtExplicit) {
-        const envFmt = process.env.OUTPUT?.trim().toLowerCase();
-        if (envFmt)
-            fmt = envFmt;
-        else if (fmt === 'table' && !process.stdout.isTTY)
+        if (fmt === 'table' && !process.stdout.isTTY)
             fmt = 'yaml';
     }
     if (data === null || data === undefined) {

package/dist/src/output.test.js

@@ -2,17 +2,12 @@ import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
 import { render } from './output.js';
 describe('output TTY detection', () => {
     const originalIsTTY = process.stdout.isTTY;
-    const originalEnv = process.env.OUTPUT;
     let logSpy;
     beforeEach(() => {
         logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
     });
     afterEach(() => {
         Object.defineProperty(process.stdout, 'isTTY', { value: originalIsTTY, writable: true });
-        if (originalEnv === undefined)
-            delete process.env.OUTPUT;
-        else
-            process.env.OUTPUT = originalEnv;
         logSpy.mockRestore();
     });
     it('outputs YAML in non-TTY when format is default table', () => {
@@ -35,22 +30,6 @@ describe('output TTY detection', () => {
         const out = logSpy.mock.calls.map((c) => c[0]).join('\n');
         expect(JSON.parse(out)).toEqual([{ name: 'alice' }]);
     });
-    it('OUTPUT env var overrides default table in non-TTY', () => {
-        Object.defineProperty(process.stdout, 'isTTY', { value: false, writable: true });
-        process.env.OUTPUT = 'json';
-        render([{ name: 'alice' }], { fmt: 'table' });
-        const out = logSpy.mock.calls.map((c) => c[0]).join('\n');
-        expect(JSON.parse(out)).toEqual([{ name: 'alice' }]);
-    });
-    it('explicit -f flag takes precedence over OUTPUT env var', () => {
-        Object.defineProperty(process.stdout, 'isTTY', { value: false, writable: true });
-        process.env.OUTPUT = 'json';
-        render([{ name: 'alice' }], { fmt: 'csv', fmtExplicit: true });
-        const out = logSpy.mock.calls.map((c) => c[0]).join('\n');
-        expect(out).toContain('name');
-        expect(out).toContain('alice');
-        expect(out).not.toContain('"name"'); // not JSON
-    });
     it('explicit -f table overrides non-TTY auto-downgrade', () => {
         Object.defineProperty(process.stdout, 'isTTY', { value: false, writable: true });
         render([{ name: 'alice' }], { fmt: 'table', fmtExplicit: true, columns: ['name'] });

package/dist/src/pipeline/steps/transform.js

@@ -40,7 +40,7 @@ export async function stepMap(_page, params, data, args) {
         for (const [key, template] of Object.entries(templateParams)) {
             if (key === 'select')
                 continue;
-            row[key] = render(template, { args, data: source, item, index: i });
+            row[key] = render(template, { args, data: source, root: data, item, index: i });
         }
         result.push(row);
     }

package/dist/src/pipeline/template.d.ts

@@ -4,6 +4,7 @@
 export interface RenderContext {
     args?: Record<string, unknown>;
     data?: unknown;
+    root?: unknown;
     item?: unknown;
     index?: number;
 }