create-windy 0.5.2 → 0.6.1

package/template/apps/server/src/ai-output-artifact/drizzle-readiness.ts

@@ -0,0 +1,46 @@
+import {
+  aiOutputArtifacts,
+  aiOutputArtifactScopes,
+} from "@southwind-ai/database";
+import { and, eq, inArray } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+
+export function deleteDrizzleOutputReadinessProbe(
+  db: NodePgDatabase,
+  scopeId: string,
+  purpose: string,
+) {
+  if (purpose !== "ai-runtime-output-readiness") return Promise.resolve(false);
+  return db.transaction(async (tx) => {
+    const [scope] = await tx
+      .select({
+        purpose: aiOutputArtifactScopes.purpose,
+        status: aiOutputArtifactScopes.status,
+      })
+      .from(aiOutputArtifactScopes)
+      .where(eq(aiOutputArtifactScopes.scopeId, scopeId))
+      .limit(1)
+      .for("update");
+    if (!scope) return true;
+    if (
+      scope.purpose !== purpose ||
+      !["aborted", "cleaned"].includes(scope.status)
+    ) {
+      return false;
+    }
+    await tx
+      .delete(aiOutputArtifacts)
+      .where(eq(aiOutputArtifacts.scopeId, scopeId));
+    const deleted = await tx
+      .delete(aiOutputArtifactScopes)
+      .where(
+        and(
+          eq(aiOutputArtifactScopes.scopeId, scopeId),
+          eq(aiOutputArtifactScopes.purpose, purpose),
+          inArray(aiOutputArtifactScopes.status, ["aborted", "cleaned"]),
+        ),
+      )
+      .returning({ scopeId: aiOutputArtifactScopes.scopeId });
+    return deleted.length === 1;
+  });
+}

package/template/apps/server/src/ai-output-artifact/drizzle-repository.ts

