@@ -215,7 +222,10 @@ export function DialogEditProject(props: { project: LocalProject }) {
"bg-transparent border border-transparent hover:bg-surface-base-hover hover:border-border-weak-base":
store.color !== color,
}}
- onClick={() => setStore("color", color)}
+ onClick={() => {
+ if (store.color === color && !props.project.icon?.url) return
+ setStore("color", store.color === color ? undefined : color)
+ }}
>
{
const globalSync = useGlobalSync()
const notification = useNotification()
@@ -42,11 +50,7 @@ export const ProjectIcon = (props: { project: LocalProject; class?: string; noti
",
@@ -65,6 +67,20 @@ export const AttachCommand = cmd({
return { Authorization: auth }
})()
const config = await TuiConfig.get()
+
+ try {
+ await validateSession({
+ url: args.url,
+ sessionID: args.session,
+ directory,
+ headers,
+ })
+ } catch (error) {
+ UI.error(errorMessage(error))
+ process.exitCode = 1
+ return
+ }
+
await tui({
url: args.url,
config,
diff --git a/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx b/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx
index 06be5dfbefbf..2f5da1d23154 100644
--- a/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx
+++ b/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx
@@ -68,6 +68,7 @@ import { Flag } from "@/flag/flag"
import { LANGUAGE_EXTENSIONS } from "@/lsp/language"
import parsers from "../../../../../../parsers-config.ts"
import * as Clipboard from "../../util/clipboard"
+import { errorMessage } from "@/util/error"
import { Toast, useToast } from "../../ui/toast"
import { useKV } from "../../context/kv.tsx"
import * as Editor from "../../util/editor"
@@ -180,31 +181,43 @@ export function Session() {
const toast = useToast()
const sdk = useSDK()
- createEffect(async () => {
- const previousWorkspace = project.workspace.current()
- const result = await sdk.client.session.get({ sessionID: route.sessionID }, { throwOnError: true })
- if (!result.data) {
+ createEffect(() => {
+ const sessionID = route.sessionID
+ void (async () => {
+ const previousWorkspace = project.workspace.current()
+ const result = await sdk.client.session.get({ sessionID }, { throwOnError: true })
+ if (!result.data) {
+ toast.show({
+ message: `Session not found: ${sessionID}`,
+ variant: "error",
+ duration: 5000,
+ })
+ navigate({ type: "home" })
+ return
+ }
+
+ if (result.data.workspaceID !== previousWorkspace) {
+ project.workspace.set(result.data.workspaceID)
+
+ // Sync all the data for this workspace. Note that this
+ // workspace may not exist anymore which is why this is not
+ // fatal. If it doesn't we still want to show the session
+ // (which will be non-interactive)
+ try {
+ await sync.bootstrap({ fatal: false })
+ } catch {}
+ }
+ await sync.session.sync(sessionID)
+ if (route.sessionID === sessionID && scroll) scroll.scrollBy(100_000)
+ })().catch((error) => {
+ if (route.sessionID !== sessionID) return
toast.show({
- message: `Session not found: ${route.sessionID}`,
+ message: errorMessage(error),
variant: "error",
+ duration: 5000,
})
navigate({ type: "home" })
- return
- }
-
- if (result.data.workspaceID !== previousWorkspace) {
- project.workspace.set(result.data.workspaceID)
-
- // Sync all the data for this workspace. Note that this
- // workspace may not exist anymore which is why this is not
- // fatal. If it doesn't we still want to show the session
- // (which will be non-interactive)
- try {
- await sync.bootstrap({ fatal: false })
- } catch (e) {}
- }
- await sync.session.sync(route.sessionID)
- if (scroll) scroll.scrollBy(100_000)
+ })
})
let lastSwitch: string | undefined = undefined
diff --git a/packages/opencode/src/cli/cmd/tui/thread.ts b/packages/opencode/src/cli/cmd/tui/thread.ts
index e3e9eb811779..a2a53ecafa0d 100644
--- a/packages/opencode/src/cli/cmd/tui/thread.ts
+++ b/packages/opencode/src/cli/cmd/tui/thread.ts
@@ -16,6 +16,7 @@ import { win32DisableProcessedInput, win32InstallCtrlCGuard } from "./win32"
import { writeHeapSnapshot } from "v8"
import { TuiConfig } from "./config/tui"
import { OPENCODE_PROCESS_ROLE, OPENCODE_RUN_ID, ensureRunID, sanitizedProcessEnv } from "@/util/opencode-process"
+import { validateSession } from "./validate-session"
declare global {
const OPENCODE_WORKER_PATH: string
@@ -202,6 +203,19 @@ export const TuiThreadCommand = cmd({
events: createEventSource(client),
}
+ try {
+ await validateSession({
+ url: transport.url,
+ sessionID: args.session,
+ directory: cwd,
+ fetch: transport.fetch,
+ })
+ } catch (error) {
+ UI.error(errorMessage(error))
+ process.exitCode = 1
+ return
+ }
+
setTimeout(() => {
client.call("checkUpgrade", { directory: cwd }).catch(() => {})
}, 1000).unref?.()
diff --git a/packages/opencode/src/cli/cmd/tui/validate-session.ts b/packages/opencode/src/cli/cmd/tui/validate-session.ts
new file mode 100644
index 000000000000..e2a21d51e14c
--- /dev/null
+++ b/packages/opencode/src/cli/cmd/tui/validate-session.ts
@@ -0,0 +1,24 @@
+import { createOpencodeClient } from "@opencode-ai/sdk/v2"
+import { SessionID } from "@/session/schema"
+
+export async function validateSession(input: {
+ url: string
+ sessionID?: string
+ directory?: string
+ fetch?: typeof fetch
+ headers?: RequestInit["headers"]
+}) {
+ if (!input.sessionID) return
+
+ const result = SessionID.zod.safeParse(input.sessionID)
+ if (!result.success) {
+ throw new Error(`Invalid session ID: ${result.error.issues.at(0)?.message ?? "unknown error"}`)
+ }
+
+ await createOpencodeClient({
+ baseUrl: input.url,
+ directory: input.directory,
+ fetch: input.fetch,
+ headers: input.headers,
+ }).session.get({ sessionID: result.data }, { throwOnError: true })
+}
diff --git a/packages/opencode/src/format/index.ts b/packages/opencode/src/format/index.ts
index 85934ce9c9a3..53a2c10119b1 100644
--- a/packages/opencode/src/format/index.ts
+++ b/packages/opencode/src/format/index.ts
@@ -25,7 +25,7 @@ export type Status = z.infer
export interface Interface {
readonly init: () => Effect.Effect
readonly status: () => Effect.Effect
- readonly file: (filepath: string) => Effect.Effect
+ readonly file: (filepath: string) => Effect.Effect
}
export class Service extends Context.Service()("@opencode/Format") {}
@@ -70,16 +70,19 @@ export const layer = Layer.effect(
}
}),
)
- return checks.filter((x) => x.cmd).map((x) => ({ item: x.item, cmd: x.cmd! }))
+ return checks
+ .filter((x): x is { item: Formatter.Info; cmd: string[] } => x.cmd !== false)
+ .map((x) => ({ item: x.item, cmd: x.cmd }))
}
function formatFile(filepath: string) {
return Effect.gen(function* () {
log.info("formatting", { file: filepath })
- const ext = path.extname(filepath)
+ const formatters = yield* Effect.promise(() => getFormatter(path.extname(filepath)))
- for (const { item, cmd } of yield* Effect.promise(() => getFormatter(ext))) {
- if (cmd === false) continue
+ if (!formatters.length) return false
+
+ for (const { item, cmd } of formatters) {
log.info("running", { command: cmd })
const replaced = cmd.map((x) => x.replace("$FILE", filepath))
const dir = yield* InstanceState.directory
@@ -113,6 +116,8 @@ export const layer = Layer.effect(
})
}
}
+
+ return true
})
}
@@ -188,7 +193,7 @@ export const layer = Layer.effect(
const file = Effect.fn("Format.file")(function* (filepath: string) {
const { formatFile } = yield* InstanceState.get(state)
- yield* formatFile(filepath)
+ return yield* formatFile(filepath)
})
return Service.of({ init, status, file })
diff --git a/packages/opencode/src/patch/index.ts b/packages/opencode/src/patch/index.ts
index 19e1d7555bb0..3662f9e908ae 100644
--- a/packages/opencode/src/patch/index.ts
+++ b/packages/opencode/src/patch/index.ts
@@ -3,6 +3,7 @@ import * as path from "path"
import * as fs from "fs/promises"
import { readFileSync } from "fs"
import { Log } from "../util"
+import * as Bom from "../util/bom"
const log = Log.create({ service: "patch" })
@@ -305,18 +306,19 @@ export function maybeParseApplyPatch(
interface ApplyPatchFileUpdate {
unified_diff: string
content: string
+ bom: boolean
}
export function deriveNewContentsFromChunks(filePath: string, chunks: UpdateFileChunk[]): ApplyPatchFileUpdate {
// Read original file content
- let originalContent: string
+ let originalContent: ReturnType
try {
- originalContent = readFileSync(filePath, "utf-8")
+ originalContent = Bom.split(readFileSync(filePath, "utf-8"))
} catch (error) {
throw new Error(`Failed to read file ${filePath}: ${error}`, { cause: error })
}
- let originalLines = originalContent.split("\n")
+ let originalLines = originalContent.text.split("\n")
// Drop trailing empty element for consistent line counting
if (originalLines.length > 0 && originalLines[originalLines.length - 1] === "") {
@@ -331,14 +333,16 @@ export function deriveNewContentsFromChunks(filePath: string, chunks: UpdateFile
newLines.push("")
}
- const newContent = newLines.join("\n")
+ const next = Bom.split(newLines.join("\n"))
+ const newContent = next.text
// Generate unified diff
- const unifiedDiff = generateUnifiedDiff(originalContent, newContent)
+ const unifiedDiff = generateUnifiedDiff(originalContent.text, newContent)
return {
unified_diff: unifiedDiff,
content: newContent,
+ bom: originalContent.bom || next.bom,
}
}
@@ -553,13 +557,13 @@ export async function applyHunksToFiles(hunks: Hunk[]): Promise {
await fs.mkdir(moveDir, { recursive: true })
}
- await fs.writeFile(hunk.move_path, fileUpdate.content, "utf-8")
+ await fs.writeFile(hunk.move_path, Bom.join(fileUpdate.content, fileUpdate.bom), "utf-8")
await fs.unlink(hunk.path)
modified.push(hunk.move_path)
log.info(`Moved file: ${hunk.path} -> ${hunk.move_path}`)
} else {
// Regular update
- await fs.writeFile(hunk.path, fileUpdate.content, "utf-8")
+ await fs.writeFile(hunk.path, Bom.join(fileUpdate.content, fileUpdate.bom), "utf-8")
modified.push(hunk.path)
log.info(`Updated file: ${hunk.path}`)
}
diff --git a/packages/opencode/src/plugin/codex.ts b/packages/opencode/src/plugin/codex.ts
index c61cb7850900..84d314f476ff 100644
--- a/packages/opencode/src/plugin/codex.ts
+++ b/packages/opencode/src/plugin/codex.ts
@@ -374,6 +374,7 @@ export async function CodexAuthPlugin(input: PluginInput): Promise {
"gpt-5.3-codex",
"gpt-5.4",
"gpt-5.4-mini",
+ "gpt-5.5",
])
for (const [modelId, model] of Object.entries(provider.models)) {
if (modelId.includes("codex")) continue
diff --git a/packages/opencode/src/project/project.ts b/packages/opencode/src/project/project.ts
index 6a2132274adf..c4ac98e4b36a 100644
--- a/packages/opencode/src/project/project.ts
+++ b/packages/opencode/src/project/project.ts
@@ -158,12 +158,18 @@ export const layer: Layer.Layer<
const scope = yield* Scope.Scope
- const readCachedProjectId = Effect.fnUntraced(function* (dir: string) {
- return yield* fs.readFileString(pathSvc.join(dir, "opencode")).pipe(
- Effect.map((x) => x.trim()),
- Effect.map(ProjectID.make),
- Effect.catch(() => Effect.void),
- )
+ const canonicalDirectory = Effect.fnUntraced(function* (directory: string) {
+ const normalized = pathSvc.normalize(directory)
+ return yield* fs
+ .realPath(normalized)
+ .pipe(
+ Effect.catch(() => Effect.succeed(normalized)),
+ Effect.map((resolved) => pathSvc.normalize(resolved)),
+ )
+ })
+
+ const projectIDFromDirectory = Effect.fnUntraced(function* (directory: string) {
+ return ProjectID.fromDirectory(yield* canonicalDirectory(directory))
})
const fromDirectory = Effect.fn("Project.fromDirectory")(function* (directory: string) {
@@ -187,11 +193,11 @@ export const layer: Layer.Layer<
let sandbox = pathSvc.dirname(dotgit)
const gitBinary = yield* Effect.sync(() => which("git"))
- let id = yield* readCachedProjectId(dotgit)
if (!gitBinary) {
+ sandbox = yield* canonicalDirectory(sandbox)
return {
- id: id ?? ProjectID.global,
+ id: yield* projectIDFromDirectory(sandbox),
worktree: sandbox,
sandbox,
vcs: fakeVcs,
@@ -200,50 +206,33 @@ export const layer: Layer.Layer<
const commonDir = yield* git(["rev-parse", "--git-common-dir"], { cwd: sandbox })
if (commonDir.code !== 0) {
+ sandbox = yield* canonicalDirectory(sandbox)
return {
- id: id ?? ProjectID.global,
+ id: yield* projectIDFromDirectory(sandbox),
worktree: sandbox,
sandbox,
vcs: fakeVcs,
}
}
- const worktree = (() => {
- const common = resolveGitPath(sandbox, commonDir.text.trim())
- return common === sandbox ? sandbox : pathSvc.dirname(common)
- })()
-
- if (id == null) {
- id = yield* readCachedProjectId(pathSvc.join(worktree, ".git"))
- }
-
- if (!id) {
- const revList = yield* git(["rev-list", "--max-parents=0", "HEAD"], { cwd: sandbox })
- const roots = revList.text
- .split("\n")
- .filter(Boolean)
- .map((x) => x.trim())
- .toSorted()
-
- id = roots[0] ? ProjectID.make(roots[0]) : undefined
- if (id) {
- yield* fs.writeFileString(pathSvc.join(worktree, ".git", "opencode"), id).pipe(Effect.ignore)
- }
- }
-
- if (!id) {
- return { id: ProjectID.global, worktree: sandbox, sandbox, vcs: "git" as const }
- }
+ const worktree = yield* canonicalDirectory(
+ (() => {
+ const common = resolveGitPath(sandbox, commonDir.text.trim())
+ return common === sandbox ? sandbox : pathSvc.dirname(common)
+ })(),
+ )
+ const id = yield* projectIDFromDirectory(worktree)
const topLevel = yield* git(["rev-parse", "--show-toplevel"], { cwd: sandbox })
if (topLevel.code !== 0) {
+ sandbox = yield* canonicalDirectory(sandbox)
return {
id,
- worktree: sandbox,
+ worktree,
sandbox,
vcs: fakeVcs,
}
}
- sandbox = resolveGitPath(sandbox, topLevel.text.trim())
+ sandbox = yield* canonicalDirectory(resolveGitPath(sandbox, topLevel.text.trim()))
return { id, sandbox, worktree, vcs: "git" as const }
})
diff --git a/packages/opencode/src/project/schema.ts b/packages/opencode/src/project/schema.ts
index 7708b8de1eee..27a5c456fe6c 100644
--- a/packages/opencode/src/project/schema.ts
+++ b/packages/opencode/src/project/schema.ts
@@ -10,6 +10,7 @@ export type ProjectID = typeof projectIdSchema.Type
export const ProjectID = projectIdSchema.pipe(
withStatics((schema: typeof projectIdSchema) => ({
global: schema.make("global"),
+ fromDirectory: (directory: string) => schema.make(`dir_${Buffer.from(directory).toString("base64url")}`),
zod: zod(schema),
})),
)
diff --git a/packages/opencode/src/tool/apply_patch.ts b/packages/opencode/src/tool/apply_patch.ts
index 7da7dd255c52..a4cf1e853f3c 100644
--- a/packages/opencode/src/tool/apply_patch.ts
+++ b/packages/opencode/src/tool/apply_patch.ts
@@ -14,6 +14,7 @@ import { AppFileSystem } from "@opencode-ai/shared/filesystem"
import DESCRIPTION from "./apply_patch.txt"
import { File } from "../file"
import { Format } from "../format"
+import * as Bom from "@/util/bom"
const PatchParams = z.object({
patchText: z.string().describe("The full patch text that describes all changes to be made"),
@@ -59,6 +60,7 @@ export const ApplyPatchTool = Tool.define(
diff: string
additions: number
deletions: number
+ bom: boolean
}> = []
let totalDiff = ""
@@ -72,11 +74,12 @@ export const ApplyPatchTool = Tool.define(
const oldContent = ""
const newContent =
hunk.contents.length === 0 || hunk.contents.endsWith("\n") ? hunk.contents : `${hunk.contents}\n`
- const diff = trimDiff(createTwoFilesPatch(filePath, filePath, oldContent, newContent))
+ const next = Bom.split(newContent)
+ const diff = trimDiff(createTwoFilesPatch(filePath, filePath, oldContent, next.text))
let additions = 0
let deletions = 0
- for (const change of diffLines(oldContent, newContent)) {
+ for (const change of diffLines(oldContent, next.text)) {
if (change.added) additions += change.count || 0
if (change.removed) deletions += change.count || 0
}
@@ -84,11 +87,12 @@ export const ApplyPatchTool = Tool.define(
fileChanges.push({
filePath,
oldContent,
- newContent,
+ newContent: next.text,
type: "add",
diff,
additions,
deletions,
+ bom: next.bom,
})
totalDiff += diff + "\n"
@@ -104,13 +108,16 @@ export const ApplyPatchTool = Tool.define(
)
}
- const oldContent = yield* afs.readFileString(filePath)
+ const source = yield* Bom.readFile(afs, filePath)
+ const oldContent = source.text
let newContent = oldContent
+ let bom = source.bom
// Apply the update chunks to get new content
try {
const fileUpdate = Patch.deriveNewContentsFromChunks(filePath, hunk.chunks)
newContent = fileUpdate.content
+ bom = fileUpdate.bom
} catch (error) {
return yield* Effect.fail(new Error(`apply_patch verification failed: ${error}`))
}
@@ -136,6 +143,7 @@ export const ApplyPatchTool = Tool.define(
diff,
additions,
deletions,
+ bom,
})
totalDiff += diff + "\n"
@@ -143,17 +151,16 @@ export const ApplyPatchTool = Tool.define(
}
case "delete": {
- const contentToDelete = yield* afs
- .readFileString(filePath)
- .pipe(
- Effect.catch((error) =>
- Effect.fail(
- new Error(
- `apply_patch verification failed: ${error instanceof Error ? error.message : String(error)}`,
- ),
+ const source = yield* Bom.readFile(afs, filePath).pipe(
+ Effect.catch((error) =>
+ Effect.fail(
+ new Error(
+ `apply_patch verification failed: ${error instanceof Error ? error.message : String(error)}`,
),
),
- )
+ ),
+ )
+ const contentToDelete = source.text
const deleteDiff = trimDiff(createTwoFilesPatch(filePath, filePath, contentToDelete, ""))
const deletions = contentToDelete.split("\n").length
@@ -166,6 +173,7 @@ export const ApplyPatchTool = Tool.define(
diff: deleteDiff,
additions: 0,
deletions,
+ bom: source.bom,
})
totalDiff += deleteDiff + "\n"
@@ -207,12 +215,12 @@ export const ApplyPatchTool = Tool.define(
case "add":
// Create parent directories (recursive: true is safe on existing/root dirs)
- yield* afs.writeWithDirs(change.filePath, change.newContent)
+ yield* afs.writeWithDirs(change.filePath, Bom.join(change.newContent, change.bom))
updates.push({ file: change.filePath, event: "add" })
break
case "update":
- yield* afs.writeWithDirs(change.filePath, change.newContent)
+ yield* afs.writeWithDirs(change.filePath, Bom.join(change.newContent, change.bom))
updates.push({ file: change.filePath, event: "change" })
break
@@ -220,7 +228,7 @@ export const ApplyPatchTool = Tool.define(
if (change.movePath) {
// Create parent directories (recursive: true is safe on existing/root dirs)
- yield* afs.writeWithDirs(change.movePath!, change.newContent)
+ yield* afs.writeWithDirs(change.movePath!, Bom.join(change.newContent, change.bom))
yield* afs.remove(change.filePath)
updates.push({ file: change.filePath, event: "unlink" })
updates.push({ file: change.movePath, event: "add" })
@@ -234,7 +242,9 @@ export const ApplyPatchTool = Tool.define(
}
if (edited) {
- yield* format.file(edited)
+ if (yield* format.file(edited)) {
+ yield* Bom.syncFile(afs, edited, change.bom)
+ }
yield* bus.publish(File.Event.Edited, { file: edited })
}
}
diff --git a/packages/opencode/src/tool/edit.ts b/packages/opencode/src/tool/edit.ts
index 2c6c2c13084a..858d14e043fe 100644
--- a/packages/opencode/src/tool/edit.ts
+++ b/packages/opencode/src/tool/edit.ts
@@ -18,6 +18,7 @@ import { Instance } from "../project/instance"
import { Snapshot } from "@/snapshot"
import { assertExternalDirectoryEffect } from "./external-directory"
import { AppFileSystem } from "@opencode-ai/shared/filesystem"
+import * as Bom from "@/util/bom"
function normalizeLineEndings(text: string): string {
return text.replaceAll("\r\n", "\n")
@@ -84,7 +85,11 @@ export const EditTool = Tool.define(
Effect.gen(function* () {
if (params.oldString === "") {
const existed = yield* afs.existsSafe(filePath)
- contentNew = params.newString
+ const source = existed ? yield* Bom.readFile(afs, filePath) : { bom: false, text: "" }
+ const next = Bom.split(params.newString)
+ const desiredBom = source.bom || next.bom
+ contentOld = source.text
+ contentNew = next.text
diff = trimDiff(createTwoFilesPatch(filePath, filePath, contentOld, contentNew))
yield* ctx.ask({
permission: "edit",
@@ -95,8 +100,10 @@ export const EditTool = Tool.define(
diff,
},
})
- yield* afs.writeWithDirs(filePath, params.newString)
- yield* format.file(filePath)
+ yield* afs.writeWithDirs(filePath, Bom.join(contentNew, desiredBom))
+ if (yield* format.file(filePath)) {
+ contentNew = yield* Bom.syncFile(afs, filePath, desiredBom)
+ }
yield* bus.publish(File.Event.Edited, { file: filePath })
yield* bus.publish(FileWatcher.Event.Updated, {
file: filePath,
@@ -108,13 +115,16 @@ export const EditTool = Tool.define(
const info = yield* afs.stat(filePath).pipe(Effect.catch(() => Effect.succeed(undefined)))
if (!info) throw new Error(`File ${filePath} not found`)
if (info.type === "Directory") throw new Error(`Path is a directory, not a file: ${filePath}`)
- contentOld = yield* afs.readFileString(filePath)
+ const source = yield* Bom.readFile(afs, filePath)
+ contentOld = source.text
const ending = detectLineEnding(contentOld)
const old = convertToLineEnding(normalizeLineEndings(params.oldString), ending)
- const next = convertToLineEnding(normalizeLineEndings(params.newString), ending)
+ const replacement = convertToLineEnding(normalizeLineEndings(params.newString), ending)
- contentNew = replace(contentOld, old, next, params.replaceAll)
+ const next = Bom.split(replace(contentOld, old, replacement, params.replaceAll))
+ const desiredBom = source.bom || next.bom
+ contentNew = next.text
diff = trimDiff(
createTwoFilesPatch(
@@ -134,14 +144,15 @@ export const EditTool = Tool.define(
},
})
- yield* afs.writeWithDirs(filePath, contentNew)
- yield* format.file(filePath)
+ yield* afs.writeWithDirs(filePath, Bom.join(contentNew, desiredBom))
+ if (yield* format.file(filePath)) {
+ contentNew = yield* Bom.syncFile(afs, filePath, desiredBom)
+ }
yield* bus.publish(File.Event.Edited, { file: filePath })
yield* bus.publish(FileWatcher.Event.Updated, {
file: filePath,
event: "change",
})
- contentNew = yield* afs.readFileString(filePath)
diff = trimDiff(
createTwoFilesPatch(
filePath,
diff --git a/packages/opencode/src/tool/write.ts b/packages/opencode/src/tool/write.ts
index 741091b21d3c..79ed58519831 100644
--- a/packages/opencode/src/tool/write.ts
+++ b/packages/opencode/src/tool/write.ts
@@ -13,6 +13,7 @@ import { AppFileSystem } from "@opencode-ai/shared/filesystem"
import { Instance } from "../project/instance"
import { trimDiff } from "./edit"
import { assertExternalDirectoryEffect } from "./external-directory"
+import * as Bom from "@/util/bom"
const MAX_PROJECT_DIAGNOSTICS_FILES = 5
@@ -38,9 +39,13 @@ export const WriteTool = Tool.define(
yield* assertExternalDirectoryEffect(ctx, filepath)
const exists = yield* fs.existsSafe(filepath)
- const contentOld = exists ? yield* fs.readFileString(filepath) : ""
+ const source = exists ? yield* Bom.readFile(fs, filepath) : { bom: false, text: "" }
+ const next = Bom.split(params.content)
+ const desiredBom = source.bom || next.bom
+ const contentOld = source.text
+ const contentNew = next.text
- const diff = trimDiff(createTwoFilesPatch(filepath, filepath, contentOld, params.content))
+ const diff = trimDiff(createTwoFilesPatch(filepath, filepath, contentOld, contentNew))
yield* ctx.ask({
permission: "edit",
patterns: [path.relative(Instance.worktree, filepath)],
@@ -51,8 +56,10 @@ export const WriteTool = Tool.define(
},
})
- yield* fs.writeWithDirs(filepath, params.content)
- yield* format.file(filepath)
+ yield* fs.writeWithDirs(filepath, Bom.join(contentNew, desiredBom))
+ if (yield* format.file(filepath)) {
+ yield* Bom.syncFile(fs, filepath, desiredBom)
+ }
yield* bus.publish(File.Event.Edited, { file: filepath })
yield* bus.publish(FileWatcher.Event.Updated, {
file: filepath,
diff --git a/packages/opencode/src/util/bom.ts b/packages/opencode/src/util/bom.ts
new file mode 100644
index 000000000000..484228f3d415
--- /dev/null
+++ b/packages/opencode/src/util/bom.ts
@@ -0,0 +1,31 @@
+import { Effect } from "effect"
+import { AppFileSystem } from "@opencode-ai/shared/filesystem"
+
+const BOM_CODE = 0xfeff
+const BOM = String.fromCharCode(BOM_CODE)
+
+export function split(text: string) {
+ if (text.charCodeAt(0) !== BOM_CODE) return { bom: false, text }
+ return { bom: true, text: text.slice(1) }
+}
+
+export function join(text: string, bom: boolean) {
+ const stripped = split(text).text
+ if (!bom) return stripped
+ return BOM + stripped
+}
+
+export const readFile = Effect.fn("Bom.readFile")(function* (fs: AppFileSystem.Interface, filePath: string) {
+ return split(new TextDecoder("utf-8", { ignoreBOM: true }).decode(yield* fs.readFile(filePath)))
+})
+
+export const syncFile = Effect.fn("Bom.syncFile")(function* (
+ fs: AppFileSystem.Interface,
+ filePath: string,
+ bom: boolean,
+) {
+ const current = yield* readFile(fs, filePath)
+ if (current.bom === bom) return current.text
+ yield* fs.writeWithDirs(filePath, join(current.text, bom))
+ return current.text
+})
diff --git a/packages/opencode/src/util/error.ts b/packages/opencode/src/util/error.ts
index 75fef9fc9a04..fbda2dc50e02 100644
--- a/packages/opencode/src/util/error.ts
+++ b/packages/opencode/src/util/error.ts
@@ -26,6 +26,10 @@ export function errorMessage(error: unknown): string {
return error.message
}
+ if (isRecord(error) && isRecord(error.data) && typeof error.data.message === "string" && error.data.message) {
+ return error.data.message
+ }
+
const text = String(error)
if (text && text !== "[object Object]") return text
diff --git a/packages/opencode/test/effect/cross-spawn-spawner.test.ts b/packages/opencode/test/effect/cross-spawn-spawner.test.ts
index 5990635aa211..b4e52529c1de 100644
--- a/packages/opencode/test/effect/cross-spawn-spawner.test.ts
+++ b/packages/opencode/test/effect/cross-spawn-spawner.test.ts
@@ -169,7 +169,9 @@ describe("cross-spawn spawner", () => {
'process.stderr.write("stderr\\n", done)',
].join("\n"),
)
- const [stdout, stderr] = yield* Effect.all([decodeByteStream(handle.stdout), decodeByteStream(handle.stderr)])
+ const [stdout, stderr] = yield* Effect.all([decodeByteStream(handle.stdout), decodeByteStream(handle.stderr)], {
+ concurrency: 2,
+ })
expect(stdout).toBe("stdout")
expect(stderr).toBe("stderr")
}),
diff --git a/packages/opencode/test/format/format.test.ts b/packages/opencode/test/format/format.test.ts
index 5530e195b268..2f6f235aa165 100644
--- a/packages/opencode/test/format/format.test.ts
+++ b/packages/opencode/test/format/format.test.ts
@@ -126,6 +126,24 @@ describe("Format", () => {
it.live("service initializes without error", () => provideTmpdirInstance(() => Format.Service.use(() => Effect.void)))
+ it.live("file() returns false when no formatter runs", () =>
+ provideTmpdirInstance(
+ (dir) =>
+ Effect.gen(function* () {
+ const file = `${dir}/test.txt`
+ yield* Effect.promise(() => Bun.write(file, "x"))
+
+ const formatted = yield* Format.Service.use((fmt) => fmt.file(file))
+ expect(formatted).toBe(false)
+ }),
+ {
+ config: {
+ formatter: false,
+ },
+ },
+ ),
+ )
+
it.live("status() initializes formatter state per directory", () =>
Effect.gen(function* () {
const a = yield* provideTmpdirInstance(() => Format.Service.use((fmt) => fmt.status()), {
@@ -219,7 +237,7 @@ describe("Format", () => {
yield* Format.Service.use((fmt) =>
Effect.gen(function* () {
yield* fmt.init()
- yield* fmt.file(file)
+ expect(yield* fmt.file(file)).toBe(true)
}),
)
@@ -229,11 +247,21 @@ describe("Format", () => {
config: {
formatter: {
first: {
- command: ["sh", "-c", 'sleep 0.05; v=$(cat "$1"); printf \'%sA\' "$v" > "$1"', "sh", "$FILE"],
+ command: [
+ "node",
+ "-e",
+ "const fs = require('fs'); const file = process.argv[1]; fs.writeFileSync(file, fs.readFileSync(file, 'utf8') + 'A')",
+ "$FILE",
+ ],
extensions: [".seq"],
},
second: {
- command: ["sh", "-c", 'v=$(cat "$1"); printf \'%sB\' "$v" > "$1"', "sh", "$FILE"],
+ command: [
+ "node",
+ "-e",
+ "const fs = require('fs'); const file = process.argv[1]; fs.writeFileSync(file, fs.readFileSync(file, 'utf8') + 'B')",
+ "$FILE",
+ ],
extensions: [".seq"],
},
},
diff --git a/packages/opencode/test/project/migrate-global.test.ts b/packages/opencode/test/project/migrate-global.test.ts
index 8c9982afb805..8967e4faa671 100644
--- a/packages/opencode/test/project/migrate-global.test.ts
+++ b/packages/opencode/test/project/migrate-global.test.ts
@@ -62,26 +62,21 @@ function ensureGlobal() {
describe("migrateFromGlobal", () => {
test("migrates global sessions on first project creation", async () => {
- // 1. Start with git init but no commits — creates "global" project row
await using tmp = await tmpdir()
- await $`git init`.cwd(tmp.path).quiet()
- await $`git config user.name "Test"`.cwd(tmp.path).quiet()
- await $`git config user.email "test@opencode.test"`.cwd(tmp.path).quiet()
- await $`git config commit.gpgsign false`.cwd(tmp.path).quiet()
const { project: pre } = await run((svc) => svc.fromDirectory(tmp.path))
expect(pre.id).toBe(ProjectID.global)
- // 2. Seed a session under "global" with matching directory
const id = uid()
seed({ id, dir: tmp.path, project: ProjectID.global })
- // 3. Make a commit so the project gets a real ID
- await $`git commit --allow-empty -m "root"`.cwd(tmp.path).quiet()
+ await $`git init`.cwd(tmp.path).quiet()
+ await $`git config user.name "Test"`.cwd(tmp.path).quiet()
+ await $`git config user.email "test@opencode.test"`.cwd(tmp.path).quiet()
+ await $`git config commit.gpgsign false`.cwd(tmp.path).quiet()
const { project: real } = await run((svc) => svc.fromDirectory(tmp.path))
expect(real.id).not.toBe(ProjectID.global)
- // 4. The session should have been migrated to the real project ID
const row = Database.use((db) => db.select().from(SessionTable).where(eq(SessionTable.id, id)).get())
expect(row).toBeDefined()
expect(row!.project_id).toBe(real.id)
diff --git a/packages/opencode/test/project/project.test.ts b/packages/opencode/test/project/project.test.ts
index 4dc9ee5efac7..c7de133bf691 100644
--- a/packages/opencode/test/project/project.test.ts
+++ b/packages/opencode/test/project/project.test.ts
@@ -76,7 +76,7 @@ describe("Project.fromDirectory", () => {
const { project } = await run((svc) => svc.fromDirectory(tmp.path))
expect(project).toBeDefined()
- expect(project.id).toBe(ProjectID.global)
+ expect(project.id).toBe(ProjectID.fromDirectory(tmp.path))
expect(project.vcs).toBe("git")
expect(project.worktree).toBe(tmp.path)
@@ -93,9 +93,10 @@ describe("Project.fromDirectory", () => {
expect(project.id).not.toBe(ProjectID.global)
expect(project.vcs).toBe("git")
expect(project.worktree).toBe(tmp.path)
+ expect(project.id).toBe(ProjectID.fromDirectory(tmp.path))
const opencodeFile = path.join(tmp.path, ".git", "opencode")
- expect(await Bun.file(opencodeFile).exists()).toBe(true)
+ expect(await Bun.file(opencodeFile).exists()).toBe(false)
})
test("returns global for non-git directory", async () => {
@@ -104,23 +105,23 @@ describe("Project.fromDirectory", () => {
expect(project.id).toBe(ProjectID.global)
})
- test("derives stable project ID from root commit", async () => {
+ test("derives stable project ID from the canonical worktree path", async () => {
await using tmp = await tmpdir({ git: true })
const { project: a } = await run((svc) => svc.fromDirectory(tmp.path))
const { project: b } = await run((svc) => svc.fromDirectory(tmp.path))
expect(b.id).toBe(a.id)
+ expect(a.id).toBe(ProjectID.fromDirectory(tmp.path))
})
})
describe("Project.fromDirectory git failure paths", () => {
- test("keeps vcs when rev-list exits non-zero (no commits)", async () => {
+ test("assigns a directory-based project ID without commits", async () => {
await using tmp = await tmpdir()
await $`git init`.cwd(tmp.path).quiet()
- // rev-list fails because HEAD doesn't exist yet — this is the natural scenario
const { project } = await run((svc) => svc.fromDirectory(tmp.path))
expect(project.vcs).toBe("git")
- expect(project.id).toBe(ProjectID.global)
+ expect(project.id).toBe(ProjectID.fromDirectory(tmp.path))
expect(project.worktree).toBe(tmp.path)
})
@@ -188,10 +189,9 @@ describe("Project.fromDirectory with worktrees", () => {
expect(wt.id).toBe(main.id)
- // Cache should live in the common .git dir, not the worktree's .git file
const cache = path.join(tmp.path, ".git", "opencode")
const exists = await Bun.file(cache).exists()
- expect(exists).toBe(true)
+ expect(exists).toBe(false)
} finally {
await $`git worktree remove ${worktreePath}`
.cwd(tmp.path)
@@ -200,7 +200,7 @@ describe("Project.fromDirectory with worktrees", () => {
}
})
- test("separate clones of the same repo should share project ID", async () => {
+ test("separate clones of the same repo should get different project IDs", async () => {
await using tmp = await tmpdir({ git: true })
// Create a bare remote, push, then clone into a second directory
@@ -213,7 +213,9 @@ describe("Project.fromDirectory with worktrees", () => {
const { project: a } = await run((svc) => svc.fromDirectory(tmp.path))
const { project: b } = await run((svc) => svc.fromDirectory(clone))
- expect(b.id).toBe(a.id)
+ expect(a.id).toBe(ProjectID.fromDirectory(tmp.path))
+ expect(b.id).toBe(ProjectID.fromDirectory(clone))
+ expect(b.id).not.toBe(a.id)
} finally {
await $`rm -rf ${bare} ${clone}`.quiet().nothrow()
}
diff --git a/packages/opencode/test/server/project-init-git.test.ts b/packages/opencode/test/server/project-init-git.test.ts
index a29b4ebb3584..785d56b8914b 100644
--- a/packages/opencode/test/server/project-init-git.test.ts
+++ b/packages/opencode/test/server/project-init-git.test.ts
@@ -9,6 +9,7 @@ import { Filesystem } from "../../src/util"
import { Log } from "../../src/util"
import { resetDatabase } from "../fixture/db"
import { provideInstance, tmpdir } from "../fixture/fixture"
+import { ProjectID } from "../../src/project/schema"
void Log.init({ print: false })
@@ -38,7 +39,7 @@ describe("project.initGit endpoint", () => {
const body = await init.json()
expect(init.status).toBe(200)
expect(body).toMatchObject({
- id: "global",
+ id: ProjectID.fromDirectory(tmp.path),
vcs: "git",
worktree: tmp.path,
})
@@ -55,7 +56,7 @@ describe("project.initGit endpoint", () => {
})
expect(current.status).toBe(200)
expect(await current.json()).toMatchObject({
- id: "global",
+ id: ProjectID.fromDirectory(tmp.path),
vcs: "git",
worktree: tmp.path,
})
diff --git a/packages/opencode/test/tool/apply_patch.test.ts b/packages/opencode/test/tool/apply_patch.test.ts
index ebfa9a531eec..fa88432136a5 100644
--- a/packages/opencode/test/tool/apply_patch.test.ts
+++ b/packages/opencode/test/tool/apply_patch.test.ts
@@ -195,6 +195,35 @@ describe("tool.apply_patch freeform", () => {
})
})
+ test("does not invent a first-line diff for BOM files", async () => {
+ await using fixture = await tmpdir()
+ const { ctx, calls } = makeCtx()
+
+ await Instance.provide({
+ directory: fixture.path,
+ fn: async () => {
+ const bom = String.fromCharCode(0xfeff)
+ const target = path.join(fixture.path, "example.cs")
+ await fs.writeFile(target, `${bom}using System;\n\nclass Test {}\n`, "utf-8")
+
+ const patchText =
+ "*** Begin Patch\n*** Update File: example.cs\n@@\n class Test {}\n+class Next {}\n*** End Patch"
+
+ await execute({ patchText }, ctx)
+
+ expect(calls.length).toBe(1)
+ const shown = calls[0].metadata.files[0]?.patch ?? ""
+ expect(shown).not.toContain(bom)
+ expect(shown).not.toContain("-using System;")
+ expect(shown).not.toContain("+using System;")
+
+ const content = await fs.readFile(target, "utf-8")
+ expect(content.charCodeAt(0)).toBe(0xfeff)
+ expect(content.slice(1)).toBe("using System;\n\nclass Test {}\nclass Next {}\n")
+ },
+ })
+ })
+
test("inserts lines with insert-only hunk", async () => {
await using fixture = await tmpdir()
const { ctx } = makeCtx()
diff --git a/packages/opencode/test/tool/edit.test.ts b/packages/opencode/test/tool/edit.test.ts
index b5fbc0a67dde..82e1b4a7fd4b 100644
--- a/packages/opencode/test/tool/edit.test.ts
+++ b/packages/opencode/test/tool/edit.test.ts
@@ -96,6 +96,37 @@ describe("tool.edit", () => {
})
})
+ test("preserves BOM when oldString is empty on existing files", async () => {
+ await using tmp = await tmpdir()
+ const filepath = path.join(tmp.path, "existing.cs")
+ const bom = String.fromCharCode(0xfeff)
+ await fs.writeFile(filepath, `${bom}using System;\n`, "utf-8")
+
+ await Instance.provide({
+ directory: tmp.path,
+ fn: async () => {
+ const edit = await resolve()
+ const result = await Effect.runPromise(
+ edit.execute(
+ {
+ filePath: filepath,
+ oldString: "",
+ newString: "using Up;\n",
+ },
+ ctx,
+ ),
+ )
+
+ expect(result.metadata.diff).toContain("-using System;")
+ expect(result.metadata.diff).toContain("+using Up;")
+
+ const content = await fs.readFile(filepath, "utf-8")
+ expect(content.charCodeAt(0)).toBe(0xfeff)
+ expect(content.slice(1)).toBe("using Up;\n")
+ },
+ })
+ })
+
test("creates new file with nested directories", async () => {
await using tmp = await tmpdir()
const filepath = path.join(tmp.path, "nested", "dir", "file.txt")
@@ -183,6 +214,38 @@ describe("tool.edit", () => {
})
})
+ test("replaces the first visible line in BOM files", async () => {
+ await using tmp = await tmpdir()
+ const filepath = path.join(tmp.path, "existing.cs")
+ const bom = String.fromCharCode(0xfeff)
+ await fs.writeFile(filepath, `${bom}using System;\nclass Test {}\n`, "utf-8")
+
+ await Instance.provide({
+ directory: tmp.path,
+ fn: async () => {
+ const edit = await resolve()
+ const result = await Effect.runPromise(
+ edit.execute(
+ {
+ filePath: filepath,
+ oldString: "using System;",
+ newString: "using Up;",
+ },
+ ctx,
+ ),
+ )
+
+ expect(result.metadata.diff).toContain("-using System;")
+ expect(result.metadata.diff).toContain("+using Up;")
+ expect(result.metadata.diff).not.toContain(bom)
+
+ const content = await fs.readFile(filepath, "utf-8")
+ expect(content.charCodeAt(0)).toBe(0xfeff)
+ expect(content.slice(1)).toBe("using Up;\nclass Test {}\n")
+ },
+ })
+ })
+
test("throws error when file does not exist", async () => {
await using tmp = await tmpdir()
const filepath = path.join(tmp.path, "nonexistent.txt")
diff --git a/packages/opencode/test/tool/write.test.ts b/packages/opencode/test/tool/write.test.ts
index 50d3b57527f9..36131f9596a3 100644
--- a/packages/opencode/test/tool/write.test.ts
+++ b/packages/opencode/test/tool/write.test.ts
@@ -114,6 +114,54 @@ describe("tool.write", () => {
),
)
+ it.live("preserves BOM when overwriting existing files", () =>
+ provideTmpdirInstance((dir) =>
+ Effect.gen(function* () {
+ const filepath = path.join(dir, "existing.cs")
+ const bom = String.fromCharCode(0xfeff)
+ yield* Effect.promise(() => fs.writeFile(filepath, `${bom}using System;\n`, "utf-8"))
+
+ yield* run({ filePath: filepath, content: "using Up;\n" })
+
+ const content = yield* Effect.promise(() => fs.readFile(filepath, "utf-8"))
+ expect(content.charCodeAt(0)).toBe(0xfeff)
+ expect(content.slice(1)).toBe("using Up;\n")
+ }),
+ ),
+ )
+
+ it.live("restores BOM after formatter strips it", () =>
+ provideTmpdirInstance(
+ (dir) =>
+ Effect.gen(function* () {
+ const filepath = path.join(dir, "formatted.cs")
+ const bom = String.fromCharCode(0xfeff)
+ yield* Effect.promise(() => fs.writeFile(filepath, `${bom}using System;\n`, "utf-8"))
+
+ yield* run({ filePath: filepath, content: "using Up;\n" })
+
+ const content = yield* Effect.promise(() => fs.readFile(filepath, "utf-8"))
+ expect(content.charCodeAt(0)).toBe(0xfeff)
+ expect(content.slice(1)).toBe("using Up;\n")
+ }),
+ {
+ config: {
+ formatter: {
+ stripbom: {
+ extensions: [".cs"],
+ command: [
+ "node",
+ "-e",
+ "const fs = require('fs'); const file = process.argv[1]; let text = fs.readFileSync(file, 'utf8'); if (text.charCodeAt(0) === 0xfeff) text = text.slice(1); fs.writeFileSync(file, text, 'utf8')",
+ "$FILE",
+ ],
+ },
+ },
+ },
+ },
+ ),
+ )
+
it.live("returns diff in metadata for existing files", () =>
provideTmpdirInstance((dir) =>
Effect.gen(function* () {
diff --git a/packages/ui/src/components/timeline-playground.stories.tsx b/packages/ui/src/components/timeline-playground.stories.tsx
index c071db303b7a..72f5730612c5 100644
--- a/packages/ui/src/components/timeline-playground.stories.tsx
+++ b/packages/ui/src/components/timeline-playground.stories.tsx
@@ -318,7 +318,7 @@ const TOOL_SAMPLES = {
tool: "bash",
input: { command: "bun test --filter session", description: "Run session tests" },
output:
- "bun test v1.3.11\n\n✓ session-turn.test.tsx (3 tests) 45ms\n✓ message-part.test.tsx (7 tests) 120ms\n\nTest Suites: 2 passed, 2 total\nTests: 10 passed, 10 total\nTime: 0.89s",
+ "bun test v1.3.13\n\n✓ session-turn.test.tsx (3 tests) 45ms\n✓ message-part.test.tsx (7 tests) 120ms\n\nTest Suites: 2 passed, 2 total\nTests: 10 passed, 10 total\nTime: 0.89s",
title: "Run session tests",
metadata: { command: "bun test --filter session" },
},