create-windy 0.8.3 → 0.10.0

package/template/apps/server/src/agent-workflow/preset-routes.test.ts

@@ -0,0 +1,94 @@
+import { expect, test } from "bun:test";
+import { licenseVersionKey } from "@southwind-ai/shared";
+import { loadFoundationModules } from "../foundation.js";
+import { createServerRuntime } from "../runtime.js";
+import { createRequestGuardContext } from "../guards.js";
+import { FakeRouteApp } from "../system/route-test-app.js";
+import {
+  createManifestAuthorizedRouteApp,
+  createStaticRouteAuthorizer,
+} from "../module-host/static-route-authorization.js";
+import { AgentWorkflowPresetRegistry } from "./preset-registry.js";
+import { registerAgentWorkflowPresetRoutes } from "./preset-routes.js";
+
+function fixture(permitted = true) {
+  const modules = loadFoundationModules();
+  const runtime = createServerRuntime(
+    {},
+    {
+      featureCatalog: modules.flatMap((module) => module.features),
+    },
+  );
+  const app = new FakeRouteApp();
+  registerAgentWorkflowPresetRoutes(
+    createManifestAuthorizedRouteApp(
+      app,
+      createStaticRouteAuthorizer(runtime, modules),
+    ),
+    new AgentWorkflowPresetRegistry(modules),
+    runtime,
+    () => true,
+  );
+  const request = new Request("http://windy.test/api/agent/workflows/presets");
+  const context = createRequestGuardContext(request, {
+    resolveLicense: () => ({
+      versionKey: licenseVersionKey("advanced"),
+      status: "valid",
+      restricted: false,
+    }),
+    resolveActor: () => ({
+      id: "preset-reader",
+      type: "user",
+      name: "预设读取用户",
+      roleCodes: [],
+      permissionKeys: permitted ? ["system.agent-workflow.read"] : [],
+    }),
+  });
+  return {
+    runtime,
+    invoke: () =>
+      app.invoke("GET", "/agent/workflows/presets", {
+        request,
+        guardContext: context,
+      }) as Promise<Response>,
+  };
+}
+
+test("preset catalog records only its result count before returning", async () => {
+  const f = fixture();
+  const response = await f.invoke();
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ items: [] });
+  const events = f.runtime.auditSink
+    .list()
+    .filter((event) => event.action === "agent.workflow.preset.read");
+  expect(events).toHaveLength(1);
+  expect(events[0]).toMatchObject({
+    actor: { id: "preset-reader" },
+    target: { type: "agent-workflow-presets", id: "catalog" },
+    metadata: { itemCount: 0 },
+  });
+});
+
+test("preset catalog audit failure returns no items or private failure", async () => {
+  const f = fixture();
+  f.runtime.auditSink.recordCriticalEvent = async () => {
+    throw new Error("private failure");
+  };
+  const response = await f.invoke();
+  expect(response.status).toBe(503);
+  expect(await response.json()).toEqual({
+    error: "AUDIT_UNAVAILABLE",
+    message: "预设目录审计暂不可用",
+  });
+});
+
+test("denied preset lookup records no successful read", async () => {
+  const f = fixture(false);
+  expect((await f.invoke()).status).toBe(403);
+  expect(
+    f.runtime.auditSink
+      .list()
+      .some((event) => event.action === "agent.workflow.preset.read"),
+  ).toBe(false);
+});

package/template/apps/server/src/agent-workflow/preset-routes.ts

