Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
21.4 KB
Raw Blame
import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
import { context, trace, TraceFlags } from "@opentelemetry/api";
import { NextRequest } from "next/server";

import { setStructuredLogSink, useJsonStdoutStructuredLogSink } from "../../../observability/runtime-logger.ts";

const previousDenApiBase = process.env.DEN_API_BASE;
const previousDenBaseUrl = process.env.DEN_BASE_URL;
const previousDenWebPublicOrigin = process.env.DEN_WEB_PUBLIC_ORIGIN;

describe("Den upstream proxy", () => {
  let server;
  let observed = null;
  let logs = [];

  beforeAll(() => {
    server = Bun.serve({
      port: 0,
      async fetch(request) {
        const url = new URL(request.url);
        observed = {
          method: request.method,
          path: `${url.pathname}${url.search}`,
          body: await request.text(),
          cookie: request.headers.get("cookie"),
          authorization: request.headers.get("authorization"),
          custom: request.headers.get("x-custom-proxy-test"),
          forwarded: request.headers.get("forwarded"),
          forwardedHost: request.headers.get("x-forwarded-host"),
          forwardedPrefix: request.headers.get("x-forwarded-prefix"),
          forwardedProto: request.headers.get("x-forwarded-proto"),
          traceparent: request.headers.get("traceparent"),
          tracestate: request.headers.get("tracestate"),
        };

        if (url.pathname === "/v1/compressed") {
          return new Response(Bun.gzipSync(JSON.stringify({ ok: true, source: "gzip" })), {
            headers: {
              "content-type": "application/json",
              "content-encoding": "gzip",
            },
          });
        }

        if (url.pathname === "/v1/error") {
          return new Response("upstream unavailable", { status: 502 });
        }

        if (url.pathname === "/v1/internal-headers") {
          const upstreamOrigin = new URL(request.url).origin;
          return new Response("sanitized", {
            headers: {
              "access-control-expose-headers": "Content-Length, X-Request-Id, X-Origin-Host",
              "content-location": `${upstreamOrigin}/v1/internal-headers/body`,
              "link": `<${upstreamOrigin}/v1/internal-headers/next>; rel="next"`,
              "location": `${upstreamOrigin}/v1/internal-headers/redirect?next=1`,
              "refresh": `0; url=${upstreamOrigin}/v1/internal-headers/login`,
              "rndr-id": "render-request",
              "server": "internal-origin",
              "via": "internal-proxy",
              "x-cache-key": "cache:key",
              "x-content-type-options": "nosniff",
              "x-origin-host": "den-api.internal",
              "x-render-origin-server": "Render",
              "x-request-id": "req_internal",
              "x-upstream-result": "ok",
            },
          });
        }

        if (url.pathname === "/api/auth/callback/google") {
          const headers = new Headers({ "content-type": "text/plain" });
          headers.append(
            "set-cookie",
            "__Secure-better-auth.session_token=abc; Path=/; Domain=api.app.example.com; Secure; HttpOnly; SameSite=Lax",
          );
          headers.append(
            "set-cookie",
            "better-auth.session_data=def; Path=/; Secure; HttpOnly; SameSite=Lax",
          );
          return new Response("signed in", { headers });
        }

        return new Response("proxied", {
          status: 207,
          headers: {
            "content-type": "text/plain",
            "set-cookie": "sid=abc; Path=/; HttpOnly",
            "x-upstream-result": "ok",
          },
        });
      },
    });
    process.env.DEN_API_BASE = `http://127.0.0.1:${server.port}`;
  });

  beforeEach(() => {
    delete process.env.DEN_BASE_URL;
    delete process.env.DEN_WEB_PUBLIC_ORIGIN;
    logs = [];
    setStructuredLogSink({
      log(level, message, fields) {
        logs.push({ level, message, fields });
      },
    });
  });

  afterAll(() => {
    useJsonStdoutStructuredLogSink();
    server.stop(true);
    if (previousDenApiBase === undefined) {
      delete process.env.DEN_API_BASE;
    } else {
      process.env.DEN_API_BASE = previousDenApiBase;
    }
    if (previousDenWebPublicOrigin === undefined) {
      delete process.env.DEN_WEB_PUBLIC_ORIGIN;
    } else {
      process.env.DEN_WEB_PUBLIC_ORIGIN = previousDenWebPublicOrigin;
    }
    if (previousDenBaseUrl === undefined) {
      delete process.env.DEN_BASE_URL;
    } else {
      process.env.DEN_BASE_URL = previousDenBaseUrl;
    }
  });

  const INSTANCE_ORIGIN = "https://8787-2bnptanfwxs5j8vu.daytonaproxy01.net";

  test("answers the preflight for a rotating Cloud instance origin", async () => {
    const { proxyUpstream } = await import("./upstream-proxy.ts");
    const request = new NextRequest("https://app.example.com/api/den/v1/me", {
      method: "OPTIONS",
      headers: {
        origin: INSTANCE_ORIGIN,
        "access-control-request-method": "GET",
        "access-control-request-headers": "authorization,content-type",
      },
    });

    const response = await proxyUpstream(request, [], { routePrefix: "/api/den" });

    expect(response.status).toBe(204);
    expect(response.headers.get("access-control-allow-origin")).toBe(INSTANCE_ORIGIN);
    expect(response.headers.get("access-control-allow-credentials")).toBe("true");
    expect(response.headers.get("access-control-allow-headers")).toBe("authorization,content-type");
    expect(response.headers.get("vary")).toContain("Origin");
  });

  test("reflects the instance origin on the real response and strips cookies upstream", async () => {
    const { proxyUpstream } = await import("./upstream-proxy.ts");
    const request = new NextRequest("https://app.example.com/api/den/v1/me", {
      method: "GET",
      headers: {
        origin: INSTANCE_ORIGIN,
        authorization: "Bearer tok_instance",
        cookie: "ow_session=must_not_leak",
      },
    });

    const response = await proxyUpstream(request, [], { routePrefix: "/api/den" });

    expect(response.headers.get("access-control-allow-origin")).toBe(INSTANCE_ORIGIN);
    // The whole safety argument: an instance-origin call is bearer-only and can
    // never ride the viewer's dashboard session.
    expect(observed.cookie).toBeNull();
    expect(observed.authorization).toBe("Bearer tok_instance");
  });

  test("does not reflect a non-instance origin and keeps its cookies", async () => {
    const { proxyUpstream } = await import("./upstream-proxy.ts");
    const request = new NextRequest("https://app.example.com/api/den/v1/me", {
      method: "GET",
      headers: {
        origin: "https://evil.example.com",
        cookie: "ow_session=sess_test",
      },
    });

    const response = await proxyUpstream(request, [], { routePrefix: "/api/den" });

    expect(response.headers.get("access-control-allow-origin")).toBeNull();
    expect(observed.cookie).toBe("ow_session=sess_test");
  });

  test("does not reflect instance origins on the auth proxy", async () => {
    const { proxyUpstream } = await import("./upstream-proxy.ts");
    const request = new NextRequest("https://app.example.com/api/auth/session", {
      method: "GET",
      headers: { origin: INSTANCE_ORIGIN, cookie: "better-auth.session_token=sess_test" },
    });

    const response = await proxyUpstream(request, [], { routePrefix: "/api/auth", upstreamPathPrefix: "api/auth" });

    expect(response.headers.get("access-control-allow-origin")).toBeNull();
    expect(observed.cookie).toBe("better-auth.session_token=sess_test");
  });

  test("forwards only OmniRush.ai Den and legacy Better Auth cookies through the auth proxy", async () => {
    const { proxyUpstream } = await import("./upstream-proxy.ts");
    const request = new NextRequest("https://app.example.com/api/auth/sign-in/social", {
      method: "POST",
      headers: {
        cookie: "ph_posthog=analytics; __Secure-omnirush-den.state=oauth-state; omnirush-den.session_token=session; better-auth.state=legacy-oauth-state; __Secure-better-auth.session_token=legacy-session; other=value",
      },
    });

    await proxyUpstream(request, [], { routePrefix: "/api/auth", upstreamPathPrefix: "api/auth" });

    expect(observed.cookie).toBe("__Secure-omnirush-den.state=oauth-state; omnirush-den.session_token=session; better-auth.state=legacy-oauth-state; __Secure-better-auth.session_token=legacy-session");
  });

  test("rewrites auth Set-Cookie domains to the browser origin", async () => {
    const { proxyUpstream } = await import("./upstream-proxy.ts");
    const originalFetch = globalThis.fetch;
    process.env.DEN_API_BASE = "https://api.app.example.com";
    globalThis.fetch = async () => {
      const headers = new Headers({ "content-type": "text/plain" });
      headers.append(
        "set-cookie",
        "__Secure-better-auth.session_token=abc; Path=/; Domain=api.app.example.com; Secure; HttpOnly; SameSite=Lax",
      );
      headers.append(
        "set-cookie",
        "better-auth.session_data=def; Path=/; Secure; HttpOnly; SameSite=Lax",
      );
      return new Response("signed in", { headers });
    };
    const request = new NextRequest("https://app.example.com/api/auth/callback/google", {
      method: "GET",
    });

    let response;
    try {
      response = await proxyUpstream(request, ["callback", "google"], { routePrefix: "/api/auth", upstreamPathPrefix: "api/auth" });
    } finally {
      globalThis.fetch = originalFetch;
      process.env.DEN_API_BASE = `http://127.0.0.1:${server.port}`;
    }

    expect(response.headers.getSetCookie()).toEqual([
      "__Secure-better-auth.session_token=abc; Path=/; Domain=app.example.com; Secure; HttpOnly; SameSite=Lax",
      "better-auth.session_data=def; Path=/; Secure; HttpOnly; SameSite=Lax; Domain=app.example.com",
    ]);
  });

  test("preserves auth Set-Cookie parent domains shared by sibling web and API hosts", async () => {
    const { proxyUpstream } = await import("./upstream-proxy.ts");
    const originalFetch = globalThis.fetch;
    process.env.DEN_API_BASE = "https://api.omnirushlabs.com";
    globalThis.fetch = async () => {
      const headers = new Headers({ "content-type": "text/plain" });
      headers.append(
        "set-cookie",
        "__Secure-better-auth.session_token=abc; Path=/; Domain=omnirushlabs.com; Secure; HttpOnly; SameSite=Lax",
      );
      return new Response("signed in", { headers });
    };
    const request = new NextRequest("https://app.omnirushlabs.com/api/auth/callback/google", {
      method: "GET",
    });

    let response;
    try {
      response = await proxyUpstream(request, ["callback", "google"], { routePrefix: "/api/auth", upstreamPathPrefix: "api/auth" });
    } finally {
      globalThis.fetch = originalFetch;
      process.env.DEN_API_BASE = `http://127.0.0.1:${server.port}`;
    }

    expect(response.headers.getSetCookie()).toEqual([
      "__Secure-better-auth.session_token=abc; Path=/; Domain=omnirushlabs.com; Secure; HttpOnly; SameSite=Lax",
    ]);
  });

  test("copies auth Set-Cookie from runtimes that only expose the combined header", async () => {
    const { proxyUpstream } = await import("./upstream-proxy.ts");
    const originalFetch = globalThis.fetch;
    process.env.DEN_API_BASE = "https://api.app.example.com";
    globalThis.fetch = async () => {
      const response = new Response("signed in", {
        headers: {
          "set-cookie": "better-auth.session_token=abc; Path=/; Secure; HttpOnly; SameSite=Lax, better-auth.session_data=def; Path=/; Expires=Tue, 25 Aug 2026 23:54:00 GMT; Secure; HttpOnly; SameSite=Lax",
        },
      });
      Object.defineProperty(response.headers, "getSetCookie", { value: () => [] });
      return response;
    };
    const request = new NextRequest("https://app.example.com/api/auth/callback/google", {
      method: "GET",
    });

    let response;
    try {
      response = await proxyUpstream(request, ["callback", "google"], { routePrefix: "/api/auth", upstreamPathPrefix: "api/auth" });
    } finally {
      globalThis.fetch = originalFetch;
      process.env.DEN_API_BASE = `http://127.0.0.1:${server.port}`;
    }

    expect(response.headers.getSetCookie()).toEqual([
      "better-auth.session_token=abc; Path=/; Secure; HttpOnly; SameSite=Lax; Domain=app.example.com",
      "better-auth.session_data=def; Path=/; Expires=Tue, 25 Aug 2026 23:54:00 GMT; Secure; HttpOnly; SameSite=Lax; Domain=app.example.com",
    ]);
  });

  test("rejects http and lookalike hostnames", async () => {
    const { proxyUpstream } = await import("./upstream-proxy.ts");
    for (const origin of ["http://8787-x.daytonaproxy01.net", "https://daytonaproxy01.net.evil.com"]) {
      const request = new NextRequest("https://app.example.com/api/den/v1/me", {
        method: "GET",
        headers: { origin },
      });
      const response = await proxyUpstream(request, [], { routePrefix: "/api/den" });
      expect(response.headers.get("access-control-allow-origin")).toBeNull();
    }
  });

  test("passes method, path, query, body, cookies, auth, status, and headers through", async () => {
    const { proxyUpstream } = await import("./upstream-proxy.ts");
    const request = new NextRequest("https://app.example.com/api/den/v1/me?include=org", {
      method: "POST",
      headers: {
        authorization: "Bearer tok_test",
        cookie: "ow_session=sess_test",
        "content-type": "application/json",
        "x-custom-proxy-test": "kept",
      },
      body: JSON.stringify({ ok: true }),
    });

    const response = await proxyUpstream(request, [], { routePrefix: "/api/den" });

    expect(observed).toEqual({
      method: "POST",
      path: "/v1/me?include=org",
      body: JSON.stringify({ ok: true }),
      cookie: "ow_session=sess_test",
      authorization: "Bearer tok_test",
      custom: "kept",
      forwarded: null,
      forwardedHost: "app.example.com",
      forwardedPrefix: "/api/den",
      forwardedProto: "https",
      traceparent: null,
      tracestate: null,
    });
    expect(response.status).toBe(207);
    expect(response.headers.get("x-upstream-result")).toBeNull();
    expect(response.headers.get("set-cookie")).toContain("sid=abc");
    expect(await response.text()).toBe("proxied");
    expect(logs).toHaveLength(1);
    expect(logs[0]).toMatchObject({
      level: "info",
      message: "den-web upstream proxy completed",
      fields: {
        route_prefix: "/api/den",
        method: "POST",
        upstream_path: "/v1/me",
        status: 207,
      },
    });
    expect(typeof logs[0].fields.duration_ms).toBe("number");
    const serializedLog = JSON.stringify(logs[0]);
    expect(serializedLog).not.toContain("include=org");
    expect(serializedLog).not.toContain("tok_test");
    expect(serializedLog).not.toContain("sess_test");
    expect(serializedLog).not.toContain(JSON.stringify({ ok: true }));
  });

  test("strips internal upstream response headers and rewrites upstream URLs", async () => {
    const { proxyUpstream } = await import("./upstream-proxy.ts");
    const request = new NextRequest("https://app.example.com/api/den/v1/internal-headers");

    const response = await proxyUpstream(request, [], { routePrefix: "/api/den" });

    expect(response.headers.get("access-control-expose-headers")).toBe("Content-Length");
    for (const header of [
      "rndr-id",
      "server",
      "via",
      "x-cache-key",
      "x-origin-host",
      "x-render-origin-server",
      "x-request-id",
      "x-upstream-result",
    ]) {
      expect(response.headers.get(header)).toBeNull();
    }
    expect(response.headers.get("x-content-type-options")).toBe("nosniff");
    expect(response.headers.get("content-location")).toBe("https://app.example.com/api/den/v1/internal-headers/body");
    expect(response.headers.get("link")).toBe("<https://app.example.com/api/den/v1/internal-headers/next>; rel=\"next\"");
    expect(response.headers.get("location")).toBe("https://app.example.com/api/den/v1/internal-headers/redirect?next=1");
    expect(response.headers.get("refresh")).toBe("0; url=https://app.example.com/api/den/v1/internal-headers/login");
    expect(await response.text()).toBe("sanitized");
  });

  test("drops content-encoding after upstream fetch decompresses the body", async () => {
    const { proxyUpstream } = await import("./upstream-proxy.ts");
    const request = new NextRequest("https://app.example.com/api/den/v1/compressed");

    const response = await proxyUpstream(request, [], { routePrefix: "/api/den" });

    expect(response.headers.get("content-encoding")).toBeNull();
    expect(await response.json()).toEqual({ ok: true, source: "gzip" });
  });

  test("logs non-ok upstream completions without credentials or query strings", async () => {
    const { proxyUpstream } = await import("./upstream-proxy.ts");
    const request = new NextRequest("https://app.example.com/api/den/v1/error?token=secret", {
      headers: {
        authorization: "Bearer should-not-log",
        cookie: "ow_session=should-not-log",
      },
    });

    const response = await proxyUpstream(request, [], { routePrefix: "/api/den" });

    expect(response.status).toBe(502);
    expect(logs).toHaveLength(1);
    expect(logs[0]).toMatchObject({
      level: "warn",
      message: "den-web upstream proxy completed",
      fields: {
        route_prefix: "/api/den",
        method: "GET",
        upstream_path: "/v1/error",
        status: 502,
      },
    });
    const serializedLog = JSON.stringify(logs[0]);
    expect(serializedLog).not.toContain("token=secret");
    expect(serializedLog).not.toContain("should-not-log");
  });

  test("continues W3C trace context into upstream requests", async () => {
    const { proxyUpstream } = await import("./upstream-proxy.ts");
    const traceparent = "00-0af7651916cd43dd8448eb211c80319c-b9c7c989f97918e1-01";
    const tracestate = "vendor=value";
    const request = new NextRequest("https://app.example.com/api/den/v1/me", {
      headers: { traceparent, tracestate },
    });

    await proxyUpstream(request, [], { routePrefix: "/api/den" });

    expect(observed.traceparent).toBe(traceparent);
    expect(observed.tracestate).toBe(tracestate);
  });

  test("overwrites spoofable forwarded headers", async () => {
    const { proxyUpstream } = await import("./upstream-proxy.ts");
    const request = new NextRequest("https://app.example.com/api/den/v1/me", {
      headers: {
        forwarded: "host=evil.example;proto=http",
        "x-forwarded-host": "evil.example",
        "x-forwarded-prefix": "/evil",
        "x-forwarded-proto": "http",
      },
    });

    await proxyUpstream(request, [], { routePrefix: "/api/den" });

    expect(observed.forwardedHost).toBe("app.example.com");
    expect(observed.forwardedPrefix).toBe("/api/den");
    expect(observed.forwardedProto).toBe("https");
    expect(observed.forwarded).toBeNull();
  });

  test("uses DEN_BASE_URL for forwarded public origin headers", async () => {
    process.env.DEN_BASE_URL = "http://cloud.example.test:3005";
    process.env.DEN_WEB_PUBLIC_ORIGIN = "https://migration.example.test";
    const { proxyUpstream } = await import("./upstream-proxy.ts");
    const request = new NextRequest("https://request.example.com/api/den/v1/me");

    await proxyUpstream(request, [], { routePrefix: "/api/den" });

    expect(observed.forwardedHost).toBe("cloud.example.test:3005");
    expect(observed.forwardedProto).toBe("http");
  });

  test("keeps DEN_WEB_PUBLIC_ORIGIN as the forwarded origin migration fallback", async () => {
    process.env.DEN_WEB_PUBLIC_ORIGIN = "https://migration.example.test";
    const { proxyUpstream } = await import("./upstream-proxy.ts");
    const request = new NextRequest("https://request.example.com/api/den/v1/me");

    await proxyUpstream(request, [], { routePrefix: "/api/den" });

    expect(observed.forwardedHost).toBe("migration.example.test");
    expect(observed.forwardedProto).toBe("https");
  });

  test("preserves a rotating public ingress origin when the server request URL is internal", async () => {
    const { proxyUpstream } = await import("./upstream-proxy.ts");
    for (const internalHost of ["127.0.0.1", "0.0.0.0"]) {
      const request = new NextRequest(`http://${internalHost}:3005/api/den/v1/me`, {
        headers: {
          "x-forwarded-host": "3005-rotated.daytonaproxy01.net",
          "x-forwarded-proto": "https",
        },
      });

      await proxyUpstream(request, [], { routePrefix: "/api/den" });

      expect(observed.forwardedHost).toBe("3005-rotated.daytonaproxy01.net");
      expect(observed.forwardedPrefix).toBe("/api/den");
      expect(observed.forwardedProto).toBe("https");
    }
  });

  test("injects the active W3C trace context into upstream requests", async () => {
    const { proxyUpstream } = await import("./upstream-proxy.ts");
    const request = new NextRequest("https://app.example.com/api/den/v1/me");
    const spanContext = {
      traceId: "0af7651916cd43dd8448eb211c80319c",
      spanId: "b9c7c989f97918e1",
      traceFlags: TraceFlags.SAMPLED,
    };

    const activeContext = trace.setSpanContext(context.active(), spanContext);
    const contextManager = {
      active: () => activeContext,
      with: (nextContext, callback, thisArg, ...args) => callback.apply(thisArg, args),
      bind: (nextContext, target) => target,
      enable: () => contextManager,
      disable: () => contextManager,
    };

    context.setGlobalContextManager(contextManager);
    try {
      await proxyUpstream(request, [], { routePrefix: "/api/den" });
    } finally {
      context.disable();
    }

    expect(observed.traceparent).toBe("00-0af7651916cd43dd8448eb211c80319c-b9c7c989f97918e1-01");
  });
});