@stigmer/cli 3.0.8

package/src/local/runtime/node.ts

@@ -0,0 +1,67 @@
+// Resolution of the Node.js runtime used to launch the runner subprocess.
+//
+// We reuse the very Node that is running the CLI (process.execPath). The CLI is
+// itself an npm package with `engines: node >= 20`, so a suitable Node is always
+// present by construction — there is deliberately no hermetic Node download
+// (DD-002: keep the base install lean; nothing to acquire that the host already
+// guarantees). This is exactly what the conformance harness does
+// (`spawn(process.execPath, ...)`). An explicit STIGMER_NODE_BIN override is
+// honored and version-checked for advanced/multi-runtime setups.
+
+import { execFileSync } from "node:child_process";
+import { CliExitError } from "../../errors/cli-exit-error.js";
+import { ExitCode } from "../../errors/exit-codes.js";
+
+/** Minimum Node major version the runner requires. */
+export const MIN_NODE_MAJOR = 20;
+
+/**
+ * Resolve the Node binary to launch the runner with. Honors STIGMER_NODE_BIN
+ * (version-checked); otherwise returns the current runtime.
+ */
+export function resolveNode(): string {
+  const override = process.env.STIGMER_NODE_BIN;
+  if (override !== undefined && override !== "") {
+    assertVersion(override, probeNodeMajor(override));
+    return override;
+  }
+  // The CLI's own runtime: major is readable directly, no subprocess needed.
+  assertVersion(process.execPath, currentMajor());
+  return process.execPath;
+}
+
+function currentMajor(): number | null {
+  return parseMajor(process.versions.node);
+}
+
+function probeNodeMajor(bin: string): number | null {
+  try {
+    const out = execFileSync(bin, ["--version"], { encoding: "utf8" });
+    return parseMajor(out.trim());
+  } catch {
+    return null;
+  }
+}
+
+// Parses "v22.22.2" or "22.22.2" to its major number.
+function parseMajor(version: string): number | null {
+  const match = /^v?(\d+)\./.exec(version.trim());
+  if (match === null) return null;
+  const major = Number.parseInt(match[1], 10);
+  return Number.isInteger(major) ? major : null;
+}
+
+function assertVersion(bin: string, major: number | null): void {
+  if (major === null) {
+    throw new CliExitError(`could not determine the Node version of ${bin}`, ExitCode.General, [
+      `Ensure ${bin} is a working Node >= ${MIN_NODE_MAJOR} runtime.`,
+    ]);
+  }
+  if (major < MIN_NODE_MAJOR) {
+    throw new CliExitError(
+      `Node >= ${MIN_NODE_MAJOR} is required to run the runner (found major ${major} at ${bin})`,
+      ExitCode.General,
+      [`Upgrade Node to ${MIN_NODE_MAJOR} or newer, or point STIGMER_NODE_BIN at one.`],
+    );
+  }
+}

package/src/local/runtime/runner.ts

