negotium 0.1.47 → 0.1.49

package/dist/browser-runtime.js

@@ -19,6 +19,7 @@ import {
   readFileSync,
   writeFileSync
 } from "fs";
+import { createRequire } from "module";
 import { homedir } from "os";
 import { dirname, join, resolve } from "path";
 import { fileURLToPath } from "url";
@@ -108,20 +109,8 @@ var DM_WORKSPACE_DIR = resolve(WORKSPACE_DIR, "dm");
 var SESSION_WORKSPACE_DIR = resolve(WORKSPACE_DIR, "sessions");
 var CLAUDE_EXECUTABLE_ENV = envText("NEGOTIUM_CLAUDE_EXECUTABLE");
 var CLAUDE_EXECUTABLE = CLAUDE_EXECUTABLE_ENV ? resolve(CLAUDE_EXECUTABLE_ENV) : undefined;
-function resolveBrowserMcpBin(envValue) {
-  const override = envValue?.trim();
-  if (override) {
-    if (!/(^|\/)(mcp-patchright|mcp-patchright-http\.mjs)$/.test(override)) {
-      throw new Error("NEGOTIUM_BROWSER_MCP_BIN must point to the authenticated mcp-patchright wrapper.");
-    }
-    return override;
-  }
-  return PATCHRIGHT_MCP_BIN;
-}
-var PATCHRIGHT_MCP_BIN = resolve(PROJECT_ROOT, "scripts/mcp-patchright-http.mjs");
-var PLAYWRIGHT_MCP_BIN = resolveBrowserMcpBin(envText("NEGOTIUM_BROWSER_MCP_BIN"));
-var BROWSER_RS_VERSION = "v0.1.13";
-var BROWSER_RS_MIN_SECURE_VERSION = "0.1.13";
+var BROWSER_RS_VERSION = "v0.1.16";
+var BROWSER_RS_MIN_SECURE_VERSION = "0.1.15";
 function versionAtLeast(actualVersion, minimumVersion) {
   const actual = actualVersion.split(".").map(Number);
   const minimum = minimumVersion.split(".").map(Number);
@@ -164,6 +153,13 @@ function resolveBrowserRsBin(envValue) {
   }
 }
 var BROWSER_RS_BIN = resolveBrowserRsBin(envText("NEGOTIUM_BROWSER_RS_BIN"));
+function resolveBrowserMcpBin(envValue) {
+  const override = envValue?.trim();
+  if (override)
+    return resolve(override);
+  return BROWSER_RS_BIN ?? resolve(STATE_DIR, "bin", "browser-rs", BROWSER_RS_VERSION, "browser-rs");
+}
+var PLAYWRIGHT_MCP_BIN = resolveBrowserMcpBin(envText("NEGOTIUM_BROWSER_MCP_BIN"));
 function resolveBrowserProxy() {
   const raw = envText("BROWSER_PROXY_URL");
   if (!raw)
@@ -187,6 +183,7 @@ function resolveBrowserProxy() {
   return proxy;
 }
 var TSX_BIN = resolveDependencyBin("tsx");
+var TSX_LOADER = createRequire(import.meta.url).resolve("tsx");
 var TSCONFIG_PATH = resolve(PROJECT_ROOT, "tsconfig.json");
 var SESSION_COMM_SERVER = resolve(PROJECT_ROOT, "src/mcp/session-comm/server.ts");
 var TASK_SERVER = resolve(PROJECT_ROOT, "src/mcp/task-server.ts");
@@ -738,18 +735,18 @@ function killProcessTreeChildren(pid) {
 }
 // ../../packages/core/src/platform/playwright/manager.ts
 import { execFileSync as execFileSync3, spawn } from "child_process";
-import { createHash, randomBytes as randomBytes2, timingSafeEqual } from "crypto";
+import { createHash as createHash2, randomBytes as randomBytes4, timingSafeEqual as timingSafeEqual2 } from "crypto";
 import {
   cpSync,
   existsSync as existsSync2,
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync4,
   readFileSync as readFileSync2,
   renameSync,
   rmSync,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync2
 } from "fs";
-import { dirname as dirname3, join as join3, resolve as resolve6 } from "path";
+import { dirname as dirname3, join as join5, resolve as resolve6 } from "path";
 
 // ../../packages/core/src/platform/delay.ts
 var delay = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -854,6 +851,388 @@ async function probePlaywrightMcpTransports(port, capability, fetchImpl = fetch)
   });
 }
 
