@jackwener/opencli 1.0.0 → 1.0.1

package/dist/daemon.js

@@ -95,8 +95,8 @@ async function handleRequest(req, res) {
             const result = await new Promise((resolve, reject) => {
                 const timer = setTimeout(() => {
                     pending.delete(body.id);
-                    reject(new Error('Command timeout (30s)'));
-                }, 30000);
+                    reject(new Error('Command timeout (120s)'));
+                }, 120000);
                 pending.set(body.id, { resolve, reject, timer });
                 extensionWs.send(JSON.stringify(body));
             });

package/dist/doctor.d.ts

@@ -30,24 +30,3 @@ export declare function checkConnectivity(opts?: {
 }): Promise<ConnectivityResult>;
 export declare function runBrowserDoctor(opts?: DoctorOptions): Promise<DoctorReport>;
 export declare function renderBrowserDoctorReport(report: DoctorReport): string;
-export declare const PLAYWRIGHT_TOKEN_ENV = "PLAYWRIGHT_MCP_EXTENSION_TOKEN";
-export declare function discoverExtensionToken(): string | null;
-export declare function checkExtensionInstalled(): {
-    installed: boolean;
-    browsers: string[];
-};
-export declare function applyBrowserDoctorFix(): Promise<string[]>;
-export declare function getDefaultShellRcPath(): string;
-export declare function getDefaultMcpConfigPaths(): string[];
-export declare function readTokenFromShellContent(_content: string): string | null;
-export declare function upsertShellToken(content: string): string;
-export declare function upsertJsonConfigToken(content: string): string;
-export declare function readTomlConfigToken(_content: string): string | null;
-export declare function upsertTomlConfigToken(content: string): string;
-export declare function shortenPath(p: string): string;
-export declare function toolName(_p: string): string;
-export declare function fileExists(filePath: string): boolean;
-export declare function writeFileWithMkdir(_p: string, _c: string): void;
-export declare function checkTokenConnectivity(opts?: {
-    timeout?: number;
-}): Promise<ConnectivityResult>;

package/dist/doctor.js

@@ -6,14 +6,14 @@
  */
 import chalk from 'chalk';
 import { checkDaemonStatus } from './browser/discover.js';
-import { PlaywrightMCP } from './browser/index.js';
+import { BrowserBridge } from './browser/index.js';
 /**
  * Test connectivity by attempting a real browser command.
  */
 export async function checkConnectivity(opts) {
     const start = Date.now();
     try {
-        const mcp = new PlaywrightMCP();
+        const mcp = new BrowserBridge();
         const page = await mcp.connect({ timeout: opts?.timeout ?? 8 });
         // Try a simple eval to verify end-to-end connectivity
         await page.evaluate('1 + 1');
@@ -82,25 +82,3 @@ export function renderBrowserDoctorReport(report) {
     }
     return lines.join('\n');
 }
-// Backward compatibility exports (no-ops for things that no longer exist)
-export const PLAYWRIGHT_TOKEN_ENV = 'PLAYWRIGHT_MCP_EXTENSION_TOKEN';
-export function discoverExtensionToken() { return null; }
-export function checkExtensionInstalled() { return { installed: false, browsers: [] }; }
-export function applyBrowserDoctorFix() { return Promise.resolve([]); }
-export function getDefaultShellRcPath() { return ''; }
-export function getDefaultMcpConfigPaths() { return []; }
-export function readTokenFromShellContent(_content) { return null; }
-export function upsertShellToken(content) { return content; }
-export function upsertJsonConfigToken(content) { return content; }
-export function readTomlConfigToken(_content) { return null; }
-export function upsertTomlConfigToken(content) { return content; }
-export function shortenPath(p) { return p; }
-export function toolName(_p) { return ''; }
-export function fileExists(filePath) { try {
-    return require('node:fs').existsSync(filePath);
-}
-catch {
-    return false;
-} }
-export function writeFileWithMkdir(_p, _c) { }
-export async function checkTokenConnectivity(opts) { return checkConnectivity(opts); }

package/dist/main.js

@@ -8,9 +8,9 @@ import { fileURLToPath } from 'node:url';
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { discoverClis, executeCommand } from './engine.js';
-import { Strategy, fullName, getRegistry, strategyLabel } from './registry.js';
+import { fullName, getRegistry, strategyLabel } from './registry.js';
 import { render as renderOutput } from './output.js';
-import { PlaywrightMCP } from './browser/index.js';
+import { BrowserBridge } from './browser/index.js';
 import { browserSession, DEFAULT_BROWSER_COMMAND_TIMEOUT, runWithTimeout } from './runtime.js';
 import { PKG_VERSION } from './version.js';
 import { getCompletions, printCompletionScript } from './completion.js';
@@ -101,15 +101,15 @@ program.command('verify').description('Validate + smoke test').argument('[target
     process.exitCode = r.ok ? 0 : 1;
 });
 program.command('explore').alias('probe').description('Explore a website: discover APIs, stores, and recommend strategies').argument('<url>').option('--site <name>').option('--goal <text>').option('--wait <s>', '', '3').option('--auto', 'Enable interactive fuzzing (simulate clicks to trigger lazy APIs)').option('--click <labels>', 'Comma-separated labels to click before fuzzing (e.g. "字幕,CC,评论")')