@@ -0,0 +1,186 @@
+// Resolution and on-demand acquisition of the unified runner.
+//
+// The runner is launched as a compiled `node main.js`, never `tsx src/main.ts`:
+// the runner bundles its Temporal workflows on boot and that bundling fails under
+// tsx on the raw-.ts proto stubs, which is exactly why the conformance and e2e
+// harnesses run `node dist/main.js`. Requiring the build is correctness.
+//
+// Two acquisition sources, tried in order:
+//   1. A repo-tree runner (dev) or an explicit STIGMER_RUNNER_DIR — `dist/main.js`.
+//   2. The already-published `@stigmer/runner-slim`, installed on demand into
+//      ~/.stigmer/runtimes/<version>/ — `node_modules/@stigmer/runner-slim/main.js`.
+//
+// (2) deliberately reuses the slim esbuild bundle the desktop already ships
+// (stigmer/stigmer#170): one CJS `main.js` plus the few unbundlable native deps,
+// with the correct `@stigmer/runner-slim-<platform>` package selected by npm via
+// optionalDependencies/os/cpu — ~85 MB instead of the full ~508 MB install. The
+// launch contract (`node main.js`) is identical to the repo-tree runner, so the
+// daemon spawns either the same way.
+
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CliExitError } from "../../errors/cli-exit-error.js";
+import { ExitCode } from "../../errors/exit-codes.js";
+import { log } from "../../logger.js";
+import { VERSION } from "../../version.js";
+import { runtimesDir } from "../paths.js";
+import { resolveNode } from "./node.js";
+
+const SLIM_PACKAGE = "@stigmer/runner-slim";
+
+/** Everything needed to spawn the runner subprocess. */
+export interface RunnerResolution {
+  /** Node binary to launch with. */
+  nodeBin: string;
+  /** Absolute path to the compiled runner entry (`main.js`). */
+  entryPath: string;
+  /** The runner package directory. */
+  appDir: string;
+}
+
+export interface EnsureRunnerOptions {
+  home?: string;
+  /** Release version of the slim runner to acquire (defaults to the CLI version). */
+  version?: string;
+  /** Node resolver (injectable for tests). */
+  node?: () => string;
+  /** npm install implementation (injectable for tests). */
+  install?: (installDir: string, spec: string) => void;
+}
+
+/**
+ * Ensure a launchable runner, acquiring `@stigmer/runner-slim` on demand if no
+ * repo-tree / STIGMER_RUNNER_DIR runner is present. Throws actionable guidance on
+ * a missing build, an invalid override, or a non-release CLI build.
+ */
+export function ensureRunner(opts: EnsureRunnerOptions = {}): RunnerResolution {
+  const node = opts.node ?? resolveNode;
+  const local = resolveRunner(node);
+  if (local !== null) return local;
+  return acquireRunner({ ...opts, node });
+}
+
+/**
+ * Resolve a repo-tree runner (dev) or an explicit STIGMER_RUNNER_DIR, or null
+ * when neither is present (the caller then acquires the slim package). Throws
+ * when an override is set but invalid, or when a found runner is not built — both
+ * are actionable user-facing conditions, not a reason to silently download.
+ * `node` is injectable for tests.
+ */
+export function resolveRunner(node: () => string = resolveNode): RunnerResolution | null {
+  const override = process.env.STIGMER_RUNNER_DIR;
+  if (override !== undefined && override !== "") {
+    if (!hasPackageJson(override)) {
+      throw new CliExitError(`STIGMER_RUNNER_DIR is not a runner package: ${override}`, ExitCode.General, [
+        "Point STIGMER_RUNNER_DIR at the @stigmer/runner package directory (the one with package.json).",
+      ]);
+    }
+    return resolveBuiltRunner(override, node);
+  }
+
+  const root = repoRoot();
+  if (root !== null) {
+    const candidate = join(root, "backend", "services", "runner");
+    if (hasPackageJson(candidate)) return resolveBuiltRunner(candidate, node);
+  }
+  return null;
+}
+
+/**
+ * Acquire the published `@stigmer/runner-slim@<version>` into
+ * ~/.stigmer/runtimes/<version>/ (idempotent: reuses a prior install) and resolve
+ * its `main.js` entry. The version is pinned to the CLI's own version so the
+ * runner's protos/SDK stay in lockstep with the control plane.
+ */
+export function acquireRunner(opts: EnsureRunnerOptions = {}): RunnerResolution {
+  const home = opts.home ?? homedir();
+  const version = opts.version ?? VERSION;
+  if (!isAcquirableRelease(version)) {
+    throw new CliExitError(`cannot acquire ${SLIM_PACKAGE} for a non-release build (${version})`, ExitCode.General, [
+      "Run from the repo with a built runner, or set STIGMER_RUNNER_DIR.",
+      "On-demand acquisition is only available for published releases.",
+    ]);
+  }
+
+  const node = opts.node ?? resolveNode;
+  const installDir = join(runtimesDir(home), version);
+  const entryPath = join(installDir, "node_modules", "@stigmer", "runner-slim", "main.js");
+
+  if (!existsSync(entryPath)) {
+    log.info(`acquiring ${SLIM_PACKAGE}`, { version, dir: installDir });
+    mkdirSync(installDir, { recursive: true });
+    // A stable package.json root makes the install deterministic and records the
+    // pinned dependency rather than letting npm synthesize an ad-hoc root.
+    writeFileSync(
+      join(installDir, "package.json"),
+      `${JSON.stringify({ name: "stigmer-runtime", private: true, version: "0.0.0" }, null, 2)}\n`,
+    );
+    const install = opts.install ?? installRunnerSlim;
+    install(installDir, `${SLIM_PACKAGE}@${version}`);
+  }
+
+  if (!existsSync(entryPath)) {
+    throw new CliExitError(`${SLIM_PACKAGE} install did not produce ${entryPath}`, ExitCode.General, [
+      "The install may have skipped the platform-native package for this OS/arch.",
+      `Remove ${installDir} and retry, or set STIGMER_RUNNER_DIR to a built runner.`,
+    ]);
+  }
+
+  return { nodeBin: node(), entryPath, appDir: dirname(entryPath) };
+}
+
+// Install the slim package (plus its platform-native optional dependency) into an
+// isolated prefix. `--omit=dev` drops devDependencies while keeping the optional
+// native package npm selects by os/cpu; output is inherited so the user sees the
+// one-time download progress.
+function installRunnerSlim(installDir: string, spec: string): void {
+  try {
+    execFileSync("npm", ["install", spec, "--prefix", installDir, "--omit=dev", "--no-audit", "--no-fund"], {
+      stdio: "inherit",
+    });
+  } catch (err) {
+    throw new CliExitError(`failed to install ${spec}`, ExitCode.General, [
+      `Command: npm install ${spec} --prefix ${installDir}`,
+      "Ensure npm is on PATH and the network is reachable.",
+      String(err),
+    ]);
+  }
+}
+
+function resolveBuiltRunner(appDir: string, node: () => string): RunnerResolution {
+  const entryPath = join(appDir, "dist", "main.js");
+  if (!existsSync(entryPath)) {
+    throw new CliExitError(`runner not built: ${entryPath} is missing`, ExitCode.General, [
+      "Build it with: npm run build -w @stigmer/protos && npm run build -w @stigmer/runner",
+      "The runner must be compiled — it cannot run from source via tsx (Temporal",
+      "workflow bundling fails on raw-.ts proto stubs).",
+    ]);
+  }
+  return { nodeBin: node(), entryPath, appDir };
+}
+
+// A source build reports "0.0.0-dev" and the dev npm channel stamps "<v>-dev.<stamp>"
+// versions; neither publishes a matching @stigmer/runner-slim, so they are not
+// acquirable. Release and rc/next versions are.
+function isAcquirableRelease(version: string): boolean {
+  return !version.includes("-dev");
+}
+
+function hasPackageJson(dir: string): boolean {
+  return existsSync(join(dir, "package.json"));
+}
+
+// Walk up from this module to a repo root containing backend/services/runner.
+function repoRoot(): string | null {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 10; i += 1) {
+    if (existsSync(join(dir, "backend", "services", "runner", "package.json"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}

package/src/local/runtime/runtime.test.ts

@@ -0,0 +1,155 @@
+import { chmodSync, 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 { CliExitError } from "../../errors/cli-exit-error.js";
+import { MIN_NODE_MAJOR, resolveNode } from "./node.js";
+import { acquireRunner, resolveRunner } from "./runner.js";
+import { resolveServerBinary } from "./server.js";
+import { which } from "./which.js";
+
+function tempDir(prefix: string): string {
+  return mkdtempSync(join(tmpdir(), prefix));
+}
+
+// Snapshot and restore the env vars these resolvers read, so tests don't leak.
+const TOUCHED = ["PATH", "STIGMER_SERVER_BIN", "STIGMER_RUNNER_DIR", "STIGMER_NODE_BIN"] as const;
+let saved: Record<string, string | undefined>;
+
+beforeEach(() => {
+  saved = {};
+  for (const key of TOUCHED) saved[key] = process.env[key];
+});
+
+afterEach(() => {
+  for (const key of TOUCHED) {
+    if (saved[key] === undefined) delete process.env[key];
+    else process.env[key] = saved[key];
+  }
+});
+
+describe("which", () => {
+  it("resolves an executable on PATH and returns null for an unknown name", () => {
+    const dir = tempDir("stigmer-which-");
+    const exe = join(dir, "myexec");
+    writeFileSync(exe, "#!/bin/sh\n");
+    chmodSync(exe, 0o755);
+    process.env.PATH = dir;
+
+    expect(which("myexec")).toBe(exe);
+    expect(which("definitely-not-a-real-binary-xyz")).toBeNull();
+  });
+
+  it("checks an absolute path directly", () => {
+    const dir = tempDir("stigmer-which-");
+    const exe = join(dir, "tool");
+    writeFileSync(exe, "#!/bin/sh\n");
+    chmodSync(exe, 0o755);
+    expect(which(exe)).toBe(exe);
+    expect(which(join(dir, "missing"))).toBeNull();
+  });
+});
+
+describe("resolveNode", () => {
+  it("defaults to the current Node runtime", () => {
+    delete process.env.STIGMER_NODE_BIN;
+    expect(resolveNode()).toBe(process.execPath);
+  });
+
+  it("honors a valid override", () => {
+    process.env.STIGMER_NODE_BIN = process.execPath; // a real Node >= 20
+    expect(resolveNode()).toBe(process.execPath);
+  });
+
+  it("rejects an override that is not a working Node", () => {
+    process.env.STIGMER_NODE_BIN = "/nonexistent/node";
+    expect(() => resolveNode()).toThrow(CliExitError);
+  });
+
+  it("requires Node >= 20", () => {
+    expect(MIN_NODE_MAJOR).toBe(20);
+  });
+});
+
+describe("resolveServerBinary", () => {
+  it("honors the STIGMER_SERVER_BIN override", () => {
+    const dir = tempDir("stigmer-server-");
+    const bin = join(dir, "stigmer-server");
+    writeFileSync(bin, "#!/bin/sh\n");
+    chmodSync(bin, 0o755);
+    process.env.STIGMER_SERVER_BIN = bin;
+    expect(resolveServerBinary()).toBe(bin);
+  });
+});
+
+describe("resolveRunner", () => {
+  const fakeNode = (): string => "/usr/bin/node";
+
+  it("resolves a built runner from STIGMER_RUNNER_DIR", () => {
+    const dir = tempDir("stigmer-runner-");
+    writeFileSync(join(dir, "package.json"), "{}");
+    mkdirSync(join(dir, "dist"));
+    writeFileSync(join(dir, "dist", "main.js"), "//");
+    process.env.STIGMER_RUNNER_DIR = dir;
+
+    const resolution = resolveRunner(fakeNode);
+    expect(resolution).toEqual({ nodeBin: "/usr/bin/node", entryPath: join(dir, "dist", "main.js"), appDir: dir });
+  });
+
+  it("errors with build guidance when dist/main.js is missing", () => {
+    const dir = tempDir("stigmer-runner-");
+    writeFileSync(join(dir, "package.json"), "{}");
+    process.env.STIGMER_RUNNER_DIR = dir;
+    expect(() => resolveRunner(fakeNode)).toThrow(/not built/);
+  });
+
+  it("rejects an override that is not a runner package", () => {
+    const dir = tempDir("stigmer-runner-");
+    process.env.STIGMER_RUNNER_DIR = join(dir, "no-package-here"); // no package.json
+    expect(() => resolveRunner(fakeNode)).toThrow(/not a runner package/);
+  });
+});
+
+describe("acquireRunner", () => {
+  const fakeNode = (): string => "/usr/bin/node";
+
+  it("installs the slim package and resolves its main.js entry", () => {
+    const home = tempDir("stigmer-home-");
+    const installed: Array<{ dir: string; spec: string }> = [];
+    const install = (dir: string, spec: string): void => {
+      installed.push({ dir, spec });
+      // Simulate the npm install laying down the slim package.
+      const pkgDir = join(dir, "node_modules", "@stigmer", "runner-slim");
+      mkdirSync(pkgDir, { recursive: true });
+      writeFileSync(join(pkgDir, "main.js"), "// slim bundle");
+    };
+
+    const resolution = acquireRunner({ home, version: "0.5.0", node: fakeNode, install });
+
+    const expectedEntry = join(home, ".stigmer", "runtimes", "0.5.0", "node_modules", "@stigmer", "runner-slim", "main.js");
+    expect(resolution.nodeBin).toBe("/usr/bin/node");
+    expect(resolution.entryPath).toBe(expectedEntry);
+    expect(resolution.appDir).toBe(join(home, ".stigmer", "runtimes", "0.5.0", "node_modules", "@stigmer", "runner-slim"));
+    expect(installed).toEqual([{ dir: join(home, ".stigmer", "runtimes", "0.5.0"), spec: "@stigmer/runner-slim@0.5.0" }]);
+  });
+
+  it("reuses a prior install without reinstalling", () => {
+    const home = tempDir("stigmer-home-");
+    const pkgDir = join(home, ".stigmer", "runtimes", "0.5.0", "node_modules", "@stigmer", "runner-slim");
+    mkdirSync(pkgDir, { recursive: true });
+    writeFileSync(join(pkgDir, "main.js"), "// slim bundle");
+
+    const install = vi.fn();
+    const resolution = acquireRunner({ home, version: "0.5.0", node: fakeNode, install });
+
+    expect(resolution.entryPath).toBe(join(pkgDir, "main.js"));
+    expect(install).not.toHaveBeenCalled();
+  });
+
+  it("refuses to acquire for a non-release (dev) build", () => {
+    const home = tempDir("stigmer-home-");
+    expect(() => acquireRunner({ home, version: "0.0.0-dev", node: fakeNode, install: vi.fn() })).toThrow(
+      /non-release build/,
+    );
+  });
+});

package/src/local/runtime/server.test.ts

@@ -0,0 +1,152 @@
+import { createHash } from "node:crypto";
+import { chmodSync, mkdtempSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { gzipSync } from "fflate";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { downloadServerBinary, ensureServerBinary } from "./server.js";
+
+// Build a minimal ustar archive with a single regular-file entry.
+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);
+  return Buffer.concat([header, data, trailer]);
+}
+
+function sha256(bytes: Uint8Array): string {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+
+// A fetch double that serves a gzipped tar for the archive URL and a
+// shasum-format checksum for the `.sha256` URL. `corruptChecksum` flips the
+// returned hash to exercise the verification failure path.
+function fakeFetch(archiveGz: Uint8Array, opts: { corruptChecksum?: boolean; capturedUrls?: string[] } = {}): typeof fetch {
+  const checksum = opts.corruptChecksum === true ? "0".repeat(64) : sha256(archiveGz);
+  return (async (url: string) => {
+    opts.capturedUrls?.push(url);
+    if (url.endsWith(".sha256")) {
+      return { ok: true, status: 200, text: async () => `${checksum}  archive.tar.gz\n` };
+    }
+    return {
+      ok: true,
+      status: 200,
+      arrayBuffer: async () => archiveGz.buffer.slice(archiveGz.byteOffset, archiveGz.byteOffset + archiveGz.byteLength),
+    };
+  }) as unknown as typeof fetch;
+}
+
+const TOUCHED = ["STIGMER_SERVER_BIN"] as const;
+let saved: Record<string, string | undefined>;
+
+beforeEach(() => {
+  saved = {};
+  for (const key of TOUCHED) saved[key] = process.env[key];
+});
+
+afterEach(() => {
+  for (const key of TOUCHED) {
+    if (saved[key] === undefined) delete process.env[key];
+    else process.env[key] = saved[key];
+  }
+});
+
+describe("downloadServerBinary", () => {
+  it("downloads, verifies the checksum, extracts, and writes an executable", async () => {
+    const payload = Buffer.from("the-stigmer-server-binary");
+    const gz = gzipSync(new Uint8Array(makeTar("stigmer-server", payload)));
+    const capturedUrls: string[] = [];
+    const binPath = join(mkdtempSync(join(tmpdir(), "stigmer-server-")), "bin", "stigmer-server");
+
+    await downloadServerBinary({
+      version: "0.5.0",
+      binPath,
+      platform: "darwin",
+      arch: "arm64",
+      fetchImpl: fakeFetch(gz, { capturedUrls }),
+    });
+
+    expect(readFileSync(binPath, "utf8")).toBe("the-stigmer-server-binary");
+    expect(statSync(binPath).mode & 0o111).not.toBe(0); // executable
+    expect(capturedUrls).toContain(
+      "https://github.com/stigmer/stigmer/releases/download/v0.5.0/stigmer-server-v0.5.0-darwin-arm64.tar.gz",
+    );
+    expect(capturedUrls).toContain(
+      "https://github.com/stigmer/stigmer/releases/download/v0.5.0/stigmer-server-v0.5.0-darwin-arm64.tar.gz.sha256",
+    );
+  });
+
+  it("maps a prerelease version to its v-prefixed release tag", async () => {
+    const gz = gzipSync(new Uint8Array(makeTar("stigmer-server", Buffer.from("x"))));
+    const capturedUrls: string[] = [];
+    const binPath = join(mkdtempSync(join(tmpdir(), "stigmer-server-")), "stigmer-server");
+
+    await downloadServerBinary({
+      version: "0.5.0-rc.1",
+      binPath,
+      platform: "linux",
+      arch: "x64",
+      fetchImpl: fakeFetch(gz, { capturedUrls }),
+    });
+
+    expect(capturedUrls[0]).toBe(
+      "https://github.com/stigmer/stigmer/releases/download/v0.5.0-rc.1/stigmer-server-v0.5.0-rc.1-linux-amd64.tar.gz",
+    );
+  });
+
+  it("refuses a mismatched checksum", async () => {
+    const gz = gzipSync(new Uint8Array(makeTar("stigmer-server", Buffer.from("x"))));
+    const binPath = join(mkdtempSync(join(tmpdir(), "stigmer-server-")), "stigmer-server");
+    await expect(
+      downloadServerBinary({
+        version: "0.5.0",
+        binPath,
+        platform: "darwin",
+        arch: "arm64",
+        fetchImpl: fakeFetch(gz, { corruptChecksum: true }),
+      }),
+    ).rejects.toThrow(/checksum mismatch/);
+  });
+
+  it("fails clearly on a non-OK archive response", async () => {
+    const fetchImpl = (async (url: string) => ({
+      ok: false,
+      status: 404,
+      arrayBuffer: async () => new ArrayBuffer(0),
+      text: async () => "",
+    })) as unknown as typeof fetch;
+    const binPath = join(mkdtempSync(join(tmpdir(), "stigmer-server-")), "stigmer-server");
+    await expect(
+      downloadServerBinary({ version: "9.9.9", binPath, platform: "darwin", arch: "arm64", fetchImpl }),
+    ).rejects.toThrow(/HTTP 404/);
+  });
+
+  it("refuses an unsupported platform with actionable guidance", async () => {
+    const binPath = join(mkdtempSync(join(tmpdir(), "stigmer-server-")), "stigmer-server");
+    const fetchImpl = vi.fn() as unknown as typeof fetch;
+    await expect(
+      downloadServerBinary({ version: "0.5.0", binPath, platform: "win32", arch: "x64", fetchImpl }),
+    ).rejects.toThrow(/does not support this platform/);
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+});
+
+describe("ensureServerBinary", () => {
+  it("returns an existing override binary without downloading", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "stigmer-server-"));
+    const bin = join(dir, "stigmer-server");
+    writeFileSync(bin, "#!/bin/sh\n");
+    chmodSync(bin, 0o755);
+    process.env.STIGMER_SERVER_BIN = bin;
+
+    const fetchImpl = vi.fn() as unknown as typeof fetch;
+    const resolved = await ensureServerBinary({ home: dir, version: "0.5.0", fetchImpl });
+
+    expect(resolved).toBe(bin);
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+});