create-windy 0.8.2 → 0.9.1

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

@@ -0,0 +1,246 @@
+import WebSocket from "ws";
+import { expect, test } from "bun:test";
+import {
+  createDshWebProxy,
+  isDshWorkbenchPath,
+  type DshWebSocketState,
+} from "../../../web/dsh-workbench-proxy.js";
+import {
+  actorId,
+  dshFixture,
+  internalToken,
+} from "./dsh-workbench-test-support.js";
+
+function opened(socket: WebSocket): Promise<void> {
+  return new Promise((resolve, reject) => {
+    socket.addEventListener("open", () => resolve(), { once: true });
+    socket.addEventListener(
+      "error",
+      () => reject(new Error("Handshake rejected")),
+      { once: true },
+    );
+    setTimeout(() => reject(new Error("Handshake timeout")), 3_000).unref();
+  });
+}
+function frame(socket: WebSocket) {
+  return new Promise<WebSocket.MessageEvent>((resolve) =>
+    socket.addEventListener("message", resolve, { once: true }),
+  );
+}
+
+test.each([
+  { name: "configured HTTPS origin", publicOrigin: "https://windy.test" },
+  { name: "dynamic HTTP LAN origin", publicOrigin: null },
+])(
+  "real native HTTP and WebSocket cross both hops for $name and close after logout",
+  async ({ publicOrigin }) => {
+    const received: Request[] = [];
+    const coordinator = Bun.serve<{ actorId: string }>({
+      hostname: "127.0.0.1",
+      port: 0,
+      fetch(request, server) {
+        received.push(
+          new Request(request.url, {
+            method: request.method,
+            headers: new Headers(request.headers),
+          }),
+        );
+        if (
+          request.headers.get("authorization") !== `Bearer ${internalToken}` ||
+          request.headers.get("x-windy-actor-id") !== actorId ||
+          request.headers.has("cookie")
+        )
+          return new Response(null, { status: 403 });
+        if (new URL(request.url).pathname === "/internal/workbench-handshake")
+          return new Response(null, { status: 204 });
+        if (request.headers.get("upgrade") === "websocket") {
+          if (server.upgrade(request, { data: { actorId } })) return;
+          return new Response(null, { status: 400 });
+        }
+        return new Response(
+          '<html><head><base href="./"></head><body>native</body></html>',
+          {
+            headers: {
+              "content-type": "text/html",
+              "set-cookie": "native-secret=private",
+            },
+          },
+        );
+      },
+      websocket: {
+        message(socket, message) {
+          socket.send(message);
+        },
+      },
+    });
+    const previousOrigin = process.env.WINDY_PUBLIC_BASE_URL;
+    let fixture: Awaited<ReturnType<typeof dshFixture>>;
+    try {
+      if (publicOrigin === null) delete process.env.WINDY_PUBLIC_BASE_URL;
+      fixture = await dshFixture(
+        {
+          baseUrl: () => coordinator.url.origin,
+          fetcher: fetch,
+          authorizationIntervalMs: 25,
+        },
+        publicOrigin,
+      );
+    } finally {
+      if (previousOrigin === undefined)
+        delete process.env.WINDY_PUBLIC_BASE_URL;
+      else process.env.WINDY_PUBLIC_BASE_URL = previousOrigin;
+    }
+    fixture.app.listen({ hostname: "127.0.0.1", port: 0 });
+    const proxy = createDshWebProxy(fixture.app.server!.url.origin);
+    const web = Bun.serve<DshWebSocketState>({
+      hostname: "127.0.0.1",
+      port: 0,
+      websocket: proxy.websocket,
+      fetch(request, server) {
+        return isDshWorkbenchPath(new URL(request.url).pathname)
+          ? proxy.fetch(request, server)
+          : new Response("pairing", { status: 200 });
+      },
+    });
+    let socket: WebSocket | undefined;
+    try {
+      const browserOrigin = publicOrigin ?? "http://192.0.2.10:9746";
+      const headers = {
+        cookie: `windy.sid=${fixture.login.token}`,
+        host: new URL(browserOrigin).host,
+        origin: browserOrigin,
+        "x-windy-actor-id": "other-user",
+        "x-windy-public-origin": "https://forged.test",
+        "x-forwarded-host": "forged.test",
+        "x-forwarded-proto": "https",
+      };
+      const response = await fetch(new URL("/agent", web.url), { headers });
+      expect(response.status).toBe(200);
+      const html = await response.text();
+      expect(html).toContain("native");
+      expect(html).toContain('<base href="/agent/">');
+      expect(html).not.toContain('<base href="./">');
+      const base = new URL("/agent/", response.url);
+      expect(new URL("./assets/index.js", base).pathname).toBe(
+        "/agent/assets/index.js",
+      );
+      expect(new URL("api/remote.mux", base).pathname).toBe(
+        "/agent/api/remote.mux",
+      );
+      expect(response.headers.has("set-cookie")).toBe(false);
+      const pairing = await fetch(
+        new URL("/agent/connect?pairing=opaque", web.url),
+      );
+      expect(pairing.status).toBe(200);
+      await pairing.text();
+      const url = new URL("/agent/api/remote.mux", web.url);
+      url.protocol = "ws:";
+      const requestsBeforeDenials = received.length;
+      for (const deniedHeaders of [
+        { ...headers, origin: "https://evil.test" },
+        { ...headers, origin: "null" },
+        { ...headers, cookie: "" },
+      ]) {
+        const rejected = new WebSocket(url, { headers: deniedHeaders });
+        await expect(opened(rejected)).rejects.toThrow("Handshake rejected");
+        rejected.close();
+      }
+      expect(received).toHaveLength(requestsBeforeDenials);
+      socket = new WebSocket(url, { headers });
+      socket.binaryType = "arraybuffer";
+      await opened(socket);
+      const text = frame(socket);
+      socket.send(
+        JSON.stringify({
+          id: "request-1",
+          params: { text: "你好", nested: [1, true] },
+        }),
+      );
+      expect(JSON.parse((await text).data as string)).toEqual({
+        id: "request-1",
+        params: { text: "你好", nested: [1, true] },
+      });
+      const binary = frame(socket);
+      socket.send(new Uint8Array([0, 1, 127, 255]));
+      expect([...new Uint8Array((await binary).data as ArrayBuffer)]).toEqual([
+        0, 1, 127, 255,
+      ]);
+      expect(
+        received.some(
+          (request) =>
+            new URL(request.url).pathname ===
+            "/internal/workbench/api/remote.mux",
+        ),
+      ).toBe(true);
+      expect(
+        received.every(
+          (request) =>
+            request.headers.get("x-windy-product-session") ===
+              fixture.login.token &&
+            request.headers.get("x-windy-public-origin") === browserOrigin,
+        ),
+      ).toBe(true);
+      const closed = new Promise<WebSocket.CloseEvent>((resolve) =>
+        socket!.addEventListener("close", resolve, { once: true }),
+      );
+      const actor = await fixture.repository.resolveSessionActor(
+        fixture.login.session.tokenHash,
+        new Date(fixture.state.now),
+      );
+      await fixture.service.logout(fixture.login.token, actor!);
+      expect((await closed).code).toBe(1008);
+      const denied = await fetch(new URL("/agent/", web.url), {
+        headers,
+        redirect: "manual",
+      });
+      expect(denied.status).toBe(302);
+      expect(denied.headers.get("location")).toBe(
+        "/login?returnTo=%2Fagent%2F",
+      );
+      await denied.text();
+    } finally {
+      socket?.close();
+      const urls = [
+        web.url.href,
+        fixture.app.server!.url.href,
+        coordinator.url.href,
+      ];
+      // Bun 1.3.14 closes the listener immediately but its stop Promise may stay
+      // pending after a WebSocket close. Assert released listeners directly.
+      void web.stop(true);
+      void fixture.app.stop(true);
+      void coordinator.stop(true);
+      for (const url of urls)
+        await expect(
+          fetch(url, { signal: AbortSignal.timeout(1_000) }),
+        ).rejects.toThrow();
+    }
+  },
+  10_000,
+);
+
+test("real WebSocket rejects cross-origin or unauthenticated handshakes before contacting coordinator", async () => {
+  const fixture = await dshFixture();
+  fixture.app.listen({ hostname: "127.0.0.1", port: 0 });
+  try {
+    const url = new URL(
+      "/api/agent/native/api/remote.mux",
+      fixture.app.server!.url,
+    );
+    url.protocol = "ws:";
+    for (const headers of [
+      {
+        cookie: `windy.sid=${fixture.login.token}`,
+        origin: "https://evil.test",
+      },
+      { origin: "https://windy.test" },
+    ]) {
+      const socket = new WebSocket(url, { headers });
+      await expect(opened(socket)).rejects.toThrow("Handshake rejected");
+      socket.close();
+    }
+    expect(fixture.state.probes).toEqual([]);
+  } finally {
+    await fixture.app.stop(true);
+  }
+});

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

