yunti-browser-runtime 0.1.0

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "yunti-browser-runtime",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Local browser runtime and MCP tools for AI agents.",
+  "license": "MIT",
+  "bin": {
+    "yunti-browser-runtime": "bin/yunti-browser-runtime.js"
+  },
+  "files": [
+    "bin/",
+    "docs/",
+    "extension/",
+    "lib/",
+    "mcp/",
+    "scripts/",
+    "skills/",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dingguangyi0/yunti-browser-runtime.git"
+  },
+  "keywords": [
+    "mcp",
+    "browser-automation",
+    "ai-agent",
+    "chrome-extension",
+    "cdp",
+    "local-first"
+  ],
+  "homepage": "https://github.com/dingguangyi0/yunti-browser-runtime#readme",
+  "bugs": {
+    "url": "https://github.com/dingguangyi0/yunti-browser-runtime/issues"
+  },
+  "packageManager": "npm@10",
+  "scripts": {
+    "mcp": "node mcp/server.js",
+    "bridge": "YUNTI_BROWSER_BRIDGE_ONLY=1 node mcp/server.js",
+    "doctor": "node scripts/doctor.js",
+    "doctor:json": "node scripts/doctor.js 2>/dev/null",
+    "print-config": "node scripts/print-config.js",
+    "package:extension": "node scripts/package-extension.js",
+    "check:metadata": "node scripts/check-package-metadata.js",
+    "release:check": "node scripts/release-check.js",
+    "release:prepublish": "npm run check:metadata && npm run release:check",
+    "release:whoami": "npm whoami --registry=https://registry.npmjs.org/",
+    "release:dry-run": "npm run release:prepublish && npm publish --dry-run --registry=https://registry.npmjs.org/",
+    "release:publish": "npm run release:prepublish && npm run release:whoami && npm publish --registry=https://registry.npmjs.org/",
+    "release:verify-published": "node scripts/check-published-package.js",
+    "test": "node --test tests/*.test.js",
+    "test:e2e": "node --test tests/e2e.test.js",
+    "check": "node --check bin/yunti-browser-runtime.js && node --check lib/runtime-paths.js && node --check mcp/server.js && node --check mcp/http-server.js && node --check mcp/bridge-hub.js && node --check mcp/tools.js && node --check mcp/redaction.js && node --check mcp/memory.js && node --check mcp/json-rpc.js && node --check scripts/doctor.js && node --check scripts/print-config.js && node --check scripts/package-extension.js && node --check scripts/check-package-metadata.js && node --check scripts/check-published-package.js && node --check scripts/release-check.js && node --check tests/e2e.test.js && node --check extension/background.js && node --check extension/cdp.js && node --check extension/session-manager.js && node --check extension/tool-handlers.js && node --check extension/settings.js && node --check extension/network-monitor.js && node --check extension/content.js && node --check extension/popup.js"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}

