|
1 | | -import { Instance } from "../project/instance" |
2 | 1 | import { Log } from "../util/log" |
3 | | -import { Flag } from "../flag/flag" |
| 2 | +import { Flag } from "@/flag/flag" |
4 | 3 | import { Filesystem } from "../util/filesystem" |
| 4 | +import { Effect, Layer, ServiceMap, Semaphore } from "effect" |
| 5 | +import { runPromiseInstance } from "@/effect/runtime" |
| 6 | +import type { SessionID } from "@/session/schema" |
5 | 7 |
|
6 | | -export namespace FileTime { |
7 | | - const log = Log.create({ service: "file.time" }) |
8 | | - // Per-session read times plus per-file write locks. |
9 | | - // All tools that overwrite existing files should run their |
10 | | - // assert/read/write/update sequence inside withLock(filepath, ...) |
11 | | - // so concurrent writes to the same file are serialized. |
12 | | - export const state = Instance.state(() => { |
13 | | - const read: { |
14 | | - [sessionID: string]: { |
15 | | - [path: string]: Date | undefined |
16 | | - } |
17 | | - } = {} |
18 | | - const locks = new Map<string, Promise<void>>() |
19 | | - return { |
20 | | - read, |
21 | | - locks, |
22 | | - } |
23 | | - }) |
24 | | - |
25 | | - export function read(sessionID: string, file: string) { |
26 | | - log.info("read", { sessionID, file }) |
27 | | - const { read } = state() |
28 | | - read[sessionID] = read[sessionID] || {} |
29 | | - read[sessionID][file] = new Date() |
| 8 | +const log = Log.create({ service: "file.time" }) |
| 9 | + |
| 10 | +export namespace FileTimeService { |
| 11 | + export interface Service { |
| 12 | + readonly read: (sessionID: SessionID, file: string) => Effect.Effect<void> |
| 13 | + readonly get: (sessionID: SessionID, file: string) => Effect.Effect<Date | undefined> |
| 14 | + readonly assert: (sessionID: SessionID, filepath: string) => Effect.Effect<void> |
| 15 | + readonly withLock: <T>(filepath: string, fn: () => Promise<T>) => Effect.Effect<T> |
30 | 16 | } |
| 17 | +} |
31 | 18 |
|
32 | | - export function get(sessionID: string, file: string) { |
33 | | - return state().read[sessionID]?.[file] |
| 19 | +type Stamp = { |
| 20 | + readonly read: Date |
| 21 | + readonly mtime: number | undefined |
| 22 | + readonly ctime: number | undefined |
| 23 | + readonly size: number | undefined |
| 24 | +} |
| 25 | + |
| 26 | +function stamp(file: string): Stamp { |
| 27 | + const stat = Filesystem.stat(file) |
| 28 | + const size = typeof stat?.size === "bigint" ? Number(stat.size) : stat?.size |
| 29 | + return { |
| 30 | + read: new Date(), |
| 31 | + mtime: stat?.mtime?.getTime(), |
| 32 | + ctime: stat?.ctime?.getTime(), |
| 33 | + size, |
34 | 34 | } |
| 35 | +} |
35 | 36 |
|
36 | | - export async function withLock<T>(filepath: string, fn: () => Promise<T>): Promise<T> { |
37 | | - const current = state() |
38 | | - const currentLock = current.locks.get(filepath) ?? Promise.resolve() |
39 | | - let release: () => void = () => {} |
40 | | - const nextLock = new Promise<void>((resolve) => { |
41 | | - release = resolve |
42 | | - }) |
43 | | - const chained = currentLock.then(() => nextLock) |
44 | | - current.locks.set(filepath, chained) |
45 | | - await currentLock |
46 | | - try { |
47 | | - return await fn() |
48 | | - } finally { |
49 | | - release() |
50 | | - if (current.locks.get(filepath) === chained) { |
51 | | - current.locks.delete(filepath) |
| 37 | +function session(reads: Map<SessionID, Map<string, Stamp>>, sessionID: SessionID) { |
| 38 | + let value = reads.get(sessionID) |
| 39 | + if (!value) { |
| 40 | + value = new Map<string, Stamp>() |
| 41 | + reads.set(sessionID, value) |
| 42 | + } |
| 43 | + return value |
| 44 | +} |
| 45 | + |
| 46 | +export class FileTimeService extends ServiceMap.Service<FileTimeService, FileTimeService.Service>()( |
| 47 | + "@opencode/FileTime", |
| 48 | +) { |
| 49 | + static readonly layer = Layer.effect( |
| 50 | + FileTimeService, |
| 51 | + Effect.gen(function* () { |
| 52 | + const disableCheck = yield* Flag.OPENCODE_DISABLE_FILETIME_CHECK |
| 53 | + const reads = new Map<SessionID, Map<string, Stamp>>() |
| 54 | + const locks = new Map<string, Semaphore.Semaphore>() |
| 55 | + |
| 56 | + function getLock(filepath: string) { |
| 57 | + let lock = locks.get(filepath) |
| 58 | + if (!lock) { |
| 59 | + lock = Semaphore.makeUnsafe(1) |
| 60 | + locks.set(filepath, lock) |
| 61 | + } |
| 62 | + return lock |
52 | 63 | } |
53 | | - } |
| 64 | + |
| 65 | + return FileTimeService.of({ |
| 66 | + read: Effect.fn("FileTimeService.read")(function* (sessionID: SessionID, file: string) { |
| 67 | + log.info("read", { sessionID, file }) |
| 68 | + session(reads, sessionID).set(file, stamp(file)) |
| 69 | + }), |
| 70 | + |
| 71 | + get: Effect.fn("FileTimeService.get")(function* (sessionID: SessionID, file: string) { |
| 72 | + return reads.get(sessionID)?.get(file)?.read |
| 73 | + }), |
| 74 | + |
| 75 | + assert: Effect.fn("FileTimeService.assert")(function* (sessionID: SessionID, filepath: string) { |
| 76 | + if (disableCheck) return |
| 77 | + |
| 78 | + const time = reads.get(sessionID)?.get(filepath) |
| 79 | + if (!time) throw new Error(`You must read file ${filepath} before overwriting it. Use the Read tool first`) |
| 80 | + const next = stamp(filepath) |
| 81 | + const changed = next.mtime !== time.mtime || next.ctime !== time.ctime || next.size !== time.size |
| 82 | + |
| 83 | + if (changed) { |
| 84 | + throw new Error( |
| 85 | + `File ${filepath} has been modified since it was last read.\nLast modification: ${new Date(next.mtime ?? next.read.getTime()).toISOString()}\nLast read: ${time.read.toISOString()}\n\nPlease read the file again before modifying it.`, |
| 86 | + ) |
| 87 | + } |
| 88 | + }), |
| 89 | + |
| 90 | + withLock: Effect.fn("FileTimeService.withLock")(function* <T>(filepath: string, fn: () => Promise<T>) { |
| 91 | + const lock = getLock(filepath) |
| 92 | + return yield* Effect.promise(fn).pipe(lock.withPermits(1)) |
| 93 | + }), |
| 94 | + }) |
| 95 | + }), |
| 96 | + ) |
| 97 | +} |
| 98 | + |
| 99 | +export namespace FileTime { |
| 100 | + export function read(sessionID: SessionID, file: string) { |
| 101 | + return runPromiseInstance(FileTimeService.use((s) => s.read(sessionID, file))) |
| 102 | + } |
| 103 | + |
| 104 | + export function get(sessionID: SessionID, file: string) { |
| 105 | + return runPromiseInstance(FileTimeService.use((s) => s.get(sessionID, file))) |
54 | 106 | } |
55 | 107 |
|
56 | | - export async function assert(sessionID: string, filepath: string) { |
57 | | - if (Flag.OPENCODE_DISABLE_FILETIME_CHECK === true) { |
58 | | - return |
59 | | - } |
60 | | - |
61 | | - const time = get(sessionID, filepath) |
62 | | - if (!time) throw new Error(`You must read file ${filepath} before overwriting it. Use the Read tool first`) |
63 | | - const mtime = Filesystem.stat(filepath)?.mtime |
64 | | - // Allow a 50ms tolerance for Windows NTFS timestamp fuzziness / async flushing |
65 | | - if (mtime && mtime.getTime() > time.getTime() + 50) { |
66 | | - throw new Error( |
67 | | - `File ${filepath} has been modified since it was last read.\nLast modification: ${mtime.toISOString()}\nLast read: ${time.toISOString()}\n\nPlease read the file again before modifying it.`, |
68 | | - ) |
69 | | - } |
| 108 | + export async function assert(sessionID: SessionID, filepath: string) { |
| 109 | + return runPromiseInstance(FileTimeService.use((s) => s.assert(sessionID, filepath))) |
| 110 | + } |
| 111 | + |
| 112 | + export async function withLock<T>(filepath: string, fn: () => Promise<T>): Promise<T> { |
| 113 | + return runPromiseInstance(FileTimeService.use((s) => s.withLock(filepath, fn))) |
70 | 114 | } |
71 | 115 | } |
0 commit comments