@btraut/browser-bridge 0.4.0 → 0.4.3

package/dist/index.js

@@ -553,10 +553,30 @@ var ArtifactsScreenshotInputSchema = import_zod2.z.object({
   session_id: import_zod2.z.string().min(1),
   target: import_zod2.z.enum(["viewport", "full"]).default("viewport"),
   fullPage: import_zod2.z.boolean().default(false),
+  selector: import_zod2.z.string().min(1).optional(),
   format: import_zod2.z.enum(["png", "jpeg", "webp"]).default("png"),
   quality: import_zod2.z.number().min(0).max(100).optional()
 });
 var ArtifactsScreenshotOutputSchema = ArtifactInfoSchema;
+var HealthCheckInputSchema = import_zod2.z.object({});
+var HealthCheckOutputSchema = import_zod2.z.object({
+  started_at: import_zod2.z.string().min(1),
+  uptime_ms: import_zod2.z.number().finite().nonnegative(),
+  memory: import_zod2.z.object({
+    rss: import_zod2.z.number().finite().nonnegative(),
+    heapTotal: import_zod2.z.number().finite().nonnegative(),
+    heapUsed: import_zod2.z.number().finite().nonnegative(),
+    external: import_zod2.z.number().finite().nonnegative(),
+    arrayBuffers: import_zod2.z.number().finite().nonnegative().optional()
+  }).passthrough(),
+  sessions: import_zod2.z.object({
+    active: import_zod2.z.number().finite().nonnegative()
+  }).passthrough(),
+  extension: import_zod2.z.object({
+    connected: import_zod2.z.boolean(),
+    last_seen_at: import_zod2.z.string().min(1).optional()
+  }).passthrough()
+}).passthrough();
 var DiagnosticsDoctorInputSchema = import_zod2.z.object({
   session_id: import_zod2.z.string().min(1).optional()
 });
@@ -844,12 +864,16 @@ var parseNumber = (value) => {
 };
 var registerArtifactsCommands = (program2) => {
   const artifacts = program2.command("artifacts").description("Artifact commands");
-  artifacts.command("screenshot").description("Request a screenshot artifact").requiredOption("--session-id <id>", "Session identifier").option("--target <target>", "Screenshot target (viewport, full)").option("--full-page", "Capture full page (alias for --target full)").option("--format <format>", "Screenshot format (png, jpeg, webp)").option("--quality <quality>", "Screenshot quality (0-100) for jpeg/webp").action(async (options, command) => {
+  artifacts.command("screenshot").description("Request a screenshot artifact").requiredOption("--session-id <id>", "Session identifier").option("--target <target>", "Screenshot target (viewport, full)").option("--full-page", "Capture full page (alias for --target full)").option(
+    "--selector <selector>",
+    "Capture a specific element by CSS selector"
+  ).option("--format <format>", "Screenshot format (png, jpeg, webp)").option("--quality <quality>", "Screenshot quality (0-100) for jpeg/webp").action(async (options, command) => {
     await runCommand(command, (client) => {
       const payload = parseInput(ArtifactsScreenshotInputSchema, {
         session_id: options.sessionId,
         target: options.target,
         fullPage: Boolean(options.fullPage),
+        selector: options.selector,
         format: options.format,
         quality: parseNumber(options.quality)
       });
@@ -900,6 +924,12 @@ var registerDiagnosticsCommands = (program2) => {
       return client.post("/diagnostics/doctor", payload);
     });
   });
+  diagnostics.command("health-check").description("Run a lightweight health check").action(async (_options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(HealthCheckInputSchema, {});
+      return client.post("/health_check", payload);
+    });
+  });
 };
 
 // packages/cli/src/locator.ts
@@ -1780,6 +1810,16 @@ var TOOL_DEFINITIONS = [
       corePath: "/artifacts/screenshot"
     }
   },
