renote-server 1.0.1 → 1.0.3

package/dist/claude/chatService.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeChatService = void 0;
+const child_process_1 = require("child_process");
+const logger_1 = require("../utils/logger");
+class ClaudeChatService {
+    constructor() {
+        // 存储正在运行的进程，按 sessionId 索引
+        this.runningProcesses = new Map();
+    }
+    /**
+     * 发送消息给 Claude CLI
+     * 使用 -p (print) 模式，消息通过 stdin 传入，响应通过 jsonl 文件监听获取
+     */
+    async sendMessage(options) {
+        const { workspaceDirName, sessionId, newSessionId, message, cwd, allowedTools } = options;
+        // 确定实际使用的 sessionId
+        const effectiveSessionId = sessionId || newSessionId;
+        // 检查该会话是否已有进程在运行
+        if (effectiveSessionId && this.runningProcesses.has(effectiveSessionId)) {
+            return {
+                success: false,
+                error: 'A message is already being processed for this session',
+                sessionId: effectiveSessionId,
+            };
+        }
+        const args = ['-p'];
+        // 恢复现有会话
+        if (sessionId) {
+            args.push('--resume', sessionId);
+        }
+        // 新建会话并指定 ID
+        else if (newSessionId) {
+            args.push('--session-id', newSessionId);
+        }
+        // 添加允许的工具参数
+        if (allowedTools && allowedTools.length > 0) {
+            args.push('--allowedTools', allowedTools.join(','));
+        }
+        logger_1.logger.info(`[ChatService] Sending message to Claude CLI`);
+        logger_1.logger.info(`[ChatService] Args: ${args.join(' ')}`);
+        logger_1.logger.info(`[ChatService] CWD: ${cwd || 'default'}`);
+        logger_1.logger.info(`[ChatService] Message length: ${message.length}`);
+        if (allowedTools && allowedTools.length > 0) {
+            logger_1.logger.info(`[ChatService] Allowed tools: ${allowedTools.join(', ')}`);
+        }
+        return new Promise((resolve) => {
+            const proc = (0, child_process_1.spawn)('claude', args, {
+                cwd: cwd || process.cwd(),
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: {
+                    ...process.env,
+                    // 确保 Claude CLI 不会等待用户输入
+                    TERM: 'dumb',
+                },
+            });
+            // 记录进程
+            if (effectiveSessionId) {
+                this.runningProcesses.set(effectiveSessionId, proc);
+            }
+            // 写入消息到 stdin
+            proc.stdin.write(message);
+            proc.stdin.end();
+            // 收集输出（主要用于错误检测）
+            let stdout = '';
+            let stderr = '';
+            proc.stdout.on('data', (data) => {
+                stdout += data.toString();
+                // 可以选择性地记录 stdout，但主要响应通过 jsonl 监听获取
+                logger_1.logger.debug(`[ChatService] stdout: ${data.toString().substring(0, 200)}...`);
+            });
+            proc.stderr.on('data', (data) => {
+                stderr += data.toString();
+                logger_1.logger.warn(`[ChatService] stderr: ${data.toString()}`);
+            });
+            proc.on('close', (code) => {
+                // 移除进程记录
+                if (effectiveSessionId) {
+                    this.runningProcesses.delete(effectiveSessionId);
+                }
+                if (code === 0) {
+                    logger_1.logger.info(`[ChatService] Claude CLI completed successfully`);
+                    resolve({
+                        success: true,
+                        sessionId: effectiveSessionId,
+                    });
+                }
+                else {
+                    logger_1.logger.error(`[ChatService] Claude CLI exited with code ${code}`);
+                    resolve({
+                        success: false,
+                        error: stderr || `Exit code: ${code}`,
+                        sessionId: effectiveSessionId,
+                    });
+                }
+            });
+            proc.on('error', (err) => {
+                // 移除进程记录
+                if (effectiveSessionId) {
+                    this.runningProcesses.delete(effectiveSessionId);
+                }
+                logger_1.logger.error(`[ChatService] Failed to spawn Claude CLI:`, err);
+                resolve({
+                    success: false,
+                    error: err.message,
+                    sessionId: effectiveSessionId,
+                });
+            });
+        });
+    }
+    /**
+     * 检查指定会话是否有正在进行的消息处理
+     */
+    isProcessing(sessionId) {
+        return this.runningProcesses.has(sessionId);
+    }
+    /**
+     * 取消正在进行的消息处理
+     */
+    cancelMessage(sessionId) {
+        const proc = this.runningProcesses.get(sessionId);
+        if (proc) {
+            proc.kill('SIGTERM');
+            this.runningProcesses.delete(sessionId);
+            logger_1.logger.info(`[ChatService] Cancelled message processing for session ${sessionId}`);
+            return true;
+        }
+        return false;
+    }
+}
+exports.claudeChatService = new ClaudeChatService();

