create-windy 0.8.3 → 0.9.1

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/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/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/dsh-skill-draft-audit.test.ts

@@ -0,0 +1,195 @@
+import { expect, test } from "bun:test";
+import {
+  auditDshSkillDraftResponse,
+  dshSkillDraftCompletionEvent,
+} from "./dsh-skill-draft-audit.js";
+import { dshFixture } from "./dsh-workbench-test-support.js";
+
+const endpoint = "/agent/native/windy/skills";
+const draft = {
+  name: "merge-tables",
+  displayName: "表格整理",
+  description: "汇总表格时使用",
+  inputs: "用户提供的表格",
+  steps: "确认范围后处理并检查结果",
+  output: "保留来源的汇总表",
+  constraints: "只处理已授权内容",
+};
+const success = (body: unknown = { draft }) =>
+  Response.json(body, {
+    headers: { "x-windy-skill-draft-complete": "1" },
+  });
+const completions = (fixture: Awaited<ReturnType<typeof dshFixture>>) =>
+  fixture.runtime.auditSink
+    .list()
+    .filter((event) => event.action === "agent.skill.draft");
+
+test("trusted complete draft records one frozen metric after reauthorization; input is passed unchanged", async () => {
+  const fixture = await dshFixture();
+  fixture.state.probe = () => success();
+  const body = JSON.stringify({
+    action: "draft",
+    workspaceId: "work",
+    workflow: "整理表格",
+  });
+  const response = await fixture.request(endpoint, "POST", { body });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ draft });
+  expect(await fixture.state.probes[0]!.text()).toBe(body);
+  expect(response.headers.has("x-windy-skill-draft-complete")).toBe(false);
+  const events = completions(fixture);
+  expect(events).toHaveLength(1);
+  expect(events[0]).toMatchObject({
+    actor: { id: "user-a" },
+    target: { type: "application", id: "system.agent-skill" },
+    metadata: { generatedSkillDraftCount: 1 },
+  });
+  const serialized = JSON.stringify(events);
+  for (const content of Object.values(draft).concat(
+    "整理表格",
+    "workflow",
+    "workspaceId",
+  ))
+    expect(serialized).not.toContain(content);
+});
+
+test("client cannot assert completion; ordinary actions and failed responses add no contribution", async () => {
+  for (const response of [
+    Response.json({ draft }),
+    new Response("cancelled", {
+      status: 499,
+      headers: { "x-windy-skill-draft-complete": "1" },
+    }),
+    new Response("failed", { status: 504 }),
+  ]) {
+    const fixture = await dshFixture();
+    fixture.state.probe = () => response;
+    await fixture.request(endpoint, "POST", {
+      body: JSON.stringify({ action: "create", raw: "draft" }),
+      headers: { "x-windy-skill-draft-complete": "1" },
+    });
+    expect(
+      fixture.state.probes[0]!.headers.has("x-windy-skill-draft-complete"),
+    ).toBe(false);
+    expect(completions(fixture)).toEqual([]);
+  }
+  const fixture = await dshFixture();
+  fixture.state.probe = () => success();
+  await fixture.request("/agent/native/other", "POST", { body: "{}" });
+  expect(completions(fixture)).toEqual([]);
+});
+
+test("malformed, partial, overlong and unexpected generated data fails closed without audit", async () => {
+  for (const body of [
+    { draft: { ...draft, steps: "" } },
+    { draft: { ...draft, actorId: "forged" } },
+    { draft: { ...draft, displayName: "a".repeat(61) } },
+    { draft: { ...draft, constraints: "bad\u0000value" } },
+    { draft, ok: true },
+  ]) {
+    const fixture = await dshFixture();
+    fixture.state.probe = () => success(body);
+    expect(
+      (await fixture.request(endpoint, "POST", { body: '{"action":"draft"}' }))
+        .status,
+    ).toBe(503);
+    expect(completions(fixture)).toEqual([]);
+  }
+});
+
+test("revoked permissions after generation suppress the result and success audit", async () => {
+  const fixture = await dshFixture();
+  fixture.state.probe = () => {
+    fixture.state.permissions = [];
+    return success();
+  };
+  expect(
+    (await fixture.request(endpoint, "POST", { body: '{"action":"draft"}' }))
+      .status,
+  ).toBe(403);
+  expect(completions(fixture)).toEqual([]);
+});
+
+test("cancelled and interrupted response never invoke completion", async () => {
+  for (const mode of ["cancel", "interrupted", "oversize"] as const) {
+    const controller = new AbortController();
+    let recorded = false;
+    const response = new Response(
+      new ReadableStream({
+        start(stream) {
+          if (mode === "cancel") controller.abort();
+          else if (mode === "interrupted")
+            stream.error(new Error("interrupted"));
+          else {
+            stream.enqueue(new Uint8Array(128 * 1024 + 1));
+            stream.close();
+          }
+        },
+      }),
+      {
+        headers: {
+          "x-windy-skill-draft-complete": "1",
+          "content-type": "application/json",
+        },
+      },
+    );
+    await expect(
+      auditDshSkillDraftResponse({
+        request: new Request(`https://windy.test/api${endpoint}`, {
+          method: "POST",
+          signal: controller.signal,
+        }),
+        response,
+        complete: async () => {
+          recorded = true;
+        },
+      }),
+    ).rejects.toThrow();
+    expect(recorded).toBe(false);
+  }
+});
+
+test("completion identity is deterministic for replay and isolated per actor", () => {
+  const actor = { id: "a", type: "user", name: "A", roleCodes: [] } as never;
+  const first = dshSkillDraftCompletionEvent(actor, "completion");
+  expect(dshSkillDraftCompletionEvent(actor, "completion").id).toBe(first.id);
+  expect(
+    dshSkillDraftCompletionEvent(
+      { ...(actor as object), id: "b" } as never,
+      "completion",
+    ).id,
+  ).not.toBe(first.id);
+});
+
+test("skill generation outlives ordinary HTTP idle timeout with a bounded upstream signal", async () => {
+  let upstreamSignal: AbortSignal | null | undefined;
+  const fixture = await dshFixture({
+    fetcher: async (_input, init) => {
+      upstreamSignal = init?.signal;
+      await Bun.sleep(3100);
+      return success();
+    },
+  });
+  fixture.app.listen({ hostname: "127.0.0.1", port: 0, idleTimeout: 1 });
+  try {
+    const response = await fetch(
+      `${fixture.app.server!.url.origin}/api${endpoint}`,
+      {
+        method: "POST",
+        headers: {
+          cookie: `windy.sid=${fixture.login.token}`,
+          origin: "https://windy.test",
+          "content-type": "application/json",
+        },
+        body: '{"action":"draft","workspaceId":"work","workflow":"整理表格"}',
+        signal: AbortSignal.timeout(6000),
+      },
+    );
+    expect(response.status).toBe(200);
+    expect(await response.json()).toEqual({ draft });
+    expect(upstreamSignal).toBeInstanceOf(AbortSignal);
+    expect(completions(fixture)).toHaveLength(1);
+  } finally {
+    await fixture.app.stop(true);
+  }
+}, 10000);

