@dmsdc-ai/aigentry-telepty 0.0.7 → 0.0.9

package/.gemini/skills/telepty/SKILL.md

@@ -0,0 +1,19 @@
+# telepty
+
+**Description:**
+Help the user interact with the `telepty` daemon, check their current session ID, list active sessions, and inject commands into remote or local PTY sessions.
+
+**Trigger:**
+When the user asks about their current session ID (e.g. "내 세션 ID가 뭐야?"), wants to check active sessions ("세션 목록 보여줘"), or wants to inject a prompt/command into a specific session ("dustcraw한테 메시지 보내줘").
+
+**Instructions:**
+1. **To check the current session ID:**
+   - Execute `run_shell_command` with `echo $TELEPTY_SESSION_ID`.
+   - If the value is empty, inform the user that the current shell is *not* running inside a telepty spawned session (it is a normal native terminal).
+   - If it has a value, output it clearly: "현재 계신 터미널의 telepty 세션 ID는 `[ID]` 입니다."
+2. **To list all sessions:**
+   - Run `telepty list`.
+3. **To inject a command into another session:**
+   - For a single session: Run `telepty inject <target_session_id> "<message or command>"`.
+   - For broadcasting to ALL active sessions: Run `telepty broadcast "<message or command>"`.
+   - For multicasting to multiple specific sessions: Run `telepty multicast <id1>,<id2> "<message or command>"`.

package/cli.js

@@ -2,8 +2,9 @@
 
 const path = require('path');
 const WebSocket = require('ws');
-const { execSync } = require('child_process');
+const { execSync, spawn } = require('child_process');
 const readline = require('readline');
+const prompts = require('prompts');
 const { getConfig } = require('./auth');
 const args = process.argv.slice(2);
 
@@ -59,8 +60,152 @@ async function discoverSessions() {
   return allSessions;
 }
 
