@dmsdc-ai/aigentry-telepty 0.1.68 → 0.1.70

package/daemon.js

@@ -8,6 +8,7 @@ const { getConfig } = require('./auth');
 const pkg = require('./package.json');
 const { claimDaemonState, clearDaemonState } = require('./daemon-control');
 const { checkEntitlement } = require('./entitlement');
+const terminalBackend = require('./terminal-backend');
 
 const config = getConfig();
 const EXPECTED_TOKEN = config.authToken;
@@ -19,7 +20,7 @@ function persistSessions() {
   try {
     const data = {};
     for (const [id, s] of Object.entries(sessions)) {
-      data[id] = { id, type: s.type, command: s.command, cwd: s.cwd, backend: s.backend || null, cmuxWorkspaceId: s.cmuxWorkspaceId || null, createdAt: s.createdAt, lastActivityAt: s.lastActivityAt || null };
+      data[id] = { id, type: s.type, command: s.command, cwd: s.cwd, backend: s.backend || null, cmuxWorkspaceId: s.cmuxWorkspaceId || null, cmuxSurfaceId: s.cmuxSurfaceId || null, createdAt: s.createdAt, lastActivityAt: s.lastActivityAt || null };
     }
     fs.mkdirSync(require('path').dirname(SESSION_PERSIST_PATH), { recursive: true });
     fs.writeFileSync(SESSION_PERSIST_PATH, JSON.stringify(data, null, 2));
@@ -138,6 +139,21 @@ const sessions = {};
 const handoffs = {};
 const threads = {};
 
+function appendToOutputRing(session, data) {
+  if (!session.outputRing) session.outputRing = [];
+  session.outputRing.push(data);
+  // Keep total data under ~200KB limit by trimming old entries
+  let totalLen = session.outputRing.reduce((sum, d) => sum + d.length, 0);
+  while (totalLen > 200000 && session.outputRing.length > 1) {
+    totalLen -= session.outputRing[0].length;
+    session.outputRing.shift();
+  }
+}
+
+// Detect terminal environment at daemon startup
+const DETECTED_TERMINAL = terminalBackend.detectTerminal();
+console.log(`[DAEMON] Terminal backend: ${DETECTED_TERMINAL}`);
+
 // Restore persisted session metadata (wrapped sessions await reconnect)
 const _persisted = loadPersistedSessions();
 for (const [id, meta] of Object.entries(_persisted)) {
@@ -147,8 +163,7 @@ for (const [id, meta] of Object.entries(_persisted)) {
       command: meta.command || 'wrapped', cwd: meta.cwd || process.cwd(),
       createdAt: meta.createdAt || new Date().toISOString(),
       lastActivityAt: meta.lastActivityAt || new Date().toISOString(),
-      clients: new Set(), isClosing: false
-    };
+      clients: new Set(), isClosing: false, outputRing: [], ready: false,     };
     console.log(`[PERSIST] Restored session ${id} (awaiting reconnect)`);
   }
 }
@@ -256,8 +271,10 @@ app.post('/api/sessions/spawn', (req, res) => {
       createdAt: new Date().toISOString(),
       lastActivityAt: new Date().toISOString(),
       clients: new Set(),
-      isClosing: false
-    };
+      isClosing: false,
+      outputRing: [],
+      ready: true,
+          };
     sessions[session_id] = sessionRecord;
 
     // Broadcast session creation to bus