package/dist/config.js

@@ -4,13 +4,36 @@ exports.CONFIG = void 0;
 const dotenv_1 = require("dotenv");
 const os_1 = require("os");
 (0, dotenv_1.config)();
+/**
+ * Parse CLI arguments: --port, --host, --token, --claude-home
+ * These take precedence over environment variables.
+ */
+function parseArgs() {
+    const args = {};
+    const argv = process.argv.slice(2);
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg.startsWith('--') && i + 1 < argv.length && !argv[i + 1].startsWith('--')) {
+            const key = arg.slice(2);
+            args[key] = argv[i + 1];
+            i++;
+        }
+        else if (arg.startsWith('--') && arg.includes('=')) {
+            const [key, value] = arg.slice(2).split('=');
+            args[key] = value;
+        }
+    }
+    return args;
+}
+const args = parseArgs();
 exports.CONFIG = {
-    port: parseInt(process.env.PORT || '8080'),
-    authToken: process.env.AUTH_TOKEN || '',
-    claudeHome: process.env.CLAUDE_HOME || `${(0, os_1.homedir)()}/.claude`,
+    host: args['host'] || process.env.HOST || '0.0.0.0',
+    port: parseInt(args['port'] || process.env.PORT || '9080'),
+    authToken: args['token'] || process.env.AUTH_TOKEN || '',
+    claudeHome: args['claude-home'] || process.env.CLAUDE_HOME || `${(0, os_1.homedir)()}/.claude`,
     maxFileSize: parseInt(process.env.MAX_FILE_SIZE || '10485760'),
     searchTimeout: parseInt(process.env.SEARCH_TIMEOUT || '5000'),
-    logLevel: process.env.LOG_LEVEL || 'info',
+    logLevel: args['log-level'] || process.env.LOG_LEVEL || 'info',
 };
 if (!exports.CONFIG.authToken) {
     console.warn('WARNING: AUTH_TOKEN not set. Generate: openssl rand -hex 32');

package/dist/http/server.js

@@ -21,8 +21,8 @@ function createHttpServer() {
         res.json({ token: config_1.CONFIG.authToken });
     });
     const httpPort = config_1.CONFIG.port + 1;
