@stigmer/cli 3.35.0 → 3.36.0

package/src/local/daemon/daemon.integration.test.ts

@@ -1,216 +0,0 @@
-import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
-import { createServer, type Server } from "node:net";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import type { Logger } from "../../logger.js";
-import { RUNNER_READY_MARKER, SERVER_PORT } from "../constants.js";
-import { isProcessAlive } from "../state/proc.js";
-import { loadHealthState, type HealthState } from "../state/health-state.js";
-import { readPidFile } from "../state/pidfile.js";
-import type { DaemonConfig } from "./env.js";
-import { NodeProcessHost } from "./host.js";
-import { runInternalDaemon, type TemporalControl } from "./process.js";
-import type { ChildHandle, Clock, ExitInfo, ProcessHost, SpawnRequest } from "./types.js";
-
-const silent: Logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-
-function tempDir(): string {
-  return mkdtempSync(join(tmpdir(), "stigmer-int-"));
-}
-
-// ---- Integration 1: the real ProcessHost spawns, tees logs, detects the
-// readiness marker, and stops a real child. ----
-describe("NodeProcessHost (real spawn)", () => {
-  it("pipes logs, detects the readiness marker, and stops the child", async () => {
-    const dir = tempDir();
-    const script = join(dir, "fake-child.cjs");
-    writeFileSync(
-      script,
-      `process.stdout.write(${JSON.stringify(`${RUNNER_READY_MARKER}\n`)});\n` +
-        `process.on("SIGTERM", () => process.exit(0));\n` +
-        `setInterval(() => {}, 1000);\n`,
-    );
-    const logFile = join(dir, "child.log");
-
-    const host = new NodeProcessHost();
-    const request: SpawnRequest = {
-      name: "runner",
-      command: process.execPath,
-      args: [script],
-      env: process.env,
-      logFile,
-      readinessMarker: RUNNER_READY_MARKER,
-    };
-    const handle = host.spawn(request);
-
-    const ready = new Promise<void>((resolve) => handle.onReady(resolve));
-    const exited = new Promise<void>((resolve) => handle.onExit(() => resolve()));
-
-    await ready;
-    expect(isProcessAlive(handle.pid)).toBe(true);
-    // The readiness marker is detected on the stdout stream, but the tee to the
-    // log file is a buffered write that may not have flushed to disk yet — poll
-    // the file rather than reading it once to avoid a race.
-    await expect.poll(() => readFileSync(logFile, "utf8")).toContain(RUNNER_READY_MARKER);
-
-    handle.kill("SIGTERM");
-    await exited;
-    expect(handle.hasExited()).toBe(true);
-  });
-
-  // The foreground launcher's window into the children: every complete line,
-  // tagged with the component, in order within a stream; a partial trailing
-  // line is delivered at exit; the log file still receives the same bytes.
-  it("mirrors complete lines tagged with the component, flushing the tail at exit", async () => {
-    const dir = tempDir();
-    const script = join(dir, "chatty-child.cjs");
-    writeFileSync(
-      script,
-      // Two writes that split a line across chunks, one stderr line, and a
-      // final line with no newline.
-      `process.stdout.write("first li");\n` +
-        `process.stdout.write("ne\\nsecond line\\n");\n` +
-        `process.stderr.write("a warning\\n");\n` +
-        `process.stdout.write("tail without newline");\n` +
-        `setTimeout(() => process.exit(0), 50);\n`,
-    );
-    const logFile = join(dir, "child.log");
-    const mirrored: string[] = [];
-    const host = new NodeProcessHost({ mirror: (component, line) => mirrored.push(`${component}|${line}`) });
-
-    const handle = host.spawn({ name: "stigmer-server", command: process.execPath, args: [script], env: process.env, logFile });
-    await new Promise<void>((resolve) => handle.onExit(() => resolve()));
-
-    expect(mirrored.filter((l) => l !== "stigmer-server|a warning")).toEqual([
-      "stigmer-server|first line",
-      "stigmer-server|second line",
-      "stigmer-server|tail without newline",
-    ]);
-    expect(mirrored).toContain("stigmer-server|a warning");
-    await expect.poll(() => readFileSync(logFile, "utf8")).toContain("first line\nsecond line\n");
-  });
-});
-
-// ---- Integration 2: the full daemon body, with a fake process host + fake
-// Temporal, but a real TCP listener satisfying the server's gRPC gate. ----
-
-// Minimal fake host whose children exit on SIGTERM.
-class FakeHost implements ProcessHost {
-  private nextPid = 2000;
-  readonly killed: NodeJS.Signals[] = [];
-  spawn(_request: SpawnRequest): ChildHandle {
-    let exited = false;
-    let exitCb: ((info: ExitInfo) => void) | null = null;
-    const pid = this.nextPid++;
-    return {
-      pid,
-      hasExited: () => exited,
-      onExit: (cb) => {
-        exitCb = cb;
-      },
-      onReady: () => {},
-      kill: (signal) => {
-        this.killed.push(signal);
-        if (!exited) {
-          exited = true;
-          exitCb?.({ code: null, signal });
-        }
-      },
-    };
-  }
-}
-
-const fastClock: Clock = { now: () => Date.now(), sleep: () => Promise.resolve() };
-
-function fakeTemporal(): TemporalControl {
-  return {
-    address: "127.0.0.1:7233",
-    start: vi.fn(async () => {}),
-    stop: vi.fn(async () => {}),
-    isRunning: vi.fn(async () => true),
-    getPid: () => 4242,
-    startSupervisor: vi.fn(),
-    stopSupervisor: vi.fn(),
-  };
-}
-
-function listenOn(port: number): Promise<Server> {
-  return new Promise((resolve, reject) => {
-    const server = createServer();
-    server.once("error", reject);
-    server.listen(port, "127.0.0.1", () => resolve(server));
-  });
-}
-
-let gateServer: Server | null = null;
-afterEach(async () => {
-  if (gateServer !== null) {
-    await new Promise<void>((resolve) => gateServer?.close(() => resolve()));
-    gateServer = null;
-  }
-});
-
-describe("runInternalDaemon (full body with fakes)", () => {
-  it("brings the stack up, writes a health snapshot, and tears down on shutdown", async () => {
-    const data = join(tempDir(), ".stigmer", "data");
-    const config: DaemonConfig = {
-      dataDir: data,
-      logDir: join(data, "logs"),
-      temporalManaged: true,
-      temporalAddress: "127.0.0.1:7233",
-      serverOnly: false,
-      noWeb: true,
-      server: { nodeBin: "node-cmd", entryPath: join(data, "server-entry.js"), appDir: data },
-      runner: { nodeBin: "node-cmd", entryPath: join(data, "entry.js"), appDir: data },
-    };
-
-    // Satisfy the server's gRPC readiness gate with a real listener.
-    try {
-      gateServer = await listenOn(SERVER_PORT);
-    } catch {
-      // Port busy (a real daemon?) — the gate will still connect to whatever is
-      // listening, which is all this test needs.
-    }
-
-    const host = new FakeHost();
-    const temporal = fakeTemporal();
-    const healthPath = join(data, "health-state.json");
-
-    let snapshot: HealthState | null = null;
-    let resolveShutdown!: () => void;
-    const shutdown = new Promise<void>((resolve) => {
-      resolveShutdown = resolve;
-    });
-
-    const code = await runInternalDaemon({
-      config,
-      host,
-      clock: fastClock,
-      temporal,
-      log: silent,
-      waitForShutdown: () => shutdown,
-      onStarted: () => {
-        snapshot = loadHealthState(healthPath);
-        resolveShutdown();
-      },
-    });
-
-    expect(code).toBe(0);
-    expect(temporal.start).toHaveBeenCalledOnce();
-    expect(temporal.stop).toHaveBeenCalledOnce();
-
-    // The snapshot captured while up shows the whole stack.
-    expect(snapshot).not.toBeNull();
-    const components = snapshot as unknown as HealthState;
-    expect(components.daemon_pid).toBe(process.pid);
-    expect(Object.keys(components.components).sort()).toEqual(["runner", "stigmer-server", "temporal", "web-console"]);
-    expect(components.components["stigmer-server"].state).toBe("running");
-    expect(components.components.runner.state).toBe("running");
-
-    // Children were signaled, and the daemon cleaned up after shutdown.
-    expect(host.killed).toContain("SIGTERM");
-    expect(readPidFile(join(data, "daemon.pid"))).toBeNull();
-    expect(loadHealthState(healthPath)).toBeNull();
-  });
-});