-    .action(async (url, opts) => { const { exploreUrl, renderExploreSummary } = await import('./explore.js'); const clickLabels = opts.click ? opts.click.split(',').map((s) => s.trim()) : undefined; console.log(renderExploreSummary(await exploreUrl(url, { BrowserFactory: PlaywrightMCP, site: opts.site, goal: opts.goal, waitSeconds: parseFloat(opts.wait), auto: opts.auto, clickLabels }))); });
+    .action(async (url, opts) => { const { exploreUrl, renderExploreSummary } = await import('./explore.js'); const clickLabels = opts.click ? opts.click.split(',').map((s) => s.trim()) : undefined; console.log(renderExploreSummary(await exploreUrl(url, { BrowserFactory: BrowserBridge, site: opts.site, goal: opts.goal, waitSeconds: parseFloat(opts.wait), auto: opts.auto, clickLabels }))); });
 program.command('synthesize').description('Synthesize CLIs from explore').argument('<target>').option('--top <n>', '', '3')
     .action(async (target, opts) => { const { synthesizeFromExplore, renderSynthesizeSummary } = await import('./synthesize.js'); console.log(renderSynthesizeSummary(synthesizeFromExplore(target, { top: parseInt(opts.top) }))); });
 program.command('generate').description('One-shot: explore → synthesize → register').argument('<url>').option('--goal <text>').option('--site <name>')
