Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
23.4 KB
Raw Blame
import { createDenTypeId } from "@omnirush-ee/utils/typeid"
import { beforeAll, expect, test } from "bun:test"
import { Hono } from "hono"
import { cors } from "hono/cors"
import type { WorkerRouteVariables } from "../src/routes/workers/shared.js"
import type { CloudRuntimeStore } from "../src/workers/worker-access.js"

function seedRequiredEnv() {
  process.env.DATABASE_URL ??= "mysql://root:[email protected]:3306/omnirush_test"
  process.env.DEN_DB_ENCRYPTION_KEY ??= "x".repeat(32)
  process.env.BETTER_AUTH_SECRET ??= "y".repeat(32)
  process.env.BETTER_AUTH_URL ??= "http://127.0.0.1:8790"
  process.env.CORS_ORIGINS ??= "http://127.0.0.1:8790"
  process.env.PROVISIONER_MODE = "daytona"
  process.env.DAYTONA_API_KEY = "daytona-test-key"
  process.env.DAYTONA_SNAPSHOT = "omnirush-0.18.8"
}

type SharedModule = typeof import("../src/routes/workers/shared.js")
type AccessModule = typeof import("../src/workers/worker-access.js")
type CompatibilityModule = typeof import("../src/routes/workers/compatibility.js")
let shared: SharedModule
let access: AccessModule
let compatibility: CompatibilityModule

beforeAll(async () => {
  seedRequiredEnv()
  ;[shared, access, compatibility] = await Promise.all([
    import("../src/routes/workers/shared.js"),
    import("../src/workers/worker-access.js"),
    import("../src/routes/workers/compatibility.js"),
  ])
})

function worker() {
  const now = new Date("2026-08-27T10:00:00.000Z")
  return {
    id: createDenTypeId("worker"),
    org_id: createDenTypeId("organization"),
    created_by_user_id: createDenTypeId("user"),
    name: "Daytona Cloud",
    description: null,
    destination: "cloud",
    status: "healthy",
    image_version: "omnirush-0.18.8",
    workspace_path: null,
    sandbox_backend: "cloud-instance",
    last_heartbeat_at: null,
    last_active_at: null,
    created_at: now,
    updated_at: now,
  } satisfies Parameters<SharedModule["fetchWorkerRuntimeJson"]>[0]["worker"]
}

function runtimeStore(): CloudRuntimeStore {
  return {
    async claimFailedWorker() { return false },
    async claimRecycleWorker() { return false },
    async getActiveTokens() {
      return [
        { scope: "host", token: "host-token" },
        { scope: "client", token: "client-token" },
        { scope: "activity", token: "activity-token" },
      ]
    },
    async markProvisioningWorkerFailed() {},
    async markHealthyWorkerFailed() {},
  }
}

test("generic Daytona runtime routes refresh expiry and request only the fresh preview", async () => {
  const runtimeWorker = worker()
  const requested: string[] = []
  const result = await shared.fetchWorkerRuntimeJson({
    worker: runtimeWorker,
    path: "/runtime/versions",
  }, {
    getOmniRushWebAccess: async () => ({ hasAccess: true }),
    resolveCloudAccess: (ownership) => access.resolveCloudRuntimeAccess(ownership, {
      loadWorker: async () => runtimeWorker,
      store: runtimeStore(),
      getSandboxRecord: async () => ({
        signed_preview_url: "https://expired.preview.example.test",
        signed_preview_url_expires_at: new Date("2026-08-27T09:00:00.000Z"),
      }),
      refreshSignedPreview: async () => ({
        signed_preview_url: "https://fresh.preview.example.test",
        signed_preview_url_expires_at: new Date("2026-08-27T12:00:00.000Z"),
      }),
      inspectSandbox: async () => ({ state: "started" }),
      probeSignedPreview: async () => true,
      startWake: () => {},
      startRecovery: () => {},
      now: () => new Date("2026-08-27T10:00:00.000Z").getTime(),
    }),
    fetchImpl: async (input, init) => {
      requested.push(String(input))
      expect(init?.redirect).toBe("error")
      return Response.json({ version: "fresh" })
    },
  })

  expect(result).toEqual({ ok: true, status: 200, payload: { version: "fresh" } })
  expect(requested).toEqual(["https://fresh.preview.example.test/runtime/versions"])
  expect(requested.join(" ")).not.toContain("expired.preview.example.test")
})

