yunti-browser-runtime 0.1.0

package/extension/manifest.json

@@ -0,0 +1,35 @@
+{
+  "manifest_version": 3,
+  "name": "Yunti Browser Runtime",
+  "version": "0.1.0",
+  "description": "Local browser runtime for AI agents through MCP.",
+  "permissions": [
+    "activeTab",
+    "debugger",
+    "storage",
+    "tabs",
+    "webRequest"
+  ],
+  "host_permissions": [
+    "https://*/*",
+    "http://*/*",
+    "http://127.0.0.1/*",
+    "http://localhost/*"
+  ],
+  "background": {
+    "service_worker": "background.js",
+    "type": "module"
+  },
+  "action": {
+    "default_title": "Yunti Browser Runtime",
+    "default_popup": "popup.html"
+  },
+  "content_scripts": [
+    {
+      "matches": ["http://*/*", "https://*/*"],
+      "js": ["content.js"],
+      "css": ["content.css"],
+      "run_at": "document_idle"
+    }
+  ]
+}

package/extension/network-monitor.js

@@ -0,0 +1,140 @@
+import { DEFAULT_PLATFORM_MATCHES, isPlatformUrl } from "./settings.js"
+
+const HTTPS_NETWORK_FILTER = { urls: ["https://*/*"] }
+const SENSITIVE_FIELD_RE =
+  /cookie|authorization|token|secret|password|passwd|pwd|sid|session|ticket|tgc|captcha|验证码|密码/i
+
+export function installNetworkMonitor({ sessionsByTab, postBridge, getPlatformMatches }) {
+  const networkRequests = new Map()
+
+  chrome.webRequest.onBeforeRequest.addListener(
+    (details) => {
+      beginNetworkEvent({ details, sessionsByTab, networkRequests, getPlatformMatches })
+    },
+    HTTPS_NETWORK_FILTER,
+    ["requestBody"]
+  )
+
+  chrome.webRequest.onCompleted.addListener((details) => {
+    finishNetworkEvent({
+      details,
+      outcome: { completed: true },
+      sessionsByTab,
+      networkRequests,
+      getPlatformMatches,
+      postBridge,
+    })
+  }, HTTPS_NETWORK_FILTER)
+
+  chrome.webRequest.onErrorOccurred.addListener((details) => {
+    finishNetworkEvent({
+      details,
+      outcome: { error: details.error || "request failed" },
+      sessionsByTab,
+      networkRequests,
+      getPlatformMatches,
+      postBridge,
+    })
+  }, HTTPS_NETWORK_FILTER)
+
+  return { networkRequests }
+}
+
+function beginNetworkEvent({ details, sessionsByTab, networkRequests, getPlatformMatches }) {
+  if (details.tabId < 0) return
+  const session = sessionsByTab.get(details.tabId)
+  if (!session) return
+  if (!isSupportedNetworkUrl(details.url, getPlatformMatches)) return
+  networkRequests.set(details.requestId, {
+    browserSessionId: session.browserSessionId,
+    tabId: details.tabId,
+    requestId: details.requestId,
+    url: details.url,
+    method: details.method,
+    type: details.type,
+    initiator: details.initiator || "",
+    documentUrl: details.documentUrl || "",
+    startedAt: new Date(details.timeStamp || Date.now()).toISOString(),
+    startTime: details.timeStamp || Date.now(),
+    requestBody: summarizeRequestBody(details.requestBody),
+  })
+}
+
+function finishNetworkEvent({
+  details,
+  outcome,
+  sessionsByTab,
+  networkRequests,
+  getPlatformMatches,
+  postBridge,
+}) {
+  if (!isSupportedNetworkUrl(details.url, getPlatformMatches)) return
+  const event = networkRequests.get(details.requestId) || {
+    tabId: details.tabId,
+    requestId: details.requestId,
+    url: details.url,
+    method: details.method,
+    type: details.type,
+    initiator: details.initiator || "",
+    documentUrl: details.documentUrl || "",
+    startedAt: new Date(details.timeStamp || Date.now()).toISOString(),
+    startTime: details.timeStamp || Date.now(),
+    requestBody: null,
+  }
+  networkRequests.delete(details.requestId)
+  if (!event.browserSessionId && details.tabId >= 0) {
+    event.browserSessionId =
+      sessionsByTab.get(details.tabId)?.browserSessionId || ""
+  }
+  if (!event.browserSessionId) return
+  const completedAt = new Date(details.timeStamp || Date.now()).toISOString()
+  void postBridge("/extension/network-event", {
+    ...event,
+    completedAt,
+    durationMs: Math.max(
+      0,
+      Math.round((details.timeStamp || Date.now()) - event.startTime)
+    ),
+    statusCode: details.statusCode ?? null,
+    ok: outcome.completed
+      ? details.statusCode >= 200 && details.statusCode < 400
+      : false,
+    fromCache: Boolean(details.fromCache),
+    error: outcome.error || "",
+  }).catch(() => {})
+}
+
+function isSupportedNetworkUrl(url, getPlatformMatches) {
+  return isPlatformUrl(url, {
+    platformMatches: getPlatformMatches?.() || DEFAULT_PLATFORM_MATCHES,
+  })
+}
+
+function summarizeRequestBody(requestBody) {
+  if (!requestBody) return null
+  const fieldNames = []
+  const formData = {}
+  if (requestBody.formData && typeof requestBody.formData === "object") {
+    for (const [key, values] of Object.entries(requestBody.formData)) {
+      fieldNames.push(key)
+      formData[key] = safeFormPreview(key, values)
+    }
+    return { kind: "formData", fieldNames, formData }
+  }
+  if (Array.isArray(requestBody.raw)) {
+    const rawBytes = requestBody.raw.reduce(
+      (total, item) => total + (item.bytes?.byteLength || 0),
+      0
+    )
+    return { kind: "raw", rawBytes }
+  }
+  return null
+}
+
+function safeFormPreview(key, values) {
+  if (SENSITIVE_FIELD_RE.test(String(key || ""))) return "[REDACTED]"
+  const joined = Array.isArray(values)
+    ? values.map((value) => String(value)).join(",")
+    : String(values)
+  return joined.length > 160 ? `${joined.slice(0, 160)}...` : joined
+}

