negotium 0.1.7 → 0.1.8

package/dist/runtime/scripts/mcp-patchright-http.mjs

@@ -0,0 +1,349 @@
+#!/usr/bin/env node
+import { createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import {
+  CallToolRequestSchema,
+  isInitializeRequest,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+function parseCli(argv = process.argv.slice(2)) {
+  const options = { host: "127.0.0.1" };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    const [flag, inlineValue] = arg.includes("=") ? arg.split(/=(.*)/s, 2) : [arg, undefined];
+    const nextValue = () => inlineValue ?? argv[++index];
+    switch (flag) {
+      case "--host":
+        options.host = nextValue();
+        break;
+      case "--port": {
+        const value = Number(nextValue());
+        if (!Number.isInteger(value) || value <= 0) throw new Error(`Invalid --port: ${value}`);
+        options.port = value;
+        break;
+      }
+      case "--user-data-dir":
+        options.userDataDir = nextValue();
+        break;
+      case "--headless":
+        options.headless = true;
+        break;
+      case "--headed":
+        options.headless = false;
+        break;
+      default:
+        throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+  if (!options.port) throw new Error("--port is required");
+  return options;
+}
+
+const require = createRequire(import.meta.url);
+const packageRoot = dirname(require.resolve("mcp-patchright/package.json"));
+const [{ BrowserManager }, { handleTool }, { tools }] = await Promise.all([
+  import(pathToFileURL(resolve(packageRoot, "dist/browser/manager.js")).href),
+  import(pathToFileURL(resolve(packageRoot, "dist/tools/handlers.js")).href),
+  import(pathToFileURL(resolve(packageRoot, "dist/tools/registry.js")).href),
+]);
+
+function createMcpServer(defaultStartOptions, sharedManager, owner) {
+  const server = new Server(
+    { name: "mcp-patchright", version: "0.1.0" },
+    { capabilities: { tools: {} } },
+  );
+  const manager = sharedManager ?? new BrowserManager(defaultStartOptions);
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+      return await manager.runAsOwner(owner, () =>
+        handleTool(manager, request.params.name, request.params.arguments ?? {}),
+      );
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: error instanceof Error ? `${error.name}: ${error.message}` : String(error),
+          },
+        ],
+        isError: true,
+      };
+    }
+  });
+  return server;
+}
+
+function requestOwner(req) {
+  const owner = req.header("x-browser-owner");
+  if (!owner || owner.length > 256) return undefined;
+  return owner;
+}
+
+function sseRequestOwner(req) {
+  const owner = requestOwner(req) ?? (typeof req.query.owner === "string" ? req.query.owner : "");
+  if (!owner || owner.length > 256) return undefined;
+  return owner;
+}
+
+const expectedCapability = process.env.NEGOTIUM_BROWSER_CAPABILITY;
+if (!expectedCapability) throw new Error("NEGOTIUM_BROWSER_CAPABILITY is required");
+
+function safeCapabilityEqual(provided, expectedValue) {
+  if (!provided) return false;
+  const actual = Buffer.from(provided);
+  const expected = Buffer.from(expectedValue);
+  return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
+
+function hasCapability(req) {
+  const provided = req.header("x-browser-capability");
+  return safeCapabilityEqual(provided, expectedCapability);
+}
+
+function hasOwnerCapability(req, owner) {
+  const expected = createHmac("sha256", expectedCapability).update(owner).digest("hex");
+  return safeCapabilityEqual(req.header("x-browser-capability"), expected);
+}
+
+function requireCapability(req, res) {
+  if (hasCapability(req)) return true;
+  res.status(401).json({ ok: false, error: "invalid browser capability" });
+  return false;
+}
+
+function requireOwnerCapability(req, res, owner) {
+  const queryCapability =
+    req.path === "/sse" && typeof req.query.capability === "string"
+      ? req.query.capability
+      : undefined;
+  const expected = createHmac("sha256", expectedCapability).update(owner).digest("hex");
+  if (hasOwnerCapability(req, owner) || safeCapabilityEqual(queryCapability, expected)) return true;
+  res.status(401).json({ ok: false, error: "invalid browser owner capability" });
+  return false;
+}
+
+// Egress proxy is passed via env (not argv) so credentials stay out of `ps`.
+// The parent backend sets NEGOTIUM_BROWSER_PROXY_* from resolveBrowserProxy().
+function proxyFromEnv() {
+  const server = process.env.NEGOTIUM_BROWSER_PROXY_SERVER;
+  if (!server) return undefined;
+  const proxy = { server };
+  if (process.env.NEGOTIUM_BROWSER_PROXY_USERNAME)
+    proxy.username = process.env.NEGOTIUM_BROWSER_PROXY_USERNAME;
+  if (process.env.NEGOTIUM_BROWSER_PROXY_PASSWORD)
+    proxy.password = process.env.NEGOTIUM_BROWSER_PROXY_PASSWORD;
+  if (process.env.NEGOTIUM_BROWSER_PROXY_BYPASS)
+    proxy.bypass = process.env.NEGOTIUM_BROWSER_PROXY_BYPASS;
+  return proxy;
+}
+
+const options = parseCli();
+const proxy = proxyFromEnv();
+const defaultStartOptions = {
+  ...(options.userDataDir ? { userDataDir: options.userDataDir } : {}),
+  ...(options.headless !== undefined ? { headless: options.headless } : {}),
+  ...(proxy ? { proxy } : {}),
+};
+const sharedManager = new BrowserManager(defaultStartOptions);
+const app = createMcpExpressApp({ host: options.host });
+
+const transports = {};
+const servers = {};
+const sessionOwners = {};
+const sseTransports = {};
+const sseServers = {};
+const sseMessageTokens = {};
+let httpServer;
+
+app.get("/health", (_req, res) => {
+  res.json({
+    ok: true,
+    name: "mcp-patchright",
+  });
+});
+
+// Claude Code and Maestro use the legacy two-endpoint SSE transport. The
+// initial connection is authenticated with the owner capability. A fresh,
+// per-session token embedded in the advertised message endpoint prevents
+// another loopback process from injecting JSON-RPC messages by session ID.
+app.get("/sse", async (req, res) => {
+  const owner = sseRequestOwner(req);
+  if (!owner) {
+    res.status(400).json({ ok: false, error: "browser owner is required in SSE mode" });
+    return;
+  }
+  if (!requireOwnerCapability(req, res, owner)) return;
+
+  const messageToken = randomBytes(32).toString("hex");
+  const transport = new SSEServerTransport(
+    `/message?token=${encodeURIComponent(messageToken)}`,
+    res,
+  );
+  const server = createMcpServer(defaultStartOptions, sharedManager, owner);
+  sseTransports[transport.sessionId] = transport;
+  sseServers[transport.sessionId] = server;
+  sseMessageTokens[transport.sessionId] = messageToken;
+  transport.onclose = () => {
+    const sessionId = transport.sessionId;
+    delete sseTransports[sessionId];
+    delete sseMessageTokens[sessionId];
+    const managedServer = sseServers[sessionId];
+    delete sseServers[sessionId];
+    void managedServer?.close().catch(() => undefined);
+  };
+  await server.connect(transport);
+});
+
+app.post("/message", async (req, res) => {
+  const sessionId = typeof req.query.sessionId === "string" ? req.query.sessionId : "";
+  const messageToken = typeof req.query.token === "string" ? req.query.token : "";
+  const transport = sseTransports[sessionId];
+  const expectedMessageToken = sseMessageTokens[sessionId];
+  if (!transport) {
+    res.status(404).send("SSE session not found");
+    return;
+  }
+  if (!expectedMessageToken || !safeCapabilityEqual(messageToken, expectedMessageToken)) {
+    res.status(401).send("invalid SSE message token");
+    return;
+  }
+  await transport.handlePostMessage(req, res, req.body);
+});
+
+app.all("/mcp", async (req, res) => {
+  try {
+    const owner = requestOwner(req);
+    if (!owner) {
+      res.status(400).json({
+        jsonrpc: "2.0",
+        error: { code: -32600, message: "browser owner is required in HTTP mode" },
+        id: null,
+      });
+      return;
+    }
+    if (!requireOwnerCapability(req, res, owner)) return;
+    const sessionId = req.headers["mcp-session-id"];
+    const normalizedSessionId = Array.isArray(sessionId)
+      ? sessionId[0]
+      : typeof sessionId === "string"
+        ? sessionId
+        : undefined;
+    let transport;
+    if (normalizedSessionId && transports[normalizedSessionId]) {
+      const existingTransport = transports[normalizedSessionId];
+      if (!(existingTransport instanceof StreamableHTTPServerTransport)) {
+        res.status(400).json({
+          jsonrpc: "2.0",
+          error: { code: -32000, message: "Session uses a different transport protocol" },
+          id: null,
+        });
+        return;
+      }
+      if (sessionOwners[normalizedSessionId] !== owner) {
+        res.status(403).json({
+          jsonrpc: "2.0",
+          error: { code: -32001, message: "Browser owner does not match this session" },
+          id: null,
+        });
+        return;
+      }
+      transport = existingTransport;
+    } else if (!normalizedSessionId && req.method === "POST" && isInitializeRequest(req.body)) {
+      let server;
+      transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID(),
+        onsessioninitialized: (newSessionId) => {
+          if (!transport || !server) return;
+          transports[newSessionId] = transport;
+          servers[newSessionId] = server;
+          sessionOwners[newSessionId] = owner;
+        },
+      });
+      server = createMcpServer(defaultStartOptions, sharedManager, owner);
+      transport.onclose = () => {
+        const sid = transport?.sessionId;
+        if (sid) {
+          delete transports[sid];
+          delete sessionOwners[sid];
+          const managedServer = servers[sid];
+          delete servers[sid];
+          void managedServer?.close().catch(() => undefined);
+        }
+      };
+      await server.connect(transport);
+    } else {
+      res.status(400).json({
+        jsonrpc: "2.0",
+        error: { code: -32000, message: "Bad Request: No valid session ID provided" },
+        id: null,
+      });
+      return;
+    }
+    await transport.handleRequest(req, res, req.body);
+  } catch (error) {
+    console.error("Error handling /mcp request:", error);
+    if (!res.headersSent) {
+      res.status(500).json({
+        jsonrpc: "2.0",
+        error: { code: -32603, message: "Internal server error" },
+        id: null,
+      });
+    }
+  }
+});
+
+app.delete("/owners", async (req, res) => {
+  if (!requireCapability(req, res)) return;
+  const owner = requestOwner(req);
+  if (!owner) {
+    res.status(400).json({ ok: false, error: "owner is required" });
+    return;
+  }
+  const closed = await sharedManager.closeOwnerPages(owner);
+  res.json({ ok: true, owner, closed });
+});
+
+async function shutdown() {
+  for (const [sessionId, transport] of Object.entries(sseTransports)) {
+    await transport.close().catch(() => undefined);
+    delete sseTransports[sessionId];
+    delete sseMessageTokens[sessionId];
+  }
+  for (const [sessionId, server] of Object.entries(sseServers)) {
+    await server.close().catch(() => undefined);
+    delete sseServers[sessionId];
+  }
+  for (const [sessionId, transport] of Object.entries(transports)) {
+    await transport.close().catch(() => undefined);
+    delete transports[sessionId];
+    delete sessionOwners[sessionId];
+  }
+  for (const [sessionId, server] of Object.entries(servers)) {
+    await server.close().catch(() => undefined);
+    delete servers[sessionId];
+  }
+  await sharedManager.close().catch(() => undefined);
+  await new Promise((resolveClose) => httpServer?.close(() => resolveClose()));
+  process.exit(0);
+}
+
+httpServer = app.listen(options.port, options.host, () => {
+  console.error(`mcp-patchright listening on http://${options.host}:${options.port}`);
+  console.error(`  SSE:        http://${options.host}:${options.port}/sse`);
+  console.error(`  Streamable: http://${options.host}:${options.port}/mcp`);
+});
+httpServer.on("error", (error) => {
+  console.error("mcp-patchright HTTP server error:", error);
+  process.exit(1);
+});
+
+process.on("SIGINT", () => void shutdown());
+process.on("SIGTERM", () => void shutdown());

