@dmsdc-ai/aigentry-telepty 0.1.4 → 0.1.6

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/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@dmsdc-ai/aigentry-telepty",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "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:watch": "node --test --watch test/auth.test.js test/daemon.test.js test/cli.test.js",
+    "test:ci": "node --test --test-reporter=spec test/auth.test.js test/daemon.test.js test/cli.test.js"
   },
   "keywords": [],
   "author": "",

package/test/auth.test.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const { test, before, after } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// Use a temp directory to isolate tests from the real ~/.telepty config.
+// We patch os.homedir() before requiring auth.js so the module-level
+// constants (CONFIG_DIR, CONFIG_FILE) resolve to the temp dir.
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'telepty-test-'));
+const originalHomedir = os.homedir.bind(os);
+
+before(() => {
+  os.homedir = () => tmpDir;
+  // Ensure auth.js is loaded fresh with the patched homedir
+  delete require.cache[require.resolve('../auth.js')];
+});
+
+after(() => {
+  os.homedir = originalHomedir;
+  delete require.cache[require.resolve('../auth.js')];
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+test('getConfig() returns an object with authToken property', () => {
+  const { getConfig } = require('../auth.js');
+  const config = getConfig();
+  assert.ok(config !== null && typeof config === 'object', 'config should be an object');
+  assert.ok('authToken' in config, 'config should have authToken property');
+  assert.equal(typeof config.authToken, 'string', 'authToken should be a string');
+});
+
+test('authToken is a valid UUID v4 format', () => {
+  const { getConfig } = require('../auth.js');
+  const config = getConfig();
+  const uuidV4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  assert.match(config.authToken, uuidV4Regex, 'authToken should be a valid UUID v4');
+});
+
+test('config object has createdAt field', () => {
+  const { getConfig } = require('../auth.js');
+  const config = getConfig();
+  assert.ok('createdAt' in config, 'config should have createdAt property');
+  const date = new Date(config.createdAt);
+  assert.ok(!isNaN(date.getTime()), 'createdAt should be a valid ISO date string');
+});
+
+test('calling getConfig() twice returns the same token (persistence)', () => {
+  const { getConfig } = require('../auth.js');
+  const config1 = getConfig();
+  const config2 = getConfig();
+  assert.equal(config1.authToken, config2.authToken, 'authToken should be identical across calls');
+  assert.equal(config1.createdAt, config2.createdAt, 'createdAt should be identical across calls');
+});

package/test/cli.test.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const { afterEach, beforeEach, test } = require('node:test');
+const assert = require('node:assert/strict');
+const { createSessionId, startTestDaemon, stripAnsi, waitFor } = require('../test-support/daemon-harness');
+
+let harness;
+
+function collectJsonMessages(ws) {
+  const messages = [];
+  ws.on('message', (chunk) => {
+    try {
+      messages.push(JSON.parse(chunk.toString()));
+    } catch {
+      // Ignore malformed payloads in tests.
+    }
+  });
+  return messages;
+}
+
+beforeEach(async () => {
+  harness = await startTestDaemon();
+});
+
+afterEach(async () => {
+  await harness.stop();
+});
+
+test('telepty list prints active sessions from the configured host and port', async () => {
+  const sessionId = createSessionId('cli-list');
+  await harness.spawnSession(sessionId);
+
+  const result = await harness.runCli(['list']);
+  assert.equal(result.code, 0, result.stderr);
+
+  const output = stripAnsi(`${result.stdout}\n${result.stderr}`);
+  assert.match(output, new RegExp(sessionId));
+  assert.match(output, /Active Sessions/i);
+});
+
+test('telepty inject forwards input to the target PTY session', async () => {
+  const sessionId = createSessionId('cli-inject');
+  await harness.spawnSession(sessionId);
+
+  const ws = await harness.connectSession(sessionId);
+  const outputs = collectJsonMessages(ws);
+  const token = createSessionId('cli-token');
+
+  const result = await harness.runCli(['inject', sessionId, `echo ${token}`]);
+  assert.equal(result.code, 0, result.stderr);
+
+  await waitFor(() => outputs.some((message) => (
+    message.type === 'output' && String(message.data).includes(token)
+  )), { timeoutMs: 7000, description: 'CLI inject output' });
+
+  ws.close();
+});