+  {
+    name: "health_check",
+    config: {
+      title: "Health Check",
+      description: "Check server health including uptime, memory usage, active session count, and extension connection status.",
+      inputSchema: HealthCheckInputSchema,
+      outputSchema: envelope(HealthCheckOutputSchema),
+      corePath: "/health_check"
+    }
+  },
   {
     name: "diagnostics.doctor",
     config: {
@@ -1822,10 +1862,16 @@ var registerBrowserBridgeTools = (server, client) => {
 };
 
 // packages/mcp-adapter/src/server.ts
+var import_node_http = require("node:http");
+var import_node_crypto = require("node:crypto");
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+var import_types = require("@modelcontextprotocol/sdk/types.js");
 var DEFAULT_SERVER_NAME = "browser-bridge";
 var DEFAULT_SERVER_VERSION = "0.0.0";
+var DEFAULT_HTTP_HOST = "127.0.0.1";
+var DEFAULT_HTTP_PATH = "/mcp";
 var createMcpServer = (options = {}) => {
   const server = new import_mcp.McpServer({
     name: options.name ?? DEFAULT_SERVER_NAME,
@@ -1841,6 +1887,151 @@ var startMcpServer = async (options = {}) => {
   await handle.server.connect(transport);
   return { ...handle, transport };
 };
+var readJsonBody = async (req, maxBytes = 5 * 1024 * 1024) => {
+  const chunks = [];
+  let total = 0;
+  await new Promise((resolve2, reject) => {
+    req.on("data", (chunk) => {
+      total += chunk.length;
+      if (total > maxBytes) {
+        reject(new Error("Request body too large."));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve2());
+    req.on("error", (err) => reject(err));
+  });
+  const raw = Buffer.concat(chunks).toString("utf8");
+  if (!raw) {
+    return void 0;
+  }
+  return JSON.parse(raw);
+};
+var getHeaderValue = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return void 0;
+};
+var startMcpHttpServer = async (options = {}) => {
+  const host = options.host ?? DEFAULT_HTTP_HOST;
+  const port = typeof options.port === "number" ? options.port : 0;
+  const path9 = options.path ?? DEFAULT_HTTP_PATH;
+  const client = options.coreClient ?? createCoreClient2(options);
+  const sessions = /* @__PURE__ */ new Map();
+  const closeAllSessions = async () => {
+    const entries = Array.from(sessions.values());
+    sessions.clear();
+    await Promise.all(
+      entries.map(async (entry) => {
+        try {
+          await entry.transport.close();
+        } catch {
+        }
+        try {
+          await entry.server.close();
+        } catch {
+        }
+      })
+    );
+  };
+  const httpServer = (0, import_node_http.createServer)(async (req, res) => {
+    try {
+      const url = new URL(req.url ?? "", `http://${host}`);
+      if (url.pathname !== path9) {
+        res.writeHead(404, { "content-type": "application/json" });
+        res.end(JSON.stringify({ error: "Not Found" }));
+        return;
+      }
+      const sessionId = getHeaderValue(req.headers["mcp-session-id"]);
+      const parsedBody = req.method === "POST" ? await readJsonBody(req) : void 0;
+      if (sessionId) {
+        const entry = sessions.get(sessionId);
+        if (!entry) {
+          res.writeHead(404, { "content-type": "application/json" });
+          res.end(JSON.stringify({ error: "Unknown session." }));
+          return;
+        }
+        await entry.transport.handleRequest(req, res, parsedBody);
+        return;
+      }
+      if (req.method !== "POST" || !(0, import_types.isInitializeRequest)(parsedBody)) {
+        res.writeHead(400, { "content-type": "application/json" });
+        res.end(
+          JSON.stringify({
+            error: "Missing mcp-session-id header. First request must be initialize."
+          })
+        );
+        return;
+      }
+      let sessionEntry;
+      const transport = new import_streamableHttp.StreamableHTTPServerTransport({
+        sessionIdGenerator: () => (0, import_node_crypto.randomUUID)(),
+        onsessioninitialized: (sid) => {
+          if (sessionEntry) {
+            sessions.set(sid, sessionEntry);
+          }
+        },
+        onsessionclosed: async (sid) => {
+          const entry = sessions.get(sid);
+          sessions.delete(sid);
+          if (!entry) {
+            return;
+          }
+          await Promise.allSettled([
+            entry.transport.close(),
+            entry.server.close()
+          ]);
+        }
+      });
+      const sessionServer = new import_mcp.McpServer({
+        name: options.name ?? DEFAULT_SERVER_NAME,
+        version: options.version ?? DEFAULT_SERVER_VERSION
+      });
+      registerBrowserBridgeTools(sessionServer, client);
+      await sessionServer.connect(transport);
+      sessionEntry = { transport, server: sessionServer };
+      await transport.handleRequest(req, res, parsedBody);
+    } catch (error) {
+      res.writeHead(500, { "content-type": "application/json" });
+      res.end(
+        JSON.stringify({
+          error: error instanceof Error ? error.message : "Internal error."
+        })
+      );
+    }
+  });
+  const resolvedPort = await new Promise((resolve2, reject) => {
+    httpServer.listen(port, host, () => {
+      const address = httpServer.address();
+      resolve2(typeof address === "object" && address ? address.port : port);
+    });
+    httpServer.on("error", reject);
+  });
+  return {
+    client,
+    host,
+    port: resolvedPort,
+    path: path9,
+    close: async () => {
+      await new Promise((resolve2, reject) => {
+        httpServer.close((err) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve2();
+          }
+        });
+      });
+      await closeAllSessions();
+    }
+  };
+};
 
 // packages/cli/src/tui.ts
 var requireTty = () => {
@@ -2071,6 +2262,31 @@ var registerMcpCommand = (program2) => {
   });
   mcp.option("--name <name>", "MCP server name").option("--version <version>", "MCP server version").action(startServer);
   mcp.command("serve").description("Run the MCP server over stdio").option("--name <name>", "MCP server name").option("--version <version>", "MCP server version").action(startServer);
+  mcp.command("serve-http").description("Run the MCP server over Streamable HTTP").option("--name <name>", "MCP server name").option("--version <version>", "MCP server version").option("--host <host>", "HTTP host (default 127.0.0.1)").option("--port <port>", "HTTP port (default random available port)").option("--path <path>", "HTTP path (default /mcp)").action(async (options, command) => {
+    const globals = getGlobalOptions(command);
+    const coreClient = createCoreClient({
+      host: globals.host,
+      port: globals.port,
+      ensureDaemon: globals.daemon !== false
+    });
+    const parsedPort = typeof options.port === "string" && options.port.length > 0 ? Number(options.port) : void 0;
+    try {
+      const handle = await startMcpHttpServer({
+        name: options.name,
+        version: options.version,
+        host: options.host,
+        port: typeof parsedPort === "number" && Number.isFinite(parsedPort) ? parsedPort : void 0,
+        path: options.path,
+        coreClient
+      });
+      console.error(
+        `MCP HTTP server listening on http://${handle.host}:${handle.port}${handle.path}`
+      );
+    } catch (error) {
+      console.error(error);
+      process.exitCode = 1;
+    }
+  });
 };
 
 // packages/core/src/server.ts
@@ -2217,6 +2433,11 @@ var PAGE_STATE_SCRIPT = [
   "})()"
 ].join("\n");
 
+// packages/core/src/routes/diagnostics.ts
+var PROCESS_STARTED_AT = new Date(
+  Date.now() - Math.floor(process.uptime() * 1e3)
+).toISOString();
+
 // packages/cli/src/open-path.ts
 var import_node_child_process3 = require("node:child_process");
 var openPath = async (target) => {