openAgent

1import { expect } from "bun:test"
2import path from "path"
3import { pathToFileURL } from "url"
4import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
5import { LayerNode } from "@opencode-ai/core/effect/layer-node"
6import { Effect, Layer } from "effect"
7import { FSUtil } from "@opencode-ai/core/fs-util"
8import { Global } from "@opencode-ai/core/global"
9import { Config } from "@/config/config"
10import { ConfigPlugin } from "@/config/plugin"
11import { CurrentWorkingDirectory } from "@/config/tui-cwd"
12import { TuiConfig } from "../../src/config/tui"
13import { TestInstance } from "../fixture/fixture"
14import { testEffect } from "../lib/effect"
15 
16const it = testEffect(LayerNode.compile(LayerNode.group([Config.node, FSUtil.node])))
17const winIt = process.platform === "win32" ? it.instance : it.instance.skip
18 
19const globalConfigFiles = ["opencode.json", "opencode.jsonc", "tui.json", "tui.jsonc"].map((file) =>
20  path.join(Global.Path.config, file),
21)
22 
23const cleanState = Effect.gen(function* () {
24  const fs = yield* FSUtil.Service
25  delete process.env.OPENCODE_CONFIG
26  delete process.env.OPENCODE_TUI_CONFIG
27  yield* Effect.forEach(globalConfigFiles, (file) => fs.remove(file, { force: true }).pipe(Effect.ignore), {
28    discard: true,
29  })
30})
31 
32const withCleanState = <A, E, R>(self: Effect.Effect<A, E, R>) =>
33  Effect.acquireUseRelease(
34    cleanState,
35    () => self,
36    () => cleanState,
37  )
38 
39const withEnv = <A, E, R>(name: string, value: string | undefined, self: Effect.Effect<A, E, R>) =>
40  Effect.acquireUseRelease(
41    Effect.sync(() => {
42      const previous = process.env[name]
43      if (value === undefined) delete process.env[name]
44      else process.env[name] = value
45      return previous
46    }),
47    () => self,
48    (previous) =>
49      Effect.sync(() => {
50        if (previous === undefined) delete process.env[name]
51        else process.env[name] = previous
52      }),
53  )
54 
55const withPlatform = <A, E, R>(platform: typeof process.platform, self: Effect.Effect<A, E, R>) =>
56  Effect.acquireUseRelease(
57    Effect.sync(() => {
58      const original = Object.getOwnPropertyDescriptor(process, "platform")
59      Object.defineProperty(process, "platform", {
60        ...original,
61        value: platform,
62      })
63      return original
64    }),
65    () => self,
66    (original) =>
67      Effect.sync(() => {
68        if (original) Object.defineProperty(process, "platform", original)
69      }),
70  )
71 
72const getTuiConfig = (directory: string) =>
73  TuiConfig.Service.use((svc) => svc.get()).pipe(
74    Effect.provide(
75      AppNodeBuilder.build(TuiConfig.node).pipe(Layer.provide(Layer.succeed(CurrentWorkingDirectory, directory))),
76    ),
77  )
78 
79const getTuiPluginOrigins = (directory: string) =>
80  TuiConfig.Service.use((svc) => svc.pluginOrigins()).pipe(
81    Effect.provide(
82      AppNodeBuilder.build(TuiConfig.node).pipe(Layer.provide(Layer.succeed(CurrentWorkingDirectory, directory))),
83    ),
84  )
85 
86it.instance("keeps server and tui plugin merge semantics aligned", () =>
87  withCleanState(
88    Effect.gen(function* () {
89      const fs = yield* FSUtil.Service
90      const test = yield* TestInstance
91      const local = path.join(test.directory, ".opencode")
92      yield* fs.makeDirectory(local, { recursive: true })
93 
94      yield* fs.writeJson(path.join(Global.Path.config, "opencode.json"), {
95        plugin: [["shared-plugin@1.0.0", { source: "global" }], "global-only@1.0.0"],
96      })
97      yield* fs.writeJson(path.join(Global.Path.config, "tui.json"), {
98        plugin: [["shared-plugin@1.0.0", { source: "global" }], "global-only@1.0.0"],
99      })
100      yield* fs.writeJson(path.join(local, "opencode.json"), {
101        plugin: [["shared-plugin@2.0.0", { source: "local" }], "local-only@1.0.0"],
102      })
103      yield* fs.writeJson(path.join(local, "tui.json"), {
104        plugin: [["shared-plugin@2.0.0", { source: "local" }], "local-only@1.0.0"],
105      })
106 
107      const server = yield* Config.use.get()
108      const tui = yield* getTuiConfig(test.directory)
109      const tuiOrigins = yield* getTuiPluginOrigins(test.directory)
110      const serverPlugins = (server.plugin ?? []).map((item) => ConfigPlugin.pluginSpecifier(item))
111      const tuiPlugins = (tui.plugin ?? []).map((item) => ConfigPlugin.pluginSpecifier(item))
112 
113      expect(serverPlugins).toEqual(tuiPlugins)
114      expect(serverPlugins).toContain("shared-plugin@2.0.0")
115      expect(serverPlugins).not.toContain("shared-plugin@1.0.0")
116 
117      const serverOrigins = server.plugin_origins ?? []
118      expect(serverOrigins.map((item) => ConfigPlugin.pluginSpecifier(item.spec))).toEqual(serverPlugins)
119      expect(tuiOrigins.map((item) => ConfigPlugin.pluginSpecifier(item.spec))).toEqual(tuiPlugins)
120      expect(serverOrigins.map((item) => item.scope)).toEqual(tuiOrigins.map((item) => item.scope))
121    }),
122  ),
123)
124 
125it.instance("loads tui config with the same precedence order as server config paths", () =>
126  withCleanState(
127    Effect.gen(function* () {
128      const fs = yield* FSUtil.Service
129      const test = yield* TestInstance
130      yield* fs.writeJson(path.join(Global.Path.config, "tui.json"), { theme: "global" })
131      yield* fs.writeJson(path.join(test.directory, "tui.json"), { theme: "project" })
132      yield* fs.writeWithDirs(
133        path.join(test.directory, ".opencode", "tui.json"),
134        JSON.stringify({ theme: "local", diff_style: "stacked" }, null, 2),
135      )
136 
137      const config = yield* getTuiConfig(test.directory)
138      expect(config.theme).toBe("local")
139      expect(config.diff_style).toBe("stacked")
140    }),
141  ),
142)
143 
144it.instance("resolves attention config defaults and overrides", () =>
145  withCleanState(
146    Effect.gen(function* () {
147      const fs = yield* FSUtil.Service
148      const test = yield* TestInstance
149 
150      expect((yield* getTuiConfig(test.directory)).attention).toEqual({
151        enabled: false,
152        notifications: true,
153        sound: true,
154        volume: 0.4,
155        sound_pack: "opencode.default",
156        sounds: {},
157      })
158 
159      yield* fs.writeJson(path.join(test.directory, "tui.json"), {
160        attention: {
161          enabled: false,
162          notifications: false,
163          sound: false,
164          volume: 0.7,
165          sound_pack: "acme.soft",
166          sounds: {
167            default: path.join(test.directory, "default.mp3"),
168            question: pathToFileURL(path.join(test.directory, "question.mp3")).href,
169            error: "./error.mp3",
170            subagent_done: "./subagent-done.mp3",
171          },
172        },
173      })
174 
175      expect((yield* getTuiConfig(test.directory)).attention).toEqual({
176        enabled: false,
177        notifications: false,
178        sound: false,
179        volume: 0.7,
180        sound_pack: "acme.soft",
181        sounds: {
182          default: path.join(test.directory, "default.mp3"),
183          question: path.join(test.directory, "question.mp3"),
184          error: path.join(test.directory, "error.mp3"),
185          subagent_done: path.join(test.directory, "subagent-done.mp3"),
186        },
187      })
188    }),
189  ),
190)
191 
192it.instance("migrates tui-specific keys from opencode.json when tui.json does not exist", () =>
193  withCleanState(
194    Effect.gen(function* () {
195      const fs = yield* FSUtil.Service
196      const test = yield* TestInstance
197      const source = path.join(test.directory, "opencode.json")
198      yield* fs.writeJson(source, {
199        theme: "migrated-theme",
200        tui: { scroll_speed: 5 },
201        keybinds: { app_exit: "ctrl+q" },
202      })
203 
204      const config = yield* getTuiConfig(test.directory)
205      expect(config.theme).toBe("migrated-theme")
206      expect(config.scroll_speed).toBe(5)
207      expect(config.keybinds.get("app.exit")?.[0]?.key).toBe("ctrl+q")
208      expect(JSON.parse(yield* fs.readFileString(path.join(test.directory, "tui.json")))).toMatchObject({
209        theme: "migrated-theme",
210        scroll_speed: 5,
211      })
212      const server = JSON.parse(yield* fs.readFileString(source))
213      expect(server.theme).toBeUndefined()
214      expect(server.keybinds).toBeUndefined()
215      expect(server.tui).toBeUndefined()
216      expect(yield* fs.existsSafe(path.join(test.directory, "opencode.json.tui-migration.bak"))).toBe(true)
217      expect(yield* fs.existsSafe(path.join(test.directory, "tui.json"))).toBe(true)
218    }),
219  ),
220)
221 
222it.instance("migrates project legacy tui keys even when global tui.json already exists", () =>
223  withCleanState(
224    Effect.gen(function* () {
225      const fs = yield* FSUtil.Service
226      const test = yield* TestInstance
227      yield* fs.writeJson(path.join(Global.Path.config, "tui.json"), { theme: "global" })
228      yield* fs.writeJson(path.join(test.directory, "opencode.json"), {
229        theme: "project-migrated",
230        tui: { scroll_speed: 2 },
231      })
232 
233      const config = yield* getTuiConfig(test.directory)
234      expect(config.theme).toBe("project-migrated")
235      expect(config.scroll_speed).toBe(2)
236      expect(yield* fs.existsSafe(path.join(test.directory, "tui.json"))).toBe(true)
237 
238      const server = JSON.parse(yield* fs.readFileString(path.join(test.directory, "opencode.json")))
239      expect(server.theme).toBeUndefined()
240      expect(server.tui).toBeUndefined()
241    }),
242  ),
243)
244 
245it.instance("drops unknown legacy tui keys during migration", () =>
246  withCleanState(
247    Effect.gen(function* () {
248      const fs = yield* FSUtil.Service
249      const test = yield* TestInstance
250      yield* fs.writeJson(path.join(test.directory, "opencode.json"), {
251        theme: "migrated-theme",
252        tui: { scroll_speed: 2, foo: 1 },
253      })
254 
255      const config = yield* getTuiConfig(test.directory)
256      expect(config.theme).toBe("migrated-theme")
257      expect(config.scroll_speed).toBe(2)
258 
259      const migrated = JSON.parse(yield* fs.readFileString(path.join(test.directory, "tui.json")))
260      expect(migrated.scroll_speed).toBe(2)
261      expect(migrated.foo).toBeUndefined()
262    }),
263  ),
264)
265 
266it.instance("skips migration when opencode.jsonc is syntactically invalid", () =>
267  withCleanState(
268    Effect.gen(function* () {
269      const fs = yield* FSUtil.Service
270      const test = yield* TestInstance
271      yield* fs.writeFileString(
272        path.join(test.directory, "opencode.jsonc"),
273        `{
274  "theme": "broken-theme",
275  "tui": { "scroll_speed": 2 }
276  "username": "still-broken"
277}`,
278      )
279 
280      const config = yield* getTuiConfig(test.directory)
281      expect(config.theme).toBeUndefined()
282      expect(config.scroll_speed).toBeUndefined()
283      expect(yield* fs.existsSafe(path.join(test.directory, "tui.json"))).toBe(false)
284      expect(yield* fs.existsSafe(path.join(test.directory, "opencode.jsonc.tui-migration.bak"))).toBe(false)
285      const source = yield* fs.readFileString(path.join(test.directory, "opencode.jsonc"))
286      expect(source).toContain('"theme": "broken-theme"')
287      expect(source).toContain('"tui": { "scroll_speed": 2 }')
288    }),
289  ),
290)
291 
292it.instance("skips migration when tui.json already exists", () =>
293  withCleanState(
294    Effect.gen(function* () {
295      const fs = yield* FSUtil.Service
296      const test = yield* TestInstance
297      yield* fs.writeJson(path.join(test.directory, "opencode.json"), { theme: "legacy" })
298      yield* fs.writeJson(path.join(test.directory, "tui.json"), { diff_style: "stacked" })
299 
300      const config = yield* getTuiConfig(test.directory)
301      expect(config.diff_style).toBe("stacked")
302      expect(config.theme).toBeUndefined()
303 
304      const server = JSON.parse(yield* fs.readFileString(path.join(test.directory, "opencode.json")))
305      expect(server.theme).toBe("legacy")
306      expect(yield* fs.existsSafe(path.join(test.directory, "opencode.json.tui-migration.bak"))).toBe(false)
307    }),
308  ),
309)
310 
311it.instance("continues loading tui config when legacy source cannot be stripped", () =>
312  withCleanState(
313    Effect.gen(function* () {
314      const fs = yield* FSUtil.Service
315      const test = yield* TestInstance
316      const source = path.join(test.directory, "opencode.json")
317      yield* fs.writeJson(source, { theme: "readonly-theme" })
318 
319      yield* Effect.acquireUseRelease(
320        fs.chmod(source, 0o444),
321        () =>
322          Effect.gen(function* () {
323            const config = yield* getTuiConfig(test.directory)
324            expect(config.theme).toBe("readonly-theme")
325            expect(yield* fs.existsSafe(path.join(test.directory, "tui.json"))).toBe(true)
326 
327            const server = JSON.parse(yield* fs.readFileString(source))
328            expect(server.theme).toBe("readonly-theme")
329          }),
330        () => fs.chmod(source, 0o644).pipe(Effect.ignore),
331      )
332    }),
333  ),
334)
335 
336it.instance("migration backup preserves JSONC comments", () =>
337  withCleanState(
338    Effect.gen(function* () {
339      const fs = yield* FSUtil.Service
340      const test = yield* TestInstance
341      yield* fs.writeFileString(
342        path.join(test.directory, "opencode.jsonc"),
343        `{
344  // top-level comment
345  "theme": "jsonc-theme",
346  "tui": {
347    // nested comment
348    "scroll_speed": 1.5
349  }
350}`,
351      )
352 
353      yield* getTuiConfig(test.directory)
354      const backup = yield* fs.readFileString(path.join(test.directory, "opencode.jsonc.tui-migration.bak"))
355      expect(backup).toContain("// top-level comment")
356      expect(backup).toContain("// nested comment")
357      expect(backup).toContain('"theme": "jsonc-theme"')
358      expect(backup).toContain('"scroll_speed": 1.5')
359    }),
360  ),
361)
362 
363it.instance("migrates legacy tui keys across multiple opencode.json levels", () =>
364  withCleanState(
365    Effect.gen(function* () {
366      const fs = yield* FSUtil.Service
367      const test = yield* TestInstance
368      const nested = path.join(test.directory, "apps", "client")
369      yield* fs.makeDirectory(nested, { recursive: true })
370      yield* fs.writeJson(path.join(test.directory, "opencode.json"), { theme: "root-theme" })
371      yield* fs.writeJson(path.join(nested, "opencode.json"), { theme: "nested-theme" })
372 
373      const config = yield* getTuiConfig(nested)
374      expect(config.theme).toBe("nested-theme")
375      expect(yield* fs.existsSafe(path.join(test.directory, "tui.json"))).toBe(true)
376      expect(yield* fs.existsSafe(path.join(nested, "tui.json"))).toBe(true)
377    }),
378  ),
379)
380 
381it.instance("flattens nested tui key inside tui.json", () =>
382  withCleanState(
383    Effect.gen(function* () {
384      const fs = yield* FSUtil.Service
385      const test = yield* TestInstance
386      yield* fs.writeJson(path.join(test.directory, "tui.json"), {
387        theme: "outer",
388        tui: { scroll_speed: 3, diff_style: "stacked" },
389      })
390 
391      const config = yield* getTuiConfig(test.directory)
392      expect(config.scroll_speed).toBe(3)
393      expect(config.diff_style).toBe("stacked")
394      expect(config.theme).toBe("outer")
395    }),
396  ),
397)
398 
399it.instance("top-level keys in tui.json take precedence over nested tui key", () =>
400  withCleanState(
401    Effect.gen(function* () {
402      const fs = yield* FSUtil.Service
403      const test = yield* TestInstance
404      yield* fs.writeJson(path.join(test.directory, "tui.json"), {
405        diff_style: "auto",
406        tui: { diff_style: "stacked", scroll_speed: 2 },
407      })
408 
409      const config = yield* getTuiConfig(test.directory)
410      expect(config.diff_style).toBe("auto")
411      expect(config.scroll_speed).toBe(2)
412    }),
413  ),
414)
415 
416it.instance("project config takes precedence over OPENCODE_TUI_CONFIG (matches OPENCODE_CONFIG)", () =>
417  withCleanState(
418    Effect.gen(function* () {
419      const fs = yield* FSUtil.Service
420      const test = yield* TestInstance
421      const custom = path.join(test.directory, "custom-tui.json")
422      yield* fs.writeJson(path.join(test.directory, "tui.json"), { theme: "project", diff_style: "auto" })
423      yield* fs.writeJson(custom, { theme: "custom", diff_style: "stacked" })
424 
425      yield* withEnv(
426        "OPENCODE_TUI_CONFIG",
427        custom,
428        Effect.gen(function* () {
429          const config = yield* getTuiConfig(test.directory)
430          expect(config.theme).toBe("project")
431          expect(config.diff_style).toBe("auto")
432        }),
433      )
434    }),
435  ),
436)
437 
438it.instance("merges keybind overrides across precedence layers", () =>
439  withCleanState(
440    Effect.gen(function* () {
441      const fs = yield* FSUtil.Service
442      const test = yield* TestInstance
443      yield* fs.writeJson(path.join(Global.Path.config, "tui.json"), { keybinds: { app_exit: "ctrl+q" } })
444      yield* fs.writeJson(path.join(test.directory, "tui.json"), { keybinds: { theme_list: "ctrl+k" } })
445 
446      const config = yield* getTuiConfig(test.directory)
447      expect(config.keybinds.get("app.exit")?.[0]?.key).toBe("ctrl+q")
448      expect(config.keybinds.get("theme.switch")?.[0]?.key).toBe("ctrl+k")
449    }),
450  ),
451)
452 
453it.instance("ignores unknown keybind names without dropping valid overrides from the same file", () =>
454  withCleanState(
455    Effect.gen(function* () {
456      const fs = yield* FSUtil.Service
457      const test = yield* TestInstance
458      yield* fs.writeJson(path.join(Global.Path.config, "tui.json"), {
459        keybinds: {
460          session_delete: "ctrl+d",
461          not_a_real_keybind: "ctrl+q",
462        },
463      })
464 
465      const config = yield* getTuiConfig(test.directory)
466      expect(config.keybinds.get("session.delete")?.[0]?.key).toBe("ctrl+d")
467      expect(config.keybinds.get("not_a_real_keybind")).toEqual([])
468    }),
469  ),
470)
471 
472it.instance("resolves keybind lookup from canonical keybinds", () =>
473  withCleanState(
474    Effect.gen(function* () {
475      const fs = yield* FSUtil.Service
476      const test = yield* TestInstance
477      yield* fs.writeJson(path.join(test.directory, "tui.json"), {
478        keybinds: {
479          leader: { key: { name: "g", ctrl: true } },
480          command_list: "alt+p",
481          diff_open: "ctrl+j",
482          which_key_toggle: "alt+k",
483          editor_open: "ctrl+e",
484          "prompt.autocomplete.next": "ctrl+j",
485          "dialog.prompt.submit": "ctrl+s",
486          "dialog.mcp.toggle": "ctrl+t",
487          model_favorite_toggle: "ctrl+f",
488          "dialog.plugins.install": "shift+i",
489        },
490        leader_timeout: 1234,
491      })
492 
493      const config = yield* getTuiConfig(test.directory)
494      expect(config.keybinds.get("leader")?.[0]?.key).toEqual({ name: "g", ctrl: true })
495      expect(config.leader_timeout).toBe(1234)
496      expect(config.keybinds.get("command.palette.show")?.[0]?.key).toBe("alt+p")
497      expect(config.keybinds.get("diff.open")?.[0]?.key).toBe("ctrl+j")
498      expect(config.keybinds.get("session.new")?.[0]?.key).toBe("<leader>n")
499      expect(config.keybinds.get("which-key.toggle")?.[0]?.key).toBe("alt+k")
500      expect(config.keybinds.get("which-key.layout.toggle")?.[0]?.key).toBe("ctrl+alt+shift+k")
501      expect(config.keybinds.get("which-key.pending.toggle")?.[0]?.key).toBe("ctrl+alt+shift+p")
502      expect(config.keybinds.get("which-key.group.next")?.[0]?.key).toBe("ctrl+alt+right,ctrl+alt+]")
503      expect((config.keybinds.get("which-key.toggle")?.[0] as { desc?: unknown } | undefined)?.desc).toBe(
504        "Toggle which-key panel",
505      )
506      expect(config.keybinds.get("prompt.editor")?.[0]?.key).toBe("ctrl+e")
507      expect(config.keybinds.get("prompt.autocomplete.next")?.[0]?.key).toBe("ctrl+j")
508      expect(config.keybinds.get("dialog.prompt.submit")?.[0]?.key).toBe("ctrl+s")
509      expect(config.keybinds.get("dialog.mcp.toggle")?.[0]?.key).toBe("ctrl+t")
510      expect(config.keybinds.get("model.dialog.favorite")?.[0]?.key).toBe("ctrl+f")
511      expect(config.keybinds.get("dialog.plugins.install")?.[0]?.key).toBe("shift+i")
512      expect(
513        config.keybinds.gather("plugins.dialog", ["dialog.plugins.install"]).map((binding) => binding.cmd),
514      ).toEqual(["dialog.plugins.install"])
515    }),
516  ),
517)
518 
519it.instance("keybinds accept OpenTUI binding specs", () =>
520  withCleanState(
521    Effect.gen(function* () {
522      const fs = yield* FSUtil.Service
523      const test = yield* TestInstance
524      yield* fs.writeJson(path.join(test.directory, "tui.json"), {
525        keybinds: {
526          command_list: [{ key: "alt+p", preventDefault: false }],
527          editor_open: { key: { name: "e", ctrl: true }, group: "Explicit" },
528          "prompt.autocomplete.next": false,
529          plugin_manager: "ctrl+shift+p",
530        },
531      })
532 
533      const config = yield* getTuiConfig(test.directory)
534      expect(config.keybinds.get("command.palette.show")).toEqual([
535        { key: "alt+p", cmd: "command.palette.show", preventDefault: false, desc: "List available commands" },
536      ])
537      expect(config.keybinds.get("prompt.editor")?.[0]).toMatchObject({
538        key: { name: "e", ctrl: true },
539        cmd: "prompt.editor",
540        group: "Explicit",
541      })
542      expect(config.keybinds.get("prompt.autocomplete.next")).toEqual([])
543      expect(config.keybinds.get("plugins.list")?.[0]?.key).toBe("ctrl+shift+p")
544    }),
545  ),
546)
547 
548winIt("defaults Ctrl+Z to input undo on Windows", () =>
549  withCleanState(
550    Effect.gen(function* () {
551      const test = yield* TestInstance
552      const config = yield* getTuiConfig(test.directory)
553      expect(config.keybinds.get("terminal.suspend")).toEqual([])
554      expect(config.keybinds.get("input.undo")?.[0]?.key).toBe("ctrl+z,ctrl+-,super+z")
555    }),
556  ),
557)
558 
559winIt("keeps explicit input undo overrides on Windows", () =>
560  withCleanState(
561    Effect.gen(function* () {
562      const fs = yield* FSUtil.Service
563      const test = yield* TestInstance
564      yield* fs.writeJson(path.join(test.directory, "tui.json"), { keybinds: { input_undo: "ctrl+y" } })
565 
566      const config = yield* getTuiConfig(test.directory)
567      expect(config.keybinds.get("terminal.suspend")).toEqual([])
568      expect(config.keybinds.get("input.undo")?.[0]?.key).toBe("ctrl+y")
569    }),
570  ),
571)
572 
573winIt("ignores terminal suspend bindings on Windows", () =>
574  withCleanState(
575    Effect.gen(function* () {
576      const fs = yield* FSUtil.Service
577      const test = yield* TestInstance
578      yield* fs.writeJson(path.join(test.directory, "tui.json"), { keybinds: { terminal_suspend: "alt+z" } })
579 
580      const config = yield* getTuiConfig(test.directory)
581      expect(config.keybinds.get("terminal.suspend")).toEqual([])
582      expect(config.keybinds.get("input.undo")?.[0]?.key).toBe("ctrl+z,ctrl+-,super+z")
583    }),
584  ),
585)
586 
587it.instance("applies Windows keybind defaults", () =>
588  withCleanState(
589    withPlatform(
590      "win32",
591      Effect.gen(function* () {
592        const test = yield* TestInstance
593        const config = yield* getTuiConfig(test.directory)
594        expect(config.keybinds.get("terminal.suspend")).toEqual([])
595        expect(config.keybinds.get("input.undo")?.[0]?.key).toBe("ctrl+z,ctrl+-,super+z")
596      }),
597    ),
598  ),
599)
600 
601it.instance("ignores explicit keybind terminal suspend binding on Windows", () =>
602  withCleanState(
603    withPlatform(
604      "win32",
605      Effect.gen(function* () {
606        const fs = yield* FSUtil.Service
607        const test = yield* TestInstance
608        yield* fs.writeJson(path.join(test.directory, "tui.json"), {
609          keybinds: {
610            terminal_suspend: "alt+z",
611          },
612        })
613 
614        const config = yield* getTuiConfig(test.directory)
615        expect(config.keybinds.get("terminal.suspend")).toEqual([])
616      }),
617    ),
618  ),
619)
620 
621it.instance("keeps explicit configured keybind input undo on Windows", () =>
622  withCleanState(
623    withPlatform(
624      "win32",
625      Effect.gen(function* () {
626        const fs = yield* FSUtil.Service
627        const test = yield* TestInstance
628        yield* fs.writeJson(path.join(test.directory, "tui.json"), {
629          keybinds: {
630            input_undo: "ctrl+y",
631          },
632        })
633 
634        const config = yield* getTuiConfig(test.directory)
635        expect(config.keybinds.get("input.undo")?.[0]?.key).toBe("ctrl+y")
636      }),
637    ),
638  ),
639)
640 
641it.instance("OPENCODE_TUI_CONFIG provides settings when no project config exists", () =>
642  withCleanState(
643    Effect.gen(function* () {
644      const fs = yield* FSUtil.Service
645      const test = yield* TestInstance
646      const custom = path.join(test.directory, "custom-tui.json")
647      yield* fs.writeJson(custom, { theme: "from-env", diff_style: "stacked" })
648 
649      yield* withEnv(
650        "OPENCODE_TUI_CONFIG",
651        custom,
652        Effect.gen(function* () {
653          const config = yield* getTuiConfig(test.directory)
654          expect(config.theme).toBe("from-env")
655          expect(config.diff_style).toBe("stacked")
656        }),
657      )
658    }),
659  ),
660)
661 
662it.instance("does not derive tui path from OPENCODE_CONFIG", () =>
663  withCleanState(
664    Effect.gen(function* () {
665      const fs = yield* FSUtil.Service
666      const test = yield* TestInstance
667      const customDir = path.join(test.directory, "custom")
668      yield* fs.makeDirectory(customDir, { recursive: true })
669      yield* fs.writeJson(path.join(customDir, "opencode.json"), { model: "test/model" })
670      yield* fs.writeJson(path.join(customDir, "tui.json"), { theme: "should-not-load" })
671 
672      yield* withEnv(
673        "OPENCODE_CONFIG",
674        path.join(customDir, "opencode.json"),
675        Effect.gen(function* () {
676          const config = yield* getTuiConfig(test.directory)
677          expect(config.theme).toBeUndefined()
678        }),
679      )
680    }),
681  ),
682)
683 
684it.instance("applies env and file substitutions in tui.json", () =>
685  withCleanState(
686    withEnv(
687      "TUI_THEME_TEST",
688      "env-theme",
689      Effect.gen(function* () {
690        const fs = yield* FSUtil.Service
691        const test = yield* TestInstance
692        yield* fs.writeFileString(path.join(test.directory, "keybind.txt"), "ctrl+q")
693        yield* fs.writeJson(path.join(test.directory, "tui.json"), {
694          theme: "{env:TUI_THEME_TEST}",
695          keybinds: { app_exit: "{file:keybind.txt}" },
696        })
697 
698        const config = yield* getTuiConfig(test.directory)
699        expect(config.theme).toBe("env-theme")
700        expect(config.keybinds.get("app.exit")?.[0]?.key).toBe("ctrl+q")
701      }),
702    ),
703  ),
704)
705 
706it.instance("applies file substitutions when first identical token is in a commented line", () =>
707  withCleanState(
708    Effect.gen(function* () {
709      const fs = yield* FSUtil.Service
710      const test = yield* TestInstance
711      yield* fs.writeFileString(path.join(test.directory, "theme.txt"), "resolved-theme")
712      yield* fs.writeFileString(
713        path.join(test.directory, "tui.jsonc"),
714        `{
715  // "theme": "{file:theme.txt}",
716  "theme": "{file:theme.txt}"
717}`,
718      )
719 
720      const config = yield* getTuiConfig(test.directory)
721      expect(config.theme).toBe("resolved-theme")
722    }),
723  ),
724)
725 
726it.instance("loads .opencode/tui.json", () =>
727  withCleanState(
728    Effect.gen(function* () {
729      const fs = yield* FSUtil.Service
730      const test = yield* TestInstance
731      yield* fs.writeWithDirs(
732        path.join(test.directory, ".opencode", "tui.json"),
733        JSON.stringify({ diff_style: "stacked" }, null, 2),
734      )
735 
736      const config = yield* getTuiConfig(test.directory)
737      expect(config.diff_style).toBe("stacked")
738    }),
739  ),
740)
741 
742it.instance("supports tuple plugin specs with options in tui.json", () =>
743  withCleanState(
744    Effect.gen(function* () {
745      const fs = yield* FSUtil.Service
746      const test = yield* TestInstance
747      yield* fs.writeJson(path.join(test.directory, "tui.json"), {
748        plugin: [["acme-plugin@1.2.3", { enabled: true, label: "demo" }]],
749      })
750 
751      const config = yield* getTuiConfig(test.directory)
752      const origins = yield* getTuiPluginOrigins(test.directory)
753      expect(config.plugin).toEqual([["acme-plugin@1.2.3", { enabled: true, label: "demo" }]])
754      expect(origins).toEqual([
755        {
756          spec: ["acme-plugin@1.2.3", { enabled: true, label: "demo" }],
757          scope: "local",
758          source: path.join(test.directory, "tui.json"),
759        },
760      ])
761    }),
762  ),
763)
764 
765it.instance("deduplicates tuple plugin specs by name with higher precedence winning", () =>
766  withCleanState(
767    Effect.gen(function* () {
768      const fs = yield* FSUtil.Service
769      const test = yield* TestInstance
770      yield* fs.writeJson(path.join(Global.Path.config, "tui.json"), {
771        plugin: [["acme-plugin@1.0.0", { source: "global" }]],
772      })
773      yield* fs.writeJson(path.join(test.directory, "tui.json"), {
774        plugin: [
775          ["acme-plugin@2.0.0", { source: "project" }],
776          ["second-plugin@3.0.0", { source: "project" }],
777        ],
778      })
779 
780      const config = yield* getTuiConfig(test.directory)
781      const origins = yield* getTuiPluginOrigins(test.directory)
782      expect(config.plugin).toEqual([
783        ["acme-plugin@2.0.0", { source: "project" }],
784        ["second-plugin@3.0.0", { source: "project" }],
785      ])
786      expect(origins).toEqual([
787        {
788          spec: ["acme-plugin@2.0.0", { source: "project" }],
789          scope: "local",
790          source: path.join(test.directory, "tui.json"),
791        },
792        {
793          spec: ["second-plugin@3.0.0", { source: "project" }],
794          scope: "local",
795          source: path.join(test.directory, "tui.json"),
796        },
797      ])
798    }),
799  ),
800)
801 
802it.instance("tracks global and local plugin metadata in merged tui config", () =>
803  withCleanState(
804    Effect.gen(function* () {
805      const fs = yield* FSUtil.Service
806      const test = yield* TestInstance
807      yield* fs.writeJson(path.join(Global.Path.config, "tui.json"), { plugin: ["global-plugin@1.0.0"] })
808      yield* fs.writeJson(path.join(test.directory, "tui.json"), { plugin: ["local-plugin@2.0.0"] })
809 
810      const config = yield* getTuiConfig(test.directory)
811      const origins = yield* getTuiPluginOrigins(test.directory)
812      expect(config.plugin).toEqual(["global-plugin@1.0.0", "local-plugin@2.0.0"])
813      expect(origins).toEqual([
814        {
815          spec: "global-plugin@1.0.0",
816          scope: "global",
817          source: path.join(Global.Path.config, "tui.json"),
818        },
819        {
820          spec: "local-plugin@2.0.0",
821          scope: "local",
822          source: path.join(test.directory, "tui.json"),
823        },
824      ])
825    }),
826  ),
827)
828 
829it.instance("merges plugin_enabled flags across config layers", () =>
830  withCleanState(
831    Effect.gen(function* () {
832      const fs = yield* FSUtil.Service
833      const test = yield* TestInstance
834      yield* fs.writeJson(path.join(Global.Path.config, "tui.json"), {
835        plugin_enabled: {
836          "internal:sidebar-context": false,
837          "demo.plugin": true,
838        },
839      })
840      yield* fs.writeJson(path.join(test.directory, "tui.json"), {
841        plugin_enabled: {
842          "demo.plugin": false,
843          "local.plugin": true,
844        },
845      })
846 
847      const config = yield* getTuiConfig(test.directory)
848      expect(config.plugin_enabled).toEqual({
849        "internal:sidebar-context": false,
850        "demo.plugin": false,
851        "local.plugin": true,
852      })
853    }),
854  ),
855)
856 
857it.instance("silently skips malformed tui.json - load failures degrade to {}", () =>
858  withCleanState(
859    Effect.gen(function* () {
860      const fs = yield* FSUtil.Service
861      const test = yield* TestInstance
862      yield* fs.writeFileString(path.join(test.directory, "tui.json"), '{ "theme": "broken",')
863      yield* fs.writeWithDirs(path.join(test.directory, ".opencode", "tui.json"), JSON.stringify({ theme: "fallback" }))
864 
865      const config = yield* getTuiConfig(test.directory)
866      expect(config.theme).toBe("fallback")
867    }),
868  ),
869)
870 
871it.instance("silently skips non-ENOENT read failures (e.g. tui.json is a directory) - fallback layer still loads", () =>
872  withCleanState(
873    Effect.gen(function* () {
874      const fs = yield* FSUtil.Service
875      const test = yield* TestInstance
876      yield* fs.makeDirectory(path.join(test.directory, "tui.json"), { recursive: true })
877      yield* fs.writeWithDirs(path.join(test.directory, ".opencode", "tui.json"), JSON.stringify({ theme: "fallback" }))
878 
879      const config = yield* getTuiConfig(test.directory)
880      expect(config.theme).toBe("fallback")
881    }),
882  ),
883)
884 
885it.instance("missing tui.json - silently treated as empty (ENOENT path)", () =>
886  withCleanState(
887    Effect.gen(function* () {
888      const test = yield* TestInstance
889      const config = yield* getTuiConfig(test.directory)
890      expect(config).toBeDefined()
891      expect(config.theme).toBeUndefined()
892    }),
893  ),
894)
895