@stigmer/cli 3.35.0 → 3.37.0

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

@@ -1,260 +0,0 @@
-import { mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { Logger } from "../../logger.js";
-import type { HealthState } from "../state/health-state.js";
-import { readPidFile } from "../state/pidfile.js";
-import { MAX_RESTARTS, ProcessSupervisor } from "./supervisor.js";
-import type { ChildHandle, Clock, ComponentSpec, ExitInfo, ProcessHost, ReadinessGate, SpawnRequest } from "./types.js";
-
-const silent: Logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-
-// A controllable fake child: the test triggers its exit/readiness and inspects
-// the signals it received.
-interface FakeChild {
-  request: SpawnRequest;
-  handle: ChildHandle;
-  signals: NodeJS.Signals[];
-  termExits: boolean;
-  triggerExit(info?: ExitInfo): void;
-  triggerReady(): void;
-}
-
-class FakeHost implements ProcessHost {
-  readonly children: FakeChild[] = [];
-  readonly killOrder: string[] = [];
-  private nextPid = 1000;
-
-  spawn(request: SpawnRequest): ChildHandle {
-    let exited = false;
-    let exitCb: ((info: ExitInfo) => void) | null = null;
-    let readyCb: (() => void) | null = null;
-    const signals: NodeJS.Signals[] = [];
-    const pid = this.nextPid++;
-    const order = this.killOrder;
-
-    const child: FakeChild = {
-      request,
-      signals,
-      termExits: true,
-      triggerExit: (info = { code: 1, signal: null }) => {
-        if (!exited) {
-          exited = true;
-          exitCb?.(info);
-        }
-      },
-      triggerReady: () => readyCb?.(),
-      handle: {
-        pid,
-        hasExited: () => exited,
-        onExit: (cb) => {
-          exitCb = cb;
-        },
-        onReady: (cb) => {
-          readyCb = cb;
-        },
-        kill: (signal) => {
-          signals.push(signal);
-          order.push(request.command);
-          if (signal === "SIGKILL" || (signal === "SIGTERM" && child.termExits)) {
-            if (!exited) {
-              exited = true;
-              exitCb?.({ code: null, signal });
-            }
-          }
-        },
-      },
-    };
-    this.children.push(child);
-    return child.handle;
-  }
-
-  /** The most-recently-spawned child for a component command. */
-  latest(command: string): FakeChild {
-    const matches = this.children.filter((c) => c.request.command === command);
-    return matches[matches.length - 1];
-  }
-
-  countOf(command: string): number {
-    return this.children.filter((c) => c.request.command === command).length;
-  }
-}
-
-class FakeClock implements Clock {
-  t = 1_000_000;
-  now(): number {
-    return this.t;
-  }
-  sleep(): Promise<void> {
-    return Promise.resolve();
-  }
-}
-
-const okGate: ReadinessGate = { description: "ok", wait: async () => {} };
-const failGate: ReadinessGate = {
-  description: "fail",
-  wait: async () => {
-    throw new Error("did not become ready");
-  },
-};
-
-let dir: string;
-beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), "stigmer-sup-"));
-});
-
-function spec(name: string, opts: { critical?: boolean; marker?: string; gate?: ReadinessGate } = {}): ComponentSpec {
-  return {
-    name,
-    pidFile: join(dir, `${name}.pid`),
-    critical: opts.critical ?? false,
-    resolve: () => ({ name, command: name, args: [], env: {}, logFile: join(dir, `${name}.log`), readinessMarker: opts.marker }),
-    gate: opts.gate,
-  };
-}
-
-function emptyHealth(): HealthState {
-  return { daemon_pid: 1, started_at: "", components: {} };
-}
-
-function makeSupervisor(
-  specs: ComponentSpec[],
-  extras: { probe?: (port: number) => Promise<boolean> } = {},
-): { sup: ProcessSupervisor; host: FakeHost; clock: FakeClock; hs: HealthState } {
-  const host = new FakeHost();
-  const clock = new FakeClock();
-  const hs = emptyHealth();
-  const sup = new ProcessSupervisor(specs, { host, clock, healthState: hs, persist: () => {}, log: silent, probe: extras.probe });
-  return { sup, host, clock, hs };
-}
-
-describe("startAll", () => {
-  it("starts components in order, writes PID files, and gates the server", async () => {
-    const { sup, host, hs } = makeSupervisor([spec("stigmer-server", { critical: true, gate: okGate }), spec("runner", { marker: "ready" })]);
-    const result = await sup.startAll();
-
-    expect(result.ok).toBe(true);
-    expect(hs.components["stigmer-server"].state).toBe("running");
-    expect(hs.components.runner.state).toBe("running");
-    expect(readPidFile(join(dir, "stigmer-server.pid"))).toBe(host.latest("stigmer-server").handle.pid);
-    expect(readPidFile(join(dir, "runner.pid"))).toBe(host.latest("runner").handle.pid);
-  });
-
-  it("aborts when a critical component fails its gate", async () => {
-    const { sup, hs } = makeSupervisor([spec("stigmer-server", { critical: true, gate: failGate }), spec("runner")]);
-    const result = await sup.startAll();
-
-    expect(result.ok).toBe(false);
-    expect(result.failedCritical).toBe("stigmer-server");
-    expect(hs.components["stigmer-server"].state).toBe("failed");
-    // The runner is registered up front but never started after the abort.
-    expect(hs.components.runner.state).toBe("stopped");
-  });
-});
-
-describe("readiness marker", () => {
-  it("flips ready false -> true when the child announces it", async () => {
-    const { sup, host, hs } = makeSupervisor([spec("runner", { marker: "ready" })]);
-    await sup.startAll();
-    expect(hs.components.runner.ready).toBe(false);
-    host.latest("runner").triggerReady();
-    expect(hs.components.runner.ready).toBe(true);
-  });
-});
-
-describe("settleCheck", () => {
-  it("marks a component that crashed during startup as failed", async () => {
-    const { sup, host, hs } = makeSupervisor([spec("runner")]);
-    await sup.startAll();
-    host.latest("runner").triggerExit();
-    sup.settleCheck();
-    expect(hs.components.runner.state).toBe("failed");
-    expect(hs.components.runner.last_error).toMatch(/crashed during startup/);
-  });
-});
-
-describe("restart policy", () => {
-  it("restarts a crashed component that ran longer than the rapid-crash window", async () => {
-    const { sup, host, clock, hs } = makeSupervisor([spec("runner")]);
-    await sup.startAll();
-    clock.t += 10_000; // 10s uptime
-    host.latest("runner").triggerExit();
-    await sup.tick();
-
-    expect(hs.components.runner.restart_count).toBe(1);
-    expect(hs.components.runner.state).toBe("running");
-    expect(host.countOf("runner")).toBe(2);
-  });
-
-  it("marks a rapid-crashing component failed without retry", async () => {
-    const { sup, host, clock, hs } = makeSupervisor([spec("runner")]);
-    await sup.startAll();
-    clock.t += 1_000; // 1s uptime — inside the rapid-crash window
-    host.latest("runner").triggerExit();
-    await sup.tick();
-
-    expect(hs.components.runner.state).toBe("failed");
-    expect(host.countOf("runner")).toBe(1); // not respawned
-  });
-
-  it("stops retrying after the max-restart ceiling", async () => {
-    const { sup, host, clock, hs } = makeSupervisor([spec("runner")]);
-    await sup.startAll();
-    hs.components.runner.restart_count = MAX_RESTARTS;
-    clock.t += 10_000;
-    host.latest("runner").triggerExit();
-    await sup.tick();
-
-    expect(hs.components.runner.state).toBe("failed");
-    expect(hs.components.runner.last_error).toMatch(/max restarts/);
-    expect(host.countOf("runner")).toBe(1);
-  });
-});
-
-describe("server health probe", () => {
-  it("escalates to kill+restart after the unhealthy threshold, then recovers", async () => {
-    let healthy = false;
-    const { sup, host, clock, hs } = makeSupervisor([spec("stigmer-server", { critical: true, gate: okGate })], {
-      probe: async () => healthy,
-    });
-    await sup.startAll();
-    clock.t += 10_000;
-
-    await sup.tick(); // 1 unhealthy
-    await sup.tick(); // 2 unhealthy
-    expect(hs.components["stigmer-server"].state).toBe("unhealthy");
-    await sup.tick(); // 3 -> kill + restart
-
-    expect(hs.components["stigmer-server"].restart_count).toBe(1);
-    expect(host.countOf("stigmer-server")).toBe(2);
-
-    healthy = true;
-    await sup.tick();
-    expect(hs.components["stigmer-server"].state).toBe("running");
-  });
-});
-
-describe("shutdown", () => {
-  it("stops components in reverse order, removing PID files", async () => {
-    const { sup, host, hs } = makeSupervisor([spec("stigmer-server", { critical: true, gate: okGate }), spec("runner")]);
-    await sup.startAll();
-    await sup.shutdown();
-
-    expect(host.killOrder).toEqual(["runner", "stigmer-server"]);
-    expect(hs.components.runner.state).toBe("stopped");
-    expect(hs.components["stigmer-server"].state).toBe("stopped");
-    expect(readPidFile(join(dir, "runner.pid"))).toBeNull();
-    expect(readPidFile(join(dir, "stigmer-server.pid"))).toBeNull();
-  });
-
-  it("escalates to SIGKILL when a child ignores SIGTERM", async () => {
-    const { sup, host } = makeSupervisor([spec("runner")]);
-    await sup.startAll();
-    host.latest("runner").termExits = false; // ignores SIGTERM
-    await sup.shutdown();
-
-    expect(host.latest("runner").signals).toContain("SIGTERM");
-    expect(host.latest("runner").signals).toContain("SIGKILL");
-  });
-});

