@link-assistant/agent 0.27.0 → 0.27.1

package/src/file/time.ts

@@ -1,41 +1,118 @@
+import * as fs from 'fs';
+import * as path from 'path';
 import { Instance } from '../project/instance';
 import { Log } from '../util/log';
 
 export namespace FileTime {
   const log = Log.create({ service: 'file.time' });
+
+  // What we knew about a file when the session last read (or wrote) it.
+  // Comparing mtime/size for equality instead of `mtime > readTime` avoids
+  // false "modified since read" errors for files whose mtime is in the
+  // future (clock skew, archives, network mounts) and still catches edits
+  // made within the same millisecond as the read (upstream #17835).
+  export type Stamp = {
+    read: Date;
+    mtime: number | undefined;
+    size: number | undefined;
+  };
+
   export const state = Instance.state(() => {
     const read: {
       [sessionID: string]: {
-        [path: string]: Date | undefined;
+        [path: string]: Stamp | undefined;
       };
     } = {};
+    const locks = new Map<string, Promise<void>>();
     return {
       read,
+      locks,
     };
   });
 
+  // `dir/./a.txt`, `dir/a.txt`, relative paths and symlinked paths of the
+  // same file must share one entry (and one lock) (upstream #20367).
+  export function normalize(file: string) {
+    const resolved = path.resolve(Instance.directory, file);
+    try {
+      return fs.realpathSync(resolved);
+    } catch {
+      // Not created yet: canonicalize the parent so the key does not change
+      // once the file exists (e.g. /tmp -> /private/tmp on macOS).
+      try {
+        return path.join(
+          fs.realpathSync(path.dirname(resolved)),
+          path.basename(resolved)
+        );
+      } catch {
+        return resolved;
+      }
+    }
+  }
+
+  function stamp(file: string): Stamp {
+    try {
+      const info = fs.statSync(file);
+      return { read: new Date(), mtime: info.mtimeMs, size: info.size };
+    } catch {
+      return { read: new Date(), mtime: undefined, size: undefined };
+    }
+  }
+
   export function read(sessionID: string, file: string) {
+    file = normalize(file);
     log.info(() => ({ message: 'read', sessionID, file }));
     const { read } = state();
     read[sessionID] = read[sessionID] || {};
-    read[sessionID][file] = new Date();
+    read[sessionID][file] = stamp(file);
+  }
+
+  /** Forgets a deleted session's read stamps (issue #335 leak audit). */
+  export function clear(sessionID: string) {
+    delete state().read[sessionID];
   }
 
   export function get(sessionID: string, file: string) {
-    return state().read[sessionID]?.[file];
+    return state().read[sessionID]?.[normalize(file)]?.read;
   }
 
   export async function assert(sessionID: string, filepath: string) {
-    const time = get(sessionID, filepath);
+    filepath = normalize(filepath);
+    const time = state().read[sessionID]?.[filepath];
     if (!time)
       throw new Error(
         `You must read the file ${filepath} before overwriting it. Use the Read tool first`
       );
-    const stats = await Bun.file(filepath).stat();
-    if (stats.mtime.getTime() > time.getTime()) {
-      throw new Error(
-        `File ${filepath} has been modified since it was last read.\nLast modification: ${stats.mtime.toISOString()}\nLast read: ${time.toISOString()}\n\nPlease read the file again before modifying it.`
-      );
+    const next = stamp(filepath);
+    if (next.mtime === time.mtime && next.size === time.size) return;
+    throw new Error(
+      `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.`
+    );
+  }
+
+  // Serializes read-modify-write cycles on one file. Tool calls of a single
+  // step run concurrently (and `batch` uses Promise.all), so without this two
+  // edits of the same file both read the old content and the last write wins,
+  // silently dropping the other edit (upstream 5cf126d489).
+  export async function withLock<T>(
+    filepath: string,
+    fn: () => Promise<T>
+  ): Promise<T> {
+    filepath = normalize(filepath);
+    const { locks } = state();
+    const current = locks.get(filepath) ?? Promise.resolve();
+    let release: () => void = () => {};
+    const next = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    const chained = current.then(() => next);
+    locks.set(filepath, chained);
+    await current;
+    try {
+      return await fn();
+    } finally {
+      release();
+      if (locks.get(filepath) === chained) locks.delete(filepath);
     }
   }
 }

package/src/index.js

@@ -495,14 +495,13 @@ async function runServerMode(
     });
 
     // Subscribe to all bus events and output in selected format
-    const { unsub: eventUnsub, idlePromise: eventPromise } =
-      createBusEventSubscription({
-        sessionID,
-        eventHandler,
-        onError: () => {
-          hasError = true;
-        },
-      });
+    const { unsub: eventUnsub } = createBusEventSubscription({
+      sessionID,
+      eventHandler,
+      onError: () => {
+        hasError = true;
+      },
+    });
     unsub = eventUnsub;
 
     // Send message to session with specified model
@@ -527,20 +526,26 @@ async function runServerMode(
           temperature,
         }),
       }
-    ).catch((error) => {
-      hasError = true;
-      eventHandler.output({
-        type: 'error',
-        timestamp: Date.now(),
-        sessionID,
-        message: errorText(error),
-        error: error instanceof Error ? error.message : String(error),
+    )
+      // Read the reply to the end: it completes only after the prompt has
+      // returned, successful or not (issue #335).
+      .then((response) => response.text())
+      .catch((error) => {
+        hasError = true;
+        eventHandler.output({
+          type: 'error',
+          timestamp: Date.now(),
+          sessionID,
+          message: errorText(error),
+          error: error instanceof Error ? error.message : String(error),
+        });
       });
-    });
 
-    // Wait for session to become idle, then for the request rejection to be
-    // observed (see runDirectMode, #290).
-    await eventPromise;
+    // Wait for the request (its rejection must be observed, see
+    // runDirectMode, #290). `session.idle` is published before the reply is
+    // written, so the idle event has been handled by then; if the prompt
+    // failed before its loop started there is no idle event at all, and
+    // waiting for it hung the process (issue #335).
     await requestPromise;
   } finally {
     // Always clean up resources
@@ -592,14 +597,13 @@ async function runDirectMode(
     });
 
     // Subscribe to all bus events and output in selected format
-    const { unsub: eventUnsub, idlePromise: eventPromise } =
-      createBusEventSubscription({
-        sessionID,
-        eventHandler,
-        onError: () => {
-          hasError = true;
-        },
-      });
+    const { unsub: eventUnsub } = createBusEventSubscription({
+      sessionID,
+      eventHandler,
+      onError: () => {
+        hasError = true;
+      },
+    });
     unsub = eventUnsub;
 
     // Send message to session directly
@@ -629,11 +633,13 @@ async function runDirectMode(
       });
     });
 
-    // Wait for session to become idle, then for the prompt itself. A fatal
-    // failure publishes `session.idle` while unwinding, so awaiting only the
-    // idle event let the process exit before the rejection handler above ran
-    // — no error record, exit code 0 (#290).
-    await eventPromise;
+    // Wait for the prompt itself. A fatal failure publishes `session.idle`
+    // while unwinding, so awaiting only the idle event let the process exit
+    // before the rejection handler above ran — no error record, exit code 0
+    // (#290). `session.idle` is published synchronously before `prompt`
+    // settles, so its output has been written by then; and a prompt that
+    // fails before its loop starts never goes idle, so also waiting for the
+    // idle event hung the process (issue #335).
     await promptPromise;
   } finally {
     // Always clean up resources