openAgent

1export * as FileMutation from "./file-mutation"
2 
3import { makeLocationNode } from "./effect/app-node"
4import { Context, Effect, Layer, Schema } from "effect"
5import { dirname } from "path"
6import { KeyedMutex } from "./effect/keyed-mutex"
7import { FSUtil } from "./fs-util"
8 
9export interface Target {
10  readonly canonical: string
11  readonly resource: string
12}
13 
14export interface WriteInput {
15  readonly target: Target
16  readonly content: string | Uint8Array
17}
18 
19export interface TextWriteInput {
20  readonly target: Target
21  readonly content: string
22}
23 
24export interface ConditionalWriteInput extends WriteInput {
25  readonly expected: Uint8Array
26}
27 
28export interface RemoveInput {
29  readonly target: Target
30}
31 
32export class StaleContentError extends Schema.TaggedErrorClass<StaleContentError>()("FileMutation.StaleContentError", {
33  path: Schema.String,
34}) {}
35 
36export class TargetExistsError extends Schema.TaggedErrorClass<TargetExistsError>()("FileMutation.TargetExistsError", {
37  path: Schema.String,
38}) {}
39 
40export interface WriteResult {
41  readonly operation: "write"
42  readonly target: string
43  readonly resource: string
44  readonly existed: boolean
45}
46 
47export interface RemoveResult {
48  readonly operation: "remove"
49  readonly target: string
50  readonly resource: string
51  readonly existed: boolean
52}
53 
54export interface Interface {
55  /** Create without replacing an existing target. */
56  readonly create: (input: WriteInput) => Effect.Effect<WriteResult, TargetExistsError | FSUtil.Error>
57  readonly write: (input: WriteInput) => Effect.Effect<WriteResult, FSUtil.Error>
58  /** Write text while retaining an existing UTF-8 BOM and emitting at most one BOM. */
59  readonly writeTextPreservingBom: (input: TextWriteInput) => Effect.Effect<WriteResult, FSUtil.Error>
60  /** Commit only if an existing target still has the expected bytes. */
61  readonly writeIfUnchanged: (
62    input: ConditionalWriteInput,
63  ) => Effect.Effect<WriteResult, StaleContentError | FSUtil.Error>
64  readonly remove: (input: RemoveInput) => Effect.Effect<RemoveResult, FSUtil.Error>
65}
66 
67export class Service extends Context.Service<Service, Interface>()("@opencode/v2/FileMutation") {}
68 
69/**
70 * Serialize file changes by canonical target. Conditional writes compare and
71 * write under the same process-local lock so cooperating OpenCode mutations do
72 * not overwrite changes made from the same stale content.
73 */
74const layer = Layer.effect(
75  Service,
76  Effect.gen(function* () {
77    const fs = yield* FSUtil.Service
78    const locks = KeyedMutex.makeUnsafe<string>()
79    const withTargetLock =
80      (target: Target) =>
81      <A, E, R>(effect: Effect.Effect<A, E, R>) =>
82        locks.withLock(target.canonical)(Effect.uninterruptible(effect))
83 
84    const writeResult = (target: Target, existed: boolean): WriteResult => ({
85      operation: "write",
86      target: target.canonical,
87      resource: target.resource,
88      existed,
89    })
90 
91    const removeResult = (target: Target, existed: boolean): RemoveResult => ({
92      operation: "remove",
93      target: target.canonical,
94      resource: target.resource,
95      existed,
96    })
97 
98    const write = Effect.fn("FileMutation.write")((input: WriteInput) =>
99      withTargetLock(input.target)(
100        Effect.gen(function* () {
101          const existed = yield* fs.exists(input.target.canonical)
102          yield* fs.writeWithDirs(input.target.canonical, input.content)
103          return writeResult(input.target, existed)
104        }),
105      ),
106    )
107 
108    const writeTextPreservingBom = Effect.fn("FileMutation.writeTextPreservingBom")((input: TextWriteInput) =>
109      withTargetLock(input.target)(
110        Effect.gen(function* () {
111          const next = splitBom(input.content)
112          const current = yield* fs
113            .readFile(input.target.canonical)
114            .pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(undefined)))
115          yield* fs.writeWithDirs(
116            input.target.canonical,
117            joinBom(next.text, Boolean(current && hasUtf8Bom(current)) || next.bom),
118          )
119          return writeResult(input.target, current !== undefined)
120        }),
121      ),
122    )
123 
124    const create = Effect.fn("FileMutation.create")((input: WriteInput) =>
125      withTargetLock(input.target)(
126        Effect.gen(function* () {
127          const write =
128            typeof input.content === "string"
129              ? fs.writeFileString(input.target.canonical, input.content, { flag: "wx" })
130              : fs.writeFile(input.target.canonical, input.content, { flag: "wx" })
131          yield* write.pipe(
132            Effect.catchReason("PlatformError", "NotFound", () =>
133              fs.ensureDir(dirname(input.target.canonical)).pipe(Effect.andThen(write)),
134            ),
135            Effect.catchReason("PlatformError", "AlreadyExists", () =>
136              Effect.fail(new TargetExistsError({ path: input.target.canonical })),
137            ),
138          )
139          return writeResult(input.target, false)
140        }),
141      ),
142    )
143 
144    const writeIfUnchanged = Effect.fn("FileMutation.writeIfUnchanged")((input: ConditionalWriteInput) =>
145      withTargetLock(input.target)(
146        Effect.gen(function* () {
147          const current = yield* fs.readFile(input.target.canonical)
148          if (!sameBytes(current, input.expected)) {
149            return yield* new StaleContentError({ path: input.target.canonical })
150          }
151          yield* typeof input.content === "string"
152            ? fs.writeFileString(input.target.canonical, input.content)
153            : fs.writeFile(input.target.canonical, input.content)
154          return writeResult(input.target, true)
155        }),
156      ),
157    )
158 
159    const remove = Effect.fn("FileMutation.remove")((input: RemoveInput) =>
160      withTargetLock(input.target)(
161        Effect.gen(function* () {
162          const existed = yield* fs.remove(input.target.canonical).pipe(
163            Effect.as(true),
164            Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(false)),
165          )
166          return removeResult(input.target, existed)
167        }),
168      ),
169    )
170 
171    return Service.of({ create, write, writeTextPreservingBom, writeIfUnchanged, remove })
172  }),
173)
174 
175function splitBom(text: string) {
176  const stripped = text.replace(/^\uFEFF+/, "")
177  return { bom: stripped.length !== text.length, text: stripped }
178}
179 
180function joinBom(text: string, bom: boolean) {
181  const stripped = splitBom(text).text
182  return bom ? `\uFEFF${stripped}` : stripped
183}
184 
185function hasUtf8Bom(content: Uint8Array) {
186  return content[0] === 0xef && content[1] === 0xbb && content[2] === 0xbf
187}
188 
189function sameBytes(left: Uint8Array, right: Uint8Array) {
190  if (left.length !== right.length) return false
191  return left.every((byte, index) => byte === right[index])
192}
193 
194export const locationLayer = layer
195 
196export const node = makeLocationNode({ service: Service, layer, deps: [FSUtil.node] })
197 
198/**
199 * Deferred until the corresponding V2 integrations exist.
200 */
201// TODO: Add formatter integration after V2 formatter runtime exists.
202// TODO: Publish watcher/file-edit events after V2 watcher integration exists.
203// TODO: Add snapshots / undo after V2 snapshot design exists.
204// TODO: Notify LSP and collect diagnostics after V2 LSP runtime exists.
205// TODO: Design multi-file transactions / rollback if apply_patch needs atomic edits.
206// Until then, edits are sequential and report partial application.
207// TODO: Define crash recovery and idempotency for side effects between Tool.Called and durable settlement.
208