ai-or-die 0.1.80 → 0.1.82

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-or-die",
-  "version": "0.1.80",
+  "version": "0.1.82",
   "description": "Universal AI coding terminal — Claude, Copilot, Gemini & more in your browser",
   "main": "src/server.js",
   "bin": {

package/src/artifact-review.js

@@ -487,8 +487,46 @@ function createArtifactReviewRouter(options) {
   if (typeof validatePath !== 'function') throw new TypeError('validatePath is required');
   if (typeof mintAssetToken !== 'function') throw new TypeError('mintAssetToken is required');
 
+  // Auto live-reload: one chokidar watcher per session, scoped to the canonical
+  // artifact file. On a settled write we broadcast a reload SIGNAL (the panel
+  // cache-busts the iframe; the feedback box lives outside it and survives).
+  // Capped, replaced on re-open, and torn down on /end. Best-effort: chokidar
+  // is loaded lazily so tests/headless runs without it degrade to no reload.
+  const MAX_WATCHERS = 64;
+  const watchers = new Map(); // sessionId -> { watcher, file }
+  function stopWatch(sessionId) {
+    const w = watchers.get(sessionId);
+    if (!w) return;
+    watchers.delete(sessionId);
+    try { w.watcher.close(); } catch (_) { /* already closed */ }
+  }
+  function startWatch(sessionId, file) {
+    const existing = watchers.get(sessionId);
+    if (existing) { if (existing.file === file) return; stopWatch(sessionId); }
+    if (watchers.size >= MAX_WATCHERS) { const first = watchers.keys().next().value; if (first) stopWatch(first); }
+    let chokidar;
+    try { chokidar = require('chokidar'); } catch (_) { return; }
+    let watcher;
+    try {
+      watcher = chokidar.watch(file, {
+        ignoreInitial: true,
+        depth: 0,
+        awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 30 },
+      });
+    } catch (_) { return; }
+    const onChange = () => {
+      if (!store.get(sessionId)) { stopWatch(sessionId); return; }
+      broadcastToSession(sessionId, { type: 'artifact_review_reload', sessionId });
+    };
+    watcher.on('change', onChange);
+    watcher.on('add', onChange);
+    watcher.on('error', () => stopWatch(sessionId));
+    watchers.set(sessionId, { watcher, file });
+  }
+
   const router = express.Router();
 
+
   router.post('/:sessionId/open', (req, res) => {
     const sessionId = req.params.sessionId;
     const file = req.body && req.body.file;
@@ -510,6 +548,7 @@ function createArtifactReviewRouter(options) {
     }
 
     const review = store.open(sessionId, validation.path);
+    startWatch(sessionId, validation.path);
     const viewUrl = artifactPath(sessionId, '/view', req);
     broadcastToSession(sessionId, {
       type: 'artifact_review_opened',
@@ -688,6 +727,7 @@ function createArtifactReviewRouter(options) {
   router.post('/:sessionId/end', (req, res) => {
     const sessionId = req.params.sessionId;
     const review = store.end(sessionId);
+    stopWatch(sessionId);
     if (!review) return res.status(404).json({ error: 'artifact review not found' });
     broadcastToSession(sessionId, { type: 'artifact_review_ended', sessionId });
     res.json({ ok: true, status: review.status });

package/src/public/app.js

@@ -286,8 +286,13 @@ class ClaudeCodeWebInterface {
         console.log('[Init] Checking sessions, tabs.size:', this.sessionTabManager.tabs.size);
         if (this.sessionTabManager.tabs.size > 0) {
             console.log('[Init] Found sessions, switching to first tab...');
-            // Sessions exist - switch to the first one (this will handle connecting)
-            const firstTabId = this.sessionTabManager.tabs.keys().next().value;
+            // Sessions exist - switch to the last-active one (persisted across
+            // reloads) so a refresh returns to the tab you were on, not tab #1.
+            let restoreId = null;
+            try { restoreId = localStorage.getItem('cc-active-session'); } catch (_) { /* private mode */ }
+            const firstTabId = (restoreId && this.sessionTabManager.tabs.has(restoreId))
+                ? restoreId
+                : this.sessionTabManager.tabs.keys().next().value;
             console.log('[Init] Switching to tab:', firstTabId);
             await this.sessionTabManager.switchToTab(firstTabId);
             // The session_joined handler decides the overlay state:
@@ -2524,8 +2529,13 @@ class ClaudeCodeWebInterface {
                     this.pendingJoinSessionId = null;
                 }
                 
-                // Replay output buffer if available
-                if (message.outputBuffer && message.outputBuffer.length > 0) {
+                // Repaint: prefer the rendered snapshot (clean last screen) so a
+                // refresh doesn't blank or show broken control sequences; fall
+                // back to raw outputBuffer replay when there's no snapshot.
+                if (message.renderedSnapshot) {
+                    this.terminal.clear();
+                    this.terminal.write(message.renderedSnapshot.replace(/\n/g, '\r\n'));
+                } else if (message.outputBuffer && message.outputBuffer.length > 0) {
                     this.terminal.clear();
                     message.outputBuffer.forEach(data => {
                         // Filter out focus tracking sequences (^[[I and ^[[O)
@@ -2738,6 +2748,10 @@ class ClaudeCodeWebInterface {
                 if (this._artifactPanel) this._artifactPanel.endReview(message);
                 break;
 
+            case 'artifact_review_reload':
+                if (this._artifactPanel) this._artifactPanel.reloadReview(message);
+                break;
+
             case 'artifact_agent_reply':
                 if (this._artifactPanel) this._artifactPanel.agentReply(message);
                 break;

package/src/public/artifact-panel.js

@@ -172,6 +172,14 @@
       this._iframe.src = review.viewUrl + sep + '_r=' + Date.now();
     }
 
+    // Server-driven auto live-reload: file changed under review. Only the active
+    // tab's iframe is cache-busted; the chat/feedback box is untouched.
+    reloadReview(message) {
+      const sessionId = message && message.sessionId ? String(message.sessionId) : this.activeSessionId;
+      if (!sessionId || sessionId !== this.activeSessionId || !this.reviews.has(sessionId)) return;
+      this.reload();
+    }
+
     // ---- iframe <-> server bridge ----------------------------------------
     _handleIframeMessage(event) {
       const data = event && event.data;

package/src/public/session-manager.js

@@ -737,6 +737,7 @@ class SessionTabManager {
         tab.classList.add('active');
         tab.setAttribute('aria-selected', 'true');
         this.activeTabId = sessionId;
+        try { localStorage.setItem('cc-active-session', sessionId); } catch (_) { /* private mode */ }
         this.ensureTabVisible(sessionId);
 
         // Update last accessed timestamp and clear unread indicator

package/src/server.js

@@ -3944,7 +3944,12 @@ class ClaudeCodeWebServer {
     this._pushEvictionEntry(claudeSessionId); // PROC-04
     session.lastAccessed = Date.now();
 
-    // Send session info and replay buffer
+    // Send session info and replay buffer. Prefer a live rendered tail, but
+    // never block the join on a slow drain — fall back to the stored snapshot.
+    let renderedSnapshot = session.renderedSnapshot || null;
+    if (session._ctlTranscript) {
+      renderedSnapshot = (await this._peekWithTimeout(session._ctlTranscript, 200, 300)) || renderedSnapshot;
+    }
     this.sendToWebSocket(wsInfo.ws, {
       type: 'session_joined',
       sessionId: claudeSessionId,
@@ -3954,6 +3959,7 @@ class ClaudeCodeWebServer {
       wasActive: session.wasActive || false,
       agent: session.agent || null,
       outputBuffer: session.outputBuffer.slice(-200), // Send last 200 lines
+      renderedSnapshot, // rendered last screen so idle/empty-buffer joins repaint
       stickyNote: session.stickyNote || null,
       autoTitle: session.nameIsUserSet ? null : (session.autoTitle || null),
       stickyNotesEnabled: session.stickyNotesEnabled !== false,
@@ -4462,6 +4468,43 @@ class ClaudeCodeWebServer {
     setTimeout(tick, 1500);
   }
 
+  // Artifact-review env trio for a spawned claude session. Injected whenever the
+  // server can serve /api/artifact — that's when auth is set OR auth is disabled
+  // (noAuth leaves the routes public, server.js:1179). Without it the in-tab
+  // agent's artifact_* tools stay dark and the viewer never opens. Token is the
+  // real bearer, or a 'noauth' sentinel under --disable-auth (the routes ignore
+  // it). Returns {} when the server is closed (auth required but unset), so a
+  // misconfigured instance never points the agent at routes it can't reach.
+  _artifactEnvForSession(sessionId) {
+    if (!this.auth && !this.noAuth) return {};
+    return {
+      AIORDIE_BASE_URL: `${this.useHttps ? 'https' : 'http'}://127.0.0.1:${this.port}`,
+      AIORDIE_TOKEN: this.auth || 'noauth',
+      AIORDIE_SESSION_ID: sessionId,
+    };
+  }
+
+  // Read a transcript's rendered tail, but never block longer than `ms` — a
+  // wedged xterm drain must not stall a join or strand a dispose. Resolves null
+  // on timeout/error so callers fall back to the stored snapshot.
+  _peekWithTimeout(t, lines, ms) {
+    return Promise.race([
+      Promise.resolve().then(() => t.peek(lines)).catch(() => null),
+      new Promise((r) => setTimeout(() => r(null), ms)),
+    ]);
+  }
+
+  // Capture the last rendered screen, then ALWAYS dispose — so a refresh
+  // repaints an exited session, without leaking the buffer if peek hangs.
+  _persistSnapshotAndDispose(s) {
+    const t = s._ctlTranscript;
+    if (!t) return;
+    s._ctlTranscript = null;
+    this._peekWithTimeout(t, 200, 1000)
+      .then((snap) => { if (snap) s.renderedSnapshot = snap; })
+      .finally(() => { try { t.dispose(); } catch (_) { /* already disposed */ } });
+  }
+
   // Headless agent spawn (no WebSocket): reuses the same bridge.startSession +
   async _controlStartAgent(sessionId, toolName, opts = {}) {
     const session = this.claudeSessions.get(sessionId);
@@ -4500,12 +4543,9 @@ class ClaudeCodeWebServer {
       const sidecar = this._prepareClaudeBindSidecar(sessionId, session);
       if (sidecar) extraEnv.AIORDIE_CLAUDE_BIND = sidecar; // deterministic JSONL turn detection (ADR-0026)
     } catch (_) { /* sidecar best-effort */ }
-    if (this.auth) {
-      // So a github-router-claude spawned here can drive the artifact-review loop.
-      extraEnv.AIORDIE_BASE_URL = `${this.useHttps ? 'https' : 'http'}://127.0.0.1:${this.port}`;
-      extraEnv.AIORDIE_TOKEN = this.auth;
-      extraEnv.AIORDIE_SESSION_ID = sessionId;
-    }
+    // So a github-router-claude spawned here can drive the artifact-review loop
+    // (works standalone and under --disable-auth; see _artifactEnvForSession).
+    Object.assign(extraEnv, this._artifactEnvForSession(sessionId));
 
     try { session._ctlTranscript = new TranscriptBuffer({ cols, rows }); } catch (_) { session._ctlTranscript = null; }
     session.active = true;
@@ -4540,7 +4580,9 @@ class ClaudeCodeWebServer {
             s.agent = null;
             s._lastExit = { code, signal };
             this.sessionStore.markDirty();
-            try { if (s._ctlTranscript) { s._ctlTranscript.dispose(); s._ctlTranscript = null; } } catch (_) { /* isolate */ }
+            // Persist the last rendered screen before disposing so a refresh
+            // repaints an idle/exited session instead of blank (always disposes).
+            this._persistSnapshotAndDispose(s);
             // F12: stop the coarse idle-debounce timer for unbound sessions.
             try { if (s._ctlIdleTimer) { clearTimeout(s._ctlIdleTimer); s._ctlIdleTimer = null; } } catch (_) { /* isolate */ }
           }
@@ -5159,6 +5201,19 @@ class ClaudeCodeWebServer {
         if (sidecarPath) terminalExtraEnv.AIORDIE_CLAUDE_BIND = sidecarPath;
       }
 
+      // Artifact-review parity for the manual (non-fleet) claude tab: a normally
+      // started claude tab gets the same env trio that _controlStartAgent injects,
+      // so the in-tab agent's artifact_* tools activate standalone — no control
+      // plane required. Injected when auth is set OR --disable-auth (routes are
+      // public then), so the viewer works standalone. Token leak to nested
+      // children is blocked by github-router's STRIPPED_PARENT_ENV_KEYS.
+      const claudeArtifactEnv = toolName === 'claude' ? this._artifactEnvForSession(sessionId) : {};
+
+      // Rendered-screen buffer so a refresh/reconnect can repaint the last
+      // screen even when the session is idle and the raw outputBuffer is empty
+      // (manual-tab parity with the control path; mirrors 4523).
+      try { session._ctlTranscript = new TranscriptBuffer({ cols: cols || 80, rows: rows || 24 }); } catch (_) { session._ctlTranscript = null; }
+
       const osc7Hooks = (toolName === 'terminal') ? {
         validatePath: (p) => this.validatePath(p),
         onCwdChange: (cwd, prev) => {
@@ -5189,6 +5244,7 @@ class ClaudeCodeWebServer {
           const currentSession = this.claudeSessions.get(sessionId);
           if (!currentSession) return;
           currentSession.outputBuffer.push(data);
+          try { if (currentSession._ctlTranscript) currentSession._ctlTranscript.write(data); } catch (_) { /* isolate */ }
           this.sessionStore.markDirty();
           this._throttledOutputBroadcast(sessionId, data);
           // Tap for the local-LLM summariser (off the hot path: this only
@@ -5218,6 +5274,9 @@ class ClaudeCodeWebServer {
             currentSession.agent = null;
             currentSession._lastExit = { code, signal };
             this.sessionStore.markDirty();
+            // Persist the last rendered screen before disposing so a later
+            // refresh/join repaints an idle session instead of going blank.
+            this._persistSnapshotAndDispose(currentSession);
           }
           // Final sticky-note flush to capture the "done" state, then stop.
           this.stickyNoteSummarizer.flushExit(sessionId);
@@ -5238,12 +5297,11 @@ class ClaudeCodeWebServer {
           this.broadcastSessionActivity(sessionId, 'session_error');
         },
         ...options,
-        extraEnv: toolName === 'terminal'
-          ? {
-              ...((options.extraEnv && typeof options.extraEnv === 'object') ? options.extraEnv : {}),
-              ...terminalExtraEnv,
-            }
-          : options.extraEnv
+        extraEnv: {
+          ...((options.extraEnv && typeof options.extraEnv === 'object') ? options.extraEnv : {}),
+          ...terminalExtraEnv,
+          ...claudeArtifactEnv,
+        }
       });
 
       session.lastActivity = new Date();

package/src/sticky-note-transcript.js

@@ -99,6 +99,31 @@ class TranscriptBuffer {
     return result;
   }
 
+  /**
+   * Like snapshot() but does NOT reset the new-output counters — a read-only
+   * view of the rendered tail for repaint-on-join, so it never steals delta
+   * lines from the sticky-note volume trigger.
+   * @param {number} [maxLines]
+   * @returns {Promise<string>}
+   */
+  async peek(maxLines) {
+    const limit = maxLines || this._maxDeltaLines;
+    await this._drain();
+    const buf = this._term.buffer.active;
+    const cursorRow = buf.baseY + buf.cursorY;
+    const rowText = (i) => {
+      const line = buf.getLine(i);
+      return line ? line.translateToString(true) : '';
+    };
+    let lastNonEmpty = cursorRow;
+    while (lastNonEmpty >= 0 && rowText(lastNonEmpty) === '') lastNonEmpty--;
+    if (lastNonEmpty < 0) return '';
+    const start = Math.max(0, lastNonEmpty - limit + 1);
+    const lines = [];
+    for (let i = start; i <= lastNonEmpty; i++) lines.push(rowText(i));
+    return lines.join('\n');
+  }
+
   /** Resolve once xterm has parsed everything written so far. */
   _drain() {
     return new Promise((resolve) => this._term.write('', resolve));