create-windy 0.8.3 → 0.10.0

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);
+});

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

@@ -0,0 +1,48 @@
+import {
+  DSH_NATIVE_STARTUP_TIMEOUT_MS,
+  dshInternalTarget,
+  dshJson,
+  type DshWorkbenchOptions,
+} from "./dsh-workbench-proxy.js";
+
+/** Probe trusted coordinator HTTP status before opening Bun's WebSocket carrier. */
+export async function preflightDshWorkbenchSocket(
+  options: DshWorkbenchOptions,
+  request: Request,
+  headers: Headers,
+  now: () => number = () => performance.now(),
+): Promise<Response | { remainingMs: number }> {
+  const deadline = now() + DSH_NATIVE_STARTUP_TIMEOUT_MS;
+  const admission = await (options.fetcher ?? fetch)(
+    dshInternalTarget(options, "/internal/workbench-handshake"),
+    {
+      method: "GET",
+      headers,
+      redirect: "error",
+      signal: AbortSignal.any([
+        request.signal,
+        AbortSignal.timeout(DSH_NATIVE_STARTUP_TIMEOUT_MS),
+      ]),
+    },
+  );
+  await admission.body?.cancel();
+  request.signal.throwIfAborted();
+  if (admission.status === 409)
+    return dshJson(
+      {
+        error: "WORKBENCH_SESSION_CONFLICT",
+        message:
+          "该账号已有另一个登录会话使用 Agent，请返回原登录继续，或退出原登录后重试。",
+      },
+      409,
+    );
+  if (admission.status !== 204)
+    return dshJson(
+      { error: "AGENT_UNAVAILABLE" },
+      [401, 403].includes(admission.status) ? admission.status : 503,
+    );
+  const remainingMs = Math.floor(deadline - now());
+  return remainingMs > 0
+    ? { remainingMs }
+    : dshJson({ error: "AGENT_UNAVAILABLE" }, 503);
+}

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

@@ -0,0 +1,96 @@
+import { expect, test } from "bun:test";
+import { dshFixture } from "./dsh-workbench-test-support.js";
+
+test("native HTML completes over real HTTP on consecutive visits", async () => {
+  const html =
+    "<!doctype html><html><head><title>DSH</title></head><body>ready</body></html>";
+  const upstream = Bun.serve({
+    port: 0,
+    fetch: () =>
+      new Response(
+        new ReadableStream({
+          async start(controller) {
+            controller.enqueue(new TextEncoder().encode(html.slice(0, 40)));
+            await Bun.sleep(20);
+            controller.enqueue(new TextEncoder().encode(html.slice(40)));
+            controller.close();
+          },
+        }),
+        { headers: { "content-type": "text/html" } },
+      ),
+  });
+  const fixture = await dshFixture({
+    baseUrl: () => upstream.url.origin,
+    fetcher: fetch,
+  });
+  fixture.app.listen({ hostname: "127.0.0.1", port: 0 });
+  try {
+    for (let i = 0; i < 4; i++) {
+      const html = await readDocument(fixture, "/api/agent/native");
+      expect(html).toContain('<base href="/agent/">');
+      expect(html).toContain("</body></html>");
+    }
+  } finally {
+    await fixture.app.stop(true);
+    upstream.stop(true);
+  }
+}, 15000);
+
+test("cold entry outlives the ordinary HTTP idle timeout", async () => {
+  const upstream = Bun.serve({
+    port: 0,
+    async fetch() {
+      await Bun.sleep(3100);
+      return new Response("<html><head></head><body>cold ready</body></html>", {
+        headers: { "content-type": "text/html" },
+      });
+    },
+  });
+  const fixture = await dshFixture({
+    baseUrl: () => upstream.url.origin,
+    fetcher: fetch,
+  });
+  fixture.app.listen({ hostname: "127.0.0.1", port: 0, idleTimeout: 1 });
+  try {
+    expect(await readDocument(fixture, "/api/agent/native/", 6000)).toContain(
+      "cold ready",
+    );
+  } finally {
+    await fixture.app.stop(true);
+    upstream.stop(true);
+  }
+}, 10000);
+
+async function readDocument(
+  fixture: Awaited<ReturnType<typeof dshFixture>>,
+  path: string,
+  timeoutMs = 2000,
+) {
+  const controller = new AbortController();
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      (async () => {
+        const response = await fetch(
+          `http://127.0.0.1:${fixture.app.server!.port}${path}`,
+          {
+            headers: { cookie: `windy.sid=${fixture.login.token}` },
+            signal: controller.signal,
+          },
+        );
+        expect(response.status).toBe(200);
+        expect(response.headers.get("cache-control")).toBe("no-store");
+        return response.text();
+      })(),
+      new Promise<never>((_, reject) => {
+        timer = setTimeout(() => {
+          controller.abort();
+          reject(new Error("Native entry did not finish its HTTP response"));
+        }, timeoutMs);
+      }),
+    ]);
+  } finally {
+    clearTimeout(timer);
+    controller.abort();
+  }
+}