create-windy 0.8.3 → 0.9.1

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

@@ -0,0 +1,59 @@
+import {
+  hashSessionToken,
+  readRequestSessionToken,
+} from "../auth/actor-resolver.js";
+import type { AuthRepository } from "../auth/repository.js";
+import type { RequestActor } from "../guards.js";
+export interface DshProductSession {
+  readonly actorId: string;
+  readonly token: string;
+  readonly expiresAt: string;
+}
+
+/** Reuse the actual product login; never create a second API-login session. */
+export async function currentDshProductSession(input: {
+  request: Request;
+  actorId: string;
+  repository: AuthRepository;
+  cookieName: string;
+  now: number;
+}): Promise<
+  (DshProductSession & { readonly actor: RequestActor }) | undefined
+> {
+  if (
+    /^Bearer\s+(?:bax_|car_)/i.test(
+      input.request.headers.get("authorization") ?? "",
+    )
+  )
+    return;
+  const token = readRequestSessionToken(input.request, input.cookieName);
+  if (!token || !/^[A-Za-z0-9_-]{43}$/.test(token)) return;
+  const hash = hashSessionToken(token);
+  const session = await input.repository.findSessionByTokenHash(hash);
+  if (
+    !session ||
+    session.userId !== input.actorId ||
+    session.status !== "active" ||
+    session.revokedAt ||
+    session.expiresAt.getTime() <= input.now ||
+    session.issuedAt.getTime() > input.now
+  )
+    return;
+  const actor = await input.repository.resolveSessionActor(
+    hash,
+    new Date(input.now),
+  );
+  if (
+    !actor ||
+    actor.type !== "user" ||
+    actor.id !== session.userId ||
+    actor.credentialState !== "active"
+  )
+    return;
+  return {
+    actorId: actor.id,
+    token,
+    expiresAt: session.expiresAt.toISOString(),
+    actor,
+  };
+}

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

@@ -0,0 +1,115 @@
+import { expect, test } from "bun:test";
+import WebSocket from "ws";
+import { dshFixture } from "./dsh-workbench-test-support.js";
+
+function opened(socket: WebSocket): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error("Socket timeout")), 3000);
+    socket.once("open", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+    socket.once("error", () => {
+      clearTimeout(timer);
+      reject(new Error("Socket rejected"));
+    });
+  });
+}
+
+function exchange(socket: WebSocket, message: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error("Frame timeout")), 3000);
+    socket.once("message", (value) => {
+      clearTimeout(timer);
+      resolve(value.toString());
+    });
+    socket.send(message);
+  });
+}
+
+test("real WebSocket records one admission before preflight and keeps reauthorization unaudited", async () => {
+  let contacts = 0;
+  let assertAudit = () => {};
+  const coordinator = Bun.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    fetch(request, server) {
+      contacts++;
+      assertAudit();
+      if (request.headers.get("upgrade") === "websocket") {
+        if (server.upgrade(request)) return;
+        return new Response(null, { status: 400 });
+      }
+      return new Response(null, { status: 204 });
+    },
+    websocket: {
+      message(socket, message) {
+        socket.send(message);
+      },
+    },
+  });
+  const fixture = await dshFixture({
+    baseUrl: () => coordinator.url.origin,
+    fetcher: fetch,
+    authorizationIntervalMs: 25,
+  });
+  const audits = () =>
+    fixture.runtime.auditSink
+      .list()
+      .filter((event) => event.action === "agent.workbench.access");
+  assertAudit = () => expect(audits()).toHaveLength(1);
+  fixture.app.listen({ hostname: "127.0.0.1", port: 0 });
+  const url = new URL(
+    "/api/agent/native/api/remote.mux",
+    fixture.app.server!.url,
+  );
+  url.protocol = "ws:";
+  const socket = new WebSocket(url, {
+    headers: {
+      origin: "https://windy.test",
+      cookie: `windy.sid=${fixture.login.token}`,
+    },
+  });
+  try {
+    await opened(socket);
+    expect(await exchange(socket, "first")).toBe("first");
+    expect(await exchange(socket, "reauthorize")).toBe("reauthorize");
+    expect(contacts).toBe(2);
+    expect(audits()).toHaveLength(1);
+    expect(audits()[0]?.metadata).toEqual({
+      kind: "websocket",
+      phase: "admission",
+    });
+    expect(JSON.stringify(audits())).not.toContain(fixture.login.token);
+  } finally {
+    socket.terminate();
+    void fixture.app.stop(true);
+    void coordinator.stop(true);
+  }
+});
+
+test("WebSocket audit failure rejects before preflight can create a worker", async () => {
+  const fixture = await dshFixture();
+  fixture.runtime.auditSink.recordCriticalEvent = async () => {
+    throw new Error("private audit persistence failure");
+  };
+  fixture.app.listen({ hostname: "127.0.0.1", port: 0 });
+  const url = new URL(
+    "/api/agent/native/api/remote.mux",
+    fixture.app.server!.url,
+  );
+  url.protocol = "ws:";
+  const socket = new WebSocket(url, {
+    headers: {
+      origin: "https://windy.test",
+      cookie: `windy.sid=${fixture.login.token}`,
+    },
+  });
+  try {
+    await expect(opened(socket)).rejects.toThrow("Socket rejected");
+    expect(fixture.state.probes).toEqual([]);
+  } finally {
+    socket.terminate();
+    void fixture.app.stop(true);
+  }
+});

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