create-windy 0.6.12 → 0.6.15

package/template/apps/server/src/agent/session-persistence/drizzle-session-mapping.ts

@@ -0,0 +1,154 @@
+import {
+  agentSessionCheckpoints,
+  agentSessionEvents,
+  agentSessions,
+} from "@southwind-ai/database";
+import {
+  assertSessionEventEnvelope,
+  type PendingSessionEvent,
+  type SessionEventEnvelope,
+} from "../session-log/events.js";
+import type {
+  SessionCheckpoint,
+  SessionId,
+  SessionRecord,
+} from "../session-log/domain.js";
+import type { CreateSessionInput, SessionAppendResult } from "../session-log/repository.js";
+import { AgentSessionPayloadCodec } from "./payload-codec.js";
+
+export type SessionRow = typeof agentSessions.$inferSelect;
+export type EventRow = typeof agentSessionEvents.$inferSelect;
+export type CheckpointRow = typeof agentSessionCheckpoints.$inferSelect;
+
+export function sessionValues(record: SessionRecord) {
+  return {
+    sessionId: record.sessionId,
+    actorId: record.governance.actorId,
+    scopeDigest: record.governance.scopeDigest,
+    status: record.status,
+    headSequence: record.headSequence,
+    parentSessionId: record.lineage?.parentSessionId,
+    parentCheckpointId: record.lineage?.checkpointId,
+    parentSequence: record.lineage?.parentSequence,
+    createdAt: Date.parse(record.createdAt),
+    updatedAt: Date.parse(record.updatedAt),
+  };
+}
+
+export function mapSession(row: SessionRow): SessionRecord {
+  return {
+    sessionId: row.sessionId as SessionId,
+    governance: {
+      actorId: row.actorId,
+      scopeDigest: row.scopeDigest as `sha256:${string}`,
+    },
+    status: row.status as SessionRecord["status"],
+    headSequence: row.headSequence,
+    createdAt: new Date(row.createdAt).toISOString(),
+    updatedAt: new Date(row.updatedAt).toISOString(),
+    ...(row.parentSessionId && row.parentCheckpointId && row.parentSequence
+      ? {
+          lineage: {
+            parentSessionId: row.parentSessionId as SessionId,
+            checkpointId: row.parentCheckpointId as `session_checkpoint_${string}`,
+            parentSequence: row.parentSequence,
+          },
+        }
+      : {}),
+  };
+}
+
+export function eventValues(
+  codec: AgentSessionPayloadCodec,
+  sessionId: SessionId,
+  sequence: number,
+  event: PendingSessionEvent,
+) {
+  const encoded = codec.encode(event.data);
+  return {
+    eventId: event.eventId,
+    sessionId,
+    sequence,
+    eventType: event.data.type,
+    schemaVersion: 1,
+    payloadCipher: encoded.cipher,
+    payloadDigest: encoded.digest,
+    occurredAt: Date.parse(event.occurredAt),
+  };
+}
+
+export function mapEvent(
+  codec: AgentSessionPayloadCodec,
+  row: EventRow,
+): SessionEventEnvelope {
+  const event = {
+    eventId: row.eventId as `session_event_${string}`,
+    sessionId: row.sessionId as SessionId,
+    sequence: row.sequence,
+    schemaVersion: row.schemaVersion,
+    occurredAt: new Date(row.occurredAt).toISOString(),
+    data: codec.decode<SessionEventEnvelope["data"]>(
+      row.payloadCipher,
+      row.payloadDigest,
+    ),
+  } as SessionEventEnvelope;
+  assertSessionEventEnvelope(event);
+  if (event.data.type !== row.eventType) {
+    throw new Error("Session Event type 与 payload 不一致");
+  }
+  return event;
+}
+
+export function checkpointValues(checkpoint: SessionCheckpoint) {
+  return {
+    checkpointId: checkpoint.checkpointId,
+    sessionId: checkpoint.sessionId,
+    throughSequence: checkpoint.throughSequence,
+    factDigest: checkpoint.factDigest,
+    createdAt: Date.parse(checkpoint.createdAt),
+  };
+}
+
+export function mapCheckpoint(row: CheckpointRow): SessionCheckpoint {
+  return {
+    checkpointId: row.checkpointId as `session_checkpoint_${string}`,
+    sessionId: row.sessionId as SessionId,
+    throughSequence: row.throughSequence,
+    factDigest: row.factDigest as `sha256:${string}`,
+    createdAt: new Date(row.createdAt).toISOString(),
+  };
+}
+
+export function createdSession(input: CreateSessionInput): SessionRecord {
+  return {
+    sessionId: input.sessionId,
+    governance: structuredClone(input.governance),
+    status: "active",
+    headSequence: 1,
+    createdAt: input.createdAt,
+    updatedAt: input.createdEvent.occurredAt,
+    ...(input.lineage ? { lineage: structuredClone(input.lineage) } : {}),
+  };
+}
+
+export function appendResult(
+  session: SessionRecord,
+  events: readonly SessionEventEnvelope[],
+  replayed: boolean,
+): SessionAppendResult {
+  return { session, events, replayed };
+}
+
+export function samePendingEvent(
+  left: SessionEventEnvelope,
+  right: PendingSessionEvent,
+) {
+  return (
+    left.occurredAt === right.occurredAt &&
+    JSON.stringify(left.data) === JSON.stringify(right.data)
+  );
+}
+
+export function sameValue(left: unknown, right: unknown) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}

