mobilecoder-mcp 1.0.4 → 2.0.0

package/src/tool-detector.ts

@@ -1,110 +0,0 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-const execAsync = promisify(exec);
-
-export interface DetectedTool {
-    id: string;
-    name: string;
-    version: string;
-    path: string;
-    isInstalled: boolean;
-}
-
-export class ToolDetector {
-    async detectAll(): Promise<DetectedTool[]> {
-        const tools = [
-            this.checkClaude(),
-            this.checkGemini(),
-            this.checkQoder(),
-            this.checkKiro(),
-            this.checkAider(),
-            this.checkCursor()
-        ];
-
-        const results = await Promise.all(tools);
-        return results.filter(t => t.isInstalled);
-    }
-
-    private async checkCommand(command: string): Promise<string | null> {
-        try {
-            const { stdout } = await execAsync(`${command} --version`);
-            return stdout.trim();
-        } catch {
-            return null;
-        }
-    }
-
-    private async checkClaude(): Promise<DetectedTool> {
-        const version = await this.checkCommand('claude');
-        return {
-            id: 'claude',
-            name: 'Claude Code',
-            version: version || '',
-            path: '',
-            isInstalled: !!version
-        };
-    }
-
-    private async checkGemini(): Promise<DetectedTool> {
-        const version = await this.checkCommand('gemini');
-        return {
-            id: 'gemini',
-            name: 'Gemini CLI',
-            version: version || '',
-            path: '',
-            isInstalled: !!version
-        };
-    }
-
-    private async checkQoder(): Promise<DetectedTool> {
-        const version = await this.checkCommand('qoder');
-        return {
-            id: 'qoder',
-            name: 'Qoder',
-            version: version || '',
-            path: '',
-            isInstalled: !!version
-        };
-    }
-
-    private async checkKiro(): Promise<DetectedTool> {
-        const version = await this.checkCommand('kiro');
-        return {
-            id: 'kiro',
-            name: 'Kiro',
-            version: version || '',
-            path: '',
-            isInstalled: !!version
-        };
-    }
-
-    private async checkAider(): Promise<DetectedTool> {
-        const version = await this.checkCommand('aider');
-        return {
-            id: 'aider',
-            name: 'Aider',
-            version: version || '',
-            path: '',
-            isInstalled: !!version
-        };
-    }
-
-    private async checkCursor(): Promise<DetectedTool> {
-        // Cursor is an app, not typically a CLI command for version checking in the same way
-        // We check for config file existence as a proxy for "installed/configured"
-        const configPath = path.join(os.homedir(), '.cursor', 'mcp.json');
-        const isInstalled = fs.existsSync(configPath);
-
-        return {
-            id: 'mcp', // Maps to 'mcp' in ToolSelector
-            name: 'Cursor',
-            version: 'App',
-            path: configPath,
-            isInstalled
-        };
-    }
-}

package/src/webrtc.ts