test("Daytona instance persistence and API responses never expose an expiring preview as timeless", () => {
  const now = new Date("2026-08-27T10:00:00.000Z")
  const runtimeWorker = worker()
  const daytona = {
    id: createDenTypeId("workerInstance"),
    worker_id: runtimeWorker.id,
    provider: "daytona",
    region: "us",
    url: "https://stale.preview.example.test",
    status: "healthy",
    created_at: now,
    updated_at: now,
  } satisfies Parameters<SharedModule["toInstanceResponse"]>[0]
  const render = { ...daytona, provider: "render", url: "https://durable.render.example.test" }

  expect(shared.persistedWorkerInstanceUrl(daytona)).toEndWith("/v1/cloud/instance")
  expect(shared.persistedWorkerInstanceUrl(daytona)).not.toContain("stale.preview.example.test")
  expect(shared.toInstanceResponse(daytona)?.url).toBeNull()
  expect(shared.persistedWorkerInstanceUrl(render)).toBe("https://durable.render.example.test")
  expect(shared.toInstanceResponse(render)?.url).toBe("https://durable.render.example.test")
})

test("cloud worker tokens expose expiring URLs only by explicit opt-in", async () => {
  const runtimeWorker = worker()
  const requested: string[] = []
  const resolveCloudAccess = async () => ({
    status: "ready" as const,
    workerId: runtimeWorker.id,
    url: "https://create-token.preview.example.test",
    expiresAt: new Date("2026-08-27T12:00:00.000Z"),
    clientToken: "client-token",
    hostToken: "host-token",
  })
  const loadActiveTokens = async () => [
    { scope: "host" as const, token: "host-token" },
    { scope: "client" as const, token: "client-token" },
  ]
  const legacy = await shared.getWorkerTokensAndConnect(runtimeWorker, {
    getOmniRushWebAccess: async () => ({ hasAccess: true }),
    apiPublicUrl: "https://den.example.test/api/den",
    resolveCloudAccess,
    loadActiveTokens,
    fetchImpl: async (input, init) => {
      requested.push(String(input))
      expect(init?.redirect).toBe("error")
      return Response.json({ activeId: "created-workspace", items: [] })
    },
  })
  const resolved = await shared.getWorkerTokensAndConnect(runtimeWorker, {
    getOmniRushWebAccess: async () => ({ hasAccess: true }),
    includeExpiringOmniRushUrl: true,
    apiPublicUrl: "https://den.example.test/api/den",
    loadActiveTokens,
    resolveCloudAccess: async () => ({
      status: "ready",
      workerId: runtimeWorker.id,
      url: "https://create-token.preview.example.test",
      expiresAt: new Date("2026-08-27T12:00:00.000Z"),
      clientToken: "client-token",
      hostToken: "host-token",
    }),
    fetchImpl: async (input, init) => {
      requested.push(String(input))
      expect(init?.redirect).toBe("error")
      return Response.json({ activeId: "created-workspace", items: [] })
    },
  })

  expect(legacy).toEqual({
    tokens: { owner: "host-token", host: "host-token", client: "client-token" },
    connect: {
      omnirushUrl: `https://den.example.test/api/den/v1/cloud/workers/${runtimeWorker.id}`,
      workspaceId: null,
    },
  })
  expect(resolved).toEqual({
    tokens: { owner: "host-token", host: "host-token", client: "client-token" },
    connect: {
      omnirushUrl: `https://den.example.test/api/den/v1/cloud/workers/${runtimeWorker.id}/w/created-workspace`,
      workspaceId: "created-workspace",
    },
    directPreview: {
      version: 1,
      omnirushUrl: "https://create-token.preview.example.test/w/created-workspace",
      workspaceId: "created-workspace",
      expiresAt: "2026-08-27T12:00:00.000Z",
    },
  })
  expect(requested).toEqual([
    "https://create-token.preview.example.test/workspaces",
  ])
  expect("connect" in legacy ? legacy.connect?.omnirushUrl : null).not.toContain("preview.example.test")
  expect("directPreview" in legacy).toBe(false)
  expect(requested.join(" ")).not.toContain("workers.example.test")
})

