yunti-browser-runtime 0.1.0

package/mcp/http-server.js

@@ -0,0 +1,326 @@
+import http from "node:http"
+import { randomUUID } from "node:crypto"
+import {
+  BridgeHub,
+  DEFAULT_SESSION_TTL_MS,
+  DEFAULT_TOOL_TIMEOUT_MS,
+  normalizeRouteUserId,
+} from "./bridge-hub.js"
+
+export const DEFAULT_HOST =
+  process.env.YUNTI_BROWSER_BRIDGE_HOST || "127.0.0.1"
+export const DEFAULT_PORT = Number(process.env.YUNTI_BROWSER_BRIDGE_PORT || 48887)
+export const BRIDGE_TOKEN_HEADER = "x-yunti-browser-token"
+const DEFAULT_ALLOWED_ORIGINS = [
+  "http://127.0.0.1",
+  "http://localhost",
+  "http://[::1]",
+  "chrome-extension://*",
+  "moz-extension://*",
+]
+const RELAY_URL = normalizeBaseUrl(process.env.YUNTI_BROWSER_RELAY_URL || "")
+const RELAY_TOKEN = process.env.YUNTI_BROWSER_RELAY_TOKEN || ""
+const SERVER_NAME = process.env.YUNTI_BROWSER_SERVER_NAME || "Yunti Browser Runtime"
+const _ROUTE_USER_ID = process.env.YUNTI_BROWSER_USER_ID || "local"
+const _ROUTE_USER_NAME = process.env.YUNTI_BROWSER_USER_NAME || "local"
+const MAX_JSON_BYTES = 2 * 1024 * 1024
+const SESSION_CLEANUP_INTERVAL_MS = Number(
+  process.env.YUNTI_BROWSER_SESSION_CLEANUP_INTERVAL_MS || 15_000
+)
+const PROTECTED_BRIDGE_PATHS = new Set([
+  "/sessions",
+  "/sessions/register",
+  "/sessions/activate",
+  "/extension/poll",
+  "/extension/result",
+  "/extension/network-event",
+  "/extension/cdp-event",
+  "/extension/console-event",
+  "/mcp/request",
+  "/mcp/local-tool",
+])
+
+function normalizeBaseUrl(value) {
+  return String(value || "")
+    .trim()
+    .replace(/\/+$/, "")
+}
+
+function normalizeBridgeToken(value) {
+  return String(value || "").trim()
+}
+
+function parseAllowedOrigins(value = process.env.YUNTI_BROWSER_BRIDGE_ALLOW_ORIGINS) {
+  const raw = String(value || "").trim()
+  if (!raw) return DEFAULT_ALLOWED_ORIGINS
+  return raw
+    .split(/[\n,]/)
+    .map((item) => item.trim())
+    .filter(Boolean)
+}
+
+function isLocalHttpOrigin(origin) {
+  try {
+    const url = new URL(origin)
+    return (
+      ["http:", "https:"].includes(url.protocol) &&
+      ["127.0.0.1", "localhost", "[::1]", "::1"].includes(url.hostname)
+    )
+  } catch {
+    return false
+  }
+}
+
+function originMatchesPattern(origin, pattern) {
+  if (!origin) return true
+  const pat = String(pattern || "").trim()
+  if (!pat) return false
+  if (pat === "*") return true
+  if (pat === "chrome-extension://*") return origin.startsWith("chrome-extension://")
+  if (pat === "moz-extension://*") return origin.startsWith("moz-extension://")
+  if (pat.endsWith("://*")) return origin.startsWith(pat.slice(0, -1))
+  if (origin === pat) return true
+  return isLocalHttpOrigin(origin) && isLocalHttpOrigin(pat)
+}
+
+function isAllowedOrigin(origin, allowOrigins) {
+  if (!origin) return true
+  return allowOrigins.some((pattern) => originMatchesPattern(origin, pattern))
+}
+
+function bridgeCorsHeaders(req, allowOrigins) {
+  const origin = String(req.headers.origin || "")
+  const headers = {
+    "content-type": "application/json; charset=utf-8",
+    "access-control-allow-methods": "GET,POST,OPTIONS",
+    "access-control-allow-headers": `content-type, ${BRIDGE_TOKEN_HEADER}`,
+    vary: "Origin",
+  }
+  if (isAllowedOrigin(origin, allowOrigins)) {
+    headers["access-control-allow-origin"] = origin || "null"
+  }
+  return headers
+}
+
+function sendJson(req, res, statusCode, value, { allowOrigins = DEFAULT_ALLOWED_ORIGINS } = {}) {
+  const body = JSON.stringify(value)
+  res.writeHead(statusCode, bridgeCorsHeaders(req, allowOrigins))
+  res.end(body)
+}
+
+function bridgeRequestToken(req) {
+  const headerValue = req.headers[BRIDGE_TOKEN_HEADER]
+  if (Array.isArray(headerValue)) return normalizeBridgeToken(headerValue[0])
+  if (headerValue) return normalizeBridgeToken(headerValue)
+  const authorization = String(req.headers.authorization || "")
+  const match = authorization.match(/^Bearer\s+(.+)$/i)
+  return match ? normalizeBridgeToken(match[1]) : ""
+}
+
+function isAuthorizedBridgeRequest(req, bridgeToken) {
+  const token = normalizeBridgeToken(bridgeToken)
+  return Boolean(token && bridgeRequestToken(req) === token)
+}
+
+function limitedHealth() {
+  return {
+    ok: true,
+    name: "yunti-browser-runtime-bridge",
+    authorized: false,
+    auth: {
+      required: true,
+      header: BRIDGE_TOKEN_HEADER,
+    },
+  }
+}
+
+function readJson(req) {
+  return new Promise((resolve, reject) => {
+    let total = 0
+    const chunks = []
+    req.on("data", (chunk) => {
+      total += chunk.length
+      if (total > MAX_JSON_BYTES) {
+        reject(new Error("request body too large"))
+        req.destroy()
+        return
+      }
+      chunks.push(chunk)
+    })
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString("utf8")
+      if (!raw.trim()) {
+        resolve({})
+        return
+      }
+      try {
+        resolve(JSON.parse(raw))
+      } catch (error) {
+        reject(error)
+      }
+    })
+    req.on("error", reject)
+  })
+}
+
+export async function startBridgeServer({
+  host = DEFAULT_HOST,
+  port = DEFAULT_PORT,
+  bridgeToken = null,
+  allowOrigins = parseAllowedOrigins(),
+  sessionTtlMs = DEFAULT_SESSION_TTL_MS,
+} = {}) {
+  const configuredBridgeToken = normalizeBridgeToken(
+    bridgeToken ?? process.env.YUNTI_BROWSER_BRIDGE_TOKEN
+  )
+  const activeBridgeToken = configuredBridgeToken || randomUUID()
+  const hub = new BridgeHub({ sessionTtlMs })
+  const cleanupTimer = setInterval(() => {
+    hub.cleanupExpiredSessions()
+  }, Math.max(5_000, SESSION_CLEANUP_INTERVAL_MS))
+  cleanupTimer.unref?.()
+  const server = http.createServer(async (req, res) => {
+    try {
+      const url = new URL(req.url || "/", `http://${host}:${port}`)
+      const authorized = isAuthorizedBridgeRequest(req, activeBridgeToken)
+
+      if (req.method === "OPTIONS") {
+        const origin = String(req.headers.origin || "")
+        sendJson(req, res, isAllowedOrigin(origin, allowOrigins) ? 200 : 403, { ok: true }, { allowOrigins })
+        return
+      }
+
+      if (req.method === "GET" && url.pathname === "/health") {
+        sendJson(
+          req,
+          res,
+          200,
+          authorized ? hub.health({ userId: url.searchParams.get("userId") }) : limitedHealth(),
+          { allowOrigins }
+        )
+        return
+      }
+
+      if (PROTECTED_BRIDGE_PATHS.has(url.pathname) && !authorized) {
+        sendJson(
+          req,
+          res,
+          401,
+          {
+            ok: false,
+            error: `missing or invalid ${BRIDGE_TOKEN_HEADER}`,
+            auth: { required: true, header: BRIDGE_TOKEN_HEADER },
+          },
+          { allowOrigins }
+        )
+        return
+      }
+
+      if (req.method === "GET" && url.pathname === "/sessions") {
+        const userId = url.searchParams.get("userId")
+        const sessions = hub.listSessions({ userId })
+        const activeSessionId = normalizeRouteUserId(userId)
+          ? hub.activeSessionByUser.get(normalizeRouteUserId(userId)) || null
+          : null
+        sendJson(req, res, 200, { sessions, activeSessionId, sessionCount: hub.sessions.size }, { allowOrigins })
+        return
+      }
+
+      if (req.method === "POST" && url.pathname === "/sessions/register") {
+        const body = await readJson(req)
+        const session = hub.registerSession(body)
+        sendJson(req, res, 200, { ok: true, session }, { allowOrigins })
+        return
+      }
+
+      if (req.method === "POST" && url.pathname === "/sessions/activate") {
+        const body = await readJson(req)
+        const session = hub.activateSession(String(body.browserSessionId || ""), body)
+        sendJson(req, res, 200, { ok: true, session }, { allowOrigins })
+        return
+      }
+
+      if (req.method === "GET" && url.pathname === "/extension/poll") {
+        const browserSessionId = String(url.searchParams.get("browserSessionId") || "").trim()
+        const timeoutMs = Number(url.searchParams.get("timeoutMs") || 25_000)
+        if (!browserSessionId) {
+          sendJson(req, res, 400, { error: "browserSessionId is required" }, { allowOrigins })
+          return
+        }
+        const event = await hub.poll(browserSessionId, timeoutMs)
+        sendJson(req, res, 200, event, { allowOrigins })
+        return
+      }
+
+      if (req.method === "POST" && url.pathname === "/extension/result") {
+        const body = await readJson(req)
+        const outcome = hub.submitResult(body)
+        sendJson(req, res, outcome.accepted ? 200 : 404, outcome, { allowOrigins })
+        return
+      }
+
+      if (req.method === "POST" && url.pathname === "/extension/network-event") {
+        const body = await readJson(req)
+        const outcome = hub.recordNetworkEvent(body)
+        sendJson(req, res, outcome.accepted ? 200 : 400, outcome, { allowOrigins })
+        return
+      }
+
+      if (req.method === "POST" && url.pathname === "/extension/cdp-event") {
+        const body = await readJson(req)
+        const outcome = hub.recordCdpEvent(body)
+        sendJson(req, res, outcome.accepted ? 200 : 400, outcome, { allowOrigins })
+        return
+      }
+
+      if (req.method === "POST" && url.pathname === "/extension/console-event") {
+        const body = await readJson(req)
+        const outcome = hub.recordConsoleEvent(body)
+        sendJson(req, res, outcome.accepted ? 200 : 400, outcome, { allowOrigins })
+        return
+      }
+
+      if (req.method === "POST" && url.pathname === "/mcp/local-tool") {
+        const body = await readJson(req)
+        const result = await hub.callBridgeLocalTool(String(body.tool || ""), body.arguments ?? {})
+        sendJson(req, res, 200, { ok: true, result }, { allowOrigins })
+        return
+      }
+
+      if (req.method === "POST" && url.pathname === "/mcp/request") {
+        const body = await readJson(req)
+        const result = await hub.callTool(
+          String(body.tool || ""),
+          body.arguments ?? {},
+          Number(body.timeoutMs || DEFAULT_TOOL_TIMEOUT_MS)
+        )
+        sendJson(req, res, 200, { ok: true, result }, { allowOrigins })
+        return
+      }
+
+      sendJson(req, res, 404, { error: "not found" }, { allowOrigins })
+    } catch (error) {
+      sendJson(req, res, 500, {
+        error: error instanceof Error ? error.message : String(error),
+      }, { allowOrigins })
+    }
+  })
+
+  const mode = await new Promise((resolve, reject) => {
+    server.once("error", (error) => {
+      if (error && error.code === "EADDRINUSE") {
+        resolve("proxy")
+      } else {
+        reject(error)
+      }
+    })
+    server.listen(port, host, () => resolve("owner"))
+  })
+
+  if (mode === "proxy") {
+    clearInterval(cleanupTimer)
+    server.close()
+    return { mode: "proxy", host, port, bridgeToken: configuredBridgeToken, allowOrigins, hub: null, server: null }
+  }
+  return { mode: "owner", host, port, bridgeToken: activeBridgeToken, allowOrigins, hub, server }
+}