-    .action(async (url, opts) => { const { generateCliFromUrl, renderGenerateSummary } = await import('./generate.js'); const r = await generateCliFromUrl({ url, BrowserFactory: PlaywrightMCP, builtinClis: BUILTIN_CLIS, userClis: USER_CLIS, goal: opts.goal, site: opts.site }); console.log(renderGenerateSummary(r)); process.exitCode = r.ok ? 0 : 1; });
+    .action(async (url, opts) => { const { generateCliFromUrl, renderGenerateSummary } = await import('./generate.js'); const r = await generateCliFromUrl({ url, BrowserFactory: BrowserBridge, builtinClis: BUILTIN_CLIS, userClis: USER_CLIS, goal: opts.goal, site: opts.site }); console.log(renderGenerateSummary(r)); process.exitCode = r.ok ? 0 : 1; });
 program.command('cascade').description('Strategy cascade: find simplest working strategy').argument('<url>').option('--site <name>')
     .action(async (url, opts) => {
     const { cascadeProbe, renderCascadeResult } = await import('./cascade.js');
-    const result = await browserSession(PlaywrightMCP, async (page) => {
+    const result = await browserSession(BrowserBridge, async (page) => {
         // Navigate to the site first for cookie context
         try {
             const siteUrl = new URL(url);
@@ -196,17 +196,7 @@ for (const [, cmd] of registry) {
                 process.env.OPENCLI_VERBOSE = '1';
             let result;
             if (cmd.browser) {
-                result = await browserSession(PlaywrightMCP, async (page) => {
-                    // Cookie/header strategies require same-origin context for credentialed fetch.
-                    // In CDP mode the active tab may be on an unrelated domain, causing CORS failures.
-                    // Navigate to the command's domain first (mirrors cascade command behavior).
-                    if ((cmd.strategy === Strategy.COOKIE || cmd.strategy === Strategy.HEADER) && cmd.domain) {
-                        try {
-                            await page.goto(`https://${cmd.domain}`);
-                            await page.wait(2);
-                        }
-                        catch { }
-                    }
+                result = await browserSession(BrowserBridge, async (page) => {
                     return runWithTimeout(executeCommand(cmd, page, kwargs, actionOpts.verbose), { timeout: cmd.timeoutSeconds ?? DEFAULT_BROWSER_COMMAND_TIMEOUT, label: fullName(cmd) });
                 });
             }

package/dist/runtime.d.ts

@@ -1,6 +1,3 @@
-/**
- * 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;
@@ -17,7 +14,7 @@ export declare function runWithTimeout<T>(promise: Promise<T>, opts: {
  * Timeout with milliseconds unit. Used for low-level internal timeouts.
  */
 export declare function withTimeoutMs<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T>;
-/** Interface for browser factory (PlaywrightMCP or test mocks) */
+/** Interface for browser factory (BrowserBridge or test mocks) */
 export interface IBrowserFactory {
     connect(opts?: {
         timeout?: number;

package/dist/runtime.js

@@ -1,8 +1,5 @@
-/**
- * Runtime utilities: timeouts and browser session management.
- */
 export const DEFAULT_BROWSER_CONNECT_TIMEOUT = parseInt(process.env.OPENCLI_BROWSER_CONNECT_TIMEOUT ?? '30', 10);
-export const DEFAULT_BROWSER_COMMAND_TIMEOUT = parseInt(process.env.OPENCLI_BROWSER_COMMAND_TIMEOUT ?? '45', 10);
+export const DEFAULT_BROWSER_COMMAND_TIMEOUT = parseInt(process.env.OPENCLI_BROWSER_COMMAND_TIMEOUT ?? '60', 10);
 export const DEFAULT_BROWSER_EXPLORE_TIMEOUT = parseInt(process.env.OPENCLI_BROWSER_EXPLORE_TIMEOUT ?? '120', 10);
 export const DEFAULT_BROWSER_SMOKE_TIMEOUT = parseInt(process.env.OPENCLI_BROWSER_SMOKE_TIMEOUT ?? '60', 10);
 /**

package/dist/setup.js

@@ -7,7 +7,7 @@
 import chalk from 'chalk';
 import { checkDaemonStatus } from './browser/discover.js';
 import { checkConnectivity } from './doctor.js';
-import { PlaywrightMCP } from './browser/index.js';
+import { BrowserBridge } from './browser/index.js';
 export async function runSetup(opts = {}) {
     console.log();
     console.log(chalk.bold('  opencli setup') + chalk.dim(' — browser bridge configuration'));
@@ -23,7 +23,7 @@ export async function runSetup(opts = {}) {
         console.log(chalk.dim('    The daemon starts automatically when you run a browser command.'));
         console.log(chalk.dim('    Starting daemon now...'));
         // Try to spawn daemon
-        const mcp = new PlaywrightMCP();
+        const mcp = new BrowserBridge();
         try {
             await mcp.connect({ timeout: 5 });
             await mcp.close();

package/extension/dist/background.js

@@ -0,0 +1,484 @@
+//#region src/protocol.ts
+/** Default daemon port */
+var DAEMON_PORT = 19825;
+var DAEMON_HOST = "localhost";
+var DAEMON_WS_URL = `ws://${DAEMON_HOST}:${DAEMON_PORT}/ext`;
+`${DAEMON_HOST}${DAEMON_PORT}`;
+/** Base reconnect delay for extension WebSocket (ms) */
+var WS_RECONNECT_BASE_DELAY = 2e3;
+/** Max reconnect delay (ms) */
+var WS_RECONNECT_MAX_DELAY = 6e4;
+//#endregion
+//#region src/cdp.ts
+/**
+* CDP execution via chrome.debugger API.
+*
+* chrome.debugger only needs the "debugger" permission — no host_permissions.
+* It can attach to any http/https tab. Avoid chrome:// and chrome-extension://
+* tabs (resolveTabId in background.ts filters them).
+*/
+var attached = /* @__PURE__ */ new Set();
+async function ensureAttached(tabId) {
+	if (attached.has(tabId)) return;
+	try {
+		await chrome.debugger.attach({ tabId }, "1.3");
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		if (msg.includes("Another debugger is already attached")) {
+			try {
+				await chrome.debugger.detach({ tabId });
+			} catch {}
+			try {
+				await chrome.debugger.attach({ tabId }, "1.3");
+			} catch {
+				throw new Error(`attach failed: ${msg}`);
+			}
+		} else throw new Error(`attach failed: ${msg}`);
+	}
+	attached.add(tabId);
+	try {
+		await chrome.debugger.sendCommand({ tabId }, "Runtime.enable");
+	} catch {}
+}
+async function evaluate(tabId, expression) {
+	await ensureAttached(tabId);
+	const result = await chrome.debugger.sendCommand({ tabId }, "Runtime.evaluate", {
+		expression,
+		returnByValue: true,
+		awaitPromise: true
+	});
+	if (result.exceptionDetails) {
+		const errMsg = result.exceptionDetails.exception?.description || result.exceptionDetails.text || "Eval error";
+		throw new Error(errMsg);
+	}
+	return result.result?.value;
+}
+var evaluateAsync = evaluate;
+/**
+* Capture a screenshot via CDP Page.captureScreenshot.
+* Returns base64-encoded image data.
+*/
+async function screenshot(tabId, options = {}) {
+	await ensureAttached(tabId);
+	const format = options.format ?? "png";
+	if (options.fullPage) {
+		const metrics = await chrome.debugger.sendCommand({ tabId }, "Page.getLayoutMetrics");
+		const size = metrics.cssContentSize || metrics.contentSize;
+		if (size) await chrome.debugger.sendCommand({ tabId }, "Emulation.setDeviceMetricsOverride", {
+			mobile: false,
+			width: Math.ceil(size.width),
+			height: Math.ceil(size.height),
+			deviceScaleFactor: 1
+		});
+	}
+	try {
+		const params = { format };
+		if (format === "jpeg" && options.quality !== void 0) params.quality = Math.max(0, Math.min(100, options.quality));
+		return (await chrome.debugger.sendCommand({ tabId }, "Page.captureScreenshot", params)).data;
+	} finally {
+		if (options.fullPage) await chrome.debugger.sendCommand({ tabId }, "Emulation.clearDeviceMetricsOverride").catch(() => {});
+	}
+}
+function detach(tabId) {
+	if (!attached.has(tabId)) return;
+	attached.delete(tabId);
+	try {
+		chrome.debugger.detach({ tabId });
+	} catch {}
+}
+function registerListeners() {
+	chrome.tabs.onRemoved.addListener((tabId) => {
+		attached.delete(tabId);
+	});
+	chrome.debugger.onDetach.addListener((source) => {
+		if (source.tabId) attached.delete(source.tabId);
+	});
+}
+//#endregion
+//#region src/background.ts
+var ws = null;
+var reconnectTimer = null;
+var reconnectAttempts = 0;
+var _origLog = console.log.bind(console);
+var _origWarn = console.warn.bind(console);
+var _origError = console.error.bind(console);
+function forwardLog(level, args) {
+	if (!ws || ws.readyState !== WebSocket.OPEN) return;
+	try {
+		const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+		ws.send(JSON.stringify({
+			type: "log",
+			level,
+			msg,
+			ts: Date.now()
+		}));
+	} catch {}
+}
+console.log = (...args) => {
+	_origLog(...args);
+	forwardLog("info", args);
+};
+console.warn = (...args) => {
+	_origWarn(...args);
+	forwardLog("warn", args);
+};
+console.error = (...args) => {
+	_origError(...args);
+	forwardLog("error", args);
+};
+function connect() {
+	if (ws?.readyState === WebSocket.OPEN || ws?.readyState === WebSocket.CONNECTING) return;
+	try {
+		ws = new WebSocket(DAEMON_WS_URL);
+	} catch {
+		scheduleReconnect();
+		return;
+	}
+	ws.onopen = () => {
+		console.log("[opencli] Connected to daemon");
+		reconnectAttempts = 0;
+		if (reconnectTimer) {
+			clearTimeout(reconnectTimer);
+			reconnectTimer = null;
+		}
+	};
+	ws.onmessage = async (event) => {
+		try {
+			const result = await handleCommand(JSON.parse(event.data));
+			ws?.send(JSON.stringify(result));
+		} catch (err) {
+			console.error("[opencli] Message handling error:", err);
+		}
+	};
+	ws.onclose = () => {
+		console.log("[opencli] Disconnected from daemon");
+		ws = null;
+		scheduleReconnect();
+	};
+	ws.onerror = () => {
+		ws?.close();
+	};
+}
+function scheduleReconnect() {
+	if (reconnectTimer) return;
+	reconnectAttempts++;
+	const delay = Math.min(WS_RECONNECT_BASE_DELAY * Math.pow(2, reconnectAttempts - 1), WS_RECONNECT_MAX_DELAY);
+	reconnectTimer = setTimeout(() => {
+		reconnectTimer = null;
+		connect();
+	}, delay);
+}
+var automationWindowId = null;
+var windowIdleTimer = null;
+var WINDOW_IDLE_TIMEOUT = 3e4;
+function resetWindowIdleTimer() {
+	if (windowIdleTimer) clearTimeout(windowIdleTimer);
+	windowIdleTimer = setTimeout(async () => {
+		if (automationWindowId !== null) {
+			try {
+				await chrome.windows.remove(automationWindowId);
+				console.log(`[opencli] Automation window ${automationWindowId} closed (idle timeout)`);
+			} catch {}
+			automationWindowId = null;
+		}
+		windowIdleTimer = null;
+	}, WINDOW_IDLE_TIMEOUT);
+}
+/** Get or create the dedicated automation window. */
+async function getAutomationWindow() {
+	if (automationWindowId !== null) try {
+		await chrome.windows.get(automationWindowId);
+		return automationWindowId;
+	} catch {
+		automationWindowId = null;
+	}
+	automationWindowId = (await chrome.windows.create({
+		url: "about:blank",
+		focused: false,
+		width: 1280,
+		height: 900,
+		type: "normal"
+	})).id;
+	console.log(`[opencli] Created automation window ${automationWindowId}`);
+	return automationWindowId;
+}
+chrome.windows.onRemoved.addListener((windowId) => {
+	if (windowId === automationWindowId) {
+		console.log("[opencli] Automation window closed");
+		automationWindowId = null;
+		if (windowIdleTimer) {
+			clearTimeout(windowIdleTimer);
+			windowIdleTimer = null;
+		}
+	}
+});
+var initialized = false;
+function initialize() {
+	if (initialized) return;
+	initialized = true;
+	chrome.alarms.create("keepalive", { periodInMinutes: .4 });
+	registerListeners();
+	connect();
+	console.log("[opencli] Browser Bridge extension initialized");
+}
+chrome.runtime.onInstalled.addListener(() => {
+	initialize();
+});
+chrome.runtime.onStartup.addListener(() => {
+	initialize();
+});
+chrome.alarms.onAlarm.addListener((alarm) => {
+	if (alarm.name === "keepalive") connect();
+});
+async function handleCommand(cmd) {
+	resetWindowIdleTimer();
+	try {
+		switch (cmd.action) {
+			case "exec": return await handleExec(cmd);
+			case "navigate": return await handleNavigate(cmd);
+			case "tabs": return await handleTabs(cmd);
+			case "cookies": return await handleCookies(cmd);
+			case "screenshot": return await handleScreenshot(cmd);
+			case "close-window": return await handleCloseWindow(cmd);
+			default: return {
+				id: cmd.id,
+				ok: false,
+				error: `Unknown action: ${cmd.action}`
+			};
+		}
+	} catch (err) {
+		return {
+			id: cmd.id,
+			ok: false,
+			error: err instanceof Error ? err.message : String(err)
+		};
+	}
+}
+/** Check if a URL is a debuggable web page (not chrome:// or extension page) */
+function isWebUrl(url) {
+	if (!url) return false;
+	return !url.startsWith("chrome://") && !url.startsWith("chrome-extension://");
+}
+/**
+* Resolve target tab in the automation window.
+* If explicit tabId is given, use that directly.
+* Otherwise, find or create a tab in the dedicated automation window.
+*/
+async function resolveTabId(tabId) {
+	if (tabId !== void 0) return tabId;
+	const windowId = await getAutomationWindow();
+	const tabs = await chrome.tabs.query({ windowId });
+	const webTab = tabs.find((t) => t.id && isWebUrl(t.url));
+	if (webTab?.id) return webTab.id;
+	if (tabs.length > 0 && tabs[0]?.id) return tabs[0].id;
+	const newTab = await chrome.tabs.create({
+		windowId,
+		url: "about:blank",
+		active: true
+	});
+	if (!newTab.id) throw new Error("Failed to create tab in automation window");
+	return newTab.id;
+}
+async function handleExec(cmd) {
+	if (!cmd.code) return {
+		id: cmd.id,
+		ok: false,
+		error: "Missing code"
+	};
+	const tabId = await resolveTabId(cmd.tabId);
+	try {
+		const data = await evaluateAsync(tabId, cmd.code);
+		return {
+			id: cmd.id,
+			ok: true,
+			data
+		};
+	} catch (err) {
+		return {
+			id: cmd.id,
+			ok: false,
+			error: err instanceof Error ? err.message : String(err)
+		};
+	}
+}
+async function handleNavigate(cmd) {
+	if (!cmd.url) return {
+		id: cmd.id,
+		ok: false,
+		error: "Missing url"
+	};
+	const tabId = await resolveTabId(cmd.tabId);
+	await chrome.tabs.update(tabId, { url: cmd.url });
+	await new Promise((resolve) => {
+		chrome.tabs.get(tabId).then((tab) => {
+			if (tab.status === "complete") {
+				resolve();
+				return;
+			}
+			const listener = (id, info) => {
+				if (id === tabId && info.status === "complete") {
+					chrome.tabs.onUpdated.removeListener(listener);
+					resolve();
+				}
+			};
+			chrome.tabs.onUpdated.addListener(listener);
+			setTimeout(() => {
+				chrome.tabs.onUpdated.removeListener(listener);
+				resolve();
+			}, 15e3);
+		});
+	});
+	const tab = await chrome.tabs.get(tabId);
+	return {
+		id: cmd.id,
+		ok: true,
+		data: {
+			title: tab.title,
+			url: tab.url,
+			tabId
+		}
+	};
+}
+async function handleTabs(cmd) {
+	switch (cmd.op) {
+		case "list": {
+			const data = (await chrome.tabs.query({})).filter((t) => isWebUrl(t.url)).map((t, i) => ({
+				index: i,
+				tabId: t.id,
+				url: t.url,
+				title: t.title,
+				active: t.active
+			}));
+			return {
+				id: cmd.id,
+				ok: true,
+				data
+			};
+		}
+		case "new": {
+			const tab = await chrome.tabs.create({
+				url: cmd.url,
+				active: true
+			});
+			return {
+				id: cmd.id,
+				ok: true,
+				data: {
+					tabId: tab.id,
+					url: tab.url
+				}
+			};
+		}
+		case "close": {
+			if (cmd.index !== void 0) {
+				const target = (await chrome.tabs.query({}))[cmd.index];
+				if (!target?.id) return {
+					id: cmd.id,
+					ok: false,
+					error: `Tab index ${cmd.index} not found`
+				};
+				await chrome.tabs.remove(target.id);
+				detach(target.id);
+				return {
+					id: cmd.id,
+					ok: true,
+					data: { closed: target.id }
+				};
+			}
+			const tabId = await resolveTabId(cmd.tabId);
+			await chrome.tabs.remove(tabId);
+			detach(tabId);
+			return {
+				id: cmd.id,
+				ok: true,
+				data: { closed: tabId }
+			};
+		}
+		case "select": {
+			if (cmd.index === void 0 && cmd.tabId === void 0) return {
+				id: cmd.id,
+				ok: false,
+				error: "Missing index or tabId"
+			};
+			if (cmd.tabId !== void 0) {
+				await chrome.tabs.update(cmd.tabId, { active: true });
+				return {
+					id: cmd.id,
+					ok: true,
+					data: { selected: cmd.tabId }
+				};
+			}
+			const target = (await chrome.tabs.query({}))[cmd.index];
+			if (!target?.id) return {
+				id: cmd.id,
+				ok: false,
+				error: `Tab index ${cmd.index} not found`
+			};
+			await chrome.tabs.update(target.id, { active: true });
+			return {
+				id: cmd.id,
+				ok: true,
+				data: { selected: target.id }
+			};
+		}
+		default: return {
+			id: cmd.id,
+			ok: false,
+			error: `Unknown tabs op: ${cmd.op}`
+		};
+	}
+}
+async function handleCookies(cmd) {
+	const details = {};
+	if (cmd.domain) details.domain = cmd.domain;
+	if (cmd.url) details.url = cmd.url;
+	const data = (await chrome.cookies.getAll(details)).map((c) => ({
+		name: c.name,
+		value: c.value,
+		domain: c.domain,
+		path: c.path,
+		secure: c.secure,
+		httpOnly: c.httpOnly,
+		expirationDate: c.expirationDate
+	}));
+	return {
+		id: cmd.id,
+		ok: true,
+		data
+	};
+}
+async function handleScreenshot(cmd) {
+	const tabId = await resolveTabId(cmd.tabId);
+	try {
+		const data = await screenshot(tabId, {
+			format: cmd.format,
+			quality: cmd.quality,
+			fullPage: cmd.fullPage
+		});
+		return {
+			id: cmd.id,
+			ok: true,
+			data
+		};
+	} catch (err) {
+		return {
+			id: cmd.id,
+			ok: false,
+			error: err instanceof Error ? err.message : String(err)
+		};
+	}
+}
+async function handleCloseWindow(cmd) {
+	if (automationWindowId !== null) {
+		try {
+			await chrome.windows.remove(automationWindowId);
+		} catch {}
+		automationWindowId = null;
+	}
+	return {
+		id: cmd.id,
+		ok: true,
+		data: { closed: true }
+	};
+}
+//#endregion

package/extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "opencli Browser Bridge",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Bridge between opencli CLI and your browser — execute commands, read cookies, manage tabs.",
   "permissions": [
     "debugger",

package/extension/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencli-extension",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "private": true,
   "type": "module",
   "scripts": {