workspace.test.ts 61 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606
  1. import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test"
  2. import { $ } from "bun"
  3. import fs from "node:fs/promises"
  4. import Http from "node:http"
  5. import path from "node:path"
  6. import { setTimeout as delay } from "node:timers/promises"
  7. import { NodeHttpServer } from "@effect/platform-node"
  8. import { Effect, Layer, Schema } from "effect"
  9. import { FetchHttpClient, HttpServer, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
  10. import { eq } from "drizzle-orm"
  11. import * as Log from "@opencode-ai/core/util/log"
  12. import { Flag } from "@opencode-ai/core/flag/flag"
  13. import { GlobalBus, type GlobalEvent } from "@/bus/global"
  14. import { Database } from "@/storage/db"
  15. import { ProjectID } from "@/project/schema"
  16. import { ProjectTable } from "@/project/project.sql"
  17. import { Instance } from "@/project/instance"
  18. import { WithInstance } from "../../src/project/with-instance"
  19. import { InstanceRef } from "@/effect/instance-ref"
  20. import { Session as SessionNs } from "@/session/session"
  21. import { SessionID } from "@/session/schema"
  22. import { SessionTable } from "@/session/session.sql"
  23. import { SyncEvent } from "@/sync"
  24. import { EventSequenceTable } from "@/sync/event.sql"
  25. import { resetDatabase } from "../fixture/db"
  26. import { disposeAllInstances, provideTmpdirInstance, TestInstance, tmpdir } from "../fixture/fixture"
  27. import { testEffect } from "../lib/effect"
  28. import { registerAdapter } from "../../src/control-plane/adapters"
  29. import { WorkspaceID } from "../../src/control-plane/schema"
  30. import { WorkspaceTable } from "../../src/control-plane/workspace.sql"
  31. import type { Target, WorkspaceAdapter, WorkspaceInfo } from "../../src/control-plane/types"
  32. import * as Workspace from "../../src/control-plane/workspace"
  33. import { AppRuntime } from "@/effect/app-runtime"
  34. import { InstanceStore } from "@/project/instance-store"
  35. import { InstanceBootstrap } from "@/project/bootstrap"
  36. import { Auth } from "@/auth"
  37. import { SessionPrompt } from "@/session/prompt"
  38. import { Project } from "@/project/project"
  39. import { Vcs } from "@/project/vcs"
  40. import { RuntimeFlags } from "@/effect/runtime-flags"
  41. void Log.init({ print: false })
  42. const originalWorkspacesFlag = Flag.OPENCODE_EXPERIMENTAL_WORKSPACES
  43. const originalEnv = {
  44. OPENCODE_AUTH_CONTENT: process.env.OPENCODE_AUTH_CONTENT,
  45. OPENCODE_EXPERIMENTAL_WORKSPACES: process.env.OPENCODE_EXPERIMENTAL_WORKSPACES,
  46. OTEL_EXPORTER_OTLP_HEADERS: process.env.OTEL_EXPORTER_OTLP_HEADERS,
  47. OTEL_EXPORTER_OTLP_ENDPOINT: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
  48. OTEL_RESOURCE_ATTRIBUTES: process.env.OTEL_RESOURCE_ATTRIBUTES,
  49. }
  50. const workspaceLayer = (experimentalWorkspaces: boolean) =>
  51. Workspace.layer.pipe(
  52. Layer.provide(Auth.defaultLayer),
  53. Layer.provide(SessionNs.defaultLayer),
  54. Layer.provide(SyncEvent.defaultLayer),
  55. Layer.provide(SessionPrompt.defaultLayer),
  56. Layer.provide(Project.defaultLayer),
  57. Layer.provide(Vcs.defaultLayer),
  58. Layer.provide(FetchHttpClient.layer),
  59. Layer.provide(RuntimeFlags.layer({ experimentalWorkspaces })),
  60. Layer.provide(InstanceStore.defaultLayer.pipe(Layer.provide(InstanceBootstrap.defaultLayer))),
  61. )
  62. const testServerLayer = Layer.mergeAll(
  63. NodeHttpServer.layer(Http.createServer, { host: "127.0.0.1", port: 0 }),
  64. workspaceLayer(true),
  65. SessionNs.defaultLayer,
  66. )
  67. const it = testEffect(testServerLayer)
  68. type RecordedCreate = {
  69. info: WorkspaceInfo
  70. env: Record<string, string | undefined>
  71. from?: WorkspaceInfo
  72. }
  73. type RecordedAdapter = {
  74. adapter: WorkspaceAdapter
  75. calls: {
  76. configure: WorkspaceInfo[]
  77. create: RecordedCreate[]
  78. list: number
  79. remove: WorkspaceInfo[]
  80. target: WorkspaceInfo[]
  81. }
  82. }
  83. type FetchCall = {
  84. url: URL
  85. method: string
  86. headers: Headers
  87. bodyText?: string
  88. json?: unknown
  89. }
  90. function unique(prefix: string) {
  91. return `${prefix}-${Math.random().toString(36).slice(2)}`
  92. }
  93. function restoreEnv() {
  94. Object.entries(originalEnv).forEach(([key, value]) => {
  95. if (value === undefined) {
  96. delete process.env[key]
  97. return
  98. }
  99. process.env[key] = value
  100. })
  101. }
  102. beforeEach(() => {
  103. Database.close()
  104. Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
  105. restoreEnv()
  106. process.env.OPENCODE_EXPERIMENTAL_WORKSPACES = "true"
  107. })
  108. afterEach(async () => {
  109. mock.restore()
  110. await disposeAllInstances()
  111. Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = originalWorkspacesFlag
  112. restoreEnv()
  113. await resetDatabase()
  114. })
  115. async function withInstance<T>(fn: (dir: string) => T | Promise<T>) {
  116. await using tmp = await tmpdir({ git: true })
  117. return await WithInstance.provide({
  118. directory: tmp.path,
  119. fn: () => fn(tmp.path),
  120. })
  121. }
  122. async function initGitRepo(dir: string) {
  123. await fs.mkdir(dir, { recursive: true })
  124. await $`git init`.cwd(dir).quiet()
  125. await $`git config core.fsmonitor false`.cwd(dir).quiet()
  126. await $`git config commit.gpgsign false`.cwd(dir).quiet()
  127. await $`git config user.email "test@opencode.test"`.cwd(dir).quiet()
  128. await $`git config user.name "Test"`.cwd(dir).quiet()
  129. await fs.writeFile(path.join(dir, "tracked.txt"), "base\n")
  130. await $`git add tracked.txt`.cwd(dir).quiet()
  131. await $`git commit -m "base"`.cwd(dir).quiet()
  132. }
  133. const runWorkspace = <A, E>(effect: Effect.Effect<A, E, Workspace.Service>) => AppRuntime.runPromise(effect)
  134. const createWorkspace = (input: Workspace.CreateInput) =>
  135. runWorkspace(Workspace.Service.use((workspace) => workspace.create(input)))
  136. const warpWorkspaceSession = (input: Workspace.SessionWarpInput) =>
  137. runWorkspace(Workspace.Service.use((workspace) => workspace.sessionWarp(input)))
  138. const listWorkspaces = (project: Parameters<Workspace.Interface["list"]>[0]) =>
  139. runWorkspace(Workspace.Service.use((workspace) => workspace.list(project)))
  140. const syncListWorkspaces = (project: Parameters<Workspace.Interface["syncList"]>[0]) =>
  141. runWorkspace(Workspace.Service.use((workspace) => workspace.syncList(project)))
  142. const getWorkspace = (id: WorkspaceID) => runWorkspace(Workspace.Service.use((workspace) => workspace.get(id)))
  143. const removeWorkspace = (id: WorkspaceID) => runWorkspace(Workspace.Service.use((workspace) => workspace.remove(id)))
  144. const workspaceStatus = () => runWorkspace(Workspace.Service.use((workspace) => workspace.status()))
  145. const isWorkspaceSyncing = (id: WorkspaceID) =>
  146. runWorkspace(Workspace.Service.use((workspace) => workspace.isSyncing(id)))
  147. const startWorkspaceSyncing = (projectID: ProjectID) => {
  148. void runWorkspace(Workspace.Service.use((workspace) => workspace.startWorkspaceSyncing(projectID)))
  149. }
  150. const startWorkspaceSyncingWithFlag = (projectID: ProjectID, experimentalWorkspaces: boolean) =>
  151. Effect.runPromise(
  152. Workspace.Service.use((workspace) => workspace.startWorkspaceSyncing(projectID)).pipe(
  153. Effect.provide(workspaceLayer(experimentalWorkspaces)),
  154. ),
  155. )
  156. const waitForWorkspaceSync = (workspaceID: WorkspaceID, state: Record<string, number>, signal?: AbortSignal) =>
  157. runWorkspace(Workspace.Service.use((workspace) => workspace.waitForSync(workspaceID, state, signal)))
  158. function captureGlobalEvents() {
  159. const events: GlobalEvent[] = []
  160. const handler = (event: GlobalEvent) => events.push(event)
  161. GlobalBus.on("event", handler)
  162. return {
  163. events,
  164. dispose() {
  165. GlobalBus.off("event", handler)
  166. },
  167. }
  168. }
  169. async function eventually<T>(fn: () => T | Promise<T>, timeout = 1500) {
  170. const started = Date.now()
  171. let last: unknown
  172. while (Date.now() - started < timeout) {
  173. try {
  174. return await fn()
  175. } catch (err) {
  176. last = err
  177. await delay(10)
  178. }
  179. }
  180. throw last ?? new Error("Timed out waiting for condition")
  181. }
  182. function eventuallyEffect(effect: Effect.Effect<void>, timeout = 1500) {
  183. return Effect.gen(function* () {
  184. const started = Date.now()
  185. let last: unknown
  186. while (Date.now() - started < timeout) {
  187. const exit = yield* Effect.exit(effect)
  188. if (exit._tag === "Success") return
  189. last = exit.cause
  190. yield* Effect.sleep("10 millis")
  191. }
  192. throw last ?? new Error("Timed out waiting for condition")
  193. })
  194. }
  195. function recordedAdapter(input: {
  196. target: (info: WorkspaceInfo) => Target | Promise<Target>
  197. configure?: (info: WorkspaceInfo) => WorkspaceInfo | Promise<WorkspaceInfo>
  198. create?: (info: WorkspaceInfo, env: Record<string, string | undefined>, from?: WorkspaceInfo) => Promise<void>
  199. list?: () => Omit<WorkspaceInfo, "id">[] | Promise<Omit<WorkspaceInfo, "id">[]>
  200. remove?: (info: WorkspaceInfo) => Promise<void>
  201. }): RecordedAdapter {
  202. const calls: RecordedAdapter["calls"] = {
  203. configure: [],
  204. create: [],
  205. list: 0,
  206. remove: [],
  207. target: [],
  208. }
  209. return {
  210. calls,
  211. adapter: {
  212. name: "recorded",
  213. description: "recorded",
  214. configure(info) {
  215. calls.configure.push(structuredClone(info))
  216. return input.configure?.(info) ?? info
  217. },
  218. async create(info, env, from) {
  219. calls.create.push({
  220. info: structuredClone(info),
  221. env: { ...env },
  222. from: from ? structuredClone(from) : undefined,
  223. })
  224. await input.create?.(info, env, from)
  225. },
  226. ...(input.list
  227. ? {
  228. async list() {
  229. calls.list += 1
  230. return input.list?.() ?? []
  231. },
  232. }
  233. : {}),
  234. async remove(info) {
  235. calls.remove.push(structuredClone(info))
  236. await input.remove?.(info)
  237. },
  238. target(info) {
  239. calls.target.push(structuredClone(info))
  240. return input.target(info)
  241. },
  242. },
  243. }
  244. }
  245. function localAdapter(dir: string, input?: { createDir?: boolean; remove?: (info: WorkspaceInfo) => Promise<void> }) {
  246. return recordedAdapter({
  247. configure(info) {
  248. return { ...info, directory: dir }
  249. },
  250. async create() {
  251. if (input?.createDir === false) return
  252. await fs.mkdir(dir, { recursive: true })
  253. },
  254. remove: input?.remove,
  255. target() {
  256. return { type: "local", directory: dir }
  257. },
  258. })
  259. }
  260. function remoteAdapter(url: string, input?: { directory?: string | null; headers?: HeadersInit }) {
  261. return recordedAdapter({
  262. configure(info) {
  263. return { ...info, directory: input?.directory ?? info.directory }
  264. },
  265. target() {
  266. return { type: "remote", url, headers: input?.headers }
  267. },
  268. })
  269. }
  270. function eventStreamResponse(events: unknown[] = [], keepOpen = true) {
  271. const encoder = new TextEncoder()
  272. return new Response(
  273. new ReadableStream<Uint8Array>({
  274. start(controller) {
  275. if (keepOpen) controller.enqueue(encoder.encode(":\n\n"))
  276. events.forEach((event) => controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`)))
  277. if (!keepOpen) controller.close()
  278. },
  279. }),
  280. { status: 200, headers: { "content-type": "text/event-stream" } },
  281. )
  282. }
  283. function serverUrl() {
  284. return Effect.gen(function* () {
  285. return HttpServer.formatAddress((yield* HttpServer.HttpServer).address)
  286. })
  287. }
  288. function workspaceInfo(projectID: ProjectID, type: string, input?: Partial<Workspace.Info>): Workspace.Info {
  289. return {
  290. id: input?.id ?? WorkspaceID.ascending(),
  291. type,
  292. name: input?.name ?? unique("workspace"),
  293. branch: input?.branch ?? null,
  294. directory: input?.directory ?? null,
  295. extra: input?.extra ?? null,
  296. projectID,
  297. timeUsed: input?.timeUsed ?? Date.now(),
  298. }
  299. }
  300. function insertWorkspace(info: Workspace.Info) {
  301. Database.use((db) =>
  302. db
  303. .insert(WorkspaceTable)
  304. .values({
  305. id: info.id,
  306. type: info.type,
  307. branch: info.branch,
  308. name: info.name,
  309. directory: info.directory,
  310. extra: info.extra,
  311. project_id: info.projectID,
  312. time_used: info.timeUsed,
  313. })
  314. .run(),
  315. )
  316. }
  317. function insertProject(id: ProjectID, worktree: string) {
  318. Database.use((db) =>
  319. db
  320. .insert(ProjectTable)
  321. .values({
  322. id,
  323. worktree,
  324. vcs: null,
  325. name: null,
  326. time_created: Date.now(),
  327. time_updated: Date.now(),
  328. sandboxes: [],
  329. })
  330. .run(),
  331. )
  332. }
  333. function attachSessionToWorkspace(sessionID: SessionID, workspaceID: WorkspaceID) {
  334. Database.use((db) =>
  335. db.update(SessionTable).set({ workspace_id: workspaceID }).where(eq(SessionTable.id, sessionID)).run(),
  336. )
  337. }
  338. function sessionSequence(sessionID: SessionID) {
  339. return Database.use((db) =>
  340. db
  341. .select({ seq: EventSequenceTable.seq })
  342. .from(EventSequenceTable)
  343. .where(eq(EventSequenceTable.aggregate_id, sessionID))
  344. .get(),
  345. )?.seq
  346. }
  347. function sessionSequenceOwner(sessionID: SessionID) {
  348. return Database.use((db) =>
  349. db
  350. .select({ ownerID: EventSequenceTable.owner_id })
  351. .from(EventSequenceTable)
  352. .where(eq(EventSequenceTable.aggregate_id, sessionID))
  353. .get(),
  354. )?.ownerID
  355. }
  356. function sessionUpdatedType() {
  357. return SyncEvent.versionedType(SessionNs.Event.Updated.type, SessionNs.Event.Updated.version)
  358. }
  359. describe("workspace schemas and exports", () => {
  360. test("keeps the historical event type names", () => {
  361. expect(Workspace.Event.Ready.type).toBe("workspace.ready")
  362. expect(Workspace.Event.Failed.type).toBe("workspace.failed")
  363. expect(Workspace.Event.Status.type).toBe("workspace.status")
  364. })
  365. test("validates create input with workspace id, project id, branch, type, and extra", () => {
  366. const input = {
  367. id: WorkspaceID.ascending("wrk_schema_create"),
  368. type: "worktree",
  369. branch: "feature/schema",
  370. projectID: ProjectID.make("project-schema"),
  371. extra: { nested: true },
  372. }
  373. const decode = Schema.decodeUnknownSync(Workspace.CreateInput)
  374. expect(decode(input)).toEqual(input)
  375. expect(() => decode({ ...input, id: 1 })).toThrow()
  376. expect(() => decode({ ...input, branch: 1 })).toThrow()
  377. })
  378. })
  379. describe("workspace CRUD", () => {
  380. test("get returns undefined for a missing workspace", async () => {
  381. await withInstance(async () => {
  382. expect(await getWorkspace(WorkspaceID.ascending("wrk_missing_get"))).toBeUndefined()
  383. })
  384. })
  385. test("list maps database rows, filters by project, and sorts by id", async () => {
  386. await withInstance(async () => {
  387. const otherProjectID = ProjectID.make("project-other")
  388. insertProject(otherProjectID, "/tmp/other")
  389. const a = workspaceInfo(Instance.project.id, "manual", {
  390. id: WorkspaceID.ascending("wrk_a_list"),
  391. branch: "a",
  392. directory: "/a",
  393. extra: { a: true },
  394. })
  395. const b = workspaceInfo(Instance.project.id, "manual", {
  396. id: WorkspaceID.ascending("wrk_b_list"),
  397. branch: "b",
  398. directory: "/b",
  399. extra: ["b"],
  400. })
  401. const other = workspaceInfo(otherProjectID, "manual", { id: WorkspaceID.ascending("wrk_c_list") })
  402. insertWorkspace(b)
  403. insertWorkspace(other)
  404. insertWorkspace(a)
  405. expect(await listWorkspaces(Instance.project)).toEqual([a, b])
  406. })
  407. })
  408. test("create configures, persists, creates, starts local sync, and passes environment", async () => {
  409. await withInstance(async (dir) => {
  410. process.env.OPENCODE_AUTH_CONTENT = JSON.stringify({ test: { type: "api", key: "secret" } })
  411. process.env.OTEL_EXPORTER_OTLP_HEADERS = "authorization=otel"
  412. process.env.OTEL_EXPORTER_OTLP_ENDPOINT = "https://otel.test"
  413. process.env.OTEL_RESOURCE_ATTRIBUTES = "service.name=opencode-test"
  414. const workspaceID = WorkspaceID.ascending("wrk_create_local")
  415. const type = unique("create-local")
  416. const targetDir = path.join(dir, "created-local")
  417. const recorded = recordedAdapter({
  418. configure(info) {
  419. return {
  420. ...info,
  421. branch: "configured-branch",
  422. name: "Configured Name",
  423. directory: targetDir,
  424. extra: { configured: true },
  425. }
  426. },
  427. async create() {
  428. await fs.mkdir(targetDir, { recursive: true })
  429. },
  430. target() {
  431. return { type: "local", directory: targetDir }
  432. },
  433. })
  434. registerAdapter(Instance.project.id, type, recorded.adapter)
  435. const info = await createWorkspace({
  436. id: workspaceID,
  437. type,
  438. branch: null,
  439. projectID: Instance.project.id,
  440. extra: null,
  441. })
  442. expect(info).toEqual({
  443. id: workspaceID,
  444. type,
  445. branch: "configured-branch",
  446. name: "Configured Name",
  447. directory: targetDir,
  448. extra: { configured: true },
  449. projectID: Instance.project.id,
  450. timeUsed: info.timeUsed,
  451. })
  452. expect(await getWorkspace(workspaceID)).toEqual(info)
  453. expect(await listWorkspaces(Instance.project)).toEqual([info])
  454. expect(recorded.calls.configure).toHaveLength(1)
  455. expect(recorded.calls.configure[0]).toMatchObject({ id: workspaceID, type, directory: null })
  456. expect(recorded.calls.create).toHaveLength(1)
  457. expect(recorded.calls.create[0].info).toEqual({
  458. id: workspaceID,
  459. type,
  460. branch: "configured-branch",
  461. name: "Configured Name",
  462. directory: targetDir,
  463. extra: { configured: true },
  464. projectID: Instance.project.id,
  465. })
  466. expect(JSON.parse(recorded.calls.create[0].env.OPENCODE_AUTH_CONTENT ?? "{}")).toEqual({
  467. test: { type: "api", key: "secret" },
  468. })
  469. expect(recorded.calls.create[0].env.OPENCODE_WORKSPACE_ID).toBe(workspaceID)
  470. expect(recorded.calls.create[0].env.OPENCODE_EXPERIMENTAL_WORKSPACES).toBe("true")
  471. expect(recorded.calls.create[0].env.OTEL_EXPORTER_OTLP_HEADERS).toBe("authorization=otel")
  472. expect(recorded.calls.create[0].env.OTEL_EXPORTER_OTLP_ENDPOINT).toBe("https://otel.test")
  473. expect(recorded.calls.create[0].env.OTEL_RESOURCE_ATTRIBUTES).toBe("service.name=opencode-test")
  474. expect((await workspaceStatus()).find((item) => item.workspaceID === workspaceID)?.status).toBe("connected")
  475. await removeWorkspace(workspaceID)
  476. expect((await workspaceStatus()).find((item) => item.workspaceID === workspaceID)?.status).toBeUndefined()
  477. })
  478. })
  479. test("create propagates configure failures and does not insert a workspace", async () => {
  480. await withInstance(async () => {
  481. const type = unique("configure-failure")
  482. registerAdapter(
  483. Instance.project.id,
  484. type,
  485. recordedAdapter({
  486. configure() {
  487. throw new Error("configure exploded")
  488. },
  489. target() {
  490. return { type: "local", directory: "/unused" }
  491. },
  492. }).adapter,
  493. )
  494. await expect(
  495. createWorkspace({ type, branch: null, projectID: Instance.project.id, extra: null }),
  496. ).rejects.toThrow("configure exploded")
  497. expect(await listWorkspaces(Instance.project)).toEqual([])
  498. })
  499. })
  500. test("create leaves the inserted row when adapter create fails", async () => {
  501. await withInstance(async () => {
  502. const type = unique("create-failure")
  503. const recorded = recordedAdapter({
  504. async create() {
  505. throw new Error("create exploded")
  506. },
  507. target() {
  508. return { type: "local", directory: "/unused" }
  509. },
  510. })
  511. registerAdapter(Instance.project.id, type, recorded.adapter)
  512. await expect(
  513. createWorkspace({ type, branch: "branch", projectID: Instance.project.id, extra: { x: 1 } }),
  514. ).rejects.toThrow("create exploded")
  515. const rows = await listWorkspaces(Instance.project)
  516. expect(rows).toHaveLength(1)
  517. expect(rows[0]).toMatchObject({ type, branch: "branch", extra: { x: 1 } })
  518. expect(recorded.calls.target).toHaveLength(0)
  519. await removeWorkspace(rows[0].id)
  520. })
  521. })
  522. test("create returns after a local workspace reports error", async () => {
  523. await withInstance(async (dir) => {
  524. const type = unique("local-error")
  525. const missing = path.join(dir, "missing-local-target")
  526. const recorded = localAdapter(missing, { createDir: false })
  527. registerAdapter(Instance.project.id, type, recorded.adapter)
  528. const info = await createWorkspace({ type, branch: null, projectID: Instance.project.id, extra: null })
  529. expect(info.directory).toBe(missing)
  530. expect((await workspaceStatus()).find((item) => item.workspaceID === info.id)?.status).toBe("error")
  531. await removeWorkspace(info.id)
  532. })
  533. })
  534. test("syncList registers adapter-listed workspaces that are missing by name", async () => {
  535. await withInstance(async (dir) => {
  536. const type = unique("list-sync")
  537. const existing = workspaceInfo(Instance.project.id, type, {
  538. id: WorkspaceID.ascending("wrk_list_sync_existing"),
  539. name: "existing",
  540. directory: path.join(dir, "existing"),
  541. })
  542. insertWorkspace(existing)
  543. const discovered = {
  544. type,
  545. name: "discovered",
  546. branch: "feature/discovered",
  547. directory: path.join(dir, "discovered"),
  548. extra: { source: "adapter" },
  549. projectID: Instance.project.id,
  550. }
  551. const recorded = recordedAdapter({
  552. list() {
  553. return [
  554. {
  555. type,
  556. name: existing.name,
  557. branch: "ignored",
  558. directory: path.join(dir, "ignored"),
  559. extra: null,
  560. projectID: Instance.project.id,
  561. },
  562. discovered,
  563. ]
  564. },
  565. target(info) {
  566. return { type: "local", directory: info.directory ?? dir }
  567. },
  568. })
  569. registerAdapter(Instance.project.id, type, recorded.adapter)
  570. await syncListWorkspaces(Instance.project)
  571. const synced = (await listWorkspaces(Instance.project)).filter((item) => item.name === discovered.name)
  572. expect(synced).toHaveLength(1)
  573. expect(synced[0]).toMatchObject(discovered)
  574. expect(synced[0]?.id).toStartWith("wrk_")
  575. expect(await listWorkspaces(Instance.project)).toEqual(expect.arrayContaining([existing, synced[0]]))
  576. expect(recorded.calls.list).toBe(1)
  577. expect(recorded.calls.configure).toHaveLength(0)
  578. expect(recorded.calls.create).toHaveLength(0)
  579. expect(recorded.calls.target).toHaveLength(1)
  580. })
  581. })
  582. test("syncList calls every registered adapter with a list method", async () => {
  583. await withInstance(async (dir) => {
  584. const typeA = unique("list-sync-a")
  585. const typeB = unique("list-sync-b")
  586. const adapterA = recordedAdapter({
  587. list() {
  588. return [
  589. {
  590. type: typeA,
  591. name: "adapter-a",
  592. branch: null,
  593. directory: path.join(dir, "adapter-a"),
  594. extra: null,
  595. projectID: Instance.project.id,
  596. },
  597. ]
  598. },
  599. target(info) {
  600. return { type: "local", directory: info.directory ?? dir }
  601. },
  602. })
  603. const adapterB = recordedAdapter({
  604. list() {
  605. return [
  606. {
  607. type: typeB,
  608. name: "adapter-b",
  609. branch: null,
  610. directory: path.join(dir, "adapter-b"),
  611. extra: null,
  612. projectID: Instance.project.id,
  613. },
  614. ]
  615. },
  616. target(info) {
  617. return { type: "local", directory: info.directory ?? dir }
  618. },
  619. })
  620. const noList = recordedAdapter({
  621. target() {
  622. return { type: "local", directory: dir }
  623. },
  624. })
  625. registerAdapter(Instance.project.id, typeA, adapterA.adapter)
  626. registerAdapter(Instance.project.id, typeB, adapterB.adapter)
  627. registerAdapter(Instance.project.id, unique("list-sync-none"), noList.adapter)
  628. await syncListWorkspaces(Instance.project)
  629. const synced = await listWorkspaces(Instance.project)
  630. expect(
  631. synced
  632. .filter((item) => item.type === typeA || item.type === typeB)
  633. .map((item) => item.name)
  634. .toSorted(),
  635. ).toEqual(["adapter-a", "adapter-b"])
  636. expect(adapterA.calls.list).toBe(1)
  637. expect(adapterB.calls.list).toBe(1)
  638. expect(noList.calls.list).toBe(0)
  639. })
  640. })
  641. it.live("remote create connects to routed event and history endpoints", () => {
  642. const calls: FetchCall[] = []
  643. return Effect.gen(function* () {
  644. yield* HttpServer.serveEffect()(
  645. Effect.gen(function* () {
  646. const req = yield* HttpServerRequest.HttpServerRequest
  647. const bodyText = yield* req.text
  648. const call = {
  649. url: new URL(req.url, "http://localhost"),
  650. method: req.method,
  651. headers: new Headers(req.headers),
  652. bodyText,
  653. json: bodyText ? JSON.parse(bodyText) : undefined,
  654. }
  655. calls.push(call)
  656. if (call.url.pathname === "/base/global/event")
  657. return HttpServerResponse.fromWeb(eventStreamResponse([], false))
  658. if (call.url.pathname === "/base/sync/history") return yield* HttpServerResponse.json([])
  659. return HttpServerResponse.text("unexpected", { status: 500 })
  660. }),
  661. )
  662. const url = yield* serverUrl()
  663. yield* provideTmpdirInstance(
  664. (dir) =>
  665. Effect.gen(function* () {
  666. const workspace = yield* Workspace.Service
  667. const type = unique("remote-create")
  668. const recorded = remoteAdapter(`${url}/base/?ignored=1#hash`, { directory: dir })
  669. registerAdapter(Instance.project.id, type, recorded.adapter)
  670. const info = yield* workspace.create({ type, branch: null, projectID: Instance.project.id, extra: null })
  671. expect(
  672. calls.map((call) => `${call.method} ${call.url.pathname}${call.url.search}${call.url.hash}`),
  673. ).toEqual(["GET /base/global/event", "POST /base/sync/history"])
  674. expect(calls[1].json).toEqual({})
  675. expect((yield* workspace.status()).find((item) => item.workspaceID === info.id)?.status).toBe("connected")
  676. expect(yield* workspace.isSyncing(info.id)).toBe(true)
  677. yield* workspace.remove(info.id)
  678. expect(yield* workspace.isSyncing(info.id)).toBe(false)
  679. expect((yield* workspace.status()).find((item) => item.workspaceID === info.id)?.status).toBeUndefined()
  680. }),
  681. { git: true },
  682. )
  683. })
  684. })
  685. test("remove returns undefined for a missing workspace", async () => {
  686. await withInstance(async () => {
  687. expect(await removeWorkspace(WorkspaceID.ascending("wrk_missing_remove"))).toBeUndefined()
  688. })
  689. })
  690. it.instance(
  691. "remove deletes the workspace, associated sessions, adapter resources, and status",
  692. () => {
  693. return Effect.gen(function* () {
  694. const { directory: dir } = yield* TestInstance
  695. const instance = yield* InstanceRef
  696. if (!instance) return yield* Effect.die(new Error("missing test instance"))
  697. const workspace = yield* Workspace.Service
  698. const sessionSvc = yield* SessionNs.Service
  699. const type = unique("remove-local")
  700. const recorded = localAdapter(path.join(dir, "remove-local"))
  701. registerAdapter(instance.project.id, type, recorded.adapter)
  702. const info = yield* workspace.create({ type, branch: null, projectID: instance.project.id, extra: null })
  703. const one = yield* sessionSvc.create({})
  704. const two = yield* sessionSvc.create({})
  705. attachSessionToWorkspace(one.id, info.id)
  706. attachSessionToWorkspace(two.id, info.id)
  707. const removed = yield* workspace.remove(info.id)
  708. expect(removed).toEqual(info)
  709. expect(yield* workspace.get(info.id)).toBeUndefined()
  710. expect(recorded.calls.remove).toEqual([info])
  711. expect((yield* workspace.status()).find((item) => item.workspaceID === info.id)?.status).toBeUndefined()
  712. expect(
  713. Database.use((db) =>
  714. db.select({ id: SessionTable.id }).from(SessionTable).where(eq(SessionTable.workspace_id, info.id)).all(),
  715. ),
  716. ).toEqual([])
  717. })
  718. },
  719. { git: true },
  720. )
  721. test("remove still deletes the row when the adapter cannot remove resources", async () => {
  722. await withInstance(async () => {
  723. const type = unique("remove-throws")
  724. const info = workspaceInfo(Instance.project.id, type, { id: WorkspaceID.ascending("wrk_remove_throws") })
  725. registerAdapter(
  726. Instance.project.id,
  727. type,
  728. recordedAdapter({
  729. async remove() {
  730. throw new Error("remove exploded")
  731. },
  732. target() {
  733. return { type: "local", directory: "/unused" }
  734. },
  735. }).adapter,
  736. )
  737. insertWorkspace(info)
  738. expect(await removeWorkspace(info.id)).toEqual(info)
  739. expect(await getWorkspace(info.id)).toBeUndefined()
  740. })
  741. })
  742. it.instance(
  743. "sessionWarp moves a session into a local workspace and claims ownership",
  744. () => {
  745. return Effect.gen(function* () {
  746. const { directory: dir } = yield* TestInstance
  747. const instance = yield* InstanceRef
  748. if (!instance) return yield* Effect.die(new Error("missing test instance"))
  749. const workspace = yield* Workspace.Service
  750. const sessionSvc = yield* SessionNs.Service
  751. const previousType = unique("warp-prev-local")
  752. const targetType = unique("warp-target-local")
  753. const previous = workspaceInfo(instance.project.id, previousType)
  754. const target = workspaceInfo(instance.project.id, targetType)
  755. insertWorkspace(previous)
  756. insertWorkspace(target)
  757. registerAdapter(instance.project.id, previousType, localAdapter(path.join(dir, "warp-prev-local")).adapter)
  758. registerAdapter(instance.project.id, targetType, localAdapter(path.join(dir, "warp-target-local")).adapter)
  759. const session = yield* sessionSvc.create({})
  760. attachSessionToWorkspace(session.id, previous.id)
  761. yield* workspace.sessionWarp({ workspaceID: target.id, sessionID: session.id })
  762. expect(
  763. Database.use((db) =>
  764. db
  765. .select({ workspaceID: SessionTable.workspace_id })
  766. .from(SessionTable)
  767. .where(eq(SessionTable.id, session.id))
  768. .get(),
  769. )?.workspaceID,
  770. ).toBe(target.id)
  771. expect(sessionSequenceOwner(session.id)).toBe(target.id)
  772. })
  773. },
  774. { git: true },
  775. )
  776. it.instance(
  777. "sessionWarp applies source workspace patch to local target workspace",
  778. () => {
  779. return Effect.gen(function* () {
  780. const { directory: dir } = yield* TestInstance
  781. const instance = yield* InstanceRef
  782. if (!instance) return yield* Effect.die(new Error("missing test instance"))
  783. const workspace = yield* Workspace.Service
  784. const sessionSvc = yield* SessionNs.Service
  785. const previousType = unique("warp-patch-prev-local")
  786. const targetType = unique("warp-patch-target-local")
  787. const previousDir = path.join(dir, "warp-patch-prev-local")
  788. const targetDir = path.join(dir, "warp-patch-target-local")
  789. yield* Effect.promise(() => initGitRepo(previousDir))
  790. yield* Effect.promise(() => initGitRepo(targetDir))
  791. yield* Effect.promise(() => fs.writeFile(path.join(previousDir, "tracked.txt"), "changed\n"))
  792. yield* Effect.promise(() => fs.writeFile(path.join(previousDir, "new.txt"), "new\n"))
  793. const previous = workspaceInfo(instance.project.id, previousType)
  794. const target = workspaceInfo(instance.project.id, targetType)
  795. insertWorkspace(previous)
  796. insertWorkspace(target)
  797. registerAdapter(instance.project.id, previousType, localAdapter(previousDir, { createDir: false }).adapter)
  798. registerAdapter(instance.project.id, targetType, localAdapter(targetDir, { createDir: false }).adapter)
  799. const session = yield* sessionSvc.create({})
  800. attachSessionToWorkspace(session.id, previous.id)
  801. yield* workspace.sessionWarp({ workspaceID: target.id, sessionID: session.id, copyChanges: true })
  802. expect(yield* Effect.promise(() => fs.readFile(path.join(targetDir, "tracked.txt"), "utf8"))).toBe("changed\n")
  803. expect(yield* Effect.promise(() => fs.readFile(path.join(targetDir, "new.txt"), "utf8"))).toBe("new\n")
  804. })
  805. },
  806. { git: true },
  807. )
  808. it.instance(
  809. "sessionWarp detaches a session to the local project and claims project ownership",
  810. () => {
  811. return Effect.gen(function* () {
  812. const { directory: dir } = yield* TestInstance
  813. const instance = yield* InstanceRef
  814. if (!instance) return yield* Effect.die(new Error("missing test instance"))
  815. const workspace = yield* Workspace.Service
  816. const sessionSvc = yield* SessionNs.Service
  817. const previousType = unique("warp-detach-local")
  818. const previous = workspaceInfo(instance.project.id, previousType)
  819. insertWorkspace(previous)
  820. registerAdapter(instance.project.id, previousType, localAdapter(path.join(dir, "warp-detach-local")).adapter)
  821. const session = yield* sessionSvc.create({})
  822. attachSessionToWorkspace(session.id, previous.id)
  823. yield* workspace.sessionWarp({ workspaceID: null, sessionID: session.id })
  824. expect(
  825. Database.use((db) =>
  826. db
  827. .select({ workspaceID: SessionTable.workspace_id })
  828. .from(SessionTable)
  829. .where(eq(SessionTable.id, session.id))
  830. .get(),
  831. )?.workspaceID,
  832. ).toBeNull()
  833. expect(sessionSequenceOwner(session.id)).toBe(instance.project.id)
  834. })
  835. },
  836. { git: true },
  837. )
  838. test("sessionWarp detaches to the source project when invoked from a workspace instance", async () => {
  839. await withInstance(async () => {
  840. const projectID = Instance.project.id
  841. await using workspaceTmp = await tmpdir({ git: true })
  842. const previousType = unique("warp-detach-workspace-instance")
  843. const previous = workspaceInfo(projectID, previousType)
  844. insertWorkspace(previous)
  845. registerAdapter(projectID, previousType, localAdapter(workspaceTmp.path, { createDir: false }).adapter)
  846. const session = await AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.create({})))
  847. attachSessionToWorkspace(session.id, previous.id)
  848. const workspaceProjectID = await WithInstance.provide({
  849. directory: workspaceTmp.path,
  850. fn: async () => {
  851. const id = Instance.project.id
  852. expect(id).not.toBe(projectID)
  853. await warpWorkspaceSession({ workspaceID: null, sessionID: session.id })
  854. return id
  855. },
  856. })
  857. expect(
  858. Database.use((db) =>
  859. db
  860. .select({ workspaceID: SessionTable.workspace_id })
  861. .from(SessionTable)
  862. .where(eq(SessionTable.id, session.id))
  863. .get(),
  864. )?.workspaceID,
  865. ).toBeNull()
  866. expect(sessionSequenceOwner(session.id)).toBe(projectID)
  867. expect(sessionSequenceOwner(session.id)).not.toBe(workspaceProjectID)
  868. })
  869. })
  870. it.live("sessionWarp syncs previous remote history, replays it, steals, and claims the sequence", () => {
  871. const calls: FetchCall[] = []
  872. let historySessionID: SessionID | undefined
  873. let historyNextSeq = 0
  874. return Effect.gen(function* () {
  875. yield* HttpServer.serveEffect()(
  876. Effect.gen(function* () {
  877. const req = yield* HttpServerRequest.HttpServerRequest
  878. const bodyText = yield* req.text
  879. const call = {
  880. url: new URL(req.url, "http://localhost"),
  881. method: req.method,
  882. headers: new Headers(req.headers),
  883. bodyText,
  884. json: bodyText ? JSON.parse(bodyText) : undefined,
  885. }
  886. calls.push(call)
  887. if (call.url.pathname === "/warp-source/sync/history") {
  888. return yield* HttpServerResponse.json([
  889. {
  890. id: `evt_${unique("warp-source-history")}`,
  891. aggregate_id: historySessionID!,
  892. seq: historyNextSeq,
  893. type: sessionUpdatedType(),
  894. data: { sessionID: historySessionID!, info: { title: "from source history" } },
  895. },
  896. ])
  897. }
  898. if (call.url.pathname === "/warp-source/vcs/diff/raw") return HttpServerResponse.text("remote patch")
  899. if (call.url.pathname === "/warp-target/sync/replay")
  900. return yield* HttpServerResponse.json({ sessionID: "ok" })
  901. if (call.url.pathname === "/warp-target/sync/steal")
  902. return yield* HttpServerResponse.json({ sessionID: "ok" })
  903. if (call.url.pathname === "/warp-target/vcs/apply") return yield* HttpServerResponse.json({ applied: true })
  904. return HttpServerResponse.text("unexpected", { status: 500 })
  905. }),
  906. )
  907. const url = yield* serverUrl()
  908. yield* provideTmpdirInstance(
  909. () =>
  910. Effect.gen(function* () {
  911. const workspace = yield* Workspace.Service
  912. const sessionSvc = yield* SessionNs.Service
  913. const previousType = unique("warp-remote-source")
  914. const targetType = unique("warp-remote-target")
  915. const previous = workspaceInfo(Instance.project.id, previousType)
  916. const target = workspaceInfo(Instance.project.id, targetType, { directory: "remote-target-dir" })
  917. insertWorkspace(previous)
  918. insertWorkspace(target)
  919. registerAdapter(Instance.project.id, previousType, remoteAdapter(`${url}/warp-source`).adapter)
  920. registerAdapter(Instance.project.id, targetType, remoteAdapter(`${url}/warp-target`).adapter)
  921. const session = yield* sessionSvc.create({})
  922. attachSessionToWorkspace(session.id, previous.id)
  923. historySessionID = session.id
  924. historyNextSeq = (sessionSequence(session.id) ?? -1) + 1
  925. yield* workspace.sessionWarp({ workspaceID: target.id, sessionID: session.id, copyChanges: true })
  926. expect(calls.map((call) => `${call.method} ${call.url.pathname}`)).toEqual([
  927. "POST /warp-source/sync/history",
  928. "GET /warp-source/vcs/diff/raw",
  929. "POST /warp-target/vcs/apply",
  930. "POST /warp-target/sync/replay",
  931. "POST /warp-target/sync/steal",
  932. ])
  933. expect(calls[0].json).toEqual({ [session.id]: historyNextSeq - 1 })
  934. expect(calls[2].json).toEqual({ patch: "remote patch" })
  935. expect(calls[3].json).toMatchObject({
  936. directory: "remote-target-dir",
  937. events: [
  938. {
  939. aggregateID: session.id,
  940. seq: 0,
  941. type: SyncEvent.versionedType(SessionNs.Event.Created.type, SessionNs.Event.Created.version),
  942. },
  943. {
  944. aggregateID: session.id,
  945. seq: historyNextSeq,
  946. type: sessionUpdatedType(),
  947. },
  948. ],
  949. })
  950. expect(calls[4].json).toEqual({ sessionID: session.id })
  951. expect((yield* sessionSvc.get(session.id)).title).toBe("from source history")
  952. expect(sessionSequenceOwner(session.id)).toBe(target.id)
  953. }),
  954. { git: true },
  955. )
  956. })
  957. })
  958. })
  959. describe("workspace sync state", () => {
  960. test("startWorkspaceSyncing is disabled by the experimental workspace flag", async () => {
  961. await withInstance(async (dir) => {
  962. const type = unique("flag-disabled")
  963. const info = workspaceInfo(Instance.project.id, type)
  964. const session = await AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.create({})))
  965. attachSessionToWorkspace(session.id, info.id)
  966. insertWorkspace(info)
  967. registerAdapter(Instance.project.id, type, localAdapter(path.join(dir, "flag-disabled")).adapter)
  968. await startWorkspaceSyncingWithFlag(Instance.project.id, false)
  969. await delay(25)
  970. expect((await workspaceStatus()).find((item) => item.workspaceID === info.id)?.status).toBeUndefined()
  971. })
  972. })
  973. it.instance(
  974. "startWorkspaceSyncing starts all workspaces",
  975. () =>
  976. Effect.gen(function* () {
  977. const { directory: dir } = yield* TestInstance
  978. const instance = yield* InstanceRef
  979. if (!instance) return yield* Effect.die(new Error("missing test instance"))
  980. const workspace = yield* Workspace.Service
  981. const projectID = instance.project.id
  982. const firstType = unique("first")
  983. const secondType = unique("second")
  984. const first = workspaceInfo(projectID, firstType)
  985. const second = workspaceInfo(projectID, secondType)
  986. yield* Effect.promise(() => fs.mkdir(path.join(dir, "first"), { recursive: true }))
  987. yield* Effect.promise(() => fs.mkdir(path.join(dir, "second"), { recursive: true }))
  988. yield* Effect.sync(() => {
  989. insertWorkspace(first)
  990. insertWorkspace(second)
  991. registerAdapter(projectID, firstType, localAdapter(path.join(dir, "first")).adapter)
  992. registerAdapter(projectID, secondType, localAdapter(path.join(dir, "second")).adapter)
  993. })
  994. yield* Effect.addFinalizer(() =>
  995. Effect.all([workspace.remove(first.id), workspace.remove(second.id)], { discard: true }).pipe(Effect.ignore),
  996. )
  997. yield* workspace.startWorkspaceSyncing(projectID)
  998. yield* eventuallyEffect(
  999. Effect.gen(function* () {
  1000. const status = yield* workspace.status()
  1001. expect(status.find((item) => item.workspaceID === first.id)?.status).toBe("connected")
  1002. expect(status.find((item) => item.workspaceID === second.id)?.status).toBe("connected")
  1003. }),
  1004. )
  1005. }),
  1006. { git: true },
  1007. )
  1008. test("local start reports error when the target directory is missing", async () => {
  1009. await withInstance(async (dir) => {
  1010. const type = unique("missing-local")
  1011. const info = workspaceInfo(Instance.project.id, type)
  1012. insertWorkspace(info)
  1013. registerAdapter(
  1014. Instance.project.id,
  1015. type,
  1016. localAdapter(path.join(dir, "missing-target"), { createDir: false }).adapter,
  1017. )
  1018. attachSessionToWorkspace(
  1019. (await AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.create({})))).id,
  1020. info.id,
  1021. )
  1022. startWorkspaceSyncing(Instance.project.id)
  1023. await eventually(() =>
  1024. workspaceStatus().then((status) =>
  1025. expect(status.find((item) => item.workspaceID === info.id)?.status).toBe("error"),
  1026. ),
  1027. )
  1028. expect(await isWorkspaceSyncing(info.id)).toBe(false)
  1029. await removeWorkspace(info.id)
  1030. })
  1031. })
  1032. test("duplicate local status updates are suppressed", async () => {
  1033. await withInstance(async (dir) => {
  1034. const captured = captureGlobalEvents()
  1035. try {
  1036. const type = unique("dedupe-local")
  1037. const info = workspaceInfo(Instance.project.id, type)
  1038. const target = path.join(dir, "dedupe-local")
  1039. await fs.mkdir(target, { recursive: true })
  1040. insertWorkspace(info)
  1041. registerAdapter(Instance.project.id, type, localAdapter(target).adapter)
  1042. attachSessionToWorkspace(
  1043. (await AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.create({})))).id,
  1044. info.id,
  1045. )
  1046. startWorkspaceSyncing(Instance.project.id)
  1047. startWorkspaceSyncing(Instance.project.id)
  1048. await eventually(() =>
  1049. workspaceStatus().then((status) =>
  1050. expect(status.find((item) => item.workspaceID === info.id)?.status).toBe("connected"),
  1051. ),
  1052. )
  1053. expect(
  1054. captured.events.filter(
  1055. (event) => event.workspace === info.id && event.payload.type === Workspace.Event.Status.type,
  1056. ),
  1057. ).toHaveLength(1)
  1058. await removeWorkspace(info.id)
  1059. } finally {
  1060. captured.dispose()
  1061. }
  1062. })
  1063. })
  1064. it.live("remote start emits disconnected, connecting, and connected then refuses duplicate listeners", () => {
  1065. const calls: FetchCall[] = []
  1066. return Effect.gen(function* () {
  1067. yield* HttpServer.serveEffect()(
  1068. Effect.gen(function* () {
  1069. const req = yield* HttpServerRequest.HttpServerRequest
  1070. const bodyText = yield* req.text
  1071. const call = {
  1072. url: new URL(req.url, "http://localhost"),
  1073. method: req.method,
  1074. headers: new Headers(req.headers),
  1075. bodyText,
  1076. json: bodyText ? JSON.parse(bodyText) : undefined,
  1077. }
  1078. calls.push(call)
  1079. if (call.url.pathname === "/sync/global/event") return HttpServerResponse.fromWeb(eventStreamResponse())
  1080. if (call.url.pathname === "/sync/sync/history") return HttpServerResponse.fromWeb(Response.json([]))
  1081. return HttpServerResponse.text("unexpected", { status: 500 })
  1082. }),
  1083. )
  1084. const url = yield* serverUrl()
  1085. yield* provideTmpdirInstance(
  1086. () =>
  1087. Effect.gen(function* () {
  1088. const workspace = yield* Workspace.Service
  1089. const sessionSvc = yield* SessionNs.Service
  1090. const captured = captureGlobalEvents()
  1091. try {
  1092. const type = unique("remote-start")
  1093. const info = workspaceInfo(Instance.project.id, type)
  1094. insertWorkspace(info)
  1095. registerAdapter(Instance.project.id, type, remoteAdapter(`${url}/sync`).adapter)
  1096. attachSessionToWorkspace((yield* sessionSvc.create({})).id, info.id)
  1097. yield* workspace.startWorkspaceSyncing(Instance.project.id)
  1098. yield* eventuallyEffect(
  1099. Effect.gen(function* () {
  1100. expect((yield* workspace.status()).find((item) => item.workspaceID === info.id)?.status).toBe(
  1101. "connected",
  1102. )
  1103. }),
  1104. )
  1105. yield* workspace.startWorkspaceSyncing(Instance.project.id)
  1106. yield* Effect.sleep("25 millis")
  1107. expect(
  1108. captured.events
  1109. .filter((event) => event.workspace === info.id && event.payload.type === Workspace.Event.Status.type)
  1110. .map((event) => event.payload.properties.status),
  1111. ).toEqual(["disconnected", "connecting", "connected"])
  1112. expect(calls.filter((call) => call.url.pathname === "/sync/global/event")).toHaveLength(1)
  1113. expect(calls.filter((call) => call.url.pathname === "/sync/sync/history")).toHaveLength(1)
  1114. expect(yield* workspace.isSyncing(info.id)).toBe(true)
  1115. yield* workspace.remove(info.id)
  1116. expect(yield* workspace.isSyncing(info.id)).toBe(false)
  1117. } finally {
  1118. captured.dispose()
  1119. }
  1120. }),
  1121. { git: true },
  1122. )
  1123. })
  1124. })
  1125. it.live("remote connection HTTP failures set error and clear syncing", () =>
  1126. Effect.gen(function* () {
  1127. yield* HttpServer.serveEffect()(
  1128. Effect.gen(function* () {
  1129. const req = yield* HttpServerRequest.HttpServerRequest
  1130. if (new URL(req.url, "http://localhost").pathname === "/failed/global/event")
  1131. return HttpServerResponse.text("nope", { status: 503 })
  1132. return HttpServerResponse.fromWeb(Response.json([]))
  1133. }),
  1134. )
  1135. const url = yield* serverUrl()
  1136. yield* provideTmpdirInstance(
  1137. () =>
  1138. Effect.gen(function* () {
  1139. const workspace = yield* Workspace.Service
  1140. const sessionSvc = yield* SessionNs.Service
  1141. const type = unique("remote-connect-fail")
  1142. const info = workspaceInfo(Instance.project.id, type)
  1143. insertWorkspace(info)
  1144. registerAdapter(Instance.project.id, type, remoteAdapter(`${url}/failed`).adapter)
  1145. attachSessionToWorkspace((yield* sessionSvc.create({})).id, info.id)
  1146. yield* workspace.startWorkspaceSyncing(Instance.project.id)
  1147. yield* eventuallyEffect(
  1148. Effect.gen(function* () {
  1149. expect((yield* workspace.status()).find((item) => item.workspaceID === info.id)?.status).toBe("error")
  1150. }),
  1151. )
  1152. expect(yield* workspace.isSyncing(info.id)).toBe(false)
  1153. yield* workspace.remove(info.id)
  1154. }),
  1155. { git: true },
  1156. )
  1157. }),
  1158. )
  1159. it.live("remote history HTTP failures set error", () =>
  1160. Effect.gen(function* () {
  1161. yield* HttpServer.serveEffect()(
  1162. Effect.gen(function* () {
  1163. const req = yield* HttpServerRequest.HttpServerRequest
  1164. const url = new URL(req.url, "http://localhost")
  1165. if (url.pathname === "/history-failed/global/event")
  1166. return HttpServerResponse.fromWeb(eventStreamResponse([], false))
  1167. if (url.pathname === "/history-failed/sync/history")
  1168. return HttpServerResponse.text("history failed", { status: 500 })
  1169. return HttpServerResponse.fromWeb(Response.json([]))
  1170. }),
  1171. )
  1172. const url = yield* serverUrl()
  1173. yield* provideTmpdirInstance(
  1174. () =>
  1175. Effect.gen(function* () {
  1176. const workspace = yield* Workspace.Service
  1177. const sessionSvc = yield* SessionNs.Service
  1178. const type = unique("remote-history-fail")
  1179. const info = workspaceInfo(Instance.project.id, type)
  1180. insertWorkspace(info)
  1181. registerAdapter(Instance.project.id, type, remoteAdapter(`${url}/history-failed`).adapter)
  1182. attachSessionToWorkspace((yield* sessionSvc.create({})).id, info.id)
  1183. yield* workspace.startWorkspaceSyncing(Instance.project.id)
  1184. yield* eventuallyEffect(
  1185. Effect.gen(function* () {
  1186. expect((yield* workspace.status()).find((item) => item.workspaceID === info.id)?.status).toBe("error")
  1187. }),
  1188. )
  1189. expect(yield* workspace.isSyncing(info.id)).toBe(false)
  1190. yield* workspace.remove(info.id)
  1191. }),
  1192. { git: true },
  1193. )
  1194. }),
  1195. )
  1196. it.live("sync history sends the local sequence fence and replays returned events in workspace context", () => {
  1197. const historyBodies: unknown[] = []
  1198. let historySessionID: SessionID | undefined
  1199. let historyNextSeq = 0
  1200. return Effect.gen(function* () {
  1201. yield* HttpServer.serveEffect()(
  1202. Effect.gen(function* () {
  1203. const req = yield* HttpServerRequest.HttpServerRequest
  1204. const bodyText = yield* req.text
  1205. const url = new URL(req.url, "http://localhost")
  1206. if (url.pathname === "/history/global/event") return HttpServerResponse.fromWeb(eventStreamResponse())
  1207. if (url.pathname === "/history/sync/history") {
  1208. historyBodies.push(bodyText ? JSON.parse(bodyText) : undefined)
  1209. return HttpServerResponse.fromWeb(
  1210. Response.json([
  1211. {
  1212. id: `evt_${unique("history")}`,
  1213. aggregate_id: historySessionID!,
  1214. seq: historyNextSeq,
  1215. type: sessionUpdatedType(),
  1216. data: { sessionID: historySessionID!, info: { title: "from history" } },
  1217. },
  1218. ]),
  1219. )
  1220. }
  1221. return HttpServerResponse.text("unexpected", { status: 500 })
  1222. }),
  1223. )
  1224. const url = yield* serverUrl()
  1225. yield* provideTmpdirInstance(
  1226. () =>
  1227. Effect.gen(function* () {
  1228. const workspace = yield* Workspace.Service
  1229. const sessionSvc = yield* SessionNs.Service
  1230. const captured = captureGlobalEvents()
  1231. try {
  1232. const type = unique("history-replay")
  1233. const info = workspaceInfo(Instance.project.id, type)
  1234. insertWorkspace(info)
  1235. registerAdapter(Instance.project.id, type, remoteAdapter(`${url}/history`).adapter)
  1236. const session = yield* sessionSvc.create({ title: "before history" })
  1237. attachSessionToWorkspace(session.id, info.id)
  1238. historySessionID = session.id
  1239. historyNextSeq = (sessionSequence(session.id) ?? -1) + 1
  1240. yield* workspace.startWorkspaceSyncing(Instance.project.id)
  1241. yield* eventuallyEffect(
  1242. Effect.gen(function* () {
  1243. expect((yield* sessionSvc.get(session.id).pipe(Effect.orDie)).title).toBe("from history")
  1244. }),
  1245. )
  1246. expect(historyBodies).toEqual([{ [session.id]: historyNextSeq - 1 }])
  1247. expect(
  1248. captured.events.some(
  1249. (event) =>
  1250. event.workspace === info.id &&
  1251. event.payload.type === "sync" &&
  1252. event.payload.syncEvent.seq === historyNextSeq,
  1253. ),
  1254. ).toBe(true)
  1255. yield* workspace.remove(info.id)
  1256. } finally {
  1257. captured.dispose()
  1258. }
  1259. }),
  1260. { git: true },
  1261. )
  1262. })
  1263. })
  1264. it.live("SSE forwards non-heartbeat events and ignores heartbeats", () =>
  1265. Effect.gen(function* () {
  1266. yield* HttpServer.serveEffect()(
  1267. Effect.gen(function* () {
  1268. const req = yield* HttpServerRequest.HttpServerRequest
  1269. const url = new URL(req.url, "http://localhost")
  1270. if (url.pathname === "/sse-forward/global/event")
  1271. return HttpServerResponse.fromWeb(
  1272. eventStreamResponse(
  1273. [
  1274. { directory: "remote-dir", project: "remote-project", payload: { type: "server.heartbeat" } },
  1275. {
  1276. directory: "remote-dir",
  1277. project: "remote-project",
  1278. payload: { type: "custom.remote", properties: { ok: true } },
  1279. },
  1280. ],
  1281. false,
  1282. ),
  1283. )
  1284. if (url.pathname === "/sse-forward/sync/history") return HttpServerResponse.fromWeb(Response.json([]))
  1285. return HttpServerResponse.text("unexpected", { status: 500 })
  1286. }),
  1287. )
  1288. const url = yield* serverUrl()
  1289. yield* provideTmpdirInstance(
  1290. () =>
  1291. Effect.gen(function* () {
  1292. const workspace = yield* Workspace.Service
  1293. const sessionSvc = yield* SessionNs.Service
  1294. const captured = captureGlobalEvents()
  1295. try {
  1296. const type = unique("sse-forward")
  1297. const info = workspaceInfo(Instance.project.id, type)
  1298. insertWorkspace(info)
  1299. registerAdapter(Instance.project.id, type, remoteAdapter(`${url}/sse-forward`).adapter)
  1300. attachSessionToWorkspace((yield* sessionSvc.create({})).id, info.id)
  1301. yield* workspace.startWorkspaceSyncing(Instance.project.id)
  1302. yield* eventuallyEffect(
  1303. Effect.sync(() =>
  1304. expect(
  1305. captured.events.some(
  1306. (event) => event.workspace === info.id && event.payload.type === "custom.remote",
  1307. ),
  1308. ).toBe(true),
  1309. ),
  1310. )
  1311. expect(
  1312. captured.events.some(
  1313. (event) => event.workspace === info.id && event.payload.type === "server.heartbeat",
  1314. ),
  1315. ).toBe(false)
  1316. expect(
  1317. captured.events.find((event) => event.workspace === info.id && event.payload.type === "custom.remote"),
  1318. ).toMatchObject({
  1319. directory: "remote-dir",
  1320. project: "remote-project",
  1321. payload: { properties: { ok: true } },
  1322. })
  1323. yield* workspace.remove(info.id)
  1324. } finally {
  1325. captured.dispose()
  1326. }
  1327. }),
  1328. { git: true },
  1329. )
  1330. }),
  1331. )
  1332. it.live("SSE sync events are replayed and forwarded", () => {
  1333. let sseSessionID: SessionID | undefined
  1334. let sseNextSeq = 0
  1335. return Effect.gen(function* () {
  1336. yield* HttpServer.serveEffect()(
  1337. Effect.gen(function* () {
  1338. const req = yield* HttpServerRequest.HttpServerRequest
  1339. const url = new URL(req.url, "http://localhost")
  1340. if (url.pathname === "/sse-sync/global/event")
  1341. return HttpServerResponse.fromWeb(
  1342. eventStreamResponse(
  1343. [
  1344. {
  1345. directory: "remote-dir",
  1346. project: "remote-project",
  1347. payload: {
  1348. type: "sync",
  1349. syncEvent: {
  1350. id: `evt_${unique("sse")}`,
  1351. aggregateID: sseSessionID!,
  1352. seq: sseNextSeq,
  1353. type: sessionUpdatedType(),
  1354. data: { sessionID: sseSessionID!, info: { title: "from sse" } },
  1355. },
  1356. },
  1357. },
  1358. ],
  1359. false,
  1360. ),
  1361. )
  1362. if (url.pathname === "/sse-sync/sync/history") return HttpServerResponse.fromWeb(Response.json([]))
  1363. return HttpServerResponse.text("unexpected", { status: 500 })
  1364. }),
  1365. )
  1366. const url = yield* serverUrl()
  1367. yield* provideTmpdirInstance(
  1368. () =>
  1369. Effect.gen(function* () {
  1370. const workspace = yield* Workspace.Service
  1371. const sessionSvc = yield* SessionNs.Service
  1372. const captured = captureGlobalEvents()
  1373. try {
  1374. const type = unique("sse-sync")
  1375. const info = workspaceInfo(Instance.project.id, type)
  1376. insertWorkspace(info)
  1377. registerAdapter(Instance.project.id, type, remoteAdapter(`${url}/sse-sync`).adapter)
  1378. const session = yield* sessionSvc.create({ title: "before sse" })
  1379. attachSessionToWorkspace(session.id, info.id)
  1380. sseSessionID = session.id
  1381. sseNextSeq = (sessionSequence(session.id) ?? -1) + 1
  1382. yield* workspace.startWorkspaceSyncing(Instance.project.id)
  1383. yield* eventuallyEffect(
  1384. Effect.gen(function* () {
  1385. expect((yield* sessionSvc.get(session.id).pipe(Effect.orDie)).title).toBe("from sse")
  1386. }),
  1387. )
  1388. expect(
  1389. captured.events.some(
  1390. (event) =>
  1391. event.workspace === info.id &&
  1392. event.payload.type === "sync" &&
  1393. event.payload.syncEvent.seq === sseNextSeq,
  1394. ),
  1395. ).toBe(true)
  1396. yield* workspace.remove(info.id)
  1397. } finally {
  1398. captured.dispose()
  1399. }
  1400. }),
  1401. { git: true },
  1402. )
  1403. })
  1404. })
  1405. })
  1406. describe("workspace waitForSync", () => {
  1407. test("returns immediately for an empty fence", async () => {
  1408. await withInstance(async () => {
  1409. await expect(waitForWorkspaceSync(WorkspaceID.ascending("wrk_wait_empty"), {})).resolves.toBeUndefined()
  1410. })
  1411. })
  1412. test("returns immediately when the stored sequence already satisfies the fence", async () => {
  1413. await withInstance(async () => {
  1414. const sessionID = SessionID.descending("ses_wait_done")
  1415. Database.use((db) => db.insert(EventSequenceTable).values({ aggregate_id: sessionID, seq: 4 }).run())
  1416. await expect(
  1417. waitForWorkspaceSync(WorkspaceID.ascending("wrk_wait_done"), { [sessionID]: 4 }),
  1418. ).resolves.toBeUndefined()
  1419. await expect(
  1420. waitForWorkspaceSync(WorkspaceID.ascending("wrk_wait_done_2"), { [sessionID]: 3 }),
  1421. ).resolves.toBeUndefined()
  1422. })
  1423. })
  1424. test("waits until the database reaches the requested sequence and a workspace event arrives", async () => {
  1425. await withInstance(async () => {
  1426. const workspaceID = WorkspaceID.ascending("wrk_wait_event")
  1427. const sessionID = SessionID.descending("ses_wait_event")
  1428. Database.use((db) => db.insert(EventSequenceTable).values({ aggregate_id: sessionID, seq: 1 }).run())
  1429. const waited = waitForWorkspaceSync(workspaceID, { [sessionID]: 2 })
  1430. await delay(10)
  1431. Database.use((db) =>
  1432. db.update(EventSequenceTable).set({ seq: 2 }).where(eq(EventSequenceTable.aggregate_id, sessionID)).run(),
  1433. )
  1434. GlobalBus.emit("event", { workspace: workspaceID, payload: { type: "anything" } })
  1435. await expect(waited).resolves.toBeUndefined()
  1436. })
  1437. })
  1438. test("a sync event for a different workspace can also release the fence", async () => {
  1439. await withInstance(async () => {
  1440. const workspaceID = WorkspaceID.ascending("wrk_wait_sync_any")
  1441. const sessionID = SessionID.descending("ses_wait_sync_any")
  1442. Database.use((db) => db.insert(EventSequenceTable).values({ aggregate_id: sessionID, seq: 0 }).run())
  1443. const waited = waitForWorkspaceSync(workspaceID, { [sessionID]: 1 })
  1444. await delay(10)
  1445. Database.use((db) =>
  1446. db.update(EventSequenceTable).set({ seq: 1 }).where(eq(EventSequenceTable.aggregate_id, sessionID)).run(),
  1447. )
  1448. GlobalBus.emit("event", {
  1449. workspace: WorkspaceID.ascending("wrk_other_workspace"),
  1450. payload: { type: "sync" },
  1451. })
  1452. await expect(waited).resolves.toBeUndefined()
  1453. })
  1454. })
  1455. test("rejects with the abort reason when aborted", async () => {
  1456. await withInstance(async () => {
  1457. const abort = new AbortController()
  1458. const reason = new Error("caller aborted")
  1459. const waited = waitForWorkspaceSync(
  1460. WorkspaceID.ascending("wrk_wait_abort"),
  1461. { [SessionID.descending("ses_wait_abort")]: 1 },
  1462. abort.signal,
  1463. )
  1464. abort.abort(reason)
  1465. await expect(waited).rejects.toMatchObject({
  1466. _tag: "WorkspaceSyncAbortedError",
  1467. message: reason.message,
  1468. cause: reason,
  1469. })
  1470. })
  1471. })
  1472. test("times out with the requested fence in the error message", async () => {
  1473. await withInstance(async () => {
  1474. const sessionID = SessionID.descending("ses_wait_timeout")
  1475. await expect(waitForWorkspaceSync(WorkspaceID.ascending("wrk_wait_timeout"), { [sessionID]: 1 })).rejects.toThrow(
  1476. `Timed out waiting for sync fence: {"${sessionID}":1}`,
  1477. )
  1478. })
  1479. }, 7000)
  1480. })