create-windy 0.8.3 → 0.9.1

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

@@ -0,0 +1,91 @@
+import { expect, test } from "bun:test";
+import type { DshHostConfiguration } from "../host-contracts.js";
+import { defaultHostFixture } from "./host-test-fixture.js";
+import { nativeProfile } from "./profile.js";
+import { hostPresetId, hostReplacements } from "./host-profile.js";
+
+const config = {
+  appRoot: "/app/agent",
+  gateUrl: "http://127.0.0.1:8080/internal/boundary",
+  model: "synthetic",
+  contextWindow: 32768,
+  maxOutputTokens: 4096,
+};
+
+test("an existing deployment preset remains consistent across registry, handoff and child agents", () => {
+  const rows = nativeProfile(config, {
+    ...defaultHostFixture,
+    presetId: "sharp",
+    skillDirectories: ["project/skills"],
+    plugins: [
+      {
+        key: "business-sessions",
+        path: "project/business-sessions/index.mjs",
+        replaces: ["session-controller"],
+      },
+    ],
+  });
+  expect(rows).toContainEqual({ id: "session-controller", disabled: true });
+  expect(
+    rows.find((row) => "id" in row && row.id === "tool-subagent"),
+  ).toMatchObject({ config: { agentPreset: "sharp" } });
+  const inserted = rows.flatMap((row) => ("insert" in row ? row.insert : []));
+  expect(
+    inserted.find((row) => row?.id === "windy-agent-preset-registry"),
+  ).toMatchObject({ config: { default: "sharp" } });
+  expect(inserted.find((row) => row?.id === "windy-access")).toMatchObject({
+    config: { presetId: "sharp" },
+  });
+  expect(inserted.find((row) => row?.id === "preset-sharp")).toMatchObject({
+    config: { id: "sharp" },
+  });
+  expect(
+    inserted.find((row) => row?.id === "project-business-sessions"),
+  ).toMatchObject({ name: "/app/agent/project/business-sessions/index.mjs" });
+  expect(
+    inserted.find((row) => row?.id === "windy-skill-library"),
+  ).toMatchObject({
+    config: { extraDefaultSkillDirs: ["/app/agent/project/skills"] },
+  });
+});
+
+test("project service replacement cannot disable model, authorization or budget owners", () => {
+  expect(hostPresetId(defaultHostFixture)).toBe("windy");
+  expect(hostReplacements(defaultHostFixture)).toEqual([]);
+  for (const value of [
+    { presetId: "../escape" },
+    { plugins: [{ key: "unsafe", path: "/external/plugin.mjs" }] },
+    { plugins: [{ key: "unsafe", path: "../plugin.mjs" }] },
+    {
+      plugins: [
+        { key: "unsafe", path: "project/plugin.mjs", replaces: ["agent-loop"] },
+      ],
+    },
+    {
+      plugins: [
+        { key: "same", path: "project/one.mjs" },
+        { key: "same", path: "project/two.mjs" },
+      ],
+    },
+    {
+      plugins: [
+        {
+          key: "one",
+          path: "project/one.mjs",
+          replaces: ["session-controller"],
+        },
+        {
+          key: "two",
+          path: "project/two.mjs",
+          replaces: ["session-controller"],
+        },
+      ],
+    },
+  ])
+    expect(() =>
+      nativeProfile(config, {
+        ...defaultHostFixture,
+        ...value,
+      } as DshHostConfiguration),
+    ).toThrow();
+});

package/template/apps/agent-server/native/host-profile.ts

