@dmsdc-ai/aigentry-telepty 0.1.87 → 0.1.89

package/cli.js

@@ -18,6 +18,7 @@ const { formatHostLabel, groupSessionsByHost, pickSessionTarget } = require('./s
 const { buildSharedContextPrompt, createSharedContextDescriptor, ensureSharedContextFile } = require('./shared-context');
 const { runInteractiveSkillInstaller } = require('./skill-installer');
 const crossMachine = require('./cross-machine');
+const { FileMailbox } = require('./src/mailbox/index');
 const args = process.argv.slice(2);
 let pendingTerminalInputError = null;
 let simulatedPromptErrorInjected = false;
@@ -334,8 +335,22 @@ function printSessionInfo(session, options = {}) {
   console.log('');
 }
 
+function resolveTeleptyEntryPoint() {
+  // After npm upgrade, process.argv[1] still points to the OLD version's cli.js.
+  // Resolve the current telepty binary from PATH, which npm updates on install.
+  try {
+    const cmd = process.platform === 'win32' ? 'where telepty' : 'which telepty';
+    const binPath = execSync(cmd, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim().split('\n')[0];
+    if (binPath && fs.existsSync(binPath)) {
+      return fs.realpathSync(binPath);
+    }
+  } catch {}
+  return process.argv[1];
+}
+
 function startDetachedDaemon() {
-  const cp = spawn(process.argv[0], [process.argv[1], 'daemon'], {
+  const entryPoint = resolveTeleptyEntryPoint();
+  const cp = spawn(process.argv[0], [entryPoint, 'daemon'], {
     detached: true,
     stdio: 'ignore'
   });
@@ -391,7 +406,11 @@ async function repairLocalDaemon(options = {}) {
   startDetachedDaemon();
   await new Promise((resolve) => setTimeout(resolve, 1000));
   const meta = await getDaemonMeta('127.0.0.1');
-  return { stopped: results.stopped.length, failed: results.failed.length, meta };
+  const versionMatch = meta && meta.version === pkg.version;
+  if (meta && !versionMatch) {
+    process.stdout.write(`\x1b[33m⚠️ Daemon restarted but version mismatch (running v${meta.version}, expected v${pkg.version})\x1b[0m\n`);
+  }
+  return { stopped: results.stopped.length, failed: results.failed.length, meta, versionMatch };
 }
 
 function getDiscoveryHosts() {
@@ -455,10 +474,14 @@ async function ensureDaemonRunning(options = {}) {
     });
 
     if (sessionsRes.ok && hasCapabilities) {
-      return;
-    }
-
-    if (sessionsRes.ok && !meta) {
+      // Version mismatch: running daemon is older than installed CLI
+      if (meta && meta.version !== pkg.version) {
+        process.stdout.write(`\x1b[33m⚙️ Daemon version mismatch (running v${meta.version}, installed v${pkg.version}). Restarting...\x1b[0m\n`);
+        cleanupDaemonProcesses();
+      } else {
+        return;
+      }
+    } else if (sessionsRes.ok && !meta) {
       process.stdout.write('\x1b[33m⚙️ Found an older local telepty daemon. Restarting it...\x1b[0m\n');
       cleanupDaemonProcesses();
     } else if (sessionsRes.ok && meta) {
@@ -978,10 +1001,41 @@ async function main() {
     const cmdBase = path.basename(command).replace(/\..*$/, '');
     const promptPattern = PROMPT_PATTERNS[cmdBase] || /[❯>$#%]\s*$/;
     let promptReady = false;  // wait for CLI prompt before accepting inject
-    const injectQueue = [];
     let lastUserInputTime = 0;  // timestamp of last user keystroke
     const IDLE_THRESHOLD = 2000; // ms after last user input to consider idle
 
+    // Mailbox-backed inject queue (replaces in-memory array for crash resilience)
+    const bridgeMailbox = new FileMailbox({
+      root: path.join(os.homedir(), '.aigentry', 'mailbox', 'bridge'),
+    });
+    const bridgeTarget = sessionId;
+    let bridgeMsgSeq = 0;
+    let bridgePendingCount = 0;
+
+    // Recover undelivered messages from a previous crash
+    try {
+      const leftover = bridgeMailbox.peek(bridgeTarget).filter(m => m.state === 'pending' || m.state === 'in_flight');
+      bridgePendingCount = leftover.length;
+      if (bridgePendingCount > 0) {
+        console.log(`\x1b[33m[BRIDGE] Recovered ${bridgePendingCount} undelivered message(s) from previous session\x1b[0m`);
+      }
+    } catch {}
+
+    function enqueueBridgeMessage(text) {
+      const msgId = `${sessionId}:${Date.now()}:${++bridgeMsgSeq}`;
+      try {
+        bridgeMailbox.enqueue({
+          msg_id: msgId, from: 'daemon', to: bridgeTarget,
+          payload: text, created_at: Math.floor(Date.now() / 1000), attempt: 0,
+        });
+        bridgePendingCount++;
+      } catch (err) {
+        // Fallback: write directly if mailbox fails
+        console.error(`[BRIDGE] Mailbox enqueue failed, writing directly: ${err.message}`);
+        child.write(text);
+      }
+    }
+
     function isIdle() {
       return promptReady && (Date.now() - lastUserInputTime > IDLE_THRESHOLD);
     }
@@ -989,34 +1043,47 @@ async function main() {
     let queueFlushTimer = null;
     let idleCheckTimer = null;
 
-    function flushInjectQueue() {
+    function flushBridgeMailbox() {
       if (queueFlushTimer) { clearTimeout(queueFlushTimer); queueFlushTimer = null; }
       if (idleCheckTimer) { clearInterval(idleCheckTimer); idleCheckTimer = null; }
-      if (injectQueue.length === 0) return;
-      const batch = injectQueue.splice(0);
+      if (bridgePendingCount === 0) return;
       let delay = 0;
-      for (const item of batch) {
-        setTimeout(() => child.write(item), delay);
-        delay += item === '\r' ? 0 : 100;
-      }
+      const batch = [];
+      // Dequeue all pending messages
+      while (true) {
+        const msg = bridgeMailbox.dequeue(bridgeTarget);
+        if (!msg) break;
+        batch.push(msg);
+      }
+      if (batch.length === 0) { bridgePendingCount = 0; return; }
+      for (const msg of batch) {
+        const text = msg.payload;
+        const msgId = msg.msg_id;
+        setTimeout(() => {
+          child.write(text);
+          try { bridgeMailbox.ack(bridgeTarget, msgId); } catch {}
+        }, delay);
+        delay += text === '\r' ? 0 : 100;
+      }
+      bridgePendingCount = Math.max(0, bridgePendingCount - batch.length);
       promptReady = false;
     }
     function scheduleIdleFlush() {
       if (idleCheckTimer) return;
       // Poll every 500ms for idle state
       idleCheckTimer = setInterval(() => {
-        if (isIdle() && injectQueue.length > 0) {
-          flushInjectQueue();
+        if (isIdle() && bridgePendingCount > 0) {
+          flushBridgeMailbox();
         }
       }, 500);
-      // Safety: flush after 15s regardless (prevent stuck queue)
+      // Safety: flush after 5s regardless (prevent stuck queue when prompt not detected)
       if (!queueFlushTimer) {
         queueFlushTimer = setTimeout(() => {
           queueFlushTimer = null;
-          if (injectQueue.length > 0) {
-            flushInjectQueue();
+          if (bridgePendingCount > 0) {
+            flushBridgeMailbox();
           }
-        }, 15000);
+        }, 5000);
       }
     }
 
@@ -1082,11 +1149,11 @@ async function main() {
               }
 
               const isCr = chunk === '\r';
-              if (isCr && injectQueue.length > 0) {
+              if (isCr && bridgePendingCount > 0) {
                 // CR with pending queued text — queue CR too and flush immediately.
-                injectQueue.push(chunk);
+                enqueueBridgeMessage(chunk);
                 if (queueFlushTimer) { clearTimeout(queueFlushTimer); queueFlushTimer = null; }
-                flushInjectQueue();
+                flushBridgeMailbox();
               } else if (isCr) {
                 // CR always written immediately — never idle-gated.
                 child.write(chunk);
@@ -1097,7 +1164,7 @@ async function main() {
                 lastInjectTextTime = Date.now();
               } else {
                 // Text when not idle — queue for safe delivery.
-                injectQueue.push(chunk);
+                enqueueBridgeMessage(chunk);
                 scheduleIdleFlush();
               }
             }
@@ -1162,6 +1229,8 @@ async function main() {
 
       allowSessionClosed = true;
       cleanupTerminal();
+      // Purge bridge mailbox on clean exit (undelivered messages are stale)
+      try { bridgeMailbox.purge(bridgeTarget); } catch {}
       process.stdout.write(`\x1b]0;\x07`);
       fetchWithAuth(`${DAEMON_URL}/api/sessions/${encodeURIComponent(sessionId)}`, { method: 'DELETE' }).catch(() => {});
       if (reconnectTimer) clearTimeout(reconnectTimer);
@@ -1198,7 +1267,7 @@ async function main() {
       // Detect prompt in output to enable inject delivery
       if (promptPattern.test(data)) {
         promptReady = true;
-        flushInjectQueue();
+        flushBridgeMailbox();
         // Notify daemon that CLI is ready for inject
         if (!readyNotified && wsReady && daemonWs.readyState === 1) {
           readyNotified = true;
@@ -1235,7 +1304,7 @@ async function main() {
                 }
                 if (promptPattern.test(data)) {
                   promptReady = true;
-                  flushInjectQueue();
+                  flushBridgeMailbox();
                   if (wsReady && daemonWs.readyState === 1) {
                     daemonWs.send(JSON.stringify({ type: 'ready' }));
                   }
@@ -1634,6 +1703,76 @@ async function main() {
     return;
   }
 
+  if (cmd === 'status') {
+    const statusSessionId = args[1] || process.env.TELEPTY_SESSION_ID;
+    if (!statusSessionId) {
+      console.error('❌ Usage: telepty status <session_id>');
+      process.exit(1);
+    }
+
+    try {
+      const target = await resolveSessionTarget(statusSessionId);
+      if (!target) {
+        console.error(`❌ Session '${statusSessionId}' was not found on any discovered host.`);
+        process.exit(1);
+      }
+
+      const res = await fetchWithAuth(`http://${target.host}:${PORT}/api/sessions/${encodeURIComponent(target.id)}/state`);
+      const data = await res.json();
+      if (!res.ok) {
+        console.error(`❌ ${formatApiError(data)}`);
+        process.exit(1);
+      }
+
+      const auto = data.auto || {};
+      const selfReport = data.self_report || {};
+
+      // Color-coded state display
+      const stateColors = {
+        running: '\x1b[32m',       // green
+        idle: '\x1b[33m',          // yellow
+        thinking: '\x1b[36m',      // cyan
+        stuck: '\x1b[31m',         // red
+        waiting_input: '\x1b[35m', // magenta
+      };
+      const stateColor = stateColors[auto.state] || '\x1b[37m';
+      const reset = '\x1b[0m';
+
+      console.log(`\n  Session: \x1b[36m${data.session_id}${reset}`);
+      console.log(`  Auto State: ${stateColor}${auto.state || 'unknown'}${reset} (confidence: ${auto.confidence != null ? (auto.confidence * 100).toFixed(0) + '%' : '?'})`);
+      if (auto.since) {
+        const durationMs = auto.duration_ms || 0;
+        const durationStr = durationMs < 60000
+          ? `${(durationMs / 1000).toFixed(0)}s`
+          : `${(durationMs / 60000).toFixed(1)}m`;
+        console.log(`  Since: ${auto.since} (${durationStr} ago)`);
+      }
+      if (auto.detail) {
+        console.log(`  Trigger: ${auto.detail.trigger || '-'}`);
+        if (auto.detail.matched_line) console.log(`  Matched: "${auto.detail.matched_line}"`);
+        if (auto.detail.silence_ms) console.log(`  Silence: ${(auto.detail.silence_ms / 1000).toFixed(1)}s`);
+        if (auto.detail.repeat_count) console.log(`  Error repeats: ${auto.detail.repeat_count}`);
+      }
+      if (auto.last_output_preview) {
+        const preview = auto.last_output_preview.replace(/\n/g, '\\n').slice(-80);
+        console.log(`  Last output: "${preview}"`);
+      }
+
+      if (selfReport.phase) {
+        console.log(`\n  Self-report:`);
+        console.log(`    Phase: ${selfReport.phase}`);
+        if (selfReport.current_task) console.log(`    Task: ${selfReport.current_task}`);
+        if (selfReport.blocker) console.log(`    Blocker: \x1b[31m${selfReport.blocker}${reset}`);
+        if (selfReport.needs_input) console.log(`    Needs input: \x1b[35myes${reset}`);
+      }
+      console.log('');
+    } catch (e) {
+      console.error(`❌ ${e.message || 'Failed to get session state.'}`);
+      process.exit(1);
+    }
+    return;
+  }
+
   if (cmd === 'status-report') {
     const reportArgs = args.slice(1);
     let sessionId = process.env.TELEPTY_SESSION_ID || undefined;