jaitus 0.3.12 → 0.3.14

package/src/rewind.js

@@ -1,148 +1,149 @@
-// ─── Rewind: go back to any earlier turn ────────────────────────────────────────
-//
-// Esc+Esc rewinds the conversation to a previous point — and restores the files as
-// they were. The mechanism is simple and honest: before each user prompt
-// is processed, snapshot the message history; before any write/edit command the agent
-// makes, snapshot the file it is about to touch. Restoring a checkpoint then means
-// truncating the message array and copying the file bytes back.
-//
-// Snapshots live in memory for the session's life: this is undo, not backup. Files are
-// capped (count and size) so one `run_command` that rewrites a giant file cannot eat
-// the heap.
-
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-
-const MAX_FILE_SNAPSHOTS = 60;
-const MAX_FILE_BYTES = 2_000_000;
-
-/**
- * The rewind journal for one session. Kept per-session so two windows on the same
- * project never share checkpoints.
- */
-export function createJournal() {
-  const checkpoints = []; // { seq, at, prompt, messages, files }
-  const fileSnapshots = []; // newest last, global cap
-  let seqCounter = 0;
-
-  return {
-    /** Snapshot the conversation before a user prompt is processed. */
-    checkpoint(messages, files = []) {
-      // Checkpoints are full deep clones with NO size cap (only file snapshots are
-      // capped above) — with pasted images in history, 60 checkpoints of megabytes
-      // of base64 each is a straight road to heap death. Past the cap the CHECKPOINT
-      // copy keeps its structure but drops the pixels (live messages are untouched):
-      // rewinding across an image restores a note, not the pixels. Undo stays usable
-      // instead of OOMing the session.
-      const MAX_CHECKPOINT_BYTES = 4_000_000;
-      let snap;
-      try {
-        const raw = JSON.stringify(messages);
-        snap = raw.length > MAX_CHECKPOINT_BYTES
-          ? JSON.parse(JSON.stringify(messages, (key, value) =>
-              (key === 'data' && typeof value === 'string' && value.length > 100_000
-                ? '[image data omitted from checkpoint]' : value)))
-          : JSON.parse(raw);
-      } catch {
-        snap = [];
-      }
-      checkpoints.push({
-        seq: ++seqCounter,
-        at: new Date().toISOString(),
-        prompt: messages.filter((m) => m.role === 'user' && typeof m.content === 'string').at(-1)?.content?.slice(0, 120) || '',
-        messages: snap,
-        files,
-      });
-      if (checkpoints.length > 60) checkpoints.shift();
-    },
-
-    /** Remember a file's current bytes before the agent overwrites it. */
-    snapshotFile(absPath) {
-      if (fileSnapshots.length >= MAX_FILE_SNAPSHOTS) fileSnapshots.shift();
-      const seq = ++seqCounter; // monotonic: immune to clock granularity
-      const takenAt = new Date().toISOString();
-      try {
-        const stat = fs.statSync(absPath);
-        if (!stat.isFile() || stat.size > MAX_FILE_BYTES) return;
-        fileSnapshots.push({ path: absPath, data: fs.readFileSync(absPath), takenAt, seq });
-      } catch {
-        // Unreadable or vanished — restoring means deleting it if it exists now.
-        fileSnapshots.push({ path: absPath, data: null, takenAt, seq });
-      }
-    },
-
-    /**
-     * Snapshot every file this journal has already seen, plus the session save file.
-     * Used before run_command: the shell can touch anything, but re-snapshotting
-     * known files is bounded and covers the session's own blast radius.
-     */
-    snapshotTracked(cwd) {
-      for (const snap of fileSnapshots) {
-        try { this.snapshotFile(snap.path); } catch { /* already counted */ }
-      }
-      try { this.snapshotFile(path.join(cwd, '.jaitus', 'session.json')); } catch { /* fine */ }
-    },
-
-    /**
-     * The most recent snapshot of one path, as text.
-     *
-     * The journal already holds what a file looked like before the agent touched it,
-     * which is exactly the "before" side of a diff — so showing what an edit actually
-     * did costs a lookup rather than a second read of the disk.
-     */
-    latestSnapshot(absPath) {
-      for (let i = fileSnapshots.length - 1; i >= 0; i--) {
-        if (fileSnapshots[i].path === absPath) {
-          return fileSnapshots[i].data ? fileSnapshots[i].data.toString('utf8') : '';
-        }
-      }
-      return null;
-    },
-
-    /** Turn summaries for the rewind dialog, oldest first. */
-    list() {
-      return checkpoints.map((cp, i) => ({ index: i, at: cp.at, prompt: cp.prompt, files: cp.files.length }));
-    },
-
-    /**
-     * Restore checkpoint `index`: truncate messages to that point and restore every
-     * file the agent changed after it. Returns what happened, for the transcript.
-     */
-    restore(index, messages) {
-      const cp = checkpoints[index];
-      if (!cp) return { ok: false, error: 'No such checkpoint.' };
-      const restored = [];
-      const deleted = [];
-      for (const snap of [...fileSnapshots].reverse()) {
-        if (snap.seq <= cp.seq) continue;
-        try {
-          if (snap.data) {
-            fs.mkdirSync(path.dirname(snap.path), { recursive: true });
-            fs.writeFileSync(snap.path, snap.data);
-            restored.push(snap.path);
-          } else if (fs.existsSync(snap.path)) {
-            fs.rmSync(snap.path);
-            deleted.push(snap.path);
-          }
-        } catch { /* best effort per file */ }
-      }
-      messages.length = 0;
-      messages.push(...JSON.parse(JSON.stringify(cp.messages)));
-      return { ok: true, restored, deleted, messageCount: cp.messages.length };
-    },
-
-    /** Drop all checkpoints (new session, /clear). */
-    reset() {
-      checkpoints.length = 0;
-      fileSnapshots.length = 0;
-    },
-  };
-}
-
-/** Human-friendly absolute-path display (short home, forward slashes). */
-export function displayPath(p) {
-  const home = os.homedir();
-  const s = String(p || '');
-  return s.startsWith(home) ? `~${s.slice(home.length)}` : s;
-}
+// ─── Rewind: go back to any earlier turn ────────────────────────────────────────
+//
+// Esc+Esc rewinds the conversation to a previous point — and restores the files as
+// they were. The mechanism is simple and honest: before each user prompt
+// is processed, snapshot the message history; before any write/edit command the agent
+// makes, snapshot the file it is about to touch. Restoring a checkpoint then means
+// truncating the message array and copying the file bytes back.
+//
+// Snapshots live in memory for the session's life: this is undo, not backup. Files are
+// capped (count and size) so one `run_command` that rewrites a giant file cannot eat
+// the heap.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const MAX_FILE_SNAPSHOTS = 60;
+const MAX_FILE_BYTES = 2_000_000;
+
+/**
+ * The rewind journal for one session. Kept per-session so two windows on the same
+ * project never share checkpoints.
+ */
+export function createJournal() {
+  const checkpoints = []; // { seq, at, prompt, messages, files }
+  const fileSnapshots = []; // newest last, global cap
+  let seqCounter = 0;
+
+  return {
+    /** Snapshot the conversation before a user prompt is processed. */
+    checkpoint(messages, files = []) {
+      // Checkpoints are deep clones, and with pasted images in history 60 of them is
+      // megabytes of base64 each. Past the cap the CHECKPOINT copy (never the live
+      // conversation) replaces each large image with a text note: rewinding across it
+      // restores the note, not the pixels. The whole block is replaced, not just its
+      // data — an image block whose data is a sentence is rejected by every provider,
+      // so a rewind used to make every following request fail.
+      const MAX_CHECKPOINT_BYTES = 4_000_000;
+      const NOTE = { type: 'text', text: '[An image was here; it is not kept in undo history.]' };
+      const lighter = (key, value) => (value && typeof value === 'object' && value.type === 'image'
+        && String(value.source?.data || '').length > 100_000 ? NOTE : value);
+      let snap;
+      try {
+        const raw = JSON.stringify(messages);
+        snap = JSON.parse(raw.length > MAX_CHECKPOINT_BYTES ? JSON.stringify(messages, lighter) : raw);
+      } catch {
+        // Too large even to serialise: keep the structure without images rather than
+        // an empty checkpoint, which would rewind the conversation to nothing.
+        try { snap = JSON.parse(JSON.stringify(messages, (k, v) => (v && typeof v === 'object' && v.type === 'image' ? NOTE : v))); } catch { return; }
+      }
+      checkpoints.push({
+        seq: ++seqCounter,
+        at: new Date().toISOString(),
+        prompt: messages.filter((m) => m.role === 'user' && typeof m.content === 'string').at(-1)?.content?.slice(0, 120) || '',
+        messages: snap,
+        files,
+      });
+      if (checkpoints.length > 60) checkpoints.shift();
+    },
+
+    /** Remember a file's current bytes before the agent overwrites it. */
+    snapshotFile(absPath) {
+      if (fileSnapshots.length >= MAX_FILE_SNAPSHOTS) fileSnapshots.shift();
+      const seq = ++seqCounter; // monotonic: immune to clock granularity
+      const takenAt = new Date().toISOString();
+      try {
+        const stat = fs.statSync(absPath);
+        if (!stat.isFile() || stat.size > MAX_FILE_BYTES) return;
+        fileSnapshots.push({ path: absPath, data: fs.readFileSync(absPath), takenAt, seq });
+      } catch {
+        // Unreadable or vanished — restoring means deleting it if it exists now.
+        fileSnapshots.push({ path: absPath, data: null, takenAt, seq });
+      }
+    },
+
+    /**
+     * Snapshot every file this journal has already seen, plus the session save file.
+     * Used before run_command: the shell can touch anything, but re-snapshotting
+     * known files is bounded and covers the session's own blast radius.
+     */
+    snapshotTracked(cwd) {
+      for (const snap of fileSnapshots) {
+        try { this.snapshotFile(snap.path); } catch { /* already counted */ }
+      }
+      try { this.snapshotFile(path.join(cwd, '.jaitus', 'session.json')); } catch { /* fine */ }
+    },
+
+    /**
+     * The most recent snapshot of one path, as text.
+     *
+     * The journal already holds what a file looked like before the agent touched it,
+     * which is exactly the "before" side of a diff — so showing what an edit actually
+     * did costs a lookup rather than a second read of the disk.
+     */
+    latestSnapshot(absPath) {
+      for (let i = fileSnapshots.length - 1; i >= 0; i--) {
+        if (fileSnapshots[i].path === absPath) {
+          return fileSnapshots[i].data ? fileSnapshots[i].data.toString('utf8') : '';
+        }
+      }
+      return null;
+    },
+
+    /** Turn summaries for the rewind dialog, oldest first. */
+    list() {
+      return checkpoints.map((cp, i) => ({ index: i, at: cp.at, prompt: cp.prompt, files: cp.files.length }));
+    },
+
+    /**
+     * Restore checkpoint `index`: truncate messages to that point and restore every
+     * file the agent changed after it. Returns what happened, for the transcript.
+     */
+    restore(index, messages) {
+      const cp = checkpoints[index];
+      if (!cp) return { ok: false, error: 'No such checkpoint.' };
+      const restored = [];
+      const deleted = [];
+      for (const snap of [...fileSnapshots].reverse()) {
+        if (snap.seq <= cp.seq) continue;
+        try {
+          if (snap.data) {
+            fs.mkdirSync(path.dirname(snap.path), { recursive: true });
+            fs.writeFileSync(snap.path, snap.data);
+            restored.push(snap.path);
+          } else if (fs.existsSync(snap.path)) {
+            fs.rmSync(snap.path);
+            deleted.push(snap.path);
+          }
+        } catch { /* best effort per file */ }
+      }
+      messages.length = 0;
+      messages.push(...JSON.parse(JSON.stringify(cp.messages)));
+      return { ok: true, restored, deleted, messageCount: cp.messages.length };
+    },
+
+    /** Drop all checkpoints (new session, /clear). */
+    reset() {
+      checkpoints.length = 0;
+      fileSnapshots.length = 0;
+    },
+  };
+}
+
+/** Human-friendly absolute-path display (short home, forward slashes). */
+export function displayPath(p) {
+  const home = os.homedir();
+  const s = String(p || '');
+  return s.startsWith(home) ? `~${s.slice(home.length)}` : s;
+}