package/src/local/llm-config.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { Config } from "../config/config.js";
-import {
-  detectProviderFromEnv,
-  readLlm,
-  resolveApiKey,
-  resolveProvider,
-  setLlm,
-} from "./llm-config.js";
-
-function config(local?: unknown): Config {
-  return { backend: { type: "local", local } };
-}
-
-describe("detectProviderFromEnv", () => {
-  it("detects Anthropic only — the sole provider local execution supports", () => {
-    expect(detectProviderFromEnv({ ANTHROPIC_API_KEY: "a" })).toBe("anthropic");
-    // Other provider keys in the shell must not flip the local story.
-    expect(detectProviderFromEnv({ OPENAI_API_KEY: "b" })).toBe("");
-    expect(detectProviderFromEnv({})).toBe("");
-  });
-});
-
-describe("resolveProvider", () => {
-  it("honors env override > config > autodetect", () => {
-    const cfg = config({ llm: { provider: "anthropic" } });
-    expect(resolveProvider(cfg, { STIGMER_LLM_PROVIDER: "other" })).toBe("other");
-    expect(resolveProvider(cfg, {})).toBe("anthropic");
-    expect(resolveProvider(config(), { ANTHROPIC_API_KEY: "x" })).toBe("anthropic");
-    expect(resolveProvider(config(), {})).toBe("");
-  });
-});
-
-describe("resolveApiKey", () => {
-  it("uses ANTHROPIC_API_KEY, then config", () => {
-    const cfg = config({ llm: { provider: "anthropic", api_key: "cfgkey" } });
-    expect(resolveApiKey(cfg, { ANTHROPIC_API_KEY: "envkey" })).toBe("envkey");
-    expect(resolveApiKey(cfg, {})).toBe("cfgkey");
-  });
-
-  it("returns empty for non-anthropic providers (e.g. hand-edited config)", () => {
-    expect(resolveApiKey(config({ llm: { provider: "other", api_key: "k" } }), {})).toBe("");
-  });
-});
-
-describe("setLlm", () => {
-  it("preserves sibling local keys and can clear the section", () => {
-    const cfg = config({ temporal: { managed: true }, llm: { provider: "anthropic" } });
-    const updated = setLlm(cfg, { provider: "anthropic", api_key: "k" });
-    expect(readLlm(updated)).toEqual({ provider: "anthropic", api_key: "k" });
-    expect((updated.backend.local as { temporal: unknown }).temporal).toEqual({ managed: true });
-
-    const cleared = setLlm(cfg, undefined);
-    expect(readLlm(cleared)).toBeUndefined();
-    expect((cleared.backend.local as { temporal: unknown }).temporal).toEqual({ managed: true });
-  });
-
-  it("replaces the section wholesale — a stale model key from a pre-oss#314 config does not survive a rewrite", () => {
-    // The graceful-migration contract: old configs may carry llm.model (the
-    // removed dead pin). Reads ignore it (LlmSettings no longer models it);
-    // the next setup write clears it because setLlm never merges.
-    const cfg = config({ llm: { provider: "anthropic", model: "stale-pin", api_key: "k" } });
-    const rewritten = setLlm(cfg, { provider: "anthropic", api_key: "k" });
-    expect(readLlm(rewritten)).toEqual({ provider: "anthropic", api_key: "k" });
-  });
-});

