mobilecoder-mcp 1.0.4 → 2.0.0

package/src/mcp-handler.ts

@@ -1,327 +0,0 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
-import { WebRTCConnection } from './webrtc.js';
-import {
-  validatePath,
-  validateFile,
-  validateCommand,
-  sanitizeInput,
-  sanitizePath,
-  safeResolvePath,
-  rateLimiters,
-  securityLogger,
-  generateSecureToken
-} from './security.js';
-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: 'mobilecoder-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 resolvedPath = await safeResolvePath(cwd, sanitizedPath);
-    const stats = await fs.promises.stat(resolvedPath);
-    if (!stats.isDirectory()) {
-      throw new Error('Path is not a directory');
-    }
-
-    const files = await fs.promises.readdir(resolvedPath, { 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 resolvedPath = await safeResolvePath(cwd, sanitizedPath);
-    const stats = await fs.promises.stat(resolvedPath);
-    if (stats.isDirectory()) {
-      throw new Error('Path is a directory, not a file');
-    }
-
-    return await fs.promises.readFile(resolvedPath, 'utf-8');
-  } catch (error: any) {
-    securityLogger.log('file_read_error', { path: sanitizedPath, error: error.message }, 'medium');
-    throw new Error(`Error reading file: ${error.message}`);
-  }
-}
-

package/src/security.ts