package/scripts/check-package-metadata.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process"
+import https from "node:https"
+import packageJson from "../package.json" with { type: "json" }
+
+const timeoutMs = Number(process.env.YUNTI_BROWSER_METADATA_CHECK_TIMEOUT_MS || 15000)
+const retryCount = Number(process.env.YUNTI_BROWSER_METADATA_CHECK_RETRIES || 2)
+
+function normalizeRepositoryUrl(value) {
+  return String(value || "")
+    .trim()
+    .replace(/^git\+/, "")
+    .replace(/\.git$/, "")
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function isRetryableHeadResult(result) {
+  return result.status === 0 || result.status >= 500
+}
+
+function requestHeadOnce(url) {
+  return new Promise((resolve) => {
+    const req = https.request(url, { method: "HEAD", timeout: timeoutMs }, (res) => {
+      const location = res.headers.location
+      if (
+        location &&
+        [301, 302, 303, 307, 308].includes(Number(res.statusCode))
+      ) {
+        resolve(requestHeadOnce(new URL(location, url).toString()))
+        return
+      }
+      resolve({
+        ok: Number(res.statusCode) >= 200 && Number(res.statusCode) < 400,
+        status: Number(res.statusCode),
+        url,
+      })
+    })
+    req.on("timeout", () => {
+      req.destroy(new Error("request timed out"))
+    })
+    req.on("error", (error) => {
+      resolve({ ok: false, status: 0, url, error: error.message })
+    })
+    req.end()
+  })
+}
+
+async function requestHead(url) {
+  let result
+  for (let attempt = 0; attempt <= retryCount; attempt += 1) {
+    result = await requestHeadOnce(url)
+    if (!isRetryableHeadResult(result)) return result
+    if (attempt < retryCount) await sleep(250 * (attempt + 1))
+  }
+  return {
+    ...result,
+    attempts: retryCount + 1,
+  }
+}
+
+function npmViewPackage(name) {
+  try {
+    const version = execFileSync("npm", ["view", name, "version", "--json"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+    }).trim()
+    return {
+      ok: true,
+      published: true,
+      version: JSON.parse(version || "null"),
+    }
+  } catch (error) {
+    const output = `${error.stdout || ""}\n${error.stderr || ""}`
+    if (output.includes("E404")) {
+      return {
+        ok: true,
+        published: false,
+        note: "Package is not currently published; this is acceptable for a first release if the name is intended.",
+      }
+    }
+    return {
+      ok: false,
+      published: false,
+      error: output.trim() || error.message,
+    }
+  }
+}
+
+const repositoryUrl = normalizeRepositoryUrl(packageJson.repository?.url)
+const homepageUrl = String(packageJson.homepage || "").trim()
+const normalizedHomepageUrl = homepageUrl.replace(/#.*$/, "")
+const bugsUrl = String(packageJson.bugs?.url || "").trim()
+
+const repositoryCheck = await requestHead(repositoryUrl)
+const homepageCheck =
+  normalizedHomepageUrl === repositoryUrl
+    ? { ...repositoryCheck, url: normalizedHomepageUrl }
+    : await requestHead(normalizedHomepageUrl)
+
+const checks = {
+  repository: repositoryCheck,
+  homepage: homepageCheck,
+  bugs: await requestHead(bugsUrl),
+  npm: npmViewPackage(packageJson.name),
+}
+
+const ok = checks.repository.ok && checks.homepage.ok && checks.bugs.ok && checks.npm.ok
+const report = {
+  ok,
+  checkedAt: new Date().toISOString(),
+  package: {
+    name: packageJson.name,
+    version: packageJson.version,
+    repository: packageJson.repository,
+    homepage: packageJson.homepage,
+    bugs: packageJson.bugs,
+  },
+  checks,
+  nextSteps: ok
+    ? []
+    : [
+        "Create or publicize the GitHub repository, or update repository/homepage/bugs in package.json to real public URLs.",
+        "If this is the first npm release, npm E404 for the package name can be accepted.",
+      ],
+}
+
+console.log(JSON.stringify(report, null, 2))
+if (!ok) process.exitCode = 1

package/scripts/check-published-package.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process"
+import packageJson from "../package.json" with { type: "json" }
+
+const registry = process.env.YUNTI_BROWSER_NPM_REGISTRY || "https://registry.npmjs.org/"
+
+function normalizeRepositoryUrl(value) {
+  const raw = typeof value === "string" ? value : value?.url
+  return String(raw || "")
+    .trim()
+    .replace(/^git\+/, "")
+    .replace(/\.git$/, "")
+}
+
+function cleanNpmError(output) {
+  return String(output || "")
+    .split("\n")
+    .filter((line) => !line.includes("A complete log of this run can be found in:"))
+    .join("\n")
+    .trim()
+}
+
+function npmView(spec) {
+  try {
+    const output = execFileSync(
+      "npm",
+      ["view", spec, "--json", `--registry=${registry}`],
+      {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+      }
+    ).trim()
+    return {
+      ok: true,
+      data: JSON.parse(output || "{}"),
+    }
+  } catch (error) {
+    const output = cleanNpmError(`${error.stdout || ""}\n${error.stderr || ""}`)
+    return {
+      ok: false,
+      unpublished: output.includes("E404"),
+      error: output || error.message,
+    }
+  }
+}
+
+const spec = `${packageJson.name}@${packageJson.version}`
+const result = npmView(spec)
+const data = result.data || {}
+
+function comparePublishedValue(actual, expected) {
+  if (!result.ok) {
+    return {
+      ok: false,
+      skipped: true,
+      reason: "package version is not published",
+      expected,
+    }
+  }
+  return {
+    ok: actual === expected,
+    expected,
+    actual,
+  }
+}
+
+const checks = {
+  published: {
+    ok: result.ok,
+    registry,
+    spec,
+    unpublished: result.unpublished || undefined,
+    error: result.ok ? undefined : result.error,
+  },
+  name: comparePublishedValue(data.name, packageJson.name),
+  version: comparePublishedValue(data.version, packageJson.version),
+  repository: comparePublishedValue(
+    normalizeRepositoryUrl(data.repository),
+    normalizeRepositoryUrl(packageJson.repository)
+  ),
+  homepage: comparePublishedValue(data.homepage, packageJson.homepage),
+  bugs: comparePublishedValue(data.bugs?.url, packageJson.bugs?.url),
+  tarball: result.ok
+    ? {
+        ok: typeof data.dist?.tarball === "string" && data.dist.tarball.includes(`${packageJson.name}-`),
+        actual: data.dist?.tarball,
+      }
+    : {
+        ok: false,
+        skipped: true,
+        reason: "package version is not published",
+      },
+}
+
+const ok = Object.values(checks).every((check) => check.ok)
+const report = {
+  ok,
+  checkedAt: new Date().toISOString(),
+  package: {
+    name: packageJson.name,
+    version: packageJson.version,
+  },
+  checks,
+  nextSteps: ok
+    ? []
+    : [
+        "Publish the package with npm run release:publish, or wait for the npm registry to reflect the just-published version.",
+        "If metadata differs, update package.json before publishing a follow-up version.",
+      ],
+}
+
+console.log(JSON.stringify(report, null, 2))
+if (!ok) process.exitCode = 1

package/scripts/doctor.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+import http from "node:http"
+import { existsSync } from "node:fs"
+import { dirname, join, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const bridgeUrl = normalizeBaseUrl(
+  process.env.YUNTI_BROWSER_BRIDGE_URL || "http://127.0.0.1:48887"
+)
+const routeUserId = process.env.YUNTI_BROWSER_USER_ID || "local"
+const bridgeToken = String(process.env.YUNTI_BROWSER_BRIDGE_TOKEN || "").trim()
+const bridgeTokenHeader = "x-yunti-browser-token"
+const rootDir = resolve(dirname(fileURLToPath(import.meta.url)), "..")
+const mcpServerPath = join(rootDir, "mcp", "server.js")
+const skillPath = join(rootDir, "skills", "yunti-browser-runtime", "SKILL.md")
+
+function normalizeBaseUrl(value) {
+  return String(value || "").trim().replace(/\/+$/, "")
+}
+
+function nodeVersionStatus() {
+  const major = Number(process.versions.node.split(".")[0])
+  return {
+    ok: Number.isFinite(major) && major >= 22,
+    version: process.version,
+    required: ">=22",
+  }
+}
+
+function getJson(url) {
+  return new Promise((resolve, reject) => {
+    const req = http.get(url, {
+      headers: bridgeToken ? { [bridgeTokenHeader]: bridgeToken } : {},
+    }, (res) => {
+      let body = ""
+      res.setEncoding("utf8")
+      res.on("data", (chunk) => {
+        body += chunk
+      })
+      res.on("end", () => {
+        try {
+          resolve({ status: res.statusCode, json: JSON.parse(body || "{}") })
+        } catch (error) {
+          reject(error)
+        }
+      })
+    })
+    req.on("error", reject)
+    req.setTimeout(3000, () => {
+      req.destroy(new Error("bridge health check timed out"))
+    })
+  })
+}
+
+async function checkBridge() {
+  try {
+    const health = await getJson(
+      `${bridgeUrl}/health?userId=${encodeURIComponent(routeUserId)}`
+    )
+    const authorized = health.json?.authorized !== false
+    const sessions = Array.isArray(health.json?.sessions) ? health.json.sessions : []
+    const activeSessionId = health.json?.activeSessionId || null
+    return {
+      ok: health.status === 200 && authorized,
+      reachable: health.status === 200,
+      authorized,
+      status: health.status,
+      url: bridgeUrl,
+      tokenConfigured: Boolean(bridgeToken),
+      tokenHeader: bridgeTokenHeader,
+      userId: routeUserId,
+      sessionCount: Number(health.json?.sessionCount || sessions.length || 0),
+      visibleSessionCount: sessions.length,
+      activeSessionId,
+      activeSession: sessions.find((session) => session.browserSessionId === activeSessionId) || null,
+      extensionConnected: sessions.length > 0,
+      raw: health.json,
+    }
+  } catch (error) {
+    return {
+      ok: false,
+      reachable: false,
+      authorized: false,
+      url: bridgeUrl,
+      tokenConfigured: Boolean(bridgeToken),
+      tokenHeader: bridgeTokenHeader,
+      userId: routeUserId,
+      error: error.message,
+      sessionCount: 0,
+      visibleSessionCount: 0,
+      activeSessionId: null,
+      activeSession: null,
+      extensionConnected: false,
+    }
+  }
+}
+
+function checkFile(path) {
+  return {
+    ok: existsSync(path),
+    path,
+  }
+}
+
+function buildNextSteps(checks) {
+  const steps = []
+  if (!checks.node.ok) {
+    steps.push("Install Node.js 22 or newer, then rerun npm run doctor.")
+  }
+  if (!checks.bridge.reachable) {
+    steps.push("Start the local bridge with npm run bridge.")
+  }
+  if (checks.bridge.reachable && !checks.bridge.authorized) {
+    steps.push("Set YUNTI_BROWSER_BRIDGE_TOKEN to the bridge token printed by npm run bridge.")
+    steps.push("Save the same token in the extension popup.")
+  }
+  if (checks.bridge.ok && !checks.bridge.extensionConnected) {
+    steps.push("Load the extension, open an http/https page, then refresh the target page.")
+  }
+  if (!checks.mcpServer.ok) {
+    steps.push(`Restore the MCP server file at ${checks.mcpServer.path}.`)
+  }
+  if (!checks.skill.ok) {
+    steps.push(`Restore the agent skill at ${checks.skill.path}.`)
+  }
+  return steps
+}
+
+function humanSummary(report) {
+  const lines = [
+    `Yunti Browser Runtime doctor: ${report.ok ? "OK" : "needs attention"}`,
+    `- Node: ${report.checks.node.version} (${report.checks.node.ok ? "ok" : "requires >=22"})`,
+    `- Bridge: ${report.checks.bridge.reachable ? report.checks.bridge.url : "not reachable"}`,
+    `- Token: ${report.checks.bridge.authorized ? "valid" : "missing or invalid"}`,
+    `- Sessions: ${report.checks.bridge.visibleSessionCount} visible, active ${report.checks.bridge.activeSessionId || "none"}`,
+    `- Extension: ${report.checks.bridge.extensionConnected ? "connected" : "not detected"}`,
+    `- MCP server: ${report.checks.mcpServer.ok ? "found" : "missing"}`,
+    `- Skill: ${report.checks.skill.ok ? "found" : "missing"}`,
+  ]
+  if (report.nextSteps.length) {
+    lines.push("Next steps:")
+    for (const step of report.nextSteps) lines.push(`- ${step}`)
+  }
+  return lines.join("\n")
+}
+
+const checks = {
+  node: nodeVersionStatus(),
+  bridge: await checkBridge(),
+  mcpServer: checkFile(mcpServerPath),
+  skill: checkFile(skillPath),
+}
+const nextSteps = buildNextSteps(checks)
+const report = {
+  ok: checks.node.ok && checks.bridge.ok && checks.mcpServer.ok && checks.skill.ok,
+  checkedAt: new Date().toISOString(),
+  checks,
+  nextSteps,
+}
+
+console.log(JSON.stringify(report, null, 2))
+console.error(humanSummary(report))
+if (!report.ok) process.exitCode = 1

package/scripts/package-extension.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+import { mkdir, rm } from "node:fs/promises"
+import { createWriteStream } from "node:fs"
+import { dirname, join, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+import { createHash } from "node:crypto"
+import { execFile } from "node:child_process"
+import { promisify } from "node:util"
+import packageJson from "../package.json" with { type: "json" }
+
+const execFileAsync = promisify(execFile)
+const rootDir = resolve(dirname(fileURLToPath(import.meta.url)), "..")
+const extensionDir = join(rootDir, "extension")
+const distDir = join(rootDir, "dist")
+const version = packageJson.version || "0.0.0"
+const zipName = `yunti-browser-runtime-extension-${version}.zip`
+const zipPath = join(distDir, zipName)
+const allowedFiles = [
+  "background.js",
+  "cdp.js",
+  "content.css",
+  "content.js",
+  "network-monitor.js",
+  "manifest.json",
+  "popup.css",
+  "popup.html",
+  "popup.js",
+  "session-manager.js",
+  "settings.js",
+  "tool-handlers.js",
+]
+
+async function zipWithSystemZip() {
+  await execFileAsync("zip", ["-X", "-q", zipPath, ...allowedFiles], {
+    cwd: extensionDir,
+  })
+}
+
+async function writeMinimalZip() {
+  const chunks = []
+  const central = []
+  let offset = 0
+
+  for (const name of allowedFiles) {
+    const data = await import("node:fs/promises").then((fs) =>
+      fs.readFile(join(extensionDir, name))
+    )
+    const nameBytes = Buffer.from(name)
+    const crc = crc32(data)
+    const localHeader = Buffer.alloc(30)
+    localHeader.writeUInt32LE(0x04034b50, 0)
+    localHeader.writeUInt16LE(20, 4)
+    localHeader.writeUInt16LE(0, 6)
+    localHeader.writeUInt16LE(0, 8)
+    localHeader.writeUInt16LE(0, 10)
+    localHeader.writeUInt16LE(0, 12)
+    localHeader.writeUInt32LE(crc, 14)
+    localHeader.writeUInt32LE(data.length, 18)
+    localHeader.writeUInt32LE(data.length, 22)
+    localHeader.writeUInt16LE(nameBytes.length, 26)
+    localHeader.writeUInt16LE(0, 28)
+    chunks.push(localHeader, nameBytes, data)
+
+    const centralHeader = Buffer.alloc(46)
+    centralHeader.writeUInt32LE(0x02014b50, 0)
+    centralHeader.writeUInt16LE(20, 4)
+    centralHeader.writeUInt16LE(20, 6)
+    centralHeader.writeUInt16LE(0, 8)
+    centralHeader.writeUInt16LE(0, 10)
+    centralHeader.writeUInt16LE(0, 12)
+    centralHeader.writeUInt16LE(0, 14)
+    centralHeader.writeUInt32LE(crc, 16)
+    centralHeader.writeUInt32LE(data.length, 20)
+    centralHeader.writeUInt32LE(data.length, 24)
+    centralHeader.writeUInt16LE(nameBytes.length, 28)
+    centralHeader.writeUInt16LE(0, 30)
+    centralHeader.writeUInt16LE(0, 32)
+    centralHeader.writeUInt16LE(0, 34)
+    centralHeader.writeUInt16LE(0, 36)
+    centralHeader.writeUInt32LE(0, 38)
+    centralHeader.writeUInt32LE(offset, 42)
+    central.push(centralHeader, nameBytes)
+    offset += localHeader.length + nameBytes.length + data.length
+  }
+
+  const centralSize = central.reduce((sum, chunk) => sum + chunk.length, 0)
+  const end = Buffer.alloc(22)
+  end.writeUInt32LE(0x06054b50, 0)
+  end.writeUInt16LE(0, 4)
+  end.writeUInt16LE(0, 6)
+  end.writeUInt16LE(allowedFiles.length, 8)
+  end.writeUInt16LE(allowedFiles.length, 10)
+  end.writeUInt32LE(centralSize, 12)
+  end.writeUInt32LE(offset, 16)
+  end.writeUInt16LE(0, 20)
+
+  await new Promise((resolvePromise, reject) => {
+    const stream = createWriteStream(zipPath)
+    stream.on("error", reject)
+    stream.on("finish", resolvePromise)
+    for (const chunk of [...chunks, ...central, end]) stream.write(chunk)
+    stream.end()
+  })
+}
+
+function crc32(buffer) {
+  let crc = 0xffffffff
+  for (const byte of buffer) {
+    crc ^= byte
+    for (let i = 0; i < 8; i += 1) {
+      crc = (crc >>> 1) ^ (0xedb88320 & -(crc & 1))
+    }
+  }
+  return (crc ^ 0xffffffff) >>> 0
+}
+
+await mkdir(distDir, { recursive: true })
+await rm(zipPath, { force: true })
+
+try {
+  await zipWithSystemZip()
+} catch {
+  await writeMinimalZip()
+}
+
+const { stat, readFile } = await import("node:fs/promises")
+const data = await readFile(zipPath)
+const info = {
+  ok: true,
+  zipPath,
+  version,
+  files: allowedFiles,
+  sizeBytes: (await stat(zipPath)).size,
+  sha256: createHash("sha256").update(data).digest("hex"),
+}
+
+console.log(JSON.stringify(info, null, 2))