@stigmer/cli 3.13.0 → 3.14.0

package/src/config/resolve.test.ts

@@ -1,6 +1,11 @@
+// Pins the effective-value resolvers over the named-backend model (O3):
+// env > active entry > defaults for endpoint/token/org/console-URL, the
+// selfhost credential lane (api_key), and the auth gate's three postures
+// (local never, selfhost never client-side, cloud requires a credential).
+
 import { afterEach, describe, expect, it } from "vitest";
 import { CliExitError } from "../errors/index.js";
-import type { Config } from "./config.js";
+import type { Config, NamedBackendConfig } from "./config.js";
 import {
   DEFAULT_CLOUD_CONSOLE_URL,
   ensureAuthenticated,
@@ -11,29 +16,78 @@ import {
   resolveToken,
 } from "./resolve.js";
 
-const ENV_KEYS = ["STIGMER_SERVER_ADDRESS", "STIGMER_API_KEY", "STIGMER_ORG_ID"] as const;
+const ENV_KEYS = [
+  "STIGMER_SERVER_ADDRESS",
+  "STIGMER_API_KEY",
+  "STIGMER_ORG_ID",
+] as const;
 
 afterEach(() => {
   for (const key of ENV_KEYS) delete process.env[key];
 });
 
-function cloudConfig(overrides: Partial<Config["backend"]["cloud"]> = {}): Config {
-  return { backend: { type: "cloud", cloud: { endpoint: "cloud.example:443", ...overrides } } };
+function localConfig(context?: Config["context"]): Config {
+  return {
+    backend: { type: "local" },
+    backends: {},
+    current_backend: "local",
+    context,
+  };
+}
+
+function cloudConfig(
+  overrides: Partial<NamedBackendConfig> = {},
+  context?: Config["context"],
+): Config {
+  return {
+    backend: { type: "cloud" },
+    backends: {
+      cloud: { type: "cloud", endpoint: "cloud.example:443", ...overrides },
+    },
+    current_backend: "cloud",
+    context,
+  };
+}
+
+function selfhostConfig(overrides: Partial<NamedBackendConfig> = {}): Config {
+  return {
+    backend: { type: "cloud" },
+    backends: {
+      staging: {
+        type: "selfhost",
+        endpoint: "stigmer.example.com:7234",
+        ...overrides,
+      },
+    },
+    current_backend: "staging",
+  };
 }
 
 describe("resolveEndpoint", () => {
   it("defaults to the local daemon address in local mode", () => {
-    expect(resolveEndpoint({ backend: { type: "local" } })).toBe("localhost:7234");
+    expect(resolveEndpoint(localConfig())).toBe("localhost:7234");
   });
 
   it("uses the cloud default when no endpoint is configured", () => {
-    expect(resolveEndpoint({ backend: { type: "cloud" } })).toBe("api.stigmer.ai:443");
+    expect(resolveEndpoint(cloudConfig({ endpoint: undefined }))).toBe(
+      "api.stigmer.ai:443",
+    );
   });
 
   it("prefers the configured cloud endpoint", () => {
     expect(resolveEndpoint(cloudConfig())).toBe("cloud.example:443");
   });
 
+  it("uses the selfhost entry's endpoint", () => {
+    expect(resolveEndpoint(selfhostConfig())).toBe("stigmer.example.com:7234");
+  });
+
+  it("refuses a selfhost entry without an endpoint (hand-edited config)", () => {
+    expect(() =>
+      resolveEndpoint(selfhostConfig({ endpoint: undefined })),
+    ).toThrow(CliExitError);
+  });
+
   it("lets STIGMER_SERVER_ADDRESS override everything", () => {
     process.env.STIGMER_SERVER_ADDRESS = "override:7234";
     expect(resolveEndpoint(cloudConfig())).toBe("override:7234");
@@ -43,15 +97,27 @@ describe("resolveEndpoint", () => {
 describe("resolveToken", () => {
   it("prefers STIGMER_API_KEY over the config token", () => {
     process.env.STIGMER_API_KEY = "env-key";
-    expect(resolveToken(cloudConfig({ token: "config-token" }))).toBe("env-key");
+    expect(resolveToken(cloudConfig({ token: "config-token" }))).toBe(
+      "env-key",
+    );
   });
 
-  it("falls back to the config token", () => {
-    expect(resolveToken(cloudConfig({ token: "config-token" }))).toBe("config-token");
+  it("falls back to the cloud entry's login token", () => {
+    expect(resolveToken(cloudConfig({ token: "config-token" }))).toBe(
+      "config-token",
+    );
+  });
+
+  it("uses the selfhost entry's api_key", () => {
+    expect(resolveToken(selfhostConfig({ api_key: "stk_stored" }))).toBe(
+      "stk_stored",
+    );
   });
 
   it("returns empty string when unauthenticated", () => {
-    expect(resolveToken({ backend: { type: "cloud" } })).toBe("");
+    expect(resolveToken(cloudConfig({ endpoint: undefined }))).toBe("");
+    expect(resolveToken(selfhostConfig())).toBe("");
+    expect(resolveToken(localConfig())).toBe("");
   });
 });
 
@@ -62,64 +128,95 @@ describe("resolveOrganization", () => {
     expect(resolveOrganization(config, "flag-org")).toBe("flag-org");
   });
 
-  it("falls back to STIGMER_ORG_ID, then context, then cloud org_id", () => {
+  it("falls back to STIGMER_ORG_ID, then context, then the entry's org_id", () => {
     process.env.STIGMER_ORG_ID = "env-org";
-    expect(resolveOrganization(cloudConfig({ org_id: "config-org" }))).toBe("env-org");
+    expect(resolveOrganization(cloudConfig({ org_id: "config-org" }))).toBe(
+      "env-org",
+    );
   });
 
   it("uses context organization when no flag/env is set", () => {
-    const config: Config = {
-      backend: { type: "cloud", cloud: { org_id: "legacy" } },
-      context: { organization: "ctx-org" },
-    };
+    const config = cloudConfig(
+      { org_id: "legacy" },
+      { organization: "ctx-org" },
+    );
     expect(resolveOrganization(config)).toBe("ctx-org");
     expect(resolveContextOrganization(config)).toBe("ctx-org");
   });
 
-  it("falls back to legacy cloud org_id", () => {
-    expect(resolveContextOrganization(cloudConfig({ org_id: "legacy" }))).toBe("legacy");
+  it("falls back to the entry's org_id", () => {
+    expect(resolveContextOrganization(cloudConfig({ org_id: "legacy" }))).toBe(
+      "legacy",
+    );
   });
 
   it("defaults to the seedpack org in local mode when nothing is configured", () => {
-    expect(resolveOrganization({ backend: { type: "local" } })).toBe("stigmer");
+    expect(resolveOrganization(localConfig())).toBe("stigmer");
+  });
+
+  it("defaults to the seedpack org on a selfhost backend (it IS the OSS server)", () => {
+    expect(resolveOrganization(selfhostConfig())).toBe("stigmer");
   });
 
   it("prefers an explicit context org over the local default", () => {
-    const config: Config = { backend: { type: "local" }, context: { organization: "my-local-org" } };
-    expect(resolveOrganization(config)).toBe("my-local-org");
+    expect(
+      resolveOrganization(localConfig({ organization: "my-local-org" })),
+    ).toBe("my-local-org");
   });
 
   it("does not apply the local default in cloud mode (org stays empty)", () => {
-    expect(resolveOrganization({ backend: { type: "cloud" } })).toBe("");
+    expect(resolveOrganization(cloudConfig({ endpoint: undefined }))).toBe("");
   });
 
   it("reports an unset local org as empty via resolveContextOrganization (no implicit default)", () => {
     // The implicit local default lives only in resolveOrganization (effective
     // org for operations); the context query must stay faithful so config/context
     // display can show "(not set)".
-    expect(resolveContextOrganization({ backend: { type: "local" } })).toBe("");
+    expect(resolveContextOrganization(localConfig())).toBe("");
   });
 });
 
 describe("resolveConsoleURL", () => {
   it("prefers the STIGMER_CONSOLE_URL override", () => {
-    expect(resolveConsoleURL("cloud", { STIGMER_CONSOLE_URL: "https://console.example" } as NodeJS.ProcessEnv)).toBe(
-      "https://console.example",
-    );
+    expect(
+      resolveConsoleURL(cloudConfig(), {
+        STIGMER_CONSOLE_URL: "https://console.example",
+      } as NodeJS.ProcessEnv),
+    ).toBe("https://console.example");
   });
 
   it("uses the local web-console port for the local backend", () => {
-    expect(resolveConsoleURL("local", {} as NodeJS.ProcessEnv)).toBe("http://localhost:7234");
+    expect(resolveConsoleURL(localConfig(), {} as NodeJS.ProcessEnv)).toBe(
+      "http://localhost:7234",
+    );
   });
 
   it("uses the cloud console URL for the cloud backend", () => {
-    expect(resolveConsoleURL("cloud", {} as NodeJS.ProcessEnv)).toBe(DEFAULT_CLOUD_CONSOLE_URL);
+    expect(resolveConsoleURL(cloudConfig(), {} as NodeJS.ProcessEnv)).toBe(
+      DEFAULT_CLOUD_CONSOLE_URL,
+    );
+  });
+
+  it("derives the selfhost console from the entry's endpoint (one-origin rule)", () => {
+    expect(resolveConsoleURL(selfhostConfig(), {} as NodeJS.ProcessEnv)).toBe(
+      "http://stigmer.example.com:7234",
+    );
+    expect(
+      resolveConsoleURL(
+        selfhostConfig({ endpoint: "stigmer.example.com:443" }),
+        {} as NodeJS.ProcessEnv,
+      ),
+    ).toBe("https://stigmer.example.com");
   });
 });
 
 describe("ensureAuthenticated", () => {
   it("never requires auth in local mode", () => {
-    expect(() => ensureAuthenticated({ backend: { type: "local" } })).not.toThrow();
+    expect(() => ensureAuthenticated(localConfig())).not.toThrow();
+  });
+
+  it("never gates selfhost client-side (the server owns that decision)", () => {
+    expect(() => ensureAuthenticated(selfhostConfig())).not.toThrow();
   });
 
   it("throws in cloud mode with no credentials", () => {
@@ -127,15 +224,19 @@ describe("ensureAuthenticated", () => {
   });
 
   it("passes with a stored access token", () => {
-    expect(() => ensureAuthenticated(cloudConfig({ token: "t" }))).not.toThrow();
+    expect(() =>
+      ensureAuthenticated(cloudConfig({ token: "t" })),
+    ).not.toThrow();
   });
 
-  it("passes with only a refresh token", () => {
-    expect(() => ensureAuthenticated(cloudConfig({ refresh_token: "r" }))).not.toThrow();
+  it("passes with only a refresh token (silent refresh will mint one)", () => {
+    expect(() =>
+      ensureAuthenticated(cloudConfig({ refresh_token: "r" })),
+    ).not.toThrow();
   });
 
-  it("passes with STIGMER_API_KEY set", () => {
-    process.env.STIGMER_API_KEY = "env-key";
+  it("passes with STIGMER_API_KEY in the environment", () => {
+    process.env.STIGMER_API_KEY = "stk_env";
     expect(() => ensureAuthenticated(cloudConfig())).not.toThrow();
   });
 });

package/src/config/resolve.ts

@@ -1,10 +1,14 @@
 // Effective-value resolution with env > config > default precedence. These are
 // the settings the backend client and read verbs depend on; centralizing the
 // precedence keeps every call site consistent (mirrors the Go CLI's Resolve*).
+//
+// All resolvers read the ACTIVE named backend (config.ts): local is the
+// managed daemon (fixed endpoint, never requires auth), cloud entries carry
+// the OAuth token set, selfhost entries carry an endpoint + api_key.
 
 import { CliExitError, ExitCode } from "../errors/index.js";
 import { SERVER_PORT } from "../local/constants.js";
-import { type BackendType, type Config, isCloudMode } from "./config.js";
+import { type Config, activeBackend, isCloudMode } from "./config.js";
 
 const DEFAULT_CLOUD_ENDPOINT = "api.stigmer.ai:443";
 const DEFAULT_LOCAL_ENDPOINT = "localhost:7234";
@@ -15,45 +19,68 @@ export const DEFAULT_CLOUD_CONSOLE_URL = "https://app.stigmer.ai";
 // Local mode is single-tenant: the seedpack bootstraps resources into the
 // "stigmer" org (see client-apps/cli/src/local/seedpack/apply.ts DEFAULT_ORG).
 // Org-scoped getByReference now requires an org, so bare-slug `get`/`run`/`apply`
-// in local mode fall back to this default when nothing else is configured. Cloud
-// mode has no implicit org — the caller must select one (flag/env/context/login).
+// in local mode fall back to this default when nothing else is configured. The
+// same holds for selfhost backends — they ARE the OSS server. Cloud mode has no
+// implicit org — the caller must select one (flag/env/context/login).
 const DEFAULT_LOCAL_ORG = "stigmer";
 
 /**
  * Resolve the server endpoint.
- *   STIGMER_SERVER_ADDRESS  (explicit override, either backend)
- *   > cloud.endpoint        (cloud mode)
- *   > api.stigmer.ai:443    (cloud default) / localhost:7234 (local default)
+ *   STIGMER_SERVER_ADDRESS   (explicit override, any backend)
+ *   > the active entry's endpoint (cloud falls back to api.stigmer.ai:443)
+ *   > localhost:7234          (the local daemon)
+ *
+ * A selfhost entry without an endpoint is a loud configuration error —
+ * `config backend add` requires one, so this only happens to hand-edited
+ * files, and guessing an address for a self-hosted server helps nobody.
  */
 export function resolveEndpoint(config: Config): string {
   const override = process.env.STIGMER_SERVER_ADDRESS;
   if (override !== undefined && override !== "") {
     return override;
   }
-  if (isCloudMode(config)) {
-    return config.backend.cloud?.endpoint || DEFAULT_CLOUD_ENDPOINT;
+  const { name, entry } = activeBackend(config);
+  if (entry === undefined) {
+    return DEFAULT_LOCAL_ENDPOINT;
+  }
+  if (entry.endpoint !== undefined && entry.endpoint !== "") {
+    return entry.endpoint;
+  }
+  if (entry.type === "cloud") {
+    return DEFAULT_CLOUD_ENDPOINT;
   }
-  return DEFAULT_LOCAL_ENDPOINT;
+  throw new CliExitError(
+    `backend "${name}" has no endpoint configured`,
+    ExitCode.Usage,
+    [
+      `Re-add it with one:`,
+      `  stigmer config backend add ${name} --endpoint <host:port>`,
+    ],
+  );
 }
 
 /**
  * Resolve the auth token.
- *   STIGMER_API_KEY  (env, also where the --api-key global is bridged)
- *   > cloud.token    (persisted login token)
- *   > ""             (unauthenticated)
+ *   STIGMER_API_KEY   (env, also where the --api-key global is bridged)
+ *   > the active entry's credential (cloud: login token; selfhost: api_key)
+ *   > ""              (unauthenticated)
  */
 export function resolveToken(config: Config): string {
   const env = process.env.STIGMER_API_KEY;
   if (env !== undefined && env !== "") {
     return env;
   }
-  return config.backend.cloud?.token ?? "";
+  const { entry } = activeBackend(config);
+  if (entry === undefined) {
+    return "";
+  }
+  return (entry.type === "cloud" ? entry.token : entry.api_key) ?? "";
 }
 
 /**
  * Resolve the active organization.
  *   --org flag override > STIGMER_ORG_ID env > context.organization
- *   > cloud.org_id (legacy fallback)
+ *   > the active entry's org_id (legacy fallback)
  */
 export function resolveOrganization(config: Config, flagOrg?: string): string {
   if (flagOrg !== undefined && flagOrg !== "") {
@@ -67,56 +94,76 @@ export function resolveOrganization(config: Config, flagOrg?: string): string {
   if (context !== "") {
     return context;
   }
-  // Nothing configured: local mode falls back to its single-tenant default org
-  // so bare-slug operations resolve without ceremony; cloud stays empty (the
-  // caller must select an org, e.g. apply raises a clear "organization not set").
+  // Nothing configured: local and selfhost fall back to the single-tenant
+  // default org so bare-slug operations resolve without ceremony; cloud
+  // stays empty (the caller must select an org, e.g. apply raises a clear
+  // "organization not set").
   return isCloudMode(config) ? "" : DEFAULT_LOCAL_ORG;
 }
 
 /**
  * Resolve the web console URL:
  *   1. `STIGMER_CONSOLE_URL` (explicit override)
- *   2. local backend → `http://localhost:{SERVER_PORT}` — the server's own
+ *   2. local daemon → `http://localhost:{SERVER_PORT}` — the server's own
  *      unified port serves the console since DD-012 (one origin for UI and
  *      API; the Go-era separate 8234 listener is retired)
- *   3. cloud backend → {@link DEFAULT_CLOUD_CONSOLE_URL}
+ *   3. selfhost → the entry's endpoint on the same one-origin rule
+ *      (https for :443, http otherwise)
+ *   4. cloud → {@link DEFAULT_CLOUD_CONSOLE_URL}
  *
  * The console origin is also the app origin that serves the hosted chat
  * page (`/chat/<org>/<slug>`) and the embed loader (`/embed.js`), so
  * share-link builders use this same resolver — both routes live in the
  * same static export the server serves.
  */
-export function resolveConsoleURL(backendType: BackendType, env: NodeJS.ProcessEnv = process.env): string {
+export function resolveConsoleURL(
+  config: Config,
+  env: NodeJS.ProcessEnv = process.env,
+): string {
   const override = env.STIGMER_CONSOLE_URL;
   if (override !== undefined && override !== "") return override;
-  if (backendType === "local") return `http://localhost:${SERVER_PORT}`;
+  const { entry } = activeBackend(config);
+  if (entry === undefined) return `http://localhost:${SERVER_PORT}`;
+  if (entry.type === "selfhost") {
+    const endpoint = entry.endpoint ?? "";
+    const scheme = endpoint.endsWith(":443") ? "https" : "http";
+    return `${scheme}://${endpoint.replace(/:443$/, "")}`;
+  }
   return DEFAULT_CLOUD_CONSOLE_URL;
 }
 
 /**
- * The configured organization, with the legacy cloud.org_id fallback. Reports
- * only what is explicitly set (no implicit local default) so config/context
- * display can faithfully show "(not set)".
+ * The configured organization, with the active entry's org_id fallback.
+ * Reports only what is explicitly set (no implicit local default) so
+ * config/context display can faithfully show "(not set)".
  */
 export function resolveContextOrganization(config: Config): string {
-  if (config.context?.organization !== undefined && config.context.organization !== "") {
+  if (
+    config.context?.organization !== undefined &&
+    config.context.organization !== ""
+  ) {
     return config.context.organization;
   }
-  return config.backend.cloud?.org_id ?? "";
+  return activeBackend(config).entry?.org_id ?? "";
 }
 
 /**
- * Fail fast with a clear "please log in" error when a cloud command has no
- * usable credential. Local mode never requires auth. A credential is any of:
- * the STIGMER_API_KEY env (or bridged --api-key), a persisted access token, or
- * a refresh token (which the token provider can exchange for a fresh access
- * token). This lives in the config layer — not the client façade — because it
- * is purely a question of which credentials are configured.
+ * Fail fast with a clear "please log in" error when a CLOUD command has no
+ * usable credential. The local daemon never requires auth. Selfhost
+ * backends are deliberately not gated client-side: an unauthenticated
+ * self-host (no issuer configured) is a legitimate posture, and an
+ * authenticated one answers UNAUTHENTICATED with a clear message — the
+ * server owns that decision. A credential is any of: the STIGMER_API_KEY
+ * env (or bridged --api-key), a persisted access token, or a refresh token
+ * (which the token provider can exchange for a fresh access token).
  */
 export function ensureAuthenticated(config: Config): void {
-  if (!isCloudMode(config)) return;
+  const { entry } = activeBackend(config);
+  if (entry?.type !== "cloud") return;
   if (process.env.STIGMER_API_KEY) return;
-  const cloud = config.backend.cloud;
-  if (cloud?.token || cloud?.refresh_token) return;
-  throw new CliExitError("Not authenticated", ExitCode.Auth, ["Please sign in:", "  stigmer auth login"]);
+  if (entry.token || entry.refresh_token) return;
+  throw new CliExitError("Not authenticated", ExitCode.Auth, [
+    "Please sign in:",
+    "  stigmer auth login",
+  ]);
 }

package/src/local/seedpack/content.ts

@@ -1,7 +1,7 @@
 // Resolution and on-demand acquisition of the seedpack content.
 //
 // The seedpack (system agents, skills, MCP servers, workflows under the
-// "stigmer" org) is the TS equivalent of the Go CLI's `go:embed`-ed bundle.
+// "stigmer" org) is the system content every backend is bootstrapped with.
 // A lean `npx @stigmer/cli` must not carry ~300 content files (DD-002), so the
 // content ships as `@stigmer/seedpack` and is acquired on demand — the same
 // pattern as `@stigmer/runner-slim` and the managed Temporal binary.
@@ -12,14 +12,22 @@
 //      ~/.stigmer/runtimes/<version>/ and read from
 //      node_modules/@stigmer/seedpack.
 //
-// The content-hash and extract logic mirror `@stigmer/seedpack` exactly (which
-// in turn mirrors the Go `seedpack` package); the CLI reimplements them over a
-// resolved directory so it stays decoupled from the package in the lean install
-// (where the package is not a dependency, only an on-demand artifact).
+// The content-hash and extract logic mirror `@stigmer/seedpack` exactly; the CLI
+// reimplements them over a resolved directory so it stays decoupled from the
+// package in the lean install (where the package is not a dependency, only an
+// on-demand artifact). `seedpack/src/index.ts` is the one definition both follow.
 
 import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, posix, relative, sep } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -33,9 +41,9 @@ const SEEDPACK_PACKAGE = "@stigmer/seedpack";
 
 /**
  * The canonical seedpack entries, in apply-safe order. Kept in sync with
- * `SEEDPACK_ENTRIES` in `@stigmer/seedpack` and the `//go:embed` set in
- * `seedpack/embed.go` — `tools/`, `icons/`, and `canary/` (CI canary metadata,
- * not a resource) are deliberately excluded so the content set (and thus the
+ * `SEEDPACK_ENTRIES` in `@stigmer/seedpack` (`seedpack/src/index.ts`, the one
+ * definition) — `tools/`, `icons/`, and `canary/` (CI canary metadata, not a
+ * resource) are deliberately excluded so the content set (and thus the
  * idempotency hash) is identical across delivery paths.
  */
 export const SEEDPACK_ENTRIES = [
@@ -70,7 +78,9 @@ export interface ResolveSeedpackOptions {
  * on-demand-acquired `@stigmer/seedpack` package. Throws actionable guidance when
  * acquisition is not possible (non-release build, or a failed/incomplete install).
  */
-export function resolveSeedpackContent(opts: ResolveSeedpackOptions = {}): SeedpackContent {
+export function resolveSeedpackContent(
+  opts: ResolveSeedpackOptions = {},
+): SeedpackContent {
   const repo = repoSeedpackDir();
   if (repo !== null) return { dir: repo, source: "repo" };
   return { dir: acquireSeedpack(opts), source: "package" };
@@ -86,10 +96,14 @@ export function acquireSeedpack(opts: ResolveSeedpackOptions = {}): string {
   const home = opts.home ?? homedir();
   const version = opts.version ?? VERSION;
   if (!isAcquirableRelease(version)) {
-    throw new CliExitError(`cannot acquire ${SEEDPACK_PACKAGE} for a non-release build (${version})`, ExitCode.General, [
-      "Run from the repo (the seedpack/ tree is used directly in dev).",
-      "On-demand acquisition is only available for published releases.",
-    ]);
+    throw new CliExitError(
+      `cannot acquire ${SEEDPACK_PACKAGE} for a non-release build (${version})`,
+      ExitCode.General,
+      [
+        "Run from the repo (the seedpack/ tree is used directly in dev).",
+        "On-demand acquisition is only available for published releases.",
+      ],
+    );
   }
 
   const installDir = join(runtimesDir(home), version);
@@ -103,16 +117,21 @@ export function acquireSeedpack(opts: ResolveSeedpackOptions = {}): string {
     // additive and non-pruning, so this prefix is safely shared with the runner.
     const rootPkg = join(installDir, "package.json");
     if (!existsSync(rootPkg)) {
-      writeFileSync(rootPkg, `${JSON.stringify({ name: "stigmer-runtime", private: true, version: "0.0.0" }, null, 2)}\n`);
+      writeFileSync(
+        rootPkg,
+        `${JSON.stringify({ name: "stigmer-runtime", private: true, version: "0.0.0" }, null, 2)}\n`,
+      );
     }
     const install = opts.install ?? installSeedpack;
     install(installDir, `${SEEDPACK_PACKAGE}@${version}`);
   }
 
   if (!existsSync(marker)) {
-    throw new CliExitError(`${SEEDPACK_PACKAGE} install did not produce ${marker}`, ExitCode.General, [
-      `Remove ${installDir} and retry.`,
-    ]);
+    throw new CliExitError(
+      `${SEEDPACK_PACKAGE} install did not produce ${marker}`,
+      ExitCode.General,
+      [`Remove ${installDir} and retry.`],
+    );
   }
   return pkgDir;
 }
@@ -121,9 +140,21 @@ export function acquireSeedpack(opts: ResolveSeedpackOptions = {}): string {
 // the user sees the one-time download progress.
 function installSeedpack(installDir: string, spec: string): void {
   try {
-    execFileSync("npm", ["install", spec, "--prefix", installDir, "--omit=dev", "--no-audit", "--no-fund"], {
-      stdio: "inherit",
-    });
+    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}`,