@lardexx/arenacode 2.11.7 → 2.11.9

package/README.md

@@ -118,7 +118,9 @@ How the copy is built and tested: [`docs/TUI.md`](docs/TUI.md).
 | `ctrl+v` | paste: a clipboard image becomes `images/clipboard-*.png` and is attached |
 | `!command` | run a command locally |
 | `↑` / `↓` | prompt history (or move through the slash list) |
-| `pgup` / `pgdn` | scroll the transcript |
+| `wheel` | scroll the transcript (three lines a notch) |
+| `pgup` / `pgdn` (or `ctrl+u` / `ctrl+j`) | scroll a page; `alt+↑` / `alt+↓` a line |
+| `home` / `end` | jump to the top / back to the bottom (when the prompt is empty) |
 | `ctrl+x` then | `q` quit · `n` new session · `l` switch session · `t` theme · `a` Ask and Proceed / Proceed · `d` tool output · `s` stop |
 | `ctrl+c` | interrupt, then quit |
 
@@ -325,9 +327,33 @@ 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.
 
-Sessions live in memory for the run of the client, the way the terminal client always behaved: nothing is
-written to disk, and the transcript of a session that was never used stays empty. The bridge keeps the tasks
-themselves — `/queue` shows them with their state and id.
+**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`:
+
+```
+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 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.
 
 ### Shells
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lardexx/arenacode",
-  "version": "2.11.7",
+  "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

@@ -24,6 +24,7 @@ const { attachRefs, attachImage, decorate, strings } = require('../attach');
 const { grabImage, readClipboardText, stamp } = require('../clipboard');
 const { decide, dangerText, approvalHelp, normaliseApproval } = require('../approval');
 const session = require('../session');