@@ -1,387 +0,0 @@
-import SimplePeer from 'simple-peer';
-import { createRequire } from 'module';
-import { createHash } from 'crypto';
-const require = createRequire(import.meta.url);
-
-// wrtc modülü Node.js ortamında WebRTC desteği sağlar
-let wrtc: any;
-try {
-  // Önce @roamhq/wrtc dene, sonra wrtc
-  wrtc = require('@roamhq/wrtc');
-} catch (e) {
-  try {
-    wrtc = require('wrtc');
-  } catch (e2) {
-    console.warn('⚠️  wrtc module not available, WebRTC may not work in Node.js environment');
-  }
-}
-
-// Simple HMAC implementation for Node.js
-function generateHMAC(data: string, secret: string): string {
-  return createHash('sha256').update(data + secret).digest('hex');
-}
-
-// Validate SDP for security
-function validateSDP(sdp: string): boolean {
-  if (!sdp || typeof sdp !== 'string') return false;
-
-  // Check for DTLS fingerprint (critical for encryption)
-  if (!sdp.includes('a=fingerprint:')) {
-    console.error('❌ [MCP] Invalid SDP: missing DTLS fingerprint');
-    return false;
-  }
-
-  // Check for DTLS setup
-  if (!sdp.includes('a=setup:')) {
-    console.error('❌ [MCP] Invalid SDP: missing DTLS setup');
-    return false;
-  }
-
-  return true;
-}
-
-export class WebRTCConnection {
-  private peer: SimplePeer.Instance | null = null;
-  private code: string;
-  private signalingUrl: string;
-  private isConnected: boolean = false;
-  private pollingInterval?: NodeJS.Timeout;
-  private onMessageCallback?: (message: any) => void;
-  private onConnectCallback?: () => void;
-  private onDisconnectCallback?: () => void;
-  private debug: boolean;
-  private hmacSecret: string;
-  private cleanupInterval?: NodeJS.Timeout;
-  private messageNonce = new Set<string>();
-
-  constructor(code: string, signalingUrl: string, debug: boolean = false) {
-    this.code = code;
-    this.signalingUrl = signalingUrl;
-    this.debug = debug;
-
-    // Generate HMAC secret for this session
-    this.hmacSecret = createHash('sha256')
-      .update(code + Date.now() + Math.random())
-      .digest('hex');
-
-    // Start cleanup interval
-    this.startCleanup();
-
-    // Validate signaling URL
-    try {
-      const url = new URL(signalingUrl);
-      if (!url.protocol.startsWith('https') && url.hostname !== 'localhost' && url.hostname !== '127.0.0.1') {
-        console.warn('⚠️  [MCP] Warning: Signaling URL should use HTTPS in production');
-      }
-    } catch (e) {
-      console.error('❌ [MCP] Invalid signaling URL:', signalingUrl);
-    }
-  }
-
-  private startCleanup(): void {
-    this.cleanupInterval = setInterval(() => {
-      // Clean up old nonces (prevent memory leak)
-      if (this.messageNonce.size > 1000) {
-        this.messageNonce.clear();
-      }
-    }, 60000); // Every minute
-  }
-
-
-  private async sendAnswerWithRetry(signal: any, attempts = 3): Promise<void> {
-    const timestamp = new Date().toLocaleTimeString();
-    const signalType = signal.type || (signal.candidate ? 'candidate' : 'answer');
-
-    // Use trickle endpoint for ICE candidates, standard answer endpoint for SDP answer
-    const endpoint = signal.candidate ? '/signaling/answer' : '/signaling/answer';
-
-    console.log(`[${timestamp}] 📤 [Desktop] Sending ${signalType} to server...`);
-
-    for (let i = 0; i < attempts; i++) {
-      try {
-        const response = await fetch(`${this.signalingUrl}${endpoint}`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ code: this.code, signal })
-        });
-
-        if (!response.ok) {
-          throw new Error(`Server returned ${response.status}`);
-        }
-
-        console.log(`[${timestamp}] ✅ [Desktop] ${signalType} sent. Waiting for P2P handshake...`);
-        return;
-      } catch (error) {
-        console.error(`[${timestamp}] ❌ [Desktop] Failed to send ${signalType} (Attempt ${i + 1}/${attempts}):`, error);
-        if (i < attempts - 1) {
-          await new Promise(r => setTimeout(r, 1000)); // Wait 1s
-        }
-      }
-    }
-    console.error(`[${timestamp}] ❌ [Desktop] Failed to send ${signalType} after all attempts.`);
-  }
-
-  async connect(): Promise<void> {
-    const timestamp = new Date().toLocaleTimeString();
-    console.log(`[${timestamp}] 📡 Connecting to signaling server: ${this.signalingUrl}`);
-    console.log(`[${timestamp}] 🔑 Using connection code: ${this.code}`);
-
-    return new Promise((resolve, reject) => {
-      try {
-        if (!wrtc) {
-          console.warn(`[${timestamp}] ⚠️  WebRTC initialized without Node.js native support (wrtc). This might fail.`);
-        }
-
-        // Fetch dynamic ICE servers from signaling backend
-        fetch(`${this.signalingUrl}/signaling/ice-servers`)
-          .then(res => res.json())
-          .then((data: any) => {
-            const rtcConfig = {
-              iceServers: data.iceServers || [
-                { urls: "stun:stun.l.google.com:19302" }
-              ],
-              iceCandidatePoolSize: 10,
-            };
-
-            this.peer = new SimplePeer({
-              initiator: false,
-              trickle: true,
-              wrtc: wrtc,
-              config: rtcConfig
-            });
-
-            this.setupPeerListeners(resolve, reject);
-          })
-          .catch(err => {
-            console.error(`[${timestamp}] ❌ Failed to fetch ICE servers:`, err);
-            // Fallback to basic STUN
-            this.peer = new SimplePeer({
-              initiator: false,
-              trickle: true,
-              wrtc: wrtc,
-              config: { iceServers: [{ urls: "stun:stun.l.google.com:19302" }] }
-            });
-            this.setupPeerListeners(resolve, reject);
-          });
-
-        console.log(`[${timestamp}] ⌛ Waiting for mobile device to initiate connection...`);
-        // Start polling for offer from mobile
-        this.startPollingForOffer();
-      } catch (error) {
-        console.error(`[${timestamp}] ❌ Initialization error:`, error);
-        reject(error);
-      }
-    });
-  }
-
-  private setupPeerListeners(resolve: any, reject: any) {
-    if (!this.peer) return;
-
-    // Monitor ICE connection state
-    this.peer.on('iceConnectionStateChange', () => {
-      const state = (this.peer as any)._pc?.iceConnectionState;
-      const timestamp = new Date().toLocaleTimeString();
-      console.log(`[${timestamp}] 🔍 ICE Connection State: ${state}`);
-
-      if (state === 'connected' || state === 'completed') {
-        const pc = (this.peer as any)._pc;
-        if (pc) {
-          // Validate SDP for security
-          const remoteDescription = pc.remoteDescription;
-          if (remoteDescription && !validateSDP(remoteDescription.sdp)) {
-            console.error('❌ [MCP] Remote SDP validation failed');
-            this.disconnect();
-            return;
-          }
-
-          pc.getStats().then((stats: any) => {
-            let usingRelay = false;
-            stats.forEach((report: any) => {
-              if (report.type === 'candidate-pair' && report.selected) {
-                const localCandidate = stats.get(report.localCandidateId);
-                if (localCandidate && localCandidate.candidateType === 'relay') usingRelay = true;
-              }
-            });
-            if (usingRelay) console.log(`[${timestamp}] 🌐 TURN relay is being used (IP leak protected)`);
-            else console.log(`[${timestamp}] ✅ Direct P2P connection established`);
-          });
-        }
-      } else if (state === 'failed' || state === 'disconnected') {
-        console.error(`[${timestamp}] ❌ ICE connection failed: ${state}`);
-        this.isConnected = false;
-      }
-    });
-
-    this.peer.on('signal', async (signal: any) => {
-      const timestamp = new Date().toLocaleTimeString();
-      const signalType = signal.type || (signal.candidate ? 'candidate' : 'unknown');
-      console.log(`[${timestamp}] 📡 [Desktop] Signal generated: ${signalType}`);
-
-      // Validate SDP before sending
-      if (signal.sdp && !validateSDP(signal.sdp)) {
-        console.error('❌ [MCP] Local SDP validation failed, not sending signal');
-        return;
-      }
-
-      // Send answer and trickle ICE candidates
-      await this.sendAnswerWithRetry(signal);
-    });
-
-    this.peer.on('connect', () => {
-      const timestamp = new Date().toLocaleTimeString();
-      console.log(`\n[${timestamp}] ✨ [ONLINE] Connected to mobile device!`);
-      this.isConnected = true;
-      if (this.onConnectCallback) this.onConnectCallback();
-      resolve();
-    });
-
-    this.peer.on('data', (data: any) => {
-      try {
-        const message = JSON.parse(data.toString());
-        this.handleIncomingMessage(message);
-      } catch (e) {
-        // Silent fail for invalid JSON
-      }
-    });
-
-    this.peer.on('error', (err: any) => {
-      console.error('❌ WebRTC error:', err);
-      this.isConnected = false;
-    });
-
-    this.peer.on('close', () => {
-      console.log('❌ Connection closed');
-      this.isConnected = false;
-    });
-  }
-
-  private handleIncomingMessage(message: any): void {
-    // Validate message structure
-    if (!message || typeof message !== 'object') {
-      console.warn('⚠️  [MCP] Invalid message structure');
-      return;
-    }
-
-    // Check for nonce to prevent replay attacks
-    if (message.nonce) {
-      if (this.messageNonce.has(message.nonce)) {
-        console.warn('⚠️  [MCP] Duplicate message detected (replay attack)');
-        return;
-      }
-      this.messageNonce.add(message.nonce);
-    }
-
-    // Verify HMAC if present
-    if (message.hmac) {
-      const data = JSON.stringify({
-        type: message.type,
-        text: message.text,
-        command: message.command,
-        timestamp: message.timestamp,
-        nonce: message.nonce
-      });
-      const expectedHMAC = generateHMAC(data, this.hmacSecret);
-
-      if (message.hmac !== expectedHMAC) {
-        console.error('❌ [MCP] HMAC verification failed');
-        return;
-      }
-    }
-
-    if (this.onMessageCallback) {
-      this.onMessageCallback(message);
-    }
-  }
-
-  private async startPollingForOffer(): Promise<void> {
-    let pollCount = 0;
-    const poll = async () => {
-      try {
-        // Stop if peer is connected or destroyed
-        if (this.peer && (this.peer as any).connected) {
-          if (this.pollingInterval) {
-            clearInterval(this.pollingInterval);
-            this.pollingInterval = undefined;
-          }
-          return;
-        }
-
-        pollCount++;
-        const response = await fetch(`${this.signalingUrl}/signaling/poll?code=${this.code}`);
-        const timestamp = new Date().toLocaleTimeString();
-
-        if (response.ok) {
-          const data = await response.json() as { signal?: any };
-          if (data.signal && this.peer) {
-            console.log(`[${timestamp}] 📥 Received signal from mobile device, applying...`);
-            this.peer.signal(data.signal);
-            // Don't clear interval, keep polling for trickle candidates
-          } else if (this.debug && pollCount % 10 === 0) {
-            console.log(`[${timestamp}] ⌛ Still waiting for signals (Poll #${pollCount})...`);
-          }
-        }
-      } catch (error) {
-        if (this.debug) {
-          console.error('❌ Error during polling:', error);
-        }
-      }
-    };
-
-    // Poll every 1.5 seconds
-    this.pollingInterval = setInterval(poll, 1500);
-    poll();
-  }
-
-  send(message: any): void {
-    if (this.peer && this.isConnected) {
-      try {
-        this.peer.send(JSON.stringify(message));
-      } catch (error) {
-        console.error('Failed to send message:', error);
-      }
-    } else {
-      console.warn('Cannot send message: not connected');
-    }
-  }
-
-  onMessage(callback: (message: any) => void): void {
-    this.onMessageCallback = callback;
-  }
-
-  onConnect(callback: () => void): void {
-    this.onConnectCallback = callback;
-  }
-
-  onDisconnect(callback: () => void): void {
-    this.onDisconnectCallback = callback;
-  }
-
-  disconnect(): void {
-    if (this.pollingInterval) {
-      clearInterval(this.pollingInterval);
-    }
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-    }
-    if (this.peer) {
-      this.peer.removeAllListeners();
-      this.peer.destroy();
-      this.peer = null;
-    }
-    this.isConnected = false;
-    this.messageNonce.clear();
-  }
-
-  // Cleanup method for proper resource disposal
-  destroy(): void {
-    this.disconnect();
-    this.onMessageCallback = undefined;
-    this.onConnectCallback = undefined;
-    this.onDisconnectCallback = undefined;
-  }
-
-  getConnected(): boolean {
-    return this.isConnected;
-  }
-}
-