@stigmer/cli 3.35.0 → 3.36.0

package/src/local/state/state.test.ts

@@ -1,210 +0,0 @@
-import { mkdtempSync, readFileSync, statSync, utimesSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, it } from "vitest";
-import { type HealthState, loadHealthState, writeHealthState } from "./health-state.js";
-import { acquireLock } from "./lock.js";
-import { cleanupOldLogs, rotateLogs } from "./log-rotation.js";
-import { readPidFile, removePidFile, writePidFile } from "./pidfile.js";
-import { isOtherLiveProcess, isProcessAlive } from "./proc.js";
-import { loadStartupConfig, removeStartupConfig, saveStartupConfig, type StartupConfig } from "./startup-config.js";
-
-function tempDir(prefix: string): string {
-  return mkdtempSync(join(tmpdir(), prefix));
-}
-
-// A PID that is exceedingly unlikely to belong to a live process.
-const DEAD_PID = 2 ** 31 - 1;
-
-describe("pidfile", () => {
-  it("writes, reads, and removes a PID", () => {
-    const path = join(tempDir("stigmer-pid-"), "daemon.pid");
-    writePidFile(path, 4321);
-    expect(readPidFile(path)).toBe(4321);
-    removePidFile(path);
-    expect(readPidFile(path)).toBeNull();
-  });
-
-  it("returns null for a missing file", () => {
-    expect(readPidFile(join(tempDir("stigmer-pid-"), "absent.pid"))).toBeNull();
-  });
-
-  it("reads only the first line of a multi-line (Temporal-style) PID file", () => {
-    const path = join(tempDir("stigmer-pid-"), "temporal.pid");
-    writeFileSync(path, "1234\ntemporal server start-dev\n2026-06-13T00:00:00Z\n");
-    expect(readPidFile(path)).toBe(1234);
-  });
-
-  it("returns null for a non-numeric first line", () => {
-    const path = join(tempDir("stigmer-pid-"), "bad.pid");
-    writeFileSync(path, "not-a-pid\n");
-    expect(readPidFile(path)).toBeNull();
-  });
-});
-
-describe("isProcessAlive", () => {
-  it("is true for the current process and false for a dead PID", () => {
-    expect(isProcessAlive(process.pid)).toBe(true);
-    expect(isProcessAlive(DEAD_PID)).toBe(false);
-  });
-});
-
-describe("isOtherLiveProcess", () => {
-  // A recorded PID equal to our own is a leftover from a previous life of this
-  // PID (a restarted container's fresh PID namespace, a laptop after reboot),
-  // never a live peer — the distinction every stale-state reader needs.
-  it("is false for the current process, true for its parent, false for a dead PID", () => {
-    expect(isOtherLiveProcess(process.pid)).toBe(false);
-    expect(isOtherLiveProcess(process.ppid)).toBe(true);
-    expect(isOtherLiveProcess(DEAD_PID)).toBe(false);
-    expect(isProcessAlive(0)).toBe(false);
-    expect(isProcessAlive(-1)).toBe(false);
-  });
-});
-
-describe("health-state", () => {
-  it("round-trips an atomic write/read", () => {
-    const path = join(tempDir("stigmer-health-"), "health-state.json");
-    const state: HealthState = {
-      daemon_pid: 100,
-      started_at: "2026-06-13T10:00:00.000Z",
-      components: {
-        "stigmer-server": { pid: 101, state: "running", started_at: "2026-06-13T10:00:01.000Z", restart_count: 0 },
-        runner: { pid: 102, state: "unhealthy", started_at: "2026-06-13T10:00:02.000Z", restart_count: 1, last_error: "boom" },
-      },
-    };
-    writeHealthState(path, state);
-    expect(loadHealthState(path)).toEqual(state);
-  });
-
-  it("returns null for a missing or corrupt file", () => {
-    const dir = tempDir("stigmer-health-");
-    expect(loadHealthState(join(dir, "absent.json"))).toBeNull();
-    const corrupt = join(dir, "corrupt.json");
-    writeFileSync(corrupt, "{not json");
-    expect(loadHealthState(corrupt)).toBeNull();
-  });
-});
-
-describe("startup-config", () => {
-  it("saves, loads, and removes", () => {
-    const dir = tempDir("stigmer-startup-");
-    const config: StartupConfig = {
-      data_dir: dir,
-      log_dir: join(dir, "logs"),
-      temporal_addr: "127.0.0.1:7233",
-      execution_mode: "local",
-      sandbox_image: "",
-      sandbox_auto_pull: false,
-      sandbox_cleanup: true,
-      sandbox_ttl: 0,
-      stigmer_server_pid: 999,
-      server_only: false,
-    };
-    saveStartupConfig(dir, config);
-    expect(loadStartupConfig(dir)).toEqual(config);
-    removeStartupConfig(dir);
-    expect(loadStartupConfig(dir)).toBeNull();
-  });
-
-  it("loads files written by older CLIs carrying since-removed fields (e.g. the llm_* trio)", () => {
-    // The lenient-load contract oss#314 leans on: no migration for on-disk
-    // files — extra keys simply come along and nothing consumes them.
-    const dir = tempDir("stigmer-startup-");
-    const legacy = {
-      data_dir: dir,
-      log_dir: join(dir, "logs"),
-      temporal_addr: "127.0.0.1:7233",
-      llm_provider: "anthropic",
-      llm_model: "claude",
-      llm_base_url: "",
-      execution_mode: "local",
-      sandbox_image: "",
-      sandbox_auto_pull: false,
-      sandbox_cleanup: true,
-      sandbox_ttl: 0,
-      stigmer_server_pid: 999,
-      server_only: false,
-    };
-    writeFileSync(join(dir, "startup-config.json"), JSON.stringify(legacy));
-    expect(loadStartupConfig(dir)).toMatchObject({ temporal_addr: "127.0.0.1:7233", stigmer_server_pid: 999 });
-  });
-});
-
-describe("log-rotation", () => {
-  it("rotates non-empty logs and leaves empty ones in place", () => {
-    const dir = tempDir("stigmer-logs-");
-    writeFileSync(join(dir, "daemon.log"), "some output\n");
-    writeFileSync(join(dir, "runner.log"), ""); // empty — skipped
-    const now = new Date("2026-06-13T14:15:02");
-
-    const rotated = rotateLogs(dir, { now });
-
-    expect(rotated).toBe(1);
-    expect(() => statSync(join(dir, "daemon.log"))).toThrow(); // renamed away
-    expect(statSync(join(dir, "daemon.log.2026-06-13-141502")).size).toBeGreaterThan(0);
-    expect(statSync(join(dir, "runner.log")).size).toBe(0); // untouched
-  });
-
-  it("prunes archives older than the retention window but keeps recent ones", () => {
-    const dir = tempDir("stigmer-logs-");
-    const now = new Date("2026-06-13T00:00:00");
-
-    const old = join(dir, "daemon.log.2026-05-01-000000");
-    const recent = join(dir, "runner.err.2026-06-12-000000");
-    writeFileSync(old, "old");
-    writeFileSync(recent, "recent");
-    const eightDaysAgo = now.getTime() / 1000 - 8 * 86400;
-    utimesSync(old, eightDaysAgo, eightDaysAgo);
-
-    const deleted = cleanupOldLogs(dir, 7, now);
-
-    expect(deleted).toBe(1);
-    expect(() => statSync(old)).toThrow();
-    expect(statSync(recent).size).toBeGreaterThan(0);
-  });
-});
-
-describe("lock", () => {
-  it("grants the lock once and refuses a second live acquirer", () => {
-    const path = join(tempDir("stigmer-lock-"), "temporal.lock");
-    const first = acquireLock(path);
-    expect(first).not.toBeNull();
-    expect(readFileSync(path, "utf8").trim()).toBe(String(process.pid));
-
-    // A second acquire while we (a live process) hold it must fail.
-    expect(acquireLock(path)).toBeNull();
-
-    first?.release();
-    expect(acquireLock(path)).not.toBeNull();
-  });
-
-  it("reclaims a lock left behind by a dead process", () => {
-    const path = join(tempDir("stigmer-lock-"), "temporal.lock");
-    writeFileSync(path, `${DEAD_PID}\n`);
-    const lock = acquireLock(path);
-    expect(lock).not.toBeNull();
-    expect(readFileSync(path, "utf8").trim()).toBe(String(process.pid));
-  });
-
-  // The container case: after an unclean stop the lock file on the volume names
-  // the PID the daemon had last time — and a fresh PID namespace hands the
-  // restarted daemon that same PID. We are not holding a lock we are trying to
-  // acquire, so an owner equal to ourselves is stale by construction.
-  it("reclaims a lock whose recorded owner is this very process (a previous life of the PID)", () => {
-    const path = join(tempDir("stigmer-lock-"), "temporal.lock");
-    writeFileSync(path, `${process.pid}\n`);
-    const lock = acquireLock(path);
-    expect(lock).not.toBeNull();
-    lock?.release();
-    expect(acquireLock(path)).not.toBeNull();
-  });
-
-  it("release is idempotent and only removes our own lock", () => {
-    const path = join(tempDir("stigmer-lock-"), "temporal.lock");
-    const lock = acquireLock(path);
-    lock?.release();
-    lock?.release(); // no throw
-    expect(acquireLock(path)).not.toBeNull();
-  });
-});