@@ -0,0 +1,45 @@
+import type { RequestGuardContext } from "../guards.js";
+import type { createServerRuntime } from "../runtime.js";
+import type { RouteApp } from "../system/route-types.js";
+import type { AgentWorkflowPresetRegistry } from "./preset-registry.js";
+import { resourceEvent } from "../system/route-helpers.js";
+
+/** app 必须经 Manifest StaticRouteAuthorizer 包装，路由不提供发布或启动操作。 */
+export function registerAgentWorkflowPresetRoutes(
+  app: Pick<RouteApp, "get">,
+  registry: AgentWorkflowPresetRegistry,
+  runtime: Pick<
+    ReturnType<typeof createServerRuntime>,
+    "resolveFeature" | "recordDecisions" | "auditSink"
+  >,
+  runtimeAvailable: () => boolean,
+) {
+  app.get("/agent/workflows/presets", async (raw) => {
+    const { guardContext } = raw as { guardContext: RequestGuardContext };
+    const items = await registry.list(
+      guardContext,
+      runtime,
+      runtimeAvailable(),
+    );
+    try {
+      await runtime.auditSink.recordCriticalEvent(
+        resourceEvent(
+          guardContext,
+          "agent.workflow.preset.read",
+          "agent-workflow-presets",
+          "catalog",
+          { itemCount: items.length },
+        ),
+      );
+    } catch {
+      return Response.json(
+        { error: "AUDIT_UNAVAILABLE", message: "预设目录审计暂不可用" },
+        { status: 503, headers: { "cache-control": "no-store" } },
+      );
+    }
+    return Response.json(
+      { items },
+      { headers: { "cache-control": "no-store" } },
+    );
+  });
+}

package/template/apps/server/src/agent-workflow/runtime-composition.ts