package/template/apps/server/src/app/dsh-skill-draft-audit.ts

@@ -0,0 +1,115 @@
+import type { AuditEvent } from "@southwind-ai/shared";
+import type { RequestActor } from "../guards.js";
+
+const path = "/api/agent/native/windy/skills";
+const maximumBytes = 128 * 1024;
+const fields = {
+  name: 64,
+  displayName: 60,
+  description: 2048,
+  inputs: 4000,
+  steps: 12000,
+  output: 4000,
+  constraints: 4000,
+};
+
+/** Only the trusted plugin's validated terminal response can assert completion. */
+export async function auditDshSkillDraftResponse(input: {
+  request: Request;
+  response: Response;
+  complete(): Promise<Response | void>;
+}): Promise<Response> {
+  const { request, response } = input;
+  if (
+    request.method !== "POST" ||
+    new URL(request.url).pathname !== path ||
+    response.headers.get("x-windy-skill-draft-complete") !== "1" ||
+    response.status !== 200
+  )
+    return response;
+  if (!response.headers.get("content-type")?.includes("application/json"))
+    throw new Error("Invalid skill draft response");
+  const reader = response.body?.getReader();
+  if (!reader) throw new Error("Missing skill draft response");
+  const abort = () => {
+    void reader.cancel().catch(() => {});
+  };
+  request.signal.addEventListener("abort", abort, { once: true });
+  let text = "",
+    bytes = 0;
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  try {
+    while (true) {
+      request.signal.throwIfAborted();
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      bytes += chunk.value.byteLength;
+      if (bytes > maximumBytes)
+        throw new Error("Skill draft response too large");
+      text += decoder.decode(chunk.value, { stream: true });
+    }
+    text += decoder.decode();
+    const value: unknown = JSON.parse(text);
+    if (!validDraft(value)) throw new Error("Invalid skill draft response");
+    request.signal.throwIfAborted();
+    const denied = await input.complete();
+    if (denied) return denied;
+    return new Response(text, { status: 200, headers: response.headers });
+  } finally {
+    request.signal.removeEventListener("abort", abort);
+    await reader.cancel().catch(() => {});
+    reader.releaseLock();
+  }
+}
+
+function validDraft(value: unknown): boolean {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    Object.keys(value).join() !== "draft"
+  )
+    return false;
+  const draft = (value as { draft: unknown }).draft;
+  if (!draft || typeof draft !== "object" || Array.isArray(draft)) return false;
+  const record = draft as Record<string, unknown>;
+  return (
+    Object.keys(record).length === Object.keys(fields).length &&
+    Object.entries(fields).every(
+      ([key, limit]) =>
+        typeof record[key] === "string" &&
+        record[key].trim().length > 0 &&
+        record[key].length <= limit &&
+        !Array.from(record[key]).some((char) => {
+          const code = char.charCodeAt(0);
+          return (code < 32 && ![9, 10, 13].includes(code)) || code === 127;
+        }),
+    ) &&
+    /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(String(record.name)) &&
+    String(record.name).length <= 64 &&
+    String(record.displayName).length <= 60
+  );
+}
+
+export function dshSkillDraftCompletionEvent(
+  actor: RequestActor,
+  completionId: string,
+): AuditEvent {
+  return {
+    id: new Bun.CryptoHasher("sha256")
+      .update(`dsh-skill-draft\0${actor.id}\0${completionId}`)
+      .digest("hex"),
+    action: "agent.skill.draft",
+    outcome: "success",
+    actor: {
+      id: actor.id,
+      type: "user",
+      name: actor.name,
+      roleCodes: [...actor.roleCodes],
+    },
+    target: { type: "application", id: "system.agent-skill" },
+    requestId: completionId,
+    occurredAt: new Date().toISOString(),
+    metadata: { completionId, generatedSkillDraftCount: 1 },
+  };
+}