package/src/local/daemon/env.test.ts

@@ -1,108 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildDaemonEnv, type DaemonEnvInputs, readDaemonConfig } from "./env.js";
-
-const baseInputs: DaemonEnvInputs = {
-  dataDir: "/home/u/.stigmer/data",
-  logDir: "/home/u/.stigmer/data/logs",
-  temporalManaged: true,
-  temporalAddress: "127.0.0.1:7233",
-  serverOnly: false,
-  noWeb: false,
-  server: {
-    nodeBin: "/usr/bin/node",
-    entryPath: "/repo/server/dist/main.js",
-    appDir: "/repo/server",
-  },
-  runner: { nodeBin: "/usr/bin/node", entryPath: "/repo/runner/dist/main.js", appDir: "/repo/runner" },
-};
-
-describe("buildDaemonEnv + readDaemonConfig", () => {
-  it("round-trips the full launcher -> daemon contract", () => {
-    const env = buildDaemonEnv(baseInputs, {});
-    const config = readDaemonConfig(env);
-    expect(config).toEqual({
-      dataDir: "/home/u/.stigmer/data",
-      logDir: "/home/u/.stigmer/data/logs",
-      temporalManaged: true,
-      temporalAddress: "127.0.0.1:7233",
-      serverOnly: false,
-      noWeb: false,
-      server: {
-        nodeBin: "/usr/bin/node",
-        entryPath: "/repo/server/dist/main.js",
-        appDir: "/repo/server",
-      },
-      runner: { nodeBin: "/usr/bin/node", entryPath: "/repo/runner/dist/main.js", appDir: "/repo/runner" },
-      cursorApiKey: undefined,
-      anthropicApiKey: undefined,
-      activityRouting: undefined,
-      operatorEmail: undefined,
-      operatorName: undefined,
-    });
-  });
-
-  it("omits runner coordinates in server-only mode", () => {
-    const env = buildDaemonEnv({ ...baseInputs, serverOnly: true }, {});
-    const config = readDaemonConfig(env);
-    expect(config.serverOnly).toBe(true);
-    expect(config.runner).toBeUndefined();
-  });
-
-  it("passes CURSOR_API_KEY and activity routing through from the base env", () => {
-    const env = buildDaemonEnv(baseInputs, { CURSOR_API_KEY: "ck", STIGMER_ACTIVITY_ROUTING: "session" });
-    const config = readDaemonConfig(env);
-    expect(config.cursorApiKey).toBe("ck");
-    expect(config.activityRouting).toBe("session");
-  });
-
-  // The config-file-only delivery path: a key from `stigmer setup` is not in the
-  // shell env, so the launcher must write it into the contract explicitly.
-  // Anthropic is the only provider with this path — the local stack executes
-  // on Anthropic only.
-  it("delivers a launcher-resolved Anthropic key with no help from the base env", () => {
-    const env = buildDaemonEnv({ ...baseInputs, anthropicApiKey: "sk-ant-cfg" }, {});
-    const config = readDaemonConfig(env);
-    expect(config.anthropicApiKey).toBe("sk-ant-cfg");
-  });
-
-  it("passes a shell-exported Anthropic key through from the base env", () => {
-    const env = buildDaemonEnv(baseInputs, { ANTHROPIC_API_KEY: "sk-ant-env" });
-    const config = readDaemonConfig(env);
-    expect(config.anthropicApiKey).toBe("sk-ant-env");
-  });
-
-  // The operator identity rides the same config-file-only delivery path as the
-  // Anthropic key (oss#796): persisted by `stigmer setup`, absent from the
-  // shell, written into the contract explicitly by the launcher.
-  it("delivers a launcher-resolved operator identity with no help from the base env", () => {
-    const env = buildDaemonEnv(
-      { ...baseInputs, operatorEmail: "ada@example.com", operatorName: "Ada Lovelace" },
-      {},
-    );
-    const config = readDaemonConfig(env);
-    expect(config.operatorEmail).toBe("ada@example.com");
-    expect(config.operatorName).toBe("Ada Lovelace");
-  });
-
-  it("passes a shell-exported operator identity through from the base env", () => {
-    const env = buildDaemonEnv(baseInputs, { STIGMER_OPERATOR_EMAIL: "env@example.com" });
-    expect(readDaemonConfig(env).operatorEmail).toBe("env@example.com");
-    expect(readDaemonConfig(env).operatorName).toBeUndefined();
-  });
-
-  // Other provider keys have no contract slot; they reach the runner solely via
-  // shell-env inheritance (the child env spreads the base env).
-  it("leaves shell-exported non-Anthropic keys in the env without parsing them", () => {
-    const env = buildDaemonEnv(baseInputs, { OPENAI_API_KEY: "sk-oai-env" });
-    expect(env.OPENAI_API_KEY).toBe("sk-oai-env");
-    expect(readDaemonConfig(env)).not.toHaveProperty("openaiApiKey");
-  });
-
-  it("requires the data dir and the full server launch triple", () => {
-    expect(() => readDaemonConfig({})).toThrow(/STIGMER_DATA_DIR/);
-    expect(() => readDaemonConfig({ STIGMER_DATA_DIR: "/x" })).toThrow(/STIGMER_SERVER_NODE_BIN/);
-    expect(() => readDaemonConfig({ STIGMER_DATA_DIR: "/x", STIGMER_SERVER_NODE_BIN: "/usr/bin/node" })).toThrow(
-      /STIGMER_SERVER_ENTRY/,
-    );
-  });
-});