@@ -0,0 +1,350 @@
+import {
+  aiOutputArtifacts,
+  aiOutputArtifactScopes,
+} from "@southwind-ai/database";
+import { and, asc, eq, inArray, sql } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type {
+  AiOutputArtifactRecord,
+  AiOutputArtifactScope,
+} from "./contracts.js";
+import type {
+  AiOutputArtifactRepository,
+  NewAiOutputArtifact,
+  NewAiOutputScope,
+} from "./repository.js";
+import { AiOutputArtifactRepositoryError as RepositoryError } from "./repository.js";
+import {
+  aiOutputArtifactValues,
+  aiOutputScopeValues,
+  mapAiOutputArtifact,
+  mapAiOutputScope,
+} from "./drizzle-mapping.js";
+import { completeDrizzleAiOutputArtifact } from "./drizzle-complete.js";
+import { sealDrizzleAiOutputScope } from "./drizzle-seal.js";
+import { listDrizzleAiOutputCleanupScopes } from "./drizzle-cleanup.js";
+import { clearExpiredDrizzleOutputGrantHashes } from "./drizzle-grant-cleanup.js";
+import {
+  prepareDrizzleOutputGrant,
+  promoteDrizzleOutputGrant,
+  rollbackDrizzleOutputGrant,
+} from "./drizzle-grants.js";
+import { deleteDrizzleOutputReadinessProbe } from "./drizzle-readiness.js";
+
+export class DrizzleAiOutputArtifactRepository implements AiOutputArtifactRepository {
+  constructor(private readonly db: NodePgDatabase) {}
+
+  async createOrGetScope(input: NewAiOutputScope) {
+    const [created] = await this.db
+      .insert(aiOutputArtifactScopes)
+      .values(aiOutputScopeValues(input))
+      .onConflictDoNothing()
+      .returning();
+    if (created) return { scope: mapAiOutputScope(created), created: true };
+    const [existing] = await this.db
+      .select()
+      .from(aiOutputArtifactScopes)
+      .where(eq(aiOutputArtifactScopes.idempotencyHash, input.idempotencyHash))
+      .limit(1);
+    if (existing) {
+      return { scope: mapAiOutputScope(existing), created: false };
+    }
+    const [sameRunKind] = await this.db
+      .select()
+      .from(aiOutputArtifactScopes)
+      .where(
+        and(
+          eq(aiOutputArtifactScopes.runId, input.runId),
+          eq(aiOutputArtifactScopes.outputKind, input.outputKind),
+        ),
+      )
+      .limit(1);
+    if (!sameRunKind) {
+      throw new Error("AI Output Scope 并发创建后无法读取");
+    }
+    return { scope: mapAiOutputScope(sameRunKind), created: false };
+  }
+
+  async getScope(scopeId: string) {
+    const [row] = await this.db
+      .select()
+      .from(aiOutputArtifactScopes)
+      .where(eq(aiOutputArtifactScopes.scopeId, scopeId))
+      .limit(1);
+    return row ? mapAiOutputScope(row) : undefined;
+  }
+
+  async listScopesByRun(runId: string) {
+    return (
+      await this.db
+        .select()
+        .from(aiOutputArtifactScopes)
+        .where(eq(aiOutputArtifactScopes.runId, runId))
+    ).map(mapAiOutputScope);
+  }
+
+  async prepareGrant(
+    scopeId: string,
+    expectedRevision: number,
+    pendingGrantHash: string,
+    pendingGrantExpiresAt: string,
+    updatedAt: string,
+  ) {
+    return prepareDrizzleOutputGrant(
+      this.db,
+      scopeId,
+      expectedRevision,
+      pendingGrantHash,
+      pendingGrantExpiresAt,
+      updatedAt,
+    );
+  }
+
+  async promoteGrant(
+    scopeId: string,
+    expectedRevision: number,
+    pendingGrantGeneration: number,
+    pendingGrantHash: string,
+    updatedAt: string,
+  ) {
+    return promoteDrizzleOutputGrant(
+      this.db,
+      scopeId,
+      expectedRevision,
+      pendingGrantGeneration,
+      pendingGrantHash,
+      updatedAt,
+    );
+  }
+
+  async rollbackGrant(
+    scopeId: string,
+    expectedRevision: number,
+    pendingGrantGeneration: number,
+    pendingGrantHash: string,
+    updatedAt: string,
+  ) {
+    return rollbackDrizzleOutputGrant(
+      this.db,
+      scopeId,
+      expectedRevision,
+      pendingGrantGeneration,
+      pendingGrantHash,
+      updatedAt,
+    );
+  }
+
+  async transitionScope(
+    scopeId: string,
+    expectedRevision: number,
+    expectedStatuses: readonly AiOutputArtifactScope["status"][],
+    status: AiOutputArtifactScope["status"],
+    updatedAt: string,
+  ) {
+    const [row] = await this.db
+      .update(aiOutputArtifactScopes)
+      .set({
+        status,
+        grantHash: status === "cleaned" ? null : undefined,
+        activeGrantGeneration: status === "cleaned" ? null : undefined,
+        pendingGrantHash: status === "open" ? undefined : null,
+        pendingGrantGeneration: status === "open" ? undefined : null,
+        pendingGrantExpiresAt: status === "open" ? undefined : null,
+        revision: sql`${aiOutputArtifactScopes.revision} + 1`,
+        updatedAt: new Date(updatedAt),
+      })
+      .where(
+        and(
+          eq(aiOutputArtifactScopes.scopeId, scopeId),
+          eq(aiOutputArtifactScopes.revision, expectedRevision),
+          inArray(aiOutputArtifactScopes.status, [...expectedStatuses]),
+        ),
+      )
+      .returning();
+    return row ? mapAiOutputScope(row) : undefined;
+  }
+
+  sealScope(
+    scopeId: string,
+    expectedRevision: number,
+    refExpiresAt: string,
+    updatedAt: string,
+  ) {
+    return sealDrizzleAiOutputScope(
+      this.db,
+      scopeId,
+      expectedRevision,
+      refExpiresAt,
+      updatedAt,
+    );
+  }
+
+  async listCleanupScopes(expiredBefore: string, limit: number) {
+    return listDrizzleAiOutputCleanupScopes(this.db, expiredBefore, limit);
+  }
+
+  async clearExpiredGrantHashes(expiredBefore: string, limit: number) {
+    return clearExpiredDrizzleOutputGrantHashes(this.db, expiredBefore, limit);
+  }
+
+  async claimArtifact(input: NewAiOutputArtifact) {
+    return this.db.transaction(async (tx) => {
+      const [scope] = await tx
+        .select()
+        .from(aiOutputArtifactScopes)
+        .where(eq(aiOutputArtifactScopes.scopeId, input.scopeId))
+        .limit(1)
+        .for("update");
+      if (!scope || scope.status !== "open") {
+        throw new RepositoryError("CONFLICT");
+      }
+      const [existing] = await tx
+        .select()
+        .from(aiOutputArtifacts)
+        .where(
+          and(
+            eq(aiOutputArtifacts.scopeId, input.scopeId),
+            eq(aiOutputArtifacts.outputKey, input.outputKey),
+          ),
+        )
+        .limit(1)
+        .for("update");
+      if (existing) {
+        if (
+          existing.fingerprint !== input.fingerprint ||
+          existing.status !== "creating"
+        ) {
+          return { artifact: mapAiOutputArtifact(existing), claimed: false };
+        }
+        const [claimed] = await tx
+          .update(aiOutputArtifacts)
+          .set({
+            generation: sql`${aiOutputArtifacts.generation} + 1`,
+            updatedAt: new Date(input.createdAt),
+          })
+          .where(eq(aiOutputArtifacts.artifactId, existing.artifactId))
+          .returning();
+        return { artifact: mapAiOutputArtifact(claimed!), claimed: true };
+      }
+      const [totals] = await tx
+        .select({
+          expectedBytes:
+            sql<number>`coalesce(sum(${aiOutputArtifacts.expectedByteSize}), 0)`.mapWith(
+              Number,
+            ),
+        })
+        .from(aiOutputArtifacts)
+        .where(eq(aiOutputArtifacts.scopeId, input.scopeId));
+      if (
+        scope.artifactCount >= scope.maxArtifacts ||
+        (totals?.expectedBytes ?? 0) + input.expectedByteSize >
+          scope.maxTotalBytes
+      ) {
+        throw new RepositoryError("LIMIT");
+      }
+      const [created] = await tx
+        .insert(aiOutputArtifacts)
+        .values(aiOutputArtifactValues(input))
+        .onConflictDoNothing({
+          target: [aiOutputArtifacts.scopeId, aiOutputArtifacts.outputKey],
+        })
+        .returning();
+      if (!created) throw new RepositoryError("CONFLICT");
+      await tx
+        .update(aiOutputArtifactScopes)
+        .set({
+          artifactCount: scope.artifactCount + 1,
+          updatedAt: new Date(input.createdAt),
+        })
+        .where(eq(aiOutputArtifactScopes.scopeId, input.scopeId));
+      return { artifact: mapAiOutputArtifact(created!), claimed: true };
+    });
+  }
+
+  async bindUploadSession(
+    artifactId: string,
+    generation: number,
+    uploadSessionId: string,
+    updatedAt: string,
+  ) {
+    const [row] = await this.db
+      .update(aiOutputArtifacts)
+      .set({
+        status: "uploading",
+        uploadSessionId,
+        updatedAt: new Date(updatedAt),
+      })
+      .where(
+        and(
+          eq(aiOutputArtifacts.artifactId, artifactId),
+          eq(aiOutputArtifacts.generation, generation),
+          eq(aiOutputArtifacts.status, "creating"),
+        ),
+      )
+      .returning();
+    return row ? mapAiOutputArtifact(row) : undefined;
+  }
+
+  async completeArtifact(
+    artifactId: string,
+    generation: number,
+    file: { id: string; byteSize: number; sha256: string },
+    updatedAt: string,
+  ) {
+    return completeDrizzleAiOutputArtifact(
+      this.db,
+      artifactId,
+      generation,
+      file,
+      updatedAt,
+    );
+  }
+
+  async transitionArtifact(
+    artifactId: string,
+    expectedGeneration: number,
+    expectedStatuses: readonly AiOutputArtifactRecord["status"][],
+    status: AiOutputArtifactRecord["status"],
+    updatedAt: string,
+  ) {
+    const [row] = await this.db
+      .update(aiOutputArtifacts)
+      .set({
+        status,
+        generation: sql`${aiOutputArtifacts.generation} + 1`,
+        updatedAt: new Date(updatedAt),
+      })
+      .where(
+        and(
+          eq(aiOutputArtifacts.artifactId, artifactId),
+          eq(aiOutputArtifacts.generation, expectedGeneration),
+          inArray(aiOutputArtifacts.status, [...expectedStatuses]),
+        ),
+      )
+      .returning();
+    return row ? mapAiOutputArtifact(row) : undefined;
+  }
+
+  async getArtifact(artifactId: string) {
+    const [row] = await this.db
+      .select()
+      .from(aiOutputArtifacts)
+      .where(eq(aiOutputArtifacts.artifactId, artifactId))
+      .limit(1);
+    return row ? mapAiOutputArtifact(row) : undefined;
+  }
+
+  async listArtifacts(scopeId: string) {
+    return (
+      await this.db
+        .select()
+        .from(aiOutputArtifacts)
+        .where(eq(aiOutputArtifacts.scopeId, scopeId))
+        .orderBy(asc(aiOutputArtifacts.createdAt))
+    ).map(mapAiOutputArtifact);
+  }
+
+  async deleteReadinessProbe(scopeId: string, purpose: string) {
+    return deleteDrizzleOutputReadinessProbe(this.db, scopeId, purpose);
+  }
+}

