Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
15.8 KB
Raw Blame
import { afterEach, describe, expect, test } from "bun:test"
import {
  accessKeyMatches,
  allowedUpstreamOverride,
  connectDebugProxyConfig,
  encodeUpstreamParameter,
} from "../src/connect-debug-proxy-config"
import {
  CONNECT_DEBUG_PROXY_BROWSER_ROUTE_COOKIE,
  connectDebugProxyBrowserRouteCookie,
  readConnectDebugProxyBrowserRoute,
} from "../src/connect-debug-proxy-browser-route"
import { proxyConnectDebugRequest } from "../src/connect-debug-proxy"
import { clearConnectDebugProxyFlakyWindows, connectDebugProxyFault } from "../src/connect-debug-proxy-faults"
import { clearConnectDebugProxyRequests, listConnectDebugProxyRequests } from "../src/connect-debug-proxy-log"
import {
  buildConnectDebugProxyResponse,
  forwardRequestHeaders,
  rewriteLocationHeader,
  rewriteSetCookieHeader,
} from "../src/connect-debug-proxy-rewrite"
import { parseConnectDebugProxyScenario } from "../src/connect-debug-proxy-scenarios"
import { tamperJsonRpcText, tamperSseText } from "../src/connect-debug-proxy-tamper"

const originalEnvironment = { ...process.env }

afterEach(() => {
  process.env = { ...originalEnvironment }
  clearConnectDebugProxyFlakyWindows()
  clearConnectDebugProxyRequests()
})

function scenario(slug: string) {
  const parsed = parseConnectDebugProxyScenario(slug)
  if (!parsed) throw new Error(`Unknown test scenario: ${slug}`)
  return parsed
}

function fault(slug: string, pathname: string, now = 1_000) {
  return connectDebugProxyFault({
    flakyKey: `${slug}:${pathname}`,
    flakyWindowMs: 60_000,
    now,
    pathname,
    requestBody: new TextEncoder().encode('{"jsonrpc":"2.0","method":"tools/list"}'),
    scenario: scenario(slug),
    slowMs: 7_000,
  })
}

describe("Connect debug proxy configuration", () => {
  test("accepts only encoded origins whose host is allowlisted", () => {
    delete process.env.VERCEL
    process.env.DEBUG_PROXY_DEFAULT_UPSTREAM = "https://app.omnirushlabs.com"
    process.env.DEBUG_PROXY_ALLOWED_UPSTREAMS = "staging.omnirushlabs.com,http://127.0.0.1:4545"
    const config = connectDebugProxyConfig()
    expect(allowedUpstreamOverride(encodeUpstreamParameter("https://staging.omnirushlabs.com"), config)).toBe("https://staging.omnirushlabs.com")
    expect(allowedUpstreamOverride(encodeUpstreamParameter("http://127.0.0.1:4545"), config)).toBe("http://127.0.0.1:4545")
    expect(allowedUpstreamOverride(encodeUpstreamParameter("https://evil.example"), config)).toBeNull()
    expect(allowedUpstreamOverride("~not-canonical-base64", config)).toBeNull()
  })

  test("requires a path-safe access key on Vercel and compares it safely", () => {
    process.env.VERCEL = "1"
    process.env.DEBUG_PROXY_ACCESS_KEY = "short"
    expect(connectDebugProxyConfig().errors).toContain("DEBUG_PROXY_ACCESS_KEY")
    process.env.DEBUG_PROXY_ACCESS_KEY = "debug-access-key-1234"
    expect(connectDebugProxyConfig().errors).not.toContain("DEBUG_PROXY_ACCESS_KEY")
    expect(accessKeyMatches("debug-access-key-1234", "debug-access-key-1234")).toBe(true)
    expect(accessKeyMatches("wrong", "debug-access-key-1234")).toBe(false)
  })
})

