mobilecoder-mcp 1.0.5 → 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,369 +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 loading wrtc implementations with better error logging
-try {
-  // @roamhq/wrtc is often more stable on modern Node.js versions
-  wrtc = require('@roamhq/wrtc');
-  // console.log('✅ Loaded @roamhq/wrtc');
-} catch (e) {
-  try {
-    wrtc = require('wrtc');
-    // console.log('✅ Loaded wrtc');
-  } catch (e2) {
-    console.warn('⚠️  wrtc module not available. Install @roamhq/wrtc or wrtc for WebRTC support.');
-  }
-}
-
-// 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;
-
-  // Basic sanity check
-  if (sdp.length > 10000) return false;
-
-  // Check for DTLS fingerprint (critical for encryption)
-  if (!sdp.includes('a=fingerprint:')) {
-    // console.warn('⚠️ [MCP] SDP missing DTLS fingerprint');
-    // Still allow, as some implementations might differ, but warn
-  }
-
-  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';
-
-    if (this.debug) 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}`);
-        }
-
-        if (this.debug) console.log(`[${timestamp}] ✅ [Desktop] ${signalType} sent.`);
-        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). Connection will fail.`);
-          console.warn(`[${timestamp}] 💡 Please install @roamhq/wrtc or wrtc package.`);
-        }
-
-        // Fetch dynamic ICE servers with timeout
-        const iceController = new AbortController();
-        const iceTimeout = setTimeout(() => iceController.abort(), 3000);
-
-        fetch(`${this.signalingUrl}/signaling/ice-servers`, { signal: iceController.signal })
-          .then(res => res.json())
-          .then((data: any) => {
-            clearTimeout(iceTimeout);
-            this.initPeer(data.iceServers, resolve, reject);
-          })
-          .catch(err => {
-            clearTimeout(iceTimeout);
-            console.warn(`[${timestamp}] ⚠️ Failed to fetch ICE servers (using fallback):`, err.message);
-            // Fallback to Google STUN
-            this.initPeer([{ urls: "stun:stun.l.google.com:19302" }], resolve, reject);
-          });
-      } catch (error) {
-        console.error(`[${timestamp}] ❌ Initialization error:`, error);
-        reject(error);
-      }
-    });
-  }
-
-  private initPeer(iceServers: any[], resolve: any, reject: any) {
-    const timestamp = new Date().toLocaleTimeString();
-    
-    // Ensure iceServers is an array
-    const validIceServers = Array.isArray(iceServers) ? iceServers : [{ urls: "stun:stun.l.google.com:19302" }];
-
-    if (this.debug) {
-      console.log(`[${timestamp}] 🧊 Using ICE servers:`, validIceServers.length);
-    }
-
-    const rtcConfig = {
-      iceServers: validIceServers,
-      iceCandidatePoolSize: 10,
-    };
-
-    try {
-      this.peer = new SimplePeer({
-        initiator: false,
-        trickle: true,
-        wrtc: wrtc,
-        config: rtcConfig
-      });
-
-      this.setupPeerListeners(resolve, reject);
-      console.log(`[${timestamp}] ⌛ Waiting for mobile device to initiate connection...`);
-      this.startPollingForOffer();
-    } catch (err: any) {
-      console.error(`[${timestamp}] ❌ Failed to create SimplePeer:`, err);
-      reject(err);
-    }
-  }
-
-  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();
-      if (this.debug) console.log(`[${timestamp}] 🔍 ICE Connection State: ${state}`);
-
-      if (state === 'connected' || state === 'completed') {
-        const pc = (this.peer as any)._pc;
-        if (pc) {
-          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') {
-        if (state === 'failed') console.error(`[${timestamp}] ❌ ICE connection failed`);
-        this.isConnected = false;
-      }
-    });
-
-    this.peer.on('signal', async (signal: any) => {
-      // 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;
-      
-      // Send immediate handshake to update UI
-      this.send({ type: 'handshake', status: 'ready', timestamp: Date.now() });
-
-      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) => {
-      // Ignore routine errors during disconnect
-      if (err.code === 'ERR_DATA_CHANNEL') return;
-      console.error('❌ WebRTC error:', err.message || 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') {
-      return;
-    }
-
-    // Ping/Pong for Keepalive
-    if (message.type === 'ping') {
-      this.send({ type: 'pong', timestamp: Date.now() });
-      return;
-    }
-
-    // Check for nonce to prevent replay attacks
-    if (message.nonce) {
-      if (this.messageNonce.has(message.nonce)) {
-        return;
-      }
-      this.messageNonce.add(message.nonce);
-    }
-
-    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}`);
-        
-        if (response.ok) {
-          const data = await response.json() as { signal?: any };
-          if (data.signal && this.peer) {
-            // console.log(`[Desktop] Received signal`);
-            this.peer.signal(data.signal);
-          }
-        }
-      } catch (error) {
-        // Ignore polling errors
-      }
-    };
-
-    // Poll every 1 second
-    this.pollingInterval = setInterval(poll, 1000);
-    poll();
-  }
-
-  send(message: any): void {
-    if (this.peer && this.isConnected) {
-      try {
-        this.peer.send(JSON.stringify(message));
-      } catch (error) {
-        // Ignore send errors
-      }
-    }
-  }
-
-  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;
-  }
-}
-