create-windy 0.8.3 → 0.10.0

package/template/apps/agent-server/native/native.test.ts

@@ -0,0 +1,207 @@
+import { describe, expect, test } from "bun:test";
+import { createServer } from "node:http";
+import { mkdtemp, mkdir, symlink, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { actorKey, authorityFrom } from "./config.js";
+import { workerPath } from "./http.js";
+import { nativeRequest } from "./request.js";
+import { diskUsage } from "./storage.js";
+import { createBoundary } from "./boundary.js";
+import type { WorkbenchManager } from "./manager.js";
+
+describe("embedded DSH boundary", () => {
+  test("only server-bound login facts form an actor authority", () => {
+    const headers = {
+      "x-windy-actor-id": "actor-a",
+      "x-windy-product-session": "s".repeat(43),
+      "x-windy-public-origin": "https://windy.example",
+    };
+    expect(
+      authorityFrom(new Request("http://agent.internal/", { headers })).actorId,
+    ).toBe("actor-a");
+    for (const invalid of [
+      "https://attacker@windy.example",
+      "https://windy.example/path",
+      "file:///tmp",
+      "https://windy.example?x=1",
+    ])
+      expect(() =>
+        authorityFrom(
+          new Request("http://agent.internal/", {
+            headers: { ...headers, "x-windy-public-origin": invalid },
+          }),
+        ),
+      ).toThrow();
+    expect(() =>
+      authorityFrom(
+        new Request("http://agent.internal/", {
+          headers: { ...headers, "x-windy-actor-id": "../other-user" },
+        }),
+      ),
+    ).toThrow();
+    expect(actorKey("actor-a")).not.toBe(actorKey("actor-b"));
+  });
+
+  test("native private bootstrap and connect cannot be browser-proxied", () => {
+    for (const path of [
+      "/windy/internal-bootstrap",
+      "/windy/internal-other",
+      "/connect",
+      "/%2fescape",
+      "/%5cescape",
+    ])
+      expect(() =>
+        workerPath(`http://agent.internal/internal/workbench${path}`),
+      ).toThrow();
+    expect(
+      workerPath("http://agent.internal/internal/workbench/api/remote.mux"),
+    ).toBe("/api/remote.mux");
+  });
+
+  test("native transport preserves virtual Host and private Cookie audience", async () => {
+    const server = createServer((request, response) => {
+      response.writeHead(
+        request.headers.host === "windy.example" &&
+          request.headers.cookie === "private=native"
+          ? 200
+          : 401,
+      );
+      response.end("native");
+    });
+    await new Promise<void>((accept) => server.listen(0, "127.0.0.1", accept));
+    try {
+      const address = server.address();
+      if (!address || typeof address === "string")
+        throw new Error("Missing listener");
+      const response = await nativeRequest(
+        `http://127.0.0.1:${address.port}/`,
+        {
+          headers: new Headers({
+            host: "windy.example",
+            cookie: "private=native",
+          }),
+          signal: AbortSignal.timeout(3000),
+        },
+      );
+      expect(response.status).toBe(200);
+      expect(await response.text()).toBe("native");
+    } finally {
+      server.closeAllConnections();
+      await new Promise<void>((accept) => server.close(() => accept()));
+    }
+  });
+
+  test("quota walk counts generated files and never follows another user's tree", async () => {
+    const root = await mkdtemp(join(tmpdir(), "windy-user-quota-"));
+    try {
+      await mkdir(join(root, "own"));
+      await mkdir(join(root, "other"));
+      await writeFile(join(root, "own", "result"), "abc");
+      await writeFile(join(root, "other", "private"), "private-other-data");
+      await symlink(join(root, "other"), join(root, "own", "foreign"));
+      expect(await diskUsage(join(root, "own"), 100)).toBe(3);
+      expect(await diskUsage(join(root, "own"), 2)).toBeGreaterThan(2);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});
+
+test("native capacity reserves a canonical slot and queues excess requests", async () => {
+  const oldGlobal = process.env.AI_PROVIDER_MAX_CONCURRENT_RUNS;
+  const oldNative = process.env.AGENT_DSH_MAX_ACTIVE_RUNS;
+  const worker = {
+    authority: { actorId: "actor-a" },
+    controller: new AbortController(),
+    admissionController: new AbortController(),
+  };
+  const manager = {
+    byToken: () => worker,
+    current: async () => true,
+  } as unknown as WorkbenchManager;
+  let calls = 0;
+  const completion = async () => {
+    calls++;
+    return new Response(new ReadableStream({ start() {} }));
+  };
+  const request = () =>
+    new Request("http://agent/internal/boundary/v1/chat/completions", {
+      method: "POST",
+      headers: { authorization: `Bearer ${"s".repeat(43)}` },
+      body: "{}",
+    });
+  try {
+    process.env.AI_PROVIDER_MAX_CONCURRENT_RUNS = "1";
+    process.env.AGENT_DSH_MAX_ACTIVE_RUNS = "1";
+    expect(
+      (await createBoundary({ manager, completion })(request())).status,
+    ).toBe(429);
+    expect(calls).toBe(0);
+    process.env.AI_PROVIDER_MAX_CONCURRENT_RUNS = "3";
+    process.env.AGENT_DSH_MAX_ACTIVE_RUNS = "32";
+    const boundary = createBoundary({ manager, completion });
+    const first = await boundary(request());
+    const second = await boundary(request());
+    const pending = boundary(request());
+    await new Promise((accept) => setTimeout(accept, 10));
+    expect(calls).toBe(2);
+    await first.body?.cancel();
+    const replacement = await pending;
+    expect(replacement.status).toBe(200);
+    await second.body?.cancel();
+    await replacement.body?.cancel();
+  } finally {
+    if (oldGlobal === undefined)
+      delete process.env.AI_PROVIDER_MAX_CONCURRENT_RUNS;
+    else process.env.AI_PROVIDER_MAX_CONCURRENT_RUNS = oldGlobal;
+    if (oldNative === undefined) delete process.env.AGENT_DSH_MAX_ACTIVE_RUNS;
+    else process.env.AGENT_DSH_MAX_ACTIVE_RUNS = oldNative;
+  }
+});
+
+test("queued native model requests reauthorize before dispatch", async () => {
+  const oldGlobal = process.env.AI_PROVIDER_MAX_CONCURRENT_RUNS;
+  const oldNative = process.env.AGENT_DSH_MAX_ACTIVE_RUNS;
+  let allowed = true,
+    calls = 0;
+  const worker = {
+    authority: { actorId: "actor-a" },
+    controller: new AbortController(),
+    admissionController: new AbortController(),
+  };
+  const manager = {
+    byToken: () => worker,
+    current: async () => allowed,
+  } as unknown as WorkbenchManager;
+  try {
+    process.env.AI_PROVIDER_MAX_CONCURRENT_RUNS = "2";
+    process.env.AGENT_DSH_MAX_ACTIVE_RUNS = "2";
+    const boundary = createBoundary({
+      manager,
+      completion: async () => {
+        calls++;
+        return new Response(new ReadableStream({ start() {} }));
+      },
+    });
+    const request = () =>
+      new Request("http://agent/internal/boundary/v1/chat/completions", {
+        method: "POST",
+        headers: { authorization: `Bearer ${"s".repeat(43)}` },
+        body: "{}",
+      });
+    const first = await boundary(request());
+    const queued = boundary(request());
+    await new Promise((accept) => setTimeout(accept, 10));
+    allowed = false;
+    await first.body?.cancel();
+    expect((await queued).status).toBe(401);
+    expect(calls).toBe(1);
+  } finally {
+    if (oldGlobal === undefined)
+      delete process.env.AI_PROVIDER_MAX_CONCURRENT_RUNS;
+    else process.env.AI_PROVIDER_MAX_CONCURRENT_RUNS = oldGlobal;
+    if (oldNative === undefined) delete process.env.AGENT_DSH_MAX_ACTIVE_RUNS;
+    else process.env.AGENT_DSH_MAX_ACTIVE_RUNS = oldNative;
+  }
+});

package/template/apps/agent-server/native/office-preview.test.ts

@@ -0,0 +1,50 @@
+import { expect, test } from "bun:test";
+import { Config } from "@deepseek-ai/dsh-office-to-pdf";
+import { officePreviewPlugin } from "./office-preview";
+import { nativePackages } from "../install-native";
+
+test("Office preview uses valid bounded foreground-only configuration", () => {
+  const row = officePreviewPlugin();
+  const config = Config(row.config);
+  expect(row.id).toBe("office-to-pdf");
+  expect(config.maxConcurrentConversions).toBe(1);
+  expect(config.maxBackgroundConversions).toBe(0);
+  expect(config.maxSourceBytes).toBe(config.maxInputBytes);
+  expect(config.maxCachedBytes).toBeLessThanOrEqual(32 * 1024 * 1024);
+});
+
+test("both Linux architectures select the exact lock-pinned Office engine", async () => {
+  const parsed: unknown = Bun.JSONC.parse(
+    await Bun.file(new URL("../../../bun.lock", import.meta.url)).text(),
+  );
+  if (
+    !parsed ||
+    typeof parsed !== "object" ||
+    !("packages" in parsed) ||
+    !parsed.packages ||
+    typeof parsed.packages !== "object"
+  )
+    throw new Error("Invalid runtime lock");
+  const packages: Record<string, [string, string, unknown, string]> = {};
+  for (const [name, value] of Object.entries(parsed.packages)) {
+    if (
+      Array.isArray(value) &&
+      typeof value[0] === "string" &&
+      typeof value[1] === "string" &&
+      typeof value[3] === "string"
+    )
+      packages[name] = [value[0], value[1], value[2], value[3]];
+  }
+  const lock = { packages };
+  for (const architecture of ["arm64", "x64"]) {
+    const selected = nativePackages(lock, architecture).filter((pkg) =>
+      pkg.name.includes("libreoffice"),
+    );
+    expect(selected).toHaveLength(1);
+    expect(selected[0]?.name).toBe("@deepseek-ai/libreoffice-kit-wasm");
+    expect(selected[0]?.version).toBe("0.1.5");
+    expect(selected[0]?.integrity).toBe(
+      lock.packages["@deepseek-ai/libreoffice-kit-wasm"][3],
+    );
+  }
+});

package/template/apps/agent-server/native/office-preview.ts

@@ -0,0 +1,25 @@
+/** Host conversion stays within the existing isolated user's Agent worker. */
+export function officePreviewPlugin() {
+  return {
+    id: "office-to-pdf",
+    config: {
+      maxConcurrentConversions: 1,
+      maxBackgroundConversions: 0,
+      maxQueuedJobs: 2,
+      maxReaders: 4,
+      maxSourceBytes: 16 * 1024 * 1024,
+      maxInputBytes: 16 * 1024 * 1024,
+      maxOutputBytes: 20 * 1024 * 1024,
+      maxCachedEntries: 2,
+      maxCachedBytes: 32 * 1024 * 1024,
+      maxSourceEntries: 8,
+      timeoutMs: 60000,
+      maxArchiveEntries: 4096,
+      maxUncompressedBytes: 64 * 1024 * 1024,
+      maxFontFiles: 128,
+      maxFontFileBytes: 64 * 1024 * 1024,
+      maxLoadedFontBytes: 128 * 1024 * 1024,
+      fontDirectories: ["/usr/share/fonts/opentype/noto"],
+    },
+  };
+}

package/template/apps/agent-server/native/parallel-harness.ts

@@ -0,0 +1,244 @@
+import { expect } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import * as Persistence from "@deepseek-ai/dsh-session-persistence-jsonl";
+import { Context } from "@deepseek-ai/cordis";
+import AgentRegistry from "@deepseek-ai/dsh-agent";
+import AgentLoop from "@deepseek-ai/dsh-agent-loop";
+import SessionStore, {
+  SessionId,
+  SessionLogOffset,
+} from "@deepseek-ai/dsh-session";
+import SessionProjections from "@deepseek-ai/dsh-session-projection";
+import LlmRuntime, {
+  LlmAdapter,
+  MessageId,
+  ToolCallId,
+  type GenerateOptions,
+  type StreamChunk,
+} from "@deepseek-ai/dsh-llm";
+import ToolRuntime from "@deepseek-ai/dsh-tools";
+import * as NativeToolExecutor from "@deepseek-ai/dsh-tool-executor-native";
+import SystemPrompt from "@deepseek-ai/dsh-system-prompt";
+import LocalFileSystem from "@deepseek-ai/dsh-fs-local";
+import WorkingDirectory from "@deepseek-ai/dsh-working-directory";
+import Subagents from "@deepseek-ai/dsh-subagent";
+import * as Spawn from "@deepseek-ai/dsh-subagent-spawn-in-process";
+import * as Delegate from "@deepseek-ai/dsh-tool-subagent";
+import * as Control from "@deepseek-ai/dsh-tool-subagent-control";
+// @ts-expect-error Project Cordis plugin uses upstream JS module convention.
+import * as Policy from "../plugins/parallel.mjs";
+import { ModelCapacity } from "../runtime/capacity.js";
+import * as Mcp from "@deepseek-ai/dsh-mcp-client";
+import { parallelMcpFixture } from "./parallel-mcp-fixture.js";
+
+const delay = (ms: number) =>
+  new Promise<void>((accept) => setTimeout(accept, ms));
+export async function until(check: () => boolean) {
+  for (let i = 0; i < 100 && !check(); i++) await delay(10);
+  expect(check()).toBe(true);
+}
+export class SyntheticModel extends LlmAdapter {
+  readonly capacity: ModelCapacity;
+  constructor(slots = 3) {
+    super();
+    this.capacity = new ModelCapacity(slots);
+  }
+  childActive = 0;
+  maximum = 0;
+  aborted = 0;
+  hold = false;
+  calls = new Map<string, number>();
+  override providerInfo(id: string) {
+    return { id, name: id };
+  }
+  override async resolveModel(provider: string, id: string) {
+    return {
+      provider,
+      id,
+      name: id,
+      inputModalities: ["text" as const],
+      context: { contextWindow: 32768 },
+    };
+  }
+  override async *stream(
+    options: GenerateOptions,
+  ): AsyncGenerator<StreamChunk> {
+    const release = await this.capacity.acquireNative(options.signal!);
+    try {
+      yield* this.generate(options);
+    } finally {
+      release();
+    }
+  }
+  private async *generate(
+    options: GenerateOptions,
+  ): AsyncGenerator<StreamChunk> {
+    const text = JSON.stringify(options.messages);
+    const child = options.messages.some(
+      (m) =>
+        m.role === "user" && JSON.stringify(m.content).includes("CHILD_TASK_"),
+    );
+    const key = child ? (text.includes("CHILD_TASK_A") ? "a" : "b") : "parent";
+    const count = (this.calls.get(key) ?? 0) + 1;
+    this.calls.set(key, count);
+    const call = (name: string, args: object, id: string): StreamChunk => ({
+      type: "block-end",
+      index: id.endsWith("B") ? 1 : 0,
+      block: {
+        type: "tool-call",
+        id: ToolCallId(id),
+        name,
+        arguments: JSON.stringify(args),
+      },
+    });
+    if (!child && count === 1) {
+      for (const suffix of ["A", "B"])
+        yield call(
+          "subagent",
+          { description: `analysis ${suffix}`, prompt: `CHILD_TASK_${suffix}` },
+          `spawn-${suffix}`,
+        );
+      yield { type: "finish", reason: { kind: "tool-calls" } };
+      return;
+    }
+    if (child && count === 1) {
+      this.childActive++;
+      this.maximum = Math.max(this.maximum, this.childActive);
+      try {
+        if (this.hold)
+          await new Promise<void>((_, reject) => {
+            const abort = () => {
+              this.aborted++;
+              reject(options.signal?.reason);
+            };
+            options.signal?.addEventListener("abort", abort, { once: true });
+            if (options.signal?.aborted) abort();
+          });
+        else await delay(50);
+      } finally {
+        this.childActive--;
+      }
+      yield call("mcp__windy__query", { source: key }, `query-${key}`);
+      yield { type: "finish", reason: { kind: "tool-calls" } };
+      return;
+    }
+    if (child && count === 2) {
+      const parent = /PARENT_ID:([^\s]+)/.exec(text)?.[1] ?? "parent";
+      yield call(
+        "send_message",
+        { agent_id: parent, message: `RESULT_${key.toUpperCase()}` },
+        `report-${key}`,
+      );
+      yield { type: "finish", reason: { kind: "tool-calls" } };
+      return;
+    }
+    yield {
+      type: "block-end",
+      index: 0,
+      block: {
+        type: "text",
+        text: child
+          ? "分析完成"
+          : text.includes("RESULT_A") && text.includes("RESULT_B")
+            ? "汇总 A+B"
+            : "等待分析",
+      },
+    };
+    yield { type: "finish", reason: { kind: "stop" } };
+  }
+}
+export async function harness(
+  model: SyntheticModel,
+  policy = {},
+  seeded = false,
+) {
+  const directory = await mkdtemp(join(tmpdir(), "windy-subagents-"));
+  const ctx = new Context();
+  const fibers: Array<{ dispose(): Promise<void> }> = [];
+  for (const plugin of [
+    LlmRuntime,
+    SessionStore,
+    SessionProjections,
+    AgentRegistry,
+    LocalFileSystem,
+    WorkingDirectory,
+  ])
+    fibers.push(await ctx.plugin(plugin));
+  fibers.push(
+    await ctx.plugin(SystemPrompt, {
+      includeHarnessIdentity: false,
+      includeRuntimeContext: false,
+    }),
+  );
+  fibers.push(await ctx.plugin(ToolRuntime));
+  fibers.push(await ctx.plugin(NativeToolExecutor));
+  fibers.push(
+    await ctx.plugin(AgentLoop, { maxParallelToolCalls: 2, agents: [] }),
+  );
+  fibers.push(
+    await ctx.plugin(Persistence, { root: directory, compression: "none" }),
+  );
+  fibers.push(
+    await ctx.plugin(Subagents, { maxDepth: 1, maxActiveSubagents: 2 }),
+  );
+  fibers.push(await ctx.plugin(Spawn));
+  fibers.push(await ctx.plugin(Delegate, { provider: "spawn", maxDepth: 1 }));
+  fibers.push(await ctx.plugin(Control));
+  ctx.provide("sessionController", {
+    cancel(request: { sessionId: string }) {
+      ctx.agents.get(SessionId(request.sessionId))?.cancel({ kind: "user" });
+      return { accepted: true };
+    },
+  } as never);
+  fibers.push(await ctx.plugin(Policy, policy));
+  for (const fiber of fibers)
+    await (fiber as { await?(): Promise<void> }).await?.();
+
+  ctx.llm.registerAdapter(["test"], model);
+  const mcp = parallelMcpFixture();
+  const mcpFiber = ctx.plugin(Mcp, mcp.config);
+  await mcpFiber.await();
+  fibers.push(mcpFiber);
+  const handle = await ctx.agents.create({
+    sessionId: SessionId("parent"),
+    ...(seeded
+      ? {
+          seed: [],
+          inheritedEventCount: SessionLogOffset(0),
+          meta: { parentSession: SessionId("closed-source"), isSeeded: true },
+        }
+      : {}),
+    agentOptions: { provider: "test", model: "synthetic" },
+  });
+  let output = "";
+  ctx.on("session/event", (session, event) => {
+    if (session.id === "parent" && event.type === "assistant/message")
+      output += event.data.message.content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("");
+  });
+  return {
+    ctx,
+    handle,
+    queries: mcp.queries,
+    checks: mcp.checks,
+    output: () => output,
+    async close() {
+      await handle.dispose();
+      for (const fiber of fibers.reverse()) await fiber.dispose();
+      mcp.close();
+      await rm(directory, { recursive: true, force: true });
+    },
+    start() {
+      handle.agent.followup({
+        id: MessageId("human"),
+        role: "user",
+        source: { kind: "user" },
+        content: [{ type: "text", text: "请并行分析并汇总" }],
+      });
+    },
+  };
+}

package/template/apps/agent-server/native/parallel-mcp-fixture.ts

@@ -0,0 +1,97 @@
+import { createBoundary } from "./boundary.js";
+import type { NativeWorker, WorkbenchManager } from "./manager.js";
+
+/** Synthetic product, real boundary + official MCP client. Never reads business data. */
+export function parallelMcpFixture() {
+  const previous = process.env.AI_TOOL_HOST_URL;
+  const queries: string[] = [];
+  let checks = 0;
+  const worker: Pick<
+    NativeWorker,
+    "authority" | "controller" | "admissionController"
+  > = {
+    authority: {
+      actorId: "fixture-user",
+      session: "p".repeat(43),
+      publicOrigin: "http://fixture.local",
+    },
+    controller: new AbortController(),
+    admissionController: new AbortController(),
+  };
+  const manager = {
+    byToken: (token: string) => (token === "w".repeat(43) ? worker : undefined),
+    current: async () => {
+      checks++;
+      return !worker.controller.signal.aborted;
+    },
+  } as unknown as WorkbenchManager;
+  const boundary = createBoundary({
+    manager,
+    completion: async () => new Response(null, { status: 500 }),
+  });
+  const server = Bun.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    async fetch(request) {
+      if (new URL(request.url).pathname.startsWith("/internal/boundary"))
+        return boundary(request);
+      if (request.method !== "POST") return new Response(null, { status: 405 });
+      if (
+        request.headers.get("authorization") !==
+        `Bearer ${worker.authority.session}`
+      )
+        return new Response(null, { status: 401 });
+      const body = await request.json();
+      if (body.id === undefined) return new Response(null, { status: 202 });
+      let result: unknown = {};
+      if (body.method === "initialize")
+        result = {
+          protocolVersion: body.params.protocolVersion,
+          capabilities: { tools: {} },
+          serverInfo: { name: "synthetic-windy", version: "1" },
+        };
+      if (body.method === "tools/list")
+        result = {
+          tools: [
+            {
+              name: "query",
+              description: "Synthetic actor-authorized read-only query",
+              inputSchema: {
+                type: "object",
+                properties: { source: { type: "string" } },
+                required: ["source"],
+              },
+            },
+          ],
+        };
+      if (body.method === "tools/call") {
+        queries.push(body.params.arguments.source);
+        result = {
+          content: [
+            { type: "text", text: `data-${body.params.arguments.source}` },
+          ],
+        };
+      }
+      return Response.json({ jsonrpc: "2.0", id: body.id, result });
+    },
+  });
+  process.env.AI_TOOL_HOST_URL = `http://127.0.0.1:${server.port}`;
+  return {
+    queries,
+    checks: () => checks,
+    config: {
+      transport: "streamable-http" as const,
+      serverName: "windy",
+      url: `http://127.0.0.1:${server.port}/internal/boundary/mcp`,
+      headers: { authorization: `Bearer ${"w".repeat(43)}` },
+      failOnStartupError: true,
+      toolCallTimeoutMs: 2000,
+    },
+    close() {
+      worker.controller.abort();
+      server.stop(true);
+      if (previous === undefined) delete process.env.AI_TOOL_HOST_URL;
+      else process.env.AI_TOOL_HOST_URL = previous;
+    },
+  };
+}