create-windy 0.6.8 → 0.6.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-windy",
-  "version": "0.6.8",
+  "version": "0.6.10",
   "description": "创建单组织、单租户、私有部署优先的 Windy 企业 Dashboard Starter",
   "type": "module",
   "bin": {

package/template/.windy-template.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "templateCommit": "47527e1bb3a2848bbb7d27eef7132c83b81d714d",
-  "generatorVersion": "0.6.8",
+  "templateCommit": "1916707e888868d817a115dc8a96244a28e41d2c",
+  "generatorVersion": "0.6.10",
   "modules": [
     {
       "name": "system",
@@ -33,7 +33,7 @@
     },
     {
       "name": "system.agent",
-      "version": "0.1.0"
+      "version": "0.1.1"
     },
     {
       "name": "system.operations",

package/template/README.md

@@ -35,6 +35,10 @@ Drizzle migration，再启动 Server 与 Web；不要跳过 migration 后直接
 BuildKit 中的 Bun 包下载缓存，只下载新增或发生变化的依赖；冷安装每 15 秒输出一次
 不含 registry 地址或凭据的进度心跳。
 
+Windows 10/11 可在原生 PowerShell 中配合 Docker Desktop 直接运行 `bun run dev` 与
+`bun run dev:build`，不需要 WSL。Windows 是本地开发宿主；生产交付仍使用 Linux
+amd64 容器。
+
 | 服务 | 地址 |
 | ---- | ---- |
 | Web | http://localhost:18746 |
@@ -132,7 +136,8 @@ browser-safe `./admin` 与 project-owned 的
 `apps/web/src/app/web-composition.ts` 装配页面，不复制第二份 Feature、Permission
 或路由清单。整个 `apps/web/src` 与整个 `apps/server/src/app` 都是
 project-owned，客户可以修改 Router、layout、页面、Host 和 Server 组合；普通
-`windy update` 不会覆盖或三方合并这些文件。
+`windy update` 不会整文件覆盖或三方合并这些文件。版本 recipe 只有在显式登记
+path 与确定性语义锚点后才能做幂等追加；锚点缺失或不唯一时必须在写入前停止。
 
 精确生成来源保留在 `.windy/generation.json`。当前版本已提供可回滚的
 `windy update` 与 `windy module list/enable/disable`。当前内置模块仍依赖
@@ -166,7 +171,8 @@ bun run format
 更新前无需提交、暂存或清理业务改动。`--dry-run` 只生成计划，不写项目；无关 WIP
 保持原样，命中同一路径时按冻结快照与三方合并 fail closed。正式更新先备份，再做
 package 字段级合并、共享脚手架三方合并与完整验证。整个 `apps/web/src` 和
-`apps/server/src/app` 保持项目版本。任何冲突都会在写入前中止，模块启停在交互
+`apps/server/src/app` 默认保持项目版本；已登记版本 recipe 只修改其声明的窄锚点。
+任何冲突都会在写入前中止，模块启停在交互
 终端确认；CI、Agent 或其它非 TTY 环境必须显式传入 `--yes`。
 无并发变化的验证失败会自动回滚；中断恢复使用
 `bun run windy doctor --repair`。该命令在提交点前保留并发编辑并回滚其余路径，

package/template/apps/agent-server/src/southwind_agent_server/contracts.py

@@ -135,6 +135,7 @@ class RuntimeRelease(CanonicalModel):
     workflow_version: str = Field(min_length=1, max_length=80)
     prompt_version: str = Field(min_length=1, max_length=80)
     route_version: str = Field(min_length=1, max_length=80)
+    output_schema_version: str = Field(min_length=1, max_length=80)
     tool_schema_version: str = Field(min_length=1, max_length=80)
     manifest_digest: str = Field(pattern=r"^[a-f0-9]{64}$")
 
@@ -166,6 +167,7 @@ def legacy_release() -> RuntimeRelease:
         workflow_version="legacy",
         prompt_version="legacy",
         route_version="legacy",
+        output_schema_version="legacy",
         tool_schema_version="legacy",
         manifest_digest="0" * 64,
     )

package/template/apps/agent-server/tests/test_multimodal.py

@@ -49,3 +49,33 @@ def test_typed_image_part_and_json_schema_output() -> None:
     with pytest.raises(SafeEngineError) as invalid:
         final_output('{"name":42}', schema)
     assert invalid.value.code == "OUTPUT_VALIDATION_FAILED"
+
+
+def test_supervisor_final_answer_schema_rejects_intermediate_text() -> None:
+    schema: dict[str, JsonValue] = {
+        "type": "object",
+        "properties": {
+            "finalAnswer": {
+                "type": "object",
+                "properties": {
+                    "schemaVersion": {"const": 1},
+                    "text": {"type": "string", "minLength": 1},
+                },
+                "required": ["schemaVersion", "text"],
+                "additionalProperties": False,
+            },
+            "nodes": {"type": "array"},
+        },
+        "required": ["finalAnswer"],
+        "additionalProperties": False,
+    }
+    assert final_output(
+        '{"finalAnswer":{"schemaVersion":1,"text":"最终回答"},"nodes":[]}',
+        schema,
+    ) == {
+        "finalAnswer": {"schemaVersion": 1, "text": "最终回答"},
+        "nodes": [],
+    }
+    with pytest.raises(SafeEngineError) as invalid:
+        final_output('{"nodes":[{"text":"中间节点","total":2}]}', schema)
+    assert invalid.value.code == "OUTPUT_VALIDATION_FAILED"

package/template/apps/agent-server/tests/test_postgres_store.py

@@ -96,6 +96,7 @@ def fixture(suffix: str) -> RunRecord:
             "workflowVersion": "workflow-1",
             "promptVersion": "prompt-1",
             "routeVersion": "route-1",
+            "outputSchemaVersion": "output-schema-1",
             "toolSchemaVersion": "schema-1",
             "manifestDigest": "0" * 64,
         },

package/template/apps/agent-server/tests/test_sqlite_store.py

@@ -174,6 +174,7 @@ def fixture(run_id: str, idempotency_key: str) -> RunRecord:
             "workflowVersion": "workflow-1",
             "promptVersion": "prompt-1",
             "routeVersion": "route-1",
+            "outputSchemaVersion": "output-schema-1",
             "toolSchemaVersion": "schema-1",
             "manifestDigest": "0" * 64,
         },

