mobilecoder-mcp 1.0.0

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "mobilecoder-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for MobileCoderMCP - enables mobile to desktop coding",
+  "main": "dist/index.js",
+  "bin": {
+    "mobile-coder-mcp": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "cursor",
+    "windsurf",
+    "mobile-coder"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "commander": "^12.1.0",
+    "qrcode-terminal": "^0.12.0",
+    "simple-peer": "^9.11.1",
+    "wrtc": "^0.4.7"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "@types/qrcode-terminal": "^0.12.2",
+    "@types/simple-peer": "^9.11.8",
+    "typescript": "^5.5.0"
+  }
+}

package/src/adapters/cli-adapter.ts

@@ -0,0 +1,73 @@
+import { spawn, ChildProcess } from 'child_process';
+import { platform } from 'os';
+
+export interface CLIResult {
+    output: string;
+    exitCode: number | null;
+}
+
+export class CLIAdapter {
+    private process: ChildProcess | null = null;
+    private onOutputCallback?: (data: string) => void;
+
+    constructor() { }
+
+    execute(command: string, args: string[] = [], cwd: string = process.cwd()): void {
+        const isWindows = platform() === 'win32';
+        const shell = isWindows ? 'powershell.exe' : '/bin/bash';
+        const shellArgs = isWindows ? ['-c', `${command} ${args.join(' ')}`] : ['-c', `${command} ${args.join(' ')}`];
+
+        console.log(`[CLI] Executing: ${command} ${args.join(' ')}`);
+
+        try {
+            this.process = spawn(shell, shellArgs, {
+                cwd,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: process.env
+            });
+
+            this.process.stdout?.on('data', (data) => {
+                const output = data.toString();
+                if (this.onOutputCallback) {
+                    this.onOutputCallback(output);
+                }
+            });
+
+            this.process.stderr?.on('data', (data) => {
+                const output = data.toString();
+                if (this.onOutputCallback) {
+                    this.onOutputCallback(output);
+                }
+            });
+
+            this.process.on('error', (error) => {
+                if (this.onOutputCallback) {
+                    this.onOutputCallback(`Error: ${error.message}\n`);
+                }
+            });
+
+            this.process.on('close', (code) => {
+                if (this.onOutputCallback) {
+                    this.onOutputCallback(`\n[Process exited with code ${code}]`);
+                }
+                this.process = null;
+            });
+
+        } catch (error: any) {
+            if (this.onOutputCallback) {
+                this.onOutputCallback(`Failed to start process: ${error.message}\n`);
+            }
+        }
+    }
+
+    onOutput(callback: (data: string) => void): void {
+        this.onOutputCallback = callback;
+    }
+
+    kill(): void {
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+        }
+    }
+}

package/src/agent.ts

@@ -0,0 +1,71 @@
+import { WebRTCConnection } from './webrtc';
+import { setupMCPServer } from './mcp-handler';
+import { CLIAdapter } from './adapters/cli-adapter';
+
+export class UniversalAgent {
+    private webrtc: WebRTCConnection;
+    private cliAdapter: CLIAdapter;
+    private activeTool: 'mcp' | 'cli' = 'mcp';
+
+    constructor(webrtc: WebRTCConnection) {
+        this.webrtc = webrtc;
+        this.cliAdapter = new CLIAdapter();
+    }
+
+    async start() {
+        console.log('🚀 Universal Agent starting...');
+
+        // Initialize MCP Server (Cursor integration)
+        // We run this in parallel because it sets up its own listeners
+        // Note: In the future, we might want to wrap this better
+        setupMCPServer(this.webrtc).catch(err => {
+            console.error('Failed to start MCP server:', err);
+        });
+
+        // Initialize CLI Adapter listeners
+        this.cliAdapter.onOutput((data) => {
+            this.webrtc.send({
+                type: 'cli_output',
+                data: data,
+                timestamp: Date.now()
+            });
+        });
+
+        // Override the WebRTC message handler to route commands
+        // We need to be careful not to conflict with mcp-handler's listeners
+        // Currently mcp-handler adds its own listener. SimplePeer supports multiple listeners.
+
+        this.webrtc.onMessage((message) => {
+            this.handleMessage(message);
+        });
+
+        try {
+            await this.webrtc.connect();
+        } catch (error) {
+            console.error('Failed to connect WebRTC:', error);
+        }
+    }
+
+    private handleMessage(message: any) {
+        // console.log('Universal Agent received:', message);
+
+        if (message.type === 'switch_tool') {
+            this.activeTool = message.tool;
+            console.log(`🔄 Switched active tool to: ${this.activeTool}`);
+
+            this.webrtc.send({
+                type: 'system',
+                message: `Switched to ${this.activeTool}`
+            });
+            return;
+        }
+
+        if (message.type === 'cli_command') {
+            const command = message.command;
+            console.log(`💻 Received CLI command: ${command}`);
+            this.cliAdapter.execute(command);
+        }
+
+        // MCP commands are handled by mcp-handler.ts directly via its own listener
+    }
+}

