@sleepinsummer/agent-browser-cli 0.2.0

package/assets/tmwd_cdp_bridge/background.js

@@ -0,0 +1,436 @@
+// background.js - Cookie + CDP Bridge
+chrome.runtime.onInstalled.addListener(() => {
+  console.log('CDP Bridge installed');
+  // Strip CSP headers to allow eval/inline scripts
+  chrome.declarativeNetRequest.updateDynamicRules({
+    removeRuleIds: [9999],
+    addRules: [{
+      id: 9999, priority: 1,
+      action: { type: 'modifyHeaders', responseHeaders: [
+        { header: 'content-security-policy', operation: 'remove' },
+        { header: 'content-security-policy-report-only', operation: 'remove' }
+      ]},
+      condition: { urlFilter: '*', resourceTypes: ['main_frame', 'sub_frame'] }
+    }]
+  });
+});
+
+async function handleExtMessage(msg, sender) {
+  if (msg.cmd === 'status') return handleStatus();
+  if (msg.cmd === 'cookies') return await handleCookies(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 === 'tabs') {
+    try {
+      if (msg.method === 'switch') {
+        const tab = await chrome.tabs.update(msg.tabId, { active: true });
+        await chrome.windows.update(tab.windowId, { focused: true });
+        return { ok: true };
+      } else {
+        const tabs = (await chrome.tabs.query({})).filter(t => isScriptable(t.url));
+        const data = tabs.map(t => ({ id: t.id, url: t.url, title: t.title, active: t.active, windowId: t.windowId }));
+        return { ok: true, data };
+      }
+    } catch (e) { return { ok: false, error: e.message }; }
+  }
+  if (msg.cmd === 'management') {
+    try {
+      if (msg.method === 'list') {
+        const all = await chrome.management.getAll();
+        return { ok: true, data: all.map(e => ({ id: e.id, name: e.name, enabled: e.enabled, type: e.type, version: e.version })) };
+      }
+      if (msg.method === 'reload') {
+        chrome.alarms.create('tmwd-self-reload', { when: Date.now() + 200 });
+        return { ok: true };
+      }
+      if (msg.method === 'disable') {
+        await chrome.management.setEnabled(msg.extId, false);
+        return { ok: true };
+      }
+      if (msg.method === 'enable') {
+        await chrome.management.setEnabled(msg.extId, true);
+        return { ok: true };
+      }
+      return { ok: false, error: 'Unknown method: ' + msg.method };
+    } catch (e) { return { ok: false, error: e.message }; }
+  }
+  if (msg.cmd === 'contentSettings') {
+    try {
+      const type = msg.type || 'automaticDownloads';
+      const setting = msg.setting || 'allow';
+      const pattern = msg.pattern || '<all_urls>';
+      await chrome.contentSettings[type].set({
+        primaryPattern: pattern,
+        setting: setting
+      });
+      return { ok: true };
+    } catch (e) { return { ok: false, error: e.message }; }
+  }
+  return { ok: false, error: 'Unknown cmd: ' + msg.cmd };
+}
+
+function handleStatus() {
+  return {
+    ok: true,
+    data: {
+      wsConnected: !!ws && ws.readyState === WebSocket.OPEN,
+      wsUrl: WS_URL
+    }
+  };
+}
+
+chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
+  handleExtMessage(msg, sender).then(sendResponse);
+  return true;
+});
+
+async function handleCookies(msg, sender) {
+  try {
+    let url = msg.url || sender.tab?.url;
+    if (!url && msg.tabId) {
+      const tab = await chrome.tabs.get(msg.tabId);
+      url = tab.url;
+    }
+    const origin = url.match(/^https?:\/\/[^\/]+/)[0];
+    const all = await chrome.cookies.getAll({ url });
+    const part = await chrome.cookies.getAll({ url, partitionKey: { topLevelSite: origin } }).catch(() => []);
+    const merged = [...all];
+    for (const c of part) {
+      if (!merged.some(x => x.name === c.name && x.domain === c.domain)) merged.push(c);
+    }
+    return { ok: true, data: merged };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+async function handleOpenTab(msg) {
+  try {
+    const url = normalizeOpenUrl(msg.url);
+    const active = msg.active !== false;
+    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 } };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+function normalizeOpenUrl(url) {
+  const raw = String(url || '').trim();
+  if (!raw) throw new Error('url is required');
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(raw)) return raw;
+  return 'https://' + raw;
+}
+
+async function handleBatch(msg, sender) {
+  const R = [];
+  let attached = null;
+  const resolve$N = (params) => JSON.parse(JSON.stringify(params || {}).replace(/"\$(\d+)\.([^"]+)"/g,
+    (_, i, path) => { let v = R[+i]; for (const k of path.split('.')) v = v[k]; return JSON.stringify(v); }));
+  try {
+    for (const c of msg.commands) {
+      if (c.tabId === undefined && msg.tabId !== undefined) c.tabId = msg.tabId;
+      if (c.cmd === 'cookies') {
+        R.push(await handleCookies(c, sender));
+      } else if (c.cmd === 'tabs') {
+        const tabs = (await chrome.tabs.query({})).filter(t => isScriptable(t.url));
+        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 (attached !== tabId) {
+          if (attached) { await chrome.debugger.detach({ tabId: attached }); attached = null; }
+          await chrome.debugger.attach({ tabId }, '1.3');
+          attached = tabId;
+        }
+        R.push(await chrome.debugger.sendCommand({ tabId }, c.method, resolve$N(c.params)));
+      } else {
+        R.push({ ok: false, error: 'unknown cmd: ' + c.cmd });
+      }
+    }
+    if (attached) await chrome.debugger.detach({ tabId: attached });
+    return { ok: true, results: R };
+  } catch (e) {
+    if (attached) try { await chrome.debugger.detach({ tabId: attached }); } catch (_) {}
+    return { ok: false, error: e.message, results: R };
+  }
+}
+
+async function handleCDP(msg, sender) {
+  const tabId = msg.tabId || sender.tab?.id;
+  if (!tabId) return { ok: false, error: 'no tabId' };
+  try {
+    await chrome.debugger.attach({ tabId }, '1.3');
+    const result = await chrome.debugger.sendCommand({ tabId }, msg.method, msg.params || {});
+    await chrome.debugger.detach({ tabId });
+    return { ok: true, data: result };
+  } catch (e) {
+    try { await chrome.debugger.detach({ tabId }); } catch (_) {}
+    return { ok: false, error: e.message };
+  }
+}
+// Filter out chrome:// and other internal tabs that can't be scripted
+const isScriptable = url => url && /^https?:/.test(url);
+
+// --- Shared page/CDP script builder core ---
+function buildExecScript(code, errorHandler) {
+  return `(async () => {
+    function smartProcessResult(result) {
+      if (result === null || result === undefined || typeof result !== 'object') return result;
+      try { if (result.window === result && result.document) return '[Window: ' + (result.location?.href || 'about:blank') + ']'; } catch(_){}
+      if (typeof jQuery !== 'undefined' && result instanceof jQuery) {
+        const elements = []; for (let i = 0; i < result.length; i++) { if (result[i] && result[i].nodeType === 1) elements.push(result[i].outerHTML); } return elements;
+      }
+      if (result instanceof NodeList || result instanceof HTMLCollection) {
+        const elements = []; for (let i = 0; i < result.length; i++) { if (result[i] && result[i].nodeType === 1) elements.push(result[i].outerHTML); } return elements;
+      }
+      if (result.nodeType === 1) return result.outerHTML;
+      if (!Array.isArray(result) && typeof result === 'object' && 'length' in result && typeof result.length === 'number') {
+        const firstElement = result[0];
+        if (firstElement && firstElement.nodeType === 1) {
+          const elements = []; const length = Math.min(result.length, 100);
+          for (let i = 0; i < length; i++) { const elem = result[i]; if (elem && elem.nodeType === 1) elements.push(elem.outerHTML); } return elements;
+        }
+      }
+      try { return JSON.parse(JSON.stringify(result, function(key, value) { if (typeof value === 'object' && value !== null) { if (value.nodeType === 1) return value.outerHTML; if (value === window || value === document) return '[Object]'; try { if (value.window === value && value.document) return '[Window]'; } catch(_){} } return value; })); } catch (e) { return '[无法序列化: ' + e.message + ']'; }
+    }
+    try {
+      const jsCode = ${JSON.stringify(code)}.trim();
+      const lines = jsCode.split(/\\r?\\n/).filter(l => l.trim());
+      const lastLine = lines.length > 0 ? lines[lines.length - 1].trim() : '';
+      const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
+      let r;
+      function _air(c) { const ls = c.split(/\\r?\\n/); let i = ls.length - 1; while (i >= 0 && !ls[i].trim()) i--; if (i < 0) return c; const t = ls[i].trim(); if (/^(return |return;|return$|let |const |var |if |if\\(|for |for\\(|while |while\\(|switch|try |throw |class |function |async |import |export |\\/\\/|})/.test(t)) return c; ls[i] = ls[i].match(/^(\\s*)/)[1] + 'return ' + t; return ls.join('\\n'); }
+      if (lastLine.startsWith('return')) {
+        r = await (new AsyncFunction(jsCode))();
+      } else {
+        try { r = eval(jsCode); if (r instanceof Promise) r = await r; } catch (e) {
+          if (e instanceof SyntaxError && (/return/i.test(e.message) || /await/i.test(e.message))) { r = await (new AsyncFunction(_air(jsCode)))(); } else throw e;
+        }
+      }
+      return { ok: true, data: smartProcessResult(r) };
+    } catch (e) {
+      ${errorHandler}
+    }
+  })()`;
+}
+
+function buildPageScript(code) {
+  return buildExecScript(code, `
+      const errMsg = e.message || String(e);
+      return { ok: false, error: { name: e.name || 'Error', message: errMsg, stack: e.stack || '' },
+        csp: errMsg.includes('Refused to evaluate') || errMsg.includes('unsafe-eval') || errMsg.includes('Content Security Policy') };
+  `);
+}
+
+function buildCdpScript(code) {
+  return buildExecScript(code, `
+      return { ok: false, error: { name: e.name || 'Error', message: e.message || String(e), stack: e.stack || '' } };
+  `);
+}
+
+// --- WebSocket Client for TMWebDriver ---
+let ws = null;
+const WS_URL = 'ws://127.0.0.1:18765';
+
+function scheduleProbe() {
+  // Use chrome.alarms to survive MV3 service worker suspension
+  chrome.alarms.create('tmwd-ws-probe', { delayInMinutes: 0.083 }); // ~5s
+}
+
+function scheduleKeepalive() {
+  // Keep SW alive while WS is connected (~25s, under 30s SW timeout)
+  chrome.alarms.create('tmwd-ws-keepalive', { delayInMinutes: 0.4 }); // ~24s
+}
+
+async function isServerAlive() {
+  try {
+    const ctrl = new AbortController();
+    setTimeout(() => ctrl.abort(), 2000);
+    await fetch('http://127.0.0.1:18765', { signal: ctrl.signal });
+    return true; // Got HTTP response → port is listening
+  } catch (e) {
+    return false; // Network error (connection refused) or timeout → server not alive
+  }
+}
+
+chrome.alarms.onAlarm.addListener(async (alarm) => {
+  if (alarm.name === 'tmwd-self-reload') {
+    chrome.runtime.reload();
+    return;
+  }
+  if (alarm.name === 'tmwd-ws-keepalive') {
+    // Keepalive: ping to keep SW alive + detect dead connections
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      try { ws.send('{"type":"ping"}'); } catch (_) {}
+      scheduleKeepalive();
+    } else {
+      // Connection lost, switch to probe mode
+      ws = null;
+      scheduleProbe();
+    }
+  }
+  if (alarm.name === 'tmwd-ws-probe') {
+    if (ws && ws.readyState <= 1) return; // Already connected/connecting
+    if (await isServerAlive()) {
+      console.log('[TMWD-WS] Server detected, connecting...');
+      connectWS();
+    } else {
+      scheduleProbe(); // Server not up, keep probing
+    }
+  }
+});
+
+async function handleWsExec(data) {
+  const tabId = data.tabId;
+  console.log('[TMWD-WS] Exec request', data.id, 'on tab', tabId);
+  ws.send(JSON.stringify({ type: 'ack', id: data.id }));
+  if (!tabId) {
+    ws.send(JSON.stringify({ type: 'error', id: data.id, error: 'No tabId provided' }));
+    return;
+  }
+  // Use onCreated listener to reliably capture new tabs (avoids race condition with query-diff)
+  const newTabIds = new Set();
+  const onCreated = (tab) => { newTabIds.add(tab.id); };
+  chrome.tabs.onCreated.addListener(onCreated);
+  try {
+    let res;
+    try {
+      const result = await chrome.scripting.executeScript({
+        target: { tabId },
+        world: 'MAIN',
+        func: async (s) => await eval(s),
+        args: [buildPageScript(data.code)]
+      });
+      res = result[0]?.result;
+      if (res === null || res === undefined) {
+        console.log('[TMWD-WS] executeScript returned null/undefined, treating as CSP issue');
+        res = { ok: false, error: { name: 'Error', message: 'executeScript returned null (possible CSP or context issue)', stack: '' }, csp: true };
+      }
+    } catch (e) {
+      console.log('[TMWD-WS] scripting.executeScript failed:', e.message);
+      res = { ok: false, error: { name: e.name || 'Error', message: e.message || String(e), stack: e.stack || '' }, csp: true };
+    }
+    // CDP fallback for CSP-restricted pages
+    if (res && !res.ok && res.csp) {
+      console.log('[TMWD-WS] CDP fallback for tab', tabId);
+      const wrappedCode = buildCdpScript(data.code);
+      try {
+        await chrome.debugger.attach({ tabId }, '1.3');
+        const cdpRes = await chrome.debugger.sendCommand({ tabId }, 'Runtime.evaluate', {
+          expression: wrappedCode, awaitPromise: true, returnByValue: true
+        });
+        await chrome.debugger.detach({ tabId });
+        if (cdpRes.exceptionDetails) {
+          const desc = cdpRes.exceptionDetails.exception?.description || 'CDP Error';
+          res = { ok: false, error: { name: 'Error', message: desc, stack: desc } };
+        } else {
+          res = cdpRes.result.value;
+        }
+      } catch (cdpErr) {
+        try { await chrome.debugger.detach({ tabId }); } catch (_) {}
+        res = { ok: false, error: { name: 'Error', message: 'CDP fallback failed: ' + cdpErr.message, stack: '' } };
+      }
+    }
+    // Grace period for async tab creation (e.g. link click with target=_blank)
+    if (newTabIds.size === 0) await new Promise(r => setTimeout(r, 200));
+    chrome.tabs.onCreated.removeListener(onCreated);
+    // Get full info for captured new tabs
+    const newTabs = [];
+    for (const id of newTabIds) {
+      try { const t = await chrome.tabs.get(id); newTabs.push({id: t.id, url: t.url, title: t.title}); } catch (_) {}
+    }
+    if (res?.ok) {
+      ws.send(JSON.stringify({ type: 'result', id: data.id, result: res.data, newTabs }));
+    } else {
+      console.log(res);
+      ws.send(JSON.stringify({ type: 'error', id: data.id, error: res?.error || 'Unknown error', newTabs }));
+    }
+  } catch (e) {
+    ws.send(JSON.stringify({ type: 'error', id: data.id, error: { name: e.name || 'Error', message: e.message || String(e), stack: e.stack || '' } }));
+  } finally {
+    chrome.tabs.onCreated.removeListener(onCreated);
+  }
+}
+
+function connectWS() {
+  if (ws && ws.readyState <= 1) return; // CONNECTING or OPEN
+  ws = null;
+  console.log('[TMWD-WS] Connecting to', WS_URL);
+  try {
+    ws = new WebSocket(WS_URL);
+  } catch (e) {
+    console.error('[TMWD-WS] Constructor error:', e);
+    ws = null;
+    scheduleProbe();
+    return;
+  }
+  ws.onopen = async () => {
+    console.log('[TMWD-WS] Connected!');
+    scheduleKeepalive(); // Keep SW alive while connected
+    const tabs = (await chrome.tabs.query({})).filter(t => isScriptable(t.url));
+    ws.send(JSON.stringify({
+      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) => {
+    try {
+      const data = JSON.parse(event.data);
+      if (data.id && data.code) {
+        let code = data.code;
+        // If code is a JSON string representing an object, parse it
+        if (typeof code === 'string') {
+          try { const p = JSON.parse(code); if (p && typeof p === 'object') code = p; } catch (_) {}
+        }
+        if (typeof code === 'object' && code !== null && code.cmd) {
+          // Custom protocol message → route to handleExtMessage
+          if (code.tabId === undefined && data.tabId !== undefined) code.tabId = data.tabId;
+          const res = await handleExtMessage(code, {});
+          ws.send(JSON.stringify({ type: res.ok ? 'result' : 'error', id: data.id, result: res.data ?? res.results ?? res, error: res.error }));
+        } else if (typeof code === 'string') {
+          // Plain JS code
+          await handleWsExec(data);
+        } else if (typeof code === 'object' && code !== null) {
+          // Object without cmd → legacy extension message
+          const msg = code.tabId === undefined && data.tabId !== undefined ? { ...code, tabId: data.tabId } : code;
+          const res = await handleExtMessage(msg, {});
+          ws.send(JSON.stringify({ type: res.ok ? 'result' : 'error', id: data.id, result: res.data ?? res.results ?? res, error: res.error }));
+        }
+      }
+    } catch (e) {
+      console.error('[TMWD-WS] message parse error', e);
+    }
+  };
+  ws.onclose = () => {
+    console.log('[TMWD-WS] Disconnected');
+    ws = null;
+    scheduleProbe();
+  };
+  ws.onerror = (e) => {
+    console.error('[TMWD-WS] Error:', e);
+    // onclose will fire after this, which triggers reconnect
+  };
+}
+
+// Initial connect + wake-up hooks
+connectWS();
+chrome.runtime.onStartup.addListener(() => connectWS());
+chrome.runtime.onInstalled.addListener(() => connectWS());
+
+// Sync tab list on changes
+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({
+    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();
+});
+chrome.tabs.onRemoved.addListener(() => sendTabsUpdate());
+chrome.tabs.onCreated.addListener(() => sendTabsUpdate());

package/assets/tmwd_cdp_bridge/config.js

@@ -0,0 +1 @@
+const TID = '__agent_browser_cli_bridge_26c9f1';

package/assets/tmwd_cdp_bridge/content.js

@@ -0,0 +1,79 @@
+;(function(){ if (/streamlit/i.test(document.title)) return;
+
+// Remove meta CSP tags
+document.querySelectorAll('meta[http-equiv="Content-Security-Policy"]').forEach(e => e.remove());
+
+/**
+ * Render a bottom-right badge that reflects the real bridge connection status.
+ */
+(function(){
+  if(window.self!==window.top)return;
+  const d=document.createElement('div');
+  d.id='agent-browser-cli-ind';
+  d.style.cssText='position:fixed;bottom:8px;right:8px;color:white;padding:4px 7px;border-radius:4px;font-size:11px;font-weight:bold;z-index:99999;cursor:pointer;box-shadow:0 2px 4px rgba(0,0,0,0.2);opacity:0.5;';
+  /**
+   * Show the badge only when the bridge is really connected.
+   */
+  function setBadgeState(connected, detail) {
+    // Hide the indicator completely when offline to avoid persistent page noise.
+    d.style.display = connected ? 'block' : 'none';
+    d.innerText = 'agent_browser_cli: 已连接';
+    d.style.background = '#4CAF50';
+    d.dataset.connected = connected ? '1' : '0';
+    d.dataset.detail = detail || '';
+  }
+  /**
+   * Poll background status and update the badge visibility.
+   */
+  async function refreshBadgeState() {
+    try {
+      const resp = await chrome.runtime.sendMessage({ cmd: 'status' });
+      const connected = !!resp?.ok && !!resp?.data?.wsConnected;
+      setBadgeState(connected, resp?.data?.wsUrl || '');
+    } catch (e) {
+      setBadgeState(false, e.message || '');
+    }
+  }
+  d.addEventListener('click',()=>alert((d.dataset.connected === '1' ? '会话活跃' : '会话未连接') + '\nURL: ' + location.href + (d.dataset.detail ? '\nBridge: ' + d.dataset.detail : '')));
+  (document.body||document.documentElement).appendChild(d);
+  setBadgeState(false, '');
+  refreshBadgeState();
+  setInterval(refreshBadgeState, 3000);
+})();
+
+new MutationObserver(muts => {
+  for (const m of muts) for (const n of m.addedNodes) {
+    if (n.id === TID || (n.querySelector && n.querySelector('#' + TID))) {
+      const el = n.id === TID ? n : n.querySelector('#' + TID);
+      handle(el);
+    }
+  }
+}).observe(document.documentElement, { childList: true, subtree: true });
+
+/**
+ * Consume page-side bridge requests and forward them to the extension background worker.
+ */
+async function handle(el) {
+  try {
+    const req = el.textContent.trim() ? JSON.parse(el.textContent) : { cmd: 'cookies' };
+    const cmd = req.cmd || 'cookies';
+    let resp;
+    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 });
+    } 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 });
+    } else if (cmd === 'openTab') {
+      resp = await chrome.runtime.sendMessage({ cmd: 'openTab', url: req.url, active: req.active });
+    } else {
+      resp = { ok: false, error: 'unknown cmd: ' + cmd };
+    }
+    el.textContent = JSON.stringify(resp);
+  } catch (e) {
+    el.textContent = JSON.stringify({ ok: false, error: e.message });
+  }
+}
+})();