@@ -0,0 +1,272 @@
+import WebSocket from "ws";
+import type { RequestActor, RequestGuardContext } from "../guards.js";
+import type { RouteApp } from "../system/route-types.js";
+import type { DshProductSession } from "./dsh-workbench-session.js";
+import { preflightDshWorkbenchSocket } from "./dsh-workbench-handshake.js";
+import {
+  DSH_NATIVE_SOCKET,
+  DSH_NATIVE_REQUEST_TIMEOUT_SECONDS,
+  dshInternalHeaders,
+  dshInternalTarget,
+  dshJson,
+  type DshWorkbenchOptions,
+} from "./dsh-workbench-proxy.js";
+
+interface Socket {
+  readonly data: { readonly request: Request };
+  readonly raw: {
+    sendText(data: string): number;
+    sendBinary(data: Uint8Array): number;
+    close(code?: number, reason?: string): void;
+  };
+}
+interface SocketOptions {
+  beforeHandle(context: unknown): Promise<Response | undefined>;
+  open(socket: Socket): void;
+  message(socket: Socket, message: unknown): Promise<void>;
+  close(socket: Socket): void;
+}
+export type DshAuthorization = (
+  context: unknown,
+  method: string,
+  path: string,
+  websocket?: boolean,
+) => Promise<Response | (DshProductSession & { readonly actor: RequestActor })>;
+
+/** Uses Elysia's real Bun WebSocket carrier; no socket or credential is browser-selected. */
+export function registerDshWorkbenchSocket(input: {
+  app: RouteApp;
+  authorize: DshAuthorization;
+  publicOrigin(request: Request): string;
+  options: DshWorkbenchOptions;
+}): void {
+  const host = input.app as RouteApp & {
+    ws?: (path: string, options: SocketOptions) => unknown;
+  };
+  const states = new WeakMap<Request, Relay>();
+  const path = `/api${DSH_NATIVE_SOCKET}`;
+  if (!host.ws) {
+    input.app.get(DSH_NATIVE_SOCKET, async (raw) => {
+      const access = await input.authorize(raw, "GET", path, true);
+      return access instanceof Response
+        ? access
+        : dshJson({ error: "WEBSOCKET_REQUIRED" }, 426);
+    });
+    return;
+  }
+  host.ws(DSH_NATIVE_SOCKET, {
+    async beforeHandle(raw) {
+      const { request, guardContext, server } = raw as {
+        request: Request;
+        guardContext: RequestGuardContext;
+        server?: { timeout(request: Request, seconds: number): void };
+      };
+      if (states.has(request)) return;
+      server?.timeout(request, DSH_NATIVE_REQUEST_TIMEOUT_SECONDS);
+      const access = await input.authorize(raw, "GET", path, true);
+      if (access instanceof Response) return access;
+      try {
+        const target = dshInternalTarget(
+          input.options,
+          "/internal/workbench/api/remote.mux",
+        );
+        target.protocol = target.protocol === "https:" ? "wss:" : "ws:";
+        const headers = dshInternalHeaders(
+          input.options,
+          access,
+          input.publicOrigin(request),
+          request.headers,
+        );
+        const admission = await preflightDshWorkbenchSocket(
+          input.options,
+          request,
+          headers,
+        );
+        if (admission instanceof Response) return admission;
+        const upstream = new WebSocket(target, {
+          headers: headerRecord(headers),
+        });
+        const authorizationContext = {
+          guardContext,
+          request: new Request(request.url, {
+            method: request.method,
+            headers: new Headers(request.headers),
+          }),
+        };
+        const relay = new Relay(
+          upstream,
+          () => input.authorize(authorizationContext, "GET", path, true),
+          input.options.authorizationIntervalMs ?? 1_000,
+          admission.remainingMs,
+        );
+        states.set(request, relay);
+        await relay.ready;
+      } catch {
+        states.get(request)?.close();
+        states.delete(request);
+        return dshJson({ error: "AGENT_UNAVAILABLE" }, 503);
+      }
+    },
+    open(socket) {
+      states.get(socket.data.request)?.attach(socket);
+    },
+    async message(socket, message) {
+      await states.get(socket.data.request)?.send(message);
+    },
+    close(socket) {
+      states.get(socket.data.request)?.close();
+      states.delete(socket.data.request);
+    },
+  });
+}
+
+class Relay {
+  readonly ready: Promise<void>;
+  private client?: Socket;
+  private readonly pending: (string | Uint8Array)[] = [];
+  private pendingBytes = 0;
+  private closed = false;
+  private checking = false;
+  private authorization?: Promise<boolean>;
+  private readonly timer: ReturnType<typeof setInterval>;
+  private readonly startup: ReturnType<typeof setTimeout>;
+
+  constructor(
+    private readonly upstream: WebSocket,
+    private readonly authorize: () => Promise<
+      Response | (DshProductSession & { readonly actor: RequestActor })
+    >,
+    interval: number,
+    startupBudgetMs: number,
+  ) {
+    upstream.binaryType = "arraybuffer";
+    this.ready = new Promise((resolve, reject) => {
+      upstream.addEventListener("open", () => resolve(), { once: true });
+      upstream.addEventListener(
+        "error",
+        () => {
+          reject(new Error("Native socket unavailable"));
+          this.close();
+        },
+        { once: true },
+      );
+      upstream.addEventListener(
+        "close",
+        () => {
+          reject(new Error("Native socket closed"));
+          this.close();
+        },
+        { once: true },
+      );
+    });
+    upstream.addEventListener("message", (event) => {
+      const frame =
+        typeof event.data === "string"
+          ? event.data
+          : new Uint8Array(event.data as ArrayBuffer);
+      if (this.client) this.deliver(frame);
+      else {
+        this.pendingBytes +=
+          typeof frame === "string"
+            ? Buffer.byteLength(frame)
+            : frame.byteLength;
+        if (this.pendingBytes > 2_097_152 || this.pending.length >= 128)
+          return this.close(1013);
+        this.pending.push(frame);
+      }
+    });
+    this.timer = setInterval(() => void this.check(), Math.max(25, interval));
+    this.startup = setTimeout(() => {
+      if (!this.client) this.close();
+    }, startupBudgetMs);
+  }
+  attach(client: Socket) {
+    this.client = client;
+    clearTimeout(this.startup);
+    if (this.closed) return client.raw.close(1011, "Agent unavailable");
+    for (const frame of this.pending) this.deliver(frame);
+    this.pending.length = 0;
+    this.pendingBytes = 0;
+  }
+  private deliver(frame: string | Uint8Array) {
+    const result =
+      typeof frame === "string"
+        ? this.client?.raw.sendText(frame)
+        : this.client?.raw.sendBinary(frame);
+    if (result === 0) this.close(1013);
+  }
+  private allowed(): Promise<boolean> {
+    if (this.authorization) return this.authorization;
+    const authorization = this.checkAuthorization();
+    this.authorization = authorization;
+    void authorization.finally(() => {
+      this.authorization = undefined;
+    });
+    return authorization;
+  }
+  private async checkAuthorization(): Promise<boolean> {
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+    try {
+      const result = await Promise.race([
+        this.authorize(),
+        new Promise<never>((_resolve, reject) => {
+          timeout = setTimeout(
+            () => reject(new Error("Authorization timeout")),
+            3_000,
+          );
+        }),
+      ]);
+      if (!(result instanceof Response)) return true;
+    } catch {
+      /* Reauthorization failures close the transport. */
+    } finally {
+      clearTimeout(timeout);
+    }
+    this.close(1008);
+    return false;
+  }
+
+  private async check() {
+    if (this.closed || this.checking) return;
+    this.checking = true;
+    try {
+      await this.allowed();
+    } finally {
+      this.checking = false;
+    }
+  }
+  async send(message: unknown) {
+    if (this.closed || !(await this.allowed())) return;
+    if (
+      this.upstream.readyState !== WebSocket.OPEN ||
+      this.upstream.bufferedAmount > 8_388_608
+    )
+      return this.close(1013);
+    if (message instanceof Uint8Array || message instanceof ArrayBuffer)
+      this.upstream.send(message);
+    else
+      this.upstream.send(
+        typeof message === "string" ? message : JSON.stringify(message),
+      );
+  }
+  close(code = 1000) {
+    if (this.closed) return;
+    this.closed = true;
+    clearInterval(this.timer);
+    clearTimeout(this.startup);
+    this.pending.length = 0;
+    this.client?.raw.close(
+      code,
+      code === 1008 ? "Authorization expired" : "Agent disconnected",
+    );
+    this.upstream.close();
+  }
+}
+
+function headerRecord(headers: Headers): Record<string, string> {
+  const record: Record<string, string> = {};
+  headers.forEach((value, name) => {
+    record[name] = value;
+  });
+  return record;
+}

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