@@ -98,6 +98,7 @@ export function composeProductionAgentWorkflowRuntime(input: {
   )
     return undefined;
   const resolveActor = input.resolveActor;
+  const agentFacade = input.agentFacade;
   const repository = new DrizzleAgentWorkflowRepository(input.db);
   const effectFence = new DrizzleWorkflowEffectCommandFence(input.db);
   const budgetLedger = new DrizzleWorkflowBudgetLedger(input.db);
@@ -105,6 +106,8 @@ export function composeProductionAgentWorkflowRuntime(input: {
     repository,
     effectFence,
     budgetLedger,
+    (operationKey) =>
+      agentFacade.operationPolicy(operationKey)?.release?.promptVersion,
   );
   const query = new AgentWorkflowQueryService(repository);
   const waitSignals = new AgentWorkflowWaitSignalService(repository);

package/template/apps/server/src/agent-workflow/service.ts

@@ -1,3 +1,4 @@
+import { AgentWorkflowCommandError } from "./command-error.js";
 import {
   budgetFitsWithin,
   type AgentWorkflowArtifactRef,
@@ -74,10 +75,25 @@ export class AgentWorkflowService {
     private readonly repository: AgentWorkflowRepository,
     private readonly effectFence: WorkflowEffectCommandFencePort,
     private readonly budgetLedger: WorkflowBudgetLedgerPort,
+    private readonly resolvePromptVersion?: (
+      operationKey: string,
+    ) => string | undefined,
   ) {}
 
   publish(input: PublishAgentWorkflowReleaseInput) {
-    return this.repository.publishRelease(buildAgentWorkflowRelease(input));
+    const release = buildAgentWorkflowRelease(input);
+    for (const node of release.definition.nodes) {
+      if (
+        node.type === "model" &&
+        this.resolvePromptVersion?.(node.operationKey) !== node.promptKey
+      ) {
+        throw new AgentWorkflowCommandError(
+          "MODEL_PROMPT_RELEASE_MISMATCH",
+          400,
+        );
+      }
+    }
+    return this.repository.publishRelease(release);
   }
 
   async createRun(input: CreateAgentWorkflowRunRequest) {

package/template/apps/server/src/ai-artifact/media-resource-route.test.ts

@@ -0,0 +1,134 @@
+import { createHash } from "node:crypto";
+import { systemModuleManifest } from "@southwind-ai/modules";
+import { expect, test } from "bun:test";
+import { initializeModuleHosts } from "../module-host/initialize.js";
+import {
+  restartActor,
+  restartModuleManifest,
+  restartUploadPolicy,
+} from "../module-host/storage-restart-fixture.test-support.js";
+import { createServerRuntime } from "../runtime.js";
+import { createStorageRuntime } from "../storage/runtime.js";
+import { createPlatformHttpApp } from "../http-app.js";
+import {
+  createManifestAuthorizedRouteApp,
+  createStaticRouteAuthorizer,
+} from "../module-host/static-route-authorization.js";
+import { createPlatformObservability } from "../observability/bootstrap.js";
+import { AiArtifactCodec } from "./codec.js";
+import { registerAiArtifactRoutes } from "./routes.js";
+import { AiArtifactRuntime } from "./runtime.js";
+
+test("关闭 Agent 后媒体 Artifact 仍读取受授权的上传文件，并在撤权后拒绝", async () => {
+  const actor = restartActor();
+  const manifest = {
+    ...restartModuleManifest,
+    apiPermissions: [],
+    tasks: [],
+    auditActions: [...restartModuleManifest.auditActions, "evidence.file.read"],
+  };
+  let active = true;
+  const hosts = await initializeModuleHosts({
+    modules: [manifest],
+    installations: [
+      {
+        manifest,
+        setup(host) {
+          host.registerUploadPolicy(restartUploadPolicy);
+          host.registerResourceFileAccessPolicies([
+            {
+              purpose: restartUploadPolicy.purpose,
+              resourceType: "evidence.document",
+              featureKey: "evidence.generate",
+              permissionKey: "evidence.generate.manage",
+              auditAction: "evidence.file.read",
+              authorize: () => active,
+            },
+          ]);
+        },
+      },
+    ],
+  });
+  const storage = createStorageRuntime({}, undefined, [restartUploadPolicy]);
+  const bytes = new TextEncoder().encode("synthetic OCR input");
+  const sha256 = createHash("sha256").update(bytes).digest("hex");
+  const session = await storage.uploads.create({
+    ownerId: actor.id,
+    purpose: restartUploadPolicy.purpose,
+    filename: "fixture.txt",
+    mimeType: "text/plain",
+    expectedByteSize: bytes.byteLength,
+  });
+  await storage.uploads.appendPart({
+    sessionId: session.id,
+    ownerId: actor.id,
+    partNumber: 0,
+    byteOffset: 0,
+    byteSize: bytes.byteLength,
+    sha256,
+    body: new Blob([bytes]).stream(),
+  });
+  const file = await storage.uploads.complete(session.id, actor.id);
+  const modules = [manifest, systemModuleManifest("system.media-runtime")];
+  const features = modules.flatMap((module) => module.features);
+  const runtime = createServerRuntime(
+    { NODE_ENV: "test" },
+    {
+      featureCatalog: features,
+      disabledFeatureKeys: new Set(["system.agent"]),
+      licenseEnforced: false,
+    },
+  );
+  const request = new Request("http://localhost/api/evidence");
+  const context = await runtime.createGuardContextForActor(request, actor);
+  const artifacts = new AiArtifactRuntime(
+    new AiArtifactCodec("test-media-secret".repeat(3)),
+    hosts,
+    runtime,
+    features,
+    storage,
+    async () => actor,
+  );
+  const reference = await artifacts
+    .createModulePort(manifest.name, context, request.signal)
+    .issue({
+      fileId: file.id,
+      purpose: restartUploadPolicy.purpose,
+      resourceType: "evidence.document",
+      resourceId: "synthetic",
+    });
+  const app = createPlatformHttpApp(
+    runtime,
+    createPlatformObservability({
+      databaseRequired: false,
+      auditStatus: () => runtime.auditSink.status(),
+      logger: { info() {} },
+    }),
+  );
+  registerAiArtifactRoutes(
+    createManifestAuthorizedRouteApp(
+      app,
+      createStaticRouteAuthorizer(runtime, modules),
+    ),
+    artifacts,
+    "internal-test-token",
+  );
+  const open = (token: string) =>
+    app.handle(
+      new Request("http://localhost/api/internal/ai/artifacts", {
+        headers: {
+          authorization: `Bearer ${token}`,
+          "x-ai-artifact-ref": reference.value,
+        },
+      }),
+    );
+
+  expect((await open("wrong-token")).status).toBe(403);
+  const opened = await open("internal-test-token");
+  expect(opened.status).toBe(200);
+  expect(opened.headers.get("x-content-sha256")).toBe(sha256);
+  expect(new Uint8Array(await opened.arrayBuffer())).toEqual(bytes);
+
+  active = false;
+  expect((await open("internal-test-token")).status).toBe(404);
+});

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

@@ -1,5 +1,5 @@
 import type { RouteApp } from "../system/route-types.js";
-import { validInternalToken } from "../agent/run-routes.js";
+import { validInternalToken } from "../ai-runtime-security/internal-token.js";
 import type { AiArtifactRuntime } from "./runtime.js";
 
 interface RouteContext {

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

@@ -1,3 +1,4 @@
+import { evaluateFeatureGuard } from "../guards.js";
 import {
   ModuleAiArtifactError,
   type ModuleAiArtifactPort,
@@ -251,6 +252,17 @@ export class AiArtifactRuntime {
       request,
       actor,
     );
+    if (claims.source.resourceType === "agent-screenshot") {
+      const agent = this.features.find(({ key }) => key === "system.agent");
+      if (
+        !agent ||
+        !evaluateFeatureGuard(
+          guardContext,
+          await this.runtime.resolveFeature(guardContext, agent),
+        ).allowed
+      )
+        throw forbidden();
+    }
     const opened =
       claims.source.resourceType === "agent-screenshot"
         ? await openedScreenshot(

package/template/apps/server/src/ai-runtime-readiness/operation-port.test-support.ts

@@ -66,7 +66,7 @@ export function degradedSnapshot(capabilities = ["document.ocr"]) {
   };
 }
 
-function readinessManifest(): ModuleManifest {
+export function readinessManifest(): ModuleManifest {
   const manifest = documentManifest();
   const operation = manifest.aiOperations?.[0];
   if (!operation) throw new Error("测试 Manifest 缺少 Operation");

package/template/apps/server/src/ai-runtime-readiness/operation-port.ts

@@ -32,6 +32,7 @@ export function createModuleAiOperationReadinessPort(input: {
   readonly now?: () => Date;
   /** Tests may shorten the bound; production defaults to five seconds. */
   readonly probeTimeoutMs?: number;
+  readonly runtimeAllowed?: (kind: AiRuntimeKindV1) => Promise<boolean>;
   readonly trustStore?: AiRuntimeReadinessTrustStoreV1;
 }): ModuleAiOperationReadinessPortV1 {
   const operations = new Map(
@@ -92,6 +93,13 @@ export function createModuleAiOperationReadinessPort(input: {
             "RUNTIME_NOT_CONFIGURED",
           );
       }
+      if (input.runtimeAllowed && !(await input.runtimeAllowed(operation.kind)))
+        return unavailable(
+          operationKey,
+          operation.kind,
+          now(),
+          "RUNTIME_NOT_CONFIGURED",
+        );
       const deadlineController = new AbortController();
       const deadline = setTimeout(
         () => deadlineController.abort("ai-runtime-health-deadline"),

package/template/apps/server/src/ai-runtime-report/service.test.ts

@@ -23,18 +23,21 @@ const feature = {
 };
 
 describe("AI Runtime report service", () => {
-  test("部门范围详情越权统一返回 404", async () => {
+  test("旧引擎详情缺失与部门越权统一明确不可用且不泄露存在性", async () => {
     const runtime = createServerRuntime({}, { featureCatalog: [feature] });
     const remote = new FakeRemote();
     remote.detail = runDetail("department-other");
     const service = createService(runtime, remote);
 
-    await expect(service.run("run_1", context(true))).rejects.toEqual(
-      new AiRuntimeReportError(
-        "AI_RUNTIME_RUN_NOT_FOUND",
-        "Agent Run 不存在",
-        404,
-      ),
+    const expected = new AiRuntimeReportError(
+      "AI_RUNTIME_RUN_NOT_FOUND",
+      "运行详情不可用：记录不在当前范围、已过期或已随旧 Agent 数据重置",
+      404,
+    );
+    await expect(service.run("run_1", context(true))).rejects.toEqual(expected);
+    remote.detail = undefined;
+    await expect(service.run("retired_run", context(true))).rejects.toEqual(
+      expected,
     );
   });
 

package/template/apps/server/src/ai-runtime-report/service.ts

@@ -80,7 +80,7 @@ export class AiRuntimeReportService {
     if (!raw || !reportScopeAllows(scope, raw)) {
       throw new AiRuntimeReportError(
         "AI_RUNTIME_RUN_NOT_FOUND",
-        "Agent Run 不存在",
+        "运行详情不可用：记录不在当前范围、已过期或已随旧 Agent 数据重置",
         404,
       );
     }

package/template/apps/server/src/ai-runtime-security/internal-token.ts

@@ -0,0 +1,14 @@
+import { timingSafeEqual } from "node:crypto";
+
+export function validInternalToken(
+  request: Request,
+  expected: string,
+): boolean {
+  const provided = request.headers
+    .get("authorization")
+    ?.replace(/^Bearer /, "");
+  if (!provided || !expected) return false;
+  const left = Buffer.from(provided);
+  const right = Buffer.from(expected);
+  return left.length === right.length && timingSafeEqual(left, right);
+}

package/template/apps/server/src/app/agent-workflow-presets.ts

@@ -0,0 +1,4 @@
+import type { AgentWorkflowPresetRegistration } from "../agent-workflow/preset-registry.js";
+/** Project-owned: registrations reference installed modules and their real business entrypoints. */
+export const projectAgentWorkflowPresets: readonly AgentWorkflowPresetRegistration[] =
+  [];

package/template/apps/server/src/app/antivirus-composition.test.ts

@@ -0,0 +1,63 @@
+import { expect, test } from "bun:test";
+import { parseEnvironmentPolicy } from "@southwind-ai/shared";
+import { configureProjectAntivirus } from "./antivirus-composition.js";
+
+test("病毒扫描必须已交付且实际就绪", async () => {
+  const base = { schemaVersion: 1, build: { modules: [] }, features: [] };
+  expect(() =>
+    parseEnvironmentPolicy({
+      ...base,
+      antivirus: { packaged: false, enabled: true },
+    }),
+  ).toThrow("病毒扫描未随项目交付");
+  const { antivirus } = parseEnvironmentPolicy({
+    ...base,
+    antivirus: { packaged: true, enabled: true },
+  });
+  await expect(configureProjectAntivirus(antivirus)).rejects.toThrow(
+    "项目未装配扫描器",
+  );
+  await expect(
+    configureProjectAntivirus(antivirus, {
+      packaged: true,
+      configure: async () => "disabled",
+    }),
+  ).rejects.toThrow("未达到环境预设要求");
+  await configureProjectAntivirus(antivirus, {
+    packaged: true,
+    async configure(mode) {
+      expect(mode).toBe("required");
+      return "ready";
+    },
+  });
+});
+
+test("关闭扫描仍显式通知已交付的扫描执行器", async () => {
+  await configureProjectAntivirus(
+    { packaged: true, enabled: false },
+    {
+      packaged: true,
+      async configure(mode) {
+        expect(mode).toBe("disabled");
+        return "disabled";
+      },
+    },
+  );
+});
+
+test("扫描交付声明与项目装配不一致时拒绝启动", async () => {
+  let configured = false;
+  await expect(
+    configureProjectAntivirus(
+      { packaged: false, enabled: false },
+      {
+        packaged: true,
+        async configure() {
+          configured = true;
+          return "disabled";
+        },
+      },
+    ),
+  ).rejects.toThrow("项目已装配扫描器");
+  expect(configured).toBe(false);
+});

package/template/apps/server/src/app/antivirus-composition.ts

@@ -0,0 +1,29 @@
+import type { AntivirusEnvironmentPolicy } from "@southwind-ai/shared";
+
+export interface ProjectAntivirusBinding {
+  readonly packaged: boolean;
+  configure(mode: "disabled" | "required"): Promise<"disabled" | "ready">;
+}
+
+// Project composition supplies the scanner wired to its protected ingestion path.
+const projectAntivirusBinding: ProjectAntivirusBinding | undefined = undefined;
+
+export async function configureProjectAntivirus(
+  policy: AntivirusEnvironmentPolicy | undefined,
+  binding: ProjectAntivirusBinding | undefined = projectAntivirusBinding,
+): Promise<void> {
+  if (!policy) return;
+  if (policy.enabled && !policy.packaged)
+    throw new Error("病毒扫描未随项目交付，不能启用");
+  if (policy.packaged && !binding?.packaged)
+    throw new Error("环境预设声明了病毒扫描交付，但项目未装配扫描器");
+  if (!policy.packaged && binding?.packaged)
+    throw new Error("环境预设声明未交付病毒扫描，但项目已装配扫描器");
+  if (!binding?.packaged) return;
+  const state = await binding.configure(
+    policy.enabled ? "required" : "disabled",
+  );
+  if (state !== (policy.enabled ? "ready" : "disabled")) {
+    throw new Error("项目病毒扫描器未达到环境预设要求的状态");
+  }
+}