@bytespell/shella 0.2.3 → 0.2.5

package/bundled-plugins/agent/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "agent",
+  "private": true,
+  "version": "0.2.5",
+  "type": "module",
+  "main": "server.js",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "lint": "eslint .",
+    "preview": "vite preview",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@base-ui/react": "^1.1.0",
+    "@fontsource-variable/inter": "^5.2.8",
+    "@pierre/diffs": "^1.0.7",
+    "@streamdown/code": "^1.0.1",
+    "@tailwindcss/typography": "^0.5.19",
+    "@tailwindcss/vite": "^4.1.17",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "express": "^5.0.0",
+    "lucide-react": "^0.562.0",
+    "radix-ui": "^1.4.3",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "shadcn": "^3.7.0",
+    "streamdown": "^2.1.0",
+    "tailwind-merge": "^3.4.0",
+    "tailwindcss": "^4.1.17",
+    "tw-animate-css": "^1.4.0",
+    "use-stick-to-bottom": "^1.1.1",
+    "ws": "^8.19.0",
+    "zustand": "^5.0.10"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/jsdom": "^27.0.0",
+    "@types/node": "^24.10.1",
+    "@types/react": "^19.2.5",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^5.1.1",
+    "eslint": "^9.39.1",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.4.24",
+    "globals": "^16.5.0",
+    "happy-dom": "^20.3.4",
+    "jsdom": "^27.4.0",
+    "typescript": "~5.9.3",
+    "typescript-eslint": "^8.46.4",
+    "vite": "^7.2.4",
+    "vitest": "^4.0.17"
+  },
+  "shella": {
+    "displayName": "Agent",
+    "devCommand": "node server.js"
+  }
+}

package/bundled-plugins/agent/public/vite.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>

package/bundled-plugins/agent/server.js