describe("Connect debug proxy fault engine", () => {
  test("scopes endpoint faults without breaking unrelated Den routes", async () => {
    expect(fault("auth-expired", "/v1/mcp/token")).toBeNull()
    const auth = fault("auth-expired", "/api/den/mcp/agent")
    expect(auth?.kind).toBe("response")
    if (auth?.kind !== "response") throw new Error("Expected auth response")
    expect(auth.response.status).toBe(401)
    expect(auth.response.headers.get("www-authenticate")).toContain("invalid_token")

    expect(fault("token-mint-fail", "/api/den/mcp/agent")).toBeNull()
    const mint = fault("token-mint-fail", "/v1/mcp/token")
    expect(mint?.kind).toBe("response")
    if (mint?.kind !== "response") throw new Error("Expected token mint response")
    expect(mint.response.status).toBe(503)
    expect(fault("token-mint-fail", "/api/den/v1/mcp/token")?.kind).toBe("response")
  })

  test("fails only the first N agent requests in each rolling window", () => {
    for (let index = 0; index < 3; index += 1) expect(fault("flaky-3", "/api/den/mcp/agent", 1_000)?.kind).toBe("response")
    expect(fault("flaky-3", "/api/den/mcp/agent", 1_000)).toBeNull()
    expect(fault("flaky-3", "/api/den/mcp/agent", 62_000)?.kind).toBe("response")
  })

  test("implements every named fault action and keeps default as pass-through", async () => {
    expect(fault("default", "/api/den/mcp/agent")).toBeNull()
    const expectations = [
      ["forbidden", "response", 403],
      ["down", "response", 502],
      ["corrupt", "response", 200],
      ["slow", "delay", null],
      ["hang", "hang", null],
      ["missing-tools", "tamper", null],
      ["bad-protocol", "tamper", null],
    ]
    for (const [slug, kind, status] of expectations) {
      if (typeof slug !== "string") throw new Error("Expected scenario slug")
      const action = fault(slug, "/api/den/mcp/agent")
      expect(action?.kind).toBe(kind)
      if (status !== null && action?.kind === "response") expect(action.response.status).toBe(status)
    }
    const outage = fault("den-outage", "/v1/me")
    expect(outage?.kind).toBe("response")
    if (outage?.kind !== "response") throw new Error("Expected outage response")
    expect(outage.response.status).toBe(503)
  })
})

