@wonderwhy-er/desktop-commander 0.2.29-alpha.4 → 0.2.29-alpha.6

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

@@ -10,7 +10,7 @@ export declare class DesktopCommanderIntegration {
     private isReady;
     initialize(): Promise<void>;
     resolveMcpConfig(): Promise<McpConfig | null>;
-    executeTool(toolName: string, args: any): Promise<{
+    callClientTool(toolName: string, args: any, metadata?: any): Promise<{
         [x: string]: unknown;
         content: ({
             type: "text";
@@ -102,7 +102,7 @@ export declare class DesktopCommanderIntegration {
             } | undefined;
         } | undefined;
     }>;
-    getCapabilities(): Promise<{
+    listClientTools(): Promise<{
         tools: {
             inputSchema: {
                 [x: string]: unknown;

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

@@ -75,16 +75,17 @@ export class DesktopCommanderIntegration {
         }
         return null;
     }
-    async executeTool(toolName, args) {
+    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`);
+            console.log(`Forwarding tool call ${toolName} to MCP server`, metadata);
             const result = await this.mcpClient.callTool({
                 name: toolName,
-                arguments: args
+                arguments: args,
+                _meta: { remote: true, ...metadata || {} }
             });
             return result;
         }
@@ -93,7 +94,7 @@ export class DesktopCommanderIntegration {
             throw error;
         }
     }
-    async getCapabilities() {
+    async listClientTools() {
         if (!this.mcpClient)
             return { tools: [] };
         try {

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

@@ -6,8 +6,10 @@ export declare class DeviceAuthenticator {
     private baseServerUrl;
     constructor(baseServerUrl: string);
     authenticate(): Promise<AuthSession>;
-    private isDesktopEnvironment;
-    private authenticateDesktop;
-    private authenticateHeadless;
+    private generatePKCE;
+    private requestDeviceCode;
+    private displayUserInstructions;
+    private pollForAuthorization;
+    private sleep;
 }
 export {};

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

@@ -1,154 +1,118 @@
-import express from 'express';
-import { createServer } from 'http';
 import open from 'open';
-import readline from 'readline';
-import { authSuccessHtml } from './templates/auth-success.js';
-function escapeHtml(text) {
-    if (text === null || text === undefined)
-        return '';
-    return String(text)
-        .replace(/&/g, "&")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;")
-        .replace(/"/g, "&quot;")
-        .replace(/'/g, "&#039;");
-}
-const CALLBACK_PORT = 8121;
+import os from 'os';
+import crypto from 'crypto';
+const CLIENT_ID = 'mcp-device';
 export class DeviceAuthenticator {
     constructor(baseServerUrl) {
         this.baseServerUrl = baseServerUrl;
     }
     async authenticate() {
-        // Detect environment
-        const isDesktop = this.isDesktopEnvironment();
-        console.log(`🔐 Starting authentication (${isDesktop ? 'desktop' : 'headless'} mode)...`);
-        if (isDesktop) {
-            return this.authenticateDesktop();
-        }
-        else {
-            return this.authenticateHeadless();
-        }
+        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);
+        // 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;
     }
-    isDesktopEnvironment() {
-        // Check if we're in a desktop environment
-        return process.platform === 'darwin' ||
-            process.platform === 'win32' ||
-            (process.platform === 'linux' && !!process.env.DISPLAY);
+    generatePKCE() {
+        const verifier = crypto.randomBytes(32).toString('base64url');
+        const challenge = crypto.createHash('sha256').update(verifier).digest('base64url');
+        return { verifier, challenge };
     }
-    async authenticateDesktop() {
-        const app = express();
-        const callbackUrl = `http://localhost:${CALLBACK_PORT}/callback`;
-        return new Promise((resolve, reject) => {
-            let server;
-            // Setup callback handler
-            app.get('/callback', (req, res) => {
-                const { access_token, refresh_token, code, error, error_description } = req.query;
-                // Extract the actual token (could be in access_token or code parameter)
-                const token = access_token || code;
-                if (error) {
-                    const safeError = escapeHtml(error);
-                    const safeErrorDesc = escapeHtml(error_description || 'Unknown error');
-                    res.send(`
-            <h2>Authentication Failed</h2>
-            <p>Error: ${safeError}</p>
-            <p>Description: ${safeErrorDesc}</p>
-            <p>You can close this window.</p>
-          `);
-                    server.close();
-                    reject(new Error(`${error}: ${error_description}`));
-                }
-                else if (token) {
-                    res.send(authSuccessHtml);
-                    server.close();
-                    console.log('   - ✅ Authentication successful, token received');
-                    resolve({
-                        access_token: token,
-                        refresh_token: refresh_token || null
-                    });
-                }
-                else {
-                    console.log('❌ No token found in callback:', req.query);
-                    const safeParams = escapeHtml(Object.keys(req.query).join(', '));
-                    res.send(`
-            <h2>Authentication Failed</h2>
-            <p>No access token received</p>
-            <p>Received parameters: ${safeParams}</p>
-            <p>You can close this window.</p>
-          `);
-                    server.close();
-                    reject(new Error('No access token received'));
-                }
-            });
-            // Start callback server
-            server = createServer(app);
-            server.listen(CALLBACK_PORT, () => {
-                const authUrl = `${this.baseServerUrl}/?redirect_uri=${encodeURIComponent(callbackUrl)}&device=true`;
-                console.log('   - 🌐 Opening browser for authentication...');
-                console.log(`   - If browser doesn't open, visit: ${authUrl}`);
-                // Open browser
-                open(authUrl).catch(() => {
-                    console.log('   - Could not open browser automatically.');
-                    console.log(`   - Please visit: ${authUrl}`);
-                });
-            });
-            server.on('error', (err) => {
-                reject(new Error(`Failed to start callback server: ${err.message}`));
-            });
-            // Timeout after 5 minutes
-            setTimeout(() => {
-                if (server.listening) {
-                    server.close();
-                    reject(new Error('   - Authentication timeout - no response received'));
-                }
-            }, 5 * 60 * 1000);
+    async requestDeviceCode(codeChallenge) {
+        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',
+                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;
     }
-    async authenticateHeadless() {
-        console.log('\n🔗 Manual Authentication Required:');
-        console.log('─'.repeat(50));
-        console.log(`1. Open this URL in a browser: ${this.baseServerUrl}/`);
-        console.log('2. Complete the authentication process');
-        console.log('3. You will be redirected to a URL with parameters.');
-        console.log('   If using device mode, look for access_token and refresh_token.');
-        console.log('4. Copy the access_token (and refresh_token if available) and paste here.');
-        console.log('   Format: access_token OR {"access_token":"...", "refresh_token":"..."}');
-        console.log('─'.repeat(50));
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout
+    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`);
         });
-        return new Promise((resolve, reject) => {
-            rl.question('\n🔑 Enter Access Token or JSON: ', (input) => {
-                rl.close();
-                const trimmedInput = input.trim();
-                if (!trimmedInput) {
-                    reject(new Error('Empty input provided'));
-                    return;
-                }
-                try {
-                    // Try parsing as JSON first
-                    const json = JSON.parse(trimmedInput);
-                    if (json.access_token) {
-                        resolve({
-                            access_token: json.access_token,
-                            refresh_token: json.refresh_token || null
-                        });
-                        return;
+        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 {
+                            access_token: tokens.access_token,
+                            refresh_token: tokens.refresh_token || null,
+                        };
                     }
                 }
-                catch (e) {
-                    // Not JSON, treat as raw token
+                const error = await response.json().catch(() => ({ error: 'unknown' }));
+                // Check error type
+                if (error.error === 'authorization_pending') {
+                    // Still waiting - continue polling
+                    continue;
                 }
-                if (trimmedInput.length < 10) {
-                    reject(new Error('Invalid token format (too short)'));
+                if (error.error === 'slow_down') {
+                    // Server requested slower polling
+                    await this.sleep(interval);
+                    continue;
                 }
-                else {
-                    resolve({
-                        access_token: trimmedInput,
-                        refresh_token: null
-                    });
+                // 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.js

@@ -24,15 +24,16 @@ export class MCPDevice {
         const handleShutdown = async (signal) => {
             if (this.isShuttingDown) {
                 console.log(`\n${signal} received, but already shutting down...`);
+                // Force exit if we get multiple signals
+                process.exit(1);
                 return;
             }
-            this.isShuttingDown = true;
             console.log(`\n${signal} received, initiating graceful shutdown...`);
-            // Force exit after 3 seconds if graceful shutdown hangs
+            // Force exit after 2 seconds if graceful shutdown hangs
             const forceExit = setTimeout(() => {
-                console.error('⚠️ Graceful shutdown timed out, forcing exit...');
+                console.error('\n⚠️ Graceful shutdown timed out, forcing exit...');
                 process.exit(1);
-            }, 3000);
+            }, 2000);
             try {
                 await this.shutdown();
                 clearTimeout(forceExit);
@@ -43,11 +44,21 @@ export class MCPDevice {
                 process.exit(1);
             }
         };
+        // Remove any existing SIGINT/SIGTERM listeners to prevent default behavior
+        process.removeAllListeners('SIGINT');
+        process.removeAllListeners('SIGTERM');
+        // Add our custom handlers
         process.on('SIGINT', () => {
-            handleShutdown('SIGINT');
+            handleShutdown('SIGINT').catch((error) => {
+                console.error('Fatal error during shutdown:', error);
+                process.exit(1);
+            });
         });
         process.on('SIGTERM', () => {
-            handleShutdown('SIGTERM');
+            handleShutdown('SIGTERM').catch((error) => {
+                console.error('Fatal error during shutdown:', error);
+                process.exit(1);
+            });
         });
     }
     async start() {
@@ -106,13 +117,14 @@ export class MCPDevice {
             this.user = user;
             const deviceName = os.hostname();
             // Register as device
-            this.deviceId = await this.remoteChannel.registerDevice(this.user.id, await this.desktop.getCapabilities(), this.deviceId, deviceName);
+            this.deviceId = await this.remoteChannel.registerDevice(this.user.id, await this.desktop.listClientTools(), this.deviceId, deviceName);
             // Also save session again just in case (optional, but harmless)
             const { data: { session: currentSession } } = await this.remoteChannel.getSession();
             await this.savePersistedConfig(currentSession);
             // Subscribe to tool calls
             await this.remoteChannel.subscribe(this.user.id, (payload) => this.handleNewToolCall(payload));
             console.log('✅ Device ready:');
+            console.log(`   - User:         ${this.user.email}`);
             console.log(`   - Device ID:    ${this.deviceId}`);
             console.log(`   - Device Name:  ${deviceName}`);
             // Keep process alive
@@ -161,7 +173,7 @@ export class MCPDevice {
             // Ensure the config directory exists
             await fs.mkdir(path.dirname(this.configPath), { recursive: true });
             await fs.writeFile(this.configPath, JSON.stringify(config, null, 2), { mode: 0o600 });
-            // if (session) console.debug('💾 Session saved to device.json');
+            // if (session) console.debug('💾 Session saved to ' + this.configPath);
         }
         catch (error) {
             console.error(' - ❌ Failed to save config:', error.message);
@@ -176,7 +188,7 @@ export class MCPDevice {
         const config = await response.json();
         return {
             supabaseUrl: config.supabaseUrl,
-            anonKey: config.supabaseAnonKey
+            anonKey: config.supabasePublishableKey
         };
     }
     // Methods moved to RemoteChannel
@@ -185,12 +197,12 @@ export class MCPDevice {
         // Assuming database also renames agent_id to device_id, but user only said rename agent -> device everywhere but only inside src/remote-device
         // If the database column is still agent_id, we need a mapping.
         // However, the user said "literally all agent should be renamed to device everywhere", so we assume DB column is device_id.
-        const { id: call_id, tool_name, tool_args, device_id } = toolCall;
+        const { id: call_id, tool_name, tool_args, device_id, metadata = {} } = toolCall;
         // Only process jobs for this device
         if (device_id && device_id !== this.deviceId) {
             return;
         }
-        console.log(`🔧 Received tool call ${call_id}: ${tool_name} ${JSON.stringify(tool_args)}`);
+        console.log(`🔧 Received tool call ${call_id}: ${tool_name} ${JSON.stringify(tool_args)} metadata: ${JSON.stringify(metadata)}`);
         try {
             // Update call status to executing
             await this.remoteChannel.markCallExecuting(call_id);
@@ -220,7 +232,7 @@ export class MCPDevice {
             }
             else {
                 // Execute other tools using desktop integration
-                result = await this.desktop.executeTool(tool_name, tool_args);
+                result = await this.desktop.callClientTool(tool_name, tool_args, metadata);
             }
             console.log(`✅ Tool call ${tool_name} completed:\r\n ${JSON.stringify(result)}`);
             // Update database with result
@@ -240,8 +252,11 @@ export class MCPDevice {
         this.isShuttingDown = true;
         console.log('\n🛑 Shutting down device...');
         try {
-            // Remote shutdown
+            // Stop heartbeat first to prevent new operations
+            this.remoteChannel.stopHeartbeat();
+            // Unsubscribe from channel
             await this.remoteChannel.unsubscribe();
+            // Mark device offline
             await this.remoteChannel.setOffline(this.deviceId);
             // Shutdown desktop integration
             await this.desktop.shutdown();

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

@@ -42,6 +42,7 @@ export declare class RemoteChannel {
     updateCallResult(callId: string, status: string, result?: any, errorMessage?: string | null): Promise<void>;
     updateHeartbeat(deviceId: string): Promise<void>;
     startHeartbeat(deviceId: string): void;
+    stopHeartbeat(): void;
     setOffline(deviceId: string | null): Promise<void>;
     unsubscribe(): Promise<void>;
 }

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

@@ -79,7 +79,7 @@ export class RemoteChannel {
             await this.updateDevice(existingDevice.id, {
                 status: 'online',
                 last_seen: new Date().toISOString(),
-                capabilities: capabilities,
+                capabilities: {}, // Not used atm
                 device_name: deviceName
             });
             return existingDevice.id;
@@ -94,7 +94,7 @@ export class RemoteChannel {
             const { data: newDevice, error } = await this.createDevice({
                 user_id: userId,
                 device_name: deviceName,
-                capabilities: capabilities,
+                capabilities: {}, // Not used atm
                 status: 'online',
                 last_seen: new Date().toISOString()
             });
@@ -108,7 +108,7 @@ export class RemoteChannel {
     async subscribe(userId, onToolCall) {
         if (!this.client)
             throw new Error('Client not initialized');
-        console.debug(` - ⏳ Subscribing to call queue...`);
+        console.debug(` - ⏳ Subscribing to tool call channel...`);
         return new Promise((resolve, reject) => {
             if (!this.client)
                 return reject(new Error('Client not initialized'));
@@ -121,16 +121,16 @@ export class RemoteChannel {
             }, (payload) => onToolCall(payload))
                 .subscribe((status, err) => {
                 if (status === 'SUBSCRIBED') {
-                    console.debug(' - 🔌 Connected to call queue');
+                    console.debug(' - 🔌 Connected to tool call channel');
                     resolve();
                 }
                 else if (status === 'CHANNEL_ERROR') {
-                    console.error(' - ❌ Failed to connect to call queue:', err);
-                    reject(err || new Error('Failed to initialize call queue subscription'));
+                    console.error(' - ❌ Failed to connect to tool call channel:', err);
+                    reject(err || new Error('Failed to initialize tool call channel subscription'));
                 }
                 else if (status === 'TIMED_OUT') {
-                    console.error(' - ❌ Connection to call queue timed out');
-                    reject(new Error('Call queue subscription timed out'));
+                    console.error(' - ❌ Connection to tool call channel timed out');
+                    reject(new Error('Tool call channel subscription timed out'));
                 }
             });
         });
@@ -178,6 +178,12 @@ export class RemoteChannel {
             await this.updateHeartbeat(deviceId);
         }, HEARTBEAT_INTERVAL);
     }
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
     async setOffline(deviceId) {
         if (deviceId && this.client) {
             await this.client
@@ -189,10 +195,9 @@ export class RemoteChannel {
     }
     async unsubscribe() {
         if (this.channel) {
-            if (this.heartbeatInterval)
-                clearInterval(this.heartbeatInterval);
             await this.channel.unsubscribe();
-            console.log('✓ Unsubscribed from channel');
+            this.channel = null;
+            console.log('✓ Unsubscribed from tool call channel');
         }
     }
 }

package/dist/server.js

@@ -61,23 +61,34 @@ server.setRequestHandler(ListPromptsRequestSchema, async () => {
 });
 // Store current client info (simple variable)
 let currentClient = { name: 'uninitialized', version: 'uninitialized' };
+/**
+ * Unified way to update client information
+ */
+async function updateCurrentClient(clientInfo) {
+    if (clientInfo.name !== currentClient.name || clientInfo.version !== currentClient.version) {
+        const nameChanged = clientInfo.name !== currentClient.name;
+        currentClient = {
+            name: clientInfo.name || currentClient.name,
+            version: clientInfo.version || currentClient.version
+        };
+        // Configure transport for client-specific behavior only if name changed
+        if (nameChanged) {
+            const transport = global.mcpTransport;
+            if (transport && typeof transport.configureForClient === 'function') {
+                transport.configureForClient(currentClient.name);
+            }
+        }
+        return true;
+    }
+    return false;
+}
 // Add handler for initialization method - capture client info
 server.setRequestHandler(InitializeRequestSchema, async (request) => {
     try {
         // Extract and store current client information
         const clientInfo = request.params?.clientInfo;
         if (clientInfo) {
-            currentClient = {
-                name: clientInfo.name || 'unknown',
-                version: clientInfo.version || 'unknown'
-            };
-            // Configure transport for client-specific behavior
-            const transport = global.mcpTransport;
-            if (transport && typeof transport.configureForClient === 'function') {
-                transport.configureForClient(currentClient.name);
-            }
-            // Defer client connection message until after initialization
-            deferLog('info', `Client connected: ${currentClient.name} v${currentClient.version}`);
+            await updateCurrentClient(clientInfo);
             // Welcome page for new claude-ai users (A/B test controlled)
             if (currentClient.name === 'claude-ai' && !global.disableOnboarding) {
                 await handleWelcomePageOnboarding();
@@ -1032,8 +1043,24 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     const startTime = Date.now();
     try {
+        // Include _meta in debug log if present
         // Prepare telemetry data - add config key for set_config_value
         const telemetryData = { name };
+        // Extract metadata from _meta field if present
+        const metadata = request.params._meta;
+        if (metadata && typeof metadata === 'object') {
+            // add remote flag if present
+            if (metadata.remote) {
+                telemetryData.remote = metadata.remote;
+            }
+            // Dynamically update client info if provided in _meta
+            // To use in capture later
+            if (metadata.clientInfo) {
+                await updateCurrentClient(metadata.clientInfo);
+                telemetryData.client_name = metadata.clientInfo.name;
+                telemetryData.client_version = metadata.clientInfo.version;
+            }
+        }
         if (name === 'set_config_value' && args && typeof args === 'object' && 'key' in args) {
             telemetryData.set_config_value_key_name = args.key;
         }
@@ -1049,6 +1076,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
         }
         capture_call_tool('server_call_tool', telemetryData);
+        // console.log(`[TELEMETRY DEBUG] Captured for tool ${name}:`, JSON.stringify(telemetryData, null, 2));
         // Log every tool request name
         // logger.info(`Tool request: ${name}`, { toolName: name, timestamp: new Date().toISOString() });
         // Track tool call

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.2.29-alpha.4";
+export declare const VERSION = "0.2.29-alpha.6";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.2.29-alpha.4';
+export const VERSION = '0.2.29-alpha.6';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.2.29-alpha.4",
+  "version": "0.2.29-alpha.6",
   "description": "MCP server for terminal operations and file editing",
   "mcpName": "io.github.wonderwhy-er/desktop-commander",
   "license": "MIT",
@@ -85,10 +85,8 @@
     "@opendocsg/pdf2md": "^0.2.2",
     "@supabase/supabase-js": "^2.89.0",
     "@vscode/ripgrep": "^1.15.9",
-    "@wonderwhy-er/desktop-commander": "^0.2.29-alpha.2",
     "cross-fetch": "^4.1.0",
     "exceljs": "^4.4.0",
-    "express": "^4.22.1",
     "fastest-levenshtein": "^1.0.16",
     "file-type": "^21.1.1",
     "glob": "^10.3.10",
@@ -99,7 +97,6 @@
     "remark": "^15.0.1",
     "remark-gfm": "^4.0.1",
     "remark-parse": "^11.0.0",
-    "remote": "^0.2.6",
     "sharp": "^0.34.5",
     "unified": "^11.0.5",
     "unpdf": "^1.4.0",
@@ -108,7 +105,6 @@
   },
   "devDependencies": {
     "@anthropic-ai/mcpb": "^1.2.0",
-    "@types/express": "^5.0.6",
     "@types/node": "^20.17.24",
     "commander": "^13.1.0",
     "nexe": "^5.0.0-beta.4",

package/dist/remote-client.d.ts

@@ -1,44 +0,0 @@
-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

@@ -1,174 +0,0 @@
-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-sse-client.d.ts

@@ -1,45 +0,0 @@
-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

@@ -1,243 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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;
-}>;

package/dist/tools/remote-mcp.js

@@ -1,149 +0,0 @@
-import { RemoteSSEClient } from '../remote-sse-client.js';
-import { logger } from '../utils/logger.js';
-let remoteClient = null;
-export async function connectRemoteMCP(serverUrl, deviceToken) {
-    try {
-        // Disconnect existing client if any
-        if (remoteClient) {
-            logger.info('Disconnecting existing remote MCP client');
-            remoteClient.disconnect();
-        }
-        // Create new client
-        const config = {
-            serverUrl,
-            deviceToken,
-            retryInterval: 5000,
-            maxRetries: 3
-        };
-        logger.info(`Connecting to Remote MCP Server via SSE: ${serverUrl}`);
-        remoteClient = new RemoteSSEClient(config);
-        await remoteClient.connect();
-        const status = remoteClient.getStatus();
-        logger.info('Remote MCP connection successful', status);
-        return {
-            success: true,
-            message: `Connected to Remote MCP Server via SSE successfully. Device ID: ${status.deviceId}`,
-            status
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logger.error('Failed to connect to Remote MCP Server:', errorMessage);
-        return {
-            success: false,
-            message: `Failed to connect to Remote MCP Server: ${errorMessage}`
-        };
-    }
-}
-export function disconnectRemoteMCP() {
-    try {
-        if (remoteClient) {
-            logger.info('Disconnecting Remote MCP client');
-            remoteClient.disconnect();
-            remoteClient = null;
-            return {
-                success: true,
-                message: 'Disconnected from Remote MCP Server'
-            };
-        }
-        else {
-            return {
-                success: true,
-                message: 'No active Remote MCP connection to disconnect'
-            };
-        }
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logger.error('Error disconnecting Remote MCP:', errorMessage);
-        return {
-            success: false,
-            message: `Error disconnecting Remote MCP: ${errorMessage}`
-        };
-    }
-}
-export function getRemoteMCPStatus() {
-    if (!remoteClient) {
-        return {
-            connected: false,
-            authenticated: false,
-            deviceId: null,
-            message: 'No Remote MCP client initialized'
-        };
-    }
-    const status = remoteClient.getStatus();
-    let message = 'Remote MCP Status: ';
-    if (status.connected && status.authenticated) {
-        message += `Connected and authenticated. Device ID: ${status.deviceId}`;
-    }
-    else if (status.connected) {
-        message += 'Connected but not authenticated';
-    }
-    else {
-        message += 'Not connected';
-    }
-    return {
-        connected: status.connected,
-        authenticated: status.authenticated,
-        deviceId: status.deviceId,
-        message
-    };
-}
-export async function executeRemoteMCP(method, params) {
-    try {
-        if (!remoteClient) {
-            throw new Error('Remote MCP client not initialized. Use connect_remote_mcp first.');
-        }
-        if (!remoteClient.isConnectedAndAuthenticated()) {
-            throw new Error('Remote MCP SSE client not connected or authenticated. Check connection status.');
-        }
-        logger.info(`Executing remote MCP method: ${method}`, { params });
-        // Create MCP request
-        const mcpRequest = {
-            jsonrpc: '2.0',
-            id: `remote-${Date.now()}-${Math.random()}`,
-            method,
-            params: params || {}
-        };
-        // Send request and wait for response
-        const response = await remoteClient.sendMCPRequest(mcpRequest);
-        if (response.error) {
-            logger.error(`Remote MCP method ${method} failed:`, response.error);
-            return {
-                success: false,
-                error: `Remote MCP error: ${response.error.message} (code: ${response.error.code})`
-            };
-        }
-        logger.info(`Remote MCP method ${method} completed successfully`);
-        return {
-            success: true,
-            result: response.result
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logger.error(`Failed to execute remote MCP method ${method}:`, errorMessage);
-        return {
-            success: false,
-            error: `Failed to execute remote MCP: ${errorMessage}`
-        };
-    }
-}
-// Cleanup function to disconnect on process exit
-process.on('exit', () => {
-    if (remoteClient) {
-        remoteClient.disconnect();
-    }
-});
-process.on('SIGINT', () => {
-    if (remoteClient) {
-        remoteClient.disconnect();
-    }
-    process.exit(0);
-});
-process.on('SIGTERM', () => {
-    if (remoteClient) {
-        remoteClient.disconnect();
-    }
-    process.exit(0);
-});