package/template/apps/server/src/ai-output-artifact/drizzle-seal.ts

@@ -0,0 +1,64 @@
+import {
+  aiOutputArtifacts,
+  aiOutputArtifactScopes,
+} from "@southwind-ai/database";
+import { and, eq, ne } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { mapAiOutputScope } from "./drizzle-mapping.js";
+
+export async function sealDrizzleAiOutputScope(
+  db: NodePgDatabase,
+  scopeId: string,
+  expectedRevision: number,
+  refExpiresAt: string,
+  updatedAt: string,
+) {
+  return db.transaction(async (tx) => {
+    const [scope] = await tx
+      .select()
+      .from(aiOutputArtifactScopes)
+      .where(eq(aiOutputArtifactScopes.scopeId, scopeId))
+      .limit(1)
+      .for("update");
+    if (
+      !scope ||
+      scope.status !== "open" ||
+      scope.revision !== expectedRevision ||
+      Date.parse(refExpiresAt) <= scope.scopeExpiresAt.getTime() ||
+      Date.parse(refExpiresAt) > scope.fileExpiresAt.getTime()
+    ) {
+      return undefined;
+    }
+    const [incomplete] = await tx
+      .select({ artifactId: aiOutputArtifacts.artifactId })
+      .from(aiOutputArtifacts)
+      .where(
+        and(
+          eq(aiOutputArtifacts.scopeId, scopeId),
+          ne(aiOutputArtifacts.status, "completed"),
+        ),
+      )
+      .limit(1);
+    if (incomplete) return undefined;
+    const [sealed] = await tx
+      .update(aiOutputArtifactScopes)
+      .set({
+        status: "sealed",
+        revision: scope.revision + 1,
+        pendingGrantHash: null,
+        pendingGrantGeneration: null,
+        pendingGrantExpiresAt: null,
+        refExpiresAt: new Date(refExpiresAt),
+        updatedAt: new Date(updatedAt),
+      })
+      .where(
+        and(
+          eq(aiOutputArtifactScopes.scopeId, scopeId),
+          eq(aiOutputArtifactScopes.status, "open"),
+          eq(aiOutputArtifactScopes.revision, expectedRevision),
+        ),
+      )
+      .returning();
+    return sealed ? mapAiOutputScope(sealed) : undefined;
+  });
+}

