@wonderwhy-er/desktop-commander 0.2.29-alpha.0 → 0.2.29-alpha.10

package/dist/index.js

@@ -7,6 +7,7 @@ import { runSetup } from './npm-scripts/setup.js';
 import { runUninstall } from './npm-scripts/uninstall.js';
 import { capture } from './utils/capture.js';
 import { logToStderr, logger } from './utils/logger.js';
+import { runRemote } from './npm-scripts/remote.js';
 // Store messages to defer until after initialization
 const deferredMessages = [];
 function deferLog(level, message) {
@@ -24,6 +25,15 @@ async function runServer() {
             await runUninstall();
             return;
         }
+        if (process.argv[2] === 'remote') {
+            await runRemote();
+            return;
+        }
+        // Check if first argument is "remote"
+        if (process.argv[2] === 'remote') {
+            await runRemote();
+            return;
+        }
         // Parse command line arguments for onboarding control
         const DISABLE_ONBOARDING = process.argv.includes('--no-onboarding');
         if (DISABLE_ONBOARDING) {

package/dist/npm-scripts/remote.d.ts

@@ -0,0 +1 @@
+export declare function runRemote(): Promise<void>;

package/dist/npm-scripts/remote.js

@@ -0,0 +1,20 @@
+import { MCPDevice } from '../remote-device/device.js';
+import os from 'os';
+import caffeinate from 'caffeinate';
+export async function runRemote() {
+    const persistSession = process.argv.includes('--persist-session');
+    const disableNoSleep = process.argv.includes('--disable-no-sleep');
+    // Start caffeinate on macOS (unless disabled)
+    // Caffeinate will monitor this process and automatically exit when it terminates
+    if (!disableNoSleep && os.platform() === 'darwin') {
+        try {
+            await caffeinate({ pid: process.pid });
+            console.log('☕ Caffeinate started (preventing system sleep)');
+        }
+        catch (error) {
+            console.warn('⚠️ Failed to start caffeinate:', error);
+        }
+    }
+    const device = new MCPDevice({ persistSession });
+    await device.start();
+}

package/dist/remote-device/desktop-commander-integration.d.ts

@@ -0,0 +1,143 @@
+interface McpConfig {
+    command: string;
+    args: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+}
+export declare class DesktopCommanderIntegration {
+    private mcpClient;
+    private mcpTransport;
+    private isReady;
+    initialize(): Promise<void>;
+    resolveMcpConfig(): Promise<McpConfig | null>;
+    callClientTool(toolName: string, args: any, metadata?: any): Promise<{
+        [x: string]: unknown;
+        content: ({
+            type: "text";
+            text: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "image";
+            data: string;
+            mimeType: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "audio";
+            data: string;
+            mimeType: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "resource";
+            resource: {
+                uri: string;
+                text: string;
+                mimeType?: string | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                uri: string;
+                blob: string;
+                mimeType?: string | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            };
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            uri: string;
+            name: string;
+            type: "resource_link";
+            description?: string | undefined;
+            mimeType?: string | undefined;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+                theme?: "light" | "dark" | undefined;
+            }[] | undefined;
+            title?: string | undefined;
+        })[];
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+        structuredContent?: Record<string, unknown> | undefined;
+        isError?: boolean | undefined;
+    } | {
+        [x: string]: unknown;
+        toolResult: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    }>;
+    listClientTools(): Promise<{
+        tools: {
+            inputSchema: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: Record<string, object> | undefined;
+                required?: string[] | undefined;
+            };
+            name: string;
+            description?: string | undefined;
+            outputSchema?: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: Record<string, object> | undefined;
+                required?: string[] | undefined;
+            } | undefined;
+            annotations?: {
+                title?: string | undefined;
+                readOnlyHint?: boolean | undefined;
+                destructiveHint?: boolean | undefined;
+                idempotentHint?: boolean | undefined;
+                openWorldHint?: boolean | undefined;
+            } | undefined;
+            execution?: {
+                taskSupport?: "optional" | "required" | "forbidden" | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+                theme?: "light" | "dark" | undefined;
+            }[] | undefined;
+            title?: string | undefined;
+        }[];
+    }>;
+    shutdown(): Promise<void>;
+}
+export {};

package/dist/remote-device/desktop-commander-integration.js