package/extension/popup.css

@@ -0,0 +1,66 @@
+body {
+  width: 260px;
+  margin: 0;
+  font-family:
+    Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  color: #0f172a;
+  background: #fff;
+}
+
+main {
+  display: grid;
+  gap: 9px;
+  padding: 12px;
+}
+
+h1 {
+  margin: 0;
+  font-size: 16px;
+}
+
+p {
+  min-height: 34px;
+  margin: 0;
+  color: #475569;
+  font-size: 12px;
+  line-height: 1.4;
+  white-space: pre-wrap;
+}
+
+label {
+  display: grid;
+  gap: 4px;
+  color: #334155;
+  font-size: 12px;
+}
+
+input,
+textarea {
+  width: 100%;
+  box-sizing: border-box;
+  border: 1px solid #cbd5e1;
+  border-radius: 6px;
+  padding: 6px 7px;
+  color: #0f172a;
+  font: 12px/1.3 system-ui;
+}
+
+textarea {
+  resize: vertical;
+}
+
+button {
+  min-height: 32px;
+  border: 1px solid #cbd5e1;
+  border-radius: 7px;
+  background: #fff;
+  color: #0f172a;
+  cursor: pointer;
+  font: 500 13px/1 system-ui;
+}
+
+button:first-of-type {
+  border-color: #0f766e;
+  background: #0f766e;
+  color: white;
+}

package/extension/popup.html

@@ -0,0 +1,30 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Yunti Browser Runtime</title>
+    <link rel="stylesheet" href="popup.css" />
+  </head>
+  <body>
+    <main>
+      <h1>Yunti Browser Runtime</h1>
+      <p id="status">正在读取状态...</p>
+      <label>
+        Bridge URL
+        <input id="bridgeUrl" autocomplete="off" />
+      </label>
+      <label>
+        Bridge Token
+        <input id="bridgeToken" autocomplete="off" type="password" />
+      </label>
+      <label>
+        页面匹配
+        <textarea id="platformMatches" rows="3"></textarea>
+      </label>
+      <button id="save">保存设置</button>
+      <button id="refresh">刷新状态</button>
+    </main>
+    <script type="module" src="popup.js"></script>
+  </body>
+</html>

package/extension/popup.js