package/template/apps/server/src/ai-output-artifact/grant.ts

@@ -0,0 +1,30 @@
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+
+const grantPattern = /^outgrant_v1_[A-Za-z0-9_-]{43}$/;
+
+export function createAiOutputArtifactGrant(): {
+  readonly token: string;
+  readonly hash: string;
+} {
+  const token = `outgrant_v1_${randomBytes(32).toString("base64url")}`;
+  return { token, hash: hashAiOutputArtifactGrant(token) };
+}
+
+export function matchesAiOutputArtifactGrant(
+  token: string,
+  expectedHash: string,
+): boolean {
+  if (!grantPattern.test(token) || !/^[0-9a-f]{64}$/.test(expectedHash)) {
+    return false;
+  }
+  const actual = Buffer.from(hashAiOutputArtifactGrant(token), "hex");
+  const expected = Buffer.from(expectedHash, "hex");
+  return (
+    actual.byteLength === expected.byteLength &&
+    timingSafeEqual(actual, expected)
+  );
+}
+
+export function hashAiOutputArtifactGrant(token: string): string {
+  return createHash("sha256").update(token).digest("hex");
+}

package/template/apps/server/src/ai-output-artifact/host-registry.ts

@@ -0,0 +1,53 @@
+import type {
+  ModuleAiOperationDefinition,
+  ModuleManifest,
+} from "@southwind-ai/modules";
+import type { FeatureFlagDefinition } from "@southwind-ai/shared";
+import { findFeature } from "../route-guards.js";
+import type { AiOutputRuntimeKind } from "./contracts.js";
+
+export interface OutputArtifactBinding {
+  readonly operationKey: string;
+  readonly runtimeKind: AiOutputRuntimeKind;
+  readonly outputKind: string;
+}
+
+export interface RegisteredOutputArtifactOperation {
+  readonly moduleName: string;
+  readonly definition: ModuleAiOperationDefinition;
+  readonly feature: FeatureFlagDefinition | undefined;
+}
+
+export function outputArtifactOperations(
+  modules: readonly ModuleManifest[],
+  features: readonly FeatureFlagDefinition[],
+  runtimeKind: AiOutputRuntimeKind,
+): Map<string, RegisteredOutputArtifactOperation> {
+  const result = new Map<string, RegisteredOutputArtifactOperation>();
+  for (const module of modules)
+    for (const definition of module.aiOperations ?? []) {
+      if (definition.kind !== runtimeKind) continue;
+      if (result.has(definition.key))
+        throw new Error(`AI Output Artifact Operation 重复：${definition.key}`);
+      result.set(definition.key, {
+        moduleName: module.name,
+        definition,
+        feature: findFeature([...features], definition.featureKey),
+      });
+    }
+  return result;
+}
+
+export function uniqueOutputArtifactBindings(
+  bindings: readonly OutputArtifactBinding[],
+): Map<string, OutputArtifactBinding> {
+  const result = new Map<string, OutputArtifactBinding>();
+  for (const binding of bindings) {
+    if (result.has(binding.operationKey))
+      throw new Error(
+        `AI Output Artifact Binding 重复：${binding.operationKey}`,
+      );
+    result.set(binding.operationKey, binding);
+  }
+  return result;
+}

