@stigmer/server 3.21.0 → 3.22.1-dev.20260922095755

package/src/domain/agentshare/__tests__/member-audience.test.ts

@@ -0,0 +1,113 @@
+/**
+ * Pins AuthorizeMemberAudience (steps.ts), the member-profile lane's gate:
+ * membership (can_view on the reference's organization) is asked before
+ * the share is loaded; deny and not-found both answer the lane's one
+ * NOT_FOUND, byte-identical to a missing share, so a share URL teaches a
+ * non-member nothing; unavailable is INTERNAL; an empty org asks nothing
+ * and is left to the loader's INVALID_ARGUMENT; the internal class skips.
+ */
+import { describe, expect, it } from "vitest";
+import { create } from "@bufbuild/protobuf";
+import { Code, ConnectError } from "@connectrpc/connect";
+
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+import { ApiResourceReferenceSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/io_pb";
+import { IamPermission } from "@stigmer/protos/ai/stigmer/iam/v1/enum_pb";
+
+import type {
+  Authorizer,
+  AuthzCheck,
+  AuthzDecision,
+} from "../../../extensions/authorizer.js";
+import type { CallerIdentity } from "../../../extensions/identity.js";
+import { testCallerIdentity } from "../../../pipeline/__tests__/support.js";
+import { RequestContext } from "../../../pipeline/request-context.js";
+import { AUTHORIZATION_UNAVAILABLE_MESSAGE } from "../../../pipeline/steps/authorize.js";
+import { newAuthorizeMemberAudienceStep, sharedNotFound } from "../steps.js";
+
+function fakeAuthorizer(decision: AuthzDecision): {
+  authorizer: Authorizer;
+  checks: AuthzCheck[];
+} {
+  const checks: AuthzCheck[] = [];
+  return {
+    checks,
+    authorizer: {
+      authorize(_caller, check) {
+        checks.push(check);
+        return Promise.resolve(decision);
+      },
+    },
+  };
+}
+
+function ctxFor(org: string, caller: CallerIdentity = testCallerIdentity()) {
+  return new RequestContext(
+    ApiResourceReferenceSchema,
+    create(ApiResourceReferenceSchema, { org, slug: "helper" }),
+    caller,
+    ApiResourceKind.agent_share,
+  );
+}
+
+async function captureError(
+  run: () => void | Promise<void>,
+): Promise<ConnectError> {
+  try {
+    await run();
+  } catch (error) {
+    return ConnectError.from(error);
+  }
+  throw new Error("expected the step to reject");
+}
+
+describe("AuthorizeMemberAudience", () => {
+  it("asks can_view on the reference's organization and admits an allow", async () => {
+    const { authorizer, checks } = fakeAuthorizer({ kind: "allow" });
+    await newAuthorizeMemberAudienceStep(authorizer).execute(ctxFor("acme"));
+    expect(checks).toEqual([
+      {
+        permission: IamPermission.can_view,
+        resourceKind: ApiResourceKind.organization,
+        resourceId: "acme",
+      },
+    ]);
+  });
+
+  it("deny and not-found both answer the lane's NOT_FOUND, byte-identical to a missing share", async () => {
+    for (const decision of [
+      { kind: "deny", reason: "not a member" },
+      { kind: "not-found" },
+    ] as const) {
+      const { authorizer } = fakeAuthorizer(decision);
+      const error = await captureError(() =>
+        newAuthorizeMemberAudienceStep(authorizer).execute(ctxFor("acme")),
+      );
+      expect(error.code).toBe(Code.NotFound);
+      expect(error.rawMessage).toBe(sharedNotFound("helper").rawMessage);
+    }
+  });
+
+  it("unavailable is INTERNAL, never a refusal", async () => {
+    const { authorizer } = fakeAuthorizer({
+      kind: "unavailable",
+      cause: new Error("backend down"),
+    });
+    const error = await captureError(() =>
+      newAuthorizeMemberAudienceStep(authorizer).execute(ctxFor("acme")),
+    );
+    expect(error.code).toBe(Code.Internal);
+    expect(error.rawMessage).toBe(AUTHORIZATION_UNAVAILABLE_MESSAGE);
+  });
+
+  it("an empty org asks nothing (the loader's INVALID_ARGUMENT answers), and the internal class skips", async () => {
+    const denying = fakeAuthorizer({ kind: "deny", reason: "" });
+    await newAuthorizeMemberAudienceStep(denying.authorizer).execute(
+      ctxFor(""),
+    );
+    await newAuthorizeMemberAudienceStep(denying.authorizer).execute(
+      ctxFor("acme", testCallerIdentity({ callerClass: "internal" })),
+    );
+    expect(denying.checks).toEqual([]);
+  });
+});

package/src/domain/agentshare/constants.ts

@@ -17,10 +17,12 @@ export const SHARE_LINK_TOKEN_BYTES = 20;
  * resolveShareDefaultsStep, byte-pinned. The share's org appears in the
  * hosted chat URL and is the billing org, so it can never be inferred.
  */
-export const ORG_REQUIRED_MESSAGE = "metadata.org is required for an agent share";
+export const ORG_REQUIRED_MESSAGE =
+  "metadata.org is required for an agent share";
 
 /** InvalidArgument copy when spec.agent_ref.slug is absent — Go, pinned. */
-export const AGENT_REF_SLUG_REQUIRED_MESSAGE = "spec.agent_ref.slug is required";
+export const AGENT_REF_SLUG_REQUIRED_MESSAGE =
+  "spec.agent_ref.slug is required";
 
 /**
  * InvalidArgument copy for BOTH profile lanes when org is absent — Go
@@ -28,34 +30,20 @@ export const AGENT_REF_SLUG_REQUIRED_MESSAGE = "spec.agent_ref.slug is required"
  * Anti-enumeration: an empty org would mean "match slug across all orgs"
  * on a public endpoint.
  */
-export const ORG_REQUIRED_FOR_LOOKUP_MESSAGE = "org is required for shared agent lookup";
+export const ORG_REQUIRED_FOR_LOOKUP_MESSAGE =
+  "org is required for shared agent lookup";
 
 /**
- * FailedPrecondition copy for an org-audience cross-org share (decision
- * 013 D3) — Go validateCrossOrgShare AND validateShareUpdateStep (update
- * replaces the spec wholesale and must not open a side door), byte-pinned.
+ * FailedPrecondition copy when spec.agent_ref names another organization's
+ * agent — the schedule's and the channel's same-organization sentence in
+ * the share's own words. A share offers an agent its own organization
+ * owns; to share another organization's agent, install the plugin that
+ * carries it and share the installed copy.
  */
-export function crossOrgAudienceMessage(agentOrg: string): string {
+export function sameOrgInvariantMessage(refOrg: string): string {
   return (
-    "a cross-org share must have a public audience — org-audience shares " +
-    `are limited to the agent's own organization (${agentOrg})`
-  );
-}
-
-/**
- * FailedPrecondition copy naming every non-public dependency blocking a
- * cross-org share (decision 013 D5) — Go validateCrossOrgShare,
- * byte-pinned. Blockers are deduped, formatted "<kind> <org>/<slug>", and
- * sorted, so the refusal is deterministic.
- */
-export function crossOrgBlockersMessage(
-  agentOrg: string,
-  agentSlug: string,
-  blockers: readonly string[],
-): string {
-  return (
-    `cannot share ${agentOrg}/${agentSlug} across organizations: ` +
-    `it references resources that are not public: ${blockers.join(", ")}`
+    "spec.agent_ref.org must match metadata.org — a share must live in " +
+    `the referenced agent's organization (${refOrg})`
   );
 }
 

package/src/domain/agentshare/controller.ts

@@ -60,6 +60,10 @@ import type { PipelineStep } from "../../pipeline/pipeline.js";
 import { callerIdentityOf } from "../../pipeline/interceptors/auth.js";
 import { RequestContext } from "../../pipeline/request-context.js";
 import { newAuthorizeStep } from "../../pipeline/steps/authorize.js";
+import {
+  loadedTargetAsMethod,
+  newAuthorizeResolvedTargetStep,
+} from "../../pipeline/steps/authorize-resolved-target.js";
 import { newGuardReservedLabelsStep } from "../../pipeline/steps/guard-reserved-labels.js";
 import {
   newBuildNewStateStep,
@@ -89,7 +93,10 @@ import {
   TARGET_RESOURCE_KEY,
   newLoadTargetStep,
 } from "../../pipeline/steps/load-target.js";
-import { newNormalizeReferencesStep } from "../../pipeline/steps/references.js";
+import {
+  newNormalizeReferencesStep,
+  newValidateReferencesStep,
+} from "../../pipeline/steps/references.js";
 import {
   newCleanupIamPoliciesStep,
   newCreateAuthorizationTuplesStep,
@@ -109,6 +116,8 @@ import {
   newValidateShareUpdateStep,
   sharedNotFound,
   sharingLinkTokenAllowed,
+  resolveShareCreateTargets,
+  newAuthorizeMemberAudienceStep,
 } from "./steps.js";
 
 export interface AgentShareControllerDeps {
@@ -176,12 +185,20 @@ async function createShare(
     .addStep(newValidateProtoStep())
     .addStep(newValidateVisibilityStep())
     .addStep(newResolveShareDefaultsStep(deps.store))
+    // Before the duplicate check (steps.ts, resolveShareCreateTargets).
+    .addStep(
+      newAuthorizeResolvedTargetStep(
+        deps.authorizer,
+        resolveShareCreateTargets,
+      ),
+    )
     .addStep(newResolveSlugStep())
     .addStep(newCheckDuplicateStep(deps.store))
     .addStep(newBuildNewStateStep())
     .addStep(newGuardReservedLabelsStep(deps.authorizer))
     .addStep(newStampAgentPinStep())
     .addStep(newNormalizeReferencesStep())
+    .addStep(newValidateReferencesStep(deps.store))
     .addStep(newPersistStep(deps.store))
     .addStep(
       newCreateAuthorizationTuplesStep(
@@ -226,6 +243,7 @@ async function update(
     .addStep(newBuildUpdateStateStep())
     .addStep(newGuardReservedLabelsStep(deps.authorizer))
     .addStep(newNormalizeReferencesStep())
+    .addStep(newValidateReferencesStep(deps.store))
     .addStep(newPersistStep(deps.store))
     .build()
     .execute(reqCtx);
@@ -491,6 +509,12 @@ async function getByReference(
     )
     .addStep(newValidateProtoStep())
     .addStep(newLoadByReferenceStep(deps.store, AgentShareSchema))
+    .addStep(
+      newAuthorizeResolvedTargetStep(
+        deps.authorizer,
+        loadedTargetAsMethod(AgentShareQueryController.method.get),
+      ),
+    )
     .build()
     .execute(reqCtx);
   return reqCtx.get(TARGET_RESOURCE_KEY) as AgentShare;
@@ -797,6 +821,8 @@ async function getSharedProfileForMember(
       ),
     )
     .addStep(newValidateProtoStep())
+    // Membership before existence (steps.ts, AuthorizeMemberAudience).
+    .addStep(newAuthorizeMemberAudienceStep(deps.authorizer))
     .addStep(newLoadShareForMemberProfileStep(deps.store))
     .addStep(newProjectMemberSharedProfileStep(deps.store))
     .build()