@wonderwhy-er/desktop-commander 0.2.29-alpha.1 → 0.2.29-alpha.3

package/dist/remote-client.d.ts

@@ -0,0 +1,44 @@
+export interface RemoteClientConfig {
+    serverUrl: string;
+    deviceToken: string;
+    retryInterval?: number;
+    maxRetries?: number;
+}
+export interface MCPRequest {
+    jsonrpc: string;
+    id: string | number;
+    method: string;
+    params?: any;
+}
+export interface MCPResponse {
+    jsonrpc: string;
+    id: string | number;
+    result?: any;
+    error?: {
+        code: number;
+        message: string;
+        data?: any;
+    };
+}
+export declare class RemoteClient {
+    private ws;
+    private config;
+    private isAuthenticated;
+    private deviceId;
+    private pendingRequests;
+    private reconnectAttempts;
+    private reconnectTimer;
+    constructor(config: RemoteClientConfig);
+    connect(): Promise<void>;
+    private handleMessage;
+    private handleReconnect;
+    private sendMessage;
+    sendMCPRequest(request: MCPRequest): Promise<MCPResponse>;
+    isConnected(): boolean;
+    disconnect(): void;
+    getStatus(): {
+        connected: boolean;
+        authenticated: boolean;
+        deviceId: string | null;
+    };
+}

package/dist/remote-client.js

