create-ailk 0.1.1 → 0.3.0

package/templates/apps/api/src/lib/tenant-db.ts

@@ -1,225 +0,0 @@
-// oss: false
-/**
- * Tenant-scoped data-access boundary (the multi-tenant module's scope layer —
- * FEAT-042, design decision (a)).
- *
- * Every domain-content query (agent_sessions, conversation_events,
- * session_read_receipts, artifacts, artifact_versions) goes through
- * `tenantDb(tenant)`, which injects the resolved `TenantContext.workspaceId`
- * into EVERY where/data clause. There is deliberately no method that accepts
- * a caller-supplied workspaceId, and lookups by id are `findFirst({ id,
- * workspaceId })` — never `findUnique({ id })` — so a foreign-tenant row is
- * indistinguishable from a missing one.
- *
- * Raw `prisma.<domainModel>` access outside this file and
- * `../services/tenant-context.ts` is forbidden by the tenant-scope
- * `forbidden_pattern` in architecture.yaml (CI: `pnpm architecture`).
- */
-import type {
-  AgentSession,
-  Artifact,
-  ConversationEvent,
-  Prisma,
-  SessionReadReceipt,
-  WorkspaceSEO,
-  WorkspaceSiteIdentity,
-  WorkspaceTheme,
-} from "@working-theory/database";
-import type { Id } from "@working-theory/ids";
-
-import type { TenantContext } from "../services/tenant-context.js";
-
-import { prisma } from "./prisma.js";
-
-/** Explicit surface (declaration-emit portability + a reviewable contract). */
-export interface TenantDb {
-  agentSession: {
-    list(limit: number): Promise<AgentSession[]>;
-    byId(id: Id<"agentSession">): Promise<AgentSession | null>;
-    create(data: { title?: string | null }): Promise<AgentSession>;
-    updateDraft(
-      id: Id<"agentSession">,
-      draftMessage: string | null,
-    ): Promise<{ count: number }>;
-  };
-  conversationEvent: {
-    listSince(
-      sessionId: Id<"agentSession">,
-      sinceSeq: number,
-      limit: number,
-    ): Promise<ConversationEvent[]>;
-  };
-  readReceipt: {
-    listForUser(): Promise<Array<Pick<SessionReadReceipt, "sessionId" | "lastReadSeq">>>;
-    upsert(
-      sessionId: Id<"agentSession">,
-      lastReadSeq: number,
-    ): Promise<SessionReadReceipt>;
-  };
-  artifact: {
-    listBySession(sessionId: Id<"agentSession">): Promise<Artifact[]>;
-    byId(id: Id<"artifact">): Promise<Artifact | null>;
-  };
-  artifactVersion: {
-    listByArtifact(
-      artifactId: Id<"artifact">,
-    ): Promise<
-      Array<{ id: Id<"artifactVersion">; savedAt: Date; isCurrent: boolean }>
-    >;
-  };
-  // Per-workspace site config (#3634). Each model is `workspaceId @unique`, so
-  // the unique key IS the tenant scope — `findUnique`/`upsert` on
-  // `{ workspaceId }` never accepts a caller-supplied scope.
-  theme: {
-    get(): Promise<WorkspaceTheme | null>;
-    upsert(data: unknown): Promise<WorkspaceTheme>;
-  };
-  siteIdentity: {
-    get(): Promise<WorkspaceSiteIdentity | null>;
-    upsert(data: unknown): Promise<WorkspaceSiteIdentity>;
-  };
-  seo: {
-    get(): Promise<WorkspaceSEO | null>;
-    upsert(data: unknown): Promise<WorkspaceSEO>;
-  };
-}
-
-export function tenantDb(tenant: TenantContext): TenantDb {
-  const { workspaceId, userId } = tenant;
-
-  return {
-    agentSession: {
-      list(limit: number) {
-        return prisma.agentSession.findMany({
-          where: { workspaceId },
-          orderBy: [
-            { lastMessageAt: { sort: "desc", nulls: "last" } },
-            { createdAt: "desc" },
-          ],
-          take: limit,
-        });
-      },
-      byId(id: string) {
-        return prisma.agentSession.findFirst({
-          where: { id, workspaceId },
-        });
-      },
-      create(data: { title?: string | null; agentId?: string }) {
-        return prisma.agentSession.create({
-          data: { title: data.title ?? null, workspaceId },
-        });
-      },
-      updateDraft(id: string, draftMessage: string | null) {
-        return prisma.agentSession.updateMany({
-          where: { id, workspaceId },
-          data: { draftMessage },
-        });
-      },
-    },
-
-    conversationEvent: {
-      listSince(sessionId: string, sinceSeq: number, limit: number) {
-        return prisma.conversationEvent.findMany({
-          where: { sessionId, workspaceId, seq: { gt: sinceSeq } },
-          orderBy: { seq: "asc" },
-          take: limit,
-        });
-      },
-    },
-
-    readReceipt: {
-      /** Read positions for the CALLING user across this workspace's sessions. */
-      listForUser() {
-        return prisma.sessionReadReceipt.findMany({
-          where: { workspaceId, userId },
-          select: { sessionId: true, lastReadSeq: true },
-        });
-      },
-      upsert(sessionId: string, lastReadSeq: number) {
-        return prisma.sessionReadReceipt.upsert({
-          where: { sessionId_userId: { sessionId, userId } },
-          create: { sessionId, workspaceId, userId, lastReadSeq },
-          update: { lastReadSeq },
-        });
-      },
-    },
-
-    artifact: {
-      listBySession(sessionId: string) {
-        return prisma.artifact.findMany({
-          where: { sessionId, workspaceId },
-          orderBy: { createdAt: "asc" },
-        });
-      },
-      byId(id: string) {
-        return prisma.artifact.findFirst({ where: { id, workspaceId } });
-      },
-    },
-
-    artifactVersion: {
-      listByArtifact(artifactId: string) {
-        // Brand assertion at the Prisma read edge (the DB CHECK constraints
-        // guarantee the id shape).
-        return prisma.artifactVersion.findMany({
-          where: { artifactId, workspaceId },
-          orderBy: { savedAt: "desc" },
-          select: {
-            id: true,
-            savedAt: true,
-            isCurrent: true,
-          },
-        }) as Promise<
-          Array<{ id: Id<"artifactVersion">; savedAt: Date; isCurrent: boolean }>
-        >;
-      },
-    },
-
-    // Site config — scoped by the `@unique` workspaceId (the unique key IS the
-    // scope). The validated blob is stored in the `data` Json column; validation
-    // happens at the route boundary against the shared @working-theory/site-config
-    // schema, so the DB layer stores an already-validated object.
-    theme: {
-      get() {
-        return prisma.workspaceTheme.findUnique({ where: { workspaceId } });
-      },
-      upsert(data: unknown) {
-        const json = data as Prisma.InputJsonValue;
-        return prisma.workspaceTheme.upsert({
-          where: { workspaceId },
-          create: { workspaceId, data: json },
-          update: { data: json },
-        });
-      },
-    },
-
-    siteIdentity: {
-      get() {
-        return prisma.workspaceSiteIdentity.findUnique({
-          where: { workspaceId },
-        });
-      },
-      upsert(data: unknown) {
-        const json = data as Prisma.InputJsonValue;
-        return prisma.workspaceSiteIdentity.upsert({
-          where: { workspaceId },
-          create: { workspaceId, data: json },
-          update: { data: json },
-        });
-      },
-    },
-
-    seo: {
-      get() {
-        return prisma.workspaceSEO.findUnique({ where: { workspaceId } });
-      },
-      upsert(data: unknown) {
-        const json = data as Prisma.InputJsonValue;
-        return prisma.workspaceSEO.upsert({
-          where: { workspaceId },
-          create: { workspaceId, data: json },
-          update: { data: json },
-        });
-      },
-    },
-  };
-}

