lmin/zmo-cli
1
0
Fork 0
Code Issues Pull Requests Actions 6 Packages Projects Releases Wiki Activity

Refactor workspace service boundaries (#25152)

Browse Source
This commit is contained in:
Kit Langton
2026-04-30 15:34:37 -04:00
committed by GitHub
parent b315a70773
commit 0e9d9282c6
14 changed files with 433 additions and 417 deletions
Download Patch File Download Diff File Expand all files Collapse all files

130
packages/opencode/test/control-plane/workspace.test.ts
View File

@@ -107,6 +107,24 @@ async function withInstance<T>(fn: (dir: string) => T | Promise<T>) {
})
}
const runWorkspace = <A, E>(effect: Effect.Effect<A, E, WorkspaceOld.Service>) => AppRuntime.runPromise(effect)
const createWorkspace = (input: WorkspaceOld.CreateInput) =>
runWorkspace(WorkspaceOld.Service.use((workspace) => workspace.create(input)))
const restoreWorkspaceSession = (input: WorkspaceOld.SessionRestoreInput) =>
runWorkspace(WorkspaceOld.Service.use((workspace) => workspace.sessionRestore(input)))
const listWorkspaces = (project: Parameters<WorkspaceOld.Interface["list"]>[0]) =>
runWorkspace(WorkspaceOld.Service.use((workspace) => workspace.list(project)))
const getWorkspace = (id: WorkspaceID) => runWorkspace(WorkspaceOld.Service.use((workspace) => workspace.get(id)))
const removeWorkspace = (id: WorkspaceID) => runWorkspace(WorkspaceOld.Service.use((workspace) => workspace.remove(id)))
const workspaceStatus = () => runWorkspace(WorkspaceOld.Service.use((workspace) => workspace.status()))
const isWorkspaceSyncing = (id: WorkspaceID) =>
runWorkspace(WorkspaceOld.Service.use((workspace) => workspace.isSyncing(id)))
const startWorkspaceSyncing = (projectID: ProjectID) => {
void runWorkspace(WorkspaceOld.Service.use((workspace) => workspace.startWorkspaceSyncing(projectID)))
}
const waitForWorkspaceSync = (workspaceID: WorkspaceID, state: Record<string, number>, signal?: AbortSignal) =>
runWorkspace(WorkspaceOld.Service.use((workspace) => workspace.waitForSync(workspaceID, state, signal)))
function captureGlobalEvents() {
const events: GlobalEvent[] = []
const handler = (event: GlobalEvent) => events.push(event)
@@ -372,12 +390,12 @@ describe("workspace-old schemas and exports", () => {
describe("workspace-old CRUD", () => {
test("get returns undefined for a missing workspace", async () => {
await withInstance(async () => {
expect(await WorkspaceOld.get(WorkspaceID.ascending("wrk_missing_get"))).toBeUndefined()
expect(await getWorkspace(WorkspaceID.ascending("wrk_missing_get"))).toBeUndefined()
})
})
test("list maps database rows, filters by project, and sorts by id", async () => {
await withInstance(() => {
await withInstance(async () => {
const otherProjectID = ProjectID.make("project-other")
insertProject(otherProjectID, "/tmp/other")
const a = workspaceInfo(Instance.project.id, "manual", {
@@ -397,7 +415,7 @@ describe("workspace-old CRUD", () => {
insertWorkspace(other)
insertWorkspace(a)
expect(WorkspaceOld.list(Instance.project)).toEqual([a, b])
expect(await listWorkspaces(Instance.project)).toEqual([a, b])
})
})
@@ -430,7 +448,7 @@ describe("workspace-old CRUD", () => {
})
registerAdaptor(Instance.project.id, type, recorded.adaptor)
const info = await WorkspaceOld.create({
const info = await createWorkspace({
id: workspaceID,
type,
branch: null,
@@ -447,8 +465,8 @@ describe("workspace-old CRUD", () => {
extra: { configured: true },
projectID: Instance.project.id,
})
expect(await WorkspaceOld.get(workspaceID)).toEqual(info)
expect(WorkspaceOld.list(Instance.project)).toEqual([info])
expect(await getWorkspace(workspaceID)).toEqual(info)
expect(await listWorkspaces(Instance.project)).toEqual([info])
expect(recorded.calls.configure).toHaveLength(1)
expect(recorded.calls.configure[0]).toMatchObject({ id: workspaceID, type, directory: null })
expect(recorded.calls.create).toHaveLength(1)
@@ -461,10 +479,10 @@ describe("workspace-old CRUD", () => {
expect(recorded.calls.create[0].env.OTEL_EXPORTER_OTLP_HEADERS).toBe("authorization=otel")
expect(recorded.calls.create[0].env.OTEL_EXPORTER_OTLP_ENDPOINT).toBe("https://otel.test")
expect(recorded.calls.create[0].env.OTEL_RESOURCE_ATTRIBUTES).toBe("service.name=opencode-test")
expect(WorkspaceOld.status().find((item) => item.workspaceID === workspaceID)?.status).toBe("connected")
expect((await workspaceStatus()).find((item) => item.workspaceID === workspaceID)?.status).toBe("connected")
await WorkspaceOld.remove(workspaceID)
expect(WorkspaceOld.status().find((item) => item.workspaceID === workspaceID)?.status).toBeUndefined()
await removeWorkspace(workspaceID)
expect((await workspaceStatus()).find((item) => item.workspaceID === workspaceID)?.status).toBeUndefined()
})
})
@@ -485,9 +503,9 @@ describe("workspace-old CRUD", () => {
)
await expect(
WorkspaceOld.create({ type, branch: null, projectID: Instance.project.id, extra: null }),
createWorkspace({ type, branch: null, projectID: Instance.project.id, extra: null }),
).rejects.toThrow("configure exploded")
expect(WorkspaceOld.list(Instance.project)).toEqual([])
expect(await listWorkspaces(Instance.project)).toEqual([])
})
})
@@ -505,14 +523,14 @@ describe("workspace-old CRUD", () => {
registerAdaptor(Instance.project.id, type, recorded.adaptor)
await expect(
WorkspaceOld.create({ type, branch: "branch", projectID: Instance.project.id, extra: { x: 1 } }),
createWorkspace({ type, branch: "branch", projectID: Instance.project.id, extra: { x: 1 } }),
).rejects.toThrow("create exploded")
const rows = WorkspaceOld.list(Instance.project)
const rows = await listWorkspaces(Instance.project)
expect(rows).toHaveLength(1)
expect(rows[0]).toMatchObject({ type, branch: "branch", extra: { x: 1 } })
expect(recorded.calls.target).toHaveLength(0)
await WorkspaceOld.remove(rows[0].id)
await removeWorkspace(rows[0].id)
})
})
@@ -523,11 +541,11 @@ describe("workspace-old CRUD", () => {
const recorded = localAdaptor(missing, { createDir: false })
registerAdaptor(Instance.project.id, type, recorded.adaptor)
const info = await WorkspaceOld.create({ type, branch: null, projectID: Instance.project.id, extra: null })
const info = await createWorkspace({ type, branch: null, projectID: Instance.project.id, extra: null })
expect(info.directory).toBe(missing)
expect(WorkspaceOld.status().find((item) => item.workspaceID === info.id)?.status).toBe("error")
await WorkspaceOld.remove(info.id)
expect((await workspaceStatus()).find((item) => item.workspaceID === info.id)?.status).toBe("error")
await removeWorkspace(info.id)
})
})
@@ -581,7 +599,7 @@ describe("workspace-old CRUD", () => {
test("remove returns undefined for a missing workspace", async () => {
await withInstance(async () => {
expect(await WorkspaceOld.remove(WorkspaceID.ascending("wrk_missing_remove"))).toBeUndefined()
expect(await removeWorkspace(WorkspaceID.ascending("wrk_missing_remove"))).toBeUndefined()
})
})
@@ -590,18 +608,18 @@ describe("workspace-old CRUD", () => {
const type = unique("remove-local")
const recorded = localAdaptor(path.join(dir, "remove-local"))
registerAdaptor(Instance.project.id, type, recorded.adaptor)
const info = await WorkspaceOld.create({ type, branch: null, projectID: Instance.project.id, extra: null })
const info = await createWorkspace({ type, branch: null, projectID: Instance.project.id, extra: null })
const one = await AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.create({})))
const two = await AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.create({})))
attachSessionToWorkspace(one.id, info.id)
attachSessionToWorkspace(two.id, info.id)
const removed = await WorkspaceOld.remove(info.id)
const removed = await removeWorkspace(info.id)
expect(removed).toEqual(info)
expect(await WorkspaceOld.get(info.id)).toBeUndefined()
expect(await getWorkspace(info.id)).toBeUndefined()
expect(recorded.calls.remove).toEqual([info])
expect(WorkspaceOld.status().find((item) => item.workspaceID === info.id)?.status).toBeUndefined()
expect((await workspaceStatus()).find((item) => item.workspaceID === info.id)?.status).toBeUndefined()
expect(
Database.use((db) =>
db.select({ id: SessionTable.id }).from(SessionTable).where(eq(SessionTable.workspace_id, info.id)).all(),
@@ -628,8 +646,8 @@ describe("workspace-old CRUD", () => {
)
insertWorkspace(info)
expect(await WorkspaceOld.remove(info.id)).toEqual(info)
expect(await WorkspaceOld.get(info.id)).toBeUndefined()
expect(await removeWorkspace(info.id)).toEqual(info)
expect(await getWorkspace(info.id)).toBeUndefined()
})
})
})
@@ -645,10 +663,10 @@ describe("workspace-old sync state", () => {
insertWorkspace(info)
registerAdaptor(Instance.project.id, type, localAdaptor(path.join(dir, "flag-disabled")).adaptor)
WorkspaceOld.startWorkspaceSyncing(Instance.project.id)
startWorkspaceSyncing(Instance.project.id)
await delay(25)
expect(WorkspaceOld.status().find((item) => item.workspaceID === info.id)?.status).toBeUndefined()
expect((await workspaceStatus()).find((item) => item.workspaceID === info.id)?.status).toBeUndefined()
})
})
@@ -671,14 +689,16 @@ describe("workspace-old sync state", () => {
withSession.id,
)
WorkspaceOld.startWorkspaceSyncing(Instance.project.id)
startWorkspaceSyncing(Instance.project.id)
await eventually(() =>
expect(WorkspaceOld.status().find((item) => item.workspaceID === withSession.id)?.status).toBe("connected"),
workspaceStatus().then((status) =>
expect(status.find((item) => item.workspaceID === withSession.id)?.status).toBe("connected"),
),
)
expect(WorkspaceOld.status().find((item) => item.workspaceID === withoutSession.id)?.status).toBeUndefined()
await WorkspaceOld.remove(withSession.id)
await WorkspaceOld.remove(withoutSession.id)
expect((await workspaceStatus()).find((item) => item.workspaceID === withoutSession.id)?.status).toBeUndefined()
await removeWorkspace(withSession.id)
await removeWorkspace(withoutSession.id)
})
})
@@ -697,13 +717,15 @@ describe("workspace-old sync state", () => {
info.id,
)
WorkspaceOld.startWorkspaceSyncing(Instance.project.id)
startWorkspaceSyncing(Instance.project.id)
await eventually(() =>
expect(WorkspaceOld.status().find((item) => item.workspaceID === info.id)?.status).toBe("error"),
workspaceStatus().then((status) =>
expect(status.find((item) => item.workspaceID === info.id)?.status).toBe("error"),
),
)
expect(await WorkspaceOld.isSyncing(info.id)).toBe(false)
await WorkspaceOld.remove(info.id)
expect(await isWorkspaceSyncing(info.id)).toBe(false)
await removeWorkspace(info.id)
})
})
@@ -722,18 +744,20 @@ describe("workspace-old sync state", () => {
info.id,
)
WorkspaceOld.startWorkspaceSyncing(Instance.project.id)
WorkspaceOld.startWorkspaceSyncing(Instance.project.id)
startWorkspaceSyncing(Instance.project.id)
startWorkspaceSyncing(Instance.project.id)
await eventually(() =>
expect(WorkspaceOld.status().find((item) => item.workspaceID === info.id)?.status).toBe("connected"),
workspaceStatus().then((status) =>
expect(status.find((item) => item.workspaceID === info.id)?.status).toBe("connected"),
),
)
expect(
captured.events.filter(
(event) => event.workspace === info.id && event.payload.type === WorkspaceOld.Event.Status.type,
),
).toHaveLength(1)
await WorkspaceOld.remove(info.id)
await removeWorkspace(info.id)
} finally {
captured.dispose()
}
@@ -1106,7 +1130,7 @@ describe("workspace-old sync state", () => {
describe("workspace-old waitForSync", () => {
test("returns immediately for an empty fence", async () => {
await withInstance(async () => {
await expect(WorkspaceOld.waitForSync(WorkspaceID.ascending("wrk_wait_empty"), {})).resolves.toBeUndefined()
await expect(waitForWorkspaceSync(WorkspaceID.ascending("wrk_wait_empty"), {})).resolves.toBeUndefined()
})
})
@@ -1116,10 +1140,10 @@ describe("workspace-old waitForSync", () => {
Database.use((db) => db.insert(EventSequenceTable).values({ aggregate_id: sessionID, seq: 4 }).run())
await expect(
WorkspaceOld.waitForSync(WorkspaceID.ascending("wrk_wait_done"), { [sessionID]: 4 }),
waitForWorkspaceSync(WorkspaceID.ascending("wrk_wait_done"), { [sessionID]: 4 }),
).resolves.toBeUndefined()
await expect(
WorkspaceOld.waitForSync(WorkspaceID.ascending("wrk_wait_done_2"), { [sessionID]: 3 }),
waitForWorkspaceSync(WorkspaceID.ascending("wrk_wait_done_2"), { [sessionID]: 3 }),
).resolves.toBeUndefined()
})
})
@@ -1130,7 +1154,7 @@ describe("workspace-old waitForSync", () => {
const sessionID = SessionID.descending("ses_wait_event")
Database.use((db) => db.insert(EventSequenceTable).values({ aggregate_id: sessionID, seq: 1 }).run())
const waited = WorkspaceOld.waitForSync(workspaceID, { [sessionID]: 2 })
const waited = waitForWorkspaceSync(workspaceID, { [sessionID]: 2 })
await delay(10)
Database.use((db) =>
db.update(EventSequenceTable).set({ seq: 2 }).where(eq(EventSequenceTable.aggregate_id, sessionID)).run(),
@@ -1147,7 +1171,7 @@ describe("workspace-old waitForSync", () => {
const sessionID = SessionID.descending("ses_wait_sync_any")
Database.use((db) => db.insert(EventSequenceTable).values({ aggregate_id: sessionID, seq: 0 }).run())
const waited = WorkspaceOld.waitForSync(workspaceID, { [sessionID]: 1 })
const waited = waitForWorkspaceSync(workspaceID, { [sessionID]: 1 })
await delay(10)
Database.use((db) =>
db.update(EventSequenceTable).set({ seq: 1 }).where(eq(EventSequenceTable.aggregate_id, sessionID)).run(),
@@ -1165,7 +1189,7 @@ describe("workspace-old waitForSync", () => {
await withInstance(async () => {
const abort = new AbortController()
const reason = new Error("caller aborted")
const waited = WorkspaceOld.waitForSync(
const waited = waitForWorkspaceSync(
WorkspaceID.ascending("wrk_wait_abort"),
{ [SessionID.descending("ses_wait_abort")]: 1 },
abort.signal,
@@ -1184,9 +1208,9 @@ describe("workspace-old waitForSync", () => {
await withInstance(async () => {
const sessionID = SessionID.descending("ses_wait_timeout")
await expect(
WorkspaceOld.waitForSync(WorkspaceID.ascending("wrk_wait_timeout"), { [sessionID]: 1 }),
).rejects.toThrow(`Timed out waiting for sync fence: {"${sessionID}":1}`)
await expect(waitForWorkspaceSync(WorkspaceID.ascending("wrk_wait_timeout"), { [sessionID]: 1 })).rejects.toThrow(
`Timed out waiting for sync fence: {"${sessionID}":1}`,
)
})
}, 7000)
})
@@ -1195,7 +1219,7 @@ describe("workspace-old sessionRestore", () => {
test("throws when the workspace is missing", async () => {
await withInstance(async () => {
await expect(
WorkspaceOld.sessionRestore({
restoreWorkspaceSession({
workspaceID: WorkspaceID.ascending("wrk_restore_missing"),
sessionID: SessionID.descending("ses_restore_missing_workspace"),
}),
@@ -1211,9 +1235,9 @@ describe("workspace-old sessionRestore", () => {
registerAdaptor(Instance.project.id, type, localAdaptor(dir).adaptor)
await expect(
WorkspaceOld.sessionRestore({ workspaceID: info.id, sessionID: SessionID.descending("ses_missing_restore") }),
restoreWorkspaceSession({ workspaceID: info.id, sessionID: SessionID.descending("ses_missing_restore") }),
).rejects.toThrow("NotFoundError")
await WorkspaceOld.remove(info.id)
await removeWorkspace(info.id)
})
})
@@ -1424,7 +1448,7 @@ describe("workspace-old sessionRestore", () => {
)
replaceSessionEvents(session.id, 20)
expect(await WorkspaceOld.sessionRestore({ workspaceID: info.id, sessionID: session.id })).toEqual({ total: 3 })
expect(await restoreWorkspaceSession({ workspaceID: info.id, sessionID: session.id })).toEqual({ total: 3 })
expect(fetchCallCount).toBe(0)
expect(replayAll).toHaveBeenCalledTimes(3)
@@ -1438,7 +1462,7 @@ describe("workspace-old sessionRestore", () => {
.filter((event) => event.workspace === info.id && event.payload.type === WorkspaceOld.Event.Restore.type)
.map((event) => event.payload.properties.step),
).toEqual([0, 1, 2, 3])
await WorkspaceOld.remove(info.id)
await removeWorkspace(info.id)
} finally {
captured.dispose()
}

17
packages/opencode/test/plugin/workspace-adaptor.test.ts
View File

@@ -13,7 +13,7 @@ const { Flag } = await import("@opencode-ai/core/flag/flag")
const { Plugin } = await import("../../src/plugin/index")
const { Workspace } = await import("../../src/control-plane/workspace")
const { Instance } = await import("../../src/project/instance")
const it = testEffect(Layer.mergeAll(Plugin.defaultLayer, CrossSpawnSpawner.defaultLayer))
const it = testEffect(Layer.mergeAll(Plugin.defaultLayer, Workspace.defaultLayer, CrossSpawnSpawner.defaultLayer))
const experimental = Flag.OPENCODE_EXPERIMENTAL_WORKSPACES
@@ -83,14 +83,13 @@ describe("plugin.workspace", () => {
const plugin = yield* Plugin.Service
yield* plugin.init()
const info = yield* Effect.promise(() =>
Workspace.create({
type,
branch: null,
extra: { key: "value" },
projectID: Instance.project.id,
}),
)
const workspace = yield* Workspace.Service
const info = yield* workspace.create({
type,
branch: null,
extra: { key: "value" },
projectID: Instance.project.id,
})
expect(info.type).toBe(type)
expect(info.name).toBe("plug")

15
packages/opencode/test/server/httpapi-instance-context.test.ts
View File

@@ -36,7 +36,13 @@ const testStateLayer = Layer.effectDiscard(
)
const it = testEffect(
Layer.mergeAll(testStateLayer, NodeHttpServer.layerTest, NodeServices.layer, Project.defaultLayer),
Layer.mergeAll(
testStateLayer,
NodeHttpServer.layerTest,
NodeServices.layer,
Project.defaultLayer,
Workspace.defaultLayer,
),
)
const instanceContextTestLayer = instanceRouterMiddleware
@@ -56,16 +62,17 @@ const localAdaptor = (directory: string): WorkspaceAdaptor => ({
const createLocalWorkspace = (input: { projectID: Project.Info["id"]; type: string; directory: string }) =>
Effect.acquireRelease(
Effect.promise(async () => {
Effect.gen(function* () {
registerAdaptor(input.projectID, input.type, localAdaptor(input.directory))
return Workspace.create({
const workspace = yield* Workspace.Service
return yield* workspace.create({
type: input.type,
branch: null,
extra: null,
projectID: input.projectID,
})
}),
(workspace) => Effect.promise(() => Workspace.remove(workspace.id)).pipe(Effect.ignore),
(info) => Workspace.Service.use((workspace) => workspace.remove(info.id)).pipe(Effect.ignore),
)
const probeInstanceContext = Effect.gen(function* () {

16
packages/opencode/test/server/httpapi-session.test.ts
View File

@@ -94,14 +94,16 @@ const localAdaptor = (directory: string): WorkspaceAdaptor => ({
})
const createLocalWorkspace = (input: { projectID: Project.Info["id"]; type: string; directory: string }) =>
Effect.promise(async () => {
Effect.gen(function* () {
registerAdaptor(input.projectID, input.type, localAdaptor(input.directory))
return Workspace.create({
type: input.type,
branch: null,
extra: null,
projectID: input.projectID,
})
return yield* Workspace.Service.use((svc) =>
svc.create({
type: input.type,
branch: null,
extra: null,
projectID: input.projectID,
}),
).pipe(Effect.provide(Workspace.defaultLayer))
})
function request(path: string, init?: RequestInit) {

8
packages/opencode/test/server/httpapi-workspace-routing.test.ts
View File

@@ -50,6 +50,7 @@ const it = testEffect(
NodeHttpServer.layerTest,
NodeServices.layer,
Project.defaultLayer,
Workspace.defaultLayer,
Socket.layerWebSocketConstructorGlobal,
),
)
@@ -116,16 +117,17 @@ const syncResponse = (request: HttpServerRequest.HttpServerRequest) => {
const createWorkspace = (input: { projectID: Project.Info["id"]; type: string; adaptor: WorkspaceAdaptor }) =>
Effect.acquireRelease(
Effect.promise(async () => {
Effect.gen(function* () {
registerAdaptor(input.projectID, input.type, input.adaptor)
return Workspace.create({
const workspace = yield* Workspace.Service
return yield* workspace.create({
type: input.type,
branch: null,
extra: null,
projectID: input.projectID,
})
}),
(workspace) => Effect.promise(() => Workspace.remove(workspace.id)).pipe(Effect.ignore),
(info) => Workspace.Service.use((workspace) => workspace.remove(info.id)).pipe(Effect.ignore),
)
const createRemoteWorkspace = (input: {

462
packages/opencode/test/server/httpapi-workspace.test.ts
View File

@@ -1,7 +1,8 @@
import { afterEach, describe, expect, mock, test } from "bun:test"
import { NodeServices } from "@effect/platform-node"
import { mkdir } from "node:fs/promises"
import path from "node:path"
import { Effect } from "effect"
import { Effect, Layer } from "effect"
import { Flag } from "@opencode-ai/core/flag/flag"
import { registerAdaptor } from "../../src/control-plane/adaptors"
import type { WorkspaceAdaptor } from "../../src/control-plane/types"
@@ -11,30 +12,28 @@ import { Session } from "@/session/session"
import * as Log from "@opencode-ai/core/util/log"
import { Server } from "../../src/server/server"
import { resetDatabase } from "../fixture/db"
import { tmpdir } from "../fixture/fixture"
import { provideInstance, tmpdirScoped } from "../fixture/fixture"
import { Instance } from "../../src/project/instance"
import { Project } from "../../src/project/project"
import { InstancePaths } from "../../src/server/routes/instance/httpapi/groups/instance"
import { WorkspaceRef } from "../../src/effect/instance-ref"
import { testEffect } from "../lib/effect"
void Log.init({ print: false })
const originalWorkspaces = Flag.OPENCODE_EXPERIMENTAL_WORKSPACES
const originalHttpApi = Flag.OPENCODE_EXPERIMENTAL_HTTPAPI
const it = testEffect(
Layer.mergeAll(NodeServices.layer, Project.defaultLayer, Session.defaultLayer, Workspace.defaultLayer),
)
function request(path: string, directory: string, init: RequestInit = {}) {
Flag.OPENCODE_EXPERIMENTAL_HTTPAPI = true
const headers = new Headers(init.headers)
headers.set("x-opencode-directory", directory)
return Server.Default().app.request(path, { ...init, headers })
}
function runSession<A, E>(fx: Effect.Effect<A, E, Session.Service>, workspaceID?: Workspace.Info["id"]) {
return Effect.runPromise(
fx.pipe(
workspaceID ? Effect.provideService(WorkspaceRef, workspaceID) : (effect) => effect,
Effect.provide(Session.defaultLayer),
),
)
return Effect.promise(() => {
Flag.OPENCODE_EXPERIMENTAL_HTTPAPI = true
const headers = new Headers(init.headers)
headers.set("x-opencode-directory", directory)
return Promise.resolve(Server.Default().app.request(path, { ...init, headers }))
})
}
function localAdaptor(directory: string): WorkspaceAdaptor {
@@ -136,243 +135,228 @@ afterEach(async () => {
describe("workspace HttpApi", () => {
test.todo("proxies remote workspace websocket through real Effect listener", () => {})
test("serves read endpoints", async () => {
await using tmp = await tmpdir({ git: true })
it.live("serves read endpoints", () =>
Effect.gen(function* () {
const dir = yield* tmpdirScoped({ git: true })
const [adaptors, workspaces, status] = await Promise.all([
request(WorkspacePaths.adaptors, tmp.path),
request(WorkspacePaths.list, tmp.path),
request(WorkspacePaths.status, tmp.path),
])
const [adaptors, workspaces, status] = yield* Effect.all([
request(WorkspacePaths.adaptors, dir),
request(WorkspacePaths.list, dir),
request(WorkspacePaths.status, dir),
])
expect(adaptors.status).toBe(200)
expect(await adaptors.json()).toEqual([
{
expect(adaptors.status).toBe(200)
expect(yield* Effect.promise(() => adaptors.json())).toContainEqual({
type: "worktree",
name: "Worktree",
description: "Create a git worktree",
},
])
expect(workspaces.status).toBe(200)
expect(await workspaces.json()).toEqual([])
expect(status.status).toBe(200)
expect(await status.json()).toEqual([])
})
test("serves mutation endpoints", async () => {
Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
await using tmp = await tmpdir({ git: true })
await Instance.provide({
directory: tmp.path,
fn: async () =>
registerAdaptor(Instance.project.id, "local-test", localAdaptor(path.join(tmp.path, ".workspace"))),
})
const created = await request(WorkspacePaths.list, tmp.path, {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ type: "local-test", branch: null, extra: null }),
})
expect(created.status).toBe(200)
const workspace = (await created.json()) as Workspace.Info
expect(workspace).toMatchObject({ type: "local-test", name: "local-test" })
const session = await Instance.provide({
directory: tmp.path,
fn: async () => runSession(Session.Service.use((svc) => svc.create({}))),
})
const restored = await request(WorkspacePaths.sessionRestore.replace(":id", workspace.id), tmp.path, {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ sessionID: session.id }),
})
expect(restored.status).toBe(200)
expect((await restored.json()) as { total: number }).toMatchObject({ total: expect.any(Number) })
const removed = await request(WorkspacePaths.remove.replace(":id", workspace.id), tmp.path, { method: "DELETE" })
expect(removed.status).toBe(200)
expect(await removed.json()).toMatchObject({ id: workspace.id })
const listed = await request(WorkspacePaths.list, tmp.path)
expect(listed.status).toBe(200)
expect(await listed.json()).toEqual([])
})
test("routes local workspace requests through the workspace target directory", async () => {
Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
await using tmp = await tmpdir({ git: true })
const workspaceDir = path.join(tmp.path, ".workspace-local")
const workspace = await Instance.provide({
directory: tmp.path,
fn: async () => {
registerAdaptor(Instance.project.id, "local-target", localAdaptor(workspaceDir))
return Workspace.create({
type: "local-target",
branch: null,
extra: null,
projectID: Instance.project.id,
})
},
})
const url = new URL(`http://localhost${InstancePaths.path}`)
url.searchParams.set("workspace", workspace.id)
try {
const response = await request(url.toString(), tmp.path)
expect(response.status).toBe(200)
expect(await response.json()).toMatchObject({ directory: workspaceDir })
} finally {
await Workspace.remove(workspace.id)
}
})
test("proxies remote workspace HTTP requests with sanitized forwarding", async () => {
Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
await using tmp = await tmpdir({ git: true })
const proxied: ProxiedRequest[] = []
const remote = listenRemoteHttp((request) => {
proxied.push(request)
const url = new URL(request.url)
if (url.pathname === "/base/global/event") return eventStreamResponse()
if (url.pathname === "/base/sync/history") return Response.json([])
return new Response(
JSON.stringify({
proxied: true,
path: url.pathname,
keep: url.searchParams.get("keep"),
workspace: url.searchParams.get("workspace"),
}),
{
status: 201,
statusText: "Created",
headers: {
"content-length": "999",
"content-type": "application/json",
"x-remote": "yes",
},
},
)
})
const workspace = await Instance.provide({
directory: tmp.path,
fn: async () => {
registerAdaptor(
Instance.project.id,
"remote-target",
remoteAdaptor(path.join(tmp.path, ".remote"), `http://127.0.0.1:${remote.port}/base`, {
"x-target-auth": "secret",
}),
)
return Workspace.create({
type: "remote-target",
branch: null,
extra: null,
projectID: Instance.project.id,
})
},
})
const url = new URL("http://localhost/config")
url.searchParams.set("workspace", workspace.id)
url.searchParams.set("keep", "yes")
try {
const response = await request(url.toString(), tmp.path, {
method: "PATCH",
headers: {
"accept-encoding": "br",
"content-type": "application/json",
"x-opencode-workspace": "internal",
},
body: JSON.stringify({ $schema: "https://opencode.ai/config.json" }),
})
const responseBody = await response.text()
expect({ status: response.status, body: responseBody }).toMatchObject({ status: 201 })
expect(response.headers.get("content-length")).toBeNull()
expect(response.headers.get("x-remote")).toBe("yes")
expect(JSON.parse(responseBody)).toEqual({ proxied: true, path: "/base/config", keep: "yes", workspace: null })
const forwarded = proxied.filter((item) => new URL(item.url).pathname === "/base/config")
expect(forwarded).toEqual([
{
url: `http://127.0.0.1:${remote.port}/base/config?keep=yes`,
method: "PATCH",
headers: expect.objectContaining({
"content-type": "application/json",
"x-target-auth": "secret",
}),
body: JSON.stringify({ $schema: "https://opencode.ai/config.json" }),
},
])
expect(forwarded[0]?.headers).not.toHaveProperty("x-opencode-directory")
expect(forwarded[0]?.headers).not.toHaveProperty("x-opencode-workspace")
} finally {
remote.stop(true)
await Workspace.remove(workspace.id)
}
})
expect(workspaces.status).toBe(200)
expect(yield* Effect.promise(() => workspaces.json())).toEqual([])
test("proxies remote workspace requests selected from session ownership", async () => {
Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
await using tmp = await tmpdir({ git: true })
const proxied: ProxiedRequest[] = []
const remote = listenRemoteHttp((request) => {
proxied.push(request)
const url = new URL(request.url)
if (url.pathname === "/base/global/event") return eventStreamResponse()
if (url.pathname === "/base/sync/history") return Response.json([])
return Response.json({ proxied: true, path: new URL(request.url).pathname })
})
expect(status.status).toBe(200)
expect(yield* Effect.promise(() => status.json())).toEqual([])
}),
)
const workspace = await Instance.provide({
directory: tmp.path,
fn: async () => {
registerAdaptor(
Instance.project.id,
"remote-session-target",
remoteAdaptor(path.join(tmp.path, ".remote-session"), `http://127.0.0.1:${remote.port}/base`),
)
return Workspace.create({
type: "remote-session-target",
branch: null,
extra: null,
projectID: Instance.project.id,
})
},
})
const session = await Instance.provide({
directory: tmp.path,
fn: async () =>
runSession(
Session.Service.use((svc) => svc.create()),
workspace.id,
),
})
it.live("serves mutation endpoints", () =>
Effect.gen(function* () {
Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
const dir = yield* tmpdirScoped({ git: true })
const project = yield* Project.use.fromDirectory(dir)
registerAdaptor(project.project.id, "local-test", localAdaptor(path.join(dir, ".workspace")))
try {
const response = await request(`http://localhost/session/${session.id}/message`, tmp.path, {
const created = yield* request(WorkspacePaths.list, dir, {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ parts: [{ type: "text", text: "hello" }] }),
body: JSON.stringify({ type: "local-test", branch: null, extra: null }),
})
expect(created.status).toBe(200)
const workspace = (yield* Effect.promise(() => created.json())) as Workspace.Info
expect(workspace).toMatchObject({ type: "local-test", name: "local-test" })
const session = yield* Session.Service.use((svc) => svc.create({})).pipe(provideInstance(dir))
const restored = yield* request(WorkspacePaths.sessionRestore.replace(":id", workspace.id), dir, {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ sessionID: session.id }),
})
expect(restored.status).toBe(200)
expect((yield* Effect.promise(() => restored.json())) as { total: number }).toMatchObject({
total: expect.any(Number),
})
const responseBody = await response.text()
expect({ status: response.status, body: responseBody }).toMatchObject({ status: 200 })
expect(JSON.parse(responseBody)).toEqual({ proxied: true, path: `/base/session/${session.id}/message` })
expect(proxied.filter((item) => new URL(item.url).pathname === `/base/session/${session.id}/message`)).toEqual([
expect.objectContaining({
url: `http://127.0.0.1:${remote.port}/base/session/${session.id}/message`,
method: "POST",
const removed = yield* request(WorkspacePaths.remove.replace(":id", workspace.id), dir, { method: "DELETE" })
expect(removed.status).toBe(200)
expect(yield* Effect.promise(() => removed.json())).toMatchObject({ id: workspace.id })
const listed = yield* request(WorkspacePaths.list, dir)
expect(listed.status).toBe(200)
expect(yield* Effect.promise(() => listed.json())).toEqual([])
}),
)
it.live("routes local workspace requests through the workspace target directory", () =>
Effect.gen(function* () {
Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
const dir = yield* tmpdirScoped({ git: true })
const workspaceDir = path.join(dir, ".workspace-local")
const project = yield* Project.use.fromDirectory(dir)
registerAdaptor(project.project.id, "local-target", localAdaptor(workspaceDir))
const created = yield* request(WorkspacePaths.list, dir, {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ type: "local-target", branch: null, extra: null }),
})
const workspace = (yield* Effect.promise(() => created.json())) as Workspace.Info
const url = new URL(`http://localhost${InstancePaths.path}`)
url.searchParams.set("workspace", workspace.id)
const response = yield* request(url.toString(), dir)
expect(response.status).toBe(200)
expect(yield* Effect.promise(() => response.json())).toMatchObject({ directory: workspaceDir })
yield* request(WorkspacePaths.remove.replace(":id", workspace.id), dir, { method: "DELETE" })
}),
)
it.live("proxies remote workspace HTTP requests with sanitized forwarding", () =>
Effect.gen(function* () {
Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
const dir = yield* tmpdirScoped({ git: true })
const proxied: ProxiedRequest[] = []
const remote = listenRemoteHttp((request) => {
proxied.push(request)
const url = new URL(request.url)
if (url.pathname === "/base/global/event") return eventStreamResponse()
if (url.pathname === "/base/sync/history") return Response.json([])
return new Response(
JSON.stringify({
proxied: true,
path: url.pathname,
keep: url.searchParams.get("keep"),
workspace: url.searchParams.get("workspace"),
}),
{
status: 201,
statusText: "Created",
headers: {
"content-length": "999",
"content-type": "application/json",
"x-remote": "yes",
},
},
)
})
const project = yield* Project.use.fromDirectory(dir)
registerAdaptor(
project.project.id,
"remote-target",
remoteAdaptor(path.join(dir, ".remote"), `http://127.0.0.1:${remote.port}/base`, {
"x-target-auth": "secret",
}),
])
} finally {
remote.stop(true)
await Workspace.remove(workspace.id)
}
})
)
const created = yield* request(WorkspacePaths.list, dir, {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ type: "remote-target", branch: null, extra: null }),
})
const workspace = (yield* Effect.promise(() => created.json())) as Workspace.Info
const url = new URL("http://localhost/config")
url.searchParams.set("workspace", workspace.id)
url.searchParams.set("keep", "yes")
try {
const response = yield* request(url.toString(), dir, {
method: "PATCH",
headers: {
"accept-encoding": "br",
"content-type": "application/json",
"x-opencode-workspace": "internal",
},
body: JSON.stringify({ $schema: "https://opencode.ai/config.json" }),
})
const responseBody = yield* Effect.promise(() => response.text())
expect({ status: response.status, body: responseBody }).toMatchObject({ status: 201 })
expect(response.headers.get("content-length")).toBeNull()
expect(response.headers.get("x-remote")).toBe("yes")
expect(JSON.parse(responseBody)).toEqual({ proxied: true, path: "/base/config", keep: "yes", workspace: null })
const forwarded = proxied.filter((item) => new URL(item.url).pathname === "/base/config")
expect(forwarded).toEqual([
{
url: `http://127.0.0.1:${remote.port}/base/config?keep=yes`,
method: "PATCH",
headers: expect.objectContaining({
"content-type": "application/json",
"x-target-auth": "secret",
}),
body: JSON.stringify({ $schema: "https://opencode.ai/config.json" }),
},
])
expect(forwarded[0]?.headers).not.toHaveProperty("x-opencode-directory")
expect(forwarded[0]?.headers).not.toHaveProperty("x-opencode-workspace")
} finally {
void remote.stop(true)
yield* request(WorkspacePaths.remove.replace(":id", workspace.id), dir, { method: "DELETE" })
}
}),
)
it.live("proxies remote workspace requests selected from session ownership", () =>
Effect.gen(function* () {
Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
const dir = yield* tmpdirScoped({ git: true })
const proxied: ProxiedRequest[] = []
const remote = listenRemoteHttp((request) => {
proxied.push(request)
const url = new URL(request.url)
if (url.pathname === "/base/global/event") return eventStreamResponse()
if (url.pathname === "/base/sync/history") return Response.json([])
return Response.json({ proxied: true, path: new URL(request.url).pathname })
})
const project = yield* Project.use.fromDirectory(dir)
registerAdaptor(
project.project.id,
"remote-session-target",
remoteAdaptor(path.join(dir, ".remote-session"), `http://127.0.0.1:${remote.port}/base`),
)
const created = yield* request(WorkspacePaths.list, dir, {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ type: "remote-session-target", branch: null, extra: null }),
})
const workspace = (yield* Effect.promise(() => created.json())) as Workspace.Info
const session = yield* Session.Service.use((svc) => svc.create()).pipe(
Effect.provideService(WorkspaceRef, workspace.id),
provideInstance(dir),
)
try {
const response = yield* request(`http://localhost/session/${session.id}/message`, dir, {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ parts: [{ type: "text", text: "hello" }] }),
})
const responseBody = yield* Effect.promise(() => response.text())
expect({ status: response.status, body: responseBody }).toMatchObject({ status: 200 })
expect(JSON.parse(responseBody)).toEqual({ proxied: true, path: `/base/session/${session.id}/message` })
expect(proxied.filter((item) => new URL(item.url).pathname === `/base/session/${session.id}/message`)).toEqual([
expect.objectContaining({
url: `http://127.0.0.1:${remote.port}/base/session/${session.id}/message`,
method: "POST",
}),
])
} finally {
void remote.stop(true)
yield* request(WorkspacePaths.remove.replace(":id", workspace.id), dir, { method: "DELETE" })
}
}),
)
})