@@ -0,0 +1,174 @@
+import WebSocket from 'ws';
+import { logger } from './utils/logger.js';
+export class RemoteClient {
+    constructor(config) {
+        this.ws = null;
+        this.isAuthenticated = false;
+        this.deviceId = null;
+        this.pendingRequests = new Map();
+        this.reconnectAttempts = 0;
+        this.reconnectTimer = null;
+        this.config = {
+            retryInterval: 5000,
+            maxRetries: 5,
+            ...config
+        };
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            try {
+                logger.info(`Connecting to Remote MCP Server: ${this.config.serverUrl}`);
+                this.ws = new WebSocket(this.config.serverUrl);
+                this.ws.on('open', () => {
+                    logger.info('Connected to Remote MCP Server');
+                    this.reconnectAttempts = 0;
+                    // Send authentication
+                    this.sendMessage({
+                        id: 'auth-1',
+                        type: 'auth',
+                        payload: { deviceToken: this.config.deviceToken },
+                        timestamp: Date.now()
+                    });
+                });
+                this.ws.on('message', (data) => {
+                    try {
+                        const message = JSON.parse(data.toString());
+                        this.handleMessage(message);
+                        // Resolve connection promise on successful auth
+                        if (message.type === 'auth' && message.payload?.success && !this.isAuthenticated) {
+                            this.isAuthenticated = true;
+                            this.deviceId = message.payload.deviceId;
+                            logger.info(`Remote MCP authentication successful! Device ID: ${this.deviceId}`);
+                            resolve();
+                        }
+                    }
+                    catch (error) {
+                        logger.error('Error processing remote message:', error);
+                    }
+                });
+                this.ws.on('close', (code, reason) => {
+                    logger.info(`Remote MCP connection closed (${code}): ${reason}`);
+                    this.isAuthenticated = false;
+                    this.deviceId = null;
+                    this.handleReconnect();
+                });
+                this.ws.on('error', (error) => {
+                    logger.error('Remote MCP WebSocket error:', error.message);
+                    if (!this.isAuthenticated) {
+                        reject(new Error(`Failed to connect to Remote MCP Server: ${error.message}`));
+                    }
+                });
+                // Set up heartbeat
+                setInterval(() => {
+                    if (this.isConnected()) {
+                        this.sendMessage({
+                            id: `heartbeat-${Date.now()}`,
+                            type: 'heartbeat',
+                            payload: { timestamp: Date.now() },
+                            timestamp: Date.now()
+                        });
+                    }
+                }, 30000);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    handleMessage(message) {
+        if (message.type === 'mcp_response') {
+            // Handle MCP response
+            const request = this.pendingRequests.get(message.payload.id);
+            if (request) {
+                clearTimeout(request.timeout);
+                this.pendingRequests.delete(message.payload.id);
+                request.resolve(message.payload);
+            }
+        }
+        else if (message.type === 'heartbeat') {
+            // Respond to heartbeat
+            this.sendMessage({
+                id: message.id,
+                type: 'heartbeat',
+                payload: { timestamp: Date.now() },
+                timestamp: Date.now()
+            });
+        }
+    }
+    handleReconnect() {
+        if (this.reconnectAttempts >= (this.config.maxRetries || 5)) {
+            logger.error('Max reconnection attempts reached. Giving up.');
+            return;
+        }
+        this.reconnectAttempts++;
+        const delay = (this.config.retryInterval || 5000) * this.reconnectAttempts;
+        logger.info(`Attempting to reconnect in ${delay}ms (attempt ${this.reconnectAttempts})`);
+        this.reconnectTimer = setTimeout(async () => {
+            try {
+                await this.connect();
+            }
+            catch (error) {
+                logger.error('Reconnection failed:', error);
+                this.handleReconnect();
+            }
+        }, delay);
+    }
+    sendMessage(message) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(message));
+        }
+    }
+    async sendMCPRequest(request) {
+        if (!this.isConnected() || !this.isAuthenticated) {
+            throw new Error('Remote MCP client not connected or authenticated');
+        }
+        return new Promise((resolve, reject) => {
+            const requestId = `mcp-${Date.now()}-${Math.random()}`;
+            // Set up timeout
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(request.id);
+                reject(new Error('Remote MCP request timeout'));
+            }, 30000); // 30 second timeout
+            this.pendingRequests.set(request.id, {
+                resolve,
+                reject,
+                timeout
+            });
+            // Send MCP request to remote server
+            this.sendMessage({
+                id: requestId,
+                type: 'mcp_request',
+                payload: request,
+                timestamp: Date.now()
+            });
+        });
+    }
+    isConnected() {
+        return this.ws !== null && this.ws.readyState === WebSocket.OPEN && this.isAuthenticated;
+    }
+    disconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        // Clear pending requests
+        this.pendingRequests.forEach(({ timeout, reject }) => {
+            clearTimeout(timeout);
+            reject(new Error('Client disconnecting'));
+        });
+        this.pendingRequests.clear();
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.isAuthenticated = false;
+        this.deviceId = null;
+    }
+    getStatus() {
+        return {
+            connected: this.ws?.readyState === WebSocket.OPEN || false,
+            authenticated: this.isAuthenticated,
+            deviceId: this.deviceId
+        };
+    }
+}

package/dist/remote-device/device-authenticator.js

