@dmsdc-ai/aigentry-telepty 0.1.5 → 0.1.7

package/daemon.js

@@ -35,9 +35,34 @@ const PORT = process.env.PORT || 3848;
 const HOST = process.env.HOST || '0.0.0.0';
 
 const sessions = {};
+const STRIPPED_SESSION_ENV_KEYS = [
+  'CLAUDECODE',
+  'CODEX_CI',
+  'CODEX_THREAD_ID'
+];
+
+function buildSessionEnv(sessionId) {
+  const env = {
+    ...process.env,
+    TERM: os.platform() === 'win32' ? undefined : 'xterm-256color',
+    TELEPTY_SESSION_ID: sessionId
+  };
+
+  for (const key of STRIPPED_SESSION_ENV_KEYS) {
+    delete env[key];
+  }
+
+  for (const key of Object.keys(env)) {
+    if (key.startsWith('CLAUDECODE_')) {
+      delete env[key];
+    }
+  }
+
+  return env;
+}
 
 app.post('/api/sessions/spawn', (req, res) => {
-  const { session_id, command, args = [], cwd = process.cwd(), cols = 80, rows = 30 } = req.body;
+  const { session_id, command, args = [], cwd = process.cwd(), cols = 80, rows = 30, type = 'AGENT' } = 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' });
@@ -49,15 +74,18 @@ app.post('/api/sessions/spawn', (req, res) => {
   try {
     console.log(`[SPAWN] Spawning ${shell} with args:`, shellArgs, "in cwd:", cwd);
 
-    // Create a custom prompt for Linux/Mac so the user sees the session ID.
-    // For bash/zsh, we can inject a custom PS1 variable.
-    let customEnv = { ...process.env, TERM: isWin ? undefined : 'xterm-256color', TELEPTY_SESSION_ID: session_id };
+    const customEnv = buildSessionEnv(session_id);
     
     if (!isWin) {
+      const label = type.toUpperCase();
+      const colorCode = label === 'USER' ? '32' : '35'; // USER: Green (32), AGENT: Magenta (35)
+      const zshColor = label === 'USER' ? 'green' : 'magenta';
+
       if (command.includes('bash')) {
-        customEnv.PS1 = `\\[\\e[36m\\][telepty: ${session_id}]\\[\\e[0m\\] \\w \\$ `;
+        customEnv.PS1 = `\\[\\e[${colorCode}m\\][${label}: ${session_id}]\\[\\e[0m\\] \\w \\$ `;
       } else if (command.includes('zsh')) {
-        customEnv.PROMPT = `%F{cyan}[telepty: ${session_id}]%f %~ %# `;
+        customEnv.DISABLE_AUTO_TITLE = 'true';
+        customEnv.PROMPT = `%F{${zshColor}}[${label}: ${session_id}]%f %~ %# `;
       }
     }
 
@@ -69,24 +97,51 @@ app.post('/api/sessions/spawn', (req, res) => {
       env: customEnv
     });
 
-    sessions[session_id] = {
+    const sessionRecord = {
+      id: session_id,
+      type: 'spawned',
       ptyProcess,
       command,
       cwd,
       createdAt: new Date().toISOString(),
-      clients: new Set()
+      clients: new Set(),
+      isClosing: false
     };
+    sessions[session_id] = sessionRecord;
+
+    // Broadcast session creation to bus
+    const spawnMsg = JSON.stringify({
+      type: 'session_spawn',
+      sender: 'daemon',
+      session_id,
+      command,
+      cwd,
+      timestamp: new Date().toISOString()
+    });
+    busClients.forEach(client => {
+      if (client.readyState === 1) client.send(spawnMsg);
+    });
 
     ptyProcess.onData((data) => {
-      sessions[session_id].clients.forEach(ws => {
+      const currentSession = sessions[sessionRecord.id];
+      if (!currentSession || currentSession !== sessionRecord) {
+        return;
+      }
+
+      // Send to direct WS clients
+      currentSession.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];
+      const currentId = sessionRecord.id;
+      console.log(`[EXIT] Session ${currentId} exited with code ${exitCode}`);
+      sessionRecord.isClosing = true;
+      sessionRecord.clients.forEach(ws => ws.close(1000, 'Session exited'));
+      if (sessions[currentId] === sessionRecord) {
+        delete sessions[currentId];
+      }
     });
 
     console.log(`[SPAWN] Created session ${session_id} (${command})`);
@@ -96,9 +151,44 @@ app.post('/api/sessions/spawn', (req, res) => {
   }
 });
 
+app.post('/api/sessions/register', (req, res) => {
+  const { session_id, command, cwd = process.cwd() } = req.body;
+  if (!session_id) return res.status(400).json({ error: 'session_id is required' });
+  if (sessions[session_id]) return res.status(409).json({ error: `Session ID '${session_id}' is already active.` });
+
+  const sessionRecord = {
+    id: session_id,
+    type: 'wrapped',
+    ptyProcess: null,
+    ownerWs: null,
+    command: command || 'wrapped',
+    cwd,
+    createdAt: new Date().toISOString(),
+    clients: new Set(),
+    isClosing: false
+  };
+  sessions[session_id] = sessionRecord;
+
+  const busMsg = JSON.stringify({
+    type: 'session_register',
+    sender: 'daemon',
+    session_id,
+    command: sessionRecord.command,
+    cwd,
+    timestamp: new Date().toISOString()
+  });
+  busClients.forEach(client => {
+    if (client.readyState === 1) client.send(busMsg);
+  });
+
+  console.log(`[REGISTER] Registered wrapped session ${session_id}`);
+  res.status(201).json({ session_id, type: 'wrapped', command: sessionRecord.command, cwd });
+});
+
 app.get('/api/sessions', (req, res) => {
   const list = Object.entries(sessions).map(([id, session]) => ({
     id,
+    type: session.type || 'spawned',
     command: session.command,
     cwd: session.cwd,
     createdAt: session.createdAt,
@@ -118,8 +208,30 @@ app.post('/api/sessions/multicast/inject', (req, res) => {
     const session = sessions[id];
     if (session) {
       try {
-        session.ptyProcess.write(`${prompt}\r`);
-        results.successful.push(id);
+        const injectData = `${prompt}\r`;
+        if (session.type === 'wrapped') {
+          if (session.ownerWs && session.ownerWs.readyState === 1) {
+            session.ownerWs.send(JSON.stringify({ type: 'inject', data: injectData }));
+            results.successful.push(id);
+          } else {
+            results.failed.push({ id, error: 'Wrap process not connected' });
+          }
+        } else {
+          session.ptyProcess.write(injectData);
+          results.successful.push(id);
+        }
+
+        // Broadcast injection to bus
+        const busMsg = JSON.stringify({
+          type: 'injection',
+          sender: 'cli',
+          target_agent: id,
+          content: prompt,
+          timestamp: new Date().toISOString()
+        });
+        busClients.forEach(client => {
+          if (client.readyState === 1) client.send(busMsg);
+        });
       } catch (err) {
         results.failed.push({ id, error: err.message });
       }
@@ -138,14 +250,40 @@ app.post('/api/sessions/broadcast/inject', (req, res) => {
   const results = { successful: [], failed: [] };
 
   Object.keys(sessions).forEach(id => {
+    const session = sessions[id];
     try {
-      sessions[id].ptyProcess.write(`${prompt}\r`);
-      results.successful.push(id);
+      const injectData = `${prompt}\r`;
+      if (session.type === 'wrapped') {
+        if (session.ownerWs && session.ownerWs.readyState === 1) {
+          session.ownerWs.send(JSON.stringify({ type: 'inject', data: injectData }));
+          results.successful.push(id);
+        } else {
+          results.failed.push({ id, error: 'Wrap process not connected' });
+        }
+      } else {
+        session.ptyProcess.write(injectData);
+        results.successful.push(id);
+      }
     } catch (err) {
       results.failed.push({ id, error: err.message });
     }
   });
 
+  // Send a single bus event for the entire broadcast (not per-session)
+  if (results.successful.length > 0) {
+    const busMsg = JSON.stringify({
+      type: 'injection',
+      sender: 'cli',
+      target_agent: 'all',
+      content: prompt,
+      session_ids: results.successful,
+      timestamp: new Date().toISOString()
+    });
+    busClients.forEach(client => {
+      if (client.readyState === 1) client.send(busMsg);
+    });
+  }
+
   res.json({ success: true, results });
 });
 
@@ -156,23 +294,80 @@ app.post('/api/sessions/:id/inject', (req, res) => {
   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(no_enter ? prompt : `${prompt}\r`);
+    const injectData = no_enter ? prompt : `${prompt}\r`;
+    if (session.type === 'wrapped') {
+      if (session.ownerWs && session.ownerWs.readyState === 1) {
+        session.ownerWs.send(JSON.stringify({ type: 'inject', data: injectData }));
+      } else {
+        return res.status(503).json({ error: 'Wrap process is not connected' });
+      }
+    } else {
+      session.ptyProcess.write(injectData);
+    }
     console.log(`[INJECT] Wrote to session ${id}`);
+
+    const busMsg = JSON.stringify({
+      type: 'injection',
+      sender: 'cli',
+      target_agent: id,
+      content: prompt,
+      timestamp: new Date().toISOString()
+    });
+    busClients.forEach(client => {
+      if (client.readyState === 1) client.send(busMsg);
+    });
+
     res.json({ success: true });
   } catch (err) {
     res.status(500).json({ error: err.message });
   }
 });
 
+app.patch('/api/sessions/:id', (req, res) => {
+  const { id } = req.params;
+  const { new_id } = req.body;
+  const session = sessions[id];
+  if (!session) return res.status(404).json({ error: 'Session not found' });
+  if (!new_id) return res.status(400).json({ error: 'new_id is required' });
+  if (sessions[new_id]) return res.status(409).json({ error: `Session ID '${new_id}' is already in use.` });
+
+  // Move session to new key
+  sessions[new_id] = session;
+  delete sessions[id];
+  session.id = new_id;
+
+  // Broadcast rename to bus
+  const busMsg = JSON.stringify({
+    type: 'session_rename',
+    sender: 'daemon',
+    old_id: id,
+    new_id,
+    timestamp: new Date().toISOString()
+  });
+  busClients.forEach(client => {
+    if (client.readyState === 1) client.send(busMsg);
+  });
+
+  console.log(`[RENAME] Session '${id}' renamed to '${new_id}'`);
+  res.json({ success: true, old_id: id, new_id });
+});
+
 app.delete('/api/sessions/:id', (req, res) => {
   const { id } = req.params;
   const session = sessions[id];
   if (!session) return res.status(404).json({ error: 'Session not found' });
+  if (session.isClosing) return res.json({ success: true, status: 'closing' });
   try {
-    session.ptyProcess.kill();
-    delete sessions[id];
-    console.log(`[KILL] Session ${id} forcefully closed`);
-    res.json({ success: true });
+    session.isClosing = true;
+    if (session.type === 'wrapped') {
+      session.clients.forEach(ws => ws.close(1000, 'Session destroyed'));
+      delete sessions[id];
+      console.log(`[KILL] Wrapped session ${id} removed`);
+    } else {
+      session.ptyProcess.kill();
+      console.log(`[KILL] Session ${id} forcefully closed`);
+    }
+    res.json({ success: true, status: 'closing' });
   } catch (err) {
     res.status(500).json({ error: err.message });
   }
@@ -215,15 +410,44 @@ wss.on('connection', (ws, req) => {
   }
 
   session.clients.add(ws);
-  console.log(`[WS] Client attached to session \${sessionId} (Total: \${session.clients.size})`);
+
+  // For wrapped sessions, first connector becomes the owner
+  if (session.type === 'wrapped' && !session.ownerWs) {
+    session.ownerWs = ws;
+    console.log(`[WS] Wrap owner connected for session ${sessionId} (Total: ${session.clients.size})`);
+  } else {
+    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);
+
+      if (session.type === 'wrapped') {
+        if (ws === session.ownerWs) {
+          // Owner sending output -> broadcast to other clients
+          if (type === 'output') {
+            session.clients.forEach(client => {
+              if (client !== ws && client.readyState === 1) {
+                client.send(JSON.stringify({ type: 'output', data }));
+              }
+            });
+          }
+        } else {
+          // Non-owner client input -> forward to owner as inject
+          if (type === 'input' && session.ownerWs && session.ownerWs.readyState === 1) {
+            session.ownerWs.send(JSON.stringify({ type: 'inject', data }));
+          } else if (type === 'resize' && session.ownerWs && session.ownerWs.readyState === 1) {
+            session.ownerWs.send(JSON.stringify({ type: 'resize', cols, rows }));
+          }
+        }
+      } else {
+        // Existing spawned session logic
+        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);
@@ -232,7 +456,17 @@ wss.on('connection', (ws, req) => {
 
   ws.on('close', () => {
     session.clients.delete(ws);
-    console.log(`[WS] Client detached from session \${sessionId} (Total: \${session.clients.size})`);
+    if (session.type === 'wrapped' && ws === session.ownerWs) {
+      session.ownerWs = null;
+      console.log(`[WS] Wrap owner disconnected from session ${sessionId} (Total: ${session.clients.size})`);
+      // Clean up wrapped session when owner disconnects and no other clients
+      if (session.clients.size === 0 && !session.isClosing) {
+        delete sessions[sessionId];
+        console.log(`[CLEANUP] Wrapped session ${sessionId} removed (owner disconnected)`);
+      }
+    } else {
+      console.log(`[WS] Client detached from session ${sessionId} (Total: ${session.clients.size})`);
+    }
   });
 });
 

package/install.js

@@ -4,6 +4,7 @@ const { execSync, spawn } = require('child_process');
 const os = require('os');
 const fs = require('fs');
 const path = require('path');
+const { runInteractiveSkillInstaller } = require('./skill-installer');
 
 console.log("🚀 Installing @dmsdc-ai/aigentry-telepty...");
 
@@ -16,38 +17,69 @@ function run(cmd) {
   }
 }
 
-// 1. Install globally via npm
-console.log("📦 Installing package globally...");
-run("npm install -g @dmsdc-ai/aigentry-telepty");
+function resolveInstalledPackageRoot() {
+  try {
+    const globalRoot = execSync('npm root -g', { encoding: 'utf8' }).trim();
+    return path.join(globalRoot, '@dmsdc-ai', 'aigentry-telepty');
+  } catch (e) {
+    return __dirname;
+  }
+}
+
+async function installSkills() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    console.log('⏭️  Skipping interactive skill installation (no TTY).');
+    console.log('   Run `telepty` later and choose "Install telepty skills".');
+    return;
+  }
+
+  console.log('\n📋 Telepty skill installation');
 
-// 2. Find executable
-let teleptyPath = '';
-try {
-  teleptyPath = execSync(os.platform() === 'win32' ? 'where telepty' : 'which telepty', { encoding: 'utf8' }).split('\n')[0].trim();
-} catch (e) {
-  teleptyPath = 'telepty'; // fallback
+  try {
+    await runInteractiveSkillInstaller({
+      packageRoot: resolveInstalledPackageRoot(),
+      cwd: process.cwd()
+    });
+  } catch (e) {
+    console.warn('⚠️ Could not install telepty skills:', e.message);
+  }
 }
 
-// 3. Setup OS-specific autostart or background daemon
-const platform = os.platform();
-
-if (platform === 'win32') {
-  console.log("⚙️ Setting up Windows background process...");
-  // Launch daemon in background detaching from current console
-  const subprocess = spawn(teleptyPath, ['daemon'], {
-    detached: true,
-    stdio: 'ignore',
-    windowsHide: true
-  });
-  subprocess.unref();
-  console.log("✅ Windows daemon started in background.");
-
-} else if (platform === 'darwin') {
-  console.log("⚙️ Setting up macOS launchd service...");
-  const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', 'com.aigentry.telepty.plist');
-  fs.mkdirSync(path.dirname(plistPath), { recursive: true });
-  
-  const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+(async () => {
+  // 1. Install globally via npm
+  console.log("📦 Installing package globally...");
+  run("npm install -g @dmsdc-ai/aigentry-telepty");
+
+  // 2. Install telepty skills for supported clients
+  await installSkills();
+
+  // 3. Find executable
+  let teleptyPath = '';
+  try {
+    teleptyPath = execSync(os.platform() === 'win32' ? 'where telepty' : 'which telepty', { encoding: 'utf8' }).split('\n')[0].trim();
+  } catch (e) {
+    teleptyPath = 'telepty'; // fallback
+  }
+
+  // 4. Setup OS-specific autostart or background daemon
+  const platform = os.platform();
+
+  if (platform === 'win32') {
+    console.log("⚙️ Setting up Windows background process...");
+    const subprocess = spawn(teleptyPath, ['daemon'], {
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true
+    });
+    subprocess.unref();
+    console.log("✅ Windows daemon started in background.");
+
+  } else if (platform === 'darwin') {
+    console.log("⚙️ Setting up macOS launchd service...");
+    const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', 'com.aigentry.telepty.plist');
+    fs.mkdirSync(path.dirname(plistPath), { recursive: true });
+
+    const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
@@ -64,20 +96,19 @@ if (platform === 'win32') {
     <true/>
 </dict>
 </plist>`;
-  
-  fs.writeFileSync(plistPath, plistContent);
-  try { execSync(`launchctl unload "${plistPath}" 2>/dev/null`); } catch(e){}
-  run(`launchctl load "${plistPath}"`);
-  console.log("✅ macOS LaunchAgent installed and started.");
-
-} else {
-  // Linux
-  try {
-    // Check if systemd is available and running as root/sudo
-    execSync('systemctl --version', { stdio: 'ignore' });
-    if (process.getuid && process.getuid() === 0) {
-      console.log("⚙️ Setting up systemd service for Linux...");
-      const serviceContent = `[Unit]
+
+    fs.writeFileSync(plistPath, plistContent);
+    try { execSync(`launchctl unload "${plistPath}" 2>/dev/null`); } catch(e){}
+    run(`launchctl load "${plistPath}"`);
+    console.log("✅ macOS LaunchAgent installed and started.");
+
+  } else {
+    // Linux
+    try {
+      execSync('systemctl --version', { stdio: 'ignore' });
+      if (process.getuid && process.getuid() === 0) {
+        console.log("⚙️ Setting up systemd service for Linux...");
+        const serviceContent = `[Unit]
 Description=Telepty Daemon
 After=network.target
 
@@ -90,25 +121,26 @@ Environment=NODE_ENV=production
 
 [Install]
 WantedBy=multi-user.target`;
-      
-      fs.writeFileSync('/etc/systemd/system/telepty.service', serviceContent);
-      run('systemctl daemon-reload');
-      run('systemctl enable telepty');
-      run('systemctl start telepty');
-      console.log("✅ Systemd service installed and started.");
-      process.exit(0);
-    }
-  } catch(e) {}
-
-  // Fallback for Linux without systemd or non-root
-  console.log("⚠️ Skipping systemd (no root or no systemd). Starting in background...");
-  const subprocess = spawn(teleptyPath, ['daemon'], {
-    detached: true,
-    stdio: 'ignore'
-  });
-  subprocess.unref();
-  console.log("✅ Linux daemon started in background using nohup equivalent.");
-}
 
-console.log("\n🎉 Installation complete! Telepty daemon is running.");
-console.log("👉 Try running: telepty attach\n");
+        fs.writeFileSync('/etc/systemd/system/telepty.service', serviceContent);
+        run('systemctl daemon-reload');
+        run('systemctl enable telepty');
+        run('systemctl start telepty');
+        console.log("✅ Systemd service installed and started.");
+        process.exit(0);
+      }
+    } catch(e) {}
+
+    // Fallback for Linux without systemd or non-root
+    console.log("⚠️ Skipping systemd (no root or no systemd). Starting in background...");
+    const subprocess = spawn(teleptyPath, ['daemon'], {
+      detached: true,
+      stdio: 'ignore'
+    });
+    subprocess.unref();
+    console.log("✅ Linux daemon started in background using nohup equivalent.");
+  }
+
+  console.log("\n🎉 Installation complete! Telepty daemon is running.");
+  console.log("👉 Try running: telepty attach\n");
+})();

package/install.ps1

@@ -31,3 +31,4 @@ Write-Host "Success: Windows daemon started in background." -ForegroundColor Gre
 
 Write-Host "`nInstallation complete! Telepty daemon is running." -ForegroundColor Cyan
 Write-Host "Next step: Try running: telepty attach" -ForegroundColor Yellow
+Write-Host "Optional: Run telepty and choose 'Install telepty skills' to add skills for Claude Code, Codex, or Gemini" -ForegroundColor Yellow

package/install.sh

@@ -116,3 +116,4 @@ fi
 echo ""
 echo "🎉 Installation complete! Telepty daemon is running in the background."
 echo "👉 Try running: telepty attach"
+echo "👉 Optional: run telepty and choose 'Install telepty skills' to add skills for Claude Code, Codex, or Gemini"

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@dmsdc-ai/aigentry-telepty",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "main": "daemon.js",
   "bin": {
     "telepty": "cli.js",
     "telepty-install": "install.js"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node --test test/auth.test.js test/daemon.test.js test/cli.test.js test/skill-installer.test.js",
+    "test:watch": "node --test --watch test/auth.test.js test/daemon.test.js test/cli.test.js test/skill-installer.test.js",
+    "test:ci": "node --test --test-reporter=spec test/auth.test.js test/daemon.test.js test/cli.test.js test/skill-installer.test.js"
   },
   "keywords": [],
   "author": "",