@wrongstack/core 0.8.6 → 0.9.1

package/dist/storage/index.js

@@ -1,6 +1,6 @@
 import { randomBytes, randomUUID, createHash } from 'crypto';
 import * as fsp from 'fs/promises';
-import * as path2 from 'path';
+import * as path7 from 'path';
 import * as os from 'os';
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
@@ -10,9 +10,9 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 async function atomicWrite(targetPath, content, opts = {}) {
-  const dir = path2.dirname(targetPath);
+  const dir = path7.dirname(targetPath);
   await fsp.mkdir(dir, { recursive: true });
-  const tmp = path2.join(dir, `.${path2.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  const tmp = path7.join(dir, `.${path7.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
   try {
     if (typeof content === "string") {
       await fsp.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
@@ -68,7 +68,7 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve2) => setTimeout(resolve2, delays[i]));
+      await new Promise((resolve3) => setTimeout(resolve3, delays[i]));
     }
   }
   throw lastErr;
@@ -174,24 +174,30 @@ var DefaultSessionStore = class {
     this.dir = opts.dir;
     this.events = opts.events;
   }
-  async create(meta) {
+  /** Join session ID to its absolute path within the store directory. */
+  sessionPath(id, ext) {
+    return path7.join(this.dir, `${id}${ext}`);
+  }
+  async ensureShardDir(_id) {
     await ensureDir(this.dir);
+    return this.dir;
+  }
+  async create(meta) {
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const id = meta.id ?? `${startedAt.replace(/[:.]/g, "-")}-${randomBytes(2).toString("hex")}`;
-    const file = path2.join(this.dir, `${id}.jsonl`);
+    const shardDir = await this.ensureShardDir(id);
+    const file = path7.join(shardDir, `${id}.jsonl`);
     let handle;
     try {
       handle = await fsp.open(file, "a", 384);
     } catch (err) {
       throw new Error(
         `Failed to open session file: ${err instanceof Error ? err.message : String(err)}`,
-        {
-          cause: err
-        }
+        { cause: err }
       );
     }
     try {
-      return new FileSessionWriter(id, handle, startedAt, meta, this.events, { dir: this.dir, filePath: file });
+      return new FileSessionWriter(id, handle, startedAt, meta, this.events, { dir: shardDir, filePath: file });
     } catch (err) {
       await handle.close().catch(() => {
       });
@@ -199,15 +205,7 @@ var DefaultSessionStore = class {
     }
   }
   async resume(id) {
-    const file = path2.join(this.dir, `${id}.jsonl`);
-    try {
-      await fsp.access(file, fsp.constants.R_OK);
-    } catch {
-      throw new Error(
-        `Session "${id}" not found \u2014 the session file does not exist or was deleted.`,
-        { cause: new Error("ENOENT") }
-      );
-    }
+    const file = this.sessionPath(id, ".jsonl");
     const data = await this.load(id);
     let handle;
     try {
@@ -239,7 +237,7 @@ var DefaultSessionStore = class {
     }
   }
   async load(id) {
-    const file = path2.join(this.dir, `${id}.jsonl`);
+    const file = this.sessionPath(id, ".jsonl");
     const raw = await fsp.readFile(file, "utf8");
     const lines = raw.split("\n").filter((l) => l.trim());
     const events = [];
@@ -259,8 +257,7 @@ var DefaultSessionStore = class {
   async list(limit = 20) {
     try {
       await ensureDir(this.dir);
-      const files = await fsp.readdir(this.dir);
-      const ids = files.filter((f) => f.endsWith(".jsonl")).map((f) => f.replace(/\.jsonl$/, ""));
+      const ids = await this.collectSessionIds(this.dir);
       const sessions = await Promise.all(ids.map((id) => this.summaryFor(id).catch(() => null)));
       const out = sessions.filter((s) => s !== null);
       out.sort((a, b) => {
@@ -273,13 +270,27 @@ var DefaultSessionStore = class {
       return [];
     }
   }
+  /** Recursively collect all session IDs from shard subdirectories. */
+  async collectSessionIds(dir) {
+    const ids = [];
+    const entries = await fsp.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path7.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        ids.push(...await this.collectSessionIds(full));
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        ids.push(entry.name.replace(/\.jsonl$/, ""));
+      }
+    }
+    return ids;
+  }
   async summaryFor(id) {
-    const manifest = path2.join(this.dir, `${id}.summary.json`);
+    const manifest = this.sessionPath(id, ".summary.json");
     try {
       const raw = await fsp.readFile(manifest, "utf8");
       return JSON.parse(raw);
     } catch {
-      const full = path2.join(this.dir, `${id}.jsonl`);
+      const full = this.sessionPath(id, ".jsonl");
       const stat3 = await fsp.stat(full);
       const summary = await this.summarize(id, stat3.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
@@ -292,12 +303,13 @@ var DefaultSessionStore = class {
     }
   }
   async delete(id) {
-    await fsp.unlink(path2.join(this.dir, `${id}.jsonl`));
-    await fsp.unlink(path2.join(this.dir, `${id}.summary.json`)).catch(() => void 0);
+    await fsp.unlink(this.sessionPath(id, ".jsonl"));
+    await fsp.unlink(this.sessionPath(id, ".summary.json")).catch(() => void 0);
   }
   async clearHistory(id) {
-    const file = path2.join(this.dir, `${id}.jsonl`);
-    const meta = path2.join(this.dir, `${id}.summary.json`);
+    await this.ensureShardDir(id);
+    const file = this.sessionPath(id, ".jsonl");
+    const meta = this.sessionPath(id, ".summary.json");
     const record = `${JSON.stringify({
       type: "session_start",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -341,7 +353,8 @@ var DefaultSessionStore = class {
       startedAt: start?.ts ?? (/* @__PURE__ */ new Date(0)).toISOString(),
       endedAt: end?.ts,
       model: start?.model,
-      provider: start?.provider
+      provider: start?.provider,
+      pendingToolUses: end?.pendingToolUses
     };
   }
   replay(events, sessionId = "unknown") {
@@ -418,7 +431,7 @@ var FileSessionWriter = class {
     this.meta = meta;
     this.events = events;
     this.resumed = opts.resumed ?? false;
-    this.manifestFile = opts.dir ? path2.join(opts.dir, `${id}.summary.json`) : "";
+    this.manifestFile = opts.dir ? path7.join(opts.dir, `${id}.summary.json`) : "";
     this.filePath = opts.filePath ?? "";
     this.summary = {
       id,
@@ -441,9 +454,6 @@ var FileSessionWriter = class {
   tokenIn = 0;
   tokenOut = 0;
   filePath;
-  /** Public accessor for the JSONL path — required by SessionWriter so
-   *  observability surfaces (`/fleet log`, FleetPanel) can locate the
-   *  transcript without recomputing the path from session metadata. */
   get transcriptPath() {
     return this.filePath || void 0;
   }
@@ -451,13 +461,16 @@ var FileSessionWriter = class {
   resumed;
   appendFailCount = 0;
   lastAppendWarnAt = 0;
-  // Rewind support: track pending file changes and prompt index
   promptIndex = 0;
   pendingFileSnapshots = [];
-  // Register a pending file change. Call recordFileChange() from tools.
+  /** Tracks open tool_use IDs during the current run to serialize on close for resume. */
+  openToolUses = /* @__PURE__ */ new Set();
   recordFileChange(input) {
     this.pendingFileSnapshots.push(input);
   }
+  get pendingToolUses() {
+    return Array.from(this.openToolUses);
+  }
   async writeSessionStartLazy() {
     const record = `${JSON.stringify({
       type: this.resumed ? "session_resumed" : "session_start",
@@ -500,13 +513,12 @@ var FileSessionWriter = class {
       }
     }
   }
-  /**
-   * Watch events as they're appended and keep the summary state hot, so
-   * `close()` can flush a `<id>.summary.json` manifest without re-reading
-   * the JSONL. `list()` reads only manifests, turning a per-session full
-   * parse into a single stat+read.
-   */
   observeForSummary(event) {
+    if (event.type === "tool_use") {
+      this.openToolUses.add(event.id);
+    } else if (event.type === "tool_result") {
+      this.openToolUses.delete(event.id);
+    }
     if (event.type === "user_input" && this.summary.title === "(empty session)") {
       this.summary = { ...this.summary, title: userInputTitle(event.content) };
     } else if (event.type === "llm_response") {
@@ -600,7 +612,16 @@ var FileSessionWriter = class {
       }
     }
     const truncated = kept.join("\n");
-    await fsp.writeFile(this.filePath, truncated + "\n", "utf8");
+    const tmpPath = `${this.filePath}.rewind.tmp`;
+    await fsp.writeFile(tmpPath, truncated + "\n", "utf8");
+    try {
+      await this.handle.close();
+      await fsp.rename(tmpPath, this.filePath);
+      this.handle = await fsp.open(this.filePath, "a", 384);
+    } catch (err) {
+      await fsp.unlink(tmpPath).catch(() => void 0);
+      throw err;
+    }
     await this.append({
       type: "rewound",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -634,7 +655,7 @@ function userInputTitle(content) {
 var QueueStore = class {
   file;
   constructor(opts) {
-    this.file = path2.join(opts.dir, "queue.json");
+    this.file = path7.join(opts.dir, "queue.json");
   }
   async write(items) {
     if (items.length === 0) {
@@ -701,7 +722,7 @@ var DefaultAttachmentStore = class {
     let data = input.data;
     if (this.spoolDir && bytes >= this.spoolThreshold) {
       await fsp.mkdir(this.spoolDir, { recursive: true });
-      spooledPath = path2.join(this.spoolDir, `${id}.bin`);
+      spooledPath = path7.join(this.spoolDir, `${id}.bin`);
       await atomicWrite(spooledPath, input.data, {
         encoding: input.kind === "image" ? "base64" : "utf8"
       });
@@ -871,7 +892,7 @@ ${body.trim()}`);
   async remember(text, scope = "project-memory") {
     return this.runSerialized(scope, async () => {
       const file = this.files[scope];
-      await ensureDir(path2.dirname(file));
+      await ensureDir(path7.dirname(file));
       let existing = "";
       try {
         existing = await fsp.readFile(file, "utf8");
@@ -1364,7 +1385,10 @@ var DefaultConfigLoader = class {
     }
     if (c.mode !== void 0 && !isContextWindowModeId(c.mode)) {
       const known = listContextWindowModes().map((m) => m.id).join(", ");
-      throw new Error(`Config: context.mode must be one of: ${known}`);
+      console.warn(
+        `[config] Ignoring unknown context.mode "${c.mode}" (expected one of: ${known}); falling back to "${DEFAULT_CONTEXT_WINDOW_MODE_ID}".`
+      );
+      c.mode = DEFAULT_CONTEXT_WINDOW_MODE_ID;
     }
   }
   validateIdentity(cfg) {
@@ -1440,7 +1464,7 @@ var RecoveryLock = class {
   sessionStore;
   probe;
   constructor(opts) {
-    this.file = path2.join(opts.dir, LOCK_FILE);
+    this.file = path7.join(opts.dir, LOCK_FILE);
     this.pid = opts.pid ?? process.pid;
     this.hostname = opts.hostname ?? os.hostname();
     this.maxAgeMs = opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
@@ -1488,12 +1512,17 @@ var RecoveryLock = class {
     };
   }
   /**
-   * Claim the lock for the given session. Overwrites any existing lock
-   * — the caller should have already handled abandonment (via
-   * `checkAbandoned`) before calling this.
+   * Claim the lock for the given session. Uses exclusive-create (`O_EXCL`)
+   * to detect whether another process acquired the lock between our
+   * `checkAbandoned()` call and now. If the file already exists, it means
+   * another process won the race and we throw instead of silently
+   * overwriting their recovery record.
+   *
+   * The caller MUST have already called `checkAbandoned()` and handled its
+   * null return before calling this.
    */
   async write(sessionId) {
-    await ensureDir(path2.dirname(this.file));
+    await ensureDir(path7.dirname(this.file));
     const lock = {
       v: 1,
       sessionId,
@@ -1501,7 +1530,15 @@ var RecoveryLock = class {
       hostname: this.hostname,
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await atomicWrite(this.file, JSON.stringify(lock), { mode: 384 });
+    try {
+      await fsp.writeFile(this.file, JSON.stringify(lock), { flag: "wx", mode: 384 });
+    } catch (err) {
+      const code = err.code;
+      if (code === "EEXIST") {
+        throw new Error(`Recovery lock already held by another process`);
+      }
+      throw err;
+    }
   }
   /**
    * Release the lock. Idempotent — silently succeeds if the file is
@@ -1945,12 +1982,14 @@ var SessionAnalyzer = class {
   }
 };
 var DefaultSessionRewinder = class {
-  constructor(sessionsDir) {
+  constructor(sessionsDir, projectRoot) {
     this.sessionsDir = sessionsDir;
+    this.projectRoot = projectRoot;
   }
   sessionsDir;
+  projectRoot;
   async listCheckpoints(sessionId) {
-    const file = path2.join(this.sessionsDir, `${sessionId}.jsonl`);
+    const file = path7.join(this.sessionsDir, `${sessionId}.jsonl`);
     const raw = await fsp.readFile(file, "utf8");
     const events = parseEvents(raw);
     const fileCountMap = /* @__PURE__ */ new Map();
@@ -1975,7 +2014,7 @@ var DefaultSessionRewinder = class {
     return checkpoints;
   }
   async rewindToCheckpoint(sessionId, checkpointIndex) {
-    const file = path2.join(this.sessionsDir, `${sessionId}.jsonl`);
+    const file = path7.join(this.sessionsDir, `${sessionId}.jsonl`);
     const raw = await fsp.readFile(file, "utf8");
     const events = parseEvents(raw);
     let targetIdx = -1;
@@ -2005,12 +2044,12 @@ var DefaultSessionRewinder = class {
         }
       }
     }
-    const result = await revertSnapshots(snapshotsToRevert);
+    const result = await revertSnapshots(snapshotsToRevert, this.projectRoot);
     const removedEvents = events.length - targetIdx - 1;
     return { ...result, toPromptIndex: checkpointIndex, removedEvents };
   }
   async rewindLastN(sessionId, n) {
-    const file = path2.join(this.sessionsDir, `${sessionId}.jsonl`);
+    const file = path7.join(this.sessionsDir, `${sessionId}.jsonl`);
     const raw = await fsp.readFile(file, "utf8");
     const events = parseEvents(raw);
     const checkpoints = [];
@@ -2035,11 +2074,11 @@ var DefaultSessionRewinder = class {
         snapshotsToRevert.push({ promptIndex: event.promptIndex, files: event.files });
       }
     }
-    const result = await revertSnapshots(snapshotsToRevert.reverse());
+    const result = await revertSnapshots(snapshotsToRevert.reverse(), this.projectRoot);
     return { ...result, toPromptIndex: targetIndex, removedEvents: snapshotsToRevert.length };
   }
   async rewindToStart(sessionId) {
-    const file = path2.join(this.sessionsDir, `${sessionId}.jsonl`);
+    const file = path7.join(this.sessionsDir, `${sessionId}.jsonl`);
     const raw = await fsp.readFile(file, "utf8");
     const events = parseEvents(raw);
     const allSnapshots = [];
@@ -2051,7 +2090,7 @@ var DefaultSessionRewinder = class {
     if (allSnapshots.length === 0) {
       return { revertedFiles: [], errors: [], toPromptIndex: 0, removedEvents: 0 };
     }
-    const result = await revertSnapshots(allSnapshots.reverse());
+    const result = await revertSnapshots(allSnapshots.reverse(), this.projectRoot);
     return { ...result, toPromptIndex: 0, removedEvents: allSnapshots.length };
   }
 };
@@ -2069,12 +2108,19 @@ function parseEvents(raw) {
   }
   return events;
 }
-async function revertSnapshots(snapshots) {
+async function revertSnapshots(snapshots, projectRoot) {
   const revertedFiles = [];
   const errors = [];
   for (const snapshot of snapshots) {
     for (const file of snapshot.files) {
       try {
+        const absPath = path7.resolve(file.path);
+        const root = path7.resolve(projectRoot);
+        const rel = path7.relative(root, absPath);
+        if (rel.startsWith("..") || path7.isAbsolute(rel)) {
+          errors.push(`${file.path}: path resolves outside project root \u2014 skipping`);
+          continue;
+        }
         if (file.action === "deleted") {
           if (file.before !== null) {
             await atomicWrite(file.path, file.before, { mode: 420 });
@@ -2630,8 +2676,8 @@ var FsError = class extends WrongStackError {
 // src/storage/goal-store.ts
 var MAX_JOURNAL_ENTRIES = 500;
 function goalFilePath(projectRoot) {
-  const hash = createHash("sha256").update(path2.resolve(projectRoot)).digest("hex").slice(0, 12);
-  return path2.join(os.homedir(), ".wrongstack", "projects", hash, "goal.json");
+  const hash = createHash("sha256").update(path7.resolve(projectRoot)).digest("hex").slice(0, 12);
+  return path7.join(os.homedir(), ".wrongstack", "projects", hash, "goal.json");
 }
 async function loadGoal(filePath) {
   let raw;