package/template/apps/server/src/agent/remote-runtime.test.ts

@@ -210,6 +210,7 @@ function runtimeRelease(): AgentRuntimeOperation["release"] {
     workflowVersion: "workflow-1",
     promptVersion: "prompt-1",
     routeVersion: "route-1",
+    outputSchemaVersion: "output-schema-1",
     toolSchemaVersion: "schema-1",
     manifestDigest: "0".repeat(64),
   };

package/template/apps/server/src/agent/run-audit.ts

@@ -41,6 +41,7 @@ export function auditAgentRun(input: {
       workflowVersion: input.release.workflowVersion,
       promptVersion: input.release.promptVersion,
       routeVersion: input.release.routeVersion,
+      outputSchemaVersion: input.release.outputSchemaVersion,
       toolSchemaVersion: input.release.toolSchemaVersion,
       traceId: input.traceId,
     },

package/template/apps/server/src/agent/run-contracts.ts

@@ -56,6 +56,7 @@ export interface AgentRuntimeRelease {
   readonly workflowVersion: string;
   readonly promptVersion: string;
   readonly routeVersion: string;
+  readonly outputSchemaVersion: string;
   readonly toolSchemaVersion: string;
   readonly manifestDigest: string;
 }

package/template/apps/server/src/agent/run-facade.ts

@@ -30,7 +30,6 @@ import {
 } from "./provider-input-governance.js";
 import {
   rotateVisionArtifacts,
-  validateOutputSchema,
   validateVisionArtifacts,
 } from "./vision-input.js";
 import { requireVisionOperationReadiness } from "./vision-readiness.js";
@@ -55,6 +54,7 @@ import {
   buildRegisteredOperations,
   type RegisteredOperation,
 } from "./run-operation-registry.js";
+import { validateRegisteredOutputSchema } from "./run-output-schema.js";
 export { AgentRunFacadeError } from "./run-errors.js";
 
 type ServerRuntime = ReturnType<typeof createServerRuntime>;
@@ -157,7 +157,7 @@ export class AgentRunFacade {
         400,
       );
     }