package/src/local/status.test.ts

@@ -1,108 +0,0 @@
-import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { beforeEach, describe, expect, it } from "vitest";
-import { configPath } from "../config/paths.js";
-import { DAEMON_PID_FILE } from "./constants.js";
-import { dataDir } from "./paths.js";
-import type { HealthState } from "./state/health-state.js";
-import { buildStatusResult, formatDuration } from "./status.js";
-
-let home: string;
-beforeEach(() => {
-  home = mkdtempSync(join(tmpdir(), "stigmer-status-"));
-});
-
-const open = async () => true;
-const closed = async () => false;
-
-function field(result: Awaited<ReturnType<typeof buildStatusResult>>, section: string, key: string): string | undefined {
-  return result.sections.find((s) => s.title === section)?.fields.find((f) => f.key === key)?.value;
-}
-
-function writeHealth(state: HealthState): void {
-  mkdirSync(dataDir(home), { recursive: true });
-  writeFileSync(join(dataDir(home), DAEMON_PID_FILE), String(process.pid));
-  writeFileSync(join(dataDir(home), "health-state.json"), JSON.stringify(state));
-}
-
-describe("buildStatusResult", () => {
-  it("reports not-running when no daemon and the port is closed", async () => {
-    const result = await buildStatusResult(home, closed);
-    expect(result.status).toBe("warning");
-    expect(result.message).toMatch(/not running/);
-  });
-
-  it("renders components in order, with runner readiness", async () => {
-    writeHealth({
-      daemon_pid: process.pid,
-      started_at: new Date().toISOString(),
-      components: {
-        temporal: { pid: 10, state: "running", restart_count: 0, started_at: new Date().toISOString() },
-        "stigmer-server": { pid: 11, state: "running", restart_count: 0, started_at: new Date().toISOString() },
-        runner: { pid: 12, state: "running", restart_count: 1, started_at: new Date().toISOString(), ready: true },
-      },
-    });
-    writeFileSync(configPath(home), "backend:\n  type: local\n  local:\n    llm:\n      provider: anthropic\n      api_key: sk-x\n");
-
-    const result = await buildStatusResult(home, open);
-    expect(result.status).toBe("success");
-
-    const titles = result.sections.map((s) => s.title);
-    expect(titles.indexOf("Temporal")).toBeLessThan(titles.indexOf("Stigmer Server"));
-    expect(titles.indexOf("Stigmer Server")).toBeLessThan(titles.indexOf("Runner"));
-
-    expect(field(result, "Runner", "Status")).toBe("Running ✓ (polling)");
-    expect(field(result, "Runner", "Restarts")).toBe("1");
-    expect(field(result, "LLM Configuration", "Provider")).toBe("Anthropic (Cloud)");
-    // No model configured: the platform model registry owns the execution
-    // default, and status says so instead of asserting a version.
-    expect(field(result, "LLM Configuration", "Model")).toBe("Auto (platform default)");
-    expect(field(result, "LLM Configuration", "API Key")).toBe("Configured ✓");
-    expect(field(result, "Web UI", "Temporal")).toBe("http://localhost:8233");
-  });
-
-  it("ignores a stale model key from a pre-oss#314 config — the pin never reached execution, so status must not display it", async () => {
-    writeHealth({ daemon_pid: process.pid, started_at: new Date().toISOString(), components: {} });
-    writeFileSync(configPath(home), "backend:\n  type: local\n  local:\n    llm:\n      provider: anthropic\n      model: claude-x\n      api_key: sk-x\n");
-
-    const result = await buildStatusResult(home, open);
-    expect(field(result, "LLM Configuration", "Model")).toBe("Auto (platform default)");
-  });
-
-  it("reports a non-anthropic provider as unknown — local execution is Anthropic-only", async () => {
-    writeHealth({ daemon_pid: process.pid, started_at: new Date().toISOString(), components: {} });
-    writeFileSync(configPath(home), "backend:\n  type: local\n  local:\n    llm:\n      provider: ollama\n");
-
-    const result = await buildStatusResult(home, open);
-    expect(field(result, "LLM Configuration", "Provider")).toBe("Unknown (ollama)");
-    expect(field(result, "LLM Configuration", "Status")).toBe("Agents will not execute");
-  });
-
-  it("shows runner as starting before the readiness marker", async () => {
-    writeHealth({
-      daemon_pid: process.pid,
-      started_at: new Date().toISOString(),
-      components: {
-        runner: { pid: 12, state: "running", restart_count: 0, started_at: new Date().toISOString(), ready: false },
-      },
-    });
-    const result = await buildStatusResult(home, open);
-    expect(field(result, "Runner", "Status")).toBe("Running ✓ (starting)");
-  });
-
-  it("synthesizes a running server when only the port answers", async () => {
-    const result = await buildStatusResult(home, open);
-    expect(result.status).toBe("success");
-    expect(field(result, "Stigmer Server", "Status")).toBe("Running ✓");
-  });
-});
-
-describe("formatDuration", () => {
-  it("renders coarse human durations", () => {
-    expect(formatDuration(5_000)).toBe("5s");
-    expect(formatDuration(125_000)).toBe("2m 5s");
-    expect(formatDuration(3_700_000)).toBe("1h 1m");
-    expect(formatDuration(90_000_000)).toBe("1d 1h");
-  });
-});

