renote-server 1.0.1

package/dist/websocket/server.js

@@ -0,0 +1,512 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketServer = void 0;
+const ws_1 = __importDefault(require("ws"));
+const http_1 = require("http");
+const config_1 = require("../config");
+const logger_1 = require("../utils/logger");
+const auth_1 = require("./auth");
+const browser_1 = require("../files/browser");
+const reader_1 = require("../files/reader");
+const search_1 = require("../files/search");
+const sessionBrowser_1 = require("../claude/sessionBrowser");
+const terminal_1 = require("../terminal");
+const git_1 = require("../git");
+const terminalWebSocket_1 = require("../terminal/terminalWebSocket");
+class WebSocketServer {
+    constructor() {
+        this.clients = new Map();
+        const server = (0, http_1.createServer)();
+        // Use noServer mode for path-based routing
+        this.wss = new ws_1.default.Server({ noServer: true });
+        this.authManager = new auth_1.AuthManager();
+        this.terminalHandler = new terminal_1.LocalTerminalHandler(this.send.bind(this));
+        this.gitHandler = new git_1.GitHandler(this.send.bind(this));
+        // Handle HTTP upgrade requests
+        server.on('upgrade', (request, socket, head) => {
+            // Route /terminal to terminal direct WebSocket handler
+            if (terminalWebSocket_1.terminalWebSocketHandler.shouldHandle(request)) {
+                const terminalWss = new ws_1.default.Server({ noServer: true });
+                terminalWss.handleUpgrade(request, socket, head, (ws) => {
+                    terminalWebSocket_1.terminalWebSocketHandler.handleConnection(ws, request);
+                });
+            }
+            else {
+                // Default: main WebSocket for JSON-RPC style messages
+                this.wss.handleUpgrade(request, socket, head, (ws) => {
+                    this.wss.emit('connection', ws, request);
+                });
+            }
+        });
+        this.setupWebSocket();
+        server.listen(config_1.CONFIG.port, () => {
+            logger_1.logger.info(`WebSocket server running on port ${config_1.CONFIG.port}`);
+            logger_1.logger.info(`  - Main API: ws://host:${config_1.CONFIG.port}/`);
+            logger_1.logger.info(`  - Terminal direct: ws://host:${config_1.CONFIG.port}/terminal`);
+        });
+    }
+    setupWebSocket() {
+        this.wss.on('connection', (ws) => {
+            logger_1.logger.info('New client connection attempt');
+            ws.on('message', async (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    await this.handleMessage(ws, message);
+                }
+                catch (error) {
+                    logger_1.logger.error('Error parsing message:', error);
+                    this.sendError(ws, 'Invalid message format');
+                }
+            });
+            ws.on('close', () => {
+                const clientId = this.getClientId(ws);
+                if (clientId) {
+                    this.terminalHandler.cleanup(clientId);
+                    (0, sessionBrowser_1.unwatchSession)(clientId);
+                    this.clients.delete(clientId);
+                    logger_1.logger.info(`Client ${clientId} disconnected`);
+                }
+            });
+            ws.on('error', (error) => {
+                logger_1.logger.error('WebSocket error:', error);
+            });
+        });
+    }
+    async handleMessage(ws, message) {
+        switch (message.type) {
+            case 'auth':
+                await this.handleAuth(ws, message.token);
+                break;
+            case 'ping':
+                // Heartbeat: respond immediately with pong
+                this.send(ws, { type: 'pong', timestamp: message.timestamp });
+                break;
+            case 'file_tree':
+                await this.handleFileTree(ws, message);
+                break;
+            case 'file_read':
+                await this.handleFileRead(ws, message);
+                break;
+            case 'search':
+                await this.handleSearch(ws, message);
+                break;
+            case 'list_workspaces':
+                await this.handleListWorkspaces(ws);
+                break;
+            case 'list_sessions':
+                await this.handleListSessions(ws, message);
+                break;
+            case 'get_session_messages':
+                await this.handleGetSessionMessages(ws, message);
+                break;
+            case 'get_session_messages_page':
+                await this.handleGetSessionMessagesPage(ws, message);
+                break;
+            case 'watch_session':
+                await this.handleWatchSession(ws, message);
+                break;
+            case 'unwatch_session':
+                this.handleUnwatchSession(ws);
+                break;
+            case 'list_subagents':
+                await this.handleListSubagents(ws, message);
+                break;
+            case 'get_subagent_messages':
+                await this.handleGetSubagentMessages(ws, message);
+                break;
+            case 'list_tool_results':
+                await this.handleListToolResults(ws, message);
+                break;
+            case 'get_tool_result_content':
+                await this.handleGetToolResultContent(ws, message);
+                break;
+            case 'get_session_folder_info':
+                await this.handleGetSessionFolderInfo(ws, message);
+                break;
+            default:
+                const clientId = this.getClientId(ws);
+                if (!clientId) {
+                    this.sendError(ws, 'Not authenticated');
+                    return;
+                }
+                // Route terminal messages to terminalHandler
+                if (this.terminalHandler.canHandle(message.type)) {
+                    await this.terminalHandler.handle(ws, clientId, message);
+                    return;
+                }
+                // Route Git messages to gitHandler
+                if (this.gitHandler.canHandle(message.type)) {
+                    await this.gitHandler.handle(ws, clientId, message);
+                    return;
+                }
+                logger_1.logger.warn(`Unknown message type: ${message.type}`);
+                this.sendError(ws, 'Unknown message type');
+        }
+    }
+    async handleFileTree(ws, message) {
+        const clientId = this.getClientId(ws);
+        if (!clientId) {
+            this.sendError(ws, 'Not authenticated');
+            return;
+        }
+        try {
+            const path = message.path || process.cwd();
+            const tree = await browser_1.fileBrowser.generateTree(path);
+            this.send(ws, {
+                type: 'file_tree_response',
+                data: tree,
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Error generating file tree:', error);
+            this.sendError(ws, `Failed to generate file tree: ${error}`);
+        }
+    }
+    async handleFileRead(ws, message) {
+        const clientId = this.getClientId(ws);
+        if (!clientId) {
+            this.sendError(ws, 'Not authenticated');
+            return;
+        }
+        try {
+            const { path } = message;
+            if (!path) {
+                this.sendError(ws, 'File path is required');
+                return;
+            }
+            const fileContent = await reader_1.fileReader.readFile(path);
+            this.send(ws, {
+                type: 'file_read_response',
+                data: fileContent,
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Error reading file:', error);
+            this.sendError(ws, `Failed to read file: ${error}`);
+        }
+    }
+    async handleSearch(ws, message) {
+        const clientId = this.getClientId(ws);
+        if (!clientId) {
+            this.sendError(ws, 'Not authenticated');
+            return;
+        }
+        try {
+            const { query, path, options } = message;
+            if (!query) {
+                this.sendError(ws, 'Search query is required');
+                return;
+            }
+            const searchPath = path || process.cwd();
+            const results = await search_1.searchService.search(query, searchPath, options);
+            this.send(ws, {
+                type: 'search_response',
+                data: {
+                    query,
+                    results,
+                    count: results.length,
+                },
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Error searching:', error);
+            this.sendError(ws, `Search failed: ${error}`);
+        }
+    }
+    async handleListWorkspaces(ws) {
+        const clientId = this.getClientId(ws);
+        if (!clientId) {
+            this.sendError(ws, 'Not authenticated');
+            return;
+        }
+        try {
+            const workspaces = await (0, sessionBrowser_1.listWorkspaces)();
+            this.send(ws, {
+                type: 'list_workspaces_response',
+                data: workspaces,
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Error listing workspaces:', error);
+            this.sendError(ws, `Failed to list workspaces: ${error}`);
+        }
+    }
+    async handleListSessions(ws, message) {
+        const clientId = this.getClientId(ws);
+        if (!clientId) {
+            this.sendError(ws, 'Not authenticated');
+            return;
+        }
+        try {
+            const { workspace } = message;
+            if (!workspace) {
+                this.sendError(ws, 'Workspace is required');
+                return;
+            }
+            const sessions = await (0, sessionBrowser_1.listSessions)(workspace);
+            this.send(ws, {
+                type: 'list_sessions_response',
+                data: sessions,
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Error listing sessions:', error);
+            this.sendError(ws, `Failed to list sessions: ${error}`);
+        }
+    }
+    async handleGetSessionMessages(ws, message) {
+        const clientId = this.getClientId(ws);
+        if (!clientId) {
+            this.sendError(ws, 'Not authenticated');
+            return;
+        }
+        try {
+            const { workspace, sessionId } = message;
+            if (!workspace || !sessionId) {
+                this.sendError(ws, 'Workspace and sessionId are required');
+                return;
+            }
+            const messages = await (0, sessionBrowser_1.getSessionMessages)(workspace, sessionId);
+            this.send(ws, {
+                type: 'get_session_messages_response',
+                data: messages,
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Error getting session messages:', error);
+            this.sendError(ws, `Failed to get session messages: ${error}`);
+        }
+    }
+    async handleGetSessionMessagesPage(ws, message) {
+        const clientId = this.getClientId(ws);
+        if (!clientId) {
+            this.sendError(ws, 'Not authenticated');
+            return;
+        }
+        try {
+            const { workspace, sessionId, limit, beforeIndex } = message;
+            if (!workspace || !sessionId) {
+                this.sendError(ws, 'Workspace and sessionId are required');
+                return;
+            }
+            const page = await (0, sessionBrowser_1.getSessionMessagesPage)(workspace, sessionId, limit || 50, beforeIndex);
+            const isInitial = beforeIndex === undefined || beforeIndex === null;
+            this.send(ws, {
+                type: 'get_session_messages_page_response',
+                data: {
+                    messages: page.messages,
+                    hasMore: page.hasMore,
+                    oldestIndex: page.oldestIndex,
+                    totalCount: page.totalCount,
+                    isInitial,
+                },
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Error getting session messages page:', error);
+            this.sendError(ws, `Failed to get session messages page: ${error}`);
+        }
+    }
+    async handleWatchSession(ws, message) {
+        const clientId = this.getClientId(ws);
+        if (!clientId) {
+            this.sendError(ws, 'Not authenticated');
+            return;
+        }
+        try {
+            const { workspace, sessionId } = message;
+            if (!workspace || !sessionId) {
+                this.sendError(ws, 'Workspace and sessionId are required');
+                return;
+            }
+            await (0, sessionBrowser_1.watchSession)(clientId, workspace, sessionId, (newMessages) => {
+                this.send(ws, {
+                    type: 'session_update',
+                    data: newMessages,
+                });
+            });
+            this.send(ws, {
+                type: 'watch_session_response',
+                data: { success: true },
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Error watching session:', error);
+            this.sendError(ws, `Failed to watch session: ${error}`);
+        }
+    }
+    handleUnwatchSession(ws) {
+        const clientId = this.getClientId(ws);
+        if (!clientId) {
+            this.sendError(ws, 'Not authenticated');
+            return;
+        }
+        (0, sessionBrowser_1.unwatchSession)(clientId);
+        this.send(ws, {
+            type: 'unwatch_session_response',
+            data: { success: true },
+        });
+    }
+    async handleListSubagents(ws, message) {
+        const clientId = this.getClientId(ws);
+        if (!clientId) {
+            this.sendError(ws, 'Not authenticated');
+            return;
+        }
+        try {
+            const { workspace, sessionId } = message;
+            if (!workspace || !sessionId) {
+                this.sendError(ws, 'Workspace and sessionId are required');
+                return;
+            }
+            const subagents = await (0, sessionBrowser_1.listSubagents)(workspace, sessionId);
+            this.send(ws, {
+                type: 'list_subagents_response',
+                data: subagents,
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Error listing subagents:', error);
+            this.sendError(ws, `Failed to list subagents: ${error}`);
+        }
+    }
+    async handleGetSubagentMessages(ws, message) {
+        const clientId = this.getClientId(ws);
+        if (!clientId) {
+            this.sendError(ws, 'Not authenticated');
+            return;
+        }
+        try {
+            const { workspace, sessionId, agentId } = message;
+            if (!workspace || !sessionId || !agentId) {
+                this.sendError(ws, 'Workspace, sessionId, and agentId are required');
+                return;
+            }
+            const messages = await (0, sessionBrowser_1.getSubagentMessages)(workspace, sessionId, agentId);
+            this.send(ws, {
+                type: 'get_subagent_messages_response',
+                data: messages,
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Error getting subagent messages:', error);
+            this.sendError(ws, `Failed to get subagent messages: ${error}`);
+        }
+    }
+    async handleListToolResults(ws, message) {
+        const clientId = this.getClientId(ws);
+        if (!clientId) {
+            this.sendError(ws, 'Not authenticated');
+            return;
+        }
+        try {
+            const { workspace, sessionId } = message;
+            if (!workspace || !sessionId) {
+                this.sendError(ws, 'Workspace and sessionId are required');
+                return;
+            }
+            const results = await (0, sessionBrowser_1.listToolResults)(workspace, sessionId);
+            this.send(ws, {
+                type: 'list_tool_results_response',
+                data: results,
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Error listing tool results:', error);
+            this.sendError(ws, `Failed to list tool results: ${error}`);
+        }
+    }
+    async handleGetToolResultContent(ws, message) {
+        const clientId = this.getClientId(ws);
+        if (!clientId) {
+            this.sendError(ws, 'Not authenticated');
+            return;
+        }
+        try {
+            const { workspace, sessionId, toolUseId } = message;
+            if (!workspace || !sessionId || !toolUseId) {
+                this.sendError(ws, 'Workspace, sessionId, and toolUseId are required');
+                return;
+            }
+            const content = await (0, sessionBrowser_1.getToolResultContent)(workspace, sessionId, toolUseId);
+            this.send(ws, {
+                type: 'get_tool_result_content_response',
+                data: { toolUseId, content },
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Error getting tool result content:', error);
+            this.sendError(ws, `Failed to get tool result content: ${error}`);
+        }
+    }
+    async handleGetSessionFolderInfo(ws, message) {
+        const clientId = this.getClientId(ws);
+        if (!clientId) {
+            this.sendError(ws, 'Not authenticated');
+            return;
+        }
+        try {
+            const { workspace, sessionId } = message;
+            if (!workspace || !sessionId) {
+                this.sendError(ws, 'Workspace and sessionId are required');
+                return;
+            }
+            const info = await (0, sessionBrowser_1.getSessionFolderInfo)(workspace, sessionId);
+            this.send(ws, {
+                type: 'get_session_folder_info_response',
+                data: info,
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Error getting session folder info:', error);
+            this.sendError(ws, `Failed to get session folder info: ${error}`);
+        }
+    }
+    async handleAuth(ws, token) {
+        if (this.authManager.validateToken(token)) {
+            const clientId = this.authManager.generateClientId();
+            this.clients.set(clientId, ws);
+            ws.clientId = clientId;
+            this.send(ws, {
+                type: 'auth_success',
+                data: { clientId }
+            });
+            logger_1.logger.info(`Client ${clientId} authenticated`);
+        }
+        else {
+            this.sendError(ws, 'Invalid token');
+            ws.close();
+        }
+    }
+    getClientId(ws) {
+        return ws.clientId || null;
+    }
+    broadcast(message) {
+        const data = JSON.stringify(message);
+        let count = 0;
+        this.clients.forEach((ws) => {
+            if (ws.readyState === ws_1.default.OPEN) {
+                ws.send(data);
+                count++;
+            }
+        });
+        if (count > 0) {
+            logger_1.logger.debug(`Broadcast to ${count} clients: ${message.type}`);
+        }
+    }
+    send(ws, message) {
+        if (ws.readyState === ws_1.default.OPEN) {
+            ws.send(JSON.stringify(message));
+        }
+    }
+    sendError(ws, error) {
+        this.send(ws, { type: 'error', error });
+    }
+    getClientCount() {
+        return this.clients.size;
+    }
+}
+exports.WebSocketServer = WebSocketServer;

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "renote-server",
+  "version": "1.0.1",
+  "description": "WebSocket server for Renote - mobile remote development client with Claude Code integration",
+  "main": "dist/index.js",
+  "bin": {
+    "renote-server": "dist/index.js"
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "dev": "nodemon --exec ts-node src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "prepublishOnly": "npm run build",
+    "postinstall": "cd node_modules/node-pty && npx node-gyp rebuild 2>/dev/null || true"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "chokidar": "^5.0.0",
+    "dotenv": "^17.2.3",
+    "express": "^5.2.1",
+    "node-pty": "^1.1.0",
+    "ssh2": "^1.17.0",
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.6",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.2.0",
+    "@types/ssh2": "^1.15.5",
+    "@types/ws": "^8.18.1",
+    "jest": "^30.2.0",
+    "nodemon": "^3.1.11",
+    "ts-jest": "^29.4.6",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "testMatch": [
+      "**/__tests__/**/*.test.ts"
+    ],
+    "collectCoverageFrom": [
+      "src/**/*.ts",
+      "!src/**/*.d.ts",
+      "!src/__tests__/**"
+    ],
+    "transformIgnorePatterns": [
+      "node_modules/(?!(chokidar)/)"
+    ],
+    "moduleNameMapper": {
+      "^chokidar$": "<rootDir>/node_modules/chokidar/index.js"
+    }
+  }
+}