package/src/local/logs/tail.test.ts

@@ -1,70 +0,0 @@
-import { appendFileSync, mkdtempSync, renameSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { followFile, tailLines } from "./tail.js";
-
-let dir: string;
-beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), "stigmer-tail-"));
-});
-
-describe("tailLines", () => {
-  it("returns the last n lines, ignoring a trailing newline", () => {
-    const file = join(dir, "a.log");
-    writeFileSync(file, "l1\nl2\nl3\nl4\n");
-    expect(tailLines(file, 2)).toEqual(["l3", "l4"]);
-    expect(tailLines(file, 0)).toEqual(["l1", "l2", "l3", "l4"]);
-    expect(tailLines(file, 10)).toEqual(["l1", "l2", "l3", "l4"]);
-  });
-
-  it("returns empty for a missing file", () => {
-    expect(tailLines(join(dir, "nope.log"), 5)).toEqual([]);
-  });
-});
-
-describe("followFile", () => {
-  const tick = () => vi.advanceTimersByTimeAsync(250);
-
-  beforeEach(() => {
-    vi.useFakeTimers();
-    return () => vi.useRealTimers();
-  });
-
-  it("emits only newly appended lines", async () => {
-    const file = join(dir, "f.log");
-    writeFileSync(file, "old\n");
-    const seen: string[] = [];
-    const handle = followFile(file, (line) => seen.push(line), { pollMs: 200 });
-
-    appendFileSync(file, "new1\nnew2\n");
-    await tick();
-    expect(seen).toEqual(["new1", "new2"]);
-    handle.stop();
-  });
-
-  it("reopens after rotation (inode change)", async () => {
-    const file = join(dir, "r.log");
-    writeFileSync(file, "before\n");
-    const seen: string[] = [];
-    const handle = followFile(file, (line) => seen.push(line), { pollMs: 200 });
-
-    // Rotate: move the file aside and create a fresh one in its place.
-    renameSync(file, join(dir, "r.log.1"));
-    writeFileSync(file, "after-rotate\n");
-    await tick();
-
-    expect(seen).toContain("after-rotate");
-    handle.stop();
-  });
-
-  it("with fromStart, emits existing content too", async () => {
-    const file = join(dir, "s.log");
-    writeFileSync(file, "existing\n");
-    const seen: string[] = [];
-    const handle = followFile(file, (line) => seen.push(line), { pollMs: 200, fromStart: true });
-    await tick();
-    expect(seen).toContain("existing");
-    handle.stop();
-  });
-});

