@dmsdc-ai/aigentry-telepty 0.0.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dmsdc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# aigentry-telepty
+
+**Personal PTY-based remote prompt injection daemon for AI CLIs.**
+
+`telepty` (Tele-Prompt) is a lightweight, personal background daemon that bridges the gap between the network and interactive AI command-line interfaces.

package/auth.js

@@ -0,0 +1,33 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { v4: uuidv4 } = require('uuid');
+
+const CONFIG_DIR = path.join(os.homedir(), '.telepty');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+function getConfig() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 }); // Restrict permissions
+  }
+
+  if (fs.existsSync(CONFIG_FILE)) {
+    try {
+      const data = fs.readFileSync(CONFIG_FILE, 'utf8');
+      return JSON.parse(data);
+    } catch (e) {
+      console.warn('⚠️ Warning: Failed to read config file, generating a new one.', e.message);
+    }
+  }
+
+  // Generate new config
+  const newConfig = {
+    authToken: uuidv4(),
+    createdAt: new Date().toISOString()
+  };
+
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(newConfig, null, 2), { mode: 0o600 });
+  return newConfig;
+}
+
+module.exports = { getConfig };

package/cli.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const WebSocket = require('ws');
+const { execSync } = require('child_process');
+const readline = require('readline');
+const { getConfig } = require('./auth');
+const args = process.argv.slice(2);
+
+// Support remote host via environment variable or default to localhost
+let REMOTE_HOST = process.env.TELEPTY_HOST || '127.0.0.1';
+const PORT = 3848;
+let DAEMON_URL = `http://${REMOTE_HOST}:${PORT}`;
+let WS_URL = `ws://${REMOTE_HOST}:${PORT}`;
+
+const config = getConfig();
+const TOKEN = config.authToken;
+
+const fetchWithAuth = (url, options = {}) => {
+  const headers = { ...options.headers, 'x-telepty-token': TOKEN };
+  return fetch(url, { ...options, headers });
+};
+
+async function discoverSessions() {
+  const hosts = ['127.0.0.1'];
+  try {
+    const tsStatus = execSync('tailscale status --json', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
+    const tsData = JSON.parse(tsStatus);
+    if (tsData && tsData.Peer) {
+      for (const peer of Object.values(tsData.Peer)) {
+        if (peer.Online && peer.TailscaleIPs && peer.TailscaleIPs.length > 0) {
+          hosts.push(peer.TailscaleIPs[0]);
+        }
+      }
+    }
+  } catch (e) {
+    // Tailscale not available or not running, ignore
+  }
+
+  const allSessions = [];
+  process.stdout.write('\x1b[36m🔍 Discovering active sessions across your Tailnet...\x1b[0m\n');
+  
+  await Promise.all(hosts.map(async (host) => {
+    try {
+      const res = await fetchWithAuth(`http://${host}:${PORT}/api/sessions`, { 
+        signal: AbortSignal.timeout(1500) 
+      });
+      if (res.ok) {
+        const sessions = await res.json();
+        sessions.forEach(s => {
+          allSessions.push({ host, ...s });
+        });
+      }
+    } catch (e) {
+      // Ignore nodes that don't have telepty running
+    }
+  }));
+
+  return allSessions;
+}
+
+async function main() {
+  const cmd = args[0];
+  if (cmd === 'mcp') {
+    require('./mcp.js');
+    return;
+  }
+
+  if (cmd === 'daemon') {
+    console.log('Starting telepty daemon...');
+    require('./daemon.js');
+    return;
+  }
+
+  if (cmd === 'list') {
+    try {
+      const res = await fetchWithAuth(`${DAEMON_URL}/api/sessions`);
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const sessions = await res.json();
+      if (sessions.length === 0) { console.log('No active sessions found.'); return; }
+      console.log('\x1b[1mActive Sessions:\x1b[0m');
+      sessions.forEach(s => {
+        console.log(`  - ID: \x1b[36m${s.id}\x1b[0m`);
+        console.log(`    Command: ${s.command}`);
+        console.log(`    CWD: ${s.cwd}`);
+        console.log(`    Clients: ${s.active_clients}`);
+        console.log(`    Started: ${new Date(s.createdAt).toLocaleString()}`);
+        console.log('');
+      });
+    } catch (e) {
+      console.error('❌ Failed to connect to daemon. Is it running? (run `telepty daemon`)');
+    }
+    return;
+  }
+
+  if (cmd === 'spawn') {
+    const idIndex = args.indexOf('--id');
+    if (idIndex === -1 || !args[idIndex + 1]) { console.error('❌ Usage: telepty spawn --id <session_id> <command> [args...]'); process.exit(1); }
+    const sessionId = args[idIndex + 1];
+    const spawnArgs = args.filter((a, i) => a !== 'spawn' && i !== idIndex && i !== idIndex + 1);
+    if (spawnArgs.length === 0) { console.error('❌ Missing command. Example: telepty spawn --id "test" bash'); process.exit(1); }
+    const command = spawnArgs[0]; const cmdArgs = spawnArgs.slice(1);
+    
+    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: sessionId, command: command, args: cmdArgs, cwd: process.cwd(), cols, rows })
+      });
+      const data = await res.json();
+      if (!res.ok) { console.error(`❌ Error: ${data.error}`); return; }
+      console.log(`✅ Session '\x1b[36m${data.session_id}\x1b[0m' spawned successfully.`);
+    } catch (e) { console.error('❌ Failed to connect to daemon. Is it running?'); }
+    return;
+  }
+
+  if (cmd === 'attach') {
+    let sessionId = args[1];
+    let targetHost = REMOTE_HOST;
+
+    if (!sessionId) {
+      const sessions = await discoverSessions();
+      if (sessions.length === 0) {
+        console.log('❌ No active sessions found on any known networks.');
+        process.exit(0);
+      }
+
+      console.log('\n\x1b[1mAvailable Sessions:\x1b[0m');
+      sessions.forEach((s, i) => {
+        const hostLabel = s.host === '127.0.0.1' ? 'Local' : s.host;
+        console.log(`  [${i + 1}] \x1b[36m${s.id}\x1b[0m (\x1b[33m${hostLabel}\x1b[0m) - ${s.command}`);
+      });
+
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await new Promise(resolve => rl.question('\nSelect a session number to attach: ', resolve));
+      rl.close();
+
+      const idx = parseInt(answer) - 1;
+      if (isNaN(idx) || !sessions[idx]) {
+        console.error('❌ Invalid selection.');
+        process.exit(1);
+      }
+
+      sessionId = sessions[idx].id;
+      targetHost = sessions[idx].host;
+    }
+
+    const wsUrl = `ws://${targetHost}:${PORT}/api/sessions/${encodeURIComponent(sessionId)}?token=${encodeURIComponent(TOKEN)}`;
+    const ws = new WebSocket(wsUrl);
+
+    ws.on('open', () => {
+      console.log(`\x1b[32mConnected to session '${sessionId}' at ${targetHost}. Press Ctrl+C to detach.\x1b[0m\n`);
+      
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+      }
+
+      process.stdin.on('data', (data) => {
+        ws.send(JSON.stringify({ type: 'input', data: data.toString() }));
+      });
+
+      const resizeHandler = () => {
+        ws.send(JSON.stringify({
+          type: 'resize',
+          cols: process.stdout.columns,
+          rows: process.stdout.rows
+        }));
+      };
+
+      process.stdout.on('resize', resizeHandler);
+      resizeHandler(); // Initial resize
+    });
+
+    ws.on('message', (message) => {
+      const { type, data } = JSON.parse(message);
+      if (type === 'output') {
+        process.stdout.write(data);
+      }
+    });
+
+    ws.on('close', (code, reason) => {
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      console.log(`\n\x1b[33mDisconnected from session. (Code: ${code}, Reason: ${reason || 'None'})\x1b[0m`);
+      process.exit(0);
+    });
+
+    ws.on('error', (err) => {
+      console.error('❌ WebSocket Error:', err.message);
+      process.exit(1);
+    });
+
+    return;
+  }
+
+  if (cmd === 'inject') {
+    const sessionId = args[1]; const prompt = args.slice(2).join(' ');
+    if (!sessionId || !prompt) { console.error('❌ Usage: telepty inject <session_id> "<prompt text>"'); process.exit(1); }
+    try {
+      const res = await fetchWithAuth(`${DAEMON_URL}/api/sessions/${encodeURIComponent(sessionId)}/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 injected successfully into '\x1b[36m${sessionId}\x1b[0m'.`);
+    } catch (e) { console.error('❌ Failed to connect to daemon. Is it running?'); }
+    return;
+  }
+
+  console.log(`
+\x1b[1maigentry-telepty\x1b[0m - Remote PTY Control
+
+Usage:
+  telepty daemon                                 Start the background daemon
+  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 mcp                                    Start the MCP stdio server
+`);
+}
+
+main();