package/assets/tmwd_cdp_bridge/disable_dialogs.js

@@ -0,0 +1,24 @@
+// Disable alert/confirm/prompt to prevent page JS from blocking extension
+(function() {
+  const _log = console.log.bind(console);
+  function toast(type, msg) {
+    _log('[TMWD] ' + type + ' suppressed:', msg);
+    try {
+      const d = document.createElement('div');
+      d.textContent = '[' + type + '] ' + msg;
+      Object.assign(d.style, {
+        position:'fixed', top:'12px', right:'12px', zIndex:'2147483647',
+        background:'#222', color:'#fff', padding:'10px 18px', borderRadius:'8px',
+        fontSize:'14px', maxWidth:'420px', wordBreak:'break-all',
+        boxShadow:'0 4px 16px rgba(0,0,0,.3)', opacity:'1',
+        transition:'opacity .5s', pointerEvents:'none'
+      });
+      (document.body || document.documentElement).appendChild(d);
+      setTimeout(() => { d.style.opacity = '0'; }, 3000);
+      setTimeout(() => { d.remove(); }, 3600);
+    } catch(e) {}
+  }
+  window.alert = function(msg) { toast('alert', msg); };
+  window.confirm = function(msg) { toast('confirm', msg); return true; };
+  window.prompt = function(msg, def) { toast('prompt', msg); return def || null; };
+})();

