@lardexx/arenacode 2.11.8 → 2.11.9

package/README.md

@@ -327,17 +327,31 @@ Every timeline in the interface is a **session**: its own transcript, its own ta
 typed in it; `enter` switches to the selected session, `n` (or the `+ new session` row) starts a fresh one.
 `ctrl+x n` is the shortcut for a new session.
 
-**The history is on disk.** Every session — transcript, task id, mode, label and the file diffs — is saved to
+**The history is on disk, one file per session.** The sessions live next to the config file — the same base
+folder on the three systems, so a portable install (`ARENACODE_CONFIG`) carries its history with it:
+
+| System | Directory |
+|---|---|
+| Windows | `%APPDATA%\ArenaCode\sessions\<folder>-<hash>\` |
+| macOS | `~/.arenacode/sessions/<folder>-<hash>/` |
+| Linux | `~/.arenacode/sessions/<folder>-<hash>/` |
+
+Inside that directory there is **one JSON file per session** plus a small `index.json`:
 
 ```
-~/.arenacode/sessions/<folder>-<hash>.json
+session-1.json     the transcript of session 1: items, task id, mode, label, diffs
+session-2.json     the transcript of session 2 — writing session 1 never touches this
+index.json         the order of the sessions and which one was open
 ```
 
-one file per folder, so two projects never mix. The file is written a moment after each change and again on
-`/quit`, atomically (a temporary file, then a rename), and it is read back at the next start: the sessions you
-had are there, with the one you left open active. A file that cannot be parsed counts as "no history" and
-never stops the client, and it is capped: the last 20 sessions, 400 entries each, 80 diff rows per change, and
-a turn that was still running when the client closed comes back marked `closed`.
+One file per session means a turn rewrites only its own transcript, and nothing is capped: no limit on the
+number of sessions, on the entries of a session, on the length of a message or on the rows of a diff. Writes
+are atomic (a temporary file in the same directory, then a rename; on Windows, where an indexer can hold the
+file, it retries and then writes in place) and happen a moment after each change, on `/quit`, and on the way
+out through EOF, `Ctrl+C` or a signal. The file name is sanitised so a project called `a folder: <weird>?` still
+gives a legal name on Windows, and the folder carries a hash of the absolute path: two folders with the same
+name never mix. A corrupted `index.json` is rebuilt from the files, a corrupted `session-*.json` is skipped and
+the others still load; a turn that was running when the client closed comes back marked `closed`.
 
 The bridge keeps the tasks themselves — `/queue` shows them with their state and id.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lardexx/arenacode",
-  "version": "2.11.8",
+  "version": "2.11.9",
   "description": "Terminal client for ArenaCode: talks to an arena-bridge, streams the Agent Mode timeline, and runs local commands, file operations and computer automation on your PC (windows-use.dll on Windows, Xlib/XTest on Linux, osascript on macOS). Node port of the ArenaCode desktop client.",
   "license": "MIT",
   "type": "commonjs",

package/src/tui/app.js

@@ -114,6 +114,32 @@ class App {
       this.flush();
     });
     this.term.on('resize', () => this.invalidate());
+    // Leaving through EOF, Ctrl+C or a signal skips quit(): the history is written here too,
+    // synchronously, because the debounced save is not guaranteed to run before exit.
+    const flush = () => {
+      try {
+        if (this._saveTimer) {
+          clearTimeout(this._saveTimer);
+          this._saveTimer = null;
+        }
+        this.persistSessions();
+      } catch {
+        /* nothing to do on the way out */
+      }
+    };
+    process.once('exit', flush);
+    for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+      try {
+        process.once(signal, () => {
+          flush();
+          this.running = false;
+          this.term.exit();
+          process.exit(0);
+        });
+      } catch {
+        /* a platform without that signal */
+      }
+    }
     this.running = true;
     if (this.approval === 'proceed') {
       this.push({
@@ -447,7 +473,7 @@ class App {
 
   // ---------------------------------------------------------------- sessions
 
-  /** Brings back the sessions of this folder from ~/.arenacode/sessions (if any). */
+  /** Brings back the sessions of this folder from the history directory (if any). */
   restoreSessions() {
     let saved = null;
     try {
@@ -456,29 +482,37 @@ class App {
       saved = null;
     }
     if (!saved) return false;
-    this.sessions = saved.sessions.map((slot) => ({
-      ...slot,
-      seqItems: new Map(),
-      since: 0,
-    }));
+    this.sessions = saved.sessions;
     this.sessionSeq = this.sessions.reduce((max, slot) => Math.max(max, slot.id || 0), this.sessions.length);
     this.sessionIndex = saved.active;
     this.applySession();
-    this.historyFile = history.fileFor(this.folder);
+    this.historyDir = saved.dir;
     // a transient note, not a transcript line: the transcript must be exactly what was saved
     this.toast(`history: ${this.sessions.length} session(s) restored`);
     return true;
   }
 
-  /** Writes the sessions now (called on quit and from the debounced saver). */
-  persistSessions() {
-    this.saveSession();
-    this.historyFile = history.fileFor(this.folder);
-    const res = history.save(this.folder, { sessions: this.sessions, active: this.sessionIndex });
+  /** Writes one session to its own file. */
+  persistSlot(slot) {
+    if (!slot) return null;
+    const res = history.saveSession(this.folder, slot);
     if (!res.ok) this.historyError = res.error;
     return res;
   }
 
+  /**
+   * Writes the active session and the index. One file per session means a turn rewrites
+   * only its own transcript; the other sessions are untouched.
+   */
+  persistSessions() {
+    this.saveSession();
+    const res = this.persistSlot(this.sessions[this.sessionIndex]);
+    const index = history.saveIndex(this.folder, { sessions: this.sessions, active: this.sessionIndex });
+    this.historyDir = history.folderDir(this.folder);
+    if (!index.ok) this.historyError = index.error;
+    return res || index;
+  }
+
   /** Saves at most a few times a second: a turn pushes items in bursts. */
   scheduleSave() {
     if (this._saveTimer) return;
@@ -526,6 +560,7 @@ class App {
 
   newSession({ silent = false } = {}) {
     this.saveSession();
+    this.persistSlot(this.sessions[this.sessionIndex]);
     this.sessionSeq += 1;
     this.sessions.push({
       id: this.sessionSeq,
@@ -550,6 +585,7 @@ class App {
       return;
     }
     this.saveSession();
+    this.persistSlot(this.sessions[this.sessionIndex]);
     this.sessionIndex = index;
     this.applySession();
     const slot = this.sessions[index];

package/src/tui/history.js

@@ -1,144 +1,258 @@
 'use strict';
 
-// The chat history of every session, on disk.
+// Chat history on disk: one file per session, plus a small index.
 //
-// One file per folder, so two projects never mix and the file name says which is which:
+//   Windows   %APPDATA%\ArenaCode\sessions\<folder>-<hash>\session-<id>.json
+//   macOS     ~/.arenacode/sessions/<folder>-<hash>/session-<id>.json
+//   Linux     ~/.arenacode/sessions/<folder>-<hash>/session-<id>.json
 //
-//   ~/.arenacode/sessions/<folder>-<hash>.json
+// The base folder is the one the config file lives in (`dirname(configPath())`), so the
+// history follows the client's own configuration on the three systems, including when
+// ARENACODE_CONFIG points somewhere else (tests, portable installs).
 //
-// The shape is small on purpose — sessions with their transcript, the active index and a
-// version — because this file is read at every start of the client.
+// One directory per project folder — the name carries a hash of the absolute path, so two
+// folders with the same last segment never mix — and inside it one JSON file per session,
+// so writing a session never rewrites the others.
 
 const fs = require('node:fs');
-const os = require('node:os');
 const path = require('node:path');
 const crypto = require('node:crypto');
 
+const { configPath } = require('../config');
+
 const VERSION = 1;
-const MAX_SESSIONS = 20; // older sessions are dropped, newest kept
-const MAX_ITEMS = 400; // per session
-const MAX_TEXT = 8000; // characters per text/detail field
-const MAX_DIFF_ROWS = 80; // rows stored for a change card
+const INDEX = 'index.json';
+
+/** Where the client keeps its configuration: the history lives next to it. */
+function baseDir() {
+  return path.dirname(configPath());
+}
 
-function dir() {
-  return path.join(os.homedir(), '.arenacode', 'sessions');
+/** A folder name that is legal on Windows, macOS and Linux whatever the project is called. */
+function slug(name) {
+  const clean = String(name || '')
+    .replace(/[^A-Za-z0-9._-]+/g, '-')
+    .replace(/^[-.]+|[-.]+$/g, '')
+    .slice(0, 40);
+  return clean || 'root';
 }
 
-function fileFor(folder) {
+/** The directory of one project folder. */
+function folderDir(folder) {
   const abs = path.resolve(folder || '.');
   const hash = crypto.createHash('sha1').update(abs).digest('hex').slice(0, 10);
-  const base = path.basename(abs).replace(/[^A-Za-z0-9._-]+/g, '-').slice(0, 40) || 'root';
-  return path.join(dir(), `${base}-${hash}.json`);
+  return path.join(baseDir(), 'sessions', `${slug(path.basename(abs))}-${hash}`);
 }
 
-function clip(value, max = MAX_TEXT) {
-  const text = String(value ?? '');
-  return text.length > max ? `${text.slice(0, max)}…` : text;
+function sessionFile(folder, id) {
+  return path.join(folderDir(folder), `session-${slug(String(id))}.json`);
 }
 
-/** Only what can be written as JSON and read back: no functions, no cycles, no giant blobs. */
+function indexFile(folder) {
+  return path.join(folderDir(folder), INDEX);
+}
+
+/**
+ * Atomic write. `rename` replaces the target on POSIX and on Windows (Node asks for
+ * MOVEFILE_REPLACE_EXISTING), and the temporary file lives in the same directory, so it
+ * never crosses a filesystem. If Windows refuses the rename (an indexer or an antivirus
+ * holding the file), it retries, then writes in place so nothing is lost.
+ */
+function writeAtomic(file, body) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tmp, body, 'utf8');
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    try {
+      fs.renameSync(tmp, file);
+      return { ok: true, file, bytes: Buffer.byteLength(body) };
+    } catch (err) {
+      if (attempt === 2) {
+        try {
+          fs.writeFileSync(file, body, 'utf8');
+          fs.rmSync(tmp, { force: true });
+          return { ok: true, file, bytes: Buffer.byteLength(body), fallback: err.code || err.message };
+        } catch (second) {
+          fs.rmSync(tmp, { force: true });
+          return { ok: false, error: second.message, file };
+        }
+      }
+      // a short, synchronous pause is enough for a lock to be released
+      const until = Date.now() + 40;
+      while (Date.now() < until) {
+        /* spin */
+      }
+    }
+  }
+  return { ok: false, error: 'rename failed', file };
+}
+
+/** JSON with the fields that are worth keeping; anything else is dropped, never truncated. */
 function cleanItem(item) {
   if (!item || typeof item !== 'object') return null;
   const out = {};
-  for (const key of ['kind', 'text', 'label', 'detail', 'state', 'icon', 'meta', 'command', 'secs', 'seq', 'color']) {
-    if (item[key] === undefined || item[key] === null) continue;
-    out[key] = typeof item[key] === 'number' ? item[key] : clip(item[key]);
+  for (const key of ['kind', 'text', 'label', 'detail', 'state', 'icon', 'meta', 'command', 'secs', 'seq', 'color', 't0', 'shell']) {
+    if (item[key] === undefined) continue;
+    out[key] = item[key];
   }
-  if (item.files && Array.isArray(item.files)) out.files = item.files.slice(0, 20).map((f) => clip(f, 300));
-  if (item.shell) out.shell = true;
+  if (Array.isArray(item.files)) out.files = item.files.slice();
   if (item.diff && Array.isArray(item.diff.rows)) {
     out.diff = {
-      file: clip(item.diff.file || '', 300),
+      file: item.diff.file || '',
       additions: Number(item.diff.additions) || 0,
       deletions: Number(item.diff.deletions) || 0,
-      rows: item.diff.rows.slice(0, MAX_DIFF_ROWS).map((row) => ({
+      rows: item.diff.rows.map((row) => ({
         type: row.type,
-        oldNo: row.oldNo === null || row.oldNo === undefined ? null : Number(row.oldNo),
-        newNo: row.newNo === null || row.newNo === undefined ? null : Number(row.newNo),
-        text: clip(row.text, 400),
+        oldNo: row.oldNo === undefined ? null : row.oldNo,
+        newNo: row.newNo === undefined ? null : row.newNo,
+        text: row.text,
       })),
     };
   }
   return out;
 }
 
-function cleanSession(slot, index) {
+function cleanSession(slot, fallbackId) {
   if (!slot || typeof slot !== 'object') return null;
-  const items = (Array.isArray(slot.items) ? slot.items : [])
-    .slice(-MAX_ITEMS)
-    .map(cleanItem)
-    .filter(Boolean)
-    // a turn that was running when the client closed is not running any more
-    .map((item) => (item.state === 'running' ? { ...item, state: 'done', meta: item.meta || 'closed' } : item));
   return {
-    id: Number(slot.id) || index + 1,
-    label: clip(slot.label || '', 120),
-    taskId: slot.taskId ? String(slot.taskId) : null,
+    version: VERSION,
+    id: Number(slot.id) || fallbackId,
+    label: slot.label || '',
+    taskId: slot.taskId || null,
     mode: slot.mode || 'agent',
     startedAt: Number(slot.startedAt) || Date.now(),
-    items,
+    updatedAt: new Date().toISOString(),
+    items: (Array.isArray(slot.items) ? slot.items : []).map(cleanItem).filter(Boolean),
   };
 }
 
-function payload(folder, { sessions, active }) {
-  const clean = (Array.isArray(sessions) ? sessions : [])
-    .slice(-MAX_SESSIONS)
-    .map(cleanSession)
-    .filter(Boolean);
-  const wanted = Number(active);
-  return {
+/** Writes one session to its own file. */
+function saveSession(folder, slot) {
+  const clean = cleanSession(slot, Date.now());
+  if (!clean) return { ok: false, error: 'nothing to save', file: null };
+  const file = sessionFile(folder, clean.id);
+  const res = writeAtomic(file, JSON.stringify(clean));
+  return { ...res, id: clean.id };
+}
+
+/**
+ * Writes the index: the order of the sessions and which one was open. Small on purpose —
+ * the session list is drawn from here without reading a single transcript.
+ */
+function saveIndex(folder, { sessions = [], active = 0 } = {}) {
+  const clean = sessions
+    .map((slot, i) => ({
+      id: Number(slot && slot.id) || i + 1,
+      label: (slot && slot.label) || '',
+      taskId: (slot && slot.taskId) || null,
+      mode: (slot && slot.mode) || 'agent',
+      startedAt: Number(slot && slot.startedAt) || 0,
+      updatedAt: (slot && slot.updatedAt) || new Date().toISOString(),
+      items: Array.isArray(slot && slot.items) ? slot.items.length : 0,
+    }))
+    .sort((a, b) => a.id - b.id);
+  const body = {
     version: VERSION,
     folder: path.resolve(folder || '.'),
     savedAt: new Date().toISOString(),
-    active: Number.isFinite(wanted) ? Math.max(0, Math.min(clean.length - 1, wanted)) : 0,
+    active: Math.max(0, Math.min(Math.max(0, clean.length - 1), Number(active) || 0)),
     sessions: clean,
   };
+  return writeAtomic(indexFile(folder), JSON.stringify(body));
 }
 
-/** Reads the saved sessions of a folder. Never throws: a broken file is "no history". */
-function load(folder) {
-  let raw;
+function readJson(file) {
   try {
-    raw = fs.readFileSync(fileFor(folder), 'utf8');
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
   } catch {
     return null;
   }
-  let data;
+}
+
+/**
+ * Reads the sessions of a folder: the order comes from the index, a session whose file is
+ * missing or broken is skipped (never "all or nothing"), and with no usable index the
+ * files themselves are used, sorted by id.
+ */
+function load(folder) {
+  const dir = folderDir(folder);
+  const index = readJson(indexFile(folder));
+  const wanted = new Set();
+  if (index && Array.isArray(index.sessions)) for (const entry of index.sessions) wanted.add(`${entry.id}.json`);
+
+  let files = [];
   try {
-    data = JSON.parse(raw);
+    files = fs
+      .readdirSync(dir)
+      .filter((name) => /^session-.+\.json$/.test(name))
+      .sort((a, b) => String(a).localeCompare(String(b), undefined, { numeric: true }));
   } catch {
-    return null;
+    files = [];
+  }
+  // the index decides the order; files the index does not know about are appended
+  const ordered = [
+    ...files.filter((name) => wanted.has(name.replace(/^session-/, ''))),
+    ...files.filter((name) => !wanted.has(name.replace(/^session-/, ''))),
+  ];
+
+  const sessions = [];
+  for (const name of ordered) {
+    const data = readJson(path.join(dir, name));
+    if (!data || !Array.isArray(data.items)) continue;
+    sessions.push({
+      id: Number(data.id) || sessions.length + 1,
+      label: data.label || '',
+      taskId: data.taskId || null,
+      mode: data.mode || 'agent',
+      startedAt: Number(data.startedAt) || 0,
+      updatedAt: data.updatedAt || null,
+      items: data.items,
+      seqItems: new Map(),
+      since: 0,
+    });
   }
-  if (!data || data.version !== VERSION || !Array.isArray(data.sessions) || !data.sessions.length) return null;
-  const sessions = data.sessions.map(cleanSession).filter(Boolean);
   if (!sessions.length) return null;
-  const active = Number.isFinite(Number(data.active)) ? Math.max(0, Math.min(sessions.length - 1, Number(data.active))) : 0;
-  return { sessions, active, savedAt: data.savedAt || null };
+  sessions.sort((a, b) => a.id - b.id);
+
+  // which session was open: the index knows its id, and the id survives a missing file
+  let active = sessions.length - 1;
+  if (index && Array.isArray(index.sessions)) {
+    const entry = index.sessions[Number(index.active)];
+    const at = entry ? sessions.findIndex((slot) => slot.id === Number(entry.id)) : -1;
+    active = at >= 0 ? at : Math.max(0, Math.min(sessions.length - 1, Number(index.active) || 0));
+  }
+  return { sessions, active, dir };
 }
 
-/** Atomic write: a crash in the middle leaves the previous file intact. */
-function save(folder, state) {
-  const file = fileFor(folder);
-  const body = JSON.stringify(payload(folder, state || {}), null, 0);
+function remove(folder, id) {
   try {
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    const tmp = `${file}.${process.pid}.tmp`;
-    fs.writeFileSync(tmp, body, 'utf8');
-    fs.renameSync(tmp, file);
-    return { ok: true, file, bytes: Buffer.byteLength(body) };
-  } catch (err) {
-    return { ok: false, error: err.message, file };
+    fs.rmSync(sessionFile(folder, id), { force: true });
+    return true;
+  } catch {
+    return false;
   }
 }
 
-/** Removes the history of a folder (not wired to a command yet, used by the tests). */
+/** Deletes every session of a folder. */
 function clear(folder) {
   try {
-    fs.unlinkSync(fileFor(folder));
+    fs.rmSync(folderDir(folder), { recursive: true, force: true });
     return true;
   } catch {
     return false;
   }
 }
 
-module.exports = { fileFor, load, save, clear, cleanItem, VERSION, MAX_SESSIONS, MAX_ITEMS };
+module.exports = {
+  VERSION,
+  baseDir,
+  folderDir,
+  sessionFile,
+  indexFile,
+  saveSession,
+  saveIndex,
+  load,
+  remove,
+  clear,
+  cleanItem,
+};