@dmsdc-ai/aigentry-telepty 0.1.68 → 0.1.70

package/cli.js

@@ -3,6 +3,7 @@
 const path = require('path');
 const os = require('os');
 const fs = require('fs');
+const { constants: osConstants } = require('os');
 const WebSocket = require('ws');
 const { execSync, spawn } = require('child_process');
 const readline = require('readline');
@@ -11,7 +12,7 @@ const updateNotifier = require('update-notifier');
 const pkg = require('./package.json');
 const { getConfig } = require('./auth');
 const { cleanupDaemonProcesses } = require('./daemon-control');
-const { attachInteractiveTerminal, getTerminalSize } = require('./interactive-terminal');
+const { attachInteractiveTerminal, getTerminalSize, restoreTerminalModes } = require('./interactive-terminal');
 const { getRuntimeInfo } = require('./runtime-info');
 const { formatHostLabel, groupSessionsByHost, pickSessionTarget } = require('./session-routing');
 const { runInteractiveSkillInstaller } = require('./skill-installer');
@@ -43,9 +44,14 @@ function resetInteractiveInput(stream = process.stdin) {
     return;
   }
 
+  if (stream.isTTY && (stream.isRaw || stream.__teleptyRawModeActive)) {
+    restoreTerminalModes(process.stdout);
+  }
+
   if (stream.isTTY && typeof stream.setRawMode === 'function') {
     try {
       stream.setRawMode(false);
+      stream.__teleptyRawModeActive = false;
     } catch {
       // Ignore raw-mode reset failures when the TTY is already gone.
     }
@@ -101,6 +107,10 @@ process.stdin.on('error', (error) => {
   process.stderr.write(`\n❌ Telepty stdin error: ${error.message}\n`);
 });
 
+process.on('exit', () => {
+  resetInteractiveInput(process.stdin);
+});
+
 // Check for updates unless explicitly disabled for tests/CI.
 if (!process.env.NO_UPDATE_NOTIFIER && !process.env.TELEPTY_DISABLE_UPDATE_NOTIFIER) {
   updateNotifier({pkg}).notify({ isGlobal: true });
@@ -196,61 +206,46 @@ async function repairLocalDaemon(options = {}) {
 
 function getDiscoveryHosts() {
   const hosts = new Set();
-
   if (REMOTE_HOST && REMOTE_HOST !== '127.0.0.1') {
     hosts.add(REMOTE_HOST);
   } else {
     hosts.add('127.0.0.1');
   }
-
-  const extraHosts = String(process.env.TELEPTY_DISCOVERY_HOSTS || '')
-    .split(',')
-    .map((host) => host.trim())
-    .filter(Boolean);
-  extraHosts.forEach((host) => hosts.add(host));
-
-  // Include relay peers for cross-machine session discovery
-  const relayPeers = String(process.env.TELEPTY_RELAY_PEERS || '')
-    .split(',')
-    .map((host) => host.trim())
-    .filter(Boolean);
-  relayPeers.forEach((host) => hosts.add(host));
-
-  // Include SSH tunnel-connected peers
-  const connectedHosts = crossMachine.getConnectedHosts();
-  connectedHosts.forEach((host) => hosts.add(host));
-
   return Array.from(hosts);
 }
 
 async function discoverSessions(options = {}) {
   await ensureDaemonRunning();
-  const hosts = getDiscoveryHosts();
   const allSessions = [];
 
   if (!options.silent) {
     process.stdout.write('\x1b[36m🔍 Discovering active sessions across connected machines...\x1b[0m\n');
   }
 
-  await Promise.all(hosts.map(async (host) => {
-    try {
-      const res = await fetchWithAuth(`http://${host}:${PORT}/api/sessions`, {
-        signal: AbortSignal.timeout(1500)
+  // Local daemon sessions
+  try {
+    const res = await fetchWithAuth(`http://127.0.0.1:${PORT}/api/sessions`, {
+      signal: AbortSignal.timeout(1500)
+    });
+    if (res.ok) {
+      const sessions = await res.json();
+      sessions.forEach((session) => {
+        allSessions.push({ host: '127.0.0.1', ...session });
       });
-      if (res.ok) {
-        const sessions = await res.json();
-        sessions.forEach((session) => {
-          allSessions.push({ host, ...session });
-        });
-      }
-    } catch (e) {
-      // Ignore nodes that don't have telepty running
     }
-  }));
+  } catch {}
+
+  // Remote peer sessions via SSH direct
+  const remoteSessions = crossMachine.discoverAllRemoteSessions();
+  allSessions.push(...remoteSessions);
 
   return allSessions;
 }
 
+function isRemoteSession(session) {
+  return session.remote === true || (session.host && session.host !== '127.0.0.1' && session.host.includes('@'));
+}
+
 async function resolveSessionTarget(sessionRef, options = {}) {
   const sessions = options.sessions || await discoverSessions({ silent: true });
   return pickSessionTarget(sessionRef, sessions, REMOTE_HOST);
@@ -697,7 +692,8 @@ async function main() {
           command,
           cwd: process.cwd(),
           backend: detectedBackend,
-          cmux_workspace_id: process.env.CMUX_WORKSPACE_ID || null
+          cmux_workspace_id: process.env.CMUX_WORKSPACE_ID || null,
+          cmux_surface_id: process.env.CMUX_SURFACE_ID || null
         })
       });
       const data = await res.json();
@@ -728,7 +724,7 @@ async function main() {
     };
     const cmdBase = path.basename(command).replace(/\..*$/, '');
     const promptPattern = PROMPT_PATTERNS[cmdBase] || /[❯>$#%]\s*$/;
-    let promptReady = true;  // assume ready initially for first inject
+    let promptReady = false;  // wait for CLI prompt before accepting inject
     const injectQueue = [];
 
     let queueFlushTimer = null;
@@ -750,7 +746,7 @@ async function main() {
         if (injectQueue.length > 0) {
           flushInjectQueue();
         }
-      }, 3000);
+      }, 15000);
     }
 
     // Connect to daemon WebSocket with auto-reconnect
@@ -776,7 +772,8 @@ async function main() {
               command,
               cwd: process.cwd(),
               backend: detectedBackend,
-              cmux_workspace_id: process.env.CMUX_WORKSPACE_ID || null
+              cmux_workspace_id: process.env.CMUX_WORKSPACE_ID || null,
+              cmux_surface_id: process.env.CMUX_SURFACE_ID || null
             })
           });
         } catch (e) {
@@ -791,6 +788,10 @@ async function main() {
         // No resize trick on reconnect — it causes visible flickering across all
         // terminals when the daemon restarts and multiple sessions reconnect at once.
         reconnectAttempts = 0;
+        // Re-send ready on reconnect so new daemon knows CLI is ready
+        if (readyNotified && promptReady) {
+          daemonWs.send(JSON.stringify({ type: 'ready' }));
+        }
       });
 
       daemonWs.on('message', (message) => {
@@ -861,6 +862,31 @@ async function main() {
         child.resize(size.cols, size.rows);
       }
     });
