@jackwener/opencli 0.1.0 → 0.1.2

package/dist/runtime.d.ts

@@ -1,6 +1,7 @@
 /**
  * Runtime utilities: timeouts and browser session management.
  */
+import type { IPage } from './types.js';
 export declare const DEFAULT_BROWSER_CONNECT_TIMEOUT: number;
 export declare const DEFAULT_BROWSER_COMMAND_TIMEOUT: number;
 export declare const DEFAULT_BROWSER_EXPLORE_TIMEOUT: number;
@@ -9,4 +10,4 @@ export declare function runWithTimeout<T>(promise: Promise<T>, opts: {
     timeout: number;
     label?: string;
 }): Promise<T>;
-export declare function browserSession<T>(BrowserFactory: new () => any, fn: (page: any) => Promise<T>): Promise<T>;
+export declare function browserSession<T>(BrowserFactory: new () => any, fn: (page: IPage) => Promise<T>): Promise<T>;

package/dist/synthesize.d.ts

@@ -1,10 +1,13 @@
 /**
- * Synthesize: turn explore capabilities into ready-to-use CLI definitions.
- *
- * Takes the structured capabilities from Deep Explore and generates
- * YAML pipeline files that can be directly registered as CLI commands.
- *
- * This is the bridge between discovery (explore) and usability (CLI).
+ * Synthesize candidate CLIs from explore artifacts.
+ * Generates evaluate-based YAML pipelines (matching hand-written adapter patterns).
  */
-export declare function synthesizeFromExplore(target: string, opts?: any): any;
-export declare function renderSynthesizeSummary(r: any): string;
+export declare function synthesizeFromExplore(target: string, opts?: {
+    outDir?: string;
+    top?: number;
+}): Record<string, any>;
+export declare function renderSynthesizeSummary(result: Record<string, any>): string;
+export declare function resolveExploreDir(target: string): string;
+export declare function loadExploreBundle(exploreDir: string): Record<string, any>;
+/** Backward-compatible export for scaffold.ts */
+export declare function buildCandidate(site: string, targetUrl: string, cap: any, endpoint: any): any;

package/dist/synthesize.js

