@jackwener/opencli 0.6.1 → 0.6.3

package/dist/clis/boss/detail.js

@@ -0,0 +1,104 @@
+/**
+ * BOSS直聘 job detail — fetch full job posting details via browser cookie API.
+ *
+ * Uses securityId from search results to call the detail API.
+ * Returns: job description, skills, welfare, boss info, company info, address.
+ */
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'boss',
+    name: 'detail',
+    description: 'BOSS直聘查看职位详情',
+    domain: 'www.zhipin.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'security_id', required: true, help: 'Security ID from search results (securityId field)' },
+    ],
+    columns: [
+        'name', 'salary', 'experience', 'degree', 'city', 'district',
+        'description', 'skills', 'welfare',
+        'boss_name', 'boss_title', 'active_time',
+        'company', 'industry', 'scale', 'stage',
+        'address', 'url',
+    ],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new Error('Browser page required');
+        const securityId = kwargs.security_id;
+        // Navigate to zhipin.com first to establish cookie context (referrer + cookies)
+        await page.goto('https://www.zhipin.com/web/geek/job');
+        await page.wait({ time: 1 });
+        const targetUrl = `https://www.zhipin.com/wapi/zpgeek/job/detail.json?securityId=${encodeURIComponent(securityId)}`;
+        if (process.env.OPENCLI_VERBOSE || process.env.DEBUG?.includes('opencli')) {
+            console.error(`[opencli:boss] Fetching job detail...`);
+        }
+        const evaluateScript = `
+      async () => {
+        return new Promise((resolve, reject) => {
+          const xhr = new window.XMLHttpRequest();
+          xhr.open('GET', ${JSON.stringify(targetUrl)}, true);
+          xhr.withCredentials = true;
+          xhr.timeout = 15000;
+          xhr.setRequestHeader('Accept', 'application/json, text/plain, */*');
+          xhr.onload = () => {
+            if (xhr.status >= 200 && xhr.status < 300) {
+              try {
+                resolve(JSON.parse(xhr.responseText));
+              } catch (e) {
+                reject(new Error('Failed to parse JSON. Raw (200 chars): ' + xhr.responseText.substring(0, 200)));
+              }
+            } else {
+              reject(new Error('XHR HTTP Status: ' + xhr.status));
+            }
+          };
+          xhr.onerror = () => reject(new Error('XHR Network Error'));
+          xhr.ontimeout = () => reject(new Error('XHR Timeout'));
+          xhr.send();
+        });
+      }
+    `;
+        let data;
+        try {
+            data = await page.evaluate(evaluateScript);
+        }
+        catch (e) {
+            throw new Error('API evaluate failed: ' + e.message);
+        }
+        if (data.code !== 0) {
+            if (data.code === 37) {
+                throw new Error('Cookie 已过期！请在当前 Chrome 浏览器中重新登录 BOSS 直聘。');
+            }
+            throw new Error(`BOSS API error: ${data.message || 'Unknown'} (code=${data.code})`);
+        }
+        const zpData = data.zpData || {};
+        const jobInfo = zpData.jobInfo || {};
+        const bossInfo = zpData.bossInfo || {};
+        const brandComInfo = zpData.brandComInfo || {};
+        if (!jobInfo.jobName) {
+            throw new Error('该职位信息不存在或已下架');
+        }
+        return [{
+                name: jobInfo.jobName || '',
+                salary: jobInfo.salaryDesc || '',
+                experience: jobInfo.experienceName || '',
+                degree: jobInfo.degreeName || '',
+                city: jobInfo.locationName || '',
+                district: [jobInfo.areaDistrict, jobInfo.businessDistrict].filter(Boolean).join('·'),
+                description: jobInfo.postDescription || '',
+                skills: (jobInfo.showSkills || []).join(', '),
+                welfare: (brandComInfo.labels || []).join(', '),
+                boss_name: bossInfo.name || '',
+                boss_title: bossInfo.title || '',
+                active_time: bossInfo.activeTimeDesc || '',
+                company: brandComInfo.brandName || bossInfo.brandName || '',
+                industry: brandComInfo.industryName || '',
+                scale: brandComInfo.scaleName || '',
+                stage: brandComInfo.stageName || '',
+                address: jobInfo.address || '',
+                url: jobInfo.encryptId
+                    ? 'https://www.zhipin.com/job_detail/' + jobInfo.encryptId + '.html'
+                    : '',
+            }];
+    },
+});

