@stigmer/cli 3.12.9 → 3.14.0-dev.20260910084630

package/src/config/keys.ts

@@ -3,7 +3,12 @@
 // managed by their own (later) commands and preserved opaquely on save.
 
 import { UsageError } from "../errors/usage-error.js";
-import type { BackendType, Config } from "./config.js";
+import {
+  CLOUD_BACKEND_NAME,
+  type Config,
+  LOCAL_BACKEND_NAME,
+  activeBackendName,
+} from "./config.js";
 
 interface ConfigKey {
   /** Stored (non-resolved) value, "" when unset. */
@@ -12,26 +17,54 @@ interface ConfigKey {
   set(config: Config, value: string): void;
 }
 
+// The backend.cloud.* keys predate named backends and remain the documented
+// kv surface for the reserved "cloud" entry; `current_backend` is the named
+// model's own key. `backend.type` stays the simple local/cloud switch
+// (named backends switch through `config backend use`).
 const KEYS: Record<string, ConfigKey> = {
   "backend.type": {
-    get: (config) => config.backend.type,
+    get: (config) =>
+      activeBackendName(config) === LOCAL_BACKEND_NAME ? "local" : "cloud",
     set: (config, value) => {
       if (value !== "local" && value !== "cloud") {
-        throw new UsageError(`invalid backend.type "${value}" (expected: local, cloud)`);
+        throw new UsageError(
+          `invalid backend.type "${value}" (expected: local, cloud)`,
+        );
       }
-      config.backend.type = value as BackendType;
+      if (value === "cloud") {
+        (config.backends ??= {})[CLOUD_BACKEND_NAME] ??= { type: "cloud" };
+        config.current_backend = CLOUD_BACKEND_NAME;
+      } else {
+        config.current_backend = LOCAL_BACKEND_NAME;
+      }
+    },
+  },
+  current_backend: {
+    get: (config) => activeBackendName(config),
+    set: (config, value) => {
+      if (
+        value !== LOCAL_BACKEND_NAME &&
+        config.backends?.[value] === undefined
+      ) {
+        throw new UsageError(
+          `unknown backend "${value}" (add it first: stigmer config backend add)`,
+        );
+      }
+      config.current_backend = value;
     },
   },
   "backend.cloud.endpoint": {
-    get: (config) => config.backend.cloud?.endpoint ?? "",
+    get: (config) => config.backends?.[CLOUD_BACKEND_NAME]?.endpoint ?? "",
     set: (config, value) => {
-      (config.backend.cloud ??= {}).endpoint = value;
+      const backends = (config.backends ??= {});
+      (backends[CLOUD_BACKEND_NAME] ??= { type: "cloud" }).endpoint = value;
     },
   },
   "backend.cloud.org_id": {
-    get: (config) => config.backend.cloud?.org_id ?? "",
+    get: (config) => config.backends?.[CLOUD_BACKEND_NAME]?.org_id ?? "",
     set: (config, value) => {
-      (config.backend.cloud ??= {}).org_id = value;
+      const backends = (config.backends ??= {});
+      (backends[CLOUD_BACKEND_NAME] ??= { type: "cloud" }).org_id = value;
     },
   },
   "context.organization": {
@@ -53,7 +86,11 @@ export function getConfigValue(config: Config, key: string): string {
   return entry.get(config);
 }
 
-export function setConfigValue(config: Config, key: string, value: string): void {
+export function setConfigValue(
+  config: Config,
+  key: string,
+  value: string,
+): void {
   const entry = KEYS[key];
   if (entry === undefined) throw new UsageError(unknownKeyMessage(key));
   entry.set(config, value);

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:8234");
+    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 { WEB_CONSOLE_PORT } from "../local/constants.js";
-import { type BackendType, type Config, isCloudMode } from "./config.js";
+import { SERVER_PORT } from "../local/constants.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,53 +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:{WEB_CONSOLE_PORT}`
- *   3. cloud backend → {@link DEFAULT_CLOUD_CONSOLE_URL}
+ *   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. 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.
+ * 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:${WEB_CONSOLE_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/constants.ts

@@ -7,12 +7,16 @@
 // runner-poll can never drift (see the T05 plan's "Critical correctness
 // finding").
 
-/** Port `stigmer-server` listens on (gRPC). Matches the Go CLI's `DaemonPort`. */
+/**
+ * Port `stigmer-server` listens on (gRPC). Matches the Go CLI's `DaemonPort`.
+ *
+ * This is also the web console's origin: since DD-012 the server serves the
+ * console's static export on this same unified port (lane 4), so the Go-era
+ * WEB_CONSOLE_PORT (8234, a separate CLI-embedded listener) is retired —
+ * one process, one origin, no CORS hop.
+ */
 export const SERVER_PORT = 7234;
 
-/** Port the embedded web console is served on (7xxx=API, 8xxx=UI convention). */
-export const WEB_CONSOLE_PORT = 8234;
-
 /** Temporal frontend gRPC port (dev server default). */
 export const TEMPORAL_PORT = 7233;
 

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

@@ -11,7 +11,7 @@ const config: DaemonConfig = {
   temporalAddress: "127.0.0.1:7233",
   serverOnly: false,
   noWeb: false,
-  serverBin: "/bin/stigmer-server",
+  server: { nodeBin: "/bin/node", entryPath: "/repo/server/dist/main.js", appDir: "/repo/server" },
   runner: { nodeBin: "/bin/node", entryPath: "/repo/runner/dist/main.js", appDir: "/repo/runner" },
 };
 
@@ -133,6 +133,14 @@ describe("buildComponents", () => {
     expect(runner.resolve().args).toEqual(["/repo/runner/dist/main.js"]);
   });
 
+  // The TS server child is `node <entry>` — the runner's launch shape.
+  it("spawns the node-shape server as node + entry", () => {
+    const [server] = buildComponents(config, {});
+    const spawn = server.resolve();
+    expect(spawn.command).toBe("/bin/node");
+    expect(spawn.args).toEqual(["/repo/server/dist/main.js"]);
+  });
+
   it("omits the runner in server-only mode", () => {
     const components = buildComponents({ ...config, serverOnly: true }, {});
     expect(components.map((c) => c.name)).toEqual(["stigmer-server"]);

package/src/local/daemon/components.ts

@@ -91,9 +91,11 @@ export function buildComponents(config: DaemonConfig, base: NodeJS.ProcessEnv =
       name: "stigmer-server",
       pidFile: join(config.dataDir, SERVER_PID_FILE),
       critical: true,
+      // The server is `node <entry>` — the runner's launch shape, one child
+      // contract for both components.
       resolve: () => ({
-        command: config.serverBin,
-        args: [],
+        command: config.server.nodeBin,
+        args: [config.server.entryPath],
         env: buildServerEnv(config, base),
         logFile: join(config.logDir, "stigmer-server.log"),
       }),

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

@@ -128,7 +128,7 @@ describe("runInternalDaemon (full body with fakes)", () => {
       temporalAddress: "127.0.0.1:7233",
       serverOnly: false,
       noWeb: true,
-      serverBin: "server-cmd",
+      server: { nodeBin: "node-cmd", entryPath: join(data, "server-entry.js"), appDir: data },
       runner: { nodeBin: "node-cmd", entryPath: join(data, "entry.js"), appDir: data },
     };