@@ -1,147 +1,181 @@
 /**
- * Synthesize: turn explore capabilities into ready-to-use CLI definitions.
- *
- * Takes the structured capabilities from Deep Explore and generates
- * YAML pipeline files that can be directly registered as CLI commands.
- *
- * This is the bridge between discovery (explore) and usability (CLI).
+ * Synthesize candidate CLIs from explore artifacts.
+ * Generates evaluate-based YAML pipelines (matching hand-written adapter patterns).
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import yaml from 'js-yaml';
+/** Volatile params to strip from generated URLs */
+const VOLATILE_PARAMS = new Set(['w_rid', 'wts', 'callback', '_', 'timestamp', 't', 'nonce', 'sign']);
+const SEARCH_PARAM_NAMES = new Set(['q', 'query', 'keyword', 'search', 'wd', 'kw', 'w', 'search_query']);
+const LIMIT_PARAM_NAMES = new Set(['ps', 'page_size', 'limit', 'count', 'per_page', 'size', 'num']);
+const PAGE_PARAM_NAMES = new Set(['pn', 'page', 'page_num', 'offset', 'cursor']);
 export function synthesizeFromExplore(target, opts = {}) {
-    const exploreDir = fs.existsSync(target) ? target : path.join('.opencli', 'explore', target);
-    if (!fs.existsSync(exploreDir))
-        throw new Error(`Explore dir not found: ${target}`);
-    const manifest = JSON.parse(fs.readFileSync(path.join(exploreDir, 'manifest.json'), 'utf-8'));
-    const capabilities = JSON.parse(fs.readFileSync(path.join(exploreDir, 'capabilities.json'), 'utf-8'));
-    const endpoints = JSON.parse(fs.readFileSync(path.join(exploreDir, 'endpoints.json'), 'utf-8'));
-    const auth = JSON.parse(fs.readFileSync(path.join(exploreDir, 'auth.json'), 'utf-8'));
+    const exploreDir = resolveExploreDir(target);
+    const bundle = loadExploreBundle(exploreDir);
     const targetDir = opts.outDir ?? path.join(exploreDir, 'candidates');
     fs.mkdirSync(targetDir, { recursive: true });
-    const site = manifest.site;
-    const topN = opts.top ?? 5;
-    const candidates = [];
-    // Sort capabilities by confidence
-    const sortedCaps = [...capabilities]
+    const site = bundle.manifest.site;
+    const capabilities = (bundle.capabilities ?? [])
         .sort((a, b) => (b.confidence ?? 0) - (a.confidence ?? 0))
-        .slice(0, topN);
-    for (const cap of sortedCaps) {
-        // Find the matching endpoint for more detail
-        const endpoint = endpoints.find((ep) => ep.pattern === cap.endpoint) ??
-            endpoints[0];
-        const candidate = buildCandidateYaml(site, manifest, cap, endpoint);
-        const fileName = `${cap.name}.yaml`;
-        const filePath = path.join(targetDir, fileName);
+        .slice(0, opts.top ?? 3);
+    const candidates = [];
+    for (const cap of capabilities) {
+        const endpoint = chooseEndpoint(cap, bundle.endpoints);
+        if (!endpoint)
+            continue;
+        const candidate = buildCandidateYaml(site, bundle.manifest, cap, endpoint);
+        const filePath = path.join(targetDir, `${candidate.name}.yaml`);
         fs.writeFileSync(filePath, yaml.dump(candidate.yaml, { sortKeys: false, lineWidth: 120 }));
-        candidates.push({
-            name: cap.name,
-            path: filePath,
-            strategy: cap.strategy,
-            endpoint: cap.endpoint,
-            confidence: cap.confidence,
-            columns: candidate.yaml.columns,
-        });
+        candidates.push({ name: candidate.name, path: filePath, strategy: cap.strategy, confidence: cap.confidence });
     }
-    const index = {
-        site,
-        target_url: manifest.target_url,
-        generated_from: exploreDir,
-        candidate_count: candidates.length,
-        candidates,
-    };
+    const index = { site, target_url: bundle.manifest.target_url, generated_from: exploreDir, candidate_count: candidates.length, candidates };
     fs.writeFileSync(path.join(targetDir, 'candidates.json'), JSON.stringify(index, null, 2));
+    return { site, explore_dir: exploreDir, out_dir: targetDir, candidate_count: candidates.length, candidates };
+}
+export function renderSynthesizeSummary(result) {
+    const lines = ['opencli synthesize: OK', `Site: ${result.site}`, `Source: ${result.explore_dir}`, `Candidates: ${result.candidate_count}`];
+    for (const c of result.candidates ?? [])
+        lines.push(`  • ${c.name} (${c.strategy}, ${((c.confidence ?? 0) * 100).toFixed(0)}% confidence) → ${c.path}`);
+    return lines.join('\n');
+}
+export function resolveExploreDir(target) {
+    if (fs.existsSync(target))
+        return target;
+    const candidate = path.join('.opencli', 'explore', target);
+    if (fs.existsSync(candidate))
+        return candidate;
+    throw new Error(`Explore directory not found: ${target}`);
+}
+export function loadExploreBundle(exploreDir) {
     return {
-        site,
-        explore_dir: exploreDir,
-        out_dir: targetDir,
-        candidate_count: candidates.length,
-        candidates,
+        manifest: JSON.parse(fs.readFileSync(path.join(exploreDir, 'manifest.json'), 'utf-8')),
+        endpoints: JSON.parse(fs.readFileSync(path.join(exploreDir, 'endpoints.json'), 'utf-8')),
+        capabilities: JSON.parse(fs.readFileSync(path.join(exploreDir, 'capabilities.json'), 'utf-8')),
+        auth: JSON.parse(fs.readFileSync(path.join(exploreDir, 'auth.json'), 'utf-8')),
     };
 }
-/** Volatile params to strip from generated URLs */
-const VOLATILE_PARAMS = new Set(['w_rid', 'wts', 'callback', '_', 'timestamp', 't', 'nonce', 'sign']);
-const SEARCH_PARAM_NAMES = new Set(['q', 'query', 'keyword', 'search', 'wd', 'kw', 'w', 'search_query']);
-const LIMIT_PARAM_NAMES = new Set(['ps', 'page_size', 'limit', 'count', 'per_page', 'size', 'num']);
-const PAGE_PARAM_NAMES = new Set(['pn', 'page', 'page_num', 'offset', 'cursor']);
-/**
- * Build a clean templated URL from a raw API URL.
- * - Strips volatile params (w_rid, wts, etc.)
- * - Templates search, limit, and pagination params
- * - Builds URL string manually to avoid URL encoding of ${{ }} expressions
- */
-function buildTemplatedUrl(rawUrl, cap, endpoint) {
+function chooseEndpoint(cap, endpoints) {
+    if (!endpoints.length)
+        return null;
+    // Match by endpoint pattern from capability
+    if (cap.endpoint) {
+        const match = endpoints.find((e) => e.pattern === cap.endpoint || e.url?.includes(cap.endpoint));
+        if (match)
+            return match;
+    }
+    return endpoints.sort((a, b) => (b.score ?? 0) - (a.score ?? 0))[0];
+}
+// ── URL templating ─────────────────────────────────────────────────────────
+function buildTemplatedUrl(rawUrl, cap, _endpoint) {
     try {
         const u = new URL(rawUrl);
         const base = `${u.protocol}//${u.host}${u.pathname}`;
         const params = [];
         const hasKeyword = cap.recommendedArgs?.some((a) => a.name === 'keyword');
         u.searchParams.forEach((v, k) => {
-            // Skip volatile params
             if (VOLATILE_PARAMS.has(k))
                 return;
-            // Template known param types
-            if (hasKeyword && SEARCH_PARAM_NAMES.has(k)) {
+            if (hasKeyword && SEARCH_PARAM_NAMES.has(k))
                 params.push([k, '${{ args.keyword }}']);
-            }
-            else if (LIMIT_PARAM_NAMES.has(k)) {
+            else if (LIMIT_PARAM_NAMES.has(k))
                 params.push([k, '${{ args.limit | default(20) }}']);
-            }
-            else if (PAGE_PARAM_NAMES.has(k)) {
+            else if (PAGE_PARAM_NAMES.has(k))
                 params.push([k, '${{ args.page | default(1) }}']);
-            }
-            else {
+            else
                 params.push([k, v]);
-            }
         });
-        if (params.length === 0)
-            return base;
-        return base + '?' + params.map(([k, v]) => `${k}=${v}`).join('&');
+        return params.length ? base + '?' + params.map(([k, v]) => `${k}=${v}`).join('&') : base;
     }
     catch {
         return rawUrl;
     }
 }
 /**
- * Build a YAML pipeline definition from a capability + endpoint.
+ * Build inline evaluate script for browser-based fetch+parse.
+ * Follows patterns from bilibili/hot.yaml and twitter/trending.yaml.
  */
+function buildEvaluateScript(url, itemPath, endpoint) {
+    const pathChain = itemPath.split('.').map((p) => `?.${p}`).join('');
+    const detectedFields = endpoint?.detectedFields ?? {};
+    const hasFields = Object.keys(detectedFields).length > 0;
+    let mapCode = '';
+    if (hasFields) {
+        const mappings = Object.entries(detectedFields)
+            .map(([role, field]) => `      ${role}: item${String(field).split('.').map(p => `?.${p}`).join('')}`)
+            .join(',\n');
+        mapCode = `.map((item) => ({\n${mappings}\n    }))`;
+    }
+    return [
+        '(async () => {',
+        `  const res = await fetch('${url}', {`,
+        `    credentials: 'include'`,
+        '  });',
+        '  const data = await res.json();',
+        `  return (data${pathChain} || [])${mapCode};`,
+        '})()\n',
+    ].join('\n');
+}
+// ── YAML pipeline generation ───────────────────────────────────────────────
 function buildCandidateYaml(site, manifest, cap, endpoint) {
     const needsBrowser = cap.strategy !== 'public';
     const pipeline = [];
-    // Step 1: Navigate (if browser-based)
-    if (needsBrowser) {
+    const templatedUrl = buildTemplatedUrl(endpoint?.url ?? manifest.target_url, cap, endpoint);
+    let domain = '';
+    try {
+        domain = new URL(manifest.target_url).hostname;
+    }
+    catch { }
+    if (cap.strategy === 'store-action' && cap.storeHint) {
+        // Store Action: navigate + wait + tap (declarative, clean)
         pipeline.push({ navigate: manifest.target_url });
+        pipeline.push({ wait: 3 });
+        const tapStep = {
+            store: cap.storeHint.store,
+            action: cap.storeHint.action,
+            timeout: 8,
+        };
+        // Infer capture pattern from endpoint URL
+        if (endpoint?.url) {
+            try {
+                const epUrl = new URL(endpoint.url);
+                const pathParts = epUrl.pathname.split('/').filter((p) => p);
+                // Use last meaningful path segment as capture pattern
+                const capturePart = pathParts.filter((p) => !p.match(/^v\d+$/)).pop();
+                if (capturePart)
+                    tapStep.capture = capturePart;
+            }
+            catch { }
+        }
+        if (cap.itemPath)
+            tapStep.select = cap.itemPath;
+        pipeline.push({ tap: tapStep });
+    }
+    else if (needsBrowser) {
+        // Browser-based: navigate + evaluate (like bilibili/hot.yaml, twitter/trending.yaml)
+        pipeline.push({ navigate: manifest.target_url });
+        const itemPath = cap.itemPath ?? 'data.data.list';
+        pipeline.push({ evaluate: buildEvaluateScript(templatedUrl, itemPath, endpoint) });
     }
-    // Step 2: Fetch the API — build a clean URL with templates
-    const rawUrl = endpoint?.url ?? manifest.target_url;
-    const fetchStep = { url: buildTemplatedUrl(rawUrl, cap, endpoint) };
-    pipeline.push({ fetch: fetchStep });
-    // Step 3: Select the item path
-    if (cap.itemPath) {
-        pipeline.push({ select: cap.itemPath });
+    else {
+        // Public API: direct fetch (like hackernews/top.yaml)
+        pipeline.push({ fetch: { url: templatedUrl } });
+        if (cap.itemPath)
+            pipeline.push({ select: cap.itemPath });
     }
-    // Step 4: Map fields to columns
+    // Map fields
     const mapStep = {};
     const columns = cap.recommendedColumns ?? ['title', 'url'];
-    // Add a rank column if not doing search
-    if (!cap.recommendedArgs?.some((a) => a.name === 'keyword')) {
+    if (!cap.recommendedArgs?.some((a) => a.name === 'keyword'))
         mapStep['rank'] = '${{ index + 1 }}';
-    }
-    // Build field mappings from the endpoint's detected fields
     const detectedFields = endpoint?.detectedFields ?? {};
     for (const col of columns) {
         const fieldPath = detectedFields[col];
-        if (fieldPath) {
-            mapStep[col] = `\${{ item.${fieldPath} }}`;
-        }
-        else {
-            mapStep[col] = `\${{ item.${col} }}`;
-        }
+        mapStep[col] = fieldPath ? `\${{ item.${fieldPath} }}` : `\${{ item.${col} }}`;
     }
     pipeline.push({ map: mapStep });
-    // Step 5: Limit
     pipeline.push({ limit: '${{ args.limit | default(20) }}' });
-    // Build args definition
+    // Args
     const argsDef = {};
     for (const arg of cap.recommendedArgs ?? []) {
         const def = { type: arg.type ?? 'str' };
@@ -157,35 +191,25 @@ function buildCandidateYaml(site, manifest, cap, endpoint) {
             def.description = 'Page number';
         argsDef[arg.name] = def;
     }
-    // Ensure limit arg always exists
-    if (!argsDef['limit']) {
+    if (!argsDef['limit'])
         argsDef['limit'] = { type: 'int', default: 20, description: 'Number of items to return' };
-    }
-    const allColumns = Object.keys(mapStep);
     return {
         name: cap.name,
         yaml: {
-            site,
-            name: cap.name,
-            description: `${site} ${cap.name} (auto-generated)`,
-            domain: manifest.final_url ? new URL(manifest.final_url).hostname : undefined,
-            strategy: cap.strategy,
-            browser: needsBrowser,
-            args: argsDef,
-            pipeline,
-            columns: allColumns,
+            site, name: cap.name, description: `${cap.description || site + ' ' + cap.name} (auto-generated)`,
+            domain, strategy: cap.strategy, browser: needsBrowser,
+            args: argsDef, pipeline, columns: Object.keys(mapStep),
         },
     };
 }
-export function renderSynthesizeSummary(r) {
-    const lines = [
-        'opencli synthesize: OK',
-        `Site: ${r.site}`,
-        `Source: ${r.explore_dir}`,
-        `Candidates: ${r.candidate_count}`,
-    ];
-    for (const c of r.candidates ?? []) {
-        lines.push(`  • ${c.name} (${c.strategy}, ${(c.confidence * 100).toFixed(0)}% confidence) → ${c.path}`);
-    }
-    return lines.join('\n');
+/** Backward-compatible export for scaffold.ts */
+export function buildCandidate(site, targetUrl, cap, endpoint) {
+    // Map old-style field names to new ones
+    const normalizedCap = {
+        ...cap,
+        recommendedArgs: cap.recommendedArgs ?? cap.recommended_args,
+        recommendedColumns: cap.recommendedColumns ?? cap.recommended_columns,
+    };
+    const manifest = { target_url: targetUrl, final_url: targetUrl };
+    return buildCandidateYaml(site, manifest, normalizedCap, endpoint);
 }

package/dist/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Page interface: type-safe abstraction over Playwright MCP browser page.
+ *
+ * All pipeline steps and CLI adapters should use this interface
+ * instead of `any` for browser interactions.
+ */
+export interface IPage {
+    goto(url: string): Promise<void>;
+    evaluate(js: string): Promise<any>;
+    snapshot(opts?: {
+        interactive?: boolean;
+        compact?: boolean;
+        maxDepth?: number;
+        raw?: boolean;
+    }): Promise<any>;
+    click(ref: string): Promise<void>;
+    typeText(ref: string, text: string): Promise<void>;
+    pressKey(key: string): Promise<void>;
+    wait(seconds: number): Promise<void>;
+    tabs(): Promise<any>;
+    closeTab(index?: number): Promise<void>;
+    newTab(): Promise<void>;
+    selectTab(index: number): Promise<void>;
+    networkRequests(includeStatic?: boolean): Promise<any>;
+    consoleMessages(level?: string): Promise<any>;
+    scroll(direction?: string, amount?: number): Promise<void>;
+}

package/dist/types.js

@@ -0,0 +1,7 @@
+/**
+ * Page interface: type-safe abstraction over Playwright MCP browser page.
+ *
+ * All pipeline steps and CLI adapters should use this interface
+ * instead of `any` for browser interactions.
+ */
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "publishConfig": {
     "access": "public"
   },
@@ -12,11 +12,15 @@
   },
   "scripts": {
     "dev": "tsx src/main.ts",
-    "build": "tsc",
+    "build": "tsc && npm run clean-yaml && npm run copy-yaml",
+    "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",
     "start": "node dist/main.js",
     "typecheck": "tsc --noEmit",
     "lint": "tsc --noEmit",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "keywords": [
     "cli",
@@ -42,6 +46,7 @@
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.13.10",
     "tsx": "^4.19.3",
-    "typescript": "^5.8.2"
+    "typescript": "^5.8.2",
+    "vitest": "^4.1.0"
   }
 }

package/src/bilibili.ts

@@ -2,6 +2,8 @@
  * Bilibili shared helpers: WBI signing, authenticated fetch, nav data, UID resolution.
  */
 
+import type { IPage } from './types.js';
+
 const MIXIN_KEY_ENC_TAB = [
   46,47,18,2,53,8,23,32,15,50,10,31,58,3,45,35,27,43,5,49,
   33,9,42,19,29,28,14,39,12,38,41,13,37,48,7,16,24,55,40,
@@ -17,7 +19,7 @@ export function payloadData(payload: any): any {
   return payload?.data ?? payload;
 }
 
-async function getNavData(page: any): Promise<any> {
+async function getNavData(page: IPage): Promise<any> {
   return page.evaluate(`
     async () => {
       const res = await fetch('https://api.bilibili.com/x/web-interface/nav', { credentials: 'include' });
@@ -26,7 +28,7 @@ async function getNavData(page: any): Promise<any> {
   `);
 }
 
-async function getWbiKeys(page: any): Promise<{ imgKey: string; subKey: string }> {
+async function getWbiKeys(page: IPage): Promise<{ imgKey: string; subKey: string }> {
   const nav = await getNavData(page);
   const wbiImg = nav?.data?.wbi_img ?? {};
   const imgUrl = wbiImg.img_url ?? '';
@@ -47,7 +49,7 @@ async function md5(text: string): Promise<string> {
 }
 
 export async function wbiSign(
-  page: any,
+  page: IPage,
   params: Record<string, any>,
 ): Promise<Record<string, string>> {
   const { imgKey, subKey } = await getWbiKeys(page);
@@ -65,7 +67,7 @@ export async function wbiSign(
 }
 
 export async function apiGet(
-  page: any,
+  page: IPage,
   path: string,
   opts: { params?: Record<string, any>; signed?: boolean } = {},
 ): Promise<any> {
@@ -81,7 +83,7 @@ export async function apiGet(
   return fetchJson(page, url);
 }
 
-export async function fetchJson(page: any, url: string): Promise<any> {
+export async function fetchJson(page: IPage, url: string): Promise<any> {
   const escapedUrl = url.replace(/"/g, '\\"');
   return page.evaluate(`
     async () => {
@@ -91,14 +93,14 @@ export async function fetchJson(page: any, url: string): Promise<any> {
   `);
 }
 
-export async function getSelfUid(page: any): Promise<string> {
+export async function getSelfUid(page: IPage): Promise<string> {
   const nav = await getNavData(page);
   const mid = nav?.data?.mid;
   if (!mid) throw new Error('Not logged in to Bilibili');
   return String(mid);
 }
 
-export async function resolveUid(page: any, input: string): Promise<string> {
+export async function resolveUid(page: IPage, input: string): Promise<string> {
   if (/^\d+$/.test(input)) return input;
   // Search for user by name
   const payload = await apiGet(page, '/x/web-interface/wbi/search/type', {

package/src/browser.ts

@@ -10,6 +10,10 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { formatSnapshot } from './snapshotFormatter.js';
 
+// Read version from package.json (single source of truth)
+const __browser_dirname = path.dirname(fileURLToPath(import.meta.url));
+const PKG_VERSION = (() => { try { return JSON.parse(fs.readFileSync(path.resolve(__browser_dirname, '..', 'package.json'), 'utf-8')).version; } catch { return '0.0.0'; } })();
+
 const EXTENSION_LOCK_TIMEOUT = parseInt(process.env.OPENCLI_EXTENSION_LOCK_TIMEOUT ?? '120', 10);
 const EXTENSION_LOCK_POLL = parseInt(process.env.OPENCLI_EXTENSION_LOCK_POLL_INTERVAL ?? '1', 10);
 const CONNECT_TIMEOUT = parseInt(process.env.OPENCLI_BROWSER_CONNECT_TIMEOUT ?? '30', 10);
@@ -21,10 +25,12 @@ function jsonRpcRequest(method: string, params: Record<string, any> = {}): strin
   return JSON.stringify({ jsonrpc: '2.0', id: _nextId++, method, params }) + '\n';
 }
 
+import type { IPage } from './types.js';
+
 /**
  * Page abstraction wrapping JSON-RPC calls to Playwright MCP.
  */
-export class Page {
+export class Page implements IPage {
   constructor(private _send: (msg: string) => void, private _recv: () => Promise<any>) {}
 
   async call(method: string, params: Record<string, any> = {}): Promise<any> {
@@ -36,7 +42,18 @@ export class Page {
     if (result?.content) {
       const textParts = result.content.filter((c: any) => c.type === 'text');
       if (textParts.length === 1) {
-        const text = textParts[0].text;
+        let text = textParts[0].text;
+        // MCP browser_evaluate returns: "[JSON]\n### Ran Playwright code\n```js\n...\n```"
+        // Strip the "### Ran Playwright code" suffix to get clean JSON
+        const codeMarker = text.indexOf('### Ran Playwright code');
+        if (codeMarker !== -1) {
+          text = text.slice(0, codeMarker).trim();
+        }
+        // Also handle "### Result\n[JSON]" format (some MCP versions)
+        const resultMarker = text.indexOf('### Result\n');
+        if (resultMarker !== -1) {
+          text = text.slice(resultMarker + '### Result\n'.length).trim();
+        }
         try { return JSON.parse(text); } catch { return text; }
       }
     }
@@ -115,6 +132,8 @@ export class PlaywrightMCP {
   private _lockAcquired = false;
   private _initialTabCount = 0;
 
+  private _page: Page | null = null;
+
   async connect(opts: { timeout?: number } = {}): Promise<Page> {
     await this._acquireLock();
     const timeout = opts.timeout ?? CONNECT_TIMEOUT;
@@ -137,6 +156,7 @@ export class PlaywrightMCP {
         (msg) => { if (this._proc?.stdin?.writable) this._proc.stdin.write(msg); },
         () => new Promise<any>((res) => { this._waiters.push(res); }),
       );
+      this._page = page;
 
       this._proc.stdout?.on('data', (chunk: Buffer) => {
         this._buffer += chunk.toString();
@@ -159,7 +179,7 @@ export class PlaywrightMCP {
       const initMsg = jsonRpcRequest('initialize', {
         protocolVersion: '2024-11-05',
         capabilities: {},
-        clientInfo: { name: 'opencli', version: '0.1.0' },
+        clientInfo: { name: 'opencli', version: PKG_VERSION },
       });
       this._proc.stdin?.write(initMsg);
 
@@ -185,11 +205,29 @@ export class PlaywrightMCP {
 
   async close(): Promise<void> {
     try {
+      // Close tabs opened during this session (site tabs + extension tabs)
+      if (this._page && this._proc && !this._proc.killed) {
+        try {
+          const tabs = await this._page.tabs();
+          const tabStr = typeof tabs === 'string' ? tabs : JSON.stringify(tabs);
+          const allTabs = tabStr.match(/Tab (\d+)/g) || [];
+          const currentTabCount = allTabs.length;
+
+          // Close tabs in reverse order to avoid index shifting issues
+          // Keep the original tabs that existed before the command started
+          if (currentTabCount > this._initialTabCount && this._initialTabCount > 0) {
+            for (let i = currentTabCount - 1; i >= this._initialTabCount; i--) {
+              try { await this._page.closeTab(i); } catch {}
+            }
+          }
+        } catch {}
+      }
       if (this._proc && !this._proc.killed) {
         this._proc.kill('SIGTERM');
         await new Promise<void>((res) => { this._proc?.on('exit', () => res()); setTimeout(res, 3000); });
       }
     } finally {
+      this._page = null;
       this._releaseLock();
     }
   }