create-windy 0.3.2 → 0.3.5

package/template/apps/server/src/ai-artifact/codec.ts

@@ -0,0 +1,137 @@
+import {
+  createCipheriv,
+  createDecipheriv,
+  createHash,
+  randomBytes,
+} from "node:crypto";
+import type { ModuleResourceFileRequest } from "@southwind-ai/server-sdk";
+
+export interface AiArtifactClaims {
+  readonly version: 1;
+  readonly moduleName: string;
+  readonly actorId: string;
+  readonly source: ModuleResourceFileRequest;
+  readonly mediaType: string;
+  readonly byteSize: number;
+  readonly sha256: string;
+  readonly issuedAt: string;
+  readonly expiresAt: string;
+}
+
+const aad = Buffer.from("southwind-ai-artifact-v1");
+
+export class AiArtifactCodec {
+  readonly #key: Buffer;
+
+  constructor(secret: string) {
+    if (secret.trim().length < 32) {
+      throw new Error("AI Artifact 加密 Secret 至少需要 32 个字符");
+    }
+    this.#key = createHash("sha256").update(secret).digest();
+  }
+
+  encode(claims: AiArtifactClaims): string {
+    const iv = randomBytes(12);
+    const cipher = createCipheriv("aes-256-gcm", this.#key, iv);
+    cipher.setAAD(aad);
+    const encrypted = Buffer.concat([
+      cipher.update(JSON.stringify(claims), "utf8"),
+      cipher.final(),
+    ]);
+    return [
+      "v1",
+      iv.toString("base64url"),
+      encrypted.toString("base64url"),
+      cipher.getAuthTag().toString("base64url"),
+    ].join(".");
+  }
+
+  decode(token: string): AiArtifactClaims {
+    try {
+      if (token.length > 4_096) throw new Error("token too large");
+      const [version, ivValue, encryptedValue, tagValue, extra] =
+        token.split(".");
+      if (
+        version !== "v1" ||
+        !ivValue ||
+        !encryptedValue ||
+        !tagValue ||
+        extra
+      ) {
+        throw new Error("token shape");
+      }
+      const decipher = createDecipheriv(
+        "aes-256-gcm",
+        this.#key,
+        decodeCanonicalBase64url(ivValue, 12),
+      );
+      decipher.setAAD(aad);
+      decipher.setAuthTag(decodeCanonicalBase64url(tagValue, 16));
+      const plaintext = Buffer.concat([
+        decipher.update(decodeCanonicalBase64url(encryptedValue)),
+        decipher.final(),
+      ]);
+      return parseClaims(JSON.parse(plaintext.toString("utf8")));
+    } catch {
+      throw new AiArtifactCodecError();
+    }
+  }
+}
+
+export class AiArtifactCodecError extends Error {
+  constructor() {
+    super("AI Artifact 引用无效");
+    this.name = "AiArtifactCodecError";
+  }
+}
+
+function decodeCanonicalBase64url(value: string, byteSize?: number): Buffer {
+  if (!/^[A-Za-z0-9_-]+$/.test(value)) {
+    throw new Error("base64url invalid");
+  }
+  const decoded = Buffer.from(value, "base64url");
+  if (
+    decoded.toString("base64url") !== value ||
+    (byteSize !== undefined && decoded.byteLength !== byteSize)
+  ) {
+    throw new Error("base64url non-canonical");
+  }
+  return decoded;
+}
+
+function parseClaims(value: unknown): AiArtifactClaims {
+  if (!isRecord(value) || value.version !== 1 || !isRecord(value.source)) {
+    throw new Error("claims invalid");
+  }
+  const claims = value as unknown as AiArtifactClaims;
+  for (const field of [
+    claims.moduleName,
+    claims.actorId,
+    claims.source.fileId,
+    claims.source.purpose,
+    claims.source.resourceType,
+    claims.source.resourceId,
+    claims.mediaType,
+    claims.sha256,
+    claims.issuedAt,
+    claims.expiresAt,
+  ]) {
+    if (typeof field !== "string" || !field.trim()) {
+      throw new Error("claims field invalid");
+    }
+  }
+  if (
+    !Number.isSafeInteger(claims.byteSize) ||
+    claims.byteSize < 0 ||
+    !/^[a-f0-9]{64}$/.test(claims.sha256) ||
+    !Number.isFinite(Date.parse(claims.issuedAt)) ||
+    !Number.isFinite(Date.parse(claims.expiresAt))
+  ) {
+    throw new Error("claims metadata invalid");
+  }
+  return claims;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}

package/template/apps/server/src/ai-artifact/routes.ts

@@ -0,0 +1,37 @@
+import type { RouteApp } from "../system/route-types.js";
+import { validInternalToken } from "../agent/run-routes.js";
+import type { AiArtifactRuntime } from "./runtime.js";
+
+interface RouteContext {
+  readonly request: Request;
+}
+
+export function registerAiArtifactRoutes(
+  app: RouteApp,
+  artifacts: AiArtifactRuntime,
+  internalToken: string,
+) {
+  app.get("/internal/ai/artifacts", async (raw) => {
+    const context = raw as RouteContext;
+    if (!validInternalToken(context.request, internalToken)) {
+      return Response.json({ code: "FORBIDDEN" }, { status: 403 });
+    }
+    const token = context.request.headers.get("x-ai-artifact-ref");
+    if (!token) {
+      return Response.json({ code: "ARTIFACT_UNAVAILABLE" }, { status: 404 });
+    }
+    try {
+      const opened = await artifacts.openToken(token, context.request.signal);
+      return new Response(opened.body, {
+        headers: {
+          "cache-control": "private, no-store",
+          "content-type": opened.mimeType,
+          "content-length": String(opened.byteSize),
+          "x-content-sha256": opened.sha256,
+        },
+      });
+    } catch {
+      return Response.json({ code: "ARTIFACT_UNAVAILABLE" }, { status: 404 });
+    }
+  });
+}

package/template/apps/server/src/ai-artifact/runtime.ts

@@ -0,0 +1,205 @@
+import {
+  ModuleAiArtifactError,
+  type ModuleAiArtifactPort,
+  type ModuleAiArtifactRef,
+  type ModuleResourceFileRequest,
+} from "@southwind-ai/server-sdk";
+import type { FeatureFlagDefinition } from "@southwind-ai/shared";
+import type { RequestActor, RequestGuardContext } from "../guards.js";
+import type { InitializedModuleHosts } from "../module-host.js";
+import {
+  createModuleStoragePort,
+  type ModuleStorageServices,
+} from "../module-host/storage-port.js";
+import { createModuleStorageScope } from "../module-host/storage-scope.js";
+import type { createServerRuntime } from "../runtime.js";
+import { AiArtifactCodec, type AiArtifactClaims } from "./codec.js";
+
+export class AiArtifactRuntime {
+  constructor(
+    private readonly codec: AiArtifactCodec,
+    private readonly hosts: InitializedModuleHosts,
+    private readonly runtime: ReturnType<typeof createServerRuntime>,
+    private readonly features: readonly FeatureFlagDefinition[],
+    private readonly storage: ModuleStorageServices,
+    private readonly resolveActor: (
+      actorId: string,
+    ) => Promise<RequestActor | undefined>,
+    private readonly now: () => Date = () => new Date(),
+  ) {}
+
+  createModulePort(
+    moduleName: string,
+    guardContext: RequestGuardContext,
+    signal: AbortSignal,
+  ): ModuleAiArtifactPort {
+    return {
+      issue: (source, options) =>
+        this.issue(
+          moduleName,
+          guardContext,
+          source,
+          options?.ttlSeconds,
+          signal,
+        ),
+    };
+  }
+
+  async rotate(
+    token: string,
+    actorId: string,
+    moduleName: string,
+    ttlSeconds: number,
+    signal: AbortSignal,
+  ): Promise<ModuleAiArtifactRef> {
+    const claims = this.requireClaims(token, actorId, moduleName);
+    const opened = await this.open(claims, signal);
+    await opened.body.cancel().catch(() => undefined);
+    return this.reference(claims, opened, boundedTtl(ttlSeconds, 60, 3_600));
+  }
+
+  async openToken(token: string, signal: AbortSignal) {
+    return this.open(this.requireClaims(token), signal);
+  }
+
+  private async issue(
+    moduleName: string,
+    guardContext: RequestGuardContext,
+    source: ModuleResourceFileRequest,
+    ttlSeconds = 300,
+    signal: AbortSignal,
+  ) {
+    const port = this.storagePort(moduleName, guardContext, signal);
+    try {
+      const opened = await port.openResourceFile(source);
+      await opened.body.cancel().catch(() => undefined);
+      return this.reference(
+        {
+          version: 1,
+          moduleName,
+          actorId: guardContext.actor.id,
+          source,
+          mediaType: opened.mimeType,
+          byteSize: opened.byteSize,
+          sha256: opened.sha256,
+          issuedAt: this.now().toISOString(),
+          expiresAt: this.now().toISOString(),
+        },
+        opened,
+        boundedTtl(ttlSeconds, 60, 900),
+      );
+    } catch (error) {
+      if (error instanceof ModuleAiArtifactError) throw error;
+      throw new ModuleAiArtifactError(
+        "AI_ARTIFACT_FORBIDDEN",
+        "业务资源不能转换为 AI Artifact",
+      );
+    }
+  }
+
+  private reference(
+    claims: AiArtifactClaims,
+    opened: {
+      mimeType: string;
+      byteSize: number;
+      sha256: string;
+    },
+    ttlSeconds: number,
+  ): ModuleAiArtifactRef {
+    const issuedAt = this.now();
+    const expiresAt = new Date(
+      issuedAt.getTime() + ttlSeconds * 1_000,
+    ).toISOString();
+    const refreshed: AiArtifactClaims = {
+      ...claims,
+      mediaType: opened.mimeType,
+      byteSize: opened.byteSize,
+      sha256: opened.sha256,
+      issuedAt: issuedAt.toISOString(),
+      expiresAt,
+    };
+    return {
+      value: this.codec.encode(refreshed),
+      mediaType: refreshed.mediaType,
+      byteSize: refreshed.byteSize,
+      sha256: refreshed.sha256,
+      expiresAt,
+    };
+  }
+
+  private requireClaims(token: string, actorId?: string, moduleName?: string) {
+    const claims = this.codec.decode(token);
+    if (
+      claims.expiresAt <= this.now().toISOString() ||
+      (actorId && claims.actorId !== actorId) ||
+      (moduleName && claims.moduleName !== moduleName)
+    ) {
+      throw new ModuleAiArtifactError(
+        "AI_ARTIFACT_FORBIDDEN",
+        "AI Artifact 已过期或不属于当前调用方",
+      );
+    }
+    return claims;
+  }
+
+  private async open(claims: AiArtifactClaims, signal: AbortSignal) {
+    const actor = await this.resolveActor(claims.actorId);
+    if (!actor) throw forbidden();
+    const request = new Request("http://ai-artifact.internal/open", { signal });
+    const guardContext = await this.runtime.createGuardContextForActor(
+      request,
+      actor,
+    );
+    const opened = await this.storagePort(
+      claims.moduleName,
+      guardContext,
+      signal,
+    ).openResourceFile(claims.source);
+    if (
+      opened.mimeType !== claims.mediaType ||
+      opened.byteSize !== claims.byteSize ||
+      opened.sha256 !== claims.sha256
+    ) {
+      await opened.body.cancel().catch(() => undefined);
+      throw forbidden();
+    }
+    return opened;
+  }
+
+  private storagePort(
+    moduleName: string,
+    guardContext: RequestGuardContext,
+    signal: AbortSignal,
+  ) {
+    return createModuleStoragePort(
+      this.storage,
+      createModuleStorageScope({
+        moduleName,
+        purposes: this.hosts.uploadPurposesOf(moduleName),
+        resourceFileAccessPolicies:
+          this.hosts.resourceFileAccessPoliciesOf(moduleName),
+        guardContext,
+        runtime: this.runtime,
+        features: this.features,
+        signal,
+      }),
+    );
+  }
+}
+
+function boundedTtl(value: number, minimum: number, maximum: number) {
+  if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+    throw new ModuleAiArtifactError(
+      "AI_ARTIFACT_INVALID",
+      `AI Artifact TTL 必须在 ${minimum}–${maximum} 秒之间`,
+    );
+  }
+  return value;
+}
+
+function forbidden() {
+  return new ModuleAiArtifactError(
+    "AI_ARTIFACT_FORBIDDEN",
+    "AI Artifact 当前授权已失效",
+  );
+}

