@cjhyy/code-shell-core 0.8.8 → 0.8.10

package/dist/run/Heartbeat.js

@@ -8,10 +8,12 @@
  * File: ~/.code-shell/runs/<runId>/heartbeat
  * Content: JSON { pid, timestamp, runId }
  */
-import { existsSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
+import { closeSync, constants, existsSync, fstatSync, lstatSync, openSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
 import { homedir } from "node:os";
+import { randomUUID } from "node:crypto";
 import { assertSafeRunId } from "./ids.js";
+const MAX_HEARTBEAT_BYTES = 64 * 1024;
 export class Heartbeat {
     runsDir;
     intervalMs;
@@ -66,14 +68,42 @@ export class Heartbeat {
     read(runId) {
         assertSafeRunId(runId);
         const filePath = this.filePath(runId);
+        try {
+            const parentInfo = lstatSync(dirname(filePath));
+            if (parentInfo.isSymbolicLink() || !parentInfo.isDirectory())
+                return null;
+        }
+        catch {
+            return null;
+        }
         if (!existsSync(filePath))
             return null;
+        let fd;
         try {
-            return JSON.parse(readFileSync(filePath, "utf-8"));
+            const entry = lstatSync(filePath);
+            if (entry.isSymbolicLink() || !entry.isFile() || entry.size > MAX_HEARTBEAT_BYTES)
+                return null;
+            fd = openSync(filePath, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+            const opened = fstatSync(fd);
+            if (!opened.isFile() || opened.size > MAX_HEARTBEAT_BYTES)
+                return null;
+            const value = JSON.parse(readFileSync(fd, "utf-8"));
+            if (value.runId !== runId ||
+                !Number.isSafeInteger(value.pid) ||
+                (value.pid ?? 0) <= 0 ||
+                !Number.isSafeInteger(value.timestamp) ||
+                (value.timestamp ?? -1) < 0) {
+                return null;
+            }
+            return value;
         }
         catch {
             return null;
         }
+        finally {
+            if (fd !== undefined)
+                closeSync(fd);
+        }
     }
     /**
      * Check if a run's heartbeat is stale (older than threshold).
@@ -110,17 +140,46 @@ export class Heartbeat {
             timestamp: Date.now(),
             runId,
         };
+        const filePath = this.filePath(runId);
+        const temporary = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
         try {
-            writeFileSync(this.filePath(runId), JSON.stringify(data), "utf-8");
+            const parent = dirname(filePath);
+            const parentInfo = lstatSync(parent);
+            if (parentInfo.isSymbolicLink() || !parentInfo.isDirectory())
+                return;
+            try {
+                const targetInfo = lstatSync(filePath);
+                if (targetInfo.isSymbolicLink() || !targetInfo.isFile())
+                    return;
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    return;
+            }
+            writeFileSync(temporary, JSON.stringify(data), {
+                encoding: "utf8",
+                mode: 0o600,
+                flag: "wx",
+            });
+            renameSync(temporary, filePath);
         }
         catch {
             // Run directory may have been deleted
         }
+        finally {
+            rmSync(temporary, { force: true });
+        }
     }
     remove(runId) {
         try {
             const filePath = this.filePath(runId);
+            const parentInfo = lstatSync(dirname(filePath));
+            if (parentInfo.isSymbolicLink() || !parentInfo.isDirectory())
+                return;
             if (existsSync(filePath)) {
+                const targetInfo = lstatSync(filePath);
+                if (targetInfo.isSymbolicLink() || !targetInfo.isFile())
+                    return;
                 unlinkSync(filePath);
             }
         }

package/dist/services/auto-dream.js

@@ -4,7 +4,7 @@
  * Periodically consolidates and organizes memories using the LLM,
  * similar to the /dream command but running automatically.
  */
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { closeSync, constants, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, } from "node:fs";
 import { join } from "node:path";
 import { resolveMemoryBaseDir } from "../session/memory.js";
 import { mutateJsonFile } from "../utils/file-mutex.js";
@@ -13,6 +13,8 @@ const DEFAULT_CONFIG = {
     minTimeBetween: 24 * 60 * 60 * 1000, // 24 hours
     enabled: true,
 };
+const MAX_DREAM_STATE_BYTES = 64 * 1024;
+const MAX_SESSION_COUNT = 1_000_000;
 // Co-locate the dream-cadence state with the memories it tracks: both resolve
 // through resolveMemoryBaseDir (CODE_SHELL_HOME ?? $HOME ?? homedir()), so a
 // relocated/test HOME moves them together and never writes the real ~/.code-shell.
@@ -21,18 +23,38 @@ function getStateFile() {
 }
 function loadState() {
     const stateFile = getStateFile();
-    if (existsSync(stateFile)) {
-        try {
-            return JSON.parse(readFileSync(stateFile, "utf-8"));
+    let descriptor;
+    try {
+        const pathInfo = lstatSync(stateFile);
+        if (pathInfo.isSymbolicLink() || !pathInfo.isFile() || pathInfo.size > MAX_DREAM_STATE_BYTES) {
+            return { lastDreamAt: null, sessionsSinceLastDream: 0 };
         }
-        catch { }
+        descriptor = openSync(stateFile, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        const opened = fstatSync(descriptor);
+        if (!opened.isFile() || opened.size > MAX_DREAM_STATE_BYTES) {
+            return { lastDreamAt: null, sessionsSinceLastDream: 0 };
+        }
+        return parseDreamState(readFileSync(descriptor, "utf-8"));
+    }
+    catch {
+        return { lastDreamAt: null, sessionsSinceLastDream: 0 };
+    }
+    finally {
+        if (descriptor !== undefined)
+            closeSync(descriptor);
     }
-    return { lastDreamAt: null, sessionsSinceLastDream: 0 };
 }
-function saveState(state) {
-    const stateFile = getStateFile();
-    mkdirSync(resolveMemoryBaseDir(), { recursive: true });
-    writeFileSync(stateFile, JSON.stringify(state, null, 2), "utf-8");
+function parseDreamState(raw) {
+    const parsed = JSON.parse(raw);
+    const timestamp = typeof parsed.lastDreamAt === "string" ? parsed.lastDreamAt : null;
+    const lastDreamAt = timestamp && timestamp.length <= 64 && Number.isFinite(Date.parse(timestamp)) ? timestamp : null;
+    const count = parsed.sessionsSinceLastDream;
+    return {
+        lastDreamAt,
+        sessionsSinceLastDream: typeof count === "number" && Number.isSafeInteger(count) && count >= 0
+            ? Math.min(count, MAX_SESSION_COUNT)
+            : 0,
+    };
 }
 /**
  * Read-modify-write the cadence state under a cross-process lock.
@@ -47,11 +69,7 @@ function mutateState(change) {
             if (raw === undefined)
                 return { lastDreamAt: null, sessionsSinceLastDream: 0 };
             try {
-                const parsed = JSON.parse(raw);
-                return {
-                    lastDreamAt: parsed.lastDreamAt ?? null,
-                    sessionsSinceLastDream: Number(parsed.sessionsSinceLastDream) || 0,
-                };
+                return parseDreamState(raw);
             }
             catch {
                 return { lastDreamAt: null, sessionsSinceLastDream: 0 };
@@ -59,6 +77,7 @@ function mutateState(change) {
         },
         serialize: (state) => JSON.stringify(state, null, 2),
         mutation: (current) => ({ value: change(current) }),
+        maxBytes: MAX_DREAM_STATE_BYTES,
     });
 }
 /**
@@ -99,7 +118,7 @@ export function recordSession() {
     // reached its threshold and auto-consolidation silently stopped happening.
     mutateState((state) => ({
         ...state,
-        sessionsSinceLastDream: state.sessionsSinceLastDream + 1,
+        sessionsSinceLastDream: Math.min(MAX_SESSION_COUNT, state.sessionsSinceLastDream + 1),
     }));
 }
 /**
@@ -111,9 +130,12 @@ export function recordSession() {
  * resetting to 0 threw away increments that belonged to the next cycle.
  */
 export function recordDreamComplete(consumed) {
+    const safeConsumed = typeof consumed === "number" && Number.isSafeInteger(consumed) && consumed >= 0
+        ? consumed
+        : undefined;
     mutateState((state) => ({
         lastDreamAt: new Date().toISOString(),
-        sessionsSinceLastDream: consumed === undefined ? 0 : Math.max(0, state.sessionsSinceLastDream - consumed),
+        sessionsSinceLastDream: safeConsumed === undefined ? 0 : Math.max(0, state.sessionsSinceLastDream - safeConsumed),
     }));
 }
 /**

package/dist/services/session-memory.js

@@ -4,10 +4,15 @@
  * Extracts and maintains conversation context as persistent memory
  * entries that survive across sessions.
  */
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { join } from "node:path";
 import { userHome } from "../settings/manager.js";
 import { sortSessionMemoriesByRecency } from "./session-memory-sort.js";
+const SESSION_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,255}$/u;
+const MAX_MEMORY_FILE_BYTES = 1024 * 1024;
+const MAX_MEMORY_ENTRIES = 20_000;
+const MAX_MEMORY_LIST_ITEMS = 1_000;
 // Resolve per-call (NOT a module const): userHome() reads $HOME live, so a
 // relocated/test HOME redirects writes instead of pinning the real ~/.code-shell
 // at import time (bun freezes a module-level homedir() and never re-reads it).
@@ -22,23 +27,54 @@ function memoryDir(baseDir) {
  */
 export function saveSessionMemory(entry, baseDir) {
     const dir = memoryDir(baseDir);
-    mkdirSync(dir, { recursive: true });
+    assertSessionMemoryEntry(entry);
+    ensureRealMemoryDirectory(dir);
     const file = join(dir, `${entry.sessionId}.json`);
-    writeFileSync(file, JSON.stringify(entry, null, 2), "utf-8");
+    assertSafeMemoryTarget(file);
+    const serialized = JSON.stringify(entry, null, 2);
+    if (Buffer.byteLength(serialized, "utf8") > MAX_MEMORY_FILE_BYTES) {
+        throw new Error("session memory is too large");
+    }
+    const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temporary, serialized, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        renameSync(temporary, file);
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
 }
 /**
  * Load a session memory by session ID.
  */
 export function loadSessionMemory(sessionId, baseDir) {
+    if (!validSessionId(sessionId))
+        return null;
     const file = join(memoryDir(baseDir), `${sessionId}.json`);
     if (!existsSync(file))
         return null;
+    let fd;
     try {
-        return JSON.parse(readFileSync(file, "utf-8"));
+        const dirInfo = lstatSync(memoryDir(baseDir));
+        if (dirInfo.isSymbolicLink() || !dirInfo.isDirectory())
+            return null;
+        const entry = lstatSync(file);
+        if (entry.isSymbolicLink() || !entry.isFile() || entry.size > MAX_MEMORY_FILE_BYTES)
+            return null;
+        fd = openSync(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        const opened = fstatSync(fd);
+        if (!opened.isFile() || opened.size > MAX_MEMORY_FILE_BYTES)
+            return null;
+        const parsed = JSON.parse(readFileSync(fd, "utf-8"));
+        return validSessionMemoryEntry(parsed) && parsed.sessionId === sessionId ? parsed : null;
     }
     catch {
         return null;
     }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
 }
 /**
  * List all session memories, most recent first.
@@ -47,21 +83,84 @@ export function listSessionMemories(limit = 50, baseDir) {
     const dir = memoryDir(baseDir);
     if (!existsSync(dir))
         return [];
+    try {
+        const info = lstatSync(dir);
+        if (info.isSymbolicLink() || !info.isDirectory())
+            return [];
+    }
+    catch {
+        return [];
+    }
     // Read all entries, then order by createdAt (not by filename — the filename
     // is the sessionId, which has no chronological meaning), then take `limit`.
     const entries = [];
-    for (const file of readdirSync(dir)) {
-        if (!file.endsWith(".json"))
+    const files = readdirSync(dir, { withFileTypes: true });
+    if (files.length > MAX_MEMORY_ENTRIES)
+        return [];
+    for (const file of files) {
+        if (!file.isFile() || !file.name.endsWith(".json"))
+            continue;
+        const sessionId = file.name.slice(0, -5);
+        if (!validSessionId(sessionId))
             continue;
         try {
-            entries.push(JSON.parse(readFileSync(join(dir, file), "utf-8")));
+            const entry = loadSessionMemory(sessionId, baseDir);
+            if (entry)
+                entries.push(entry);
         }
         catch {
             /* intentional: skip a corrupt/torn memory file rather than failing the
                whole listing — one bad entry must not hide all the others. */
         }
     }
-    return sortSessionMemoriesByRecency(entries).slice(0, limit);
+    const safeLimit = Number.isSafeInteger(limit) && limit > 0 ? Math.min(limit, MAX_MEMORY_LIST_ITEMS) : 0;
+    return sortSessionMemoriesByRecency(entries).slice(0, safeLimit);
+}
+function validSessionId(value) {
+    return typeof value === "string" && SESSION_ID_RE.test(value) && value !== "." && value !== "..";
+}
+function validSessionMemoryEntry(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const entry = value;
+    return (validSessionId(entry.sessionId) &&
+        typeof entry.summary === "string" &&
+        entry.summary.length <= 100_000 &&
+        validMemoryStringList(entry.keyTopics) &&
+        validMemoryStringList(entry.decisions) &&
+        typeof entry.createdAt === "string" &&
+        entry.createdAt.length <= 64 &&
+        Number.isFinite(Date.parse(entry.createdAt)) &&
+        (entry.tokenCount === undefined ||
+            (Number.isSafeInteger(entry.tokenCount) && entry.tokenCount >= 0 && entry.tokenCount <= 10_000_000)));
+}
+function validMemoryStringList(value) {
+    return (Array.isArray(value) &&
+        value.length <= 1_000 &&
+        value.every((item) => typeof item === "string" && item.length <= 4_096 && !item.includes("\0")));
+}
+function assertSessionMemoryEntry(entry) {
+    if (!validSessionMemoryEntry(entry))
+        throw new Error("invalid session memory entry");
+}
+function ensureRealMemoryDirectory(dir) {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const info = lstatSync(dir);
+    if (info.isSymbolicLink() || !info.isDirectory()) {
+        throw new Error("session memory directory must be a real directory");
+    }
+}
+function assertSafeMemoryTarget(file) {
+    try {
+        const info = lstatSync(file);
+        if (info.isSymbolicLink() || !info.isFile()) {
+            throw new Error("session memory target must be a regular file");
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
 }
 /**
  * Search session memories by keyword.

package/dist/session/file-history.d.ts

@@ -10,6 +10,10 @@ export interface FileSnapshot {
     backupPath: string;
     hash: string;
     size: number;
+    /** Original POSIX permission bits, restored independently of backup privacy. */
+    mode?: number;
+    /** Canonical location at capture time, used to detect parent symlink swaps. */
+    realPath?: string;
     /**
      * The conversation turn (one user message = one turn) this snapshot was taken
      * in. Powers turn-level undo (`latestTurnUndoTargets`). Optional so snapshots
@@ -37,6 +41,12 @@ export interface RedoRecord {
     turnSeq: number;
     /** Backup of the post-turn content to re-apply on redo. */
     backupPath: string;
+    /** False when the turn's result was file absence (for example a delete). */
+    existedAfter?: boolean;
+    /** Post-turn POSIX permission bits to restore on redo. */
+    mode?: number;
+    /** Canonical location of the target at capture time. */
+    realPath?: string;
     /**
      * Whether the file EXISTED before this turn (had a pre-turn snapshot). False
      * means the turn CREATED it — undo deleted it, so redo must recreate it (and
@@ -55,10 +65,20 @@ export interface RedoRecord {
 export interface CreatedMarker {
     filePath: string;
     turnSeq: number;
+    /** Canonical destination planned before the creating tool ran. */
+    realPath?: string;
     undone?: boolean;
 }
+export interface TurnUndoPlan {
+    /** Undefined denotes a legacy, pre-turnSeq history bucket. */
+    turnSeq?: number;
+    snapshots: FileSnapshot[];
+    createdPaths: string[];
+    filePaths: string[];
+}
 export declare class FileHistory {
     private readonly historyDir;
+    private lockDepth;
     private snapshots;
     /**
      * Redo material for undone turns, kept SEPARATE from `snapshots` so it never
@@ -77,6 +97,7 @@ export declare class FileHistory {
      * latestTurnUndoTargets). Omit it for callers without turn context.
      */
     saveSnapshot(filePath: string, turnSeq?: number): FileSnapshot | null;
+    private saveSnapshotUnlocked;
     /**
      * Record that `filePath` was CREATED in `turnSeq` — called by the engine hook
      * when the pre-edit saveSnapshot returns null (file did not exist yet). Idempotent
@@ -86,8 +107,27 @@ export declare class FileHistory {
      * re-armed) — only fresh turns create new markers.
      */
     recordCreated(filePath: string, turnSeq: number): void;
+    private recordCreatedUnlocked;
+    /**
+     * Capture a create marker before the tool runs, but do not persist it yet.
+     * `lstat` (rather than `existsSync`) deliberately treats dangling symlinks as
+     * existing: a failed/no-follow Write must never turn such a path into a
+     * create marker that a later undo would remove.
+     */
+    prepareCreated(filePath: string, turnSeq: number): CreatedMarker | null;
+    /** Persist a marker previously returned by prepareCreated after tool success. */
+    commitCreated(marker: CreatedMarker): void;
+    private commitCreatedUnlocked;
     /** Redo material captured by past undos (see RedoRecord). Returns a copy. */
     getRedoRecords(): RedoRecord[];
+    /** Latest redo records after accounting for create-only live turns. */
+    getLatestRedoRecords(): RedoRecord[];
+    /**
+     * Authoritative latest-turn plan, including turns that only created files.
+     * Keeping this decision in FileHistory prevents UI callers from accidentally
+     * selecting an older snapshot-only turn.
+     */
+    getLatestTurnUndoPlan(): TurnUndoPlan | null;
     /**
      * Get all snapshots for a specific file.
      */
@@ -138,8 +178,7 @@ export declare class FileHistory {
         filePath: string;
         ok: boolean;
     }>;
-    /** Greatest turnSeq among not-yet-undone created markers, or undefined. */
-    private latestLiveCreatedTurn;
+    private undoLatestTurnUnlocked;
     /**
      * Turn-level redo: re-apply a previously undone turn. For each redo target,
      * write the stashed post-turn content back to disk (existedBefore:false
@@ -153,6 +192,7 @@ export declare class FileHistory {
         filePath: string;
         ok: boolean;
     }>;
+    private redoLatestTurnUnlocked;
     /**
      * All snapshots in record (chronological) order. Used by undo to pick the
      * single most-recent modification across every file (see latestUndoTarget).
@@ -161,4 +201,25 @@ export declare class FileHistory {
     getAllSnapshots(): FileSnapshot[];
     private saveIndex;
     static loadFromDir(sessionDir: string): FileHistory;
+    /** Serialize every read-modify-write and refresh after taking the lock. */
+    private withCurrentIndex;
+    private reloadIndex;
+    private isSafeBackup;
+    private isContainedBackupPath;
+    /** Never follow a destination symlink while restoring an old file version. */
+    private isSafeDestination;
+    private canonicalizeNewPath;
+    private matchesRecordedLocation;
+    private restoreSnapshot;
+    private readMode;
+    private restoreMode;
+    private discardRedoTurn;
+    private turnKey;
+    private latestTurnUndoPlanInternal;
+    private isExactSnapshotSet;
+    private sameSnapshot;
+    private findSnapshot;
+    private findRedoRecord;
+    private isSnapshot;
+    private isRedoRecord;
 }