+// ../../packages/core/src/platform/playwright/vault-broker.ts
+import { randomBytes as randomBytes3, timingSafeEqual } from "crypto";
+import { chmodSync as chmodSync3 } from "fs";
+import { createServer as createServer2 } from "net";
+import { tmpdir } from "os";
+import { join as join4 } from "path";
+
+// ../../packages/core/src/storage/vault.ts
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync3 } from "fs";
+import { join as join3 } from "path";
+
+// ../../packages/core/src/storage/vault-crypto.ts
+import { createCipheriv, createDecipheriv, createHash, randomBytes as randomBytes2 } from "crypto";
+var ENVELOPE_PREFIX = "otium-vault:v1:";
+var IV_BYTES = 12;
+var KEY_BYTES = 32;
+function encryptionKey(masterKey = VAULT_MASTER_KEY) {
+  return createHash("sha256").update("otium-vault-value-v1\x00", "utf8").update(masterKey, "utf8").digest().subarray(0, KEY_BYTES);
+}
+function aad(userId, key) {
+  return Buffer.from(`${userId}\x00${key.toUpperCase()}`, "utf8");
+}
+function isEncryptedVaultValue(value) {
+  return value.startsWith(ENVELOPE_PREFIX);
+}
+function encryptVaultValue(userId, key, value, masterKey = VAULT_MASTER_KEY) {
+  const iv = randomBytes2(IV_BYTES);
+  const cipher = createCipheriv("aes-256-gcm", encryptionKey(masterKey), iv);
+  cipher.setAAD(aad(userId, key));
+  const ciphertext = Buffer.concat([cipher.update(value, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return `${ENVELOPE_PREFIX}${iv.toString("base64url")}.${ciphertext.toString("base64url")}.${tag.toString("base64url")}`;
+}
+function decryptVaultValue(userId, key, storedValue, masterKey = VAULT_MASTER_KEY) {
+  if (!isEncryptedVaultValue(storedValue)) {
+    return { value: storedValue, legacyPlaintext: true };
+  }
+  const encoded = storedValue.slice(ENVELOPE_PREFIX.length);
+  const [ivPart, ciphertextPart, tagPart, ...extra] = encoded.split(".");
+  if (!ivPart || ciphertextPart === undefined || !tagPart || extra.length > 0) {
+    throw new Error("Invalid encrypted vault value");
+  }
+  const iv = Buffer.from(ivPart, "base64url");
+  const ciphertext = Buffer.from(ciphertextPart, "base64url");
+  const tag = Buffer.from(tagPart, "base64url");
+  if (iv.length !== IV_BYTES || tag.length !== 16) {
+    throw new Error("Invalid encrypted vault value");
+  }
+  const decipher = createDecipheriv("aes-256-gcm", encryptionKey(masterKey), iv);
+  decipher.setAAD(aad(userId, key));
+  decipher.setAuthTag(tag);
+  const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+  return { value: plaintext.toString("utf8"), legacyPlaintext: false };
+}
+
+// ../../packages/core/src/storage/vault.ts
+var vaultDb;
+var vaultMasterKey = VAULT_MASTER_KEY;
+function initializeVaultDatabase(database) {
+  database.exec("PRAGMA journal_mode = WAL");
+  database.exec("PRAGMA busy_timeout = 5000");
+  database.exec(`
+  CREATE TABLE IF NOT EXISTS vault (
+    user_id     TEXT    NOT NULL,
+    key         TEXT    NOT NULL,
+    value       TEXT    NOT NULL,
+    description TEXT    NOT NULL DEFAULT '',
+    PRIMARY KEY (user_id, key)
+  )
+  `);
+  {
+    const cols = database.prepare("PRAGMA table_info(vault)").all();
+    const uid = cols.find((c) => c.name === "user_id");
+    if (uid && uid.type.toUpperCase() === "INTEGER") {
+      database.exec("BEGIN");
+      database.exec(`
+      CREATE TABLE vault_migrated (
+        user_id     TEXT    NOT NULL,
+        key         TEXT    NOT NULL,
+        value       TEXT    NOT NULL,
+        description TEXT    NOT NULL DEFAULT '',
+        PRIMARY KEY (user_id, key)
+      )
+    `);
+      database.exec("INSERT INTO vault_migrated SELECT CAST(user_id AS TEXT), key, value, description FROM vault");
+      database.exec("DROP TABLE vault");
+      database.exec("ALTER TABLE vault_migrated RENAME TO vault");
+      database.exec("COMMIT");
+    }
+  }
+}
+function openVaultDatabase(dataDir) {
+  const path = join3(dataDir, "vault.db");
+  mkdirSync3(dataDir, { recursive: true });
+  const database = new Database(path, { create: true });
+  chmodSync2(path, 384);
+  initializeVaultDatabase(database);
+  return database;
+}
+function activeVaultDatabase() {
+  if (!vaultDb)
+    vaultDb = openVaultDatabase(DATA_DIR);
+  return vaultDb;
+}
+var VAULT_VALUE_MAX_BYTES = 64 * 1024;
+function normalizeVaultKey(key) {
+  return key.trim().toUpperCase();
+}
+function decryptRow(userId, key, storedValue) {
+  const database = activeVaultDatabase();
+  const decoded = decryptVaultValue(userId, key, storedValue, vaultMasterKey);
+  if (decoded.legacyPlaintext) {
+    database.prepare("UPDATE vault SET value = ? WHERE user_id = ? AND key = ? AND value = ?").run(encryptVaultValue(userId, key, decoded.value, vaultMasterKey), userId, key, storedValue);
+  }
+  return decoded.value;
+}
+function vaultListWithValues(userId) {
+  const rows = activeVaultDatabase().prepare("SELECT key, description, value FROM vault WHERE user_id = ? ORDER BY key").all(userId);
+  return rows.map((row) => ({
+    key: row.key,
+    description: row.description,
+    value: decryptRow(userId, row.key, row.value)
+  }));
+}
+function encodedSecretForms(value) {
+  const forms = new Set([
+    value,
+    encodeURIComponent(value),
+    Buffer.from(value, "utf8").toString("base64"),
+    Buffer.from(value, "utf8").toString("base64url"),
+    Buffer.from(value, "utf8").toString("hex")
+  ]);
+  forms.delete("");
+  return [...forms].sort((a, b) => b.length - a.length);
+}
+function redactVaultSecrets(userId, text) {
+  const candidates = vaultListWithValues(userId).flatMap((entry) => encodedSecretForms(entry.value).map((form) => ({ form, key: entry.key }))).sort((a, b) => b.form.length - a.form.length || a.key.localeCompare(b.key));
+  if (candidates.length === 0)
+    return text;
+  const candidatesByFirstCharacter = new Map;
+  for (const candidate of candidates) {
+    const first = candidate.form[0];
+    if (!first)
+      continue;
+    const bucket = candidatesByFirstCharacter.get(first) ?? [];
+    bucket.push(candidate);
+    candidatesByFirstCharacter.set(first, bucket);
+  }
+  let redacted = "";
+  let offset = 0;
+  while (offset < text.length) {
+    const match = candidatesByFirstCharacter.get(text[offset] ?? "")?.find((candidate) => text.startsWith(candidate.form, offset));
+    if (!match) {
+      redacted += text[offset];
+      offset += 1;
+      continue;
+    }
+    redacted += `[REDACTED:${match.key}]`;
+    offset += match.form.length;
+  }
+  return redacted;
+}
+// ../../packages/core/src/platform/playwright/vault-broker.ts
+var MAX_REQUEST_BYTES = 16 * 1024 * 1024;
+var DEFAULT_OUTPUT_LIMIT = 1e5;
+var LEASE_TTL_MS = 5 * 60000;
+var MAX_ACTIVE_LEASES = 1024;
+var BOUNDED_OUTPUTS = {
+  browser_snapshot: { argument: "maxLength", field: "snapshot" },
+  browser_api_request: { argument: "maxBytes", field: "body" },
+  browser_get_visible_text: { argument: "maxLength", field: "text" },
+  browser_get_visible_html: { argument: "maxLength", field: "html" }
+};
+function deepMapStrings(value, transform) {
+  if (typeof value === "string")
+    return transform(value);
+  if (Array.isArray(value))
+    return value.map((entry) => deepMapStrings(entry, transform));
+  if (!value || typeof value !== "object")
+    return value;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null)
+    return value;
+  return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, deepMapStrings(entry, transform)]));
+}
+function encodedSecretForms2(value) {
+  return [
+    ...new Set([
+      value,
+      encodeURIComponent(value),
+      Buffer.from(value, "utf8").toString("base64"),
+      Buffer.from(value, "utf8").toString("base64url"),
+      Buffer.from(value, "utf8").toString("hex")
+    ])
+  ].filter(Boolean).sort((left, right) => right.length - left.length);
+}
+function prepareInput(tool, value) {
+  const config = BOUNDED_OUTPUTS[tool];
+  if (!config || !value || typeof value !== "object" || Array.isArray(value))
+    return { value };
+  const input = value;
+  const requested = input[config.argument];
+  if (requested !== undefined && (!Number.isSafeInteger(requested) || Number(requested) <= 0)) {
+    return { value };
+  }
+  const limit = requested === undefined ? DEFAULT_OUTPUT_LIMIT : Number(requested);
+  return {
+    value: { ...input, [config.argument]: Number.MAX_SAFE_INTEGER },
+    boundary: { field: config.field, limit }
+  };
+}
+function redactTextEntry(entry, redact, boundary) {
+  if (!entry || typeof entry !== "object")
+    return redact(entry);
+  const content = entry;
+  if (content.type !== "text" || typeof content.text !== "string")
+    return redact(entry);
+  try {
+    const parsed = redact(JSON.parse(content.text));
+    if (boundary && parsed && typeof parsed === "object") {
+      const object = parsed;
+      const fieldValue = object[boundary.field];
+      if (typeof fieldValue === "string") {
+        const originalExceeded = typeof object.length === "number" && object.length > boundary.limit;
+        if (fieldValue.length > boundary.limit)
+          object[boundary.field] = fieldValue.slice(0, boundary.limit);
+        if (originalExceeded || fieldValue.length > boundary.limit)
+          object.truncated = true;
+      }
+    }
+    return { ...content, text: JSON.stringify(parsed, null, 2) };
+  } catch {
+    const redacted = redact(content.text);
+    if (boundary && typeof redacted === "string" && redacted.length > boundary.limit) {
+      return {
+        ...content,
+        text: `${redacted.slice(0, boundary.limit)}
+[truncated]`
+      };
+    }
+    return { ...content, text: redacted };
+  }
+}
+function secureOutput(result, redact, boundary) {
+  if (!result || typeof result !== "object")
+    return redact(result);
+  const object = result;
+  const content = Array.isArray(object.content) ? object.content.map((entry) => redactTextEntry(entry, redact, boundary)) : object.content;
+  return redact({ ...object, content });
+}
+function authorized(actual, expected) {
+  if (typeof actual !== "string")
+    return false;
+  const left = Buffer.from(actual);
+  const right = Buffer.from(expected);
+  return left.length === right.length && timingSafeEqual(left, right);
+}
+async function createBrowserVaultBroker(userId) {
+  const token = randomBytes3(32).toString("hex");
+  const socketPath = join4(process.platform === "win32" ? tmpdir() : "/tmp", `negotium-browser-vault-${process.pid}-${randomBytes3(8).toString("hex")}.sock`);
+  const retainedForms = new Map;
+  const leases = new Map;
+  const sockets = new Set;
+  const redactRetained = (text) => {
+    let output = text;
+    for (const [form, key] of [...retainedForms].sort(([left], [right]) => right.length - left.length)) {
+      output = output.replaceAll(form, `[REDACTED:${key}]`);
+    }
+    return output;
+  };
+  const redact = (value) => deepMapStrings(value, (text) => redactRetained(redactVaultSecrets(userId, text)));
+  const handleRequest = (request) => {
+    const id = request.id;
+    if (!authorized(request.token, token))
+      return { id, ok: false, error: "unauthorized" };
+    if (request.op === "transform_input") {
+      if (typeof request.tool !== "string")
+        return { id, ok: false, error: "invalid tool" };
+      const leaseCutoff = Date.now() - LEASE_TTL_MS;
+      for (const [lease2, binding] of leases) {
+        if (binding.createdAt < leaseCutoff)
+          leases.delete(lease2);
+      }
+      if (leases.size >= MAX_ACTIVE_LEASES) {
+        return { id, ok: false, error: "too many active leases" };
+      }
+      const entries = new Map(vaultListWithValues(userId).map((entry) => [entry.key, entry.value]));
+      const substituted = deepMapStrings(request.value, (text) => text.replace(/\{\{([^}]+)\}\}/g, (match, rawKey) => {
+        const key = normalizeVaultKey(rawKey);
+        const secret = entries.get(key);
+        if (secret === undefined)
+          return match;
+        for (const form of encodedSecretForms2(secret))
+          retainedForms.set(form, key);
+        return secret;
+      }));
+      const prepared = prepareInput(request.tool, substituted);
+      const lease = randomBytes3(24).toString("hex");
+      leases.set(lease, { boundary: prepared.boundary, createdAt: Date.now() });
+      return {
+        id,
+        ok: true,
+        value: prepared.value,
+        lease,
+        boundary: prepared.boundary
+      };
+    }
+    if (request.op === "redact_output") {
+      if (typeof request.lease !== "string") {
+        return { id, ok: false, error: "invalid lease" };
+      }
+      const binding = leases.get(request.lease);
+      leases.delete(request.lease);
+      if (!binding || binding.createdAt < Date.now() - LEASE_TTL_MS) {
+        return { id, ok: false, error: "invalid lease" };
+      }
+      try {
+        const value = secureOutput(request.value, redact, binding.boundary);
+        const serialized = JSON.stringify(value);
+        if (redactRetained(serialized) !== serialized) {
+          return { id, ok: false, error: "redaction verification failed" };
+        }
+        return { id, ok: true, value };
+      } catch {
+        return { id, ok: false, error: "redaction failed" };
+      }
+    }
+    return { id, ok: false, error: "unknown operation" };
+  };
+  const server = createServer2((socket) => {
+    sockets.add(socket);
+    let pending = "";
+    socket.setEncoding("utf8");
+    socket.on("data", (chunk) => {
+      pending += chunk;
+      if (Buffer.byteLength(pending) > MAX_REQUEST_BYTES) {
+        socket.destroy();
+        return;
+      }
+      while (true) {
+        const newline = pending.indexOf(`
+`);
+        if (newline < 0)
+          break;
+        const line = pending.slice(0, newline);
+        pending = pending.slice(newline + 1);
+        if (!line)
+          continue;
+        let response;
+        try {
+          response = handleRequest(JSON.parse(line));
+        } catch {
+          response = { ok: false, error: "invalid request" };
+        }
+        socket.write(`${JSON.stringify(response)}
+`);
+      }
+    });
+    socket.once("close", () => sockets.delete(socket));
+  });
+  await new Promise((resolveListen, reject) => {
+    server.once("error", reject);
+    server.listen(socketPath, resolveListen);
+  });
+  chmodSync3(socketPath, 384);
+  let closed = false;
+  return {
+    socketPath,
+    token,
+    async close() {
+      if (closed)
+        return;
+      closed = true;
+      leases.clear();
+      retainedForms.clear();
+      for (const socket of sockets)
+        socket.destroy();
+      await new Promise((resolveClose) => server.close(() => resolveClose()));
+    }
+  };
+}
+
 // ../../packages/core/src/security/sanitize.ts
 function sanitizeTopicName(name, lowercase = false) {
   const safe = name.replace(/[^a-zA-Z0-9\uAC00-\uD7A3_-]/g, "_") || "_";
@@ -946,7 +1325,7 @@ function defaultNamedBinding(ownerId, rawProfile) {
   };
 }
 function legacyBrowserProfileName(topic) {
-  return `legacy_${createHash("sha256").update(topic).digest("hex").slice(0, 12)}`;
+  return `legacy_${createHash2("sha256").update(topic).digest("hex").slice(0, 12)}`;
 }
 function migrateLegacyTopicProfile(ownerId, topic) {
   const current = getTopicBrowserProfile(topic);
@@ -957,7 +1336,7 @@ function migrateLegacyTopicProfile(ownerId, topic) {
     return current;
   const profile = legacyBrowserProfileName(topic);
   const profileDir = defaultProfileDir(ownerId, profile);
-  mkdirSync3(dirname3(profileDir), { recursive: true });
+  mkdirSync4(dirname3(profileDir), { recursive: true });
   if (!existsSync2(profileDir))
     renameSync(legacyDir, profileDir);
   assignTopicBrowserProfile({ topicId: topic, actorUserId: ownerId, profile });
@@ -965,26 +1344,39 @@ function migrateLegacyTopicProfile(ownerId, topic) {
   return profile;
 }
 function defaultChildEnvironment(context) {
-  const { capability, ownerId, proxy, browserRsBin, environment } = context;
-  return {
-    ...environment,
-    NEGOTIUM_BROWSER_CAPABILITY: capability,
-    NEGOTIUM_BROWSER_VAULT_USER_ID: ownerId,
-    ...browserRsBin && !proxy ? { NEGOTIUM_BROWSER_RS_BIN: browserRsBin } : {},
-    ...proxy ? {
-      NEGOTIUM_BROWSER_PROXY_SERVER: proxy.server,
-      ...proxy.username ? { NEGOTIUM_BROWSER_PROXY_USERNAME: proxy.username } : {},
-      ...proxy.password ? { NEGOTIUM_BROWSER_PROXY_PASSWORD: proxy.password } : {},
-      ...proxy.bypass ? { NEGOTIUM_BROWSER_PROXY_BYPASS: proxy.bypass } : {}
-    } : {}
-  };
+  const childEnvironment = {};
+  for (const key of [
+    "HOME",
+    "PATH",
+    "TMPDIR",
+    "TMP",
+    "TEMP",
+    "LANG",
+    "LC_ALL",
+    "LC_CTYPE",
+    "DISPLAY",
+    "WAYLAND_DISPLAY",
+    "XAUTHORITY",
+    "DBUS_SESSION_BUS_ADDRESS",
+    "XDG_RUNTIME_DIR",
+    "XDG_CONFIG_HOME",
+    "XDG_CACHE_HOME",
+    "XDG_DATA_HOME",
+    "AB_CHROME",
+    "AB_CONNECT",
+    "RUST_LOG",
+    "RUST_BACKTRACE"
+  ]) {
+    if (context.environment[key] !== undefined)
+      childEnvironment[key] = context.environment[key];
+  }
+  return childEnvironment;
 }
 var defaultManagerHost = Object.freeze({
   portsDir: PLAYWRIGHT_PORTS_DIR,
   basePort: PLAYWRIGHT_BASE_PORT,
   maxPort: PLAYWRIGHT_MAX_PORT,
   browserBin: PLAYWRIGHT_MCP_BIN,
-  fallbackBrowserBin: PATCHRIGHT_MCP_BIN,
   browserRsBin: BROWSER_RS_BIN,
   resolveProxy: resolveBrowserProxy,
   resolveTopicBinding: defaultTopicBinding,
@@ -1009,8 +1401,8 @@ function configurePlaywrightManagerHost(overrides) {
   if (next.basePort < 1 || next.maxPort > 65535 || next.basePort > next.maxPort) {
     throw new Error("invalid Playwright manager port range");
   }
-  if (!next.browserBin || !next.fallbackBrowserBin) {
-    throw new Error("Playwright manager browser binaries are required");
+  if (!next.browserBin) {
+    throw new Error("Browser manager gateway is required");
   }
   if (next.resolveInstanceDataDir !== defaultManagerHost.resolveInstanceDataDir && (next.cleanupBrowserProcessesForDataDir === defaultManagerHost.cleanupBrowserProcessesForDataDir || next.reapOrphanBrowsers === defaultManagerHost.reapOrphanBrowsers)) {
     throw new Error("custom Playwright profile paths require host crash cleanup and orphan sweep hooks");
@@ -1034,26 +1426,26 @@ function parseInstanceKey(instanceKey) {
   };
 }
 function portFileName(instanceKey) {
-  return createHash("sha256").update(instanceKey).digest("hex").slice(0, 24);
+  return createHash2("sha256").update(instanceKey).digest("hex").slice(0, 24);
 }
 function writePortFile(instanceKey, port) {
   try {
-    mkdirSync3(managerHost.portsDir, { recursive: true });
-    writeFileSync2(join3(managerHost.portsDir, portFileName(instanceKey)), String(port));
+    mkdirSync4(managerHost.portsDir, { recursive: true });
+    writeFileSync2(join5(managerHost.portsDir, portFileName(instanceKey)), String(port));
   } catch (e) {
     logger.warn({ err: e, instanceKey, port }, "Failed to save playwright port file");
   }
 }
 function deletePortFile(instanceKey) {
   try {
-    unlinkSync2(join3(managerHost.portsDir, portFileName(instanceKey)));
+    unlinkSync2(join5(managerHost.portsDir, portFileName(instanceKey)));
   } catch (e) {
     logger.warn({ err: e, instanceKey }, "Failed to delete playwright port file");
   }
 }
 function readPortFile(instanceKey) {
   try {
-    const port = Number.parseInt(readFileSync2(join3(managerHost.portsDir, portFileName(instanceKey)), "utf8").trim(), 10);
+    const port = Number.parseInt(readFileSync2(join5(managerHost.portsDir, portFileName(instanceKey)), "utf8").trim(), 10);
     return Number.isInteger(port) ? port : null;
   } catch {
     return null;
@@ -1150,7 +1542,7 @@ function resolvePlaywrightCapabilityOwner(capability) {
   const provided = Buffer.from(capability);
   for (const instance of instances.values()) {
     const expected = Buffer.from(instance.capability);
-    if (provided.length === expected.length && timingSafeEqual(provided, expected)) {
+    if (provided.length === expected.length && timingSafeEqual2(provided, expected)) {
       return instance.ownerId;
     }
   }
@@ -1207,7 +1599,7 @@ function releasePort(port) {
   usedPorts.delete(port);
 }
 function ownerDirectory(ownerId) {
-  const digest = createHash("sha256").update(ownerId).digest("hex").slice(0, 16);
+  const digest = createHash2("sha256").update(ownerId).digest("hex").slice(0, 16);
   return `${sanitizeTopicName(ownerId).slice(0, 24)}_${digest}`;
 }
 function defaultProfileDir(ownerId, profile) {
@@ -1228,6 +1620,7 @@ function killInstance(instanceKey, opts) {
   } catch (e) {
     logger.warn({ err: e, instanceKey }, "Failed to kill playwright instance");
   }
+  inst.vaultBroker.close();
   inst.process.removeAllListeners("error");
   inst.process.removeAllListeners("exit");
   cleanSingletonFiles(resolveUserDataDir(instanceKey));
@@ -1282,10 +1675,13 @@ ${stderr}` : "";
   };
   return { failure, stop };
 }
-async function spawnPlaywright(instanceKey, ownerId, reservedPort, browserBin = managerHost.browserBin, allowFallback = true) {
+async function spawnPlaywright(instanceKey, ownerId, reservedPort, browserBin = managerHost.browserBin) {
+  if (!managerHost.browserRsBin) {
+    throw new Error("Browser.rs is unavailable or below the minimum secure version");
+  }
   const userDataDir = resolveUserDataDir(instanceKey);
   const port = reservedPort ?? await allocatePort();
-  mkdirSync3(userDataDir, { recursive: true });
+  mkdirSync4(userDataDir, { recursive: true });
   const mcpArgs = [
     "--port",
     String(port),
@@ -1296,8 +1692,19 @@ async function spawnPlaywright(instanceKey, ownerId, reservedPort, browserBin =
     userDataDir
   ];
   const proxy = managerHost.resolveProxy();
-  const capability = randomBytes2(32).toString("hex");
-  const spawnNonce = randomBytes2(32).toString("hex");
+  if (proxy) {
+    releasePort(port);
+    throw new Error("Browser.rs managed mode does not support authenticated egress proxies");
+  }
+  const capability = randomBytes4(32).toString("hex");
+  const spawnNonce = randomBytes4(32).toString("hex");
+  let vaultBroker;
+  try {
+    vaultBroker = await createBrowserVaultBroker(ownerId);
+  } catch (error) {
+    releasePort(port);
+    throw error;
+  }
   const childEnv = {
     ...managerHost.createChildEnvironment({
       instanceKey,
@@ -1307,18 +1714,19 @@ async function spawnPlaywright(instanceKey, ownerId, reservedPort, browserBin =
       browserRsBin: managerHost.browserRsBin,
       environment: process.env
     }),
-    NEGOTIUM_BROWSER_CAPABILITY: capability,
-    NEGOTIUM_BROWSER_SPAWN_NONCE: spawnNonce
+    AB_MANAGED: "1",
+    AB_HTTP_CAPABILITY: capability,
+    AB_SPAWN_NONCE: spawnNonce,
+    AB_SECRET_BROKER_SOCKET: vaultBroker.socketPath,
+    AB_SECRET_BROKER_TOKEN: vaultBroker.token
   };
-  if (proxy) {
-    logger.info({ instanceKey, proxyServer: proxy.server }, "Browser egress proxy enabled");
-  }
   const command = browserBin.endsWith(".mjs") ? process.execPath : browserBin;
   const args = browserBin.endsWith(".mjs") ? [browserBin, ...mcpArgs] : mcpArgs;
   let spawnSpec;
   try {
     spawnSpec = resolveHeadedPlaywrightSpawn(command, args, { environment: childEnv });
   } catch (err) {
+    await vaultBroker.close();
     releasePort(port);
     throw err;
   }
@@ -1330,6 +1738,7 @@ async function spawnPlaywright(instanceKey, ownerId, reservedPort, browserBin =
       env: childEnv
     });
   } catch (err) {
+    await vaultBroker.close();
     releasePort(port);
     throw err;
   }
@@ -1345,6 +1754,7 @@ async function spawnPlaywright(instanceKey, ownerId, reservedPort, browserBin =
     if (instances.get(instanceKey)?.process === proc) {
       releasePort(port);
       instances.delete(instanceKey);
+      vaultBroker.close();
       reapCrashedBrowser();
       notifyPlaywrightFailure(instanceKey, {
         reason: "process-error",
@@ -1358,6 +1768,7 @@ async function spawnPlaywright(instanceKey, ownerId, reservedPort, browserBin =
     if (wasOurs) {
       releasePort(port);
       instances.delete(instanceKey);
+      vaultBroker.close();
       reapCrashedBrowser();
       notifyPlaywrightFailure(instanceKey, { reason: "exit", code });
     }
@@ -1369,7 +1780,8 @@ async function spawnPlaywright(instanceKey, ownerId, reservedPort, browserBin =
     ownerId,
     startedAt: now,
     lastUsedAt: now,
-    capability
+    capability,
+    vaultBroker
   });
   let startupError;
   let ready = false;
@@ -1392,16 +1804,6 @@ ${stderrTail()}` : ""));
   if (!ready) {
     const exitCode = proc.exitCode;
     killInstance(instanceKey);
-    if (allowFallback && browserBin !== managerHost.fallbackBrowserBin) {
-      logger.warn({
-        err: startupError,
-        instanceKey,
-        browserBin,
-        fallback: managerHost.fallbackBrowserBin,
-        stderr: stderrTail() || undefined
-      }, "Preferred browser MCP unavailable or lacks owner isolation; using Patchright fallback");
-      return spawnPlaywright(instanceKey, ownerId, undefined, managerHost.fallbackBrowserBin, false);
-    }
     if (startupError)
       throw startupError;
     throw new Error(`Playwright MCP failed health check after spawn on port ${port}` + (exitCode === null ? "" : ` (exitCode=${exitCode})`) + (stderrTail() ? `
@@ -1639,4 +2041,4 @@ export {
   browserProcessMatchesExpectedProfile
 };
 
-//# debugId=1E566069F9A87A9F64756E2164756E21
+//# debugId=2CF8E30F8AE6C02A64756E2164756E21