@@ -0,0 +1,147 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs/promises';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class DesktopCommanderIntegration {
+    constructor() {
+        this.mcpClient = null;
+        this.mcpTransport = null;
+        this.isReady = false;
+    }
+    async initialize() {
+        const config = await this.resolveMcpConfig();
+        if (!config) {
+            throw new Error('Desktop Commander MCP not found. Please install it globally via `npm install -g @wonderwhy-er/desktop-commander` or build the local project.');
+        }
+        console.log(` - ⏳ Connecting to Local Desktop Commander MCP using: ${config.command} ${config.args.join(' ')}`);
+        try {
+            this.mcpTransport = new StdioClientTransport(config);
+            // Create MCP client
+            this.mcpClient = new Client({
+                name: "desktop-commander-client",
+                version: "1.0.0"
+            }, {
+                capabilities: {}
+            });
+            // Connect to Desktop Commander
+            await this.mcpClient.connect(this.mcpTransport);
+            this.isReady = true;
+            console.log(' - 🔌 Connected to Desktop Commander MCP');
+        }
+        catch (error) {
+            console.error(' - ❌ Failed to connect to Desktop Commander MCP:', error);
+            throw error;
+        }
+    }
+    async resolveMcpConfig() {
+        // Option 1: Development/Local Build
+        // Adjusting path resolution since we are now in src/remote-device and dist is in root/dist
+        // Original: path.resolve(__dirname, '../../dist/index.js')
+        const devPath = path.resolve(__dirname, '../../dist/index.js');
+        try {
+            await fs.access(devPath);
+            console.debug(' - 🔍 Found local MCP server at:', devPath);
+            return {
+                command: process.execPath, // Use the current node executable
+                args: [devPath],
+                cwd: path.dirname(devPath)
+            };
+        }
+        catch {
+            // Local file not found, continue...
+        }
+        // Option 2: Global Installation
+        const commandName = 'desktop-commander';
+        try {
+            await new Promise((resolve, reject) => {
+                // Use 'which' to check if the command exists in PATH
+                // We can't run it directly as it's an stdio MCP server that waits for input
+                const check = spawn('which', [commandName]);
+                check.on('error', reject);
+                check.on('close', (code) => code === 0 ? resolve() : reject(new Error('Command not found')));
+            });
+            console.debug(' - Found global desktop-commander CLI');
+            return {
+                command: commandName,
+                args: []
+            };
+        }
+        catch {
+            // Global command not found
+        }
+        return null;
+    }
+    async callClientTool(toolName, args, metadata) {
+        if (!this.isReady || !this.mcpClient) {
+            throw new Error('DesktopIntegration not initialized');
+        }
+        // Proxy other tools to MCP server
+        try {
+            console.log(`Forwarding tool call ${toolName} to MCP server`, metadata);
+            const result = await this.mcpClient.callTool({
+                name: toolName,
+                arguments: args,
+                _meta: { remote: true, ...metadata || {} }
+            });
+            return result;
+        }
+        catch (error) {
+            console.error(`Error executing tool ${toolName}:`, error);
+            throw error;
+        }
+    }
+    async listClientTools() {
+        if (!this.mcpClient)
+            return { tools: [] };
+        try {
+            // List tools from MCP server
+            const mcpTools = await this.mcpClient.listTools();
+            // Merge tools
+            return {
+                tools: mcpTools.tools || []
+            };
+        }
+        catch (error) {
+            console.error('Error fetching capabilities:', error);
+            // Fallback to local tools
+            return {
+                tools: []
+            };
+        }
+    }
+    async shutdown() {
+        const closeWithTimeout = async (operation, name, timeoutMs = 3000) => {
+            return Promise.race([
+                operation(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error(`${name} timeout after ${timeoutMs}ms`)), timeoutMs))
+            ]);
+        };
+        if (this.mcpClient) {
+            try {
+                console.log('  → Closing MCP client...');
+                await closeWithTimeout(() => this.mcpClient.close(), 'MCP client close');
+                console.log('  ✓ MCP client closed');
+            }
+            catch (e) {
+                console.warn('  ⚠️  MCP client close timeout or error:', e.message);
+            }
+            this.mcpClient = null;
+        }
+        if (this.mcpTransport) {
+            try {
+                console.log('  → Closing MCP transport...');
+                await closeWithTimeout(() => this.mcpTransport.close(), 'MCP transport close');
+                console.log('  ✓ MCP transport closed');
+            }
+            catch (e) {
+                console.warn('  ⚠️  MCP transport close timeout or error:', e.message);
+            }
+            this.mcpTransport = null;
+        }
+        this.isReady = false;
+    }
+}

package/dist/remote-device/device-authenticator.d.ts

@@ -0,0 +1,16 @@
+interface AuthSession {
+    access_token: string;
+    refresh_token: string | null;
+    device_id?: string;
+}
+export declare class DeviceAuthenticator {
+    private baseServerUrl;
+    constructor(baseServerUrl: string);
+    authenticate(deviceId?: string): Promise<AuthSession>;
+    private generatePKCE;
+    private requestDeviceCode;
+    private displayUserInstructions;
+    private pollForAuthorization;
+    private sleep;
+}
+export {};

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