package/mcp/json-rpc.js

@@ -0,0 +1,35 @@
+export function jsonRpcOk(id, result) {
+  return { jsonrpc: "2.0", id, result }
+}
+
+export function jsonRpcErr(id, code, message) {
+  return { jsonrpc: "2.0", id, error: { code, message } }
+}
+
+export function toolOk(value) {
+  if (value && typeof value === "object" && typeof value.dataUrl === "string") {
+    const match = value.dataUrl.match(/^data:(image\/[a-z0-9.+-]+);base64,(.+)$/i)
+    if (match) {
+      const { dataUrl: _dataUrl, ...summary } = value
+      return {
+        content: [
+          { type: "text", text: JSON.stringify(summary, null, 2) },
+          { type: "image", mimeType: match[1], data: match[2] },
+        ],
+        structuredContent: summary,
+      }
+    }
+  }
+  return {
+    content: [{ type: "text", text: JSON.stringify(value, null, 2) }],
+    structuredContent: value,
+  }
+}
+
+export function toolError(message, detail = null) {
+  const payload = detail ? `${message}\n${detail}` : message
+  return {
+    isError: true,
+    content: [{ type: "text", text: payload }],
+  }
+}

package/mcp/memory.js

@@ -0,0 +1,126 @@
+import { randomUUID } from "node:crypto"
+import { mkdir, readFile, writeFile } from "node:fs/promises"
+import { yuntiMemoryDir, yuntiMemoryFile } from "../lib/runtime-paths.js"
+import { clampNumber, redactLikelySecrets, truncateText } from "./redaction.js"
+
+const MAX_MEMORY_ITEMS = 500
+const DEFAULT_ROUTE_USER_ID = process.env.YUNTI_BROWSER_USER_ID || "local"
+
+function normalizeMemoryUserId(value) {
+  const userId = String(value || "").trim()
+  return userId && userId !== "anonymous" ? userId : ""
+}
+
+export function requireMemoryUserId(value = "") {
+  const userId = normalizeMemoryUserId(value) || normalizeMemoryUserId(DEFAULT_ROUTE_USER_ID)
+  if (!userId) {
+    throw new Error("userId is required for Yunti learning memory")
+  }
+  return userId
+}
+
+export function memoryFile(userId) {
+  return yuntiMemoryFile(requireMemoryUserId(userId))
+}
+
+function memoryDir(userId) {
+  return yuntiMemoryDir(requireMemoryUserId(userId))
+}
+
+async function readMemoryStore(userId) {
+  try {
+    const data = JSON.parse(await readFile(memoryFile(userId), "utf8"))
+    return { version: 1, memories: Array.isArray(data.memories) ? data.memories : [] }
+  } catch {
+    return { version: 1, memories: [] }
+  }
+}
+
+async function writeMemoryStore(store, userId) {
+  await mkdir(memoryDir(userId), { recursive: true })
+  const memories = store.memories.slice(-MAX_MEMORY_ITEMS)
+  await writeFile(memoryFile(userId), `${JSON.stringify({ version: 1, memories }, null, 2)}\n`)
+  return { version: 1, memories }
+}
+
+function sanitizeMemoryInput(args = {}) {
+  return {
+    id: randomUUID(),
+    kind: truncateText(args.kind || "other", 80),
+    title: redactLikelySecrets(truncateText(args.title, 300)),
+    detail: redactLikelySecrets(truncateText(args.detail, 4000)),
+    tags: Array.isArray(args.tags)
+      ? args.tags.map((x) => truncateText(x, 80)).filter(Boolean).slice(0, 20)
+      : [],
+    confidence: clampNumber(args.confidence ?? 0.5, 0, 1, 0.5),
+    source: redactLikelySecrets(truncateText(args.source || "", 500)),
+    relatedNetworkEventIds: Array.isArray(args.relatedNetworkEventIds)
+      ? args.relatedNetworkEventIds.map((x) => Number(x)).filter(Number.isFinite).slice(0, 50)
+      : [],
+    createdAt: new Date().toISOString(),
+  }
+}
+
+export async function rememberLearning(args = {}) {
+  if (!String(args.title || "").trim()) throw new Error("title is required")
+  if (!String(args.detail || "").trim()) throw new Error("detail is required")
+  const userId = requireMemoryUserId(args.userId)
+  const store = await readMemoryStore(userId)
+  const memory = sanitizeMemoryInput({ ...args, userId })
+  store.memories.push(memory)
+  await writeMemoryStore(store, userId)
+  return { remembered: true, memory }
+}
+
+export async function getLearningMemory(args = {}) {
+  const userId = requireMemoryUserId(args.userId)
+  const store = await readMemoryStore(userId)
+  const query = String(args.query || "").trim().toLowerCase()
+  const kind = String(args.kind || "").trim().toLowerCase()
+  const tags = Array.isArray(args.tags)
+    ? args.tags.map((x) => String(x).trim().toLowerCase()).filter(Boolean)
+    : []
+  const limit = clampNumber(args.limit || 50, 1, 100, 50)
+  let memories = store.memories
+  if (kind) memories = memories.filter((item) => String(item.kind || "").toLowerCase() === kind)
+  if (query) {
+    memories = memories.filter((item) =>
+      [item.title, item.detail, item.source, ...(item.tags || [])].some((value) =>
+        String(value || "").toLowerCase().includes(query)
+      )
+    )
+  }
+  if (tags.length > 0) {
+    memories = memories.filter((item) => {
+      const ownTags = new Set((item.tags || []).map((tag) => String(tag).toLowerCase()))
+      return tags.every((tag) => ownTags.has(tag))
+    })
+  }
+  memories = memories.slice(-limit).reverse()
+  return { memories, total: store.memories.length, returned: memories.length, storagePath: memoryFile(userId) }
+}
+
+export async function forgetLearningMemory(args = {}) {
+  const userId = requireMemoryUserId(args.userId)
+  const store = await readMemoryStore(userId)
+  if (args.all) {
+    if (!args.confirmed) throw new Error("confirmed=true is required to delete all learning memories")
+    const deleted = store.memories.length
+    await writeMemoryStore({ version: 1, memories: [] }, userId)
+    return { deleted }
+  }
+  const id = String(args.id || "").trim()
+  if (!id) {
+    throw new Error("id is required unless all=true and confirmed=true. Call yunti_get_learning_memory first to find the memory id.")
+  }
+  const before = store.memories.length
+  const memories = store.memories.filter((item) => item.id !== id)
+  await writeMemoryStore({ version: 1, memories }, userId)
+  const deleted = before - memories.length
+  return {
+    deleted,
+    ...(deleted
+      ? {}
+      : { message: `No learning memory found for id: ${id}. Call yunti_get_learning_memory to list current ids.` }),
+  }
+}