package/template/apps/server/src/app/dsh-workbench-audit.test.ts

@@ -0,0 +1,71 @@
+import { expect, test } from "bun:test";
+import { dshFixture, internalToken } from "./dsh-workbench-test-support.js";
+
+function events(fixture: Awaited<ReturnType<typeof dshFixture>>) {
+  return fixture.runtime.auditSink
+    .list()
+    .filter((event) => event.action === "agent.workbench.access");
+}
+
+test.each([
+  ["/agent/native", "GET", "entry"],
+  ["/agent/native/", "GET", "entry"],
+  ["/agent/workbench/launch", "POST", "launch"],
+] as const)(
+  "%s writes admission before the coordinator request",
+  async (path, method, kind) => {
+    const fixture = await dshFixture();
+    fixture.state.probe = () => {
+      expect(events(fixture)).toHaveLength(1);
+      return Response.json({ ready: true });
+    };
+    const response = await fixture.request(path, method);
+    expect(response.status).toBe(200);
+    expect(events(fixture)[0]).toMatchObject({
+      actor: { id: "user-a", type: "user" },
+      target: { type: "agent-workbench", id: "native" },
+      outcome: "success",
+      metadata: { kind, phase: "admission" },
+    });
+    const serialized = JSON.stringify(events(fixture));
+    expect(serialized).not.toContain(fixture.login.token);
+    expect(serialized).not.toContain(internalToken);
+  },
+);
+
+test("status, authorization refresh and assets do not flood admission audit", async () => {
+  const fixture = await dshFixture({ publishedSkills: async () => [] });
+  for (const path of [
+    "/agent/workbench",
+    "/agent/workbench/admission",
+    "/agent/workbench/skills",
+    "/agent/native/assets/index.js",
+  ])
+    expect((await fixture.request(path)).status).toBe(200);
+  expect(events(fixture)).toEqual([]);
+});
+
+test.each([
+  ["/agent/native/", "GET"],
+  ["/agent/workbench/launch", "POST"],
+] as const)(
+  "audit failure rejects %s without contacting the coordinator",
+  async (path, method) => {
+    const fixture = await dshFixture();
+    fixture.runtime.auditSink.recordCriticalEvent = async () => {
+      throw new Error("private audit persistence failure");
+    };
+    const response = await fixture.request(path, method);
+    expect(response.status).toBe(503);
+    expect(await response.json()).toMatchObject({ error: "AUDIT_UNAVAILABLE" });
+    expect(fixture.state.probes).toEqual([]);
+  },
+);
+
+test("denied entry never records successful admission", async () => {
+  const fixture = await dshFixture();
+  fixture.state.permissions = [];
+  expect((await fixture.request("/agent/native/")).status).toBe(403);
+  expect(events(fixture)).toEqual([]);
+  expect(fixture.state.probes).toEqual([]);
+});