-    validateOutputSchema(plan.outputSchema, operation.definition);
+    validateRegisteredOutputSchema(plan.outputSchema, operation);
     const rotatedArtifacts = await rotateVisionArtifacts(
       artifacts,
       operation.definition,

package/template/apps/server/src/agent/run-operation-registry.ts

@@ -13,6 +13,7 @@ export interface RegisteredOperation {
   feature: ReturnType<typeof findFeature>;
   tools: AgentRuntimeOperation["allowedTools"];
   release: AgentRuntimeOperation["release"];
+  outputSchema?: NonNullable<ModuleManifest["jsonSchemas"]>[number]["schema"];
 }
 
 export function buildRegisteredOperations(
@@ -26,6 +27,11 @@ export function buildRegisteredOperations(
     ]),
   );
   const features = modules.flatMap(({ features }) => features);
+  const schemas = new Map(
+    modules.flatMap(({ jsonSchemas }) =>
+      (jsonSchemas ?? []).map((schema) => [schema.key, schema.schema] as const),
+    ),
+  );
   return new Map(
     modules.flatMap((module) =>
       (module.aiOperations ?? []).map((definition) => {
@@ -37,6 +43,7 @@ export function buildRegisteredOperations(
             ...handler,
             feature: findFeature(features, definition.featureKey),
             tools: toolDefinitions(modules, definition.allowedToolKeys),
+            outputSchema: schemas.get(definition.outputSchemaKey),
             release: buildAgentRuntimeRelease(
               modules,
               module,

package/template/apps/server/src/agent/run-output-schema.ts

@@ -0,0 +1,15 @@
+import type { ModuleAiJsonValue } from "@southwind-ai/server-sdk";
+import type { RegisteredOperation } from "./run-operation-registry.js";
+import { validateOutputSchema } from "./vision-input.js";
+
+export function validateRegisteredOutputSchema(
+  schema: ModuleAiJsonValue | undefined,
+  operation: RegisteredOperation,
+): void {
+  validateOutputSchema(
+    schema,
+    operation.definition,
+    operation.registration?.supervisor,
+    operation.outputSchema,
+  );
+}

package/template/apps/server/src/agent/run-release.ts

@@ -20,6 +20,7 @@ export function buildAgentRuntimeRelease(
   const coordinates = {
     operationVersion: module.version,
     ...versions,
+    outputSchemaVersion: outputSchemaDigest(modules, definition),
     toolSchemaVersion: operationSchemaDigest(modules, definition),
     manifestDigest: digest(module),
   };
@@ -29,6 +30,16 @@ export function buildAgentRuntimeRelease(
   };
 }
 
+function outputSchemaDigest(
+  modules: readonly ModuleManifest[],
+  definition: ModuleAiOperationDefinition,
+): string {
+  const schema = modules
+    .flatMap(({ jsonSchemas }) => jsonSchemas ?? [])
+    .find(({ key }) => key === definition.outputSchemaKey)?.schema;
+  return digest(schema);
+}
+
 function operationSchemaDigest(
   modules: readonly ModuleManifest[],
   definition: ModuleAiOperationDefinition,

package/template/apps/server/src/agent/supervisor-output-schema.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, test } from "bun:test";
+import {
+  composeSystemAgentFinalAnswerSchemaV1,
+  type ModuleAiOperationDefinition,
+} from "@southwind-ai/modules";
+import { validateOutputSchema } from "./vision-input.js";
+
+const definition: ModuleAiOperationDefinition = {
+  key: "business.copilot",
+  kind: "agent",
+  featureKey: "business.copilot",
+  permissionKey: "business.copilot.execute",
+  auditAction: "business.copilot.execute",
+  inputSchemaKey: "business.copilot.input.v1",
+  outputSchemaKey: "business.copilot.output.v1",
+  requiredCapabilities: ["text-generation"],
+  allowedToolKeys: [],
+  dataClassification: "internal",
+  execution: "interactive",
+  providerEgress: { mode: "configured-endpoint", deploymentKey: "ai.default" },
+  providerDataPolicy: {
+    inputFields: [
+      {
+        jsonPointer: "/prompt",
+        classification: "internal",
+        dlpAction: "redact",
+      },
+    ],
+    envelopeFields: [
+      {
+        field: "instructions",
+        classification: "internal",
+        dlpAction: "redact",
+      },
+      {
+        field: "user-prompt",
+        classification: "internal",
+        dlpAction: "redact",
+      },
+      {
+        field: "output-schema",
+        classification: "internal",
+        dlpAction: "redact",
+      },
+    ],
+  },
+  toolNetworkPolicy: { mode: "forbidden" },
+  limits: {
+    maxDurationSeconds: 60,
+    maxInputBytes: 4_096,
+    maxOutputBytes: 1_048_576,
+  },
+};
+
+const supervisor = {
+  contractVersion: 1,
+  finalAnswerSchemaVersion: 1,
+} as const;
+
+describe("Supervisor output schema admission", () => {
+  test("只接受与 Manifest 完全一致的 canonical Schema", () => {
+    const schema = composeSystemAgentFinalAnswerSchemaV1({
+      properties: { citations: { type: "array" } },
+    });
+    expect(() =>
+      validateOutputSchema(schema, definition, supervisor, schema),
+    ).not.toThrow();
+    expect(() =>
+      validateOutputSchema(
+        composeSystemAgentFinalAnswerSchemaV1(),
+        definition,
+        supervisor,
+        schema,
+      ),
+    ).toThrow("与 Manifest 声明不一致");
+  });
+
+  test("拒绝缺失 Schema 或 legacy text Schema", () => {
+    expect(() =>
+      validateOutputSchema(undefined, definition, supervisor),
+    ).toThrow("必须提供 typed 输出 Schema");
+    expect(() =>
+      validateOutputSchema(
+        {
+          type: "object",
+          properties: { text: { type: "string" } },
+          required: ["text"],
+          additionalProperties: false,
+        },
+        definition,
+        supervisor,
+      ),
+    ).toThrow("canonical finalAnswer V1");
+  });
+});

package/template/apps/server/src/agent/vision-input.ts

@@ -1,6 +1,10 @@
-import type { ModuleAiOperationDefinition } from "@southwind-ai/modules";
+import {
+  assertSystemAgentFinalAnswerSchemaV1,
+  type ModuleAiOperationDefinition,
+} from "@southwind-ai/modules";
 import type {
   ModuleAiArtifactRef,
+  ModuleAiOperationHandlerRegistration,
   ModuleAiJsonValue,
 } from "@southwind-ai/server-sdk";
 import type { AiArtifactRuntime } from "../ai-artifact/runtime.js";
@@ -56,8 +60,13 @@ export async function rotateVisionArtifacts(
 export function validateOutputSchema(
   schema: ModuleAiJsonValue | undefined,
   definition: ModuleAiOperationDefinition,
+  supervisor?: ModuleAiOperationHandlerRegistration["supervisor"],
+  declaredSchema?: ModuleAiJsonValue,
 ) {
-  if (schema === undefined) return;
+  if (schema === undefined) {
+    if (supervisor) throw invalid("Supervisor 必须提供 typed 输出 Schema");
+    return;
+  }
   if (
     !schema ||
     typeof schema !== "object" ||
@@ -70,6 +79,16 @@ export function validateOutputSchema(
       400,
     );
   }
+  if (supervisor) {
+    try {
+      assertSystemAgentFinalAnswerSchemaV1(schema);
+    } catch {
+      throw invalid("Supervisor 输出 Schema 缺少 canonical finalAnswer V1");
+    }
+    if (canonicalJson(schema) !== canonicalJson(declaredSchema)) {
+      throw invalid("Supervisor 运行时输出 Schema 与 Manifest 声明不一致");
+    }
+  }
   if (
     definition.providerEgress?.mode === "configured-endpoint" &&
     !definition.providerDataPolicy?.envelopeFields.some(
@@ -84,6 +103,22 @@ export function validateOutputSchema(
   }
 }
 
+function canonicalJson(value: unknown): string {
+  return JSON.stringify(canonicalValue(value));
+}
+
+function canonicalValue(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(canonicalValue);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value as Record<string, unknown>)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => [key, canonicalValue(item)]),
+    );
+  }
+  return value;
+}
+
 export function validateVisionArtifacts(
   artifacts: readonly Pick<
     ModuleAiArtifactRef,

package/template/apps/server/src/license/pairing-http.ts

@@ -0,0 +1,138 @@
+import { boundedJsonBodyErrorResponse } from "@southwind-ai/license";
+import { LicensePairingError } from "./pairing-service.js";
+
+export function createPairingCorsPolicy(
+  env: Record<string, string | undefined>,
+) {
+  const configured = env.WINDY_LICENSE_PAIRING_ORIGINS;
+  const candidates =
+    configured === undefined
+      ? env.NODE_ENV === "production"
+        ? []
+        : ["http://localhost:9843"]
+      : configured.split(",").map((value) => value.trim());
+  const origins = new Set(candidates.filter(isExactHttpOrigin));
+  return {
+    enabled: origins.size > 0,
+    accept: (request: Request) => {
+      const origin = request.headers.get("origin") || "";
+      return origins.has(origin) ? origin : undefined;
+    },
+    headers: (origin: string) => ({
+      "access-control-allow-origin": origin,
+      "access-control-allow-methods": "POST, OPTIONS",
+      "access-control-allow-headers": "Content-Type",
+      "access-control-allow-private-network": "true",
+      vary: "Origin, Access-Control-Request-Method, Access-Control-Request-Headers, Access-Control-Request-Private-Network",
+    }),
+  };
+}
+
+export function allowedPreflightHeaders(value: string | null): boolean {
+  if (!value) return true;
+  return value
+    .split(",")
+    .map((header) => header.trim().toLowerCase())
+    .every((header) => header === "content-type");
+}
+
+export function requireCallbackOrigin(
+  value: unknown,
+  request: Request,
+): string {
+  const callbackOrigin = requiredText(value, "callbackOrigin");
+  if (!isExactHttpOrigin(callbackOrigin)) {
+    throw new LicensePairingError(
+      "PAIRING_CALLBACK_ORIGIN_INVALID",
+      400,
+      "callbackOrigin 必须是精确的 HTTP(S) Origin",
+    );
+  }
+  if (request.headers.get("origin") !== callbackOrigin) {
+    throw new LicensePairingError(
+      "PAIRING_CALLBACK_ORIGIN_MISMATCH",
+      403,
+      "请求 Origin 与 callbackOrigin 不一致",
+    );
+  }
+  return callbackOrigin;
+}
+
+export function requireDeliveryContentType(request: Request): void {
+  const value = request.headers.get("content-type")?.toLowerCase() || "";
+  if (value.startsWith("application/json") || value.startsWith("text/plain")) {
+    return;
+  }
+  throw new LicensePairingError(
+    "PAIRING_CONTENT_TYPE_INVALID",
+    415,
+    "投递只接受 application/json 或 text/plain JSON",
+  );
+}
+
+export function requiredText(value: unknown, name: string): string {
+  if (typeof value === "string" && value.trim()) return value;
+  throw new LicensePairingError(
+    "PAIRING_REQUEST_INVALID",
+    400,
+    `${name} 必须为非空字符串`,
+  );
+}
+
+export function pairingErrorResponse(
+  error: unknown,
+  headers: Record<string, string> = {},
+): Response {
+  const bodyError = boundedJsonBodyErrorResponse(error);
+  if (bodyError) return noStore(bodyError, headers);
+  if (error instanceof LicensePairingError) {
+    return json(
+      { error: error.code, reason: error.message, ...error.details },
+      error.status,
+      headers,
+    );
+  }
+  throw error;
+}
+
+export function corsRejected(): Response {
+  return json({ error: "PAIRING_CORS_REJECTED" }, 403, { vary: "Origin" });
+}
+
+export function json(
+  body: unknown,
+  status = 200,
+  headers: Record<string, string> = {},
+): Response {
+  return Response.json(body, { status, headers: responseHeaders(headers) });
+}
+
+export function noStore(
+  response: Response,
+  headers: Record<string, string> = {},
+) {
+  const nextHeaders = new Headers(response.headers);
+  for (const [key, value] of Object.entries(responseHeaders(headers))) {
+    nextHeaders.set(key, value);
+  }
+  return new Response(response.body, {
+    status: response.status,
+    headers: nextHeaders,
+  });
+}
+
+export function responseHeaders(headers: Record<string, string>) {
+  return { ...headers, "cache-control": "no-store" };
+}
+
+function isExactHttpOrigin(value: string): boolean {
+  try {
+    const url = new URL(value);
+    return (
+      (url.protocol === "http:" || url.protocol === "https:") &&
+      url.origin === value
+    );
+  } catch {
+    return false;
+  }
+}