+    let allowSessionClosed = false;
+    const allowSignalHandlers = new Map();
+
+    function closeAllowSession() {
+      if (allowSessionClosed) {
+        return false;
+      }
+
+      allowSessionClosed = true;
+      cleanupTerminal();
+      process.stdout.write(`\x1b]0;\x07`);
+      fetchWithAuth(`${DAEMON_URL}/api/sessions/${encodeURIComponent(sessionId)}`, { method: 'DELETE' }).catch(() => {});
+      if (reconnectTimer) clearTimeout(reconnectTimer);
+      try {
+        daemonWs.close();
+      } catch {}
+      for (const [signalName, handler] of allowSignalHandlers) {
+        process.off(signalName, handler);
+      }
+      return true;
+    }
+
+    function exitAllowSession(code) {
+      setTimeout(() => process.exit(code), 25);
+    }
 
     // Intercept terminal title escape sequences and prefix with session ID
     const titlePrefix = `\u26A1 ${sessionId}`;
@@ -872,6 +898,7 @@ async function main() {
     }
 
     // Relay PTY output to current terminal + send to daemon for attach clients
+    let readyNotified = false;
     child.onData((data) => {
       const rewritten = rewriteTitleSequences(data);
       process.stdout.write(rewritten);
@@ -882,22 +909,36 @@ async function main() {
       if (promptPattern.test(data)) {
         promptReady = true;
         flushInjectQueue();
+        // Notify daemon that CLI is ready for inject
+        if (!readyNotified && wsReady && daemonWs.readyState === 1) {
+          readyNotified = true;
+          daemonWs.send(JSON.stringify({ type: 'ready' }));
+        }
       }
     });
 
     // Handle child exit
     child.onExit(({ exitCode }) => {
-      cleanupTerminal();
-      process.stdout.write(`\x1b]0;\x07`);
+      if (!closeAllowSession()) {
+        return;
+      }
       console.log(`\n\x1b[33mSession '${sessionId}' exited (code ${exitCode}).\x1b[0m`);
-
-      // Deregister from daemon
-      fetchWithAuth(`${DAEMON_URL}/api/sessions/${encodeURIComponent(sessionId)}`, { method: 'DELETE' }).catch(() => {});
-      if (reconnectTimer) clearTimeout(reconnectTimer);
-      daemonWs.close();
-      process.exit(exitCode || 0);
+      exitAllowSession(exitCode || 0);
     });
 
+    for (const signalName of ['SIGTERM', 'SIGHUP', 'SIGQUIT']) {
+      const handler = () => {
+        closeAllowSession();
+        try {
+          child.kill(signalName);
+        } catch {}
+        const signalCode = osConstants.signals[signalName] || 1;
+        exitAllowSession(128 + signalCode);
+      };
+      allowSignalHandlers.set(signalName, handler);
+      process.on(signalName, handler);
+    }
+
     // Graceful shutdown on SIGINT (let child handle it via PTY)
     process.on('SIGINT', () => {});
 
@@ -1009,6 +1050,34 @@ async function main() {
     return;
   }
 
+  if (cmd === 'read-screen') {
+    const sessionId = args[1];
+    if (!sessionId) { console.error('❌ Usage: telepty read-screen <session_id> [--lines N] [--raw]'); process.exit(1); }
+
+    const linesIndex = args.indexOf('--lines');
+    const lines = (linesIndex !== -1 && args[linesIndex + 1]) ? args[linesIndex + 1] : '50';
+    const raw = args.includes('--raw');
+
+    try {
+      const target = await resolveSessionTarget(sessionId);
+      if (!target) {
+        console.error(`❌ Session '${sessionId}' was not found on any discovered host.`);
+        process.exit(1);
+      }
+
+      const res = await fetchWithAuth(`http://${target.host}:${PORT}/api/sessions/${encodeURIComponent(target.id)}/screen?lines=${lines}${raw ? '&raw=1' : ''}`);
+      const data = await res.json();
+      if (!res.ok) { console.error(`❌ Error: ${data.error}`); process.exit(1); }
+
+      if (!data.screen) {
+        console.log('(empty screen)');
+      } else {
+        console.log(data.screen);
+      }
+    } catch (e) { console.error(`❌ ${e.message || 'Failed to connect to the target daemon.'}`); }
+    return;
+  }
+
   if (cmd === 'inject') {
     // Check for --no-enter flag
     const noEnterIndex = args.indexOf('--no-enter');
@@ -1047,14 +1116,24 @@ async function main() {
         process.exit(1);
       }
 
-      // Entitlement: remote session check
-      if (target.host && target.host !== '127.0.0.1' && target.host !== 'localhost') {
+      // Remote session: use SSH direct execution
+      if (isRemoteSession(target)) {
         const { checkEntitlement } = require('./entitlement');
         const ent = checkEntitlement({ feature: 'telepty.remote_sessions' });
         if (!ent.allowed) {
           console.error(`⚠️  ${ent.reason}\n   Upgrade: ${ent.upgrade_url}`);
           process.exit(1);
         }
+        const result = crossMachine.remoteInject(target.peerName, target.id, prompt, {
+          from: fromId,
+          no_enter: noEnter
+        });
+        if (result.success) {
+          console.log(`✅ Context injected successfully into '\x1b[36m${target.id}\x1b[0m' @ ${target.peerName}.`);
+        } else {
+          console.error(`❌ Error: ${result.error}`);
+        }
+        return;
       }
 
       const body = { prompt, no_enter: noEnter };
@@ -1067,8 +1146,7 @@ async function main() {
       });
       const data = await res.json();
       if (!res.ok) { console.error(`❌ Error: ${data.error}`); return; }
-      const hostSuffix = target.host === '127.0.0.1' ? '' : ` @ ${target.host}`;
-      console.log(`✅ Context injected successfully into '\x1b[36m${target.id}\x1b[0m'${hostSuffix}.`);
+      console.log(`✅ Context injected successfully into '\x1b[36m${target.id}\x1b[0m'.`);
     } catch (e) { console.error(`❌ ${e.message || 'Failed to connect to the target daemon.'}`); }
     return;
   }
