cloudforge-agent 0.1.0

package/dist/websocket.js

@@ -0,0 +1,695 @@
+/**
+ * CloudForge Agent WebSocket Manager
+ * Handles connection to CloudForge server
+ */
+import { io } from 'socket.io-client';
+import * as os from 'os';
+import chalk from 'chalk';
+import { getSystemInfo, VERSION } from './config.js';
+export class WebSocketManager {
+    socket = null;
+    config;
+    terminalManager;
+    fileManager;
+    gitManager;
+    reconnectAttempts = 0;
+    heartbeatTimer = null;
+    isConnected = false;
+    constructor(config, terminalManager, fileManager, gitManager) {
+        this.config = config;
+        this.terminalManager = terminalManager;
+        this.fileManager = fileManager;
+        this.gitManager = gitManager;
+    }
+    /**
+     * Connect to CloudForge server
+     */
+    async connect() {
+        return new Promise((resolve, reject) => {
+            const socketUrl = `${this.config.serverUrl}/agent`;
+            this.socket = io(socketUrl, {
+                auth: {
+                    token: this.config.token,
+                },
+                transports: ['websocket', 'polling'],
+                reconnection: true,
+                reconnectionAttempts: Infinity,
+                reconnectionDelay: this.config.reconnectDelay,
+                reconnectionDelayMax: this.config.maxReconnectDelay,
+                timeout: 20000,
+            });
+            // Connection events
+            this.socket.on('connect', () => {
+                this.isConnected = true;
+                this.reconnectAttempts = 0;
+                console.log(chalk.green('Connected to CloudForge!'));
+                // Send system info
+                this.sendSystemInfo();
+                // Start heartbeat
+                this.startHeartbeat();
+                resolve();
+            });
+            this.socket.on('connect_error', (err) => {
+                if (this.reconnectAttempts === 0) {
+                    console.error(chalk.red('Connection failed:'), err.message);
+                }
+                this.reconnectAttempts++;
+                if (this.reconnectAttempts >= 5 && !this.isConnected) {
+                    reject(new Error(`Failed to connect after ${this.reconnectAttempts} attempts: ${err.message}`));
+                }
+            });
+            this.socket.on('disconnect', (reason) => {
+                this.isConnected = false;
+                this.stopHeartbeat();
+                console.log(chalk.yellow('Disconnected:'), reason);
+                if (reason === 'io server disconnect') {
+                    // Server disconnected us, try to reconnect
+                    console.log(chalk.yellow('Server disconnected. Reconnecting...'));
+                    this.socket?.connect();
+                }
+            });
+            this.socket.on('reconnect', (attemptNumber) => {
+                console.log(chalk.green(`Reconnected after ${attemptNumber} attempts`));
+                this.sendSystemInfo();
+                this.startHeartbeat();
+            });
+            this.socket.on('reconnect_attempt', (attemptNumber) => {
+                if (this.config.debug) {
+                    console.log(chalk.gray(`Reconnect attempt ${attemptNumber}...`));
+                }
+            });
+            this.socket.on('error', (err) => {
+                console.error(chalk.red('Socket error:'), err);
+            });
+            // Terminal events from server
+            this.setupTerminalHandlers();
+            // File events from server
+            this.setupFileHandlers();
+            // Git events from server
+            this.setupGitHandlers();
+        });
+    }
+    /**
+     * Setup terminal event handlers
+     */
+    setupTerminalHandlers() {
+        if (!this.socket)
+            return;
+        // Spawn terminal request
+        this.socket.on('terminal:spawn', (msg) => {
+            if (this.config.debug) {
+                console.log(chalk.gray(`Terminal spawn request: ${msg.sessionId}`));
+            }
+            // Resolve cwd: use provided cwd, or fall back to homeDir
+            let cwd = this.config.homeDir;
+            if (msg.cwd) {
+                let expanded = msg.cwd;
+                if (expanded === '~' || expanded.startsWith('~/')) {
+                    expanded = expanded.replace('~', os.homedir());
+                }
+                cwd = expanded;
+            }
+            try {
+                const session = this.terminalManager.spawn(msg.sessionId, msg.shell || this.config.shell, msg.cols || 80, msg.rows || 24, cwd);
+                // Forward output to server
+                session.onData((data) => {
+                    this.socket?.emit('terminal:output', {
+                        type: 'terminal:output',
+                        sessionId: msg.sessionId,
+                        data,
+                    });
+                });
+                // Forward exit to server
+                session.onExit((exitCode) => {
+                    this.socket?.emit('terminal:closed', {
+                        type: 'terminal:closed',
+                        sessionId: msg.sessionId,
+                        exitCode,
+                    });
+                    this.terminalManager.remove(msg.sessionId);
+                });
+            }
+            catch (err) {
+                console.error(chalk.red('Terminal spawn error:'), err);
+                this.socket?.emit('terminal:error', {
+                    type: 'terminal:error',
+                    sessionId: msg.sessionId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        });
+        // Terminal input from server
+        this.socket.on('terminal:input', (msg) => {
+            if (this.config.debug) {
+                console.log(chalk.gray(`Terminal input: sessionId=${msg.sessionId}, data length=${msg.data.length}`));
+            }
+            const session = this.terminalManager.get(msg.sessionId);
+            if (session) {
+                session.write(msg.data);
+            }
+            else {
+                console.warn(chalk.yellow(`No terminal session found for: ${msg.sessionId}`));
+                console.warn(chalk.yellow(`Available sessions: ${this.terminalManager.sessionIds.join(', ')}`));
+            }
+        });
+        // Terminal resize from server
+        this.socket.on('terminal:resize', (msg) => {
+            const session = this.terminalManager.get(msg.sessionId);
+            if (session) {
+                session.resize(msg.cols, msg.rows);
+            }
+        });
+        // Terminal kill from server
+        this.socket.on('terminal:kill', (msg) => {
+            this.terminalManager.kill(msg.sessionId);
+        });
+        // Get terminal cwd
+        this.socket.on('terminal:getcwd', async (msg) => {
+            const cwd = await this.terminalManager.getCwd(msg.sessionId);
+            if (cwd) {
+                this.socket?.emit('terminal:cwd', {
+                    type: 'terminal:cwd',
+                    sessionId: msg.sessionId,
+                    cwd,
+                });
+            }
+        });
+    }
+    /**
+     * Setup file event handlers
+     */
+    setupFileHandlers() {
+        if (!this.socket)
+            return;
+        // List directory
+        this.socket.on('files:list', async (msg) => {
+            if (this.config.debug) {
+                console.log(chalk.gray(`Files list request: ${msg.path}`));
+            }
+            try {
+                const entries = await this.fileManager.list(msg.path);
+                this.socket?.emit('files:list:response', {
+                    type: 'files:list:response',
+                    requestId: msg.requestId,
+                    path: msg.path,
+                    entries,
+                    success: true,
+                });
+            }
+            catch (err) {
+                console.error(chalk.red('Files list error:'), err);
+                this.socket?.emit('files:list:response', {
+                    type: 'files:list:response',
+                    requestId: msg.requestId,
+                    path: msg.path,
+                    entries: [],
+                    success: false,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        });
+        // Read file
+        this.socket.on('file:read', async (msg) => {
+            if (this.config.debug) {
+                console.log(chalk.gray(`File read request: ${msg.path}`));
+            }
+            try {
+                const result = await this.fileManager.read(msg.path);
+                this.socket?.emit('file:read:response', {
+                    type: 'file:read:response',
+                    requestId: msg.requestId,
+                    ...result,
+                    success: true,
+                });
+            }
+            catch (err) {
+                console.error(chalk.red('File read error:'), err);
+                this.socket?.emit('file:read:response', {
+                    type: 'file:read:response',
+                    requestId: msg.requestId,
+                    path: msg.path,
+                    content: '',
+                    encoding: 'utf8',
+                    size: 0,
+                    isBinary: false,
+                    success: false,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        });
+        // Write file
+        this.socket.on('file:write', async (msg) => {
+            if (this.config.debug) {
+                console.log(chalk.gray(`File write request: ${msg.path}`));
+            }
+            try {
+                const result = await this.fileManager.write(msg.path, msg.content, msg.encoding || 'utf8');
+                this.socket?.emit('file:write:response', {
+                    type: 'file:write:response',
+                    requestId: msg.requestId,
+                    ...result,
+                });
+            }
+            catch (err) {
+                console.error(chalk.red('File write error:'), err);
+                this.socket?.emit('file:write:response', {
+                    type: 'file:write:response',
+                    requestId: msg.requestId,
+                    path: msg.path,
+                    success: false,
+                    bytesWritten: 0,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        });
+        // Delete file/directory
+        this.socket.on('file:delete', async (msg) => {
+            if (this.config.debug) {
+                console.log(chalk.gray(`File delete request: ${msg.path}`));
+            }
+            try {
+                const result = await this.fileManager.delete(msg.path, msg.recursive);
+                this.socket?.emit('file:delete:response', {
+                    type: 'file:delete:response',
+                    requestId: msg.requestId,
+                    ...result,
+                });
+            }
+            catch (err) {
+                console.error(chalk.red('File delete error:'), err);
+                this.socket?.emit('file:delete:response', {
+                    type: 'file:delete:response',
+                    requestId: msg.requestId,
+                    path: msg.path,
+                    success: false,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        });
+        // Create directory
+        this.socket.on('file:mkdir', async (msg) => {
+            if (this.config.debug) {
+                console.log(chalk.gray(`Mkdir request: ${msg.path}`));
+            }
+            try {
+                const result = await this.fileManager.mkdir(msg.path, msg.recursive);
+                this.socket?.emit('file:mkdir:response', {
+                    type: 'file:mkdir:response',
+                    requestId: msg.requestId,
+                    ...result,
+                });
+            }
+            catch (err) {
+                console.error(chalk.red('Mkdir error:'), err);
+                this.socket?.emit('file:mkdir:response', {
+                    type: 'file:mkdir:response',
+                    requestId: msg.requestId,
+                    path: msg.path,
+                    success: false,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        });
+        // Rename/move file
+        this.socket.on('file:rename', async (msg) => {
+            if (this.config.debug) {
+                console.log(chalk.gray(`Rename request: ${msg.fromPath} -> ${msg.toPath}`));
+            }
+            try {
+                const result = await this.fileManager.rename(msg.fromPath, msg.toPath);
+                this.socket?.emit('file:rename:response', {
+                    type: 'file:rename:response',
+                    requestId: msg.requestId,
+                    fromPath: msg.fromPath,
+                    ...result,
+                });
+            }
+            catch (err) {
+                console.error(chalk.red('Rename error:'), err);
+                this.socket?.emit('file:rename:response', {
+                    type: 'file:rename:response',
+                    requestId: msg.requestId,
+                    fromPath: msg.fromPath,
+                    path: msg.toPath,
+                    success: false,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        });
+        // Stat file/directory
+        this.socket.on('file:stat', async (msg) => {
+            if (this.config.debug) {
+                console.log(chalk.gray(`Stat request: ${msg.path}`));
+            }
+            try {
+                const entry = await this.fileManager.stat(msg.path);
+                this.socket?.emit('file:stat:response', {
+                    type: 'file:stat:response',
+                    requestId: msg.requestId,
+                    path: msg.path,
+                    entry,
+                    success: entry !== null,
+                    error: entry === null ? 'File not found' : undefined,
+                });
+            }
+            catch (err) {
+                console.error(chalk.red('Stat error:'), err);
+                this.socket?.emit('file:stat:response', {
+                    type: 'file:stat:response',
+                    requestId: msg.requestId,
+                    path: msg.path,
+                    entry: null,
+                    success: false,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        });
+    }
+    /**
+     * Resolve git cwd - handles ~ expansion and field name compatibility
+     */
+    resolveGitCwd(msg) {
+        let cwd = msg.cwd || msg.path || os.homedir();
+        if (cwd === '~' || cwd.startsWith('~/')) {
+            cwd = cwd.replace('~', os.homedir());
+        }
+        return cwd;
+    }
+    /**
+     * Setup Git event handlers
+     */
+    setupGitHandlers() {
+        if (!this.socket)
+            return;
+        // Git status
+        this.socket.on('git:status', async (msg) => {
+            const cwd = this.resolveGitCwd(msg);
+            if (this.config.debug) {
+                console.log(chalk.gray(`Git status request: ${cwd}`));
+            }
+            try {
+                const status = await this.gitManager.status(cwd);
+                this.socket?.emit('git:status:response', {
+                    type: 'git:status:response',
+                    requestId: msg.requestId,
+                    status,
+                    success: true,
+                });
+            }
+            catch (err) {
+                console.error(chalk.red('Git status error:'), err);
+                this.socket?.emit('git:status:response', {
+                    type: 'git:status:response',
+                    requestId: msg.requestId,
+                    status: null,
+                    success: false,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        });
+        // Git add (stage files)
+        this.socket.on('git:add', async (msg) => {
+            const cwd = this.resolveGitCwd(msg);
+            if (this.config.debug) {
+                console.log(chalk.gray(`Git add request: ${msg.files.join(', ')}`));
+            }
+            try {
+                const result = await this.gitManager.add(cwd, msg.files);
+                this.socket?.emit('git:add:response', {
+                    type: 'git:add:response',
+                    requestId: msg.requestId,
+                    ...result,
+                });
+            }
+            catch (err) {
+                console.error(chalk.red('Git add error:'), err);
+                this.socket?.emit('git:add:response', {
+                    type: 'git:add:response',
+                    requestId: msg.requestId,
+                    success: false,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        });
+        // Git reset (unstage files)
+        this.socket.on('git:reset', async (msg) => {
+            const cwd = this.resolveGitCwd(msg);
+            if (this.config.debug) {
+                console.log(chalk.gray(`Git reset request: ${msg.files.join(', ')}`));
+            }
+            try {
+                const result = await this.gitManager.reset(cwd, msg.files);
+                this.socket?.emit('git:reset:response', {
+                    type: 'git:reset:response',
+                    requestId: msg.requestId,
+                    ...result,
+                });
+            }
+            catch (err) {
+                console.error(chalk.red('Git reset error:'), err);
+                this.socket?.emit('git:reset:response', {
+                    type: 'git:reset:response',
+                    requestId: msg.requestId,
+                    success: false,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        });
+        // Git commit
+        this.socket.on('git:commit', async (msg) => {
+            const cwd = this.resolveGitCwd(msg);
+            if (this.config.debug) {
+                console.log(chalk.gray(`Git commit request: ${msg.message}`));
+            }
+            try {
+                const result = await this.gitManager.commit(cwd, msg.message);
+                this.socket?.emit('git:commit:response', {
+                    type: 'git:commit:response',
+                    requestId: msg.requestId,
+                    ...result,
+                });
+            }
+            catch (err) {
+                console.error(chalk.red('Git commit error:'), err);
+                this.socket?.emit('git:commit:response', {
+                    type: 'git:commit:response',
+                    requestId: msg.requestId,
+                    success: false,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        });
+        // Git pull
+        this.socket.on('git:pull', async (msg) => {
+            const cwd = this.resolveGitCwd(msg);
+            if (this.config.debug) {
+                console.log(chalk.gray('Git pull request'));
+            }
+            try {
+                const result = await this.gitManager.pull(cwd);
+                this.socket?.emit('git:pull:response', {
+                    type: 'git:pull:response',
+                    requestId: msg.requestId,
+                    ...result,
+                });
+            }
+            catch (err) {
+                console.error(chalk.red('Git pull error:'), err);
+                this.socket?.emit('git:pull:response', {
+                    type: 'git:pull:response',
+                    requestId: msg.requestId,
+                    success: false,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        });
+        // Git push
+        this.socket.on('git:push', async (msg) => {
+            const cwd = this.resolveGitCwd(msg);
+            if (this.config.debug) {
+                console.log(chalk.gray('Git push request'));
+            }
+            try {
+                const result = await this.gitManager.push(cwd);
+                this.socket?.emit('git:push:response', {
+                    type: 'git:push:response',
+                    requestId: msg.requestId,
+                    ...result,
+                });
+            }
+            catch (err) {
+                console.error(chalk.red('Git push error:'), err);
+                this.socket?.emit('git:push:response', {
+                    type: 'git:push:response',
+                    requestId: msg.requestId,
+                    success: false,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        });
+        // Git diff
+        this.socket.on('git:diff', async (msg) => {
+            const cwd = this.resolveGitCwd(msg);
+            if (this.config.debug) {
+                console.log(chalk.gray(`Git diff request: ${msg.file || 'all'}`));
+            }
+            try {
+                const diff = await this.gitManager.diff(cwd, msg.file, msg.staged);
+                this.socket?.emit('git:diff:response', {
+                    type: 'git:diff:response',
+                    requestId: msg.requestId,
+                    diff,
+                    success: true,
+                });
+            }
+            catch (err) {
+                console.error(chalk.red('Git diff error:'), err);
+                this.socket?.emit('git:diff:response', {
+                    type: 'git:diff:response',
+                    requestId: msg.requestId,
+                    diff: null,
+                    success: false,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        });
+        // Git log
+        this.socket.on('git:log', async (msg) => {
+            const cwd = this.resolveGitCwd(msg);
+            if (this.config.debug) {
+                console.log(chalk.gray(`Git log request: limit=${msg.limit || 20}`));
+            }
+            try {
+                const logs = await this.gitManager.log(cwd, msg.limit);
+                this.socket?.emit('git:log:response', {
+                    type: 'git:log:response',
+                    requestId: msg.requestId,
+                    logs,
+                    success: true,
+                });
+            }
+            catch (err) {
+                console.error(chalk.red('Git log error:'), err);
+                this.socket?.emit('git:log:response', {
+                    type: 'git:log:response',
+                    requestId: msg.requestId,
+                    logs: [],
+                    success: false,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        });
+        // Git branches
+        this.socket.on('git:branches', async (msg) => {
+            const cwd = this.resolveGitCwd(msg);
+            if (this.config.debug) {
+                console.log(chalk.gray('Git branches request'));
+            }
+            try {
+                const result = await this.gitManager.branches(cwd);
+                this.socket?.emit('git:branches:response', {
+                    type: 'git:branches:response',
+                    requestId: msg.requestId,
+                    ...result,
+                    success: true,
+                });
+            }
+            catch (err) {
+                console.error(chalk.red('Git branches error:'), err);
+                this.socket?.emit('git:branches:response', {
+                    type: 'git:branches:response',
+                    requestId: msg.requestId,
+                    current: '',
+                    branches: [],
+                    success: false,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        });
+        // Git checkout (discard changes)
+        this.socket.on('git:checkout', async (msg) => {
+            const cwd = this.resolveGitCwd(msg);
+            if (this.config.debug) {
+                console.log(chalk.gray(`Git checkout request: ${msg.files.join(', ')}`));
+            }
+            try {
+                const result = await this.gitManager.checkout(cwd, msg.files);
+                this.socket?.emit('git:checkout:response', {
+                    type: 'git:checkout:response',
+                    requestId: msg.requestId,
+                    ...result,
+                });
+            }
+            catch (err) {
+                console.error(chalk.red('Git checkout error:'), err);
+                this.socket?.emit('git:checkout:response', {
+                    type: 'git:checkout:response',
+                    requestId: msg.requestId,
+                    success: false,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        });
+    }
+    /**
+     * Send system info to server
+     */
+    sendSystemInfo() {
+        const systemInfo = getSystemInfo();
+        this.socket?.emit('system:info', {
+            type: 'system:info',
+            os: systemInfo.os,
+            hostname: systemInfo.hostname,
+            version: VERSION,
+            shell: systemInfo.shell,
+            homeDir: systemInfo.homeDir,
+        });
+    }
+    /**
+     * Start heartbeat timer
+     */
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            if (!this.isConnected)
+                return;
+            const systemInfo = getSystemInfo();
+            this.socket?.emit('heartbeat', {
+                type: 'heartbeat',
+                timestamp: Date.now(),
+                os: systemInfo.os,
+                hostname: systemInfo.hostname,
+                version: VERSION,
+                uptime: process.uptime(),
+            });
+            if (this.config.debug) {
+                console.log(chalk.gray('Heartbeat sent'));
+            }
+        }, this.config.heartbeatInterval);
+    }
+    /**
+     * Stop heartbeat timer
+     */
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    /**
+     * Disconnect from server
+     */
+    disconnect() {
+        this.stopHeartbeat();
+        this.socket?.disconnect();
+        this.socket = null;
+        this.isConnected = false;
+    }
+    /**
+     * Check if connected
+     */
+    get connected() {
+        return this.isConnected;
+    }
+}
+//# sourceMappingURL=websocket.js.map