package/template/apps/server/src/ai-output-artifact/memory-cleanup.ts

@@ -0,0 +1,47 @@
+import type { AiOutputArtifactScope } from "./contracts.js";
+
+export function listMemoryCleanupScopes(
+  scopes: ReadonlyMap<string, AiOutputArtifactScope>,
+  expiredBefore: string,
+  limit: number,
+): AiOutputArtifactScope[] {
+  const staleBefore = new Date(
+    Date.parse(expiredBefore) - 60_000,
+  ).toISOString();
+  return [...scopes.values()]
+    .filter(
+      (scope) =>
+        scope.status === "cleanup-pending" ||
+        ((scope.status === "open" || scope.status === "aborted") &&
+          scope.scopeExpiresAt <= expiredBefore) ||
+        (scope.status === "sealed" && scope.fileExpiresAt <= expiredBefore) ||
+        (scope.status === "aborting" && scope.updatedAt <= staleBefore),
+    )
+    .slice(0, limit)
+    .map((scope) => structuredClone(scope));
+}
+
+export function clearExpiredMemoryGrantHashes(
+  scopes: Map<string, AiOutputArtifactScope>,
+  expiredBefore: string,
+  limit: number,
+): number {
+  const candidates = [...scopes.values()]
+    .filter(
+      (scope) =>
+        ["sealed", "aborted"].includes(scope.status) &&
+        scope.grantHash !== undefined &&
+        scope.refExpiresAt <= expiredBefore,
+    )
+    .slice(0, limit);
+  for (const scope of candidates) {
+    scopes.set(scope.scopeId, {
+      ...scope,
+      grantHash: undefined,
+      activeGrantGeneration: undefined,
+      revision: scope.revision + 1,
+      updatedAt: expiredBefore,
+    });
+  }
+  return candidates.length;
+}