package/mcp/redaction.js

@@ -0,0 +1,94 @@
+const SENSITIVE_KEY_RE =
+  /cookie|authorization|token|secret|password|passwd|pwd|sid|session|ticket|tgc|captcha|验证码|密码/i
+
+export function clampNumber(value, min, max, fallback = min) {
+  const number = Number(value)
+  if (!Number.isFinite(number)) return fallback
+  return Math.max(min, Math.min(max, number))
+}
+
+export function truncateText(value, max = 1000) {
+  return String(value ?? "").slice(0, max)
+}
+
+export function redactValue(key, value) {
+  if (SENSITIVE_KEY_RE.test(String(key))) return "[REDACTED]"
+  return truncateText(value, 500)
+}
+
+export function redactLikelySecrets(text) {
+  return truncateText(text, 1500).replace(
+    /(cookie|authorization|token|secret|password|passwd|pwd|sid|session|ticket|tgc|captcha)(["'\s:=]+)([^"',\s}&]+)/gi,
+    "$1$2[REDACTED]"
+  )
+}
+
+export function sanitizeUrl(rawUrl) {
+  try {
+    const url = new URL(String(rawUrl || ""))
+    for (const key of [...url.searchParams.keys()]) {
+      const values = url.searchParams.getAll(key)
+      url.searchParams.delete(key)
+      for (const value of values) url.searchParams.append(key, redactValue(key, value))
+    }
+    return url.toString()
+  } catch {
+    return truncateText(rawUrl, 1000)
+  }
+}
+
+export function sanitizeRequestBody(body) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) return null
+  const out = {}
+  if (typeof body.kind === "string") out.kind = truncateText(body.kind, 80)
+  if (Array.isArray(body.fieldNames)) {
+    out.fieldNames = body.fieldNames.map((x) => truncateText(x, 120)).filter(Boolean)
+  }
+  if (body.formData && typeof body.formData === "object" && !Array.isArray(body.formData)) {
+    out.formData = {}
+    for (const [key, value] of Object.entries(body.formData)) {
+      out.formData[truncateText(key, 120)] = redactValue(key, value)
+    }
+  }
+  if (Number.isFinite(Number(body.rawBytes))) out.rawBytes = Number(body.rawBytes)
+  if (typeof body.preview === "string") out.preview = redactLikelySecrets(body.preview)
+  return Object.keys(out).length ? out : null
+}
+
+export function sanitizeNetworkEvent(input, id) {
+  return {
+    id,
+    browserSessionId: truncateText(input.browserSessionId, 160),
+    tabId: Number.isFinite(Number(input.tabId)) ? Number(input.tabId) : null,
+    requestId: truncateText(input.requestId, 160),
+    url: sanitizeUrl(input.url),
+    method: truncateText(input.method || "GET", 20).toUpperCase(),
+    type: truncateText(input.type, 80),
+    initiator: truncateText(input.initiator, 300),
+    documentUrl: input.documentUrl ? sanitizeUrl(input.documentUrl) : "",
+    statusCode: Number.isFinite(Number(input.statusCode)) ? Number(input.statusCode) : null,
+    ok: typeof input.ok === "boolean" ? input.ok : null,
+    fromCache: typeof input.fromCache === "boolean" ? input.fromCache : null,
+    error: input.error ? truncateText(input.error, 500) : "",
+    startedAt: truncateText(input.startedAt, 80),
+    completedAt: truncateText(input.completedAt, 80),
+    durationMs: Number.isFinite(Number(input.durationMs)) ? Math.round(Number(input.durationMs)) : null,
+    requestBody: sanitizeRequestBody(input.requestBody),
+    capturedBy: "extension.webRequest",
+  }
+}
+
+export function normalizeCdpEvent(input, id) {
+  return {
+    id,
+    browserSessionId: truncateText(input.browserSessionId, 160),
+    tabId: Number.isFinite(Number(input.tabId)) ? Number(input.tabId) : null,
+    method: truncateText(input.method, 200),
+    params:
+      input.params && typeof input.params === "object" && !Array.isArray(input.params)
+        ? input.params
+        : {},
+    receivedAt: truncateText(input.receivedAt || new Date().toISOString(), 80),
+    capturedBy: "extension.chrome.debugger",
+  }
+}