openAgent

1import { Database } from "bun:sqlite"
2import { mkdir, symlink } from "node:fs/promises"
3import os from "node:os"
4import path from "node:path"
5import { afterEach, expect, spyOn, test } from "bun:test"
6import { isZedTerminal, offsetToPosition, resolveZedDbPath, resolveZedSelection } from "@opencode-ai/tui/editor-zed"
7import { tmpdir } from "../../fixture/fixture"
8 
9const originalZedTerm = process.env.ZED_TERM
10const originalTermProgram = process.env.TERM_PROGRAM
11 
12afterEach(() => {
13  if (originalZedTerm === undefined) delete process.env.ZED_TERM
14  else process.env.ZED_TERM = originalZedTerm
15  if (originalTermProgram === undefined) delete process.env.TERM_PROGRAM
16  else process.env.TERM_PROGRAM = originalTermProgram
17})
18 
19type ZedFixtureOptions = {
20  workspacePaths?: string | null
21  itemKind?: string
22  editor?: boolean
23  selectionStart?: number | null
24  selectionEnd?: number | null
25  selections?: Array<{ start: number | null; end: number | null }>
26  contents?: string
27}
28 
29async function writeZedFixture(dir: string, options: ZedFixtureOptions = {}) {
30  const dbPath = path.join(dir, "zed.sqlite")
31  const filePath = path.join(dir, "file.ts")
32  const contents = options.contents ?? "one\ntwo\nthree"
33  await Bun.write(filePath, contents)
34 
35  const db = new Database(dbPath)
36  db.run("create table workspaces (workspace_id integer, paths text, timestamp text)")
37  db.run("create table panes (pane_id integer, workspace_id integer, active integer)")
38  db.run("create table items (item_id integer, workspace_id integer, pane_id integer, active integer, kind text)")
39  db.run("create table editors (item_id integer, workspace_id integer, buffer_path text, contents text)")
40  db.run("create table editor_selections (editor_id integer, workspace_id integer, start integer, end integer)")
41  db.run("insert into workspaces values (1, ?, ?)", [options.workspacePaths ?? JSON.stringify([dir]), "2026-04-27"])
42  db.run("insert into panes values (1, 1, 1)")
43  db.run("insert into items values (1, 1, 1, 1, ?)", [options.itemKind ?? "Editor"])
44  if (options.editor !== false) {
45    db.run("insert into editors values (1, 1, ?, ?)", [filePath, contents])
46    ;(
47      options.selections ?? [
48        {
49          start: options.selectionStart === undefined ? 4 : options.selectionStart,
50          end: options.selectionEnd === undefined ? 7 : options.selectionEnd,
51        },
52      ]
53    ).forEach((selection) =>
54      db.run("insert into editor_selections values (1, 1, ?, ?)", [selection.start, selection.end]),
55    )
56  }
57  db.close()
58 
59  return { dbPath, filePath }
60}
61 
62function utf8ByteOffset(text: string, offset: number) {
63  return new TextEncoder().encode(text.slice(0, offset)).length
64}
65 
66test("offsetToPosition converts Zed offsets to 1-based editor positions", () => {
67  expect(offsetToPosition("one\ntwo\nthree", 0)).toEqual({ line: 1, character: 1 })
68  expect(offsetToPosition("one\ntwo\nthree", 4)).toEqual({ line: 2, character: 1 })
69  expect(offsetToPosition("one\ntwo\nthree", 6)).toEqual({ line: 2, character: 3 })
70  expect(offsetToPosition("one\ntwo\nthree", 100)).toEqual({ line: 3, character: 6 })
71  expect(offsetToPosition("Ж\nabc", utf8ByteOffset("Ж\nabc", "Ж\nabc".indexOf("a")))).toEqual({
72    line: 2,
73    character: 1,
74  })
75  expect(offsetToPosition("😀\nabc", utf8ByteOffset("😀\nabc", "😀\nabc".indexOf("a")))).toEqual({
76    line: 2,
77    character: 1,
78  })
79})
80 
81test("resolveZedDbPath skips candidates that cannot be stated", async () => {
82  await using tmp = await tmpdir()
83  const loop = path.join(tmp.path, "loop")
84  await symlink(loop, loop)
85  const home = spyOn(os, "homedir").mockImplementation(() => tmp.path)
86  const previous = process.env.OPENCODE_ZED_DB
87  process.env.OPENCODE_ZED_DB = loop
88 
89  try {
90    expect(resolveZedDbPath()).toBeUndefined()
91  } finally {
92    if (previous === undefined) delete process.env.OPENCODE_ZED_DB
93    else process.env.OPENCODE_ZED_DB = previous
94    home.mockRestore()
95  }
96})
97 
98test("isZedTerminal only returns true for Zed terminal environments", () => {
99  delete process.env.ZED_TERM
100  delete process.env.TERM_PROGRAM
101  expect(isZedTerminal()).toBeFalse()
102 
103  process.env.ZED_TERM = "true"
104  expect(isZedTerminal()).toBeTrue()
105 
106  process.env.ZED_TERM = "false"
107  process.env.TERM_PROGRAM = "zed"
108  expect(isZedTerminal()).toBeTrue()
109})
110 
111test("resolveZedSelection returns active editor selection", async () => {
112  await using tmp = await tmpdir()
113  const fixture = await writeZedFixture(tmp.path)
114 
115  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({
116    type: "selection",
117    selection: {
118      filePath: fixture.filePath,
119      source: "zed",
120      ranges: [
121        {
122          text: "two",
123          selection: {
124            start: { line: 2, character: 1 },
125            end: { line: 2, character: 4 },
126          },
127        },
128      ],
129    },
130  })
131})
132 
133test("resolveZedSelection returns all active editor selections sorted by offset", async () => {
134  await using tmp = await tmpdir()
135  const contents = "one\ntwo\nthree\nfour"
136  const fixture = await writeZedFixture(tmp.path, {
137    contents,
138    selections: [
139      {
140        start: utf8ByteOffset(contents, contents.indexOf("four")),
141        end: utf8ByteOffset(contents, contents.indexOf("four") + 4),
142      },
143      {
144        start: utf8ByteOffset(contents, contents.indexOf("two")),
145        end: utf8ByteOffset(contents, contents.indexOf("two") + 3),
146      },
147    ],
148  })
149 
150  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({
151    type: "selection",
152    selection: {
153      filePath: fixture.filePath,
154      source: "zed",
155      ranges: [
156        {
157          text: "two",
158          selection: {
159            start: { line: 2, character: 1 },
160            end: { line: 2, character: 4 },
161          },
162        },
163        {
164          text: "four",
165          selection: {
166            start: { line: 4, character: 1 },
167            end: { line: 4, character: 5 },
168          },
169        },
170      ],
171    },
172  })
173})
174 
175test("resolveZedSelection converts Zed UTF-8 byte offsets to string offsets", async () => {
176  await using tmp = await tmpdir()
177  const contents = "a\nЖЖЖЖЖЖЖЖЖЖ\nb\nTARGET\nz"
178  const start = contents.indexOf("TARGET")
179  const fixture = await writeZedFixture(tmp.path, {
180    contents,
181    selectionStart: utf8ByteOffset(contents, start),
182    selectionEnd: utf8ByteOffset(contents, start + "TARGET".length),
183  })
184 
185  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({
186    type: "selection",
187    selection: {
188      filePath: fixture.filePath,
189      source: "zed",
190      ranges: [
191        {
192          text: "TARGET",
193          selection: {
194            start: { line: 4, character: 1 },
195            end: { line: 4, character: 7 },
196          },
197        },
198      ],
199    },
200  })
201})
202 
203test("resolveZedSelection handles non-ASCII text inside the selected range", async () => {
204  await using tmp = await tmpdir()
205  const contents = "a\npre\nвыбор\nz"
206  const start = contents.indexOf("выбор")
207  const fixture = await writeZedFixture(tmp.path, {
208    contents,
209    selectionStart: utf8ByteOffset(contents, start),
210    selectionEnd: utf8ByteOffset(contents, start + "выбор".length),
211  })
212 
213  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({
214    type: "selection",
215    selection: {
216      filePath: fixture.filePath,
217      source: "zed",
218      ranges: [
219        {
220          text: "выбор",
221          selection: {
222            start: { line: 3, character: 1 },
223            end: { line: 3, character: 6 },
224          },
225        },
226      ],
227    },
228  })
229})
230 
231test("resolveZedSelection handles emoji before the selected range", async () => {
232  await using tmp = await tmpdir()
233  const contents = "😀\nTARGET\nz"
234  const start = contents.indexOf("TARGET")
235  const fixture = await writeZedFixture(tmp.path, {
236    contents,
237    selectionStart: utf8ByteOffset(contents, start),
238    selectionEnd: utf8ByteOffset(contents, start + "TARGET".length),
239  })
240 
241  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({
242    type: "selection",
243    selection: {
244      filePath: fixture.filePath,
245      source: "zed",
246      ranges: [
247        {
248          text: "TARGET",
249          selection: {
250            start: { line: 2, character: 1 },
251            end: { line: 2, character: 7 },
252          },
253        },
254      ],
255    },
256  })
257})
258 
259test("resolveZedSelection handles reversed Zed byte offsets", async () => {
260  await using tmp = await tmpdir()
261  const contents = "a\nЖЖЖ\nTARGET\nz"
262  const start = contents.indexOf("TARGET")
263  const fixture = await writeZedFixture(tmp.path, {
264    contents,
265    selectionStart: utf8ByteOffset(contents, start + "TARGET".length),
266    selectionEnd: utf8ByteOffset(contents, start),
267  })
268 
269  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({
270    type: "selection",
271    selection: {
272      filePath: fixture.filePath,
273      source: "zed",
274      ranges: [
275        {
276          text: "TARGET",
277          selection: {
278            start: { line: 3, character: 1 },
279            end: { line: 3, character: 7 },
280          },
281        },
282      ],
283    },
284  })
285})
286 
287test("resolveZedSelection returns empty when no workspace matches", async () => {
288  await using tmp = await tmpdir()
289  const fixture = await writeZedFixture(tmp.path, {
290    workspacePaths: JSON.stringify([path.join(path.dirname(tmp.path), "other-workspace")]),
291  })
292 
293  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({ type: "empty" })
294})
295 
296test("resolveZedSelection matches a Zed workspace that contains the session directory", async () => {
297  await using tmp = await tmpdir()
298  const fixture = await writeZedFixture(tmp.path)
299 
300  expect(await resolveZedSelection(fixture.dbPath, path.join(tmp.path, "packages", "app"))).toEqual({
301    type: "selection",
302    selection: {
303      filePath: fixture.filePath,
304      source: "zed",
305      ranges: [
306        {
307          text: "two",
308          selection: {
309            start: { line: 2, character: 1 },
310            end: { line: 2, character: 4 },
311          },
312        },
313      ],
314    },
315  })
316})
317 
318test("resolveZedSelection prefers the most specific containing Zed workspace", async () => {
319  await using tmp = await tmpdir()
320  const fixture = await writeZedFixture(tmp.path)
321  const child = path.join(tmp.path, "packages")
322  const childFile = path.join(child, "child.ts")
323  await mkdir(child, { recursive: true })
324  await Bun.write(childFile, "child")
325 
326  const db = new Database(fixture.dbPath)
327  db.run("insert into workspaces values (2, ?, ?)", [JSON.stringify([child]), "2026-01-01"])
328  db.run("insert into panes values (2, 2, 1)")
329  db.run("insert into items values (2, 2, 2, 1, ?)", ["Editor"])
330  db.run("insert into editors values (2, 2, ?, ?)", [childFile, "child"])
331  db.run("insert into editor_selections values (2, 2, 0, 5)")
332  db.close()
333 
334  expect(await resolveZedSelection(fixture.dbPath, path.join(child, "app"))).toEqual({
335    type: "selection",
336    selection: {
337      filePath: childFile,
338      source: "zed",
339      ranges: [
340        {
341          text: "child",
342          selection: {
343            start: { line: 1, character: 1 },
344            end: { line: 1, character: 6 },
345          },
346        },
347      ],
348    },
349  })
350})
351 
352test("resolveZedSelection ignores a Zed workspace nested inside the session directory", async () => {
353  await using tmp = await tmpdir()
354  const child = path.join(tmp.path, "effect-lab")
355  await mkdir(child, { recursive: true })
356  const fixture = await writeZedFixture(child)
357 
358  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({ type: "empty" })
359})
360 
361test("resolveZedSelection returns unavailable when a Zed terminal is active", async () => {
362  await using tmp = await tmpdir()
363  const fixture = await writeZedFixture(tmp.path, { itemKind: "Terminal", editor: false })
364 
365  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({ type: "unavailable" })
366})
367 
368test("resolveZedSelection returns unavailable when the database cannot be queried", async () => {
369  await using tmp = await tmpdir()
370 
371  expect(await resolveZedSelection(path.join(tmp.path, "missing.sqlite"), tmp.path)).toEqual({ type: "unavailable" })
372})
373 
374test("resolveZedSelection returns unavailable when active selection is missing offsets", async () => {
375  await using tmp = await tmpdir()
376  const fixture = await writeZedFixture(tmp.path, { selectionStart: null, selectionEnd: null })
377 
378  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({ type: "unavailable" })
379})
380