openAgent

1import { afterEach, describe, expect, mock } from "bun:test"
2import { mkdir } from "node:fs/promises"
3import path from "node:path"
4import { Effect, Layer, Stream } from "effect"
5import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
6import { LayerNode } from "@opencode-ai/core/effect/layer-node"
7import { Flag } from "@opencode-ai/core/flag/flag"
8import { registerAdapter } from "../../src/control-plane/adapters"
9import { WorkspaceV2 } from "@opencode-ai/core/workspace"
10import type { WorkspaceAdapter } from "../../src/control-plane/types"
11import { Workspace } from "../../src/control-plane/workspace"
12import { WorkspacePaths } from "../../src/server/routes/instance/httpapi/groups/workspace"
13import { EventPaths } from "../../src/server/routes/instance/httpapi/groups/event"
14import { Session } from "@/session/session"
15import { Database } from "@opencode-ai/core/database/database"
16import { Ripgrep } from "@opencode-ai/core/ripgrep"
17import { Server } from "../../src/server/server"
18import { resetDatabase } from "../fixture/db"
19import { disposeAllInstances, provideInstance, tmpdirScoped } from "../fixture/fixture"
20import { InstanceBootstrap } from "../../src/project/bootstrap"
21import { InstanceStore } from "../../src/project/instance-store"
22import { Project } from "../../src/project/project"
23import { InstancePaths } from "../../src/server/routes/instance/httpapi/groups/instance"
24import { testEffect } from "../lib/effect"
25import { httpApiLayer, requestInDirectory } from "./httpapi-layer"
26 
27const originalWorkspaces = Flag.OPENCODE_EXPERIMENTAL_WORKSPACES
28const appLayer = AppNodeBuilder.build(
29  LayerNode.group([Project.node, Session.node, Workspace.node, InstanceStore.node, Database.node, Ripgrep.node]),
30  [[InstanceStore.bootstrapNode, InstanceBootstrap.node]],
31)
32const it = testEffect(Layer.mergeAll(appLayer, httpApiLayer))
33 
34function request(path: string, directory: string, init: RequestInit = {}) {
35  return requestInDirectory(path, directory, init)
36}
37 
38function requestDefault(path: string, directory: string, init: RequestInit = {}) {
39  return requestInDirectory(path, directory, init)
40}
41 
42function requestServer(path: string, directory: string, init: RequestInit = {}) {
43  const headers = new Headers(init.headers)
44  headers.set("x-opencode-directory", directory)
45  return Effect.promise(() => Promise.resolve(Server.Default().app.request(path, { ...init, headers })))
46}
47 
48function localAdapter(directory: string): WorkspaceAdapter {
49  return {
50    name: "Local Test",
51    description: "Create a local test workspace",
52    configure(info) {
53      return {
54        ...info,
55        name: "local-test",
56        directory,
57      }
58    },
59    async create() {
60      await mkdir(directory, { recursive: true })
61    },
62    async remove() {},
63    target() {
64      return {
65        type: "local" as const,
66        directory,
67      }
68    },
69  }
70}
71 
72function listedAdapter(directory: string, type: string): WorkspaceAdapter {
73  return {
74    name: "Listed Test",
75    description: "List a local test workspace",
76    configure(info) {
77      return { ...info, name: "unused", directory }
78    },
79    async create() {},
80    async remove() {},
81    list(context) {
82      return [
83        {
84          type,
85          name: "listed-test",
86          branch: "listed/main",
87          directory,
88          extra: { listed: true },
89          projectID: context?.instance?.project.id ?? missingAdapterContext(),
90        },
91      ]
92    },
93    target() {
94      return {
95        type: "local" as const,
96        directory,
97      }
98    },
99  }
100}
101 
102function missingAdapterContext(): never {
103  throw new Error("missing workspace adapter context")
104}
105 
106function remoteAdapter(directory: string, url: string, headers?: HeadersInit): WorkspaceAdapter {
107  return {
108    name: "Remote Test",
109    description: "Create a remote test workspace",
110    configure(info) {
111      return {
112        ...info,
113        name: "remote-test",
114        directory,
115      }
116    },
117    async create() {
118      await mkdir(directory, { recursive: true })
119    },
120    async remove() {},
121    target() {
122      return {
123        type: "remote" as const,
124        url,
125        headers,
126      }
127    },
128  }
129}
130 
131type ProxiedRequest = {
132  url: string
133  method: string
134  headers: Record<string, string>
135  body: string
136}
137 
138function listenRemoteHttp(handler: (request: ProxiedRequest) => Response | Promise<Response>) {
139  return Bun.serve({
140    port: 0,
141    async fetch(request) {
142      return handler({
143        url: request.url,
144        method: request.method,
145        headers: Object.fromEntries(request.headers.entries()),
146        body: await request.text(),
147      })
148    },
149  })
150}
151 
152function eventStreamResponse() {
153  return new Response(
154    new ReadableStream({
155      start(controller) {
156        controller.enqueue(
157          new TextEncoder().encode('data: {"payload":{"type":"server.connected","properties":{}}}\n\n'),
158        )
159      },
160    }),
161    {
162      status: 200,
163      headers: {
164        "content-type": "text/event-stream",
165      },
166    },
167  )
168}
169 
170afterEach(async () => {
171  mock.restore()
172  Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = originalWorkspaces
173  await disposeAllInstances()
174  await resetDatabase()
175})
176 
177describe("workspace HttpApi", () => {
178  it.live("serves read endpoints", () =>
179    Effect.gen(function* () {
180      const dir = yield* tmpdirScoped({ git: true })
181 
182      const [adapters, workspaces, status] = yield* Effect.all([
183        request(WorkspacePaths.adapters, dir),
184        request(WorkspacePaths.list, dir),
185        request(WorkspacePaths.status, dir),
186      ])
187 
188      expect(adapters.status).toBe(200)
189      expect(yield* adapters.json).toContainEqual({
190        type: "worktree",
191        name: "Worktree",
192        description: "Create a git worktree",
193      })
194 
195      expect(workspaces.status).toBe(200)
196      expect(yield* workspaces.json).toEqual([])
197 
198      expect(status.status).toBe(200)
199      expect(yield* status.json).toEqual([])
200    }),
201  )
202 
203  it.live("serves mutation endpoints", () =>
204    Effect.gen(function* () {
205      Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
206      const dir = yield* tmpdirScoped({ git: true })
207      const project = yield* Project.use.fromDirectory(dir)
208      registerAdapter(project.project.id, "local-test", localAdapter(path.join(dir, ".workspace")))
209 
210      const created = yield* request(WorkspacePaths.list, dir, {
211        method: "POST",
212        headers: { "content-type": "application/json" },
213        body: JSON.stringify({ type: "local-test", branch: null }),
214      })
215      expect(created.status).toBe(200)
216      const workspace = (yield* created.json) as Workspace.Info
217      expect(workspace).toMatchObject({ type: "local-test", name: "local-test" })
218 
219      const session = yield* Session.use.create({}).pipe(provideInstance(dir))
220      const warped = yield* request(WorkspacePaths.warp, dir, {
221        method: "POST",
222        headers: { "content-type": "application/json" },
223        body: JSON.stringify({ id: workspace.id, sessionID: session.id }),
224      })
225      expect(warped.status).toBe(204)
226 
227      const removed = yield* request(WorkspacePaths.remove.replace(":id", workspace.id), dir, { method: "DELETE" })
228      expect(removed.status).toBe(200)
229      expect(yield* removed.json).toMatchObject({ id: workspace.id })
230 
231      const listed = yield* request(WorkspacePaths.list, dir)
232      expect(listed.status).toBe(200)
233      expect(yield* listed.json).toEqual([])
234    }),
235  )
236 
237  it.live("serves list sync endpoint", () =>
238    Effect.gen(function* () {
239      Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
240      const dir = yield* tmpdirScoped({ git: true })
241      const project = yield* Project.use.fromDirectory(dir)
242      const type = `listed-${Math.random().toString(36).slice(2)}`
243      registerAdapter(project.project.id, type, listedAdapter(path.join(dir, ".listed"), type))
244 
245      const response = yield* request(WorkspacePaths.syncList, dir, { method: "POST" })
246 
247      expect(response.status).toBe(204)
248      const listed = yield* request(WorkspacePaths.list, dir)
249      expect(yield* listed.json).toMatchObject([
250        {
251          type,
252          name: "listed-test",
253          branch: "listed/main",
254          directory: path.join(dir, ".listed"),
255          extra: { listed: true },
256        },
257      ])
258    }),
259  )
260 
261  it.live("returns a declared not found error when warping into a missing workspace", () =>
262    Effect.gen(function* () {
263      const dir = yield* tmpdirScoped({ git: true })
264      const session = yield* Session.use.create({}).pipe(provideInstance(dir))
265      const workspaceID = WorkspaceV2.ID.ascending("wrk_missing_warp")
266 
267      const response = yield* request(WorkspacePaths.warp, dir, {
268        method: "POST",
269        headers: { "content-type": "application/json" },
270        body: JSON.stringify({ id: workspaceID, sessionID: session.id }),
271      })
272 
273      expect(response.status).toBe(404)
274      expect(yield* response.json).toEqual({
275        name: "NotFoundError",
276        data: { message: `Workspace not found: ${workspaceID}` },
277      })
278    }),
279  )
280 
281  it.live("creates workspace with the TUI payload shape", () =>
282    Effect.gen(function* () {
283      Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
284      const dir = yield* tmpdirScoped({ git: true })
285      const project = yield* Project.use.fromDirectory(dir)
286      registerAdapter(project.project.id, "local-test", localAdapter(path.join(dir, ".workspace")))
287 
288      const created = yield* request(WorkspacePaths.list, dir, {
289        method: "POST",
290        headers: { "content-type": "application/json" },
291        body: JSON.stringify({ type: "local-test", branch: null }),
292      })
293 
294      expect(created.status).toBe(200)
295      expect((yield* created.json) as Workspace.Info).toMatchObject({
296        type: "local-test",
297        name: "local-test",
298      })
299    }),
300  )
301 
302  it.live("creates a real git worktree workspace via the builtin adapter", () =>
303    Effect.gen(function* () {
304      Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
305      const dir = yield* tmpdirScoped({ git: true })
306 
307      const created = yield* requestServer(WorkspacePaths.list, dir, {
308        method: "POST",
309        headers: { "content-type": "application/json" },
310        body: JSON.stringify({ type: "worktree", branch: null }),
311      })
312 
313      const body = yield* Effect.promise(() => created.text())
314      expect({ status: created.status, body }).toMatchObject({ status: 200 })
315      const workspace = JSON.parse(body) as Workspace.Info
316      expect(workspace).toMatchObject({ type: "worktree" })
317    }),
318  )
319 
320  it.live("routes local workspace requests through the workspace target directory", () =>
321    Effect.gen(function* () {
322      Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
323      const dir = yield* tmpdirScoped({ git: true })
324      const workspaceDir = path.join(dir, ".workspace-local")
325      const project = yield* Project.use.fromDirectory(dir)
326      registerAdapter(project.project.id, "local-target", localAdapter(workspaceDir))
327      const created = yield* request(WorkspacePaths.list, dir, {
328        method: "POST",
329        headers: { "content-type": "application/json" },
330        body: JSON.stringify({ type: "local-target", branch: null }),
331      })
332      const workspace = (yield* created.json) as Workspace.Info
333 
334      const url = new URL(`http://localhost${InstancePaths.path}`)
335      url.searchParams.set("workspace", workspace.id)
336 
337      const response = yield* request(url.toString(), dir)
338 
339      expect(response.status).toBe(200)
340      expect(yield* response.json).toMatchObject({ directory: workspaceDir })
341      yield* request(WorkspacePaths.remove.replace(":id", workspace.id), dir, { method: "DELETE" })
342    }),
343  )
344 
345  it.live("proxies remote workspace HTTP requests with sanitized forwarding", () =>
346    Effect.gen(function* () {
347      Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
348      const dir = yield* tmpdirScoped({ git: true })
349      const proxied: ProxiedRequest[] = []
350      const remote = listenRemoteHttp((request) => {
351        proxied.push(request)
352        const url = new URL(request.url)
353        if (url.pathname === "/base/global/event") return eventStreamResponse()
354        if (url.pathname === "/base/event") return eventStreamResponse()
355        if (url.pathname === "/base/sync/history") return Response.json([])
356        return new Response(
357          JSON.stringify({
358            proxied: true,
359            path: url.pathname,
360            keep: url.searchParams.get("keep"),
361            workspace: url.searchParams.get("workspace"),
362          }),
363          {
364            status: 201,
365            statusText: "Created",
366            headers: {
367              "content-length": "999",
368              "content-type": "application/json",
369              "x-remote": "yes",
370            },
371          },
372        )
373      })
374 
375      const project = yield* Project.use.fromDirectory(dir)
376      registerAdapter(
377        project.project.id,
378        "remote-target",
379        remoteAdapter(path.join(dir, ".remote"), `http://127.0.0.1:${remote.port}/base`, {
380          "x-target-auth": "secret",
381        }),
382      )
383      const created = yield* requestDefault(WorkspacePaths.list, dir, {
384        method: "POST",
385        headers: { "content-type": "application/json" },
386        body: JSON.stringify({ type: "remote-target", branch: null }),
387      })
388      const workspace = (yield* created.json) as Workspace.Info
389 
390      const url = new URL("http://localhost/config")
391      url.searchParams.set("workspace", workspace.id)
392      url.searchParams.set("keep", "yes")
393 
394      try {
395        const response = yield* requestDefault(url.toString(), dir, {
396          method: "PATCH",
397          headers: {
398            "accept-encoding": "br",
399            "content-type": "application/json",
400            "x-opencode-workspace": "internal",
401          },
402          body: JSON.stringify({ $schema: "https://opencode.ai/config.json" }),
403        })
404 
405        const responseBody = yield* response.text
406        expect({ status: response.status, body: responseBody }).toMatchObject({ status: 201 })
407        expect(response.headers["content-length"]).toBeUndefined()
408        expect(response.headers["x-remote"]).toBe("yes")
409        expect(JSON.parse(responseBody)).toEqual({ proxied: true, path: "/base/config", keep: "yes", workspace: null })
410        const forwarded = proxied.filter((item) => new URL(item.url).pathname === "/base/config")
411        expect(forwarded).toEqual([
412          {
413            url: `http://127.0.0.1:${remote.port}/base/config?keep=yes`,
414            method: "PATCH",
415            headers: expect.objectContaining({
416              "content-type": "application/json",
417              "x-target-auth": "secret",
418            }),
419            body: JSON.stringify({ $schema: "https://opencode.ai/config.json" }),
420          },
421        ])
422        expect(forwarded[0]?.headers).not.toHaveProperty("x-opencode-directory")
423        expect(forwarded[0]?.headers).not.toHaveProperty("x-opencode-workspace")
424 
425        const eventURL = new URL(`http://localhost${EventPaths.event}`)
426        eventURL.searchParams.set("workspace", workspace.id)
427        const eventResponse = yield* request(eventURL.toString(), dir)
428        expect(eventResponse.status).toBe(200)
429        expect(eventResponse.headers["content-type"]).toContain("text/event-stream")
430        const event = Array.from(yield* eventResponse.stream.pipe(Stream.take(1), Stream.runCollect))[0]
431        expect(new TextDecoder().decode(event)).toContain("server.connected")
432        expect(proxied.some((item) => new URL(item.url).pathname === "/base/event")).toBe(true)
433      } finally {
434        void remote.stop(true)
435        yield* requestDefault(WorkspacePaths.remove.replace(":id", workspace.id), dir, { method: "DELETE" })
436      }
437    }),
438  )
439 
440  it.live("proxies remote workspace requests selected from session ownership", () =>
441    Effect.gen(function* () {
442      Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
443      const dir = yield* tmpdirScoped({ git: true })
444      const proxied: ProxiedRequest[] = []
445      const remote = listenRemoteHttp((request) => {
446        proxied.push(request)
447        const url = new URL(request.url)
448        if (url.pathname === "/base/global/event") return eventStreamResponse()
449        if (url.pathname === "/base/sync/history") return Response.json([])
450        return Response.json({ proxied: true, path: new URL(request.url).pathname })
451      })
452 
453      const project = yield* Project.use.fromDirectory(dir)
454      registerAdapter(
455        project.project.id,
456        "remote-session-target",
457        remoteAdapter(path.join(dir, ".remote-session"), `http://127.0.0.1:${remote.port}/base`),
458      )
459      const created = yield* requestDefault(WorkspacePaths.list, dir, {
460        method: "POST",
461        headers: { "content-type": "application/json" },
462        body: JSON.stringify({ type: "remote-session-target", branch: null }),
463      })
464      const workspace = (yield* created.json) as Workspace.Info
465      const sessionResponse = yield* requestDefault("/session", dir, { method: "POST" })
466      const session = (yield* sessionResponse.json) as Session.Info
467      const warped = yield* requestDefault(WorkspacePaths.warp, dir, {
468        method: "POST",
469        headers: { "content-type": "application/json" },
470        body: JSON.stringify({ id: workspace.id, sessionID: session.id }),
471      })
472      expect(warped.status).toBe(204)
473 
474      try {
475        const response = yield* requestDefault(`http://localhost/session/${session.id}/message`, dir, {
476          method: "POST",
477          headers: { "content-type": "application/json" },
478          body: JSON.stringify({ parts: [{ type: "text", text: "hello" }] }),
479        })
480 
481        const responseBody = yield* response.text
482        expect({ status: response.status, body: responseBody }).toMatchObject({ status: 200 })
483        expect(JSON.parse(responseBody)).toEqual({ proxied: true, path: `/base/session/${session.id}/message` })
484        expect(proxied.filter((item) => new URL(item.url).pathname === `/base/session/${session.id}/message`)).toEqual([
485          expect.objectContaining({
486            url: `http://127.0.0.1:${remote.port}/base/session/${session.id}/message`,
487            method: "POST",
488          }),
489        ])
490 
491        const aborted = yield* request(`http://localhost/session/${session.id}/abort`, dir, { method: "POST" })
492        expect(aborted.status).toBe(200)
493        expect(proxied.filter((item) => new URL(item.url).pathname === `/base/session/${session.id}/abort`)).toEqual([
494          expect.objectContaining({
495            url: `http://127.0.0.1:${remote.port}/base/session/${session.id}/abort`,
496            method: "POST",
497            body: "",
498          }),
499        ])
500      } finally {
501        void remote.stop(true)
502        yield* requestDefault(WorkspacePaths.remove.replace(":id", workspace.id), dir, { method: "DELETE" })
503      }
504    }),
505  )
506})
507