@stonerzju/opencode 1.2.17 → 1.2.18

package/test/pty/pty-output-isolation.test.ts

@@ -1,140 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Instance } from "../../src/project/instance"
-import { Pty } from "../../src/pty"
-import { tmpdir } from "../fixture/fixture"
-
-describe("pty", () => {
-  test("does not leak output when websocket objects are reused", async () => {
-    await using dir = await tmpdir({ git: true })
-
-    await Instance.provide({
-      directory: dir.path,
-      fn: async () => {
-        const a = await Pty.create({ command: "cat", title: "a" })
-        const b = await Pty.create({ command: "cat", title: "b" })
-        try {
-          const outA: string[] = []
-          const outB: string[] = []
-
-          const ws = {
-            readyState: 1,
-            data: { events: { connection: "a" } },
-            send: (data: unknown) => {
-              outA.push(typeof data === "string" ? data : Buffer.from(data as Uint8Array).toString("utf8"))
-            },
-            close: () => {
-              // no-op (simulate abrupt drop)
-            },
-          }
-
-          // Connect "a" first with ws.
-          Pty.connect(a.id, ws as any)
-
-          // Now "reuse" the same ws object for another connection.
-          ws.data = { events: { connection: "b" } }
-          ws.send = (data: unknown) => {
-            outB.push(typeof data === "string" ? data : Buffer.from(data as Uint8Array).toString("utf8"))
-          }
-          Pty.connect(b.id, ws as any)
-
-          // Clear connect metadata writes.
-          outA.length = 0
-          outB.length = 0
-
-          // Output from a must never show up in b.
-          Pty.write(a.id, "AAA\n")
-          await Bun.sleep(100)
-
-          expect(outB.join("")).not.toContain("AAA")
-        } finally {
-          await Pty.remove(a.id)
-          await Pty.remove(b.id)
-        }
-      },
-    })
-  })
-
-  test("does not leak output when Bun recycles websocket objects before re-connect", async () => {
-    await using dir = await tmpdir({ git: true })
-
-    await Instance.provide({
-      directory: dir.path,
-      fn: async () => {
-        const a = await Pty.create({ command: "cat", title: "a" })
-        try {
-          const outA: string[] = []
-          const outB: string[] = []
-
-          const ws = {
-            readyState: 1,
-            data: { events: { connection: "a" } },
-            send: (data: unknown) => {
-              outA.push(typeof data === "string" ? data : Buffer.from(data as Uint8Array).toString("utf8"))
-            },
-            close: () => {
-              // no-op (simulate abrupt drop)
-            },
-          }
-
-          // Connect "a" first.
-          Pty.connect(a.id, ws as any)
-          outA.length = 0
-
-          // Simulate Bun reusing the same websocket object for another
-          // connection before the next onOpen calls Pty.connect.
-          ws.data = { events: { connection: "b" } }
-          ws.send = (data: unknown) => {
-            outB.push(typeof data === "string" ? data : Buffer.from(data as Uint8Array).toString("utf8"))
-          }
-
-          Pty.write(a.id, "AAA\n")
-          await Bun.sleep(100)
-
-          expect(outB.join("")).not.toContain("AAA")
-        } finally {
-          await Pty.remove(a.id)
-        }
-      },
-    })
-  })
-
-  test("treats in-place socket data mutation as the same connection", async () => {
-    await using dir = await tmpdir({ git: true })
-
-    await Instance.provide({
-      directory: dir.path,
-      fn: async () => {
-        const a = await Pty.create({ command: "cat", title: "a" })
-        try {
-          const out: string[] = []
-
-          const ctx = { connId: 1 }
-          const ws = {
-            readyState: 1,
-            data: ctx,
-            send: (data: unknown) => {
-              out.push(typeof data === "string" ? data : Buffer.from(data as Uint8Array).toString("utf8"))
-            },
-            close: () => {
-              // no-op
-            },
-          }
-
-          Pty.connect(a.id, ws as any)
-          out.length = 0
-
-          // Mutating fields on ws.data should not look like a new
-          // connection lifecycle when the object identity stays stable.
-          ctx.connId = 2
-
-          Pty.write(a.id, "AAA\n")
-          await Bun.sleep(100)
-
-          expect(out.join("")).toContain("AAA")
-        } finally {
-          await Pty.remove(a.id)
-        }
-      },
-    })
-  })
-})

package/test/question/question.test.ts

