@hmduc16031996/claude-mb-bridge 2.3.6 → 2.4.1

package/dist/index.js

@@ -6,7 +6,7 @@ const program = new Command();
 program
     .name('claude-mobile-bridge')
     .description('Bridge Claude Code CLI to mobile via WebView')
-    .version('2.3.6')
+    .version('2.4.1')
     .option('--token <token>', 'Pairing token from mobile app')
     .option('--server <url>', 'Backend server URL', 'http://127.0.0.1:3110')
     .option('--path <path>', 'Working directory', process.cwd())
@@ -33,7 +33,7 @@ program
     // 1. Start local terminal server
     console.log('📦 Starting terminal server...');
     const localPort = parseInt(port, 10);
-    const { server: terminalServer, actualPort } = await startTerminalServer(localPort, path, cleanup);
+    const { server: terminalServer, actualPort } = await startTerminalServer(localPort, path, token, cleanup);
     console.log(`✅ Terminal server started on port ${actualPort}`);
     // 2. Start Cloudflare Tunnel
     console.log('🌐 Establishing secure tunnel...');

package/dist/server.d.ts

@@ -1,4 +1,4 @@
-export declare function startTerminalServer(port: number, workingDir: string, onDisconnect?: () => void): Promise<{
+export declare function startTerminalServer(port: number, workingDir: string, terminalToken: string, onDisconnect?: () => void): Promise<{
     server: any;
     actualPort: number;
 }>;

package/dist/server.js

@@ -1,81 +1,301 @@
 import express from 'express';
 import { createServer } from 'http';
-import { WebSocketServer } from 'ws';
+import { WebSocketServer, WebSocket } from 'ws';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
+import * as fs from 'fs';
+import * as os from 'os';
+import { randomUUID } from 'crypto';
 const require = createRequire(import.meta.url);
 const pty = require('node-pty');
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-export function startTerminalServer(port, workingDir, onDisconnect) {
+class Session {
+    term;
+    id;
+    cwd;
+    createdAt;
+    constructor(id, cwd, shell) {
+        this.id = id;
+        this.cwd = cwd;
+        this.createdAt = new Date().toISOString();
+        this.term = pty.spawn(shell, [], {
+            name: 'xterm-256color',
+            cols: 120,
+            rows: 40,
+            cwd: cwd,
+            env: {
+                ...process.env,
+                TERM: 'xterm-256color',
+                FORCE_COLOR: '1',
+            }
+        });
+        this.term.write('claude\r');
+    }
+    getInfo() {
+        return {
+            id: this.id,
+            cwd: this.cwd,
+            createdAt: this.createdAt,
+            status: 'running'
+        };
+    }
+    kill() {
+        try {
+            this.term.kill();
+        }
+        catch (e) {
+            console.warn(`Failed to kill pty ${this.id}:`, e);
+        }
+    }
+}
+class SessionManager {
+    sessions = new Map();
+    createSession(cwd) {
+        const id = randomUUID().slice(0, 8);
+        let shell = '/bin/bash';
+        if (process.platform === 'win32') {
+            shell = 'powershell.exe';
+        }
+        else if (process.platform === 'darwin') {
+            shell = fs.existsSync('/bin/zsh') ? '/bin/zsh' : '/bin/bash';
+        }
+        const session = new Session(id, cwd, shell);
+        this.sessions.set(id, session);
+        return session;
+    }
+    getSession(id) {
+        return this.sessions.get(id);
+    }
+    removeSession(id) {
+        const session = this.sessions.get(id);
+        if (session) {
+            session.kill();
+            this.sessions.delete(id);
+        }
+    }
+    listSessions() {
+        return Array.from(this.sessions.values()).map(s => s.getInfo());
+    }
+}
+export function startTerminalServer(port, workingDir, terminalToken, onDisconnect) {
     const app = express();
     const server = createServer(app);
     const wss = new WebSocketServer({ server });
+    const sessionManager = new SessionManager();
     const publicPath = path.join(__dirname, '../public');
     app.use(express.static(publicPath));
     app.get('/health', (req, res) => {
         res.json({ status: 'ok' });
     });
-    wss.on('connection', (ws, req) => {
-        console.log(`📡 New connection attempt from ${req.socket.remoteAddress}`);
-        console.log('✅ Connection authorized');
-        // Use absolute paths for shells to avoid posix_spawnp failure
-        let shell = '/bin/bash';
-        if (process.platform === 'win32') {
-            shell = 'powershell.exe';
-        }
-        else if (process.platform === 'darwin') {
-            // Prefer zsh on macOS as it's the modern default, fallback to bash
-            shell = require('fs').existsSync('/bin/zsh') ? '/bin/zsh' : '/bin/bash';
-        }
-        console.log(`🚀 Spawning shell: ${shell} in ${workingDir}`);
-        let term;
+    // Ports endpoint - returns empty list (no port detection in bridge mode)
+    app.get('/api/ports', (req, res) => {
+        res.json([]);
+    });
+    // Directory listing for autocomplete
+    app.get('/api/dirs', (req, res) => {
         try {
-            // Ensure working directory exists
-            if (!require('fs').existsSync(workingDir)) {
-                console.error(`❌ Working directory does not exist: ${workingDir}`);
-                ws.send('\r\n\x1b[31mError: Working directory does not exist\x1b[0m\r\n');
-                ws.close();
-                return;
+            let inputPath = req.query.path || '';
+            if (inputPath.startsWith('~/')) {
+                inputPath = inputPath.replace('~/', `${os.homedir()}/`);
             }
-            term = pty.spawn(shell, [], {
-                name: 'xterm-256color',
-                cols: 80,
-                rows: 24,
-                cwd: workingDir,
-                env: process.env
+            else if (inputPath === '~') {
+                inputPath = os.homedir();
+            }
+            let dirToRead;
+            let prefix;
+            if (inputPath.endsWith('/')) {
+                dirToRead = inputPath;
+                prefix = '';
+            }
+            else {
+                dirToRead = path.dirname(inputPath) || '/';
+                prefix = path.basename(inputPath).toLowerCase();
+            }
+            if (!path.isAbsolute(dirToRead)) {
+                dirToRead = path.resolve(process.cwd(), dirToRead);
+            }
+            const entries = fs.readdirSync(dirToRead, { withFileTypes: true });
+            const dirs = entries
+                .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+                .filter(e => !prefix || e.name.toLowerCase().startsWith(prefix))
+                .slice(0, 20)
+                .map(e => {
+                const fullPath = path.join(dirToRead, e.name);
+                const displayPath = fullPath.startsWith(os.homedir())
+                    ? fullPath.replace(os.homedir(), '~')
+                    : fullPath;
+                return { name: e.name, path: displayPath + '/' };
             });
+            res.json(dirs);
         }
-        catch (err) {
-            console.error(`❌ Failed to spawn terminal: ${err.message}`);
-            ws.send(`\r\n\x1b[31mError: Failed to spawn terminal (${err.message})\x1b[0m\r\n`);
-            ws.close();
-            return;
+        catch {
+            res.json([]);
         }
-        term.write('claude\r');
-        term.onData((data) => {
-            ws.send(data);
-        });
-        ws.on('message', (msg) => {
-            const data = msg.toString();
-            try {
-                const json = JSON.parse(data);
-                if (json.type === 'resize' && json.cols && json.rows) {
-                    term.resize(json.cols, json.rows);
+    });
+    wss.on('connection', (ws, req) => {
+        console.log(`📡 New connection from ${req.socket.remoteAddress}`);
+        let authenticated = false;
+        let activeSessionId = null;
+        let outputHandler = null;
+        const sendControl = (message) => {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(Buffer.from(JSON.stringify(message)));
+            }
+        };
+        const attachToSession = (sessionId) => {
+            const session = sessionManager.getSession(sessionId);
+            if (!session) {
+                sendControl({ type: 'error', error: 'Session not found' });
+                return;
+            }
+            // Cleanup old handler
+            if (activeSessionId && outputHandler) {
+                const oldSession = sessionManager.getSession(activeSessionId);
+                if (oldSession) {
+                    oldSession.term.removeListener('data', outputHandler);
                 }
-                else {
-                    term.write(data);
+            }
+            activeSessionId = sessionId;
+            outputHandler = (data) => {
+                if (ws.readyState === WebSocket.OPEN) {
+                    ws.send(data); // Send as text
+                }
+            };
+            session.term.on('data', outputHandler);
+            sendControl({ type: 'session:attached', session: session.getInfo() });
+        };
+        ws.on('message', (msg, isBinary) => {
+            if (isBinary) {
+                let message;
+                try {
+                    message = JSON.parse(msg.toString());
+                }
+                catch {
+                    sendControl({ type: 'error', error: 'Invalid control message' });
+                    return;
+                }
+                // Auth must happen first
+                if (message.type === 'auth') {
+                    if (message.token === terminalToken) {
+                        authenticated = true;
+                        sendControl({ type: 'auth:success' });
+                        // Auto-create initial session and attach
+                        const initialSession = sessionManager.createSession(workingDir);
+                        attachToSession(initialSession.id);
+                        console.log('✅ Client authenticated');
+                    }
+                    else {
+                        sendControl({ type: 'auth:failed', error: 'Invalid token' });
+                        ws.close();
+                    }
+                    return;
+                }
+                if (!authenticated) {
+                    sendControl({ type: 'auth:failed', error: 'Not authenticated' });
+                    return;
+                }
+                switch (message.type) {
+                    case 'session:create': {
+                        let cwd = message.cwd || workingDir;
+                        if (cwd.startsWith('~/')) {
+                            cwd = cwd.replace('~/', `${os.homedir()}/`);
+                        }
+                        if (!fs.existsSync(cwd)) {
+                            sendControl({ type: 'error', error: 'Directory not found' });
+                            break;
+                        }
+                        const session = sessionManager.createSession(cwd);
+                        sendControl({ type: 'session:created', session: session.getInfo() });
+                        attachToSession(session.id);
+                        break;
+                    }
+                    case 'session:attach': {
+                        if (message.sessionId) {
+                            attachToSession(message.sessionId);
+                        }
+                        break;
+                    }
+                    case 'session:list': {
+                        sendControl({ type: 'session:list', sessions: sessionManager.listSessions() });
+                        break;
+                    }
+                    case 'session:discover': {
+                        // No external session discovery in bridge mode
+                        sendControl({ type: 'session:discovered', sessions: [] });
+                        break;
+                    }
+                    case 'resize': {
+                        const session = activeSessionId ? sessionManager.getSession(activeSessionId) : null;
+                        if (session && message.cols && message.rows) {
+                            session.term.resize(message.cols, message.rows);
+                        }
+                        break;
+                    }
+                    case 'image:upload': {
+                        const { data, mimeType, filename } = message;
+                        if (!data)
+                            break;
+                        const ext = mimeType?.split('/')[1] || 'png';
+                        const tempPath = path.join(os.tmpdir(), `claude-bridge-${Date.now()}-${filename || 'image'}.${ext}`);
+                        try {
+                            const buffer = Buffer.from(data, 'base64');
+                            fs.writeFileSync(tempPath, buffer);
+                            sendControl({ type: 'image:uploaded', path: tempPath });
+                        }
+                        catch (err) {
+                            sendControl({ type: 'error', error: 'Failed to save image' });
+                        }
+                        break;
+                    }
+                    case 'session:destroy': {
+                        if (message.sessionId) {
+                            sessionManager.removeSession(message.sessionId);
+                            sendControl({ type: 'session:destroyed', sessionId: message.sessionId });
+                        }
+                        break;
+                    }
+                    // Schedule stubs - not supported in bridge mode
+                    case 'schedule:list': {
+                        sendControl({ type: 'schedule:list', schedules: [] });
+                        break;
+                    }
+                    case 'schedule:create': {
+                        sendControl({ type: 'schedule:create_error', error: 'Schedules are not supported in bridge mode' });
+                        break;
+                    }
+                    case 'schedule:update':
+                    case 'schedule:delete':
+                    case 'schedule:trigger':
+                    case 'schedule:runs':
+                    case 'schedule:log': {
+                        // No-op stubs
+                        break;
+                    }
+                    // Preferences - store in memory only (no persistence needed)
+                    case 'preferences:set': {
+                        // No-op: preferences are managed client-side via localStorage
+                        break;
+                    }
                 }
             }
-            catch {
-                term.write(data);
+            else {
+                if (!authenticated)
+                    return;
+                // Raw text -> forward to active pty
+                const session = activeSessionId ? sessionManager.getSession(activeSessionId) : null;
+                if (session) {
+                    session.term.write(msg.toString());
+                }
             }
         });
-        term.onExit(() => {
-            ws.close();
-        });
         ws.on('close', () => {
-            term.kill();
+            if (activeSessionId && outputHandler) {
+                const session = sessionManager.getSession(activeSessionId);
+                if (session) {
+                    session.term.removeListener('data', outputHandler);
+                }
+            }
             if (onDisconnect)
                 onDisconnect();
         });
@@ -84,7 +304,7 @@ export function startTerminalServer(port, workingDir, onDisconnect) {
         server.on('error', (err) => {
             if (err.code === 'EADDRINUSE' && port !== 0) {
                 console.warn(`⚠️ Port ${port} is busy, trying a random port...`);
-                resolve(startTerminalServer(0, workingDir, onDisconnect));
+                resolve(startTerminalServer(0, workingDir, terminalToken, onDisconnect));
             }
             else {
                 reject(err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hmduc16031996/claude-mb-bridge",
-  "version": "2.3.6",
+  "version": "2.4.1",
   "description": "Bridge between Claude Code CLI and your mobile app via WebView",
   "type": "module",
   "main": "dist/index.js",