create-ailk 0.12.1 → 0.13.0

package/templates/apps/api/src/middleware/__tests__/auth.bearer-path.test.ts

@@ -25,11 +25,19 @@ jest.mock("../../lib/prisma.js", () => ({
       findUnique: jest.fn(),
       update: jest.fn().mockResolvedValue(undefined),
     },
+    // #3591 — the agent branch's lookup and its best-effort lastActiveAt bump.
+    agent: {
+      findUnique: jest.fn(),
+      update: jest.fn().mockResolvedValue(undefined),
+    },
   },
 }));
 
+import { hashAgentKey, mintAgentKey } from "../../lib/agent-store.js";
 import { prisma } from "../../lib/prisma.js";
-import { authPreHandlerPlugin } from "../auth.js";
+import { leadListRoute } from "../../routes/leads/list.js";
+import { tokenRoutes } from "../../routes/auth/tokens.js";
+import { __resetAgentRateBuckets, authPreHandlerPlugin } from "../auth.js";
 
 const FRONTEND = "https://app.example.com";
 const BEARER = "tok_live_abc";
@@ -173,3 +181,378 @@ describe("auth preHandler — bearer path", () => {
     expect(res.statusCode).toBe(401);
   });
 });
+
+// ── #3591 — the agent branch (spec docs/specs/3591-tenant-scoped-agent-auth-secure-spec.md D4, D6, D9) ──
+
+const AGENT_A = "agent_00000000-0000-7000-8000-0000000000c1";
+const AGENT_B = "agent_00000000-0000-7000-8000-0000000000c2";
+const PERSON = "user_00000000-0000-7000-8000-0000000000f2";
+const PERSON_MEMBERSHIP = "member_00000000-0000-7000-8000-0000000000f2";
+const ADMIN_MEMBERSHIP = "member_00000000-0000-7000-8000-0000000000f1";
+const ORG_A = "org_00000000-0000-7000-8000-000000000aaa";
+const WS_A1 = "wksp_00000000-0000-7000-8000-0000000000a1";
+
+type AgentFixture = {
+  id: string;
+  enabled?: boolean;
+  keyIssuedToMembershipId?: string | null;
+  lastActiveAt?: Date | null;
+};
+
+/**
+ * Keys are minted at run time — a key-shaped literal in a fixture trips the
+ * repo-wide secret scan. Each key maps, by its digest, to one agent row.
+ */
+function installAgents(agents: Array<AgentFixture & { key: string }>): void {
+  const byHash = new Map(agents.map((a) => [hashAgentKey(a.key), a]));
+  (prisma.agent.findUnique as jest.Mock).mockImplementation(
+    ({ where }: { where: { credentialHash: string } }) => {
+      const a = byHash.get(where.credentialHash);
+      return Promise.resolve(
+        a
+          ? {
+              id: a.id,
+              workspaceId: WS_A1,
+              organizationId: ORG_A,
+              permissionLevel: "member",
+              enabled: a.enabled ?? true,
+              keyIssuedToMembershipId:
+                a.keyIssuedToMembershipId === undefined ? ADMIN_MEMBERSHIP : a.keyIssuedToMembershipId,
+              lastActiveAt: a.lastActiveAt ?? null,
+              responsible: { id: PERSON_MEMBERSHIP, userId: PERSON },
+            }
+          : null,
+      );
+    },
+  );
+}
+
+/** Collects every JSON log line the app writes. */
+function captureLogs(): { lines: Array<Record<string, unknown>>; raw: string[]; stream: { write(line: string): void } } {
+  const lines: Array<Record<string, unknown>> = [];
+  const raw: string[] = [];
+  return {
+    lines,
+    raw,
+    stream: {
+      write(line: string) {
+        raw.push(line);
+        lines.push(JSON.parse(line) as Record<string, unknown>);
+      },
+    },
+  };
+}
+
+/** Echo routes: one the tenant guard would tag, one it would not (D6). */
+function buildAgentApp(stream?: { write(line: string): void }): FastifyInstance {
+  const app = Fastify(stream ? { logger: { level: "info", stream } } : {});
+  app.register(authPreHandlerPlugin, { trustedOrigins: [FRONTEND] });
+  const echo = async (req: import("fastify").FastifyRequest) => ({
+    userId: req.userId ?? null,
+    agent: req.agent ?? null,
+    actor: req.actor ?? null,
+    sessionTenant: req.sessionTenant ?? null,
+  });
+  for (const method of ["GET", "POST", "PATCH"] as const) {
+    app.route({ method, url: "/guarded", config: { tenantGuarded: true }, handler: echo });
+    app.route({ method, url: "/unguarded", handler: echo });
+  }
+  return app;
+}
+
+describe("auth preHandler — agent branch (#3591)", () => {
+  let app: FastifyInstance;
+  let keyA: string;
+  let keyB: string;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    __resetAgentRateBuckets();
+    keyA = mintAgentKey();
+    keyB = mintAgentKey();
+    installAgents([
+      { id: AGENT_A, key: keyA },
+      { id: AGENT_B, key: keyB },
+    ]);
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+
+  const agentGet = (url: string, key: string) =>
+    app.inject({ method: "GET", url, headers: { authorization: `Bearer ${key}` } });
+
+  it("an ailk_agt_ bearer takes the agent branch: request.userId is the person, request.agent the binding, request.actor the agent — never sessionTenant", async () => {
+    app = buildAgentApp();
+    await app.ready();
+
+    const res = await agentGet("/guarded", keyA);
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toEqual({
+      userId: PERSON,
+      agent: {
+        agentId: AGENT_A,
+        workspaceId: WS_A1,
+        organizationId: ORG_A,
+        responsibleMembershipId: PERSON_MEMBERSHIP,
+        permissionLevel: "member",
+      },
+      actor: { type: "agent", agentId: AGENT_A, onBehalfOfUserId: PERSON },
+      sessionTenant: null,
+    });
+    expect(prisma.agent.findUnique).toHaveBeenCalledWith(
+      expect.objectContaining({ where: { credentialHash: hashAgentKey(keyA) } }),
+    );
+    // The ApiToken table is never consulted for an agent key.
+    expect(prisma.apiToken.findUnique).not.toHaveBeenCalled();
+  });
+
+  it("bumps lastActiveAt best-effort — a failed bump never 401s", async () => {
+    (prisma.agent.update as jest.Mock).mockRejectedValueOnce(new Error("db down"));
+    app = buildAgentApp();
+    await app.ready();
+
+    const res = await agentGet("/guarded", keyA);
+
+    expect(res.statusCode).toBe(200);
+    expect(prisma.agent.update).toHaveBeenCalledWith(
+      expect.objectContaining({ where: { id: AGENT_A } }),
+    );
+  });
+
+  it("writes lastActiveAt at most once a minute: a stamp under 60s old is left alone, an older one is refreshed", async () => {
+    const fresh = mintAgentKey();
+    const stale = mintAgentKey();
+    installAgents([
+      { id: AGENT_A, key: fresh, lastActiveAt: new Date(Date.now() - 10_000) },
+      { id: AGENT_B, key: stale, lastActiveAt: new Date(Date.now() - 120_000) },
+    ]);
+    app = buildAgentApp();
+    await app.ready();
+
+    expect((await agentGet("/guarded", fresh)).statusCode).toBe(200);
+    expect(prisma.agent.update).not.toHaveBeenCalled();
+
+    expect((await agentGet("/guarded", stale)).statusCode).toBe(200);
+    expect(prisma.agent.update).toHaveBeenCalledTimes(1);
+    expect(prisma.agent.update).toHaveBeenCalledWith(
+      expect.objectContaining({ where: { id: AGENT_B } }),
+    );
+  });
+
+  it("a refused request writes no lastActiveAt", async () => {
+    app = buildAgentApp();
+    await app.ready();
+
+    expect((await agentGet("/unguarded", keyA)).statusCode).toBe(403);
+    expect(prisma.agent.update).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    ["an unknown key", () => mintAgentKey()],
+    ["a switched-off agent", () => "off"],
+    ["an agent whose key-holder has left (keyIssuedToMembershipId null)", () => "orphaned"],
+  ])("answers 401 with one body for %s", async (_label, pick) => {
+    const off = mintAgentKey();
+    const orphaned = mintAgentKey();
+    installAgents([
+      { id: AGENT_A, key: off, enabled: false },
+      { id: AGENT_B, key: orphaned, keyIssuedToMembershipId: null },
+    ]);
+    const chosen = pick();
+    const key = chosen === "off" ? off : chosen === "orphaned" ? orphaned : chosen;
+    app = buildAgentApp();
+    await app.ready();
+
+    const res = await agentGet("/guarded", key);
+
+    expect(res.statusCode).toBe(401);
+    expect(res.json()).toEqual({ error: "unauthorized" });
+    expect(prisma.agent.update).not.toHaveBeenCalled();
+  });
+
+  it("a lookup failure is 401, not a 500", async () => {
+    (prisma.agent.findUnique as jest.Mock).mockRejectedValueOnce(new Error("db down"));
+    app = buildAgentApp();
+    await app.ready();
+
+    const res = await agentGet("/guarded", keyA);
+
+    expect(res.statusCode).toBe(401);
+  });
+
+  it("the cookie still wins over an agent bearer (precedence unchanged)", async () => {
+    (prisma.session.findUnique as jest.Mock).mockResolvedValue({
+      id: "sess_1",
+      userId: "user_cookie",
+      expiresAt: new Date(Date.now() + 60_000),
+      activeOrganizationId: null,
+      activeWorkspaceId: null,
+    });
+    app = buildAgentApp();
+    await app.ready();
+
+    const res = await app.inject({
+      method: "GET",
+      url: "/unguarded",
+      headers: { cookie: "better-auth.session_token=tok", authorization: `Bearer ${keyA}` },
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json().actor).toEqual({ type: "user", userId: "user_cookie" });
+    expect(prisma.agent.findUnique).not.toHaveBeenCalled();
+  });
+
+  describe("D6 — an agent reaches only routes the tenant guard runs on", () => {
+    it("is 403 on a route the guard did not tag", async () => {
+      app = buildAgentApp();
+      await app.ready();
+
+      const res = await agentGet("/unguarded", keyA);
+
+      expect(res.statusCode).toBe(403);
+      expect(res.json()).toEqual({ ok: false, error: { code: "forbidden", message: "Forbidden" } });
+    });
+
+    it("a personal ApiToken still reaches an untagged route (tok_ behaviour unchanged)", async () => {
+      (prisma.apiToken.findUnique as jest.Mock).mockResolvedValue({
+        id: "tok_id",
+        userId: "user_bear",
+        expiresAt: null,
+        revokedAt: null,
+      });
+      app = buildAgentApp();
+      await app.ready();
+
+      const res = await app.inject({
+        method: "GET",
+        url: "/unguarded",
+        headers: { authorization: `Bearer ${BEARER}` },
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(res.json().actor).toEqual({ type: "user", userId: "user_bear" });
+      expect(res.json().agent).toBeNull();
+    });
+
+    it("is 403 on GET /v1/leads and POST /v1/auth/tokens, before either handler reads anything", async () => {
+      app = Fastify();
+      app.register(authPreHandlerPlugin, { trustedOrigins: [FRONTEND] });
+      app.register(tokenRoutes);
+      app.register(leadListRoute);
+      await app.ready();
+
+      const leads = await agentGet("/v1/leads", keyA);
+      const tokens = await app.inject({
+        method: "POST",
+        url: "/v1/auth/tokens",
+        headers: { authorization: `Bearer ${keyA}` },
+        payload: { name: "escalation" },
+      });
+
+      expect(leads.statusCode).toBe(403);
+      expect(tokens.statusCode).toBe(403);
+      expect(prisma.apiToken.findUnique).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("the per-agent limit (D4 step 5, SEC-3591-04)", () => {
+    const write = (key: string) =>
+      app.inject({ method: "PATCH", url: "/guarded", headers: { authorization: `Bearer ${key}` } });
+
+    it("the eleventh non-GET request in a minute is 429 with Retry-After, while a second agent is unaffected", async () => {
+      app = buildAgentApp();
+      await app.ready();
+
+      for (let i = 0; i < 10; i += 1) {
+        expect((await write(keyA)).statusCode).toBe(200);
+      }
+      const eleventh = await write(keyA);
+      expect(eleventh.statusCode).toBe(429);
+      expect(Number(eleventh.headers["retry-after"])).toBeGreaterThan(0);
+      expect(eleventh.json()).toEqual({
+        ok: false,
+        error: { code: "rate_limited", message: "Too many requests" },
+      });
+
+      expect((await write(keyB)).statusCode).toBe(200);
+    });
+
+    it("reads count toward 60 a minute, and the sixty-first is 429", async () => {
+      app = buildAgentApp();
+      await app.ready();
+
+      for (let i = 0; i < 60; i += 1) {
+        expect((await agentGet("/guarded", keyA)).statusCode).toBe(200);
+      }
+      expect((await agentGet("/guarded", keyA)).statusCode).toBe(429);
+      expect((await agentGet("/guarded", keyB)).statusCode).toBe(200);
+    });
+
+    it("an invented key never gets a bucket: it is 401 every time, never 429", async () => {
+      app = buildAgentApp();
+      await app.ready();
+
+      const invented = mintAgentKey();
+      for (let i = 0; i < 15; i += 1) {
+        expect((await write(invented)).statusCode).toBe(401);
+      }
+    });
+  });
+
+  describe("D9 — the completion log line names the actor", () => {
+    it("carries actorType agent, the agent id and its person; the key appears in no line", async () => {
+      const logs = captureLogs();
+      app = buildAgentApp(logs.stream);
+      await app.ready();
+
+      const res = await agentGet("/guarded", keyA);
+      expect(res.statusCode).toBe(200);
+
+      const completed = logs.lines.find((l) => l.msg === "request completed");
+      expect(completed).toMatchObject({
+        actorType: "agent",
+        agentId: AGENT_A,
+        onBehalfOfUserId: PERSON,
+      });
+      expect(logs.raw.join("\n")).not.toContain(keyA);
+    });
+
+    it("a refused agent's lines carry no key either", async () => {
+      const logs = captureLogs();
+      app = buildAgentApp(logs.stream);
+      await app.ready();
+
+      await agentGet("/unguarded", keyA);
+      await agentGet("/guarded", mintAgentKey());
+
+      expect(logs.raw.length).toBeGreaterThan(0);
+      expect(logs.raw.join("\n")).not.toContain(keyA);
+      expect(logs.raw.join("\n")).not.toContain("ailk_agt_");
+    });
+
+    it("an ApiToken request's completion line carries actorType user", async () => {
+      (prisma.apiToken.findUnique as jest.Mock).mockResolvedValue({
+        id: "tok_id",
+        userId: "user_bear",
+        expiresAt: null,
+        revokedAt: null,
+      });
+      const logs = captureLogs();
+      app = buildAgentApp(logs.stream);
+      await app.ready();
+
+      await app.inject({
+        method: "GET",
+        url: "/unguarded",
+        headers: { authorization: `Bearer ${BEARER}` },
+      });
+
+      const completed = logs.lines.find((l) => l.msg === "request completed");
+      expect(completed).toMatchObject({ actorType: "user" });
+      expect(completed).not.toHaveProperty("agentId");
+    });
+  });
+});

package/templates/apps/api/src/middleware/__tests__/auth.cookie-path.test.ts

@@ -157,3 +157,64 @@ describe("auth preHandler — cookie path", () => {
     expect(prisma.apiToken.findUnique).not.toHaveBeenCalled();
   });
 });
+
+// ── #3591 D9 — every request names its actor ────────────────────────────────
+
+describe("auth preHandler — cookie path names the actor (#3591 D9)", () => {
+  let app: FastifyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (prisma.session.findUnique as jest.Mock).mockResolvedValue({
+      id: "sess_1",
+      userId: "user_42",
+      expiresAt: new Date(Date.now() + 60_000),
+      activeOrganizationId: null,
+      activeWorkspaceId: null,
+    });
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+
+  it("decorates request.actor as the person, and no request.agent", async () => {
+    app = Fastify();
+    app.register(authPreHandlerPlugin, { trustedOrigins: [FRONTEND] });
+    app.get("/actor", async (req) => ({ actor: req.actor ?? null, agent: req.agent ?? null }));
+    await app.ready();
+
+    const res = await app.inject({
+      method: "GET",
+      url: "/actor",
+      headers: { cookie: `${COOKIE_NAME}=sess_tok_abc` },
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toEqual({ actor: { type: "user", userId: "user_42" }, agent: null });
+  });
+
+  it("the completion log line carries actorType user, and no agent fields", async () => {
+    const lines: Array<Record<string, unknown>> = [];
+    app = Fastify({
+      logger: {
+        level: "info",
+        stream: { write: (line: string) => void lines.push(JSON.parse(line)) },
+      },
+    });
+    app.register(authPreHandlerPlugin, { trustedOrigins: [FRONTEND] });
+    app.get("/actor", async () => ({ ok: true }));
+    await app.ready();
+
+    await app.inject({
+      method: "GET",
+      url: "/actor",
+      headers: { cookie: `${COOKIE_NAME}=sess_tok_abc` },
+    });
+
+    const completed = lines.find((l) => l.msg === "request completed");
+    expect(completed).toMatchObject({ actorType: "user" });
+    expect(completed).not.toHaveProperty("agentId");
+    expect(completed).not.toHaveProperty("onBehalfOfUserId");
+  });
+});

package/templates/apps/api/src/middleware/__tests__/default-tenant.test.ts

@@ -519,3 +519,179 @@ describe("resolveDefaultTenant — the operator bind's own verified-email check
     await expect(resolveDefaultTenant(USER_ID)).resolves.toBeNull();
   });
 });
+
+// ── #3591 — the base-build agent branch (spec D5, D6, D7) ───────────────────
+
+describe("defaultTenantPreHandler — agents (#3591 D5, D7)", () => {
+  const AGENT_ID = "agent_00000000-0000-7000-8000-0000000000c1" as Id<"agent">;
+
+  function agentBinding(
+    overrides: Partial<{
+      workspaceId: string;
+      organizationId: string;
+      responsibleMembershipId: string;
+    }> = {},
+  ) {
+    return {
+      agentId: AGENT_ID,
+      workspaceId: (overrides.workspaceId ?? DEFAULT_WORKSPACE_ID) as Id<"workspace">,
+      organizationId: (overrides.organizationId ?? DEFAULT_ORG_ID) as Id<"organization">,
+      responsibleMembershipId: (overrides.responsibleMembershipId ??
+        OPERATOR_MEMBERSHIP_ID) as Id<"membership">,
+      permissionLevel: "member" as const,
+    };
+  }
+
+  /** An agent caller: `request.agent` set, `request.sessionTenant` never. */
+  function buildAgentApp(agent: ReturnType<typeof agentBinding>): FastifyInstance {
+    const app = Fastify();
+    app.addHook("preHandler", async (req) => {
+      req.userId = USER_ID;
+      req.agent = agent;
+    });
+    app.register(defaultTenantPreHandlerPlugin);
+    app.get("/scoped", async (req) => ({ tenant: req.tenant ?? null }));
+    app.get("/workspaces/:workspaceId/general", async (req) => ({
+      workspaceId: req.tenant?.workspaceId ?? null,
+    }));
+    return app;
+  }
+
+  function mockOperatorMembership(): void {
+    mockBoundOperator();
+    (prisma.membership.findUnique as jest.Mock).mockResolvedValue({
+      id: OPERATOR_MEMBERSHIP_ID,
+      role: "owner",
+    });
+  }
+
+  it("the pinned operator's agent, bound to the default workspace, is granted the operator's tenant with role member", async () => {
+    mockSingleTenantWorkspace();
+    mockOperatorMembership();
+    const app = buildAgentApp(agentBinding());
+
+    const res = await app.inject({ method: "GET", url: "/scoped" });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json().tenant).toEqual({
+      userId: USER_ID,
+      organizationId: DEFAULT_ORG_ID,
+      workspaceId: DEFAULT_WORKSPACE_ID,
+      role: "member",
+    });
+    await app.close();
+  });
+
+  it("reaches the grant through the operator's own reads: the same membership compound key", async () => {
+    mockSingleTenantWorkspace();
+    mockOperatorMembership();
+    const app = buildAgentApp(agentBinding());
+
+    await app.inject({ method: "GET", url: "/scoped" });
+
+    expect(prisma.membership.findUnique).toHaveBeenCalledWith({
+      where: {
+        organizationId_userId: { organizationId: DEFAULT_ORG_ID, userId: USER_ID },
+      },
+      select: { id: true, role: true },
+    });
+    await app.close();
+  });
+
+  it.each([
+    ["bound to another workspace", { workspaceId: FOREIGN_WORKSPACE_ID }],
+    ["created under another membership", { responsibleMembershipId: "member_00000000-0000-7000-8000-0000000000dd" }],
+    ["of another organization", { organizationId: "org_00000000-0000-7000-8000-0000000000dd" }],
+  ])("refuses (403) an agent %s", async (_label, overrides) => {
+    mockSingleTenantWorkspace();
+    mockOperatorMembership();
+    const app = buildAgentApp(agentBinding(overrides));
+
+    const res = await app.inject({ method: "GET", url: "/scoped" });
+
+    expect(res.statusCode).toBe(403);
+    await app.close();
+  });
+
+  it("refuses (403) the agent of a person who is not the pinned operator, before any membership read", async () => {
+    mockSingleTenantWorkspace();
+    mockOperatorMembership();
+    (prisma.user.findUnique as jest.Mock).mockResolvedValue({
+      email: "someone-else@example.com",
+      emailVerified: true,
+    });
+    const app = buildAgentApp(agentBinding());
+
+    const res = await app.inject({ method: "GET", url: "/scoped" });
+
+    expect(res.statusCode).toBe(403);
+    expect(prisma.membership.findUnique).not.toHaveBeenCalled();
+    await app.close();
+  });
+
+  it("refuses (403) every agent when the operator pin is unset", async () => {
+    delete process.env.AILK_OPERATOR_EMAIL;
+    mockSingleTenantWorkspace();
+    mockOperatorMembership();
+    const app = buildAgentApp(agentBinding());
+
+    const res = await app.inject({ method: "GET", url: "/scoped" });
+
+    expect(res.statusCode).toBe(403);
+    await app.close();
+  });
+
+  it("refuses (403) an agent naming a foreign workspace in the URL, before the handler runs", async () => {
+    mockSingleTenantWorkspace();
+    mockOperatorMembership();
+    const app = buildAgentApp(agentBinding());
+
+    const res = await app.inject({
+      method: "GET",
+      url: `/workspaces/${FOREIGN_WORKSPACE_ID}/general`,
+    });
+
+    expect(res.statusCode).toBe(403);
+    await app.close();
+  });
+});
+
+describe("defaultTenantPreHandlerPlugin — the tenantGuarded tag (#3591 D6)", () => {
+  it("tags every route registered after it in its scope, and no route before it or outside it", async () => {
+    // A root onRoute hook runs first and keeps each route's options object;
+    // the guard's own hook then tags that same object.
+    const routes: Record<string, { config?: { tenantGuarded?: boolean } }> = {};
+    const app = Fastify();
+    app.addHook("onRoute", (opts) => {
+      if (opts.method === "GET") routes[opts.url] = opts;
+    });
+    app.get("/before", async () => ({}));
+    app.register(async (scope) => {
+      scope.get("/scope-before", async () => ({}));
+      await scope.register(defaultTenantPreHandlerPlugin);
+      scope.get("/after", async () => ({}));
+      await scope.register(async (child) => {
+        child.get("/child", async () => ({}));
+      });
+    });
+    app.register(async (sibling) => {
+      sibling.get("/sibling", async () => ({}));
+    });
+    await app.ready();
+    const tagged = Object.fromEntries(
+      ["/before", "/scope-before", "/after", "/child", "/sibling"].map((url) => [
+        url,
+        routes[url]?.config?.tenantGuarded,
+      ]),
+    );
+
+    expect(tagged).toEqual({
+      "/before": undefined,
+      "/scope-before": undefined,
+      "/after": true,
+      "/child": true,
+      "/sibling": undefined,
+    });
+    await app.close();
+  });
+});