@jackwener/opencli 1.5.8 → 1.6.0

package/dist/clis/xiaohongshu/note.test.js

@@ -112,6 +112,55 @@ describe('xiaohongshu note', () => {
         const page = createPageMock({ loginWall: false, notFound: true });
         await expect(command.func(page, { 'note-id': 'abc123' })).rejects.toThrow('returned no data');
     });
+    it('throws a token hint when the note page renders as an empty shell', async () => {
+        const page = createPageMock({
+            loginWall: false,
+            notFound: false,
+            title: '',
+            desc: '',
+            author: '',
+            likes: '',
+            collects: '',
+            comments: '',
+            tags: [],
+        });
+        try {
+            await command.func(page, { 'note-id': '69ca3927000000001a020fd5' });
+            throw new Error('expected xiaohongshu note to fail on an empty shell page');
+        }
+        catch (error) {
+            expect(error).toMatchObject({
+                code: 'EMPTY_RESULT',
+                hint: expect.stringMatching(/xsec_token|full url|search_result/i),
+            });
+        }
+    });
+    it('keeps the empty-shell hint generic when the user already passed a full URL', async () => {
+        const page = createPageMock({
+            loginWall: false,
+            notFound: false,
+            title: '',
+            desc: '',
+            author: '',
+            likes: '',
+            collects: '',
+            comments: '',
+            tags: [],
+        });
+        try {
+            await command.func(page, {
+                'note-id': 'https://www.xiaohongshu.com/search_result/69ca3927000000001a020fd5?xsec_token=abc',
+            });
+            throw new Error('expected xiaohongshu note to fail on an empty shell page');
+        }
+        catch (error) {
+            expect(error).toMatchObject({
+                code: 'EMPTY_RESULT',
+                hint: expect.stringContaining('loaded without visible content'),
+            });
+            expect(error.hint).not.toContain('bare note ID');
+        }
+    });
     it('normalizes placeholder text to 0 for zero-count metrics', async () => {
         const page = createPageMock({
             loginWall: false, notFound: false,

package/dist/commanderAdapter.js

@@ -59,7 +59,7 @@ export function registerCommandToProgram(siteCmd, cmd) {
         }
     }
     subCmd
-        .option('-f, --format <fmt>', 'Output format: table, json, yaml, md, csv', 'table')
+        .option('-f, --format <fmt>', 'Output format: table, plain, json, yaml, md, csv', 'table')
         .option('-v, --verbose', 'Debug output', false);
     subCmd.addHelpText('after', formatRegistryHelpText(cmd));
     subCmd.action(async (...actionArgs) => {
@@ -84,7 +84,7 @@ export function registerCommandToProgram(siteCmd, cmd) {
                     kwargs[arg.name] = normalizeArgValue(arg.type, v, arg.name);
             }
             const verbose = optionsRecord.verbose === true;
-            const format = typeof optionsRecord.format === 'string' ? optionsRecord.format : 'table';
+            let format = typeof optionsRecord.format === 'string' ? optionsRecord.format : 'table';
             if (verbose)
                 process.env.OPENCLI_VERBOSE = '1';
             if (cmd.deprecated) {
@@ -96,10 +96,13 @@ export function registerCommandToProgram(siteCmd, cmd) {
             if (result === null || result === undefined) {
                 return;
             }
+            const resolved = getRegistry().get(fullName(cmd)) ?? cmd;
+            if (format === 'table' && resolved.defaultFormat) {
+                format = resolved.defaultFormat;
+            }
             if (verbose && (!result || (Array.isArray(result) && result.length === 0))) {
                 console.error(chalk.yellow('[Verbose] Warning: Command returned an empty result.'));
             }
-            const resolved = getRegistry().get(fullName(cmd)) ?? cmd;
             renderOutput(result, {
                 fmt: format,
                 columns: resolved.columns,
@@ -209,7 +212,7 @@ async function renderError(err, cmdName, verbose) {
     if (err instanceof SelectorError || err instanceof EmptyResultError) {
         const icon = ERROR_ICONS[err.code] ?? '⚠️';
         console.error(chalk.red(`${icon} ${err.message}`));
-        console.error(chalk.yellow('→ The page structure may have changed — this adapter may be outdated.'));
+        console.error(chalk.yellow(`→ ${err.hint ?? 'The page structure may have changed — this adapter may be outdated.'}`));
         console.error(chalk.dim(`  Debug:  ${cmdName} --verbose`));
         console.error(chalk.dim(`  Report: ${ISSUES_URL}`));
         return;

package/dist/commanderAdapter.test.js

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { Command } from 'commander';
+import { EmptyResultError, SelectorError } from './errors.js';
 const { mockExecuteCommand, mockRenderOutput } = vi.hoisted(() => ({
     mockExecuteCommand: vi.fn(),
     mockRenderOutput: vi.fn(),
@@ -124,3 +125,78 @@ describe('commanderAdapter command aliases', () => {
         expect(mockExecuteCommand).toHaveBeenCalledWith(cmd, {}, false);
     });
 });
+describe('commanderAdapter default formats', () => {
+    const cmd = {
+        site: 'gemini',
+        name: 'ask',
+        description: 'Ask Gemini',
+        browser: false,
+        args: [],
+        columns: ['response'],
+        defaultFormat: 'plain',
+        func: vi.fn(),
+    };
+    beforeEach(() => {
+        mockExecuteCommand.mockReset();
+        mockExecuteCommand.mockResolvedValue([{ response: 'hello' }]);
+        mockRenderOutput.mockReset();
+        delete process.env.OPENCLI_VERBOSE;
+        process.exitCode = undefined;
+    });
+    it('uses the command defaultFormat when the user keeps the default table format', async () => {
+        const program = new Command();
+        const siteCmd = program.command('gemini');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'gemini', 'ask']);
+        expect(mockRenderOutput).toHaveBeenCalledWith([{ response: 'hello' }], expect.objectContaining({ fmt: 'plain' }));
+    });
+    it('respects an explicit user format over the command defaultFormat', async () => {
+        const program = new Command();
+        const siteCmd = program.command('gemini');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'gemini', 'ask', '--format', 'json']);
+        expect(mockRenderOutput).toHaveBeenCalledWith([{ response: 'hello' }], expect.objectContaining({ fmt: 'json' }));
+    });
+});
+describe('commanderAdapter empty result hints', () => {
+    const cmd = {
+        site: 'xiaohongshu',
+        name: 'note',
+        description: 'Read one note',
+        browser: false,
+        args: [
+            { name: 'note-id', positional: true, required: true, help: 'Note ID' },
+        ],
+        func: vi.fn(),
+    };
+    beforeEach(() => {
+        mockExecuteCommand.mockReset();
+        mockRenderOutput.mockReset();
+        delete process.env.OPENCLI_VERBOSE;
+        process.exitCode = undefined;
+    });
+    it('prints the adapter hint instead of the generic outdated-adapter message', async () => {
+        const program = new Command();
+        const siteCmd = program.command('xiaohongshu');
+        registerCommandToProgram(siteCmd, cmd);
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        mockExecuteCommand.mockRejectedValueOnce(new EmptyResultError('xiaohongshu/note', 'Pass the full search_result URL with xsec_token instead of a bare note ID.'));
+        await program.parseAsync(['node', 'opencli', 'xiaohongshu', 'note', '69ca3927000000001a020fd5']);
+        const output = errorSpy.mock.calls.flat().join('\n');
+        expect(output).toContain('xsec_token');
+        expect(output).not.toContain('this adapter may be outdated');
+        errorSpy.mockRestore();
+    });
+    it('prints selector-specific hints too', async () => {
+        const program = new Command();
+        const siteCmd = program.command('xiaohongshu');
+        registerCommandToProgram(siteCmd, cmd);
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        mockExecuteCommand.mockRejectedValueOnce(new SelectorError('.note-title', 'The note title selector no longer matches the current page.'));
+        await program.parseAsync(['node', 'opencli', 'xiaohongshu', 'note', '69ca3927000000001a020fd5']);
+        const output = errorSpy.mock.calls.flat().join('\n');
+        expect(output).toContain('selector no longer matches');
+        expect(output).not.toContain('this adapter may be outdated');
+        errorSpy.mockRestore();
+    });
+});

package/dist/commands/daemon.js

@@ -5,46 +5,7 @@
  *   opencli daemon restart — stop + respawn
  */
 import chalk from 'chalk';
-import { DEFAULT_DAEMON_PORT } from '../constants.js';
-const DAEMON_PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
-const DAEMON_URL = `http://127.0.0.1:${DAEMON_PORT}`;
-async function fetchStatus() {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 2000);
-    try {
-        const res = await fetch(`${DAEMON_URL}/status`, {
-            headers: { 'X-OpenCLI': '1' },
-            signal: controller.signal,
-        });
-        if (!res.ok)
-            return null;
-        return await res.json();
-    }
-    catch {
-        return null;
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
-async function requestShutdown() {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 5000);
-    try {
-        const res = await fetch(`${DAEMON_URL}/shutdown`, {
-            method: 'POST',
-            headers: { 'X-OpenCLI': '1' },
-            signal: controller.signal,
-        });
-        return res.ok;
-    }
-    catch {
-        return false;
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
+import { fetchDaemonStatus, requestDaemonShutdown } from '../browser/daemon-client.js';
 function formatUptime(seconds) {
     const h = Math.floor(seconds / 3600);
     const m = Math.floor((seconds % 3600) / 60);
@@ -65,7 +26,7 @@ function formatTimeSince(timestampMs) {
     return `${h}h ${m % 60}m ago`;
 }
 export async function daemonStatus() {
-    const status = await fetchStatus();
+    const status = await fetchDaemonStatus();
     if (!status) {
         console.log(`Daemon: ${chalk.dim('not running')}`);
         return;
@@ -78,12 +39,12 @@ export async function daemonStatus() {
     console.log(`Port: ${status.port}`);
 }
 export async function daemonStop() {
-    const status = await fetchStatus();
+    const status = await fetchDaemonStatus();
     if (!status) {
         console.log(chalk.dim('Daemon is not running.'));
         return;
     }
-    const ok = await requestShutdown();
+    const ok = await requestDaemonShutdown();
     if (ok) {
         console.log(chalk.green('Daemon stopped.'));
     }
@@ -93,9 +54,9 @@ export async function daemonStop() {
     }
 }
 export async function daemonRestart() {
-    const status = await fetchStatus();
+    const status = await fetchDaemonStatus();
     if (status) {
-        const ok = await requestShutdown();
+        const ok = await requestDaemonShutdown();
         if (!ok) {
             console.error(chalk.red('Failed to stop daemon.'));
             process.exitCode = 1;
@@ -105,12 +66,12 @@ export async function daemonRestart() {
         const deadline = Date.now() + 5000;
         while (Date.now() < deadline) {
             await new Promise(r => setTimeout(r, 200));
-            if (!(await fetchStatus()))
+            if (!(await fetchDaemonStatus()))
                 break;
         }
     }
     // Import BrowserBridge to spawn a new daemon
-    const { BrowserBridge } = await import('../browser/mcp.js');
+    const { BrowserBridge } = await import('../browser/bridge.js');
     const bridge = new BrowserBridge();
     try {
         console.log('Starting daemon...');

package/dist/commands/daemon.test.js

@@ -1,4 +1,8 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+const { fetchDaemonStatusMock, requestDaemonShutdownMock, } = vi.hoisted(() => ({
+    fetchDaemonStatusMock: vi.fn(),
+    requestDaemonShutdownMock: vi.fn(),
+}));
 vi.mock('chalk', () => ({
     default: {
         green: (s) => s,
@@ -8,11 +12,15 @@ vi.mock('chalk', () => ({
     },
 }));
 const mockConnect = vi.fn();
-vi.mock('../browser/mcp.js', () => ({
+vi.mock('../browser/bridge.js', () => ({
     BrowserBridge: class {
         connect = mockConnect;
     },
 }));
+vi.mock('../browser/daemon-client.js', () => ({
+    fetchDaemonStatus: fetchDaemonStatusMock,
+    requestDaemonShutdown: requestDaemonShutdownMock,
+}));
 import { daemonStatus, daemonStop, daemonRestart } from './daemon.js';
 describe('daemon commands', () => {
     let logSpy;
@@ -20,6 +28,8 @@ describe('daemon commands', () => {
     beforeEach(() => {
         logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
         errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        fetchDaemonStatusMock.mockReset();
+        requestDaemonShutdownMock.mockReset();
     });
     afterEach(() => {
         vi.restoreAllMocks();
@@ -27,12 +37,12 @@ describe('daemon commands', () => {
     });
     describe('daemonStatus', () => {
         it('shows "not running" when daemon is unreachable', async () => {
-            vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('ECONNREFUSED')));
+            fetchDaemonStatusMock.mockResolvedValue(null);
             await daemonStatus();
             expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('not running'));
         });
         it('shows "not running" when daemon returns non-ok response', async () => {
-            vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: false }));
+            fetchDaemonStatusMock.mockResolvedValue(null);
             await daemonStatus();
             expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('not running'));
         });
@@ -47,10 +57,7 @@ describe('daemon commands', () => {
                 memoryMB: 64,
                 port: 19825,
             };
-            vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve(status),
-            }));
+            fetchDaemonStatusMock.mockResolvedValue(status);
             await daemonStatus();
             expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('running'));
             expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('PID 12345'));
@@ -70,66 +77,45 @@ describe('daemon commands', () => {
                 memoryMB: 32,
                 port: 19825,
             };
-            vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve(status),
-            }));
+            fetchDaemonStatusMock.mockResolvedValue(status);
             await daemonStatus();
             expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('disconnected'));
         });
     });
     describe('daemonStop', () => {
         it('reports "not running" when daemon is unreachable', async () => {
-            vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('ECONNREFUSED')));
+            fetchDaemonStatusMock.mockResolvedValue(null);
             await daemonStop();
             expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('not running'));
         });
         it('sends shutdown and reports success', async () => {
-            const statusResponse = {
+            fetchDaemonStatusMock.mockResolvedValue({
                 ok: true,
-                json: () => Promise.resolve({
-                    ok: true,
-                    pid: 12345,
-                    uptime: 100,
-                    extensionConnected: true,
-                    pending: 0,
-                    lastCliRequestTime: Date.now(),
-                    memoryMB: 50,
-                    port: 19825,
-                }),
-            };
-            const shutdownResponse = { ok: true };
-            const mockFetch = vi.fn()
-                .mockResolvedValueOnce(statusResponse)
-                .mockResolvedValueOnce(shutdownResponse);
-            vi.stubGlobal('fetch', mockFetch);
+                pid: 12345,
+                uptime: 100,
+                extensionConnected: true,
+                pending: 0,
+                lastCliRequestTime: Date.now(),
+                memoryMB: 50,
+                port: 19825,
+            });
+            requestDaemonShutdownMock.mockResolvedValue(true);
             await daemonStop();
-            // Verify shutdown was called with POST
-            expect(mockFetch).toHaveBeenCalledTimes(2);
-            const shutdownCall = mockFetch.mock.calls[1];
-            expect(shutdownCall[0]).toContain('/shutdown');
-            expect(shutdownCall[1]).toMatchObject({ method: 'POST' });
+            expect(requestDaemonShutdownMock).toHaveBeenCalledTimes(1);
             expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Daemon stopped'));
         });
         it('reports failure when shutdown request fails', async () => {
-            const statusResponse = {
+            fetchDaemonStatusMock.mockResolvedValue({
                 ok: true,
-                json: () => Promise.resolve({
-                    ok: true,
-                    pid: 12345,
-                    uptime: 100,
-                    extensionConnected: true,
-                    pending: 0,
-                    lastCliRequestTime: Date.now(),
-                    memoryMB: 50,
-                    port: 19825,
-                }),
-            };
-            const shutdownResponse = { ok: false };
-            const mockFetch = vi.fn()
-                .mockResolvedValueOnce(statusResponse)
-                .mockResolvedValueOnce(shutdownResponse);
-            vi.stubGlobal('fetch', mockFetch);
+                pid: 12345,
+                uptime: 100,
+                extensionConnected: true,
+                pending: 0,
+                lastCliRequestTime: Date.now(),
+                memoryMB: 50,
+                port: 19825,
+            });
+            requestDaemonShutdownMock.mockResolvedValue(false);
             await daemonStop();
             expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to stop daemon'));
         });
@@ -146,37 +132,26 @@ describe('daemon commands', () => {
             port: 19825,
         };
         it('starts daemon directly when not running', async () => {
-            vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('ECONNREFUSED')));
+            fetchDaemonStatusMock.mockResolvedValue(null);
             mockConnect.mockResolvedValue(undefined);
             await daemonRestart();
             expect(mockConnect).toHaveBeenCalledWith({ timeout: 10 });
             expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Daemon restarted'));
         });
         it('stops then starts when daemon is running', async () => {
-            const mockFetch = vi.fn()
-                // First call: fetchStatus in daemonRestart — daemon is running
-                .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(statusData) })
-                // Second call: requestShutdown — success
-                .mockResolvedValueOnce({ ok: true })
-                // Subsequent calls: polling fetchStatus until unreachable
-                .mockRejectedValue(new Error('ECONNREFUSED'));
-            vi.stubGlobal('fetch', mockFetch);
+            fetchDaemonStatusMock
+                .mockResolvedValueOnce(statusData)
+                .mockResolvedValueOnce(null);
+            requestDaemonShutdownMock.mockResolvedValue(true);
             mockConnect.mockResolvedValue(undefined);
             await daemonRestart();
-            // Verify shutdown was called
-            const shutdownCall = mockFetch.mock.calls[1];
-            expect(shutdownCall[0]).toContain('/shutdown');
-            expect(shutdownCall[1]).toMatchObject({ method: 'POST' });
+            expect(requestDaemonShutdownMock).toHaveBeenCalledTimes(1);
             expect(mockConnect).toHaveBeenCalledWith({ timeout: 10 });
             expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Daemon restarted'));
         });
         it('aborts when shutdown fails', async () => {
-            const mockFetch = vi.fn()
-                // fetchStatus — daemon is running
-                .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(statusData) })
-                // requestShutdown — failure
-                .mockResolvedValueOnce({ ok: false });
-            vi.stubGlobal('fetch', mockFetch);
+            fetchDaemonStatusMock.mockResolvedValue(statusData);
+            requestDaemonShutdownMock.mockResolvedValue(false);
             await daemonRestart();
             expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to stop daemon'));
             expect(mockConnect).not.toHaveBeenCalled();

package/dist/discovery.js

@@ -66,6 +66,33 @@ export async function ensureUserCliCompatShims(baseDir = USER_OPENCLI_DIR) {
         writeCompatShimIfNeeded(path.join(baseDir, 'errors.js'), `export * from '${errorsUrl}';\n`),
         writeCompatShimIfNeeded(path.join(baseDir, 'package.json'), `${JSON.stringify({ name: 'opencli-user-runtime', private: true, type: 'module' }, null, 2)}\n`),
     ]);
+    // Create node_modules/@jackwener/opencli symlink so user TS CLIs can import
+    // from '@jackwener/opencli/registry' (the package export).
+    // This is needed because ~/.opencli/clis/ is outside opencli's node_modules tree.
+    const opencliRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+    const symlinkDir = path.join(baseDir, 'node_modules', '@jackwener');
+    const symlinkPath = path.join(symlinkDir, 'opencli');
+    try {
+        // Only recreate if symlink is missing or points to wrong target
+        let needsUpdate = true;
+        try {
+            const existing = await fs.promises.readlink(symlinkPath);
+            if (existing === opencliRoot)
+                needsUpdate = false;
+        }
+        catch { /* doesn't exist */ }
+        if (needsUpdate) {
+            await fs.promises.mkdir(symlinkDir, { recursive: true });
+            try {
+                await fs.promises.unlink(symlinkPath);
+            }
+            catch { /* doesn't exist */ }
+            await fs.promises.symlink(opencliRoot, symlinkPath, 'dir');
+        }
+    }
+    catch {
+        // Non-fatal: npm-linked installs or permission issues may prevent this
+    }
 }
 /**
  * Discover and register CLI commands.

package/dist/doctor.d.ts

@@ -1,8 +1,7 @@
 /**
  * opencli doctor — diagnose browser connectivity.
  *
- * Simplified for the daemon-based architecture. No more token management,
- * MCP path discovery, or config file scanning.
+ * Simplified for the daemon-based architecture.
  */
 export type DoctorOptions = {
     yes?: boolean;

package/dist/doctor.js

@@ -1,8 +1,7 @@
 /**
  * opencli doctor — diagnose browser connectivity.
  *
- * Simplified for the daemon-based architecture. No more token management,
- * MCP path discovery, or config file scanning.
+ * Simplified for the daemon-based architecture.
  */
 import chalk from 'chalk';
 import { DEFAULT_DAEMON_PORT } from './constants.js';
@@ -17,11 +16,11 @@ import { getRuntimeLabel } from './runtime-detect.js';
 export async function checkConnectivity(opts) {
     const start = Date.now();
     try {
-        const mcp = new BrowserBridge();
-        const page = await mcp.connect({ timeout: opts?.timeout ?? 8 });
+        const bridge = new BrowserBridge();
+        const page = await bridge.connect({ timeout: opts?.timeout ?? 8 });
         // Try a simple eval to verify end-to-end connectivity
         await page.evaluate('1 + 1');
-        await mcp.close();
+        await bridge.close();
         return { ok: true, durationMs: Date.now() - start };
     }
     catch (err) {
@@ -33,9 +32,9 @@ export async function runBrowserDoctor(opts = {}) {
     let initialStatus = await checkDaemonStatus();
     if (!initialStatus.running) {
         try {
-            const mcp = new BrowserBridge();
-            await mcp.connect({ timeout: 5 });
-            await mcp.close();
+            const bridge = new BrowserBridge();
+            await bridge.connect({ timeout: 5 });
+            await bridge.close();
         }
         catch {
             // Auto-start failed; we'll report it below.

package/dist/explore.js

@@ -46,7 +46,7 @@ export function slugify(value) {
     return value.trim().toLowerCase().replace(/[^a-zA-Z0-9]+/g, '-').replace(/^-|-$/g, '') || 'site';
 }
 /**
- * Parse raw network output from Playwright MCP.
+ * Parse raw network output from browser page.
  * Handles text format: [GET] url => [200]
  */
 function parseNetworkRequests(raw) {

package/dist/output.js

@@ -24,6 +24,9 @@ export function render(data, opts = {}) {
         case 'json':
             renderJson(data);
             break;
+        case 'plain':
+            renderPlain(data, opts);
+            break;
         case 'md':
         case 'markdown':
             renderMarkdown(data, opts);
@@ -77,6 +80,31 @@ function renderTable(data, opts) {
 function renderJson(data) {
     console.log(JSON.stringify(data, null, 2));
 }
+function renderPlain(data, opts) {
+    const rows = normalizeRows(data);
+    if (!rows.length)
+        return;
+    // Single-row single-field shortcuts for chat-style commands.
+    if (rows.length === 1) {
+        const row = rows[0];
+        const entries = Object.entries(row);
+        if (entries.length === 1) {
+            const [key, value] = entries[0];
+            if (key === 'response' || key === 'content' || key === 'text' || key === 'value') {
+                console.log(String(value ?? ''));
+                return;
+            }
+        }
+    }
+    rows.forEach((row, index) => {
+        const entries = Object.entries(row).filter(([, value]) => value !== undefined && value !== null && String(value) !== '');
+        entries.forEach(([key, value]) => {
+            console.log(`${key}: ${value}`);
+        });
+        if (index < rows.length - 1)
+            console.log('');
+    });
+}
 function renderMarkdown(data, opts) {
     const rows = normalizeRows(data);
     if (!rows.length)

package/dist/output.test.js

@@ -77,4 +77,19 @@ describe('render', () => {
         const calls = log.mock.calls.map(c => c[0]);
         expect(calls[1]).toBe('test,');
     });
+    it('renders single-field rows in plain mode as the bare value', () => {
+        const log = vi.spyOn(console, 'log').mockImplementation(() => { });
+        render([{ response: 'Gemini says hi' }], { fmt: 'plain' });
+        expect(log).toHaveBeenCalledWith('Gemini says hi');
+    });
+    it('renders multi-field rows in plain mode as key-value lines', () => {
+        const log = vi.spyOn(console, 'log').mockImplementation(() => { });
+        render([{ status: 'ok', file: '~/tmp/a.png', link: 'https://example.com' }], { fmt: 'plain' });
+        const calls = log.mock.calls.map(c => c[0]);
+        expect(calls).toEqual([
+            'status: ok',
+            'file: ~/tmp/a.png',
+            'link: https://example.com',
+        ]);
+    });
 });

package/dist/pipeline/executor.js

@@ -5,6 +5,7 @@ import { getStep } from './registry.js';
 import { log } from '../logger.js';
 import { ConfigError } from '../errors.js';
 import { BROWSER_ONLY_STEPS } from '../capabilityRouting.js';
+import { isTransientBrowserError } from '../browser/errors.js';
 export async function executePipeline(page, pipeline, ctx = {}) {
     const args = ctx.args ?? {};
     const debug = ctx.debug ?? false;
@@ -52,13 +53,7 @@ async function executeStepWithRetry(handler, page, params, data, args, op, confi
             if (attempt >= maxRetries)
                 throw err;
             // Only retry on transient browser errors
-            const msg = err instanceof Error ? err.message : '';
-            const isTransient = msg.includes('Extension disconnected')
-                || msg.includes('attach failed')
-                || msg.includes('no longer exists')
-                || msg.includes('CDP connection')
-                || msg.includes('Daemon command failed');
-            if (!isTransient)
+            if (!isTransientBrowserError(err))
                 throw err;
             // Brief delay before retry
             await new Promise(resolve => setTimeout(resolve, 1000));