package/daemon.js

@@ -0,0 +1,159 @@
+const express = require('express');
+const cors = require('cors');
+const pty = require('node-pty');
+const os = require('os');
+const { WebSocketServer } = require('ws');
+const { getConfig } = require('./auth');
+
+const config = getConfig();
+const EXPECTED_TOKEN = config.authToken;
+
+const app = express();
+app.use(cors());
+app.use(express.json());
+
+// Authentication Middleware
+app.use((req, res, next) => {
+  const isLocalhost = req.ip === '127.0.0.1' || req.ip === '::1' || req.ip === '::ffff:127.0.0.1';
+  const isTailscale = req.ip && req.ip.startsWith('100.');
+  
+  if (isLocalhost || isTailscale) {
+    return next(); // Trust local and Tailscale networks
+  }
+
+  const token = req.headers['x-telepty-token'] || req.query.token;
+  if (token === EXPECTED_TOKEN) {
+    return next();
+  }
+
+  console.warn(`[AUTH] Rejected unauthorized request from ${req.ip}`);
+  res.status(401).json({ error: 'Unauthorized: Invalid or missing token.' });
+});
+
+const PORT = process.env.PORT || 3848;
+
+const HOST = process.env.HOST || '0.0.0.0';
+
+const sessions = {};
+
+app.post('/api/sessions/spawn', (req, res) => {
+  const { session_id, command, args = [], cwd = process.cwd(), cols = 80, rows = 30 } = req.body;
+  if (!session_id) return res.status(400).json({ error: 'session_id is strictly required.' });
+  if (sessions[session_id]) return res.status(409).json({ error: `Session ID '${session_id}' is already active.` });
+  if (!command) return res.status(400).json({ error: 'command is required' });
+
+  const isWin = os.platform() === 'win32';
+  const shell = isWin ? (command === 'powershell' ? 'powershell.exe' : 'cmd.exe') : command;
+  const shellArgs = isWin ? (command === 'powershell' || command === 'cmd' ? args : ['/c', command, ...args]) : args;
+
+  try {
+    console.log(`[SPAWN] Spawning ${shell} with args:`, shellArgs, "in cwd:", cwd);
+    const ptyProcess = pty.spawn(shell, shellArgs, {
+      name: isWin ? 'Windows Terminal' : 'xterm-256color',
+      cols: parseInt(cols),
+      rows: parseInt(rows),
+      cwd,
+      env: { ...process.env, TERM: isWin ? undefined : 'xterm-256color' }
+    });
+
+    sessions[session_id] = {
+      ptyProcess,
+      command,
+      cwd,
+      createdAt: new Date().toISOString(),
+      clients: new Set()
+    };
+
+    ptyProcess.onData((data) => {
+      sessions[session_id].clients.forEach(ws => {
+        if (ws.readyState === 1) ws.send(JSON.stringify({ type: 'output', data }));
+      });
+    });
+
+    ptyProcess.onExit(({ exitCode, signal }) => {
+      console.log(`[EXIT] Session ${session_id} exited with code ${exitCode}`);
+      sessions[session_id].clients.forEach(ws => ws.close(1000, 'Session exited'));
+      delete sessions[session_id];
+    });
+
+    console.log(`[SPAWN] Created session ${session_id} (${command})`);
+    res.status(201).json({ session_id, command, cwd });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+app.get('/api/sessions', (req, res) => {
+  const list = Object.entries(sessions).map(([id, session]) => ({
+    id,
+    command: session.command,
+    cwd: session.cwd,
+    createdAt: session.createdAt,
+    active_clients: session.clients.size
+  }));
+  res.json(list);
+});
+
+app.post('/api/sessions/:id/inject', (req, res) => {
+  const { id } = req.params;
+  const { prompt } = req.body;
+  const session = sessions[id];
+  if (!session) return res.status(404).json({ error: 'Session not found' });
+  if (!prompt) return res.status(400).json({ error: 'prompt is required' });
+  try {
+    session.ptyProcess.write(`${prompt}\r`);
+    console.log(`[INJECT] Wrote to session ${id}`);
+    res.json({ success: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+const server = app.listen(PORT, HOST, () => {
+  console.log(`🚀 aigentry-telepty daemon listening on http://${HOST}:${PORT}`);
+});
+
+const wss = new WebSocketServer({ server });
+
+wss.on('connection', (ws, req) => {
+  const isLocalhost = req.socket.remoteAddress === '127.0.0.1' || req.socket.remoteAddress === '::1' || req.socket.remoteAddress === '::ffff:127.0.0.1';
+  const isTailscale = req.socket.remoteAddress && req.socket.remoteAddress.startsWith('100.');
+  
+  const url = new URL(req.url, `http://${req.headers.host}`);
+  const token = url.searchParams.get('token');
+
+  if (!isLocalhost && !isTailscale && token !== EXPECTED_TOKEN) {
+    console.warn(`[WS-AUTH] Rejected unauthorized WebSocket from ${req.socket.remoteAddress}`);
+    ws.close(1008, 'Unauthorized');
+    return;
+  }
+
+  const sessionId = url.pathname.split('/').pop();
+  const session = sessions[sessionId];
+
+  if (!session) {
+    ws.close(1008, 'Session not found');
+    return;
+  }
+
+  session.clients.add(ws);
+  console.log(`[WS] Client attached to session ${sessionId} (Total: ${session.clients.size})`);
+
+  ws.on('message', (message) => {
+    try {
+      const { type, data, cols, rows } = JSON.parse(message);
+      if (type === 'input') {
+        session.ptyProcess.write(data);
+      } else if (type === 'resize') {
+        session.ptyProcess.resize(cols, rows);
+      }
+    } catch (e) {
+      console.error('[WS] Invalid message format', e);
+    }
+  });
+
+  ws.on('close', () => {
+    session.clients.delete(ws);
+    console.log(`[WS] Client detached from session ${sessionId} (Total: ${session.clients.size})`);
+  });
+});

package/install.sh

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+set -e
+
+echo "🚀 Installing aigentry-telepty..."
+if ! command -v npm &> /dev/null; then
+    echo "❌ Error: npm is not installed. Please install Node.js first."
+    exit 1
+fi
+
+npm install -g git+https://github.com/dmsdc-ai/aigentry-telepty.git
+
+# Set up systemd service if systemd is available
+if command -v systemctl &> /dev/null && [ -d "/etc/systemd/system" ] && [ "$EUID" -eq 0 ]; then
+    echo "⚙️ Setting up systemd service..."
+    TELEPTY_PATH=$(which telepty)
+    cat <<SYSTEMD_EOF > /etc/systemd/system/telepty.service
+[Unit]
+Description=Telepty Daemon
+After=network.target tailscaled.service
+
+[Service]
+ExecStart=$TELEPTY_PATH daemon
+Restart=always
+User=$SUDO_USER
+Environment=PATH=/usr/bin:/usr/local/bin:$PATH
+Environment=NODE_ENV=production
+
+[Install]
+WantedBy=multi-user.target
+SYSTEMD_EOF
+
+    systemctl daemon-reload
+    systemctl enable telepty
+    systemctl start telepty
+    echo "✅ Systemd service installed and started. Daemon will run automatically on boot."
+else
+    echo "⚠️ Skipping systemd setup (requires root and systemd). Starting daemon in background..."
+    nohup telepty daemon > /dev/null 2>&1 &
+    echo "✅ Daemon started in background. (Note: It will not auto-start on reboot)"
+fi
+
+echo "🎉 Installation complete!"
+echo "You can now use 'telepty spawn --id <name> <command>' to create sessions."

package/mcp.js

@@ -0,0 +1,68 @@
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const { CallToolRequestSchema, ListToolsRequestSchema } = require('@modelcontextprotocol/sdk/types.js');
+const { z } = require('zod');
+const { zodToJsonSchema } = require('zod-to-json-schema');
+const { getConfig } = require('./auth');
+
+const config = getConfig();
+const TOKEN = config.authToken;
+
+const server = new Server({ name: 'telepty-mcp-server', version: '0.0.1' }, { capabilities: { tools: {} } });
+
+const tools = [
+  {
+    name: 'telepty_list_remote_sessions',
+    description: 'List all active AI CLI sessions (PTYs) running on a remote telepty daemon. Used to discover available target session IDs.',
+    schema: z.object({ remote_url: z.string().describe('Tailscale IP/Host and port (e.g., 100.100.100.5:3848) of the remote daemon.') })
+  },
+  {
+    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.') })
+  }
+];
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: tools.map(t => {
+    const schema = zodToJsonSchema(t.schema);
+    delete schema.$schema;
+    if (!schema.type) schema.type = 'object';
+    return { name: t.name, description: t.description, inputSchema: schema };
+  })
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  try {
+    const { name, arguments: args } = request.params;
+    if (name === 'telepty_list_remote_sessions') {
+      const baseUrl = args.remote_url.startsWith('http') ? args.remote_url : `http://${args.remote_url}`;
+      const res = await fetch(`${baseUrl}/api/sessions`, { headers: { 'x-telepty-token': TOKEN } });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const sessions = await res.json();
+      if (!sessions || sessions.length === 0) return { content: [{ type: 'text', text: `No active sessions found on ${args.remote_url}` }] };
+      let text = `Active sessions on ${args.remote_url}:\n\n`;
+      sessions.forEach(s => { text += `- ID: ${s.id}\n  Command: ${s.command}\n  Workspace: ${s.cwd}\n\n`; });
+      return { content: [{ type: 'text', text }] };
+    }
+    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 })
+      });
+      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.` }] };
+    }
+    throw new Error(`Unknown tool: ${name}`);
+  } catch (err) {
+    return { content: [{ type: 'text', text: `❌ Error: ${err.message}` }], isError: true };
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('Telepty MCP Server running on stdio');
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@dmsdc-ai/aigentry-telepty",
+  "version": "0.0.5",
+  "main": "daemon.js",
+  "bin": {
+    "telepty": "cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "cors": "^2.8.6",
+    "express": "^5.2.1",
+    "node-pty": "^1.2.0-beta.11",
+    "uuid": "^13.0.0",
+    "ws": "^8.19.0",
+    "zod": "^4.3.6"
+  }
+}

package/test-pty.js

@@ -0,0 +1,14 @@
+const pty = require('node-pty');
+try {
+  const p = pty.spawn('/bin/bash', [], {
+    name: 'xterm-color',
+    cols: 80,
+    rows: 30,
+    cwd: process.env.HOME,
+    env: process.env
+  });
+  console.log('Success, PID:', p.pid);
+  p.kill();
+} catch (e) {
+  console.error('Error:', e);
+}