describe("Connect debug proxy rewriting and streaming", () => {
  test("rewrites upstream Location, absolute JSON URLs, and cookie scope", async () => {
    const upstreamUrl = new URL("https://api.omnirushlabs.com/v1/session")
    const proxyBase = "https://proxy.example/via/default/access-key"
    expect(rewriteLocationHeader("/login?next=%2F", upstreamUrl, proxyBase)).toBe(`${proxyBase}/login?next=%2F`)
    expect(rewriteLocationHeader("https://identity.example/login", upstreamUrl, proxyBase)).toBe("https://identity.example/login")
    expect(rewriteSetCookieHeader("session=value; Domain=api.omnirushlabs.com; Path=/; Secure; HttpOnly", "/via/default/access-key"))
      .toBe("session=value;Path=/via/default/access-key; Secure; HttpOnly")
    expect(rewriteSetCookieHeader("session=value; Path=/api; Secure", "/")).toBe("session=value;Path=/api; Secure")

    const response = await buildConnectDebugProxyResponse({
      proxyBase,
      tamperMode: null,
      upstream: Response.json({ redirect: "https://api.omnirushlabs.com/next" }),
      upstreamRequestUrl: upstreamUrl,
    })
    expect(await response.json()).toEqual({ redirect: `${proxyBase}/next` })
  })

  test("keeps the desktop auth handoff on the selected proxy base", async () => {
    const upstreamUrl = new URL("https://app.omnirushlabs.com/api/den/v1/auth/desktop-handoff")
    const proxyBase = "https://proxy.example/via/default/access-key"
    const upstreamDenBaseUrl = "https://app.omnirushlabs.com/api/den"
    const deepLink = `omnirush://den-auth?grant=one-time-grant&denBaseUrl=${encodeURIComponent(upstreamDenBaseUrl)}`

    expect(rewriteLocationHeader(deepLink, upstreamUrl, proxyBase)).toBe(
      `omnirush://den-auth?grant=one-time-grant&denBaseUrl=${encodeURIComponent(`${proxyBase}/api/den`)}`,
    )

    const response = await buildConnectDebugProxyResponse({
      proxyBase,
      tamperMode: null,
      upstream: Response.json({ omnirushUrl: deepLink }),
      upstreamRequestUrl: upstreamUrl,
    })
    const payload = await response.json() as { omnirushUrl: string }
    expect(new URL(payload.omnirushUrl).searchParams.get("denBaseUrl")).toBe(`${proxyBase}/api/den`)
  })

  test("keeps the proxy key private while translating same-origin browser headers", () => {
    const headers = forwardRequestHeaders(new Headers({
      "x-connect-debug-proxy-key": "do-not-forward",
      origin: "https://proxy.example",
      referer: "https://proxy.example/via/default/access-key/login?next=1",
      cookie: `${CONNECT_DEBUG_PROXY_BROWSER_ROUTE_COOKIE}=%2Fvia%2Fdefault%2Faccess-key; den-session=opaque`,
    }), {
      proxyBase: "https://proxy.example/via/default/access-key",
      upstreamOrigin: "https://api.omnirushlabs.com",
    })
    expect(headers.has("x-connect-debug-proxy-key")).toBe(false)
    expect(headers.get("origin")).toBe("https://api.omnirushlabs.com")
    expect(headers.get("referer")).toBe("https://api.omnirushlabs.com/login?next=1")
    expect(headers.get("cookie")).toBe("den-session=opaque")
  })

  test("sets a short-lived browser route without exposing it to Den", async () => {
    delete process.env.VERCEL
    process.env.DEBUG_PROXY_ACCESS_KEY = "debug-access-key-1234"
    process.env.DEBUG_PROXY_DEFAULT_UPSTREAM = "https://app.omnirushlabs.com"
    let forwardedCookie = ""
    const response = await proxyConnectDebugRequest({
      pathSegments: ["debug-access-key-1234"],
      request: new Request("https://proxy.example/via/default/debug-access-key-1234?desktopAuth=1", {
        headers: { accept: "text/html", cookie: `${CONNECT_DEBUG_PROXY_BROWSER_ROUTE_COOKIE}=%2Fvia%2Fdefault%2Fdebug-access-key-1234; den-session=opaque` },
      }),
      scenarioSlug: "default",
    }, {
      fetchImpl: async (_url, init) => {
        forwardedCookie = new Headers(init?.headers).get("cookie") ?? ""
        return new Response("<html>Den</html>", {
          headers: { "content-type": "text/html", "set-cookie": "den-session=next; Path=/; Secure; HttpOnly" },
        })
      },
    })
    const cookies = response.headers.getSetCookie()
    const routeCookie = cookies.find((cookie) => cookie.startsWith(`${CONNECT_DEBUG_PROXY_BROWSER_ROUTE_COOKIE}=`))

    expect(forwardedCookie).toBe("den-session=opaque")
    expect(cookies).toContain("den-session=next;Path=/; Secure; HttpOnly")
    expect(routeCookie).toContain("HttpOnly")
    expect(routeCookie).toContain("SameSite=Lax")
    expect(readConnectDebugProxyBrowserRoute(routeCookie)).toBe("/via/default/debug-access-key-1234")
    expect(connectDebugProxyBrowserRouteCookie("http://localhost:3010/via/default/local-connect-debug-proxy")).not.toContain("Secure")
  })

  test("passes SSE through without waiting for the stream to finish", async () => {
    let release: (() => void) | undefined
    const secondChunk = new Promise<void>((resolve) => { release = resolve })
    const encoder = new TextEncoder()
    const upstreamBody = new ReadableStream<Uint8Array>({
      async start(controller) {
        controller.enqueue(encoder.encode("event: message\ndata: first\n\n"))
        await secondChunk
        controller.enqueue(encoder.encode("event: message\ndata: second\n\n"))
        controller.close()
      },
    })
    const response = await buildConnectDebugProxyResponse({
      proxyBase: "https://proxy.example/via/default/access-key",
      tamperMode: null,
      upstream: new Response(upstreamBody, { headers: { "content-type": "text/event-stream" } }),
      upstreamRequestUrl: new URL("https://api.omnirushlabs.com/mcp/agent"),
    })
    const reader = response.body?.getReader()
    if (!reader) throw new Error("Expected streamed body")
    const first = await reader.read()
    expect(new TextDecoder().decode(first.value)).toContain("first")
    release?.()
    const second = await reader.read()
    expect(new TextDecoder().decode(second.value)).toContain("second")
  })

  test("rewrites chunked JSON without buffering the complete response", async () => {
    let release: (() => void) | undefined
    const secondChunk = new Promise<void>((resolve) => { release = resolve })
    const encoder = new TextEncoder()
    const upstreamBody = new ReadableStream<Uint8Array>({
      async start(controller) {
        controller.enqueue(encoder.encode(`{"padding":"${"x".repeat(80)}","url":"https://api.omnirushlabs.com`))
        await secondChunk
        controller.enqueue(encoder.encode(`/next"}`))
        controller.close()
      },
    })
    const response = await buildConnectDebugProxyResponse({
      proxyBase: "https://proxy.example/via/default/access-key",
      tamperMode: null,
      upstream: new Response(upstreamBody, { headers: { "content-type": "application/json" } }),
      upstreamRequestUrl: new URL("https://api.omnirushlabs.com/mcp/agent"),
    })
    const reader = response.body?.getReader()
    if (!reader) throw new Error("Expected streamed body")
    const first = await reader.read()
    expect(new TextDecoder().decode(first.value)).toContain("padding")
    release?.()
    let text = new TextDecoder().decode(first.value)
    while (true) {
      const next = await reader.read()
      if (next.done) break
      text += new TextDecoder().decode(next.value)
    }
    expect(JSON.parse(text)).toEqual({ padding: "x".repeat(80), url: "https://proxy.example/via/default/access-key/next" })
  })

  test("drops execute_capability from plain JSON and SSE tools/list responses", () => {
    const payload = { jsonrpc: "2.0", id: 2, result: { tools: [{ name: "search_capabilities" }, { name: "execute_capability" }] } }
    const plain = JSON.parse(tamperJsonRpcText(JSON.stringify(payload), "missing-tools"))
    expect(plain.result.tools).toEqual([{ name: "search_capabilities" }])
    const sse = tamperSseText(`event: message\ndata: ${JSON.stringify(payload)}\n\n`, "missing-tools")
    expect(sse).toContain("search_capabilities")
    expect(sse).not.toContain("execute_capability")
  })

  test("rewrites initialize protocolVersion in plain JSON and SSE", () => {
    const payload = { jsonrpc: "2.0", id: 1, result: { protocolVersion: "2025-06-18", capabilities: {} } }
    expect(tamperJsonRpcText(JSON.stringify(payload), "bad-protocol")).toContain("1900-01-01")
    expect(tamperSseText(`data: ${JSON.stringify(payload)}\n\n`, "bad-protocol")).toContain("1900-01-01")
  })

  test("keeps the bad protocol header consistent with the tampered initialize payload", async () => {
    const response = await buildConnectDebugProxyResponse({
      proxyBase: "https://proxy.example/via/bad-protocol/access-key",
      tamperMode: "bad-protocol",
      upstream: Response.json({ jsonrpc: "2.0", id: 1, result: { protocolVersion: "2025-06-18" } }, {
        headers: { "mcp-protocol-version": "2025-06-18" },
      }),
      upstreamRequestUrl: new URL("https://app.omnirushlabs.com/api/den/mcp/agent"),
    })
    expect(response.headers.get("mcp-protocol-version")).toBe("1900-01-01")
    expect(await response.text()).toContain("1900-01-01")
  })
})

