renote-server 1.0.1

package/dist/git/gitHandler.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHandler = void 0;
+const logger_1 = require("../utils/logger");
+const gitService_1 = require("./gitService");
+/**
+ * Handles Git-related WebSocket messages.
+ * Routes git_* messages to GitService methods.
+ */
+class GitHandler {
+    constructor(sendFn) {
+        this.sendFn = sendFn;
+    }
+    canHandle(messageType) {
+        return messageType.startsWith('git_');
+    }
+    async handle(ws, clientId, message) {
+        switch (message.type) {
+            case 'git_status':
+                await this.handleStatus(ws, message);
+                break;
+            case 'git_file_diff':
+                await this.handleFileDiff(ws, message);
+                break;
+            case 'git_check_repo':
+                await this.handleCheckRepo(ws, message);
+                break;
+            default:
+                logger_1.logger.warn(`Unknown git message type: ${message.type}`);
+        }
+    }
+    async handleCheckRepo(ws, message) {
+        try {
+            const workingDir = message.path || process.cwd();
+            const isGitRepo = await gitService_1.gitService.isGitRepo(workingDir);
+            this.sendFn(ws, {
+                type: 'git_check_repo_response',
+                data: { isGitRepo },
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Git check repo error:', error);
+            this.sendFn(ws, {
+                type: 'git_check_repo_response',
+                data: { isGitRepo: false },
+                error: error.message,
+            });
+        }
+    }
+    async handleStatus(ws, message) {
+        try {
+            const workingDir = message.path || process.cwd();
+            const files = await gitService_1.gitService.getStatus(workingDir);
+            this.sendFn(ws, {
+                type: 'git_status_response',
+                data: { files },
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Git status error:', error);
+            this.sendFn(ws, {
+                type: 'error',
+                error: `Failed to get git status: ${error.message}`,
+            });
+        }
+    }
+    async handleFileDiff(ws, message) {
+        try {
+            const workingDir = message.path || process.cwd();
+            const { filePath, staged } = message;
+            logger_1.logger.info(`Git diff request: filePath=${filePath}, staged=${staged}, workingDir=${workingDir}`);
+            if (!filePath) {
+                this.sendFn(ws, {
+                    type: 'error',
+                    error: 'File path is required for git diff',
+                });
+                return;
+            }
+            const diff = await gitService_1.gitService.getFileDiff(workingDir, filePath, staged);
+            logger_1.logger.info(`Git diff result: ${diff.length} bytes`);
+            this.sendFn(ws, {
+                type: 'git_file_diff_response',
+                data: { filePath, diff },
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Git diff error:', error);
+            this.sendFn(ws, {
+                type: 'error',
+                error: `Failed to get diff: ${error.message}`,
+            });
+        }
+    }
+}
+exports.GitHandler = GitHandler;

package/dist/git/gitService.js

@@ -0,0 +1,237 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitService = exports.GitService = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const promises_1 = require("fs/promises");
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../utils/logger");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+/**
+ * Git service for executing git commands safely.
+ */
+class GitService {
+    /**
+     * Check if a directory is inside a git repository.
+     */
+    async isGitRepo(workingDir) {
+        try {
+            const { stdout } = await execFileAsync('git', ['rev-parse', '--is-inside-work-tree'], {
+                cwd: workingDir,
+            });
+            return stdout.trim() === 'true';
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get the root directory of the git repository.
+     */
+    async getRepoRoot(workingDir) {
+        try {
+            const { stdout } = await execFileAsync('git', ['rev-parse', '--show-toplevel'], {
+                cwd: workingDir,
+            });
+            return stdout.trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get git status for all changed files.
+     * Uses `git status --porcelain` for machine-parseable output.
+     */
+    async getStatus(workingDir) {
+        try {
+            // Use repo root so paths in output are consistent
+            const repoRoot = await this.getRepoRoot(workingDir);
+            const cwd = repoRoot || workingDir;
+            const { stdout } = await execFileAsync('git', ['status', '--porcelain', '-uall'], { cwd, maxBuffer: 10 * 1024 * 1024 });
+            if (!stdout.trim()) {
+                return [];
+            }
+            const files = [];
+            const lines = stdout.split('\n').filter(line => line.length > 0);
+            for (const line of lines) {
+                const parsed = this.parseStatusLine(line);
+                if (parsed) {
+                    files.push(parsed);
+                }
+            }
+            return files;
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to get git status:', error);
+            throw error;
+        }
+    }
+    /**
+     * Parse a single line of git status --porcelain output.
+     * Format: XY PATH or XY ORIG_PATH -> PATH (for renames)
+     */
+    parseStatusLine(line) {
+        if (line.length < 3)
+            return null;
+        const indexStatus = line[0];
+        const workTreeStatus = line[1];
+        const filePath = line.slice(3);
+        // Handle renames: "R  old -> new"
+        if (indexStatus === 'R' || workTreeStatus === 'R') {
+            const parts = filePath.split(' -> ');
+            if (parts.length === 2) {
+                return {
+                    path: parts[1],
+                    status: 'renamed',
+                    staged: indexStatus === 'R',
+                    oldPath: parts[0],
+                };
+            }
+        }
+        // Determine status based on index and work tree status
+        let status;
+        let staged = false;
+        // Prioritize staged changes for display
+        if (indexStatus === 'A') {
+            status = 'added';
+            staged = true;
+        }
+        else if (indexStatus === 'D') {
+            status = 'deleted';
+            staged = true;
+        }
+        else if (indexStatus === 'M') {
+            status = 'modified';
+            staged = true;
+        }
+        else if (workTreeStatus === 'M') {
+            status = 'modified';
+            staged = false;
+        }
+        else if (workTreeStatus === 'D') {
+            status = 'deleted';
+            staged = false;
+        }
+        else if (workTreeStatus === '?' || indexStatus === '?') {
+            status = 'untracked';
+            staged = false;
+        }
+        else if (workTreeStatus === 'A') {
+            status = 'added';
+            staged = false;
+        }
+        else {
+            // Fallback
+            status = 'modified';
+            staged = indexStatus !== ' ' && indexStatus !== '?';
+        }
+        return { path: filePath, status, staged };
+    }
+    /**
+     * Get diff for a specific file.
+     * Returns unified diff format.
+     *
+     * Strategy:
+     * - Untracked files (??) → generate synthetic diff from file content
+     * - New files (A) → use git diff --cached (compare with empty)
+     * - Other files → use git diff HEAD (shows all changes vs last commit)
+     */
+    async getFileDiff(workingDir, filePath, staged = false) {
+        try {
+            // Get the repo root to ensure correct path handling
+            const repoRoot = await this.getRepoRoot(workingDir);
+            const cwd = repoRoot || workingDir;
+            logger_1.logger.info(`getFileDiff: cwd=${cwd}, filePath=${filePath}`);
+            // Get the actual status of this file
+            const { stdout: statusOut } = await execFileAsync('git', ['status', '--porcelain', '--', filePath], { cwd });
+            const statusLine = statusOut.trim().split('\n')[0] || '';
+            const indexStatus = statusLine[0] || ' ';
+            const workTreeStatus = statusLine[1] || ' ';
+            logger_1.logger.info(`getFileDiff: status line="${statusLine}", index=${indexStatus}, worktree=${workTreeStatus}`);
+            // Case 1: Untracked file - generate diff from file content
+            if (indexStatus === '?' || workTreeStatus === '?') {
+                logger_1.logger.info('getFileDiff: untracked file, generating synthetic diff');
+                return this.getUntrackedFileDiff(cwd, filePath);
+            }
+            // Case 2: Newly added file (only in index, not in HEAD)
+            if (indexStatus === 'A') {
+                logger_1.logger.info('getFileDiff: new file, using --cached');
+                const { stdout } = await execFileAsync('git', ['diff', '--cached', '--', filePath], { cwd, maxBuffer: 10 * 1024 * 1024 });
+                if (stdout.trim()) {
+                    return stdout;
+                }
+                // Fallback: if --cached returns empty (shouldn't happen), show file content
+                return this.getUntrackedFileDiff(cwd, filePath);
+            }
+            // Case 3: Modified/Deleted files - use git diff HEAD to show all changes
+            // This captures both staged and unstaged changes relative to last commit
+            logger_1.logger.info('getFileDiff: tracked file, using diff HEAD');
+            const { stdout: headDiff } = await execFileAsync('git', ['diff', 'HEAD', '--', filePath], { cwd, maxBuffer: 10 * 1024 * 1024 });
+            if (headDiff.trim()) {
+                logger_1.logger.info(`getFileDiff: HEAD diff length=${headDiff.length}`);
+                return headDiff;
+            }
+            // Fallback: try regular diff (in case HEAD doesn't exist)
+            logger_1.logger.info('getFileDiff: HEAD diff empty, trying regular diff');
+            const { stdout: regularDiff } = await execFileAsync('git', ['diff', '--', filePath], { cwd, maxBuffer: 10 * 1024 * 1024 });
+            if (regularDiff.trim()) {
+                return regularDiff;
+            }
+            // Last resort: try --cached
+            logger_1.logger.info('getFileDiff: regular diff empty, trying --cached');
+            const { stdout: cachedDiff } = await execFileAsync('git', ['diff', '--cached', '--', filePath], { cwd, maxBuffer: 10 * 1024 * 1024 });
+            return cachedDiff;
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to get file diff:', error);
+            throw error;
+        }
+    }
+    /**
+     * Generate a diff-like output for an untracked file.
+     */
+    async getUntrackedFileDiff(workingDir, filePath) {
+        try {
+            const fullPath = path_1.default.join(workingDir, filePath);
+            // Check if file is binary
+            const isBinary = await this.isBinaryFile(fullPath);
+            if (isBinary) {
+                return `diff --git a/${filePath} b/${filePath}\nnew file mode 100644\nBinary file`;
+            }
+            // Read file content
+            const content = await (0, promises_1.readFile)(fullPath, 'utf-8');
+            const lines = content.split('\n');
+            const diffLines = [
+                `diff --git a/${filePath} b/${filePath}`,
+                'new file mode 100644',
+                '--- /dev/null',
+                `+++ b/${filePath}`,
+                `@@ -0,0 +1,${lines.length} @@`,
+                ...lines.map(line => `+${line}`),
+            ];
+            return diffLines.join('\n');
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to generate untracked file diff:', error);
+            throw error;
+        }
+    }
+    /**
+     * Check if a file is binary by looking at the first few bytes.
+     */
+    async isBinaryFile(filePath) {
+        try {
+            const { stdout } = await execFileAsync('file', ['--mime', filePath]);
+            return stdout.includes('charset=binary');
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.GitService = GitService;
+exports.gitService = new GitService();

package/dist/git/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHandler = exports.gitService = exports.GitService = void 0;
+var gitService_1 = require("./gitService");
+Object.defineProperty(exports, "GitService", { enumerable: true, get: function () { return gitService_1.GitService; } });
+Object.defineProperty(exports, "gitService", { enumerable: true, get: function () { return gitService_1.gitService; } });
+var gitHandler_1 = require("./gitHandler");
+Object.defineProperty(exports, "GitHandler", { enumerable: true, get: function () { return gitHandler_1.GitHandler; } });

package/dist/http/server.js

@@ -0,0 +1,28 @@
+"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 config_1 = require("../config");
+const logger_1 = require("../utils/logger");
+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 });
+    });
+    const httpPort = config_1.CONFIG.port + 1;
+    app.listen(httpPort, () => {
+        logger_1.logger.info(`HTTP server running on port ${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;