create-windy 0.8.0 → 0.8.2

package/template/packages/modules/src/ai-isolated-execution-policy.ts

@@ -0,0 +1,76 @@
+import type { ModuleAiOperationDefinition } from "./manifest.js";
+
+const ceilings = {
+  maxWorkspaceBytes: 256 * 1024 * 1024,
+  maxFileBytes: 64 * 1024 * 1024,
+  maxOutputBytes: 16 * 1024 * 1024,
+  maxDurationSeconds: 300,
+  maxCpuMillis: 300_000,
+  maxMemoryBytes: 1024 * 1024 * 1024,
+  maxPids: 64,
+  maxConcurrentProcesses: 4,
+  maxToolCalls: 128,
+  maxToolRounds: 32,
+} as const;
+
+export function validateAiIsolatedExecutionPolicy(
+  operation: ModuleAiOperationDefinition,
+): void {
+  const policy = operation.isolatedExecution;
+  if (policy === undefined) return;
+  if (
+    !policy ||
+    operation.kind !== "agent" ||
+    policy.version !== 1 ||
+    policy.mode !== "isolated" ||
+    Object.keys(policy).sort().join(",") !==
+      "inputArtifactTypes,languages,limits,mode,network,version"
+  ) {
+    throw new Error(
+      `${operation.key} 隔离执行只允许 Agent Operation 的 V1 策略`,
+    );
+  }
+  if (
+    !Array.isArray(policy.languages) ||
+    !policy.languages.length ||
+    new Set(policy.languages).size !== policy.languages.length ||
+    policy.languages.some((language) => !["python", "node"].includes(language))
+  ) {
+    throw new Error(`${operation.key} 隔离执行语言无效`);
+  }
+  if (
+    !Array.isArray(policy.inputArtifactTypes) ||
+    !policy.inputArtifactTypes.length ||
+    new Set(policy.inputArtifactTypes).size !==
+      policy.inputArtifactTypes.length ||
+    policy.inputArtifactTypes.some(
+      (type) =>
+        typeof type !== "string" ||
+        !/^[a-z][a-z0-9.+-]*\/[a-z0-9.+-]+$/u.test(type),
+    )
+  ) {
+    throw new Error(`${operation.key} 隔离执行输入 Artifact 类型无效`);
+  }
+  if (
+    policy.network !== "forbidden" ||
+    operation.toolNetworkPolicy?.mode !== "forbidden"
+  ) {
+    throw new Error(`${operation.key} 隔离执行必须禁止 Tool 网络`);
+  }
+  const limits = policy.limits;
+  if (
+    !limits ||
+    Object.keys(limits).length !== Object.keys(ceilings).length ||
+    Object.entries(ceilings).some(([key, ceiling]) => {
+      const value = limits[key as keyof typeof ceilings];
+      return !Number.isSafeInteger(value) || value <= 0 || value > ceiling;
+    }) ||
+    limits.maxFileBytes > limits.maxWorkspaceBytes ||
+    limits.maxOutputBytes > limits.maxWorkspaceBytes ||
+    limits.maxDurationSeconds > operation.limits.maxDurationSeconds ||
+    limits.maxOutputBytes > operation.limits.maxOutputBytes ||
+    limits.maxToolRounds > limits.maxToolCalls
+  ) {
+    throw new Error(`${operation.key} 隔离执行预算越过 Operation 或 Host 上限`);
+  }
+}

package/template/packages/modules/src/ai-operation-composition.ts

@@ -6,6 +6,7 @@ import { validateAiNetworkPolicy } from "./ai-network-policy.js";
 import { validateAiOperationReadinessContract } from "./ai-operation-readiness-contract.js";
 import { validateAiScreenshotContext } from "./ai-screenshot-context.js";
 import { validateClientExecution } from "./ai-client-execution-policy.js";
