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

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,6 @@
+import { MCPDevice } from '../remote-device/device.js';
+export async function runRemote() {
+    const persistSession = process.argv.includes('--persist-session');
+    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>;
+    executeTool(toolName: string, args: 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;
+    }>;
+    getCapabilities(): 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,136 @@
+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 executeTool(toolName, args) {
+        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`);
+            const result = await this.mcpClient.callTool({
+                name: toolName,
+                arguments: args
+            });
+            return result;
+        }
+        catch (error) {
+            console.error(`Error executing tool ${toolName}:`, error);
+            throw error;
+        }
+    }
+    async getCapabilities() {
+        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() {
+        if (this.mcpClient) {
+            try {
+                await this.mcpClient.close();
+            }
+            catch (e) {
+                console.error('Error closing MCP client:', e);
+            }
+            this.mcpClient = null;
+        }
+        if (this.mcpTransport) {
+            try {
+                await this.mcpTransport.close();
+            }
+            catch (e) {
+                console.error('Error closing MCP transport:', e);
+            }
+            this.mcpTransport = null;
+        }
+        this.isReady = false;
+    }
+}

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

@@ -0,0 +1,13 @@
+interface AuthSession {
+    access_token: string;
+    refresh_token: string | null;
+}
+export declare class DeviceAuthenticator {
+    private baseServerUrl;
+    constructor(baseServerUrl: string);
+    authenticate(): Promise<AuthSession>;
+    private isDesktopEnvironment;
+    private authenticateDesktop;
+    private authenticateHeadless;
+}
+export {};

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

@@ -0,0 +1,160 @@
+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);
+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;
+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();
+        }
+    }
+    isDesktopEnvironment() {
+        // Check if we're in a desktop environment
+        return process.platform === 'darwin' ||
+            process.platform === 'win32' ||
+            (process.platform === 'linux' && !!process.env.DISPLAY);
+    }
+    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) {
+                    const templatePath = path.join(__dirname, 'templates', 'auth-success.html');
+                    const htmlContent = fs.readFileSync(templatePath, 'utf8');
+                    res.send(htmlContent);
+                    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 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
+        });
+        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;
+                    }
+                }
+                catch (e) {
+                    // Not JSON, treat as raw token
+                }
+                if (trimmedInput.length < 10) {
+                    reject(new Error('Invalid token format (too short)'));
+                }
+                else {
+                    resolve({
+                        access_token: trimmedInput,
+                        refresh_token: null
+                    });
+                }
+            });
+        });
+    }
+}

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>;
+}

package/dist/remote-device/device.js

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+import { RemoteChannel } from './remote-channel.js';
+import { DeviceAuthenticator } from './device-authenticator.js';
+import { DesktopCommanderIntegration } from './desktop-commander-integration.js';
+import { fileURLToPath } from 'url';
+import os from 'os';
+import fs from 'fs/promises';
+import path from 'path';
+export class MCPDevice {
+    constructor(options = {}) {
+        this.baseServerUrl = process.env.MCP_SERVER_URL || 'https://mcp.desktopcommander.app';
+        this.remoteChannel = new RemoteChannel();
+        this.deviceId = null;
+        this.user = null;
+        this.isShuttingDown = false;
+        this.configPath = path.join(os.homedir(), '.desktop-commander-device', 'device.json');
+        this.persistSession = options.persistSession || false;
+        // Initialize desktop integration
+        this.desktop = new DesktopCommanderIntegration();
+        // Graceful shutdown handlers (only set once)
+        this.setupShutdownHandlers();
+    }
+    setupShutdownHandlers() {
+        const handleShutdown = async (signal) => {
+            if (this.isShuttingDown) {
+                console.log(`\n${signal} received, but already shutting down...`);
+                return;
+            }
+            this.isShuttingDown = true;
+            console.log(`\n${signal} received, initiating graceful shutdown...`);
+            // Force exit after 3 seconds if graceful shutdown hangs
+            const forceExit = setTimeout(() => {
+                console.error('⚠️ Graceful shutdown timed out, forcing exit...');
+                process.exit(1);
+            }, 3000);
+            try {
+                await this.shutdown();
+                clearTimeout(forceExit);
+                process.exit(0);
+            }
+            catch (error) {
+                console.error('Error during shutdown:', error);
+                process.exit(1);
+            }
+        };
+        process.on('SIGINT', () => {
+            handleShutdown('SIGINT');
+        });
+        process.on('SIGTERM', () => {
+            handleShutdown('SIGTERM');
+        });
+    }
+    async start() {
+        try {
+            console.log('🚀 Starting MCP Device...');
+            if (process.env.DEBUG_MODE === 'true') {
+                console.log(`  - 🐞 DEBUG_MODE`);
+            }
+            // Initialize desktop integration
+            await this.desktop.initialize();
+            console.log(`⏳ Connecting to Remote MCP ${this.baseServerUrl}`);
+            const { supabaseUrl, anonKey } = await this.fetchSupabaseConfig();
+            console.log(`   - 🔌 Connected to Remote MCP`);
+            // Initialize Remote Channel
+            this.remoteChannel.initialize(supabaseUrl, anonKey);
+            // Load persisted configuration (deviceId, session)
+            let session = await this.loadPersistedConfig();
+            // 2. Set Session or Authenticate
+            if (session) {
+                const { error } = await this.remoteChannel.setSession(session);
+                if (error) {
+                    console.log('   - ⚠️ Persisted session invalid:', error.message);
+                    session = null;
+                }
+                else {
+                    console.log('   - ✅ Session restored');
+                }
+            }
+            if (!session) {
+                console.log('\n🔐 Authenticating with Remote MCP server...');
+                const authenticator = new DeviceAuthenticator(this.baseServerUrl);
+                session = await authenticator.authenticate();
+                // Set session in Remote Channel
+                const { error } = await this.remoteChannel.setSession(session);
+                if (error)
+                    throw error;
+            }
+            // 3. Setup Token Refresh Listener
+            this.remoteChannel.onAuthStateChange(async (event, newSession) => {
+                const eventMap = {
+                    'SIGNED_IN': '🔑 User signed in',
+                    'TOKEN_REFRESHED': '🔄 Token refreshed',
+                    'SIGNED_OUT': '⚠️ User signed out',
+                };
+                if (eventMap[event]) {
+                    console.log(eventMap[event]);
+                }
+            });
+            // Force save the current session immediately to ensure it's persisted
+            const currentSessionStore = await this.remoteChannel.getSession();
+            await this.savePersistedConfig(currentSessionStore.data.session);
+            // Get user info
+            const { data: { user }, error: userError } = await this.remoteChannel.getUser();
+            if (userError)
+                throw userError;
+            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);
+            // 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(`   - Device ID:    ${this.deviceId}`);
+            console.log(`   - Device Name:  ${deviceName}`);
+            // Keep process alive
+            this.remoteChannel.startHeartbeat(this.deviceId);
+        }
+        catch (error) {
+            console.error(' - ❌ Device startup failed:', error.message);
+            if (error.stack && process.env.DEBUG_MODE === 'true') {
+                console.error('Stack trace:', error.stack);
+            }
+            await this.shutdown();
+            process.exit(1);
+        }
+    }
+    async loadPersistedConfig() {
+        try {
+            const data = await fs.readFile(this.configPath, 'utf8');
+            const config = JSON.parse(data);
+            this.deviceId = config?.deviceId;
+            console.log('💾 Found persisted session for device ' + this.deviceId);
+            if (config.session) {
+                return config.session;
+            }
+            return null;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.warn('⚠️ Failed to load config:', error.message);
+            }
+            return null;
+        }
+        finally {
+            // No need to ensure device ID here
+        }
+    }
+    async savePersistedConfig(session) {
+        try {
+            const config = {
+                deviceId: this.deviceId,
+                // Only save session if --persist-session flag is set
+                session: (session && this.persistSession) ? {
+                    access_token: session.access_token,
+                    refresh_token: session.refresh_token
+                } : null
+            };
+            // 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');
+        }
+        catch (error) {
+            console.error(' - ❌ Failed to save config:', error.message);
+        }
+    }
+    async fetchSupabaseConfig() {
+        // No auth header needed for this public endpoint
+        const response = await fetch(`${this.baseServerUrl}/api/mcp-info`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch Supabase config: ${response.statusText}`);
+        }
+        const config = await response.json();
+        return {
+            supabaseUrl: config.supabaseUrl,
+            anonKey: config.supabaseAnonKey
+        };
+    }
+    // Methods moved to RemoteChannel
+    async handleNewToolCall(payload) {
+        const toolCall = payload.new;
+        // 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;
+        // 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)}`);
+        try {
+            // Update call status to executing
+            await this.remoteChannel.markCallExecuting(call_id);
+            let result;
+            // Handle 'ping' tool specially
+            if (tool_name === 'ping') {
+                result = {
+                    content: [{
+                            type: 'text',
+                            text: `pong ${new Date().toISOString()}`
+                        }]
+                };
+            }
+            else if (tool_name === 'shutdown') {
+                result = {
+                    content: [{
+                            type: 'text',
+                            text: `Shutdown initialized at ${new Date().toISOString()}`
+                        }]
+                };
+                // Trigger shutdown after sending response
+                setTimeout(async () => {
+                    console.log('🛑 Remote shutdown requested. Exiting...');
+                    await this.shutdown();
+                    process.exit(0);
+                }, 1000);
+            }
+            else {
+                // Execute other tools using desktop integration
+                result = await this.desktop.executeTool(tool_name, tool_args);
+            }
+            console.log(`✅ Tool call ${tool_name} completed:\r\n ${JSON.stringify(result)}`);
+            // Update database with result
+            await this.remoteChannel.updateCallResult(call_id, 'completed', result);
+        }
+        catch (error) {
+            console.error(`❌ Tool call ${tool_name} failed:`, error.message);
+            await this.remoteChannel.updateCallResult(call_id, 'failed', null, error.message);
+        }
+    }
+    // Moved to RemoteChannel
+    // Moved to RemoteChannel
+    async shutdown() {
+        if (this.isShuttingDown) {
+            return;
+        }
+        this.isShuttingDown = true;
+        console.log('\n🛑 Shutting down device...');
+        try {
+            // Remote shutdown
+            await this.remoteChannel.unsubscribe();
+            await this.remoteChannel.setOffline(this.deviceId);
+            // Shutdown desktop integration
+            await this.desktop.shutdown();
+            console.log('✓ Device shutdown complete');
+        }
+        catch (error) {
+            console.error('Shutdown error:', error.message);
+        }
+    }
+}
+// Start device if called directly or as a bin command
+// When installed globally, npm creates a wrapper, so we need to check multiple conditions
+const isMainModule = process.argv[1] && (
+// Direct execution: node device.js
+import.meta.url === `file://${process.argv[1]}` ||
+    fileURLToPath(import.meta.url) === process.argv[1] ||
+    // Global bin execution: desktop-commander-device (npm creates a wrapper)
+    process.argv[1].endsWith('desktop-commander-device') ||
+    process.argv[1].endsWith('desktop-commander-device.js'));
+if (isMainModule) {
+    // Parse command-line arguments
+    const args = process.argv.slice(2);
+    const options = {
+        persistSession: args.includes('--persist-session')
+    };
+    if (options.persistSession) {
+        console.log('🔒 Session persistence enabled');
+    }
+    const device = new MCPDevice(options);
+    device.start();
+}

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