package/src/local/logs/view.test.ts

@@ -1,46 +0,0 @@
-import { mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { beforeEach, describe, expect, it } from "vitest";
-import { allComponents, componentByName, printTail } from "./view.js";
-
-let dir: string;
-beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), "stigmer-logsview-"));
-});
-
-class CaptureSink {
-  chunks: string[] = [];
-  write(chunk: string): void {
-    this.chunks.push(chunk);
-  }
-  get text(): string {
-    return this.chunks.join("");
-  }
-}
-
-describe("componentByName / allComponents", () => {
-  it("knows the three daemon components", () => {
-    expect(allComponents(dir).map((c) => c.name)).toEqual(["stigmer-server", "runner", "temporal"]);
-    expect(componentByName(dir, "runner")?.file).toBe(join(dir, "runner.log"));
-    expect(componentByName(dir, "bogus")).toBeUndefined();
-  });
-});
-
-describe("printTail", () => {
-  it("does not prefix a single component", () => {
-    writeFileSync(join(dir, "runner.log"), "r1\nr2\n");
-    const sink = new CaptureSink();
-    printTail([componentByName(dir, "runner")!], 5, sink);
-    expect(sink.text).toBe("r1\nr2\n");
-  });
-
-  it("prefixes lines with the component name when showing several", () => {
-    writeFileSync(join(dir, "stigmer-server.log"), "s1\n");
-    writeFileSync(join(dir, "runner.log"), "r1\n");
-    writeFileSync(join(dir, "temporal.log"), "t1\n");
-    const sink = new CaptureSink();
-    printTail(allComponents(dir), 5, sink);
-    expect(sink.text).toBe("[stigmer-server] s1\n[runner] r1\n[temporal] t1\n");
-  });
-});