@@ -0,0 +1,55 @@
+const statusEl = document.querySelector("#status")
+const bridgeUrlEl = document.querySelector("#bridgeUrl")
+const bridgeTokenEl = document.querySelector("#bridgeToken")
+const platformMatchesEl = document.querySelector("#platformMatches")
+document.querySelector("#save").addEventListener("click", save)
+document.querySelector("#refresh").addEventListener("click", refresh)
+
+void refresh()
+
+async function refresh() {
+  const state = await send({ type: "yunti_panel_get_state" })
+  if (!state.ok) {
+    setStatus(state.error || "状态读取失败")
+    return
+  }
+  renderSettings(state.settings || {})
+  setStatus(
+    state.activeSession
+      ? `页面已连接\n${state.activeSession.title || state.activeSession.url}`
+      : "请打开任意 http/https 页面，并确认本地 bridge 已启动。"
+  )
+}
+
+async function save() {
+  const state = await send({
+    type: "yunti_panel_save_settings",
+    settings: {
+      bridgeUrl: bridgeUrlEl.value,
+      bridgeToken: bridgeTokenEl.value,
+      platformMatches: platformMatchesEl.value,
+    },
+  })
+  if (!state.ok) {
+    setStatus(state.error || "保存失败")
+    return
+  }
+  renderSettings(state.settings || {})
+  setStatus("设置已保存，请刷新目标页面完成重新注册。")
+}
+
+function renderSettings(settings) {
+  bridgeUrlEl.value = settings.bridgeUrl || "http://127.0.0.1:48887"
+  bridgeTokenEl.value = settings.bridgeToken || ""
+  platformMatchesEl.value = Array.isArray(settings.platformMatches)
+    ? settings.platformMatches.join("\n")
+    : "*"
+}
+
+function setStatus(text) {
+  statusEl.textContent = text
+}
+
+function send(message) {
+  return chrome.runtime.sendMessage(message)
+}

package/extension/session-manager.js

