termites 1.0.29 → 1.0.31

package/.claude/settings.local.json

@@ -7,7 +7,9 @@
       "Bash(npm view ptyshare)",
       "Bash(npm view turtleshell)",
       "Bash(npm view snailshell)",
-      "Bash(npm view crabshell)"
+      "Bash(npm view crabshell)",
+      "Bash(node:*)",
+      "Bash(curl:*)"
     ]
   }
 }

package/bin/termites.js

@@ -12,54 +12,30 @@ if (command === '-v' || command === '--version' || command === 'version') {
 
 function showHelp() {
     console.log(`
-Termites - Web terminal with server-client architecture
+Termites - Local multi-terminal manager with web interface
 
 Usage:
-  termites server [options]    Start the server
-  termites client [url]        Connect to a server
-
-Server Options:
-  --no-client                  Don't start local client (default: starts client)
+  termites [options]           Start the terminal server
+  termites server [options]    Start the terminal server
 
 Environment:
   PORT=<port>                  Set server port (default: 6789)
 
 Examples:
-  termites server              Start server with local client
-  termites server --no-client  Start server only
-  PORT=8080 termites server    Start on port 8080
-  termites client              Connect to ws://localhost:6789
-  termites client myserver     Connect to ws://myserver:6789
+  termites                     Start server on default port
+  PORT=8080 termites           Start on port 8080
 `);
 }
 
-if (!command || command === '-h' || command === '--help' || command === 'help') {
+if (command === '-h' || command === '--help' || command === 'help') {
     showHelp();
     process.exit(0);
 }
 
 const rootDir = path.join(__dirname, '..');
 
-if (command === 'server') {
-    const noClient = args.includes('--no-client');
-    const startClient = !noClient;
-
-    // Set environment variable for server to know whether to start client
-    process.env.START_CLIENT = startClient ? 'true' : 'false';
-
+if (!command || command === 'server') {
     require(path.join(rootDir, 'server.js'));
-} else if (command === 'client') {
-    let serverUrl = args[1] || 'ws://localhost:6789';
-    // Add ws:// prefix if missing
-    if (!serverUrl.startsWith('ws://') && !serverUrl.startsWith('wss://')) {
-        serverUrl = 'ws://' + serverUrl;
-    }
-    // Add default port if not specified
-    if (!serverUrl.match(/:\d+/)) {
-        serverUrl = serverUrl.replace(/^(wss?:\/\/[^\/]+)/, '$1:6789');
-    }
-    process.argv = [process.argv[0], path.join(rootDir, 'client.js'), serverUrl];
-    require(path.join(rootDir, 'client.js'));
 } else {
     console.error(`Unknown command: ${command}`);
     showHelp();

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "termites",
-  "version": "1.0.29",
-  "description": "Web terminal with server-client architecture for remote shell access",
+  "version": "1.0.31",
+  "description": "Local multi-terminal manager with web interface",
   "main": "index.js",
   "scripts": {
     "start": "node index.js",
-    "server": "node server.js",
-    "client": "node client.js"
+    "server": "node server.js"
   },
   "bin": {
     "termites": "bin/termites.js"
@@ -18,7 +17,7 @@
   "keywords": [
     "terminal",
     "shell",
-    "remote",
+    "multi-terminal",
     "web",
     "pty"
   ],

package/server.js

@@ -2,13 +2,14 @@
 const http = require('http');
 const WebSocket = require('ws');
 const crypto = require('crypto');
-const { spawn } = require('child_process');
 const path = require('path');
 const fs = require('fs');
+const os = require('os');
+const pty = require('node-pty');
 
 const PORT = process.env.PORT || 6789;
-const START_CLIENT = process.env.START_CLIENT !== 'false'; // default true
 const CONFIG_FILE = path.join(__dirname, '.termites.json');
+const SHELL = process.env.SHELL || '/bin/bash';
 
 // Load or create config
 function loadConfig() {
@@ -31,9 +32,8 @@ function hashPassword(password) {
 class TermitesServer {
     constructor(port) {
         this.port = port;
-        this.clients = new Map(); // clientId -> { ws, info, outputBuffer }
+        this.terminals = new Map(); // terminalId -> { pty, info, outputBuffer }
         this.browsers = new Set(); // browser WebSocket connections
-        this.selectedClient = null; // currently selected client for each browser
         this.config = loadConfig();
         // Use saved sessionToken or generate new one
         if (this.config.passwordHash) {
@@ -57,34 +57,26 @@ class TermitesServer {
         this.wss = new WebSocket.Server({ server: this.httpServer });
 
         this.wss.on('connection', (ws, req) => {
-            const isClient = req.url === '/client';
-            console.log(`WebSocket connection: ${req.url}, isClient: ${isClient}`);
+            console.log(`WebSocket connection: ${req.url}`);
 
             // Browser connections require auth (if password is set)
-            if (!isClient && this.config.passwordHash && !this.checkSession(req)) {
+            if (this.config.passwordHash && !this.checkSession(req)) {
                 console.log('WebSocket rejected: unauthorized browser connection');
                 ws.close(1008, 'Unauthorized');
                 return;
             }
 
-            if (isClient) {
-                this.handleClientConnection(ws);
-            } else {
-                this.handleBrowserConnection(ws);
-            }
+            this.handleBrowserConnection(ws);
         });
 
         this.httpServer.listen(this.port, () => {
             console.log(`Termites Server started: http://localhost:${this.port}`);
-            console.log(`Client connection: ws://localhost:${this.port}/client`);
             if (!this.config.passwordHash) {
                 console.log('Warning: No password set, please visit browser to set password');
             }
 
-            // Auto-start local client if enabled
-            if (START_CLIENT) {
-                this.startLocalClient();
-            }
+            // Auto-create first terminal
+            this.createTerminal();
         });
     }
 
@@ -108,103 +100,159 @@ class TermitesServer {
         return cookies;
     }
 
-    startLocalClient() {
-        console.log('Starting local client...');
-        const clientPath = path.join(__dirname, 'client.js');
-        const serverUrl = `ws://localhost:${this.port}/client`;
-
-        this.localClient = spawn(process.execPath, [clientPath, serverUrl], {
-            stdio: 'inherit'
+    // Create a new local terminal
+    createTerminal() {
+        const terminalId = crypto.randomUUID();
+        const ptyProcess = pty.spawn(SHELL, ['-l'], {
+            name: 'xterm-256color',
+            cols: 120,
+            rows: 40,
+            cwd: process.cwd(),
+            env: process.env
         });
-        global.localClient = this.localClient;
-
-        this.localClient.on('error', (err) => {
-            console.error('Failed to start local client:', err.message);
-        });
-
-        this.localClient.on('exit', (code) => {
-            console.log(`Local client exited (code: ${code})`);
-            this.localClient = null;
-            global.localClient = null;
-        });
-    }
 
-    // Handle shell client connections
-    handleClientConnection(ws) {
-        const clientId = crypto.randomUUID();
-        console.log(`New client connected: ${clientId}`);
+        const info = {
+            username: os.userInfo().username,
+            hostname: os.hostname(),
+            cwd: process.cwd().replace(os.homedir(), '~'),
+            platform: os.platform()
+        };
 
-        const clientData = {
-            ws,
-            info: null,
+        const terminal = {
+            pty: ptyProcess,
+            info,
             outputBuffer: []
         };
-        this.clients.set(clientId, clientData);
 
-        ws.on('message', (message) => {
-            try {
-                const data = JSON.parse(message);
-                this.handleClientMessage(clientId, data);
-            } catch (e) {
-                console.error('Failed to parse client message:', e);
+        this.terminals.set(terminalId, terminal);
+        console.log(`Terminal created: ${terminalId} (PID: ${ptyProcess.pid})`);
+
+        ptyProcess.onData(data => {
+            terminal.outputBuffer.push(data);
+            if (terminal.outputBuffer.length > 1000) {
+                terminal.outputBuffer = terminal.outputBuffer.slice(-500);
+            }
+
+            // Parse terminal output to detect user@host changes (e.g., after SSH)
+            // Method 1: OSC 0 sequences (window title)
+            const oscMatch = data.match(/\x1b\]0;([^\x07\x1b]+)[\x07\x1b]/);
+            if (oscMatch) {
+                const title = oscMatch[1];
+                const match = title.match(/^([^@]+)@([^:]+)(?::(.*))?$/);
+                if (match) {
+                    this.updateTerminalInfo(terminalId, terminal, match[1], match[2], match[3]);
+                }
             }
+
+            // Method 2: Parse shell prompt patterns (works without any config)
+            // Look for the LAST (most recent) prompt pattern in output
+            const lines = data.split(/\r?\n/);
+            let lastMatch = null;
+            for (const line of lines) {
+                // Strip ANSI escape codes for matching
+                const cleanLine = line.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '').replace(/\x1b\][^\x07]*\x07/g, '');
+
+                // Pattern 1: user@host format (e.g., "user@host:path$", "[user@host path]$")
+                const userHostMatch = cleanLine.match(/[\[\s]?([a-zA-Z0-9_-]+)@([a-zA-Z0-9_.-]+)[\s:\]]/);
+                if (userHostMatch) {
+                    const [, username, hostname] = userHostMatch;
+                    if (hostname && !hostname.includes('/') && hostname.length < 64) {
+                        lastMatch = { username, hostname };
+                    }
+                }
+
+                // Pattern 2: hostname:path format (e.g., "seis10:/gds/zhfu[22] > ")
+                const hostPathMatch = cleanLine.match(/^([a-zA-Z0-9_-]+):([\/~][^\s\[]*)/);
+                if (hostPathMatch) {
+                    const [, hostname, cwd] = hostPathMatch;
+                    if (hostname && hostname.length < 64) {
+                        lastMatch = { hostname, cwd, keepUsername: true };
+                    }
+                }
+            }
+            // Use only the last (most recent) match
+            if (lastMatch) {
+                if (lastMatch.keepUsername) {
+                    this.updateTerminalInfo(terminalId, terminal, null, lastMatch.hostname, lastMatch.cwd);
+                } else {
+                    this.updateTerminalInfo(terminalId, terminal, lastMatch.username, lastMatch.hostname);
+                }
+            }
+
+            this.broadcastToBrowsers({
+                type: 'output',
+                clientId: terminalId,
+                data
+            });
         });
 
-        ws.on('close', () => {
-            console.log(`Client disconnected: ${clientId}`);
-            this.clients.delete(clientId);
+        ptyProcess.onExit(() => {
+            console.log(`Terminal exited: ${terminalId}`);
+            this.terminals.delete(terminalId);
             this.broadcastToBrowsers({
                 type: 'client-disconnected',
-                clientId
+                clientId: terminalId
             });
         });
-    }
 
-    handleClientMessage(clientId, data) {
-        const client = this.clients.get(clientId);
-        if (!client) return;
+        // Notify browsers
+        this.broadcastToBrowsers({
+            type: 'client-connected',
+            client: { id: terminalId, ...info }
+        });
+        this.broadcastTerminalList();
 
-        switch (data.type) {
-            case 'register':
-                client.info = data.info;
-                console.log(`Client registered: ${data.info.username}@${data.info.hostname}`);
-                this.broadcastToBrowsers({
-                    type: 'client-connected',
-                    client: { id: clientId, ...data.info }
-                });
-                this.broadcastClientList();
-                break;
+        return terminalId;
+    }
 
-            case 'output':
-                client.outputBuffer.push(data.data);
-                if (client.outputBuffer.length > 1000) {
-                    client.outputBuffer = client.outputBuffer.slice(-500);
-                }
-                this.broadcastToBrowsers({
-                    type: 'output',
-                    clientId,
-                    data: data.data
-                });
-                break;
+    // Close a terminal
+    closeTerminal(terminalId) {
+        const terminal = this.terminals.get(terminalId);
+        if (terminal) {
+            terminal.pty.kill();
+            this.terminals.delete(terminalId);
+            console.log(`Terminal closed: ${terminalId}`);
+        }
+    }
 
-            case 'exit':
-                console.log(`Client shell exited: ${clientId}`);
-                break;
+    // Update terminal info (user@host) when detected from output
+    updateTerminalInfo(terminalId, terminal, username, hostname, cwd) {
+        let infoChanged = false;
+        if (username && terminal.info.username !== username) {
+            terminal.info.username = username;
+            infoChanged = true;
+        }
+        if (hostname && terminal.info.hostname !== hostname) {
+            terminal.info.hostname = hostname;
+            infoChanged = true;
+        }
+        if (cwd !== undefined && terminal.info.cwd !== cwd) {
+            terminal.info.cwd = cwd || '~';
+            infoChanged = true;
+        }
+        if (infoChanged) {
+            console.log(`Terminal ${terminalId} info updated: ${username}@${hostname}`);
+            this.broadcastToBrowsers({
+                type: 'client-info-updated',
+                clientId: terminalId,
+                info: terminal.info
+            });
+            this.broadcastTerminalList();
         }
     }
 
     // Handle browser connections
     handleBrowserConnection(ws) {
         console.log('New browser connected');
-        console.log('Current clients count:', this.clients.size);
+        console.log('Current terminals count:', this.terminals.size);
         this.browsers.add(ws);
 
-        // Send current client list
-        const clientList = this.getClientList();
-        console.log('Sending client list:', clientList.length, 'clients');
+        // Send current terminal list
+        const terminalList = this.getTerminalList();
+        console.log('Sending terminal list:', terminalList.length, 'terminals');
         ws.send(JSON.stringify({
             type: 'clients',
-            list: clientList
+            list: terminalList
         }));
 
         ws.on('message', (message) => {
@@ -223,11 +271,21 @@ class TermitesServer {
 
     handleBrowserMessage(browserWs, data) {
         switch (data.type) {
+            case 'create-terminal':
+                this.createTerminal();
+                break;
+
+            case 'close-terminal':
+                if (data.clientId) {
+                    this.closeTerminal(data.clientId);
+                }
+                break;
+
             case 'select':
-                const client = this.clients.get(data.clientId);
-                if (client) {
+                const terminal = this.terminals.get(data.clientId);
+                if (terminal) {
                     // Send buffered output to browser
-                    client.outputBuffer.forEach(output => {
+                    terminal.outputBuffer.forEach(output => {
                         browserWs.send(JSON.stringify({
                             type: 'output',
                             clientId: data.clientId,
@@ -239,45 +297,36 @@ class TermitesServer {
 
             case 'input':
                 if (data.clientId) {
-                    const targetClient = this.clients.get(data.clientId);
-                    if (targetClient && targetClient.ws.readyState === WebSocket.OPEN) {
-                        targetClient.ws.send(JSON.stringify({
-                            type: 'input',
-                            text: data.text
-                        }));
+                    const targetTerminal = this.terminals.get(data.clientId);
+                    if (targetTerminal) {
+                        targetTerminal.pty.write(data.text);
                     }
                 }
                 break;
 
             case 'resize':
                 if (data.clientId) {
-                    const targetClient = this.clients.get(data.clientId);
-                    if (targetClient && targetClient.ws.readyState === WebSocket.OPEN) {
-                        targetClient.ws.send(JSON.stringify({
-                            type: 'resize',
-                            cols: data.cols,
-                            rows: data.rows
-                        }));
+                    const targetTerminal = this.terminals.get(data.clientId);
+                    if (targetTerminal) {
+                        targetTerminal.pty.resize(data.cols, data.rows);
                     }
                 }
                 break;
         }
     }
 
-    getClientList() {
+    getTerminalList() {
         const list = [];
-        this.clients.forEach((client, id) => {
-            if (client.info) {
-                list.push({ id, ...client.info });
-            }
+        this.terminals.forEach((terminal, id) => {
+            list.push({ id, ...terminal.info });
         });
         return list;
     }
 
-    broadcastClientList() {
+    broadcastTerminalList() {
         this.broadcastToBrowsers({
             type: 'clients',
-            list: this.getClientList()
+            list: this.getTerminalList()
         });
     }
 
@@ -632,6 +681,11 @@ class TermitesServer {
         .font-size-row input { flex: 1; }
         .font-size-row span { font-size: 12px; min-width: 36px; }
         .empty-clients { padding: 16px; font-size: 12px; opacity: 0.5; text-align: center; }
+        .add-btn {
+            margin-left: auto; padding: 4px 12px; border: 1px solid; border-radius: 4px;
+            background: transparent; color: inherit; cursor: pointer; font-size: 11px;
+        }
+        .add-btn:hover { opacity: 0.8; }
         /* Mobile toolbar */
         .mobile-toolbar {
             display: none; flex-shrink: 0; padding: 6px 8px; gap: 6px;
@@ -736,9 +790,9 @@ class TermitesServer {
                 </div>
             </div>
             <div class="drawer-section">
-                <div class="drawer-section-header">◉ Clients</div>
+                <div class="drawer-section-header">◉ Terminals <button id="add-terminal-btn" class="add-btn">+ Add</button></div>
                 <div class="client-list" id="client-list">
-                    <div class="empty-clients">Waiting for clients...</div>
+                    <div class="empty-clients">No terminals</div>
                 </div>
             </div>
         </div>
@@ -988,11 +1042,17 @@ class TermitesServer {
             const drawer = document.getElementById('drawer');
             const overlay = document.getElementById('overlay');
             const closeBtn = document.getElementById('drawer-close');
+            const addTerminalBtn = document.getElementById('add-terminal-btn');
             const openDrawer = () => { drawer.classList.add('open'); overlay.classList.add('open'); };
             const closeDrawer = () => { drawer.classList.remove('open'); overlay.classList.remove('open'); };
             menuBtn.onclick = openDrawer;
             closeBtn.onclick = closeDrawer;
             overlay.onclick = closeDrawer;
+            addTerminalBtn.onclick = () => {
+                if (ws?.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({ type: 'create-terminal' }));
+                }
+            };
             document.getElementById('theme-select').onchange = e => applyTheme(e.target.value);
             document.getElementById('font-select').onchange = e => applyFont(e.target.value);
             document.getElementById('font-size').oninput = e => applyFontSize(parseInt(e.target.value));
@@ -1398,7 +1458,7 @@ class TermitesServer {
             const listEl = document.getElementById('client-list');
             const t = themes[currentTheme];
             if (clients.length === 0) {
-                listEl.innerHTML = '<div class="empty-clients">Waiting for clients...</div>';
+                listEl.innerHTML = '<div class="empty-clients">No terminals</div>';
                 return;
             }
             listEl.innerHTML = clients.map(c => {
@@ -1580,6 +1640,18 @@ class TermitesServer {
                             if (clients.length > 0) selectClient(clients[0].id);
                         }
                         break;
+                    case 'client-info-updated':
+                        const clientToUpdate = clients.find(c => c.id === d.clientId);
+                        if (clientToUpdate && d.info) {
+                            Object.assign(clientToUpdate, d.info);
+                            updateClientList();
+                            if (selectedClientId === d.clientId) {
+                                document.getElementById('header-title').innerHTML =
+                                    '<span class="user">' + d.info.username + '</span>' +
+                                    '<span class="sep">@</span><span class="host">' + d.info.hostname + '</span>';
+                            }
+                        }
+                        break;
                     case 'output':
                         if (d.clientId === selectedClientId) {
                             addToHistory(d.data);
@@ -1610,10 +1682,4 @@ class TermitesServer {
 new TermitesServer(PORT);
 
 process.on('SIGINT', () => process.exit(0));
-process.on('SIGTERM', () => process.exit(0));
-process.on('exit', () => {
-    // Clean up local client on exit
-    if (global.localClient) {
-        global.localClient.kill();
-    }
-});
+process.on('SIGTERM', () => process.exit(0));

package/client.js

@@ -1,150 +0,0 @@
-#!/usr/bin/env node
-const os = require('os');
-const WebSocket = require('ws');
-
-const SHELL = process.env.SHELL || '/bin/bash';
-const SERVER_URL = process.argv[2] || 'ws://localhost:6789/client';
-
-function getSystemInfo() {
-    const username = os.userInfo().username;
-    const hostname = os.hostname();
-    const cwd = process.cwd().replace(os.homedir(), '~');
-    const platform = os.platform();
-    return { username, hostname, cwd, platform };
-}
-
-class TermitesClient {
-    constructor(serverUrl) {
-        this.serverUrl = serverUrl.endsWith('/client') ? serverUrl : serverUrl + '/client';
-        this.ws = null;
-        this.pty = null;
-        this.reconnectDelay = 1000;
-        this.maxReconnectDelay = 30000;
-        this.systemInfo = getSystemInfo();
-
-        this.connect();
-    }
-
-    connect() {
-        console.log(`Connecting to server: ${this.serverUrl}`);
-
-        this.ws = new WebSocket(this.serverUrl);
-
-        this.ws.on('open', () => {
-            console.log('Connected to server');
-            this.reconnectDelay = 1000;
-
-            // Register with server
-            this.ws.send(JSON.stringify({
-                type: 'register',
-                info: this.systemInfo
-            }));
-
-            // Start shell
-            this.startShell();
-        });
-
-        this.ws.on('message', (message) => {
-            try {
-                const data = JSON.parse(message);
-                this.handleServerMessage(data);
-            } catch (e) {
-                console.error('Failed to parse server message:', e);
-            }
-        });
-
-        this.ws.on('close', () => {
-            console.log('Disconnected from server');
-            this.stopShell();
-            this.scheduleReconnect();
-        });
-
-        this.ws.on('error', (err) => {
-            console.error('WebSocket error:', err.message);
-        });
-    }
-
-    scheduleReconnect() {
-        console.log(`Reconnecting in ${this.reconnectDelay / 1000}s...`);
-        setTimeout(() => {
-            this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
-            this.connect();
-        }, this.reconnectDelay);
-    }
-
-    handleServerMessage(data) {
-        switch (data.type) {
-            case 'input':
-                if (this.pty) {
-                    this.pty.write(data.text);
-                }
-                break;
-
-            case 'resize':
-                if (this.pty) {
-                    this.pty.resize(data.cols, data.rows);
-                }
-                break;
-        }
-    }
-
-    startShell() {
-        if (this.pty) return;
-
-        const pty = require('node-pty');
-        this.pty = pty.spawn(SHELL, ['-l'], {
-            name: 'xterm-256color',
-            cols: 120,
-            rows: 40,
-            cwd: process.cwd(),
-            env: process.env
-        });
-
-        console.log(`Shell started (PID: ${this.pty.pid})`);
-
-        this.pty.onData((data) => {
-            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-                this.ws.send(JSON.stringify({
-                    type: 'output',
-                    data
-                }));
-            }
-        });
-
-        this.pty.onExit(() => {
-            console.log('Shell exited');
-            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-                this.ws.send(JSON.stringify({ type: 'exit' }));
-            }
-            this.pty = null;
-            // Restart shell
-            setTimeout(() => this.startShell(), 1000);
-        });
-    }
-
-    stopShell() {
-        if (this.pty) {
-            this.pty.kill();
-            this.pty = null;
-        }
-    }
-}
-
-// Parse server URL from command line
-let serverUrl = SERVER_URL;
-if (!serverUrl.startsWith('ws://') && !serverUrl.startsWith('wss://')) {
-    serverUrl = 'ws://' + serverUrl;
-}
-// Add default port if not specified
-if (!serverUrl.match(/:\d+/) && !serverUrl.includes('localhost')) {
-    serverUrl = serverUrl.replace(/^(wss?:\/\/[^\/]+)/, '$1:6789');
-}
-
-console.log('Termites Client');
-console.log(`System: ${getSystemInfo().username}@${getSystemInfo().hostname}`);
-console.log(`Shell: ${SHELL}`);
-
-new TermitesClient(serverUrl);
-
-process.on('SIGINT', () => process.exit(0));
-process.on('SIGTERM', () => process.exit(0));