test("cloud worker tokens retain the stable route while provisioning", async () => {
  const runtimeWorker = { ...worker(), status: "provisioning" as const }
  const resolved = await shared.getWorkerTokensAndConnect(runtimeWorker, {
    getOmniRushWebAccess: async () => ({ hasAccess: true }),
    apiPublicUrl: "https://den.example.test/api/den",
    includeExpiringOmniRushUrl: true,
    loadActiveTokens: async () => [
      { scope: "host", token: "host-token" },
      { scope: "client", token: "client-token" },
    ],
    resolveCloudAccess: async () => ({ status: "waking", workerId: runtimeWorker.id, reason: "reprovisioning" }),
  })

  expect(resolved).toEqual({
    tokens: { owner: "host-token", host: "host-token", client: "client-token" },
    connect: {
      omnirushUrl: `https://den.example.test/api/den/v1/cloud/workers/${runtimeWorker.id}`,
      workspaceId: null,
    },
    directPreview: null,
  })
})

function registerCompatibilityTestApp(input: {
  workerId: ReturnType<typeof createDenTypeId<"worker">>
  runtimeUrls?: string[]
  requests: Array<{ url: string; init: RequestInit }>
  response?: (url: string, init: RequestInit) => Response | Promise<Response>
  maxActiveRequestsPerWorker?: number
  hasWebAccess?: boolean
  onResolve?: () => void
}) {
  const app = new Hono<{ Variables: WorkerRouteVariables }>()
  const organizationId = createDenTypeId("organization")
  let resolveIndex = 0
  compatibility.registerCloudWorkerCompatibilityRoutes(app, {
    getOmniRushWebAccess: async () => ({ hasAccess: input.hasWebAccess ?? true }),
    authenticate: async ({ request, workerId }) => {
      if (workerId !== input.workerId) return null
      const bearer = request.headers.get("authorization")?.replace(/^Bearer\s+/i, "") ?? ""
      const host = request.headers.get("x-omnirush-host-token") ?? ""
      if (host === "host-token" || bearer === "host-token") return { organizationId, scope: "host" }
      if (bearer === "client-token") return { organizationId, scope: "client" }
      return null
    },
    resolveCloudAccess: async () => {
      input.onResolve?.()
      const urls = input.runtimeUrls ?? ["https://fresh.preview.example.test"]
      const url = urls[Math.min(resolveIndex, urls.length - 1)]
      resolveIndex += 1
      return {
        status: "ready",
        workerId: input.workerId,
        url,
        expiresAt: new Date("2026-08-27T12:00:00.000Z"),
        clientToken: "fresh-client-token",
        hostToken: "fresh-host-token",
      }
    },
    fetchImpl: async (url, init = {}) => {
      const normalized = { url: String(url), init }
      input.requests.push(normalized)
      return await input.response?.(normalized.url, init) ?? Response.json({ ok: true })
    },
    maxActiveRequestsPerWorker: input.maxActiveRequestsPerWorker,
  })
  return app
}

test("cloud worker OPTIONS bypasses global credentialed CORS for native origins", async () => {
  const app = new Hono<{ Variables: WorkerRouteVariables }>()
  compatibility.registerCloudWorkerCompatibilityPreflightRoute(app)
  app.use("*", cors({
    origin: ["https://browser.example.test"],
    credentials: true,
    allowHeaders: ["Content-Type", "Authorization"],
    allowMethods: ["GET", "POST", "OPTIONS"],
  }))
  compatibility.registerCloudWorkerCompatibilityRoutes(app, {
    authenticate: async () => {
      throw new Error("preflight must not authenticate")
    },
  })

  for (const origin of ["null", "omnirush://desktop"]) {
    const response = await app.request("https://den.example.test/v1/cloud/workers/worker_native/health", {
      method: "OPTIONS",
      headers: {
        Origin: origin,
        "Access-Control-Request-Method": "PATCH",
        "Access-Control-Request-Headers": "content-type,x-omnirush-host-token,x-opencode-directory",
      },
    })
    expect(response.status).toBe(204)
    expect(response.headers.get("access-control-allow-origin")).toBe(origin)
    expect(response.headers.get("access-control-allow-credentials")).toBeNull()
    expect(response.headers.get("access-control-allow-headers")?.toLowerCase()).toContain("x-omnirush-host-token")
    expect(response.headers.get("access-control-allow-methods")).toContain("PATCH")
  }

  const unrelated = await app.request("https://den.example.test/v1/other", {
    method: "OPTIONS",
    headers: { Origin: "omnirush://desktop", "Access-Control-Request-Method": "POST" },
  })
  expect(unrelated.headers.get("access-control-allow-origin")).toBeNull()
})