@@ -0,0 +1,33 @@
+import type { DshHostConfiguration } from "../host-contracts.js";
+
+export function hostPresetId(host: DshHostConfiguration): string {
+  const id = host.presetId ?? "windy";
+  if (!/^[a-z][a-z0-9-]{0,63}$/.test(id))
+    throw new Error("Invalid deployment preset identity");
+  return id;
+}
+
+export function hostReplacements(host: DshHostConfiguration): string[] {
+  const keys = new Set<string>();
+  const replacements = new Set<string>();
+  for (const plugin of host.plugins) {
+    if (!/^[a-z][a-z0-9-]{0,63}$/.test(plugin.key) || keys.has(plugin.key))
+      throw new Error("Duplicate or invalid project plugin key");
+    keys.add(plugin.key);
+    if (
+      !plugin.path ||
+      plugin.path.startsWith("/") ||
+      plugin.path.includes("\\") ||
+      plugin.path
+        .split("/")
+        .some((part) => !part || part === "." || part === "..")
+    )
+      throw new Error("Invalid project plugin path");
+    for (const replaced of plugin.replaces ?? []) {
+      if (replaced !== "session-controller" || replacements.has(replaced))
+        throw new Error("Unsupported or duplicate project service replacement");
+      replacements.add(replaced);
+    }
+  }
+  return [...replacements];
+}

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

@@ -0,0 +1,13 @@
+import type { DshHostConfiguration } from "../host-contracts.js";
+
+/** Explicit platform defaults; downstream project composition may override these. */
+export const defaultHostFixture: DshHostConfiguration = {
+  presetId: "windy",
+  assistantName: "Windy Agent",
+  assistantDescription: "处理授权资料、查询业务信息并交付可核验的工作成果。",
+  workspaceLabel: "我的工作区",
+  instructions: [],
+  skillDirectories: [],
+  plugins: [],
+  boundaryRoutes: [],
+};

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

@@ -0,0 +1,129 @@
+import { authorityFrom } from "./config.js";
+import { boundedBody, productOrigin } from "./boundary.js";
+import { WorkbenchManager } from "./manager.js";
+import { nativeRequest } from "./request.js";
+import { workerTransportSignal } from "./lifecycle.js";
+import {
+  WorkbenchSessionConflict,
+  sessionConflictResponse,
+} from "./session-conflict.js";
+import {
+  isWorkbenchAuthorizationUnavailable,
+  authorizationUnavailableResponse,
+} from "./authorization.js";
+
+export function workerPath(raw: string): string {
+  const url = new URL(raw);
+  const path = url.pathname.slice("/internal/workbench".length) || "/";
+  const decoded = decodeURIComponent(path);
+  if (
+    decoded.includes("\\") ||
+    decoded.startsWith("//") ||
+    decoded.split("/").includes("..") ||
+    decoded.startsWith("/windy/internal-") ||
+    decoded === "/connect"
+  )
+    throw new Error("INVALID_NATIVE_PATH");
+  return `${path}${url.search}`;
+}
+
+async function handleWorkbenchHttp(
+  request: Request,
+  manager: WorkbenchManager,
+): Promise<Response> {
+  const authority = authorityFrom(request);
+  if (!(await manager.authorizeAuthority(authority, request.signal)))
+    return new Response(null, { status: 401 });
+  const path = workerPath(request.url);
+  if (path === "/windy/branding") {
+    const response = await fetch(`${productOrigin()}/api/platform/branding`, {
+      redirect: "error",
+      signal: request.signal,
+    });
+    return new Response(response.body, {
+      status: response.status,
+      headers: {
+        "content-type": "application/json",
+        "cache-control": "no-store",
+      },
+    });
+  }
+  const worker = await manager.get(authority);
+  if (!(await manager.current(worker)))
+    return new Response(null, { status: 401 });
+  const headers = new Headers({
+    host: new URL(authority.publicOrigin).host,
+    origin: authority.publicOrigin,
+    cookie: worker.cookie,
+  });
+  for (const key of ["content-type", "accept", "range", "if-none-match"])
+    if (request.headers.has(key)) headers.set(key, request.headers.get(key)!);
+  const response = await nativeRequest(
+    `http://127.0.0.1:${worker.port}${path}`,
+    {
+      method: request.method,
+      headers,
+      signal: AbortSignal.any([request.signal, workerTransportSignal(worker)]),
+      ...(request.body
+        ? { body: await boundedBody(request, 64 * 1024 * 1024) }
+        : {}),
+    },
+  );
+  const resultHeaders = new Headers(response.headers);
+  resultHeaders.delete("set-cookie");
+  resultHeaders.delete("content-length");
+  resultHeaders.delete("content-encoding");
+  resultHeaders.set("cache-control", "no-store");
+  // Native launch-token/connect redirects never reach the product browser.
+  if (response.status >= 300 && response.status < 400)
+    return Response.json(
+      { error: "WORKBENCH_AUTHENTICATION_FAILED" },
+      { status: 502 },
+    );
+  return new Response(response.body, {
+    status: response.status,
+    headers: resultHeaders,
+  });
+}
+
+export async function workbenchHttp(
+  request: Request,
+  manager: WorkbenchManager,
+): Promise<Response> {
+  try {
+    return await handleWorkbenchHttp(request, manager);
+  } catch (error) {
+    if (error instanceof WorkbenchSessionConflict)
+      return sessionConflictResponse(error);
+    if (isWorkbenchAuthorizationUnavailable(error))
+      return authorizationUnavailableResponse();
+    throw error;
+  }
+}
+
+/** Internal-token protected by the coordinator; returns no worker/session data. */
+export async function workbenchHandshake(
+  request: Request,
+  manager: WorkbenchManager,
+): Promise<Response> {
+  if (request.method !== "GET" || new URL(request.url).search)
+    return new Response(null, { status: 404 });
+  try {
+    const authority = authorityFrom(request);
+    if (!(await manager.authorizeAuthority(authority, request.signal)))
+      return new Response(null, { status: 401 });
+    const worker = await manager.get(authority);
+    if (!(await manager.current(worker)))
+      return new Response(null, { status: 401 });
+    return new Response(null, {
+      status: 204,
+      headers: { "cache-control": "no-store" },
+    });
+  } catch (error) {
+    if (error instanceof WorkbenchSessionConflict)
+      return sessionConflictResponse(error);
+    if (isWorkbenchAuthorizationUnavailable(error))
+      return authorizationUnavailableResponse();
+    throw error;
+  }
+}

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