+import { validateAiIsolatedExecutionPolicy } from "./ai-isolated-execution-policy.js";
 
 interface AiOperationCatalogs {
   permissions: ReadonlySet<string>;
@@ -107,6 +108,7 @@ function validateOperation(
   validateAiNetworkPolicy(operation);
   validateProviderDataPolicy(operation);
   validateClientExecution(operation);
+  validateAiIsolatedExecutionPolicy(operation);
   validateLimits(operation);
   validateAiOperationReadinessContract(operation);
   validateAiScreenshotContext(operation);

package/template/packages/modules/src/manifest.ts

@@ -167,6 +167,27 @@ export interface AiOperationLimits {
   maxPixelsPerArtifact?: number;
 }
 
+/** Opt-in policy for a future, separate Python/Node Execution Runtime. Absence disables execution. */
+export interface AiIsolatedExecutionPolicyV1 {
+  readonly version: 1;
+  readonly mode: "isolated";
+  readonly languages: readonly ("python" | "node")[];
+  readonly inputArtifactTypes: readonly string[];
+  readonly network: "forbidden";
+  readonly limits: {
+    readonly maxWorkspaceBytes: number;
+    readonly maxFileBytes: number;
+    readonly maxOutputBytes: number;
+    readonly maxDurationSeconds: number;
+    readonly maxCpuMillis: number;
+    readonly maxMemoryBytes: number;
+    readonly maxPids: number;
+    readonly maxConcurrentProcesses: number;
+    readonly maxToolCalls: number;
+    readonly maxToolRounds: number;
+  };
+}
+
 /**
  * 允许受治理的宿主客户端在本地编排模型循环。
  *
@@ -234,6 +255,8 @@ export interface ModuleAiOperationDefinition {
   providerDataPolicy?: AiProviderDataPolicy;
   /** 缺省不允许浏览器或其它宿主客户端执行本地 Agent 循环。 */
   clientExecution?: AiClientExecutionPolicy;
+  /** Missing means no workspace or process execution capability. */
+  isolatedExecution?: AiIsolatedExecutionPolicyV1;
   toolNetworkPolicy?: AiToolNetworkPolicy;
   limits: AiOperationLimits;
 }

package/template/packages/modules/src/system-features.ts

@@ -1,10 +1,11 @@
-import { featureKey, licenseVersionKey } from "@southwind-ai/shared";
+import * as shared from "@southwind-ai/shared";
 import type { ModuleManifest } from "./manifest.js";
 
 // @windy-module system.scheduler begin
-const standardAndAdvanced = ["standard", "advanced"].map(licenseVersionKey);
+const standardAndAdvanced = ["standard", "advanced"].map(
+  shared.licenseVersionKey,
+);
 // @windy-module system.scheduler end
-const advancedOnly = [licenseVersionKey("advanced")];
 
 export const systemFeatures: ModuleManifest["features"] = [
   feature(
@@ -109,7 +110,7 @@ export const systemFeatures: ModuleManifest["features"] = [
       "Agent 长期会话",
       "恢复受治理的长期 Session，并解释 Context 与 Memory 来源。",
     ),
-    dependencies: [featureKey("system.agent")],
+    dependencies: [shared.featureKey("system.agent")],
   },
   {
     ...feature(
@@ -117,7 +118,7 @@ export const systemFeatures: ModuleManifest["features"] = [
       "AI Runtime 报表",
       "查看受数据范围约束的 Agent Run、模型用量、缓存与失败事实。",
     ),
-    dependencies: [featureKey("system.agent")],
+    dependencies: [shared.featureKey("system.agent")],
   },
   {
     ...feature(
@@ -125,8 +126,8 @@ export const systemFeatures: ModuleManifest["features"] = [
       "Agent Workflow",
       "查看和运行具备预算、恢复、委派与持久审计边界的不可变 Agent Workflow Release。",
     ),
-    dependencies: [featureKey("system.agent")],
-    allowedLicenseVersions: advancedOnly,
+    dependencies: [shared.featureKey("system.agent")],
+    allowedLicenseVersions: [shared.licenseVersionKey("advanced")],
   },
   // @windy-module system.agent end
   // @windy-module system.operations begin
@@ -167,7 +168,7 @@ export const systemFeatures: ModuleManifest["features"] = [
       "批量数据任务",
       "受控的大批量导入、导出、失败明细和结果留存。",
     ),
-    allowedLicenseVersions: advancedOnly,
+    allowedLicenseVersions: [shared.licenseVersionKey("advanced")],
   },
   // @windy-module system.bulk-data end
 ];
@@ -178,7 +179,7 @@ function feature(
   description?: string,
 ): ModuleManifest["features"][number] {
   return {
-    key: featureKey(key),
+    key: shared.featureKey(key),
     label,
     module: "system",
     description,
@@ -195,6 +196,6 @@ function rbacFeature(
 ): ModuleManifest["features"][number] {
   return {
     ...feature(key, label, description),
-    dependencies: [featureKey("system.rbac")],
+    dependencies: [shared.featureKey("system.rbac")],
   };
 }

package/template/packages/server-sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@southwind-ai/server-sdk",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "license": "UNLICENSED",
   "type": "module",
   "engines": {

package/template/packages/shared/index.ts

@@ -17,6 +17,7 @@ export * from "./src/migration-bundle-validation.js";
 export * from "./src/mcp.js";
 export * from "./src/module-configuration.js";
 export * from "./src/correlation.js";
+export * from "./src/structured-log.js";
 export * from "./src/notification.js";
 export * from "./src/password.js";
 export * from "./src/platform-settings.js";

package/template/packages/shared/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@southwind-ai/shared",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "license": "UNLICENSED",
   "type": "module",
   "engines": {
@@ -15,7 +15,8 @@
     "typecheck": "tsc --noEmit --project tsconfig.json"
   },
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./structured-log": "./src/structured-log.ts"
   },
   "publishConfig": {
     "access": "public"

package/template/packages/shared/src/structured-log.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, test } from "bun:test";
+import {
+  createStructuredLogger,
+  STRUCTURED_LOG_MAX_BYTES,
+} from "./structured-log.js";
+
+describe("structured operational log", () => {
+  test("保留跨服务关联标识与稳定排障字段", () => {
+    const records: Record<string, unknown>[] = [];
+    const logger = createStructuredLogger(
+      {
+        info: (record) => records.push(record),
+        warn: (record) => records.push(record),
+        error: (record) => records.push(record),
+      },
+      "windy-server",
+      () => new Date("2026-09-29T00:00:00.000Z"),
+    );
+    logger.error({
+      event: "agent.workflow.continuation.failed",
+      requestId: "request-1",
+      runId: "run-1",
+      jobId: "job-1",
+      traceId: "trace-1",
+      diagnosticId: "diag-1",
+      route: "/api/agent/runs/:runId/events",
+      outcome: "failure",
+      errorCode: "AGENT_WORKFLOW_CONTINUATION_FAILED",
+      stageKey: "dispatch",
+      handlerKey: "system.scheduler.dispatch",
+      queue: "default",
+      attemptNumber: 2,
+      count: 10,
+    });
+    expect(records).toEqual([
+      {
+        timestamp: "2026-09-29T00:00:00.000Z",
+        level: "error",
+        component: "windy-server",
+        event: "agent.workflow.continuation.failed",
+        retentionClass: "operational",
+        requestId: "request-1",
+        runId: "run-1",
+        jobId: "job-1",
+        traceId: "trace-1",
+        diagnosticId: "diag-1",
+        route: "/api/agent/runs/:runId/events",
+        outcome: "failure",
+        errorCode: "AGENT_WORKFLOW_CONTINUATION_FAILED",
+        stageKey: "dispatch",
+        handlerKey: "system.scheduler.dispatch",
+        queue: "default",
+        attemptNumber: 2,
+        count: 10,
+      },
+    ]);
+  });
+
+  test("拒绝未列字段、原始错误和不安全关联标识", () => {
+    const records: Record<string, unknown>[] = [];
+    const logger = createStructuredLogger(
+      {
+        info: (record) => records.push(record),
+        warn: (record) => records.push(record),
+        error: (record) => records.push(record),
+      },
+      "windy-server",
+    );
+    logger.error(
+      {
+        event: "unsafe\nrequest",
+        requestId: "bad\nsecret-request",
+        runId: "x".repeat(200),
+        errorCode: "provider secret payload",
+        handlerKey: "payload secret-handler",
+        queue: "secret\nqueue",
+        attemptNumber: -1,
+        diagnosticId: "secret\ndiag",
+        route: "/api/users/123?secret-route",
+        completedUnits: -1,
+        totalUnits: Number.POSITIVE_INFINITY,
+        count: -1,
+        body: "secret-body",
+        authorization: "Bearer secret-token",
+        error: new Error("secret-stack"),
+      } as unknown as Parameters<typeof logger.error>[0],
+      "secret-message",
+      "secret-handler",
+      "secret-route",
+      "secret\\nqueue",
+    );
+    const serialized = JSON.stringify(records);
+    expect(records[0]?.event).toBe("logging.event.invalid");
+    for (const secret of [
+      "secret-request",
+      "secret-body",
+      "secret-token",
+      "secret-stack",
+      "secret-message",
+    ]) {
+      expect(serialized).not.toContain(secret);
+    }
+    expect(Buffer.byteLength(serialized)).toBeLessThanOrEqual(
+      STRUCTURED_LOG_MAX_BYTES + 2,
+    );
+  });
+
+  test("长字段不撑破单行预算", () => {
+    const records: Record<string, unknown>[] = [];
+    const logger = createStructuredLogger(
+      {
+        info: (record) => records.push(record),
+        warn: (record) => records.push(record),
+        error: (record) => records.push(record),
+      },
+      "windy-server",
+    );
+    logger.info({
+      event: "http.request.completed",
+      requestId: "x".repeat(128),
+      runId: "x".repeat(128),
+      jobId: "x".repeat(128),
+      traceId: "x".repeat(128),
+      diagnosticId: "x".repeat(128),
+      stageKey: "x".repeat(64),
+      handlerKey: "x".repeat(64),
+      queue: "x".repeat(64),
+      attemptNumber: 1_000_000_000,
+    });
+    expect(Buffer.byteLength(JSON.stringify(records[0]))).toBeLessThanOrEqual(
+      STRUCTURED_LOG_MAX_BYTES,
+    );
+  });
+
+  test("输出端故障不影响业务调用", () => {
+    const fail = () => {
+      throw new Error("stdout unavailable");
+    };
+    const logger = createStructuredLogger(
+      { info: fail, warn: fail, error: fail },
+      "windy-server",
+    );
+    expect(() =>
+      logger.error({ event: "agent.workflow.continuation.failed" }),
+    ).not.toThrow();
+  });
+});

package/template/packages/shared/src/structured-log.ts

@@ -0,0 +1,215 @@
+/** 运行日志只承载排障线索；业务审计和 Agent Run 事实使用各自的持久化入口。 */
+export const STRUCTURED_LOG_MAX_BYTES = 2048;
+
+export type StructuredLogLevel = "info" | "warn" | "error";
+export type StructuredLogOutcome = "success" | "failure" | "denied";
+
+export interface StructuredLogInput {
+  event: string;
+  requestId?: string;
+  runId?: string;
+  jobId?: string;
+  traceId?: string;
+  diagnosticId?: string;
+  outcome?: StructuredLogOutcome;
+  errorCode?: string;
+  stageKey?: string;
+  handlerKey?: string;
+  queue?: string;
+  attemptNumber?: number;
+  method?: string;
+  /** 只接受框架登记的路由模板，不能传请求 URL 或实际对象路径。 */
+  route?: string;
+  statusCode?: number;
+  durationMs?: number;
+  actorType?: string;
+  authority?: string;
+  port?: number;
+  created?: number;
+  metadataUpdated?: number;
+  archived?: number;
+  unchanged?: number;
+  queued?: number;
+  dropped?: number;
+  completedUnits?: number;
+  totalUnits?: number;
+  count?: number;
+  /** 兼容现有 Logger 接口；未知字段在序列化时一律丢弃。 */
+  [key: string]: unknown;
+}
+
+export interface StructuredLogSink {
+  info(record: Record<string, unknown>): void;
+  warn(record: Record<string, unknown>): void;
+  error(record: Record<string, unknown>): void;
+}
+
+export interface StructuredLogger {
+  info(input: StructuredLogInput, message?: string): void;
+  warn(input: StructuredLogInput, message?: string): void;
+  error(input: StructuredLogInput, message?: string): void;
+}
+
+const stableKey = /^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/;
+const correlationKey = /^[A-Za-z0-9._-]{1,128}$/;
+const errorKey = /^[A-Z][A-Z0-9_]{0,95}$/;
+const methodKey = /^[A-Z]{1,12}$/;
+const routeTemplate =
+  /^\/(?:[A-Za-z][A-Za-z0-9_-]*|:[A-Za-z][A-Za-z0-9_]*|\*)(?:\/(?:[A-Za-z][A-Za-z0-9_-]*|:[A-Za-z][A-Za-z0-9_]*|\*))*$/;
+
+/** Adapter 可接 Pino、stdout 或测试 Sink；自由文本 message 不进入日志。 */
+export function createStructuredLogger(
+  sink: StructuredLogSink,
+  component: string,
+  now: () => Date = () => new Date(),
+): StructuredLogger {
+  if (!stableKey.test(component) || component.length > 64) {
+    throw new Error("运行日志 component 必须是有界稳定 Key");
+  }
+  const emit = (level: StructuredLogLevel, input: StructuredLogInput) => {
+    const record = structuredLogRecord(level, component, input, now());
+    try {
+      sink[level](record);
+    } catch {
+      // 排障日志是旁路输出；审计和业务结果由各自的可靠存储决定。
+    }
+  };
+  return {
+    info: (input) => emit("info", input),
+    warn: (input) => emit("warn", input),
+    error: (input) => emit("error", input),
+  };
+}
+
+export function structuredLogRecord(
+  level: StructuredLogLevel,
+  component: string,
+  input: StructuredLogInput,
+  at: Date,
+): Record<string, unknown> {
+  const record: Record<string, unknown> = {
+    timestamp: at.toISOString(),
+    level,
+    component,
+    event:
+      stableKey.test(input.event) && input.event.length <= 96
+        ? input.event
+        : "logging.event.invalid",
+    retentionClass: "operational",
+  };
+  for (const key of [
+    "requestId",
+    "runId",
+    "jobId",
+    "traceId",
+    "diagnosticId",
+  ] as const) {
+    const value = input[key];
+    if (typeof value === "string" && correlationKey.test(value)) {
+      record[key] = value;
+    }
+  }
+  if (
+    input.outcome === "success" ||
+    input.outcome === "failure" ||
+    input.outcome === "denied"
+  )
+    record.outcome = input.outcome;
+  if (typeof input.errorCode === "string" && errorKey.test(input.errorCode)) {
+    record.errorCode = input.errorCode;
+  }
+  for (const key of [
+    "stageKey",
+    "handlerKey",
+    "queue",
+    "actorType",
+    "authority",
+  ] as const) {
+    const value = input[key];
+    if (
+      typeof value === "string" &&
+      value.length <= 64 &&
+      stableKey.test(value)
+    ) {
+      record[key] = value;
+    }
+  }
+  if (typeof input.method === "string" && methodKey.test(input.method)) {
+    record.method = input.method;
+  }
+  if (
+    typeof input.route === "string" &&
+    input.route.length <= 160 &&
+    (input.route === "/" || routeTemplate.test(input.route))
+  )
+    record.route = input.route;
+  if (validNumber(input.statusCode, 100, 599, true))
+    record.statusCode = input.statusCode;
+  if (validNumber(input.durationMs, 0, 3_600_000))
+    record.durationMs = input.durationMs;
+  if (validNumber(input.port, 1, 65535, true)) record.port = input.port;
+  if (validNumber(input.attemptNumber, 1, 1_000_000_000, true))
+    record.attemptNumber = input.attemptNumber;
+  for (const key of [
+    "created",
+    "metadataUpdated",
+    "archived",
+    "unchanged",
+    "queued",
+    "dropped",
+    "completedUnits",
+    "totalUnits",
+    "count",
+  ] as const) {
+    const value = input[key];
+    if (validNumber(value, 0, 1_000_000_000, true)) record[key] = value;
+  }
+  for (const key of [
+    "dropped",
+    "completedUnits",
+    "totalUnits",
+    "count",
+    "route",
+    "queued",
+    "unchanged",
+    "archived",
+    "metadataUpdated",
+    "created",
+    "port",
+    "attemptNumber",
+    "queue",
+    "handlerKey",
+    "authority",
+    "actorType",
+    "stageKey",
+    "diagnosticId",
+    "traceId",
+    "jobId",
+    "runId",
+    "requestId",
+  ] as const) {
+    if (
+      new TextEncoder().encode(JSON.stringify(record)).length <=
+      STRUCTURED_LOG_MAX_BYTES
+    )
+      break;
+    delete record[key];
+    record.truncated = true;
+  }
+  return record;
+}
+
+function validNumber(
+  value: unknown,
+  min: number,
+  max: number,
+  integer = false,
+): value is number {
+  return (
+    typeof value === "number" &&
+    Number.isFinite(value) &&
+    value >= min &&
+    value <= max &&
+    (!integer || Number.isInteger(value))
+  );
+}