@@ -0,0 +1,120 @@
+import open from 'open';
+import os from 'os';
+import crypto from 'crypto';
+const CLIENT_ID = 'mcp-device';
+export class DeviceAuthenticator {
+    constructor(baseServerUrl) {
+        this.baseServerUrl = baseServerUrl;
+    }
+    async authenticate(deviceId) {
+        console.log('🔐 Starting device authorization flow...\n');
+        // Generate PKCE
+        const pkce = this.generatePKCE();
+        // Step 1: Request device code
+        const deviceAuth = await this.requestDeviceCode(pkce.challenge, deviceId);
+        // Step 2: Display user instructions and open browser
+        this.displayUserInstructions(deviceAuth);
+        // Step 3: Poll for authorization
+        const tokens = await this.pollForAuthorization(deviceAuth, pkce.verifier);
+        console.log('   - ✅ Authorization successful!\n');
+        return tokens;
+    }
+    generatePKCE() {
+        const verifier = crypto.randomBytes(32).toString('base64url');
+        const challenge = crypto.createHash('sha256').update(verifier).digest('base64url');
+        return { verifier, challenge };
+    }
+    async requestDeviceCode(codeChallenge, deviceId) {
+        console.log('   - 📡 Requesting device code...');
+        const response = await fetch(`${this.baseServerUrl}/device/start`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                client_id: CLIENT_ID,
+                scope: 'mcp:tools',
+                device_name: os.hostname(),
+                device_type: 'mcp',
+                device_id: deviceId,
+                code_challenge: codeChallenge,
+                code_challenge_method: 'S256',
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+            throw new Error(error.error_description || 'Failed to start device flow');
+        }
+        const data = await response.json();
+        console.log('   - ✅ Device code received\n');
+        return data;
+    }
+    displayUserInstructions(deviceAuth) {
+        console.log('📋 Please complete authentication:\n');
+        console.log('   1. Open this URL in your browser:');
+        console.log(`      ${deviceAuth.verification_uri}\n`);
+        console.log('   2. Enter this code when prompted:');
+        console.log(`      ${deviceAuth.user_code}\n`);
+        console.log(`   Code expires in ${Math.floor(deviceAuth.expires_in / 60)} minutes.\n`);
+        // Try to open browser automatically
+        open(deviceAuth.verification_uri_complete).catch(() => {
+            console.log('   - Could not open browser automatically.');
+            console.log(`   - Please visit: ${deviceAuth.verification_uri}\n`);
+        });
+        console.log('   - ⏳ Waiting for authorization...\n');
+    }
+    async pollForAuthorization(deviceAuth, codeVerifier) {
+        const interval = (deviceAuth.interval || 5) * 1000;
+        const maxAttempts = Math.floor(deviceAuth.expires_in / (deviceAuth.interval || 5));
+        let attempt = 0;
+        while (attempt < maxAttempts) {
+            attempt++;
+            // Wait before polling
+            await this.sleep(interval);
+            try {
+                const response = await fetch(`${this.baseServerUrl}/device/poll`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        device_code: deviceAuth.device_code,
+                        client_id: CLIENT_ID,
+                        code_verifier: codeVerifier,
+                    }),
+                });
+                if (response.ok) {
+                    const tokens = await response.json();
+                    if (tokens.access_token) {
+                        return {
+                            device_id: tokens.device_id,
+                            access_token: tokens.access_token,
+                            refresh_token: tokens.refresh_token || null,
+                        };
+                    }
+                }
+                const error = await response.json().catch(() => ({ error: 'unknown' }));
+                // Check error type
+                if (error.error === 'authorization_pending') {
+                    // Still waiting - continue polling
+                    continue;
+                }
+                if (error.error === 'slow_down') {
+                    // Server requested slower polling
+                    await this.sleep(interval);
+                    continue;
+                }
+                // Terminal error
+                throw new Error(error.error_description || error.error || 'Authorization failed');
+            }
+            catch (fetchError) {
+                // Network error - retry unless we're out of attempts
+                if (attempt >= maxAttempts) {
+                    throw fetchError;
+                }
+                // Continue polling on network errors
+                continue;
+            }
+        }
+        throw new Error('Authorization timeout - user did not authorize within the time limit');
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}

package/dist/remote-device/device.d.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+export interface MCPDeviceOptions {
+    persistSession?: boolean;
+}
+export declare class MCPDevice {
+    private baseServerUrl;
+    private remoteChannel;
+    private deviceId?;
+    private user;
+    private isShuttingDown;
+    private configPath;
+    private persistSession;
+    private desktop;
+    constructor(options?: MCPDeviceOptions);
+    private setupShutdownHandlers;
+    start(): Promise<void>;
+    loadPersistedConfig(): Promise<any>;
+    savePersistedConfig(session: any): Promise<void>;
+    fetchSupabaseConfig(): Promise<{
+        supabaseUrl: any;
+        anonKey: any;
+    }>;
+    handleNewToolCall(payload: any): Promise<void>;
+    shutdown(): Promise<void>;
+}