@flrande/browserctl 0.5.0 → 0.6.0

package/apps/browserctl/src/smoke.e2e.test.ts

@@ -1,97 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-
-import { stopDaemon } from "./daemon-client";
-import { EXIT_CODES, runCli } from "./main";
-import { reserveLoopbackPort } from "./test-port";
-
-let testDaemonPort = 0;
-let activeRelayPort = 0;
-
-function createIoCapture() {
-  const state = {
-    stdout: "",
-    stderr: ""
-  };
-
-  return {
-    state,
-    io: {
-      stdout: {
-        write(content: string) {
-          state.stdout += content;
-        }
-      },
-      stderr: {
-        write(content: string) {
-          state.stderr += content;
-        }
-      }
-    }
-  };
-}
-
-function parseJsonLine(state: { stdout: string }): Record<string, unknown> {
-  return JSON.parse(state.stdout.trim()) as Record<string, unknown>;
-}
-
-beforeEach(async () => {
-  testDaemonPort = await reserveLoopbackPort();
-  activeRelayPort = await reserveLoopbackPort();
-  while (activeRelayPort === testDaemonPort) {
-    activeRelayPort = await reserveLoopbackPort();
-  }
-
-  process.env.BROWSERCTL_DAEMON_PORT = String(testDaemonPort);
-  process.env.BROWSERD_CHROME_RELAY_URL = `http://127.0.0.1:${activeRelayPort}`;
-  delete process.env.BROWSERD_MANAGED_LOCAL_ENABLED;
-  delete process.env.BROWSERD_DEFAULT_DRIVER;
-  delete process.env.BROWSERD_CHROME_RELAY_MODE;
-  delete process.env.BROWSERD_CHROME_RELAY_EXTENSION_TOKEN;
-  await stopDaemon(testDaemonPort);
-});
-
-afterEach(async () => {
-  await stopDaemon(testDaemonPort);
-  delete process.env.BROWSERCTL_DAEMON_PORT;
-  delete process.env.BROWSERD_CHROME_RELAY_URL;
-  delete process.env.BROWSERD_MANAGED_LOCAL_ENABLED;
-  delete process.env.BROWSERD_DEFAULT_DRIVER;
-  delete process.env.BROWSERD_CHROME_RELAY_MODE;
-  delete process.env.BROWSERD_CHROME_RELAY_EXTENSION_TOKEN;
-});
-
-describe("browserctl smoke e2e", () => {
-  it("starts with extension-first defaults and reports chrome-relay status", async () => {
-    const startCapture = createIoCapture();
-    const startExitCode = await runCli(["daemon-start", "--json"], startCapture.io);
-
-    expect(startExitCode).toBe(EXIT_CODES.OK);
-    const startPayload = parseJsonLine(startCapture.state);
-    expect(startPayload.ok).toBe(true);
-
-    const statusCapture = createIoCapture();
-    const statusExitCode = await runCli(["status", "--json"], statusCapture.io);
-
-    expect(statusExitCode).toBe(EXIT_CODES.OK);
-    const statusPayload = parseJsonLine(statusCapture.state);
-    expect(statusPayload.ok).toBe(true);
-    const statusData = statusPayload.data as Record<string, unknown>;
-    expect(statusData.driver).toBe("chrome-relay");
-    expect(statusData.status).toMatchObject({
-      kind: "chrome-relay",
-      connected: false
-    });
-    const relayStatus = statusData.status as Record<string, unknown>;
-    expect(String(relayStatus.relayUrl ?? "")).toContain(`:${activeRelayPort}`);
-
-    const stopCapture = createIoCapture();
-    const stopExitCode = await runCli(["daemon-stop", "--json"], stopCapture.io);
-    expect(stopExitCode).toBe(EXIT_CODES.OK);
-    const stopPayload = parseJsonLine(stopCapture.state);
-    expect(stopPayload.ok).toBe(true);
-    expect(stopPayload.data).toMatchObject({
-      stopped: true,
-      port: testDaemonPort
-    });
-  }, 20_000);
-});

package/apps/browserctl/src/test-port.ts

