@stigmer/server 3.17.0 → 3.18.0

package/src/domain/oauthapp/__tests__/oauthapp.test.ts

@@ -330,8 +330,8 @@ describe("oauthapp domain (encryption enabled)", () => {
 
     it("blocks through the unique-slug fallback (ref pinned to a foreign org)", async () => {
       const app = await ts.command.create(appInput());
-      // The seedpack posture: ref pinned to `org: stigmer`, app applied in
-      // the user's own org — resolution reaches it via unique slug (#584).
+      // A public server's posture: ref pinned to `org: stigmer`, app applied
+      // in the user's own org — resolution reaches it via unique slug (#584).
       await seedReferencingMcpServer(
         ts.server.store,
         "mcps_01reffallback",

package/src/domain/oauthapp/__tests__/refresolution.test.ts

@@ -1,7 +1,7 @@
 /**
  * Pins the OAuthApp ref-resolution ladder against Go's
  * refresolution_test.go table: exact (org, slug) wins; a UNIQUE slug-only
- * match is honored across orgs (the seedpack `org: stigmer` case, #584);
+ * match is honored across orgs (a public server's `org: stigmer` ref, #584);
  * ambiguity resolves to nothing; an empty slug is the DCR/manual-token
  * arm, not a lookup.
  */
@@ -58,7 +58,7 @@ describe("resolveOAuthAppRef", () => {
     expect(app?.metadata?.id).toBe("oaa_github_beta");
   });
 
-  it("honors a UNIQUE slug-only match when the ref's org has no app (the seedpack case, #584)", async () => {
+  it("honors a UNIQUE slug-only match when the ref's org has no app (a public server's ref, #584)", async () => {
     // Two orgs hold 'github' and neither is 'stigmer': ambiguous → nothing.
     expect(await resolveOAuthAppRef(store, ref("stigmer", "github"), silentLogger)).toBeUndefined();
 

package/src/domain/oauthapp/refresolution/refresolution.ts

@@ -18,7 +18,7 @@
  *  1. An exact (org, slug) match wins — unique by the create pipeline's
  *     duplicate check.
  *  2. Otherwise a slug-only match is honored when it is UNIQUE. This lets
- *     a self-hosted deployment satisfy seedpack refs pinned to
+ *     a deployment satisfy a public server's ref pinned to
  *     `org: stigmer` with an OAuthApp applied in the user's own org (#584).
  *  3. Two or more slug matches with no exact hit resolve to nothing, with
  *     a WARN naming the candidate orgs: ambiguity is never silently

package/src/domain/oauthapp/refresolution.ts

@@ -18,7 +18,7 @@
  *  1. An exact (org, slug) match wins. Uniqueness is guaranteed by the
  *     create pipeline's duplicate check.
  *  2. Otherwise a slug-only match is honored when it is UNIQUE — what
- *     lets a self-hosted deployment satisfy seedpack refs pinned to
+ *     lets a deployment satisfy a public server's ref pinned to
  *     `org: stigmer` with an OAuthApp applied in the user's own org.
  *  3. Two or more slug matches with no exact hit resolve to nothing, with
  *     a WARN naming the candidate orgs: ambiguity is never silently

package/src/domain/platform/__tests__/platform.test.ts

@@ -15,6 +15,9 @@
  *     execution id;
  *   - getRunnerBootstrapConfig echoes the configured Temporal coordinates
  *     with the token fields empty (minting a proxy token is cloud-only);
+ *   - getServerInfo reports the build stamp by default and the release a
+ *     library consumer states through ComposeOptions.version otherwise
+ *     (stigmer#1168: unbundled, the stamp is always "dev");
  *   - getLicenseStatus answers `absent` with no claims and no key when no
  *     provider is composed, and the composed provider's report verbatim
  *     when one is — both stamped with the ONE instant the controller
@@ -229,6 +232,48 @@ describe("platform domain (composed server)", () => {
   });
 });
 
+describe("platform domain (composed with a stated version)", () => {
+  let server: ComposedServer;
+  let client: PlatformClient;
+  let dir: string;
+
+  beforeAll(async () => {
+    dir = mkdtempSync(path.join(tmpdir(), "platform-domain-version-test-"));
+    vi.stubEnv("STIGMER_ENCRYPTION_KEY", ENC_KEY.toString("base64"));
+    server = await composeServer({
+      config: loadConfig({
+        STIGMER_MODEL_REGISTRY_REFRESH: "off",
+        DB_PATH: path.join(dir, "stigmer.db"),
+        ARTIFACT_LOCAL_BASE_PATH: path.join(dir, "artifacts"),
+      }),
+      logger: silentLogger,
+      version: "3.99.0",
+      portOverride: 0,
+      host: "127.0.0.1",
+    });
+    const port = await server.start();
+    client = createClient(
+      PlatformQueryController,
+      createGrpcTransport({ baseUrl: `http://127.0.0.1:${port}` }),
+    );
+  });
+
+  afterAll(async () => {
+    await server.shutdown();
+    rmSync(dir, { recursive: true, force: true });
+    vi.unstubAllEnvs();
+  });
+
+  it("getServerInfo reports the composition's stated release, not the build stamp", async () => {
+    // A library consumer (the cloud composition) runs no bundle, so the
+    // define is never stamped for it; ComposeOptions.version is how it
+    // states the release it installed. Edition is untouched by it.
+    const info = await client.getServerInfo({});
+    expect(info.version).toBe("3.99.0");
+    expect(info.edition).toBe(ServerEdition.oss);
+  });
+});
+
 describe("platform domain (keyless runner-token service)", () => {
   it("a keyless service answers not-minted — fail-soft, never an error", async () => {
     const transport = createRouterTransport((router) => {
@@ -239,6 +284,7 @@ describe("platform domain (keyless runner-token service)", () => {
           RunnerAuthService.create(undefined),
         ),
         edition: ServerEdition.oss,
+        version: "dev",
         licenseStatus: ABSENT_LICENSE_STATUS,
         now: () => new Date(),
         logger: silentLogger,
@@ -273,6 +319,7 @@ describe("platform domain (license status)", () => {
           RunnerAuthService.create(undefined),
         ),
         edition: ServerEdition.enterprise,
+        version: "dev",
         licenseStatus: provider,
         now: () => instant,
         logger: silentLogger,

package/src/domain/platform/controller.ts

@@ -7,7 +7,7 @@
  * getRunnerBootstrapConfig and getLicenseStatus shapes; getRunnerScopedToken
  * is deliberately excluded there — its arms are exercised mid-execution)
  * and __tests__/platform.test.ts (the fail-soft mint matrix, the license
- * status arms, the #15 composed-server pattern).
+ * status arms, the stated-version arm, the #15 composed-server pattern).
  *
  * getLicenseStatus is the one arm every edition answers from a driver
  * point: a server's license is a fact about the server, like its edition,
@@ -75,7 +75,6 @@ import type {
   RunnerScopedTokenRequest,
 } from "../../runnerauth/runner-credential-provider.js";
 import { TOKEN_TYPE_EXECUTION_SCOPED } from "../../runnerauth/runnerauth.js";
-import { SERVER_VERSION } from "./version.js";
 
 export interface PlatformControllerDeps {
   /**
@@ -100,6 +99,13 @@ export interface PlatformControllerDeps {
    * cloud composition answers `cloud` without forking this controller.
    */
   readonly edition: ServerEdition;
+  /**
+   * The release reported beside the edition. The composition root resolves
+   * it (ComposeOptions.version, else SERVER_VERSION), so this controller
+   * never reads the build stamp itself: a library consumer with no bundle
+   * states its installed release and answers exactly as a bundle would.
+   */
+  readonly version: string;
   /**
    * What license this server holds (extensions/license-status.ts). The
    * composition root installs the built-in `absent` provider when no unit
@@ -130,11 +136,11 @@ export function registerPlatformServices(
   });
 }
 
-/** Go GetServerInfo: the server edition and build version. */
+/** Go GetServerInfo: the server edition and release version. */
 function getServerInfo(deps: PlatformControllerDeps): GetServerInfoOutput {
   return create(GetServerInfoOutputSchema, {
     edition: deps.edition,
-    version: SERVER_VERSION,
+    version: deps.version,
   });
 }
 

package/src/domain/plugin/__tests__/materialize.test.ts

@@ -8,8 +8,10 @@
  * SKILL.md with the plugin's labels on the request, a version the tag
  * pattern rejects becoming a warning, an overlay that redefines the
  * transport refused, the composed agent declaring its tools' variables
- * (OAuth targets excluded, an authored agent left as written), and the
- * convergence and drop rules over members.
+ * (OAuth targets excluded, an authored agent left as written), and each
+ * planned member's system flag read from its overlay and never from a
+ * skill. The member rules themselves (the slug decision, convergence, the
+ * dropped set) are members.test.ts's.
  */
 import { describe, expect, it } from "vitest";
 
@@ -37,6 +39,7 @@ import { openArchive } from "../../../archive/open.js";
 import {
   PLUGIN_LABEL,
   PLUGIN_VERSION_LABEL,
+  SYSTEM_LABEL,
 } from "../../../pipeline/apiresource-labels.js";
 import {
   DEFAULT_AGENT_INSTRUCTIONS_VERSION,
@@ -45,8 +48,6 @@ import {
 import type { PluginIdentity } from "../materialize/identity.js";
 import { McpServerOverlayError } from "../materialize/mcp-servers.js";
 import { planMaterialization } from "../materialize/plan.js";
-import { droppedMembers, membersConverge } from "../members.js";
-import type { Member } from "../members.js";
 
 const IDENTITY: PluginIdentity = {
   org: "acme",
@@ -231,7 +232,10 @@ describe("planMaterialization", () => {
 
   it("declares the servers' variables on the composed agent so a session asks for them", () => {
     expect(plan.agent!.resource.spec?.env).toEqual({
-      GITHUB_TOKEN: expect.objectContaining({ isSecret: true, optional: false }),
+      GITHUB_TOKEN: expect.objectContaining({
+        isSecret: true,
+        optional: false,
+      }),
     });
   });
 
@@ -259,7 +263,9 @@ describe("planMaterialization", () => {
     );
     // The server still declares it (the connect flow reads it there); the
     // agent does not, because the value comes from a managed environment.
-    expect(withOAuth.mcpServers[0]!.resource.spec?.env).toHaveProperty("GITHUB_TOKEN");
+    expect(withOAuth.mcpServers[0]!.resource.spec?.env).toHaveProperty(
+      "GITHUB_TOKEN",
+    );
     expect(withOAuth.agent!.resource.spec?.env).toEqual({});
   });
 
@@ -313,50 +319,39 @@ describe("planMaterialization", () => {
   });
 });
 
-describe("members: convergence and drops", () => {
-  const digest = "d".repeat(64);
-  const stored: Member[] = [
-    {
-      kind: ApiResourceKind.skill,
-      id: "skl_1",
-      slug: "thermo-review",
-      name: "thermo-review",
-      version: digest,
-    },
-    {
-      kind: ApiResourceKind.agent,
-      id: "agt_1",
-      slug: "thermos",
-      name: "thermos",
-      version: digest,
-    },
-  ];
-  const planned = [
-    {
-      kind: ApiResourceKind.skill,
-      slug: "thermo-review",
-      name: "thermo-review",
-    },
-    { kind: ApiResourceKind.agent, slug: "thermos", name: "thermos" },
-  ];
+describe("planned members: the system flag", () => {
+  const pkg = read(thermos);
 
-  it("converges only when every planned member is present and stamped with the digest", () => {
-    expect(membersConverge(stored, planned, digest)).toBe(true);
-    expect(membersConverge(stored, planned, "e".repeat(64))).toBe(false);
-    expect(membersConverge(stored.slice(1), planned, digest)).toBe(false);
-    expect(
-      membersConverge(
-        [...stored, { ...stored[0]!, slug: "extra", id: "skl_2" }],
-        planned,
-        digest,
-      ),
-    ).toBe(false);
+  it("reads system content from the overlay's labels, never from a skill's request", () => {
+    const authored = create(AgentSchema, {
+      metadata: { name: "thermos", labels: { [SYSTEM_LABEL]: "true" } },
+      spec: create(AgentSpecSchema, { instructions: "You read thermostats." }),
+    });
+    const plan = planMaterialization(
+      pkg,
+      inMemoryPluginFiles(thermos),
+      {
+        agent: { path: "ai.stigmer/agent.yaml", resource: authored },
+        workflows: [],
+        mcpServers: [],
+      },
+      IDENTITY,
+      "",
+    );
+    const byKind = new Map(plan.members.map((m) => [m.kind, m.system]));
+    expect(byKind.get(ApiResourceKind.agent)).toBe(true);
+    expect(byKind.get(ApiResourceKind.skill)).toBe(false);
+    expect(byKind.get(ApiResourceKind.mcp_server)).toBe(false);
   });
 
-  it("drops the members the plan no longer names", () => {
-    expect(droppedMembers(stored, planned.slice(1)).map((m) => m.slug)).toEqual(
-      ["thermo-review"],
+  it("plans no system content when no overlay declares it", () => {
+    const plan = planMaterialization(
+      pkg,
+      inMemoryPluginFiles(thermos),
+      { workflows: [], mcpServers: [] },
+      IDENTITY,
+      "",
     );
-    expect(droppedMembers(stored, planned)).toEqual([]);
+    expect(plan.members.every((m) => m.system === false)).toBe(true);
   });
 });

package/src/domain/plugin/__tests__/members.test.ts

@@ -0,0 +1,149 @@
+/**
+ * Pins the member rules on plain values, no store: the slug decision
+ * (`judgeSlug`) in each of its five arms — free, ours, adopt when system
+ * content meets system content, refused for an unmanaged row whenever
+ * either side lacks the label, refused for another plugin's member
+ * whatever labels either side carries — and the convergence and drop rules
+ * over stored and planned members. The same decision through a composed
+ * server, with a real authorizer, is plugin.test.ts's.
+ */
+import { describe, expect, it } from "vitest";
+
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+
+import { droppedMembers, judgeSlug, membersConverge } from "../members.js";
+import type { Member, PlannedMember, SlugHolder } from "../members.js";
+
+const DIGEST = "d".repeat(64);
+const OURS = "plg_ours";
+const OTHER = "plg_other";
+
+function stored(overrides: Partial<Member> = {}): Member {
+  return {
+    kind: ApiResourceKind.agent,
+    id: "agt_1",
+    slug: "assistant",
+    name: "assistant",
+    version: DIGEST,
+    system: false,
+    ...overrides,
+  };
+}
+
+function planned(overrides: Partial<PlannedMember> = {}): PlannedMember {
+  return {
+    kind: ApiResourceKind.agent,
+    slug: "assistant",
+    name: "assistant",
+    system: false,
+    ...overrides,
+  };
+}
+
+function heldBy(
+  byPlugin: string | undefined,
+  holder: Member = stored(),
+): SlugHolder {
+  return { held: true, byPlugin, holder };
+}
+
+describe("judgeSlug", () => {
+  it("is free when nothing holds the slug", () => {
+    expect(judgeSlug({ held: false }, planned(), OURS)).toEqual({
+      kind: "free",
+    });
+  });
+
+  it("is ours when this plugin already holds it, whatever the labels", () => {
+    const holder = stored({ system: true });
+    expect(judgeSlug(heldBy(OURS, holder), planned(), OURS)).toEqual({
+      kind: "ours",
+      holder,
+    });
+  });
+
+  it("adopts an unmanaged row only when both sides are system content", () => {
+    const holder = stored({ system: true });
+    expect(
+      judgeSlug(heldBy(undefined, holder), planned({ system: true }), OURS),
+    ).toEqual({ kind: "adopt", holder });
+  });
+
+  it("refuses an unmanaged row when either side lacks the system label", () => {
+    const userRow = stored({ system: false });
+    expect(
+      judgeSlug(heldBy(undefined, userRow), planned({ system: true }), OURS),
+    ).toEqual({ kind: "held-unmanaged", holder: userRow });
+
+    const systemRow = stored({ system: true });
+    expect(
+      judgeSlug(heldBy(undefined, systemRow), planned({ system: false }), OURS),
+    ).toEqual({ kind: "held-unmanaged", holder: systemRow });
+
+    expect(
+      judgeSlug(heldBy(undefined, userRow), planned({ system: false }), OURS),
+    ).toEqual({ kind: "held-unmanaged", holder: userRow });
+  });
+
+  it("never transfers another plugin's member, even system content to system content", () => {
+    const holder = stored({ system: true });
+    expect(
+      judgeSlug(heldBy(OTHER, holder), planned({ system: true }), OURS),
+    ).toEqual({ kind: "held-by-plugin", holder, pluginId: OTHER });
+  });
+});
+
+describe("members: convergence and drops", () => {
+  const stored: Member[] = [
+    {
+      kind: ApiResourceKind.skill,
+      id: "skl_1",
+      slug: "thermo-review",
+      name: "thermo-review",
+      version: DIGEST,
+      system: false,
+    },
+    {
+      kind: ApiResourceKind.agent,
+      id: "agt_1",
+      slug: "thermos",
+      name: "thermos",
+      version: DIGEST,
+      system: false,
+    },
+  ];
+  const planned: PlannedMember[] = [
+    {
+      kind: ApiResourceKind.skill,
+      slug: "thermo-review",
+      name: "thermo-review",
+      system: false,
+    },
+    {
+      kind: ApiResourceKind.agent,
+      slug: "thermos",
+      name: "thermos",
+      system: false,
+    },
+  ];
+
+  it("converges only when every planned member is present and stamped with the digest", () => {
+    expect(membersConverge(stored, planned, DIGEST)).toBe(true);
+    expect(membersConverge(stored, planned, "e".repeat(64))).toBe(false);
+    expect(membersConverge(stored.slice(1), planned, DIGEST)).toBe(false);
+    expect(
+      membersConverge(
+        [...stored, { ...stored[0]!, slug: "extra", id: "skl_2" }],
+        planned,
+        DIGEST,
+      ),
+    ).toBe(false);
+  });
+
+  it("drops the members the plan no longer names", () => {
+    expect(droppedMembers(stored, planned.slice(1)).map((m) => m.slug)).toEqual(
+      ["thermo-review"],
+    );
+    expect(droppedMembers(stored, planned)).toEqual([]);
+  });
+});