test("stable cloud worker route refreshes the preview on every request", async () => {
  const workerId = createDenTypeId("worker")
  const requests: Array<{ url: string; init: RequestInit }> = []
  const app = registerCompatibilityTestApp({
    workerId,
    runtimeUrls: ["https://preview-a.example.test", "https://preview-b.example.test"],
    requests,
  })
  const stableUrl = `https://den.example.test/v1/cloud/workers/${workerId}/health?probe=1`
  const headers = { Authorization: "Bearer client-token" }

  expect((await app.request(stableUrl, { headers })).status).toBe(200)
  expect((await app.request(stableUrl, { headers })).status).toBe(200)
  expect(requests.map((request) => request.url)).toEqual([
    "https://preview-a.example.test/health?probe=1",
    "https://preview-b.example.test/health?probe=1",
  ])
})

test("stable cloud worker route requires Web access before resolving or calling the VM", async () => {
  const workerId = createDenTypeId("worker")
  const requests: Array<{ url: string; init: RequestInit }> = []
  let resolutions = 0
  const app = registerCompatibilityTestApp({
    workerId,
    requests,
    hasWebAccess: false,
    onResolve: () => {
      resolutions += 1
    },
  })

  const response = await app.request(
    `https://den.example.test/v1/cloud/workers/${workerId}/workspace/demo/sessions`,
    { method: "POST", headers: { "X-OmniRush-Host-Token": "host-token" } },
  )

  expect(response.status).toBe(403)
  expect(await response.json()).toEqual({
    error: "omnirush_web_access_required",
    message: "An active OmniRush.ai Web subscription or complimentary access is required to use OmniRush.ai Cloud.",
  })
  expect(resolutions).toBe(0)
  expect(requests).toHaveLength(0)
})

test("stable cloud worker route enforces worker token and method scope", async () => {
  const workerId = createDenTypeId("worker")
  const requests: Array<{ url: string; init: RequestInit }> = []
  const app = registerCompatibilityTestApp({ workerId, requests })
  const route = `https://den.example.test/v1/cloud/workers/${workerId}/workspace/demo/config`

  const clientRead = await app.request(route, { headers: { Authorization: "Bearer client-token" } })
  const clientWrite = await app.request(route, {
    method: "PUT",
    headers: { Authorization: "Bearer client-token", "Content-Type": "application/json" },
    body: "{}",
  })
  const wrongWorker = await app.request(
    `https://den.example.test/v1/cloud/workers/${createDenTypeId("worker")}/health`,
    { headers: { Authorization: "Bearer client-token" } },
  )
  const hostWrite = await app.request(route, {
    method: "PUT",
    headers: { "X-OmniRush-Host-Token": "host-token", "Content-Type": "application/json" },
    body: "{}",
  })
  const desktopHandoffWrite = await app.request(route, {
    method: "POST",
    headers: { Authorization: "Bearer host-token", "Content-Type": "application/json" },
    body: JSON.stringify({ from: "desktop-handoff" }),
  })

  expect(clientRead.status).toBe(200)
  expect(clientWrite.status).toBe(401)
  expect(await clientWrite.json()).toEqual({ error: "unauthorized" })
  expect(clientWrite.headers.get("cache-control")).toBe("no-store")
  expect(wrongWorker.status).toBe(401)
  expect(await wrongWorker.json()).toEqual({ error: "unauthorized" })
  expect(hostWrite.status).toBe(200)
  expect(desktopHandoffWrite.status).toBe(200)
  expect(requests).toHaveLength(3)
  const handoffHeaders = new Headers(requests[2]?.init.headers)
  expect(handoffHeaders.get("authorization")).toBe("Bearer fresh-client-token")
  expect(handoffHeaders.get("x-omnirush-host-token")).toBe("fresh-host-token")
})