package/src/index.ts

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as qrcode from 'qrcode-terminal';
+import { UniversalAgent } from './agent';
+import { WebRTCConnection } from './webrtc';
+
+const program = new Command();
+
+program
+  .name('mobile-coder-mcp')
+  .description('MCP server for MobileCoderMCP - enables mobile to desktop coding')
+  .version('1.0.0');
+
+program
+  .command('init')
+  .description('Initialize connection, generate QR code and start the agent')
+  .option('-s, --signaling <url>', 'Signaling server URL', 'https://mcp-signal.workers.dev')
+  .action(async (options: { signaling: string }) => {
+    const code = generateConnectionCode();
+
+    console.log('\n📱 MobileCoder MCP - Quick Setup');
+    console.log('================================');
+    console.log(`\n🔑 Your Pairing Code: ${code}`);
+    console.log('Scan the QR code below with your mobile device to connect:\n');
+
+    // Generate QR code in terminal
+    // We use the full URL if we want to deep link, or just the code
+    const pairingUrl = `https://mobilecoder-mcp.app/connect?code=${code}`;
+    qrcode.generate(pairingUrl, { small: true });
+
+    console.log('\n🚀 Configuring IDEs...');
+    await autoConfigureIDEs(code, options.signaling);
+
+    console.log('\n🔌 Starting Universal Agent...');
+    const webrtc = new WebRTCConnection(code, options.signaling);
+    const agent = new UniversalAgent(webrtc);
+    await agent.start();
+  });
+
+program
+  .command('start')
+  .description('Start the Universal Agent with an existing code')
+  .option('-c, --code <code>', 'Connection code')
+  .option('-s, --signaling <url>', 'Signaling server URL', 'https://mcp-signal.workers.dev')
+  .action(async (options: { code?: string; signaling: string }) => {
+    if (!options.code) {
+      console.error('❌ Error: Connection code is required');
+      console.log('   Use: mobile-coder-mcp start --code=YOUR_CODE');
+      process.exit(1);
+    }
+
+    console.log('🔌 Starting Universal Agent...');
+    console.log(`   Connection code: ${options.code}`);
+    console.log(`   Signaling server: ${options.signaling}\n`);
+
+    const webrtc = new WebRTCConnection(options.code, options.signaling);
+    const agent = new UniversalAgent(webrtc);
+    await agent.start();
+  });
+
+program
+  .command('reset')
+  .description('Reset connection and remove config from all IDEs')
+  .option('-i, --ide <ide>', 'IDE to reset (cursor, windsurf, vscode, all)', 'all')
+  .action(async (options: { ide: string }) => {
+    console.log('🔄 Resetting MobileCoderMCP...\n');
+
+    const configs = {
+      cursor: path.join(os.homedir(), '.cursor', 'mcp.json'),
+      windsurf: path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json'),
+      vscode: path.join(os.homedir(), '.vscode', 'mcp.json'),
+    };
+
+    const ide = options.ide.toLowerCase();
+
+    if (ide === 'all') {
+      for (const [name, configPath] of Object.entries(configs)) {
+        await removeFromConfig(configPath, 'mobile-coder');
+      }
+    } else if (configs[ide as keyof typeof configs]) {
+      await removeFromConfig(configs[ide as keyof typeof configs], 'mobile-coder');
+    }
+
+    console.log('✅ Configuration reset complete\n');
+  });
+
+program.parse();
+
+function generateConnectionCode(): string {
+  return Math.random().toString(36).substring(2, 8).toUpperCase();
+}
+
+async function autoConfigureIDEs(code: string, signalingUrl: string) {
+  const configs = {
+    cursor: path.join(os.homedir(), '.cursor', 'mcp.json'),
+    windsurf: path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json'),
+    vscode: path.join(os.homedir(), '.vscode', 'mcp.json'),
+  };
+
+  for (const [name, configPath] of Object.entries(configs)) {
+    try {
+      await configureIDE(configPath, name, code, signalingUrl);
+    } catch (e) {
+      // Ignore if IDE config dir doesn't exist
+    }
+  }
+}
+
+async function configureIDE(configPath: string, ideName: string, code: string, signalingUrl: string) {
+  const configDir = path.dirname(configPath);
+  if (!fs.existsSync(configDir)) {
+    return; // Skip if IDE is not installed/configured
+  }
+
+  let config: any = { mcpServers: {} };
+  if (fs.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    } catch (e) {
+      console.warn(`⚠️  Could not read existing ${ideName} config, creating new one`);
+    }
+  }
+
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
+
+  // We assume the user has mobile-coder-mcp installed globally or via npx
+  // In npx context, we use the command name directly
+  config.mcpServers['mobile-coder'] = {
+    command: 'npx',
+    args: ['mobile-coder-mcp', 'start', '--code', code, '--signaling', signalingUrl],
+    env: {
+      MCP_CONNECTION_CODE: code,
+      MCP_SIGNALING_URL: signalingUrl
+    }
+  };
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log(`   ✅ ${ideName.charAt(0).toUpperCase() + ideName.slice(1)} linked.`);
+}
+
+async function removeFromConfig(configPath: string, serverName: string) {
+  if (!fs.existsSync(configPath)) {
+    return;
+  }
+
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    if (config.mcpServers && config.mcpServers[serverName]) {
+      delete config.mcpServers[serverName];
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+      console.log(`   ✅ Removed from ${path.basename(configPath)}`);
+    }
+  } catch (e) {
+    console.warn(`⚠️  Could not update ${configPath}`);
+  }
+}