package/assets/tmwd_cdp_bridge/manifest.json

@@ -0,0 +1,40 @@
+{
+  "manifest_version": 3,
+  "name": "TMWD CDP Bridge",
+  "version": "2.0",
+  "description": "Cookie viewer + CDP bridge",
+  "permissions": [
+    "cookies",
+    "tabs",
+    "activeTab",
+    "debugger",
+    "scripting",
+    "alarms",
+    "declarativeNetRequest",
+    "management",
+    "contentSettings"
+  ],
+  "host_permissions": ["<all_urls>"],
+  "background": {
+    "service_worker": "background.js"
+  },
+  "content_scripts": [
+    {
+      "matches": ["<all_urls>"],
+      "js": ["disable_dialogs.js"],
+      "run_at": "document_start",
+      "all_frames": true,
+      "world": "MAIN"
+    },
+    {
+      "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"
+  }
+}

package/assets/tmwd_cdp_bridge/popup.html

@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<style>
+body{width:420px;max-height:500px;margin:0;padding:8px;font:12px monospace;background:#1e1e1e;color:#d4d4d4;overflow-y:auto}
+h3{margin:4px 0;color:#569cd6}
+button{background:#264f78;color:#fff;border:none;padding:4px 12px;cursor:pointer;border-radius:3px;margin-bottom:6px}
+button:hover{background:#37699e}
+pre{white-space:pre-wrap;word-break:break-all;margin:0;padding:6px;background:#252526;border-radius:3px;max-height:420px;overflow-y:auto}
+</style>
+</head>
+<body>
+<h3>🍪 Cookies</h3>
+<button id="refresh">刷新</button>
+<pre id="out">点击刷新获取 cookies...</pre>
+<script src="popup.js"></script>
+</body>
+</html>

package/assets/tmwd_cdp_bridge/popup.js

@@ -0,0 +1,24 @@
+document.addEventListener('DOMContentLoaded', () => {
+  const out = document.getElementById('out');
+  const btn = document.getElementById('refresh');
+  btn.addEventListener('click', fetchCookies);
+  fetchCookies();
+});
+
+async function fetchCookies() {
+  const out = document.getElementById('out');
+  try {
+    const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
+    if (!tab?.url) { out.textContent = 'No active tab'; return; }
+    const resp = await chrome.runtime.sendMessage({ cmd: 'cookies', url: tab.url });
+    if (!resp?.ok) { out.textContent = 'Error: ' + (resp?.error || 'unknown'); return; }
+    if (!resp.data.length) { out.textContent = '(no cookies)'; return; }
+    // 展示带标记
+    out.textContent = resp.data.map(c =>
+      `${c.name}=${c.value}` + (c.httpOnly ? ' [H]' : '') + (c.secure ? ' [S]' : '') + (c.partitionKey ? ' [P]' : '')
+    ).join('\n');
+    // 自动复制 name=value; 格式到剪贴板
+    const str = resp.data.map(c => `${c.name}=${c.value}`).join('; ');
+    await navigator.clipboard.writeText(str);
+  } catch (e) { out.textContent = 'Error: ' + e.message; }
+}

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

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+function platformPackageName() {
+  const platform = process.platform;
+  const arch = process.arch;
+  if (platform === "darwin" && arch === "arm64") return "@sleepinsummer/agent-browser-cli-darwin-arm64";
+  if (platform === "darwin" && arch === "x64") return "@sleepinsummer/agent-browser-cli-darwin-x64";
+  if (platform === "win32" && arch === "x64") return "@sleepinsummer/agent-browser-cli-win32-x64";
+  throw new Error(`Unsupported platform: ${platform}-${arch}`);
+}
+
+function resolveBinary() {
+  if (process.env.AGENT_BROWSER_CLI_BIN) return process.env.AGENT_BROWSER_CLI_BIN;
+  try {
+    const pkg = platformPackageName();
+    return require.resolve(`${pkg}/bin/agent-browser-cli${process.platform === "win32" ? ".exe" : ""}`);
+  } catch (_) {
+    const ext = process.platform === "win32" ? ".exe" : "";
+    const local = path.resolve(__dirname, "..", "..", "target", "release", `agent-browser-cli${ext}`);
+    if (fs.existsSync(local)) return local;
+    throw new Error("agent-browser-cli native binary not found. Run `npm run build` for local development.");
+  }
+}
+
+const bin = resolveBinary();
+const result = spawnSync(bin, process.argv.slice(2), { stdio: "inherit" });
+if (result.error) {
+  console.error(result.error.message);
+  process.exit(1);
+}
+process.exit(result.status ?? 0);