test("stable cloud worker route safely proxies bodies, headers, and streaming responses", async () => {
  const workerId = createDenTypeId("worker")
  const requests: Array<{ url: string; init: RequestInit }> = []
  const encoder = new TextEncoder()
  const app = registerCompatibilityTestApp({
    workerId,
    requests,
    response: (url) => {
      if (url.includes("/event-stream")) {
        return new Response(new ReadableStream({
          start(controller) {
            controller.enqueue(encoder.encode("data: one\n\n"))
            controller.enqueue(encoder.encode("data: two\n\n"))
            controller.close()
          },
        }), {
          headers: {
            "Content-Type": "text/event-stream",
            Connection: "x-runtime-secret",
            "X-Runtime-Secret": "hidden",
            Location: "https://attacker.example.test",
          },
        })
      }
      return Response.json({ saved: true }, {
        headers: { "Content-Encoding": "gzip", "Set-Cookie": "runtime=secret" },
      })
    },
  })
  const route = `https://den.example.test/v1/cloud/workers/${workerId}`
  const write = await app.request(`${route}/workspace/demo/config?mode=replace`, {
    method: "PATCH",
    headers: {
      "Content-Type": "application/json",
      Connection: "x-client-secret",
      "X-Client-Secret": "hidden",
      "X-OmniRush-Host-Token": "host-token",
    },
    body: JSON.stringify({ enabled: true }),
  })
  const stream = await app.request(`${route}/event-stream?cursor=2`, {
    headers: { Authorization: "Bearer client-token", "Last-Event-ID": "one" },
  })

  expect(write.status).toBe(200)
  expect(await write.json()).toEqual({ saved: true })
  expect(requests[0]?.url).toBe("https://fresh.preview.example.test/workspace/demo/config?mode=replace")
  expect(requests[0]?.init.method).toBe("PATCH")
  expect(await new Response(requests[0]?.init.body).text()).toBe(JSON.stringify({ enabled: true }))
  const writeHeaders = new Headers(requests[0]?.init.headers)
  expect(writeHeaders.get("authorization")).toBe("Bearer fresh-client-token")
  expect(writeHeaders.get("x-omnirush-host-token")).toBe("fresh-host-token")
  expect(writeHeaders.get("x-client-secret")).toBeNull()
  expect(requests[0]?.init.redirect).toBe("error")
  expect(write.headers.get("content-encoding")).toBeNull()
  expect(write.headers.get("set-cookie")).toBeNull()
  expect(write.headers.get("cache-control")).toBe("no-store")

  expect(stream.status).toBe(200)
  expect(stream.headers.get("content-type")).toBe("text/event-stream")
  expect(stream.headers.get("x-runtime-secret")).toBeNull()
  expect(stream.headers.get("location")).toBeNull()
  expect(stream.headers.get("cache-control")).toBe("no-store")
  expect(await stream.text()).toBe("data: one\n\ndata: two\n\n")
  const streamHeaders = new Headers(requests[1]?.init.headers)
  expect(streamHeaders.get("authorization")).toBe("Bearer fresh-client-token")
  expect(streamHeaders.get("x-omnirush-host-token")).toBeNull()
  expect(streamHeaders.get("last-event-id")).toBe("one")
})

test("stable cloud worker route never relays a runtime redirect", async () => {
  const workerId = createDenTypeId("worker")
  const requests: Array<{ url: string; init: RequestInit }> = []
  const app = registerCompatibilityTestApp({
    workerId,
    requests,
    response: () => new Response(null, {
      status: 302,
      headers: { Location: "https://attacker.example.test/redirected" },
    }),
  })
  const response = await app.request(`https://den.example.test/v1/cloud/workers/${workerId}/health`, {
    headers: { Authorization: "Bearer client-token" },
  })

  expect(response.status).toBe(502)
  expect(response.headers.get("location")).toBeNull()
  expect(await response.json()).toEqual({ error: "worker_runtime_proxy_failed" })
  expect(requests[0]?.init.redirect).toBe("error")
})