package/src/mcp-handler.ts

@@ -0,0 +1,324 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types';
+import { WebRTCConnection } from './webrtc';
+import {
+  validatePath,
+  validateFile,
+  validateCommand,
+  sanitizeInput,
+  sanitizePath,
+  rateLimiters,
+  securityLogger,
+  generateSecureToken
+} from './security';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+
+// Queue to store commands received from mobile
+const commandQueue: string[] = [];
+
+export async function setupMCPServer(webrtc: WebRTCConnection): Promise<void> {
+  // Create MCP server
+  const server = new Server(
+    {
+      name: 'mobile-coder-mcp',
+      version: '1.0.0',
+    },
+    {
+      capabilities: {
+        tools: {},
+      },
+    }
+  );
+
+  // Set up error handling
+  server.onerror = (error: any) => {
+    console.error('[MCP Error]', error);
+    securityLogger.log('mcp_server_error', { error: error.message || 'Unknown error' }, 'medium');
+  };
+
+  // List available tools
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: [
+        {
+          name: 'get_next_command',
+          description: 'Get next pending command from mobile device',
+          inputSchema: {
+            type: 'object',
+            properties: {},
+          },
+        },
+        {
+          name: 'send_message',
+          description: 'Send a message or status update to mobile device',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              message: {
+                type: 'string',
+                description: 'The message to send to user',
+              },
+            },
+            required: ['message'],
+          },
+        },
+        {
+          name: 'list_directory',
+          description: 'List files and directories in a path',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              path: {
+                type: 'string',
+                description: 'The directory path to list (relative to cwd)',
+              },
+            },
+          },
+        },
+        {
+          name: 'read_file',
+          description: 'Read contents of a file',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              path: {
+                type: 'string',
+                description: 'The file path to read',
+              },
+            },
+            required: ['path'],
+          },
+        },
+      ],
+    };
+  });
+
+  // Handle tool calls from MCP (Claude/Cursor)
+  server.setRequestHandler(CallToolRequestSchema, async (request: any) => {
+    const { name, arguments: args } = request.params;
+
+    if (name === 'get_next_command') {
+      const command = commandQueue.shift();
+      if (!command) {
+        return { content: [{ type: 'text', text: 'No pending commands.' }] };
+      }
+      return { content: [{ type: 'text', text: command }] };
+    }
+
+    if (name === 'send_message') {
+      const message = (args as { message?: string })?.message;
+      if (!message) {
+        return { content: [{ type: 'text', text: 'Error: Message is required' }], isError: true };
+      }
+
+      // Sanitize message content
+      const sanitizedMessage = sanitizeInput(message);
+
+      // Check if message contains diff data
+      if (typeof args === 'object' && (args as any).diff) {
+        webrtc.send({
+          type: 'result',
+          data: {
+            diff: (args as any).diff,
+            oldCode: (args as any).oldCode,
+            newCode: (args as any).newCode,
+            fileName: (args as any).fileName
+          },
+          timestamp: Date.now()
+        });
+      } else {
+        webrtc.send({ type: 'result', data: sanitizedMessage, timestamp: Date.now() });
+      }
+
+      return { content: [{ type: 'text', text: `Message sent to mobile: ${typeof args === 'object' ? 'Diff data' : sanitizedMessage}` }] };
+    }
+
+    if (name === 'list_directory') {
+      try {
+        const requestId = generateSecureToken(16);
+        const fileList = await handleListDirectory(process.cwd(), args as any, requestId);
+        return { content: [{ type: 'text', text: JSON.stringify(fileList) }] };
+      } catch (error: any) {
+        return { content: [{ type: 'text', text: error.message }], isError: true };
+      }
+    }
+
+    if (name === 'read_file') {
+      try {
+        const requestId = generateSecureToken(16);
+        const content = await handleReadFile(process.cwd(), args as any, requestId);
+        return { content: [{ type: 'text', text: content }] };
+      } catch (error: any) {
+        return { content: [{ type: 'text', text: error.message }], isError: true };
+      }
+    }
+
+    return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+  });
+
+  // Connect WebRTC listeners
+  webrtc.onConnect(() => {
+    console.log('📱 [MCP] Mobile device connected');
+    securityLogger.log('mobile_device_connected', { timestamp: Date.now() }, 'low');
+  });
+
+  webrtc.onMessage(async (message: any) => {
+    // Handle command queueing
+    if (message.type === 'command' && message.text) {
+      const sanitizedCommand = sanitizeInput(message.text);
+
+      // Rate limiting
+      if (!rateLimiters.commands.isAllowed('command')) {
+        securityLogger.logRateLimitExceeded('command', 'queue_command');
+        webrtc.send({
+          type: 'error',
+          data: 'Rate limit exceeded. Please try again later.',
+          timestamp: Date.now()
+        });
+        return;
+      }
+
+      // Command validation
+      const commandValidation = validateCommand(sanitizedCommand);
+      if (!commandValidation.valid) {
+        securityLogger.logBlockedCommand(sanitizedCommand, commandValidation.error || 'Unknown reason');
+        webrtc.send({
+          type: 'error',
+          data: 'Command blocked for security reasons.',
+          timestamp: Date.now()
+        });
+        return;
+      }
+
+      console.log(`   [MCP] Queuing command: ${sanitizedCommand}`);
+      commandQueue.push(sanitizedCommand);
+    }
+
+    // Handle direct tool calls from mobile (for File Explorer)
+    if (message.type === 'tool_call') {
+      const { tool, data, id } = message;
+      console.log(`🛠️ [MCP] Tool call received: ${tool}`, data);
+
+      try {
+        let result;
+        if (tool === 'list_directory') {
+          result = await handleListDirectory(process.cwd(), data, id);
+        } else if (tool === 'read_file') {
+          result = await handleReadFile(process.cwd(), data, id);
+        } else {
+          throw new Error(`Unknown tool: ${tool}`);
+        }
+
+        webrtc.send({
+          type: 'tool_result',
+          id: id, // Echo back ID for correlation
+          tool: tool,
+          data: result,
+          timestamp: Date.now()
+        });
+      } catch (error: any) {
+        console.error(`❌ [MCP] Tool execution failed: ${error.message}`);
+        securityLogger.log('tool_execution_failed', { tool, error: error.message }, 'medium');
+        webrtc.send({
+          type: 'tool_result',
+          id: id,
+          tool: tool,
+          error: error.message,
+          timestamp: Date.now()
+        });
+      }
+    }
+  });
+
+  // Start MCP server with stdio transport
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  console.log('✅ MCP Server initialized (stdio transport)');
+  securityLogger.log('mcp_server_started', { timestamp: Date.now() }, 'low');
+}
+
+// Helper functions for file system operations
+async function handleListDirectory(cwd: string, args: { path?: string }, requestId?: string) {
+  const dirPath = args?.path || '.';
+  const sanitizedPath = sanitizePath(dirPath);
+
+  // Rate limiting
+  if (!rateLimiters.fileOperations.isAllowed(requestId || 'unknown')) {
+    securityLogger.logRateLimitExceeded(requestId || 'unknown', 'list_directory');
+    throw new Error('Rate limit exceeded for directory operations');
+  }
+
+  // Security validation
+  const pathValidation = validatePath(sanitizedPath, cwd);
+  if (!pathValidation.valid) {
+    securityLogger.logPathTraversal(sanitizedPath, path.resolve(cwd, sanitizedPath));
+    throw new Error(`Access denied: ${pathValidation.error}`);
+  }
+
+  try {
+    const stats = await fs.promises.stat(path.resolve(cwd, sanitizedPath));
+    if (!stats.isDirectory()) {
+      throw new Error('Path is not a directory');
+    }
+
+    const files = await fs.promises.readdir(path.resolve(cwd, sanitizedPath), { withFileTypes: true });
+    const fileList = files.map((f) => ({
+      name: f.name,
+      isDirectory: f.isDirectory(),
+      path: path.join(sanitizedPath, f.name).replace(/\\/g, '/'), // Normalize paths
+    }));
+
+    // Sort: directories first, then files
+    fileList.sort((a, b) => {
+      if (a.isDirectory === b.isDirectory) {
+        return a.name.localeCompare(b.name);
+      }
+      return a.isDirectory ? -1 : 1;
+    });
+
+    return fileList;
+  } catch (error: any) {
+    securityLogger.log('directory_list_error', { path: sanitizedPath, error: error.message }, 'medium');
+    throw new Error(`Error listing directory: ${error.message}`);
+  }
+}
+
+async function handleReadFile(cwd: string, args: { path?: string }, requestId?: string) {
+  const filePath = args?.path;
+  if (!filePath) throw new Error('Path is required');
+
+  const sanitizedPath = sanitizePath(filePath);
+
+  // Rate limiting
+  if (!rateLimiters.fileOperations.isAllowed(requestId || 'unknown')) {
+    securityLogger.logRateLimitExceeded(requestId || 'unknown', 'read_file');
+    throw new Error('Rate limit exceeded for file operations');
+  }
+
+  // Security validation
+  const fileValidation = validateFile(sanitizedPath, cwd);
+  if (!fileValidation.valid) {
+    securityLogger.log('file_access_denied', { path: sanitizedPath, reason: fileValidation.error }, 'high');
+    throw new Error(`Access denied: ${fileValidation.error}`);
+  }
+
+  try {
+    const fullPath = path.resolve(cwd, sanitizedPath);
+    const stats = await fs.promises.stat(fullPath);
+    if (stats.isDirectory()) {
+      throw new Error('Path is a directory, not a file');
+    }
+
+    return await fs.promises.readFile(fullPath, 'utf-8');
+  } catch (error: any) {
+    securityLogger.log('file_read_error', { path: sanitizedPath, error: error.message }, 'medium');
+    throw new Error(`Error reading file: ${error.message}`);
+  }
+}