+async function manageInteractive() {
+  console.clear();
+  console.log('\x1b[36m\x1b[1m⚡ Telepty Agent Manager\x1b[0m\n');
+
+  while (true) {
+    const response = await prompts({
+      type: 'select',
+      name: 'action',
+      message: 'What would you like to do?',
+      choices: [
+        { title: '📡  Attach to a session', value: 'attach' },
+        { title: '🚀  Spawn a new session', value: 'spawn' },
+        { title: '💉  Inject command into a session', value: 'inject' },
+        { title: '📋  List active sessions', value: 'list' },
+        { title: '⚙️   Start background daemon', value: 'daemon' },
+        { title: '❌  Exit', value: 'exit' }
+      ]
+    });
+
+    if (!response.action || response.action === 'exit') {
+      console.log('Goodbye!');
+      process.exit(0);
+    }
+
+    if (response.action === 'daemon') {
+      console.log('\n\x1b[33mStarting daemon in background...\x1b[0m');
+      const cp = spawn(process.argv[0], [process.argv[1], 'daemon'], {
+        detached: true,
+        stdio: 'ignore'
+      });
+      cp.unref();
+      console.log('✅ Daemon started.\n');
+      continue;
+    }
+
+    if (response.action === 'list') {
+      console.log('\n');
+      const sessions = await discoverSessions();
+      if (sessions.length === 0) {
+        console.log('❌ No active sessions found.');
+      } else {
+        console.log('\x1b[1mAvailable Sessions:\x1b[0m');
+        sessions.forEach(s => {
+          const hostLabel = s.host === '127.0.0.1' ? 'Local' : s.host;
+          console.log(`  - \x1b[36m${s.id}\x1b[0m (\x1b[33m${hostLabel}\x1b[0m) [${s.command}] - Clients: ${s.active_clients}`);
+        });
+      }
+      console.log('\n');
+      continue;
+    }
+
+    if (response.action === 'spawn') {
+      const { id, command } = await prompts([
+        { type: 'text', name: 'id', message: 'Enter new session ID (e.g. agent-1):', validate: v => v ? true : 'Required' },
+        { type: 'text', name: 'command', message: 'Enter command to run (e.g. bash, zsh, python):', initial: 'bash' }
+      ]);
+      if (!id || !command) continue;
+      
+      const cols = process.stdout.columns || 80;
+      const rows = process.stdout.rows || 30;
+      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 })
+        });
+        const data = await res.json();
+        if (!res.ok) console.error(`\n❌ Error: ${data.error}\n`);
+        else console.log(`\n✅ Session '\x1b[36m${data.session_id}\x1b[0m' spawned successfully.\n`);
+      } catch (e) {
+        console.error('\n❌ Failed to connect to local daemon. Is it running?\n');
+      }
+      continue;
+    }
+
+    if (response.action === 'attach' || response.action === 'inject') {
+      const sessions = await discoverSessions();
+      if (sessions.length === 0) {
+        console.log('\n❌ No active sessions found to ' + response.action + '.\n');
+        continue;
+      }
+      const { target } = await prompts({
+        type: 'select',
+        name: 'target',
+        message: `Select a session to ${response.action}:`,
+        choices: sessions.map(s => ({
+          title: `${s.id} (${s.host === '127.0.0.1' ? 'Local' : s.host}) - ${s.command}`,
+          value: s
+        }))
+      });
+
+      if (!target) continue;
+
+      if (response.action === 'attach') {
+        const wsUrl = `ws://${target.host}:${PORT}/api/sessions/${encodeURIComponent(target.id)}?token=${encodeURIComponent(TOKEN)}`;
+        const ws = new WebSocket(wsUrl);
+        await new Promise((resolve) => {
+          ws.on('open', () => {
+            console.log(`\n\x1b[32mConnected to '${target.id}'. Press Ctrl+C to detach.\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();
+          });
+          ws.on('message', m => {
+            const msg = JSON.parse(m);
+            if (msg.type === 'output') process.stdout.write(msg.data);
+          });
+          ws.on('close', () => {
+            if (process.stdin.isTTY) process.stdin.setRawMode(false);
+            console.log(`\n\x1b[33mDisconnected from session.\x1b[0m\n`);
+            process.stdin.removeAllListeners('data');
+            resolve();
+          });
+        });
+        continue;
+      }
+
+      if (response.action === 'inject') {
+        const { promptText } = await prompts({
+          type: 'text',
+          name: 'promptText',
+          message: 'Enter text to inject:',
+          validate: v => v ? true : 'Required'
+        });
+        if (!promptText) continue;
+        try {
+          const res = await fetchWithAuth(`http://${target.host}:${PORT}/api/sessions/${encodeURIComponent(target.id)}/inject`, {
+            method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ prompt: promptText })
+          });
+          const data = await res.json();
+          if (!res.ok) console.error(`\n❌ Error: ${data.error}\n`);
+          else console.log(`\n✅ Injected successfully into '\x1b[36m${target.id}\x1b[0m'.\n`);
+        } catch (e) { console.error('\n❌ Failed to connect.\n'); }
+        continue;
+      }
+    }
+  }
+}
+
 async function main() {
   const cmd = args[0];
+  
+  if (!cmd) {
+    return manageInteractive();
+  }
+
   if (cmd === 'mcp') {
     require('./mcp.js');
     return;
@@ -210,6 +355,38 @@ async function main() {
     return;
   }
 
+  if (cmd === 'multicast') {
+    const sessionIdsRaw = args[1]; const prompt = args.slice(2).join(' ');
+    if (!sessionIdsRaw || !prompt) { console.error('❌ Usage: telepty multicast <id1,id2,...> "<prompt text>"'); process.exit(1); }
+    const sessionIds = sessionIdsRaw.split(',').map(s => s.trim()).filter(s => s);
+    try {
+      const res = await fetchWithAuth(`${DAEMON_URL}/api/sessions/multicast/inject`, {
+        method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ session_ids: sessionIds, prompt })
+      });
+      const data = await res.json();
+      if (!res.ok) { console.error(`❌ Error: ${data.error}`); return; }
+      console.log(`✅ Context multicasted successfully to ${data.results.successful.length} sessions.`);
+      if (data.results.failed.length > 0) {
+        console.warn(`⚠️ Failed to inject into ${data.results.failed.length} sessions:`, data.results.failed.map(f => f.id).join(', '));
+      }
+    } catch (e) { console.error('❌ Failed to connect to daemon. Is it running?'); }
+    return;
+  }
+
+  if (cmd === 'broadcast') {
+    const prompt = args.slice(1).join(' ');
+    if (!prompt) { console.error('❌ Usage: telepty broadcast "<prompt text>"'); process.exit(1); }
+    try {
+      const res = await fetchWithAuth(`${DAEMON_URL}/api/sessions/broadcast/inject`, {
+        method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ prompt })
+      });
+      const data = await res.json();
+      if (!res.ok) { console.error(`❌ Error: ${data.error}`); return; }
+      console.log(`✅ Context broadcasted successfully to ${data.results.successful.length} active sessions.`);
+    } catch (e) { console.error('❌ Failed to connect to daemon. Is it running?'); }
+    return;
+  }
+
   console.log(`
 \x1b[1maigentry-telepty\x1b[0m - Remote PTY Control
 
@@ -218,7 +395,9 @@ Usage:
   telepty spawn --id <id> <command> [args...]    Spawn a new background CLI
   telepty list                                   List all active sessions
   telepty attach [id]                            Attach to a session (Interactive picker if no ID)
-  telepty inject <id> "<prompt>"                 Inject text into an active session
+  telepty inject <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 mcp                                    Start the MCP stdio server
 `);
 }