@@ -1879,8 +1957,6 @@ Discuss the following topic from your project's perspective. Engage with other s
     if (result.success) {
       console.log(`\x1b[32m✅ Connected to ${result.name}\x1b[0m`);
       console.log(`   Machine ID: ${result.machineId}`);
-      console.log(`   Local port: ${result.localPort}`);
-      console.log(`   Version: ${result.version}`);
       console.log(`\nSessions on ${result.name} are now discoverable via \x1b[36mtelepty list\x1b[0m`);
     } else {
       console.error(`\x1b[31m❌ ${result.error}\x1b[0m`);
@@ -2021,6 +2097,7 @@ Usage:
   telepty list                                   List all active sessions across discovered hosts
   telepty attach [id[@host]]                     Attach to a session (Interactive picker if no ID)
   telepty inject [--no-enter] [--from <id>] [--reply-to <id>] <id[@host]> "<prompt>"    Inject text into a single session
+  telepty read-screen <id[@host]> [--lines N] [--raw]                  Read session screen buffer
   telepty reply "<text>"                         Reply to the session that last injected into $TELEPTY_SESSION_ID
   telepty multicast <id1[@host],id2[@host]> "<prompt>"  Inject text into multiple specific sessions
   telepty broadcast "<prompt>"                   Inject text into ALL active sessions