@@ -1,345 +0,0 @@
-import * as crypto from 'crypto';
-import * as fs from 'fs';
-import * as path from 'path';
-
-// Security configuration
-export const SECURITY_CONFIG = {
-  maxFileSize: 10 * 1024 * 1024, // 10MB
-  maxRequestsPerMinute: 60,
-  maxRequestsPerHour: 1000,
-  allowedFileExtensions: ['.ts', '.js', '.jsx', '.tsx', '.json', '.md', '.txt', '.yml', '.yaml', '.env.example'],
-  blockedPaths: [
-    '.git',
-    'node_modules',
-    '.env',
-    '.env.local',
-    '.env.development',
-    '.env.production',
-    'dist',
-    'build',
-    '.next',
-    '.nuxt',
-    '.cache',
-    'tmp',
-    'temp'
-  ],
-  blockedFilePatterns: [
-    /\.key$/,
-    /\.pem$/,
-    /\.crt$/,
-    /\.p12$/,
-    /private/i,
-    /secret/i,
-    /password/i,
-    /token/i,
-    /\.log$/,
-    /\.pid$/,
-    /\.lock$/,
-  ]
-};
-
-// Rate limiting
-class RateLimiter {
-  private requests = new Map<string, { count: number; resetTime: number; lastReset: number }>();
-
-  constructor(private maxRequests: number, private windowMs: number) { }
-
-  isAllowed(identifier: string): boolean {
-    const now = Date.now();
-    const entry = this.requests.get(identifier);
-
-    if (!entry) {
-      this.requests.set(identifier, {
-        count: 1,
-        resetTime: now + this.windowMs,
-        lastReset: now
-      });
-      return true;
-    }
-
-    // Reset if window expired
-    if (now > entry.resetTime) {
-      entry.count = 1;
-      entry.resetTime = now + this.windowMs;
-      entry.lastReset = now;
-      return true;
-    }
-
-    if (entry.count >= this.maxRequests) {
-      return false;
-    }
-
-    entry.count++;
-    return true;
-  }
-
-  cleanup(): void {
-    const now = Date.now();
-    for (const [key, entry] of this.requests.entries()) {
-      if (now > entry.resetTime) {
-        this.requests.delete(key);
-      }
-    }
-  }
-}
-
-export const rateLimiters = {
-  perMinute: new RateLimiter(SECURITY_CONFIG.maxRequestsPerMinute, 60 * 1000),
-  perHour: new RateLimiter(SECURITY_CONFIG.maxRequestsPerHour, 60 * 60 * 1000),
-  fileOperations: new RateLimiter(30, 60 * 1000),
-  commands: new RateLimiter(10, 60 * 1000)
-};
-
-// Allowed commands for MCP agent
-export const ALLOWED_COMMANDS = new Set([
-  'npm', 'yarn', 'pnpm', 'git', 'docker', 'docker-compose', 'claude-code', 'gemini', 'qoder',
-  'node', 'python', 'python3', 'pip', 'pipx', 'cargo', 'brew', 'echo', 'ls', 'pwd',
-  'cat', 'mkdir', 'touch', 'rmdir', 'mv', 'cp', 'test', 'grep', 'find'
-]);
-
-// Input validation
-export async function safeResolvePath(base: string, userInput: string): Promise<string> {
-  const resolved = path.resolve(base, userInput);
-
-  // Follow symlinks and get the real absolute path
-  try {
-    const realPath = fs.realpathSync(resolved);
-    const realBase = fs.realpathSync(path.resolve(base));
-
-    if (!realPath.startsWith(realBase)) {
-      securityLogger.logPathTraversal(userInput, realPath);
-      throw new Error('Path traversal attempt detected');
-    }
-    return realPath;
-  } catch (err: any) {
-    if (err.code === 'ENOENT') {
-      // If path doesn't exist yet (e.g. creating a new file), just check the parent
-      const parentDir = path.dirname(resolved);
-      try {
-        const realParent = fs.realpathSync(parentDir);
-        const realBase = fs.realpathSync(path.resolve(base));
-        if (!realParent.startsWith(realBase)) {
-          throw new Error('Path traversal attempt detected (parent)');
-        }
-        return resolved;
-      } catch (parentErr) {
-        throw new Error(`Invalid path: ${err.message}`);
-      }
-    }
-    throw err;
-  }
-}
-
-export function validatePath(filePath: string, cwd: string): { valid: boolean; error?: string } {
-  // Normalize path
-  const normalizedPath = path.normalize(filePath);
-
-  // Check for blocked paths in components
-  const pathParts = normalizedPath.split(path.sep);
-  for (const part of pathParts) {
-    if (SECURITY_CONFIG.blockedPaths.includes(part)) {
-      return { valid: false, error: `Access to ${part} is not allowed` };
-    }
-  }
-
-  // Check for blocked file patterns
-  for (const pattern of SECURITY_CONFIG.blockedFilePatterns) {
-    if (pattern.test(normalizedPath)) {
-      return { valid: false, error: 'Access to sensitive files is not allowed' };
-    }
-  }
-
-  return { valid: true };
-}
-
-export function validateFile(filePath: string, cwd: string): { valid: boolean; error?: string } {
-  const pathValidation = validatePath(filePath, cwd);
-  if (!pathValidation.valid) {
-    return pathValidation;
-  }
-
-  // Check file extension
-  const ext = path.extname(filePath).toLowerCase();
-  if (!ext || !SECURITY_CONFIG.allowedFileExtensions.includes(ext)) {
-    // Also allow files without extension if they are in the allowed list (like .gitignore)
-    const basename = path.basename(filePath);
-    if (!['.gitignore', '.mcprules', 'package.json', 'README.md'].includes(basename)) {
-      return { valid: false, error: `File type ${ext} or name ${basename} is not allowed` };
-    }
-  }
-
-  // Check file size if exists
-  const fullPath = path.resolve(cwd, filePath);
-  try {
-    const stats = fs.statSync(fullPath);
-    if (stats.size > SECURITY_CONFIG.maxFileSize) {
-      return { valid: false, error: 'File too large' };
-    }
-  } catch {
-    // File doesn't exist, that's ok
-  }
-
-  return { valid: true };
-}
-
-export function validateCommand(command: string): { valid: boolean; error?: string } {
-  const trimmedCmd = command.trim();
-  const firstWord = trimmedCmd.split(/\s+/)[0].toLowerCase();
-
-  // Check against allow-list
-  if (!ALLOWED_COMMANDS.has(firstWord)) {
-    return { valid: false, error: `Command '${firstWord}' is not in the allow-list` };
-  }
-
-  // Check for command injection/chaining characters
-  const forbiddenChars = [';', '&', '|', '`', '$('];
-  for (const char of forbiddenChars) {
-    if (trimmedCmd.includes(char)) {
-      return { valid: false, error: `Forbidden character detected: ${char}` };
-    }
-  }
-
-  // Check for dangerous patterns as a second layer
-  const dangerousPatterns = [
-    /\brm\s+-rf\b/i,
-    /\bsudo\b/i,
-    /\bsu\s/i,
-    /\bchmod\s+777\b/i,
-    /\bwget\b|\bcurl\b/i,
-    /\bnc\s|\bnetcat\b/i,
-    /\bssh\b/i,
-    /\bscp\b/i,
-    /\brsync\b/i,
-    /\bdd\s+if=/i,
-    /\bmkfs\b/i,
-    /\bfdisk\b/i,
-    /\bmount\b/i,
-    /\bumount\b/i,
-    /\bpasswd\b/i,
-    /\bshadow\b/i,
-    /\bcrontab\b/i,
-    /\bsystemctl\b/i,
-    /\bservice\s/i,
-    /\bkill\s+-9\b/i,
-    /\bkillall\b/i,
-    />\s*\/dev\/null/,
-    />\s*\/dev\/(zero|random|urandom)/,
-  ];
-
-  for (const pattern of dangerousPatterns) {
-    if (pattern.test(command)) {
-      return { valid: false, error: 'Dangerous command detected' };
-    }
-  }
-
-  return { valid: true };
-}
-
-// Sanitization
-export function sanitizeInput(input: string): string {
-  return input
-    .replace(/[<>]/g, '') // Remove HTML tags
-    .replace(/[\x00-\x1f\x7f]/g, '') // Remove control characters
-    .replace(/[\r\n\t]/g, ' ') // Replace newlines and tabs
-    .trim()
-    .substring(0, 5000); // Increased limit slightly for large diffs
-}
-
-export function sanitizePath(input: string): string {
-  return input
-    .replace(/\.\./g, '') // Basic protection, safeResolvePath does the heavy lifting
-    .replace(/[<>:"|?*]/g, '') // Remove invalid characters
-    .trim();
-}
-
-// Security logging
-export class SecurityLogger {
-  private static instance: SecurityLogger;
-  private logFile: string;
-
-  private constructor() {
-    this.logFile = path.join(process.cwd(), '.security.log');
-  }
-
-  static getInstance(): SecurityLogger {
-    if (!SecurityLogger.instance) {
-      SecurityLogger.instance = new SecurityLogger();
-    }
-    return SecurityLogger.instance;
-  }
-
-  log(event: string, details: any, severity: 'low' | 'medium' | 'high' = 'medium'): void {
-    const logEntry = {
-      timestamp: new Date().toISOString(),
-      event,
-      details,
-      severity,
-      pid: process.pid,
-      user: process.env.USER || 'unknown'
-    };
-
-    const logLine = JSON.stringify(logEntry) + '\n';
-
-    try {
-      fs.appendFileSync(this.logFile, logLine);
-    } catch (error) {
-      console.error('Failed to write security log:', error);
-    }
-
-    // Also log to console for immediate visibility
-    if (severity === 'high') {
-      console.error('🚨 SECURITY ALERT:', logEntry);
-    } else if (severity === 'medium') {
-      console.warn('⚠️  SECURITY WARNING:', logEntry);
-    } else {
-      console.log('ℹ️  SECURITY INFO:', logEntry);
-    }
-  }
-
-  logBlockedCommand(command: string, reason: string): void {
-    this.log('blocked_command', { command, reason }, 'high');
-  }
-
-  logPathTraversal(attemptedPath: string, resolvedPath: string): void {
-    this.log('path_traversal', { attemptedPath, resolvedPath }, 'high');
-  }
-
-  logRateLimitExceeded(identifier: string, operation: string): void {
-    this.log('rate_limit_exceeded', { identifier, operation }, 'medium');
-  }
-
-  logSuspiciousActivity(activity: string, details: any): void {
-    this.log('suspicious_activity', { activity, details }, 'medium');
-  }
-}
-
-export const securityLogger = SecurityLogger.getInstance();
-
-// Cleanup old rate limit entries periodically
-setInterval(() => {
-  rateLimiters.perMinute.cleanup();
-  rateLimiters.perHour.cleanup();
-  rateLimiters.fileOperations.cleanup();
-  rateLimiters.commands.cleanup();
-}, 5 * 60 * 1000); // Every 5 minutes
-
-// Generate secure tokens
-export function generateSecureToken(length: number = 32): string {
-  return crypto.randomBytes(length).toString('hex');
-}
-
-// Validate session tokens
-export function validateSessionToken(token: string): boolean {
-  // Basic token validation
-  if (!token || typeof token !== 'string') {
-    return false;
-  }
-
-  // Check length
-  if (token.length < 16 || token.length > 128) {
-    return false;
-  }
-
-  // Check format (hex)
-  return /^[a-f0-9]+$/.test(token);
-}