package/templates/apps/api/src/lib/ws-token.ts

@@ -1,91 +0,0 @@
-// oss: false
-/**
- * Short-lived stream tokens (BACKEND-REQUIREMENTS R-T3): the push channel is
- * authenticated by a per-session token minted over REST, not the ambient
- * cookie. Compact HMAC-SHA256 JWT via node:crypto — no new dependency; the
- * Phase-6 realtime server verifies with `verifyWsToken`.
- *
- * Secret resolution mirrors apps/web's Better Auth pattern: AILK_WS_TOKEN_SECRET
- * wins, BETTER_AUTH_SECRET is the shared fallback, and a dev-only default
- * keeps the OSS zero-config boot working. Production deployments MUST set one
- * of the two env vars.
- */
-import { createHmac, timingSafeEqual } from "node:crypto";
-
-import { getClock } from "@working-theory/common";
-import type { Id } from "@working-theory/ids";
-
-export const WS_TOKEN_TTL_SECONDS = 60;
-
-export interface WsTokenClaims {
-  /** Caller user id. */
-  sub: Id<"user">;
-  /** Agent-session id the stream is scoped to. */
-  sid: Id<"agentSession">;
-  /** Workspace id the session belongs to (tenant scope). */
-  wid: Id<"workspace">;
-  iat: number;
-  exp: number;
-}
-
-function resolveSecret(): string {
-  const secret =
-    process.env.AILK_WS_TOKEN_SECRET ?? process.env.BETTER_AUTH_SECRET;
-  if (secret) return secret;
-  // Fail CLOSED in production (security review M2): a token-minting path
-  // must never run on a guessable default secret.
-  if (process.env.NODE_ENV === "production") {
-    throw new Error(
-      "ws-token: set AILK_WS_TOKEN_SECRET or BETTER_AUTH_SECRET in production",
-    );
-  }
-  return "ailk-dev-secret-do-not-use-in-production";
-}
-
-function b64url(input: Buffer | string): string {
-  return Buffer.from(input).toString("base64url");
-}
-
-function sign(payload: string): string {
-  return createHmac("sha256", resolveSecret()).update(payload).digest("base64url");
-}
-
-/** Mint a short-lived stream token for (user, session, workspace). */
-export function mintWsToken(params: {
-  userId: Id<"user">;
-  sessionId: Id<"agentSession">;
-  workspaceId: Id<"workspace">;
-}): { token: string; expiresAt: string } {
-  const nowSec = Math.floor(getClock().now() / 1000);
-  const claims: WsTokenClaims = {
-    sub: params.userId,
-    sid: params.sessionId,
-    wid: params.workspaceId,
-    iat: nowSec,
-    exp: nowSec + WS_TOKEN_TTL_SECONDS,
-  };
-  const head = b64url(JSON.stringify({ alg: "HS256", typ: "JWT" }));
-  const body = b64url(JSON.stringify(claims));
-  const token = `${head}.${body}.${sign(`${head}.${body}`)}`;
-  return { token, expiresAt: new Date(claims.exp * 1000).toISOString() };
-}
-
-/** Verify a stream token; returns claims or null (invalid / expired). */
-export function verifyWsToken(token: string): WsTokenClaims | null {
-  const [head, body, sig] = token.split(".");
-  if (!head || !body || !sig) return null;
-  const expected = sign(`${head}.${body}`);
-  const a = Buffer.from(sig);
-  const b = Buffer.from(expected);
-  if (a.length !== b.length || !timingSafeEqual(a, b)) return null;
-  try {
-    const claims = JSON.parse(
-      Buffer.from(body, "base64url").toString("utf-8"),
-    ) as WsTokenClaims;
-    if (typeof claims.exp !== "number") return null;
-    if (claims.exp * 1000 <= getClock().now()) return null;
-    return claims;
-  } catch {
-    return null;
-  }
-}