describe("Connect debug proxy request handling", () => {
  test("preserves credentials in transit but retains only redacted request metadata", async () => {
    delete process.env.VERCEL
    process.env.DEBUG_PROXY_ACCESS_KEY = "debug-access-key-1234"
    process.env.DEBUG_PROXY_DEFAULT_UPSTREAM = "https://app.omnirushlabs.com"
    let forwardedAuthorization = ""
    let forwardedCookie = ""
    let forwardedBody = ""
    const response = await proxyConnectDebugRequest({
      pathSegments: ["debug-access-key-1234", "v1", "mcp", "token"],
      request: new Request("https://proxy.example/via/default/debug-access-key-1234/v1/mcp/token?token=query-secret", {
        body: '{"refreshToken":"body-secret"}',
        headers: { authorization: "Bearer header-secret", cookie: "session=cookie-secret", "content-type": "application/json" },
        method: "POST",
      }),
      scenarioSlug: "default",
    }, {
      fetchImpl: async (_url, init) => {
        const headers = new Headers(init?.headers)
        forwardedAuthorization = headers.get("authorization") ?? ""
        forwardedCookie = headers.get("cookie") ?? ""
        forwardedBody = new TextDecoder().decode(init?.body instanceof Uint8Array ? init.body : undefined)
        return Response.json({ ok: true })
      },
      now: () => 5_000,
    })
    expect(response.status).toBe(200)
    expect(forwardedAuthorization).toBe("Bearer header-secret")
    expect(forwardedCookie).toBe("session=cookie-secret")
    expect(forwardedBody).toContain("body-secret")
    expect(listConnectDebugProxyRequests()).toEqual([expect.objectContaining({
      method: "POST",
      path: "/v1/mcp/token",
      scenario: "default",
      status: 200,
    })])
    expect(JSON.stringify(listConnectDebugProxyRequests())).not.toContain("secret")
  })
})