package/template/apps/server/src/app/dsh-workbench-audit.ts

@@ -0,0 +1,34 @@
+import type { RequestActor, RequestGuardContext } from "../guards.js";
+import type { createServerRuntime } from "../runtime.js";
+import { resourceEvent } from "../system/route-helpers.js";
+import { dshJson } from "./dsh-workbench-proxy.js";
+
+export type DshWorkbenchAdmissionKind = "entry" | "launch" | "websocket";
+
+/** Record platform admission before the coordinator can create a worker. */
+export async function auditDshWorkbenchAdmission(input: {
+  readonly runtime: Pick<ReturnType<typeof createServerRuntime>, "auditSink">;
+  readonly context: RequestGuardContext;
+  readonly actor: RequestActor;
+  readonly kind: DshWorkbenchAdmissionKind;
+}): Promise<Response | undefined> {
+  try {
+    await input.runtime.auditSink.recordCriticalEvent(
+      resourceEvent(
+        { ...input.context, actor: input.actor },
+        "agent.workbench.access",
+        "agent-workbench",
+        "native",
+        { kind: input.kind, phase: "admission" },
+      ),
+    );
+  } catch {
+    return dshJson(
+      {
+        error: "AUDIT_UNAVAILABLE",
+        message: "工作台准入审计暂不可用，请稍后重试",
+      },
+      503,
+    );
+  }
+}

package/template/apps/server/src/app/dsh-workbench-handshake.test.ts

@@ -0,0 +1,63 @@
+import { expect, test } from "bun:test";
+import { preflightDshWorkbenchSocket } from "./dsh-workbench-handshake.js";
+import { DSH_NATIVE_STARTUP_TIMEOUT_MS } from "./dsh-workbench-proxy.js";
+
+test("45秒冷启动使用既有75秒总预算，连接建立只获得剩余预算", async () => {
+  let elapsed = 0;
+  const result = await preflightDshWorkbenchSocket(
+    {
+      baseUrl: () => "http://coordinator.invalid",
+      fetcher: async (url, init) => {
+        expect(String(url)).toBe(
+          "http://coordinator.invalid/internal/workbench-handshake",
+        );
+        expect(init?.redirect).toBe("error");
+        expect(new Headers(init?.headers).get("authorization")).toBe(
+          "Bearer synthetic-internal",
+        );
+        elapsed = 45_000;
+        return new Response(null, { status: 204 });
+      },
+    },
+    new Request("http://product.invalid"),
+    new Headers({ authorization: "Bearer synthetic-internal" }),
+    () => elapsed,
+  );
+  expect(DSH_NATIVE_STARTUP_TIMEOUT_MS).toBe(75_000);
+  expect(result).toEqual({ remainingMs: 30_000 });
+});
+
+test("超出总预算不再建立WS，明确冲突/撤权/暂不可用仍保持原状态", async () => {
+  for (const [status, expected] of [
+    [409, 409],
+    [401, 401],
+    [403, 403],
+    [503, 503],
+    [200, 503],
+  ]) {
+    const result = await preflightDshWorkbenchSocket(
+      {
+        baseUrl: () => "http://coordinator.invalid",
+        fetcher: async () => new Response(null, { status }),
+      },
+      new Request("http://product.invalid"),
+      new Headers(),
+    );
+    expect(result).toBeInstanceOf(Response);
+    expect((result as Response).status).toBe(expected);
+  }
+  let elapsed = 0;
+  const expired = await preflightDshWorkbenchSocket(
+    {
+      baseUrl: () => "http://coordinator.invalid",
+      fetcher: async () => {
+        elapsed = 75_001;
+        return new Response(null, { status: 204 });
+      },
+    },
+    new Request("http://product.invalid"),
+    new Headers(),
+    () => elapsed,
+  );
+  expect((expired as Response).status).toBe(503);
+});