@dmsdc-ai/aigentry-telepty 0.1.5 → 0.1.7

package/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 const path = require('path');
+const os = require('os');
 const WebSocket = require('ws');
 const { execSync, spawn } = require('child_process');
 const readline = require('readline');
@@ -8,14 +9,17 @@ const prompts = require('prompts');
 const updateNotifier = require('update-notifier');
 const pkg = require('./package.json');
 const { getConfig } = require('./auth');
+const { runInteractiveSkillInstaller } = require('./skill-installer');
 const args = process.argv.slice(2);
 
-// Check for updates
-updateNotifier({pkg}).notify({ isGlobal: true });
+// 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 });
+}
 
 // Support remote host via environment variable or default to localhost
 let REMOTE_HOST = process.env.TELEPTY_HOST || '127.0.0.1';
-const PORT = 3848;
+const PORT = Number(process.env.TELEPTY_PORT || 3848);
 let DAEMON_URL = `http://${REMOTE_HOST}:${PORT}`;
 let WS_URL = `ws://${REMOTE_HOST}:${PORT}`;
 
@@ -27,25 +31,6 @@ const fetchWithAuth = (url, options = {}) => {
   return fetch(url, { ...options, headers });
 };
 
-async function ensureDaemonRunning() {
-  if (REMOTE_HOST !== '127.0.0.1') return; // Only auto-start local daemon
-  try {
-    const res = await fetchWithAuth(`${DAEMON_URL}/api/sessions`);
-    if (res.ok) return; // Already running
-  } catch (e) {
-    // Not running, let's start it
-    process.stdout.write('\x1b[33m⚙️ Auto-starting local telepty daemon...\x1b[0m\n');
-    const cp = spawn(process.argv[0], [process.argv[1], 'daemon'], {
-      detached: true,
-      stdio: 'ignore'
-    });
-    cp.unref();
-    
-    // Wait a brief moment for the daemon to boot up
-    await new Promise(r => setTimeout(r, 1000));
-  }
-}
-
 async function discoverSessions() {
   await ensureDaemonRunning();
   const hosts = ['127.0.0.1'];
@@ -107,13 +92,19 @@ async function ensureDaemonRunning() {
 async function manageInteractiveAttach(sessionId, targetHost) {
   const wsUrl = `ws://${targetHost}:${PORT}/api/sessions/${encodeURIComponent(sessionId)}?token=${encodeURIComponent(TOKEN)}`;
   const ws = new WebSocket(wsUrl);
+  let inputHandler = null;
+  let resizeHandler = null;
   return new Promise((resolve) => {
     ws.on('open', () => {
-      console.log(`\n\x1b[32mEntered room '${sessionId}'. The room will be destroyed if you exit (Ctrl+C or exit command).\x1b[0m\n`);
+      // Set Ghostty tab title to show session ID
+      process.stdout.write(`\x1b]0;⚡ telepty :: ${sessionId}\x07`);
+      console.log(`\n\x1b[32mEntered room '${sessionId}'.\x1b[0m\n`);
       if (process.stdin.isTTY) process.stdin.setRawMode(true);
-      process.stdin.on('data', d => ws.send(JSON.stringify({ type: 'input', data: d.toString() })));
-      const resizer = () => ws.send(JSON.stringify({ type: 'resize', cols: process.stdout.columns, rows: process.stdout.rows }));
-      process.stdout.on('resize', resizer); resizer();
+      inputHandler = (d) => ws.send(JSON.stringify({ type: 'input', data: d.toString() }));
+      resizeHandler = () => ws.send(JSON.stringify({ type: 'resize', cols: process.stdout.columns, rows: process.stdout.rows }));
+      process.stdin.on('data', inputHandler);
+      process.stdout.on('resize', resizeHandler);
+      resizeHandler();
     });
     ws.on('message', m => {
       const msg = JSON.parse(m);
@@ -121,14 +112,27 @@ async function manageInteractiveAttach(sessionId, targetHost) {
     });
     ws.on('close', async () => {
       if (process.stdin.isTTY) process.stdin.setRawMode(false);
-      console.log(`\n\x1b[33mLeft room '${sessionId}'. Destroying session to prevent zombies...\x1b[0m\n`);
-      process.stdin.removeAllListeners('data');
-      
-      // Auto-kill session when the primary creator leaves
+      process.stdout.write(`\x1b]0;\x07`); // Restore default terminal title
+      if (inputHandler) process.stdin.off('data', inputHandler);
+      if (resizeHandler) process.stdout.off('resize', resizeHandler);
+
+      // Check if other clients are still attached before destroying
       try {
-        await fetchWithAuth(`http://${targetHost}:${PORT}/api/sessions/${encodeURIComponent(sessionId)}`, { method: 'DELETE' });
-      } catch(e) {}
-      
+        const res = await fetchWithAuth(`http://${targetHost}:${PORT}/api/sessions`);
+        if (res.ok) {
+          const sessions = await res.json();
+          const session = sessions.find(s => s.id === sessionId);
+          if (session && session.active_clients > 0) {
+            console.log(`\n\x1b[33mLeft room '${sessionId}'. Other clients still attached — session kept alive.\x1b[0m\n`);
+          } else {
+            console.log(`\n\x1b[33mLeft room '${sessionId}'. No other clients — destroying session.\x1b[0m\n`);
+            await fetchWithAuth(`http://${targetHost}:${PORT}/api/sessions/${encodeURIComponent(sessionId)}`, { method: 'DELETE' });
+          }
+        }
+      } catch(e) {
+        // Daemon unreachable, nothing to clean up
+      }
+
       resolve();
     });
   });
@@ -146,8 +150,10 @@ async function manageInteractive() {
       choices: [
         { title: '🖥️   Enter a room (Attach to session)', value: 'attach' },
         { title: '➕  Create a new room (Spawn session)', value: 'spawn' },
+        { title: '🔌  Allow inject (Run CLI with inject)', value: 'allow' },
         { title: '💬  Send message to a room (Inject command)', value: 'inject' },
         { title: '📋  View all open rooms (List sessions)', value: 'list' },
+        { title: '🧠  Install telepty skills', value: 'install-skills' },
         { title: '🔄  Update telepty to latest version', value: 'update' },
         { title: '❌  Exit', value: 'exit' }
       ]
@@ -185,6 +191,15 @@ async function manageInteractive() {
       continue;
     }
 
+    if (response.action === 'install-skills') {
+      try {
+        await runInteractiveSkillInstaller({ packageRoot: __dirname, cwd: process.cwd() });
+      } catch (e) {
+        console.error(`\n❌ ${e.message}\n`);
+      }
+      continue;
+    }
+
     if (response.action === 'list') {
       console.log('\n');
       const sessions = await discoverSessions();
@@ -215,7 +230,7 @@ async function manageInteractive() {
       try {
         const res = await fetchWithAuth(`${DAEMON_URL}/api/sessions/spawn`, {
           method: 'POST', headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ session_id: id, command, args: [], cwd: process.cwd(), cols, rows })
+          body: JSON.stringify({ session_id: id, command, args: [], cwd: process.cwd(), cols, rows, type: 'USER' })
         });
         const data = await res.json();
         if (!res.ok) console.error(`\n❌ Error: ${data.error}\n`);
@@ -231,6 +246,20 @@ async function manageInteractive() {
       continue;
     }
 
+    if (response.action === 'allow') {
+      const { id, command } = await prompts([
+        { type: 'text', name: 'id', message: 'Enter session ID (e.g. my-claude):', validate: v => v ? true : 'Required' },
+        { type: 'text', name: 'command', message: 'Enter command to run (e.g. claude, codex, gemini, bash):', initial: 'bash' }
+      ]);
+      if (!id || !command) continue;
+
+      // Delegate to the allow command handler by setting up args and calling main flow
+      process.argv.splice(2, process.argv.length - 2, 'allow', '--id', id, command);
+      args.length = 0;
+      args.push('allow', '--id', id, command);
+      return main();
+    }
+
     if (response.action === 'attach' || response.action === 'inject') {
       const sessions = await discoverSessions();
       if (sessions.length === 0) {
@@ -346,7 +375,7 @@ async function main() {
     try {
       const res = await fetchWithAuth(`${DAEMON_URL}/api/sessions/spawn`, {
         method: 'POST', headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ session_id: sessionId, command: command, args: cmdArgs, cwd: process.cwd(), cols, rows })
+        body: JSON.stringify({ session_id: sessionId, command: command, args: cmdArgs, cwd: process.cwd(), cols, rows, type: 'USER' })
       });
       const data = await res.json();
       if (!res.ok) { console.error(`❌ Error: ${data.error}`); return; }
@@ -356,6 +385,139 @@ async function main() {
     return;
   }
 
+  if (cmd === 'allow' || cmd === 'enable' || cmd === 'wrap') {
+    // Parse arguments: telepty allow [--id <session_id>] <command> [args...]
+    // Also supports legacy: telepty allow [--id <session_id>] -- <command> [args...]
+    const allowArgs = args.slice(1);
+
+    // Extract --id flag
+    let sessionId;
+    const idIndex = allowArgs.indexOf('--id');
+    if (idIndex !== -1 && allowArgs[idIndex + 1]) {
+      sessionId = allowArgs[idIndex + 1];
+      allowArgs.splice(idIndex, 2);
+    }
+
+    // Strip optional -- separator for backward compat
+    const sepIndex = allowArgs.indexOf('--');
+    if (sepIndex !== -1) allowArgs.splice(sepIndex, 1);
+
+    const command = allowArgs[0];
+    const cmdArgs = allowArgs.slice(1);
+
+    if (!command) {
+      console.error('❌ Usage: telepty allow [--id <session_id>] <command> [args...]');
+      process.exit(1);
+    }
+
+    // Default session ID = command name
+    if (!sessionId) {
+      sessionId = path.basename(command);
+    }
+
+    await ensureDaemonRunning();
+
+    // Register session with daemon
+    try {
+      const res = await fetchWithAuth(`${DAEMON_URL}/api/sessions/register`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ session_id: sessionId, command, cwd: process.cwd() })
+      });
+      const data = await res.json();
+      if (!res.ok) {
+        console.error(`❌ Error: ${data.error}`);
+        process.exit(1);
+      }
+    } catch (e) {
+      console.error('❌ Failed to register with daemon:', e.message);
+      process.exit(1);
+    }
+
+    // Spawn local PTY (preserves isTTY, env, shell config)
+    const pty = require('node-pty');
+    const child = pty.spawn(command, cmdArgs, {
+      name: 'xterm-256color',
+      cols: process.stdout.columns || 80,
+      rows: process.stdout.rows || 30,
+      cwd: process.cwd(),
+      env: { ...process.env, TELEPTY_SESSION_ID: sessionId }
+    });
+
+    // Connect to daemon WebSocket for inject reception and output relay
+    const wsUrl = `ws://${REMOTE_HOST}:${PORT}/api/sessions/${encodeURIComponent(sessionId)}?token=${encodeURIComponent(TOKEN)}`;
+    const daemonWs = new WebSocket(wsUrl);
+    let wsReady = false;
+
+    daemonWs.on('open', () => {
+      wsReady = true;
+    });
+
+    // Receive inject messages from daemon
+    daemonWs.on('message', (message) => {
+      try {
+        const msg = JSON.parse(message);
+        if (msg.type === 'inject') {
+          child.write(msg.data);
+        } else if (msg.type === 'resize') {
+          child.resize(msg.cols, msg.rows);
+        }
+      } catch (e) {
+        // ignore malformed messages
+      }
+    });
+
+    daemonWs.on('close', () => {
+      wsReady = false;
+      console.error(`\n\x1b[33m⚠️ Disconnected from daemon. Inject unavailable. Session continues locally.\x1b[0m`);
+    });
+
+    daemonWs.on('error', () => {
+      // silently handle
+    });
+
+    // Set terminal title
+    process.stdout.write(`\x1b]0;⚡ telepty :: ${sessionId}\x07`);
+    console.log(`\x1b[32m⚡ '${command}' is now session '\x1b[36m${sessionId}\x1b[32m'. Inject allowed.\x1b[0m\n`);
+
+    // Enter raw mode and relay stdin to local PTY
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+
+    process.stdin.on('data', (data) => {
+      child.write(data.toString());
+    });
+
+    // Relay PTY output to current terminal + send to daemon for attach clients
+    child.onData((data) => {
+      process.stdout.write(data);
+      if (wsReady && daemonWs.readyState === 1) {
+        daemonWs.send(JSON.stringify({ type: 'output', data }));
+      }
+    });
+
+    // Handle terminal resize
+    process.stdout.on('resize', () => {
+      child.resize(process.stdout.columns, process.stdout.rows);
+    });
+
+    // Handle child exit
+    child.onExit(({ exitCode }) => {
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+      process.stdout.write(`\x1b]0;\x07`);
+      console.log(`\n\x1b[33mSession '${sessionId}' exited (code ${exitCode}).\x1b[0m`);
+
+      // Deregister from daemon
+      fetchWithAuth(`${DAEMON_URL}/api/sessions/${encodeURIComponent(sessionId)}`, { method: 'DELETE' }).catch(() => {});
+      daemonWs.close();
+      process.exit(exitCode || 0);
+    });
+
+    // Graceful shutdown on SIGINT (let child handle it via PTY)
+    process.on('SIGINT', () => {});
+
+    return;
+  }
+
   if (cmd === 'attach') {
     let sessionId = args[1];
     let targetHost = REMOTE_HOST;
@@ -389,19 +551,25 @@ async function main() {
 
     const wsUrl = `ws://${targetHost}:${PORT}/api/sessions/${encodeURIComponent(sessionId)}?token=${encodeURIComponent(TOKEN)}`;
     const ws = new WebSocket(wsUrl);
+    let inputHandler = null;
+    let resizeHandler = null;
 
     ws.on('open', () => {
-      console.log(`\x1b[32mEntered room '${sessionId}' at ${targetHost}. The room will be destroyed if you exit.\x1b[0m\n`);
-      
+      // Set Ghostty tab title to show session ID
+      const hostSuffix = targetHost === '127.0.0.1' ? '' : ` @ ${targetHost}`;
+      process.stdout.write(`\x1b]0;⚡ telepty :: ${sessionId}${hostSuffix}\x07`);
+      console.log(`\x1b[32mEntered room '${sessionId}'${hostSuffix ? ` (${targetHost})` : ''}.\x1b[0m\n`);
+
       if (process.stdin.isTTY) {
         process.stdin.setRawMode(true);
       }
 
-      process.stdin.on('data', (data) => {
+      inputHandler = (data) => {
         ws.send(JSON.stringify({ type: 'input', data: data.toString() }));
-      });
+      };
+      process.stdin.on('data', inputHandler);
 
-      const resizeHandler = () => {
+      resizeHandler = () => {
         ws.send(JSON.stringify({
           type: 'resize',
           cols: process.stdout.columns,
@@ -424,9 +592,23 @@ async function main() {
       if (process.stdin.isTTY) {
         process.stdin.setRawMode(false);
       }
-      console.log(`\n\x1b[33mLeft room. Destroying session '${sessionId}' to prevent zombies... (Code: ${code})\x1b[0m`);
+      process.stdout.write(`\x1b]0;\x07`); // Restore default terminal title
+      if (inputHandler) process.stdin.off('data', inputHandler);
+      if (resizeHandler) process.stdout.off('resize', resizeHandler);
+
+      // Check if other clients are still attached before destroying
       try {
-        await fetchWithAuth(`http://${targetHost}:${PORT}/api/sessions/${encodeURIComponent(sessionId)}`, { method: 'DELETE' });
+        const res = await fetchWithAuth(`http://${targetHost}:${PORT}/api/sessions`);
+        if (res.ok) {
+          const allSessions = await res.json();
+          const session = allSessions.find(s => s.id === sessionId);
+          if (session && session.active_clients > 0) {
+            console.log(`\n\x1b[33mLeft room '${sessionId}'. Other clients still attached — session kept alive.\x1b[0m`);
+          } else {
+            console.log(`\n\x1b[33mLeft room '${sessionId}'. No other clients — destroying session.\x1b[0m`);
+            await fetchWithAuth(`http://${targetHost}:${PORT}/api/sessions/${encodeURIComponent(sessionId)}`, { method: 'DELETE' });
+          }
+        }
       } catch(e) {}
       process.exit(0);
     });
@@ -490,6 +672,20 @@ async function main() {
     return;
   }
 
+  if (cmd === 'rename') {
+    const oldId = args[1]; const newId = args[2];
+    if (!oldId || !newId) { console.error('❌ Usage: telepty rename <old_id> <new_id>'); process.exit(1); }
+    try {
+      const res = await fetchWithAuth(`${DAEMON_URL}/api/sessions/${encodeURIComponent(oldId)}`, {
+        method: 'PATCH', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ new_id: newId })
+      });
+      const data = await res.json();
+      if (!res.ok) { console.error(`❌ Error: ${data.error}`); return; }
+      console.log(`✅ Session renamed: '\x1b[36m${oldId}\x1b[0m' → '\x1b[36m${newId}\x1b[0m'`);
+    } catch (e) { console.error('❌ Failed to connect to daemon. Is it running?'); }
+    return;
+  }
+
   if (cmd === 'listen' || cmd === 'monitor') {
     await ensureDaemonRunning();
     
@@ -518,14 +714,19 @@ async function main() {
           const msg = JSON.parse(raw);
           const time = new Date().toLocaleTimeString();
           const sender = msg.sender || msg.from || 'Unknown';
-          const target = msg.target_agent || msg.to || 'Broadcast';
+          const target = msg.target_agent || msg.to || 'Bus';
+          
+          let preview = msg.content || msg.message || msg.payload || msg.data;
+          if (msg.type === 'session_spawn') {
+            console.log(`\x1b[90m[${time}]\x1b[0m 🚀 \x1b[32m\x1b[1mNew Session\x1b[0m: \x1b[36m${msg.session_id}\x1b[0m (${msg.command})`);
+            return;
+          }
           
-          let preview = msg.content || msg.message || msg.payload || JSON.stringify(msg);
           if (typeof preview === 'object') preview = JSON.stringify(preview);
-          if (preview.length > 200) preview = preview.substring(0, 197) + '...';
+          if (preview && preview.length > 200) preview = preview.substring(0, 197) + '...';
 
           console.log(`\x1b[90m[${time}]\x1b[0m \x1b[32m\x1b[1m${sender}\x1b[0m ➔ \x1b[33m\x1b[1m${target}\x1b[0m`);
-          console.log(`  \x1b[37m${preview}\x1b[0m\n`);
+          if (preview) console.log(`  \x1b[37m${preview}\x1b[0m\n`);
         } catch (e) {
           // Fallback if not valid JSON
           console.log(`\x1b[90m[${new Date().toLocaleTimeString()}]\x1b[0m 📦 \x1b[37m${raw}\x1b[0m\n`);
@@ -550,11 +751,13 @@ async function main() {
 Usage:
   telepty daemon                                 Start the background daemon
   telepty spawn --id <id> <command> [args...]    Spawn a new background CLI
+  telepty allow [--id <id>] <command> [args...]       Allow inject on a CLI
   telepty list                                   List all active sessions
   telepty attach [id]                            Attach to a session (Interactive picker if no ID)
   telepty inject [--no-enter] <id> "<prompt>"    Inject text into a single session
   telepty multicast <id1,id2> "<prompt>"         Inject text into multiple specific sessions
   telepty broadcast "<prompt>"                   Inject text into ALL active sessions
+  telepty rename <old_id> <new_id>               Rename a session (updates terminal title too)
   telepty listen                                 Listen to the event bus and print JSON to stdout
   telepty monitor                                Human-readable real-time billboard of bus events
   telepty update                                 Update telepty to the latest version