@@ -0,0 +1,158 @@
+import { Elysia } from "elysia";
+import { licenseVersionKey } from "@southwind-ai/shared";
+import { RepositoryActorResolver } from "../auth/actor-resolver.js";
+import { InMemoryAuthRepository } from "../auth/repository.js";
+import { AuthService } from "../auth/service.js";
+import { loadFoundationModules } from "../foundation.js";
+import { createServerRuntime } from "../runtime.js";
+import {
+  registerDshWorkbenchRoutes,
+  type DshWorkbenchOptions,
+} from "./dsh-workbench.js";
+
+export const actorId = "user-a";
+export const internalToken = "internal-test-token-with-32-characters";
+
+export async function dshFixture(
+  options: DshWorkbenchOptions = {},
+  publicOrigin: string | null = "https://windy.test",
+) {
+  const state = {
+    now: Date.now(),
+    permissions: ["system.agent.read", "system.agent-workbench.use"],
+    roles: [] as string[],
+    disabledFeature: "",
+    restricted: false,
+    probes: [] as Request[],
+    probe: (_request: Request): Response => Response.json({ ready: true }),
+  };
+  class MutableRoleRepository extends InMemoryAuthRepository {
+    override async resolveSessionActor(hash: string, now: Date) {
+      const actor = await super.resolveSessionActor(hash, now);
+      return actor
+        ? {
+            ...actor,
+            permissionKeys: [...state.permissions],
+            roleCodes: [...state.roles],
+          }
+        : undefined;
+    }
+  }
+  const repository = new MutableRoleRepository([
+    {
+      id: actorId,
+      username: "trial",
+      displayName: "Trial",
+      passwordHash: "test-password",
+      credentialState: "active",
+      status: "active",
+      roleCodes: [],
+      permissionKeys: state.permissions,
+    },
+  ]);
+  const service = new AuthService(repository, {
+    now: () => new Date(state.now),
+    sessionTtlSeconds: 36_000,
+    passwordHasher: {
+      hash: async (value) => value,
+      verify: async (hash, value) => hash === value,
+    },
+    auditWriter: { write: () => {} },
+  });
+  const login = await service.login("trial", "test-password");
+  if (!login.ok) throw new Error("Fixture login failed");
+  const resolver = new RepositoryActorResolver(repository, {
+    now: () => new Date(state.now),
+  });
+  const modules = loadFoundationModules();
+  const runtime = createServerRuntime(
+    {},
+    {
+      actorResolver: {
+        resolve: async (request) => {
+          const actor = await resolver.resolve(request);
+          return actor
+            ? {
+                ...actor,
+                permissionKeys: [...state.permissions],
+                roleCodes: [...state.roles],
+              }
+            : undefined;
+        },
+      },
+      featureCatalog: modules.flatMap(({ features }) => features),
+      featureResolver: {
+        resolve: (key) => {
+          const feature = modules
+            .flatMap(({ features }) => features)
+            .find((candidate) => candidate.key === key);
+          return feature
+            ? {
+                key,
+                enabled: feature.enabled && key !== state.disabledFeature,
+                visible: feature.visible,
+                allowedLicenseVersions: feature.allowedLicenseVersions,
+              }
+            : undefined;
+        },
+      },
+      licenseResolver: {
+        resolve: () => ({
+          status: state.restricted ? "expired" : "valid",
+          restricted: state.restricted,
+          versionKey: licenseVersionKey("advanced"),
+        }),
+      },
+    },
+  );
+  const app = new Elysia({ prefix: "/api" }).derive(async ({ request }) => ({
+    guardContext: await runtime.createGuardContext(request),
+  }));
+  registerDshWorkbenchRoutes({
+    app,
+    modules,
+    runtime,
+    authRepository: repository,
+    publicOrigin: publicOrigin ?? undefined,
+    options: {
+      now: () => state.now,
+      internalToken: () => internalToken,
+      baseUrl: () => "http://agent-runtime.test",
+      fetcher: async (input, init) => {
+        const request = new Request(input, init);
+        state.probes.push(request);
+        return state.probe(request);
+      },
+      ...options,
+    },
+  });
+  return {
+    app,
+    state,
+    service,
+    repository,
+    login,
+    runtime,
+    async request(
+      path = "/agent/workbench",
+      method = "GET",
+      init: RequestInit = {},
+    ): Promise<Response> {
+      const headers = new Headers({
+        cookie: `windy.sid=${login.token}`,
+        origin: "https://windy.test",
+        "content-type": "application/json",
+      });
+      new Headers(init.headers).forEach((value, key) =>
+        headers.set(key, value),
+      );
+      return app.handle(
+        new Request(`https://windy.test/api${path}`, {
+          ...init,
+          method,
+          headers,
+        }),
+      );
+    },
+  };
+}