package/src/local/daemon/launch.test.ts

@@ -1,136 +0,0 @@
-// Pins the foreground launcher's contract with the daemon body: the config it
-// hands over is the detached shape's, encoded through the same env contract;
-// the children inherit that built environment; the post-readiness work (the
-// bootstrap, the startup record, the caller's onReady) runs from onStarted;
-// the daemon's exit code is the launcher's. Resolution is driven through the
-// same overrides a container sets (STIGMER_SERVER_DIR, STIGMER_RUNNER_DIR,
-// STIGMER_TEMPORAL_BIN), so nothing is downloaded or installed.
-
-import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { SERVER_PORT } from "../constants.js";
-import { tcpConnects } from "../net/tcp.js";
-import { loadStartupConfig } from "../state/startup-config.js";
-import { DaemonEnvVar } from "./env.js";
-import { upForeground } from "./launch.js";
-import type { InternalDaemonDeps } from "./process.js";
-
-// The launcher refuses to start beside a stack already serving on the server
-// port — including a developer's own `stigmer up`. Report SKIPPED rather than
-// a false failure in that case.
-const serverPortBusy = await tcpConnects(SERVER_PORT, "127.0.0.1", 300);
-
-function tempDir(prefix: string): string {
-  return mkdtempSync(join(tmpdir(), prefix));
-}
-
-// A built package in the shape the resolvers accept: package.json + dist/main.js.
-function builtPackage(prefix: string): string {
-  const dir = tempDir(prefix);
-  writeFileSync(join(dir, "package.json"), "{}");
-  mkdirSync(join(dir, "dist"));
-  writeFileSync(join(dir, "dist", "main.js"), "//");
-  return dir;
-}
-
-const TOUCHED = ["STIGMER_SERVER_DIR", "STIGMER_RUNNER_DIR", "STIGMER_TEMPORAL_BIN", "STIGMER_NODE_BIN", "ANTHROPIC_API_KEY"] as const;
-let saved: Record<string, string | undefined>;
-
-beforeEach(() => {
-  saved = {};
-  for (const key of TOUCHED) {
-    saved[key] = process.env[key];
-    delete process.env[key];
-  }
-  process.env.STIGMER_SERVER_DIR = builtPackage("stigmer-fg-server-");
-  process.env.STIGMER_RUNNER_DIR = builtPackage("stigmer-fg-runner-");
-  const temporalBin = join(tempDir("stigmer-fg-temporal-"), "temporal");
-  writeFileSync(temporalBin, "#!/bin/sh\n");
-  process.env.STIGMER_TEMPORAL_BIN = temporalBin;
-});
-
-afterEach(() => {
-  for (const key of TOUCHED) {
-    if (saved[key] === undefined) delete process.env[key];
-    else process.env[key] = saved[key];
-  }
-});
-
-describe.skipIf(serverPortBusy)("upForeground", () => {
-  it("runs the daemon body in-process with the detached shape's config and env, bootstrapping from onStarted", async () => {
-    const home = tempDir("stigmer-fg-home-");
-    process.env.ANTHROPIC_API_KEY = "sk-test";
-    const order: string[] = [];
-    let captured: InternalDaemonDeps | null = null;
-
-    const code = await upForeground({ noWeb: true }, home, {
-      runDaemon: async (deps) => {
-        captured = deps;
-        order.push("daemon:started");
-        await deps.onStarted?.();
-        order.push("daemon:waiting");
-        return 0;
-      },
-      bootstrap: async () => {
-        order.push("bootstrap");
-      },
-      onReady: () => {
-        order.push("onReady");
-      },
-      waitForShutdown: () => Promise.resolve(),
-    });
-
-    expect(code).toBe(0);
-    expect(order).toEqual(["daemon:started", "bootstrap", "onReady", "daemon:waiting"]);
-
-    const deps = captured as unknown as InternalDaemonDeps;
-    // The config is the env contract read back — the detached daemon's view.
-    expect(deps.config?.dataDir).toBe(join(home, ".stigmer", "data"));
-    expect(deps.config?.temporalManaged).toBe(true);
-    expect(deps.config?.noWeb).toBe(true);
-    expect(deps.config?.server.entryPath).toBe(join(process.env.STIGMER_SERVER_DIR!, "dist", "main.js"));
-    expect(deps.config?.runner?.entryPath).toBe(join(process.env.STIGMER_RUNNER_DIR!, "dist", "main.js"));
-    expect(deps.config?.anthropicApiKey).toBe("sk-test");
-    // The children inherit the built environment, contract variables included.
-    expect(deps.env?.[DaemonEnvVar.DataDir]).toBe(join(home, ".stigmer", "data"));
-    expect(deps.env?.[DaemonEnvVar.ServerEntry]).toBe(deps.config?.server.entryPath);
-    // The startup record names this process as the daemon.
-    expect(loadStartupConfig(join(home, ".stigmer", "data"))?.stigmer_server_pid).toBe(process.pid);
-  });
-
-  it("propagates the daemon's failure exit code without bootstrapping", async () => {
-    const home = tempDir("stigmer-fg-home-");
-    const bootstrap = vi.fn(async () => {});
-
-    const code = await upForeground({}, home, {
-      // A critical component failed to start: the body returns 1 before onStarted.
-      runDaemon: async () => 1,
-      bootstrap,
-      waitForShutdown: () => Promise.resolve(),
-    });
-
-    expect(code).toBe(1);
-    expect(bootstrap).not.toHaveBeenCalled();
-    expect(loadStartupConfig(join(home, ".stigmer", "data"))).toBeNull();
-  });
-
-  it("omits the runner from the contract in server-only mode", async () => {
-    const home = tempDir("stigmer-fg-home-");
-    let captured: InternalDaemonDeps | null = null;
-
-    await upForeground({ serverOnly: true }, home, {
-      runDaemon: async (deps) => {
-        captured = deps;
-        return 0;
-      },
-      bootstrap: async () => {},
-      waitForShutdown: () => Promise.resolve(),
-    });
-
-    const deps = captured as unknown as InternalDaemonDeps;
-    expect(deps.config?.serverOnly).toBe(true);
-    expect(deps.config?.runner).toBeUndefined();
-  });
-});