@@ -1,300 +0,0 @@
-import { test, expect } from "bun:test"
-import { Question } from "../../src/question"
-import { Instance } from "../../src/project/instance"
-import { tmpdir } from "../fixture/fixture"
-
-test("ask - returns pending promise", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const promise = Question.ask({
-        sessionID: "ses_test",
-        questions: [
-          {
-            question: "What would you like to do?",
-            header: "Action",
-            options: [
-              { label: "Option 1", description: "First option" },
-              { label: "Option 2", description: "Second option" },
-            ],
-          },
-        ],
-      })
-      expect(promise).toBeInstanceOf(Promise)
-    },
-  })
-})
-
-test("ask - adds to pending list", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const questions = [
-        {
-          question: "What would you like to do?",
-          header: "Action",
-          options: [
-            { label: "Option 1", description: "First option" },
-            { label: "Option 2", description: "Second option" },
-          ],
-        },
-      ]
-
-      Question.ask({
-        sessionID: "ses_test",
-        questions,
-      })
-
-      const pending = await Question.list()
-      expect(pending.length).toBe(1)
-      expect(pending[0].questions).toEqual(questions)
-    },
-  })
-})
-
-// reply tests
-
-test("reply - resolves the pending ask with answers", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const questions = [
-        {
-          question: "What would you like to do?",
-          header: "Action",
-          options: [
-            { label: "Option 1", description: "First option" },
-            { label: "Option 2", description: "Second option" },
-          ],
-        },
-      ]
-
-      const askPromise = Question.ask({
-        sessionID: "ses_test",
-        questions,
-      })
-
-      const pending = await Question.list()
-      const requestID = pending[0].id
-
-      await Question.reply({
-        requestID,
-        answers: [["Option 1"]],
-      })
-
-      const answers = await askPromise
-      expect(answers).toEqual([["Option 1"]])
-    },
-  })
-})
-
-test("reply - removes from pending list", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      Question.ask({
-        sessionID: "ses_test",
-        questions: [
-          {
-            question: "What would you like to do?",
-            header: "Action",
-            options: [
-              { label: "Option 1", description: "First option" },
-              { label: "Option 2", description: "Second option" },
-            ],
-          },
-        ],
-      })
-
-      const pending = await Question.list()
-      expect(pending.length).toBe(1)
-
-      await Question.reply({
-        requestID: pending[0].id,
-        answers: [["Option 1"]],
-      })
-
-      const pendingAfter = await Question.list()
-      expect(pendingAfter.length).toBe(0)
-    },
-  })
-})
-
-test("reply - does nothing for unknown requestID", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      await Question.reply({
-        requestID: "que_unknown",
-        answers: [["Option 1"]],
-      })
-      // Should not throw
-    },
-  })
-})
-
-// reject tests
-
-test("reject - throws RejectedError", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const askPromise = Question.ask({
-        sessionID: "ses_test",
-        questions: [
-          {
-            question: "What would you like to do?",
-            header: "Action",
-            options: [
-              { label: "Option 1", description: "First option" },
-              { label: "Option 2", description: "Second option" },
-            ],
-          },
-        ],
-      })
-
-      const pending = await Question.list()
-      await Question.reject(pending[0].id)
-
-      await expect(askPromise).rejects.toBeInstanceOf(Question.RejectedError)
-    },
-  })
-})
-
-test("reject - removes from pending list", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const askPromise = Question.ask({
-        sessionID: "ses_test",
-        questions: [
-          {
-            question: "What would you like to do?",
-            header: "Action",
-            options: [
-              { label: "Option 1", description: "First option" },
-              { label: "Option 2", description: "Second option" },
-            ],
-          },
-        ],
-      })
-
-      const pending = await Question.list()
-      expect(pending.length).toBe(1)
-
-      await Question.reject(pending[0].id)
-      askPromise.catch(() => {}) // Ignore rejection
-
-      const pendingAfter = await Question.list()
-      expect(pendingAfter.length).toBe(0)
-    },
-  })
-})
-
-test("reject - does nothing for unknown requestID", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      await Question.reject("que_unknown")
-      // Should not throw
-    },
-  })
-})
-
-// multiple questions tests
-
-test("ask - handles multiple questions", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const questions = [
-        {
-          question: "What would you like to do?",
-          header: "Action",
-          options: [
-            { label: "Build", description: "Build the project" },
-            { label: "Test", description: "Run tests" },
-          ],
-        },
-        {
-          question: "Which environment?",
-          header: "Env",
-          options: [
-            { label: "Dev", description: "Development" },
-            { label: "Prod", description: "Production" },
-          ],
-        },
-      ]
-
-      const askPromise = Question.ask({
-        sessionID: "ses_test",
-        questions,
-      })
-
-      const pending = await Question.list()
-
-      await Question.reply({
-        requestID: pending[0].id,
-        answers: [["Build"], ["Dev"]],
-      })
-
-      const answers = await askPromise
-      expect(answers).toEqual([["Build"], ["Dev"]])
-    },
-  })
-})
-
-// list tests
-
-test("list - returns all pending requests", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      Question.ask({
-        sessionID: "ses_test1",
-        questions: [
-          {
-            question: "Question 1?",
-            header: "Q1",
-            options: [{ label: "A", description: "A" }],
-          },
-        ],
-      })
-
-      Question.ask({
-        sessionID: "ses_test2",
-        questions: [
-          {
-            question: "Question 2?",
-            header: "Q2",
-            options: [{ label: "B", description: "B" }],
-          },
-        ],
-      })
-
-      const pending = await Question.list()
-      expect(pending.length).toBe(2)
-    },
-  })
-})
-
-test("list - returns empty when no pending", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const pending = await Question.list()
-      expect(pending.length).toBe(0)
-    },
-  })
-})

