artificial-code 1.17.13 → 1.17.15

package/test/server/workspace-proxy.test.ts

@@ -1,181 +0,0 @@
-import { NodeHttpServer, NodeServices } from "@effect/platform-node"
-import Http from "node:http"
-import { describe, expect } from "bun:test"
-import { Context, Effect, Layer, Queue } from "effect"
-import { FetchHttpClient, HttpClient, HttpServer, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
-import * as Socket from "effect/unstable/socket/Socket"
-import { HttpApiProxy } from "../../src/server/routes/instance/httpapi/middleware/proxy"
-import { testEffect } from "../lib/effect"
-
-function serverUrl() {
-  return HttpServer.HttpServer.use((server) => Effect.succeed(HttpServer.formatAddress(server.address)))
-}
-
-const testServerLayer = Layer.mergeAll(
-  NodeHttpServer.layer(Http.createServer, { host: "127.0.0.1", port: 0 }),
-  NodeServices.layer,
-  FetchHttpClient.layer,
-  Socket.layerWebSocketConstructorGlobal,
-)
-const it = testEffect(testServerLayer)
-
-type TestHandler<E, R> = (
-  request: HttpServerRequest.HttpServerRequest,
-) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>
-
-function listenServer<E, R>(handler: TestHandler<E, R>) {
-  return Effect.gen(function* () {
-    yield* HttpServer.serveEffect()(HttpServerRequest.HttpServerRequest.use(handler))
-    return yield* serverUrl()
-  })
-}
-
-function listenTestServer<E, R>(handler: TestHandler<E, R>) {
-  return Effect.gen(function* () {
-    // Build into the current test scope so the listener stays alive until the
-    // test finishes. Using Effect.provide here would release it immediately.
-    const context = yield* Layer.build(NodeHttpServer.layer(Http.createServer, { host: "127.0.0.1", port: 0 }))
-    const server = Context.get(context, HttpServer.HttpServer)
-    yield* server.serve(HttpServerRequest.HttpServerRequest.use(handler))
-    return HttpServer.formatAddress(server.address)
-  })
-}
-
-function echoWebSocket(request: HttpServerRequest.HttpServerRequest) {
-  return Effect.gen(function* () {
-    const socket = yield* Effect.orDie(request.upgrade)
-    const write = yield* socket.writer
-    // The upstream announces the negotiated protocol, then echoes every
-    // received frame. The assertions use those messages to prove proxy flow.
-    yield* socket
-      .runRaw((message) => write(`echo:${String(message)}`), {
-        onOpen: write(`protocol:${request.headers["sec-websocket-protocol"] ?? "none"}`).pipe(
-          Effect.catch(() => Effect.void),
-        ),
-      })
-      .pipe(Effect.catch(() => Effect.void))
-    return HttpServerResponse.empty()
-  })
-}
-
-describe("HttpApi workspace proxy", () => {
-  it.live("proxies HTTP request and returns streamed response with status and headers", () =>
-    Effect.gen(function* () {
-      const url = yield* listenServer(
-        Effect.fnUntraced(function* (req: HttpServerRequest.HttpServerRequest) {
-          const body = yield* req.text
-          return yield* HttpServerResponse.json(
-            { path: req.url, method: req.method, body },
-            {
-              status: 201,
-              headers: {
-                "content-encoding": "identity",
-                "content-length": "999",
-                "x-remote": "yes",
-              },
-            },
-          )
-        }),
-      )
-
-      const request = HttpServerRequest.fromWeb(
-        new Request("http://localhost/session/abc", { method: "POST", body: "request-body" }),
-      )
-      const httpClient = yield* HttpClient.HttpClient
-      const response = yield* HttpApiProxy.http(
-        httpClient,
-        `${url}/session/abc?keep=yes`,
-        { "x-extra": "injected" },
-        request,
-      )
-
-      expect(response.status).toBe(201)
-      const client = HttpServerResponse.toClientResponse(response)
-      expect(yield* client.json).toEqual({
-        path: "/session/abc?keep=yes",
-        method: "POST",
-        body: "request-body",
-      })
-      expect(response.headers["x-remote"]).toBe("yes")
-      expect(response.headers["content-encoding"]).toBeUndefined()
-      expect(response.headers["content-length"]).toBeUndefined()
-    }),
-  )
-
-  it.live("returns 500 when remote is unreachable", () =>
-    Effect.gen(function* () {
-      const request = HttpServerRequest.fromWeb(new Request("http://localhost/anything"))
-      const httpClient = yield* HttpClient.HttpClient
-      const response = yield* HttpApiProxy.http(httpClient, "http://127.0.0.1:1/unreachable", undefined, request)
-
-      expect(response.status).toBe(500)
-    }),
-  )
-
-  it.live("proxies bodyless Web mutation requests as an empty body", () =>
-    Effect.gen(function* () {
-      const url = yield* listenServer(
-        Effect.fnUntraced(function* (req: HttpServerRequest.HttpServerRequest) {
-          return yield* HttpServerResponse.json({ method: req.method, body: yield* req.text })
-        }),
-      )
-      const request = HttpServerRequest.fromWeb(new Request("http://localhost/session/abc/abort", { method: "POST" }))
-      const httpClient = yield* HttpClient.HttpClient
-      const response = yield* HttpApiProxy.http(httpClient, `${url}/session/abc/abort`, undefined, request)
-
-      expect(response.status).toBe(200)
-      expect(yield* HttpServerResponse.toClientResponse(response).json).toEqual({ method: "POST", body: "" })
-    }),
-  )
-
-  it.live("strips opencode-internal headers and merges extra headers", () =>
-    Effect.gen(function* () {
-      let forwarded: Record<string, string> = {}
-      const url = yield* listenServer((req) =>
-        Effect.sync(() => {
-          forwarded = req.headers
-          return HttpServerResponse.empty()
-        }),
-      )
-
-      const request = HttpServerRequest.fromWeb(
-        new Request("http://localhost/test", {
-          headers: {
-            "x-opencode-directory": "/secret/path",
-            "x-opencode-workspace": "ws_123",
-            "x-custom": "preserved",
-          },
-        }),
-      )
-      const httpClient = yield* HttpClient.HttpClient
-      yield* HttpApiProxy.http(httpClient, `${url}/test`, { "x-injected": "extra" }, request)
-
-      expect(forwarded["x-opencode-directory"]).toBeUndefined()
-      expect(forwarded["x-opencode-workspace"]).toBeUndefined()
-      expect(forwarded["x-custom"]).toBe("preserved")
-      expect(forwarded["x-injected"]).toBe("extra")
-    }),
-  )
-
-  it.live("proxies websocket messages and protocols", () =>
-    Effect.gen(function* () {
-      const upstreamUrl = yield* listenTestServer(echoWebSocket)
-
-      // Client -> proxy listener -> HttpApiProxy.websocket -> upstream listener.
-      // The client never connects to upstream directly.
-      const proxyUrl = yield* listenServer((request) => HttpApiProxy.websocket(request, `${upstreamUrl}/echo`))
-
-      const socket = yield* Socket.makeWebSocket(`${proxyUrl.replace(/^http/, "ws")}/proxy`, {
-        closeCodeIsError: () => false,
-        protocols: "chat",
-      })
-      const messages = yield* Queue.unbounded<string>()
-      yield* socket.runRaw((message) => Queue.offer(messages, String(message))).pipe(Effect.forkScoped)
-      const write = yield* socket.writer
-
-      expect(yield* Queue.take(messages)).toBe("protocol:chat")
-      yield* write("hello")
-      expect(yield* Queue.take(messages)).toBe("echo:hello")
-    }),
-  )
-})

package/test/server/workspace-routing.test.ts

@@ -1,94 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import {
-  isLocalWorkspaceRoute,
-  getWorkspaceRouteSessionID,
-  workspaceProxyURL,
-} from "../../src/server/shared/workspace-routing"
-import { SessionID } from "../../src/session/schema"
-
-describe("isLocalWorkspaceRoute", () => {
-  test("GET /session is local", () => {
-    expect(isLocalWorkspaceRoute("GET", "/session")).toBe(true)
-  })
-
-  test("GET /session/ses_abc is local (prefix match)", () => {
-    expect(isLocalWorkspaceRoute("GET", "/session/ses_abc")).toBe(true)
-  })
-
-  test("POST /session is not local (method mismatch)", () => {
-    expect(isLocalWorkspaceRoute("POST", "/session")).toBe(false)
-  })
-
-  test("/session/status is forwarded regardless of method", () => {
-    expect(isLocalWorkspaceRoute("GET", "/session/status")).toBe(false)
-    expect(isLocalWorkspaceRoute("POST", "/session/status")).toBe(false)
-  })
-
-  test("unrecognized paths are not local", () => {
-    expect(isLocalWorkspaceRoute("GET", "/config")).toBe(false)
-    expect(isLocalWorkspaceRoute("POST", "/session/ses_abc/message")).toBe(false)
-  })
-})
-
-describe("getWorkspaceRouteSessionID", () => {
-  test("extracts session ID from path", () => {
-    const url = new URL("http://localhost/session/ses_abc123/message")
-    expect(getWorkspaceRouteSessionID(url)).toBe(SessionID.make("ses_abc123"))
-  })
-
-  test("extracts session ID without trailing path", () => {
-    const url = new URL("http://localhost/session/ses_xyz")
-    expect(getWorkspaceRouteSessionID(url)).toBe(SessionID.make("ses_xyz"))
-  })
-
-  test("extracts session ID from experimental background path", () => {
-    const url = new URL("http://localhost/experimental/session/ses_bg/background")
-    expect(getWorkspaceRouteSessionID(url)).toBe(SessionID.make("ses_bg"))
-  })
-
-  test("returns null for /session/status", () => {
-    const url = new URL("http://localhost/session/status")
-    expect(getWorkspaceRouteSessionID(url)).toBeNull()
-  })
-
-  test("returns null for non-session paths", () => {
-    const url = new URL("http://localhost/config")
-    expect(getWorkspaceRouteSessionID(url)).toBeNull()
-  })
-
-  test("returns null for bare /session path", () => {
-    const url = new URL("http://localhost/session")
-    expect(getWorkspaceRouteSessionID(url)).toBeNull()
-  })
-})
-
-describe("workspaceProxyURL", () => {
-  test("appends request path to target", () => {
-    const result = workspaceProxyURL("http://remote:8080/base", new URL("http://localhost/config"))
-    expect(result.toString()).toBe("http://remote:8080/base/config")
-  })
-
-  test("strips trailing slash on target before appending", () => {
-    const result = workspaceProxyURL("http://remote:8080/base/", new URL("http://localhost/session/abc"))
-    expect(result.pathname).toBe("/base/session/abc")
-  })
-
-  test("preserves query params from request but removes workspace", () => {
-    const url = new URL("http://localhost/config?workspace=ws_123&keep=yes")
-    const result = workspaceProxyURL("http://remote:8080/base", url)
-    expect(result.searchParams.get("workspace")).toBeNull()
-    expect(result.searchParams.get("keep")).toBe("yes")
-  })
-
-  test("preserves hash from request", () => {
-    const url = new URL("http://localhost/page#section")
-    const result = workspaceProxyURL("http://remote:8080", url)
-    expect(result.hash).toBe("#section")
-  })
-
-  test("works with URL object as target", () => {
-    const target = new URL("http://remote:3000/api")
-    const result = workspaceProxyURL(target, new URL("http://localhost/users"))
-    expect(result.toString()).toBe("http://remote:3000/api/users")
-  })
-})

package/test/server/worktree-endpoint-repro.test.ts

@@ -1,307 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Layer, Queue } from "effect"
-import { Flag } from "@ac/core/flag/flag"
-import { GlobalBus, type GlobalEvent } from "@/bus/global"
-import { Worktree } from "@/worktree"
-import { Server } from "../../src/server/server"
-import { ExperimentalPaths } from "../../src/server/routes/instance/httpapi/groups/experimental"
-import { WorkspacePaths } from "../../src/server/routes/instance/httpapi/groups/workspace"
-import { resetDatabase } from "../fixture/db"
-import { disposeAllInstances, TestInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-const stateLayer = Layer.effectDiscard(
-  Effect.gen(function* () {
-    const original = {
-      AC_EXPERIMENTAL_WORKSPACES: Flag.AC_EXPERIMENTAL_WORKSPACES,
-    }
-
-    Flag.AC_EXPERIMENTAL_WORKSPACES = true
-
-    yield* Effect.addFinalizer(() =>
-      Effect.promise(async () => {
-        Flag.AC_EXPERIMENTAL_WORKSPACES = original.AC_EXPERIMENTAL_WORKSPACES
-        await resetDatabase()
-      }),
-    )
-  }),
-)
-
-const it = testEffect(stateLayer)
-const worktreeTest = process.platform === "win32" ? it.instance.skip : it.instance
-type TestServer = ReturnType<typeof Server.Default>["app"]
-type CreatedWorktree = { directory: string }
-type ScopedWorktree = { directory: string; body: CreatedWorktree; ready: Effect.Effect<void, Error> }
-
-function serverScoped() {
-  return Effect.sync(() => Server.Default().app)
-}
-
-function request(server: TestServer, input: string, init?: RequestInit) {
-  return Effect.promise(() => Promise.resolve(server.request(input, init)))
-}
-
-function withRequestTimeout(effect: Effect.Effect<Response>, label: string, ms = 5_000) {
-  return effect.pipe(
-    Effect.timeoutOrElse({
-      duration: `${ms} millis`,
-      orElse: () => Effect.fail(new Error(`${label} timed out after ${ms}ms`)),
-    }),
-  )
-}
-
-function json<T>(response: Response) {
-  return Effect.promise(() => response.json() as Promise<T>)
-}
-
-function readyWatcher() {
-  return Effect.gen(function* () {
-    const events = yield* Queue.bounded<GlobalEvent>(1)
-    const on = (event: GlobalEvent) => {
-      if (event.payload.type === Worktree.Event.Ready.type) Queue.offerUnsafe(events, event)
-    }
-
-    GlobalBus.on("event", on)
-    yield* Effect.addFinalizer(() => Effect.sync(() => GlobalBus.off("event", on)))
-
-    return (directory: string) =>
-      Effect.gen(function* () {
-        while (true) {
-          const event = yield* Queue.take(events)
-          if (event.directory === directory) return
-        }
-      }).pipe(
-        Effect.timeoutOrElse({
-          duration: "10 seconds",
-          orElse: () => Effect.fail(new Error(`timed out waiting for worktree.ready: ${directory}`)),
-        }),
-      )
-  })
-}
-
-function removeCreatedWorktree(input: {
-  server: TestServer
-  rootDirectory: string
-  worktreeDirectory: string
-  ready: Effect.Effect<void, Error>
-}) {
-  return Effect.gen(function* () {
-    yield* input.ready.pipe(Effect.timeout("1 second"), Effect.ignore)
-    yield* Effect.promise(() => disposeAllInstances()).pipe(Effect.ignore)
-
-    const removed = yield* request(
-      input.server,
-      `${ExperimentalPaths.worktree}?directory=${encodeURIComponent(input.rootDirectory)}`,
-      {
-        method: "DELETE",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ directory: input.worktreeDirectory }),
-      },
-    )
-    if (removed.status !== 200) {
-      const message = yield* Effect.promise(() => removed.text())
-      throw new Error(`failed to remove worktree: ${removed.status} ${message}`)
-    }
-    const ok = yield* json<boolean>(removed)
-    if (!ok) throw new Error(`failed to remove worktree ${input.worktreeDirectory}`)
-  })
-}
-
-function createWorktreeScoped(input: {
-  server: TestServer
-  directory: string
-  path: string
-  init: RequestInit
-  timeoutLabel: string
-  timeoutMs?: number
-}) {
-  return Effect.acquireRelease(
-    Effect.gen(function* () {
-      const waitReady = yield* readyWatcher()
-      const response = yield* withRequestTimeout(
-        request(input.server, input.path, input.init),
-        input.timeoutLabel,
-        input.timeoutMs,
-      )
-      if (response.status !== 200) {
-        const message = yield* Effect.promise(() => response.text())
-        throw new Error(`${input.timeoutLabel} failed: ${response.status} ${message}`)
-      }
-      expect(response.status).toBe(200)
-      const body = yield* json<CreatedWorktree>(response)
-      return { directory: body.directory, body, ready: waitReady(body.directory) } satisfies ScopedWorktree
-    }),
-    (created) =>
-      removeCreatedWorktree({
-        server: input.server,
-        rootDirectory: input.directory,
-        worktreeDirectory: created.directory,
-        ready: created.ready,
-      }).pipe(Effect.orDie),
-  ).pipe(Effect.map((created) => created.body))
-}
-
-function setProjectStartCommand(input: { server: TestServer; directory: string; command: string }) {
-  return Effect.gen(function* () {
-    const current = yield* request(input.server, `/project/current?directory=${encodeURIComponent(input.directory)}`)
-    expect(current.status).toBe(200)
-    const project = yield* json<{ id: string }>(current)
-    const updated = yield* request(
-      input.server,
-      `/project/${project.id}?directory=${encodeURIComponent(input.directory)}`,
-      {
-        method: "PATCH",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ commands: { start: input.command } }),
-      },
-    )
-    expect(updated.status).toBe(200)
-  })
-}
-
-describe("worktree endpoint reproduction", () => {
-  worktreeTest(
-    "direct HttpApi worktree create returns without waiting for boot",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        const server = yield* serverScoped()
-
-        const response = yield* createWorktreeScoped({
-          server,
-          directory: test.directory,
-          path: `${ExperimentalPaths.worktree}?directory=${encodeURIComponent(test.directory)}`,
-          init: {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({}),
-          },
-          timeoutLabel: "direct worktree create",
-        })
-
-        expect(response).toMatchObject({ directory: expect.any(String) })
-      }),
-    { git: true },
-  )
-
-  worktreeTest(
-    "direct HttpApi worktree create accepts missing body",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        const server = yield* serverScoped()
-
-        const response = yield* createWorktreeScoped({
-          server,
-          directory: test.directory,
-          path: `${ExperimentalPaths.worktree}?directory=${encodeURIComponent(test.directory)}`,
-          init: { method: "POST", headers: { "content-type": "application/json" } },
-          timeoutLabel: "direct worktree create without body",
-        })
-
-        expect(response).toMatchObject({ directory: expect.any(String) })
-      }),
-    { git: true },
-  )
-
-  worktreeTest(
-    "direct HttpApi worktree create accepts missing content type and body",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        const server = yield* serverScoped()
-
-        const response = yield* createWorktreeScoped({
-          server,
-          directory: test.directory,
-          path: `${ExperimentalPaths.worktree}?directory=${encodeURIComponent(test.directory)}`,
-          init: { method: "POST" },
-          timeoutLabel: "direct worktree create without content type or body",
-        })
-
-        expect(response).toMatchObject({ directory: expect.any(String) })
-      }),
-    { git: true },
-  )
-
-  worktreeTest(
-    "direct HttpApi worktree create rejects explicit null payload",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        const server = yield* serverScoped()
-
-        const response = yield* request(
-          server,
-          `${ExperimentalPaths.worktree}?directory=${encodeURIComponent(test.directory)}`,
-          {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: "null",
-          },
-        )
-
-        expect(response.status).toBe(400)
-      }),
-    { git: true },
-  )
-
-  worktreeTest(
-    "workspace worktree create does not hang",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        const server = yield* serverScoped()
-
-        const response = yield* createWorktreeScoped({
-          server,
-          directory: test.directory,
-          path: `${WorkspacePaths.list}?directory=${encodeURIComponent(test.directory)}`,
-          init: {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ type: "worktree", branch: null }),
-          },
-          timeoutLabel: "workspace worktree create",
-          timeoutMs: 8_000,
-        })
-
-        expect(response).toMatchObject({
-          type: "worktree",
-          directory: expect.any(String),
-        })
-      }),
-    { git: true },
-  )
-
-  worktreeTest(
-    "workspace worktree create returns without waiting for project start command",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        const server = yield* serverScoped()
-        yield* setProjectStartCommand({
-          server,
-          directory: test.directory,
-          command: 'bun -e "setTimeout(() => {}, 2000)"',
-        })
-
-        const started = Date.now()
-        yield* createWorktreeScoped({
-          server,
-          directory: test.directory,
-          path: `${WorkspacePaths.list}?directory=${encodeURIComponent(test.directory)}`,
-          init: {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ type: "worktree", branch: null }),
-          },
-          timeoutLabel: "workspace worktree create with project start command",
-          timeoutMs: 6_000,
-        })
-
-        expect(Date.now() - started).toBeLessThan(1_500)
-      }),
-    { git: true },
-  )
-})