farming-code 2.2.29 → 2.2.32

package/extensions/browser/backend/browser-resource-manager.cjs

@@ -0,0 +1,1486 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var browser_resource_manager_exports = {};
+__export(browser_resource_manager_exports, {
+  BrowserResourceManager: () => BrowserResourceManager,
+  browserError: () => browserError,
+  externalBrowserFailure: () => externalBrowserFailure,
+  normalizeUrl: () => normalizeUrl
+});
+module.exports = __toCommonJS(browser_resource_manager_exports);
+var storageLayout = __toESM(require("../../../backend/storage-layout.cjs"));
+var import_server_process_identity = require("../../../backend/server-process-identity.cjs");
+var import_browser_resource_store = require("./browser-resource-store.cjs");
+var import_agent_browser_runtime = require("./agent-browser-runtime.cjs");
+var import_executable_discovery = require("./executable-discovery.cjs");
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { EventEmitter } = require("events");
+const MAX_VIEWER_BUFFER_BYTES = 2 * 1024 * 1024;
+const VIEWER_RESIZE_SETTLE_MS = 80;
+const BROWSER_RECOVERY_TIMEOUT_MS = 5e3;
+const BROWSER_RECOVERY_POLL_MS = 100;
+const MAX_UPLOAD_FILES = 20;
+const INACTIVE_AGENT_STATUSES = /* @__PURE__ */ new Set(["dead", "error", "exited", "stopped"]);
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function errorCode(error) {
+  if (!error || typeof error !== "object" || !("code" in error)) return "";
+  return typeof error.code === "string" ? error.code : "";
+}
+function publicResource(resource, collectionRevision) {
+  return {
+    id: resource.id,
+    ownerType: resource.ownerType,
+    ownerAgentId: resource.ownerAgentId,
+    projectRootId: resource.projectRootId,
+    workspace: resource.workspace,
+    name: resource.name,
+    status: resource.status,
+    generation: resource.generation,
+    revision: resource.revision,
+    collectionRevision,
+    url: resource.url,
+    title: resource.title,
+    browserKind: resource.browserKind,
+    error: resource.error,
+    createdAt: resource.createdAt,
+    updatedAt: resource.updatedAt
+  };
+}
+function browserError(message, status = 400, code = "BROWSER_INVALID_REQUEST") {
+  const error = new Error(message);
+  error.status = status;
+  error.code = code;
+  return error;
+}
+function browserOwnerKey(resource) {
+  return resource.ownerType === "agent" ? `agent:${resource.ownerAgentId}` : `project:${resource.projectRootId}`;
+}
+function externalBrowserFailure(action, cause) {
+  const error = browserError(
+    `${action}; verify the Browser plugin's external CDP address and the browser's /json/version endpoint`,
+    500,
+    "BROWSER_EXTERNAL_CDP_FAILED"
+  );
+  error.cause = cause;
+  return error;
+}
+function normalizeUrl(value) {
+  const input = String(value || "").trim();
+  if (!input) return "about:blank";
+  if (input === "about:blank") return input;
+  let url = input;
+  if (!/^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(input)) {
+    const authority = input.split(/[/?#]/, 1)[0];
+    const hostname = authority.replace(/:\d+$/, "").replace(/^\[|\]$/g, "").toLowerCase();
+    const explicitPort = authority.match(/:(\d+)$/)?.[1] || "";
+    const isIpLiteral = /^\d{1,3}(?:\.\d{1,3}){3}$/.test(hostname) || authority.startsWith("[");
+    const localHost = hostname === "localhost" || hostname.endsWith(".localhost") || !hostname.includes(".") || isIpLiteral;
+    url = `${localHost || explicitPort && explicitPort !== "443" ? "http" : "https"}://${input}`;
+  }
+  try {
+    const parsed = new URL(url);
+    if (!["http:", "https:"].includes(parsed.protocol)) {
+      throw browserError("Browser navigation supports only http, https, and about:blank URLs");
+    }
+    return parsed.href;
+  } catch (error) {
+    if (error && typeof error === "object" && "status" in error) throw error;
+    throw browserError("Invalid Browser URL");
+  }
+}
+function browserSiteScope(value) {
+  const input = String(value || "").trim();
+  if (!input || input === "about:blank") return null;
+  try {
+    const parsed = new URL(normalizeUrl(input));
+    if (!["http:", "https:"].includes(parsed.protocol) || !parsed.host) return null;
+    return {
+      scopeKey: `site:${parsed.origin.toLowerCase()}`,
+      site: parsed.host.toLowerCase()
+    };
+  } catch {
+    return null;
+  }
+}
+function tabResourceName(tab) {
+  const title = String(tab?.title || "").trim();
+  if (title) return title.slice(0, 120);
+  try {
+    return new URL(String(tab?.url || "")).hostname.slice(0, 120) || "Browser";
+  } catch {
+    return "Browser";
+  }
+}
+function pathInside(root, candidate) {
+  return candidate === root || candidate.startsWith(`${root}${path.sep}`);
+}
+function resolveWorkspaceInputFile(resource, value) {
+  const workspace = fs.realpathSync(resource.workspace);
+  const requested = path.resolve(resource.workspace, String(value || ""));
+  let resolved;
+  try {
+    resolved = fs.realpathSync(requested);
+  } catch {
+    throw browserError(`Upload file does not exist: ${value}`);
+  }
+  if (!pathInside(workspace, resolved)) {
+    throw browserError("Browser uploads must stay inside the Browser Project workspace");
+  }
+  if (!fs.statSync(resolved).isFile()) {
+    throw browserError(`Browser upload path is not a file: ${value}`);
+  }
+  return resolved;
+}
+function resolveWorkspaceOutputFile(resource, value) {
+  const requestedValue = String(value || "").trim();
+  if (!requestedValue) throw browserError("Download output path is required");
+  const workspace = fs.realpathSync(resource.workspace);
+  const requested = path.resolve(resource.workspace, requestedValue);
+  if (!pathInside(path.resolve(resource.workspace), requested)) {
+    throw browserError("Browser downloads must stay inside the Browser Project workspace");
+  }
+  let parent;
+  try {
+    parent = fs.realpathSync(path.dirname(requested));
+  } catch {
+    throw browserError("Browser download parent directory does not exist");
+  }
+  if (!pathInside(workspace, parent)) {
+    throw browserError("Browser downloads must stay inside the Browser Project workspace");
+  }
+  if (fs.existsSync(requested)) {
+    throw browserError("Browser download target already exists");
+  }
+  return requested;
+}
+class BrowserResourceManager extends EventEmitter {
+  configDir;
+  store;
+  isolatedBrowserProvider;
+  discoverExecutable;
+  discoverBrowserOptions;
+  getBrowserSettings;
+  saveBrowserSelection;
+  createRuntime;
+  recoverRuntime;
+  isEnabled;
+  readProcessIdentity;
+  killProcessGroup;
+  wait;
+  scheduleTimeout;
+  cancelTimeout;
+  runtimes = /* @__PURE__ */ new Map();
+  sessions = /* @__PURE__ */ new Map();
+  operations = /* @__PURE__ */ new Map();
+  stopAdmissions = /* @__PURE__ */ new Map();
+  disposed = false;
+  runtimeCapability = null;
+  browserOptions = [];
+  isolatedBrowserCapability = null;
+  capabilityProbeSignature = "";
+  capabilityRefreshPromise = null;
+  constructor(options) {
+    super();
+    this.configDir = options.configDir;
+    this.store = options.store || new import_browser_resource_store.BrowserResourceStore(options.configDir);
+    this.isolatedBrowserProvider = options.isolatedBrowserProvider || null;
+    this.discoverExecutable = options.discoverExecutable || ((selection) => (0, import_executable_discovery.discoverBrowserRuntime)({
+      ...options,
+      ...selection
+    }));
+    this.discoverBrowserOptions = options.discoverBrowserOptions || (options.discoverExecutable ? () => [] : () => (0, import_executable_discovery.discoverBrowserExecutables)());
+    this.getBrowserSettings = typeof options.getBrowserSettings === "function" ? options.getBrowserSettings : () => ({ browserSource: "system", browserExecutablePath: "", browserExternalCdpUrl: "" });
+    this.saveBrowserSelection = typeof options.saveBrowserSelection === "function" ? options.saveBrowserSelection : () => {
+    };
+    this.createRuntime = options.createRuntime || ((input) => new import_agent_browser_runtime.AgentBrowserRuntime(input));
+    this.recoverRuntime = options.recoverRuntime || ((input) => import_agent_browser_runtime.AgentBrowserRuntime.recover(input));
+    this.isEnabled = typeof options.isEnabled === "function" ? options.isEnabled : () => true;
+    this.readProcessIdentity = options.readProcessIdentity || import_server_process_identity.readServerProcessIdentity;
+    this.killProcessGroup = options.killProcessGroup || ((processGroupId, signal) => process.kill(-processGroupId, signal));
+    this.wait = options.wait || ((durationMs) => new Promise((resolve) => setTimeout(resolve, durationMs)));
+    this.scheduleTimeout = options.scheduleTimeout || setTimeout;
+    this.cancelTimeout = options.cancelTimeout || clearTimeout;
+  }
+  async init() {
+    this.store.init();
+    await this.refreshCapability();
+    const interrupted = this.store.list().filter(
+      (resource) => Boolean(resource.processIdentity) || ["running", "starting", "stopping"].includes(resource.status)
+    );
+    const groups = /* @__PURE__ */ new Map();
+    for (const resource of interrupted) {
+      const key = resource.runtimeKind === "agent-browser" ? resource.sessionId || resource.id : resource.id;
+      const group = groups.get(key) || [];
+      group.push(resource);
+      groups.set(key, group);
+    }
+    await Promise.all([...groups.values()].map((resources) => {
+      const owner = resources.find((resource) => resource.processIdentity) || resources[0];
+      if (!owner) return Promise.resolve();
+      return this.recoverInterruptedRuntime(owner, resources);
+    }));
+  }
+  async recoverInterruptedRuntime(resource, relatedResources = [resource]) {
+    if (resource.runtimeKind === "agent-browser") {
+      const capability = this.runtimeCapability?.agentBrowserPath ? this.runtimeCapability : await this.discoverExecutable({ source: "isolated" });
+      let runtimeError = null;
+      if (!capability || capability.error || !capability.agentBrowserPath) {
+        runtimeError = new Error(
+          capability?.error || "The exact agent-browser runtime required to clean up this Browser is unavailable"
+        );
+      } else {
+        try {
+          await this.recoverRuntime({
+            id: resource.sessionId || resource.id,
+            generation: resource.sessionGeneration || resource.generation,
+            processIdentity: resource.processIdentity,
+            configDir: this.configDir,
+            profileDir: storageLayout.browserProfileDir(
+              this.configDir,
+              resource.sessionId || resource.id
+            ),
+            agentBrowserPath: capability.agentBrowserPath,
+            readProcessIdentity: this.readProcessIdentity,
+            wait: this.wait
+          });
+        } catch (error) {
+          runtimeError = error;
+        }
+      }
+      for (const related of relatedResources) {
+        this.store.update(related.id, {
+          status: "failed",
+          error: runtimeError ? `agent-browser Session cleanup failed: ${errorMessage(runtimeError)}` : "Farming restarted and cleaned up the previous Browser runtime",
+          ...!runtimeError ? { processIdentity: null } : {},
+          tabId: ""
+        });
+      }
+      return;
+    }
+    const expected = resource.processIdentity;
+    if (!expected) {
+      this.store.update(resource.id, {
+        status: "failed",
+        error: resource.browserKind === "external-cdp" ? "Farming restarted and disconnected from the external Browser" : resource.browserKind === "isolated-computer" ? "Farming restarted and stopped the isolated Browser runtime" : "Farming restarted before the Browser runtime identity was committed",
+        processIdentity: null
+      });
+      return;
+    }
+    const current = await this.readProcessIdentity(expected.pid);
+    if (!(0, import_server_process_identity.matchingProcessIdentity)(expected, current)) {
+      this.store.update(resource.id, {
+        status: "failed",
+        error: "Farming restarted after the previous Browser runtime exited",
+        processIdentity: null
+      });
+      return;
+    }
+    if (expected.processGroupId !== expected.pid) {
+      this.store.update(resource.id, {
+        status: "failed",
+        error: `Previous Browser process ${expected.pid} has an unsafe process-group identity; stop it manually`
+      });
+      return;
+    }
+    try {
+      this.killProcessGroup(expected.processGroupId, "SIGKILL");
+    } catch (error) {
+      if (errorCode(error) !== "ESRCH") {
+        const permission = errorCode(error) === "EPERM" || errorCode(error) === "EACCES";
+        this.store.update(resource.id, {
+          status: "failed",
+          error: permission ? `Farming cannot clean up previous Browser process ${expected.pid} because it lacks permission` : `Farming could not clean up previous Browser process ${expected.pid}: ${errorMessage(error)}`
+        });
+        return;
+      }
+    }
+    const startedAt = Date.now();
+    while ((0, import_server_process_identity.matchingProcessIdentity)(expected, await this.readProcessIdentity(expected.pid))) {
+      if (Date.now() - startedAt >= BROWSER_RECOVERY_TIMEOUT_MS) {
+        this.store.update(resource.id, {
+          status: "failed",
+          error: `Previous Browser process ${expected.pid} did not exit after SIGKILL`
+        });
+        return;
+      }
+      await this.wait(BROWSER_RECOVERY_POLL_MS);
+    }
+    this.store.update(resource.id, {
+      status: "failed",
+      error: "Farming restarted and cleaned up the previous Browser runtime",
+      processIdentity: null
+    });
+  }
+  capability() {
+    const executable = this.runtimeCapability;
+    const runnable = executable && !executable.error;
+    const enabled = this.isEnabled() === true;
+    const selection = this.browserSelection();
+    return {
+      enabled,
+      available: enabled && Boolean(runnable),
+      browser: runnable ? { kind: executable.kind, path: executable.path } : null,
+      selection,
+      options: this.browserOptions.map((option) => ({ kind: option.kind, path: option.path })),
+      ...this.isolatedBrowserCapability ? { isolated: this.isolatedBrowserCapability } : {},
+      message: !enabled ? "Browser extension is disabled" : executable?.error || (runnable ? "" : "Choose a local Chromium browser or prepare the isolated Browser runtime")
+    };
+  }
+  browserSelection(settings = this.getBrowserSettings()) {
+    const source = settings?.browserSource;
+    return {
+      source: source && ["external-cdp", "isolated"].includes(source) ? source : "system",
+      executablePath: String(settings?.browserExecutablePath || ""),
+      externalCdpUrl: String(settings?.browserExternalCdpUrl || "http://127.0.0.1:9222")
+    };
+  }
+  browserCapabilitySignature(selection, browserOptions, isolatedBrowserCapability = this.isolatedBrowserCapability) {
+    const executablePaths = [...new Set([
+      ...browserOptions.map((option) => option.path),
+      selection.executablePath
+    ].filter(Boolean))].sort();
+    return JSON.stringify({
+      selection,
+      options: browserOptions.map((option) => ({ kind: option.kind, path: option.path })),
+      executables: executablePaths.map((executablePath) => {
+        try {
+          const stat = fs.statSync(executablePath);
+          return { path: executablePath, size: stat.size, mtimeMs: stat.mtimeMs };
+        } catch {
+          return { path: executablePath, missing: true };
+        }
+      }),
+      isolatedBrowserCapability
+    });
+  }
+  async probeCapability(selection = this.browserSelection(), discoveredOptions, discoveredIsolatedCapability) {
+    const browserOptions = discoveredOptions || this.discoverBrowserOptions();
+    const selectedOption = browserOptions.find((option) => option.path === selection.executablePath);
+    const isolatedBrowserCapability = discoveredIsolatedCapability !== void 0 ? discoveredIsolatedCapability : this.isolatedBrowserProvider ? await this.isolatedBrowserProvider.capability() : null;
+    let runtimeCapability = await this.discoverExecutable({
+      source: selection.source,
+      executablePath: selection.executablePath,
+      executableKind: selectedOption?.kind,
+      externalCdpUrl: selection.externalCdpUrl
+    });
+    if (selection.source === "isolated" && isolatedBrowserCapability?.available === true) {
+      runtimeCapability = await this.discoverExecutable({ source: "isolated" });
+    }
+    if (selection.source === "isolated" && isolatedBrowserCapability?.available !== true) {
+      runtimeCapability = {
+        kind: "isolated-computer",
+        path: "",
+        error: isolatedBrowserCapability?.dockerAvailable === true ? "Prepare the isolated Browser runtime before selecting it" : "Docker is required for the isolated Browser"
+      };
+    }
+    return { browserOptions, isolatedBrowserCapability, runtimeCapability };
+  }
+  async refreshCapability(selection, options = {}) {
+    if (options.reuseVerified && this.capabilityRefreshPromise) {
+      return this.capabilityRefreshPromise;
+    }
+    const refresh = async () => {
+      let desiredSelection = selection || this.browserSelection();
+      const browserOptions = this.discoverBrowserOptions();
+      if (!selection && desiredSelection.source === "system" && !desiredSelection.executablePath) {
+        const defaultBrowser = browserOptions[0];
+        if (defaultBrowser) {
+          this.saveBrowserSelection({
+            source: "system",
+            executablePath: defaultBrowser.path
+          });
+          desiredSelection = {
+            ...desiredSelection,
+            executablePath: defaultBrowser.path
+          };
+        }
+      }
+      const cachedIsolatedCapability = options.reuseVerified && this.isolatedBrowserProvider ? await this.isolatedBrowserProvider.capability() : void 0;
+      const signature = this.browserCapabilitySignature(
+        desiredSelection,
+        browserOptions,
+        cachedIsolatedCapability
+      );
+      if (options.reuseVerified && signature === this.capabilityProbeSignature) {
+        this.browserOptions = browserOptions;
+        if (cachedIsolatedCapability !== void 0) {
+          this.isolatedBrowserCapability = cachedIsolatedCapability;
+        }
+        return this.runtimeCapability;
+      }
+      const probe = await this.probeCapability(
+        desiredSelection,
+        browserOptions,
+        cachedIsolatedCapability
+      );
+      this.browserOptions = browserOptions;
+      this.isolatedBrowserCapability = probe.isolatedBrowserCapability;
+      this.runtimeCapability = probe.runtimeCapability;
+      this.capabilityProbeSignature = this.browserCapabilitySignature(
+        desiredSelection,
+        probe.browserOptions,
+        probe.isolatedBrowserCapability
+      );
+      return this.runtimeCapability;
+    };
+    if (!options.reuseVerified) return refresh();
+    this.capabilityRefreshPromise = refresh().finally(() => {
+      this.capabilityRefreshPromise = null;
+    });
+    return this.capabilityRefreshPromise;
+  }
+  async prepareIsolatedBrowser() {
+    if (!this.isolatedBrowserProvider) {
+      throw browserError("The isolated Browser runtime is unavailable", 503, "ISOLATED_BROWSER_UNAVAILABLE");
+    }
+    await this.isolatedBrowserProvider.prepare();
+    await this.refreshCapability();
+    return this.capability();
+  }
+  list() {
+    this.requireEnabled();
+    return this.store.list().map((resource) => publicResource(resource, this.store.revision));
+  }
+  snapshot() {
+    this.requireEnabled();
+    return this.stateSnapshot();
+  }
+  stateSnapshot() {
+    return {
+      collectionRevision: this.store.revision,
+      resources: this.store.list().map((resource) => publicResource(resource, this.store.revision))
+    };
+  }
+  get(id) {
+    this.requireEnabled();
+    return publicResource(this.requireStored(id), this.store.revision);
+  }
+  permissionDecision(agentId, tool, input = {}) {
+    if (["browser_list", "browser_stop"].includes(tool)) {
+      return { requiresApproval: false, scopeKey: "", site: "" };
+    }
+    if (tool === "browser_open" || tool === "browser_navigate") {
+      const site2 = browserSiteScope(input.url);
+      return site2 ? { requiresApproval: true, ...site2 } : { requiresApproval: false, scopeKey: "", site: "" };
+    }
+    const browserId = String(input.browserId || "");
+    const resource = browserId ? this.store.get(browserId) : null;
+    if (!resource || resource.ownerType !== "agent" || resource.ownerAgentId !== agentId) {
+      return { requiresApproval: true, scopeKey: "", site: "" };
+    }
+    const site = browserSiteScope(resource.url);
+    return site ? { requiresApproval: true, ...site } : { requiresApproval: false, scopeKey: "", site: "" };
+  }
+  create(input) {
+    this.requireAvailable();
+    if (this.disposed) throw browserError("Browser manager is stopping", 503, "BROWSER_MANAGER_STOPPING");
+    const resource = this.store.create({
+      projectRootId: input.projectRootId,
+      workspace: input.workspace,
+      ownerType: input.ownerType,
+      ownerAgentId: input.ownerAgentId,
+      name: input.name,
+      url: normalizeUrl(input.url)
+    });
+    this.emitResource(resource);
+    return publicResource(resource, this.store.revision);
+  }
+  rename(id, name) {
+    this.requireEnabled();
+    const title = String(name || "").trim();
+    if (!title) throw browserError("Browser name is required");
+    const resource = this.requireStored(id);
+    const next = this.store.update(resource.id, {
+      name: title.slice(0, 120),
+      autoName: false
+    });
+    this.emitResource(next);
+    return publicResource(next, this.store.revision);
+  }
+  start(id) {
+    this.requireEnabled();
+    return this.enqueue(id, async () => {
+      const resource = this.requireStored(id);
+      const existingBinding = this.runtimes.get(id);
+      if (resource.status === "running" && existingBinding) {
+        return publicResource(resource, this.store.revision);
+      }
+      if (existingBinding) {
+        throw browserError(
+          "A previous Browser runtime still owns this resource; stop it before restarting",
+          409,
+          "BROWSER_RUNTIME_OWNED"
+        );
+      }
+      if (resource.status === "starting" || resource.status === "stopping") {
+        throw browserError(`Browser is ${resource.status}`, 409, "BROWSER_BUSY");
+      }
+      if (resource.processIdentity) {
+        const blockedIdentity = resource.processIdentity;
+        throw browserError(
+          `Previous Browser process ${blockedIdentity.pid} still requires cleanup`,
+          409,
+          "BROWSER_RECOVERY_CLEANUP_REQUIRED"
+        );
+      }
+      const executable = await this.refreshCapability();
+      if (!executable || executable.error || !executable.agentBrowserPath) {
+        const failed = this.store.update(id, {
+          status: "failed",
+          error: executable?.error || "Choose a local Chromium browser or prepare the isolated Browser runtime"
+        });
+        this.emitResource(failed);
+        throw browserError(failed.error, 503, "BROWSER_EXECUTABLE_NOT_FOUND");
+      }
+      const generation = resource.generation + 1;
+      const starting = this.store.update(id, {
+        status: "starting",
+        generation,
+        browserKind: executable.kind,
+        runtimeKind: "agent-browser",
+        error: "",
+        processIdentity: null
+      });
+      this.emitResource(starting);
+      const reusableSession = [...this.sessions.values()].find((session2) => !session2.closing && session2.ownerKey === browserOwnerKey(resource) && session2.projectRootId === resource.projectRootId && session2.browserKind === executable.kind);
+      if (reusableSession) {
+        try {
+          let running;
+          let binding2;
+          const operation = (reusableSession.actionChain || Promise.resolve()).catch(() => {
+          }).then(async () => {
+            const tab = await reusableSession.runtime.createTab(
+              resource.url,
+              ["external-cdp", "isolated-computer"].includes(executable.kind) ? `farming-${resource.id}-g${generation}` : ""
+            );
+            binding2 = this.createBinding(reusableSession, {
+              ...starting,
+              tabId: tab.tabId
+            });
+            reusableSession.bindings.set(id, binding2);
+            reusableSession.activeResourceId = id;
+            this.runtimes.set(id, binding2);
+            running = this.store.update(id, {
+              status: "running",
+              sessionId: reusableSession.id,
+              sessionGeneration: reusableSession.generation,
+              tabId: tab.tabId,
+              url: tab.url || resource.url,
+              title: tab.title || "",
+              error: "",
+              processIdentity: null
+            });
+          });
+          reusableSession.actionChain = operation;
+          await operation;
+          if (!running || !binding2) {
+            throw browserError("Browser tab creation did not commit ownership", 500, "BROWSER_START_FAILED");
+          }
+          this.emitResource(running);
+          this.broadcastRuntimeState(binding2);
+          return publicResource(running, this.store.revision);
+        } catch (error) {
+          const failed = this.store.update(id, {
+            status: "failed",
+            error: errorMessage(error) || "Failed to create Browser tab",
+            tabId: ""
+          });
+          this.emitResource(failed);
+          throw browserError(failed.error, 500, "BROWSER_START_FAILED");
+        }
+      }
+      const sessionId = resource.sessionId || id;
+      const previousSessionGeneration = this.store.list().filter((candidate) => candidate.sessionId === sessionId).reduce((maximum, candidate) => Math.max(maximum, candidate.sessionGeneration || 0), 0);
+      const sessionGeneration = previousSessionGeneration + 1;
+      let isolatedLeaseKey = "";
+      let externalCdpUrl = executable.cdpUrl || "";
+      if (executable.kind === "isolated-computer") {
+        try {
+          if (!this.isolatedBrowserProvider) {
+            throw browserError(
+              "The isolated Browser runtime is unavailable",
+              503,
+              "ISOLATED_BROWSER_UNAVAILABLE"
+            );
+          }
+          const isolated = await this.isolatedBrowserProvider.acquire({
+            ownerAgentId: resource.ownerAgentId,
+            ownerKey: browserOwnerKey(resource),
+            projectRootId: resource.projectRootId,
+            workspace: resource.workspace
+          });
+          externalCdpUrl = isolated.cdpUrl;
+          isolatedLeaseKey = isolated.leaseKey;
+        } catch (error) {
+          const failed = this.store.update(id, {
+            status: "failed",
+            error: errorMessage(error) || "Failed to start the isolated Browser runtime"
+          });
+          this.emitResource(failed);
+          throw error;
+        }
+      }
+      let runtime;
+      try {
+        runtime = this.createRuntime({
+          id: sessionId,
+          generation: sessionGeneration,
+          configDir: this.configDir,
+          agentBrowserPath: executable.agentBrowserPath,
+          executablePath: executable.path,
+          externalCdpUrl,
+          profileDir: storageLayout.browserProfileDir(this.configDir, sessionId)
+        });
+      } catch (error) {
+        if (isolatedLeaseKey && this.isolatedBrowserProvider) {
+          await this.isolatedBrowserProvider.release(isolatedLeaseKey).catch(() => null);
+        }
+        const failed = this.store.update(id, {
+          status: "failed",
+          error: errorMessage(error) || "Failed to create Browser runtime"
+        });
+        this.emitResource(failed);
+        throw error;
+      }
+      const session = {
+        id: sessionId,
+        generation: sessionGeneration,
+        projectRootId: resource.projectRootId,
+        ownerKey: browserOwnerKey(resource),
+        browserKind: executable.kind,
+        runtime,
+        bindings: /* @__PURE__ */ new Map(),
+        activeResourceId: id,
+        processOwnerResourceId: id,
+        actionChain: Promise.resolve(),
+        reconcilingTabs: Promise.resolve(),
+        initializing: true,
+        isolatedLeaseKey,
+        closing: false
+      };
+      const binding = this.createBinding(session, starting);
+      session.bindings.set(id, binding);
+      this.sessions.set(sessionId, session);
+      this.runtimes.set(id, binding);
+      this.bindSession(session);
+      try {
+        const metadata = await runtime.start(resource.url);
+        const tabs = await runtime.listTabs();
+        const tab = tabs.find((candidate) => candidate.active) || tabs[0];
+        if (!tab) throw new Error("agent-browser did not report the Browser tab");
+        binding.tabId = tab.tabId;
+        if (this.runtimes.get(id) !== binding) {
+          throw browserError("Browser startup lost runtime ownership", 409, "BROWSER_START_REPLACED");
+        }
+        const running = this.store.update(id, {
+          status: "running",
+          sessionId,
+          sessionGeneration,
+          tabId: tab.tabId,
+          url: metadata.url || resource.url,
+          title: metadata.title || "",
+          error: ""
+        });
+        session.initializing = false;
+        this.emitResource(running);
+        this.broadcastRuntimeState(binding);
+        return publicResource(running, this.store.revision);
+      } catch (error) {
+        session.initializing = false;
+        let cleanupError = null;
+        try {
+          await runtime.close();
+        } catch (closeError) {
+          cleanupError = closeError;
+        }
+        if (!cleanupError && isolatedLeaseKey && this.isolatedBrowserProvider) {
+          try {
+            await this.isolatedBrowserProvider.release(isolatedLeaseKey);
+          } catch (releaseError) {
+            cleanupError = releaseError;
+          }
+        }
+        if (!cleanupError && this.runtimes.get(id) === binding) this.runtimes.delete(id);
+        if (!cleanupError && this.sessions.get(sessionId) === session) this.sessions.delete(sessionId);
+        const current = this.store.get(id);
+        const failureMessage = executable.kind === "external-cdp" ? externalBrowserFailure("External Browser connection failed", error).message : executable.kind === "isolated-computer" ? `Isolated Browser connection failed: ${errorMessage(error)}` : errorMessage(error) || "Failed to start Browser";
+        const failed = current?.generation === generation ? this.store.update(id, {
+          status: "failed",
+          error: cleanupError ? `${failureMessage}; cleanup failed` : failureMessage,
+          tabId: "",
+          ...!cleanupError ? { processIdentity: null } : {}
+        }) : null;
+        if (failed) this.emitResource(failed);
+        throw browserError(
+          failed?.error || errorMessage(error) || "Failed to start Browser",
+          500,
+          "BROWSER_START_FAILED"
+        );
+      }
+    });
+  }
+  stop(id, internal = false) {
+    if (!internal) this.requireEnabled();
+    this.stopAdmissions.set(id, (this.stopAdmissions.get(id) || 0) + 1);
+    return this.enqueue(id, async () => {
+      const resource = this.requireStored(id);
+      const binding = this.runtimes.get(id);
+      if (!binding) {
+        if (resource.processIdentity) {
+          await this.recoverInterruptedRuntime(resource);
+          const recovered = this.requireStored(id);
+          if (recovered.processIdentity) {
+            const blockedIdentity = recovered.processIdentity;
+            throw browserError(
+              recovered.error || `Previous Browser process ${blockedIdentity.pid} still requires cleanup`,
+              500,
+              "BROWSER_RECOVERY_CLEANUP_REQUIRED"
+            );
+          }
+        }
+        const stopped2 = this.store.update(id, {
+          status: "stopped",
+          error: "",
+          processIdentity: null
+        });
+        this.emitResource(stopped2);
+        return publicResource(stopped2, this.store.revision);
+      }
+      const stopping = this.store.update(id, { status: "stopping", error: "" });
+      this.emitResource(stopping);
+      this.broadcastRuntimeState(binding);
+      const { session } = binding;
+      session.closing = session.bindings.size === 1;
+      let isolatedReleaseError = null;
+      try {
+        const closeOperation = (session.actionChain || Promise.resolve()).catch(() => {
+        }).then(() => session.bindings.size > 1 ? session.runtime.closeTab(binding.tabId) : session.runtime.close());
+        session.actionChain = closeOperation;
+        await closeOperation;
+        if (session.bindings.size === 1 && session.isolatedLeaseKey && this.isolatedBrowserProvider) {
+          try {
+            await this.isolatedBrowserProvider.release(session.isolatedLeaseKey);
+            session.isolatedLeaseKey = "";
+          } catch (error) {
+            isolatedReleaseError = error;
+          }
+        }
+      } catch (error) {
+        session.closing = false;
+        if (resource.browserKind === "external-cdp") {
+          throw externalBrowserFailure("External Browser targets could not be closed", error);
+        }
+        throw error;
+      }
+      if (isolatedReleaseError) {
+        session.closing = false;
+        const failed = this.store.update(id, {
+          status: "failed",
+          error: `Browser closed, but its isolated container could not be stopped: ${errorMessage(isolatedReleaseError)}`
+        });
+        this.emitResource(failed);
+        this.broadcastRuntimeState(binding);
+        throw browserError(failed.error, 500, "ISOLATED_BROWSER_RELEASE_FAILED");
+      }
+      session.bindings.delete(id);
+      if (this.runtimes.get(id) === binding) this.runtimes.delete(id);
+      if (session.bindings.size === 0 && this.sessions.get(session.id) === session) {
+        this.sessions.delete(session.id);
+      }
+      session.closing = false;
+      if (session.processOwnerResourceId === id && session.bindings.size > 0) {
+        const nextOwner = session.bindings.values().next().value;
+        if (!nextOwner) throw new Error("Browser Session lost its remaining resource owner");
+        session.processOwnerResourceId = nextOwner.id;
+        const ownerResource = this.store.update(nextOwner.id, {
+          processIdentity: resource.processIdentity
+        });
+        this.emitResource(ownerResource);
+        this.broadcastRuntimeState(nextOwner);
+      }
+      const stopped = this.store.update(id, {
+        status: "stopped",
+        error: "",
+        processIdentity: null,
+        tabId: ""
+      });
+      this.emitResource(stopped);
+      this.broadcastRuntimeState(binding);
+      this.releaseViewerState(binding);
+      return publicResource(stopped, this.store.revision);
+    }).finally(() => {
+      const remainingStops = (this.stopAdmissions.get(id) || 1) - 1;
+      if (remainingStops > 0) this.stopAdmissions.set(id, remainingStops);
+      else this.stopAdmissions.delete(id);
+    });
+  }
+  async delete(id, internal = false) {
+    if (!internal) this.requireEnabled();
+    await this.stop(id, internal);
+    const resource = this.requireStored(id);
+    const ownerKey = browserOwnerKey(resource);
+    const deletesLastIsolatedOwner = resource.browserKind === "isolated-computer" && this.isolatedBrowserProvider && !this.store.list().some((candidate) => candidate.id !== resource.id && candidate.browserKind === "isolated-computer" && browserOwnerKey(candidate) === ownerKey);
+    if (deletesLastIsolatedOwner) {
+      await this.isolatedBrowserProvider.deleteOwner(ownerKey);
+    }
+    this.store.delete(id);
+    const sessionId = resource.sessionId || id;
+    const profileDir = storageLayout.browserProfileDir(this.configDir, sessionId);
+    const browsersDir = path.resolve(storageLayout.browserResourcesDir(this.configDir));
+    const resourceDir = path.resolve(profileDir, "..");
+    const sessionStillReferenced = this.store.list().some((candidate) => candidate.sessionId === sessionId);
+    if (!sessionStillReferenced && resourceDir.startsWith(`${browsersDir}${path.sep}`) && import_browser_resource_store.RESOURCE_ID_RE.test(sessionId)) {
+      fs.rmSync(resourceDir, { recursive: true, force: true });
+    }
+    this.emit("deleted", { id, collectionRevision: this.store.revision });
+    return { id, collectionRevision: this.store.revision };
+  }
+  navigate(id, url) {
+    this.requireEnabled();
+    const normalized = normalizeUrl(url);
+    return this.withRuntime(id, async (runtime, binding) => {
+      const metadata = await runtime.navigate(normalized);
+      this.updateMetadata(binding, metadata);
+      return this.get(id);
+    });
+  }
+  goBack(id) {
+    return this.withRuntime(id, async (runtime, binding) => {
+      const metadata = await runtime.goBack();
+      this.updateMetadata(binding, metadata);
+      return this.get(id);
+    });
+  }
+  goForward(id) {
+    return this.withRuntime(id, async (runtime, binding) => {
+      const metadata = await runtime.goForward();
+      this.updateMetadata(binding, metadata);
+      return this.get(id);
+    });
+  }
+  reload(id) {
+    return this.withRuntime(id, async (runtime, binding) => {
+      const metadata = await runtime.reload();
+      this.updateMetadata(binding, metadata);
+      return this.get(id);
+    });
+  }
+  action(id, input) {
+    this.requireEnabled();
+    const kind = String(input?.kind || "").trim();
+    if (kind === "snapshot") return this.withRuntime(id, (runtime) => runtime.snapshot());
+    if (kind === "screenshot") return this.withRuntime(id, (runtime) => runtime.screenshot());
+    if (kind === "navigate") return this.navigate(id, input.url);
+    if (kind === "back") return this.goBack(id);
+    if (kind === "forward") return this.goForward(id);
+    if (kind === "reload") return this.reload(id);
+    if (kind === "click") return this.withRuntime(id, (runtime) => runtime.click(input));
+    if ([
+      "dblclick",
+      "hover",
+      "focus",
+      "check",
+      "uncheck",
+      "scrollintoview",
+      "highlight"
+    ].includes(kind)) {
+      return this.withRuntime(id, (runtime) => runtime.elementAction(kind, input));
+    }
+    if (kind === "type") return this.withRuntime(id, (runtime) => runtime.type(input, false));
+    if (kind === "fill") return this.withRuntime(id, (runtime) => runtime.type(input, true));
+    if (kind === "keyboard") return this.withRuntime(id, (runtime) => runtime.keyboard(input));
+    if (kind === "press") return this.withRuntime(id, (runtime) => runtime.press(input));
+    if (kind === "select") return this.withRuntime(id, (runtime) => runtime.select(input));
+    if (kind === "drag") return this.withRuntime(id, (runtime) => runtime.drag(input));
+    if (kind === "wait") return this.withRuntime(id, (runtime) => runtime.waitFor(input));
+    if (kind === "get") return this.withRuntime(id, (runtime) => runtime.get(input));
+    if (kind === "is") return this.withRuntime(id, (runtime) => runtime.is(input));
+    if (kind === "find") return this.withRuntime(id, (runtime) => runtime.find(input));
+    if (kind === "eval") return this.withRuntime(id, (runtime) => runtime.evaluate(input));
+    if (kind === "console" || kind === "errors") {
+      return this.withRuntime(id, (runtime) => runtime.debugLog(kind, input));
+    }
+    if (kind === "network") return this.withRuntime(id, (runtime) => runtime.network(input));
+    if (kind === "cookies") return this.withRuntime(id, (runtime) => runtime.cookies(input));
+    if (kind === "storage") return this.withRuntime(id, (runtime) => runtime.storage(input));
+    if (kind === "frame") return this.withRuntime(id, (runtime) => runtime.frame(input));
+    if (kind === "dialog") return this.withRuntime(id, (runtime) => runtime.dialog(input));
+    if (kind === "upload") {
+      const resource = this.requireStored(id);
+      const requestedFiles = Array.isArray(input?.files) ? input.files : [];
+      if (requestedFiles.length === 0 || requestedFiles.length > MAX_UPLOAD_FILES) {
+        throw browserError(`Browser upload requires between 1 and ${MAX_UPLOAD_FILES} files`);
+      }
+      const files = requestedFiles.map((file) => resolveWorkspaceInputFile(resource, file));
+      return this.withRuntime(id, (runtime) => runtime.upload({ ...input, files }));
+    }
+    if (kind === "download") {
+      const resource = this.requireStored(id);
+      const target = resolveWorkspaceOutputFile(resource, input?.path);
+      return this.withRuntime(id, async (runtime) => {
+        const resourceDir = path.dirname(storageLayout.browserProfileDir(
+          this.configDir,
+          resource.sessionId || id
+        ));
+        const downloadDir = path.join(resourceDir, "downloads");
+        fs.mkdirSync(downloadDir, { recursive: true, mode: 448 });
+        const temporaryPath = path.join(
+          downloadDir,
+          `${crypto.randomUUID()}-${path.basename(target)}`
+        );
+        try {
+          await runtime.download({ ...input, outputPath: temporaryPath });
+          const stat = fs.statSync(temporaryPath);
+          if (!stat.isFile()) throw browserError("Browser download did not produce a regular file");
+          fs.copyFileSync(temporaryPath, target, fs.constants.COPYFILE_EXCL);
+          return {
+            ok: true,
+            path: path.relative(resource.workspace, target) || path.basename(target),
+            size: stat.size
+          };
+        } finally {
+          fs.rmSync(temporaryPath, { force: true });
+        }
+      });
+    }
+    if (kind === "scroll") return this.withRuntime(id, async (runtime) => {
+      await runtime.wheel(input);
+      return { ok: true };
+    });
+    throw browserError(`Unsupported Browser action: ${kind || "(missing)"}`);
+  }
+  attachViewer(id, ws) {
+    this.requireEnabled();
+    const resource = this.requireStored(id);
+    const binding = this.runtimes.get(id);
+    ws.send(JSON.stringify({
+      type: "browser-state",
+      resource: publicResource(resource, this.store.revision)
+    }));
+    if (!binding || resource.status !== "running") return () => {
+    };
+    binding.viewers.add(ws);
+    if (binding.latestFrame) ws.send(JSON.stringify(binding.latestFrame));
+    void this.withRuntime(id, () => {
+    }).catch((error) => {
+      if (ws.readyState === 1) {
+        ws.send(JSON.stringify({ type: "browser-error", message: errorMessage(error) || "Browser tab failed" }));
+      }
+    });
+    const onMessage = (raw) => {
+      let message;
+      try {
+        message = JSON.parse(raw.toString());
+      } catch {
+        return;
+      }
+      const operation = message.type === "resize" ? this.scheduleViewerResize(binding, ws, message) : this.handleViewerMessage(binding, ws, message);
+      void Promise.resolve(operation).catch((error) => {
+        if (ws.readyState === 1) {
+          ws.send(JSON.stringify({ type: "browser-error", message: errorMessage(error) || "Browser input failed" }));
+        }
+      });
+    };
+    ws.on("message", onMessage);
+    const detach = () => {
+      binding.viewers.delete(ws);
+      binding.viewerGeometries.delete(ws);
+      if (binding.viewerViewportOwner === ws) {
+        binding.viewerViewportOwner = binding.viewers.values().next().value || null;
+        if (binding.viewerViewportOwner) {
+          const geometry = binding.viewerGeometries.get(binding.viewerViewportOwner);
+          if (geometry) {
+            void this.scheduleViewerResize(binding, binding.viewerViewportOwner, geometry).catch(() => {
+            });
+          }
+        } else {
+          this.clearViewerResize(binding);
+        }
+      }
+      ws.off("message", onMessage);
+    };
+    ws.once("close", detach);
+    return detach;
+  }
+  handleViewerMessage(binding, viewer, message) {
+    const resource = this.requireStored(binding.id);
+    if (resource.status !== "running" || this.stopAdmissions.has(binding.id) || message.generation !== binding.generation || this.runtimes.get(binding.id) !== binding) {
+      return Promise.reject(browserError(
+        "Browser Viewer input is no longer admitted",
+        409,
+        "BROWSER_NOT_RUNNING"
+      ));
+    }
+    const { session } = binding;
+    const next = (session.actionChain || Promise.resolve()).catch(() => {
+    }).then(async () => {
+      await this.activateBinding(binding);
+      return this.performViewerMessage(binding, viewer, message);
+    });
+    session.actionChain = next;
+    return next;
+  }
+  scheduleViewerResize(binding, viewer, message) {
+    const resource = this.requireStored(binding.id);
+    if (resource.status !== "running" || this.stopAdmissions.has(binding.id) || message.generation !== binding.generation || this.runtimes.get(binding.id) !== binding) {
+      return Promise.reject(browserError(
+        "Browser Viewer resize is no longer admitted",
+        409,
+        "BROWSER_NOT_RUNNING"
+      ));
+    }
+    const width = Math.round(Number(message.width));
+    const height = Math.round(Number(message.height));
+    const requestedDeviceScaleFactor = Number(message.deviceScaleFactor);
+    if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+      return Promise.reject(browserError("Browser Viewer size is invalid"));
+    }
+    const deviceScaleFactor = Number.isFinite(requestedDeviceScaleFactor) ? Math.max(1, Math.min(2, requestedDeviceScaleFactor)) : 1;
+    const geometry = {
+      type: "resize",
+      generation: binding.generation,
+      width,
+      height,
+      deviceScaleFactor
+    };
+    binding.viewerGeometries.set(viewer, geometry);
+    if (message.claim === true || !binding.viewerViewportOwner || !binding.viewers.has(binding.viewerViewportOwner)) {
+      binding.viewerViewportOwner = viewer;
+    }
+    if (binding.viewerViewportOwner !== viewer) return Promise.resolve();
+    binding.pendingViewerResize = { viewer, geometry };
+    if (binding.viewerResizeTimer) this.cancelTimeout(binding.viewerResizeTimer);
+    binding.viewerResizeTimer = this.scheduleTimeout(() => {
+      binding.viewerResizeTimer = null;
+      const pending = binding.pendingViewerResize;
+      binding.pendingViewerResize = null;
+      if (!pending || binding.viewerViewportOwner !== pending.viewer) return;
+      void this.handleViewerMessage(binding, pending.viewer, pending.geometry).catch((error) => {
+        if (pending.viewer.readyState === 1) {
+          pending.viewer.send(JSON.stringify({
+            type: "browser-error",
+            message: errorMessage(error) || "Browser resize failed"
+          }));
+        }
+      });
+    }, VIEWER_RESIZE_SETTLE_MS);
+    binding.viewerResizeTimer.unref?.();
+    return Promise.resolve();
+  }
+  clearViewerResize(runtime) {
+    if (runtime.viewerResizeTimer) this.cancelTimeout(runtime.viewerResizeTimer);
+    runtime.viewerResizeTimer = null;
+    runtime.pendingViewerResize = null;
+  }
+  releaseViewerState(runtime) {
+    this.clearViewerResize(runtime);
+    runtime.viewerGeometries?.clear?.();
+    runtime.viewerViewportOwner = null;
+    runtime.viewers?.clear?.();
+  }
+  async performViewerMessage(binding, viewer, message) {
+    if (message.generation !== binding.generation || this.runtimes.get(binding.id) !== binding) {
+      throw browserError("Browser Viewer generation is stale", 409, "BROWSER_STALE_GENERATION");
+    }
+    const runtime = binding.session.runtime;
+    if (message.type === "resize") {
+      if (binding.viewerViewportOwner !== viewer) return;
+      if (typeof message.width !== "number" || typeof message.height !== "number" || typeof message.deviceScaleFactor !== "number") {
+        throw browserError("Browser Viewer size is invalid");
+      }
+      await runtime.resize({
+        width: message.width,
+        height: message.height,
+        deviceScaleFactor: message.deviceScaleFactor
+      });
+      return;
+    }
+    if (message.type === "pointer") {
+      await runtime.pointer(message);
+      return;
+    }
+    if (message.type === "wheel") {
+      await runtime.wheel(message);
+      return;
+    }
+    if (message.type === "key") {
+      await runtime.press(message);
+      return;
+    }
+    if (message.type === "text") {
+      await runtime.insertText(String(message.text || ""));
+    }
+  }
+  async dispose() {
+    this.disposed = true;
+    const sessions = [...this.sessions.values()];
+    const results = await Promise.allSettled(sessions.map(async (session) => {
+      await session.runtime.close();
+      if (session.isolatedLeaseKey && this.isolatedBrowserProvider) {
+        await this.isolatedBrowserProvider.release(session.isolatedLeaseKey);
+        session.isolatedLeaseKey = "";
+      }
+    }));
+    const failures = results.filter((result) => result.status === "rejected").map((result) => result.reason?.message || String(result.reason));
+    if (failures.length > 0) {
+      throw new Error(`Browser runtime cleanup failed: ${failures.join("; ")}`);
+    }
+    for (const binding of this.runtimes.values()) this.releaseViewerState(binding);
+    this.runtimes.clear();
+    this.sessions.clear();
+  }
+  async stopAll() {
+    const ids = [...this.runtimes.keys()];
+    const results = [];
+    for (const id of ids) {
+      try {
+        results.push({ status: "fulfilled", value: await this.stop(id) });
+      } catch (reason) {
+        results.push({ status: "rejected", reason });
+      }
+    }
+    const failures = results.filter((result) => result.status === "rejected").map((result) => errorMessage(result.reason));
+    if (failures.length > 0) {
+      throw browserError(
+        `Browser extension could not stop every running Browser: ${failures.join("; ")}`,
+        500,
+        "BROWSER_DISABLE_FAILED"
+      );
+    }
+  }
+  async reconcileAgentLifecycle(agentStates) {
+    const agents = new Map(agentStates.map((agent) => [String(agent.id || ""), agent]));
+    const resources = this.store.list().filter((resource) => resource.ownerType === "agent");
+    for (const resource of resources) {
+      const owner = agents.get(resource.ownerAgentId);
+      if (!owner) {
+        await this.delete(resource.id, true);
+        continue;
+      }
+      const preservesBrowserRuntime = ["permission-restart", "runtime-switch"].includes(
+        String(owner.lifecycleOperation?.type || "")
+      );
+      const ownerStopped = !preservesBrowserRuntime && (owner.archived === true || INACTIVE_AGENT_STATUSES.has(String(owner.status || "")));
+      if (ownerStopped && (this.runtimes.has(resource.id) || ["running", "starting", "stopping"].includes(resource.status) || Boolean(resource.processIdentity))) {
+        await this.stop(resource.id, true);
+      }
+    }
+  }
+  requireEnabled() {
+    if (this.isEnabled() !== true) {
+      throw browserError("Browser extension is disabled", 409, "BROWSER_EXTENSION_DISABLED");
+    }
+  }
+  requireAvailable() {
+    this.requireEnabled();
+    const executable = this.runtimeCapability;
+    if (!executable || executable.error) {
+      throw browserError(
+        executable?.error || "Choose a local Chromium browser or prepare the isolated Browser runtime",
+        503,
+        "BROWSER_EXECUTABLE_NOT_FOUND"
+      );
+    }
+  }
+  requireStored(id) {
+    if (!import_browser_resource_store.RESOURCE_ID_RE.test(String(id || ""))) {
+      throw browserError("Invalid Browser resource id");
+    }
+    const resource = this.store.get(id);
+    if (!resource) throw browserError("Browser resource not found", 404, "BROWSER_NOT_FOUND");
+    return resource;
+  }
+  enqueue(id, operation) {
+    const previous = this.operations.get(id) || Promise.resolve();
+    const next = previous.catch(() => {
+    }).then(operation);
+    this.operations.set(id, next);
+    return next.finally(() => {
+      if (this.operations.get(id) === next) this.operations.delete(id);
+    });
+  }
+  createBinding(session, resource) {
+    return {
+      id: resource.id,
+      generation: resource.generation,
+      session,
+      tabId: resource.tabId || "",
+      viewers: /* @__PURE__ */ new Set(),
+      viewerGeometries: /* @__PURE__ */ new Map(),
+      viewerViewportOwner: null,
+      viewerResizeTimer: null,
+      pendingViewerResize: null,
+      latestFrame: null
+    };
+  }
+  async activateBinding(binding) {
+    const { session } = binding;
+    if (!binding.tabId) throw browserError("Browser tab is unavailable", 409, "BROWSER_TAB_UNAVAILABLE");
+    if (session.runtime.activeTabId !== binding.tabId || session.runtime.streamTabId !== binding.tabId) {
+      await session.runtime.switchTab(binding.tabId);
+    }
+    session.activeResourceId = binding.id;
+  }
+  withRuntime(id, operation) {
+    const binding = this.runtimes.get(id);
+    const resource = this.requireStored(id);
+    if (!binding || resource.status !== "running") {
+      throw browserError("Browser is not running", 409, "BROWSER_NOT_RUNNING");
+    }
+    if (this.stopAdmissions.has(id)) {
+      throw browserError("Browser is stopping", 409, "BROWSER_STOPPING");
+    }
+    if (resource.generation !== binding.generation || resource.sessionId !== binding.session.id || resource.sessionGeneration !== binding.session.generation || resource.tabId !== binding.tabId) {
+      throw browserError(
+        "Browser runtime ownership changed; refresh the Browser Resource before retrying",
+        409,
+        "BROWSER_STALE_GENERATION"
+      );
+    }
+    const { session } = binding;
+    const next = (session.actionChain || Promise.resolve()).catch(() => {
+    }).then(async () => {
+      await this.activateBinding(binding);
+      return operation(session.runtime, binding);
+    });
+    session.actionChain = next;
+    return next;
+  }
+  bindSession(session) {
+    const { runtime } = session;
+    runtime.on("process-identity", (processIdentity) => {
+      const owner = this.store.get(session.processOwnerResourceId);
+      if (this.sessions.get(session.id) !== session || !owner || owner.sessionId && owner.sessionId !== session.id) return;
+      const next = this.store.update(owner.id, { processIdentity });
+      this.emitResource(next);
+    });
+    runtime.on("frame", (frame) => {
+      const binding = [...session.bindings.values()].find((candidate) => candidate.tabId === runtime.streamTabId) || session.bindings.get(session.activeResourceId);
+      if (!binding) return;
+      const resourceFrame = {
+        ...frame,
+        generation: binding.generation
+      };
+      binding.latestFrame = resourceFrame;
+      for (const viewer of binding.viewers) {
+        if (viewer.readyState === 1 && (Number(viewer.bufferedAmount) || 0) <= MAX_VIEWER_BUFFER_BYTES) {
+          viewer.send(JSON.stringify(resourceFrame));
+        }
+      }
+    });
+    runtime.on("metadata", (metadata) => {
+      const binding = [...session.bindings.values()].find((candidate) => candidate.tabId === runtime.activeTabId) || session.bindings.get(session.activeResourceId);
+      if (binding) this.updateMetadata(binding, metadata);
+    });
+    runtime.on("tabs", (event) => {
+      if (session.initializing || session.closing) return;
+      const next = (session.actionChain || Promise.resolve()).catch(() => {
+      }).then(() => this.reconcileTabs(session, event));
+      session.actionChain = next;
+    });
+    runtime.on("error", (error) => {
+      for (const binding of session.bindings.values()) {
+        for (const viewer of binding.viewers) {
+          if (viewer.readyState === 1) {
+            viewer.send(JSON.stringify({ type: "browser-error", message: errorMessage(error) || "Browser runtime failed" }));
+          }
+        }
+      }
+    });
+    runtime.once("exit", (message) => {
+      void this.handleRuntimeExit(session, message);
+    });
+  }
+  async reconcileTabs(session, event) {
+    if (this.sessions.get(session.id) !== session || session.closing) return;
+    const tabs = Array.isArray(event?.tabs) ? event.tabs.filter((tab) => tab.type === "page") : [];
+    const newlyObservedTabIds = new Set(
+      Array.isArray(event?.newTabIds) ? event.newTabIds.map(String) : []
+    );
+    const byTabId = new Map([...session.bindings.values()].map((binding) => [binding.tabId, binding]));
+    const opener = session.bindings.get(session.activeResourceId) || null;
+    const opened = [];
+    for (const tab of tabs) {
+      let binding = byTabId.get(tab.tabId);
+      if (!binding && newlyObservedTabIds.has(tab.tabId) && (!session.runtime.externalCdpUrl || event.popupAdmitted)) {
+        session.runtime.ownedTabIds.add(tab.tabId);
+        const created = this.store.createRunningTab({
+          projectRootId: opener?.session.projectRootId || session.projectRootId,
+          ownerType: opener ? this.store.get(opener.id)?.ownerType : void 0,
+          ownerAgentId: opener ? this.store.get(opener.id)?.ownerAgentId : void 0,
+          workspace: (opener ? this.store.get(opener.id)?.workspace : void 0) || this.store.list().find((resource) => resource.sessionId === session.id)?.workspace,
+          name: tabResourceName(tab),
+          url: tab.url,
+          title: tab.title,
+          browserKind: session.browserKind,
+          sessionId: session.id,
+          sessionGeneration: session.generation,
+          tabId: tab.tabId
+        });
+        binding = this.createBinding(session, created);
+        session.bindings.set(created.id, binding);
+        this.runtimes.set(created.id, binding);
+        byTabId.set(tab.tabId, binding);
+        this.emitResource(created);
+        opened.push(publicResource(created, this.store.revision));
+      }
+      if (!binding) continue;
+      const current = this.store.get(binding.id);
+      if (!current || current.status !== "running") continue;
+      if (current.url !== tab.url || current.title !== tab.title) {
+        const updated = this.store.update(binding.id, {
+          url: tab.url || current.url,
+          title: tab.title || "",
+          ...current.autoName ? { name: tabResourceName(tab) } : {}
+        });
+        this.emitResource(updated);
+        this.broadcastRuntimeState(binding);
+      }
+    }
+    const liveTabIds = new Set(tabs.map((tab) => tab.tabId));
+    for (const binding of [...session.bindings.values()]) {
+      if (liveTabIds.has(binding.tabId)) continue;
+      const current = this.store.get(binding.id);
+      if (!current || current.status === "stopping") continue;
+      session.bindings.delete(binding.id);
+      this.runtimes.delete(binding.id);
+      if (session.processOwnerResourceId === binding.id && session.bindings.size > 0) {
+        const nextOwner = session.bindings.values().next().value;
+        if (!nextOwner) throw new Error("Browser Session lost its remaining resource owner");
+        session.processOwnerResourceId = nextOwner.id;
+        const transferred = this.store.update(nextOwner.id, {
+          processIdentity: current.processIdentity
+        });
+        this.emitResource(transferred);
+        this.broadcastRuntimeState(nextOwner);
+      }
+      const stopped = this.store.update(binding.id, {
+        status: "stopped",
+        tabId: "",
+        processIdentity: null,
+        error: ""
+      });
+      this.emitResource(stopped);
+      this.broadcastRuntimeState(binding);
+      this.releaseViewerState(binding);
+    }
+    const activeTab = tabs.find((tab) => tab.active);
+    const activeBinding = activeTab ? byTabId.get(activeTab.tabId) : null;
+    if (activeBinding) {
+      session.activeResourceId = activeBinding.id;
+      if (session.runtime.streamTabId !== activeBinding.tabId) {
+        await session.runtime.switchTab(activeBinding.tabId);
+      }
+    }
+    if (opened.length > 0 && opener) {
+      const message = JSON.stringify({
+        type: "browser-tab-opened",
+        resource: opened.at(-1)
+      });
+      for (const viewer of opener.viewers) {
+        if (viewer.readyState === 1) viewer.send(message);
+      }
+    }
+  }
+  updateMetadata(binding, metadata) {
+    const current = this.store.get(binding.id);
+    if (!current || current.generation !== binding.generation || !metadata) return;
+    const next = this.store.update(binding.id, {
+      url: String(metadata.url || current.url),
+      title: String(metadata.title || "")
+    });
+    this.emitResource(next);
+    this.broadcastRuntimeState(binding);
+  }
+  emitResource(resource) {
+    this.emit("resource", publicResource(resource, this.store.revision));
+  }
+  broadcastRuntimeState(binding) {
+    const resource = this.store.get(binding.id);
+    if (!resource) return;
+    const message = JSON.stringify({
+      type: "browser-state",
+      resource: publicResource(resource, this.store.revision)
+    });
+    for (const viewer of binding.viewers || []) {
+      if (viewer.readyState === 1) viewer.send(message);
+    }
+  }
+  async handleRuntimeExit(session, message) {
+    if (this.sessions.get(session.id) !== session) return;
+    const failedBindings = [...session.bindings.values()];
+    for (const binding of failedBindings) {
+      const current = this.store.get(binding.id);
+      if (!current) continue;
+      const failed = this.store.update(binding.id, {
+        status: "failed",
+        error: current.browserKind === "external-cdp" ? "External Browser connection exited" : current.browserKind === "isolated-computer" ? "Isolated Browser connection exited" : message || "Browser connection exited"
+      });
+      this.emitResource(failed);
+      this.broadcastRuntimeState(binding);
+    }
+    try {
+      await session.runtime.close();
+      if (session.isolatedLeaseKey && this.isolatedBrowserProvider) {
+        await this.isolatedBrowserProvider.release(session.isolatedLeaseKey);
+        session.isolatedLeaseKey = "";
+      }
+      this.sessions.delete(session.id);
+      for (const binding of failedBindings) {
+        this.runtimes.delete(binding.id);
+        this.releaseViewerState(binding);
+        const cleaned = this.store.update(binding.id, { processIdentity: null });
+        if (cleaned) this.emitResource(cleaned);
+      }
+    } catch (error) {
+      for (const binding of failedBindings) {
+        const current = this.store.get(binding.id);
+        if (!current) continue;
+        const cleanupFailed = this.store.update(binding.id, {
+          status: "failed",
+          error: current.browserKind === "external-cdp" ? `${current.error}; target cleanup failed` : `${current.error}; cleanup failed: ${errorMessage(error)}`
+        });
+        this.emitResource(cleanupFailed);
+        this.broadcastRuntimeState(binding);
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserResourceManager,
+  browserError,
+  externalBrowserFailure,
+  normalizeUrl
+});