package/template/apps/server/src/agent/session-persistence/drizzle-session-mutations.ts

@@ -0,0 +1,64 @@
+import { randomUUID } from "node:crypto";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { SessionEventId, SessionId } from "../session-log/domain.js";
+import { SessionLifecycleService } from "../session-log/lifecycle.js";
+import { DrizzleSessionInvalidationOutbox } from "./drizzle-invalidation-outbox.js";
+import { DrizzleMemoryProjectionDeletion } from "./drizzle-memory-projection-deletion.js";
+import { DrizzleSessionEventRepository } from "./drizzle-session-repository.js";
+import { AgentSessionPayloadCodec } from "./payload-codec.js";
+
+export class DrizzleSessionMutationCoordinator {
+  constructor(
+    private readonly db: NodePgDatabase,
+    private readonly codec: AgentSessionPayloadCodec,
+  ) {}
+
+  archive(input: {
+    readonly sessionId: SessionId;
+    readonly expectedSequence: number;
+    readonly eventId: SessionEventId;
+  }) {
+    return this.db.transaction(async (transaction) => {
+      const db = transaction as unknown as NodePgDatabase;
+      const repository = new DrizzleSessionEventRepository(db, this.codec);
+      const result = await new SessionLifecycleService(repository).archive({
+        ...input,
+        reason: "user-request",
+      });
+      await new DrizzleSessionInvalidationOutbox(db).appendInTransaction(
+        db,
+        {
+          contractVersion: 1,
+          invalidationId: `source_invalidation_${randomUUID()}`,
+          source: {
+            moduleKey: "system.agent",
+            sourceKind: "session",
+            sourceId: input.sessionId,
+            version: String(result.session.headSequence),
+            sequence: result.session.headSequence,
+          },
+          causedBy: {
+            kind: "session-event",
+            eventId: input.eventId,
+            eventSequence: result.session.headSequence,
+            sessionId: input.sessionId,
+          },
+          occurredAt: result.events[0]!.occurredAt,
+          transition: { reason: "source-archived", targetState: "archived" },
+          scope: { kind: "session-derived", sessionId: input.sessionId },
+        },
+      );
+      return result;
+    });
+  }
+
+  deleteMemory(sessionId: SessionId, memoryId: string) {
+    return this.db.transaction(async (transaction) => {
+      const db = transaction as unknown as NodePgDatabase;
+      const result = await new DrizzleMemoryProjectionDeletion(
+        db,
+      ).deleteProjection({ sessionId, memoryId, deletedAt: Date.now() });
+      return result !== "not-found";
+    });
+  }
+}

