@hncode/hncode 0.5.2 → 0.5.5

package/src/update.js

@@ -166,6 +166,28 @@ export function readUpdateStamp() {
   try { return JSON.parse(fs.readFileSync(updateStampFile(), 'utf8')); } catch { return null; }
 }
 
+// npm's own stderr from the background install, beside the stamp. A FILE because
+// the install outlives this process: a pipe belonged to hncode, and quitting
+// mid-install closed it under npm — the install died on EPIPE partway through.
+function updateLogFile() {
+  const dir = process.env.HNCODE_HOME || path.join(os.homedir(), '.hncode');
+  return path.join(dir, 'update-log.txt');
+}
+
+/** Last `n` bytes of a file, or ''. Never throws. */
+function tailOfFile(p, n = 4000) {
+  try {
+    const st = fs.statSync(p);
+    const fh = fs.openSync(p, 'r');
+    try {
+      const start = Math.max(0, st.size - n);
+      const buf = Buffer.alloc(st.size - start);
+      fs.readSync(fh, buf, 0, buf.length, start);
+      return buf.toString('utf8');
+    } finally { fs.closeSync(fh); }
+  } catch { return ''; }
+}
+
 /** Forget it, once it has been reported. Never throws. */
 export function clearUpdateStamp() {
   try { fs.unlinkSync(updateStampFile()); return true; } catch { return false; }
@@ -202,13 +224,23 @@ export function updateBackground(version = '') {
       return;
     }
 
+    // stderr lands in a file (survives this process); when the file cannot be
+    // opened, fall back to a pipe and the in-memory capture below.
+    const logFile = updateLogFile();
+    let logFd = null;
+    try {
+      fs.mkdirSync(path.dirname(logFile), { recursive: true });
+      logFd = fs.openSync(logFile, 'w');
+    } catch { logFd = null; }
+
     let child;
     try {
       child = spawnNpm(['install', '-g', `${PKG_NAME}@latest`], {
         detached: true,
-        stdio: ['ignore', 'ignore', 'pipe'],
+        stdio: ['ignore', 'ignore', logFd == null ? 'pipe' : logFd],
       });
     } catch (e) {
+      if (logFd != null) { try { fs.closeSync(logFd); } catch { /* already gone */ } }
       releaseInstallLock();
       const error = (e && e.message) || String(e);
       writeUpdateStamp({ status: 'error', version, error });
@@ -217,7 +249,7 @@ export function updateBackground(version = '') {
     }
 
     let stderr = '';
-    if (child.stderr) {
+    if (logFd == null && child.stderr) {
       child.stderr.setEncoding('utf8');
       child.stderr.on('data', (d) => {
         stderr += d;
@@ -230,17 +262,20 @@ export function updateBackground(version = '') {
     // it prevents.
     child.on('error', (e) => {
       releaseInstallLock();
+      if (logFd != null) { try { fs.closeSync(logFd); } catch { /* already gone */ } }
       writeUpdateStamp({ status: 'error', version, error: (e && e.message) || String(e) });
     });
     child.on('close', (code) => {
       releaseInstallLock();
+      if (logFd != null) { try { fs.closeSync(logFd); } catch { /* already gone */ } }
       // Exit code 0 is the only thing that means the files were replaced. Anything else —
       // no permission, an unreachable registry, a killed process — is recorded with npm's
       // own last words, which is what makes the next launch's message actionable.
       if (code === 0) {
         writeUpdateStamp({ status: 'installed', version });
       } else {
-        const tail = stderr.trim().split(/\r?\n/).slice(-6).join('\n');
+        const raw = logFd != null ? tailOfFile(logFile) : stderr;
+        const tail = raw.trim().split(/\r?\n/).slice(-6).join('\n');
         writeUpdateStamp({ status: 'error', version, code, error: tail || `npm exited ${code}` });
       }
     });

package/src/web.js

@@ -270,7 +270,53 @@ attachWebSocket(server, {
     }
 
     // --- API ------------------------------------------------------------------
-    if (p === '/api/state') return json(res, 200, { ok: true, ...hub.snapshot() });
+    if (p === '/api/state') {
+      // WHAT TO SEND, decided by the caller.
+      //
+      // `/api/state` used to answer with one fixed shape: every row, every tool result, the whole
+      // transcript. That is what a browser wants and the wrong answer for a script asking "what did the
+      // last turn do", which pays for the entire session to read the last few rows.
+      //
+      //   ?detail=full      every row, tool results included (the default: unchanged behaviour)
+      //   ?detail=summary   drop tool RESULTS, keep the "Used Bash (cmd)" rows and the assistant text
+      //   ?detail=minimal   assistant and user text only — no tool rows at all
+      //   ?turn=last        only the most recent turn (a turn starts at a user message)
+      //   ?turn=<n>         only turn n, counting from 1
+      //   ?limit=<n>        at most n rows, taken from the end
+      //
+      // All of them compose, so `/api/state?detail=summary&turn=last` is one request for "what just
+      // happened, and with which tools" without the payload of the results themselves.
+      const detail = String(url.searchParams.get('detail') || 'full');
+      const turn = url.searchParams.get('turn');
+      const limit = Number(url.searchParams.get('limit'));
+      const snap = hub.snapshot();
+      let rows = snap.rows;
+      // A turn begins at a user message; splitting on those is what makes "the last turn" mean the same
+      // thing here as it does in the transcript.
+      if (turn === 'last' || (turn && /^\d+$/.test(turn))) {
+        const starts = [];
+        rows.forEach((r, idx) => { if (r.role === 'user') starts.push(idx); });
+        const which = turn === 'last' ? starts.length - 1 : Number(turn) - 1;
+        if (which >= 0 && which < starts.length) {
+          const from = starts[which];
+          const to = which + 1 < starts.length ? starts[which + 1] : rows.length;
+          rows = rows.slice(from, to);
+        } else {
+          rows = [];   // no such turn: an empty list is the honest answer
+        }
+      }
+      if (detail === 'summary' || detail === 'minimal') {
+        // `summary` keeps the tool ROWS but clears their output: the caller wants to know which tools
+        // ran, not what they printed. `minimal` drops the rows entirely.
+        rows = rows.filter((r) => r.role !== 'tool' || detail === 'summary');
+        if (detail === 'summary') {
+          rows = rows.map((r) => (r.role === 'tool' ? { ...r, text: '', liveOutput: '', diff: undefined } : r));
+        }
+      }
+      // Any row carrying a `card` is an interactive prompt; those are never trimmed by `minimal`.
+      if (Number.isFinite(limit) && limit > 0) rows = rows.slice(-Math.floor(limit));
+      return json(res, 200, { ok: true, ...snap, rows, hidden: snap.totalRows - rows.length, detail, turn: turn || null });
+    }
 
     // The session list for the left rail. `listSavedSessions` already powers the
     // daemon's landing page, so a session page shows the same names in the same