negotium 0.1.37 → 0.1.39

package/dist/browser-runtime.js

@@ -0,0 +1,1600 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = import.meta.require;
+
+// ../../packages/core/src/platform/playwright/browser-processes.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { readdirSync, unlinkSync } from "fs";
+import { resolve as resolve4, sep } from "path";
+
+// ../../packages/core/src/platform/config.ts
+import { execFileSync } from "child_process";
+import { randomBytes } from "crypto";
+import {
+  accessSync,
+  chmodSync,
+  constants,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+
+// ../../packages/core/src/platform/config-helpers.ts
+function readEnvText(env, key) {
+  const value = env[key]?.trim();
+  return value || undefined;
+}
+function parseRuntimePort(value, fallback) {
+  if (!value)
+    return fallback;
+  const port = Number.parseInt(value, 10);
+  return Number.isInteger(port) && port > 0 && port <= 65535 ? port : fallback;
+}
+
+// ../../packages/core/src/platform/logger.ts
+import pino from "pino";
+function createStdioLogger(options = {}) {
+  const development = options.development ?? true;
+  return pino({
+    level: options.level ?? process.env.LOG_LEVEL ?? "info",
+    transport: development ? {
+      target: "pino-pretty",
+      options: {
+        colorize: true,
+        translateTime: "SYS:yyyy-mm-dd HH:MM:ss",
+        destination: 2
+      }
+    } : undefined
+  }, pino.destination(2));
+}
+var logger = createStdioLogger();
+
+// ../../packages/core/src/types.ts
+var SUPPORTED_AGENTS = ["maestro", "claude", "codex"];
+function isAgentKind(value) {
+  return typeof value === "string" && SUPPORTED_AGENTS.includes(value);
+}
+
+// ../../packages/core/src/platform/config.ts
+function envText(envKey) {
+  return readEnvText(process.env, envKey);
+}
+function resolveAgentEnv(envKey, fallback, legacyEnvKey) {
+  const value = envText(envKey) ?? (legacyEnvKey ? envText(legacyEnvKey) : undefined);
+  return isAgentKind(value) ? value : fallback;
+}
+var HOME = homedir();
+function resolveProjectRoot() {
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  const packagedRuntime = resolve(moduleDir, "runtime");
+  if (existsSync(resolve(packagedRuntime, "src")))
+    return packagedRuntime;
+  return resolve(moduleDir, "../..");
+}
+var PROJECT_ROOT = resolveProjectRoot();
+function resolveDependencyBin(name) {
+  let dir = PROJECT_ROOT;
+  while (true) {
+    const candidate = resolve(dir, "node_modules", ".bin", name);
+    if (existsSync(candidate))
+      return candidate;
+    const parent = dirname(dir);
+    if (parent === dir)
+      return candidate;
+    dir = parent;
+  }
+}
+var STATE_DIR_ENV = envText("NEGOTIUM_STATE_DIR");
+var STATE_DIR = STATE_DIR_ENV ? resolve(STATE_DIR_ENV) : resolve(HOME, ".negotium");
+function resolveLocalStateDir(envKey, stateName) {
+  const envValue = envText(envKey);
+  if (envValue)
+    return resolve(envValue);
+  return resolve(STATE_DIR, stateName);
+}
+function parsePortEnv(envValue, fallback) {
+  return parseRuntimePort(envValue, fallback);
+}
+var WORKSPACE_DIR = resolveLocalStateDir("NEGOTIUM_WORKSPACE_DIR", "workspace");
+var TOPIC_WORKSPACE_DIR = resolve(WORKSPACE_DIR, "topics");
+var SHARED_WIKI_DIR = resolve(WORKSPACE_DIR, "wiki");
+var CONTEXTS_DIR = resolve(WORKSPACE_DIR, "contexts");
+var BROWSER_PROFILES_DIR = resolve(WORKSPACE_DIR, "browser-profiles");
+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";
+function versionAtLeast(actualVersion, minimumVersion) {
+  const actual = actualVersion.split(".").map(Number);
+  const minimum = minimumVersion.split(".").map(Number);
+  if (actual.some(Number.isNaN) || minimum.some(Number.isNaN))
+    return false;
+  for (let index = 0;index < minimum.length; index += 1) {
+    if ((actual[index] ?? 0) > (minimum[index] ?? 0))
+      return true;
+    if ((actual[index] ?? 0) < (minimum[index] ?? 0))
+      return false;
+  }
+  return true;
+}
+function browserRsMeetsMinimumVersion(candidate) {
+  try {
+    const output = execFileSync(candidate, ["--version"], {
+      encoding: "utf8",
+      timeout: 2000,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const match = output.match(/^browser-rs (\d+)\.(\d+)\.(\d+)$/);
+    if (!match)
+      return false;
+    return versionAtLeast(match.slice(1).join("."), BROWSER_RS_MIN_SECURE_VERSION);
+  } catch {
+    return false;
+  }
+}
+function resolveBrowserRsBin(envValue) {
+  const override = envValue?.trim();
+  if (!override && !versionAtLeast(BROWSER_RS_VERSION.replace(/^v/, ""), BROWSER_RS_MIN_SECURE_VERSION)) {
+    return;
+  }
+  const candidate = override ? resolve(override) : resolve(STATE_DIR, "bin", "browser-rs", BROWSER_RS_VERSION, "browser-rs");
+  try {
+    accessSync(candidate, constants.X_OK);
+    return browserRsMeetsMinimumVersion(candidate) ? candidate : undefined;
+  } catch {
+    return;
+  }
+}
+var BROWSER_RS_BIN = resolveBrowserRsBin(envText("NEGOTIUM_BROWSER_RS_BIN"));
+function resolveBrowserProxy() {
+  const raw = envText("BROWSER_PROXY_URL");
+  if (!raw)
+    return null;
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    logger.warn({ raw }, "Ignoring malformed BROWSER_PROXY_URL");
+    return null;
+  }
+  const server = `${url.protocol}//${url.host}`;
+  const proxy = { server };
+  if (url.username)
+    proxy.username = decodeURIComponent(url.username);
+  if (url.password)
+    proxy.password = decodeURIComponent(url.password);
+  const bypass = envText("BROWSER_PROXY_BYPASS");
+  if (bypass)
+    proxy.bypass = bypass;
+  return proxy;
+}
+var TSX_BIN = resolveDependencyBin("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");
+var BROWSER_MCP_SSE_PROXY_SERVER = resolve(PROJECT_ROOT, "src/mcp/browser-sse-proxy-server.ts");
+var CANONICAL_MCP_PROXY_SERVER = resolve(PROJECT_ROOT, "src/mcp/canonical-proxy-server.ts");
+var WIKI_SERVER = resolve(PROJECT_ROOT, "src/mcp/wiki-server.ts");
+var TOKEN_STATS_SERVER = resolve(PROJECT_ROOT, "src/mcp/token-stats-server.ts");
+var COMPACTION_LOG_SERVER = resolve(PROJECT_ROOT, "src/mcp/compaction-log-server.ts");
+var SYSTEM_HEALTH_SERVER = resolve(PROJECT_ROOT, "src/mcp/system-health-server.ts");
+var AGENT_HEALTH_SERVER = resolve(PROJECT_ROOT, "src/mcp/agent-health-server.ts");
+var BACKGROUND_BASH_SERVER = resolve(PROJECT_ROOT, "src/mcp/background-bash-server.ts");
+var VAULT_SERVER = resolve(PROJECT_ROOT, "src/mcp/vault-server.ts");
+var BG_BASH_BASE_PORT = parsePortEnv(process.env.BG_BASH_BASE_PORT, 9700);
+var BG_BASH_MAX_PORT = parsePortEnv(process.env.BG_BASH_MAX_PORT, 9799);
+function loadOrCreateLocalSecret(envKey, filename, options = {}) {
+  const envValue = envText(envKey);
+  const secretFile = resolve(STATE_DIR, filename);
+  mkdirSync(dirname(secretFile), { recursive: true });
+  if (envValue) {
+    if (options.persistEnvValue) {
+      writeFileSync(secretFile, `${envValue}
+`, { mode: 384 });
+      chmodSync(secretFile, 384);
+    }
+    return envValue;
+  }
+  if (existsSync(secretFile)) {
+    const stored = readFileSync(secretFile, "utf-8").trim();
+    if (stored) {
+      chmodSync(secretFile, 384);
+      return stored;
+    }
+  }
+  const secret = randomBytes(32).toString("base64url");
+  try {
+    writeFileSync(secretFile, `${secret}
+`, { mode: 384, flag: "wx" });
+    return secret;
+  } catch (error) {
+    if (error.code !== "EEXIST")
+      throw error;
+    const stored = readFileSync(secretFile, "utf-8").trim();
+    if (!stored)
+      throw new Error(`Secret file exists but is empty: ${secretFile}`);
+    chmodSync(secretFile, 384);
+    return stored;
+  }
+}
+var RUNTIME_MCP_SECRET = loadOrCreateLocalSecret("RUNTIME_MCP_SECRET", "runtime-mcp-secret");
+var NODE_CONTROL_TOKEN = loadOrCreateLocalSecret("NEGOTIUM_CONTROL_TOKEN", "node-control-token");
+var VAULT_MASTER_KEY = loadOrCreateLocalSecret("NEGOTIUM_VAULT_MASTER_KEY", "vault-master-key", { persistEnvValue: true });
+delete process.env.NEGOTIUM_VAULT_MASTER_KEY;
+var NEGOTIUM_PORT = parseInt(process.env.NEGOTIUM_PORT || "7777", 10);
+var hostname = process.env.HOSTNAME || "127.0.0.1";
+var DATA_DIR = resolveLocalStateDir("NEGOTIUM_DATA_DIR", "data");
+var LOG_DIR = resolveLocalStateDir("NEGOTIUM_LOG_DIR", "logs");
+var SESSIONS_DB = process.env.SESSIONS_DB_PATH ? resolve(process.env.SESSIONS_DB_PATH) : resolve(DATA_DIR, "sessions.db");
+var DEBUG_FILE = resolve(DATA_DIR, "debug-users.json");
+var USERS_LOG_DIR = resolve(DATA_DIR, "users");
+var RUN_DIR = resolveLocalStateDir("NEGOTIUM_RUN_DIR", "run");
+var PROGRESS_DIR = resolve(RUN_DIR, "progress");
+var DM_CMD_DIR = resolve(RUN_DIR, "dm-commands");
+var DM_RESP_DIR = resolve(RUN_DIR, "dm-responses");
+var SESSION_INBOX_DIR = resolve(RUN_DIR, "session-inbox");
+var SESSION_ASKS_DIR = resolve(RUN_DIR, "session-asks");
+var PLAYWRIGHT_BASE_PORT = parsePortEnv(process.env.PLAYWRIGHT_BASE_PORT, 9100);
+var PLAYWRIGHT_MAX_PORT = parsePortEnv(process.env.PLAYWRIGHT_MAX_PORT, 9499);
+var PLAYWRIGHT_PORTS_DIR = resolve(RUN_DIR, "playwright-ports");
+mkdirSync(STATE_DIR, { recursive: true });
+mkdirSync(DATA_DIR, { recursive: true });
+mkdirSync(LOG_DIR, { recursive: true });
+mkdirSync(PROGRESS_DIR, { recursive: true });
+mkdirSync(DM_CMD_DIR, { recursive: true });
+mkdirSync(DM_RESP_DIR, { recursive: true });
+mkdirSync(SESSION_INBOX_DIR, { recursive: true });
+mkdirSync(SESSION_ASKS_DIR, { recursive: true });
+mkdirSync(PLAYWRIGHT_PORTS_DIR, { recursive: true });
+mkdirSync(WORKSPACE_DIR, { recursive: true });
+mkdirSync(TOPIC_WORKSPACE_DIR, { recursive: true });
+mkdirSync(SHARED_WIKI_DIR, { recursive: true });
+mkdirSync(CONTEXTS_DIR, { recursive: true });
+mkdirSync(BROWSER_PROFILES_DIR, { recursive: true });
+mkdirSync(DM_WORKSPACE_DIR, { recursive: true });
+mkdirSync(SESSION_WORKSPACE_DIR, { recursive: true });
+var ACTIVE_QUERY_STALE_MS = 10 * 60 * 1000;
+var AGENTS_PROMPTS_DIR = resolve(PROJECT_ROOT, "src/prompts/agents");
+var RESOURCES_DIR = resolve(PROJECT_ROOT, "src/resources");
+var FALLBACK_AGENT = resolveAgentEnv("FALLBACK_AGENT", "maestro", "DEFAULT_AGENT");
+var SESSION_AGENT = resolveAgentEnv("SESSION_AGENT", FALLBACK_AGENT);
+var GATEWAY_AGENT = resolveAgentEnv("GATEWAY_AGENT", FALLBACK_AGENT);
+var FALLBACK_MODEL = envText("FALLBACK_MODEL") ?? envText("DEFAULT_MODEL");
+function resolveModelEnv(envKey, agentConst) {
+  return envText(envKey) ?? (agentConst === FALLBACK_AGENT ? FALLBACK_MODEL : undefined);
+}
+var SESSION_MODEL = resolveModelEnv("SESSION_MODEL", SESSION_AGENT);
+var GATEWAY_MODEL = resolveModelEnv("GATEWAY_MODEL", GATEWAY_AGENT);
+var FFMPEG_BIN = envText("FFMPEG_BIN");
+var FFPROBE_BIN = envText("FFPROBE_BIN");
+var PYTHON_BIN = envText("PYTHON_BIN") ?? "python3";
+var FASTER_WHISPER_WRAPPER = envText("FASTER_WHISPER_WRAPPER") ?? resolve(PROJECT_ROOT, "scripts/faster-whisper-wrapper.py");
+var WHISPER_MODEL = envText("WHISPER_MODEL_FILE") ?? "turbo";
+var TESSERACT_BIN = envText("TESSERACT_BIN") ?? "tesseract";
+var PDFTOTEXT_BIN = envText("PDFTOTEXT_BIN") ?? "pdftotext";
+var _envMaxTellDepth = Number.parseInt(process.env.MAX_TELL_DEPTH ?? "", 10);
+var MAX_TELL_DEPTH = Number.isInteger(_envMaxTellDepth) && _envMaxTellDepth > 0 ? _envMaxTellDepth : 20;
+
+// ../../packages/core/src/platform/delay.ts
+var delay = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// ../../packages/core/src/platform/playwright/manager-utils.ts
+import { resolve as resolve2 } from "path";
+function selectIdleEvictionKey(candidates, pinnedKeys, busyKeys, now, maxIdleMs) {
+  const pinned = new Set(pinnedKeys);
+  const busy = new Set(busyKeys);
+  let oldest = null;
+  for (const [key, instance] of candidates) {
+    if (pinned.has(key) || busy.has(key))
+      continue;
+    if (now - instance.lastUsedAt < maxIdleMs)
+      continue;
+    if (!oldest || instance.lastUsedAt < oldest.lastUsedAt) {
+      oldest = { key, lastUsedAt: instance.lastUsedAt };
+    }
+  }
+  return oldest?.key ?? null;
+}
+function selectReusablePort(minPort, maxPort, reservedPorts, isOccupied) {
+  for (let port = minPort;port <= maxPort; port++) {
+    if (reservedPorts.has(port) || isOccupied(port))
+      continue;
+    return port;
+  }
+  return null;
+}
+function extractUserDataDirArg(cmdline) {
+  const match = cmdline.match(/--user-data-dir(?:\s+|=)(\S+)/);
+  return match ? match[1] : null;
+}
+function browserProcessMatchesExpectedProfile(cmdline, expectedUserDataDir) {
+  const actualUserDataDir = extractUserDataDirArg(cmdline);
+  return actualUserDataDir !== null && resolve2(actualUserDataDir) === resolve2(expectedUserDataDir);
+}
+function waitForChildProcessExit(proc, timeoutMs) {
+  if (proc.exitCode !== null || proc.signalCode !== null)
+    return Promise.resolve(true);
+  return new Promise((resolveWait) => {
+    let settled = false;
+    let timer;
+    const finish = (exited) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      proc.off("exit", onExit);
+      resolveWait(exited);
+    };
+    const onExit = () => finish(true);
+    proc.once("exit", onExit);
+    timer = setTimeout(() => finish(proc.exitCode !== null || proc.signalCode !== null), timeoutMs);
+    if (typeof timer === "object")
+      timer.unref?.();
+    if (proc.exitCode !== null || proc.signalCode !== null)
+      finish(true);
+  });
+}
+function waitForChildProcessSpawnError(proc) {
+  return new Promise((_resolve, reject) => {
+    proc.once("error", reject);
+  });
+}
+
+// ../../packages/core/src/storage/storage-host.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join2, resolve as resolve3 } from "path";
+
+// ../../packages/core/src/storage/sqlite.ts
+var isBun = typeof process.versions.bun === "string";
+var Database;
+if (isBun) {
+  ({ Database } = await import("bun:sqlite"));
+} else {
+  const nodeSqliteSpecifier = ["node", "sqlite"].join(":");
+  const { DatabaseSync } = await import(nodeSqliteSpecifier);
+
+  class NodeDatabase {
+    #db;
+    constructor(path, options = {}) {
+      this.#db = options.readonly ? new DatabaseSync(path, { readOnly: true }) : new DatabaseSync(path);
+    }
+    query(sql) {
+      return this.#db.prepare(sql);
+    }
+    prepare(sql) {
+      return this.#db.prepare(sql);
+    }
+    exec(sql) {
+      this.#db.exec(sql);
+    }
+    run(sql, ...params) {
+      return this.#db.prepare(sql).run(...params);
+    }
+    transaction(fn) {
+      const run = (begin) => (...args) => {
+        this.#db.exec(begin);
+        try {
+          const result = fn(...args);
+          this.#db.exec("COMMIT");
+          return result;
+        } catch (err) {
+          this.#db.exec("ROLLBACK");
+          throw err;
+        }
+      };
+      const tx = run("BEGIN");
+      tx.deferred = run("BEGIN DEFERRED");
+      tx.immediate = run("BEGIN IMMEDIATE");
+      tx.exclusive = run("BEGIN EXCLUSIVE");
+      return tx;
+    }
+    close() {
+      this.#db.close();
+    }
+  }
+  Database = NodeDatabase;
+}
+
+// ../../packages/core/src/storage/storage-host.ts
+var configuredHost = {};
+var fallbackDatabase = null;
+var fallbackDatabasePath = null;
+var schemaInitializers = [];
+var initializedSchemas = new WeakMap;
+var initializingDatabases = new WeakSet;
+function envPath(name, fallback) {
+  const value = process.env[name]?.trim();
+  return resolve3(value || fallback);
+}
+function defaultStateDir() {
+  return envPath("NEGOTIUM_STATE_DIR", join2(homedir2(), ".negotium"));
+}
+function defaultDataDir() {
+  return envPath("NEGOTIUM_DATA_DIR", join2(defaultStateDir(), "data"));
+}
+function defaultSessionsDatabasePath() {
+  return envPath("SESSIONS_DB_PATH", join2(resolveStorageDataDir(), "sessions.db"));
+}
+function initializeDatabase(database) {
+  database.exec("PRAGMA journal_mode = WAL");
+  database.exec("PRAGMA foreign_keys = ON");
+  database.exec("PRAGMA busy_timeout = 5000");
+  database.exec("PRAGMA wal_autocheckpoint = 1000");
+  try {
+    database.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+  } catch {}
+}
+function defaultDatabase() {
+  const path = defaultSessionsDatabasePath();
+  if (fallbackDatabase && fallbackDatabasePath === path)
+    return fallbackDatabase;
+  if (fallbackDatabase)
+    fallbackDatabase.close();
+  mkdirSync2(dirname2(path), { recursive: true });
+  fallbackDatabase = new Database(path, { create: true });
+  fallbackDatabasePath = path;
+  initializeDatabase(fallbackDatabase);
+  return fallbackDatabase;
+}
+function resolveStorageDatabase() {
+  return configuredHost.database ?? defaultDatabase();
+}
+function resolveStorageDataDir() {
+  return configuredHost.dataDir ?? defaultDataDir();
+}
+function ensureStorageSchemas(database = resolveStorageDatabase()) {
+  if (initializingDatabases.has(database))
+    return;
+  let initialized = initializedSchemas.get(database);
+  if (!initialized) {
+    initialized = new Set;
+    initializedSchemas.set(database, initialized);
+  }
+  initializingDatabases.add(database);
+  try {
+    for (const entry of schemaInitializers) {
+      if (initialized.has(entry.initialize))
+        continue;
+      initialized.add(entry.initialize);
+      try {
+        entry.initialize(database);
+      } catch (error) {
+        initialized.delete(entry.initialize);
+        throw error;
+      }
+    }
+  } finally {
+    initializingDatabases.delete(database);
+  }
+}
+var internalStorageDatabase = new Proxy({}, {
+  get(_target, property) {
+    const database = resolveStorageDatabase();
+    ensureStorageSchemas(database);
+    const value = Reflect.get(database, property, database);
+    return typeof value === "function" ? value.bind(database) : value;
+  },
+  set(_target, property, value) {
+    const database = resolveStorageDatabase();
+    ensureStorageSchemas(database);
+    return Reflect.set(database, property, value, database);
+  }
+});
+
+// ../../packages/core/src/storage/forum-db.ts
+var db = internalStorageDatabase;
+
+// ../../packages/core/src/storage/runtime-leases.ts
+import { randomUUID } from "crypto";
+
+// ../../packages/core/src/storage/runtime-topic-state.ts
+db.exec(`
+  CREATE TABLE IF NOT EXISTS runtime_topic_state (
+    topic_id TEXT PRIMARY KEY,
+    epoch INTEGER NOT NULL DEFAULT 0,
+    maintenance INTEGER NOT NULL DEFAULT 0 CHECK (maintenance IN (0, 1)),
+    maintenance_owner TEXT,
+    heartbeat_at INTEGER
+  )
+`);
+
+// ../../packages/core/src/storage/runtime-leases.ts
+var RUNTIME_INSTANCE_ID = `${process.pid}-${randomUUID()}`;
+db.exec(`
+  CREATE TABLE IF NOT EXISTS runtime_turn_leases (
+    topic_id TEXT PRIMARY KEY,
+    query_id TEXT NOT NULL UNIQUE,
+    owner_id TEXT NOT NULL,
+    origin TEXT NOT NULL,
+    started_at INTEGER NOT NULL,
+    heartbeat_at INTEGER NOT NULL,
+    abort_requested INTEGER NOT NULL DEFAULT 0 CHECK (abort_requested IN (0, 1)),
+    abort_reason TEXT CHECK (abort_reason IS NULL OR abort_reason IN ('internal', 'external'))
+  )
+`);
+db.exec("CREATE INDEX IF NOT EXISTS idx_runtime_turn_leases_heartbeat ON runtime_turn_leases(heartbeat_at)");
+
+// ../../packages/core/src/storage/runtime-process-leases.ts
+var PROCESS_LEASE_STALE_MS = 5000;
+db.exec(`
+  CREATE TABLE IF NOT EXISTS runtime_process_leases (
+    role TEXT PRIMARY KEY,
+    owner_id TEXT NOT NULL UNIQUE,
+    pid INTEGER NOT NULL,
+    started_at INTEGER NOT NULL,
+    heartbeat_at INTEGER NOT NULL
+  )
+`);
+db.exec("CREATE INDEX IF NOT EXISTS idx_runtime_process_leases_heartbeat ON runtime_process_leases(heartbeat_at)");
+function rowToLease(row) {
+  return {
+    role: row.role,
+    ownerId: row.owner_id,
+    pid: Number(row.pid),
+    startedAt: Number(row.started_at),
+    heartbeatAt: Number(row.heartbeat_at)
+  };
+}
+function getRuntimeProcessLease(role, now = Date.now(), staleMs = PROCESS_LEASE_STALE_MS) {
+  const row = db.query("SELECT * FROM runtime_process_leases WHERE role = ?").get(role);
+  if (!row)
+    return null;
+  const lease = rowToLease(row);
+  return now - lease.heartbeatAt <= staleMs ? lease : null;
+}
+
+// ../../packages/core/src/platform/playwright/browser-processes.ts
+function isPortInUse(port) {
+  try {
+    execFileSync2("lsof", ["-i", `:${port}`, "-t"], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function killPlaywrightOnPort(port, expectedUserDataDir) {
+  try {
+    const pids = execFileSync2("lsof", ["-i", `:${port}`, "-t"], { stdio: "pipe" }).toString().trim();
+    if (!pids)
+      return;
+    for (const pid of pids.split(`
+`)) {
+      try {
+        const cmdline = execFileSync2("ps", ["-p", pid, "-o", "command="], { stdio: "pipe" }).toString().trim();
+        if (!cmdline.includes("mcp-patchright-http.mjs")) {
+          logger.warn({ port, pid, cmdline: cmdline.slice(0, 80) }, "Port occupied by non-browser-MCP process, skipping");
+          continue;
+        }
+        if (expectedUserDataDir) {
+          const otherDataDir = extractUserDataDirArg(cmdline);
+          if (!browserProcessMatchesExpectedProfile(cmdline, expectedUserDataDir)) {
+            logger.warn({
+              port,
+              pid,
+              otherDataDir,
+              expectedUserDataDir
+            }, "Port occupied by another topic's playwright-mcp, skipping");
+            continue;
+          }
+        }
+        const pidNum = parseInt(pid, 10);
+        if (!Number.isNaN(pidNum)) {
+          killProcessTreeChildren(pidNum);
+          process.kill(pidNum, "SIGKILL");
+        }
+        logger.info({ pid, port }, "Killed zombie mcp-patchright");
+      } catch (e) {
+        logger.warn({ err: e, port }, "Failed to inspect process occupying port");
+      }
+    }
+  } catch (e) {
+    logger.warn({ err: e, port }, "Failed to check processes on port");
+  }
+  const start = Date.now();
+  while (Date.now() - start < 3000) {
+    if (!isPortInUse(port))
+      return;
+    await delay(200);
+  }
+}
+function killBrowserProcsForUserDataDir(userDataDir) {
+  const target = resolve4(userDataDir);
+  const profileRoot = resolve4(BROWSER_PROFILES_DIR);
+  if (target !== profileRoot && !target.startsWith(`${profileRoot}${sep}`))
+    return;
+  let pids;
+  try {
+    pids = execFileSync2("pgrep", ["-f", "--", userDataDir], { stdio: "pipe" }).toString().trim();
+  } catch {
+    return;
+  }
+  if (!pids)
+    return;
+  for (const pid of pids.split(`
+`)) {
+    const pidNum = parseInt(pid.trim(), 10);
+    if (Number.isNaN(pidNum) || pidNum === process.pid)
+      continue;
+    try {
+      const cmdline = execFileSync2("ps", ["-p", String(pidNum), "-o", "command="], {
+        stdio: "pipe"
+      }).toString().trim();
+      const argDir = extractUserDataDirArg(cmdline);
+      if (!argDir || resolve4(argDir) !== target)
+        continue;
+      killProcessTreeChildren(pidNum);
+      process.kill(pidNum, "SIGKILL");
+      logger.info({ pid: pidNum, userDataDir }, "Reaped orphaned browser process by user-data-dir");
+    } catch (e) {
+      logger.debug({ err: e, pid: pidNum, userDataDir }, "Failed to reap browser proc by dir");
+    }
+  }
+}
+function selectOrphanBrowserPids(procs, liveUserDataDirs, profileRoot, selfPid) {
+  const root = resolve4(profileRoot);
+  const live = new Set([...liveUserDataDirs].map((d) => resolve4(d)));
+  const out = [];
+  for (const { pid, userDataDir } of procs) {
+    if (pid === selfPid || !userDataDir)
+      continue;
+    const dir = resolve4(userDataDir);
+    if (dir !== root && !dir.startsWith(`${root}${sep}`))
+      continue;
+    if (live.has(dir))
+      continue;
+    out.push(pid);
+  }
+  return out;
+}
+function isBrowserJanitorOwner(leaseOwnerPid, selfPid) {
+  return leaseOwnerPid === selfPid;
+}
+function reapOrphanBrowsers(liveUserDataDirs) {
+  const daemonLease = getRuntimeProcessLease("node-daemon", Date.now(), Number.POSITIVE_INFINITY);
+  if (!isBrowserJanitorOwner(daemonLease?.pid ?? null, process.pid))
+    return;
+  const profileRoot = resolve4(BROWSER_PROFILES_DIR);
+  let pids;
+  try {
+    pids = execFileSync2("pgrep", ["-f", "--", profileRoot], { stdio: "pipe" }).toString().trim();
+  } catch {
+    return;
+  }
+  if (!pids)
+    return;
+  const procs = [];
+  for (const pid of pids.split(`
+`)) {
+    const pidNum = parseInt(pid.trim(), 10);
+    if (Number.isNaN(pidNum))
+      continue;
+    try {
+      const cmdline = execFileSync2("ps", ["-p", String(pidNum), "-o", "command="], {
+        stdio: "pipe"
+      }).toString().trim();
+      procs.push({ pid: pidNum, userDataDir: extractUserDataDirArg(cmdline) });
+    } catch {}
+  }
+  const orphanPids = selectOrphanBrowserPids(procs, liveUserDataDirs, profileRoot, process.pid);
+  for (const pid of orphanPids) {
+    try {
+      killProcessTreeChildren(pid);
+      process.kill(pid, "SIGKILL");
+      logger.info({ pid }, "Reaped orphaned browser process (janitor)");
+    } catch (e) {
+      logger.debug({ err: e, pid }, "Janitor failed to reap orphaned browser process");
+    }
+  }
+}
+async function isHealthy(port) {
+  for (const path of ["/health", "/sse?owner=__negotium_health__"]) {
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}${path}`, {
+        signal: AbortSignal.timeout(2000)
+      });
+      await res.body?.cancel();
+      if (res.ok)
+        return true;
+    } catch {}
+  }
+  return false;
+}
+function cleanSingletonFiles(userDataDir) {
+  try {
+    const files = readdirSync(userDataDir);
+    for (const f of files) {
+      if (f.startsWith("Singleton")) {
+        try {
+          unlinkSync(resolve4(userDataDir, f));
+          logger.info({ file: f, userDataDir }, "Removed stale Singleton file");
+        } catch (e) {
+          logger.warn({ err: e, file: f }, "Failed to remove stale Chrome Singleton file");
+        }
+      }
+    }
+  } catch {}
+}
+function killProcessTreeChildren(pid) {
+  try {
+    const children = execFileSync2("pgrep", ["-P", String(pid)], { stdio: "pipe" }).toString().trim();
+    if (!children)
+      return;
+    const childPids = children.split(`
+`).map((cpid) => parseInt(cpid, 10)).filter((pidNum) => !Number.isNaN(pidNum));
+    for (const childPid of childPids) {
+      killProcessTreeChildren(childPid);
+    }
+    for (const signal of ["SIGTERM", "SIGKILL"]) {
+      for (const childPid of childPids) {
+        try {
+          process.kill(childPid, signal);
+        } catch (e) {
+          logger.debug({ err: e, pid: childPid, signal }, "Failed to signal browser child process");
+        }
+      }
+    }
+    logger.info({ parentPid: pid, childPids }, "Killed browser-MCP child process tree");
+  } catch {}
+}
+// ../../packages/core/src/platform/playwright/manager.ts
+import { execFileSync as execFileSync3, spawn } from "child_process";
+import { createHash, randomBytes as randomBytes2, timingSafeEqual } from "crypto";
+import {
+  cpSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync3,
+  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";
+
+// ../../packages/core/src/platform/playwright/headed-launch.ts
+import { accessSync as accessSync2, constants as constants2 } from "fs";
+import { delimiter, isAbsolute, resolve as resolve5 } from "path";
+function findExecutableOnPath(command, environment = process.env) {
+  const candidates = isAbsolute(command) ? [command] : (environment.PATH ?? "").split(delimiter).filter(Boolean).map((directory) => resolve5(directory, command));
+  for (const candidate of candidates) {
+    try {
+      accessSync2(candidate, constants2.X_OK);
+      return candidate;
+    } catch {}
+  }
+  return null;
+}
+function resolveHeadedPlaywrightSpawn(command, args, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const environment = options.environment ?? process.env;
+  const hasDisplay = Boolean(environment.DISPLAY?.trim() || environment.WAYLAND_DISPLAY?.trim());
+  if (platform !== "linux" || hasDisplay) {
+    return { command, args: [...args], virtualDisplay: false };
+  }
+  const xvfbRun = (options.findExecutable ?? findExecutableOnPath)("xvfb-run", environment);
+  if (!xvfbRun) {
+    throw new Error("Headed Playwright on Linux requires DISPLAY/WAYLAND_DISPLAY or xvfb-run; install Xvfb and ensure xvfb-run is on PATH");
+  }
+  return {
+    command: xvfbRun,
+    args: ["-a", "-s", "-screen 0 1440x1000x24", command, ...args],
+    virtualDisplay: true
+  };
+}
+
+// ../../packages/core/src/platform/playwright/transport-probe.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+// ../../packages/core/src/platform/playwright/capability.ts
+import { createHmac } from "crypto";
+function browserOwnerCapability(capability, owner) {
+  return createHmac("sha256", capability).update(owner).digest("hex");
+}
+
+// ../../packages/core/src/platform/playwright/transport-probe.ts
+var PROBE_OWNER = "__negotium_transport_probe__";
+var PROBE_TIMEOUT_MS = 3000;
+async function probeMcpTransport(transport, options = {}) {
+  const client = new Client({ name: "negotium-browser-healthcheck", version: "1.0.0" });
+  let timeout;
+  try {
+    const tools = await Promise.race([
+      (async () => {
+        await client.connect(transport);
+        const result = await client.listTools();
+        if (result.tools.length === 0)
+          throw new Error("browser MCP returned no tools");
+        await options.terminate?.();
+        return result.tools;
+      })(),
+      new Promise((_, reject) => {
+        timeout = setTimeout(() => reject(new Error("browser MCP transport probe timed out")), options.timeoutMs ?? PROBE_TIMEOUT_MS);
+        timeout.unref?.();
+      })
+    ]);
+    return tools.length > 0;
+  } catch {
+    return false;
+  } finally {
+    if (timeout)
+      clearTimeout(timeout);
+    try {
+      await client.close();
+    } catch {}
+  }
+}
+async function probePlaywrightMcpTransports(port, capability, fetchImpl = fetch) {
+  const query = new URLSearchParams({ owner: PROBE_OWNER });
+  const baseUrl = `http://127.0.0.1:${port}`;
+  const ownerCapability = browserOwnerCapability(capability, PROBE_OWNER);
+  const capabilityHeaders = { "X-Browser-Capability": ownerCapability };
+  const authenticatedFetch = (input, init) => {
+    const headers = new Headers(init?.headers);
+    headers.set("X-Browser-Capability", ownerCapability);
+    return fetchImpl(input, { ...init, headers });
+  };
+  const sseTransport = new SSEClientTransport(new URL(`${baseUrl}/sse?${query}`), {
+    fetch: authenticatedFetch,
+    eventSourceInit: { fetch: authenticatedFetch },
+    requestInit: { headers: capabilityHeaders }
+  });
+  if (!await probeMcpTransport(sseTransport))
+    return false;
+  const streamableTransport = new StreamableHTTPClientTransport(new URL(`${baseUrl}/mcp?${query}`), {
+    fetch: authenticatedFetch,
+    requestInit: { headers: capabilityHeaders }
+  });
+  return probeMcpTransport(streamableTransport, {
+    terminate: () => streamableTransport.terminateSession()
+  });
+}
+
+// ../../packages/core/src/security/sanitize.ts
+function sanitizeTopicName(name, lowercase = false) {
+  const safe = name.replace(/[^a-zA-Z0-9\uAC00-\uD7A3_-]/g, "_") || "_";
+  return lowercase ? safe.toLowerCase() : safe;
+}
+
+// ../../packages/core/src/storage/browser-profiles.ts
+var DEFAULT_BROWSER_PROFILE = "default";
+function normalizeBrowserProfileName(name) {
+  const value = name.trim().toLowerCase();
+  if (!/^[a-z0-9][a-z0-9_-]{0,47}$/.test(value)) {
+    throw new Error("Profile name must be 1-48 lowercase letters, numbers, '-' or '_'.");
+  }
+  return value;
+}
+db.exec(`
+  CREATE TABLE IF NOT EXISTS browser_profiles (
+    owner_id TEXT NOT NULL,
+    name TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    PRIMARY KEY (owner_id, name)
+  )
+`);
+function getBrowserProfileOwner(topicId, fallbackUserId) {
+  return db.query("SELECT browser_profile_owner FROM api_topics WHERE id = ?").get(topicId)?.browser_profile_owner ?? fallbackUserId;
+}
+function getTopicBrowserProfile(topicId) {
+  const value = db.query("SELECT browser_profile FROM api_topics WHERE id = ?").get(topicId)?.browser_profile;
+  return value || DEFAULT_BROWSER_PROFILE;
+}
+function hasBrowserProfileTopic(topicId) {
+  return Boolean(db.query("SELECT id FROM api_topics WHERE id = ?").get(topicId));
+}
+function createBrowserProfile(ownerId, rawName) {
+  const name = normalizeBrowserProfileName(rawName);
+  if (name === DEFAULT_BROWSER_PROFILE)
+    return name;
+  db.query("INSERT OR IGNORE INTO browser_profiles (owner_id, name, created_at) VALUES (?, ?, ?)").run(ownerId, name, new Date().toISOString());
+  return name;
+}
+function assignTopicBrowserProfile(opts) {
+  const actualOwner = getBrowserProfileOwner(opts.topicId, "");
+  if (!actualOwner)
+    throw new Error(`Topic "${opts.topicId}" not found or has no owner.`);
+  if (actualOwner !== opts.actorUserId) {
+    throw new Error(`Only the topic owner can change its browser profile.`);
+  }
+  const profile = normalizeBrowserProfileName(opts.profile);
+  if (profile !== DEFAULT_BROWSER_PROFILE)
+    createBrowserProfile(actualOwner, profile);
+  const previous = getTopicBrowserProfile(opts.topicId);
+  const result = db.query("UPDATE api_topics SET browser_profile = ? WHERE id = ?").run(profile, opts.topicId);
+  if (Number(result.changes ?? 0) !== 1)
+    throw new Error(`Topic "${opts.topicId}" not found.`);
+  return { previous, profile };
+}
+// ../../packages/core/src/platform/playwright/manager.ts
+function makeInstanceKey(userId, topic) {
+  return resolvePlaywrightTopicBinding(userId, topic).instanceKey;
+}
+function resolvePlaywrightTopicBinding(userId, topic) {
+  return validateProfileBinding(managerHost.resolveTopicBinding(userId, topic));
+}
+function defaultTopicBinding(userId, topic) {
+  if (!topic)
+    return managerHost.resolveNamedBinding(userId, "default");
+  const ownerId = getBrowserProfileOwner(topic, userId);
+  const profile = migrateLegacyTopicProfile(ownerId, topic);
+  return managerHost.resolveNamedBinding(ownerId, profile);
+}
+function makeBrowserProfileInstanceKey(ownerId, rawProfile) {
+  return resolvePlaywrightProfileBinding(ownerId, rawProfile).instanceKey;
+}
+function resolvePlaywrightProfileBinding(ownerId, rawProfile) {
+  return validateProfileBinding(managerHost.resolveNamedBinding(ownerId, rawProfile));
+}
+function validateProfileBinding(binding) {
+  if (!binding || typeof binding.instanceKey !== "string" || !binding.instanceKey.trim() || typeof binding.ownerId !== "string" || !binding.ownerId.trim() || typeof binding.profile !== "string" || !binding.profile.trim()) {
+    throw new Error("invalid Playwright profile binding");
+  }
+  return Object.freeze({ ...binding });
+}
+function defaultNamedBinding(ownerId, rawProfile) {
+  const profile = normalizeBrowserProfileName(rawProfile);
+  const instanceKey = `profile:${encodeURIComponent(ownerId)}:${profile}`;
+  return {
+    instanceKey,
+    ownerId,
+    profile
+  };
+}
+function legacyBrowserProfileName(topic) {
+  return `legacy_${createHash("sha256").update(topic).digest("hex").slice(0, 12)}`;
+}
+function migrateLegacyTopicProfile(ownerId, topic) {
+  const current = getTopicBrowserProfile(topic);
+  if (current !== "default" || !hasBrowserProfileTopic(topic))
+    return current;
+  const legacyDir = resolve6(BROWSER_PROFILES_DIR, sanitizeTopicName(topic));
+  if (!existsSync2(legacyDir))
+    return current;
+  const profile = legacyBrowserProfileName(topic);
+  const profileDir = defaultProfileDir(ownerId, profile);
+  mkdirSync3(dirname3(profileDir), { recursive: true });
+  if (!existsSync2(profileDir))
+    renameSync(legacyDir, profileDir);
+  assignTopicBrowserProfile({ topicId: topic, actorUserId: ownerId, profile });
+  logger.info({ ownerId, topic, profile }, "Adopted legacy topic browser profile");
+  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 } : {}
+    } : {}
+  };
+}
+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,
+  resolveNamedBinding: defaultNamedBinding,
+  resolveInstanceDataDir(instanceKey) {
+    const { ownerId, profile } = parseInstanceKey(instanceKey);
+    return defaultProfileDir(ownerId, profile);
+  },
+  createChildEnvironment: defaultChildEnvironment,
+  cleanupBrowserProcessesForDataDir: killBrowserProcsForUserDataDir,
+  reapOrphanBrowsers
+});
+var managerHost = defaultManagerHost;
+function configurePlaywrightManagerHost(overrides) {
+  if (instances.size > 0 || spawning.size > 0 || pinnedInstances.size > 0) {
+    throw new Error("cannot configure Playwright manager while browser instances are active");
+  }
+  const next = { ...managerHost, ...overrides };
+  if (!next.portsDir || !Number.isInteger(next.basePort) || !Number.isInteger(next.maxPort)) {
+    throw new Error("invalid Playwright manager paths or port range");
+  }
+  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.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");
+  }
+  managerHost = Object.freeze(next);
+  return managerHost;
+}
+function getPlaywrightManagerHost() {
+  return managerHost;
+}
+function resetPlaywrightManagerHost() {
+  configurePlaywrightManagerHost(defaultManagerHost);
+}
+function parseInstanceKey(instanceKey) {
+  const match = /^profile:([^:]+):(.+)$/.exec(instanceKey);
+  if (!match)
+    return { ownerId: "legacy", profile: sanitizeTopicName(instanceKey) };
+  return {
+    ownerId: decodeURIComponent(match[1]),
+    profile: normalizeBrowserProfileName(match[2])
+  };
+}
+function portFileName(instanceKey) {
+  return createHash("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));
+  } catch (e) {
+    logger.warn({ err: e, instanceKey, port }, "Failed to save playwright port file");
+  }
+}
+function deletePortFile(instanceKey) {
+  try {
+    unlinkSync2(join3(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);
+    return Number.isInteger(port) ? port : null;
+  } catch {
+    return null;
+  }
+}
+var MAX_IDLE_MS = 2 * 60 * 60 * 1000;
+var instances = new Map;
+function assertInstanceOwner(instanceKey, ownerId) {
+  const existing = instances.get(instanceKey);
+  if (existing && existing.ownerId !== ownerId) {
+    throw new Error(`Playwright profile binding owner changed for "${instanceKey}" (${existing.ownerId} -> ${ownerId})`);
+  }
+}
+var usedPorts = new Set;
+var spawning = new Map;
+async function withPlaywrightInstanceMaintenance(rawKeys, operation) {
+  const keys = [...new Set(rawKeys)].sort();
+  const lockedKeys = new Set(keys);
+  for (;; ) {
+    const pending = keys.map((key) => spawning.get(key)).filter((promise) => promise !== undefined);
+    if (pending.length > 0) {
+      await Promise.allSettled(pending);
+      continue;
+    }
+    let releaseBarrier;
+    const barrier = new Promise((resolveBarrier) => {
+      releaseBarrier = () => resolveBarrier(null);
+    });
+    for (const key of keys)
+      spawning.set(key, barrier);
+    try {
+      return await operation({
+        async stopInstance(instanceKey) {
+          if (!lockedKeys.has(instanceKey)) {
+            throw new Error(`Playwright maintenance does not own instance "${instanceKey}"`);
+          }
+          const process2 = instances.get(instanceKey)?.process;
+          if (!process2)
+            return false;
+          killInstance(instanceKey);
+          if (!await waitForChildProcessExit(process2, 3000)) {
+            logger.warn({ instanceKey, pid: process2.pid }, "Playwright MCP ignored SIGTERM during profile maintenance");
+            try {
+              process2.kill("SIGKILL");
+            } catch (error) {
+              logger.warn({ err: error, instanceKey, pid: process2.pid }, "Failed to SIGKILL Playwright MCP during profile maintenance");
+            }
+            await waitForChildProcessExit(process2, 1000);
+          }
+          return true;
+        }
+      });
+    } finally {
+      for (const key of keys) {
+        if (spawning.get(key) === barrier)
+          spawning.delete(key);
+      }
+      releaseBarrier();
+    }
+  }
+}
+function stopPlaywrightInstance(instanceKey) {
+  return withPlaywrightInstanceMaintenance([instanceKey], ({ stopInstance }) => stopInstance(instanceKey));
+}
+function withPlaywrightProfileMaintenance(ownerId, rawProfile, operation) {
+  const binding = resolvePlaywrightProfileBinding(ownerId, rawProfile);
+  return withPlaywrightInstanceMaintenance([binding.instanceKey], async (control) => {
+    assertInstanceOwner(binding.instanceKey, binding.ownerId);
+    return operation(binding, control);
+  });
+}
+function stopPlaywrightProfile(ownerId, rawProfile) {
+  return withPlaywrightProfileMaintenance(ownerId, rawProfile, (binding, { stopInstance }) => stopInstance(binding.instanceKey));
+}
+var pinnedInstances = new Map;
+function pinPlaywrightInstance(instanceKey) {
+  pinnedInstances.set(instanceKey, (pinnedInstances.get(instanceKey) ?? 0) + 1);
+}
+function unpinPlaywrightInstance(instanceKey) {
+  const count = pinnedInstances.get(instanceKey);
+  if (count === undefined)
+    return;
+  if (count <= 1)
+    pinnedInstances.delete(instanceKey);
+  else
+    pinnedInstances.set(instanceKey, count - 1);
+}
+function getPlaywrightCapability(instanceKey) {
+  return instances.get(instanceKey)?.capability;
+}
+function resolvePlaywrightCapabilityOwner(capability) {
+  if (!capability)
+    return;
+  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)) {
+      return instance.ownerId;
+    }
+  }
+  return;
+}
+function reapPlaywrightOrphans() {
+  managerHost.reapOrphanBrowsers([...instances.keys()].map(resolveUserDataDir));
+}
+var playwrightFailureHandlers = new Set;
+function onPlaywrightFailure(handler) {
+  playwrightFailureHandlers.add(handler);
+  return () => playwrightFailureHandlers.delete(handler);
+}
+function notifyPlaywrightFailure(instanceKey, failure) {
+  for (const handler of playwrightFailureHandlers) {
+    try {
+      handler(instanceKey, failure);
+    } catch (err) {
+      logger.warn({ err, instanceKey, failure }, "Playwright failure handler failed");
+    }
+  }
+}
+function evictIdleInstance() {
+  const now = Date.now();
+  const oldestKey = selectIdleEvictionKey(instances, pinnedInstances.keys(), spawning.keys(), now, MAX_IDLE_MS);
+  if (oldestKey) {
+    const instance = instances.get(oldestKey);
+    if (!instance)
+      return null;
+    const idleMin = ((now - instance.lastUsedAt) / 60000).toFixed(0);
+    logger.info({ key: oldestKey, idleMin }, "Evicting idle playwright instance");
+    killInstance(oldestKey);
+    return instance.port;
+  }
+  return null;
+}
+async function allocatePort(expectedUserDataDir) {
+  for (let port = managerHost.basePort;port <= managerHost.maxPort; port++) {
+    if (usedPorts.has(port))
+      continue;
+    usedPorts.add(port);
+    if (isPortInUse(port)) {
+      logger.warn({ port }, "Port occupied by external process, attempting cleanup");
+      await killPlaywrightOnPort(port, expectedUserDataDir);
+      if (isPortInUse(port)) {
+        usedPorts.delete(port);
+        continue;
+      }
+    }
+    return port;
+  }
+  const evictedPort = evictIdleInstance();
+  if (evictedPort !== null) {
+    await waitForPortRelease(evictedPort);
+    const reusablePort = selectReusablePort(managerHost.basePort, managerHost.maxPort, usedPorts, isPortInUse);
+    if (reusablePort !== null) {
+      usedPorts.add(reusablePort);
+      return reusablePort;
+    }
+  }
+  throw new Error(`No available ports for Playwright MCP (${instances.size} active instances, range ${managerHost.basePort}-${managerHost.maxPort})`);
+}
+function releasePort(port) {
+  usedPorts.delete(port);
+}
+function ownerDirectory(ownerId) {
+  const digest = createHash("sha256").update(ownerId).digest("hex").slice(0, 16);
+  return `${sanitizeTopicName(ownerId).slice(0, 24)}_${digest}`;
+}
+function defaultProfileDir(ownerId, profile) {
+  return resolve6(BROWSER_PROFILES_DIR, "profiles", ownerDirectory(ownerId), profile);
+}
+function resolveUserDataDir(instanceKey) {
+  return managerHost.resolveInstanceDataDir(instanceKey);
+}
+function killInstance(instanceKey, opts) {
+  const inst = instances.get(instanceKey);
+  if (!inst)
+    return;
+  if (inst.process.pid) {
+    killProcessTreeChildren(inst.process.pid);
+  }
+  try {
+    inst.process.kill("SIGTERM");
+  } catch (e) {
+    logger.warn({ err: e, instanceKey }, "Failed to kill playwright instance");
+  }
+  inst.process.removeAllListeners("error");
+  inst.process.removeAllListeners("exit");
+  cleanSingletonFiles(resolveUserDataDir(instanceKey));
+  if (!opts?.keepPort)
+    releasePort(inst.port);
+  instances.delete(instanceKey);
+  deletePortFile(instanceKey);
+  logger.info({ instanceKey, port: inst.port, keepPort: !!opts?.keepPort }, "Killed Playwright MCP (with cleanup)");
+}
+async function spawnPlaywright(instanceKey, ownerId, reservedPort, browserBin = managerHost.browserBin, allowFallback = true) {
+  const userDataDir = resolveUserDataDir(instanceKey);
+  const port = reservedPort ?? await allocatePort(userDataDir);
+  mkdirSync3(userDataDir, { recursive: true });
+  const mcpArgs = [
+    "--port",
+    String(port),
+    "--host",
+    "127.0.0.1",
+    "--headed",
+    "--user-data-dir",
+    userDataDir
+  ];
+  const proxy = managerHost.resolveProxy();
+  const capability = randomBytes2(32).toString("hex");
+  const childEnv = {
+    ...managerHost.createChildEnvironment({
+      instanceKey,
+      ownerId,
+      capability,
+      proxy,
+      browserRsBin: managerHost.browserRsBin,
+      environment: process.env
+    }),
+    NEGOTIUM_BROWSER_CAPABILITY: capability
+  };
+  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) {
+    releasePort(port);
+    throw err;
+  }
+  let proc;
+  try {
+    proc = spawn(spawnSpec.command, spawnSpec.args, {
+      stdio: "ignore",
+      detached: false,
+      env: childEnv
+    });
+  } catch (err) {
+    releasePort(port);
+    throw err;
+  }
+  const spawnError = waitForChildProcessSpawnError(proc);
+  const reapCrashedBrowser = () => {
+    const userDataDir2 = resolveUserDataDir(instanceKey);
+    managerHost.cleanupBrowserProcessesForDataDir(userDataDir2);
+    cleanSingletonFiles(userDataDir2);
+  };
+  proc.once("error", (err) => {
+    logger.error({ err, instanceKey }, "Playwright MCP error");
+    if (instances.get(instanceKey)?.process === proc) {
+      releasePort(port);
+      instances.delete(instanceKey);
+      reapCrashedBrowser();
+      notifyPlaywrightFailure(instanceKey, {
+        reason: "process-error",
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  });
+  proc.once("exit", (code) => {
+    logger.info({ instanceKey, code }, "Playwright MCP exited");
+    const wasOurs = instances.get(instanceKey)?.process === proc;
+    if (wasOurs) {
+      releasePort(port);
+      instances.delete(instanceKey);
+      reapCrashedBrowser();
+      notifyPlaywrightFailure(instanceKey, { reason: "exit", code });
+    }
+  });
+  const now = Date.now();
+  instances.set(instanceKey, {
+    process: proc,
+    port,
+    ownerId,
+    startedAt: now,
+    lastUsedAt: now,
+    capability
+  });
+  const ready = await Promise.race([
+    (async () => await waitForServer(port, 1e4) && await supportsOwnerCleanup(port, capability) && await probePlaywrightMcpTransports(port, capability))(),
+    spawnError
+  ]);
+  if (!ready) {
+    const exitCode = proc.exitCode;
+    killInstance(instanceKey);
+    if (allowFallback && browserBin !== managerHost.fallbackBrowserBin) {
+      logger.warn({ instanceKey, browserBin, fallback: managerHost.fallbackBrowserBin }, "Preferred browser MCP unavailable or lacks owner isolation; using Patchright fallback");
+      return spawnPlaywright(instanceKey, ownerId, undefined, managerHost.fallbackBrowserBin, false);
+    }
+    throw new Error(`Playwright MCP failed health check after spawn on port ${port}` + (exitCode === null ? "" : ` (exitCode=${exitCode})`));
+  }
+  writePortFile(instanceKey, port);
+  logger.info({ instanceKey, port, pid: proc.pid, ready, virtualDisplay: spawnSpec.virtualDisplay }, "Playwright MCP started");
+  return port;
+}
+async function supportsOwnerCleanup(port, capability) {
+  try {
+    const query = new URLSearchParams({ owner: "__negotium_capability_probe__" });
+    const response = await fetch(`http://127.0.0.1:${port}/owners?${query}`, {
+      method: "DELETE",
+      headers: {
+        "X-Browser-Capability": capability
+      },
+      signal: AbortSignal.timeout(2000)
+    });
+    await response.body?.cancel();
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function ensurePlaywright(userId, topic) {
+  const binding = resolvePlaywrightTopicBinding(userId, topic);
+  const { instanceKey, ownerId } = binding;
+  const inProgress = spawning.get(instanceKey);
+  if (inProgress) {
+    const port = await inProgress;
+    assertInstanceOwner(instanceKey, ownerId);
+    if (port !== null)
+      return port;
+    return ensurePlaywright(userId, topic);
+  }
+  const promise = (async () => {
+    const existing = instances.get(instanceKey);
+    assertInstanceOwner(instanceKey, ownerId);
+    if (existing && !existing.process.killed && existing.process.exitCode === null) {
+      if (await probePlaywrightMcpTransports(existing.port, existing.capability)) {
+        existing.lastUsedAt = Date.now();
+        return existing.port;
+      }
+      logger.warn({ instanceKey }, "Playwright MCP unresponsive, restarting");
+      const oldPort = existing.port;
+      killInstance(instanceKey);
+      notifyPlaywrightFailure(instanceKey, { reason: "unhealthy" });
+      await waitForPortRelease(oldPort);
+      cleanSingletonFiles(resolveUserDataDir(instanceKey));
+    } else if (existing) {
+      releasePort(existing.port);
+      instances.delete(instanceKey);
+      cleanSingletonFiles(resolveUserDataDir(instanceKey));
+      notifyPlaywrightFailure(instanceKey, {
+        reason: "exit",
+        code: existing.process.exitCode
+      });
+    }
+    return spawnPlaywright(instanceKey, ownerId);
+  })().finally(() => spawning.delete(instanceKey));
+  spawning.set(instanceKey, promise);
+  return promise;
+}
+async function waitForPortRelease(port, timeoutMs = 3000) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (!isPortInUse(port))
+      return;
+    await delay(200);
+  }
+}
+async function ensureBrowserProfile(ownerId, rawProfile) {
+  const binding = resolvePlaywrightProfileBinding(ownerId, rawProfile);
+  const instanceKey = binding.instanceKey;
+  const inProgress = spawning.get(instanceKey);
+  if (inProgress) {
+    const port = await inProgress;
+    assertInstanceOwner(instanceKey, binding.ownerId);
+    const capability = instances.get(instanceKey)?.capability;
+    if (port !== null && capability && await probePlaywrightMcpTransports(port, capability)) {
+      return port;
+    }
+    if (port === null)
+      return ensureBrowserProfile(ownerId, rawProfile);
+    throw new Error(`Browser profile "${rawProfile}" failed to start.`);
+  }
+  const promise = (async () => {
+    const publishedPort = readPortFile(instanceKey);
+    const existing = instances.get(instanceKey);
+    assertInstanceOwner(instanceKey, binding.ownerId);
+    if (publishedPort !== null && !existing) {
+      logger.warn({ instanceKey, publishedPort }, "Recycling untracked browser profile process from stale port file");
+      await killPlaywrightOnPort(publishedPort, resolveUserDataDir(instanceKey));
+      await waitForPortRelease(publishedPort);
+      deletePortFile(instanceKey);
+    }
+    if (existing && !existing.process.killed && existing.process.exitCode === null) {
+      if (await probePlaywrightMcpTransports(existing.port, existing.capability)) {
+        existing.lastUsedAt = Date.now();
+        return existing.port;
+      }
+      const oldPort = existing.port;
+      killInstance(instanceKey);
+      notifyPlaywrightFailure(instanceKey, { reason: "unhealthy" });
+      await waitForPortRelease(oldPort);
+      cleanSingletonFiles(resolveUserDataDir(instanceKey));
+    } else if (existing) {
+      releasePort(existing.port);
+      instances.delete(instanceKey);
+      cleanSingletonFiles(resolveUserDataDir(instanceKey));
+      notifyPlaywrightFailure(instanceKey, {
+        reason: "exit",
+        code: existing.process.exitCode
+      });
+    }
+    const port = await spawnPlaywright(instanceKey, binding.ownerId);
+    const capability = instances.get(instanceKey)?.capability;
+    if (!capability || !await probePlaywrightMcpTransports(port, capability)) {
+      killInstance(instanceKey);
+      throw new Error(`Browser profile "${rawProfile}" did not pass its health check.`);
+    }
+    return port;
+  })().finally(() => spawning.delete(instanceKey));
+  spawning.set(instanceKey, promise);
+  return promise;
+}
+async function closeBrowserOwnerTabs(ownerId, rawProfile, owner) {
+  const binding = resolvePlaywrightProfileBinding(ownerId, rawProfile);
+  const instanceKey = binding.instanceKey;
+  const inProgress = spawning.get(instanceKey);
+  if (inProgress)
+    await inProgress;
+  assertInstanceOwner(instanceKey, binding.ownerId);
+  const instance = instances.get(instanceKey);
+  if (!instance)
+    return 0;
+  const port = instance.port;
+  const query = new URLSearchParams({ owner });
+  const response = await fetch(`http://127.0.0.1:${port}/owners?${query}`, {
+    method: "DELETE",
+    headers: {
+      "X-Browser-Capability": instance.capability
+    },
+    signal: AbortSignal.timeout(5000)
+  });
+  if (!response.ok)
+    throw new Error(`browser MCP owner cleanup failed (${response.status})`);
+  const result = await response.json();
+  return typeof result.closed === "number" ? result.closed : 0;
+}
+async function waitForServer(port, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (await isHealthy(port))
+      return true;
+    await delay(300);
+  }
+  logger.warn({ port, timeoutMs }, "Playwright MCP not ready before timeout");
+  return false;
+}
+function resolveTopicProfileDir(userId, topic) {
+  return resolveUserDataDir(makeInstanceKey(userId, topic));
+}
+async function killAllPlaywright() {
+  const procs = [...instances.entries()].map(([key, inst]) => ({ key, proc: inst.process }));
+  for (const { key } of procs)
+    killInstance(key);
+  await Promise.all(procs.map(async ({ key, proc }) => {
+    if (await waitForChildProcessExit(proc, 3000))
+      return;
+    logger.warn({ instanceKey: key, pid: proc.pid }, "Playwright MCP ignored SIGTERM");
+    try {
+      proc.kill("SIGKILL");
+    } catch (err) {
+      logger.warn({ err, instanceKey: key, pid: proc.pid }, "Failed to SIGKILL Playwright MCP");
+    }
+    if (!await waitForChildProcessExit(proc, 1000)) {
+      logger.warn({ instanceKey: key, pid: proc.pid }, "Playwright MCP did not report exit");
+    }
+  }));
+}
+setInterval(() => {
+  while (evictIdleInstance() !== null) {}
+  try {
+    reapPlaywrightOrphans();
+  } catch (e) {
+    logger.debug({ err: e }, "reapOrphanBrowsers sweep failed");
+  }
+}, 30 * 60 * 1000).unref();
+export {
+  withPlaywrightProfileMaintenance,
+  withPlaywrightInstanceMaintenance,
+  waitForChildProcessSpawnError,
+  waitForChildProcessExit,
+  unpinPlaywrightInstance,
+  stopPlaywrightProfile,
+  stopPlaywrightInstance,
+  selectReusablePort,
+  selectOrphanBrowserPids,
+  selectIdleEvictionKey,
+  resolveTopicProfileDir,
+  resolvePlaywrightTopicBinding,
+  resolvePlaywrightProfileBinding,
+  resolvePlaywrightCapabilityOwner,
+  resetPlaywrightManagerHost,
+  reapPlaywrightOrphans,
+  probePlaywrightMcpTransports,
+  probeMcpTransport,
+  pinPlaywrightInstance,
+  onPlaywrightFailure,
+  makeInstanceKey,
+  makeBrowserProfileInstanceKey,
+  killAllPlaywright,
+  isBrowserJanitorOwner,
+  getPlaywrightManagerHost,
+  getPlaywrightCapability,
+  extractUserDataDirArg,
+  ensurePlaywright,
+  ensureBrowserProfile,
+  configurePlaywrightManagerHost,
+  closeBrowserOwnerTabs,
+  browserProcessMatchesExpectedProfile
+};
+
+//# debugId=712A86561C9BF9CC64756E2164756E21