package/template/apps/server/src/application-services.ts

@@ -5,7 +5,10 @@ import { GovernedExportJobRuntime } from "./data-governance/export/job-runtime.j
 import { SystemGovernedExportAuthorization } from "./data-governance/export/authorization-port.js";
 import { InMemoryGovernedExportRepository } from "./data-governance/export/repository.js";
 import { GovernedExportService } from "./data-governance/export/service.js";
-import { GovernedUserExportSource } from "./data-governance/export/source.js";
+import {
+  GovernedUserExportSource,
+  ModuleGovernedExportSource,
+} from "./data-governance/export/source.js";
 import { DrizzleBulkDataRepository } from "./bulk-data/drizzle-repository.js";
 import { InMemoryBulkDataRepository } from "./bulk-data/repository.js";
 import type { createFoundationSnapshot } from "./foundation.js";
@@ -45,6 +48,12 @@ import {
 import { SystemNotificationRecipientDirectory } from "./notification/recipient-directory.js";
 import { NotificationService } from "./notification/service.js";
 import { SmtpNotificationChannelAdapter } from "./notification/smtp-adapter.js";
+import type { InitializedModuleHosts } from "./module-host.js";
+import {
+  createModuleDurableContextualizer,
+  type ModuleDurableContextServices,
+} from "./module-host/durable-context.js";
+import { resolveCurrentSystemActor } from "./system/actor.js";
 
 interface ApplicationServicesInput {
   persistence: ReturnType<typeof createServerPersistence>;
@@ -56,6 +65,10 @@ interface ApplicationServicesInput {
   bulkRetentionDays: number;
   mailConfig?: PlatformConfig["mail"];
   installModuleDurableHandlers?: (registry: DurableHandlerRegistry) => void;
+  moduleHosts: InitializedModuleHosts;
+  // @windy-module system.agent begin
+  backgroundAi?: ModuleDurableContextServices["backgroundAi"];
+  // @windy-module system.agent end
 }
 
 export async function createApplicationServices(
@@ -155,6 +168,17 @@ export async function createApplicationServices(
     runtime: input.runtime,
     workflow,
     installModuleDurableHandlers: input.installModuleDurableHandlers,
+    durableContextualize: createModuleDurableContextualizer({
+      hosts: input.moduleHosts,
+      runtime: input.runtime,
+      features: input.foundation.features,
+      storage: input.storage,
+      // @windy-module system.agent begin
+      backgroundAi: input.backgroundAi,
+      // @windy-module system.agent end
+      resolveActor: (actorId) =>
+        resolveCurrentSystemActor(input.systemRepositories, actorId),
+    }),
   });
   const governedExportRequests = persistence
     ? new DrizzleGovernedExportRepository(persistence.db)
@@ -162,6 +186,33 @@ export async function createApplicationServices(
   const governedExportApprovals = new WorkflowGovernedExportApproval(workflow, [
     { code: "super-admin", name: "超级管理员" },
   ]);
+  const moduleGovernedExportSources = input.moduleHosts.governedResources
+    .filter(({ registration }) => registration.export)
+    .map(({ moduleName, registration }) => {
+      const policy = input.moduleHosts
+        .manifestOf(moduleName)
+        .dataPolicies?.find(({ key }) => key === registration.policyKey);
+      if (!policy) {
+        throw new Error(`模块数据治理策略不存在：${registration.policyKey}`);
+      }
+      return new ModuleGovernedExportSource(registration, policy, (actorId) =>
+        resolveCurrentSystemActor(input.systemRepositories, actorId),
+      );
+    });
+  const moduleGovernedExportRenderers = input.moduleHosts.governedResources.flatMap(
+    ({ moduleName, registration }) => {
+      const policy = input.moduleHosts
+        .manifestOf(moduleName)
+        .dataPolicies?.find(({ key }) => key === registration.policyKey);
+      if (!policy) {
+        throw new Error(`模块数据治理策略不存在：${registration.policyKey}`);
+      }
+      return (registration.export?.renderers ?? []).map((renderer) => ({
+        resourceType: policy.resourceType,
+        renderer,
+      }));
+    },
+  );
   const governedExports = new GovernedExportJobRuntime(
     governedExportRequests,
     services.durable.service,
@@ -177,9 +228,18 @@ export async function createApplicationServices(
           persistence?.authRepository,
         ).users,
       ),
+      ...moduleGovernedExportSources,
     ],
     (request) => governedExportApprovals.isApproved(request),
-    new SystemGovernedExportAuthorization(input.systemRepositories),
+    new SystemGovernedExportAuthorization(input.systemRepositories, {
+      policies: input.moduleHosts.manifests.flatMap(
+        (manifest) => manifest.dataPolicies ?? [],
+      ),
+      features: input.foundation.features,
+      runtime: input.runtime,
+    }),
+    undefined,
+    moduleGovernedExportRenderers,
   );
   const governedExportService = new GovernedExportService(
     governedExportRequests,

package/template/apps/server/src/auth/reauthentication.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, test } from "bun:test";
+import { InMemoryAuthRepository } from "./repository.js";
+import { ReauthenticationService } from "./reauthentication.js";
+
+describe("AuthService reauthenticate", () => {
+  test("只接受当前启用用户的正确密码", async () => {
+    const repository = new InMemoryAuthRepository([
+      {
+        id: "user-active",
+        username: "active",
+        displayName: "启用用户",
+        passwordHash: "stored-hash",
+        credentialState: "active",
+        status: "active",
+        roleCodes: [],
+        permissionKeys: [],
+      },
+      {
+        id: "user-disabled",
+        username: "disabled",
+        displayName: "停用用户",
+        passwordHash: "stored-hash",
+        credentialState: "active",
+        status: "disabled",
+        roleCodes: [],
+        permissionKeys: [],
+      },
+    ]);
+    const service = new ReauthenticationService(repository, {
+      hash: async () => "stored-hash",
+      verify: async (hash, password) =>
+        hash === "stored-hash" && password === "correct",
+    });
+
+    expect(await service.verify("user-active", "correct")).toBe(true);
+    expect(await service.verify("user-active", "wrong")).toBe(false);
+    expect(await service.verify("user-disabled", "correct")).toBe(false);
+    expect(await service.verify("missing", "correct")).toBe(false);
+  });
+});

package/template/apps/server/src/auth/reauthentication.ts

@@ -0,0 +1,19 @@
+import type { PasswordHasher } from "./password.js";
+import type { AuthRepository } from "./repository.js";
+
+export class ReauthenticationService {
+  constructor(
+    private readonly repository: AuthRepository,
+    private readonly passwordHasher: PasswordHasher,
+  ) {}
+
+  async verify(actorId: string, password: string): Promise<boolean> {
+    if (!actorId.trim() || !password || password.length > 512) return false;
+    const user = await this.repository.findUserByReference(actorId);
+    return Boolean(
+      user?.status === "active" &&
+      user.passwordHash &&
+      (await this.passwordHasher.verify(user.passwordHash, password)),
+    );
+  }
+}

package/template/apps/server/src/auth/runtime.ts

@@ -2,6 +2,8 @@ import type { AuditEventReader, AuditEventWriter } from "../runtime.js";
 import type { PasswordPolicy } from "@southwind-ai/shared";
 import { InMemoryAuthRepository, type AuthRepository } from "./repository.js";
 import { AuthService } from "./service.js";
+import { createArgon2PasswordHasher } from "./password.js";
+import { ReauthenticationService } from "./reauthentication.js";
 
 interface AuthRuntimeInput {
   repository?: AuthRepository;
@@ -13,11 +15,17 @@ interface AuthRuntimeInput {
 
 export function createAuthRuntime(input: AuthRuntimeInput) {
   const authRepository = input.repository ?? new InMemoryAuthRepository();
+  const passwordHasher = createArgon2PasswordHasher(input.passwordPolicy);
   const authService = new AuthService(authRepository, {
     sessionTtlSeconds: input.sessionTtlSeconds,
     passwordPolicy: input.passwordPolicy,
     auditWriter: { write: input.auditWriter },
     auditReader: input.auditReader,
+    passwordHasher,
   });
-  return { authRepository, authService };
+  const reauthentication = new ReauthenticationService(
+    authRepository,
+    passwordHasher,
+  );
+  return { authRepository, authService, reauthentication };
 }

package/template/apps/server/src/data-access/context.ts

@@ -1,5 +1,7 @@
-import type { DataScope } from "@southwind-ai/shared";
-import type { GovernedExportScopeSnapshot } from "@southwind-ai/database";
+import type {
+  AuthorizationScopeSnapshot,
+  DataScope,
+} from "@southwind-ai/shared";
 
 export interface DataAccessRolePolicy {
   id: string;
@@ -96,7 +98,7 @@ export function isServerScopeContext(value: unknown): value is ScopeContext {
  */
 export function snapshotServerScopeContext(
   value: unknown,
-): GovernedExportScopeSnapshot {
+): AuthorizationScopeSnapshot {
   if (!isServerScopeContext(value)) {
     throw new Error("治理任务缺少服务端 ScopeContext");
   }
@@ -126,7 +128,7 @@ export function snapshotServerScopeContext(
 
 /** Worker 只从受控 Repository 读取投影并在服务端恢复 nominal context。 */
 export function restoreServerScopeContext(
-  snapshot: GovernedExportScopeSnapshot,
+  snapshot: AuthorizationScopeSnapshot,
 ): ScopeContext {
   if (
     snapshot.tenantId !== "single-tenant" ||

package/template/apps/server/src/data-access/scope-snapshot.ts

@@ -0,0 +1,27 @@
+import { createHash } from "node:crypto";
+import type { AuthorizationScopeSnapshot } from "@southwind-ai/shared";
+import { snapshotServerScopeContext } from "./context.js";
+
+export function captureAuthorizationScope(value: unknown) {
+  const snapshot = snapshotServerScopeContext(value);
+  return { snapshot, hash: hashAuthorizationScope(snapshot) };
+}
+
+export function hashAuthorizationScope(
+  snapshot: AuthorizationScopeSnapshot,
+): string {
+  return createHash("sha256").update(stableJson(snapshot)).digest("hex");
+}
+
+function stableJson(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value as Record<string, unknown>)
+      .filter(([, item]) => item !== undefined)
+      .sort(([left], [right]) => left.localeCompare(right));
+    return `{${entries
+      .map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`)
+      .join(",")}}`;
+  }
+  return JSON.stringify(value);
+}

package/template/apps/server/src/data-governance/export/approval-port.ts

@@ -26,13 +26,16 @@ export class WorkflowGovernedExportApproval implements GovernedExportApprovalPor
   async create(request: GovernedExportRequest, actor: RequestActor) {
     const item = await this.workflow.create(
       {
-        title: `敏感用户数据导出：${request.reason}`,
+        title: `敏感数据导出：${request.reason}`,
         candidateRoles: [...this.candidateRoles],
         dueAt: request.expiresAt,
         target: {
-          type: "system.user.governed-export",
+          type: `${request.resourceType}.governed-export`,
           id: request.id,
-          route: `/system/users/exports/${request.id}`,
+          route:
+            request.resourceType === "system.user"
+              ? `/system/users/exports/${request.id}`
+              : "/system/workflow",
         },
         idempotencyKey: `governed-export:${request.id}`,
       },