Move service state into InstanceState, flatten service facades (#18483)

packages/opencode/test/file/index.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test"
+import { afterEach, describe, test, expect } from "bun:test"
 import { $ } from "bun"
 import path from "path"
 import fs from "fs/promises"
@@ -7,6 +7,10 @@ import { Instance } from "../../src/project/instance"
 import { Filesystem } from "../../src/util/filesystem"
 import { tmpdir } from "../fixture/fixture"
 
+afterEach(async () => {
+  await Instance.disposeAll()
+})
+
 describe("file/index Filesystem patterns", () => {
   describe("File.read() - text content", () => {
     test("reads text file via Filesystem.readText()", async () => {
@@ -689,6 +693,18 @@ describe("file/index Filesystem patterns", () => {
       })
     })
 
+    test("search works before explicit init", async () => {
+      await using tmp = await setupSearchableRepo()
+
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          const result = await File.search({ query: "main", type: "file" })
+          expect(result.some((f) => f.includes("main"))).toBe(true)
+        },
+      })
+    })
+
     test("empty query returns dirs sorted with hidden last", async () => {
       await using tmp = await setupSearchableRepo()
 
@@ -785,6 +801,23 @@ describe("file/index Filesystem patterns", () => {
         },
       })
     })
+
+    test("search refreshes after init when files change", async () => {
+      await using tmp = await setupSearchableRepo()
+
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await File.init()
+          expect(await File.search({ query: "fresh", type: "file" })).toEqual([])
+
+          await fs.writeFile(path.join(tmp.path, "fresh.ts"), "fresh", "utf-8")
+
+          const result = await File.search({ query: "fresh", type: "file" })
+          expect(result).toContain("fresh.ts")
+        },
+      })
+    })
   })
 
   describe("File.read() - diff/patch", () => {
@@ -849,4 +882,65 @@ describe("file/index Filesystem patterns", () => {
       })
     })
   })
+
+  describe("InstanceState isolation", () => {
+    test("two directories get independent file caches", async () => {
+      await using one = await tmpdir({ git: true })
+      await using two = await tmpdir({ git: true })
+      await fs.writeFile(path.join(one.path, "a.ts"), "one", "utf-8")
+      await fs.writeFile(path.join(two.path, "b.ts"), "two", "utf-8")
+
+      await Instance.provide({
+        directory: one.path,
+        fn: async () => {
+          await File.init()
+          const results = await File.search({ query: "a.ts", type: "file" })
+          expect(results).toContain("a.ts")
+          const results2 = await File.search({ query: "b.ts", type: "file" })
+          expect(results2).not.toContain("b.ts")
+        },
+      })
+
+      await Instance.provide({
+        directory: two.path,
+        fn: async () => {
+          await File.init()
+          const results = await File.search({ query: "b.ts", type: "file" })
+          expect(results).toContain("b.ts")
+          const results2 = await File.search({ query: "a.ts", type: "file" })
+          expect(results2).not.toContain("a.ts")
+        },
+      })
+    })
+
+    test("disposal gives fresh state on next access", async () => {
+      await using tmp = await tmpdir({ git: true })
+      await fs.writeFile(path.join(tmp.path, "before.ts"), "before", "utf-8")
+
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await File.init()
+          const results = await File.search({ query: "before", type: "file" })
+          expect(results).toContain("before.ts")
+        },
+      })
+
+      await Instance.disposeAll()
+
+      await fs.writeFile(path.join(tmp.path, "after.ts"), "after", "utf-8")
+      await fs.rm(path.join(tmp.path, "before.ts"))
+
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await File.init()
+          const results = await File.search({ query: "after", type: "file" })
+          expect(results).toContain("after.ts")
+          const stale = await File.search({ query: "before", type: "file" })
+          expect(stale).not.toContain("before.ts")
+        },
+      })
+    })
+  })
 })

packages/opencode/test/file/time.test.ts

@@ -7,7 +7,9 @@ import { SessionID } from "../../src/session/schema"
 import { Filesystem } from "../../src/util/filesystem"
 import { tmpdir } from "../fixture/fixture"
 
-afterEach(() => Instance.disposeAll())
+afterEach(async () => {
+  await Instance.disposeAll()
+})
 
 async function touch(file: string, time: number) {
   const date = new Date(time)
@@ -84,6 +86,28 @@ describe("file/time", () => {
         },
       })
     })
+
+    test("isolates reads by directory", async () => {
+      await using one = await tmpdir()
+      await using two = await tmpdir()
+      await using shared = await tmpdir()
+      const filepath = path.join(shared.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
+
+      await Instance.provide({
+        directory: one.path,
+        fn: async () => {
+          await FileTime.read(sessionID, filepath)
+        },
+      })
+
+      await Instance.provide({
+        directory: two.path,
+        fn: async () => {
+          expect(await FileTime.get(sessionID, filepath)).toBeUndefined()
+        },
+      })
+    })
   })
 
   describe("assert()", () => {

packages/opencode/test/file/watcher.test.ts

@@ -25,7 +25,7 @@ function withWatcher<E>(directory: string, body: Effect.Effect<void, E>) {
     directory,
     FileWatcher.layer,
     async (rt) => {
-      await rt.runPromise(FileWatcher.Service.use(() => Effect.void))
+      await rt.runPromise(FileWatcher.Service.use((s) => s.init()))
       await Effect.runPromise(ready(directory))
       await Effect.runPromise(body)
     },
@@ -136,7 +136,9 @@ function ready(directory: string) {
 // ---------------------------------------------------------------------------
 
 describeWatcher("FileWatcher", () => {
-  afterEach(() => Instance.disposeAll())
+  afterEach(async () => {
+    await Instance.disposeAll()
+  })
 
   test("publishes root create, update, and delete events", async () => {
     await using tmp = await tmpdir({ git: true })