@@ -2,11 +2,7 @@ import express from 'express';
 import { createServer } from 'http';
 import open from 'open';
 import readline from 'readline';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+import { authSuccessHtml } from './templates/auth-success.js';
 function escapeHtml(text) {
     if (text === null || text === undefined)
         return '';
@@ -62,9 +58,7 @@ export class DeviceAuthenticator {
                     reject(new Error(`${error}: ${error_description}`));
                 }
                 else if (token) {
-                    const templatePath = path.join(__dirname, 'templates', 'auth-success.html');
-                    const htmlContent = fs.readFileSync(templatePath, 'utf8');
-                    res.send(htmlContent);
+                    res.send(authSuccessHtml);
                     server.close();
                     console.log('   - ✅ Authentication successful, token received');
                     resolve({

package/dist/remote-device/templates/auth-success.d.ts

@@ -0,0 +1 @@
+export declare const authSuccessHtml = "\n<!DOCTYPE html>\n<html lang=\"en\">\n\n<head>\n    <meta charset=\"UTF-8\">\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n    <title>Authentication Successful</title>\n</head>\n\n<body\n    style=\"margin: 0; font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif; line-height: 1.5; color: #F8FAFC; background-color: #101219; min-height: 100vh; display: flex; align-items: center; justify-content: center;\">\n    <div\n        style=\"background: rgba(30, 41, 59, 0.4); backdrop-filter: blur(12px); border: 1px solid #2B303B; border-radius: 12px; padding: 40px; width: 100%; max-width: 480px; margin: 20px; text-align: center; box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.5);\">\n        <h2 style=\"font-size: 24px; font-weight: 700; color: #F8FAFC; margin-top: 0; margin-bottom: 16px;\">\n            Authentication Successful!</h2>\n        <p style=\"color: #94A3B8; font-size: 15px; line-height: 1.6; margin: 0 0 8px 0;\">Your device is now connected.\n        </p>\n        <p style=\"color: #94A3B8; font-size: 15px; line-height: 1.6; margin: 0;\">You can close this window.</p>\n    </div>\n    <script>\n        // Clean up URL parameters and hash\n        if (window.history && window.history.replaceState) {\n            window.history.replaceState(null, '', window.location.pathname);\n        }\n    </script>\n</body>\n\n</html>\n";

package/dist/remote-device/templates/auth-success.js

@@ -0,0 +1,30 @@
+export const authSuccessHtml = `
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Authentication Successful</title>
+</head>
+
+<body
+    style="margin: 0; font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif; line-height: 1.5; color: #F8FAFC; background-color: #101219; min-height: 100vh; display: flex; align-items: center; justify-content: center;">
+    <div
+        style="background: rgba(30, 41, 59, 0.4); backdrop-filter: blur(12px); border: 1px solid #2B303B; border-radius: 12px; padding: 40px; width: 100%; max-width: 480px; margin: 20px; text-align: center; box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.5);">
+        <h2 style="font-size: 24px; font-weight: 700; color: #F8FAFC; margin-top: 0; margin-bottom: 16px;">
+            Authentication Successful!</h2>
+        <p style="color: #94A3B8; font-size: 15px; line-height: 1.6; margin: 0 0 8px 0;">Your device is now connected.
+        </p>
+        <p style="color: #94A3B8; font-size: 15px; line-height: 1.6; margin: 0;">You can close this window.</p>
+    </div>
+    <script>
+        // Clean up URL parameters and hash
+        if (window.history && window.history.replaceState) {
+            window.history.replaceState(null, '', window.location.pathname);
+        }
+    </script>
+</body>
+
+</html>
+`;

package/dist/remote-sse-client.d.ts

@@ -0,0 +1,45 @@
+export interface RemoteSSEClientConfig {
+    serverUrl: string;
+    deviceToken: string;
+    retryInterval?: number;
+    maxRetries?: number;
+}
+export interface MCPRequest {
+    jsonrpc: string;
+    id: string | number;
+    method: string;
+    params?: any;
+}
+export interface MCPResponse {
+    jsonrpc: string;
+    id: string | number;
+    result?: any;
+    error?: {
+        code: number;
+        message: string;
+        data?: any;
+    };
+}
+export declare class RemoteSSEClient {
+    private eventSource;
+    private config;
+    private isConnected;
+    private isAuthenticated;
+    private deviceId;
+    private pendingRequests;
+    private reconnectAttempts;
+    private reconnectTimer;
+    constructor(config: RemoteSSEClientConfig);
+    connect(): Promise<void>;
+    private connectWithFetch;
+    private handleSSEMessage;
+    sendMCPRequest(request: MCPRequest): Promise<MCPResponse>;
+    private handleReconnect;
+    isConnectedAndAuthenticated(): boolean;
+    disconnect(): void;
+    getStatus(): {
+        connected: boolean;
+        authenticated: boolean;
+        deviceId: string | null;
+    };
+}

package/dist/remote-sse-client.js

@@ -0,0 +1,243 @@
+import { logger } from './utils/logger.js';
+export class RemoteSSEClient {
+    constructor(config) {
+        this.eventSource = null;
+        this.isConnected = false;
+        this.isAuthenticated = false;
+        this.deviceId = null;
+        this.pendingRequests = new Map();
+        this.reconnectAttempts = 0;
+        this.reconnectTimer = null;
+        this.config = {
+            retryInterval: 5000,
+            maxRetries: 5,
+            ...config
+        };
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            try {
+                const sseUrl = `${this.config.serverUrl}/sse?deviceToken=${encodeURIComponent(this.config.deviceToken)}`;
+                logger.info(`Connecting to Remote MCP Server via SSE: ${sseUrl}`);
+                // Check if EventSource is available (Node.js environment needs polyfill)
+                if (typeof EventSource === 'undefined') {
+                    // For Node.js environment, we'll use a different approach
+                    this.connectWithFetch(sseUrl, resolve, reject);
+                    return;
+                }
+                this.eventSource = new EventSource(sseUrl);
+                this.eventSource.onopen = () => {
+                    logger.info('SSE connection opened');
+                    this.isConnected = true;
+                    this.reconnectAttempts = 0;
+                };
+                this.eventSource.onmessage = (event) => {
+                    this.handleSSEMessage('message', event.data);
+                };
+                this.eventSource.addEventListener('connected', (event) => {
+                    this.handleSSEMessage('connected', event.data);
+                    this.isAuthenticated = true;
+                    resolve();
+                });
+                this.eventSource.addEventListener('mcp_response', (event) => {
+                    this.handleSSEMessage('mcp_response', event.data);
+                });
+                this.eventSource.addEventListener('heartbeat', (event) => {
+                    this.handleSSEMessage('heartbeat', event.data);
+                });
+                this.eventSource.onerror = (event) => {
+                    logger.error('SSE connection error:', event);
+                    if (!this.isAuthenticated) {
+                        reject(new Error('Failed to connect to Remote MCP Server via SSE'));
+                    }
+                    else {
+                        this.handleReconnect();
+                    }
+                };
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    async connectWithFetch(sseUrl, resolve, reject) {
+        try {
+            // For Node.js environment, use fetch with streaming
+            const fetch = (await import('cross-fetch')).default;
+            const response = await fetch(sseUrl, {
+                headers: {
+                    'Accept': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`SSE connection failed: ${response.status} ${response.statusText}`);
+            }
+            this.isConnected = true;
+            this.reconnectAttempts = 0;
+            logger.info('SSE connection established via fetch');
+            // Handle the readable stream
+            const reader = response.body?.getReader();
+            if (!reader) {
+                throw new Error('No readable stream available');
+            }
+            const decoder = new TextDecoder();
+            let buffer = '';
+            // Process the stream
+            const processStream = async () => {
+                while (this.isConnected) {
+                    try {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        buffer += decoder.decode(value, { stream: true });
+                        // Process complete SSE messages
+                        const lines = buffer.split('\n');
+                        buffer = lines.pop() || ''; // Keep incomplete line in buffer
+                        let eventType = 'message';
+                        let eventData = '';
+                        for (const line of lines) {
+                            if (line.startsWith('event: ')) {
+                                eventType = line.substring(7);
+                            }
+                            else if (line.startsWith('data: ')) {
+                                eventData = line.substring(6);
+                            }
+                            else if (line === '' && eventData) {
+                                // Complete event received
+                                this.handleSSEMessage(eventType, eventData);
+                                // Resolve on first successful connection
+                                if (eventType === 'connected' && !this.isAuthenticated) {
+                                    this.isAuthenticated = true;
+                                    resolve();
+                                }
+                                eventType = 'message';
+                                eventData = '';
+                            }
+                        }
+                    }
+                    catch (error) {
+                        logger.error('Error reading SSE stream:', error);
+                        break;
+                    }
+                }
+            };
+            processStream().catch(error => {
+                logger.error('SSE stream processing error:', error);
+                if (!this.isAuthenticated) {
+                    reject(error);
+                }
+                else {
+                    this.handleReconnect();
+                }
+            });
+        }
+        catch (error) {
+            reject(error);
+        }
+    }
+    handleSSEMessage(eventType, data) {
+        try {
+            const message = JSON.parse(data);
+            switch (eventType) {
+                case 'connected':
+                    this.deviceId = message.deviceId;
+                    logger.info(`Remote MCP SSE authentication successful! Device ID: ${this.deviceId}`);
+                    break;
+                case 'mcp_response':
+                    // This shouldn't happen in our architecture since the local agent sends responses directly
+                    // But we can handle it for completeness
+                    logger.info('Received unexpected mcp_response via SSE');
+                    break;
+                case 'heartbeat':
+                    // Silent heartbeat handling
+                    break;
+                default:
+                    logger.info(`Received SSE event: ${eventType}`, message);
+            }
+        }
+        catch (error) {
+            logger.error('Error processing SSE message:', error);
+        }
+    }
+    async sendMCPRequest(request) {
+        if (!this.isConnected || !this.isAuthenticated) {
+            throw new Error('Remote MCP SSE client not connected or authenticated');
+        }
+        // In the SSE architecture, we don't send requests directly via SSE
+        // Instead, we send them via HTTP POST to the server's MCP endpoint
+        return new Promise(async (resolve, reject) => {
+            try {
+                const fetch = (await import('cross-fetch')).default;
+                const response = await fetch(`${this.config.serverUrl}/api/mcp/execute`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.config.deviceToken}`
+                    },
+                    body: JSON.stringify({
+                        deviceToken: this.config.deviceToken,
+                        request: request
+                    })
+                });
+                if (!response.ok) {
+                    throw new Error(`MCP request failed: ${response.status} ${response.statusText}`);
+                }
+                const result = await response.json();
+                resolve(result);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    handleReconnect() {
+        if (this.reconnectAttempts >= (this.config.maxRetries || 5)) {
+            logger.error('Max SSE reconnection attempts reached. Giving up.');
+            return;
+        }
+        this.isConnected = false;
+        this.isAuthenticated = false;
+        this.reconnectAttempts++;
+        const delay = (this.config.retryInterval || 5000) * this.reconnectAttempts;
+        logger.info(`Attempting to reconnect SSE in ${delay}ms (attempt ${this.reconnectAttempts})`);
+        this.reconnectTimer = setTimeout(async () => {
+            try {
+                await this.connect();
+            }
+            catch (error) {
+                logger.error('SSE reconnection failed:', error);
+                this.handleReconnect();
+            }
+        }, delay);
+    }
+    isConnectedAndAuthenticated() {
+        return this.isConnected && this.isAuthenticated;
+    }
+    disconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        // Clear pending requests
+        this.pendingRequests.forEach(({ timeout, reject }) => {
+            clearTimeout(timeout);
+            reject(new Error('Client disconnecting'));
+        });
+        this.pendingRequests.clear();
+        if (this.eventSource) {
+            this.eventSource.close();
+            this.eventSource = null;
+        }
+        this.isConnected = false;
+        this.isAuthenticated = false;
+        this.deviceId = null;
+    }
+    getStatus() {
+        return {
+            connected: this.isConnected,
+            authenticated: this.isAuthenticated,
+            deviceId: this.deviceId
+        };
+    }
+}

package/dist/tools/remote-mcp.d.ts

@@ -0,0 +1,20 @@
+export declare function connectRemoteMCP(serverUrl: string, deviceToken: string): Promise<{
+    success: boolean;
+    message: string;
+    status?: any;
+}>;
+export declare function disconnectRemoteMCP(): {
+    success: boolean;
+    message: string;
+};
+export declare function getRemoteMCPStatus(): {
+    connected: boolean;
+    authenticated: boolean;
+    deviceId: string | null;
+    message: string;
+};
+export declare function executeRemoteMCP(method: string, params?: any): Promise<{
+    success: boolean;
+    result?: any;
+    error?: string;
+}>;