package/daemon.js

@@ -94,6 +94,48 @@ app.get('/api/sessions', (req, res) => {
   res.json(list);
 });
 
+app.post('/api/sessions/multicast/inject', (req, res) => {
+  const { session_ids, prompt } = req.body;
+  if (!prompt) return res.status(400).json({ error: 'prompt is required' });
+  if (!Array.isArray(session_ids)) return res.status(400).json({ error: 'session_ids must be an array' });
+
+  const results = { successful: [], failed: [] };
+
+  session_ids.forEach(id => {
+    const session = sessions[id];
+    if (session) {
+      try {
+        session.ptyProcess.write(`${prompt}\r`);
+        results.successful.push(id);
+      } catch (err) {
+        results.failed.push({ id, error: err.message });
+      }
+    } else {
+      results.failed.push({ id, error: 'Session not found' });
+    }
+  });
+
+  res.json({ success: true, results });
+});
+
+app.post('/api/sessions/broadcast/inject', (req, res) => {
+  const { prompt } = req.body;
+  if (!prompt) return res.status(400).json({ error: 'prompt is required' });
+
+  const results = { successful: [], failed: [] };
+
+  Object.keys(sessions).forEach(id => {
+    try {
+      sessions[id].ptyProcess.write(`${prompt}\r`);
+      results.successful.push(id);
+    } catch (err) {
+      results.failed.push({ id, error: err.message });
+    }
+  });
+
+  res.json({ success: true, results });
+});
+
 app.post('/api/sessions/:id/inject', (req, res) => {
   const { id } = req.params;
   const { prompt } = req.body;

package/install.ps1

@@ -26,7 +26,7 @@ if (!$teleptyCmd) {
 }
 
 $teleptyPath = $teleptyCmd.Source
-Start-Process -NoNewWindow -FilePath node -ArgumentList "$teleptyPath daemon" -WindowStyle Hidden
+Start-Process -FilePath node -ArgumentList "$teleptyPath daemon" -WindowStyle Hidden
 Write-Host "✅ Windows daemon started in background." -ForegroundColor Green
 
 Write-Host "`n🎉 Installation complete! Telepty daemon is running." -ForegroundColor Cyan

package/mcp.js

@@ -18,8 +18,14 @@ const tools = [
   },
   {
     name: 'telepty_inject_context',
-    description: 'Inject a prompt or context into an active AI CLI session on a remote machine. WARNING: You MUST use telepty_list_remote_sessions first to find the exact session_id, and ask the user for confirmation if ambiguous.',
-    schema: z.object({ remote_url: z.string(), session_id: z.string().describe('The EXACT session ID.'), prompt: z.string().describe('Text to inject into stdin.') })
+    description: 'Inject a prompt or context into specific active AI CLI sessions on a remote machine. You can specify a single session ID, multiple session IDs, or broadcast to all.',
+    schema: z.object({ 
+      remote_url: z.string(), 
+      session_ids: z.array(z.string()).optional().describe('An array of exact session IDs to inject into. If not provided, it will inject into session_id.'), 
+      session_id: z.string().optional().describe('Legacy fallback for a single session ID.'),
+      broadcast: z.boolean().optional().describe('If true, injects the prompt into ALL active sessions on the remote daemon. Overrides session_ids.'),
+      prompt: z.string().describe('Text to inject into stdin.') 
+    })
   }
 ];
 
@@ -47,12 +53,35 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
     if (name === 'telepty_inject_context') {
       const baseUrl = args.remote_url.startsWith('http') ? args.remote_url : `http://${args.remote_url}`;
-      const res = await fetch(`${baseUrl}/api/sessions/${encodeURIComponent(args.session_id)}/inject`, {
-        method: 'POST', headers: { 'Content-Type': 'application/json', 'x-telepty-token': TOKEN }, body: JSON.stringify({ prompt: args.prompt })
+      
+      let endpoint = '';
+      let body = {};
+      
+      if (args.broadcast) {
+        endpoint = `${baseUrl}/api/sessions/broadcast/inject`;
+        body = { prompt: args.prompt };
+      } else if (args.session_ids && args.session_ids.length > 0) {
+        endpoint = `${baseUrl}/api/sessions/multicast/inject`;
+        body = { session_ids: args.session_ids, prompt: args.prompt };
+      } else if (args.session_id) {
+        endpoint = `${baseUrl}/api/sessions/${encodeURIComponent(args.session_id)}/inject`;
+        body = { prompt: args.prompt };
+      } else {
+        throw new Error('You must provide either broadcast: true, session_ids: [...], or session_id: "..."');
+      }
+
+      const res = await fetch(endpoint, {
+        method: 'POST', headers: { 'Content-Type': 'application/json', 'x-telepty-token': TOKEN }, body: JSON.stringify(body)
       });
       const data = await res.json();
       if (!res.ok) throw new Error(data.error || `HTTP ${res.status}`);
-      return { content: [{ type: 'text', text: `✅ Successfully injected context into session '${args.session_id}'. The remote agent has been awakened.` }] };
+      
+      let msg = `✅ Successfully injected context.`;
+      if (args.broadcast) msg += ` (Broadcasted to ${data.results.successful.length} sessions)`;
+      else if (args.session_ids) msg += ` (Multicasted to ${data.results.successful.length} sessions)`;
+      else msg += ` (Targeted session '${args.session_id}')`;
+
+      return { content: [{ type: 'text', text: msg }] };
     }
     throw new Error(`Unknown tool: ${name}`);
   } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dmsdc-ai/aigentry-telepty",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "main": "daemon.js",
   "bin": {
     "telepty": "cli.js",
@@ -18,6 +18,7 @@
     "cors": "^2.8.6",
     "express": "^5.2.1",
     "node-pty": "^1.2.0-beta.11",
+    "prompts": "^2.4.2",
     "uuid": "^13.0.0",
     "ws": "^8.19.0",
     "zod": "^4.3.6"