@flrande/browserctl 0.1.0-dev.7.1

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

@@ -0,0 +1,253 @@
+import { createServer, type AddressInfo } from "node:net";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { DAEMON_STARTUP_ARGUMENT } from "./commands/common";
+import { callDaemonTool, getDaemonStatus, stopDaemon } from "./daemon-client";
+
+type CapturedRequest = {
+  id: string;
+  name: string;
+  traceId: string;
+  arguments: Record<string, unknown>;
+};
+
+const ORIGINAL_DAEMON_PORT = process.env.BROWSERCTL_DAEMON_PORT;
+const ORIGINAL_AUTH_TOKEN = process.env.BROWSERCTL_AUTH_TOKEN;
+const TEST_PID_PORTS = new Set<number>();
+
+function resolveRuntimeDirForTests(): string {
+  const currentFile = fileURLToPath(import.meta.url);
+  return resolve(dirname(currentFile), "../../../.browserctl-runtime");
+}
+
+function resolvePidFileForTests(port: number): string {
+  return join(resolveRuntimeDirForTests(), `daemon-${port}.pid`);
+}
+
+function writePidRecordForTests(port: number, record: number | { pid: number; authToken?: string }): void {
+  mkdirSync(resolveRuntimeDirForTests(), { recursive: true });
+  writeFileSync(
+    resolvePidFileForTests(port),
+    typeof record === "number" ? String(record) : JSON.stringify(record),
+    { encoding: "utf8" }
+  );
+  TEST_PID_PORTS.add(port);
+}
+
+afterEach(() => {
+  if (ORIGINAL_DAEMON_PORT === undefined) {
+    delete process.env.BROWSERCTL_DAEMON_PORT;
+  } else {
+    process.env.BROWSERCTL_DAEMON_PORT = ORIGINAL_DAEMON_PORT;
+  }
+
+  if (ORIGINAL_AUTH_TOKEN === undefined) {
+    delete process.env.BROWSERCTL_AUTH_TOKEN;
+  } else {
+    process.env.BROWSERCTL_AUTH_TOKEN = ORIGINAL_AUTH_TOKEN;
+  }
+
+  for (const port of TEST_PID_PORTS) {
+    rmSync(resolvePidFileForTests(port), { force: true });
+  }
+  TEST_PID_PORTS.clear();
+  vi.restoreAllMocks();
+});
+
+async function withDaemonHarness(
+  run: (state: { port: number; requests: CapturedRequest[] }) => Promise<void>
+): Promise<void> {
+  const requests: CapturedRequest[] = [];
+  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);
+        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`
+        );
+
+        lineBreakIndex = buffer.indexOf("\n");
+      }
+    });
+  });
+
+  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;
+
+  try {
+    await run({ port: address.port, requests });
+  } finally {
+    await new Promise<void>((resolve, reject) => {
+      server.close((error) => {
+        if (error !== undefined) {
+          reject(error);
+          return;
+        }
+
+        resolve();
+      });
+    });
+  }
+}
+
+describe("daemon client auth token forwarding", () => {
+  it("includes env token in daemon status probes", async () => {
+    await withDaemonHarness(async ({ port, requests }) => {
+      process.env.BROWSERCTL_DAEMON_PORT = String(port);
+      process.env.BROWSERCTL_AUTH_TOKEN = "env-token";
+
+      const status = await getDaemonStatus();
+
+      expect(status.running).toBe(true);
+      expect(requests).toHaveLength(1);
+      expect(requests[0]).toMatchObject({
+        name: "browser.status",
+        arguments: {
+          sessionId: "cli:daemon-status",
+          authToken: "env-token"
+        }
+      });
+    });
+  });
+
+  it("includes env token in tool calls when not explicitly provided", async () => {
+    await withDaemonHarness(async ({ port, requests }) => {
+      process.env.BROWSERCTL_DAEMON_PORT = String(port);
+      process.env.BROWSERCTL_AUTH_TOKEN = "env-token";
+
+      await callDaemonTool("browser.tab.list", {
+        sessionId: "cli:test"
+      });
+
+      expect(requests).toHaveLength(1);
+      expect(requests[0]).toMatchObject({
+        name: "browser.tab.list",
+        arguments: {
+          sessionId: "cli:test",
+          authToken: "env-token"
+        }
+      });
+    });
+  });
+
+  it("preserves explicit authToken in tool calls", async () => {
+    await withDaemonHarness(async ({ port, requests }) => {
+      process.env.BROWSERCTL_DAEMON_PORT = String(port);
+      process.env.BROWSERCTL_AUTH_TOKEN = "env-token";
+
+      await callDaemonTool("browser.tab.list", {
+        sessionId: "cli:test",
+        authToken: "cli-token"
+      });
+
+      expect(requests).toHaveLength(1);
+      expect(requests[0]).toMatchObject({
+        name: "browser.tab.list",
+        arguments: {
+          sessionId: "cli:test",
+          authToken: "cli-token"
+        }
+      });
+    });
+  });
+
+  it("does not forward internal daemon startup metadata as tool arguments", async () => {
+    await withDaemonHarness(async ({ port, requests }) => {
+      process.env.BROWSERCTL_DAEMON_PORT = String(port);
+
+      await callDaemonTool("browser.tab.list", {
+        sessionId: "cli:test",
+        [DAEMON_STARTUP_ARGUMENT]: {
+          managedLocal: {
+            browserName: "chromium",
+            channel: "msedge"
+          }
+        }
+      });
+
+      expect(requests).toHaveLength(1);
+      expect(requests[0].arguments).toMatchObject({
+        sessionId: "cli:test"
+      });
+      expect(requests[0].arguments).not.toHaveProperty(DAEMON_STARTUP_ARGUMENT);
+    });
+  });
+
+  it("reuses persisted daemon auth token when env token is missing", async () => {
+    await withDaemonHarness(async ({ port, requests }) => {
+      process.env.BROWSERCTL_DAEMON_PORT = String(port);
+      delete process.env.BROWSERCTL_AUTH_TOKEN;
+      writePidRecordForTests(port, {
+        pid: 12345,
+        authToken: "persisted-token"
+      });
+
+      const status = await getDaemonStatus();
+
+      expect(status.running).toBe(true);
+      expect(requests).toHaveLength(1);
+      expect(requests[0]).toMatchObject({
+        name: "browser.status",
+        arguments: {
+          sessionId: "cli:daemon-status",
+          authToken: "persisted-token"
+        }
+      });
+    });
+  });
+
+  it("avoids killing stale pid records when daemon cannot be verified", async () => {
+    const unreachablePort = 45999;
+    writePidRecordForTests(unreachablePort, {
+      pid: 70001,
+      authToken: "persisted-token"
+    });
+
+    const killSpy = vi.spyOn(process, "kill").mockImplementation(() => true);
+    const stopResult = await stopDaemon(unreachablePort);
+
+    expect(stopResult).toMatchObject({
+      stopped: false,
+      port: unreachablePort,
+      pid: 70001
+    });
+    expect(killSpy).not.toHaveBeenCalled();
+  });
+});