@@ -0,0 +1,285 @@
+import { expect, test } from "bun:test";
+import { EventEmitter } from "node:events";
+import type { ChildProcess } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { WorkbenchManager, type NativeWorker } from "./manager.js";
+import { actorKey } from "./config.js";
+import { workerTransportSignal } from "./lifecycle.js";
+import {
+  authorizeWorkbench,
+  WorkbenchAuthorizationUnavailable,
+} from "./authorization.js";
+import { createBoundary } from "./boundary.js";
+import { workbenchHttp } from "./http.js";
+
+async function fixtureNativeWorker(authorize: () => Promise<boolean>) {
+  const home = await mkdtemp(join(tmpdir(), "windy-lifecycle-"));
+  const manager = new WorkbenchManager({
+    gateOrigin: "http://synthetic.invalid",
+    authorize,
+  });
+  const authority = {
+    actorId: "synthetic-user",
+    session: "s".repeat(43),
+    publicOrigin: "http://synthetic.invalid",
+  };
+  const child = Object.assign(new EventEmitter(), {
+    exitCode: 0,
+    signalCode: null,
+  }) as unknown as ChildProcess;
+  const worker: NativeWorker = {
+    uid: 20000,
+    key: actorKey(authority.actorId),
+    authority,
+    token: "t".repeat(43),
+    port: 0,
+    cookie: "synthetic=1",
+    child,
+    home,
+    controller: new AbortController(),
+    admissionController: new AbortController(),
+  };
+  manager.workers.set(worker.key, worker);
+  return {
+    manager,
+    worker,
+    async close() {
+      await manager.close();
+      await rm(home, { recursive: true, force: true });
+    },
+  };
+}
+
+function boundaryRequest(worker: NativeWorker, path = "/v1/chat/completions") {
+  return new Request(`http://synthetic.invalid/internal/boundary${path}`, {
+    method: "POST",
+    headers: { authorization: `Bearer ${worker.token}` },
+    body: "{}",
+  });
+}
+
+function httpRequest(worker: NativeWorker) {
+  return new Request("http://synthetic.invalid/internal/workbench/", {
+    headers: {
+      "x-windy-actor-id": worker.authority.actorId,
+      "x-windy-product-session": worker.authority.session,
+      "x-windy-public-origin": worker.authority.publicOrigin,
+    },
+  });
+}
+
+for (const scenario of ["503", "network"] as const) {
+  test(`${scenario} preserves worker but invalidates transports until fresh recovery`, async () => {
+    let healthy = false;
+    const fixture = await fixtureNativeWorker(() =>
+      authorizeWorkbench(
+        fixture.worker.authority,
+        fixture.worker.controller.signal,
+        {
+          productOrigin: "http://synthetic-product.invalid",
+          fetcher: async () => {
+            if (healthy)
+              return Response.json({
+                actor: { id: fixture.worker.authority.actorId, type: "user" },
+              });
+            if (scenario === "network")
+              throw new TypeError("synthetic network failure");
+            return new Response(null, { status: 503 });
+          },
+        },
+      ),
+    );
+    try {
+      const { manager, worker } = fixture;
+      const oldTransport = workerTransportSignal(worker);
+      await expect(manager.current(worker)).rejects.toBeInstanceOf(
+        WorkbenchAuthorizationUnavailable,
+      );
+      expect(manager.workers.get(worker.key)).toBe(worker);
+      expect(worker.controller.signal.aborted).toBe(false);
+      expect(worker.admissionController.signal.aborted).toBe(true);
+      expect(oldTransport.aborted).toBe(true);
+      await manager.inspect(worker);
+      expect(worker.controller.signal.aborted).toBe(false);
+      healthy = true;
+      expect(await manager.current(worker)).toBe(true);
+      expect(await manager.get(worker.authority)).toBe(worker);
+      expect(workerTransportSignal(worker).aborted).toBe(false);
+      expect(oldTransport.aborted).toBe(true);
+    } finally {
+      await fixture.close();
+    }
+  });
+}
+
+for (const status of [401, 403]) {
+  test(`confirmed ${status} denial stops and removes the worker`, async () => {
+    const fixture = await fixtureNativeWorker(() =>
+      authorizeWorkbench(
+        fixture.worker.authority,
+        fixture.worker.controller.signal,
+        {
+          productOrigin: "http://synthetic-product.invalid",
+          fetcher: async () => new Response(null, { status }),
+        },
+      ),
+    );
+    try {
+      expect(await fixture.manager.current(fixture.worker)).toBe(false);
+      expect(fixture.worker.controller.signal.aborted).toBe(true);
+      expect(fixture.worker.admissionController.signal.aborted).toBe(true);
+      expect(fixture.manager.workers.has(fixture.worker.key)).toBe(false);
+    } finally {
+      await fixture.close();
+    }
+  });
+}
+
+test("concurrent current and inspect share in-flight authorization, never cached success", async () => {
+  let calls = 0;
+  const gate = Promise.withResolvers<boolean>();
+  const fixture = await fixtureNativeWorker(async () => {
+    calls++;
+    return calls === 1 ? gate.promise : true;
+  });
+  try {
+    const first = fixture.manager.current(fixture.worker);
+    const second = fixture.manager.current(fixture.worker);
+    const poll = fixture.manager.inspect(fixture.worker);
+    const duplicatePoll = fixture.manager.inspect(fixture.worker);
+    expect(calls).toBe(1);
+    gate.resolve(true);
+    expect(await first).toBe(true);
+    expect(await second).toBe(true);
+    await Promise.all([poll, duplicatePoll]);
+    expect(calls).toBe(1);
+    expect(await fixture.manager.current(fixture.worker)).toBe(true);
+    expect(calls).toBe(2);
+  } finally {
+    await fixture.close();
+  }
+});
+
+test("quota is enforced even when authorization is temporarily unavailable", async () => {
+  const fixture = await fixtureNativeWorker(async () => {
+    throw new WorkbenchAuthorizationUnavailable("network");
+  });
+  try {
+    fixture.manager.config.workspaceBytes = 1;
+    await writeFile(
+      join(fixture.worker.home, "synthetic-quota.txt"),
+      "over-quota",
+    );
+    await fixture.manager.inspect(fixture.worker);
+    expect(fixture.worker.controller.signal.aborted).toBe(true);
+    expect(fixture.manager.workers.has(fixture.worker.key)).toBe(false);
+  } finally {
+    await fixture.close();
+  }
+});
+
+test("HTTP, MCP and model requests return 503 without forwarding on initial unavailable admission", async () => {
+  const fixture = await fixtureNativeWorker(async () => {
+    throw new WorkbenchAuthorizationUnavailable("upstream_status", 503);
+  });
+  const originalFetch = globalThis.fetch;
+  let forwarded = 0,
+    completions = 0;
+  // Every admission is injected above; any global fetch here would be a business forward.
+  globalThis.fetch = Object.assign(async () => {
+    forwarded++;
+    return new Response("unexpected");
+  }, originalFetch);
+  try {
+    const boundary = createBoundary({
+      manager: fixture.manager,
+      completion: async () => {
+        completions++;
+        return new Response("unexpected");
+      },
+    });
+    const responses = [
+      await workbenchHttp(httpRequest(fixture.worker), fixture.manager),
+      await boundary(boundaryRequest(fixture.worker, "/mcp")),
+      await boundary(boundaryRequest(fixture.worker)),
+    ];
+    for (const response of responses) {
+      expect(response.status).toBe(503);
+      expect(response.headers.get("retry-after")).toBe("2");
+    }
+    expect(forwarded).toBe(0);
+    expect(completions).toBe(0);
+    expect(fixture.worker.controller.signal.aborted).toBe(false);
+  } finally {
+    globalThis.fetch = originalFetch;
+    await fixture.close();
+  }
+});
+
+test("HTTP second authorization gate returns 503 before native transport", async () => {
+  let calls = 0;
+  const fixture = await fixtureNativeWorker(async () => {
+    if (++calls === 1) return true;
+    throw new WorkbenchAuthorizationUnavailable("network");
+  });
+  try {
+    expect(
+      (await workbenchHttp(httpRequest(fixture.worker), fixture.manager))
+        .status,
+    ).toBe(503);
+    expect(calls).toBe(2);
+    expect(fixture.worker.controller.signal.aborted).toBe(false);
+  } finally {
+    await fixture.close();
+  }
+});
+
+test("queued model admission fails closed with 503 after temporary loss, without second completion", async () => {
+  const oldGlobal = process.env.AI_PROVIDER_MAX_CONCURRENT_RUNS;
+  const oldNative = process.env.AGENT_DSH_MAX_ACTIVE_RUNS;
+  let healthy = true,
+    calls = 0,
+    completions = 0;
+  const queuedAdmission = Promise.withResolvers<void>();
+  const fixture = await fixtureNativeWorker(async () => {
+    calls++;
+    if (calls === 3) queuedAdmission.resolve();
+    if (!healthy)
+      throw new WorkbenchAuthorizationUnavailable("upstream_status", 503);
+    return true;
+  });
+  let first: Response | undefined;
+  try {
+    process.env.AI_PROVIDER_MAX_CONCURRENT_RUNS = "2";
+    process.env.AGENT_DSH_MAX_ACTIVE_RUNS = "2";
+    const boundary = createBoundary({
+      manager: fixture.manager,
+      completion: async () => {
+        completions++;
+        return new Response(new ReadableStream({ start() {} }));
+      },
+    });
+    first = await boundary(boundaryRequest(fixture.worker));
+    const queued = boundary(boundaryRequest(fixture.worker));
+    await queuedAdmission.promise;
+    // Allow initial admission's promise to settle and the request to join the FIFO.
+    await Bun.sleep(0);
+    healthy = false;
+    await first.body?.cancel();
+    expect((await queued).status).toBe(503);
+    expect(completions).toBe(1);
+    expect(calls).toBe(4);
+    expect(fixture.worker.controller.signal.aborted).toBe(false);
+    expect(fixture.worker.admissionController.signal.aborted).toBe(true);
+  } finally {
+    await first?.body?.cancel().catch(() => {});
+    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;
+    await fixture.close();
+  }
+});

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

