agent-log-viewer 1.0.1 → 1.0.3

package/bin/server-runtime.test.ts

@@ -1,5 +1,6 @@
 import path from "node:path";
 import fs from "node:fs";
+import net from "node:net";
 import os from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
@@ -10,8 +11,11 @@ import { loadFlows } from "@/lib/flows/store";
 import { loadArchivedPipelines, loadPipelines } from "@/lib/pipelines/store";
 import { structuredHostsEnabled as structuredHostsEnabledInApp } from "@/lib/runtime/flags";
 import { loadWorkflows } from "@/lib/workflows/store";
+import { RuntimeHostFence } from "@/runtime-host/runtimeHostFence";
 
 import {
+  cliRuntimeHostConfig,
+  cliRuntimeHostEnvironment,
   structuredHostsEnabled as structuredHostsEnabledInLauncher,
   viewerServerBunRuntime,
   viewerChildProcessOptions,
@@ -19,6 +23,192 @@ import {
   withoutWakatimeCredential,
 } from "./server-runtime.mjs";
 
+async function availablePort(): Promise<number> {
+  const server = net.createServer();
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve);
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") throw new Error("could not reserve a launcher test port");
+  await new Promise<void>((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+  return address.port;
+}
+
+test("the CLI derives a distinct managed runtime host for each install", () => {
+  const sandbox = fs.mkdtempSync(path.join(os.tmpdir(), "llv-runtime-package-"));
+  const firstPackageRoot = path.join(sandbox, "first");
+  const secondPackageRoot = path.join(sandbox, "second");
+  const stateDirectory = path.join(sandbox, "state");
+  const ambientSocket = path.join(sandbox, "operator-runtime.sock");
+  const ambientJournal = path.join(sandbox, "operator-runtime.sqlite");
+  const firstBundle = path.join(firstPackageRoot, "dist", "runtime-host.mjs");
+  const secondBundle = path.join(secondPackageRoot, "dist", "runtime-host.mjs");
+  fs.mkdirSync(path.dirname(firstBundle), { recursive: true });
+  fs.mkdirSync(path.dirname(secondBundle), { recursive: true });
+  fs.writeFileSync(firstBundle, "export {};\n");
+  fs.writeFileSync(secondBundle, "export {};\n");
+  try {
+    const options = {
+      env: {
+        LLV_STATE_DIR: stateDirectory,
+        LLV_RUNTIME_HOST_SOCKET: ambientSocket,
+        LLV_RUNTIME_JOURNAL: ambientJournal,
+      },
+      home: path.join(sandbox, "home"),
+    };
+    const first = cliRuntimeHostConfig(firstPackageRoot, options);
+    const second = cliRuntimeHostConfig(secondPackageRoot, options);
+
+    expect(first.entrypoint).toBe(firstBundle);
+    expect(second.entrypoint).toBe(secondBundle);
+    expect(path.dirname(first.socketPath)).toBe(stateDirectory);
+    expect(path.dirname(second.socketPath)).toBe(stateDirectory);
+    expect(path.basename(first.socketPath)).toMatch(/^runtime-host-[a-f0-9]{16}\.sock$/);
+    expect(path.basename(second.socketPath)).toMatch(/^runtime-host-[a-f0-9]{16}\.sock$/);
+    expect(path.dirname(first.journalPath)).toBe(stateDirectory);
+    expect(path.dirname(second.journalPath)).toBe(stateDirectory);
+    expect(path.basename(first.journalPath)).toMatch(/^runtime-events-[a-f0-9]{16}\.sqlite$/);
+    expect(path.basename(second.journalPath)).toMatch(/^runtime-events-[a-f0-9]{16}\.sqlite$/);
+    expect(first.socketPath).not.toBe(second.socketPath);
+    expect(first.journalPath).not.toBe(second.journalPath);
+    expect(first.socketPath).not.toBe(ambientSocket);
+    expect(second.socketPath).not.toBe(ambientSocket);
+    expect(first.journalPath).not.toBe(ambientJournal);
+    expect(second.journalPath).not.toBe(ambientJournal);
+  } finally {
+    fs.rmSync(sandbox, { recursive: true, force: true });
+  }
+});
+
+test("the CLI uses the source runtime host in a checkout", () => {
+  const packageRoot = fs.mkdtempSync(path.join(os.tmpdir(), "llv-runtime-source-"));
+  const source = path.join(packageRoot, "src", "runtime-host", "main.ts");
+  const stateDirectory = path.join(packageRoot, "state");
+  fs.mkdirSync(path.dirname(source), { recursive: true });
+  fs.writeFileSync(source, "export {};\n");
+  try {
+    const config = cliRuntimeHostConfig(packageRoot, {
+      env: { LLV_STATE_DIR: stateDirectory },
+      home: path.join(packageRoot, "home"),
+    });
+    expect(config.entrypoint).toBe(source);
+    expect(path.dirname(config.socketPath)).toBe(stateDirectory);
+    expect(path.dirname(config.journalPath)).toBe(stateDirectory);
+  } finally {
+    fs.rmSync(packageRoot, { recursive: true, force: true });
+  }
+});
+
+test("the CLI runtime environment owns its socket and journal and strips ambient WakaTime credentials", () => {
+  const socketPath = "/runtime/viewer.sock";
+  const journalPath = "/runtime/viewer.sqlite";
+  const env: Record<string, string | undefined> = cliRuntimeHostEnvironment({
+    PATH: "/usr/bin",
+    LLV_RUNTIME_HOST_SOCKET: "/runtime/operator.sock",
+    LLV_RUNTIME_JOURNAL: "/runtime/operator.sqlite",
+    LLV_STRUCTURED_HOSTS: "off",
+    LLV_RUNTIME_EVENTS: "0",
+    LLV_SPAWN_TRANSPORT: "tmux",
+    NEXT_PUBLIC_RUNTIME_UI: "0",
+    [WAKATIME_CREDENTIAL_ENV]: "fixture-value",
+  }, { socketPath, journalPath });
+
+  expect(env).toMatchObject({
+    PATH: "/usr/bin",
+    LLV_RUNTIME_HOST_SOCKET: socketPath,
+    LLV_RUNTIME_JOURNAL: journalPath,
+    LLV_STRUCTURED_HOSTS: "1",
+    LLV_RUNTIME_EVENTS: "1",
+    LLV_SPAWN_TRANSPORT: "structured",
+    NEXT_PUBLIC_RUNTIME_UI: "1",
+  });
+  expect(env[WAKATIME_CREDENTIAL_ENV]).toBeUndefined();
+});
+
+test("the CLI rejects a ready runtime socket owned by another process", async () => {
+  const sandbox = fs.mkdtempSync(path.join(os.tmpdir(), "llv-runtime-incumbent-"));
+  const packageRoot = path.resolve(import.meta.dir, "..");
+  const stateDirectory = path.join(sandbox, "state");
+  const environment: Record<string, string | undefined> = {
+    ...process.env,
+    HOME: path.join(sandbox, "home"),
+    XDG_CONFIG_HOME: path.join(sandbox, "config"),
+    LLV_STATE_DIR: stateDirectory,
+    TMPDIR: path.join(sandbox, "tmp"),
+    LLV_LANG: "en",
+    LLV_RUNTIME_HOST_FENCE_WAIT_MS: "0",
+  };
+  const socketPath = cliRuntimeHostConfig(packageRoot, { env: environment, home: environment.HOME }).socketPath;
+  const fence = new RuntimeHostFence(`${socketPath}.lock`);
+  const listener = net.createServer((socket) => socket.end());
+  fs.mkdirSync(environment.HOME!, { recursive: true });
+  fs.mkdirSync(environment.XDG_CONFIG_HOME!, { recursive: true });
+  fs.mkdirSync(environment.TMPDIR!, { recursive: true });
+  fence.acquire();
+  await new Promise<void>((resolve, reject) => {
+    listener.once("error", reject);
+    listener.listen(socketPath, resolve);
+  });
+
+  const child = Bun.spawn([
+    process.execPath,
+    "--bun",
+    path.join(import.meta.dir, "cli.mjs"),
+    "--no-open",
+    "--port",
+    String(await availablePort()),
+  ], { cwd: packageRoot, env: environment, stdout: "pipe", stderr: "pipe" });
+  try {
+    const [exitCode, stderr] = await Promise.all([child.exited, new Response(child.stderr).text()]);
+    expect(exitCode).toBe(1);
+    expect(stderr).toContain("Couldn't start the structured runtime host");
+    expect(stderr).toContain(`runtime host socket is owned by pid ${process.pid}`);
+    expect(stderr).toContain("stop the other agent-log-viewer instance");
+  } finally {
+    if (!child.killed) child.kill();
+    await new Promise<void>((resolve, reject) => listener.close((error) => error ? reject(error) : resolve()));
+    fence.release();
+    fs.rmSync(sandbox, { recursive: true, force: true });
+  }
+}, 10_000);
+
+test("the CLI names a missing Bun prerequisite before starting the Viewer", async () => {
+  const sandbox = fs.mkdtempSync(path.join(os.tmpdir(), "llv-runtime-missing-bun-"));
+  const nodeSearchPath = (process.env.PATH ?? "")
+    .split(path.delimiter)
+    .filter((directory) => !path.basename(directory).startsWith("bun-node-"))
+    .join(path.delimiter);
+  const nodeExecutable = Bun.which("node", { PATH: nodeSearchPath });
+  if (!nodeExecutable) throw new Error("the launcher prerequisite test requires Node");
+  const environment: Record<string, string | undefined> = {
+    ...process.env,
+    PATH: nodeSearchPath,
+    HOME: path.join(sandbox, "home"),
+    XDG_CONFIG_HOME: path.join(sandbox, "config"),
+    LLV_STATE_DIR: path.join(sandbox, "state"),
+    TMPDIR: path.join(sandbox, "tmp"),
+    LLV_BUN_EXECUTABLE: path.join(sandbox, "missing-bun"),
+  };
+  delete environment.LLV_RUNTIME_HOST_SOCKET;
+  const child = Bun.spawn([
+    nodeExecutable,
+    path.join(import.meta.dir, "cli.mjs"),
+    "--no-open",
+    "--port",
+    String(await availablePort()),
+  ], { cwd: path.resolve(import.meta.dir, ".."), env: environment, stdout: "pipe", stderr: "pipe" });
+  try {
+    const [exitCode, stderr] = await Promise.all([child.exited, new Response(child.stderr).text()]);
+    expect(exitCode).toBe(1);
+    expect(stderr).toContain("Couldn't start the structured runtime host");
+    expect(stderr).toContain("Bun executable");
+    expect(stderr).toContain("is unavailable");
+  } finally {
+    fs.rmSync(sandbox, { recursive: true, force: true });
+  }
+}, 10_000);
+
 test("structured hosts select Bun for a CLI process launched by Node", () => {
   expect(viewerServerBunRuntime({
     env: { LLV_STRUCTURED_HOSTS: "1" },