@opencode/browse 0.0.3-dev.2 → 0.0.6-dev.18

package/dist/main-ha5bnd77.mjs

@@ -0,0 +1,731 @@
+// src/protocol.ts
+var extensionProtocolVersion = 3;
+var minExtensionProtocolVersion = 3;
+var unpackedExtensionId = "afeafocngkodbmaipcngoamamfmekgfo";
+var unpackedReloadAdvice = "Reload Browse on your browser's extensions page (↻).";
+var checkoutReloadPrefix = "Extension protocol incompatible: extension-older; reload ";
+var extensionReconnectAlarmPeriodMs = 30000;
+var legacyExtensionProtocolVersion = 1;
+function extensionProtocolCompatibility(value) {
+  const legacy = value === undefined;
+  const valid = typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+  const version = valid ? value : legacy ? legacyExtensionProtocolVersion : null;
+  return { version, compatible: version !== null && version >= minExtensionProtocolVersion && version <= extensionProtocolVersion, legacy };
+}
+function extensionProtocolSkew(version) {
+  if (typeof version !== "number")
+    return;
+  if (version > extensionProtocolVersion)
+    return "extension-newer";
+  if (version < minExtensionProtocolVersion)
+    return "extension-older";
+  return;
+}
+function extensionProtocolAdvice(version, commands, distribution) {
+  const skew = extensionProtocolSkew(version);
+  const versions = `extension protocol ${version ?? "unknown"}, this relay speaks ${minExtensionProtocolVersion === extensionProtocolVersion ? extensionProtocolVersion : `${minExtensionProtocolVersion} to ${extensionProtocolVersion}`}`;
+  if (skew === "extension-newer")
+    return `The Browse extension is newer than this browse CLI (${versions}). Update the CLI: run \`${commands.install}\` (an npm install with automatic updates also catches up by itself within a day), then restart opencode.`;
+  if (skew === "extension-older") {
+    const store = "The Chrome Web Store updates it within a few hours (to update now, open chrome://extensions, turn on Developer mode and click Update).";
+    const next = distribution === "unpacked" ? unpackedReloadAdvice : distribution === "store" ? store : `For an unpacked extension: ${unpackedReloadAdvice} For a store extension: ${store}`;
+    return `The Browse extension is older than this browse CLI (${versions}). ${next}`;
+  }
+  return `The Browse extension and this browse CLI don't speak the same protocol (${versions}). Run \`${commands.install}\` again and update the extension.`;
+}
+function makePageStatus(options) {
+  return {
+    state: options.state,
+    owner: options.targetOwner === "user" ? "user" : "session",
+    ...options.sessionId ? { sessionId: options.sessionId } : {},
+    ...options.sessionId && options.readOnly ? { readOnly: true } : {},
+    ...options.message ? { message: options.message } : {},
+    ...options.handoffId ? { handoffId: options.handoffId } : {},
+    ...options.recording ? { recording: true } : {}
+  };
+}
+var extensionCommandMethodValues = [
+  "ping",
+  "debugger.attach",
+  "debugger.detach",
+  "debugger.sendCommand",
+  "tabs.create",
+  "tabs.remove",
+  "tabs.group",
+  "tabs.ungroup",
+  "action.setAttached",
+  "action.setBadge",
+  "pageStatus.set",
+  "pageStatus.clear",
+  "runtime.reload",
+  "recording.start",
+  "recording.stop",
+  "recording.status",
+  "recording.cancel",
+  "tabs.cleanup",
+  "update.notice",
+  "relay.settings",
+  "settings.get",
+  "settings.set"
+];
+var extensionEventMethodValues = [
+  "protocol",
+  "hello",
+  "auth.code",
+  "auth.response",
+  "ready",
+  "toolbar.clicked",
+  "handoff.completed",
+  "debugger.event",
+  "debugger.attached",
+  "debugger.detached",
+  "tabs.removed",
+  "tabs.opened",
+  "pong",
+  "log",
+  "recording.cancelled",
+  "pageStatus.requested",
+  "settings"
+];
+function parseJsonObject(input) {
+  const parsed = JSON.parse(input);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Expected JSON object");
+  }
+  return parsed;
+}
+var extensionCommandMethods = new Set(extensionCommandMethodValues);
+var extensionEventMethods = new Set(extensionEventMethodValues);
+function isCdpRequest(input) {
+  return typeof input.id === "number" && typeof input.method === "string" && (input.params === undefined || isJsonObject(input.params)) && (input.sessionId === undefined || typeof input.sessionId === "string");
+}
+function isExtensionResponse(input) {
+  return typeof input.id === "number" && (input.result === undefined || isJsonObject(input.result)) && (input.error === undefined || typeof input.error === "string") && !(input.result !== undefined && input.error !== undefined);
+}
+function isExtensionEvent(input) {
+  return typeof input.method === "string" && extensionEventMethods.has(input.method) && (input.params === undefined || isJsonObject(input.params));
+}
+function isJsonObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/paths.ts
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function dataRoot(home = os.homedir()) {
+  const override = process.env.OPENCODE_BROWSER_HOME;
+  if (override)
+    return override;
+  if (process.platform === "win32")
+    return path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "opencode-browser");
+  const xdg = home === os.homedir() ? process.env.XDG_DATA_HOME : undefined;
+  return path.join(xdg ?? path.join(home, ".local", "share"), "opencode-browser");
+}
+var packageRoot = () => path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+var oldStoreMarker = () => path.join(dataRoot(), "old-store-extension");
+function fromCheckout() {
+  return fs.existsSync(path.join(packageRoot(), "src", "main.ts"));
+}
+function checkoutRoot() {
+  return fromCheckout() ? path.dirname(packageRoot()) : undefined;
+}
+var quoted = (value) => /^[\w@%+=:,./-]+$/.test(value) ? value : JSON.stringify(value);
+function cliCommand(args) {
+  if (fromCheckout())
+    return `node ${quoted(path.join(packageRoot(), "dist", "cli.mjs"))} ${args}`;
+  const shim = path.join(dataRoot(), "bin", "opencode-browser.mjs");
+  const versions = path.join(dataRoot(), "runtime", "versions");
+  if (!path.relative(versions, packageRoot()).startsWith("..") && fs.existsSync(shim))
+    return `node ${quoted(shim)} ${args}`;
+  return `npx @opencode/browse ${args}`;
+}
+var STORE_ITEM_ID = /^[a-p]{32}$/;
+function storeConfig(env = process.env, baked = { id: "mfnicocicmmlkpjnaffgihfjhdgjkdjg" }) {
+  const id = [env.OPENCODE_BROWSER_STORE_ID, baked?.id].find((value) => value && STORE_ITEM_ID.test(value));
+  return id ? { id } : {};
+}
+var RELEASE_SERVICE = "https://anoma.ly/release";
+function devExtension(baked = { file: "browse-extension-0.0.6-dev.18.zip", sha256: "2f8f69b9022f9835f564f96ccc5fd07c48ad78e95488eeb2a83f253d8fafbb49", size: 38413 }) {
+  return baked && /^[0-9a-f]{64}$/.test(baked.sha256) && /^[\w.-]+\.zip$/.test(baked.file) ? baked : undefined;
+}
+var devExtensionUrl = (extension, env = process.env) => `${(env.OPENCODE_BROWSER_RELEASE_SERVICE || RELEASE_SERVICE).replace(/\/+$/, "")}/browse/files/${extension.sha256}/${extension.file}`;
+var devExtensionFolder = (root = dataRoot()) => path.join(root, "extension");
+var storeUrl = (id) => `https://chromewebstore.google.com/detail/${id}`;
+function installCommand() {
+  return fromCheckout() ? `cd ${quoted(path.dirname(packageRoot()))} && bun run setup` : "npx @opencode/browse install";
+}
+
+// src/auto-update.ts
+import { spawn } from "node:child_process";
+import { chmodSync, closeSync, cpSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path2 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var PACKAGE_NAME = "@opencode/browse";
+var DAY_MS = 24 * 60 * 60 * 1000;
+var DEFAULT_REGISTRY = "https://registry.npmjs.org";
+var autoUpdateModes = ["on", "notify", "off"];
+function runtimeLayout(root = dataRoot()) {
+  const runtime = path2.join(root, "runtime");
+  return {
+    root,
+    runtime,
+    versions: path2.join(runtime, "versions"),
+    current: path2.join(runtime, "current.json"),
+    shim: path2.join(root, "bin", "opencode-browser.mjs"),
+    state: path2.join(root, "auto-update.json")
+  };
+}
+var versionDirectory = (layout, version) => path2.join(layout.versions, version);
+var versionEntry = (layout, version) => path2.join(versionDirectory(layout, version), "node_modules", "@opencode", "browse", "dist", "cli.mjs");
+var channelOf = (version) => version.includes("-dev.") ? "dev" : "latest";
+var UPDATE_VERSION = /^(\d+)\.(\d+)\.(\d+)(?:-dev\.(\d+)(?:\.(\d+))?)?$/;
+function compareVersions(left, right) {
+  const parse = (value) => {
+    const match = UPDATE_VERSION.exec(value);
+    if (!match)
+      return;
+    const release = match[4] === undefined ? 1 : 0;
+    return [Number(match[1]), Number(match[2]), Number(match[3]), release, Number(match[4] ?? 0), Number(match[5] ?? 0)];
+  };
+  const a = parse(left);
+  const b = parse(right);
+  if (!a || !b)
+    return 0;
+  for (let index = 0;index < a.length; index++)
+    if (a[index] !== b[index])
+      return a[index] < b[index] ? -1 : 1;
+  return 0;
+}
+function readJson(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return;
+  }
+}
+function writeJsonAtomic(file, value) {
+  mkdirSync(path2.dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.tmp`;
+  writeFileSync(temporary, JSON.stringify(value, null, 2) + `
+`, { mode: 384 });
+  renameSync(temporary, file);
+}
+function readCurrent(layout = runtimeLayout()) {
+  const current = readJson(layout.current);
+  return current && typeof current.version === "string" ? current : undefined;
+}
+function writeCurrent(layout, current) {
+  writeJsonAtomic(layout.current, { ...current, switchedAt: new Date().toISOString() });
+}
+function readState(layout = runtimeLayout()) {
+  return readJson(layout.state) ?? {};
+}
+function updateState(layout, change) {
+  const next = change(readState(layout));
+  writeJsonAtomic(layout.state, next);
+  return next;
+}
+var realpath = (file) => {
+  try {
+    return realpathSync(file);
+  } catch {
+    return path2.resolve(file);
+  }
+};
+function npmRuntime(options = {}) {
+  if (options.checkout ?? fromCheckout())
+    return;
+  const layout = options.layout ?? runtimeLayout();
+  const defaultEntry = () => fileURLToPath2(import.meta.url.endsWith(".ts") ? import.meta.url : new URL("./cli.mjs", import.meta.url));
+  const entry = realpath(options.entry ?? defaultEntry());
+  const relative = path2.relative(realpath(layout.versions), entry).split(path2.sep);
+  if (relative.length !== 6 || relative[0] === ".." || relative.slice(1).join("/") !== "node_modules/@opencode/browse/dist/cli.mjs")
+    return;
+  const current = readCurrent(layout);
+  if (!current)
+    return;
+  return { layout, version: relative[0], current };
+}
+function autoUpdateOverride(env = process.env) {
+  const value = env.OPENCODE_BROWSER_AUTO_UPDATE?.trim().toLowerCase();
+  if (value === "on" || value === "1" || value === "true")
+    return "on";
+  if (value === "notify")
+    return "notify";
+  if (value === "off" || value === "0" || value === "false")
+    return "off";
+  if (env.OPENCODE_BROWSER_UPDATE_CHECK === "0")
+    return "off";
+  return;
+}
+function storedMode(layout = runtimeLayout()) {
+  const mode = readState(layout).mode;
+  return mode && autoUpdateModes.includes(mode) ? mode : "on";
+}
+function effectiveMode(layout = runtimeLayout(), env = process.env) {
+  return autoUpdateOverride(env) ?? storedMode(layout);
+}
+function setStoredMode(mode, layout = runtimeLayout()) {
+  updateState(layout, (state) => ({ ...state, mode }));
+}
+function autoUpdateStatus(options = {}) {
+  const layout = options.layout ?? runtimeLayout();
+  const env = options.env ?? process.env;
+  const runtime = options.runtime === undefined ? npmRuntime({ layout }) : options.runtime;
+  const state = readState(layout);
+  const override = autoUpdateOverride(env);
+  const current = runtime?.current ?? readCurrent(layout);
+  const install = runtime ? "npm" : fromCheckout() ? "checkout" : current ? "npm" : "other";
+  return {
+    install,
+    mode: storedMode(layout),
+    effective: install === "npm" ? override ?? storedMode(layout) : "off",
+    ...override ? { overriddenBy: env.OPENCODE_BROWSER_AUTO_UPDATE !== undefined ? "OPENCODE_BROWSER_AUTO_UPDATE" : "OPENCODE_BROWSER_UPDATE_CHECK" } : {},
+    ...current ? { version: current.version, channel: current.channel } : {},
+    ...current?.previous && existsSync(versionEntry(layout, current.previous)) ? { previous: current.previous } : {},
+    ...state.latest ? { latest: state.latest } : {},
+    ...state.pending ? { pending: state.pending } : {},
+    ...state.skipped ? { skipped: state.skipped } : {},
+    ...state.checkedAt ? { checkedAt: new Date(state.checkedAt).toISOString() } : {},
+    ...state.lastUpdate ? { lastUpdate: state.lastUpdate } : {},
+    ...state.lastError ? { lastError: state.lastError } : {}
+  };
+}
+function describeAutoUpdate(status) {
+  if (status.install === "checkout")
+    return "Updates:   checkout install; `update` pulls new commits";
+  if (status.install !== "npm")
+    return "Updates:   not an installed runtime";
+  const mode = { on: "automatic", notify: "notify only", off: "off" }[status.effective];
+  const parts = [`${mode}${status.overriddenBy ? ` (set by ${status.overriddenBy})` : ""}`, `channel ${status.channel ?? "latest"}`];
+  if (status.pending)
+    parts.push(`${status.pending} installed, switches in when no agent is using the browser`);
+  else if (status.latest && status.latest === status.skipped)
+    parts.push(`skipping ${status.latest} (rolled back from it; \`update\` installs it again)`);
+  else if (status.latest && status.version && compareVersions(status.latest, status.version) > 0)
+    parts.push(`${status.latest} available`);
+  if (status.previous && status.version && compareVersions(status.previous, status.version) < 0)
+    parts.push(`\`rollback\` returns to ${status.previous}`);
+  if (status.lastError)
+    parts.push(`last attempt failed: ${status.lastError.message}`);
+  return `Updates:   ${parts.join("; ")}`;
+}
+var runCommand = (command, args, options = {}) => new Promise((resolve) => {
+  const npmCli = process.platform === "win32" && command === "npm" ? path2.join(path2.dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js") : undefined;
+  const [file, argv] = npmCli && existsSync(npmCli) ? [process.execPath, [npmCli, ...args]] : [command, args];
+  const child = spawn(file, argv, { env: options.env ?? process.env, stdio: ["ignore", "pipe", "pipe"] });
+  let stdout = "";
+  let stderr = "";
+  child.stdout.setEncoding("utf8").on("data", (chunk) => void (stdout += chunk));
+  child.stderr.setEncoding("utf8").on("data", (chunk) => void (stderr += chunk));
+  const timer = setTimeout(() => child.kill(), options.timeoutMs ?? 120000);
+  child.on("error", (error) => {
+    clearTimeout(timer);
+    resolve({ status: null, stdout, stderr: stderr + error.message });
+  });
+  child.on("close", (status) => {
+    clearTimeout(timer);
+    resolve({ status, stdout, stderr });
+  });
+});
+async function registryUrl(run = runCommand, env = process.env) {
+  const override = env.OPENCODE_BROWSER_NPM_REGISTRY?.trim();
+  const configured = override || (await run("npm", ["config", "get", "registry"], { timeoutMs: 15000 })).stdout.trim();
+  return /^https?:\/\//.test(configured) ? configured.replace(/\/+$/, "") : DEFAULT_REGISTRY;
+}
+async function fetchPublished(options) {
+  const request = options.fetch ?? fetch;
+  const response = await request(`${options.registry}/${PACKAGE_NAME.replace("/", "%2f")}`, {
+    headers: { accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8" },
+    signal: AbortSignal.timeout(20000)
+  });
+  if (!response.ok)
+    throw new Error(`the registry answered ${response.status} for ${PACKAGE_NAME}`);
+  const body = await response.json();
+  const version = body["dist-tags"]?.[options.channel];
+  if (!version)
+    throw new Error(`${PACKAGE_NAME} has no ${options.channel} dist-tag`);
+  const integrity = body.versions?.[version]?.dist?.integrity;
+  if (!integrity || !/^sha512-/.test(integrity))
+    throw new Error(`${PACKAGE_NAME}@${version} has no sha512 integrity in the registry`);
+  return { version, integrity };
+}
+function copyRunningPackage(source, prefix) {
+  const modules = path2.dirname(path2.dirname(source));
+  const seen = new Set;
+  const copy = (dir) => {
+    if (seen.has(dir))
+      return;
+    seen.add(dir);
+    const target = path2.join(prefix, "node_modules", path2.relative(modules, dir));
+    cpSync(dir, target, { recursive: true, dereference: true, filter: (file) => path2.basename(file) !== "node_modules" });
+    const manifest = path2.join(dir, "package.json");
+    const pkg = JSON.parse(readFileSync(manifest, "utf8"));
+    const require2 = createRequire(manifest);
+    for (const name of Object.keys({ ...pkg.dependencies, ...pkg.peerDependencies, ...pkg.optionalDependencies })) {
+      const dependency = require2.resolve.paths(name)?.map((parent) => path2.join(parent, name)).find((candidate) => candidate.startsWith(modules + path2.sep) && existsSync(path2.join(candidate, "package.json")));
+      if (dependency)
+        copy(dependency);
+      else if (!pkg.optionalDependencies?.[name] && !pkg.peerDependenciesMeta?.[name]?.optional)
+        throw new Error(`Missing installed dependency ${name} of ${pkg.name}`);
+    }
+  };
+  copy(source);
+}
+async function installVersion(options) {
+  const run = options.run ?? runCommand;
+  const { layout } = options;
+  const spec = options.spec ?? `${PACKAGE_NAME}@${options.version}`;
+  if (spec.startsWith("-") || /[\s"'`&|<>^%!;]/.test(spec))
+    throw new Error(`Invalid package spec ${JSON.stringify(spec)}`);
+  mkdirSync(layout.versions, { recursive: true });
+  const temporary = path2.join(layout.versions, `.install-${process.pid}-${Date.now()}`);
+  rmSync(temporary, { recursive: true, force: true });
+  mkdirSync(temporary, { recursive: true });
+  try {
+    writeFileSync(path2.join(temporary, "package.json"), `{"private":true}
+`);
+    if (options.runningPackage)
+      copyRunningPackage(options.runningPackage, temporary);
+    else {
+      const args = ["install", "--prefix", temporary, "--no-audit", "--no-fund", "--ignore-scripts", "--loglevel=error", ...options.registry ? [`--registry=${options.registry}`] : [], spec];
+      const npm = await run("npm", args, { timeoutMs: 10 * 60000 });
+      if (npm.status !== 0)
+        throw new Error(`npm install ${spec} failed: ${(npm.stderr || npm.stdout).trim().split(`
+`).slice(-3).join(" ")}`);
+    }
+    const installed = readJson(path2.join(temporary, "node_modules", "@opencode", "browse", "package.json"))?.version;
+    if (!installed)
+      throw new Error(`npm install ${spec} didn't install ${PACKAGE_NAME}`);
+    if (options.spec === undefined && installed !== options.version)
+      throw new Error(`npm installed ${installed}, not ${options.version}`);
+    if (options.integrity) {
+      const locked = readJson(path2.join(temporary, "package-lock.json"))?.packages?.["node_modules/@opencode/browse"];
+      if (locked?.integrity !== options.integrity)
+        throw new Error(`${PACKAGE_NAME}@${installed} installed with integrity ${locked?.integrity ?? "unknown"}, not the registry's ${options.integrity}`);
+    }
+    const entry = path2.join(temporary, "node_modules", "@opencode", "browse", "dist", "cli.mjs");
+    const reported = await run(options.node ?? process.execPath, [entry, "--version"], { timeoutMs: 30000, env: { ...process.env, OPENCODE_BROWSER_AUTOSTART: "0" } });
+    if (reported.status !== 0 || reported.stdout.trim() !== installed)
+      throw new Error(`${PACKAGE_NAME}@${installed} didn't run: \`--version\` printed ${JSON.stringify(reported.stdout.trim() || reported.stderr.trim()).slice(0, 200)}`);
+    const target = versionDirectory(layout, installed);
+    rmSync(target, { recursive: true, force: true });
+    renameSync(temporary, target);
+    return versionEntry(layout, installed);
+  } finally {
+    rmSync(temporary, { recursive: true, force: true });
+  }
+}
+function processAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function pruneVersions(layout, keep = []) {
+  let names = [];
+  try {
+    names = readdirSync(layout.versions);
+  } catch {
+    return;
+  }
+  const current = readCurrent(layout);
+  const kept = new Set([...keep, current?.version, current?.previous, readState(layout).pending].filter((name) => !!name));
+  for (const name of names) {
+    if (kept.has(name))
+      continue;
+    const temporary = /^\.install-(\d+)-\d+$/.exec(name);
+    if (temporary && processAlive(Number(temporary[1])))
+      continue;
+    rmSync(path2.join(layout.versions, name), { recursive: true, force: true });
+  }
+}
+function validatePending(layout) {
+  const state = readState(layout);
+  if (!state.pending || existsSync(versionEntry(layout, state.pending)))
+    return state;
+  return updateState(layout, ({ pending: _pending, ...rest }) => rest);
+}
+function switchVersion(layout, version, previous) {
+  if (!existsSync(versionEntry(layout, version)))
+    throw new Error(`${version} isn't installed in ${layout.versions}`);
+  writeCurrent(layout, { version, ...previous && previous !== version ? { previous } : {}, channel: channelOf(version) });
+  writeShim(layout);
+}
+function shimSource() {
+  return `#!/usr/bin/env node
+// Browse's stable entry, written by install (cli/src/auto-update.ts). opencode's browse MCP server runs this
+// file, so its configuration never changes when the runtime updates. Don't edit; install rewrites it.
+import { spawn } from "node:child_process"
+import { readFileSync } from "node:fs"
+import path from "node:path"
+import { createInterface } from "node:readline"
+import { fileURLToPath, pathToFileURL } from "node:url"
+
+const root = path.dirname(path.dirname(fileURLToPath(import.meta.url)))
+const runtime = path.join(root, "runtime")
+const current = () => JSON.parse(readFileSync(path.join(runtime, "current.json"), "utf8")).version
+const entry = (version) => path.join(runtime, "versions", version, "node_modules", "@opencode", "browse", "dist", "cli.mjs")
+process.env.OPENCODE_BROWSER_HOME ??= root
+const relayPort = Number(process.env.OPENCODE_BROWSER_PORT) || 19988
+
+if (process.argv[2] !== "mcp") {
+  process.argv[1] = entry(current())
+  await import(pathToFileURL(entry(current())).href)
+} else {
+  const REPLAY = "opencode-browser-shim-initialize"
+  // Every server this supervisor starts keeps one implicit session, and the relay watches this process (not the
+  // server it replaces), so an update doesn't end the agent's session or close its tabs.
+  process.env.OPENCODE_BROWSER_MCP_SESSION ??= "mcp-" + Math.random().toString(16).slice(2, 10).padEnd(8, "0")
+  process.env.OPENCODE_BROWSER_CLIENT_PID = String(process.pid)
+  let version = current()
+  let child
+  let initialize
+  let initialized
+  let swapping = false
+  let listChanged = false
+  const inflight = new Set()
+  const queue = []
+  const toClient = (line) => process.stdout.write(line + "\\n")
+  const toChild = (line) => child.stdin.write(line + "\\n")
+  const parse = (line) => { try { return JSON.parse(line) } catch { return undefined } }
+
+  const start = (replay) => {
+    const next = spawn(process.execPath, [entry(version), "mcp"], { stdio: ["pipe", "pipe", "inherit"], env: process.env })
+    // A server that exits mid-write (an old one being replaced) must not take the supervisor down with EPIPE.
+    next.stdin.on("error", () => {})
+    child = next
+    next.on("exit", (code, signal) => {
+      if (next !== child) return
+      process.exit(code ?? (signal ? 1 : 0))
+    })
+    createInterface({ input: next.stdout }).on("line", (line) => {
+      if (next !== child) return
+      const message = parse(line)
+      if (message && message.id === REPLAY) {
+        if (initialized) toChild(initialized)
+        swapping = false
+        if (listChanged) toClient(JSON.stringify({ jsonrpc: "2.0", method: "notifications/tools/list_changed" }))
+        for (const queued of queue.splice(0)) fromClient(queued)
+        return
+      }
+      if (message && message.id !== undefined && message.method === undefined) {
+        inflight.delete(message.id)
+        if (message.result && message.result.capabilities && message.result.capabilities.tools) listChanged = message.result.capabilities.tools.listChanged === true
+      }
+      toClient(line)
+      void maybeSwap()
+    })
+    if (replay && initialize) {
+      swapping = true
+      toChild(JSON.stringify({ ...initialize, id: REPLAY }))
+    }
+  }
+
+  // Once current.json names another version, new requests wait for the swap instead of reaching a server whose relay is
+  // going away (or already runs the other version); a switch that doesn't happen releases them.
+  let heldSince
+  const moved = () => { try { return current() !== version } catch { return false } }
+  const fromClient = (line) => {
+    if (swapping) return void queue.push(line)
+    if (moved()) {
+      heldSince ??= Date.now()
+      queue.push(line)
+      return void maybeSwap()
+    }
+    const message = parse(line)
+    if (message && message.method === "initialize") initialize = message
+    if (message && message.method === "notifications/initialized") initialized = line
+    if (message && message.id !== undefined && message.method !== undefined) inflight.add(message.id)
+    toChild(line)
+  }
+
+  // A new version in current.json swaps the server only once the relay runs it too (GET /version), so a server never
+  // talks to a relay of another version. With no relay at all for a few checks, nothing can mix, and it swaps.
+  let checking = false
+  let unreachable = 0
+  const relayVersion = () => fetch("http://127.0.0.1:" + relayPort + "/version", { signal: AbortSignal.timeout(2000) })
+    .then((response) => (response.ok ? response.json() : undefined))
+    .then((body) => (body && typeof body.version === "string" ? body.version : undefined), () => undefined)
+  const maybeSwap = async () => {
+    if (swapping || checking || inflight.size > 0) return
+    let next
+    try { next = current() } catch { return }
+    if (next === version) {
+      unreachable = 0
+      heldSince = undefined
+      for (const queued of queue.splice(0)) fromClient(queued)
+      return
+    }
+    checking = true
+    const running = await relayVersion()
+    checking = false
+    unreachable = running === undefined ? unreachable + 1 : 0
+    // Held requests don't wait forever for a relay that never reports the new version: they go to the current server.
+    if (running !== next && unreachable < 3) {
+      if (heldSince !== undefined && Date.now() - heldSince > 15000) {
+        heldSince = undefined
+        const released = queue.splice(0)
+        for (const line of released) { const message = parse(line); if (message && message.id !== undefined && message.method !== undefined) inflight.add(message.id); toChild(line) }
+      }
+      return
+    }
+    if (swapping || inflight.size > 0 || current() !== next) return
+    const old = child
+    version = next
+    heldSince = undefined
+    start(true)
+    old.stdin.end()
+    setTimeout(() => old.kill(), 5000).unref()
+  }
+
+  start(false)
+  createInterface({ input: process.stdin }).on("line", fromClient).on("close", () => {
+    child.stdin.end()
+    setTimeout(() => process.exit(0), 5000).unref()
+  })
+  setInterval(() => void maybeSwap(), 1000).unref()
+}
+`;
+}
+function writeShim(layout) {
+  mkdirSync(path2.dirname(layout.shim), { recursive: true });
+  const source = shimSource();
+  try {
+    if (readFileSync(layout.shim, "utf8") === source)
+      return;
+  } catch {}
+  const temporary = `${layout.shim}.${process.pid}.tmp`;
+  writeFileSync(temporary, source);
+  chmodSync(temporary, 493);
+  renameSync(temporary, layout.shim);
+}
+var INSTALL_TIMEOUT_MS = 15 * 60000;
+var SWITCH_TIMEOUT_MS = 5 * 60000;
+function createAutoUpdater(deps) {
+  const env = deps.env ?? process.env;
+  const now = deps.now ?? Date.now;
+  const { layout, version: running } = deps.runtime;
+  const checkIntervalMs = Number(env.OPENCODE_BROWSER_AUTO_UPDATE_INTERVAL_MS) || DAY_MS;
+  const spawnChild = deps.spawnChild ?? ((args, onExit) => spawnRuntimeChild(layout, versionEntry(layout, running), args, onExit, env));
+  let busy = false;
+  let switching;
+  let timer;
+  const settled = readState(layout);
+  if (settled.pending === running) {
+    updateState(layout, ({ pending: _pending, lastError: _error, ...state }) => ({ ...state, lastUpdate: { from: deps.runtime.current.previous ?? "unknown", to: running, at: new Date(now()).toISOString() } }));
+    deps.log("autoupdate.switched", { version: running, previous: deps.runtime.current.previous });
+    pruneVersions(layout, [running]);
+  }
+  async function tick() {
+    if (switching && (now() - switching.startedAt > SWITCH_TIMEOUT_MS || switching.pid !== undefined && !processAlive(switching.pid))) {
+      deps.log("autoupdate.switch_abandoned", { pid: switching.pid });
+      switching = undefined;
+    }
+    if (busy || switching)
+      return;
+    busy = true;
+    try {
+      const mode = effectiveMode(layout, env);
+      if (mode === "off")
+        return;
+      let state = validatePending(layout);
+      if (!state.checkedAt || now() - state.checkedAt >= checkIntervalMs || now() < state.checkedAt) {
+        const channel = channelOf(running);
+        try {
+          const published = await fetchPublished({ registry: await registryUrl(deps.run, env), channel, ...deps.fetch ? { fetch: deps.fetch } : {} });
+          state = updateState(layout, ({ failed: _failed, ...rest }) => ({ ...rest, checkedAt: now(), latest: published.version, integrity: published.integrity }));
+          deps.log("autoupdate.checked", { channel, latest: published.version, running });
+        } catch (error) {
+          state = updateState(layout, (rest) => ({ ...rest, checkedAt: now(), failed: error.message }));
+          deps.log("autoupdate.check_failed", { error: error.message });
+        }
+        deps.onChange?.();
+      }
+      const latest = state.latest;
+      const wanted = latest && compareVersions(latest, running) > 0 && latest !== state.skipped ? latest : undefined;
+      if (!wanted || mode !== "on")
+        return;
+      const installing = state.installing;
+      if (installing) {
+        if (processAlive(installing.pid) && now() - installing.startedAt < INSTALL_TIMEOUT_MS)
+          return;
+        const done = existsSync(versionEntry(layout, installing.version));
+        state = updateState(layout, ({ installing: _installing, ...rest }) => ({
+          ...rest,
+          ...done ? { pending: installing.version } : rest.pending === installing.version ? {} : { lastError: { message: "the installer stopped without finishing", at: new Date(now()).toISOString(), version: installing.version } }
+        }));
+        deps.log("autoupdate.installer_gone", { version: installing.version });
+      }
+      if (state.pending !== wanted) {
+        if (state.lastError?.version === wanted && now() - Date.parse(state.lastError.at) < checkIntervalMs)
+          return;
+        deps.log("autoupdate.installing", { version: wanted });
+        const pid = spawnChild(["runtime-install", wanted, ...state.integrity ? ["--integrity", state.integrity] : []], (code) => {
+          deps.log(code === 0 ? "autoupdate.installed" : "autoupdate.install_failed", { version: wanted, code });
+          deps.onChange?.();
+          if (code === 0)
+            tick();
+        });
+        if (pid)
+          updateState(layout, (rest) => ({ ...rest, installing: { version: wanted, pid, startedAt: now() } }));
+        return;
+      }
+      if (!deps.isIdle())
+        return;
+      const current = readCurrent(layout);
+      if (!current || current.version !== running)
+        return;
+      const attempt = { pid: undefined, startedAt: now() };
+      switching = attempt;
+      deps.log("autoupdate.switching", { from: running, to: wanted });
+      attempt.pid = spawnChild(["runtime-switch", wanted], (code) => {
+        if (switching === attempt)
+          switching = undefined;
+        if (code !== 0)
+          deps.log("autoupdate.restart_refused", { version: wanted, code });
+      });
+    } catch (error) {
+      deps.log("autoupdate.error", { error: error.message });
+    } finally {
+      busy = false;
+    }
+  }
+  return {
+    tick,
+    start(intervalMs = Number(env.OPENCODE_BROWSER_AUTO_UPDATE_TICK_MS) || 10 * 60000) {
+      timer = setInterval(() => void tick(), intervalMs);
+      timer.unref();
+      setTimeout(() => void tick(), Math.min(intervalMs, 60000)).unref();
+    },
+    stop() {
+      clearInterval(timer);
+    }
+  };
+}
+function spawnRuntimeChild(layout, entry, args, onExit, env = process.env) {
+  const { OPENCODE_BROWSER_MANAGED_RELAY: _managed, OPENCODE_BROWSER_RESTART_REQUEST_ID: _request, ...rest } = env;
+  mkdirSync(path2.join(layout.root, "logs"), { recursive: true });
+  const log = openSync(path2.join(layout.root, "logs", "auto-update.log"), "a", 384);
+  try {
+    const child = spawn(process.execPath, [entry, ...args], { detached: true, stdio: ["ignore", log, log], env: { ...rest, OPENCODE_BROWSER_HOME: layout.root } });
+    child.on("error", () => onExit(null));
+    child.on("exit", (code) => onExit(code));
+    child.unref();
+    return child.pid;
+  } catch {
+    onExit(null);
+    return;
+  } finally {
+    closeSync(log);
+  }
+}
+
+export { extensionProtocolVersion, minExtensionProtocolVersion, unpackedExtensionId, unpackedReloadAdvice, checkoutReloadPrefix, extensionReconnectAlarmPeriodMs, extensionProtocolCompatibility, extensionProtocolSkew, extensionProtocolAdvice, makePageStatus, parseJsonObject, isCdpRequest, isExtensionResponse, isExtensionEvent, isJsonObject, dataRoot, oldStoreMarker, fromCheckout, checkoutRoot, cliCommand, storeConfig, devExtension, devExtensionUrl, devExtensionFolder, storeUrl, installCommand, autoUpdateModes, runtimeLayout, versionEntry, channelOf, UPDATE_VERSION, compareVersions, readCurrent, writeCurrent, updateState, npmRuntime, autoUpdateOverride, storedMode, effectiveMode, setStoredMode, autoUpdateStatus, describeAutoUpdate, registryUrl, fetchPublished, installVersion, pruneVersions, switchVersion, createAutoUpdater };