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

package/dist/remote-device/device.js

@@ -0,0 +1,308 @@
+#!/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 = undefined;
+        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...`);
+                // Force exit if we get multiple signals
+                process.exit(1);
+                return;
+            }
+            console.log(`\n${signal} received, initiating graceful shutdown...`);
+            // Force exit after 5 seconds if graceful shutdown hangs
+            const forceExit = setTimeout(() => {
+                console.error('\n⚠️ Graceful shutdown timed out, forcing exit...');
+                process.exit(1);
+            }, 5000);
+            try {
+                await this.shutdown();
+                clearTimeout(forceExit);
+                process.exit(0);
+            }
+            catch (error) {
+                console.error('Error during shutdown:', error);
+                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').catch((error) => {
+                console.error('Fatal error during shutdown:', error);
+                process.exit(1);
+            });
+        });
+        process.on('SIGTERM', () => {
+            handleShutdown('SIGTERM').catch((error) => {
+                console.error('Fatal error during shutdown:', error);
+                process.exit(1);
+            });
+        });
+    }
+    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(this.deviceId);
+                if (session.device_id) {
+                    if (!this.deviceId) {
+                        console.log(`   - ✅ Device ID assigned: ${session.device_id}`);
+                    }
+                    else if (this.deviceId !== session.device_id) {
+                        console.log(`   - ⚠️ Device ID changed: ${this.deviceId} → ${session.device_id}`);
+                    }
+                    else {
+                        console.log(`   - ✅ Device ID authenticated: ${session.device_id}`);
+                    }
+                    this.deviceId = session.device_id;
+                }
+                // 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
+            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
+            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 ' + this.configPath);
+        }
+        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.supabasePublishableKey
+        };
+    }
+    // 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, 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)} metadata: ${JSON.stringify(metadata)}`);
+        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.callClientTool(tool_name, tool_args, metadata);
+            }
+            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 {
+            // Stop heartbeat first to prevent new operations
+            console.log('  → Stopping heartbeat...');
+            this.remoteChannel.stopHeartbeat();
+            console.log('  ✓ Heartbeat stopped');
+            // Unsubscribe from channel
+            console.log('  → Unsubscribing from channel...');
+            await this.remoteChannel.unsubscribe();
+            // Mark device offline
+            console.log('  → Marking device offline...');
+            await this.remoteChannel.setOffline(this.deviceId);
+            // Shutdown desktop integration
+            console.log('  → Shutting down desktop integration...');
+            await this.desktop.shutdown();
+            console.log('  ✓ Desktop integration shut down');
+            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,51 @@
+import { Session, UserResponse } from '@supabase/supabase-js';
+export interface AuthSession {
+    access_token: string;
+    refresh_token: string | null;
+    device_id?: string;
+}
+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 | undefined, deviceName: string): Promise<void>;
+    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;
+    stopHeartbeat(): void;
+    setOnlineStatus(deviceId: string, status: 'online' | 'offline'): Promise<void>;
+    setOffline(deviceId: string | undefined): Promise<void>;
+    unsubscribe(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,255 @@
+import { createClient } from '@supabase/supabase-js';
+const HEARTBEAT_INTERVAL = 15000;
+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) {
+            existingDevice = await this.findDevice(currentDeviceId, userId);
+        }
+        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: {}, // Not used atm
+                device_name: deviceName
+            });
+        }
+        else {
+            console.error(`   - ❌ Device not found: ${currentDeviceId}`);
+            throw new Error(`Device not found: ${currentDeviceId}`);
+        }
+    }
+    async subscribe(userId, onToolCall) {
+        if (!this.client)
+            throw new Error('Client not initialized');
+        console.debug(` - ⏳ Subscribing to tool call channel...`);
+        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 tool call channel');
+                    this.setOnlineStatus(userId, 'online');
+                    resolve();
+                }
+                else if (status === 'CHANNEL_ERROR') {
+                    // console.error(' - ❌ Failed to connect to tool call channel:', err);
+                    this.setOnlineStatus(userId, 'offline');
+                    reject(err || new Error('Failed to initialize tool call channel subscription'));
+                }
+                else if (status === 'TIMED_OUT') {
+                    // console.error(' - ❌ Connection to tool call channel timed out');
+                    this.setOnlineStatus(userId, 'offline');
+                    reject(new Error('Tool call channel 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);
+            // console.log(`🔌 Heartbeat sent for device: ${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);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+    async setOnlineStatus(deviceId, status) {
+        if (!this.client)
+            return;
+        const { error } = await this.client
+            .from('mcp_devices')
+            .update({ status: status, last_seen: new Date().toISOString() })
+            .eq('id', deviceId);
+        if (error) {
+            console.error('Failed to update device status:', error.message);
+            return;
+        }
+        console.log(status === 'online' ? `🔌 Device marked as ${status}` : `❌ Device marked as ${status}`);
+    }
+    async setOffline(deviceId) {
+        if (!deviceId || !this.client) {
+            return;
+        }
+        // console.log('🔍 [setOffline] Initiating blocking update...');
+        try {
+            // Get current session for the subprocess
+            const { data: sessionData } = await this.client.auth.getSession();
+            if (!sessionData?.session?.access_token) {
+                console.error('❌ No valid session for offline update');
+                return;
+            }
+            // Get Supabase config from client
+            const supabaseUrl = this.client.supabaseUrl;
+            const supabaseKey = this.client.supabaseKey;
+            if (!supabaseUrl || !supabaseKey) {
+                console.error('❌ Missing Supabase configuration');
+                return;
+            }
+            // Use spawnSync to run the blocking update script
+            const { spawnSync } = await import('child_process');
+            const { fileURLToPath } = await import('url');
+            const path = await import('path');
+            // Get the script path relative to this file
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = path.dirname(__filename);
+            const scriptPath = path.join(__dirname, 'scripts', 'blocking-offline-update.js');
+            const result = spawnSync('node', [
+                scriptPath,
+                deviceId,
+                supabaseUrl,
+                supabaseKey,
+                sessionData.session.access_token,
+                sessionData.session.refresh_token || ''
+            ], {
+                timeout: 3000,
+                stdio: 'pipe', // Capture output to prevent blocking
+                encoding: 'utf-8'
+            });
+            // Log subprocess output (with encoding:'utf-8', these are already strings)
+            if (result.stdout && result.stdout.trim()) {
+                console.log(result.stdout.trim());
+            }
+            if (result.stderr && result.stderr.trim()) {
+                console.error(result.stderr.trim());
+            }
+            // Handle exit codes
+            if (result.error) {
+                console.error('❌ Failed to spawn update process:', result.error.message);
+            }
+            else if (result.status === 0) {
+                console.log('✓ Device marked as offline (blocking)');
+            }
+            else if (result.status === 2) {
+                console.warn('⚠️ Device offline update timed out');
+            }
+            else if (result.signal) {
+                console.error(`❌ Update process killed by signal: ${result.signal}`);
+            }
+            else {
+                console.error(`❌ Update process failed with exit code: ${result.status}`);
+            }
+        }
+        catch (error) {
+            console.error('❌ Error in blocking offline update:', error.message);
+        }
+    }
+    async unsubscribe() {
+        if (this.channel) {
+            await this.channel.unsubscribe();
+            this.channel = null;
+            console.log('✓ Unsubscribed from tool call channel');
+        }
+    }
+}

package/dist/remote-device/scripts/blocking-offline-update.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+/**
+ * Blocking script to update device status to offline
+ * Runs synchronously during shutdown to ensure DB update completes
+ * 
+ * Usage: node blocking-offline-update.js <deviceId> <supabaseUrl> <supabaseKey> <accessToken> <refreshToken>
+ */
+
+import { createClient } from '@supabase/supabase-js';
+
+// Parse command line arguments
+const [deviceId, supabaseUrl, supabaseKey, accessToken, refreshToken] = process.argv.slice(2);
+
+if (!deviceId || !supabaseUrl || !supabaseKey || !accessToken || !refreshToken) {
+    console.error('❌ Missing required arguments');
+    console.error('Usage: node blocking-offline-update.js <deviceId> <supabaseUrl> <supabaseKey> <accessToken> <refreshToken>');
+    process.exit(1);
+}
+
+// Set timeout for entire operation
+const TIMEOUT_MS = 3000;
+const timeoutHandle = setTimeout(() => {
+    console.error('⏱️ Timeout: Update took too long');
+    process.exit(2); // Exit code 2 for timeout
+}, TIMEOUT_MS);
+
+try {
+    // Create Supabase client
+    const client = createClient(supabaseUrl, supabaseKey);
+
+    // Set session using access token and refresh token
+    const { error: authError } = await client.auth.setSession({
+        access_token: accessToken,
+        refresh_token: refreshToken
+    });
+
+    if (authError) {
+        console.error('❌ Auth error:', authError.message);
+        clearTimeout(timeoutHandle);
+        process.exit(3); // Exit code 3 for auth error
+    }
+
+    // Update device status to offline
+    const { data, error } = await client
+        .from('mcp_devices')
+        .update({ status: 'offline' })
+        .eq('id', deviceId);
+
+    clearTimeout(timeoutHandle);
+
+    if (error) {
+        console.error('❌ DB update error:', error.message);
+        process.exit(4); // Exit code 4 for DB error
+    }
+
+    console.log('✓ Device marked as offline');
+    process.exit(0); // Success
+
+} catch (error) {
+    clearTimeout(timeoutHandle);
+    console.error('❌ Unexpected error:', error.message);
+    process.exit(5); // Exit code 5 for unexpected error
+}

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

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