+const history = require('./history');
 
 const AGENT_PROMPT = (() => {
   try {
@@ -86,6 +87,7 @@ class App {
     this.sessionIndex = 0;
     this.sessionSeq = 0;
     this.newSession({ silent: true });
+    this.restoreSessions();
 
     this.term = new Term();
     this.parser = new KeyParser((key) => this.onKey(key));
@@ -112,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({
@@ -182,6 +210,7 @@ class App {
     this.state.items.push(item);
     this.state.scroll = 0;
     this.invalidate();
+    this.scheduleSave();
     return item;
   }
 
@@ -276,6 +305,19 @@ class App {
       this.invalidate();
       return undefined;
     }
+    // the wheel scrolls the transcript (three lines a notch, like every terminal app)
+    if (key.name === 'wheel') {
+      if (key.dir === 'up') st.scroll += 3;
+      else st.scroll = Math.max(0, st.scroll - 3);
+      this.invalidate();
+      return undefined;
+    }
+    // home/end jump to the two ends when the prompt is empty (they move the cursor otherwise)
+    if ((key.name === 'home' || key.name === 'end') && !st.input) {
+      st.scroll = key.name === 'home' ? Number.MAX_SAFE_INTEGER : 0;
+      this.invalidate();
+      return undefined;
+    }
 
     return this.editInput(key);
   }
@@ -431,6 +473,60 @@ class App {
 
   // ---------------------------------------------------------------- sessions
 
+  /** Brings back the sessions of this folder from the history directory (if any). */
+  restoreSessions() {
+    let saved = null;
+    try {
+      saved = history.load(this.folder);
+    } catch {
+      saved = null;
+    }
+    if (!saved) return false;
+    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.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 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;
+    this._saveTimer = setTimeout(() => {
+      this._saveTimer = null;
+      try {
+        this.persistSessions();
+      } catch {
+        /* a read-only HOME must not stop the client */
+      }
+    }, 600);
+    if (typeof this._saveTimer.unref === 'function') this._saveTimer.unref();
+  }
+
   /** Copies the live timeline into the active session slot. */
   saveSession() {
     const st = this.state;
@@ -464,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,
@@ -478,6 +575,7 @@ class App {
     this.sessionIndex = this.sessions.length - 1;
     this.applySession();
     if (!silent) this.toast(`session ${this.sessionSeq} · new`);
+    this.scheduleSave();
   }
 
   activateSession(index) {
@@ -487,10 +585,12 @@ class App {
       return;
     }
     this.saveSession();
+    this.persistSlot(this.sessions[this.sessionIndex]);
     this.sessionIndex = index;
     this.applySession();
     const slot = this.sessions[index];
     this.toast(`session ${slot.id}${slot.label ? ` · ${slot.label}` : ''}`);
+    this.scheduleSave();
   }
 
   async openSessions() {
@@ -1046,6 +1146,7 @@ class App {
         if (ev.label) this.push({ kind: 'status', label: ev.label });
     }
     this.invalidate();
+    this.scheduleSave();
   }
 
   // ---------------------------------------------------------------- local cards
@@ -1481,7 +1582,14 @@ class App {
     const st = this.state;
     const prompt = this.promptBlock(W);
     const taskTag = st.taskId ? `${st.taskId.slice(-6)} · ` : '';
-    const footer = W2.footerLine(t, { width: W, left: this.shortFolder(), right: `${taskTag}v${VERSION}` });
+    // built lazily: the session branch clamps `scroll` while slicing the transcript, and the
+    // footer must show the value the reader sees, not the one from before the clamp
+    const footerFor = () =>
+      W2.footerLine(t, {
+        width: W,
+        left: this.shortFolder(),
+        right: `${taskTag}v${VERSION}${st.scroll > 0 ? ` · ↑${st.scroll}` : ''}`,
+      });
 
     let frame = [];
     let cursor = null;
@@ -1500,7 +1608,7 @@ class App {
       frame.push(this.tipLine(W));
       while (frame.length < H - 2) frame.push('');
       frame.push('');
-      frame.push(footer);
+      frame.push(footerFor());
       if (prompt.cursor) cursor = { row: promptStart + prompt.cursor.row, col: prompt.cursor.col };
     } else {
       const chat = W2
@@ -1524,7 +1632,7 @@ class App {
       const promptStart = frame.length;
       frame.push(...prompt.lines);
       frame.push('');
-      frame.push(footer);
+      frame.push(footerFor());
       this._promptTop = promptStart;
       if (prompt.cursor) cursor = { row: promptStart + prompt.cursor.row, col: prompt.cursor.col };
     }
@@ -1725,6 +1833,15 @@ class App {
 
   quit() {
     this.running = false;
+    if (this._saveTimer) {
+      clearTimeout(this._saveTimer);
+      this._saveTimer = null;
+    }
+    try {
+      this.persistSessions();
+    } catch {
+      /* nothing to do on the way out */
+    }
     this.term.exit();
     process.exit(0);
   }

package/src/tui/history.js

@@ -0,0 +1,258 @@
+'use strict';
+
+// Chat history on disk: one file per session, plus a small index.
+//
+//   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
+//
+// 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).
+//
+// 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 path = require('node:path');
+const crypto = require('node:crypto');
+
+const { configPath } = require('../config');
+
+const VERSION = 1;
+const INDEX = 'index.json';
+
+/** Where the client keeps its configuration: the history lives next to it. */
+function baseDir() {
+  return path.dirname(configPath());
+}
+
+/** 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';
+}
+
+/** 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);
+  return path.join(baseDir(), 'sessions', `${slug(path.basename(abs))}-${hash}`);
+}
+
+function sessionFile(folder, id) {
+  return path.join(folderDir(folder), `session-${slug(String(id))}.json`);
+}
+
+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', 't0', 'shell']) {
+    if (item[key] === undefined) continue;
+    out[key] = item[key];
+  }
+  if (Array.isArray(item.files)) out.files = item.files.slice();
+  if (item.diff && Array.isArray(item.diff.rows)) {
+    out.diff = {
+      file: item.diff.file || '',
+      additions: Number(item.diff.additions) || 0,
+      deletions: Number(item.diff.deletions) || 0,
+      rows: item.diff.rows.map((row) => ({
+        type: row.type,
+        oldNo: row.oldNo === undefined ? null : row.oldNo,
+        newNo: row.newNo === undefined ? null : row.newNo,
+        text: row.text,
+      })),
+    };
+  }
+  return out;
+}
+
+function cleanSession(slot, fallbackId) {
+  if (!slot || typeof slot !== 'object') return null;
+  return {
+    version: VERSION,
+    id: Number(slot.id) || fallbackId,
+    label: slot.label || '',
+    taskId: slot.taskId || null,
+    mode: slot.mode || 'agent',
+    startedAt: Number(slot.startedAt) || Date.now(),
+    updatedAt: new Date().toISOString(),
+    items: (Array.isArray(slot.items) ? slot.items : []).map(cleanItem).filter(Boolean),
+  };
+}
+
+/** 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: Math.max(0, Math.min(Math.max(0, clean.length - 1), Number(active) || 0)),
+    sessions: clean,
+  };
+  return writeAtomic(indexFile(folder), JSON.stringify(body));
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 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 {
+    files = fs
+      .readdirSync(dir)
+      .filter((name) => /^session-.+\.json$/.test(name))
+      .sort((a, b) => String(a).localeCompare(String(b), undefined, { numeric: true }));
+  } catch {
+    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 (!sessions.length) return 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 };
+}
+
+function remove(folder, id) {
+  try {
+    fs.rmSync(sessionFile(folder, id), { force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Deletes every session of a folder. */
+function clear(folder) {
+  try {
+    fs.rmSync(folderDir(folder), { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  VERSION,
+  baseDir,
+  folderDir,
+  sessionFile,
+  indexFile,
+  saveSession,
+  saveIndex,
+  load,
+  remove,
+  clear,
+  cleanItem,
+};

package/src/tui/keys.js

@@ -9,6 +9,10 @@
  * A lone ESC is only reported after a short timeout, so escape sequences
  * (arrows, function keys) are not mistaken for the Esc key.
  */
+// SGR mouse: ESC [ < button ; x ; y M (press) or m (release). The wheel is button 64/65.
+const MOUSE_RE = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/;
+const WHEEL_STEP = { 64: 'up', 65: 'down' };
+
 const CSI_KEYS = {
   A: 'up',
   B: 'down',
@@ -82,6 +86,11 @@ class KeyParser {
       if (i >= b.length) return null;
       return b.slice(0, i + 1);
     }
+    if (b[1] === 'M') {
+      // X10 mouse: ESC [ M + 3 bytes (button, x+32, y+32)
+      if (b.length < 6) return null;
+      return b.slice(0, 6);
+    }
     if (b[1] === 'O') {
       if (b.length < 3) return null;
       return b.slice(0, 3);
@@ -106,7 +115,25 @@ class KeyParser {
       return mk(seq);
     }
 
+    if (seq[0] === '\x1b' && seq[1] === 'M' && seq.length === 6) {
+      const button = seq.charCodeAt(3) - 32;
+      const x = seq.charCodeAt(4) - 32;
+      const y = seq.charCodeAt(5) - 32;
+      const wheel = WHEEL_STEP[button & 0x43] || WHEEL_STEP[button];
+      if (wheel) return mk('wheel', { dir: wheel, x, y });
+      return mk('mouse', { button: button & 3, x, y, release: (button & 3) === 3 });
+    }
+
     if (seq[0] === '\x1b' && seq[1] === '[') {
+      const mouse = MOUSE_RE.exec(seq);
+      if (mouse) {
+        const code = Number(mouse[1]);
+        // bit 6 (64) marks the wheel; bit 5 (32) marks motion, which we ignore
+        const wheel = WHEEL_STEP[code & 0x43] || WHEEL_STEP[code];
+        if (wheel) return mk('wheel', { dir: wheel, x: Number(mouse[2]), y: Number(mouse[3]) });
+        if (code & 32) return null;
+        return mk('mouse', { button: code & 3, x: Number(mouse[2]), y: Number(mouse[3]), release: mouse[4] === 'm' });
+      }
       const body = seq.slice(2, -1);
       const final = seq[seq.length - 1];
       if (final === '~') {

package/src/tui/term.js

@@ -9,6 +9,10 @@ const SHOW_CURSOR = '\x1b[?25h';
 const SYNC_ON = '\x1b[?2026h';
 const SYNC_OFF = '\x1b[?2026l';
 const CLEAR = '\x1b[2J\x1b[H';
+// Mouse reporting: buttons and the wheel (1000) with the SGR coordinates (1006).
+// Without it a terminal sends nothing when the user scrolls over the transcript.
+const MOUSE_ON = '\x1b[?1000h\x1b[?1006h';
+const MOUSE_OFF = '\x1b[?1006l\x1b[?1000l';
 
 /**
  * Thin wrapper over the tty: alternate screen, raw mode, resize events and
@@ -35,7 +39,7 @@ class Term {
     if (this.entered) return;
     this.entered = true;
     if (this.altScreen) stdout.write(ENTER_ALT);
-    stdout.write(CLEAR + HIDE_CURSOR);
+    stdout.write(CLEAR + HIDE_CURSOR + MOUSE_ON);
     if (stdin.isTTY) stdin.setRawMode(true);
     stdin.resume();
     stdin.setEncoding('utf8');
@@ -51,7 +55,7 @@ class Term {
     stdout.removeListener('resize', this._onResize);
     if (stdin.isTTY) stdin.setRawMode(false);
     stdin.pause();
-    stdout.write(SHOW_CURSOR + (this.altScreen ? EXIT_ALT : '\n'));
+    stdout.write(MOUSE_OFF + SHOW_CURSOR + (this.altScreen ? EXIT_ALT : '\n'));
   }
 
   on(event, fn) {