@@ -0,0 +1,332 @@
+import {
+  DEFAULT_BRIDGE_URL,
+  bridgeHeaders,
+  getSettings,
+  isPlatformUrl,
+  normalizeBaseUrl,
+  normalizeBridgeToken,
+  normalizePlatformMatches,
+  platformLabelForUrl,
+} from "./settings.js"
+
+export function createSessionManager() {
+  const sessionsByTab = new Map()
+  const pollers = new Map()
+  let cachedPlatformMatches = null
+  let toolRequestHandler = null
+
+  function getPlatformMatches() {
+    return cachedPlatformMatches
+  }
+
+  function setToolRequestHandler(handler) {
+    toolRequestHandler = typeof handler === "function" ? handler : null
+  }
+
+  function forgetTab(tabId) {
+    sessionsByTab.delete(tabId)
+    pollers.get(tabId)?.abort()
+    pollers.delete(tabId)
+  }
+
+  async function activateTab(tabId) {
+    const session = sessionsByTab.get(tabId)
+    if (!session) return
+    await postBridge("/sessions/activate", {
+      browserSessionId: session.browserSessionId,
+      userId: session.userId || "",
+    }).catch(() => {})
+  }
+
+  async function handleMessage(message, sender) {
+    switch (message?.type) {
+      case "yunti_content_ready":
+        return registerContentSession(sender.tab, message.page)
+      case "yunti_is_supported_page":
+        return checkSupportedPage(message.page)
+      case "yunti_panel_get_state":
+        return getPanelState()
+      case "yunti_panel_save_settings":
+        await chrome.storage.local.set({
+          localUserName: "local",
+          localUserId: "local",
+          bridgeUrl: normalizeBaseUrl(
+            message.settings?.bridgeUrl || DEFAULT_BRIDGE_URL
+          ),
+          bridgeToken: normalizeBridgeToken(message.settings?.bridgeToken || ""),
+          agentType: "browser_agent",
+          platformMatches: normalizePlatformMatches(
+            message.settings?.platformMatches
+          ),
+        })
+        return getPanelState()
+      case "yunti_panel_refresh_active":
+        return refreshActiveTab()
+      default:
+        return { ok: false, error: `unknown message: ${message?.type}` }
+    }
+  }
+
+  async function registerContentSession(tab, page) {
+    const settings = await getSettings()
+    cachedPlatformMatches = settings.platformMatches
+    if (!tab?.id || !isPlatformUrl(page?.url, settings)) {
+      return { ok: false, error: "not an Yunti tab" }
+    }
+    const browserSessionId =
+      sessionsByTab.get(tab.id)?.browserSessionId ||
+      `yunti-${tab.id}-${crypto.randomUUID ? crypto.randomUUID() : Date.now()}`
+    const session = {
+      browserSessionId,
+      userId: settings.localUserId || "",
+      displayName: settings.localUserName || "",
+      tabId: tab.id,
+      windowId: tab.windowId,
+      url: page.url,
+      title: page.title || tab.title || platformLabelForUrl(page.url),
+      client: normalizeClientInfo({
+        ...getBackgroundClientInfo(),
+        ...(page.client || {}),
+      }),
+      auth: normalizePageAuth(page.auth, "content_script_register"),
+      registeredAt: new Date().toISOString(),
+    }
+    sessionsByTab.set(tab.id, session)
+    await postBridge("/sessions/register", session).catch(() => null)
+    startPolling(tab.id)
+    return { ok: true, session, settings }
+  }
+
+  async function checkSupportedPage(page) {
+    const settings = await getSettings()
+    cachedPlatformMatches = settings.platformMatches
+    return {
+      ok: true,
+      supported: isPlatformUrl(page?.url, settings),
+      settings,
+    }
+  }
+
+  async function startPolling(tabId) {
+    if (pollers.has(tabId)) return
+    const controller = new AbortController()
+    pollers.set(tabId, controller)
+    const loop = async () => {
+      while (!controller.signal.aborted) {
+        const session = sessionsByTab.get(tabId)
+        if (!session) break
+        try {
+          const settings = await getSettings()
+          cachedPlatformMatches = settings.platformMatches
+          await postBridge("/sessions/register", session).catch(() => null)
+          const url = `${settings.bridgeUrl}/extension/poll?browserSessionId=${encodeURIComponent(
+            session.browserSessionId
+          )}&timeoutMs=25000`
+          const response = await fetch(url, {
+            signal: controller.signal,
+            headers: bridgeHeaders(settings),
+          })
+          const event = await response.json()
+          if (event?.type === "tool_request" && toolRequestHandler) {
+            await toolRequestHandler(tabId, session, event)
+          }
+        } catch {
+          if (!controller.signal.aborted) await delay(1500)
+        }
+      }
+      pollers.delete(tabId)
+    }
+    void loop()
+  }
+
+  async function forwardConsoleEvent(session, tabId, method, params = {}) {
+    let level = "log"
+    let text = ""
+    let source = "console-api"
+    let stackTrace = ""
+    let args = []
+    let url = ""
+    let lineNumber = null
+    let columnNumber = null
+
+    if (method === "Runtime.consoleAPICalled") {
+      source = "console-api"
+      level = String(params.type || "log").toLowerCase()
+      args = (params.args || []).map((arg) => {
+        if (arg.type === "string") return String(arg.value || "")
+        if (arg.type === "number" || arg.type === "boolean") {
+          return String(arg.value)
+        }
+        if (arg.type === "undefined") return "undefined"
+        if (arg.type === "null") return "null"
+        if (arg.type === "object" && arg.description) return arg.description
+        return arg.type || "unknown"
+      })
+      text = args.filter((arg) => typeof arg === "string").join(" ") || args.join(" ")
+      stackTrace = formatConsoleStackTrace(params.stackTrace)
+    } else if (method === "Log.entryAdded") {
+      source = "other"
+      const entry = params.entry || {}
+      level = String(entry.level || "verbose").toLowerCase()
+      text = String(entry.text || "").slice(0, 2000)
+      url = entry.url || ""
+      lineNumber = entry.lineNumber ?? null
+      columnNumber = entry.columnNumber ?? null
+      if (entry.stackTrace) stackTrace = formatConsoleStackTrace(entry.stackTrace)
+    }
+
+    await postBridge("/extension/console-event", {
+      browserSessionId: session.browserSessionId,
+      tabId,
+      level,
+      text: text.slice(0, 2000),
+      source,
+      stackTrace,
+      args,
+      url,
+      lineNumber,
+      columnNumber,
+      timestamp: new Date().toISOString(),
+    }).catch(() => {})
+  }
+
+  async function postBridge(path, body) {
+    const settings = await getSettings()
+    cachedPlatformMatches = settings.platformMatches
+    const response = await fetch(`${settings.bridgeUrl}${path}`, {
+      method: "POST",
+      headers: bridgeHeaders(settings),
+      body: JSON.stringify(body),
+    })
+    if (!response.ok) throw new Error(`bridge HTTP ${response.status}`)
+    return response.json()
+  }
+
+  async function getPanelState() {
+    const settings = await getSettings()
+    cachedPlatformMatches = settings.platformMatches
+    const [activeTab] = await chrome.tabs.query({
+      active: true,
+      currentWindow: true,
+    })
+    const activeSession = activeTab?.id
+      ? sessionsByTab.get(activeTab.id) || null
+      : null
+    let bridge = null
+    try {
+      const userId = encodeURIComponent(settings.localUserId || "")
+      const healthUrl = userId
+        ? `${settings.bridgeUrl}/health?userId=${userId}`
+        : `${settings.bridgeUrl}/health`
+      const response = await fetch(healthUrl, {
+        headers: bridgeHeaders(settings),
+      })
+      bridge = await response.json()
+    } catch {
+      bridge = { ok: false }
+    }
+    return {
+      ok: true,
+      settings,
+      activeTab: activeTab
+        ? {
+            id: activeTab.id,
+            url: activeTab.url,
+            title: activeTab.title,
+            windowId: activeTab.windowId,
+          }
+        : null,
+      activeSession,
+      bridge,
+    }
+  }
+
+  async function refreshActiveTab() {
+    const [tab] = await chrome.tabs.query({ active: true, currentWindow: true })
+    if (!tab?.id) return { ok: false, error: "no active tab" }
+    await chrome.tabs
+      .sendMessage(tab.id, { type: "yunti_refresh_registration" })
+      .catch(() => null)
+    return getPanelState()
+  }
+
+  return {
+    sessionsByTab,
+    pollers,
+    activateTab,
+    forgetTab,
+    forwardConsoleEvent,
+    getPlatformMatches,
+    handleMessage,
+    postBridge,
+    setToolRequestHandler,
+    startPolling,
+  }
+}
+
+function formatConsoleStackTrace(stackTrace) {
+  if (!stackTrace?.callFrames) return ""
+  return stackTrace.callFrames
+    .map(
+      (frame) =>
+        `${frame.functionName || "(anonymous)"} (${frame.url || ""}:${frame.lineNumber}:${frame.columnNumber})`
+    )
+    .join("\n")
+}
+
+function normalizePageAuth(auth, source = "unknown") {
+  if (!auth || typeof auth !== "object") {
+    return {
+      state: "missing_from_content_script",
+      loggedIn: false,
+      reason: "Content script did not report page state; reload the extension and refresh the page",
+      checkedAt: new Date().toISOString(),
+      checkedBy: source,
+    }
+  }
+  return {
+    state: String(auth.state || "unknown"),
+    loggedIn: Boolean(auth.loggedIn),
+    reason: String(auth.reason || ""),
+    checkedAt: auth.checkedAt || new Date().toISOString(),
+    checkedBy: String(auth.checkedBy || source),
+    status: auth.status ?? null,
+    apiAuthError: auth.apiAuthError || "",
+    userName: auth.userName ? String(auth.userName).slice(0, 120) : "",
+  }
+}
+
+function normalizeClientInfo(client) {
+  const value = client && typeof client === "object" ? client : {}
+  return {
+    family: normalizeBrowserFamily(value.family || value.userAgent),
+    userAgent: String(value.userAgent || "").slice(0, 500),
+    platform: String(value.platform || "").slice(0, 120),
+    language: String(value.language || "").slice(0, 80),
+  }
+}
+
+function getBackgroundClientInfo() {
+  return {
+    userAgent: String(globalThis.navigator?.userAgent || ""),
+    platform: String(globalThis.navigator?.platform || ""),
+    language: String(globalThis.navigator?.language || ""),
+  }
+}
+
+function normalizeBrowserFamily(value) {
+  const text = String(value || "").toLowerCase()
+  if (text === "edge" || /edg\//i.test(text)) return "edge"
+  if (text === "chrome" || /chrome\//i.test(text) || /chromium\//i.test(text)) {
+    return "chrome"
+  }
+  if (text === "brave" || /brave\//i.test(text)) return "brave"
+  if (text === "opera" || /opr\//i.test(text)) return "opera"
+  if (text === "firefox" || /firefox\//i.test(text)) return "firefox"
+  if (text === "safari" || /safari\//i.test(text)) return "safari"
+  return "unknown"
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}