package/template/apps/server/src/agent/session-persistence/drizzle-session-repository.ts

@@ -0,0 +1,335 @@
+import {
+  agentSessionCheckpoints,
+  agentSessionEvents,
+  agentSessions,
+} from "@southwind-ai/database";
+import { and, asc, eq, gt, inArray, lte, sql } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { SessionId } from "../session-log/domain.js";
+import type {
+  PendingSessionEvent,
+  SessionEventEnvelope,
+} from "../session-log/events.js";
+import {
+  SessionRepositoryConflict,
+  type ArchiveSessionInput,
+  type AppendSessionEventsInput,
+  type CreateCheckpointInput,
+  type CreateSessionInput,
+  type ForkSessionInput,
+  type SessionAppendResult,
+  type SessionEventRepository,
+  type SessionForkResult,
+} from "../session-log/repository.js";
+import {
+  checkpointValues,
+  appendResult as result,
+  createdSession,
+  eventValues,
+  mapCheckpoint,
+  mapEvent,
+  mapSession,
+  samePendingEvent,
+  sameValue,
+  sessionValues,
+} from "./drizzle-session-mapping.js";
+import { AgentSessionPayloadCodec } from "./payload-codec.js";
+import { listSessionsForGovernance } from "./drizzle-session-list.js";
+import { forkDrizzleSession } from "./drizzle-session-fork.js";
+export class DrizzleSessionEventRepository implements SessionEventRepository {
+  constructor(
+    private readonly db: NodePgDatabase,
+    private readonly codec: AgentSessionPayloadCodec,
+  ) {}
+
+  create(input: CreateSessionInput): Promise<SessionAppendResult> {
+    return this.db.transaction(async (transaction) => {
+      const db = transaction as unknown as NodePgDatabase;
+      const session = createdSession(input);
+      const [created] = await db
+        .insert(agentSessions)
+        .values(sessionValues(session))
+        .onConflictDoNothing({ target: agentSessions.sessionId })
+        .returning();
+      if (!created) return this.replayCreate(db, input);
+      const [event] = await db
+        .insert(agentSessionEvents)
+        .values(eventValues(this.codec, input.sessionId, 1, input.createdEvent))
+        .returning();
+      if (!event) throw new Error("Session 首事件写入失败");
+      return result(mapSession(created), [mapEvent(this.codec, event)], false);
+    });
+  }
+
+  async get(sessionId: SessionId) {
+    const [row] = await this.db
+      .select()
+      .from(agentSessions)
+      .where(eq(agentSessions.sessionId, sessionId))
+      .limit(1);
+    return row ? mapSession(row) : undefined;
+  }
+
+  async listForActor(actorId: string, scopeDigest: string, limit = 100) {
+    return listSessionsForGovernance(this.db, actorId, scopeDigest, limit);
+  }
+
+  async read(input: {
+    sessionId: SessionId;
+    afterSequence: number;
+    throughSequence?: number;
+    limit: number;
+  }) {
+    const rows = await this.db
+      .select()
+      .from(agentSessionEvents)
+      .where(
+        and(
+          eq(agentSessionEvents.sessionId, input.sessionId),
+          gt(agentSessionEvents.sequence, input.afterSequence),
+          input.throughSequence === undefined
+            ? undefined
+            : lte(agentSessionEvents.sequence, input.throughSequence),
+        ),
+      )
+      .orderBy(asc(agentSessionEvents.sequence))
+      .limit(input.limit);
+    return rows.map((row) => mapEvent(this.codec, row));
+  }
+
+  async findEvent(sessionId: SessionId, eventId: string) {
+    const [row] = await this.db
+      .select()
+      .from(agentSessionEvents)
+      .where(
+        and(
+          eq(agentSessionEvents.sessionId, sessionId),
+          eq(agentSessionEvents.eventId, eventId),
+        ),
+      )
+      .limit(1);
+    return row ? mapEvent(this.codec, row) : undefined;
+  }
+
+  append(input: AppendSessionEventsInput): Promise<SessionAppendResult> {
+    return this.db.transaction((transaction) =>
+      this.appendLocked(transaction as unknown as NodePgDatabase, input),
+    );
+  }
+
+  checkpoint(input: CreateCheckpointInput): Promise<SessionAppendResult> {
+    return this.db.transaction(async (transaction) => {
+      const db = transaction as unknown as NodePgDatabase;
+      const existing = await this.getCheckpointLocked(
+        db,
+        input.checkpoint.checkpointId,
+      );
+      if (existing) {
+        const replay = await this.replayEvents(db, input.sessionId, [
+          input.event,
+        ]);
+        if (replay && sameValue(existing, input.checkpoint)) {
+          const session = await this.requireSession(db, input.sessionId);
+          return result(session, replay, true);
+        }
+        throw new SessionRepositoryConflict("CHECKPOINT_CONFLICT");
+      }
+      const appended = await this.appendLocked(db, {
+        sessionId: input.sessionId,
+        expectedSequence: input.expectedSequence,
+        events: [input.event],
+      });
+      await db
+        .insert(agentSessionCheckpoints)
+        .values(checkpointValues(input.checkpoint));
+      return appended;
+    });
+  }
+
+  async getCheckpoint(checkpointId: `session_checkpoint_${string}`) {
+    return this.getCheckpointLocked(this.db, checkpointId);
+  }
+
+  fork(input: ForkSessionInput): Promise<SessionForkResult> {
+    return this.db.transaction(async (transaction) => {
+      const db = transaction as unknown as NodePgDatabase;
+      return forkDrizzleSession(
+        {
+          db,
+          codec: this.codec,
+          lockSession: (sessionId) => this.lockSession(db, sessionId),
+          selectSession: (sessionId) => this.selectSession(db, sessionId),
+          getCheckpoint: (checkpointId) =>
+            this.getCheckpointLocked(db, checkpointId),
+          replayEvents: (sessionId, events) =>
+            this.replayEvents(db, sessionId, events),
+          assertEventIdsFree: (events) => this.assertEventIdsFree(db, events),
+        },
+        input,
+      );
+    });
+  }
+
+  archive(input: ArchiveSessionInput): Promise<SessionAppendResult> {
+    return this.db.transaction((transaction) =>
+      this.archiveInTransaction(
+        transaction as unknown as NodePgDatabase,
+        input,
+      ),
+    );
+  }
+
+  async archiveInTransaction(db: NodePgDatabase, input: ArchiveSessionInput) {
+    const appended = await this.appendLocked(db, {
+      sessionId: input.sessionId,
+      expectedSequence: input.expectedSequence,
+      events: [input.event],
+    });
+    const [row] = await db
+      .update(agentSessions)
+      .set({ status: "archived" })
+      .where(eq(agentSessions.sessionId, input.sessionId))
+      .returning();
+    if (!row) throw new SessionRepositoryConflict("SESSION_NOT_FOUND");
+    return { ...appended, session: mapSession(row) };
+  }
+
+  private async appendLocked(
+    db: NodePgDatabase,
+    input: AppendSessionEventsInput,
+  ) {
+    if (!input.events.length) throw new Error("Session append 不能为空");
+    const session = await this.lockSession(db, input.sessionId);
+    if (!session) throw new SessionRepositoryConflict("SESSION_NOT_FOUND");
+    const replay = await this.replayEvents(db, input.sessionId, input.events);
+    if (replay) return result(session, replay, true);
+    if (session.status !== "active") {
+      throw new SessionRepositoryConflict("SESSION_NOT_ACTIVE");
+    }
+    if (session.headSequence !== input.expectedSequence) {
+      throw new SessionRepositoryConflict("SEQUENCE_CONFLICT");
+    }
+    await this.assertEventIdsFree(db, input.events);
+    const values = input.events.map((event, index) =>
+      eventValues(
+        this.codec,
+        input.sessionId,
+        input.expectedSequence + index + 1,
+        event,
+      ),
+    );
+    const [updated] = await db
+      .update(agentSessions)
+      .set({
+        headSequence: values.at(-1)!.sequence,
+        updatedAt: values.at(-1)!.occurredAt,
+      })
+      .where(
+        and(
+          eq(agentSessions.sessionId, input.sessionId),
+          eq(agentSessions.headSequence, input.expectedSequence),
+        ),
+      )
+      .returning();
+    if (!updated) throw new SessionRepositoryConflict("SEQUENCE_CONFLICT");
+    const rows = await db.insert(agentSessionEvents).values(values).returning();
+    return result(
+      mapSession(updated),
+      rows.map((row) => mapEvent(this.codec, row)),
+      false,
+    );
+  }
+
+  private async replayCreate(db: NodePgDatabase, input: CreateSessionInput) {
+    const session = await this.requireSession(db, input.sessionId);
+    const events = await this.replayEvents(db, input.sessionId, [
+      input.createdEvent,
+    ]);
+    if (!events) throw new SessionRepositoryConflict("SESSION_EXISTS");
+    return result(session, events, true);
+  }
+
+  private async replayEvents(
+    db: NodePgDatabase,
+    sessionId: SessionId,
+    pending: readonly PendingSessionEvent[],
+  ): Promise<SessionEventEnvelope[] | undefined> {
+    const rows = await db
+      .select()
+      .from(agentSessionEvents)
+      .where(
+        inArray(
+          agentSessionEvents.eventId,
+          pending.map(({ eventId }) => eventId),
+        ),
+      );
+    if (!rows.length) return undefined;
+    if (rows.length !== pending.length)
+      throw new SessionRepositoryConflict("EVENT_ID_CONFLICT");
+    const events = rows.map((row) => mapEvent(this.codec, row));
+    const ordered = pending.map((item) =>
+      events.find(({ eventId }) => eventId === item.eventId)!,
+    );
+    if (
+      ordered.some(
+        (event, index) =>
+          !event ||
+          event.sessionId !== sessionId ||
+          !samePendingEvent(event, pending[index]!),
+      )
+    )
+      throw new SessionRepositoryConflict("EVENT_ID_CONFLICT");
+    return ordered;
+  }
+
+  private async assertEventIdsFree(
+    db: NodePgDatabase,
+    events: readonly PendingSessionEvent[],
+  ) {
+    if (new Set(events.map(({ eventId }) => eventId)).size !== events.length) {
+      throw new SessionRepositoryConflict("EVENT_ID_CONFLICT");
+    }
+    const rows = await db
+      .select({ eventId: agentSessionEvents.eventId })
+      .from(agentSessionEvents)
+      .where(
+        inArray(
+          agentSessionEvents.eventId,
+          events.map(({ eventId }) => eventId),
+        ),
+      )
+      .limit(1);
+    if (rows.length) throw new SessionRepositoryConflict("EVENT_ID_CONFLICT");
+  }
+
+  private async lockSession(db: NodePgDatabase, sessionId: SessionId) {
+    await db.execute(
+      sql`select session_id from agent_sessions where session_id = ${sessionId} for update`,
+    );
+    return this.selectSession(db, sessionId);
+  }
+
+  private async selectSession(db: NodePgDatabase, sessionId: SessionId) {
+    const [row] = await db
+      .select()
+      .from(agentSessions)
+      .where(eq(agentSessions.sessionId, sessionId))
+      .limit(1);
+    return row ? mapSession(row) : undefined;
+  }
+
+  private async requireSession(db: NodePgDatabase, sessionId: SessionId) {
+    const session = await this.selectSession(db, sessionId);
+    if (!session) throw new SessionRepositoryConflict("SESSION_NOT_FOUND");
+    return session;
+  }
+
+  private async getCheckpointLocked(db: NodePgDatabase, checkpointId: string) {
+    const [row] = await db
+      .select()
+      .from(agentSessionCheckpoints)
+      .where(eq(agentSessionCheckpoints.checkpointId, checkpointId))
+      .limit(1);
+    return row ? mapCheckpoint(row) : undefined;
+  }
+}