openAgent

1import { PermissionV1 } from "@opencode-ai/core/v1/permission"
2import { NodeHttpServer, NodeServices } from "@effect/platform-node"
3import { Flag } from "@opencode-ai/core/flag/flag"
4import { describe, expect } from "bun:test"
5import { Config, Context, Effect, FileSystem, Layer, Path } from "effect"
6import { HttpClient, HttpClientRequest, HttpRouter, HttpServer } from "effect/unstable/http"
7import * as Socket from "effect/unstable/socket/Socket"
8import { WorkspaceV2 } from "@opencode-ai/core/workspace"
9import { ControlPaths } from "../../src/server/routes/instance/httpapi/groups/control"
10import { InstancePaths } from "../../src/server/routes/instance/httpapi/groups/instance"
11import { SessionPaths } from "../../src/server/routes/instance/httpapi/groups/session"
12import { ProjectV2 } from "@opencode-ai/core/project"
13import { QuestionID } from "../../src/question/schema"
14import { HttpApiApp } from "../../src/server/routes/instance/httpapi/server"
15import { HEADER as FenceHeader } from "../../src/server/shared/fence"
16import { resetDatabase } from "../fixture/db"
17import { tmpdirScoped } from "../fixture/fixture"
18import { testEffect } from "../lib/effect"
19 
20// Flip the experimental workspaces flag so EventV2.run actually writes to
21// EventSequenceTable (the source of truth the fence middleware reads). Reset
22// the database around the test so per-instance state does not leak between
23// runs. resetDatabase() already calls disposeAllInstances(), so we don't
24// repeat it.
25const testStateLayer = Layer.effectDiscard(
26  Effect.gen(function* () {
27    const originalWorkspaces = Flag.OPENCODE_EXPERIMENTAL_WORKSPACES
28    Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
29    yield* Effect.promise(() => resetDatabase())
30    yield* Effect.addFinalizer(() =>
31      Effect.promise(async () => {
32        Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = originalWorkspaces
33        await resetDatabase()
34      }),
35    )
36  }),
37)
38 
39// Mount the production HttpApi route tree on a real Node HTTP server bound to
40// 127.0.0.1:0 and a fetch-based HttpClient that prepends the server URL. This
41// keeps the test wired directly through the same route layer production uses.
42const servedRoutes: Layer.Layer<never, Config.ConfigError, HttpServer.HttpServer> = HttpRouter.serve(
43  HttpApiApp.routes,
44  { disableListenLog: true, disableLogger: true },
45)
46 
47const httpApiServerLayer = servedRoutes.pipe(
48  Layer.provide(Socket.layerWebSocketConstructorGlobal),
49  Layer.provideMerge(NodeHttpServer.layerTest),
50  Layer.provideMerge(NodeServices.layer),
51)
52 
53const it = testEffect(Layer.mergeAll(testStateLayer, httpApiServerLayer))
54const handlerContext = Context.empty() as Context.Context<unknown>
55 
56const directoryHeader = (dir: string) => HttpClientRequest.setHeader("x-opencode-directory", dir)
57 
58describe("instance HttpApi", () => {
59  it.live("serves the OpenAPI document", () =>
60    Effect.gen(function* () {
61      const response = yield* HttpClient.get("/doc")
62 
63      expect(response.status).toBe(200)
64      expect(response.headers["content-type"]).toContain("application/json")
65      expect(yield* response.json).toMatchObject({
66        openapi: expect.any(String),
67        info: expect.any(Object),
68        paths: expect.objectContaining({
69          "/global/health": expect.any(Object),
70          "/session": expect.any(Object),
71        }),
72      })
73    }),
74  )
75 
76  it.live("emits a sync fence header for fixed-workspace mutations", () =>
77    Effect.gen(function* () {
78      const originalWorkspaceID = Flag.OPENCODE_WORKSPACE_ID
79      Flag.OPENCODE_WORKSPACE_ID = WorkspaceV2.ID.ascending()
80      yield* Effect.addFinalizer(() =>
81        Effect.sync(() => {
82          Flag.OPENCODE_WORKSPACE_ID = originalWorkspaceID
83        }),
84      )
85 
86      const dir = yield* tmpdirScoped({ git: true })
87      const response = yield* HttpClientRequest.post(SessionPaths.create).pipe(
88        directoryHeader(dir),
89        HttpClientRequest.bodyJson({ title: "fenced" }),
90        Effect.flatMap(HttpClient.execute),
91      )
92 
93      expect(response.status).toBe(200)
94      expect(JSON.parse(response.headers[FenceHeader] ?? "{}")).not.toEqual({})
95    }),
96  )
97 
98  it.live("does not emit sync fence headers for fixed-workspace reads or no-op mutations", () =>
99    Effect.gen(function* () {
100      const originalWorkspaceID = Flag.OPENCODE_WORKSPACE_ID
101      Flag.OPENCODE_WORKSPACE_ID = WorkspaceV2.ID.ascending()
102      yield* Effect.addFinalizer(() =>
103        Effect.sync(() => {
104          Flag.OPENCODE_WORKSPACE_ID = originalWorkspaceID
105        }),
106      )
107 
108      const dir = yield* tmpdirScoped({ git: true })
109      const read = yield* HttpClientRequest.get(InstancePaths.path).pipe(directoryHeader(dir), HttpClient.execute)
110      const log = yield* HttpClientRequest.post(ControlPaths.log).pipe(
111        directoryHeader(dir),
112        HttpClientRequest.bodyJson({ service: "fence-test", level: "info", message: "noop" }),
113        Effect.flatMap(HttpClient.execute),
114      )
115 
116      expect(read.status).toBe(200)
117      expect(read.headers[FenceHeader]).toBeUndefined()
118      expect(log.status).toBe(200)
119      expect(log.headers[FenceHeader]).toBeUndefined()
120    }),
121  )
122 
123  it.live("rejects malformed permission and question request ids", () =>
124    Effect.gen(function* () {
125      const dir = yield* tmpdirScoped({ git: true })
126      const request = (path: string, init?: RequestInit) =>
127        Effect.promise(() =>
128          HttpApiApp.webHandler().handler(
129            new Request(`http://localhost${path}`, {
130              ...init,
131              headers: { "x-opencode-directory": dir, "content-type": "application/json", ...init?.headers },
132            }),
133            handlerContext,
134          ),
135        )
136      const [permission, questionReply, questionReject] = yield* Effect.all(
137        [
138          request("/permission/invalid-permission-id/reply", {
139            method: "POST",
140            body: JSON.stringify({ reply: "once" }),
141          }),
142          request("/question/invalid-question-id/reply", {
143            method: "POST",
144            body: JSON.stringify({ answers: [["Yes"]] }),
145          }),
146          request("/question/invalid-question-id/reject", { method: "POST" }),
147        ],
148        { concurrency: "unbounded" },
149      )
150 
151      expect(permission.status).toBe(400)
152      expect(questionReply.status).toBe(400)
153      expect(questionReject.status).toBe(400)
154    }),
155  )
156 
157  it.live("returns typed not found bodies for missing permission and question requests", () =>
158    Effect.gen(function* () {
159      const dir = yield* tmpdirScoped({ git: true })
160      const request = (path: string, init?: RequestInit) =>
161        Effect.promise(() =>
162          HttpApiApp.webHandler().handler(
163            new Request(`http://localhost${path}`, {
164              ...init,
165              headers: { "x-opencode-directory": dir, "content-type": "application/json", ...init?.headers },
166            }),
167            handlerContext,
168          ),
169        )
170      const permissionID = PermissionV1.ID.ascending()
171      const questionReplyID = QuestionID.ascending()
172      const questionRejectID = QuestionID.ascending()
173      const [permission, questionReply, questionReject] = yield* Effect.all(
174        [
175          request(`/permission/${permissionID}/reply`, {
176            method: "POST",
177            body: JSON.stringify({ reply: "once" }),
178          }),
179          request(`/question/${questionReplyID}/reply`, {
180            method: "POST",
181            body: JSON.stringify({ answers: [["Yes"]] }),
182          }),
183          request(`/question/${questionRejectID}/reject`, { method: "POST" }),
184        ],
185        { concurrency: "unbounded" },
186      )
187 
188      expect(permission.status).toBe(404)
189      expect(yield* Effect.promise(() => permission.json())).toEqual({
190        _tag: "PermissionNotFoundError",
191        requestID: permissionID,
192        message: `Permission request not found: ${permissionID}`,
193      })
194      expect(questionReply.status).toBe(404)
195      expect(yield* Effect.promise(() => questionReply.json())).toEqual({
196        _tag: "QuestionNotFoundError",
197        requestID: questionReplyID,
198        message: `Question request not found: ${questionReplyID}`,
199      })
200      expect(questionReject.status).toBe(404)
201      expect(yield* Effect.promise(() => questionReject.json())).toEqual({
202        _tag: "QuestionNotFoundError",
203        requestID: questionRejectID,
204        message: `Question request not found: ${questionRejectID}`,
205      })
206    }),
207  )
208 
209  it.live("returns typed not found bodies for missing projects", () =>
210    Effect.gen(function* () {
211      const dir = yield* tmpdirScoped({ git: true })
212      const projectID = ProjectV2.ID.make("project_missing")
213      const response = yield* Effect.promise(() =>
214        HttpApiApp.webHandler().handler(
215          new Request(`http://localhost/project/${projectID}`, {
216            method: "PATCH",
217            headers: { "x-opencode-directory": dir, "content-type": "application/json" },
218            body: JSON.stringify({ name: "Missing" }),
219          }),
220          handlerContext,
221        ),
222      )
223 
224      expect(response.status).toBe(404)
225      expect(yield* Effect.promise(() => response.json())).toEqual({
226        _tag: "ProjectNotFoundError",
227        projectID,
228        message: `Project not found: ${projectID}`,
229      })
230    }),
231  )
232 
233  it.live("serves path and VCS read endpoints", () =>
234    Effect.gen(function* () {
235      const dir = yield* tmpdirScoped({ git: true })
236      const fs = yield* FileSystem.FileSystem
237      const path = yield* Path.Path
238      yield* fs.writeFileString(path.join(dir, "changed.txt"), "hello")
239 
240      const [paths, vcs, diff] = yield* Effect.all(
241        [
242          HttpClientRequest.get(InstancePaths.path).pipe(directoryHeader(dir), HttpClient.execute),
243          HttpClientRequest.get(InstancePaths.vcs).pipe(directoryHeader(dir), HttpClient.execute),
244          HttpClientRequest.get(InstancePaths.vcsDiff).pipe(
245            HttpClientRequest.setUrlParam("mode", "git"),
246            directoryHeader(dir),
247            HttpClient.execute,
248          ),
249        ],
250        { concurrency: "unbounded" },
251      )
252 
253      expect(paths.status).toBe(200)
254      expect(yield* paths.json).toMatchObject({ directory: dir, worktree: dir })
255 
256      expect(vcs.status).toBe(200)
257      expect(yield* vcs.json).toMatchObject({ branch: expect.any(String) })
258 
259      expect(diff.status).toBe(200)
260      expect(yield* diff.json).toContainEqual(
261        expect.objectContaining({ file: "changed.txt", additions: 1, status: "added" }),
262      )
263    }),
264  )
265})
266