@flrande/browserctl 0.5.0-dev.19.1 → 0.5.0-dev.22.1

package/apps/browserctl/src/daemon-client.test.ts

@@ -17,6 +17,8 @@ type CapturedRequest = {
 
 const ORIGINAL_DAEMON_PORT = process.env.BROWSERCTL_DAEMON_PORT;
 const ORIGINAL_AUTH_TOKEN = process.env.BROWSERCTL_AUTH_TOKEN;
+const ORIGINAL_DAEMON_STARTUP_TIMEOUT_MS = process.env.BROWSERCTL_DAEMON_STARTUP_TIMEOUT_MS;
+const ORIGINAL_DAEMON_REQUEST_TIMEOUT_MS = process.env.BROWSERCTL_DAEMON_REQUEST_TIMEOUT_MS;
 const TEST_PID_PORTS = new Set<number>();
 
 function resolveRuntimeDirForTests(): string {
@@ -51,6 +53,18 @@ afterEach(() => {
     process.env.BROWSERCTL_AUTH_TOKEN = ORIGINAL_AUTH_TOKEN;
   }
 
+  if (ORIGINAL_DAEMON_STARTUP_TIMEOUT_MS === undefined) {
+    delete process.env.BROWSERCTL_DAEMON_STARTUP_TIMEOUT_MS;
+  } else {
+    process.env.BROWSERCTL_DAEMON_STARTUP_TIMEOUT_MS = ORIGINAL_DAEMON_STARTUP_TIMEOUT_MS;
+  }
+
+  if (ORIGINAL_DAEMON_REQUEST_TIMEOUT_MS === undefined) {
+    delete process.env.BROWSERCTL_DAEMON_REQUEST_TIMEOUT_MS;
+  } else {
+    process.env.BROWSERCTL_DAEMON_REQUEST_TIMEOUT_MS = ORIGINAL_DAEMON_REQUEST_TIMEOUT_MS;
+  }
+
   for (const port of TEST_PID_PORTS) {
     rmSync(resolvePidFileForTests(port), { force: true });
   }
@@ -59,8 +73,12 @@ afterEach(() => {
 });
 
 async function withDaemonHarness(
-  run: (state: { port: number; requests: CapturedRequest[] }) => Promise<void>
+  run: (state: { port: number; requests: CapturedRequest[] }) => Promise<void>,
+  options: {
+    responseDelayMs?: number;
+  } = {}
 ): Promise<void> {
+  const responseDelayMs = options.responseDelayMs ?? 0;
   const requests: CapturedRequest[] = [];
   const server = createServer((socket) => {
     socket.setEncoding("utf8");
@@ -81,20 +99,27 @@ async function withDaemonHarness(
 
         const request = JSON.parse(line) as CapturedRequest;
         requests.push(request);
-        socket.write(
-          `${JSON.stringify({
-            id: request.id,
-            ok: true,
-            traceId: request.traceId,
-            sessionId:
-              typeof request.arguments.sessionId === "string"
-                ? request.arguments.sessionId
-                : "cli:test",
-            data: {
-              ok: true
-            }
-          })}\n`
-        );
+        const respond = () => {
+          socket.write(
+            `${JSON.stringify({
+              id: request.id,
+              ok: true,
+              traceId: request.traceId,
+              sessionId:
+                typeof request.arguments.sessionId === "string"
+                  ? request.arguments.sessionId
+                  : "cli:test",
+              data: {
+                ok: true
+              }
+            })}\n`
+          );
+        };
+        if (responseDelayMs > 0) {
+          setTimeout(respond, responseDelayMs);
+        } else {
+          respond();
+        }
 
         lineBreakIndex = buffer.indexOf("\n");
       }
@@ -127,6 +152,126 @@ async function withDaemonHarness(
   }
 }
 
+async function reservePortForTests(): Promise<number> {
+  const server = createServer();
+
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+
+  const address = server.address() as AddressInfo;
+  await new Promise<void>((resolve, reject) => {
+    server.close((error) => {
+      if (error !== undefined) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+
+  return address.port;
+}
+
+async function startDaemonHarnessOnPort(
+  port: number,
+  requests: CapturedRequest[],
+  options: {
+    responseDelayMs?: number;
+  } = {}
+): Promise<() => Promise<void>> {
+  const responseDelayMs = options.responseDelayMs ?? 0;
+  const server = createServer((socket) => {
+    socket.setEncoding("utf8");
+    let buffer = "";
+
+    socket.on("data", (chunk: string) => {
+      buffer += chunk;
+
+      let lineBreakIndex = buffer.indexOf("\n");
+      while (lineBreakIndex >= 0) {
+        const line = buffer.slice(0, lineBreakIndex).trim();
+        buffer = buffer.slice(lineBreakIndex + 1);
+
+        if (line.length === 0) {
+          lineBreakIndex = buffer.indexOf("\n");
+          continue;
+        }
+
+        const request = JSON.parse(line) as CapturedRequest;
+        requests.push(request);
+        const respond = () => {
+          socket.write(
+            `${JSON.stringify({
+              id: request.id,
+              ok: true,
+              traceId: request.traceId,
+              sessionId:
+                typeof request.arguments.sessionId === "string"
+                  ? request.arguments.sessionId
+                  : "cli:test",
+              data: {
+                ok: true
+              }
+            })}\n`
+          );
+        };
+        if (responseDelayMs > 0) {
+          setTimeout(respond, responseDelayMs);
+        } else {
+          respond();
+        }
+
+        lineBreakIndex = buffer.indexOf("\n");
+      }
+    });
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+
+  return async () =>
+    await new Promise<void>((resolve, reject) => {
+      server.close((error) => {
+        if (error !== undefined) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+}
+
+async function importDaemonClientWithMockedSpawn(
+  spawnImplementation: () => {
+    pid: number;
+    unref(): void;
+  }
+): Promise<{
+  callDaemonToolWithMock: typeof callDaemonTool;
+  spawnMock: ReturnType<typeof vi.fn>;
+}> {
+  vi.resetModules();
+  const spawnMock = vi.fn(spawnImplementation);
+  vi.doMock("node:child_process", () => ({
+    spawn: spawnMock
+  }));
+  const daemonClientModule = await import("./daemon-client");
+  return {
+    callDaemonToolWithMock: daemonClientModule.callDaemonTool,
+    spawnMock
+  };
+}
+
 describe("daemon client auth token forwarding", () => {
   it("includes env token in daemon status probes", async () => {
     await withDaemonHarness(async ({ port, requests }) => {
@@ -251,3 +396,117 @@ describe("daemon client auth token forwarding", () => {
     expect(killSpy).not.toHaveBeenCalled();
   });
 });
+
+describe("daemon client timeout env branches", () => {
+  it("applies BROWSERCTL_DAEMON_REQUEST_TIMEOUT_MS to daemon responses", async () => {
+    await withDaemonHarness(
+      async ({ port }) => {
+        process.env.BROWSERCTL_DAEMON_PORT = String(port);
+        process.env.BROWSERCTL_DAEMON_REQUEST_TIMEOUT_MS = "10";
+
+        await expect(
+          callDaemonTool("browser.tab.list", {
+            sessionId: "cli:timeout"
+          })
+        ).rejects.toThrow("Timed out waiting for daemon response after 10ms");
+      },
+      {
+        responseDelayMs: 80
+      }
+    );
+  });
+
+  it("falls back to default request timeout when env value is invalid", async () => {
+    await withDaemonHarness(
+      async ({ port, requests }) => {
+        process.env.BROWSERCTL_DAEMON_PORT = String(port);
+        process.env.BROWSERCTL_DAEMON_REQUEST_TIMEOUT_MS = "-1";
+
+        await expect(
+          callDaemonTool("browser.tab.list", {
+            sessionId: "cli:timeout-fallback"
+          })
+        ).resolves.toEqual({
+          ok: true
+        });
+        expect(requests).toHaveLength(1);
+      },
+      {
+        responseDelayMs: 80
+      }
+    );
+  });
+
+  it("applies BROWSERCTL_DAEMON_STARTUP_TIMEOUT_MS while polling spawned daemon readiness", async () => {
+    const unavailablePort = await reservePortForTests();
+    TEST_PID_PORTS.add(unavailablePort);
+    process.env.BROWSERCTL_DAEMON_PORT = String(unavailablePort);
+    process.env.BROWSERCTL_DAEMON_STARTUP_TIMEOUT_MS = "50";
+    process.env.BROWSERCTL_DAEMON_REQUEST_TIMEOUT_MS = "20";
+
+    const { callDaemonToolWithMock, spawnMock } = await importDaemonClientWithMockedSpawn(() => ({
+      pid: 424242,
+      unref: vi.fn()
+    }));
+
+    try {
+      const startedAt = Date.now();
+      await expect(
+        callDaemonToolWithMock("browser.status", {
+          sessionId: "cli:startup-timeout"
+        })
+      ).rejects.toThrow(`Daemon did not become ready on port ${unavailablePort}:`);
+      expect(spawnMock).toHaveBeenCalledTimes(1);
+      expect(Date.now() - startedAt).toBeLessThan(1_500);
+    } finally {
+      vi.doUnmock("node:child_process");
+      vi.resetModules();
+    }
+  });
+
+  it("falls back to default startup timeout when env value is invalid", async () => {
+    const port = await reservePortForTests();
+    TEST_PID_PORTS.add(port);
+    process.env.BROWSERCTL_DAEMON_PORT = String(port);
+    process.env.BROWSERCTL_DAEMON_STARTUP_TIMEOUT_MS = "-1";
+    process.env.BROWSERCTL_DAEMON_REQUEST_TIMEOUT_MS = "50";
+
+    const requests: CapturedRequest[] = [];
+    let closeServer: (() => Promise<void>) | undefined;
+    let startupError: unknown;
+    const startupTimer = setTimeout(() => {
+      void startDaemonHarnessOnPort(port, requests)
+        .then((close) => {
+          closeServer = close;
+        })
+        .catch((error) => {
+          startupError = error;
+        });
+    }, 300);
+
+    const { callDaemonToolWithMock, spawnMock } = await importDaemonClientWithMockedSpawn(() => ({
+      pid: 434343,
+      unref: vi.fn()
+    }));
+
+    try {
+      await expect(
+        callDaemonToolWithMock("browser.status", {
+          sessionId: "cli:startup-fallback"
+        })
+      ).resolves.toEqual({
+        ok: true
+      });
+      expect(spawnMock).toHaveBeenCalledTimes(1);
+      expect(requests.some((request) => request.name === "browser.status")).toBe(true);
+      expect(startupError).toBeUndefined();
+    } finally {
+      clearTimeout(startupTimer);
+      if (closeServer !== undefined) {
+        await closeServer();
+      }
+      vi.doUnmock("node:child_process");
+      vi.resetModules();
+    }
+  });
+});

package/apps/browserd/src/main.test.ts

@@ -229,6 +229,42 @@ describe("browserd container", () => {
     expect(config.defaultDriver).toBe("chrome-relay");
   });
 
+  it("parses managed-local launch env branches for browser/headless/channel/path/timeout/args", () => {
+    const config = loadBrowserdConfig({
+      BROWSERD_MANAGED_LOCAL_BROWSER: "firefox",
+      BROWSERD_MANAGED_LOCAL_HEADLESS: "off",
+      BROWSERD_MANAGED_LOCAL_CHANNEL: "msedge",
+      BROWSERD_MANAGED_LOCAL_EXECUTABLE_PATH: "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
+      BROWSERD_MANAGED_LOCAL_LAUNCH_TIMEOUT_MS: "45000",
+      BROWSERD_MANAGED_LOCAL_ARGS: "--disable-gpu,--lang=en-US"
+    });
+
+    expect(config.managedLocalLaunch).toEqual({
+      browserName: "firefox",
+      headless: false,
+      channel: "msedge",
+      executablePath: "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
+      launchTimeoutMs: 45000,
+      args: ["--disable-gpu", "--lang=en-US"]
+    });
+  });
+
+  it("falls back to managed-local defaults for invalid launch env values", () => {
+    const config = loadBrowserdConfig({
+      BROWSERD_MANAGED_LOCAL_BROWSER: "invalid-browser",
+      BROWSERD_MANAGED_LOCAL_HEADLESS: "maybe",
+      BROWSERD_MANAGED_LOCAL_LAUNCH_TIMEOUT_MS: "-10",
+      BROWSERD_MANAGED_LOCAL_ARGS: " , , "
+    });
+
+    expect(config.managedLocalLaunch).toMatchObject({
+      browserName: "chromium",
+      headless: true,
+      launchTimeoutMs: undefined,
+      args: []
+    });
+  });
+
   it("does not register managed-local driver when explicitly disabled", () => {
     const c = createContainer(
       loadBrowserdConfig({
@@ -292,6 +328,26 @@ describe("browserd bootstrap", () => {
     runtime.close();
   });
 
+  it("reads tcp host from BROWSERD_HOST env in tcp transport mode", () => {
+    const port = testTcpPort;
+    const runtime = bootstrapBrowserd({
+      env: createTestEnv({
+        BROWSERD_TRANSPORT: "tcp",
+        BROWSERD_HOST: "localhost",
+        BROWSERD_PORT: String(port),
+        BROWSERD_AUTH_TOKEN: "tcp-token"
+      })
+    });
+
+    expect(runtime.transport).toBe("tcp");
+    expect(runtime.listening).toEqual({
+      host: "localhost",
+      port
+    });
+
+    runtime.close();
+  });
+
   it("rejects tcp transport mode when auth token is not configured", () => {
     let runtime: ReturnType<typeof bootstrapBrowserd> | undefined;
     try {
@@ -1388,6 +1444,36 @@ describe("browserd bootstrap", () => {
     output.end();
   });
 
+  it("uses legacy stdio protocol when BROWSERD_STDIO_PROTOCOL=legacy", async () => {
+    const input = new PassThrough();
+    const output = new PassThrough();
+    const runtime = bootstrapBrowserd({
+      env: createTestEnv({
+        BROWSERD_STDIO_PROTOCOL: "legacy"
+      }),
+      input,
+      output
+    });
+
+    const response = await sendToolRequest(input, output, {
+      id: "request-legacy-env",
+      name: "browser.status",
+      traceId: "trace:legacy-env",
+      arguments: {
+        sessionId: "session:legacy-env"
+      }
+    });
+
+    expect(response.ok).toBe(true);
+    expect(response.id).toBe("request-legacy-env");
+    expect(response.traceId).toBe("trace:legacy-env");
+    expect(response.sessionId).toBe("session:legacy-env");
+
+    runtime.close();
+    input.end();
+    output.end();
+  });
+
   it("preserves id and trace/session metadata when queue-level error handling runs", async () => {
     const input = new PassThrough();
     const output = new PassThrough();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flrande/browserctl",
-  "version": "0.5.0-dev.19.1",
+  "version": "0.5.0-dev.22.1",
   "private": false,
   "bin": {
     "browserctl": "bin/browserctl.cjs",
@@ -36,6 +36,7 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@vitest/coverage-v8": "^2.1.8",
     "@types/node": "^22.15.30",
     "typescript": "^5.6.3",
     "vitest": "^2.1.8"
@@ -49,6 +50,7 @@
     "test:e2e:full": "vitest run --config vitest.e2e.full.config.ts",
     "test:e2e:stress": "vitest run --config vitest.e2e.stress.config.ts",
     "test:smoke": "vitest run --config vitest.smoke.config.ts",
+    "test:coverage": "vitest run --config vitest.config.ts --coverage",
     "test:all": "pnpm run test:unit && pnpm run test:contract && pnpm run test:e2e && pnpm run test:smoke",
     "build": "npm pack --dry-run",
     "typecheck": "pnpm exec tsc --noEmit -p tsconfig.typecheck.json",