package/src/local/temporal/download.test.ts

@@ -1,248 +0,0 @@
-// The Temporal CLI download end to end over a scripted `fetch`: asset naming,
-// verification against the release's checksums.txt, extraction, and the retry
-// contract `../artifact.ts` gives every release download. The retry cases pin
-// which failures are transient (a dropped connection before or during the body,
-// a 5xx, a 429) and which are answers (a 404, a bad digest), the backoff, and
-// the error a persistent failure ends in. A recording `sleep` keeps them instant.
-
-import { createHash } from "node:crypto";
-import { existsSync, mkdtempSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { gzipSync } from "fflate";
-import { describe, expect, it } from "vitest";
-import { CliExitError } from "../../errors/cli-exit-error.js";
-import {
-  TEMPORAL_CHECKSUMS_FILE,
-  downloadTemporalCli,
-  extractTarEntry,
-  temporalArchiveName,
-  temporalReleaseAssetUrl,
-} from "./download.js";
-
-// Build a minimal ustar archive containing a single regular-file entry. Only
-// the fields the reader uses (name, octal size, type flag) are populated.
-function makeTar(name: string, content: Buffer): Buffer {
-  const header = Buffer.alloc(512);
-  header.write(name, 0, "utf8");
-  header.write(content.length.toString(8).padStart(11, "0"), 124, "ascii");
-  header.write("0", 156, "ascii");
-  const data = Buffer.alloc(Math.ceil(content.length / 512) * 512);
-  content.copy(data);
-  const trailer = Buffer.alloc(1024); // two zero blocks end the archive
-  return Buffer.concat([header, data, trailer]);
-}
-
-describe("extractTarEntry", () => {
-  it("extracts a named regular file", () => {
-    const payload = Buffer.from("#!/bin/sh\necho temporal\n");
-    const tar = makeTar("temporal", payload);
-    const out = extractTarEntry(new Uint8Array(tar), "temporal");
-    expect(out).not.toBeNull();
-    expect(Buffer.from(out!).toString("utf8")).toBe(payload.toString("utf8"));
-  });
-
-  it("matches by basename for nested entries", () => {
-    const payload = Buffer.from("binary-bytes");
-    const tar = makeTar("temporal_cli/temporal", payload);
-    const out = extractTarEntry(new Uint8Array(tar), "temporal");
-    expect(Buffer.from(out!).toString("utf8")).toBe("binary-bytes");
-  });
-
-  it("returns null when the entry is absent", () => {
-    const tar = makeTar("something-else", Buffer.from("x"));
-    expect(extractTarEntry(new Uint8Array(tar), "temporal")).toBeNull();
-  });
-});
-
-// A release as GitHub serves it: the archive for the requested platform plus a
-// release-wide checksums.txt listing every asset. `fetchImpl` routes by URL so
-// the checksum arm is exercised against a realistic multi-line file.
-function release(version: string, archives: Record<string, Buffer>, checksums: string): typeof fetch {
-  return (async (input: string | URL | Request) => {
-    const url = String(input);
-    const name = url.slice(url.lastIndexOf("/") + 1);
-    if (name === TEMPORAL_CHECKSUMS_FILE) {
-      return { ok: true, status: 200, text: async () => checksums } as unknown as Response;
-    }
-    const gz = archives[name];
-    if (gz === undefined) return { ok: false, status: 404, arrayBuffer: async () => new ArrayBuffer(0) } as unknown as Response;
-    return {
-      ok: true,
-      status: 200,
-      arrayBuffer: async () => gz.buffer.slice(gz.byteOffset, gz.byteOffset + gz.byteLength),
-    } as unknown as Response;
-  }) as unknown as typeof fetch;
-}
-
-function archiveFor(payload: Buffer): Buffer {
-  return Buffer.from(gzipSync(new Uint8Array(makeTar("temporal", payload))));
-}
-
-function sha256(bytes: Buffer): string {
-  return createHash("sha256").update(bytes).digest("hex");
-}
-
-describe("downloadTemporalCli", () => {
-  const linuxArm = temporalArchiveName("1.5.1", "linux", "arm64");
-  const linuxAmd = temporalArchiveName("1.5.1", "linux", "x64");
-
-  it("names the release assets the way Temporal publishes them", () => {
-    expect(linuxArm).toBe("temporal_cli_1.5.1_linux_arm64.tar.gz");
-    expect(linuxAmd).toBe("temporal_cli_1.5.1_linux_amd64.tar.gz");
-    expect(temporalArchiveName("1.5.1", "darwin", "arm64")).toBe("temporal_cli_1.5.1_darwin_arm64.tar.gz");
-    expect(temporalReleaseAssetUrl("1.5.1", TEMPORAL_CHECKSUMS_FILE)).toBe(
-      "https://github.com/temporalio/cli/releases/download/v1.5.1/checksums.txt",
-    );
-  });
-
-  it("downloads, verifies against the matching checksums.txt line, gunzips, untars, and writes the binary", async () => {
-    const arm = archiveFor(Buffer.from("the-arm64-binary"));
-    const amd = archiveFor(Buffer.from("the-amd64-binary"));
-    // amd64 listed FIRST: a first-token parser would verify arm64 against it.
-    const checksums = `${sha256(amd)}  ${linuxAmd}\n${sha256(arm)}  ${linuxArm}\n`;
-    const fetchImpl = release("1.5.1", { [linuxArm]: arm, [linuxAmd]: amd }, checksums);
-
-    const binPath = join(mkdtempSync(join(tmpdir(), "stigmer-temporal-")), "bin", "temporal");
-    await downloadTemporalCli({ version: "1.5.1", binPath, platform: "linux", arch: "arm64", fetchImpl });
-
-    expect(readFileSync(binPath, "utf8")).toBe("the-arm64-binary");
-  });
-
-  it("refuses an archive whose digest does not match its checksums.txt line", async () => {
-    const arm = archiveFor(Buffer.from("tampered"));
-    const checksums = `${"0".repeat(64)}  ${linuxArm}\n`;
-    const fetchImpl = release("1.5.1", { [linuxArm]: arm }, checksums);
-
-    const binPath = join(mkdtempSync(join(tmpdir(), "stigmer-temporal-")), "temporal");
-    await expect(
-      downloadTemporalCli({ version: "1.5.1", binPath, platform: "linux", arch: "arm64", fetchImpl }),
-    ).rejects.toThrow(/checksum mismatch/);
-    expect(existsSync(binPath)).toBe(false);
-  });
-
-  it("refuses an archive the checksums.txt has no entry for", async () => {
-    const arm = archiveFor(Buffer.from("unlisted"));
-    const checksums = `${sha256(arm)}  some_other_asset.tar.gz\n`;
-    const fetchImpl = release("1.5.1", { [linuxArm]: arm }, checksums);
-
-    const binPath = join(mkdtempSync(join(tmpdir(), "stigmer-temporal-")), "temporal");
-    await expect(
-      downloadTemporalCli({ version: "1.5.1", binPath, platform: "linux", arch: "arm64", fetchImpl }),
-    ).rejects.toThrow(/checksum mismatch/);
-  });
-
-  it("fails clearly on a non-OK response", async () => {
-    const fetchImpl = release("9.9.9", {}, "");
-    const binPath = join(mkdtempSync(join(tmpdir(), "stigmer-temporal-")), "temporal");
-    await expect(downloadTemporalCli({ version: "9.9.9", binPath, fetchImpl })).rejects.toThrow(/HTTP 404/);
-  });
-});
-
-type Failure = "reject" | "body" | number;
-
-// Wraps a release so requests for one asset fail as scripted before the real
-// release answers: each entry of `failures` is consumed by one request for
-// `asset`. "reject" is a connection that never answers (Node's fetch rejects
-// with the socket error as `cause`), "body" one that drops after the headers,
-// a number an HTTP status. `calls` counts the requests for `asset`.
-function flaky(inner: typeof fetch, asset: string, failures: Failure[]): { fetchImpl: typeof fetch; calls: () => number } {
-  let calls = 0;
-  const fetchImpl = (async (input: string | URL | Request) => {
-    const url = String(input);
-    if (!url.endsWith(`/${asset}`)) return inner(input);
-    calls += 1;
-    const failure = failures[calls - 1];
-    if (failure === "reject") throw new TypeError("fetch failed", { cause: new Error("read ECONNRESET") });
-    if (failure === "body") {
-      return {
-        ok: true,
-        status: 200,
-        arrayBuffer: async () => {
-          throw new TypeError("terminated", { cause: new Error("other side closed") });
-        },
-      } as unknown as Response;
-    }
-    if (typeof failure === "number") {
-      return { ok: false, status: failure, arrayBuffer: async () => new ArrayBuffer(0) } as unknown as Response;
-    }
-    return inner(input);
-  }) as unknown as typeof fetch;
-  return { fetchImpl, calls: () => calls };
-}
-
-describe("downloadTemporalCli over an unreliable network", () => {
-  const linuxArm = temporalArchiveName("1.5.1", "linux", "arm64");
-  const arm = archiveFor(Buffer.from("the-arm64-binary"));
-  const good = release("1.5.1", { [linuxArm]: arm }, `${sha256(arm)}  ${linuxArm}\n`);
-
-  function install(fetchImpl: typeof fetch): { binPath: string; delays: number[]; run: Promise<void> } {
-    const binPath = join(mkdtempSync(join(tmpdir(), "stigmer-temporal-")), "temporal");
-    const delays: number[] = [];
-    const sleep = async (ms: number): Promise<void> => {
-      delays.push(ms);
-    };
-    const run = downloadTemporalCli({ version: "1.5.1", binPath, platform: "linux", arch: "arm64", fetchImpl, sleep });
-    return { binPath, delays, run };
-  }
-
-  it("retries a connection that never answers, then installs the verified binary", async () => {
-    const net = flaky(good, linuxArm, ["reject"]);
-    const { binPath, delays, run } = install(net.fetchImpl);
-    await run;
-    expect(readFileSync(binPath, "utf8")).toBe("the-arm64-binary");
-    expect(net.calls()).toBe(2);
-    expect(delays).toEqual([1000]);
-  });
-
-  it("retries a connection that drops after the headers", async () => {
-    const net = flaky(good, linuxArm, ["body"]);
-    const { binPath, run } = install(net.fetchImpl);
-    await run;
-    expect(readFileSync(binPath, "utf8")).toBe("the-arm64-binary");
-    expect(net.calls()).toBe(2);
-  });
-
-  it("retries a 5xx and a 429, doubling the wait", async () => {
-    const net = flaky(good, linuxArm, [503, 429]);
-    const { binPath, delays, run } = install(net.fetchImpl);
-    await run;
-    expect(readFileSync(binPath, "utf8")).toBe("the-arm64-binary");
-    expect(net.calls()).toBe(3);
-    expect(delays).toEqual([1000, 2000]);
-  });
-
-  it("retries the checksums.txt fetch the same way", async () => {
-    const net = flaky(good, TEMPORAL_CHECKSUMS_FILE, ["reject"]);
-    const { binPath, run } = install(net.fetchImpl);
-    await run;
-    expect(readFileSync(binPath, "utf8")).toBe("the-arm64-binary");
-    expect(net.calls()).toBe(2);
-  });
-
-  it("takes a 404 as the answer and does not retry it", async () => {
-    const net = flaky(good, linuxArm, [404]);
-    const { delays, run } = install(net.fetchImpl);
-    await expect(run).rejects.toThrow(/HTTP 404/);
-    expect(net.calls()).toBe(1);
-    expect(delays).toEqual([]);
-  });
-
-  it("gives up after four attempts, saying what failed and what to do", async () => {
-    const net = flaky(good, linuxArm, ["reject", "reject", "reject", "reject"]);
-    const { binPath, delays, run } = install(net.fetchImpl);
-    const err: unknown = await run.then(
-      () => undefined,
-      (e: unknown) => e,
-    );
-    expect(err).toBeInstanceOf(CliExitError);
-    const exit = err as CliExitError;
-    expect(exit.message).toBe(
-      `failed to download Temporal CLI from ${temporalReleaseAssetUrl("1.5.1", linuxArm)} after 4 attempts: fetch failed: read ECONNRESET`,
-    );
-    expect(exit.hints).toEqual(["check the network connection, then run the command again"]);
-    expect(net.calls()).toBe(4);
-    expect(delays).toEqual([1000, 2000, 4000]);
-    expect(existsSync(binPath)).toBe(false);
-  });
-});

package/src/local/temporal/inspect.test.ts

@@ -1,83 +0,0 @@
-// Pins the process-identity reader: the kernel's /proc answer comes first, `ps`
-// is the fallback, and neither's absence is mistaken for "not Temporal" when the
-// other can answer. The /proc arm is what keeps a minimal container (no `ps`)
-// from restarting a healthy Temporal every supervisor tick.
-
-import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { isLikelyTemporal, processCommandLine } from "./inspect.js";
-
-function procFixture(entries: Record<number, string[] | "">): string {
-  const root = mkdtempSync(join(tmpdir(), "stigmer-proc-"));
-  for (const [pid, argv] of Object.entries(entries)) {
-    mkdirSync(join(root, pid));
-    // /proc/<pid>/cmdline: argv joined by NUL, NUL-terminated; empty for a zombie.
-    writeFileSync(join(root, pid, "cmdline"), argv === "" ? "" : `${argv.join("\0")}\0`);
-  }
-  return root;
-}
-
-// Hide `ps` so the fallback cannot answer; tests that need it restore PATH.
-let savedPath: string | undefined;
-beforeEach(() => {
-  savedPath = process.env.PATH;
-});
-afterEach(() => {
-  if (savedPath === undefined) delete process.env.PATH;
-  else process.env.PATH = savedPath;
-});
-
-describe("processCommandLine", () => {
-  it("reads argv from <procRoot>/<pid>/cmdline, joining the NUL-separated arguments", () => {
-    const root = procFixture({ 42: ["/opt/stigmer/bin/temporal", "server", "start-dev", "--port", "7233"] });
-    process.env.PATH = "";
-    expect(processCommandLine(42, { procRoot: root })).toBe("/opt/stigmer/bin/temporal server start-dev --port 7233");
-  });
-
-  it("falls back to ps when the pid has no cmdline entry", () => {
-    const root = procFixture({});
-    // Our own process is the one PID whose command line `ps` can always report.
-    const line = processCommandLine(process.pid, { procRoot: root });
-    expect(line).not.toBeNull();
-    expect(line).toMatch(/node|vitest/);
-  });
-
-  it("treats an empty cmdline (a zombie) as unreadable and falls back to ps", () => {
-    const root = procFixture({ [process.pid]: "" });
-    expect(processCommandLine(process.pid, { procRoot: root })).toMatch(/node|vitest/);
-  });
-
-  it("returns null when neither /proc nor ps can answer", () => {
-    process.env.PATH = "";
-    expect(processCommandLine(process.pid, { procRoot: null })).toBeNull();
-  });
-});
-
-describe("isLikelyTemporal", () => {
-  it("recognises the managed dev server by its binary path", () => {
-    const root = procFixture({ 7: ["/home/u/.stigmer/bin/temporal", "server", "start-dev"] });
-    process.env.PATH = "";
-    expect(isLikelyTemporal(7, "/home/u/.stigmer/bin/temporal", { procRoot: root })).toBe(true);
-  });
-
-  it("recognises a temporal server started from another path by its subcommand", () => {
-    const root = procFixture({ 8: ["/usr/local/bin/temporal", "server", "start-dev"] });
-    process.env.PATH = "";
-    expect(isLikelyTemporal(8, "/elsewhere/temporal", { procRoot: root })).toBe(true);
-  });
-
-  it("rejects an unrelated process that reused the pid", () => {
-    const root = procFixture({ 9: ["/usr/bin/node", "/app/main.js"] });
-    process.env.PATH = "";
-    expect(isLikelyTemporal(9, "/home/u/.stigmer/bin/temporal", { procRoot: root })).toBe(false);
-  });
-
-  // The defect the /proc arm fixes: with `ps` gone and no /proc reader, a live
-  // Temporal read as "not Temporal" and the supervisor restarted it forever.
-  it("is false, not an exception, when no reader can answer", () => {
-    process.env.PATH = "";
-    expect(isLikelyTemporal(process.pid, "/x/temporal", { procRoot: null })).toBe(false);
-  });
-});