@wonderwhy-er/desktop-commander
Version:
MCP server for terminal operations and file editing
425 lines (424 loc) • 18.8 kB
JavaScript
import { createClient } from '@supabase/supabase-js';
import { captureRemote } from '../utils/capture.js';
const HEARTBEAT_INTERVAL = 15000;
export class RemoteChannel {
constructor() {
this.client = null;
this.channel = null;
this.heartbeatInterval = null;
this.connectionCheckInterval = null;
// Store subscription parameters for channel recreation
this.deviceId = null;
this.onToolCall = null;
// Track last device status to prevent duplicate log messages
this.lastDeviceStatus = 'offline';
// Track last channel state for debug logging
this.lastChannelState = null;
this._user = null;
}
get user() { return this._user; }
initialize(url, key) {
this.client = createClient(url, key);
}
async setSession(session) {
if (!this.client)
throw new Error('Client not initialized');
console.debug('[DEBUG] RemoteChannel.setSession() called, has refresh_token:', !!session.refresh_token);
const { error } = await this.client.auth.setSession({
access_token: session.access_token,
refresh_token: session.refresh_token || ''
});
if (error) {
console.error('[DEBUG] Failed to set session:', error.message);
await captureRemote('remote_channel_set_session_error', { error });
return { error };
}
// Get user info
const { data: { user }, error: userError } = await this.client.auth.getUser();
if (userError) {
console.error('[DEBUG] Failed to get user:', userError.message);
await captureRemote('remote_channel_get_user_error', { error: userError });
throw userError;
}
if (!user) {
const noUserError = new Error('No user returned after setSession');
console.error('[DEBUG] No user returned:', noUserError.message);
await captureRemote('remote_channel_get_user_empty', {});
throw noUserError;
}
this._user = user;
console.debug('[DEBUG] Session set successfully, user:', user.email);
return { error };
}
async getSession() {
if (!this.client)
throw new Error('Client not initialized');
return await this.client.auth.getSession();
}
async findDevice(deviceId) {
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', this.user?.id)
.maybeSingle();
if (error) {
console.error('[DEBUG] Failed to find device:', error.message);
await captureRemote('remote_channel_find_device_error', { error });
throw error;
}
return data;
}
async updateDevice(deviceId, updates) {
if (!this.client)
throw new Error('Client not initialized');
const { data, error } = await this.client
.from('mcp_devices')
.update(updates)
.eq('id', deviceId)
.select();
if (error) {
console.error('[DEBUG] Failed to update device:', error.message);
await captureRemote('remote_channel_update_device_error', { error });
}
else {
console.debug('[DEBUG] Device updated successfully');
}
return { data, error };
}
async createDevice(deviceData) {
if (!this.client)
throw new Error('Client not initialized');
const { data, error } = await this.client
.from('mcp_devices')
.insert(deviceData)
.select()
.single();
if (error) {
console.error('[DEBUG] Failed to create device:', error.message);
await captureRemote('remote_channel_create_device_error', { error });
throw error;
}
console.debug('[DEBUG] Device created successfully');
return { data, error };
}
async registerDevice(capabilities, currentDeviceId, deviceName, onToolCall) {
console.debug('[DEBUG] RemoteChannel.registerDevice() called, deviceId:', currentDeviceId);
let existingDevice = null;
if (currentDeviceId && this.user) {
console.debug('[DEBUG] Finding existing device...');
existingDevice = await this.findDevice(currentDeviceId);
console.debug('[DEBUG] Existing device found:', !!existingDevice);
}
if (existingDevice) {
console.debug('[DEBUG] Updating device status to online');
await this.updateDevice(existingDevice.id, {
status: 'online',
last_seen: new Date().toISOString(),
capabilities: {}, // TODO: Capabilities are not yet implemented; keep this empty object for schema compatibility until device capabilities are defined and stored.
device_name: deviceName
});
// Store parameters for channel recreation
this.deviceId = existingDevice.id;
this.onToolCall = onToolCall;
console.debug(`⏳ Subscribing to tool call channel...`);
// Create and subscribe to the channel
console.debug('[DEBUG] Calling createChannel()');
// ! Ignore silently in Initialization to reconnect after
await this.createChannel().catch((error) => {
console.debug('[DEBUG] Failed to create channel, will retry after socket reconnect', error);
});
}
else {
console.error(` - ❌ Device not found: ${currentDeviceId}`);
await captureRemote('remote_channel_register_device_error', { error: 'Device not found', deviceId: currentDeviceId });
throw new Error(`Device not found: ${currentDeviceId}`);
}
}
/**
* Create and subscribe to the channel.
* This is used for both initial subscription and recreation after socket reconnects.
*/
createChannel() {
return new Promise((resolve, reject) => {
if (!this.client || !this.user?.id || !this.onToolCall) {
console.debug('[DEBUG] createChannel() failed - missing prerequisites');
return reject(new Error('Client not initialized or missing subscription parameters'));
}
console.debug('[DEBUG] Creating channel: device_tool_call_queue');
this.channel = this.client.channel('device_tool_call_queue')
.on('postgres_changes', {
event: 'INSERT',
schema: 'public',
table: 'mcp_remote_calls',
filter: `user_id=eq.${this.user.id}`
}, (payload) => {
console.debug('[DEBUG] Realtime event received, payload:', payload?.new?.id);
if (this.onToolCall) {
this.onToolCall(payload);
}
})
.subscribe((status, err) => {
// Debug: Log all subscription status events
console.debug(`[DEBUG] Channel subscription status: ${status}${err ? ' (error: ' + err + ')' : ''}`);
if (status === 'SUBSCRIBED') {
console.log('✅ Channel subscribed');
// Update device status on successful connection
if (this.deviceId) {
this.setOnlineStatus(this.deviceId, 'online').catch(e => {
console.error('Failed to set online status:', e.message);
});
}
resolve();
}
else if (status === 'CHANNEL_ERROR') {
// console.error('❌ Channel subscription failed:', err);
this.setOnlineStatus(this.deviceId, 'offline');
captureRemote('remote_channel_subscription_error', { error: err || 'Channel error' }).catch(() => { });
reject(err || new Error('Failed to initialize tool call channel subscription'));
}
else if (status === 'TIMED_OUT') {
console.error('⏱️ Channel subscription timed out, Reconnecting...');
this.setOnlineStatus(this.deviceId, 'offline');
captureRemote('remote_channel_subscription_timeout', {}).catch(() => { });
reject(new Error('Tool call channel subscription timed out'));
}
});
});
}
/**
* Check if channel is connected, recreate if not.
*/
checkConnectionHealth() {
if (!this.channel || !this.client || !this.user?.id || !this.onToolCall) {
return;
}
const state = this.channel.state;
// Debug: Log current channel state (only if changed)
if (!this.lastChannelState || this.lastChannelState !== state) {
console.debug(`[DEBUG] channel state: ${state}`);
this.lastChannelState = state;
}
// Aggressive health check: Only 'joined' is considered healthy
// Any other state (joining, leaving, closed, errored, etc.) triggers recreation
if (state !== 'joined') {
captureRemote('remote_channel_state_health', { state });
console.debug(`[DEBUG] ⚠️ Channel in unhealthy state '${state}' - recreating...`);
this.recreateChannel();
}
}
/**
* Recreate the channel by destroying old one and creating fresh instance.
*/
recreateChannel() {
if (!this.client || !this.user?.id || !this.onToolCall) {
console.warn('Cannot recreate channel - missing parameters');
console.debug('[DEBUG] recreateChannel() aborted - missing prerequisites');
return;
}
// Destroy old channel
if (this.channel) {
console.debug('[DEBUG] Destroying old channel');
this.client.removeChannel(this.channel);
this.channel = null;
}
// Create fresh channel
console.log('🔄 Recreating channel...');
console.debug('[DEBUG] Calling createChannel() for recreation');
this.createChannel().catch(err => {
captureRemote('remote_channel_recreate_error', { err });
console.debug('[DEBUG] Channel recreation failed:', err.message);
// TODO: enable only for debug mode
// console.error('Failed to recreate channel:', err);
});
}
async markCallExecuting(callId) {
if (!this.client)
throw new Error('Client not initialized');
const { error } = await this.client
.from('mcp_remote_calls')
.update({ status: 'executing' })
.eq('id', callId);
if (error) {
console.error('[DEBUG] Failed to mark call executing:', error.message);
await captureRemote('remote_channel_mark_call_executing_error', { error });
}
else {
console.debug('[DEBUG] Call marked executing:', 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;
console.debug('[DEBUG] Updating call result:', updateData);
const { data, error } = await this.client
.from('mcp_remote_calls')
.update(updateData)
.eq('id', callId);
if (error) {
console.error('[DEBUG] Failed to update call result:', error.message);
await captureRemote('remote_channel_update_call_result_error', { error });
}
else {
console.debug('[DEBUG] Call result updated successfully:', data);
}
}
async updateHeartbeat(deviceId) {
if (!this.client)
return;
try {
const { error } = await this.client
.from('mcp_devices')
.update({ last_seen: new Date().toISOString() })
.eq('id', deviceId);
if (error) {
console.error('[DEBUG] Heartbeat update failed:', error.message);
await captureRemote('remote_channel_heartbeat_error', { error });
}
// console.log(`🔌 Heartbeat sent for device: ${deviceId}`);
}
catch (error) {
console.error('Heartbeat failed:', error.message);
await captureRemote('remote_channel_heartbeat_error', { error });
}
}
startHeartbeat(deviceId) {
console.debug('[DEBUG] Starting heartbeat for device:', deviceId);
this.connectionCheckInterval = setInterval(() => {
this.checkConnectionHealth();
}, 10000);
// Update last_seen every 15 seconds
this.heartbeatInterval = setInterval(async () => {
await this.updateHeartbeat(deviceId);
}, HEARTBEAT_INTERVAL);
console.debug('[DEBUG] Heartbeat intervals set - connectionCheck: 10s, heartbeat: 15s');
}
stopHeartbeat() {
if (this.heartbeatInterval) {
clearInterval(this.heartbeatInterval);
this.heartbeatInterval = null;
}
if (this.connectionCheckInterval) {
clearInterval(this.connectionCheckInterval);
this.connectionCheckInterval = null;
}
}
async setOnlineStatus(deviceId, status) {
if (!this.client)
return;
// Only log if status changed
if (this.lastDeviceStatus !== status) {
console.log(`🔌 Device marked as ${status}`);
this.lastDeviceStatus = status;
}
const { error } = await this.client
.from('mcp_devices')
.update({ status: status, last_seen: new Date().toISOString() })
.eq('id', deviceId);
if (error) {
console.error(`[DEBUG] Failed to set status ${status}:`, error.message);
if (status == "online") {
console.error('Failed to update device status:', error.message);
}
await captureRemote('remote_channel_status_update_error', { error, status });
return;
}
else {
console.debug(`[DEBUG] Device status set to ${status}`);
}
// console.log(status === 'online' ? `🔌 Device marked as ${status}` : `❌ Device marked as ${status}`);
}
async setOffline(deviceId) {
if (!deviceId || !this.client) {
console.debug('[DEBUG] setOffline() skipped - no deviceId or client');
return;
}
console.debug('[DEBUG] setOffline() initiating blocking update for device:', deviceId);
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');
console.debug('[DEBUG] Session data missing or invalid');
return;
}
// Get Supabase config from client
const supabaseUrl = this.client.supabaseUrl;
const supabaseKey = this.client.supabaseKey;
if (!supabaseUrl || !supabaseKey) {
console.error('❌ Missing Supabase configuration');
console.debug('[DEBUG] supabaseUrl or supabaseKey is missing');
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');
console.debug('[DEBUG] Spawning blocking update script:', scriptPath);
console.debug('[DEBUG] Using node executable:', process.execPath);
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'
});
console.debug('[DEBUG] spawnSync completed, exit code:', result.status, 'signal:', result.signal);
// 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);
console.debug('[DEBUG] spawn error:', result.error);
}
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);
console.debug('[DEBUG] setOffline() error stack:', error.stack);
await captureRemote('remote_channel_offline_update_error', { error });
}
}
async unsubscribe() {
if (this.channel) {
await this.channel.unsubscribe();
this.channel = null;
console.log('✓ Unsubscribed from tool call channel');
}
}
}