package/test/scheduler.test.ts

@@ -1,73 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Scheduler } from "../src/scheduler"
-import { Instance } from "../src/project/instance"
-import { tmpdir } from "./fixture/fixture"
-
-describe("Scheduler.register", () => {
-  const hour = 60 * 60 * 1000
-
-  test("defaults to instance scope per directory", async () => {
-    await using one = await tmpdir({ git: true })
-    await using two = await tmpdir({ git: true })
-    const runs = { count: 0 }
-    const id = "scheduler.instance." + Math.random().toString(36).slice(2)
-    const task = {
-      id,
-      interval: hour,
-      run: async () => {
-        runs.count += 1
-      },
-    }
-
-    await Instance.provide({
-      directory: one.path,
-      fn: async () => {
-        Scheduler.register(task)
-        await Instance.dispose()
-      },
-    })
-    expect(runs.count).toBe(1)
-
-    await Instance.provide({
-      directory: two.path,
-      fn: async () => {
-        Scheduler.register(task)
-        await Instance.dispose()
-      },
-    })
-    expect(runs.count).toBe(2)
-  })
-
-  test("global scope runs once across instances", async () => {
-    await using one = await tmpdir({ git: true })
-    await using two = await tmpdir({ git: true })
-    const runs = { count: 0 }
-    const id = "scheduler.global." + Math.random().toString(36).slice(2)
-    const task = {
-      id,
-      interval: hour,
-      run: async () => {
-        runs.count += 1
-      },
-      scope: "global" as const,
-    }
-
-    await Instance.provide({
-      directory: one.path,
-      fn: async () => {
-        Scheduler.register(task)
-        await Instance.dispose()
-      },
-    })
-    expect(runs.count).toBe(1)
-
-    await Instance.provide({
-      directory: two.path,
-      fn: async () => {
-        Scheduler.register(task)
-        await Instance.dispose()
-      },
-    })
-    expect(runs.count).toBe(1)
-  })
-})

package/test/server/global-session-list.test.ts

