create-windy 0.2.9 → 0.2.11

package/dist/cli.js

@@ -213,7 +213,6 @@ var optionalModuleManifests = [
       "system",
       "system.settings"
     ]),
-    packages: ["packages/storage"],
     fileRoots: ["apps/server/src/storage"],
     documentation: ["docs/architecture/object-storage.md"],
     schemaFiles: ["packages/database/src/schema/file-storage.ts"],
@@ -1585,9 +1584,11 @@ function createStarterPackage(source, projectName, includeOxc = true, projectLic
       typecheck: [
         "bun run --cwd apps/web typecheck",
         "bun run --cwd apps/server typecheck",
+        "bun run --cwd packages/agent-contracts typecheck",
+        "bun run --cwd packages/agent-client typecheck",
         "bun run --cwd packages/jobs typecheck",
         "bun run --cwd packages/server-sdk typecheck",
-        ...selectedModules.includes("system.storage") ? ["bun run --cwd packages/storage typecheck"] : [],
+        "bun run --cwd packages/storage typecheck",
         "bun run --cwd packages/database typecheck",
         "bun run --cwd packages/crud-generator typecheck"
       ].join(" && "),
@@ -1623,6 +1624,8 @@ var templateDirectories = [
   "apps/server",
   "apps/web",
   "examples",
+  "packages/agent-client",
+  "packages/agent-contracts",
   "packages/config",
   "packages/crud-generator",
   "packages/database",
@@ -4002,7 +4005,9 @@ var recipes = [
   { id: "starter-0.2.5-to-0.2.6", from: "0.2.5", to: "0.2.6" },
   { id: "starter-0.2.6-to-0.2.7", from: "0.2.6", to: "0.2.7" },
   { id: "starter-0.2.7-to-0.2.8", from: "0.2.7", to: "0.2.8" },
-  { id: "starter-0.2.8-to-0.2.9", from: "0.2.8", to: "0.2.9" }
+  { id: "starter-0.2.8-to-0.2.9", from: "0.2.8", to: "0.2.9" },
+  { id: "starter-0.2.9-to-0.2.10", from: "0.2.9", to: "0.2.10" },
+  { id: "starter-0.2.10-to-0.2.11", from: "0.2.10", to: "0.2.11" }
 ];
 function resolveRecipeChain(sourceVersion, targetVersion) {
   if (sourceVersion === targetVersion)

package/package.json

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

package/template/.windy-template.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "templateCommit": "52071fd54061fd9b5578a11d3b64f9d687122378",
-  "generatorVersion": "0.2.9",
+  "templateCommit": "3be52627976c276e8dafafa6bfd2c23ab10fd908",
+  "generatorVersion": "0.2.11",
   "modules": [
     {
       "name": "system",

package/template/apps/server/Dockerfile

@@ -8,6 +8,8 @@ COPY apps/server/package.json apps/server/package.json
 COPY apps/web/package.json apps/web/package.json
 COPY apps/license/package.json apps/license/package.json
 COPY apps/signing-service/package.json apps/signing-service/package.json
+COPY packages/agent-client/package.json packages/agent-client/package.json
+COPY packages/agent-contracts/package.json packages/agent-contracts/package.json
 COPY packages/config/package.json packages/config/package.json
 COPY packages/create-windy/package.json packages/create-windy/package.json
 COPY packages/crud-generator/package.json packages/crud-generator/package.json

package/template/apps/server/src/module-host.test.ts

@@ -1,12 +1,16 @@
 import { describe, expect, test } from "bun:test";
 import { DurableHandlerRegistry } from "@southwind-ai/jobs";
 import type { ModuleInitializer } from "@southwind-ai/server-sdk";
+// @windy-module work-order begin
 import { workOrderModuleInitializer } from "./example-modules.js";
+// @windy-module work-order end
 import { initializeModuleHosts } from "./module-host.js";
+// @windy-module work-order begin
 import {
   createStorageRuntime,
   platformUploadPolicies,
 } from "./storage/runtime.js";
+// @windy-module work-order end
 
 describe("模块 Host 初始化", () => {
   test("按安装顺序完成初始化后再创建运行时注册表", async () => {
@@ -93,6 +97,7 @@ describe("模块 Host 初始化", () => {
     ).rejects.toThrow("任务 handler 重复注册：known.refresh");
   });
 
+  // @windy-module work-order begin
   test("work-order 附件策略只随模块初始化并被上传运行时采用", async () => {
     const withoutWorkOrder = await initializeModuleHosts({
       modules: [],
@@ -124,6 +129,7 @@ describe("模块 Host 初始化", () => {
     });
     expect(session.purpose).toBe("work-order.ticket.attachment");
   });
+  // @windy-module work-order end
 });
 
 function initializer(

package/template/apps/server/src/module-host.ts

@@ -2,8 +2,11 @@ import {
   DurableHandlerRegistry,
   type DurableHandlerDefinition,
 } from "@southwind-ai/jobs";
-import type { ModuleHost, ModuleInitializer } from "@southwind-ai/server-sdk";
-import type { UploadPolicy } from "@southwind-ai/storage";
+import type {
+  ModuleHost,
+  ModuleInitializer,
+  ModuleUploadPolicy,
+} from "@southwind-ai/server-sdk";
 
 interface InstalledModule {
   name: string;
@@ -12,11 +15,11 @@ interface InstalledModule {
 export interface InitializeModuleHostsInput {
   modules: readonly InstalledModule[];
   initializers: readonly ModuleInitializer[];
-  baseUploadPolicies?: readonly UploadPolicy[];
+  baseUploadPolicies?: readonly ModuleUploadPolicy[];
 }
 
 export interface InitializedModuleHosts {
-  readonly uploadPolicies: readonly UploadPolicy[];
+  readonly uploadPolicies: readonly ModuleUploadPolicy[];
   installDurableHandlers(registry: DurableHandlerRegistry): void;
 }
 
@@ -27,7 +30,7 @@ export async function initializeModuleHosts(
 ): Promise<InitializedModuleHosts> {
   const installedNames = new Set(input.modules.map(({ name }) => name));
   const initializedNames = new Set<string>();
-  const uploadPolicies: UploadPolicy[] = [];
+  const uploadPolicies: ModuleUploadPolicy[] = [];
   const uploadPurposes = new Set<string>();
   for (const policy of input.baseUploadPolicies ?? []) {
     if (uploadPurposes.has(policy.purpose)) {
@@ -69,7 +72,7 @@ export async function initializeModuleHosts(
 
 interface ScopedHostState {
   moduleName: string;
-  uploadPolicies: UploadPolicy[];
+  uploadPolicies: ModuleUploadPolicy[];
   uploadPurposes: Set<string>;
   handlerKeys: Set<string>;
   handlerInstallers: HandlerInstaller[];

package/template/apps/web/Dockerfile

@@ -8,6 +8,8 @@ COPY apps/license/package.json apps/license/package.json
 COPY apps/server/package.json apps/server/package.json
 COPY apps/signing-service/package.json apps/signing-service/package.json
 COPY apps/web/package.json apps/web/package.json
+COPY packages/agent-client/package.json packages/agent-client/package.json
+COPY packages/agent-contracts/package.json packages/agent-contracts/package.json
 COPY packages/config/package.json packages/config/package.json
 COPY packages/create-windy/package.json packages/create-windy/package.json
 COPY packages/crud-generator/package.json packages/crud-generator/package.json

package/template/apps/web/src/pages/system/components/SystemResourceTable.vue

@@ -15,7 +15,10 @@ import {
 import type { ResourceColumn, ResourceInlineToggle } from "../resource-config";
 import type { SystemRecord } from "@/services/system-api";
 import { formatDateTime } from "@/lib/date-time";
-import { AUDIT_ACTION_DEFINITIONS } from "@southwind-ai/shared";
+import {
+  AUDIT_ACTION_DEFINITIONS,
+  LICENSE_CATALOG,
+} from "@southwind-ai/shared";
 import { useAccessSnapshot } from "@/composables/useAccessSnapshot";
 import {
   Tooltip,
@@ -108,10 +111,8 @@ function formatLicensePolicy(item: SystemRecord): string {
 }
 
 function licenseVersionLabel(version: string): string {
-  return (
-    access.snapshot.value?.licenseCatalog?.find(({ key }) => key === version)
-      ?.label || version
-  );
+  const catalog = access.snapshot.value?.licenseCatalog || LICENSE_CATALOG;
+  return catalog.find(({ key }) => key === version)?.label || version;
 }
 </script>
 

package/template/package.json

@@ -38,7 +38,7 @@
     "ops:release": "bun run scripts/production-release.ts",
     "test:release:evidence": "bun run scripts/release-evidence.ts",
     "test:packages:pack": "bun run scripts/platform-package-release.ts",
-    "typecheck": "bun run --cwd apps/web typecheck && bun run --cwd apps/server typecheck && bun run --cwd apps/license typecheck && bun run --cwd apps/signing-service typecheck && bun run --cwd packages/license-sdk typecheck && bun run --cwd packages/jobs typecheck && bun run --cwd packages/server-sdk typecheck && bun run --cwd packages/storage typecheck && bun run --cwd packages/database typecheck && bun run --cwd packages/crud-generator typecheck && bun run --cwd packages/create-windy typecheck",
+    "typecheck": "bun run --cwd apps/web typecheck && bun run --cwd apps/server typecheck && bun run --cwd apps/license typecheck && bun run --cwd apps/signing-service typecheck && bun run --cwd packages/agent-contracts typecheck && bun run --cwd packages/agent-client typecheck && bun run --cwd packages/license-sdk typecheck && bun run --cwd packages/jobs typecheck && bun run --cwd packages/server-sdk typecheck && bun run --cwd packages/storage typecheck && bun run --cwd packages/database typecheck && bun run --cwd packages/crud-generator typecheck && bun run --cwd packages/create-windy typecheck",
     "lint": "oxlint .",
     "format": "oxfmt",
     "format:staged": "lint-staged",

package/template/packages/agent-client/index.ts

@@ -0,0 +1,3 @@
+export * from "./src/client.js";
+export * from "./src/error.js";
+export type * from "./src/types.js";

package/template/packages/agent-client/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@southwind-ai/agent-client",
+  "version": "0.1.0",
+  "license": "UNLICENSED",
+  "type": "module",
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "files": [
+    "index.ts",
+    "src/**/*.ts",
+    "!src/**/*.test.ts"
+  ],
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "tsc --noEmit --project tsconfig.json"
+  },
+  "dependencies": {
+    "@southwind-ai/agent-contracts": "workspace:*"
+  },
+  "exports": {
+    ".": "./index.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/template/packages/agent-client/src/client.test.ts

@@ -0,0 +1,344 @@
+import { describe, expect, test } from "bun:test";
+import {
+  defineAgentOperation,
+  type AgentEvent,
+} from "@southwind-ai/agent-contracts";
+import { createAgentCaller } from "../index.js";
+import { AgentClientError } from "./error.js";
+import type { AgentFetch } from "./types.js";
+
+interface FetchCall {
+  url: URL;
+  init?: RequestInit;
+}
+
+type FetchPlan = (call: FetchCall) => Response | Promise<Response>;
+
+const operation = defineAgentOperation<{ text: string }, { answer: string }>(
+  "support.answer",
+  (value) => {
+    if (
+      !value ||
+      typeof value !== "object" ||
+      Array.isArray(value) ||
+      typeof (value as Record<string, unknown>).answer !== "string"
+    ) {
+      throw new TypeError("answer 必须是字符串");
+    }
+    return { answer: (value as Record<string, unknown>).answer as string };
+  },
+);
+
+describe("@southwind-ai/agent-client", () => {
+  test("创建 Run、消费可恢复 SSE，并在 completed 后读取类型化结果", async () => {
+    const fake = plannedFetch([
+      () =>
+        json({
+          runId: "run-1",
+          status: "accepted",
+          eventsUrl: "/api/agent/runs/run-1/events",
+        }),
+      () =>
+        sse([
+          frame({ type: "run.started", runId: "run-1", sequence: 1 }),
+          ": heartbeat\n\n",
+          frame({
+            type: "output.delta",
+            runId: "run-1",
+            sequence: 2,
+            text: "你",
+          }),
+        ]),
+      () =>
+        sse([
+          frame({
+            type: "output.delta",
+            runId: "run-1",
+            sequence: 2,
+            text: "你",
+          }),
+          frame({ type: "run.completed", runId: "run-1", sequence: 3 }),
+        ]),
+      () =>
+        json({
+          runId: "run-1",
+          status: "completed",
+          output: { answer: "你好" },
+        }),
+    ]);
+    const caller = createAgentCaller({
+      baseUrl: "https://agent.internal",
+      fetch: fake.fetch,
+      reconnectDelayMs: 0,
+      wait: async () => undefined,
+    });
+
+    const run = await caller.start(
+      operation,
+      { text: "你好" },
+      {
+        idempotencyKey: "request-1",
+      },
+    );
+    const collected = collect(run.events);
+    await expect(run.result()).resolves.toEqual({ answer: "你好" });
+    expect((await collected).map(({ sequence }) => sequence)).toEqual([
+      1, 2, 3,
+    ]);
+
+    expect(fake.calls).toHaveLength(4);
+    expect(fake.calls[0]?.url.pathname).toBe("/api/agent/runs");
+    expect(fake.calls[0]?.init?.headers).toEqual({
+      "content-type": "application/json",
+      "idempotency-key": "request-1",
+    });
+    expect(JSON.parse(String(fake.calls[0]?.init?.body))).toEqual({
+      operationKey: "support.answer",
+      input: { text: "你好" },
+    });
+    const resumedHeaders = new Headers(fake.calls[2]?.init?.headers);
+    expect(resumedHeaders.get("last-event-id")).toBe("2");
+    expect(fake.calls[2]?.url.searchParams.get("after")).toBe("2");
+    expect(fake.calls[3]?.url.pathname).toBe("/api/agent/runs/run-1/result");
+  });
+
+  test("EOF 会消耗恢复预算，超过预算返回稳定中断错误", async () => {
+    const fake = plannedFetch([
+      () =>
+        json({
+          runId: "run-eof",
+          status: "accepted",
+          eventsUrl: "/api/agent/runs/run-eof/events",
+        }),
+      () =>
+        sse([
+          frame({
+            type: "run.started",
+            runId: "run-eof",
+            sequence: 1,
+          }),
+        ]),
+      () => sse([": heartbeat\n\n"]),
+    ]);
+    const waits: number[] = [];
+    const caller = createAgentCaller({
+      baseUrl: "https://agent.internal",
+      fetch: fake.fetch,
+      maxReconnects: 1,
+      reconnectDelayMs: 7,
+      wait: async (milliseconds) => {
+        waits.push(milliseconds);
+      },
+    });
+    const run = await caller.start(
+      operation,
+      { text: "x" },
+      {
+        idempotencyKey: "request-eof",
+      },
+    );
+
+    await expect(run.result()).rejects.toMatchObject({
+      code: "STREAM_INTERRUPTED",
+      retryable: true,
+      runId: "run-eof",
+    });
+    expect(waits).toEqual([7]);
+    expect(fake.calls).toHaveLength(3);
+    expect(new Headers(fake.calls[2]?.init?.headers).get("last-event-id")).toBe(
+      "1",
+    );
+  });
+
+  test("result 使用 Operation parser，拒绝未校验的远端输出", async () => {
+    const fake = plannedFetch([
+      () =>
+        json({
+          runId: "run-invalid",
+          status: "accepted",
+          eventsUrl: "/events",
+        }),
+      () =>
+        sse([
+          frame({
+            type: "run.completed",
+            runId: "run-invalid",
+            sequence: 1,
+          }),
+        ]),
+      () =>
+        json({
+          runId: "run-invalid",
+          status: "completed",
+          output: { answer: 42 },
+        }),
+    ]);
+    const run = await createAgentCaller({
+      baseUrl: "https://agent.internal",
+      fetch: fake.fetch,
+    }).start(operation, { text: "x" }, { idempotencyKey: "invalid-output" });
+
+    await expect(run.result()).rejects.toMatchObject({
+      code: "PROTOCOL_VIOLATION",
+      retryable: false,
+    });
+  });
+
+  test("cancel 幂等发送独立 command，AbortSignal 也触发取消", async () => {
+    const fake = plannedFetch([
+      () =>
+        json({
+          runId: "run-cancel",
+          status: "accepted",
+          eventsUrl: "/events",
+        }),
+      () => json({ accepted: true }),
+    ]);
+    const abort = new AbortController();
+    const run = await createAgentCaller({
+      baseUrl: "https://agent.internal",
+      fetch: fake.fetch,
+    }).start(
+      operation,
+      { text: "x" },
+      { idempotencyKey: "cancel-1", signal: abort.signal },
+    );
+
+    abort.abort();
+    await Promise.all([run.cancel("重复调用"), run.cancel("再次重复")]);
+    expect(fake.calls).toHaveLength(2);
+    expect(fake.calls[1]?.url.pathname).toBe(
+      "/api/agent/runs/run-cancel/cancel",
+    );
+  });
+
+  test("创建阶段 AbortSignal 使用稳定取消错误", async () => {
+    const abort = new AbortController();
+    abort.abort(new Error("caller stopped"));
+    const fetch: AgentFetch = async (_input, init) => {
+      expect(init?.signal?.aborted).toBe(true);
+      throw init?.signal?.reason;
+    };
+
+    await expect(
+      createAgentCaller({
+        baseUrl: "https://agent.internal",
+        fetch,
+      }).start(
+        operation,
+        { text: "x" },
+        { idempotencyKey: "aborted", signal: abort.signal },
+      ),
+    ).rejects.toMatchObject({
+      code: "CANCELLED",
+      retryable: false,
+    });
+  });
+
+  test("只保留已知 canonical HTTP 错误，未知正文不会泄漏", async () => {
+    const known = plannedFetch([
+      () =>
+        json(
+          {
+            code: "RATE_LIMITED",
+            message: "请求过于频繁",
+            requestId: "request-known",
+            retryable: true,
+          },
+          429,
+        ),
+    ]);
+    const caller = createAgentCaller({
+      baseUrl: "https://agent.internal",
+      fetch: known.fetch,
+    });
+    try {
+      await caller.start(
+        operation,
+        { text: "x" },
+        {
+          idempotencyKey: "known",
+        },
+      );
+      throw new Error("expected rejection");
+    } catch (error) {
+      expect(error).toBeInstanceOf(AgentClientError);
+      expect(error).toMatchObject({
+        code: "RUN_REJECTED",
+        message: "请求过于频繁",
+        retryable: true,
+        agentError: { code: "RATE_LIMITED", requestId: "request-known" },
+      });
+    }
+
+    const secret = "provider-body-secret";
+    const unknown = plannedFetch([
+      () =>
+        new Response(`upstream failure ${secret}`, {
+          status: 502,
+          headers: { "content-type": "text/plain" },
+        }),
+    ]);
+    try {
+      await createAgentCaller({
+        baseUrl: "https://agent.internal",
+        fetch: unknown.fetch,
+      }).start(operation, { text: "x" }, { idempotencyKey: "unknown" });
+      throw new Error("expected rejection");
+    } catch (error) {
+      expect(error).toBeInstanceOf(AgentClientError);
+      expect(String((error as Error).message)).not.toContain(secret);
+      expect(error).toMatchObject({
+        code: "REQUEST_FAILED",
+        message: "创建 Agent Run失败（HTTP 502）",
+      });
+    }
+  });
+});
+
+function plannedFetch(plans: FetchPlan[]): {
+  fetch: AgentFetch;
+  calls: FetchCall[];
+} {
+  const calls: FetchCall[] = [];
+  const fetch: AgentFetch = async (input, init) => {
+    const call = {
+      url: new URL(input instanceof Request ? input.url : input.toString()),
+      init,
+    };
+    calls.push(call);
+    const plan = plans[calls.length - 1];
+    if (!plan) throw new Error(`unexpected fetch ${call.url}`);
+    return plan(call);
+  };
+  return { fetch, calls };
+}
+
+function json(value: unknown, status = 200): Response {
+  return Response.json(value, { status });
+}
+
+function sse(parts: string[]): Response {
+  const encoder = new TextEncoder();
+  return new Response(
+    new ReadableStream<Uint8Array>({
+      start(controller) {
+        for (const part of parts) controller.enqueue(encoder.encode(part));
+        controller.close();
+      },
+    }),
+    { headers: { "content-type": "text/event-stream; charset=utf-8" } },
+  );
+}
+
+function frame(event: AgentEvent): string {
+  return `id: ${event.sequence}\nevent: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`;
+}
+
+async function collect(
+  events: AsyncIterable<AgentEvent>,
+): Promise<AgentEvent[]> {
+  const collected: AgentEvent[] = [];
+  for await (const event of events) collected.push(event);
+  return collected;
+}