@@ -0,0 +1,48 @@
+import { Session, UserResponse } from '@supabase/supabase-js';
+export interface AuthSession {
+    access_token: string;
+    refresh_token: string | null;
+}
+interface DeviceData {
+    user_id: string;
+    device_name: string;
+    capabilities: any;
+    status: string;
+    last_seen: string;
+}
+export declare class RemoteChannel {
+    private client;
+    private channel;
+    private heartbeatInterval;
+    initialize(url: string, key: string): void;
+    setSession(session: AuthSession): Promise<{
+        error: any;
+    }>;
+    getSession(): Promise<{
+        data: {
+            session: Session | null;
+        };
+        error: any;
+    }>;
+    getUser(): Promise<UserResponse>;
+    onAuthStateChange(callback: (event: string, session: Session | null) => void): {
+        data: {
+            subscription: import("@supabase/supabase-js").Subscription;
+        };
+    };
+    findDevice(deviceId: string, userId: string): Promise<{
+        id: any;
+        device_name: any;
+    } | null>;
+    updateDevice(deviceId: string, updates: any): Promise<import("@supabase/postgrest-js").PostgrestSingleResponse<null>>;
+    createDevice(deviceData: DeviceData): Promise<import("@supabase/postgrest-js").PostgrestSingleResponse<any>>;
+    registerDevice(userId: string, capabilities: any, currentDeviceId: string | null, deviceName: string): Promise<string>;
+    subscribe(userId: string, onToolCall: (payload: any) => void): Promise<void>;
+    markCallExecuting(callId: string): Promise<void>;
+    updateCallResult(callId: string, status: string, result?: any, errorMessage?: string | null): Promise<void>;
+    updateHeartbeat(deviceId: string): Promise<void>;
+    startHeartbeat(deviceId: string): void;
+    setOffline(deviceId: string | null): Promise<void>;
+    unsubscribe(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,198 @@
+import { createClient } from '@supabase/supabase-js';
+const HEARTBEAT_INTERVAL = 30000;
+export class RemoteChannel {
+    constructor() {
+        this.client = null;
+        this.channel = null;
+        this.heartbeatInterval = null;
+    }
+    initialize(url, key) {
+        this.client = createClient(url, key);
+    }
+    async setSession(session) {
+        if (!this.client)
+            throw new Error('Client not initialized');
+        const { error } = await this.client.auth.setSession({
+            access_token: session.access_token,
+            refresh_token: session.refresh_token || ''
+        });
+        return { error };
+    }
+    async getSession() {
+        if (!this.client)
+            throw new Error('Client not initialized');
+        return await this.client.auth.getSession();
+    }
+    async getUser() {
+        if (!this.client)
+            throw new Error('Client not initialized');
+        return await this.client.auth.getUser();
+    }
+    onAuthStateChange(callback) {
+        if (!this.client)
+            throw new Error('Client not initialized');
+        return this.client.auth.onAuthStateChange(callback);
+    }
+    async findDevice(deviceId, userId) {
+        if (!this.client)
+            throw new Error('Client not initialized');
+        const { data, error } = await this.client
+            .from('mcp_devices')
+            .select('id, device_name')
+            .eq('id', deviceId)
+            .eq('user_id', userId)
+            .maybeSingle();
+        if (error)
+            throw error;
+        return data;
+    }
+    async updateDevice(deviceId, updates) {
+        if (!this.client)
+            throw new Error('Client not initialized');
+        return await this.client
+            .from('mcp_devices')
+            .update(updates)
+            .eq('id', deviceId);
+    }
+    async createDevice(deviceData) {
+        if (!this.client)
+            throw new Error('Client not initialized');
+        return await this.client
+            .from('mcp_devices')
+            .insert(deviceData)
+            .select()
+            .single();
+    }
+    async registerDevice(userId, capabilities, currentDeviceId, deviceName) {
+        let existingDevice = null;
+        if (currentDeviceId) {
+            try {
+                existingDevice = await this.findDevice(currentDeviceId, userId);
+            }
+            catch (e) {
+                // ignore error, treat as not found
+                console.warn('Error checking existing device:', e.message);
+            }
+        }
+        if (existingDevice) {
+            console.log(`🔍 Found existing device: ${existingDevice.device_name} (${existingDevice.id})`);
+            await this.updateDevice(existingDevice.id, {
+                status: 'online',
+                last_seen: new Date().toISOString(),
+                capabilities: capabilities,
+                device_name: deviceName
+            });
+            return existingDevice.id;
+        }
+        else {
+            if (currentDeviceId) {
+                console.log(`   - ⚠️ persisted deviceId ${currentDeviceId} not found for user ${userId}. Creating new device...`);
+            }
+            else {
+                console.log('   - 📝 No existing device found, creating new registration...');
+            }
+            const { data: newDevice, error } = await this.createDevice({
+                user_id: userId,
+                device_name: deviceName,
+                capabilities: capabilities,
+                status: 'online',
+                last_seen: new Date().toISOString()
+            });
+            if (error)
+                throw error;
+            console.log(`   - ✅ Device registered: ${newDevice.device_name}`);
+            console.log(`   - ✅ Assigned new Device ID: ${newDevice.id}`);
+            return newDevice.id;
+        }
+    }
+    async subscribe(userId, onToolCall) {
+        if (!this.client)
+            throw new Error('Client not initialized');
+        console.debug(` - ⏳ Subscribing to call queue...`);
+        return new Promise((resolve, reject) => {
+            if (!this.client)
+                return reject(new Error('Client not initialized'));
+            this.channel = this.client.channel('device_tool_call_queue')
+                .on('postgres_changes', {
+                event: 'INSERT',
+                schema: 'public',
+                table: 'mcp_remote_calls',
+                filter: `user_id=eq.${userId}`
+            }, (payload) => onToolCall(payload))
+                .subscribe((status, err) => {
+                if (status === 'SUBSCRIBED') {
+                    console.debug(' - 🔌 Connected to call queue');
+                    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'));
+                }
+                else if (status === 'TIMED_OUT') {
+                    console.error(' - ❌ Connection to call queue timed out');
+                    reject(new Error('Call queue subscription timed out'));
+                }
+            });
+        });
+    }
+    async markCallExecuting(callId) {
+        if (!this.client)
+            throw new Error('Client not initialized');
+        await this.client
+            .from('mcp_remote_calls')
+            .update({ status: 'executing' })
+            .eq('id', callId);
+    }
+    async updateCallResult(callId, status, result = null, errorMessage = null) {
+        if (!this.client)
+            throw new Error('Client not initialized');
+        const updateData = {
+            status: status,
+            completed_at: new Date().toISOString()
+        };
+        if (result !== null)
+            updateData.result = result;
+        if (errorMessage !== null)
+            updateData.error_message = errorMessage;
+        await this.client
+            .from('mcp_remote_calls')
+            .update(updateData)
+            .eq('id', callId);
+    }
+    async updateHeartbeat(deviceId) {
+        if (!this.client)
+            return;
+        try {
+            await this.client
+                .from('mcp_devices')
+                .update({ last_seen: new Date().toISOString() })
+                .eq('id', deviceId);
+        }
+        catch (error) {
+            console.error('Heartbeat failed:', error.message);
+        }
+    }
+    startHeartbeat(deviceId) {
+        // Update last_seen every 30 seconds
+        this.heartbeatInterval = setInterval(async () => {
+            await this.updateHeartbeat(deviceId);
+        }, HEARTBEAT_INTERVAL);
+    }
+    async setOffline(deviceId) {
+        if (deviceId && this.client) {
+            await this.client
+                .from('mcp_devices')
+                .update({ status: 'offline' })
+                .eq('id', deviceId);
+            console.log('✓ Device marked as offline');
+        }
+    }
+    async unsubscribe() {
+        if (this.channel) {
+            if (this.heartbeatInterval)
+                clearInterval(this.heartbeatInterval);
+            await this.channel.unsubscribe();
+            console.log('✓ Unsubscribed from channel');
+        }
+    }
+}

package/dist/version.d.ts

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

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.2.29-alpha.0",
+  "version": "0.2.29-alpha.1",
   "description": "MCP server for terminal operations and file editing",
   "mcpName": "io.github.wonderwhy-er/desktop-commander",
   "license": "MIT",
@@ -25,8 +25,8 @@
     "postinstall": "node dist/track-installation.js && node dist/npm-scripts/verify-ripgrep.js || node -e \"process.exit(0)\"",
     "open-chat": "open -n /Applications/Claude.app",
     "device:install": "cd src/remote-device && npm install",
-    "device:start": "cd src/remote-device && npm run device",
-    "device:dev": "cd src/remote-device && npm run device:dev",
+    "device:start": "tsx src/remote-device/device.ts",
+    "device:start:dev": "nodemon --watch src/remote-device --exec tsx src/remote-device/device.ts",
     "sync-version": "node scripts/sync-version.js",
     "bump": "node scripts/sync-version.js --bump",
     "bump:minor": "node scripts/sync-version.js --bump --minor",
@@ -83,14 +83,17 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.9.0",
     "@opendocsg/pdf2md": "^0.2.2",
+    "@supabase/supabase-js": "^2.89.0",
     "@vscode/ripgrep": "^1.15.9",
     "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",
     "isbinaryfile": "^5.0.4",
     "md-to-pdf": "^5.2.5",
+    "open": "^10.2.0",
     "pdf-lib": "^1.17.1",
     "remark": "^15.0.1",
     "remark-gfm": "^4.0.1",
@@ -103,11 +106,14 @@
   },
   "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",
     "nodemon": "^3.0.2",
     "shx": "^0.3.4",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.21.0",
     "typescript": "^5.3.3"
   }
 }