package/templates/apps/api/src/middleware/tenant.ts

@@ -1,99 +0,0 @@
-// oss: false
-/**
- * Tenant guard preHandler (multi-tenant module — FEAT-042).
- *
- * Runs AFTER the dual-mode auth preHandler inside the workspace route scope.
- * Default-deny: resolves the caller's active tenant via
- * `services/tenant-context.ts#resolveActiveTenant` and rejects everything
- * that is not an explicit grant:
- *
- *   - bearer-authenticated requests (no workspace binding yet — #3591) → 403
- *   - cookie sessions with no / stale active workspace                 → 403
- *   - revoked membership                                               → 403
- *   - URL workspaceId ≠ the session's active workspace                 → 403
- *     (compared BEFORE any lookup of the target — no tenant enumeration)
- *
- * On grant it decorates `request.tenant` (a `TenantContext`); route handlers
- * pass that to `tenantDb(tenant)` so every domain query is workspace-scoped.
- * Routes whose target is a session/artifact id (no workspaceId param) rely on
- * the scope layer's `findFirst({ id, workspaceId })` — a foreign target is a
- * 404, indistinguishable from a missing one.
- */
-import type {
-  FastifyPluginCallback,
-  FastifyReply,
-  FastifyRequest,
-} from "fastify";
-
-import {
-  resolveActiveTenant,
-  type TenantContext,
-} from "../services/tenant-context.js";
-
-declare module "fastify" {
-  interface FastifyRequest {
-    tenant?: TenantContext;
-  }
-}
-
-const FORBIDDEN = {
-  ok: false,
-  error: { code: "forbidden", message: "Forbidden" },
-} as const;
-
-/**
- * Resolve + attach the active tenant, or reply 403. Registered as a hook in
- * the workspace route scope (after auth), so no tenant-scoped handler runs
- * without a granted TenantContext.
- */
-export async function tenantPreHandler(
-  request: FastifyRequest,
-  reply: FastifyReply,
-): Promise<void> {
-  const userId = request.userId;
-  if (!userId) {
-    reply.code(401).send({
-      ok: false,
-      error: { code: "unauthorized", message: "Authentication required" },
-    });
-    return;
-  }
-
-  const resolved = await resolveActiveTenant({
-    userId,
-    sessionTenant: request.sessionTenant,
-  });
-  if (!resolved.ok) {
-    reply.code(403).send(FORBIDDEN);
-    return;
-  }
-
-  // URL-scoped routes: the target workspace MUST be the session's active
-  // workspace. Compared before any target lookup — a foreign (or nonexistent)
-  // workspaceId gets the same 403.
-  const params = request.params as { workspaceId?: string } | undefined;
-  if (params?.workspaceId && params.workspaceId !== resolved.value.workspaceId) {
-    reply.code(403).send(FORBIDDEN);
-    return;
-  }
-
-  request.tenant = resolved.value;
-}
-
-/**
- * Plugin form, mirroring `authPreHandlerPlugin`: skip-override so the hook
- * propagates to sibling route plugins registered in the same scope.
- */
-export const tenantPreHandlerPlugin: FastifyPluginCallback = (
-  fastify,
-  _opts,
-  done,
-) => {
-  fastify.decorateRequest("tenant", undefined);
-  fastify.addHook("preHandler", tenantPreHandler);
-  done();
-};
-
-(tenantPreHandlerPlugin as FastifyPluginCallback & { [key: symbol]: boolean })[
-  Symbol.for("skip-override")
-] = true;