@@ -0,0 +1,136 @@
+import type { WorkbenchAuthority } from "./config.js";
+import type { NativeWorker } from "./manager.js";
+import { diskUsage } from "./storage.js";
+import { WorkbenchAuthorizationUnavailable } from "./authorization.js";
+
+export type WorkerStopReason =
+  | "authorization_denied"
+  | "session_replaced"
+  | "service_shutdown"
+  | "process_exit"
+  | "startup_failed"
+  | "quota_exceeded"
+  | "storage_check_failed"
+  | "maintenance_failed"
+  | "explicit_stop";
+
+/** Only safe operational categories are logged; never identities, tokens or raw errors. */
+export function workerLifecycleEvent(
+  worker: NativeWorker,
+  event: string,
+  reason?: string,
+) {
+  console.info(
+    JSON.stringify({
+      level: "info",
+      timestamp: new Date().toISOString(),
+      component: "agent-native",
+      event,
+      retentionClass: "operational",
+      pid: worker.child.pid,
+      ...(reason ? { reason } : {}),
+    }),
+  );
+}
+
+export function workerTransportSignal(worker: NativeWorker): AbortSignal {
+  return AbortSignal.any([
+    worker.controller.signal,
+    worker.admissionController.signal,
+  ]);
+}
+
+/** Share only in-flight checks. Every later request obtains fresh authorization. */
+export class WorkerLifecycle {
+  private readonly checks = new WeakMap<NativeWorker, Promise<boolean>>();
+  private readonly polls = new WeakMap<NativeWorker, Promise<void>>();
+  constructor(
+    private readonly authorize: (
+      authority: WorkbenchAuthority,
+      signal: AbortSignal,
+    ) => Promise<boolean>,
+    private readonly stop: (
+      worker: NativeWorker,
+      reason: WorkerStopReason,
+    ) => Promise<void>,
+  ) {}
+
+  current(worker: NativeWorker): Promise<boolean> {
+    if (worker.controller.signal.aborted) return Promise.resolve(false);
+    const pending = this.checks.get(worker);
+    if (pending) return pending;
+    const check = this.check(worker);
+    this.checks.set(worker, check);
+    void check.then(
+      () => this.checks.delete(worker),
+      () => this.checks.delete(worker),
+    );
+    return check;
+  }
+
+  private async check(worker: NativeWorker): Promise<boolean> {
+    let allowed: boolean;
+    try {
+      allowed = await this.authorize(
+        worker.authority,
+        worker.controller.signal,
+      );
+    } catch (error) {
+      if (worker.controller.signal.aborted) return false;
+      const unavailable =
+        error instanceof WorkbenchAuthorizationUnavailable
+          ? error
+          : new WorkbenchAuthorizationUnavailable("network");
+      if (!worker.admissionController.signal.aborted) {
+        worker.admissionController.abort(unavailable);
+        workerLifecycleEvent(
+          worker,
+          "worker.authorization.unavailable",
+          unavailable.status
+            ? `${unavailable.reason}:${unavailable.status}`
+            : unavailable.reason,
+        );
+      }
+      throw unavailable;
+    }
+    if (worker.controller.signal.aborted) return false;
+    if (!allowed) {
+      await this.stop(worker, "authorization_denied");
+      return false;
+    }
+    if (worker.admissionController.signal.aborted) {
+      worker.admissionController = new AbortController();
+      workerLifecycleEvent(worker, "worker.authorization.recovered");
+    }
+    return true;
+  }
+
+  inspect(worker: NativeWorker, quota: number): Promise<void> {
+    const existing = this.polls.get(worker);
+    if (existing) return existing;
+    const pending = this.poll(worker, quota);
+    this.polls.set(worker, pending);
+    void pending.then(
+      () => this.polls.delete(worker),
+      () => this.polls.delete(worker),
+    );
+    return pending;
+  }
+
+  private async poll(worker: NativeWorker, quota: number) {
+    if (worker.controller.signal.aborted) return;
+    try {
+      if (!(await this.current(worker))) return;
+    } catch (error) {
+      if (!(error instanceof WorkbenchAuthorizationUnavailable)) throw error;
+      // Admission failure closes transports, but quota remains independently enforced.
+    }
+    if (worker.controller.signal.aborted) return;
+    try {
+      if ((await diskUsage(worker.home, quota)) > quota)
+        await this.stop(worker, "quota_exceeded");
+    } catch {
+      await this.stop(worker, "storage_check_failed");
+    }
+  }
+}