package/src/local/operator-config.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { Config } from "../config/config.js";
-import {
-  readOperator,
-  resolveOperatorIdentity,
-  setOperator,
-  validateOperatorIdentity,
-} from "./operator-config.js";
-
-function config(local?: unknown): Config {
-  return { backend: { type: "local", local } };
-}
-
-describe("resolveOperatorIdentity", () => {
-  it("honors env > config, never mixing sources", () => {
-    const cfg = config({ operator: { email: "cfg@example.com", name: "Config Name" } });
-
-    // Env email brings the env name (or none) — the config name must not
-    // ride along under an env identity, that would be attribution lying.
-    expect(resolveOperatorIdentity(cfg, { STIGMER_OPERATOR_EMAIL: "env@example.com" })).toEqual({
-      email: "env@example.com",
-    });
-    expect(
-      resolveOperatorIdentity(cfg, {
-        STIGMER_OPERATOR_EMAIL: "env@example.com",
-        STIGMER_OPERATOR_NAME: "Env Name",
-      }),
-    ).toEqual({ email: "env@example.com", name: "Env Name" });
-
-    expect(resolveOperatorIdentity(cfg, {})).toEqual({
-      email: "cfg@example.com",
-      name: "Config Name",
-    });
-  });
-
-  it("returns undefined when neither source has an email — the anonymous default", () => {
-    expect(resolveOperatorIdentity(config(), {})).toBeUndefined();
-    expect(resolveOperatorIdentity(config({ operator: {} }), {})).toBeUndefined();
-    // Whitespace-only values are unset, matching the server's TrimSpace.
-    expect(resolveOperatorIdentity(config(), { STIGMER_OPERATOR_EMAIL: "  " })).toBeUndefined();
-  });
-
-  it("trims values, matching the server's boot check", () => {
-    const cfg = config({ operator: { email: " ada@example.com ", name: " Ada " } });
-    expect(resolveOperatorIdentity(cfg, {})).toEqual({ email: "ada@example.com", name: "Ada" });
-  });
-});
-
-describe("validateOperatorIdentity", () => {
-  it("mirrors the server's boot rules: minimal @ check, name requires email", () => {
-    expect(validateOperatorIdentity("ada@example.com", "Ada")).toBeUndefined();
-    expect(validateOperatorIdentity("ada@example.com", "")).toBeUndefined();
-    expect(validateOperatorIdentity("", "")).toBeUndefined(); // "no identity" is valid
-
-    expect(validateOperatorIdentity("not-an-email", "")).toContain("missing '@'");
-    expect(validateOperatorIdentity("", "Ada")).toContain("set both or neither");
-  });
-});
-
-describe("setOperator", () => {
-  it("preserves sibling local keys and can clear the section", () => {
-    const cfg = config({ temporal: { managed: true }, llm: { provider: "anthropic" } });
-    const updated = setOperator(cfg, { email: "ada@example.com", name: "Ada" });
-    expect(readOperator(updated)).toEqual({ email: "ada@example.com", name: "Ada" });
-    expect((updated.backend.local as { temporal: unknown }).temporal).toEqual({ managed: true });
-    expect((updated.backend.local as { llm: unknown }).llm).toEqual({ provider: "anthropic" });
-
-    const cleared = setOperator(updated, undefined);
-    expect(readOperator(cleared)).toBeUndefined();
-    expect((cleared.backend.local as { temporal: unknown }).temporal).toEqual({ managed: true });
-  });
-});

package/src/local/reset.test.ts

@@ -1,53 +0,0 @@
-import { existsSync, mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { configPath } from "../config/paths.js";
-import { binDir, configDir, databasePath, dataDir, temporalDataDir } from "./paths.js";
-import { reset } from "./reset.js";
-
-let home: string;
-beforeEach(() => {
-  home = mkdtempSync(join(tmpdir(), "stigmer-reset-"));
-});
-
-function seedState(): void {
-  mkdirSync(dataDir(home), { recursive: true });
-  mkdirSync(temporalDataDir(home), { recursive: true });
-  mkdirSync(binDir(home), { recursive: true });
-  writeFileSync(databasePath(home), "db");
-  writeFileSync(`${databasePath(home)}-wal`, "wal");
-  writeFileSync(join(dataDir(home), "runner.pid"), "1");
-  writeFileSync(configPath(home), "backend:\n  type: local\n");
-}
-
-const noopStop = vi.fn(async () => true);
-
-describe("reset", () => {
-  it("wipes state but preserves config by default", async () => {
-    seedState();
-    const result = await reset({}, home, noopStop);
-
-    expect(result.servicesStopped).toBe(true);
-    expect(existsSync(dataDir(home))).toBe(false);
-    expect(existsSync(databasePath(home))).toBe(false);
-    expect(existsSync(`${databasePath(home)}-wal`)).toBe(false);
-    expect(existsSync(temporalDataDir(home))).toBe(false);
-    expect(existsSync(binDir(home))).toBe(false);
-    // Config is preserved.
-    expect(existsSync(configPath(home))).toBe(true);
-    expect(result.removedPaths).toContain(dataDir(home));
-  });
-
-  it("removes config when includeConfig is set", async () => {
-    seedState();
-    await reset({ includeConfig: true }, home, noopStop);
-    expect(existsSync(configPath(home))).toBe(false);
-  });
-
-  it("reports services not stopped when nothing was running", async () => {
-    mkdirSync(configDir(home), { recursive: true });
-    const result = await reset({}, home, vi.fn(async () => false));
-    expect(result.servicesStopped).toBe(false);
-  });
-});