@@ -0,0 +1,631 @@
+import express from 'express';
+import { createServer } from 'http';
+import { WebSocketServer, WebSocket } from 'ws';
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import readline from 'readline';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const app = express();
+const PORT = process.env.PORT;
+const INSTANCE_ID = process.env.INSTANCE_ID;
+const isDev = !fs.existsSync(path.join(__dirname, 'dist', 'index.html'));
+const PI_AUTH_PATH = path.join(os.homedir(), '.pi', 'agent', 'auth.json');
+const PI_SESSIONS_DIR = path.join(os.homedir(), '.pi', 'agent', 'sessions');
+const AGENT_STATE_DIR = path.join(os.homedir(), '.local', 'state', 'shella', 'agent');
+const AGENT_STATE_FILE = path.join(AGENT_STATE_DIR, `instance-${INSTANCE_ID}.json`);
+
+// Convert cwd to session directory name (matches pi's encoding)
+function cwdToSessionDirName(cwd) {
+  return `--${cwd.replace(/^[/\\]/, '').replace(/[/\\:]/g, '-')}--`;
+}
+
+// Convert session directory name back to cwd path
+function sessionDirNameToCwd(dirName) {
+  // Format: --path-to-dir-- -> /path/to/dir
+  const inner = dirName.replace(/^--/, '').replace(/--$/, '');
+  return '/' + inner.replace(/-/g, '/');
+}
+
+// Extract cwd from a session file path
+function cwdFromSessionPath(sessionPath) {
+  // Session path format: ~/.pi/agent/sessions/--path-encoded--/session.jsonl
+  const sessionsDir = PI_SESSIONS_DIR;
+  if (!sessionPath.startsWith(sessionsDir)) {
+    return null;
+  }
+  const relativePath = sessionPath.slice(sessionsDir.length + 1); // +1 for trailing /
+  const dirName = relativePath.split('/')[0]; // Get the --path-encoded-- part
+  if (dirName.startsWith('--') && dirName.endsWith('--')) {
+    return sessionDirNameToCwd(dirName);
+  }
+  return null;
+}
+
+// Load persisted agent state
+function loadAgentState() {
+  console.log('[agent] Loading state for instance:', INSTANCE_ID);
+  console.log('[agent] State file path:', AGENT_STATE_FILE);
+  try {
+    if (fs.existsSync(AGENT_STATE_FILE)) {
+      const data = JSON.parse(fs.readFileSync(AGENT_STATE_FILE, 'utf-8'));
+      console.log('[agent] Loaded persisted state:', JSON.stringify(data));
+      return data;
+    } else {
+      console.log('[agent] No state file found, starting fresh');
+    }
+  } catch (err) {
+    console.log('[agent] Failed to load persisted state:', err.message);
+  }
+  return {};
+}
+
+// Save agent state to disk
+function saveAgentState(state) {
+  try {
+    fs.mkdirSync(AGENT_STATE_DIR, { recursive: true });
+    fs.writeFileSync(AGENT_STATE_FILE, JSON.stringify(state, null, 2));
+    console.log('[agent] Saved state:', state);
+  } catch (err) {
+    console.log('[agent] Failed to save state:', err.message);
+  }
+}
+
+// List sessions for a given cwd
+async function listSessions(cwd, currentSessionFile) {
+  const sessionDirName = cwdToSessionDirName(cwd);
+  const sessionDir = path.join(PI_SESSIONS_DIR, sessionDirName);
+
+  if (!fs.existsSync(sessionDir)) {
+    return [];
+  }
+
+  const files = fs.readdirSync(sessionDir)
+    .filter(f => f.endsWith('.jsonl'))
+    .sort()
+    .reverse(); // Most recent first
+
+  const sessions = [];
+  for (const file of files) {
+    const filePath = path.join(sessionDir, file);
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const lines = content.split('\n').filter(l => l.trim());
+
+      let header = null;
+      let name = null;
+      let lastUserMessage = null;
+      let messageCount = 0;
+      let created = null;
+
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+
+          // Get header
+          if (entry.type === 'session') {
+            header = entry;
+            created = entry.timestamp;
+          }
+
+          // Get name from session_info entry (use latest)
+          if (entry.type === 'session_info' && entry.name) {
+            name = entry.name.trim();
+          }
+
+          // Count messages and track last user message as fallback name
+          if (entry.type === 'message' && entry.message) {
+            messageCount++;
+            if (entry.message.role === 'user') {
+              // Extract text from content
+              const content = entry.message.content;
+              if (typeof content === 'string') {
+                lastUserMessage = content.slice(0, 100);
+              } else if (Array.isArray(content)) {
+                const textBlock = content.find(b => b.type === 'text');
+                if (textBlock?.text) {
+                  lastUserMessage = textBlock.text.slice(0, 100);
+                }
+              }
+            }
+          }
+        } catch { /* skip malformed lines */ }
+      }
+
+      if (header) {
+        sessions.push({
+          id: header.id,
+          name: name || lastUserMessage || null,
+          file: filePath,
+          messageCount,
+          created: created ? new Date(created).getTime() : null,
+          lastModified: fs.statSync(filePath).mtimeMs,
+          isCurrent: filePath === currentSessionFile,
+        });
+      }
+    } catch (err) {
+      console.log('[agent] Error reading session file:', file, err.message);
+    }
+  }
+
+  return sessions;
+}
+
+// Load persisted state
+const persistedState = loadAgentState();
+
+// Current working directory for pi process (restore from persisted state)
+let currentCwd = persistedState.cwd || os.homedir();
+// Current session file path (tracked from get_state responses)
+let currentSessionFile = persistedState.sessionFile || null;
+
+// Allow embedding in iframes
+app.use((req, res, next) => {
+  res.removeHeader('X-Frame-Options');
+  res.setHeader('Content-Security-Policy', 'frame-ancestors *');
+  next();
+});
+
+app.use(express.json());
+
+// Health check
+app.get('/api/health', (req, res) => {
+  res.json({ status: 'ok' });
+});
+
+// Check auth status
+app.get('/api/auth/status', (req, res) => {
+  try {
+    if (fs.existsSync(PI_AUTH_PATH)) {
+      const authData = JSON.parse(fs.readFileSync(PI_AUTH_PATH, 'utf-8'));
+      const providers = Object.keys(authData);
+      res.json({ authenticated: providers.length > 0, providers });
+    } else {
+      res.json({ authenticated: false, providers: [] });
+    }
+  } catch {
+    res.json({ authenticated: false, providers: [] });
+  }
+});
+
+// List directories for picker
+app.get('/api/directories', (req, res) => {
+  const dirPath = req.query.path || os.homedir();
+  try {
+    const stats = fs.statSync(dirPath);
+    if (!stats.isDirectory()) {
+      return res.status(400).json({ error: 'Not a directory' });
+    }
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    const directories = entries
+      .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+      .map(e => e.name)
+      .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+    res.json({
+      path: dirPath,
+      parent: path.dirname(dirPath),
+      directories,
+      isRoot: dirPath === '/' || dirPath === path.dirname(dirPath),
+    });
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+async function startServer() {
+  if (isDev) {
+    const { createServer: createViteServer } = await import('vite');
+    const vite = await createViteServer({
+      server: { middlewareMode: true, hmr: { port: Number(PORT) + 1000 } },
+      appType: 'spa',
+    });
+    app.use(vite.middlewares);
+  } else {
+    app.use(express.static(path.join(__dirname, 'dist')));
+    app.get('/{*splat}', (req, res) => {
+      res.sendFile(path.join(__dirname, 'dist', 'index.html'));
+    });
+  }
+
+  const server = createServer(app);
+
+  // Single pi process shared across all clients
+  let piProcess = null;
+  let rl = null;
+  const clients = new Set();
+
+  function broadcast(message) {
+    for (const client of clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(message);
+      }
+    }
+  }
+
+  function sendCommand(cmd) {
+    if (piProcess?.stdin?.writable) {
+      console.log('[agent] Sending command:', JSON.stringify(cmd));
+      piProcess.stdin.write(JSON.stringify(cmd) + '\n');
+    } else {
+      console.log('[agent] WARNING: Cannot send command, stdin not writable. piProcess:', !!piProcess, 'stdin:', !!piProcess?.stdin, 'writable:', piProcess?.stdin?.writable);
+      console.log('[agent] Dropped command:', JSON.stringify(cmd));
+    }
+  }
+
+  let piReady = false;
+  let onPiReady = null;
+
+  // Current session file to load (null = new session)
+  // Initialize from persisted state if available
+  let currentSessionPath = currentSessionFile;
+
+  function spawnPi() {
+    if (piProcess) return;
+
+    const args = ['--mode', 'rpc'];
+    if (currentSessionPath) {
+      args.push('--session', currentSessionPath);
+    }
+    console.log('[agent] Spawning pi', args.join(' '));
+    piReady = false;
+
+    piProcess = spawn('pi', args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env },
+      cwd: currentCwd,
+    });
+
+    piProcess.on('spawn', () => {
+      console.log('[agent] pi process spawned and ready');
+      piReady = true;
+      if (onPiReady) {
+        onPiReady();
+        onPiReady = null;
+      }
+    });
+
+    rl = readline.createInterface({
+      input: piProcess.stdout,
+      crlfDelay: Infinity
+    });
+
+    rl.on('line', (line) => {
+      try {
+        const event = JSON.parse(line);
+        // Log different event types
+        switch (event.type) {
+          case 'response':
+            console.log('[agent] Response:', event.command, event.success ? 'success' : 'failed',
+              event.data ? `data keys: ${Object.keys(event.data)}` : 'no data');
+            // Track current session file for session listing and persist it
+            if (event.command === 'get_state' && event.success && event.data?.sessionFile) {
+              if (currentSessionFile !== event.data.sessionFile) {
+                currentSessionFile = event.data.sessionFile;
+                saveAgentState({ cwd: currentCwd, sessionFile: currentSessionFile });
+              }
+            }
+            break;
+          case 'agent_start':
+            console.log('[agent] Agent started');
+            break;
+          case 'agent_end':
+            console.log('[agent] Agent ended:', event.stopReason || 'unknown reason');
+            break;
+          case 'tool_execution_start':
+            console.log('[agent] Tool start:', event.toolName, 'id:', event.toolCallId);
+            if (event.args) {
+              const argsStr = JSON.stringify(event.args);
+              console.log('[agent]   args:', argsStr.length > 200 ? argsStr.slice(0, 200) + '...' : argsStr);
+            }
+            break;
+          case 'tool_execution_update':
+            // Don't log updates to avoid spam, but could enable for debugging
+            break;
+          case 'tool_execution_end':
+            console.log('[agent] Tool end:', event.toolCallId, event.isError ? 'ERROR' : 'success');
+            break;
+          case 'message_start':
+            console.log('[agent] Message start:', event.message?.role || 'unknown role');
+            break;
+          case 'message_update':
+            // Don't log message updates to avoid spam
+            break;
+          case 'message_end':
+            console.log('[agent] Message end');
+            break;
+          default:
+            console.log('[agent] Event:', event.type);
+        }
+        broadcast(JSON.stringify({ type: 'rpc_event', event }));
+      } catch {
+        console.log('[agent] Non-JSON output:', line);
+      }
+    });
+
+    piProcess.stderr?.on('data', (data) => {
+      console.error('[agent] stderr:', data.toString());
+    });
+
+    const thisProcess = piProcess;
+    piProcess.on('exit', (code, signal) => {
+      console.log(`[agent] pi exited: code=${code}, signal=${signal}`);
+      // Only clear/broadcast if this is still the current process (not if we've already respawned)
+      if (piProcess === thisProcess) {
+        piProcess = null;
+        rl?.close();
+        rl = null;
+        broadcast(JSON.stringify({ type: 'process_exit', code, signal }));
+      }
+    });
+
+    piProcess.on('error', (err) => {
+      console.error('[agent] error:', err);
+      broadcast(JSON.stringify({
+        type: 'error',
+        message: `Failed to start pi: ${err.message}`
+      }));
+    });
+
+    sendCommand({ type: 'get_state' });
+    sendCommand({ type: 'get_messages' });
+  }
+
+  spawnPi();
+
+  const wss = new WebSocketServer({ server, path: '/ws' });
+
+  wss.on('connection', (ws) => {
+    console.log('[agent] Client connected, currentCwd:', currentCwd);
+    clients.add(ws);
+
+    if (piProcess) {
+      console.log('[agent] Sending ready with cwd:', currentCwd);
+      ws.send(JSON.stringify({ type: 'ready', cwd: currentCwd }));
+      sendCommand({ type: 'get_state' });
+      sendCommand({ type: 'get_messages' });
+      sendCommand({ type: 'get_session_stats' });
+    } else {
+      ws.send(JSON.stringify({ type: 'error', message: 'Pi process not running' }));
+    }
+
+    ws.on('message', (message) => {
+      try {
+        const msg = JSON.parse(message.toString());
+
+        switch (msg.type) {
+          case 'start':
+            if (!piProcess) spawnPi();
+            ws.send(JSON.stringify({ type: 'ready' }));
+            break;
+          case 'command':
+            if (msg.command) {
+              // Handle get_sessions locally (pi doesn't have this command)
+              if (msg.command.type === 'get_sessions') {
+                // Get current session file from pi state if we have it
+                // For now, we'll mark current based on sessionFile from get_state response
+                listSessions(currentCwd, currentSessionFile).then(sessions => {
+                  ws.send(JSON.stringify({
+                    type: 'rpc_event',
+                    event: {
+                      type: 'response',
+                      command: 'get_sessions',
+                      success: true,
+                      data: { sessions }
+                    }
+                  }));
+                }).catch(err => {
+                  ws.send(JSON.stringify({
+                    type: 'rpc_event',
+                    event: {
+                      type: 'response',
+                      command: 'get_sessions',
+                      success: false,
+                      error: err.message
+                    }
+                  }));
+                });
+              } else if (msg.command.type === 'switch_session') {
+                // Switch session by respawning pi with --session flag
+                const sessionPath = msg.command.sessionPath;
+                if (sessionPath && fs.existsSync(sessionPath)) {
+                  console.log('[agent] Switching session to:', sessionPath);
+                  currentSessionPath = sessionPath;
+                  currentSessionFile = sessionPath;
+                  
+                  // Extract cwd from session path and update if different
+                  const sessionCwd = cwdFromSessionPath(sessionPath);
+                  const cwdChanged = sessionCwd && sessionCwd !== currentCwd;
+                  if (cwdChanged) {
+                    console.log('[agent] Session cwd differs, updating from', currentCwd, 'to', sessionCwd);
+                    currentCwd = sessionCwd;
+                  }
+                  
+                  // Persist state
+                  saveAgentState({ cwd: currentCwd, sessionFile: currentSessionFile });
+                  
+                  // Kill current process and wait for exit before respawning
+                  const oldProcess = piProcess;
+                  const oldRl = rl;
+                  piProcess = null;
+                  rl = null;
+                  
+                  const doSpawn = () => {
+                    console.log('[agent] Spawning new pi for session switch');
+                    // Respawn with new session, notify clients when ready
+                    // Also fetch messages automatically after switching
+                    onPiReady = () => {
+                      console.log('[agent] Pi ready after session switch, sending response');
+                      
+                      // If cwd changed, notify clients first
+                      if (cwdChanged) {
+                        broadcast(JSON.stringify({ type: 'cwd_changed', cwd: currentCwd }));
+                      }
+                      
+                      // Send success response
+                      broadcast(JSON.stringify({
+                        type: 'rpc_event',
+                        event: {
+                          type: 'response',
+                          command: 'switch_session',
+                          success: true,
+                          data: { sessionPath, cwd: currentCwd }
+                        }
+                      }));
+                      // Also request messages and state so client gets them
+                      console.log('[agent] Requesting messages after session switch');
+                      sendCommand({ type: 'get_messages' });
+                      sendCommand({ type: 'get_state' });
+                      sendCommand({ type: 'get_session_stats' });
+                    };
+                    spawnPi();
+                  };
+                  
+                  if (oldProcess) {
+                    console.log('[agent] Killing old pi process, waiting for exit');
+                    oldRl?.close();
+                    oldProcess.once('exit', () => {
+                      console.log('[agent] Old pi process exited');
+                      doSpawn();
+                    });
+                    oldProcess.kill();
+                  } else {
+                    doSpawn();
+                  }
+                } else {
+                  ws.send(JSON.stringify({
+                    type: 'rpc_event',
+                    event: {
+                      type: 'response',
+                      command: 'switch_session',
+                      success: false,
+                      error: 'Session file not found'
+                    }
+                  }));
+                }
+              } else if (msg.command.type === 'new_session') {
+                // New session by respawning pi without --session flag
+                console.log('[agent] Starting new session');
+                currentSessionPath = null;
+                currentSessionFile = null;
+                
+                // Kill current process and wait for exit before respawning
+                const oldProcess = piProcess;
+                const oldRl = rl;
+                piProcess = null;
+                rl = null;
+                
+                const doSpawn = () => {
+                  console.log('[agent] Spawning new pi for new session');
+                  onPiReady = () => {
+                    broadcast(JSON.stringify({
+                      type: 'rpc_event',
+                      event: {
+                        type: 'response',
+                        command: 'new_session',
+                        success: true,
+                        data: {}
+                      }
+                    }));
+                  };
+                  spawnPi();
+                };
+                
+                if (oldProcess) {
+                  console.log('[agent] Killing old pi process, waiting for exit');
+                  oldRl?.close();
+                  oldProcess.once('exit', () => {
+                    console.log('[agent] Old pi process exited');
+                    doSpawn();
+                  });
+                  oldProcess.kill();
+                } else {
+                  doSpawn();
+                }
+              } else {
+                sendCommand(msg.command);
+              }
+            }
+            break;
+          case 'prompt':
+            sendCommand({ type: 'prompt', message: msg.message, images: msg.images });
+            break;
+          case 'abort':
+            sendCommand({ type: 'abort' });
+            break;
+          case 'steer':
+            sendCommand({ type: 'steer', message: msg.message });
+            break;
+          case 'extension_ui_response':
+            sendCommand(msg);
+            break;
+          case 'change_cwd':
+            if (msg.path) {
+              try {
+                const stats = fs.statSync(msg.path);
+                if (stats.isDirectory()) {
+                  console.log('[agent] Changing cwd to:', msg.path);
+                  currentCwd = msg.path;
+                  currentSessionPath = null; // New cwd means new session
+                  currentSessionFile = null;
+                  // Persist state
+                  saveAgentState({ cwd: currentCwd, sessionFile: null });
+                  // Kill current process - it will respawn with new cwd
+                  if (piProcess) {
+                    piProcess.kill();
+                    piProcess = null;
+                    rl?.close();
+                    rl = null;
+                  }
+                  // Respawn with new cwd, wait for ready before notifying clients
+                  onPiReady = () => {
+                    broadcast(JSON.stringify({ type: 'cwd_changed', cwd: currentCwd }));
+                  };
+                  spawnPi();
+                  // If already ready (shouldn't happen but just in case)
+                  if (piReady && onPiReady) {
+                    onPiReady();
+                    onPiReady = null;
+                  }
+                } else {
+                  ws.send(JSON.stringify({ type: 'error', message: 'Path is not a directory' }));
+                }
+              } catch (err) {
+                ws.send(JSON.stringify({ type: 'error', message: `Invalid path: ${err.message}` }));
+              }
+            }
+            break;
+        }
+      } catch (err) {
+        console.error('[agent] Invalid message:', err);
+      }
+    });
+
+    ws.on('close', () => {
+      console.log('[agent] Client disconnected');
+      clients.delete(ws);
+    });
+
+    ws.on('error', (err) => {
+      console.error('[agent] WebSocket error:', err);
+      clients.delete(ws);
+    });
+  });
+
+  server.listen(PORT, () => {
+    console.log(`[agent] Running on port ${PORT}${isDev ? ' (dev mode)' : ''}`);
+  });
+
+  process.on('SIGTERM', () => {
+    console.log('[agent] Shutting down');
+    piProcess?.kill();
+    rl?.close();
+    for (const ws of clients) ws.close();
+    wss.close();
+    server.close(() => process.exit(0));
+  });
+}
+
+startServer();