-    app.listen(httpPort, () => {
-        logger_1.logger.info(`HTTP server running on port ${httpPort}`);
+    app.listen(httpPort, config_1.CONFIG.host, () => {
+        logger_1.logger.info(`HTTP server running on ${config_1.CONFIG.host}:${httpPort}`);
     });
     return app;
 }

package/dist/terminal/terminalWebSocket.js

@@ -38,6 +38,8 @@ class TerminalWebSocketHandler {
             const type = (url.searchParams.get('type') || 'shell');
             const cols = parseInt(url.searchParams.get('cols') || '80', 10);
             const rows = parseInt(url.searchParams.get('rows') || '24', 10);
+            const claudeArgsParam = url.searchParams.get('claudeArgs');
+            const cwd = url.searchParams.get('cwd') || undefined;
             // Validate token
             if (!this.authManager.validateToken(token)) {
                 logger_1.logger.warn('Terminal WebSocket: invalid token');
@@ -54,7 +56,13 @@ class TerminalWebSocketHandler {
             this.wsToSession.set(ws, { clientId, sessionId });
             logger_1.logger.info(`Terminal WebSocket connected: clientId=${clientId}, sessionId=${sessionId}, type=${type}, ${cols}x${rows}`);
             const connection = localTerminalManager_1.localTerminalManager.getOrCreateConnection(clientId);
-            const options = { type, cols, rows };
+            const options = {
+                type,
+                cols,
+                rows,
+                cwd,
+                claudeArgs: claudeArgsParam ? JSON.parse(decodeURIComponent(claudeArgsParam)) : undefined,
+            };
             const success = connection.startTerminal(sessionId, (data) => {
                 // Send terminal output as text frame
                 if (ws.readyState === ws_1.default.OPEN) {

package/dist/websocket/server.js

@@ -16,6 +16,7 @@ const sessionBrowser_1 = require("../claude/sessionBrowser");
 const terminal_1 = require("../terminal");
 const git_1 = require("../git");
 const terminalWebSocket_1 = require("../terminal/terminalWebSocket");
+const chatService_1 = require("../claude/chatService");
 class WebSocketServer {
     constructor() {
         this.clients = new Map();
@@ -27,51 +28,60 @@ class WebSocketServer {
         this.gitHandler = new git_1.GitHandler(this.send.bind(this));
         // Handle HTTP upgrade requests
         server.on('upgrade', (request, socket, head) => {
+            const clientIp = request.socket.remoteAddress;
+            const clientPort = request.socket.remotePort;
+            logger_1.logger.info(`[WS Upgrade] Request from ${clientIp}:${clientPort}, URL: ${request.url}`);
             // Route /terminal to terminal direct WebSocket handler
             if (terminalWebSocket_1.terminalWebSocketHandler.shouldHandle(request)) {
+                logger_1.logger.info(`[WS Upgrade] Routing to terminal handler`);
                 const terminalWss = new ws_1.default.Server({ noServer: true });
                 terminalWss.handleUpgrade(request, socket, head, (ws) => {
+                    logger_1.logger.info(`[WS Upgrade] Terminal upgrade complete`);
                     terminalWebSocket_1.terminalWebSocketHandler.handleConnection(ws, request);
                 });
             }
             else {
                 // Default: main WebSocket for JSON-RPC style messages
+                logger_1.logger.info(`[WS Upgrade] Routing to main handler`);
                 this.wss.handleUpgrade(request, socket, head, (ws) => {
+                    logger_1.logger.info(`[WS Upgrade] Main upgrade complete`);
                     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`);
+        server.listen(config_1.CONFIG.port, config_1.CONFIG.host, () => {
+            logger_1.logger.info(`WebSocket server running on ${config_1.CONFIG.host}:${config_1.CONFIG.port}`);
+            logger_1.logger.info(`  - Main API: ws://${config_1.CONFIG.host}:${config_1.CONFIG.port}/`);
+            logger_1.logger.info(`  - Terminal direct: ws://${config_1.CONFIG.host}:${config_1.CONFIG.port}/terminal`);
         });
     }
     setupWebSocket() {
-        this.wss.on('connection', (ws) => {
-            logger_1.logger.info('New client connection attempt');
+        this.wss.on('connection', (ws, request) => {
+            const clientIp = request?.socket?.remoteAddress || 'unknown';
+            logger_1.logger.info(`[WS Connection] New client from ${clientIp}`);
             ws.on('message', async (data) => {
                 try {
                     const message = JSON.parse(data.toString());
+                    logger_1.logger.info(`[WS Message] Type: ${message.type}, from ${clientIp}`);
                     await this.handleMessage(ws, message);
                 }
                 catch (error) {
-                    logger_1.logger.error('Error parsing message:', error);
+                    logger_1.logger.error(`[WS Message] Parse error from ${clientIp}:`, error);
                     this.sendError(ws, 'Invalid message format');
                 }
             });
-            ws.on('close', () => {
+            ws.on('close', (code, reason) => {
                 const clientId = this.getClientId(ws);
+                logger_1.logger.info(`[WS Close] Client ${clientId || 'unknown'} closed with code ${code}, reason: ${reason?.toString() || 'none'}`);
                 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);
+                logger_1.logger.error('[WS Error]:', error);
             });
         });
     }
@@ -126,6 +136,9 @@ class WebSocketServer {
             case 'get_session_folder_info':
                 await this.handleGetSessionFolderInfo(ws, message);
                 break;
+            case 'send_claude_message':
+                await this.handleSendClaudeMessage(ws, message);
+                break;
             default:
                 const clientId = this.getClientId(ws);
                 if (!clientId) {
@@ -465,7 +478,58 @@ class WebSocketServer {
             this.sendError(ws, `Failed to get session folder info: ${error}`);
         }
     }
+    async handleSendClaudeMessage(ws, message) {
+        const clientId = this.getClientId(ws);
+        if (!clientId) {
+            this.sendError(ws, 'Not authenticated');
+            return;
+        }
+        try {
+            const { data } = message;
+            if (!data || !data.workspaceDirName || !data.message) {
+                this.sendError(ws, 'workspaceDirName and message are required');
+                return;
+            }
+            const { workspaceDirName, sessionId, newSessionId, message: userMessage, allowedTools } = data;
+            // 解码 workspaceDirName 为实际路径
+            const cwd = '/' + workspaceDirName.replace(/-/g, '/');
+            logger_1.logger.info(`[SendClaudeMessage] Sending message to Claude CLI`);
+            logger_1.logger.info(`[SendClaudeMessage] CWD: ${cwd}`);
+            logger_1.logger.info(`[SendClaudeMessage] SessionId: ${sessionId || 'none'}`);
+            logger_1.logger.info(`[SendClaudeMessage] NewSessionId: ${newSessionId || 'none'}`);
+            if (allowedTools && allowedTools.length > 0) {
+                logger_1.logger.info(`[SendClaudeMessage] AllowedTools: ${allowedTools.join(', ')}`);
+            }
+            // 调用 chatService 发送消息
+            const result = await chatService_1.claudeChatService.sendMessage({
+                workspaceDirName,
+                sessionId,
+                newSessionId,
+                message: userMessage,
+                cwd,
+                allowedTools,
+            });
+            // 响应客户端
+            this.send(ws, {
+                type: 'send_claude_message_response',
+                data: {
+                    success: result.success,
+                    error: result.error,
+                    sessionId: result.sessionId,
+                },
+            });
+            // 如果成功，响应会通过现有的 watchSession 机制推送
+            if (result.success) {
+                logger_1.logger.info(`[SendClaudeMessage] Message sent successfully, responses will be pushed via watchSession`);
+            }
+        }
+        catch (error) {
+            logger_1.logger.error('Error sending Claude message:', error);
+            this.sendError(ws, `Failed to send message: ${error}`);
+        }
+    }
     async handleAuth(ws, token) {
+        logger_1.logger.info(`[Auth] Validating token: "${token ? '***' : '(empty)'}"`);
         if (this.authManager.validateToken(token)) {
             const clientId = this.authManager.generateClientId();
             this.clients.set(clientId, ws);
@@ -474,9 +538,10 @@ class WebSocketServer {
                 type: 'auth_success',
                 data: { clientId }
             });
-            logger_1.logger.info(`Client ${clientId} authenticated`);
+            logger_1.logger.info(`[Auth] Client ${clientId} authenticated successfully`);
         }
         else {
+            logger_1.logger.warn(`[Auth] Invalid token rejected`);
             this.sendError(ws, 'Invalid token');
             ws.close();
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "renote-server",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "WebSocket server for Renote - mobile remote development client with Claude Code integration",
   "main": "dist/index.js",
   "bin": {