@dmsdc-ai/aigentry-telepty 0.1.88 → 0.1.90

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;
@@ -356,6 +357,61 @@ function startDetachedDaemon() {
   cp.unref();
 }
 
+async function waitForDaemonHealth(maxMs = 5000) {
+  const deadline = Date.now() + maxMs;
+  while (Date.now() < deadline) {
+    try {
+      const meta = await getDaemonMeta('127.0.0.1');
+      if (meta && meta.version) return meta;
+    } catch {}
+    await new Promise(r => setTimeout(r, 300));
+  }
+  return null;
+}
+
+async function restartDaemonGraceful(options = {}) {
+  const maxAttempts = options.maxAttempts || 3;
+  const requiredCapabilities = options.requiredCapabilities || [];
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    // (a) Kill existing daemon processes
+    const results = cleanupDaemonProcesses();
+
+    // (b) Wait up to 3s for old processes to fully exit
+    if (results.stopped.length > 0) {
+      const { isProcessRunning } = require('./daemon-control');
+      const killDeadline = Date.now() + 3000;
+      for (const item of results.stopped) {
+        while (Date.now() < killDeadline && isProcessRunning(item.pid)) {
+          await new Promise(r => setTimeout(r, 100));
+        }
+      }
+    }
+
+    // (c) Start new daemon
+    startDetachedDaemon();
+
+    // (d) Wait for new daemon to respond with correct version
+    const meta = await waitForDaemonHealth(5000);
+    if (meta && meta.version === pkg.version) {
+      const hasCapabilities = requiredCapabilities.every(c => (meta.capabilities || []).includes(c));
+      if (hasCapabilities || requiredCapabilities.length === 0) {
+        return { success: true, meta, attempt };
+      }
+    }
+
+    // Retry with backoff
+    if (attempt < maxAttempts) {
+      const backoff = 1000 * attempt;
+      process.stdout.write(`\x1b[33m⚠️ Daemon restart attempt ${attempt}/${maxAttempts} failed. Retrying in ${backoff / 1000}s...\x1b[0m\n`);
+      await new Promise(r => setTimeout(r, backoff));
+    }
+  }
+
+  console.error(`\x1b[31m❌ Daemon restart failed after ${maxAttempts} attempts. Run "telepty daemon" manually to start.\x1b[0m`);
+  return { success: false, meta: null, attempt: maxAttempts };
+}
+
 function renderInteractiveHeader() {
   const runtimeInfo = getRuntimeInfo(__dirname);
   console.clear();
@@ -402,14 +458,13 @@ async function repairLocalDaemon(options = {}) {
     return { stopped: results.stopped.length, failed: results.failed.length, meta: null };
   }
 
-  startDetachedDaemon();
-  await new Promise((resolve) => setTimeout(resolve, 1000));
-  const meta = await getDaemonMeta('127.0.0.1');
-  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 };
+  const restartResult = await restartDaemonGraceful();
+  return {
+    stopped: results.stopped.length,
+    failed: results.failed.length,
+    meta: restartResult.meta,
+    versionMatch: restartResult.success
+  };
 }
 
 function getDiscoveryHosts() {
@@ -476,30 +531,22 @@ async function ensureDaemonRunning(options = {}) {
       // 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();
+        await restartDaemonGraceful({ requiredCapabilities });
+        return;
       } 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) {
       process.stdout.write('\x1b[33m⚙️ Found a local telepty daemon without the required features. Restarting it...\x1b[0m\n');
-      cleanupDaemonProcesses();
     }
   } catch (e) {
     // Continue to auto-start below.
   }
 
   process.stdout.write('\x1b[33m⚙️ Auto-starting local telepty daemon...\x1b[0m\n');
-  cleanupDaemonProcesses();
-  startDetachedDaemon();
-  await new Promise(r => setTimeout(r, 1000));
-
-  const meta = await getDaemonMeta('127.0.0.1');
-  if (!meta || !requiredCapabilities.every((item) => meta.capabilities.includes(item))) {
-    console.error('❌ Failed to start a compatible local telepty daemon. Open telepty and choose "Repair local daemon", or rerun the installer.');
-  }
+  await restartDaemonGraceful({ requiredCapabilities });
 }
 
 async function manageInteractiveAttach(sessionId, targetHost) {
@@ -1000,10 +1047,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);
     }
@@ -1011,34 +1089,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);
       }
     }
 
@@ -1104,11 +1195,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);
@@ -1119,7 +1210,7 @@ async function main() {
                 lastInjectTextTime = Date.now();
               } else {
                 // Text when not idle — queue for safe delivery.
-                injectQueue.push(chunk);
+                enqueueBridgeMessage(chunk);
                 scheduleIdleFlush();
               }
             }
@@ -1184,6 +1275,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);
@@ -1220,7 +1313,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;
@@ -1257,7 +1350,7 @@ async function main() {
                 }
                 if (promptPattern.test(data)) {
                   promptReady = true;
-                  flushInjectQueue();
+                  flushBridgeMailbox();
                   if (wsReady && daemonWs.readyState === 1) {
                     daemonWs.send(JSON.stringify({ type: 'ready' }));
                   }
@@ -1656,6 +1749,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;