package/template/apps/server/src/ai-output-artifact/memory-grants.ts

@@ -0,0 +1,98 @@
+import type { AiOutputArtifactScope } from "./contracts.js";
+
+export function prepareMemoryOutputGrant(
+  scopes: Map<string, AiOutputArtifactScope>,
+  scopeId: string,
+  expectedRevision: number,
+  pendingGrantHash: string,
+  pendingGrantExpiresAt: string,
+  updatedAt: string,
+): AiOutputArtifactScope | undefined {
+  const scope = scopes.get(scopeId);
+  if (
+    !scope ||
+    scope.status !== "open" ||
+    scope.revision !== expectedRevision ||
+    (scope.pendingGrantExpiresAt && scope.pendingGrantExpiresAt > updatedAt)
+  ) {
+    return undefined;
+  }
+  const pendingGrantGeneration = scope.grantSequence + 1;
+  return save(scopes, {
+    ...scope,
+    revision: scope.revision + 1,
+    grantSequence: pendingGrantGeneration,
+    pendingGrantHash,
+    pendingGrantGeneration,
+    pendingGrantExpiresAt,
+    updatedAt,
+  });
+}
+
+export function promoteMemoryOutputGrant(
+  scopes: Map<string, AiOutputArtifactScope>,
+  scopeId: string,
+  expectedRevision: number,
+  pendingGrantGeneration: number,
+  pendingGrantHash: string,
+  updatedAt: string,
+): AiOutputArtifactScope | undefined {
+  const scope = scopes.get(scopeId);
+  if (
+    !scope ||
+    scope.status !== "open" ||
+    scope.revision !== expectedRevision ||
+    scope.pendingGrantGeneration !== pendingGrantGeneration ||
+    scope.pendingGrantHash !== pendingGrantHash ||
+    !scope.pendingGrantExpiresAt ||
+    scope.pendingGrantExpiresAt <= updatedAt
+  ) {
+    return undefined;
+  }
+  return save(scopes, {
+    ...scope,
+    revision: scope.revision + 1,
+    grantHash: scope.pendingGrantHash,
+    activeGrantGeneration: scope.pendingGrantGeneration,
+    pendingGrantHash: undefined,
+    pendingGrantGeneration: undefined,
+    pendingGrantExpiresAt: undefined,
+    updatedAt,
+  });
+}
+
+export function rollbackMemoryOutputGrant(
+  scopes: Map<string, AiOutputArtifactScope>,
+  scopeId: string,
+  expectedRevision: number,
+  pendingGrantGeneration: number,
+  pendingGrantHash: string,
+  updatedAt: string,
+): AiOutputArtifactScope | undefined {
+  const scope = scopes.get(scopeId);
+  if (
+    !scope ||
+    scope.status !== "open" ||
+    scope.revision !== expectedRevision ||
+    scope.pendingGrantGeneration !== pendingGrantGeneration ||
+    scope.pendingGrantHash !== pendingGrantHash
+  ) {
+    return undefined;
+  }
+  return save(scopes, {
+    ...scope,
+    revision: scope.revision + 1,
+    pendingGrantHash: undefined,
+    pendingGrantGeneration: undefined,
+    pendingGrantExpiresAt: undefined,
+    updatedAt,
+  });
+}
+
+function save(
+  scopes: Map<string, AiOutputArtifactScope>,
+  scope: AiOutputArtifactScope,
+) {
+  scopes.set(scope.scopeId, scope);
+  return structuredClone(scope);
+}