@sleepinsummer/agent-browser-cli 0.2.9 → 0.3.1-beta.2

package/assets/tmwd_cdp_bridge/background.js

@@ -19,6 +19,25 @@ let lastCommandAt = 0;
 const DEFAULT_WS_PORT = 18765;
 const CLI_API_PORT = 18767;
 let wsPort = DEFAULT_WS_PORT;
+const browserId = `browser-${crypto.randomUUID()}`;
+let profileId = null;
+let profileLabel = null;
+
+async function loadClientIdentity() {
+  const data = await chrome.storage.local.get({ profileId: null, profileLabel: null });
+  profileId = data.profileId || `profile-${crypto.randomUUID()}`;
+  profileLabel = data.profileLabel || null;
+  if (!data.profileId) await chrome.storage.local.set({ profileId });
+  return { browserId, profileId, profileLabel };
+}
+
+function withClientIdentity(payload) {
+  return Object.assign({
+    browser_id: browserId,
+    profile_id: profileId || 'profile-pending',
+    profile_label: profileLabel || undefined
+  }, payload);
+}
 
 async function handleExtMessage(msg, sender) {
   if (msg.cmd === 'status') return handleStatus();
@@ -28,11 +47,23 @@ async function handleExtMessage(msg, sender) {
   if (msg.cmd === 'cdp') return await handleCDP(msg, sender);
   if (msg.cmd === 'batch') return await handleBatch(msg, sender);
   if (msg.cmd === 'openTab') return await handleOpenTab(msg);
+  if (msg.cmd === 'closeTab') return await handleCloseTab(msg, sender);
+  if (msg.cmd === 'networkStart') return await handleNetworkStart(msg, sender);
+  if (msg.cmd === 'networkList') return await handleNetworkList(msg, sender);
+  if (msg.cmd === 'networkDetail') return await handleNetworkDetail(msg, sender);
+  if (msg.cmd === 'networkClear') return await handleNetworkClear(msg, sender);
+  if (msg.cmd === 'networkStop') return await handleNetworkStop(msg, sender);
+  if (msg.cmd === 'consoleStart') return await handleConsoleStart(msg, sender);
+  if (msg.cmd === 'consoleList') return await handleConsoleList(msg, sender);
+  if (msg.cmd === 'consoleClear') return await handleConsoleClear(msg, sender);
+  if (msg.cmd === 'consoleStop') return await handleConsoleStop(msg, sender);
+  if (msg.cmd === 'debugClearAll') return await handleDebugClearAll();
   if (msg.cmd === 'tabs') {
     try {
       if (msg.method === 'switch') {
         const tab = await chrome.tabs.update(msg.tabId, { active: true });
-        await chrome.windows.update(tab.windowId, { focused: true });
+        // 默认只切换 Chrome 内部 active tab，不抢占系统前台窗口。
+        if (msg.allowFocus === true && tab.windowId) await chrome.windows.update(tab.windowId, { focused: true });
         return { ok: true };
       } else {
         const tabs = (await chrome.tabs.query({})).filter(t => isScriptable(t.url));
@@ -84,7 +115,10 @@ function handleStatus() {
       wsConnected: !!ws && ws.readyState === WebSocket.OPEN,
       wsUrl: getWsUrl(),
       wsPort,
-      lastCommandAt
+      lastCommandAt,
+      browserId,
+      profileId,
+      profileLabel
     }
   };
 }
@@ -128,18 +162,385 @@ async function handleCookies(msg, sender) {
   }
 }
 
+
+const debugSessions = new Map();
+
+function resolveTabId(msg, sender) {
+  const tabId = Number(msg.tabId || sender.tab?.id);
+  if (!Number.isInteger(tabId) || tabId <= 0) throw new Error('no tabId');
+  return tabId;
+}
+
+function getDebugSession(tabId) {
+  let session = debugSessions.get(tabId);
+  if (!session) {
+    session = {
+      tabId,
+      attached: false,
+      network: false,
+      console: false,
+      requests: new Map(),
+      requestOrder: [],
+      logs: []
+    };
+    debugSessions.set(tabId, session);
+  }
+  return session;
+}
+
+async function ensureDebugAttached(session) {
+  if (session.attached) return;
+  await chrome.debugger.attach({ tabId: session.tabId }, '1.3');
+  session.attached = true;
+}
+
+async function detachDebugIfIdle(session) {
+  if (!session.attached || session.network || session.console) return;
+  try { await chrome.debugger.detach({ tabId: session.tabId }); } catch (_) {}
+  session.attached = false;
+}
+
+async function handleNetworkStart(msg, sender) {
+  try {
+    const tabId = resolveTabId(msg, sender);
+    const session = getDebugSession(tabId);
+    await ensureDebugAttached(session);
+    await chrome.debugger.sendCommand({ tabId }, 'Network.enable', {});
+    session.network = true;
+    return { ok: true, status: 'started', tabId, count: session.requestOrder.length };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+async function handleNetworkList(msg, sender) {
+  try {
+    const tabId = resolveTabId(msg, sender);
+    const session = getDebugSession(tabId);
+    const filter = String(msg.filter || '').toLowerCase();
+    const limit = Math.max(1, Math.min(Number(msg.limit || 100), 1000));
+    let items = session.requestOrder.map(id => session.requests.get(id)).filter(Boolean);
+    if (filter) {
+      items = items.filter(item => [item.url, item.method, item.status, item.mimeType, item.resourceType].some(v => String(v || '').toLowerCase().includes(filter)));
+    }
+    items = items.slice(-limit).map(summarizeRequest);
+    return { ok: true, status: session.network ? 'started' : 'stopped', tabId, count: items.length, requests: items };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+async function handleNetworkDetail(msg, sender) {
+  try {
+    const tabId = resolveTabId(msg, sender);
+    const requestId = String(msg.requestId || '');
+    const session = getDebugSession(tabId);
+    const item = session.requests.get(requestId);
+    if (!item) return { ok: false, error: 'unknown requestId: ' + requestId };
+    const detail = Object.assign({}, item);
+    if (item.completed && !item.failed && session.attached) {
+      try {
+        const body = await chrome.debugger.sendCommand({ tabId }, 'Network.getResponseBody', { requestId });
+        detail.body = truncateText(body.body || '', 20000);
+        detail.base64Encoded = !!body.base64Encoded;
+        detail.bodyTruncated = String(body.body || '').length > 20000;
+      } catch (e) {
+        detail.bodyError = e.message;
+      }
+    }
+    return { ok: true, tabId, request: detail };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+async function handleNetworkClear(msg, sender) {
+  try {
+    const tabId = resolveTabId(msg, sender);
+    const session = getDebugSession(tabId);
+    session.requests.clear();
+    session.requestOrder = [];
+    return { ok: true, status: 'cleared', tabId };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+async function handleNetworkStop(msg, sender) {
+  try {
+    const tabId = resolveTabId(msg, sender);
+    const session = getDebugSession(tabId);
+    if (session.attached) {
+      try { await chrome.debugger.sendCommand({ tabId }, 'Network.disable', {}); } catch (_) {}
+    }
+    session.network = false;
+    session.requests.clear();
+    session.requestOrder = [];
+    await detachDebugIfIdle(session);
+    return { ok: true, status: 'stopped', cleared: true, tabId };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+async function handleConsoleStart(msg, sender) {
+  try {
+    const tabId = resolveTabId(msg, sender);
+    const session = getDebugSession(tabId);
+    await ensureDebugAttached(session);
+    await chrome.debugger.sendCommand({ tabId }, 'Runtime.enable', {});
+    await chrome.debugger.sendCommand({ tabId }, 'Log.enable', {}).catch(() => null);
+    session.console = true;
+    return { ok: true, status: 'started', tabId, count: session.logs.length };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+async function handleConsoleList(msg, sender) {
+  try {
+    const tabId = resolveTabId(msg, sender);
+    const session = getDebugSession(tabId);
+    const level = String(msg.level || '').toLowerCase();
+    const limit = Math.max(1, Math.min(Number(msg.limit || 100), 1000));
+    let logs = session.logs;
+    if (level) logs = logs.filter(item => String(item.level || '').toLowerCase() === level);
+    return { ok: true, status: session.console ? 'started' : 'stopped', tabId, count: logs.length, logs: logs.slice(-limit) };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+async function handleConsoleClear(msg, sender) {
+  try {
+    const tabId = resolveTabId(msg, sender);
+    const session = getDebugSession(tabId);
+    session.logs = [];
+    return { ok: true, status: 'cleared', tabId };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+async function handleConsoleStop(msg, sender) {
+  try {
+    const tabId = resolveTabId(msg, sender);
+    const session = getDebugSession(tabId);
+    if (session.attached) {
+      try { await chrome.debugger.sendCommand({ tabId }, 'Runtime.disable', {}); } catch (_) {}
+      try { await chrome.debugger.sendCommand({ tabId }, 'Log.disable', {}); } catch (_) {}
+    }
+    session.console = false;
+    session.logs = [];
+    await detachDebugIfIdle(session);
+    return { ok: true, status: 'stopped', cleared: true, tabId };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+function summarizeRequest(item) {
+  return {
+    requestId: item.requestId,
+    url: item.url,
+    method: item.method,
+    status: item.status,
+    mimeType: item.mimeType,
+    resourceType: item.resourceType,
+    completed: !!item.completed,
+    failed: !!item.failed,
+    errorText: item.errorText,
+    timestamp: item.timestamp
+  };
+}
+
+function rememberRequest(session, requestId) {
+  if (!session.requests.has(requestId)) session.requestOrder.push(requestId);
+  while (session.requestOrder.length > 1000) {
+    const old = session.requestOrder.shift();
+    session.requests.delete(old);
+  }
+  let item = session.requests.get(requestId);
+  if (!item) {
+    item = { requestId };
+    session.requests.set(requestId, item);
+  }
+  return item;
+}
+
+function pushLog(session, item) {
+  session.logs.push(item);
+  if (session.logs.length > 1000) session.logs.splice(0, session.logs.length - 1000);
+}
+
+function remoteObjectText(arg) {
+  if (!arg) return '';
+  if ('value' in arg) {
+    if (typeof arg.value === 'string') return truncateText(arg.value, 2000);
+    try { return truncateText(JSON.stringify(arg.value), 2000); } catch (_) { return String(arg.value); }
+  }
+  return truncateText(arg.description || arg.type || '', 2000);
+}
+
+function truncateText(text, max) {
+  const value = String(text || '');
+  return value.length > max ? value.slice(0, max) : value;
+}
+
+function onDebuggerEvent(source, method, params) {
+  const tabId = source.tabId;
+  if (!tabId) return;
+  const session = debugSessions.get(tabId);
+  if (!session) return;
+  if (method === 'Network.requestWillBeSent') {
+    const item = rememberRequest(session, params.requestId);
+    item.url = params.request?.url || item.url;
+    item.method = params.request?.method || item.method;
+    item.resourceType = params.type || item.resourceType;
+    item.timestamp = params.wallTime || params.timestamp || item.timestamp;
+    item.requestHeaders = params.request?.headers;
+  } else if (method === 'Network.responseReceived') {
+    const item = rememberRequest(session, params.requestId);
+    item.status = params.response?.status;
+    item.statusText = params.response?.statusText;
+    item.mimeType = params.response?.mimeType;
+    item.responseHeaders = params.response?.headers;
+    item.url = params.response?.url || item.url;
+    item.resourceType = params.type || item.resourceType;
+  } else if (method === 'Network.loadingFinished') {
+    const item = rememberRequest(session, params.requestId);
+    item.completed = true;
+    item.encodedDataLength = params.encodedDataLength;
+  } else if (method === 'Network.loadingFailed') {
+    const item = rememberRequest(session, params.requestId);
+    item.completed = true;
+    item.failed = true;
+    item.errorText = params.errorText;
+  } else if (method === 'Runtime.consoleAPICalled') {
+    pushLog(session, {
+      level: params.type || 'log',
+      text: (params.args || []).map(remoteObjectText).join(' '),
+      timestamp: params.timestamp || Date.now(),
+      url: params.stackTrace?.callFrames?.[0]?.url || '',
+      line: params.stackTrace?.callFrames?.[0]?.lineNumber,
+      column: params.stackTrace?.callFrames?.[0]?.columnNumber
+    });
+  } else if (method === 'Runtime.exceptionThrown') {
+    pushLog(session, {
+      level: 'error',
+      text: params.exceptionDetails?.text || params.exceptionDetails?.exception?.description || 'exception thrown',
+      timestamp: params.timestamp || Date.now(),
+      url: params.exceptionDetails?.url || '',
+      line: params.exceptionDetails?.lineNumber,
+      column: params.exceptionDetails?.columnNumber
+    });
+  } else if (method === 'Log.entryAdded') {
+    const e = params.entry || {};
+    pushLog(session, {
+      level: e.level || 'log',
+      text: e.text || '',
+      timestamp: e.timestamp || Date.now(),
+      url: e.url || '',
+      line: e.lineNumber,
+      column: undefined
+    });
+  }
+}
+
+function onDebuggerDetach(source) {
+  if (!source.tabId) return;
+  const session = debugSessions.get(source.tabId);
+  if (session) {
+    session.attached = false;
+    session.network = false;
+    session.console = false;
+  }
+}
+
+chrome.debugger.onEvent.addListener(onDebuggerEvent);
+chrome.debugger.onDetach.addListener(onDebuggerDetach);
+
+
+
+async function handleCloseTab(msg, sender) {
+  try {
+    const tabId = Number(msg.tabId || sender.tab?.id);
+    if (!Number.isInteger(tabId) || tabId <= 0) throw new Error('tabId is required');
+    const session = debugSessions.get(tabId);
+    if (session?.attached) {
+      try { await chrome.debugger.detach({ tabId }); } catch (_) {}
+    }
+    debugSessions.delete(tabId);
+    await chrome.tabs.remove(tabId);
+    return { ok: true, data: { status: 'success', tabId } };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+async function handleDebugClearAll() {
+  const tabIds = [...debugSessions.keys()];
+  for (const tabId of tabIds) {
+    const session = debugSessions.get(tabId);
+    if (!session) continue;
+    session.requests.clear();
+    session.requestOrder = [];
+    session.logs = [];
+    session.network = false;
+    session.console = false;
+    if (session.attached) {
+      try { await chrome.debugger.detach({ tabId }); } catch (_) {}
+      session.attached = false;
+    }
+  }
+  debugSessions.clear();
+  return { ok: true, status: 'cleared', tabs: tabIds.length };
+}
+
 async function handleOpenTab(msg) {
   try {
     const url = normalizeOpenUrl(msg.url);
     const active = msg.active !== false;
+    if (msg.window === true) {
+      // window 模式默认不聚焦，避免新窗口打断用户当前工作区。
+      const win = await chrome.windows.create({ url, focused: msg.allowFocus === true });
+      const tab = Array.isArray(win.tabs) && win.tabs.length ? win.tabs[0] : null;
+      const group = tab?.id ? await groupTabIfRequested(tab.id, msg.groupTitle) : { ok: false, skipped: true, reason: 'window created without tab info' };
+      return { ok: true, data: { id: tab?.id, url: tab?.url || url, title: tab?.title || '', active: !!tab?.active, windowId: win.id, window: true, group } };
+    }
     const tab = await chrome.tabs.create({ url, active });
-    if (active && tab.windowId) await chrome.windows.update(tab.windowId, { focused: true });
-    return { ok: true, data: { id: tab.id, url: tab.url || url, title: tab.title || '', active: tab.active, windowId: tab.windowId } };
+    const group = await groupTabIfRequested(tab.id, msg.groupTitle);
+    // 默认创建/激活标签页但不聚焦浏览器窗口，避免打断当前工作区。
+    if (active && msg.allowFocus === true && tab.windowId) await chrome.windows.update(tab.windowId, { focused: true });
+    return { ok: true, data: { id: tab.id, url: tab.url || url, title: tab.title || '', active: tab.active, windowId: tab.windowId, window: false, group } };
   } catch (e) {
     return { ok: false, error: e.message };
   }
 }
 
+async function groupTabIfRequested(tabId, title) {
+  const cleanTitle = String(title || '').trim();
+  if (!cleanTitle) return null;
+  if (!chrome.tabs?.group || !chrome.tabGroups?.update) {
+    return { ok: false, skipped: true, reason: 'tabGroups API unavailable' };
+  }
+  try {
+    const existing = await findTabGroupByTitle(cleanTitle);
+    const groupId = await chrome.tabs.group(existing ? { tabIds: tabId, groupId: existing.id } : { tabIds: tabId });
+    await chrome.tabGroups.update(groupId, { title: cleanTitle });
+    return { ok: true, id: groupId, title: cleanTitle };
+  } catch (e) {
+    // 分组只是整理标签，不影响打开页面的主流程。
+    return { ok: false, skipped: true, reason: e.message };
+  }
+}
+
+async function findTabGroupByTitle(title) {
+  if (!chrome.tabGroups?.query) return null;
+  const groups = await chrome.tabGroups.query({});
+  return groups.find(group => group.title === title) || null;
+}
+
 function normalizeOpenUrl(url) {
   const raw = String(url || '').trim();
   if (!raw) throw new Error('url is required');
@@ -162,6 +563,10 @@ async function handleBatch(msg, sender) {
         R.push({ ok: true, data: tabs.map(t => ({ id: t.id, url: t.url, title: t.title, active: t.active, windowId: t.windowId })) });
       } else if (c.cmd === 'cdp') {
         const tabId = c.tabId || msg.tabId || sender.tab?.id;
+        if (c.method === 'Page.bringToFront' && c.allowFocus !== true && msg.allowFocus !== true) {
+          R.push({ skipped: true, reason: 'Page.bringToFront requires allowFocus=true' });
+          continue;
+        }
         if (attached !== tabId) {
           if (attached) { await chrome.debugger.detach({ tabId: attached }); attached = null; }
           await chrome.debugger.attach({ tabId }, '1.3');
@@ -183,6 +588,9 @@ async function handleBatch(msg, sender) {
 async function handleCDP(msg, sender) {
   const tabId = msg.tabId || sender.tab?.id;
   if (!tabId) return { ok: false, error: 'no tabId' };
+  if (msg.method === 'Page.bringToFront' && msg.allowFocus !== true) {
+    return { ok: true, data: { skipped: true, reason: 'Page.bringToFront requires allowFocus=true' } };
+  }
   try {
     await chrome.debugger.attach({ tabId }, '1.3');
     const result = await chrome.debugger.sendCommand({ tabId }, msg.method, msg.params || {});
@@ -439,11 +847,12 @@ async function connectWS() {
   ws.onopen = async () => {
     console.log('[TMWD-WS] Connected!');
     scheduleKeepalive(); // Keep SW alive while connected
+    await loadClientIdentity();
     const tabs = (await chrome.tabs.query({})).filter(t => isScriptable(t.url));
-    ws.send(JSON.stringify({
+    ws.send(JSON.stringify(withClientIdentity({
       type: 'ext_ready',
       tabs: tabs.map(t => ({ id: t.id, url: t.url, title: t.title }))
-    }));
+    })));
     console.log('[TMWD-WS] Sent ext_ready with', tabs.length, 'tabs');
   };
   ws.onmessage = async (event) => {
@@ -512,10 +921,11 @@ chrome.runtime.onInstalled.addListener(() => {
 async function sendTabsUpdate() {
   if (!ws || ws.readyState !== WebSocket.OPEN) return;
   const tabs = (await chrome.tabs.query({})).filter(t => isScriptable(t.url) && !/streamlit/i.test(t.title));
-  ws.send(JSON.stringify({
+  await loadClientIdentity();
+  ws.send(JSON.stringify(withClientIdentity({
     type: 'tabs_update',
     tabs: tabs.map(t => ({ id: t.id, url: t.url, title: t.title }))
-  }));
+  })));
 }
 chrome.tabs.onUpdated.addListener((_, changeInfo) => {
   if (changeInfo.status === 'complete') sendTabsUpdate();

package/assets/tmwd_cdp_bridge/content.js

@@ -142,13 +142,17 @@ async function handle(el) {
     if (cmd === 'cookies') {
       resp = await chrome.runtime.sendMessage({ cmd: 'cookies', url: req.url || location.href });
     } else if (cmd === 'cdp') {
-      resp = await chrome.runtime.sendMessage({ cmd: 'cdp', method: req.method, params: req.params || {}, tabId: req.tabId });
+      resp = await chrome.runtime.sendMessage({ cmd: 'cdp', method: req.method, params: req.params || {}, tabId: req.tabId, allowFocus: req.allowFocus });
     } else if (cmd === 'batch') {
       resp = await chrome.runtime.sendMessage({ cmd: 'batch', commands: req.commands, tabId: req.tabId });
     } else if (cmd === 'tabs') {
-      resp = await chrome.runtime.sendMessage({ cmd: 'tabs', method: req.method, tabId: req.tabId });
+      resp = await chrome.runtime.sendMessage({ cmd: 'tabs', method: req.method, tabId: req.tabId, allowFocus: req.allowFocus });
     } else if (cmd === 'openTab') {
-      resp = await chrome.runtime.sendMessage({ cmd: 'openTab', url: req.url, active: req.active });
+      resp = await chrome.runtime.sendMessage({ cmd: 'openTab', url: req.url, active: req.active, allowFocus: req.allowFocus, groupTitle: req.groupTitle });
+    } else if (cmd === 'closeTab') {
+      resp = await chrome.runtime.sendMessage({ cmd: 'closeTab', tabId: req.tabId });
+    } else if (cmd === 'networkStart' || cmd === 'networkList' || cmd === 'networkDetail' || cmd === 'networkClear' || cmd === 'networkStop' || cmd === 'consoleStart' || cmd === 'consoleList' || cmd === 'consoleClear' || cmd === 'consoleStop' || cmd === 'debugClearAll') {
+      resp = await chrome.runtime.sendMessage(Object.assign({}, req, { cmd }));
     } else {
       resp = { ok: false, error: 'unknown cmd: ' + cmd };
     }

package/assets/tmwd_cdp_bridge/manifest.json

@@ -1,11 +1,12 @@
 {
   "manifest_version": 3,
-  "name": "TMWD CDP Bridge",
+  "name": "Agent Browser CLI Bridge",
   "version": "2.0",
-  "description": "Cookie viewer + CDP bridge",
+  "description": "Browser control bridge for agent-browser-cli",
   "permissions": [
     "cookies",
     "tabs",
+    "tabGroups",
     "activeTab",
     "debugger",
     "scripting",
@@ -15,27 +16,50 @@
     "management",
     "contentSettings"
   ],
-  "host_permissions": ["<all_urls>"],
+  "host_permissions": [
+    "<all_urls>"
+  ],
   "background": {
     "service_worker": "background.js"
   },
   "content_scripts": [
     {
-      "matches": ["<all_urls>"],
-      "js": ["disable_dialogs.js"],
+      "matches": [
+        "<all_urls>"
+      ],
+      "js": [
+        "disable_dialogs.js"
+      ],
       "run_at": "document_start",
       "all_frames": true,
       "world": "MAIN"
     },
     {
-      "matches": ["<all_urls>"],
-      "js": ["config.js", "content.js"],
+      "matches": [
+        "<all_urls>"
+      ],
+      "js": [
+        "config.js",
+        "content.js"
+      ],
       "run_at": "document_idle",
       "all_frames": true
     }
   ],
   "action": {
     "default_popup": "popup.html",
-    "default_title": "TMWD CDP Bridge"
+    "default_title": "Agent Browser CLI Bridge",
+    "default_icon": {
+      "16": "icons/bot-16.png",
+      "32": "icons/bot-32.png",
+      "48": "icons/bot-48.png",
+      "128": "icons/bot-128.png"
+    }
+  },
+  "icons": {
+    "16": "icons/bot-16.png",
+    "32": "icons/bot-32.png",
+    "48": "icons/bot-48.png",
+    "128": "icons/bot-128.png"
   }
 }

package/npm/bin/agent-browser-cli.js

@@ -29,7 +29,8 @@ function resolveBinary() {
 }
 
 const bin = resolveBinary();
-const result = spawnSync(bin, process.argv.slice(2), { stdio: "inherit" });
+const env = { ...process.env, AGENT_BROWSER_CLI_PACKAGE_DIR: path.resolve(__dirname, "..") };
+const result = spawnSync(bin, process.argv.slice(2), { stdio: "inherit", env });
 if (result.error) {
   console.error(result.error.message);
   process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleepinsummer/agent-browser-cli",
-  "version": "0.2.9",
+  "version": "0.3.1-beta.2",
   "description": "Agent-oriented browser sensing and control CLI backed by a native Rust daemon.",
   "license": "MIT",
   "bin": {
@@ -14,6 +14,7 @@
     "README.md",
     "README_EN.md",
     "AI_INSTALL.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "scripts": {
@@ -23,11 +24,11 @@
     "postinstall": "node npm/postinstall.js"
   },
   "optionalDependencies": {
-    "@sleepinsummer/agent-browser-cli-darwin-arm64": "0.2.9",
-    "@sleepinsummer/agent-browser-cli-darwin-x64": "0.2.9",
-    "@sleepinsummer/agent-browser-cli-linux-x64": "0.2.9",
-    "@sleepinsummer/agent-browser-cli-linux-arm64": "0.2.9",
-    "@sleepinsummer/agent-browser-cli-win32-x64": "0.2.9"
+    "@sleepinsummer/agent-browser-cli-darwin-arm64": "0.3.1-beta.2",
+    "@sleepinsummer/agent-browser-cli-darwin-x64": "0.3.1-beta.2",
+    "@sleepinsummer/agent-browser-cli-linux-x64": "0.3.1-beta.2",
+    "@sleepinsummer/agent-browser-cli-linux-arm64": "0.3.1-beta.2",
+    "@sleepinsummer/agent-browser-cli-win32-x64": "0.3.1-beta.2"
   },
   "engines": {
     "node": ">=18"