test("stable cloud worker route streams a multi-chunk large request without buffering", async () => {
  const workerId = createDenTypeId("worker")
  const requests: Array<{ url: string; init: RequestInit }> = []
  const observedChunks: Array<{ length: number; firstByte: number }> = []
  const app = registerCompatibilityTestApp({
    workerId,
    requests,
    response: async (_url, init) => {
      expect("duplex" in init && init.duplex).toBe("half")
      const body = new Response(init.body).body
      if (!body) throw new Error("upstream request body was not streamed")
      const reader = body.getReader()
      for (;;) {
        const chunk = await reader.read()
        if (chunk.done) break
        observedChunks.push({ length: chunk.value.byteLength, firstByte: chunk.value[0] ?? -1 })
      }
      return Response.json({ streamed: true })
    },
  })
  const route = `https://den.example.test/v1/cloud/workers/${workerId}/workspace/demo/files/raw`
  const chunkSize = 3 * 1024 * 1024
  const body = new ReadableStream<Uint8Array>({
    start(controller) {
      for (const value of [1, 2, 3]) controller.enqueue(new Uint8Array(chunkSize).fill(value))
      controller.close()
    },
  })
  const requestInit: RequestInit & { duplex: "half" } = {
    method: "POST",
    headers: { "X-OmniRush-Host-Token": "host-token" },
    body,
    duplex: "half",
  }
  const response = await app.request(new Request(route, requestInit))

  expect(response.status).toBe(200)
  expect(await response.json()).toEqual({ streamed: true })
  expect(observedChunks).toEqual([
    { length: chunkSize, firstByte: 1 },
    { length: chunkSize, firstByte: 2 },
    { length: chunkSize, firstByte: 3 },
  ])
  expect(requests).toHaveLength(1)
})

test("stable cloud worker route releases its slot after an upstream request error", async () => {
  const workerId = createDenTypeId("worker")
  const requests: Array<{ url: string; init: RequestInit }> = []
  let calls = 0
  const app = registerCompatibilityTestApp({
    workerId,
    requests,
    maxActiveRequestsPerWorker: 1,
    response: () => {
      calls += 1
      if (calls === 1) throw new Error("upstream failed")
      return Response.json({ recovered: true })
    },
  })
  const route = `https://den.example.test/v1/cloud/workers/${workerId}/health`
  const failed = await app.request(route, { headers: { Authorization: "Bearer client-token" } })
  const recovered = await app.request(route, { headers: { Authorization: "Bearer client-token" } })

  expect(failed.status).toBe(502)
  expect(recovered.status).toBe(200)
  expect(await recovered.json()).toEqual({ recovered: true })
})

test("stable cloud worker route limits active streams and releases on cancel", async () => {
  const workerId = createDenTypeId("worker")
  const requests: Array<{ url: string; init: RequestInit }> = []
  let upstreamCalls = 0
  const app = registerCompatibilityTestApp({
    workerId,
    requests,
    maxActiveRequestsPerWorker: 1,
    response: () => {
      upstreamCalls += 1
      if (upstreamCalls > 1) return Response.json({ ok: true })
      return new Response(new ReadableStream({ start(controller) { controller.enqueue(new TextEncoder().encode("data: held\n\n")) } }), {
        headers: { "Content-Type": "text/event-stream" },
      })
    },
  })
  const route = `https://den.example.test/v1/cloud/workers/${workerId}/event-stream`
  const first = await app.request(route, { headers: { Authorization: "Bearer client-token" } })
  const limited = await app.request(route, { headers: { Authorization: "Bearer client-token" } })

  expect(first.status).toBe(200)
  expect(limited.status).toBe(429)
  expect(limited.headers.get("retry-after")).toBe("1")
  await first.body?.cancel()

  const afterCancel = await app.request(route, { headers: { Authorization: "Bearer client-token" } })
  expect(afterCancel.status).toBe(200)
  expect(await afterCancel.json()).toEqual({ ok: true })
  const afterClose = await app.request(route, { headers: { Authorization: "Bearer client-token" } })
  expect(afterClose.status).toBe(200)
  await afterClose.body?.cancel()
})