orc-server 1.0.5

package/dist/http/server.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpServer = createHttpServer;
+const express_1 = __importDefault(require("express"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const config_1 = require("../config");
+const logger_1 = require("../utils/logger");
+const MIME_TYPES = {
+    '.pdf': 'application/pdf',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.bmp': 'image/bmp',
+    '.ico': 'image/x-icon',
+};
+function authenticateRequest(req) {
+    const token = req.query.token;
+    if (token && token === config_1.CONFIG.authToken)
+        return true;
+    const authHeader = req.headers.authorization;
+    if (authHeader === `Bearer ${config_1.CONFIG.authToken}`)
+        return true;
+    return !config_1.CONFIG.authToken; // allow if no token configured
+}
+function createHttpServer() {
+    const app = (0, express_1.default)();
+    app.get('/health', (_req, res) => {
+        res.json({ status: 'ok', timestamp: Date.now() });
+    });
+    app.get('/token', (req, res) => {
+        const authHeader = req.headers.authorization;
+        if (authHeader !== `Bearer ${config_1.CONFIG.authToken}`) {
+            res.status(401).json({ error: 'Unauthorized' });
+            return;
+        }
+        res.json({ token: config_1.CONFIG.authToken });
+    });
+    // File serving endpoint for PDF/image preview
+    app.get('/api/file', (req, res) => {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        if (!authenticateRequest(req)) {
+            res.status(401).json({ error: 'Unauthorized' });
+            return;
+        }
+        const filePath = req.query.path;
+        if (!filePath) {
+            res.status(400).json({ error: 'Missing path parameter' });
+            return;
+        }
+        const resolved = path_1.default.resolve(filePath);
+        const ext = path_1.default.extname(resolved).toLowerCase();
+        const mimeType = MIME_TYPES[ext];
+        if (!mimeType) {
+            res.status(400).json({ error: 'Unsupported file type' });
+            return;
+        }
+        let stat;
+        try {
+            stat = fs_1.default.statSync(resolved);
+        }
+        catch {
+            res.status(404).json({ error: 'File not found' });
+            return;
+        }
+        if (stat.size > config_1.CONFIG.maxFileSize) {
+            res.status(413).json({ error: 'File too large' });
+            return;
+        }
+        res.setHeader('Content-Type', mimeType);
+        res.setHeader('Content-Disposition', 'inline');
+        res.setHeader('Content-Length', stat.size);
+        fs_1.default.createReadStream(resolved).pipe(res);
+    });
+    // Serve web client static files
+    const webDistPath = process.env.WEB_DIST_PATH
+        || path_1.default.join(__dirname, '../../web-dist');
+    if (fs_1.default.existsSync(webDistPath)) {
+        logger_1.logger.info(`Serving web client from ${webDistPath}`);
+        app.use(express_1.default.static(webDistPath));
+        app.get('{*path}', (_req, res) => {
+            res.sendFile(path_1.default.join(webDistPath, 'index.html'));
+        });
+    }
+    const httpPort = config_1.CONFIG.port + 1;
+    app.listen(httpPort, config_1.CONFIG.host, () => {
+        logger_1.logger.info(`HTTP server running on ${config_1.CONFIG.host}:${httpPort}`);
+    });
+    return app;
+}

package/dist/index.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const server_1 = require("./websocket/server");
+const watcher_1 = require("./claude/watcher");
+const server_2 = require("./http/server");
+const logger_1 = require("./utils/logger");
+class RemoteDevServer {
+    constructor() {
+        this.wsServer = new server_1.WebSocketServer();
+        this.claudeWatcher = new watcher_1.ClaudeWatcher();
+        (0, server_2.createHttpServer)();
+        this.setupClaudeWatcher();
+    }
+    setupClaudeWatcher() {
+        this.claudeWatcher.on('user_input', (data) => {
+            this.wsServer.broadcast({
+                type: 'claude_user_input',
+                data
+            });
+        });
+        this.claudeWatcher.on('assistant_message', (data) => {
+            this.wsServer.broadcast({
+                type: 'claude_assistant_message',
+                data
+            });
+        });
+        this.claudeWatcher.on('tool_call', (data) => {
+            this.wsServer.broadcast({
+                type: 'claude_tool_call',
+                data
+            });
+        });
+        this.claudeWatcher.on('tool_result', (data) => {
+            this.wsServer.broadcast({
+                type: 'claude_tool_result',
+                data
+            });
+        });
+        this.claudeWatcher.on('file_change', (data) => {
+            this.wsServer.broadcast({
+                type: 'claude_file_change',
+                data
+            });
+        });
+        this.claudeWatcher.on('progress', (data) => {
+            this.wsServer.broadcast({
+                type: 'claude_progress',
+                data
+            });
+        });
+    }
+    async start() {
+        logger_1.logger.info('Starting Remote Dev Server');
+        await this.claudeWatcher.start();
+        logger_1.logger.info('Server ready');
+    }
+    stop() {
+        logger_1.logger.info('Stopping Remote Dev Server');
+        this.claudeWatcher.stop();
+    }
+}
+const server = new RemoteDevServer();
+server.start().catch((error) => {
+    logger_1.logger.error('Failed to start server:', error);
+    process.exit(1);
+});
+process.on('SIGINT', () => {
+    logger_1.logger.info('Received SIGINT, shutting down');
+    server.stop();
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    logger_1.logger.info('Received SIGTERM, shutting down');
+    server.stop();
+    process.exit(0);
+});

package/dist/ssh/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSHHandler = exports.sshManager = exports.SSHConnection = exports.SSHManager = void 0;
+var sshManager_1 = require("./sshManager");
+Object.defineProperty(exports, "SSHManager", { enumerable: true, get: function () { return sshManager_1.SSHManager; } });
+Object.defineProperty(exports, "SSHConnection", { enumerable: true, get: function () { return sshManager_1.SSHConnection; } });
+Object.defineProperty(exports, "sshManager", { enumerable: true, get: function () { return sshManager_1.sshManager; } });
+var sshHandler_1 = require("./sshHandler");
+Object.defineProperty(exports, "SSHHandler", { enumerable: true, get: function () { return sshHandler_1.SSHHandler; } });

package/dist/ssh/sshHandler.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSHHandler = void 0;
+const logger_1 = require("../utils/logger");
+const sshManager_1 = require("./sshManager");
+/**
+ * Handles SSH-related WebSocket messages.
+ * Routes ssh_* messages to the appropriate SSHManager methods.
+ * Supports multiple shell sessions per client via sessionId.
+ */
+class SSHHandler {
+    constructor(sendFn) {
+        this.sendFn = sendFn;
+    }
+    /**
+     * Check if this handler should process the message.
+     */
+    canHandle(messageType) {
+        return messageType.startsWith('ssh_');
+    }
+    /**
+     * Process an SSH message.
+     */
+    async handle(ws, clientId, message) {
+        switch (message.type) {
+            case 'ssh_connect':
+                await this.handleConnect(ws, clientId, message);
+                break;
+            case 'ssh_start_shell':
+                await this.handleStartShell(ws, clientId, message);
+                break;
+            case 'ssh_input':
+                this.handleInput(clientId, message);
+                break;
+            case 'ssh_resize':
+                this.handleResize(clientId, message);
+                break;
+            case 'ssh_disconnect':
+                this.handleDisconnect(ws, clientId);
+                break;
+            case 'ssh_close_shell':
+                this.handleCloseShell(ws, clientId, message);
+                break;
+            case 'ssh_list_shells':
+                this.handleListShells(ws, clientId);
+                break;
+            case 'ssh_port_forward':
+                await this.handlePortForward(ws, clientId, message);
+                break;
+            case 'ssh_stop_port_forward':
+                this.handleStopPortForward(ws, clientId, message);
+                break;
+            default:
+                logger_1.logger.warn(`Unknown SSH message type: ${message.type}`);
+        }
+    }
+    async handleConnect(ws, clientId, message) {
+        try {
+            const { host, port, username, privateKey, password } = message.data;
+            logger_1.logger.info(`SSH connect request: host=${host}, port=${port}, username=${username}, hasPassword=${!!password}, hasPrivateKey=${!!privateKey}`);
+            const connection = sshManager_1.sshManager.getConnection(clientId);
+            await connection.connect({ host, port, username, privateKey, password });
+            this.sendFn(ws, {
+                type: 'ssh_connect_response',
+                data: { success: true },
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('SSH connect error:', error);
+            this.sendFn(ws, {
+                type: 'ssh_connect_response',
+                data: { success: false, message: error.message },
+            });
+        }
+    }
+    async handleStartShell(ws, clientId, message) {
+        try {
+            const connection = sshManager_1.sshManager.getConnection(clientId);
+            if (!connection.isConnected()) {
+                this.sendFn(ws, {
+                    type: 'ssh_status',
+                    data: { status: 'error', message: 'SSH not connected' },
+                });
+                return;
+            }
+            const sessionId = message.data?.sessionId || 'default';
+            const cols = message.data?.cols || 80;
+            const rows = message.data?.rows || 24;
+            await connection.startShell(sessionId, (data) => {
+                this.sendFn(ws, { type: 'ssh_output', data: { sessionId, output: data } });
+            }, () => {
+                this.sendFn(ws, {
+                    type: 'ssh_shell_closed',
+                    data: { sessionId },
+                });
+            }, cols, rows);
+            this.sendFn(ws, {
+                type: 'ssh_shell_started',
+                data: { sessionId },
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('SSH start shell error:', error);
+            this.sendFn(ws, {
+                type: 'ssh_status',
+                data: { status: 'error', message: error.message },
+            });
+        }
+    }
+    handleInput(clientId, message) {
+        const connection = sshManager_1.sshManager.getConnection(clientId);
+        if (connection.isConnected()) {
+            const sessionId = message.data?.sessionId || 'default';
+            const input = message.data?.input || message.data;
+            // Try new API first, fall back to legacy
+            if (!connection.writeToShell(sessionId, typeof input === 'string' ? input : input.input)) {
+                // Legacy fallback
+                connection.write(typeof input === 'string' ? input : input.input);
+            }
+        }
+    }
+    handleResize(clientId, message) {
+        const connection = sshManager_1.sshManager.getConnection(clientId);
+        if (connection.isConnected()) {
+            const sessionId = message.data?.sessionId;
+            const cols = message.data.cols;
+            const rows = message.data.rows;
+            if (sessionId) {
+                connection.resizeShell(sessionId, cols, rows);
+            }
+            else {
+                // Legacy fallback
+                connection.resize(cols, rows);
+            }
+        }
+    }
+    handleCloseShell(ws, clientId, message) {
+        const connection = sshManager_1.sshManager.getConnection(clientId);
+        const sessionId = message.data?.sessionId;
+        if (sessionId && connection.isConnected()) {
+            const closed = connection.closeShell(sessionId);
+            this.sendFn(ws, {
+                type: 'ssh_shell_closed',
+                data: { sessionId, success: closed },
+            });
+        }
+    }
+    handleListShells(ws, clientId) {
+        const connection = sshManager_1.sshManager.getConnection(clientId);
+        const shells = connection.isConnected() ? connection.getActiveShells() : [];
+        this.sendFn(ws, {
+            type: 'ssh_list_shells_response',
+            data: { shells },
+        });
+    }
+    handleDisconnect(ws, clientId) {
+        sshManager_1.sshManager.removeConnection(clientId);
+        this.sendFn(ws, {
+            type: 'ssh_status',
+            data: { status: 'disconnected', message: 'Disconnected' },
+        });
+    }
+    async handlePortForward(ws, clientId, message) {
+        try {
+            const { localPort, remoteHost, remotePort } = message.data;
+            const connection = sshManager_1.sshManager.getConnection(clientId);
+            if (!connection.isConnected()) {
+                this.sendFn(ws, {
+                    type: 'ssh_port_forward_response',
+                    data: { success: false, localPort, message: 'SSH not connected' },
+                });
+                return;
+            }
+            await connection.setupPortForward({ localPort, remoteHost, remotePort });
+            this.sendFn(ws, {
+                type: 'ssh_port_forward_response',
+                data: { success: true, localPort },
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('SSH port forward error:', error);
+            this.sendFn(ws, {
+                type: 'ssh_port_forward_response',
+                data: { success: false, localPort: message.data.localPort, message: error.message },
+            });
+        }
+    }
+    handleStopPortForward(ws, clientId, message) {
+        const connection = sshManager_1.sshManager.getConnection(clientId);
+        if (connection.isConnected()) {
+            connection.stopPortForward(message.data.localPort);
+        }
+        this.sendFn(ws, {
+            type: 'ssh_port_forward_response',
+            data: { success: true, localPort: message.data.localPort, message: 'Port forward stopped' },
+        });
+    }
+    /**
+     * Clean up SSH resources for a disconnected client.
+     */
+    cleanup(clientId) {
+        sshManager_1.sshManager.removeConnection(clientId);
+    }
+}
+exports.SSHHandler = SSHHandler;