@@ -1,26 +0,0 @@
-import { createServer } from "node:net";
-
-export async function reserveLoopbackPort(): Promise<number> {
-  return await new Promise<number>((resolve, reject) => {
-    const server = createServer();
-
-    server.once("error", reject);
-    server.listen(0, "127.0.0.1", () => {
-      const address = server.address();
-      if (typeof address !== "object" || address === null) {
-        server.close(() => reject(new Error("Failed to reserve loopback port.")));
-        return;
-      }
-
-      const port = address.port;
-      server.close((error) => {
-        if (error !== undefined) {
-          reject(error);
-          return;
-        }
-
-        resolve(port);
-      });
-    });
-  });
-}

package/apps/browserd/src/bootstrap.ts

@@ -1,432 +0,0 @@
-import { createContainer, loadBrowserdConfig, type BrowserdContainer } from "./container";
-import { createMcpSdkServer } from "../../../packages/transport-mcp-stdio/src";
-import { createServer, Socket } from "node:net";
-import { Readable, Writable } from "node:stream";
-
-const UNKNOWN_TRACE_ID = "trace:unknown";
-const UNKNOWN_SESSION_ID = "session:unknown";
-const INVALID_REQUEST_CODE = "E_INVALID_ARG";
-const DEFAULT_TCP_HOST = "127.0.0.1";
-const DEFAULT_TCP_PORT = 41337;
-const DEFAULT_SERVER_VERSION = "0.1.0";
-
-type StdioToolRequest = {
-  name: string;
-  arguments?: unknown;
-  traceId?: string;
-  id?: unknown;
-};
-
-type StdioTransport = {
-  input: Readable;
-  output: Writable;
-};
-
-type StdioProtocol = "mcp" | "legacy";
-
-type TcpTransport = {
-  host: string;
-  port: number;
-};
-
-type ErrorEnvelope = {
-  id?: unknown;
-  ok: false;
-  traceId: string;
-  sessionId: string;
-  error: {
-    code: string;
-    message: string;
-  };
-};
-
-type RequestMetadata = {
-  id?: unknown;
-  traceId?: string;
-  sessionId?: string;
-};
-
-class ProcessLineError extends Error {
-  readonly metadata: RequestMetadata;
-
-  constructor(message: string, metadata: RequestMetadata) {
-    super(message);
-    this.metadata = metadata;
-  }
-}
-
-function resolveNonEmptyString(value: unknown): string | undefined {
-  if (typeof value !== "string") {
-    return undefined;
-  }
-
-  const trimmedValue = value.trim();
-  return trimmedValue.length === 0 ? undefined : trimmedValue;
-}
-
-function extractRequestMetadata(value: unknown): RequestMetadata {
-  if (!isObjectRecord(value)) {
-    return {};
-  }
-
-  const metadata: RequestMetadata = {};
-  if (Object.prototype.hasOwnProperty.call(value, "id")) {
-    metadata.id = value.id;
-  }
-
-  const traceId = resolveNonEmptyString(value.traceId);
-  if (traceId !== undefined) {
-    metadata.traceId = traceId;
-  }
-
-  const args = value.arguments;
-  if (isObjectRecord(args)) {
-    const sessionId = resolveNonEmptyString(args.sessionId);
-    if (sessionId !== undefined) {
-      metadata.sessionId = sessionId;
-    }
-  }
-
-  return metadata;
-}
-
-function toErrorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : "Unexpected request handling failure.";
-}
-
-function createInvalidRequestEnvelope(
-  message: string,
-  metadata: RequestMetadata = {}
-): ErrorEnvelope {
-  const envelope: ErrorEnvelope = {
-    ok: false,
-    traceId: metadata.traceId ?? UNKNOWN_TRACE_ID,
-    sessionId: metadata.sessionId ?? UNKNOWN_SESSION_ID,
-    error: {
-      code: INVALID_REQUEST_CODE,
-      message
-    }
-  };
-
-  if (metadata.id !== undefined) {
-    envelope.id = metadata.id;
-  }
-
-  return envelope;
-}
-
-function isObjectRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function normalizeToolRequest(value: unknown): ToolRequestParseResult {
-  if (!isObjectRecord(value)) {
-    return {
-      ok: false,
-      error: createInvalidRequestEnvelope("Request must be a JSON object.")
-    };
-  }
-
-  const metadata = extractRequestMetadata(value);
-  const { id, name, arguments: args, traceId } = value;
-  if (typeof name !== "string" || name.trim().length === 0) {
-    return {
-      ok: false,
-      error: createInvalidRequestEnvelope(
-        'Request field "name" must be a non-empty string.',
-        metadata
-      )
-    };
-  }
-
-  const request: StdioToolRequest = {
-    name: name.trim(),
-    arguments: args
-  };
-
-  if (typeof traceId === "string") {
-    request.traceId = traceId;
-  }
-
-  if (Object.prototype.hasOwnProperty.call(value, "id")) {
-    request.id = id;
-  }
-
-  return {
-    ok: true,
-    request
-  };
-}
-
-type ToolRequestParseResult =
-  | {
-      ok: true;
-      request: StdioToolRequest;
-    }
-  | {
-      ok: false;
-      error: ErrorEnvelope;
-    };
-
-function writeJsonLine(output: Writable, payload: unknown): void {
-  output.write(`${JSON.stringify(payload)}\n`);
-}
-
-export type BrowserdRuntime = {
-  container: BrowserdContainer;
-  transport: "stdio" | "tcp";
-  listening?: TcpTransport;
-  mcpStdioStarted: true;
-  close(): void;
-};
-
-type LineWriter = (payload: unknown) => void;
-
-function createLineProcessor(container: BrowserdContainer, writer: LineWriter) {
-  return async (line: string): Promise<void> => {
-    const trimmedLine = line.trim();
-    if (trimmedLine.length === 0) {
-      return;
-    }
-
-    let parsedRequest: unknown;
-    try {
-      parsedRequest = JSON.parse(trimmedLine);
-    } catch {
-      writer(createInvalidRequestEnvelope("Invalid JSON request."));
-      return;
-    }
-
-    const requestMetadata = extractRequestMetadata(parsedRequest);
-    try {
-      const normalizedRequest = normalizeToolRequest(parsedRequest);
-      if (!normalizedRequest.ok) {
-        writer(normalizedRequest.error);
-        return;
-      }
-
-      const request = normalizedRequest.request;
-      const response = await container.mcpServer.callTool({
-        name: request.name,
-        arguments: request.arguments,
-        traceId: request.traceId
-      });
-
-      const payload = request.id === undefined ? response : { id: request.id, ...response };
-      writer(payload);
-    } catch (error) {
-      throw new ProcessLineError(toErrorMessage(error), requestMetadata);
-    }
-  };
-}
-
-function createLineQueue(
-  processLine: (line: string) => Promise<void>,
-  writer: LineWriter
-): (line: string) => void {
-  let processing = Promise.resolve();
-
-  return (line: string) => {
-    processing = processing
-      .then(() => processLine(line))
-      .catch((error: unknown) => {
-        if (error instanceof ProcessLineError) {
-          writer(createInvalidRequestEnvelope(error.message, error.metadata));
-          return;
-        }
-
-        writer(createInvalidRequestEnvelope(toErrorMessage(error)));
-      });
-  };
-}
-
-function attachStreamReader(
-  input: Readable,
-  onLine: (line: string) => void
-): () => void {
-  let buffer = "";
-  const onData = (chunk: string | Buffer) => {
-    buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
-
-    let lineBreakIndex = buffer.indexOf("\n");
-    while (lineBreakIndex >= 0) {
-      const line = buffer.slice(0, lineBreakIndex);
-      buffer = buffer.slice(lineBreakIndex + 1);
-      onLine(line);
-      lineBreakIndex = buffer.indexOf("\n");
-    }
-  };
-
-  input.setEncoding("utf8");
-  input.on("data", onData);
-  input.resume();
-  return () => {
-    input.off("data", onData);
-    input.pause();
-  };
-}
-
-function toTcpTransport(value: BootstrapBrowserdOptions): TcpTransport {
-  const env = value.env ?? process.env;
-  const envPort = toPositiveNumber(env.BROWSERD_PORT);
-  const optionPort = value.port;
-  return {
-    host: value.host ?? env.BROWSERD_HOST ?? DEFAULT_TCP_HOST,
-    port: optionPort ?? envPort ?? DEFAULT_TCP_PORT
-  };
-}
-
-function toPositiveNumber(value: string | undefined): number | undefined {
-  if (value === undefined) {
-    return undefined;
-  }
-
-  const parsed = Number.parseInt(value, 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
-}
-
-function resolveTransportMode(options: BootstrapBrowserdOptions): "stdio" | "tcp" {
-  if (options.transport !== undefined) {
-    return options.transport;
-  }
-
-  const env = options.env ?? process.env;
-  return env.BROWSERD_TRANSPORT === "tcp" ? "tcp" : "stdio";
-}
-
-export function startMcpStdioServer(
-  container: BrowserdContainer,
-  transport: StdioTransport = { input: process.stdin, output: process.stdout }
-): BrowserdRuntime {
-  const mcpSdkServer = createMcpSdkServer({
-    toolMap: container.mcpServer.toolMap,
-    serverInfo: {
-      name: "browserd",
-      version: DEFAULT_SERVER_VERSION
-    }
-  });
-
-  // MCP server startup is async but starts listening synchronously before this Promise resolves.
-  void mcpSdkServer.connectStdio(transport).catch(() => undefined);
-
-  return {
-    container,
-    transport: "stdio",
-    mcpStdioStarted: true,
-    close() {
-      void mcpSdkServer.close();
-      container.close();
-    }
-  };
-}
-
-export function startLegacyStdioServer(
-  container: BrowserdContainer,
-  transport: StdioTransport = { input: process.stdin, output: process.stdout }
-): BrowserdRuntime {
-  const writer: LineWriter = (payload) => {
-    writeJsonLine(transport.output, payload);
-  };
-  const processLine = createLineProcessor(container, writer);
-  const queueLine = createLineQueue(processLine, writer);
-  const detach = attachStreamReader(transport.input, queueLine);
-
-  return {
-    container,
-    transport: "stdio",
-    mcpStdioStarted: true,
-    close() {
-      detach();
-      container.close();
-    }
-  };
-}
-
-export function startMcpTcpServer(container: BrowserdContainer, transport: TcpTransport): BrowserdRuntime {
-  const server = createServer();
-  const sockets = new Set<Socket>();
-
-  server.on("connection", (socket) => {
-    sockets.add(socket);
-    socket.setEncoding("utf8");
-
-    const writer: LineWriter = (payload) => {
-      socket.write(`${JSON.stringify(payload)}\n`);
-    };
-
-    const processLine = createLineProcessor(container, writer);
-    const queueLine = createLineQueue(processLine, writer);
-    const detachReader = attachStreamReader(socket, queueLine);
-
-    socket.on("close", () => {
-      detachReader();
-      sockets.delete(socket);
-    });
-
-    socket.on("error", () => {
-      detachReader();
-      sockets.delete(socket);
-    });
-  });
-
-  server.listen(transport.port, transport.host);
-
-  return {
-    container,
-    transport: "tcp",
-    listening: transport,
-    mcpStdioStarted: true,
-    close() {
-      for (const socket of sockets) {
-        socket.destroy();
-      }
-      sockets.clear();
-      server.close();
-      container.close();
-    }
-  };
-}
-
-type BootstrapBrowserdOptions = {
-  env?: Record<string, string | undefined>;
-  transport?: "stdio" | "tcp";
-  stdioProtocol?: StdioProtocol;
-  host?: string;
-  port?: number;
-  input?: Readable;
-  output?: Writable;
-};
-
-function resolveStdioProtocol(options: BootstrapBrowserdOptions): StdioProtocol {
-  if (options.stdioProtocol !== undefined) {
-    return options.stdioProtocol;
-  }
-
-  const env = options.env ?? process.env;
-  return env.BROWSERD_STDIO_PROTOCOL === "legacy" ? "legacy" : "mcp";
-}
-
-export function bootstrapBrowserd(options: BootstrapBrowserdOptions = {}): BrowserdRuntime {
-  const config = loadBrowserdConfig(options.env);
-  const container = createContainer(config);
-  const mode = resolveTransportMode(options);
-  if (mode === "tcp") {
-    if (config.authToken === undefined) {
-      container.close();
-      throw new Error(
-        "BROWSERD_AUTH_TOKEN is required when BROWSERD_TRANSPORT=tcp to prevent unauthenticated network access."
-      );
-    }
-    return startMcpTcpServer(container, toTcpTransport(options));
-  }
-
-  const stdioTransport: StdioTransport = {
-    input: options.input ?? process.stdin,
-    output: options.output ?? process.stdout
-  };
-  if (resolveStdioProtocol(options) === "legacy") {
-    return startLegacyStdioServer(container, stdioTransport);
-  }
-
-  return startMcpStdioServer(container, stdioTransport);
-}