@@ -1,89 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Instance } from "../../src/project/instance"
-import { Project } from "../../src/project/project"
-import { Session } from "../../src/session"
-import { Log } from "../../src/util/log"
-import { tmpdir } from "../fixture/fixture"
-
-Log.init({ print: false })
-
-describe("Session.listGlobal", () => {
-  test("lists sessions across projects with project metadata", async () => {
-    await using first = await tmpdir({ git: true })
-    await using second = await tmpdir({ git: true })
-
-    const firstSession = await Instance.provide({
-      directory: first.path,
-      fn: async () => Session.create({ title: "first-session" }),
-    })
-    const secondSession = await Instance.provide({
-      directory: second.path,
-      fn: async () => Session.create({ title: "second-session" }),
-    })
-
-    const sessions = [...Session.listGlobal({ limit: 200 })]
-    const ids = sessions.map((session) => session.id)
-
-    expect(ids).toContain(firstSession.id)
-    expect(ids).toContain(secondSession.id)
-
-    const firstProject = Project.get(firstSession.projectID)
-    const secondProject = Project.get(secondSession.projectID)
-
-    const firstItem = sessions.find((session) => session.id === firstSession.id)
-    const secondItem = sessions.find((session) => session.id === secondSession.id)
-
-    expect(firstItem?.project?.id).toBe(firstProject?.id)
-    expect(firstItem?.project?.worktree).toBe(firstProject?.worktree)
-    expect(secondItem?.project?.id).toBe(secondProject?.id)
-    expect(secondItem?.project?.worktree).toBe(secondProject?.worktree)
-  })
-
-  test("excludes archived sessions by default", async () => {
-    await using tmp = await tmpdir({ git: true })
-
-    const archived = await Instance.provide({
-      directory: tmp.path,
-      fn: async () => Session.create({ title: "archived-session" }),
-    })
-
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => Session.setArchived({ sessionID: archived.id, time: Date.now() }),
-    })
-
-    const sessions = [...Session.listGlobal({ limit: 200 })]
-    const ids = sessions.map((session) => session.id)
-
-    expect(ids).not.toContain(archived.id)
-
-    const allSessions = [...Session.listGlobal({ limit: 200, archived: true })]
-    const allIds = allSessions.map((session) => session.id)
-
-    expect(allIds).toContain(archived.id)
-  })
-
-  test("supports cursor pagination", async () => {
-    await using tmp = await tmpdir({ git: true })
-
-    const first = await Instance.provide({
-      directory: tmp.path,
-      fn: async () => Session.create({ title: "page-one" }),
-    })
-    await new Promise((resolve) => setTimeout(resolve, 5))
-    const second = await Instance.provide({
-      directory: tmp.path,
-      fn: async () => Session.create({ title: "page-two" }),
-    })
-
-    const page = [...Session.listGlobal({ directory: tmp.path, limit: 1 })]
-    expect(page.length).toBe(1)
-    expect(page[0].id).toBe(second.id)
-
-    const next = [...Session.listGlobal({ directory: tmp.path, limit: 10, cursor: page[0].time.updated })]
-    const ids = next.map((session) => session.id)
-
-    expect(ids).toContain(first.id)
-    expect(ids).not.toContain(second.id)
-  })
-})

package/test/server/session-list.test.ts

@@ -1,90 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import path from "path"
-import { Instance } from "../../src/project/instance"
-import { Session } from "../../src/session"
-import { Log } from "../../src/util/log"
-
-const projectRoot = path.join(__dirname, "../..")
-Log.init({ print: false })
-
-describe("Session.list", () => {
-  test("filters by directory", async () => {
-    await Instance.provide({
-      directory: projectRoot,
-      fn: async () => {
-        const first = await Session.create({})
-
-        const otherDir = path.join(projectRoot, "..", "__session_list_other")
-        const second = await Instance.provide({
-          directory: otherDir,
-          fn: async () => Session.create({}),
-        })
-
-        const sessions = [...Session.list({ directory: projectRoot })]
-        const ids = sessions.map((s) => s.id)
-
-        expect(ids).toContain(first.id)
-        expect(ids).not.toContain(second.id)
-      },
-    })
-  })
-
-  test("filters root sessions", async () => {
-    await Instance.provide({
-      directory: projectRoot,
-      fn: async () => {
-        const root = await Session.create({ title: "root-session" })
-        const child = await Session.create({ title: "child-session", parentID: root.id })
-
-        const sessions = [...Session.list({ roots: true })]
-        const ids = sessions.map((s) => s.id)
-
-        expect(ids).toContain(root.id)
-        expect(ids).not.toContain(child.id)
-      },
-    })
-  })
-
-  test("filters by start time", async () => {
-    await Instance.provide({
-      directory: projectRoot,
-      fn: async () => {
-        const session = await Session.create({ title: "new-session" })
-        const futureStart = Date.now() + 86400000
-
-        const sessions = [...Session.list({ start: futureStart })]
-        expect(sessions.length).toBe(0)
-      },
-    })
-  })
-
-  test("filters by search term", async () => {
-    await Instance.provide({
-      directory: projectRoot,
-      fn: async () => {
-        await Session.create({ title: "unique-search-term-abc" })
-        await Session.create({ title: "other-session-xyz" })
-
-        const sessions = [...Session.list({ search: "unique-search" })]
-        const titles = sessions.map((s) => s.title)
-
-        expect(titles).toContain("unique-search-term-abc")
-        expect(titles).not.toContain("other-session-xyz")
-      },
-    })
-  })
-
-  test("respects limit parameter", async () => {
-    await Instance.provide({
-      directory: projectRoot,
-      fn: async () => {
-        await Session.create({ title: "session-1" })
-        await Session.create({ title: "session-2" })
-        await Session.create({ title: "session-3" })
-
-        const sessions = [...Session.list({ limit: 2 })]
-        expect(sessions.length).toBe(2)
-      },
-    })
-  })
-})