package/dist/clis/boss/search.js

@@ -78,7 +78,7 @@ cli({
         { name: 'page', type: 'int', default: 1, help: 'Page number' },
         { name: 'limit', type: 'int', default: 15, help: 'Number of results' },
     ],
-    columns: ['name', 'salary', 'company', 'area', 'experience', 'degree', 'skills', 'boss', 'url'],
+    columns: ['name', 'salary', 'company', 'area', 'experience', 'degree', 'skills', 'boss', 'security_id', 'url'],
     func: async (page, kwargs) => {
         if (!page)
             throw new Error('Browser page required');
@@ -180,6 +180,7 @@ cli({
                     degree: j.jobDegree,
                     skills: (j.skills || []).join(','),
                     boss: j.bossName + ' · ' + j.bossTitle,
+                    security_id: j.securityId || '',
                     url: 'https://www.zhipin.com/job_detail/' + j.encryptJobId + '.html',
                 });
                 addedInBatch++;

package/dist/interceptor.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for interceptor.ts: JavaScript code generators for XHR/Fetch interception.
+ */
+export {};

package/dist/interceptor.test.js

@@ -0,0 +1,81 @@
+/**
+ * Tests for interceptor.ts: JavaScript code generators for XHR/Fetch interception.
+ */
+import { describe, it, expect } from 'vitest';
+import { generateInterceptorJs, generateReadInterceptedJs, generateTapInterceptorJs } from './interceptor.js';
+describe('generateInterceptorJs', () => {
+    it('generates valid JavaScript function source', () => {
+        const js = generateInterceptorJs('"api/search"');
+        expect(js).toContain('window.fetch');
+        expect(js).toContain('XMLHttpRequest');
+        expect(js).toContain('"api/search"');
+        // Should be a function expression wrapping
+        expect(js.trim()).toMatch(/^\(\)\s*=>/);
+    });
+    it('uses default array name and patch guard', () => {
+        const js = generateInterceptorJs('"test"');
+        expect(js).toContain('__opencli_intercepted');
+        expect(js).toContain('__opencli_interceptor_patched');
+    });
+    it('uses custom array name and patch guard', () => {
+        const js = generateInterceptorJs('"test"', {
+            arrayName: '__my_data',
+            patchGuard: '__my_guard',
+        });
+        expect(js).toContain('__my_data');
+        expect(js).toContain('__my_guard');
+        expect(js).not.toContain('__opencli_intercepted');
+    });
+    it('includes fetch clone and json parsing', () => {
+        const js = generateInterceptorJs('"api"');
+        expect(js).toContain('response.clone()');
+        expect(js).toContain('clone.json()');
+    });
+    it('includes XHR open and send patching', () => {
+        const js = generateInterceptorJs('"api"');
+        expect(js).toContain('XMLHttpRequest.prototype');
+        expect(js).toContain('__origOpen');
+        expect(js).toContain('__origSend');
+    });
+});
+describe('generateReadInterceptedJs', () => {
+    it('generates valid JavaScript to read and clear data', () => {
+        const js = generateReadInterceptedJs();
+        expect(js).toContain('__opencli_intercepted');
+        // Should clear the array after reading
+        expect(js).toContain('= []');
+    });
+    it('uses custom array name', () => {
+        const js = generateReadInterceptedJs('__custom_arr');
+        expect(js).toContain('__custom_arr');
+        expect(js).not.toContain('__opencli_intercepted');
+    });
+});
+describe('generateTapInterceptorJs', () => {
+    it('returns all required fields', () => {
+        const tap = generateTapInterceptorJs('"api/data"');
+        expect(tap.setupVar).toBeDefined();
+        expect(tap.capturedVar).toBe('captured');
+        expect(tap.promiseVar).toBe('capturePromise');
+        expect(tap.resolveVar).toBe('captureResolve');
+        expect(tap.fetchPatch).toBeDefined();
+        expect(tap.xhrPatch).toBeDefined();
+        expect(tap.restorePatch).toBeDefined();
+    });
+    it('contains the capture pattern in setup', () => {
+        const tap = generateTapInterceptorJs('"my-pattern"');
+        expect(tap.setupVar).toContain('"my-pattern"');
+    });
+    it('restores original fetch and XHR in restorePatch', () => {
+        const tap = generateTapInterceptorJs('"test"');
+        expect(tap.restorePatch).toContain('origFetch');
+        expect(tap.restorePatch).toContain('origXhrOpen');
+        expect(tap.restorePatch).toContain('origXhrSend');
+    });
+    it('uses first-match capture (only first response)', () => {
+        const tap = generateTapInterceptorJs('"test"');
+        // Both fetch and xhr patches should check !captured before storing
+        expect(tap.fetchPatch).toContain('!captured');
+        expect(tap.xhrPatch).toContain('!captured');
+    });
+});

package/dist/output.test.d.ts

@@ -1 +1,4 @@
+/**
+ * Tests for output.ts: render function format coverage.
+ */
 export {};

package/dist/output.test.js

@@ -1,9 +1,63 @@
+/**
+ * Tests for output.ts: render function format coverage.
+ */
 import { describe, it, expect, vi, afterEach } from 'vitest';
 import { render } from './output.js';
 afterEach(() => {
     vi.restoreAllMocks();
 });
 describe('render', () => {
+    it('renders JSON output', () => {
+        const log = vi.spyOn(console, 'log').mockImplementation(() => { });
+        render([{ title: 'Hello', rank: 1 }], { fmt: 'json' });
+        expect(log).toHaveBeenCalledOnce();
+        const output = log.mock.calls[0]?.[0];
+        const parsed = JSON.parse(output);
+        expect(parsed).toEqual([{ title: 'Hello', rank: 1 }]);
+    });
+    it('renders Markdown table output', () => {
+        const log = vi.spyOn(console, 'log').mockImplementation(() => { });
+        render([{ name: 'Alice', score: 100 }], { fmt: 'md', columns: ['name', 'score'] });
+        const calls = log.mock.calls.map(c => c[0]);
+        expect(calls[0]).toContain('| name | score |');
+        expect(calls[1]).toContain('| --- | --- |');
+        expect(calls[2]).toContain('| Alice | 100 |');
+    });
+    it('renders CSV output with proper quoting', () => {
+        const log = vi.spyOn(console, 'log').mockImplementation(() => { });
+        render([{ name: 'Alice, Bob', value: 'say "hi"' }], { fmt: 'csv' });
+        const calls = log.mock.calls.map(c => c[0]);
+        // Header
+        expect(calls[0]).toBe('name,value');
+        // Values with commas/quotes are quoted
+        expect(calls[1]).toContain('"Alice, Bob"');
+        expect(calls[1]).toContain('"say ""hi"""');
+    });
+    it('handles null and undefined data', () => {
+        const log = vi.spyOn(console, 'log').mockImplementation(() => { });
+        render(null, { fmt: 'json' });
+        expect(log).toHaveBeenCalledWith(null);
+    });
+    it('renders single object as single-row table', () => {
+        const log = vi.spyOn(console, 'log').mockImplementation(() => { });
+        render({ title: 'Test' }, { fmt: 'json' });
+        const output = log.mock.calls[0]?.[0];
+        const parsed = JSON.parse(output);
+        expect(parsed).toEqual({ title: 'Test' });
+    });
+    it('handles empty array gracefully', () => {
+        const log = vi.spyOn(console, 'log').mockImplementation(() => { });
+        render([], { fmt: 'table' });
+        // Should show "(no data)" for empty arrays
+        expect(log).toHaveBeenCalled();
+    });
+    it('uses custom columns for CSV', () => {
+        const log = vi.spyOn(console, 'log').mockImplementation(() => { });
+        render([{ a: 1, b: 2, c: 3 }], { fmt: 'csv', columns: ['a', 'c'] });
+        const calls = log.mock.calls.map(c => c[0]);
+        expect(calls[0]).toBe('a,c');
+        expect(calls[1]).toBe('1,3');
+    });
     it('renders YAML output', () => {
         const log = vi.spyOn(console, 'log').mockImplementation(() => { });
         render([{ title: 'Hello', rank: 1 }], { fmt: 'yaml' });
@@ -17,4 +71,10 @@ describe('render', () => {
         expect(log).toHaveBeenCalledOnce();
         expect(log.mock.calls[0]?.[0]).toContain('title: Hello');
     });
+    it('handles null values in CSV cells', () => {
+        const log = vi.spyOn(console, 'log').mockImplementation(() => { });
+        render([{ name: 'test', value: null }], { fmt: 'csv' });
+        const calls = log.mock.calls.map(c => c[0]);
+        expect(calls[1]).toBe('test,');
+    });
 });

package/dist/pipeline/executor.js

@@ -45,12 +45,6 @@ export async function executePipeline(page, pipeline, ctx = {}) {
                 if (debug)
                     process.stderr.write(`  ${chalk.yellow('⚠')}  Unknown step: ${op}\n`);
             }
-            // Detect error objects returned by steps (e.g. tap store not found)
-            if (data && typeof data === 'object' && !Array.isArray(data) && data.error) {
-                process.stderr.write(`  ${chalk.yellow('⚠')}  ${chalk.yellow(op)}: ${data.error}\n`);
-                if (data.hint)
-                    process.stderr.write(`  ${chalk.dim('💡')} ${chalk.dim(data.hint)}\n`);
-            }
             if (debug)
                 debugStepResult(op, data);
         }

package/dist/pipeline/executor.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for pipeline/executor.ts: pipeline execution with mock page.
+ */
+export {};

package/dist/pipeline/executor.test.js

@@ -0,0 +1,145 @@
+/**
+ * Tests for pipeline/executor.ts: pipeline execution with mock page.
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { executePipeline } from './index.js';
+/** Create a minimal mock page for testing */
+function createMockPage(overrides = {}) {
+    return {
+        goto: vi.fn(),
+        evaluate: vi.fn().mockResolvedValue(null),
+        snapshot: vi.fn().mockResolvedValue(''),
+        click: vi.fn(),
+        typeText: vi.fn(),
+        pressKey: vi.fn(),
+        wait: vi.fn(),
+        tabs: vi.fn().mockResolvedValue([]),
+        closeTab: vi.fn(),
+        newTab: vi.fn(),
+        selectTab: vi.fn(),
+        networkRequests: vi.fn().mockResolvedValue([]),
+        consoleMessages: vi.fn().mockResolvedValue(''),
+        scroll: vi.fn(),
+        autoScroll: vi.fn(),
+        installInterceptor: vi.fn(),
+        getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        ...overrides,
+    };
+}
+describe('executePipeline', () => {
+    it('returns null for empty pipeline', async () => {
+        const result = await executePipeline(null, []);
+        expect(result).toBeNull();
+    });
+    it('skips null/invalid steps', async () => {
+        const result = await executePipeline(null, [null, undefined, 42]);
+        expect(result).toBeNull();
+    });
+    it('executes navigate step', async () => {
+        const page = createMockPage();
+        await executePipeline(page, [
+            { navigate: 'https://example.com' },
+        ]);
+        expect(page.goto).toHaveBeenCalledWith('https://example.com');
+    });
+    it('executes evaluate + select pipeline', async () => {
+        const page = createMockPage({
+            evaluate: vi.fn().mockResolvedValue({ data: { list: [{ name: 'a' }, { name: 'b' }] } }),
+        });
+        const result = await executePipeline(page, [
+            { evaluate: '() => ({ data: { list: [{name: "a"}, {name: "b"}] } })' },
+            { select: 'data.list' },
+        ]);
+        expect(result).toEqual([{ name: 'a' }, { name: 'b' }]);
+    });
+    it('executes map step to transform items', async () => {
+        const page = createMockPage({
+            evaluate: vi.fn().mockResolvedValue([
+                { title: 'Hello', count: 10 },
+                { title: 'World', count: 20 },
+            ]),
+        });
+        const result = await executePipeline(page, [
+            { evaluate: 'test' },
+            { map: { name: '${{ item.title }}', score: '${{ item.count }}' } },
+        ]);
+        expect(result).toEqual([
+            { name: 'Hello', score: 10 },
+            { name: 'World', score: 20 },
+        ]);
+    });
+    it('executes limit step', async () => {
+        const page = createMockPage({
+            evaluate: vi.fn().mockResolvedValue([1, 2, 3, 4, 5]),
+        });
+        const result = await executePipeline(page, [
+            { evaluate: 'test' },
+            { limit: '3' },
+        ]);
+        expect(result).toEqual([1, 2, 3]);
+    });
+    it('executes sort step', async () => {
+        const page = createMockPage({
+            evaluate: vi.fn().mockResolvedValue([{ n: 3 }, { n: 1 }, { n: 2 }]),
+        });
+        const result = await executePipeline(page, [
+            { evaluate: 'test' },
+            { sort: { by: 'n', order: 'asc' } },
+        ]);
+        expect(result).toEqual([{ n: 1 }, { n: 2 }, { n: 3 }]);
+    });
+    it('executes sort step with desc order', async () => {
+        const page = createMockPage({
+            evaluate: vi.fn().mockResolvedValue([{ n: 1 }, { n: 3 }, { n: 2 }]),
+        });
+        const result = await executePipeline(page, [
+            { evaluate: 'test' },
+            { sort: { by: 'n', order: 'desc' } },
+        ]);
+        expect(result).toEqual([{ n: 3 }, { n: 2 }, { n: 1 }]);
+    });
+    it('executes wait step with number', async () => {
+        const page = createMockPage();
+        await executePipeline(page, [
+            { wait: 2 },
+        ]);
+        expect(page.wait).toHaveBeenCalledWith(2);
+    });
+    it('handles unknown steps gracefully in debug mode', async () => {
+        const stderr = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        await executePipeline(null, [
+            { unknownStep: 'test' },
+        ], { debug: true });
+        expect(stderr).toHaveBeenCalledWith(expect.stringContaining('Unknown step'));
+        stderr.mockRestore();
+    });
+    it('passes args through template rendering', async () => {
+        const page = createMockPage({
+            evaluate: vi.fn().mockResolvedValue([1, 2, 3, 4, 5]),
+        });
+        const result = await executePipeline(page, [
+            { evaluate: 'test' },
+            { limit: '${{ args.count }}' },
+        ], { args: { count: 2 } });
+        expect(result).toEqual([1, 2]);
+    });
+    it('click step calls page.click', async () => {
+        const page = createMockPage();
+        await executePipeline(page, [
+            { click: '@5' },
+        ]);
+        expect(page.click).toHaveBeenCalledWith('5');
+    });
+    it('navigate preserves existing data through pipeline', async () => {
+        const page = createMockPage({
+            evaluate: vi.fn().mockResolvedValue([{ a: 1 }]),
+        });
+        const result = await executePipeline(page, [
+            { evaluate: 'test' },
+            { navigate: 'https://example.com' },
+        ]);
+        // navigate should preserve existing data
+        expect(result).toEqual([{ a: 1 }]);
+        expect(page.goto).toHaveBeenCalledWith('https://example.com');
+    });
+});

package/dist/pipeline/steps/fetch.js

@@ -34,11 +34,12 @@ async function fetchSingle(page, url, method, queryParams, headers, args, data)
         return resp.json();
     }
     const headersJs = JSON.stringify(renderedHeaders);
-    const escapedUrl = finalUrl.replace(/"/g, '\\"');
+    const urlJs = JSON.stringify(finalUrl);
+    const methodJs = JSON.stringify(method.toUpperCase());
     return page.evaluate(`
     async () => {
-      const resp = await fetch("${escapedUrl}", {
-        method: "${method}", headers: ${headersJs}, credentials: "include"
+      const resp = await fetch(${urlJs}, {
+        method: ${methodJs}, headers: ${headersJs}, credentials: "include"
       });
       return await resp.json();
     }

package/dist/registry.d.ts

@@ -26,7 +26,7 @@ export interface CliCommand {
     browser?: boolean;
     args: Arg[];
     columns?: string[];
-    func?: (page: IPage | null, kwargs: Record<string, any>, debug?: boolean) => Promise<any>;
+    func?: (page: IPage, kwargs: Record<string, any>, debug?: boolean) => Promise<any>;
     pipeline?: any[];
     timeoutSeconds?: number;
     source?: string;
@@ -45,7 +45,7 @@ export interface CliOptions {
     browser?: boolean;
     args?: Arg[];
     columns?: string[];
-    func?: (page: IPage | null, kwargs: Record<string, any>, debug?: boolean) => Promise<any>;
+    func?: (page: IPage, kwargs: Record<string, any>, debug?: boolean) => Promise<any>;
     pipeline?: any[];
     timeoutSeconds?: number;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "publishConfig": {
     "access": "public"
   },
@@ -16,9 +16,9 @@
   "scripts": {
     "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 || true",
-    "clean-yaml": "find dist/clis -name '*.yaml' -o -name '*.yml' 2>/dev/null | xargs rm -f",
-    "copy-yaml": "find src/clis -name '*.yaml' -o -name '*.yml' | while read f; do d=\"dist/${f#src/}\"; mkdir -p \"$(dirname \"$d\")\"; cp \"$f\" \"$d\"; done",
+    "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')\"",
     "start": "node dist/main.js",
     "typecheck": "tsc --noEmit",
     "lint": "tsc --noEmit",

package/src/bilibili.ts

@@ -84,10 +84,10 @@ export async function apiGet(
 }
 
 export async function fetchJson(page: IPage, url: string): Promise<any> {
-  const escapedUrl = url.replace(/"/g, '\\"');
+  const urlJs = JSON.stringify(url);
   return page.evaluate(`
     async () => {
-      const res = await fetch("${escapedUrl}", { credentials: "include" });
+      const res = await fetch(${urlJs}, { credentials: "include" });
       return await res.json();
     }
   `);

package/src/browser.test.ts

@@ -49,23 +49,61 @@ describe('browser helpers', () => {
     expect(__test__.appendLimited('12345', '67890', 8)).toBe('34567890');
   });
 
-  it('builds Playwright MCP args with kebab-case executable path', () => {
-    expect(__test__.buildMcpArgs({
-      mcpPath: '/tmp/cli.js',
-      executablePath: '/mnt/c/Program Files/Google/Chrome/Application/chrome.exe',
-    })).toEqual([
-      '/tmp/cli.js',
-      '--extension',
-      '--executable-path',
-      '/mnt/c/Program Files/Google/Chrome/Application/chrome.exe',
-    ]);
+  it('builds extension MCP args in local mode (no CI)', () => {
+    const savedCI = process.env.CI;
+    delete process.env.CI;
+    try {
+      expect(__test__.buildMcpArgs({
+        mcpPath: '/tmp/cli.js',
+        executablePath: '/mnt/c/Program Files/Google/Chrome/Application/chrome.exe',
+      })).toEqual([
+        '/tmp/cli.js',
+        '--extension',
+        '--executable-path',
+        '/mnt/c/Program Files/Google/Chrome/Application/chrome.exe',
+      ]);
+
+      expect(__test__.buildMcpArgs({
+        mcpPath: '/tmp/cli.js',
+      })).toEqual([
+        '/tmp/cli.js',
+        '--extension',
+      ]);
+    } finally {
+      if (savedCI !== undefined) {
+        process.env.CI = savedCI;
+      } else {
+        delete process.env.CI;
+      }
+    }
+  });
 
-    expect(__test__.buildMcpArgs({
-      mcpPath: '/tmp/cli.js',
-    })).toEqual([
-      '/tmp/cli.js',
-      '--extension',
-    ]);
+  it('builds standalone MCP args in CI mode', () => {
+    const savedCI = process.env.CI;
+    process.env.CI = 'true';
+    try {
+      // CI mode: no --extension — browser launches in standalone headed mode
+      expect(__test__.buildMcpArgs({
+        mcpPath: '/tmp/cli.js',
+      })).toEqual([
+        '/tmp/cli.js',
+      ]);
+
+      expect(__test__.buildMcpArgs({
+        mcpPath: '/tmp/cli.js',
+        executablePath: '/usr/bin/chromium',
+      })).toEqual([
+        '/tmp/cli.js',
+        '--executable-path',
+        '/usr/bin/chromium',
+      ]);
+    } finally {
+      if (savedCI !== undefined) {
+        process.env.CI = savedCI;
+      } else {
+        delete process.env.CI;
+      }
+    }
   });
 
   it('times out slow promises', async () => {

package/src/browser.ts

@@ -214,7 +214,7 @@ export class Page implements IPage {
     return this.call('tools/call', { name: 'browser_console_messages', arguments: { level } });
   }
 
-  async scroll(direction: string = 'down', amount: number = 500): Promise<void> {
+  async scroll(direction: string = 'down', _amount: number = 500): Promise<void> {
     await this.call('tools/call', { name: 'browser_press_key', arguments: { key: direction === 'down' ? 'PageDown' : 'PageUp' } });
   }
 
@@ -349,6 +349,7 @@ export class PlaywrightMCP {
     return new Promise<Page>((resolve, reject) => {
       const isDebug = process.env.DEBUG?.includes('opencli:mcp');
       const debugLog = (msg: string) => isDebug && console.error(`[opencli:mcp] ${msg}`);
+      const useExtension = !!process.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN;
       const extensionToken = process.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN;
       const tokenFingerprint = getTokenFingerprint(extensionToken);
       let stderrBuffer = '';
@@ -392,7 +393,8 @@ export class PlaywrightMCP {
         executablePath: process.env.OPENCLI_BROWSER_EXECUTABLE_PATH,
       });
       if (process.env.OPENCLI_VERBOSE) {
-        console.error(`[opencli] Extension token: ${extensionToken ? `configured (fingerprint ${tokenFingerprint})` : 'missing'}`);
+        console.error(`[opencli] Mode: ${useExtension ? 'extension' : 'standalone'}`);
+        if (useExtension) console.error(`[opencli] Extension token: fingerprint ${tokenFingerprint}`);
       }
       debugLog(`Spawning node ${mcpArgs.join(' ')}`);
 
@@ -610,7 +612,13 @@ function appendLimited(current: string, chunk: string, limit: number): string {
 }
 
 function buildMcpArgs(input: { mcpPath: string; executablePath?: string | null }): string[] {
-  const args = [input.mcpPath, '--extension'];
+  const args = [input.mcpPath];
+  if (!process.env.CI) {
+    // Local: always connect to user's running Chrome via MCP Bridge extension
+    args.push('--extension');
+  }
+  // CI: standalone mode — @playwright/mcp launches its own browser (headed by default).
+  // xvfb provides a virtual display for headed mode in GitHub Actions.
   if (input.executablePath) {
     args.push('--executable-path', input.executablePath);
   }