@@ -279,6 +296,8 @@ app.post('/api/sessions/spawn', (req, res) => {
         return;
       }
 
+      appendToOutputRing(currentSession, data);
+
       // Send to direct WS clients
       currentSession.clients.forEach(ws => {
         if (ws.readyState === 1) ws.send(JSON.stringify({ type: 'output', data }));
@@ -304,7 +323,7 @@ app.post('/api/sessions/spawn', (req, res) => {
 });
 
 app.post('/api/sessions/register', (req, res) => {
-  const { session_id, command, cwd = process.cwd(), backend, cmux_workspace_id } = req.body;
+  const { session_id, command, cwd = process.cwd(), backend, cmux_workspace_id, cmux_surface_id } = req.body;
   if (!session_id) return res.status(400).json({ error: 'session_id is required' });
   // Entitlement: check session limit for new registrations
   if (!sessions[session_id]) {
@@ -322,6 +341,7 @@ app.post('/api/sessions/register', (req, res) => {
     if (cwd) existing.cwd = cwd;
     if (backend) existing.backend = backend;
     if (cmux_workspace_id) existing.cmuxWorkspaceId = cmux_workspace_id;
+    if (cmux_surface_id) existing.cmuxSurfaceId = cmux_surface_id;
     console.log(`[REGISTER] Re-registered session ${session_id} (updated metadata)`);
     return res.status(200).json({ session_id, type: 'wrapped', command: existing.command, cwd: existing.cwd, reregistered: true });
   }
@@ -335,11 +355,14 @@ app.post('/api/sessions/register', (req, res) => {
     cwd,
     backend: backend || 'kitty',
     cmuxWorkspaceId: cmux_workspace_id || null,
+    cmuxSurfaceId: cmux_surface_id || null,
     createdAt: new Date().toISOString(),
     lastActivityAt: new Date().toISOString(),
     clients: new Set(),
-    isClosing: false
-  };
+    isClosing: false,
+    outputRing: [],
+    ready: false,
+      };
   // Check for existing session with same base alias and emit replaced event
   const baseAlias = session_id.replace(/-\d+$/, '');
   const replaced = Object.keys(sessions).find(id => {
@@ -393,10 +416,12 @@ app.get('/api/sessions', (req, res) => {
       cwd: session.cwd,
       backend: session.backend || 'kitty',
       cmuxWorkspaceId: session.cmuxWorkspaceId || null,
+      cmuxSurfaceId: session.cmuxSurfaceId || null,
       createdAt: session.createdAt,
       lastActivityAt: session.lastActivityAt || null,
       idleSeconds,
-      active_clients: session.clients.size
+      active_clients: session.clients.size,
+      ready: session.ready || false
     };
   });
   if (idleGt !== null) {
@@ -436,6 +461,7 @@ app.get('/api/meta', (req, res) => {
     host: HOST,
     port: Number(PORT),
     machine_id: MACHINE_ID,
+    terminal: DETECTED_TERMINAL,
     capabilities: ['sessions', 'wrapped-sessions', 'skill-installer', 'singleton-daemon', 'handoff-inbox', 'deliberation-threads', 'cross-machine']
   });
 });
@@ -464,6 +490,27 @@ app.post('/api/sessions/multicast/inject', (req, res) => {
     const session = sessions[id];
     if (session) {
       try {
+        // cmux per-session backend (text + enter)
+        if (session.backend === 'cmux') {
+          const ok = terminalBackend.cmuxSendText(id, prompt);
+          if (ok) {
+            setTimeout(() => terminalBackend.cmuxSendEnter(id), 300);
+            results.successful.push({ id, strategy: 'cmux_auto' });
+            // Broadcast injection to bus
+            const busMsg = JSON.stringify({
+              type: 'injection',
+              sender: 'cli',
+              target_agent: id,
+              content: prompt,
+              timestamp: new Date().toISOString()
+            });
+            busClients.forEach(client => {
+              if (client.readyState === 1) client.send(busMsg);
+            });
+            return; // skip WS path for this session
+          }
+        }
+
         // Inject text first, then \r separately after delay
         if (session.type === 'wrapped') {
           if (session.ownerWs && session.ownerWs.readyState === 1) {
@@ -516,6 +563,16 @@ app.post('/api/sessions/broadcast/inject', (req, res) => {
   Object.keys(sessions).forEach(id => {
     const session = sessions[id];
     try {
+      // cmux per-session backend (text + enter)
+      if (session.backend === 'cmux') {
+        const ok = terminalBackend.cmuxSendText(id, prompt);
+        if (ok) {
+          setTimeout(() => terminalBackend.cmuxSendEnter(id), 300);
+          results.successful.push({ id, strategy: 'cmux_auto' });
+          return; // skip WS path for this session
+        }
+      }
+
       // Inject text first, then \r separately after delay
       if (session.type === 'wrapped') {
         if (session.ownerWs && session.ownerWs.readyState === 1) {
@@ -729,8 +786,11 @@ app.post('/api/sessions/:id/submit', (req, res) => {
   console.log(`[SUBMIT] Session ${id} (${session.command}) using strategy: ${strategy}`);
 
   let success = false;
-  // cmux backend takes priority
-  if (session.backend === 'cmux' && session.cmuxWorkspaceId) {
+  // cmux per-session backend
+  if (session.backend === 'cmux') {
+    success = terminalBackend.cmuxSendEnter(id);
+  }
+  if (!success && session.backend === 'cmux' && session.cmuxWorkspaceId) {
     success = submitViaCmux(id);
   }
   if (!success) {
@@ -768,8 +828,11 @@ app.post('/api/sessions/submit-all', (req, res) => {
     const strategy = getSubmitStrategy(session.command);
     let success = false;
 
-    // cmux backend takes priority
-    if (session.backend === 'cmux' && session.cmuxWorkspaceId) {
+    // cmux per-session backend
+    if (session.backend === 'cmux') {
+      success = terminalBackend.cmuxSendEnter(id);
+    }
+    if (!success && session.backend === 'cmux' && session.cmuxWorkspaceId) {
       success = submitViaCmux(id);
     }
     if (!success) {
@@ -835,68 +898,115 @@ app.post('/api/sessions/:id/inject', (req, res) => {
 
     let submitResult = null;
     if (session.type === 'wrapped') {
-      // For wrapped sessions: try kitty send-text (bypasses allow bridge queue)
-      // then WS as fallback, then kitty send-key Return for enter
-      const sock = findKittySocket();
-      if (!session.kittyWindowId && sock) session.kittyWindowId = findKittyWindowId(sock, id);
-      const wid = session.kittyWindowId;
+      // For wrapped sessions: try cmux send (daemon-level auto-detect),
+      // then kitty send-text (bypasses allow bridge queue),
+      // then WS as fallback, then submit via consistent path for CR.
+      //
+      // When session is NOT ready (CLI hasn't shown prompt yet), skip cmux/kitty
+      // because they bypass the allow-bridge's prompt-ready queue.
+      // The WS path sends to the allow-bridge which queues until CLI is ready.
+      const sock = session.ready ? findKittySocket() : null;
+      if (sock && !session.kittyWindowId) session.kittyWindowId = findKittyWindowId(sock, id);
+      const wid = session.ready ? session.kittyWindowId : null;
 
       let kittyOk = false;
-      if (wid && sock) {
-        // Kitty send-text primary (bypasses allow bridge queue)
+      let cmuxOk = false;
+      let deliveryPath = null; // 'cmux', 'kitty', 'ws'
+
+      // cmux per-session backend: send text directly to surface (only when ready)
+      if (session.ready && session.backend === 'cmux') {
+        cmuxOk = terminalBackend.cmuxSendText(id, finalPrompt);
+        if (cmuxOk) {
+          deliveryPath = 'cmux';
+          console.log(`[INJECT] cmux send for ${id}`);
+        }
+      }
+
+      if (!cmuxOk && wid && sock) {
+        // Kitty send-text primary (only when ready — bypasses allow bridge queue)
         try {
           const escaped = finalPrompt.replace(/\\/g, '\\\\').replace(/'/g, "'\\''");
           require('child_process').execSync(`kitty @ --to unix:${sock} send-text --match id:${wid} '${escaped}'`, {
             timeout: 5000, stdio: ['pipe', 'pipe', 'pipe']
           });
           kittyOk = true;
+          deliveryPath = 'kitty';
           console.log(`[INJECT] Kitty send-text for ${id} (window ${wid})`);
         } catch {
           // Invalidate cached window ID — window may have changed or been closed
           session.kittyWindowId = null;
         }
       }
-      if (!kittyOk) {
-        // Fallback: WS (works with new allow bridges that have queue flush)
+      if (!cmuxOk && !kittyOk) {
+        // WS path: allow-bridge has its own prompt-ready queue
         const wsOk = writeToSession(finalPrompt);
         if (!wsOk) {
           return res.status(503).json({ error: 'Process not connected' });
         }
-        console.log(`[INJECT] WS fallback for ${id}`);
+        deliveryPath = 'ws';
+        if (!session.ready) {
+          console.log(`[INJECT] WS (not ready, allow-bridge will queue) for ${id}`);
+        } else {
+          console.log(`[INJECT] WS fallback for ${id}`);
+        }
       }
 
       if (!no_enter) {
         setTimeout(() => {
           let submitted = false;
 
-          // 1. cmux backend: use cmux send-key
-          if (session.backend === 'cmux' && session.cmuxWorkspaceId) {
-            submitted = submitViaCmux(id);
-            if (submitted) console.log(`[INJECT] cmux submit for ${id}`);
-          }
-
-          // 2. kitty/default backend: osascript primary
-          if (!submitted) {
-            const submitStrategy = getSubmitStrategy(session.command);
-            const keyCombo = submitStrategy === 'osascript_cmd_enter' ? 'cmd_enter' : 'return_key';
-            submitted = submitViaOsascript(id, keyCombo);
-          }
-
-          // 3. Fallback: kitty send-text → WS
-          if (!submitted) {
-            console.log(`[INJECT] submit fallback for ${id}`);
+          // Use the SAME path that delivered text for CR to guarantee ordering
+          if (deliveryPath === 'cmux') {
+            // cmux: send-key return via same surface
+            if (session.backend === 'cmux') {
+              submitted = terminalBackend.cmuxSendEnter(id);
+              if (submitted) console.log(`[INJECT] cmux submit for ${id}`);
+            }
+            if (!submitted && session.backend === 'cmux' && session.cmuxWorkspaceId) {
+              submitted = submitViaCmux(id);
+              if (submitted) console.log(`[INJECT] cmux session-level submit for ${id}`);
+            }
+          } else if (deliveryPath === 'kitty') {
+            // kitty: send-text CR via same window (not osascript!)
             if (wid && sock) {
               try {
                 require('child_process').execSync(`kitty @ --to unix:${sock} send-text --match id:${wid} $'\\r'`, {
                   timeout: 3000, stdio: ['pipe', 'pipe', 'pipe']
                 });
+                submitted = true;
+                console.log(`[INJECT] kitty submit for ${id} (window ${wid})`);
               } catch {
-                writeToSession('\r');
+                session.kittyWindowId = null;
               }
-            } else {
-              writeToSession('\r');
             }
           }
+          // deliveryPath === 'ws' or any fallback:
+          // Try terminal-level submit first (bypasses PTY ICRNL which converts CR→LF)
+          // This matters for cmux/kitty sessions where text went via WS but
+          // the application expects CR(13) not LF(10) from Enter.
+          if (!submitted && session.backend === 'cmux') {
+            submitted = terminalBackend.cmuxSendEnter(id);
+            if (submitted) console.log(`[INJECT] cmux submit (fallback) for ${id}`);
+          }
+          if (!submitted && session.backend === 'cmux' && session.cmuxWorkspaceId) {
+            submitted = submitViaCmux(id);
+            if (submitted) console.log(`[INJECT] cmux session-level submit (fallback) for ${id}`);
+          }
+          if (!submitted && wid && sock) {
+            try {
+              require('child_process').execSync(`kitty @ --to unix:${sock} send-text --match id:${wid} $'\\r'`, {
+                timeout: 3000, stdio: ['pipe', 'pipe', 'pipe']
+              });
+              submitted = true;
+              console.log(`[INJECT] kitty submit (fallback) for ${id}`);
+            } catch {
+              session.kittyWindowId = null;
+            }
+          }
+          if (!submitted) {
+            writeToSession('\r');
+            console.log(`[INJECT] WS submit for ${id}`);
+          }
 
           // Update tab title (kitty-specific, safe to fail)
           if (wid && sock) {
@@ -907,7 +1017,7 @@ app.post('/api/sessions/:id/inject', (req, res) => {
             } catch {}
           }
         }, 500);
-        submitResult = { deferred: true, strategy: session.backend === 'cmux' ? 'cmux_with_fallback' : 'osascript_with_fallback' };
+        submitResult = { deferred: true, strategy: deliveryPath || 'ws' };
       }
     } else {
       // Spawned sessions: direct PTY write
@@ -979,6 +1089,53 @@ app.post('/api/sessions/:id/inject', (req, res) => {
   }
 });
 
+// GET /api/sessions/:id/screen — read current screen buffer
+app.get('/api/sessions/:id/screen', (req, res) => {
+  const requestedId = req.params.id;
+  const resolvedId = resolveSessionAlias(requestedId);
+  if (!resolvedId) return res.status(404).json({ error: 'Session not found', requested: requestedId });
+  const session = sessions[resolvedId];
+
+  const lines = parseInt(req.query.lines) || 50;
+  const raw = req.query.raw === '1' || req.query.raw === 'true';
+
+  if (!session.outputRing || session.outputRing.length === 0) {
+    return res.json({ session_id: resolvedId, screen: '', lines: 0, raw: false });
+  }
+
+  // Join all buffered output
+  const fullOutput = session.outputRing.join('');
+
+  // Strip ANSI escape sequences for clean text
+  function stripAnsi(str) {
+    return str
+      .replace(/[[0-9;]*[a-zA-Z]/g, '')      // CSI sequences
+      .replace(/][^]*/g, '')          // OSC sequences (BEL terminated)
+      .replace(/][^]*\\/g, '')  // OSC sequences (ST terminated)
+      .replace(/[()][AB012]/g, '')              // Character set selection
+      .replace(/[>=<]/g, '')                    // Keypad mode
+      .replace(/[[?]?[0-9;]*[hlsurm]/g, '') // Mode set/reset
+      .replace(/[[0-9;]*[ABCDHJ]/g, '')       // Cursor movement
+      .replace(/[[0-9;]*[KG]/g, '')           // Line clearing
+      .replace(/\r/g, '');                         // Carriage returns
+  }
+
+  const cleaned = raw ? fullOutput : stripAnsi(fullOutput);
+
+  // Take last N lines
+  const allLines = cleaned.split('\n');
+  const lastLines = allLines.slice(-lines);
+  const screen = lastLines.join('\n').trim();
+
+  res.json({
+    session_id: resolvedId,
+    screen,
+    lines: lastLines.length,
+    total_lines: allLines.length,
+    raw: !!raw
+  });
+});
+
 app.patch('/api/sessions/:id', (req, res) => {
   const requestedId = req.params.id;
   const resolvedId = resolveSessionAlias(requestedId);
@@ -1060,13 +1217,22 @@ function busAutoRoute(msg) {
   const prompt = (msg.payload && msg.payload.prompt) || msg.content || msg.prompt || JSON.stringify(msg);
   const inject_id = crypto.randomUUID();
 
-  // Write to session (kitty primary, WS fallback)
+  // Write to session (cmux auto-detect > kitty > session-level cmux > WS fallback)
   const sock = findKittySocket();
   if (!targetSession.kittyWindowId && sock) targetSession.kittyWindowId = findKittyWindowId(sock, targetId);
   const wid = targetSession.kittyWindowId;
   let delivered = false;
 
-  if (wid && sock && targetSession.type === 'wrapped') {
+  // cmux per-session backend: send text + enter to surface
+  if (!delivered && targetSession.backend === 'cmux') {
+    const textOk = terminalBackend.cmuxSendText(targetId, prompt);
+    if (textOk) {
+      setTimeout(() => terminalBackend.cmuxSendEnter(targetId), 500);
+      delivered = true;
+    }
+  }
+
+  if (!delivered && wid && sock && targetSession.type === 'wrapped') {
     try {
       const escaped = prompt.replace(/\\/g, '\\\\').replace(/'/g, "'\\''");
       require('child_process').execSync(`kitty @ --to unix:${sock} send-text --match id:${wid} '${escaped}'`, {
@@ -1082,7 +1248,7 @@ function busAutoRoute(msg) {
       delivered = true;
     } catch {}
   }
-  // cmux backend: use WS for text, cmux send-key for enter
+  // Session-level cmux backend: use WS for text, cmux send-key for enter
   if (!delivered && targetSession.backend === 'cmux' && targetSession.cmuxWorkspaceId) {
     if (targetSession.type === 'wrapped' && targetSession.ownerWs && targetSession.ownerWs.readyState === 1) {
       targetSession.ownerWs.send(JSON.stringify({ type: 'inject', data: prompt }));
@@ -1469,8 +1635,10 @@ wss.on('connection', (ws, req) => {
       createdAt: new Date().toISOString(),
       lastActivityAt: new Date().toISOString(),
       clients: new Set([ws]),
-      isClosing: false
-    };
+      isClosing: false,
+      outputRing: [],
+      ready: false,
+          };
     sessions[sessionId] = autoSession;
     console.log(`[WS] Auto-registered wrapped session ${sessionId} on reconnect`);
     // Set tab title via kitty (no \x0c redraw — it causes flickering on multi-session reconnect)
@@ -1515,11 +1683,25 @@ wss.on('connection', (ws, req) => {
           // Owner sending output -> broadcast to other clients + update activity
           if (type === 'output') {
             activeSession.lastActivityAt = new Date().toISOString();
+            appendToOutputRing(activeSession, data);
             activeSession.clients.forEach(client => {
               if (client !== ws && client.readyState === 1) {
                 client.send(JSON.stringify({ type: 'output', data }));
               }
             });
+          } else if (type === 'ready') {
+            activeSession.ready = true;
+            activeSession.lastActivityAt = new Date().toISOString();
+            console.log(`[READY] Session ${sessionId} CLI is ready for inject`);
+            // Broadcast readiness to bus (cmux/kitty paths now enabled for this session)
+            const readyMsg = JSON.stringify({
+              type: 'session_ready',
+              session_id: sessionId,
+              timestamp: new Date().toISOString()
+            });
+            busClients.forEach(client => {
+              if (client.readyState === 1) client.send(readyMsg);
+            });
           }
         } else {
           // Non-owner client input -> forward to owner as inject

package/interactive-terminal.js

@@ -1,5 +1,25 @@
 'use strict';
 
+const fs = require('fs');
+
+const TERMINAL_CLEANUP_SEQUENCE = [
+  '\x1b[?1049l', // Leave the alternate screen if the child died before cleanup.
+  '\x1b[?25h',   // Ensure the cursor is visible again.
+  '\x1b[?1l',    // Disable application cursor keys.
+  '\x1b>',       // Disable application keypad mode.
+  '\x1b[?1000l',
+  '\x1b[?1002l',
+  '\x1b[?1003l',
+  '\x1b[?1004l',
+  '\x1b[?1005l',
+  '\x1b[?1006l',
+  '\x1b[?1007l',
+  '\x1b[?1015l',
+  '\x1b[<u',     // Disable kitty keyboard protocol.
+  '\x1b[>4;0m',  // Disable modifyOtherKeys.
+  '\x1b[?2004l'  // Disable bracketed paste.
+].join('');
+
 function getTerminalSize(output, fallback = {}) {
   const envCols = Number.parseInt(process.env.COLUMNS || '', 10);
   const envRows = Number.parseInt(process.env.LINES || '', 10);
@@ -31,10 +51,30 @@ function removeListener(stream, eventName, handler) {
   }
 }
 
+function restoreTerminalModes(output) {
+  if (!output) {
+    return;
+  }
+
+  try {
+    if (typeof output.fd === 'number') {
+      fs.writeSync(output.fd, TERMINAL_CLEANUP_SEQUENCE);
+      return;
+    }
+
+    if (typeof output.write === 'function') {
+      output.write(TERMINAL_CLEANUP_SEQUENCE);
+    }
+  } catch {
+    // Ignore cleanup failures when the TTY is already gone.
+  }
+}
+
 function attachInteractiveTerminal(input, output, handlers = {}) {
   const { onData = null, onResize = null } = handlers;
 
   if (input && input.isTTY && typeof input.setRawMode === 'function') {
+    input.__teleptyRawModeActive = true;
     input.setRawMode(true);
   }
 
@@ -57,15 +97,20 @@ function attachInteractiveTerminal(input, output, handlers = {}) {
 
     if (input && input.isTTY && typeof input.setRawMode === 'function') {
       input.setRawMode(false);
+      input.__teleptyRawModeActive = false;
     }
 
     if (input && typeof input.pause === 'function') {
       input.pause();
     }
+
+    restoreTerminalModes(output);
   };
 }
 
 module.exports = {
   attachInteractiveTerminal,
-  getTerminalSize
+  getTerminalSize,
+  restoreTerminalModes,
+  TERMINAL_CLEANUP_SEQUENCE
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dmsdc-ai/aigentry-telepty",
-  "version": "0.1.68",
+  "version": "0.1.70",
   "main": "daemon.js",
   "bin": {
     "aigentry-telepty": "install.js",