(info: Info): Effect.Effect> { return Effect.gen(function* () { const init = yield* Effect.promise(() => info.init()) return { diff --git a/packages/opencode/test/server/project-init-git.test.ts b/packages/opencode/test/server/project-init-git.test.ts index 8559977758bc..eca562a0f53a 100644 --- a/packages/opencode/test/server/project-init-git.test.ts +++ b/packages/opencode/test/server/project-init-git.test.ts @@ -19,7 +19,7 @@ afterEach(async () => { describe("project.initGit endpoint", () => { test("initializes git and reloads immediately", async () => { await using tmp = await tmpdir() - const app = Server.Default() + const app = Server.Default().app const seen: { directory?: string; payload: { type: string } }[] = [] const fn = (evt: { directory?: string; payload: { type: string } }) => { seen.push(evt) @@ -76,7 +76,7 @@ describe("project.initGit endpoint", () => { test("does not reload when the project is already git", async () => { await using tmp = await tmpdir({ git: true }) - const app = Server.Default() + const app = Server.Default().app const seen: { directory?: string; payload: { type: string } }[] = [] const fn = (evt: { directory?: string; payload: { type: string } }) => { seen.push(evt) diff --git a/packages/opencode/test/server/session-actions.test.ts b/packages/opencode/test/server/session-actions.test.ts index e6dba676ce35..004c2900a208 100644 --- a/packages/opencode/test/server/session-actions.test.ts +++ b/packages/opencode/test/server/session-actions.test.ts @@ -42,7 +42,7 @@ describe("session action routes", () => { fn: async () => { const session = await Session.create({}) const cancel = spyOn(SessionPrompt, "cancel").mockResolvedValue() - const app = Server.Default() + const app = Server.Default().app const res = await app.request(`/session/${session.id}/abort`, { method: "POST", @@ -66,7 +66,7 @@ describe("session action routes", () => { const msg = await user(session.id, "hello") const busy = spyOn(SessionPrompt, "assertNotBusy").mockRejectedValue(new Session.BusyError(session.id)) const remove = spyOn(Session, "removeMessage").mockResolvedValue(msg.id) - const app = Server.Default() + const app = Server.Default().app const res = await app.request(`/session/${session.id}/message/${msg.id}`, { method: "DELETE", diff --git a/packages/opencode/test/server/session-messages.test.ts b/packages/opencode/test/server/session-messages.test.ts index 89e6fba5c5fd..7ba95f3b1ec8 100644 --- a/packages/opencode/test/server/session-messages.test.ts +++ b/packages/opencode/test/server/session-messages.test.ts @@ -60,7 +60,7 @@ describe("session messages endpoint", () => { fn: async () => { const session = await Session.create({}) const ids = await fill(session.id, 5) - const app = Server.Default() + const app = Server.Default().app const a = await app.request(`/session/${session.id}/message?limit=2`) expect(a.status).toBe(200) @@ -89,7 +89,7 @@ describe("session messages endpoint", () => { fn: async () => { const session = await Session.create({}) const ids = await fill(session.id, 3) - const app = Server.Default() + const app = Server.Default().app const res = await app.request(`/session/${session.id}/message`) expect(res.status).toBe(200) @@ -109,7 +109,7 @@ describe("session messages endpoint", () => { directory: tmp.path, fn: async () => { const session = await Session.create({}) - const app = Server.Default() + const app = Server.Default().app const bad = await app.request(`/session/${session.id}/message?limit=2&before=bad`) expect(bad.status).toBe(400) @@ -131,7 +131,7 @@ describe("session messages endpoint", () => { fn: async () => { const session = await Session.create({}) await fill(session.id, 520) - const app = Server.Default() + const app = Server.Default().app const res = await app.request(`/session/${session.id}/message?limit=510`) expect(res.status).toBe(200) diff --git a/packages/opencode/test/server/session-select.test.ts b/packages/opencode/test/server/session-select.test.ts index 345b4314675b..7558b4a6b624 100644 --- a/packages/opencode/test/server/session-select.test.ts +++ b/packages/opencode/test/server/session-select.test.ts @@ -21,7 +21,7 @@ describe("tui.selectSession endpoint", () => { const session = await Session.create({}) // #when - const app = Server.Default() + const app = Server.Default().app const response = await app.request("/tui/select-session", { method: "POST", headers: { "Content-Type": "application/json" }, @@ -47,7 +47,7 @@ describe("tui.selectSession endpoint", () => { const nonExistentSessionID = "ses_nonexistent123" // #when - const app = Server.Default() + const app = Server.Default().app const response = await app.request("/tui/select-session", { method: "POST", headers: { "Content-Type": "application/json" }, @@ -69,7 +69,7 @@ describe("tui.selectSession endpoint", () => { const invalidSessionID = "invalid_session_id" // #when - const app = Server.Default() + const app = Server.Default().app const response = await app.request("/tui/select-session", { method: "POST", headers: { "Content-Type": "application/json" }, diff --git a/packages/opencode/test/session/compaction.test.ts b/packages/opencode/test/session/compaction.test.ts index 799bb3e2aeb1..c37371d9f871 100644 --- a/packages/opencode/test/session/compaction.test.ts +++ b/packages/opencode/test/session/compaction.test.ts @@ -139,7 +139,6 @@ function fake( get message() { return msg }, - abort: Effect.fn("TestSessionProcessor.abort")(() => Effect.void), partFromToolCall() { return { id: PartID.ascending(), diff --git a/packages/opencode/test/session/message-v2.test.ts b/packages/opencode/test/session/message-v2.test.ts index 3634d6fb7ec8..64a5d3e4b257 100644 --- a/packages/opencode/test/session/message-v2.test.ts +++ b/packages/opencode/test/session/message-v2.test.ts @@ -570,6 +570,81 @@ describe("session.message-v2.toModelMessage", () => { ]) }) + test("forwards partial bash output for aborted tool calls", async () => { + const userID = "m-user" + const assistantID = "m-assistant" + const output = [ + "31403", + "12179", + "4575", + "", + "", + "User aborted the command", + "", + ].join("\n") + + const input: MessageV2.WithParts[] = [ + { + info: userInfo(userID), + parts: [ + { + ...basePart(userID, "u1"), + type: "text", + text: "run tool", + }, + ] as MessageV2.Part[], + }, + { + info: assistantInfo(assistantID, userID), + parts: [ + { + ...basePart(assistantID, "a1"), + type: "tool", + callID: "call-1", + tool: "bash", + state: { + status: "error", + input: { command: "for i in {1..20}; do print -- $RANDOM; sleep 1; done" }, + error: "Tool execution aborted", + metadata: { interrupted: true, output }, + time: { start: 0, end: 1 }, + }, + }, + ] as MessageV2.Part[], + }, + ] + + expect(await MessageV2.toModelMessages(input, model)).toStrictEqual([ + { + role: "user", + content: [{ type: "text", text: "run tool" }], + }, + { + role: "assistant", + content: [ + { + type: "tool-call", + toolCallId: "call-1", + toolName: "bash", + input: { command: "for i in {1..20}; do print -- $RANDOM; sleep 1; done" }, + providerExecuted: undefined, + }, + ], + }, + { + role: "tool", + content: [ + { + type: "tool-result", + toolCallId: "call-1", + toolName: "bash", + output: { type: "text", value: output }, + }, + ], + }, + ]) + }) + test("filters assistant messages with non-abort errors", async () => { const assistantID = "m-assistant" diff --git a/packages/opencode/test/session/processor-effect.test.ts b/packages/opencode/test/session/processor-effect.test.ts index 5f1912c6087d..26f412c7eefa 100644 --- a/packages/opencode/test/session/processor-effect.test.ts +++ b/packages/opencode/test/session/processor-effect.test.ts @@ -21,7 +21,7 @@ import { Log } from "../../src/util/log" import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner" import { provideTmpdirServer } from "../fixture/fixture" import { testEffect } from "../lib/effect" -import { reply, TestLLMServer } from "../lib/llm-server" +import { raw, reply, TestLLMServer } from "../lib/llm-server" Log.init({ print: false }) @@ -218,6 +218,93 @@ it.live("session.processor effect tests capture llm input cleanly", () => ), ) +it.live("session.processor effect tests preserve text start time", () => + provideTmpdirServer( + ({ dir, llm }) => + Effect.gen(function* () { + const gate = defer() + const { processors, session, provider } = yield* boot() + + yield* llm.push( + raw({ + head: [ + { + id: "chatcmpl-test", + object: "chat.completion.chunk", + choices: [{ delta: { role: "assistant" } }], + }, + { + id: "chatcmpl-test", + object: "chat.completion.chunk", + choices: [{ delta: { content: "hello" } }], + }, + ], + wait: gate.promise, + tail: [ + { + id: "chatcmpl-test", + object: "chat.completion.chunk", + choices: [{ delta: {}, finish_reason: "stop" }], + }, + ], + }), + ) + + const chat = yield* session.create({}) + const parent = yield* user(chat.id, "hi") + const msg = yield* assistant(chat.id, parent.id, path.resolve(dir)) + const mdl = yield* provider.getModel(ref.providerID, ref.modelID) + const handle = yield* processors.create({ + assistantMessage: msg, + sessionID: chat.id, + model: mdl, + }) + + const run = yield* handle + .process({ + user: { + id: parent.id, + sessionID: chat.id, + role: "user", + time: parent.time, + agent: parent.agent, + model: { providerID: ref.providerID, modelID: ref.modelID }, + } satisfies MessageV2.User, + sessionID: chat.id, + model: mdl, + agent: agent(), + system: [], + messages: [{ role: "user", content: "hi" }], + tools: {}, + }) + .pipe(Effect.forkChild) + + yield* Effect.promise(async () => { + const stop = Date.now() + 500 + while (Date.now() < stop) { + const text = MessageV2.parts(msg.id).find((part): part is MessageV2.TextPart => part.type === "text") + if (text?.time?.start) return + await Bun.sleep(10) + } + throw new Error("timed out waiting for text part") + }) + yield* Effect.sleep("20 millis") + gate.resolve() + + const exit = yield* Fiber.await(run) + const text = MessageV2.parts(msg.id).find((part): part is MessageV2.TextPart => part.type === "text") + + expect(Exit.isSuccess(exit)).toBe(true) + expect(text?.text).toBe("hello") + expect(text?.time?.start).toBeDefined() + expect(text?.time?.end).toBeDefined() + if (!text?.time?.start || !text.time.end) return + expect(text.time.start).toBeLessThan(text.time.end) + }), + { git: true, config: (url) => providerCfg(url) }, + ), +) + it.live("session.processor effect tests stop after token overflow requests compaction", () => provideTmpdirServer( ({ dir, llm }) => @@ -636,9 +723,6 @@ it.live("session.processor effect tests mark pending tools as aborted on cleanup yield* Fiber.interrupt(run) const exit = yield* Fiber.await(run) - if (Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)) { - yield* handle.abort() - } const parts = MessageV2.parts(msg.id) const call = parts.find((part): part is MessageV2.ToolPart => part.type === "tool") @@ -650,6 +734,7 @@ it.live("session.processor effect tests mark pending tools as aborted on cleanup expect(call?.state.status).toBe("error") if (call?.state.status === "error") { expect(call.state.error).toBe("Tool execution aborted") + expect(call.state.metadata?.interrupted).toBe(true) expect(call.state.time.end).toBeDefined() } }), @@ -708,9 +793,6 @@ it.live("session.processor effect tests record aborted errors and idle state", ( yield* Fiber.interrupt(run) const exit = yield* Fiber.await(run) - if (Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)) { - yield* handle.abort() - } yield* Effect.promise(() => seen.promise) const stored = MessageV2.get({ sessionID: chat.id, messageID: msg.id }) const state = yield* sts.get(chat.id) diff --git a/packages/opencode/test/session/prompt-effect.test.ts b/packages/opencode/test/session/prompt-effect.test.ts index 1c92c38428c0..5e45ebf83263 100644 --- a/packages/opencode/test/session/prompt-effect.test.ts +++ b/packages/opencode/test/session/prompt-effect.test.ts @@ -1,5 +1,5 @@ import { NodeFileSystem } from "@effect/platform-node" -import { expect, spyOn } from "bun:test" +import { expect } from "bun:test" import { Cause, Effect, Exit, Fiber, Layer } from "effect" import path from "path" import z from "zod" @@ -29,7 +29,6 @@ import { MessageID, PartID, SessionID } from "../../src/session/schema" import { SessionStatus } from "../../src/session/status" import { Shell } from "../../src/shell/shell" import { Snapshot } from "../../src/snapshot" -import { TaskTool } from "../../src/tool/task" import { ToolRegistry } from "../../src/tool/registry" import { Truncate } from "../../src/tool/truncate" import { Log } from "../../src/util/log" @@ -703,34 +702,27 @@ it.live( "cancel finalizes subtask tool state", () => provideTmpdirInstance( - (dir) => + () => Effect.gen(function* () { const ready = defer() const aborted = defer() - const init = spyOn(TaskTool, "init").mockImplementation(async () => ({ - description: "task", - parameters: z.object({ - description: z.string(), - prompt: z.string(), - subagent_type: z.string(), - task_id: z.string().optional(), - command: z.string().optional(), - }), - execute: async (_args, ctx) => { - ready.resolve() - ctx.abort.addEventListener("abort", () => aborted.resolve(), { once: true }) - await new Promise(() => {}) - return { - title: "", - metadata: { - sessionId: SessionID.make("task"), - model: ref, - }, - output: "", - } - }, - })) - yield* Effect.addFinalizer(() => Effect.sync(() => init.mockRestore())) + const registry = yield* ToolRegistry.Service + const { task } = yield* registry.named() + const original = task.execute + task.execute = async (_args, ctx) => { + ready.resolve() + ctx.abort.addEventListener("abort", () => aborted.resolve(), { once: true }) + await new Promise(() => {}) + return { + title: "", + metadata: { + sessionId: SessionID.make("task"), + model: ref, + }, + output: "", + } + } + yield* Effect.addFinalizer(() => Effect.sync(() => void (task.execute = original))) const { prompt, chat } = yield* boot() const msg = yield* user(chat.id, "hello") @@ -1324,3 +1316,109 @@ unix( ), 30_000, ) + +// Abort signal propagation tests for inline tool execution + +/** Override a tool's execute to hang until aborted. Returns ready/aborted defers and a finalizer. */ +function hangUntilAborted(tool: { execute: (...args: any[]) => any }) { + const ready = defer() + const aborted = defer() + const original = tool.execute + tool.execute = async (_args: any, ctx: any) => { + ready.resolve() + ctx.abort.addEventListener("abort", () => aborted.resolve(), { once: true }) + await new Promise(() => {}) + return { title: "", metadata: {}, output: "" } + } + const restore = Effect.addFinalizer(() => Effect.sync(() => void (tool.execute = original))) + return { ready, aborted, restore } +} + +it.live( + "interrupt propagates abort signal to read tool via file part (text/plain)", + () => + provideTmpdirInstance( + (dir) => + Effect.gen(function* () { + const registry = yield* ToolRegistry.Service + const { read } = yield* registry.named() + const { ready, aborted, restore } = hangUntilAborted(read) + yield* restore + + const prompt = yield* SessionPrompt.Service + const sessions = yield* Session.Service + const chat = yield* sessions.create({ title: "Abort Test" }) + + const testFile = path.join(dir, "test.txt") + yield* Effect.promise(() => Bun.write(testFile, "hello world")) + + const fiber = yield* prompt + .prompt({ + sessionID: chat.id, + agent: "build", + parts: [ + { type: "text", text: "read this" }, + { type: "file", url: `file://${testFile}`, filename: "test.txt", mime: "text/plain" }, + ], + }) + .pipe(Effect.forkChild) + + yield* Effect.promise(() => ready.promise) + yield* Fiber.interrupt(fiber) + + yield* Effect.promise(() => + Promise.race([ + aborted.promise, + new Promise((_, reject) => + setTimeout(() => reject(new Error("abort signal not propagated within 2s")), 2_000), + ), + ]), + ) + }), + { git: true, config: cfg }, + ), + 30_000, +) + +it.live( + "interrupt propagates abort signal to read tool via file part (directory)", + () => + provideTmpdirInstance( + (dir) => + Effect.gen(function* () { + const registry = yield* ToolRegistry.Service + const { read } = yield* registry.named() + const { ready, aborted, restore } = hangUntilAborted(read) + yield* restore + + const prompt = yield* SessionPrompt.Service + const sessions = yield* Session.Service + const chat = yield* sessions.create({ title: "Abort Test" }) + + const fiber = yield* prompt + .prompt({ + sessionID: chat.id, + agent: "build", + parts: [ + { type: "text", text: "read this" }, + { type: "file", url: `file://${dir}`, filename: "dir", mime: "application/x-directory" }, + ], + }) + .pipe(Effect.forkChild) + + yield* Effect.promise(() => ready.promise) + yield* Fiber.interrupt(fiber) + + yield* Effect.promise(() => + Promise.race([ + aborted.promise, + new Promise((_, reject) => + setTimeout(() => reject(new Error("abort signal not propagated within 2s")), 2_000), + ), + ]), + ) + }), + { git: true, config: cfg }, + ), + 30_000, +) diff --git a/packages/opencode/test/storage/json-migration.test.ts b/packages/opencode/test/storage/json-migration.test.ts index a714f1147345..e76401ae75c8 100644 --- a/packages/opencode/test/storage/json-migration.test.ts +++ b/packages/opencode/test/storage/json-migration.test.ts @@ -1,6 +1,6 @@ import { describe, test, expect, beforeEach, afterEach } from "bun:test" import { Database } from "bun:sqlite" -import { drizzle } from "drizzle-orm/bun-sqlite" +import { drizzle, SQLiteBunDatabase } from "drizzle-orm/bun-sqlite" import { migrate } from "drizzle-orm/bun-sqlite/migrator" import path from "path" import fs from "fs/promises" @@ -89,18 +89,21 @@ function createTestDb() { name: entry.name, })) .sort((a, b) => a.timestamp - b.timestamp) - migrate(drizzle({ client: sqlite }), migrations) - return sqlite + const db = drizzle({ client: sqlite }) + migrate(db, migrations) + + return [sqlite, db] as const } describe("JSON to SQLite migration", () => { let storageDir: string let sqlite: Database + let db: SQLiteBunDatabase beforeEach(async () => { storageDir = await setupStorageDir() - sqlite = createTestDb() + ;[sqlite, db] = createTestDb() }) afterEach(async () => { @@ -118,11 +121,10 @@ describe("JSON to SQLite migration", () => { sandboxes: ["/test/sandbox"], }) - const stats = await JsonMigration.run(sqlite) + const stats = await JsonMigration.run(db) expect(stats?.projects).toBe(1) - const db = drizzle({ client: sqlite }) const projects = db.select().from(ProjectTable).all() expect(projects.length).toBe(1) expect(projects[0].id).toBe(ProjectID.make("proj_test123abc")) @@ -143,11 +145,10 @@ describe("JSON to SQLite migration", () => { }), ) - const stats = await JsonMigration.run(sqlite) + const stats = await JsonMigration.run(db) expect(stats?.projects).toBe(1) - const db = drizzle({ client: sqlite }) const projects = db.select().from(ProjectTable).all() expect(projects.length).toBe(1) expect(projects[0].id).toBe(ProjectID.make("proj_filename")) // Uses filename, not JSON id @@ -164,11 +165,10 @@ describe("JSON to SQLite migration", () => { commands: { start: "npm run dev" }, }) - const stats = await JsonMigration.run(sqlite) + const stats = await JsonMigration.run(db) expect(stats?.projects).toBe(1) - const db = drizzle({ client: sqlite }) const projects = db.select().from(ProjectTable).all() expect(projects.length).toBe(1) expect(projects[0].id).toBe(ProjectID.make("proj_with_commands")) @@ -185,11 +185,10 @@ describe("JSON to SQLite migration", () => { sandboxes: [], }) - const stats = await JsonMigration.run(sqlite) + const stats = await JsonMigration.run(db) expect(stats?.projects).toBe(1) - const db = drizzle({ client: sqlite }) const projects = db.select().from(ProjectTable).all() expect(projects.length).toBe(1) expect(projects[0].id).toBe(ProjectID.make("proj_no_commands")) @@ -216,9 +215,8 @@ describe("JSON to SQLite migration", () => { share: { url: "https://example.com/share" }, }) - await JsonMigration.run(sqlite) + await JsonMigration.run(db) - const db = drizzle({ client: sqlite }) const sessions = db.select().from(SessionTable).all() expect(sessions.length).toBe(1) expect(sessions[0].id).toBe(SessionID.make("ses_test456def")) @@ -247,12 +245,11 @@ describe("JSON to SQLite migration", () => { JSON.stringify({ ...fixtures.part }), ) - const stats = await JsonMigration.run(sqlite) + const stats = await JsonMigration.run(db) expect(stats?.messages).toBe(1) expect(stats?.parts).toBe(1) - const db = drizzle({ client: sqlite }) const messages = db.select().from(MessageTable).all() expect(messages.length).toBe(1) expect(messages[0].id).toBe(MessageID.make("msg_test789ghi")) @@ -287,12 +284,11 @@ describe("JSON to SQLite migration", () => { }), ) - const stats = await JsonMigration.run(sqlite) + const stats = await JsonMigration.run(db) expect(stats?.messages).toBe(1) expect(stats?.parts).toBe(1) - const db = drizzle({ client: sqlite }) const messages = db.select().from(MessageTable).all() expect(messages.length).toBe(1) expect(messages[0].id).toBe(MessageID.make("msg_test789ghi")) @@ -329,11 +325,10 @@ describe("JSON to SQLite migration", () => { }), ) - const stats = await JsonMigration.run(sqlite) + const stats = await JsonMigration.run(db) expect(stats?.messages).toBe(1) - const db = drizzle({ client: sqlite }) const messages = db.select().from(MessageTable).all() expect(messages.length).toBe(1) expect(messages[0].id).toBe(MessageID.make("msg_from_filename")) // Uses filename, not JSON id @@ -367,11 +362,10 @@ describe("JSON to SQLite migration", () => { }), ) - const stats = await JsonMigration.run(sqlite) + const stats = await JsonMigration.run(db) expect(stats?.parts).toBe(1) - const db = drizzle({ client: sqlite }) const parts = db.select().from(PartTable).all() expect(parts.length).toBe(1) expect(parts[0].id).toBe(PartID.make("prt_from_filename")) // Uses filename, not JSON id @@ -392,7 +386,7 @@ describe("JSON to SQLite migration", () => { }), ) - const stats = await JsonMigration.run(sqlite) + const stats = await JsonMigration.run(db) expect(stats?.sessions).toBe(0) }) @@ -420,11 +414,10 @@ describe("JSON to SQLite migration", () => { time: { created: 1700000000000, updated: 1700000001000 }, }) - const stats = await JsonMigration.run(sqlite) + const stats = await JsonMigration.run(db) expect(stats?.sessions).toBe(1) - const db = drizzle({ client: sqlite }) const sessions = db.select().from(SessionTable).all() expect(sessions.length).toBe(1) expect(sessions[0].id).toBe(SessionID.make("ses_migrated")) @@ -452,11 +445,10 @@ describe("JSON to SQLite migration", () => { }), ) - const stats = await JsonMigration.run(sqlite) + const stats = await JsonMigration.run(db) expect(stats?.sessions).toBe(1) - const db = drizzle({ client: sqlite }) const sessions = db.select().from(SessionTable).all() expect(sessions.length).toBe(1) expect(sessions[0].id).toBe(SessionID.make("ses_from_filename")) // Uses filename, not JSON id @@ -471,10 +463,9 @@ describe("JSON to SQLite migration", () => { sandboxes: [], }) - await JsonMigration.run(sqlite) - await JsonMigration.run(sqlite) + await JsonMigration.run(db) + await JsonMigration.run(db) - const db = drizzle({ client: sqlite }) const projects = db.select().from(ProjectTable).all() expect(projects.length).toBe(1) // Still only 1 due to onConflictDoNothing }) @@ -507,11 +498,10 @@ describe("JSON to SQLite migration", () => { ]), ) - const stats = await JsonMigration.run(sqlite) + const stats = await JsonMigration.run(db) expect(stats?.todos).toBe(2) - const db = drizzle({ client: sqlite }) const todos = db.select().from(TodoTable).orderBy(TodoTable.position).all() expect(todos.length).toBe(2) expect(todos[0].content).toBe("First todo") @@ -540,9 +530,8 @@ describe("JSON to SQLite migration", () => { ]), ) - await JsonMigration.run(sqlite) + await JsonMigration.run(db) - const db = drizzle({ client: sqlite }) const todos = db.select().from(TodoTable).orderBy(TodoTable.position).all() expect(todos.length).toBe(3) @@ -570,11 +559,10 @@ describe("JSON to SQLite migration", () => { ] await Bun.write(path.join(storageDir, "permission", "proj_test123abc.json"), JSON.stringify(permissionData)) - const stats = await JsonMigration.run(sqlite) + const stats = await JsonMigration.run(db) expect(stats?.permissions).toBe(1) - const db = drizzle({ client: sqlite }) const permissions = db.select().from(PermissionTable).all() expect(permissions.length).toBe(1) expect(permissions[0].project_id).toBe("proj_test123abc") @@ -600,11 +588,10 @@ describe("JSON to SQLite migration", () => { }), ) - const stats = await JsonMigration.run(sqlite) + const stats = await JsonMigration.run(db) expect(stats?.shares).toBe(1) - const db = drizzle({ client: sqlite }) const shares = db.select().from(SessionShareTable).all() expect(shares.length).toBe(1) expect(shares[0].session_id).toBe("ses_test456def") @@ -616,7 +603,7 @@ describe("JSON to SQLite migration", () => { test("returns empty stats when storage directory does not exist", async () => { await fs.rm(storageDir, { recursive: true, force: true }) - const stats = await JsonMigration.run(sqlite) + const stats = await JsonMigration.run(db) expect(stats.projects).toBe(0) expect(stats.sessions).toBe(0) @@ -637,12 +624,11 @@ describe("JSON to SQLite migration", () => { }) await Bun.write(path.join(storageDir, "project", "broken.json"), "{ invalid json") - const stats = await JsonMigration.run(sqlite) + const stats = await JsonMigration.run(db) expect(stats.projects).toBe(1) expect(stats.errors.some((x) => x.includes("failed to read") && x.includes("broken.json"))).toBe(true) - const db = drizzle({ client: sqlite }) const projects = db.select().from(ProjectTable).all() expect(projects.length).toBe(1) expect(projects[0].id).toBe(ProjectID.make("proj_test123abc")) @@ -666,10 +652,9 @@ describe("JSON to SQLite migration", () => { ]), ) - const stats = await JsonMigration.run(sqlite) + const stats = await JsonMigration.run(db) expect(stats.todos).toBe(2) - const db = drizzle({ client: sqlite }) const todos = db.select().from(TodoTable).orderBy(TodoTable.position).all() expect(todos.length).toBe(2) expect(todos[0].content).toBe("keep-0") @@ -714,13 +699,12 @@ describe("JSON to SQLite migration", () => { JSON.stringify({ id: "share_missing", secret: "secret", url: "https://missing.example.com" }), ) - const stats = await JsonMigration.run(sqlite) + const stats = await JsonMigration.run(db) expect(stats.todos).toBe(1) expect(stats.permissions).toBe(1) expect(stats.shares).toBe(1) - const db = drizzle({ client: sqlite }) expect(db.select().from(TodoTable).all().length).toBe(1) expect(db.select().from(PermissionTable).all().length).toBe(1) expect(db.select().from(SessionShareTable).all().length).toBe(1) @@ -823,7 +807,7 @@ describe("JSON to SQLite migration", () => { ) await Bun.write(path.join(storageDir, "session_share", "ses_broken.json"), "{ nope") - const stats = await JsonMigration.run(sqlite) + const stats = await JsonMigration.run(db) // Projects: proj_test123abc (valid), proj_missing_id (now derives id from filename) // Sessions: ses_test456def (valid), ses_missing_project (now uses dir path), @@ -837,7 +821,6 @@ describe("JSON to SQLite migration", () => { expect(stats.shares).toBe(1) expect(stats.errors.length).toBeGreaterThanOrEqual(6) - const db = drizzle({ client: sqlite }) expect(db.select().from(ProjectTable).all().length).toBe(2) expect(db.select().from(SessionTable).all().length).toBe(3) expect(db.select().from(MessageTable).all().length).toBe(1) diff --git a/packages/opencode/test/tool/task.test.ts b/packages/opencode/test/tool/task.test.ts index fe936a242aaf..8ebfa59d2313 100644 --- a/packages/opencode/test/tool/task.test.ts +++ b/packages/opencode/test/tool/task.test.ts @@ -1,50 +1,412 @@ -import { Effect } from "effect" -import { afterEach, describe, expect, test } from "bun:test" +import { afterEach, describe, expect } from "bun:test" +import { Effect, Layer } from "effect" import { Agent } from "../../src/agent/agent" +import { Config } from "../../src/config/config" +import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner" import { Instance } from "../../src/project/instance" -import { TaskDescription } from "../../src/tool/task" -import { tmpdir } from "../fixture/fixture" +import { Session } from "../../src/session" +import { MessageV2 } from "../../src/session/message-v2" +import { SessionPrompt } from "../../src/session/prompt" +import { MessageID, PartID } from "../../src/session/schema" +import { ModelID, ProviderID } from "../../src/provider/schema" +import { TaskDescription, TaskTool } from "../../src/tool/task" +import { provideTmpdirInstance } from "../fixture/fixture" +import { testEffect } from "../lib/effect" afterEach(async () => { await Instance.disposeAll() }) +const ref = { + providerID: ProviderID.make("test"), + modelID: ModelID.make("test-model"), +} + +const it = testEffect( + Layer.mergeAll(Agent.defaultLayer, Config.defaultLayer, CrossSpawnSpawner.defaultLayer, Session.defaultLayer), +) + +const seed = Effect.fn("TaskToolTest.seed")(function* (title = "Pinned") { + const session = yield* Session.Service + const chat = yield* session.create({ title }) + const user = yield* session.updateMessage({ + id: MessageID.ascending(), + role: "user", + sessionID: chat.id, + agent: "build", + model: ref, + time: { created: Date.now() }, + }) + const assistant: MessageV2.Assistant = { + id: MessageID.ascending(), + role: "assistant", + parentID: user.id, + sessionID: chat.id, + mode: "build", + agent: "build", + cost: 0, + path: { cwd: "/tmp", root: "/tmp" }, + tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }, + modelID: ref.modelID, + providerID: ref.providerID, + time: { created: Date.now() }, + } + yield* session.updateMessage(assistant) + return { chat, assistant } +}) + +function reply(input: Parameters[0], text: string): MessageV2.WithParts { + const id = MessageID.ascending() + return { + info: { + id, + role: "assistant", + parentID: input.messageID ?? MessageID.ascending(), + sessionID: input.sessionID, + mode: input.agent ?? "general", + agent: input.agent ?? "general", + cost: 0, + path: { cwd: "/tmp", root: "/tmp" }, + tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }, + modelID: input.model?.modelID ?? ref.modelID, + providerID: input.model?.providerID ?? ref.providerID, + time: { created: Date.now() }, + finish: "stop", + }, + parts: [ + { + id: PartID.ascending(), + messageID: id, + sessionID: input.sessionID, + type: "text", + text, + }, + ], + } +} + describe("tool.task", () => { - test("description sorts subagents by name and is stable across calls", async () => { - await using tmp = await tmpdir({ - config: { - agent: { - zebra: { - description: "Zebra agent", - mode: "subagent", + it.live("description sorts subagents by name and is stable across calls", () => + provideTmpdirInstance( + () => + Effect.gen(function* () { + const agent = yield* Agent.Service + const build = yield* agent.get("build") + const first = yield* TaskDescription(build) + const second = yield* TaskDescription(build) + + expect(first).toBe(second) + + const alpha = first.indexOf("- alpha: Alpha agent") + const explore = first.indexOf("- explore:") + const general = first.indexOf("- general:") + const zebra = first.indexOf("- zebra: Zebra agent") + + expect(alpha).toBeGreaterThan(-1) + expect(explore).toBeGreaterThan(alpha) + expect(general).toBeGreaterThan(explore) + expect(zebra).toBeGreaterThan(general) + }), + { + config: { + agent: { + zebra: { + description: "Zebra agent", + mode: "subagent", + }, + alpha: { + description: "Alpha agent", + mode: "subagent", + }, }, - alpha: { - description: "Alpha agent", - mode: "subagent", + }, + }, + ), + ) + + it.live("description hides denied subagents for the caller", () => + provideTmpdirInstance( + () => + Effect.gen(function* () { + const agent = yield* Agent.Service + const build = yield* agent.get("build") + const description = yield* TaskDescription(build) + + expect(description).toContain("- alpha: Alpha agent") + expect(description).not.toContain("- zebra: Zebra agent") + }), + { + config: { + permission: { + task: { + "*": "allow", + zebra: "deny", + }, + }, + agent: { + zebra: { + description: "Zebra agent", + mode: "subagent", + }, + alpha: { + description: "Alpha agent", + mode: "subagent", + }, }, }, }, - }) - - await Instance.provide({ - directory: tmp.path, - fn: async () => { - const agent = { name: "build", mode: "primary" as const, permission: [], options: {} } - const first = await Effect.runPromise(TaskDescription(agent)) - const second = await Effect.runPromise(TaskDescription(agent)) - - expect(first).toBe(second) - - const alpha = first.indexOf("- alpha: Alpha agent") - const explore = first.indexOf("- explore:") - const general = first.indexOf("- general:") - const zebra = first.indexOf("- zebra: Zebra agent") - - expect(alpha).toBeGreaterThan(-1) - expect(explore).toBeGreaterThan(alpha) - expect(general).toBeGreaterThan(explore) - expect(zebra).toBeGreaterThan(general) + ), + ) + + it.live("execute resumes an existing task session from task_id", () => + provideTmpdirInstance(() => + Effect.gen(function* () { + const sessions = yield* Session.Service + const { chat, assistant } = yield* seed() + const child = yield* sessions.create({ parentID: chat.id, title: "Existing child" }) + const tool = yield* TaskTool + const def = yield* Effect.promise(() => tool.init()) + const resolve = SessionPrompt.resolvePromptParts + const prompt = SessionPrompt.prompt + let seen: Parameters[0] | undefined + + SessionPrompt.resolvePromptParts = async (template) => [{ type: "text", text: template }] + SessionPrompt.prompt = async (input) => { + seen = input + return reply(input, "resumed") + } + yield* Effect.addFinalizer(() => + Effect.sync(() => { + SessionPrompt.resolvePromptParts = resolve + SessionPrompt.prompt = prompt + }), + ) + + const result = yield* Effect.promise(() => + def.execute( + { + description: "inspect bug", + prompt: "look into the cache key path", + subagent_type: "general", + task_id: child.id, + }, + { + sessionID: chat.id, + messageID: assistant.id, + agent: "build", + abort: new AbortController().signal, + messages: [], + metadata() {}, + ask: async () => {}, + }, + ), + ) + + const kids = yield* sessions.children(chat.id) + expect(kids).toHaveLength(1) + expect(kids[0]?.id).toBe(child.id) + expect(result.metadata.sessionId).toBe(child.id) + expect(result.output).toContain(`task_id: ${child.id}`) + expect(seen?.sessionID).toBe(child.id) + }), + ), + ) + + it.live("execute asks by default and skips checks when bypassed", () => + provideTmpdirInstance(() => + Effect.gen(function* () { + const { chat, assistant } = yield* seed() + const tool = yield* TaskTool + const def = yield* Effect.promise(() => tool.init()) + const resolve = SessionPrompt.resolvePromptParts + const prompt = SessionPrompt.prompt + const calls: unknown[] = [] + + SessionPrompt.resolvePromptParts = async (template) => [{ type: "text", text: template }] + SessionPrompt.prompt = async (input) => reply(input, "done") + yield* Effect.addFinalizer(() => + Effect.sync(() => { + SessionPrompt.resolvePromptParts = resolve + SessionPrompt.prompt = prompt + }), + ) + + const exec = (extra?: { bypassAgentCheck?: boolean }) => + Effect.promise(() => + def.execute( + { + description: "inspect bug", + prompt: "look into the cache key path", + subagent_type: "general", + }, + { + sessionID: chat.id, + messageID: assistant.id, + agent: "build", + abort: new AbortController().signal, + extra, + messages: [], + metadata() {}, + ask: async (input) => { + calls.push(input) + }, + }, + ), + ) + + yield* exec() + yield* exec({ bypassAgentCheck: true }) + + expect(calls).toHaveLength(1) + expect(calls[0]).toEqual({ + permission: "task", + patterns: ["general"], + always: ["*"], + metadata: { + description: "inspect bug", + subagent_type: "general", + }, + }) + }), + ), + ) + + it.live("execute creates a child when task_id does not exist", () => + provideTmpdirInstance(() => + Effect.gen(function* () { + const sessions = yield* Session.Service + const { chat, assistant } = yield* seed() + const tool = yield* TaskTool + const def = yield* Effect.promise(() => tool.init()) + const resolve = SessionPrompt.resolvePromptParts + const prompt = SessionPrompt.prompt + let seen: Parameters[0] | undefined + + SessionPrompt.resolvePromptParts = async (template) => [{ type: "text", text: template }] + SessionPrompt.prompt = async (input) => { + seen = input + return reply(input, "created") + } + yield* Effect.addFinalizer(() => + Effect.sync(() => { + SessionPrompt.resolvePromptParts = resolve + SessionPrompt.prompt = prompt + }), + ) + + const result = yield* Effect.promise(() => + def.execute( + { + description: "inspect bug", + prompt: "look into the cache key path", + subagent_type: "general", + task_id: "ses_missing", + }, + { + sessionID: chat.id, + messageID: assistant.id, + agent: "build", + abort: new AbortController().signal, + messages: [], + metadata() {}, + ask: async () => {}, + }, + ), + ) + + const kids = yield* sessions.children(chat.id) + expect(kids).toHaveLength(1) + expect(kids[0]?.id).toBe(result.metadata.sessionId) + expect(result.metadata.sessionId).not.toBe("ses_missing") + expect(result.output).toContain(`task_id: ${result.metadata.sessionId}`) + expect(seen?.sessionID).toBe(result.metadata.sessionId) + }), + ), + ) + + it.live("execute shapes child permissions for task, todowrite, and primary tools", () => + provideTmpdirInstance( + () => + Effect.gen(function* () { + const sessions = yield* Session.Service + const { chat, assistant } = yield* seed() + const tool = yield* TaskTool + const def = yield* Effect.promise(() => tool.init()) + const resolve = SessionPrompt.resolvePromptParts + const prompt = SessionPrompt.prompt + let seen: Parameters[0] | undefined + + SessionPrompt.resolvePromptParts = async (template) => [{ type: "text", text: template }] + SessionPrompt.prompt = async (input) => { + seen = input + return reply(input, "done") + } + yield* Effect.addFinalizer(() => + Effect.sync(() => { + SessionPrompt.resolvePromptParts = resolve + SessionPrompt.prompt = prompt + }), + ) + + const result = yield* Effect.promise(() => + def.execute( + { + description: "inspect bug", + prompt: "look into the cache key path", + subagent_type: "reviewer", + }, + { + sessionID: chat.id, + messageID: assistant.id, + agent: "build", + abort: new AbortController().signal, + messages: [], + metadata() {}, + ask: async () => {}, + }, + ), + ) + + const child = yield* sessions.get(result.metadata.sessionId) + expect(child.parentID).toBe(chat.id) + expect(child.permission).toEqual([ + { + permission: "todowrite", + pattern: "*", + action: "deny", + }, + { + permission: "bash", + pattern: "*", + action: "allow", + }, + { + permission: "read", + pattern: "*", + action: "allow", + }, + ]) + expect(seen?.tools).toEqual({ + todowrite: false, + bash: false, + read: false, + }) + }), + { + config: { + agent: { + reviewer: { + mode: "subagent", + permission: { + task: "allow", + }, + }, + }, + experimental: { + primary_tools: ["bash", "read"], + }, + }, }, - }) - }) + ), + ) }) diff --git a/packages/opencode/test/tool/webfetch.test.ts b/packages/opencode/test/tool/webfetch.test.ts index 5233f10816b5..00e9dcc96cef 100644 --- a/packages/opencode/test/tool/webfetch.test.ts +++ b/packages/opencode/test/tool/webfetch.test.ts @@ -17,58 +17,25 @@ const ctx = { ask: async () => {}, } -type TimerID = ReturnType - -async function withFetch( - mockFetch: (input: string | URL | Request, init?: RequestInit) => Promise, - fn: () => Promise, -) { - const originalFetch = globalThis.fetch - globalThis.fetch = mockFetch as unknown as typeof fetch - try { - await fn() - } finally { - globalThis.fetch = originalFetch - } -} - -async function withTimers(fn: (state: { ids: TimerID[]; cleared: TimerID[] }) => Promise) { - const set = globalThis.setTimeout - const clear = globalThis.clearTimeout - const ids: TimerID[] = [] - const cleared: TimerID[] = [] - - globalThis.setTimeout = ((...args: Parameters) => { - const id = set(...args) - ids.push(id) - return id - }) as typeof setTimeout - - globalThis.clearTimeout = ((id?: TimerID) => { - if (id !== undefined) cleared.push(id) - return clear(id) - }) as typeof clearTimeout - - try { - await fn({ ids, cleared }) - } finally { - ids.forEach(clear) - globalThis.setTimeout = set - globalThis.clearTimeout = clear - } +async function withFetch(fetch: (req: Request) => Response | Promise, fn: (url: URL) => Promise) { + using server = Bun.serve({ port: 0, fetch }) + await fn(server.url) } describe("tool.webfetch", () => { test("returns image responses as file attachments", async () => { const bytes = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]) await withFetch( - async () => new Response(bytes, { status: 200, headers: { "content-type": "IMAGE/PNG; charset=binary" } }), - async () => { + () => new Response(bytes, { status: 200, headers: { "content-type": "IMAGE/PNG; charset=binary" } }), + async (url) => { await Instance.provide({ directory: projectRoot, fn: async () => { const webfetch = await WebFetchTool.init() - const result = await webfetch.execute({ url: "https://example.com/image.png", format: "markdown" }, ctx) + const result = await webfetch.execute( + { url: new URL("/image.png", url).toString(), format: "markdown" }, + ctx, + ) expect(result.output).toBe("Image fetched successfully") expect(result.attachments).toBeDefined() expect(result.attachments?.length).toBe(1) @@ -87,17 +54,17 @@ describe("tool.webfetch", () => { test("keeps svg as text output", async () => { const svg = 'hello' await withFetch( - async () => + () => new Response(svg, { status: 200, headers: { "content-type": "image/svg+xml; charset=UTF-8" }, }), - async () => { + async (url) => { await Instance.provide({ directory: projectRoot, fn: async () => { const webfetch = await WebFetchTool.init() - const result = await webfetch.execute({ url: "https://example.com/image.svg", format: "html" }, ctx) + const result = await webfetch.execute({ url: new URL("/image.svg", url).toString(), format: "html" }, ctx) expect(result.output).toContain(" { test("keeps text responses as text output", async () => { await withFetch( - async () => + () => new Response("hello from webfetch", { status: 200, headers: { "content-type": "text/plain; charset=utf-8" }, }), - async () => { + async (url) => { await Instance.provide({ directory: projectRoot, fn: async () => { const webfetch = await WebFetchTool.init() - const result = await webfetch.execute({ url: "https://example.com/file.txt", format: "text" }, ctx) + const result = await webfetch.execute({ url: new URL("/file.txt", url).toString(), format: "text" }, ctx) expect(result.output).toBe("hello from webfetch") expect(result.attachments).toBeUndefined() }, @@ -126,28 +93,4 @@ describe("tool.webfetch", () => { }, ) }) - - test("clears timeout when fetch rejects", async () => { - await withTimers(async ({ ids, cleared }) => { - await withFetch( - async () => { - throw new Error("boom") - }, - async () => { - await Instance.provide({ - directory: projectRoot, - fn: async () => { - const webfetch = await WebFetchTool.init() - await expect( - webfetch.execute({ url: "https://example.com/file.txt", format: "text" }, ctx), - ).rejects.toThrow("boom") - }, - }) - }, - ) - - expect(ids).toHaveLength(1) - expect(cleared).toContain(ids[0]) - }) - }) }) diff --git a/packages/plugin/package.json b/packages/plugin/package.json index 6e3fc8348aa0..0b52bbd47cf7 100644 --- a/packages/plugin/package.json +++ b/packages/plugin/package.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/package.json", "name": "@opencode-ai/plugin", - "version": "1.4.0", + "version": "1.4.1", "type": "module", "license": "MIT", "scripts": { diff --git a/packages/sdk/js/package.json b/packages/sdk/js/package.json index c33b561d1861..a3aa709a712e 100644 --- a/packages/sdk/js/package.json +++ b/packages/sdk/js/package.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/package.json", "name": "@opencode-ai/sdk", - "version": "1.4.0", + "version": "1.4.1", "type": "module", "license": "MIT", "scripts": { diff --git a/packages/sdk/js/src/v2/gen/types.gen.ts b/packages/sdk/js/src/v2/gen/types.gen.ts index 0a9aa4358ec5..e7098f264315 100644 --- a/packages/sdk/js/src/v2/gen/types.gen.ts +++ b/packages/sdk/js/src/v2/gen/types.gen.ts @@ -1250,6 +1250,29 @@ export type ProviderConfig = { env?: Array id?: string npm?: string + whitelist?: Array + blacklist?: Array + options?: { + apiKey?: string + baseURL?: string + /** + * GitHub Enterprise URL for copilot authentication + */ + enterpriseUrl?: string + /** + * Enable promptCacheKey for this provider (default false) + */ + setCacheKey?: boolean + /** + * Timeout in milliseconds for requests to this provider. Default is 300000 (5 minutes). Set to false to disable timeout. + */ + timeout?: number | false + /** + * Timeout in milliseconds between streamed SSE chunks for this provider. If no chunk arrives within this window, the request is aborted. + */ + chunkTimeout?: number + [key: string]: unknown | string | boolean | number | false | number | undefined + } models?: { [key: string]: { id?: string @@ -1288,16 +1311,16 @@ export type ProviderConfig = { } experimental?: boolean status?: "alpha" | "beta" | "deprecated" + provider?: { + npm?: string + api?: string + } options?: { [key: string]: unknown } headers?: { [key: string]: string } - provider?: { - npm?: string - api?: string - } /** * Variant-specific configuration */ @@ -1312,29 +1335,6 @@ export type ProviderConfig = { } } } - whitelist?: Array - blacklist?: Array - options?: { - apiKey?: string - baseURL?: string - /** - * GitHub Enterprise URL for copilot authentication - */ - enterpriseUrl?: string - /** - * Enable promptCacheKey for this provider (default false) - */ - setCacheKey?: boolean - /** - * Timeout in milliseconds for requests to this provider. Default is 300000 (5 minutes). Set to false to disable timeout. - */ - timeout?: number | false - /** - * Timeout in milliseconds between streamed SSE chunks for this provider. If no chunk arrives within this window, the request is aborted. - */ - chunkTimeout?: number - [key: string]: unknown | string | boolean | number | false | number | undefined - } } export type McpLocalConfig = { @@ -1573,6 +1573,67 @@ export type Config = { tools?: { [key: string]: boolean } + /** + * Shell script hooks for lifecycle events + */ + hooks?: { + PreToolUse?: Array<{ + /** + * Shell command or path to script + */ + command: string + /** + * Tool name glob pattern (PreToolUse/PostToolUse only) + */ + matcher?: string + /** + * Timeout in ms (default: 10000) + */ + timeout?: number + }> + PostToolUse?: Array<{ + /** + * Shell command or path to script + */ + command: string + /** + * Tool name glob pattern (PreToolUse/PostToolUse only) + */ + matcher?: string + /** + * Timeout in ms (default: 10000) + */ + timeout?: number + }> + SessionStart?: Array<{ + /** + * Shell command or path to script + */ + command: string + /** + * Tool name glob pattern (PreToolUse/PostToolUse only) + */ + matcher?: string + /** + * Timeout in ms (default: 10000) + */ + timeout?: number + }> + Notification?: Array<{ + /** + * Shell command or path to script + */ + command: string + /** + * Tool name glob pattern (PreToolUse/PostToolUse only) + */ + matcher?: string + /** + * Timeout in ms (default: 10000) + */ + timeout?: number + }> + } enterprise?: { /** * Enterprise URL @@ -1593,6 +1654,20 @@ export type Config = { */ reserved?: number } + memory?: { + /** + * Enable or disable memory system + */ + enabled?: boolean + /** + * Enable automatic memory extraction from sessions + */ + auto_extract?: boolean + /** + * Maximum number of lines to load from MEMORY.md + */ + max_memory_lines?: number + } experimental?: { disable_paste_summary?: boolean /** @@ -3936,7 +4011,10 @@ export type SessionShellResponses = { /** * Created message */ - 200: AssistantMessage + 200: { + info: Message + parts: Array + } } export type SessionShellResponse = SessionShellResponses[keyof SessionShellResponses] @@ -4212,68 +4290,7 @@ export type ProviderListResponses = { * List of providers */ 200: { - all: Array<{ - api?: string - name: string - env: Array - id: string - npm?: string - models: { - [key: string]: { - id: string - name: string - family?: string - release_date: string - attachment: boolean - reasoning: boolean - temperature: boolean - tool_call: boolean - interleaved?: - | true - | { - field: "reasoning_content" | "reasoning_details" - } - cost?: { - input: number - output: number - cache_read?: number - cache_write?: number - context_over_200k?: { - input: number - output: number - cache_read?: number - cache_write?: number - } - } - limit: { - context: number - input?: number - output: number - } - modalities?: { - input: Array<"text" | "audio" | "image" | "video" | "pdf"> - output: Array<"text" | "audio" | "image" | "video" | "pdf"> - } - experimental?: boolean - status?: "alpha" | "beta" | "deprecated" - options: { - [key: string]: unknown - } - headers?: { - [key: string]: string - } - provider?: { - npm?: string - api?: string - } - variants?: { - [key: string]: { - [key: string]: unknown - } - } - } - } - }> + all: Array default: { [key: string]: string } diff --git a/packages/sdk/openapi.json b/packages/sdk/openapi.json index 207b400a7dea..a0672df2d764 100644 --- a/packages/sdk/openapi.json +++ b/packages/sdk/openapi.json @@ -4098,7 +4098,19 @@ "content": { "application/json": { "schema": { - "$ref": "#/components/schemas/AssistantMessage" + "type": "object", + "properties": { + "info": { + "$ref": "#/components/schemas/Message" + }, + "parts": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Part" + } + } + }, + "required": ["info", "parts"] } } } @@ -4790,211 +4802,7 @@ "all": { "type": "array", "items": { - "type": "object", - "properties": { - "api": { - "type": "string" - }, - "name": { - "type": "string" - }, - "env": { - "type": "array", - "items": { - "type": "string" - } - }, - "id": { - "type": "string" - }, - "npm": { - "type": "string" - }, - "models": { - "type": "object", - "propertyNames": { - "type": "string" - }, - "additionalProperties": { - "type": "object", - "properties": { - "id": { - "type": "string" - }, - "name": { - "type": "string" - }, - "family": { - "type": "string" - }, - "release_date": { - "type": "string" - }, - "attachment": { - "type": "boolean" - }, - "reasoning": { - "type": "boolean" - }, - "temperature": { - "type": "boolean" - }, - "tool_call": { - "type": "boolean" - }, - "interleaved": { - "anyOf": [ - { - "type": "boolean", - "const": true - }, - { - "type": "object", - "properties": { - "field": { - "type": "string", - "enum": ["reasoning_content", "reasoning_details"] - } - }, - "required": ["field"], - "additionalProperties": false - } - ] - }, - "cost": { - "type": "object", - "properties": { - "input": { - "type": "number" - }, - "output": { - "type": "number" - }, - "cache_read": { - "type": "number" - }, - "cache_write": { - "type": "number" - }, - "context_over_200k": { - "type": "object", - "properties": { - "input": { - "type": "number" - }, - "output": { - "type": "number" - }, - "cache_read": { - "type": "number" - }, - "cache_write": { - "type": "number" - } - }, - "required": ["input", "output"] - } - }, - "required": ["input", "output"] - }, - "limit": { - "type": "object", - "properties": { - "context": { - "type": "number" - }, - "input": { - "type": "number" - }, - "output": { - "type": "number" - } - }, - "required": ["context", "output"] - }, - "modalities": { - "type": "object", - "properties": { - "input": { - "type": "array", - "items": { - "type": "string", - "enum": ["text", "audio", "image", "video", "pdf"] - } - }, - "output": { - "type": "array", - "items": { - "type": "string", - "enum": ["text", "audio", "image", "video", "pdf"] - } - } - }, - "required": ["input", "output"] - }, - "experimental": { - "type": "boolean" - }, - "status": { - "type": "string", - "enum": ["alpha", "beta", "deprecated"] - }, - "options": { - "type": "object", - "propertyNames": { - "type": "string" - }, - "additionalProperties": {} - }, - "headers": { - "type": "object", - "propertyNames": { - "type": "string" - }, - "additionalProperties": { - "type": "string" - } - }, - "provider": { - "type": "object", - "properties": { - "npm": { - "type": "string" - }, - "api": { - "type": "string" - } - } - }, - "variants": { - "type": "object", - "propertyNames": { - "type": "string" - }, - "additionalProperties": { - "type": "object", - "propertyNames": { - "type": "string" - }, - "additionalProperties": {} - } - } - }, - "required": [ - "id", - "name", - "release_date", - "attachment", - "reasoning", - "temperature", - "tool_call", - "limit", - "options" - ] - } - } - }, - "required": ["name", "env", "id", "models"] + "$ref": "#/components/schemas/Provider" } }, "default": { @@ -10788,6 +10596,60 @@ "npm": { "type": "string" }, + "whitelist": { + "type": "array", + "items": { + "type": "string" + } + }, + "blacklist": { + "type": "array", + "items": { + "type": "string" + } + }, + "options": { + "type": "object", + "properties": { + "apiKey": { + "type": "string" + }, + "baseURL": { + "type": "string" + }, + "enterpriseUrl": { + "description": "GitHub Enterprise URL for copilot authentication", + "type": "string" + }, + "setCacheKey": { + "description": "Enable promptCacheKey for this provider (default false)", + "type": "boolean" + }, + "timeout": { + "description": "Timeout in milliseconds for requests to this provider. Default is 300000 (5 minutes). Set to false to disable timeout.", + "anyOf": [ + { + "description": "Timeout in milliseconds for requests to this provider. Default is 300000 (5 minutes). Set to false to disable timeout.", + "type": "integer", + "exclusiveMinimum": 0, + "maximum": 9007199254740991 + }, + { + "description": "Disable timeout for this provider entirely.", + "type": "boolean", + "const": false + } + ] + }, + "chunkTimeout": { + "description": "Timeout in milliseconds between streamed SSE chunks for this provider. If no chunk arrives within this window, the request is aborted.", + "type": "integer", + "exclusiveMinimum": 0, + "maximum": 9007199254740991 + } + }, + "additionalProperties": {} + }, "models": { "type": "object", "propertyNames": { @@ -10917,6 +10779,17 @@ "type": "string", "enum": ["alpha", "beta", "deprecated"] }, + "provider": { + "type": "object", + "properties": { + "npm": { + "type": "string" + }, + "api": { + "type": "string" + } + } + }, "options": { "type": "object", "propertyNames": { @@ -10933,17 +10806,6 @@ "type": "string" } }, - "provider": { - "type": "object", - "properties": { - "npm": { - "type": "string" - }, - "api": { - "type": "string" - } - } - }, "variants": { "description": "Variant-specific configuration", "type": "object", @@ -10963,60 +10825,6 @@ } } } - }, - "whitelist": { - "type": "array", - "items": { - "type": "string" - } - }, - "blacklist": { - "type": "array", - "items": { - "type": "string" - } - }, - "options": { - "type": "object", - "properties": { - "apiKey": { - "type": "string" - }, - "baseURL": { - "type": "string" - }, - "enterpriseUrl": { - "description": "GitHub Enterprise URL for copilot authentication", - "type": "string" - }, - "setCacheKey": { - "description": "Enable promptCacheKey for this provider (default false)", - "type": "boolean" - }, - "timeout": { - "description": "Timeout in milliseconds for requests to this provider. Default is 300000 (5 minutes). Set to false to disable timeout.", - "anyOf": [ - { - "description": "Timeout in milliseconds for requests to this provider. Default is 300000 (5 minutes). Set to false to disable timeout.", - "type": "integer", - "exclusiveMinimum": 0, - "maximum": 9007199254740991 - }, - { - "description": "Disable timeout for this provider entirely.", - "type": "boolean", - "const": false - } - ] - }, - "chunkTimeout": { - "description": "Timeout in milliseconds between streamed SSE chunks for this provider. If no chunk arrives within this window, the request is aborted.", - "type": "integer", - "exclusiveMinimum": 0, - "maximum": 9007199254740991 - } - }, - "additionalProperties": {} } }, "additionalProperties": false diff --git a/packages/slack/package.json b/packages/slack/package.json index 0e7752527327..4e3e54800be5 100644 --- a/packages/slack/package.json +++ b/packages/slack/package.json @@ -1,6 +1,6 @@ { "name": "@opencode-ai/slack", - "version": "1.4.0", + "version": "1.4.1", "type": "module", "license": "MIT", "scripts": { diff --git a/packages/ui/package.json b/packages/ui/package.json index 3693175b8ac2..8de6ea0d43bf 100644 --- a/packages/ui/package.json +++ b/packages/ui/package.json @@ -1,6 +1,6 @@ { "name": "@opencode-ai/ui", - "version": "1.4.0", + "version": "1.4.1", "type": "module", "license": "MIT", "exports": { diff --git a/packages/ui/src/components/apply-patch-file.test.ts b/packages/ui/src/components/apply-patch-file.test.ts new file mode 100644 index 000000000000..6c5858156477 --- /dev/null +++ b/packages/ui/src/components/apply-patch-file.test.ts @@ -0,0 +1,43 @@ +import { describe, expect, test } from "bun:test" +import { patchFiles } from "./apply-patch-file" +import { text } from "./session-diff" + +describe("apply patch file", () => { + test("parses patch metadata from the server", () => { + const file = patchFiles([ + { + filePath: "/tmp/a.ts", + relativePath: "a.ts", + type: "update", + patch: + "Index: a.ts\n===================================================================\n--- a.ts\t\n+++ a.ts\t\n@@ -1,2 +1,2 @@\n one\n-two\n+three\n", + additions: 1, + deletions: 1, + }, + ])[0] + + expect(file).toBeDefined() + expect(file?.view.fileDiff.name).toBe("a.ts") + expect(text(file!.view, "deletions")).toBe("one\ntwo\n") + expect(text(file!.view, "additions")).toBe("one\nthree\n") + }) + + test("keeps legacy before and after payloads working", () => { + const file = patchFiles([ + { + filePath: "/tmp/a.ts", + relativePath: "a.ts", + type: "update", + before: "one\n", + after: "two\n", + additions: 1, + deletions: 1, + }, + ])[0] + + expect(file).toBeDefined() + expect(file?.view.patch).toContain("@@ -1,1 +1,1 @@") + expect(text(file!.view, "deletions")).toBe("one\n") + expect(text(file!.view, "additions")).toBe("two\n") + }) +}) diff --git a/packages/ui/src/components/apply-patch-file.ts b/packages/ui/src/components/apply-patch-file.ts new file mode 100644 index 000000000000..8e0c54082607 --- /dev/null +++ b/packages/ui/src/components/apply-patch-file.ts @@ -0,0 +1,78 @@ +import { normalize, type ViewDiff } from "./session-diff" + +type Kind = "add" | "update" | "delete" | "move" + +type Raw = { + filePath?: string + relativePath?: string + type?: Kind + patch?: string + diff?: string + before?: string + after?: string + additions?: number + deletions?: number + movePath?: string +} + +export type ApplyPatchFile = { + filePath: string + relativePath: string + type: Kind + additions: number + deletions: number + movePath?: string + view: ViewDiff +} + +function kind(value: unknown) { + if (value === "add" || value === "update" || value === "delete" || value === "move") return value +} + +function status(type: Kind): "added" | "deleted" | "modified" { + if (type === "add") return "added" + if (type === "delete") return "deleted" + return "modified" +} + +export function patchFile(raw: unknown): ApplyPatchFile | undefined { + if (!raw || typeof raw !== "object") return + + const value = raw as Raw + const type = kind(value.type) + const filePath = typeof value.filePath === "string" ? value.filePath : undefined + const relativePath = typeof value.relativePath === "string" ? value.relativePath : filePath + const patch = typeof value.patch === "string" ? value.patch : typeof value.diff === "string" ? value.diff : undefined + const before = typeof value.before === "string" ? value.before : undefined + const after = typeof value.after === "string" ? value.after : undefined + + if (!type || !filePath || !relativePath) return + if (!patch && before === undefined && after === undefined) return + + const additions = typeof value.additions === "number" ? value.additions : 0 + const deletions = typeof value.deletions === "number" ? value.deletions : 0 + const movePath = typeof value.movePath === "string" ? value.movePath : undefined + + return { + filePath, + relativePath, + type, + additions, + deletions, + movePath, + view: normalize({ + file: relativePath, + patch, + before, + after, + additions, + deletions, + status: status(type), + }), + } +} + +export function patchFiles(raw: unknown) { + if (!Array.isArray(raw)) return [] + return raw.map(patchFile).filter((file): file is ApplyPatchFile => !!file) +} diff --git a/packages/ui/src/components/message-part.tsx b/packages/ui/src/components/message-part.tsx index 3627eca409ad..02bd80ac9c3c 100644 --- a/packages/ui/src/components/message-part.tsx +++ b/packages/ui/src/components/message-part.tsx @@ -54,6 +54,7 @@ import { Spinner } from "./spinner" import { TextShimmer } from "./text-shimmer" import { AnimatedCountList } from "./tool-count-summary" import { ToolStatusTitle } from "./tool-status-title" +import { patchFiles } from "./apply-patch-file" import { animate } from "motion" import { useLocation } from "@solidjs/router" import { attached, inline, kind } from "./message-file" @@ -2014,24 +2015,12 @@ ToolRegistry.register({ }, }) -interface ApplyPatchFile { - filePath: string - relativePath: string - type: "add" | "update" | "delete" | "move" - diff: string - before: string - after: string - additions: number - deletions: number - movePath?: string -} - ToolRegistry.register({ name: "apply_patch", render(props) { const i18n = useI18n() const fileComponent = useFileComponent() - const files = createMemo(() => (props.metadata.files ?? []) as ApplyPatchFile[]) + const files = createMemo(() => patchFiles(props.metadata.files)) const pending = createMemo(() => props.status === "pending" || props.status === "running") const single = createMemo(() => { const list = files() @@ -2137,12 +2126,7 @@ ToolRegistry.register({ - + @@ -2212,12 +2196,7 @@ ToolRegistry.register({ } > - + diff --git a/packages/ui/src/components/session-review.tsx b/packages/ui/src/components/session-review.tsx index 90da853efc1a..4a7205a5dc56 100644 --- a/packages/ui/src/components/session-review.tsx +++ b/packages/ui/src/components/session-review.tsx @@ -65,6 +65,26 @@ export type SessionReviewFocus = { file: string; id: string } type ReviewDiff = (SnapshotFileDiff | VcsFileDiff) & { preloaded?: PreloadMultiFileDiffResult } type Item = ViewDiff & { preloaded?: PreloadMultiFileDiffResult } +function diff(value: unknown): value is ReviewDiff { + if (!value || typeof value !== "object" || Array.isArray(value)) return false + if (!("file" in value) || typeof value.file !== "string") return false + if (!("additions" in value) || typeof value.additions !== "number") return false + if (!("deletions" in value) || typeof value.deletions !== "number") return false + if ("patch" in value && value.patch !== undefined && typeof value.patch !== "string") return false + if ("before" in value && value.before !== undefined && typeof value.before !== "string") return false + if ("after" in value && value.after !== undefined && typeof value.after !== "string") return false + if (!("status" in value) || value.status === undefined) return true + return value.status === "added" || value.status === "deleted" || value.status === "modified" +} + +function list(value: unknown): ReviewDiff[] { + if (Array.isArray(value) && value.every(diff)) return value + if (Array.isArray(value)) return value.filter(diff) + if (diff(value)) return [value] + if (!value || typeof value !== "object") return [] + return Object.values(value).filter(diff) +} + export interface SessionReviewProps { title?: JSX.Element empty?: JSX.Element @@ -157,7 +177,9 @@ export const SessionReview = (props: SessionReviewProps) => { const opened = () => store.opened const open = () => props.open ?? store.open - const items = createMemo(() => props.diffs.map((diff) => ({ ...normalize(diff), preloaded: diff.preloaded }))) + const items = createMemo(() => + list(props.diffs).map((diff) => ({ ...normalize(diff), preloaded: diff.preloaded })), + ) const files = createMemo(() => items().map((diff) => diff.file)) const grouped = createMemo(() => { const next = new Map() diff --git a/packages/ui/src/components/session-turn.css b/packages/ui/src/components/session-turn.css index 53e2b58f45a2..b01343a01d7c 100644 --- a/packages/ui/src/components/session-turn.css +++ b/packages/ui/src/components/session-turn.css @@ -94,9 +94,15 @@ [data-slot="session-turn-diffs-header"] { display: flex; - align-items: baseline; + align-items: center; gap: 8px; + padding-top: 4px; padding-bottom: 12px; + position: sticky; + top: var(--sticky-accordion-top, 0px); + z-index: 20; + background-color: var(--background-stronger); + height: 44px; } [data-slot="session-turn-diffs-label"] { diff --git a/packages/ui/src/components/session-turn.tsx b/packages/ui/src/components/session-turn.tsx index bb699a77e2a4..e891a6febe2f 100644 --- a/packages/ui/src/components/session-turn.tsx +++ b/packages/ui/src/components/session-turn.tsx @@ -447,7 +447,7 @@ export function SessionTurn( setState("expanded", Array.isArray(value) ? value : value ? [value] : [])} > diff --git a/packages/util/package.json b/packages/util/package.json index 8b44dc7ae611..105098595eb1 100644 --- a/packages/util/package.json +++ b/packages/util/package.json @@ -1,6 +1,6 @@ { "name": "@opencode-ai/util", - "version": "1.4.0", + "version": "1.4.1", "private": true, "type": "module", "license": "MIT", diff --git a/packages/web/package.json b/packages/web/package.json index 8f963eedf4a0..de36ca6574a3 100644 --- a/packages/web/package.json +++ b/packages/web/package.json @@ -2,7 +2,7 @@ "name": "@opencode-ai/web", "type": "module", "license": "MIT", - "version": "1.4.0", + "version": "1.4.1", "scripts": { "dev": "astro dev", "dev:remote": "VITE_API_URL=https://api.opencode.ai astro dev", diff --git a/scripts/link-guardrails.sh b/scripts/link-guardrails.sh new file mode 100755 index 000000000000..17234fd91ddc --- /dev/null +++ b/scripts/link-guardrails.sh @@ -0,0 +1,40 @@ +#!/usr/bin/env bash +# link-guardrails.sh — Symlink guardrails profile commands/agents to .opencode/ +# Runs automatically via postinstall to ensure desktop app sees all commands. +set -euo pipefail + +ROOT="$(cd "$(dirname "$0")/.." && pwd)" +PROFILE="$ROOT/packages/guardrails/profile" +CONFIG="$ROOT/.opencode" + +if [ ! -d "$PROFILE/commands" ]; then + echo "[link-guardrails] Profile not found at $PROFILE, skipping" + exit 0 +fi + +mkdir -p "$CONFIG/command" "$CONFIG/agent" + +linked=0 +for cmd in "$PROFILE/commands"/*.md; do + name=$(basename "$cmd") + target="$CONFIG/command/$name" + if [ ! -e "$target" ]; then + ln -s "../../packages/guardrails/profile/commands/$name" "$target" + linked=$((linked + 1)) + fi +done + +for agent in "$PROFILE/agents"/*.md; do + name=$(basename "$agent") + target="$CONFIG/agent/$name" + if [ ! -e "$target" ]; then + ln -s "../../packages/guardrails/profile/agents/$name" "$target" + linked=$((linked + 1)) + fi +done + +if [ "$linked" -gt 0 ]; then + echo "[link-guardrails] Created $linked symlinks" +else + echo "[link-guardrails] All symlinks up to date" +fi diff --git a/scripts/upstream-sync.sh b/scripts/upstream-sync.sh new file mode 100755 index 000000000000..b2b9b1c3988c --- /dev/null +++ b/scripts/upstream-sync.sh @@ -0,0 +1,101 @@ +#!/usr/bin/env bash +# upstream-sync.sh — Selective upstream merge with fork-only path protection +# +# Prerequisites: +# git remote add upstream https://github.com/anomalyco/opencode.git (if not already) +# git config merge.ours.driver true (registers the "keep ours" merge driver) +# +# Usage: +# ./scripts/upstream-sync.sh [upstream-ref] +# Default ref: upstream/dev +# +# What it does: +# 1. Fetches upstream +# 2. Registers merge.ours driver (idempotent) +# 3. Merges upstream with fork-only paths auto-resolved via .gitattributes merge=ours +# 4. If conflicts remain (in shared files), lists them for manual resolution +# 5. After resolution, runs build verification +# +# Fork-only paths (auto-protected by .gitattributes): +# packages/opencode/src/hook/**, packages/opencode/src/memory/**, +# packages/guardrails/**, .opencode/**, docs/ai-guardrails/**, +# packages/opencode/src/notification/**, etc. + +set -euo pipefail + +UPSTREAM_REF="${1:-upstream/dev}" +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +NC='\033[0m' + +log() { echo -e "${GREEN}[sync]${NC} $*"; } +warn() { echo -e "${YELLOW}[sync]${NC} $*"; } +err() { echo -e "${RED}[sync]${NC} $*" >&2; } + +# Ensure clean working tree +if ! git diff --quiet || ! git diff --cached --quiet; then + err "Working tree is not clean. Commit or stash changes first." + exit 1 +fi + +# Ensure upstream remote exists +if ! git remote get-url upstream &>/dev/null; then + err "No 'upstream' remote. Run: git remote add upstream https://github.com/anomalyco/opencode.git" + exit 1 +fi + +# Fetch latest upstream +log "Fetching upstream..." +git fetch upstream + +# Register merge.ours driver (idempotent) +git config merge.ours.driver true + +# Show what we're merging +CURRENT=$(git rev-parse --short HEAD) +TARGET=$(git rev-parse --short "$UPSTREAM_REF") +ANCESTOR=$(git merge-base HEAD "$UPSTREAM_REF" 2>/dev/null || echo "none") +AHEAD=$(git rev-list --count "$ANCESTOR".."$UPSTREAM_REF" 2>/dev/null || echo "?") + +log "Current: $CURRENT ($(git branch --show-current))" +log "Target: $TARGET ($UPSTREAM_REF)" +log "Ancestor: ${ANCESTOR:0:7}" +log "Commits to merge: $AHEAD" + +if [ "$AHEAD" = "0" ]; then + log "Already up to date." + exit 0 +fi + +# Attempt merge +log "Merging $UPSTREAM_REF..." +log "Fork-only paths will auto-resolve via .gitattributes merge=ours" + +if git merge "$UPSTREAM_REF" --no-edit -m "chore: upstream sync $(git rev-parse --short "$UPSTREAM_REF") ($(date +%Y-%m-%d))"; then + log "Merge completed cleanly!" +else + # Conflicts detected + warn "Merge has conflicts in shared files:" + echo "" + git diff --name-only --diff-filter=U | while read -r f; do + echo " CONFLICT: $f" + done + echo "" + warn "Resolve conflicts manually, then run:" + warn " git add -A && git commit" + warn " bun turbo build && bun test" + exit 1 +fi + +# Post-merge verification +log "Running build verification..." +if bun turbo build 2>&1 | tail -5; then + log "Build succeeded!" +else + err "Build failed after merge. Check the output above." + exit 1 +fi + +log "Upstream sync complete." +log "Run 'bun dev:guardrails' to verify TUI functionality." diff --git a/sdks/vscode/package.json b/sdks/vscode/package.json index 2004bd733f19..afe506d0ea11 100644 --- a/sdks/vscode/package.json +++ b/sdks/vscode/package.json @@ -2,7 +2,7 @@ "name": "opencode", "displayName": "opencode", "description": "opencode for VS Code", - "version": "1.4.0", + "version": "1.4.1", "publisher": "sst-dev", "repository": { "type": "git",