package/src/serviceNotice.js

@@ -0,0 +1,151 @@
+// ─── Service notices in the CLI ─────────────────────────────────────────────────
+//
+// The status page (www.jaitus.com/status) is the record. The CLI only says something
+// when it affects using Jaitus right now, the way flyctl checks its status page:
+//
+//   - At start-up, in the background with a short timeout: one line for a major or
+//     critical incident on the Jaitus service, maintenance in progress, or maintenance
+//     starting within 24 hours. Each notice at most once a day on this machine.
+//   - When a request has finally failed (after the usual retries) as unavailable, timed
+//     out or down for maintenance: the error says which known problem it is, or when
+//     Jaitus will be back.
+//
+// The server decides which notices qualify (GET /api/status/notices), by its own clock.
+// Nothing here ever blocks, and any failure is silent. JAITUS_NO_STATUS_CHECK=1 or CI
+// turns the start-up line off.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { HOME, endpoints } from './config.js';
+
+const TIMEOUT_MS = 2000;
+const DAY_MS = 24 * 60 * 60 * 1000;
+const SHOWN_FILE = path.join(HOME, 'notice-check.json');
+
+/** Whether the start-up line may run at all. */
+export function noticeCheckEnabled(env = process.env) {
+  return !(env.JAITUS_NO_STATUS_CHECK || env.CI);
+}
+
+/** The public notices payload, or null. Never throws. */
+export async function fetchNotices({ baseUrl = endpoints().baseUrl, fetchImpl = fetch, timeoutMs = TIMEOUT_MS } = {}) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(`${baseUrl}/api/status/notices`, { signal: ctrl.signal, headers: { accept: 'application/json' } });
+    if (!res.ok) return null;
+    const body = await res.json();
+    return body && typeof body === 'object' && body.data && typeof body.data === 'object' ? body.data : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/** "www.jaitus.com/status", from the configured site. */
+export function statusAddress(siteUrl = endpoints().siteUrl) {
+  return `${String(siteUrl).replace(/^https?:\/\//, '').replace(/\/+$/, '')}/status`;
+}
+
+// Text from the server is printed into a terminal: no escape codes, no control
+// characters, one short line.
+const clean = (t, max = 100) => {
+  const s = String(t ?? '')
+    // eslint-disable-next-line no-control-regex
+    .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, '')
+    // eslint-disable-next-line no-control-regex
+    .replace(/[\x00-\x1f\x7f-\x9f]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return s.length > max ? `${s.slice(0, max - 1)}…` : s;
+};
+const dropStop = (t) => t.replace(/[.!?…]+$/, '');
+
+/** The start-up line for one notice from the server's `cli` list. */
+export function lineFor(item, where = statusAddress()) {
+  if (!item || typeof item !== 'object') return null;
+  const title = dropStop(clean(item.title));
+  if (item.kind === 'incident') {
+    return `Jaitus is having problems${title ? `: ${title}` : ''}. Updates: ${where}`;
+  }
+  if (item.kind === 'maintenance' && item.phase === 'in_progress') {
+    const until = clean(item.until, 40);
+    if (item.overrun && until) return `Jaitus is down for maintenance, running past its planned end (${until}). Updates: ${where}`;
+    if (until) return `Jaitus is down for maintenance until ${until}. Updates: ${where}`;
+    return `Jaitus is down for maintenance. Updates: ${where}`;
+  }
+  if (item.kind === 'maintenance' && item.phase === 'upcoming') {
+    const when = clean(item.window, 60);
+    if (!when) return null;
+    return `Planned maintenance ${when}: Jaitus will not answer during it. Details: ${where}`;
+  }
+  return null;
+}
+
+function readShown(file) {
+  try {
+    const v = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return v && typeof v.shown === 'object' && v.shown ? v.shown : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * The one line to show at start-up, or null. A notice is shown at most once a day per
+ * machine; a planned window and the same window in progress are separate notices.
+ */
+export async function startupNotice({ env = process.env, now = Date.now(), file = SHOWN_FILE, fetchNotices: get = fetchNotices, where } = {}) {
+  if (!noticeCheckEnabled(env)) return null;
+  const data = await get().catch(() => null);
+  const items = Array.isArray(data?.cli) ? data.cli : [];
+  if (!items.length) return null;
+  const shown = readShown(file);
+  for (const item of items) {
+    const key = `${item?.id}:${item?.phase}`;
+    if (shown[key] != null && now - Number(shown[key]) < DAY_MS) continue;
+    const line = lineFor(item, where);
+    if (!line) continue;
+    shown[key] = now;
+    // Forget anything a week old, so the file never grows.
+    for (const k of Object.keys(shown)) if (now - Number(shown[k]) > 7 * DAY_MS) delete shown[k];
+    try {
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      fs.writeFileSync(file, JSON.stringify({ shown }));
+    } catch { /* read-only home: it may show again next start */ }
+    return line;
+  }
+  return null;
+}
+
+const EXPLAINED = new Set(['maintenance', 'unavailable', 'timeout']);
+
+/**
+ * A request that finally failed: add what the status page knows to the error's hint —
+ * when Jaitus is back from maintenance, or which known problem this is. Mutates and
+ * returns `error`; leaves it alone when there is nothing to add or the check fails.
+ */
+export async function explainFailure(error, { baseUrl, fetchNotices: get = fetchNotices, where } = {}) {
+  if (!error || !EXPLAINED.has(error.code)) return error;
+  const data = await get(baseUrl ? { baseUrl } : undefined).catch(() => null);
+  if (!data) return error;
+  const at = where || statusAddress();
+  const m = data.maintenance;
+  if (error.code === 'maintenance' || m?.enabled) {
+    const until = clean(m?.until, 40);
+    error.title = 'Down for maintenance';
+    error.hint = m?.enabled && until
+      ? (m.overrun
+        ? `It was planned to end at ${until} and is running late. Updates: ${at}`
+        : `Jaitus should be back by ${until}. Updates: ${at}`)
+      : `Try again shortly. Updates: ${at}`;
+    return error;
+  }
+  const incident = Array.isArray(data.incidents) ? data.incidents[0] : null;
+  const title = incident ? dropStop(clean(incident.title)) : '';
+  error.hint = title
+    ? `Known problem: ${title}. Updates: ${at}`
+    : `${error.hint ? `${dropStop(error.hint)}. ` : ''}Service status: ${at}`;
+  return error;
+}

package/src/sessions.js

@@ -9,6 +9,7 @@ import crypto from 'node:crypto';
 import { SESSIONS } from './config.js';
 import { c } from './ui.js';
 import { unifiedDiff } from './diff.js';
+import { TOOLS } from './agent/tools.js';
 
 function safeId(id) {
   return String(id || '').replace(/[^a-zA-Z0-9_-]/g, '').slice(0, 80);
@@ -195,6 +196,13 @@ export function replaySession(tui, messages) {
 /** The same one-line summary the live loop shows, without importing the tool table. */
 function summariseCall(call) {
   const input = call.input && typeof call.input === 'object' ? call.input : {};
+  // The same label the row had while the session ran. A second, guessed label here
+  // showed a resumed task list as `{"todos":[{"content":…` and a background read as
+  // `{"id":"bg1"}`.
+  const tool = TOOLS.find((t) => t.name === call.name);
+  if (tool?.summarise) {
+    try { const s = tool.summarise(input); if (s) return String(s); } catch { /* fall back below */ }
+  }
   if (input.command) return String(input.command);
   if (input.path) return String(input.path);
   if (input.pattern) return String(input.pattern);