package/dist/runtime/src/agents/api-topic-agent-switch.ts

@@ -0,0 +1,178 @@
+import { unlinkSync } from "node:fs";
+import { checkAgentAuth } from "#agents/auth-check";
+import { resolveModelForAgent } from "#agents/model-catalog";
+import { getRegistry } from "#agents/registry";
+import { logger } from "#platform/logger";
+import { setApiTopicConfig, type TopicConfig } from "#storage/api-topic-config";
+import { clearTopicSessionId, setApiTopicAgent, setTopicSessionId } from "#storage/api-topics";
+import {
+  appendConversationEventStrict,
+  findLastSessionIdForAgent,
+  readConversation,
+} from "#storage/conversations";
+import type { AgentKind, EffortLevel } from "#types";
+
+export type ApiTopicSwitchOutcome =
+  | { kind: "fresh"; agent: AgentKind; reason: "no-history" | "bridge-failed" }
+  | { kind: "bridged"; agent: AgentKind; bridgedSessionId: string; rolloutPath: string };
+
+export type ApiTopicSwitchResult =
+  | { ok: true; outcome: ApiTopicSwitchOutcome }
+  | { ok: false; error: string };
+
+export interface SwitchApiTopicAgentOptions {
+  topicId: string;
+  topicTitle: string;
+  userId: string;
+  fromAgent?: AgentKind;
+  agent: AgentKind;
+  cwd: string;
+  config: TopicConfig;
+  /** Topic base values used when config has no explicit override. */
+  defaultModel?: string;
+  defaultEffort?: EffortLevel;
+  reason: string;
+}
+
+function commitApiTopicSwitch(
+  opts: SwitchApiTopicAgentOptions,
+  bridgedSessionId: string | null,
+): void {
+  const registry = getRegistry(opts.agent);
+  const model = resolveModelForAgent(opts.agent, opts.defaultModel, registry);
+  const effort =
+    opts.defaultEffort && registry.validateEffort(opts.defaultEffort)
+      ? opts.defaultEffort
+      : registry.defaultEffort;
+  // Keep the durable topic DTO internally consistent too. The turn runner's
+  // model-owner guard remains the final safety net for legacy rows, but a
+  // Codex topic should never continue advertising Maestro's deepseek-pro.
+  setApiTopicAgent(opts.topicId, opts.agent, { model, effort });
+  setApiTopicConfig(opts.topicId, opts.config);
+  if (bridgedSessionId) {
+    setTopicSessionId(opts.topicId, bridgedSessionId, {
+      reason: opts.reason,
+      agent: opts.agent,
+    });
+  } else {
+    clearTopicSessionId(opts.topicId, opts.reason);
+  }
+}
+
+/**
+ * API-topic equivalent of `switchTopicAgent`: all web/MCP agent changes must
+ * pass through this path so the synthetic SDK rollout, unified-log manifest,
+ * and durable topic session stay in sync.
+ */
+export function switchApiTopicAgent(opts: SwitchApiTopicAgentOptions): ApiTopicSwitchResult {
+  const auth = checkAgentAuth(opts.agent);
+  if (!auth.ok) return { ok: false, error: auth.error };
+
+  const entries = readConversation(opts.userId, opts.topicTitle);
+  if (entries.length === 0) {
+    try {
+      commitApiTopicSwitch(opts, null);
+    } catch (err) {
+      logger.warn({ err, topicId: opts.topicId, agent: opts.agent }, "api-topic switch failed");
+      return { ok: false, error: `failed to set agent for "${opts.topicTitle}"` };
+    }
+    return { ok: true, outcome: { kind: "fresh", agent: opts.agent, reason: "no-history" } };
+  }
+
+  let bridgedSessionId: string;
+  let rolloutPath: string;
+  try {
+    const reuseSessionId = findLastSessionIdForAgent(entries, opts.agent) ?? undefined;
+    const registry = getRegistry(opts.agent);
+    const model = resolveModelForAgent(
+      opts.agent,
+      opts.config.model ?? opts.defaultModel,
+      registry,
+    );
+    const requestedEffort = opts.config.effort ?? opts.defaultEffort;
+    const effort =
+      requestedEffort && registry.validateEffort(requestedEffort)
+        ? requestedEffort
+        : registry.defaultEffort;
+    const result = registry.writeRollout({
+      cwd: opts.cwd,
+      entries,
+      model,
+      ...(effort ? { effort } : {}),
+      ...(reuseSessionId ? { reuseSessionId } : {}),
+    });
+    bridgedSessionId = result.sessionId;
+    rolloutPath = result.rolloutPath;
+  } catch (err) {
+    logger.warn(
+      {
+        err,
+        topicId: opts.topicId,
+        topicTitle: opts.topicTitle,
+        from: opts.fromAgent,
+        to: opts.agent,
+      },
+      "api-topic switch: rollout encoding failed — falling back to fresh session",
+    );
+    try {
+      commitApiTopicSwitch(opts, null);
+    } catch (commitErr) {
+      logger.warn(
+        { err: commitErr, topicId: opts.topicId, agent: opts.agent },
+        "api-topic switch fallback commit failed",
+      );
+      return { ok: false, error: `failed to set agent for "${opts.topicTitle}"` };
+    }
+    return { ok: true, outcome: { kind: "fresh", agent: opts.agent, reason: "bridge-failed" } };
+  }
+
+  try {
+    appendConversationEventStrict(opts.userId, opts.topicTitle, opts.agent, {
+      type: "session",
+      sessionId: bridgedSessionId,
+    });
+  } catch (err) {
+    try {
+      unlinkSync(rolloutPath);
+    } catch {
+      // best-effort
+    }
+    logger.warn(
+      { err, topicId: opts.topicId, rolloutPath },
+      "api-topic switch: manifest append failed, removed orphan rollout",
+    );
+    return { ok: false, error: `failed to record agent switch for "${opts.topicTitle}"` };
+  }
+
+  try {
+    commitApiTopicSwitch(opts, bridgedSessionId);
+  } catch (err) {
+    try {
+      unlinkSync(rolloutPath);
+    } catch {
+      // best-effort
+    }
+    logger.warn(
+      { err, topicId: opts.topicId, rolloutPath },
+      "api-topic switch: config/session commit failed, removed orphan rollout",
+    );
+    return { ok: false, error: `failed to commit agent switch for "${opts.topicTitle}"` };
+  }
+
+  logger.info(
+    {
+      topicId: opts.topicId,
+      from: opts.fromAgent,
+      to: opts.agent,
+      sessionId: bridgedSessionId,
+      rolloutPath,
+      entries: entries.length,
+    },
+    "api-topic switch: rollout bridged from unified log",
+  );
+
+  return {
+    ok: true,
+    outcome: { kind: "bridged", agent: opts.agent, bridgedSessionId, rolloutPath },
+  };
+}