@lardexx/arenacode 2.11.7 → 2.11.8

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,19 @@ 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.** Every session — transcript, task id, mode, label and the file diffs — is saved to
+
+```
+~/.arenacode/sessions/<folder>-<hash>.json
+```
+
+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`.
+
+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.8",
   "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));
@@ -182,6 +184,7 @@ class App {
     this.state.items.push(item);
     this.state.scroll = 0;
     this.invalidate();
+    this.scheduleSave();
     return item;
   }
 
@@ -276,6 +279,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 +447,52 @@ class App {
 
   // ---------------------------------------------------------------- sessions
 
+  /** Brings back the sessions of this folder from ~/.arenacode/sessions (if any). */
+  restoreSessions() {
+    let saved = null;
+    try {
+      saved = history.load(this.folder);
+    } catch {
+      saved = null;
+    }
+    if (!saved) return false;
+    this.sessions = saved.sessions.map((slot) => ({
+      ...slot,
+      seqItems: new Map(),
+      since: 0,
+    }));
+    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);
+    // 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 });
+    if (!res.ok) this.historyError = res.error;
+    return res;
+  }
+
+  /** 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;
@@ -478,6 +540,7 @@ class App {
     this.sessionIndex = this.sessions.length - 1;
     this.applySession();
     if (!silent) this.toast(`session ${this.sessionSeq} · new`);
+    this.scheduleSave();
   }
 
   activateSession(index) {
@@ -491,6 +554,7 @@ class App {
     this.applySession();
     const slot = this.sessions[index];
     this.toast(`session ${slot.id}${slot.label ? ` · ${slot.label}` : ''}`);
+    this.scheduleSave();
   }
 
   async openSessions() {
@@ -1046,6 +1110,7 @@ class App {
         if (ev.label) this.push({ kind: 'status', label: ev.label });
     }
     this.invalidate();
+    this.scheduleSave();
   }
 
   // ---------------------------------------------------------------- local cards
@@ -1481,7 +1546,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 +1572,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 +1596,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 +1797,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,144 @@
+'use strict';
+
+// The chat history of every session, on disk.
+//
+// One file per folder, so two projects never mix and the file name says which is which:
+//
+//   ~/.arenacode/sessions/<folder>-<hash>.json
+//
+// 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.
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+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
+
+function dir() {
+  return path.join(os.homedir(), '.arenacode', 'sessions');
+}
+
+function fileFor(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`);
+}
+
+function clip(value, max = MAX_TEXT) {
+  const text = String(value ?? '');
+  return text.length > max ? `${text.slice(0, max)}…` : text;
+}
+
+/** Only what can be written as JSON and read back: no functions, no cycles, no giant blobs. */
+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]);
+  }
+  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 (item.diff && Array.isArray(item.diff.rows)) {
+    out.diff = {
+      file: clip(item.diff.file || '', 300),
+      additions: Number(item.diff.additions) || 0,
+      deletions: Number(item.diff.deletions) || 0,
+      rows: item.diff.rows.slice(0, MAX_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),
+      })),
+    };
+  }
+  return out;
+}
+
+function cleanSession(slot, index) {
+  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,
+    mode: slot.mode || 'agent',
+    startedAt: Number(slot.startedAt) || Date.now(),
+    items,
+  };
+}
+
+function payload(folder, { sessions, active }) {
+  const clean = (Array.isArray(sessions) ? sessions : [])
+    .slice(-MAX_SESSIONS)
+    .map(cleanSession)
+    .filter(Boolean);
+  const wanted = Number(active);
+  return {
+    version: VERSION,
+    folder: path.resolve(folder || '.'),
+    savedAt: new Date().toISOString(),
+    active: Number.isFinite(wanted) ? Math.max(0, Math.min(clean.length - 1, wanted)) : 0,
+    sessions: clean,
+  };
+}
+
+/** Reads the saved sessions of a folder. Never throws: a broken file is "no history". */
+function load(folder) {
+  let raw;
+  try {
+    raw = fs.readFileSync(fileFor(folder), 'utf8');
+  } catch {
+    return null;
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  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 };
+}
+
+/** 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);
+  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 };
+  }
+}
+
+/** Removes the history of a folder (not wired to a command yet, used by the tests). */
+function clear(folder) {
+  try {
+    fs.unlinkSync(fileFor(folder));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = { fileFor, load, save, clear, cleanItem, VERSION, MAX_SESSIONS, MAX_ITEMS };

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) {