shell-mirror 1.0.0

package/lib/health-checker.js

@@ -0,0 +1,192 @@
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+
+const execAsync = promisify(exec);
+
+class HealthChecker {
+  constructor() {
+    this.configDir = path.join(os.homedir(), '.terminal-mirror');
+    this.envFile = path.join(process.cwd(), '.env');
+  }
+
+  async run() {
+    console.log('🏥 Terminal Mirror Health Check');
+    console.log('─'.repeat(40));
+    console.log('');
+
+    const checks = [
+      { name: 'Node.js Version', check: () => this.checkNodeVersion() },
+      { name: 'Configuration Files', check: () => this.checkConfigFiles() },
+      { name: 'Environment Variables', check: () => this.checkEnvironment() },
+      { name: 'Network Connectivity', check: () => this.checkNetwork() },
+      { name: 'Dependencies', check: () => this.checkDependencies() },
+      { name: 'Port Availability', check: () => this.checkPort() },
+      { name: 'Google OAuth Setup', check: () => this.checkOAuth() },
+      { name: 'Permissions', check: () => this.checkPermissions() }
+    ];
+
+    let allPassed = true;
+
+    for (const check of checks) {
+      try {
+        const result = await check.check();
+        console.log(`✅ ${check.name}: ${result}`);
+      } catch (error) {
+        console.log(`❌ ${check.name}: ${error.message}`);
+        allPassed = false;
+      }
+    }
+
+    console.log('');
+    if (allPassed) {
+      console.log('🎉 All health checks passed! Terminal Mirror should work correctly.');
+    } else {
+      console.log('⚠️  Some health checks failed. Please address the issues above.');
+      console.log('');
+      console.log('Common solutions:');
+      console.log('• Run "terminal-mirror setup" to reconfigure');
+      console.log('• Check your Google OAuth credentials');
+      console.log('• Ensure the port is not in use by another application');
+      console.log('• Verify your internet connection');
+    }
+  }
+
+  async checkNodeVersion() {
+    const version = process.version;
+    const major = parseInt(version.split('.')[0].substring(1));
+    
+    if (major < 14) {
+      throw new Error(`Node.js ${major} is too old. Requires Node.js 14 or newer.`);
+    }
+    
+    return `${version} (supported)`;
+  }
+
+  async checkConfigFiles() {
+    const files = [
+      { path: this.envFile, name: '.env' },
+      { path: path.join(this.configDir, 'config.json'), name: 'user config' }
+    ];
+
+    let found = 0;
+    for (const file of files) {
+      try {
+        await fs.access(file.path);
+        found++;
+      } catch (error) {
+        // File doesn't exist
+      }
+    }
+
+    if (found === 0) {
+      throw new Error('No configuration files found. Run "terminal-mirror setup".');
+    }
+
+    return `${found}/${files.length} files found`;
+  }
+
+  async checkEnvironment() {
+    require('dotenv').config({ path: this.envFile });
+
+    const required = [
+      'BASE_URL',
+      'GOOGLE_CLIENT_ID', 
+      'GOOGLE_CLIENT_SECRET',
+      'SESSION_SECRET'
+    ];
+
+    const missing = required.filter(key => !process.env[key]);
+
+    if (missing.length > 0) {
+      throw new Error(`Missing variables: ${missing.join(', ')}`);
+    }
+
+    return 'All required variables set';
+  }
+
+  async checkNetwork() {
+    try {
+      // Test DNS resolution
+      await execAsync('nslookup google.com');
+      return 'Internet connectivity OK';
+    } catch (error) {
+      throw new Error('Cannot resolve DNS. Check internet connection.');
+    }
+  }
+
+  async checkDependencies() {
+    const packageJsonPath = path.join(__dirname, '..', 'package.json');
+    
+    try {
+      const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+      const dependencies = Object.keys(packageJson.dependencies || {});
+      
+      // Check if node_modules exists
+      const nodeModulesPath = path.join(__dirname, '..', 'node_modules');
+      await fs.access(nodeModulesPath);
+      
+      return `${dependencies.length} dependencies installed`;
+    } catch (error) {
+      throw new Error('Dependencies not installed. Run "npm install".');
+    }
+  }
+
+  async checkPort() {
+    require('dotenv').config({ path: this.envFile });
+    const port = process.env.PORT || 3000;
+
+    try {
+      const { stdout } = await execAsync(`lsof -i :${port}`);
+      if (stdout.trim()) {
+        throw new Error(`Port ${port} is already in use`);
+      }
+    } catch (error) {
+      if (error.message.includes('already in use')) {
+        throw error;
+      }
+      // lsof command failed (probably port is free)
+    }
+
+    return `Port ${port} is available`;
+  }
+
+  async checkOAuth() {
+    require('dotenv').config({ path: this.envFile });
+    
+    const clientId = process.env.GOOGLE_CLIENT_ID;
+    const clientSecret = process.env.GOOGLE_CLIENT_SECRET;
+
+    if (!clientId || !clientSecret) {
+      throw new Error('OAuth credentials not configured');
+    }
+
+    // Basic format validation
+    if (!clientId.includes('.googleusercontent.com')) {
+      throw new Error('Client ID format appears invalid');
+    }
+
+    if (clientSecret.length < 20) {
+      throw new Error('Client secret appears too short');
+    }
+
+    return 'OAuth credentials format looks correct';
+  }
+
+  async checkPermissions() {
+    // Check if we can write to config directory
+    try {
+      await fs.mkdir(this.configDir, { recursive: true });
+      const testFile = path.join(this.configDir, 'test-permissions.tmp');
+      await fs.writeFile(testFile, 'test');
+      await fs.unlink(testFile);
+      return 'File system permissions OK';
+    } catch (error) {
+      throw new Error('Cannot write to config directory: ' + error.message);
+    }
+  }
+}
+
+module.exports = new HealthChecker();

package/lib/server-manager.js

@@ -0,0 +1,225 @@
+const { spawn, exec } = require('child_process');
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+
+class ServerManager {
+  constructor() {
+    this.pidFile = path.join(os.homedir(), '.terminal-mirror', 'server.pid');
+    this.logFile = path.join(os.homedir(), '.terminal-mirror', 'server.log');
+    this.serverScript = path.join(__dirname, '..', 'server.js');
+  }
+
+  async start(options = {}) {
+    // Check if server is already running
+    if (await this.isRunning()) {
+      console.log('⚠️  Terminal Mirror server is already running');
+      await this.status();
+      return;
+    }
+
+    // Load configuration
+    require('dotenv').config();
+    
+    const port = options.port || process.env.PORT || 3000;
+    const host = options.host || process.env.HOST || '0.0.0.0';
+    const baseUrl = process.env.BASE_URL || `http://localhost:${port}`;
+
+    console.log('🚀 Starting Terminal Mirror server...');
+    console.log('');
+
+    // Ensure log directory exists
+    await fs.mkdir(path.dirname(this.logFile), { recursive: true });
+
+    if (options.daemon) {
+      // Start as daemon
+      await this.startDaemon(port, host);
+    } else {
+      // Start in foreground
+      await this.startForeground(port, host, baseUrl);
+    }
+  }
+
+  async startForeground(port, host, baseUrl) {
+    console.log(`📍 Server URL: ${baseUrl}`);
+    console.log(`🔧 Host: ${host}:${port}`);
+    console.log('');
+    console.log('Press Ctrl+C to stop the server');
+    console.log('─'.repeat(50));
+    console.log('');
+
+    // Start server process
+    const serverProcess = spawn('node', [this.serverScript], {
+      stdio: 'inherit',
+      env: { ...process.env, PORT: port, HOST: host }
+    });
+
+    // Handle graceful shutdown
+    const shutdown = () => {
+      console.log('\n🛑 Shutting down server...');
+      serverProcess.kill('SIGTERM');
+      process.exit(0);
+    };
+
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+
+    serverProcess.on('error', (error) => {
+      console.error('❌ Failed to start server:', error.message);
+      process.exit(1);
+    });
+
+    serverProcess.on('exit', (code) => {
+      if (code !== 0) {
+        console.error(`❌ Server exited with code ${code}`);
+        process.exit(code);
+      }
+    });
+  }
+
+  async startDaemon(port, host) {
+    console.log('🔧 Starting server as daemon...');
+
+    const serverProcess = spawn('node', [this.serverScript], {
+      detached: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, PORT: port, HOST: host }
+    });
+
+    // Save PID
+    await fs.writeFile(this.pidFile, serverProcess.pid.toString());
+
+    // Redirect output to log file
+    const logStream = await fs.open(this.logFile, 'a');
+    serverProcess.stdout.pipe(logStream.createWriteStream());
+    serverProcess.stderr.pipe(logStream.createWriteStream());
+
+    serverProcess.unref();
+
+    console.log(`✅ Server started as daemon (PID: ${serverProcess.pid})`);
+    console.log(`📝 Logs: ${this.logFile}`);
+    
+    // Wait a moment to check if it started successfully
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    
+    if (await this.isRunning()) {
+      console.log('🌐 Server is running and accessible');
+      await this.status();
+    } else {
+      console.log('❌ Server failed to start');
+      process.exit(1);
+    }
+  }
+
+  async stop() {
+    console.log('🛑 Stopping Terminal Mirror server...');
+
+    if (!await this.isRunning()) {
+      console.log('⚠️  Server is not running');
+      return;
+    }
+
+    try {
+      const pid = await fs.readFile(this.pidFile, 'utf8');
+      process.kill(parseInt(pid), 'SIGTERM');
+      
+      // Wait for process to stop
+      await new Promise(resolve => setTimeout(resolve, 2000));
+      
+      if (!await this.isRunning()) {
+        console.log('✅ Server stopped successfully');
+        // Clean up PID file
+        try {
+          await fs.unlink(this.pidFile);
+        } catch (error) {
+          // Ignore if file doesn't exist
+        }
+      } else {
+        console.log('⚠️  Server may still be running');
+      }
+    } catch (error) {
+      console.error('❌ Failed to stop server:', error.message);
+      throw error;
+    }
+  }
+
+  async status() {
+    console.log('📊 Terminal Mirror Status');
+    console.log('─'.repeat(30));
+
+    const isRunning = await this.isRunning();
+    console.log(`Status: ${isRunning ? '🟢 Running' : '🔴 Stopped'}`);
+
+    if (isRunning) {
+      try {
+        const pid = await fs.readFile(this.pidFile, 'utf8');
+        console.log(`PID: ${pid.trim()}`);
+        
+        // Get process info
+        const processInfo = await this.getProcessInfo(parseInt(pid));
+        if (processInfo) {
+          console.log(`Memory: ${processInfo.memory} MB`);
+          console.log(`CPU: ${processInfo.cpu}%`);
+          console.log(`Uptime: ${processInfo.uptime}`);
+        }
+      } catch (error) {
+        console.log('PID: Unknown');
+      }
+    }
+
+    // Show configuration
+    require('dotenv').config();
+    console.log(`URL: ${process.env.BASE_URL || 'Not configured'}`);
+    console.log(`Port: ${process.env.PORT || 'Not configured'}`);
+    
+    // Check log file
+    try {
+      const stats = await fs.stat(this.logFile);
+      console.log(`Log file: ${this.logFile} (${Math.round(stats.size / 1024)} KB)`);
+    } catch (error) {
+      console.log('Log file: Not found');
+    }
+
+    console.log('');
+    
+    if (isRunning) {
+      console.log('🌐 Access your terminal at: ' + (process.env.BASE_URL || 'http://localhost:3000'));
+    } else {
+      console.log('💡 Run "terminal-mirror start" to start the server');
+    }
+  }
+
+  async isRunning() {
+    try {
+      const pid = await fs.readFile(this.pidFile, 'utf8');
+      process.kill(parseInt(pid), 0); // Check if process exists
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  async getProcessInfo(pid) {
+    return new Promise((resolve) => {
+      exec(`ps -p ${pid} -o pid,pcpu,pmem,etime --no-headers`, (error, stdout) => {
+        if (error) {
+          resolve(null);
+          return;
+        }
+
+        const parts = stdout.trim().split(/\s+/);
+        if (parts.length >= 4) {
+          resolve({
+            cpu: parseFloat(parts[1]),
+            memory: Math.round(parseFloat(parts[2]) * 100) / 100,
+            uptime: parts[3]
+          });
+        } else {
+          resolve(null);
+        }
+      });
+    });
+  }
+}
+
+module.exports = new ServerManager();

package/lib/setup-wizard.js

@@ -0,0 +1,222 @@
+const inquirer = require('inquirer');
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+class SetupWizard {
+  constructor() {
+    this.configDir = path.join(os.homedir(), '.terminal-mirror');
+    this.configFile = path.join(this.configDir, 'config.json');
+    this.envFile = path.join(process.cwd(), '.env');
+  }
+
+  async run(options = {}) {
+    console.log('🚀 Welcome to Terminal Mirror Setup!');
+    console.log('');
+    console.log('This wizard will help you configure Google OAuth and get Terminal Mirror running.');
+    console.log('');
+
+    // Check if already configured
+    if (!options.force && await this.isConfigured()) {
+      const { proceed } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'proceed',
+        message: 'Terminal Mirror is already configured. Reconfigure?',
+        default: false
+      }]);
+
+      if (!proceed) {
+        console.log('Setup cancelled.');
+        return;
+      }
+    }
+
+    console.log('📋 First, you\'ll need Google OAuth credentials.');
+    console.log('');
+    console.log('1. Go to: https://console.cloud.google.com/');
+    console.log('2. Create a new project or select existing one');
+    console.log('3. Enable the Google People API');
+    console.log('4. Create OAuth 2.0 credentials (Web application)');
+    console.log('5. Add authorized origins and redirect URIs');
+    console.log('');
+
+    const { ready } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'ready',
+      message: 'Have you completed the Google Cloud Console setup?',
+      default: false
+    }]);
+
+    if (!ready) {
+      console.log('');
+      console.log('Please complete the Google Cloud Console setup first.');
+      console.log('Detailed instructions: https://github.com/yourusername/terminal-mirror#setup');
+      return;
+    }
+
+    // Collect configuration
+    const config = await this.collectConfig();
+    
+    // Save configuration
+    await this.saveConfig(config);
+    
+    // Run verification
+    await this.verifySetup(config);
+
+    console.log('');
+    console.log('✅ Setup completed successfully!');
+    console.log('');
+    console.log('Next steps:');
+    console.log('1. Run: terminal-mirror start');
+    console.log(`2. Open: ${config.baseUrl}`);
+    console.log('3. Log in with your Google account');
+    console.log('');
+  }
+
+  async collectConfig() {
+    const questions = [
+      {
+        type: 'input',
+        name: 'clientId',
+        message: 'Google Client ID:',
+        validate: (input) => input.length > 0 || 'Client ID is required'
+      },
+      {
+        type: 'password',
+        name: 'clientSecret',
+        message: 'Google Client Secret:',
+        validate: (input) => input.length > 0 || 'Client Secret is required'
+      },
+      {
+        type: 'list',
+        name: 'environment',
+        message: 'Environment:',
+        choices: ['Development (localhost)', 'Production (custom domain)'],
+        default: 'Development (localhost)'
+      }
+    ];
+
+    const answers = await inquirer.prompt(questions);
+
+    let baseUrl, port = '3000';
+    
+    if (answers.environment === 'Development (localhost)') {
+      const portQuestion = await inquirer.prompt([{
+        type: 'input',
+        name: 'port',
+        message: 'Port number:',
+        default: '3000',
+        validate: (input) => {
+          const port = parseInt(input);
+          return (port > 0 && port < 65536) || 'Please enter a valid port number';
+        }
+      }]);
+      port = portQuestion.port;
+      baseUrl = `http://localhost:${port}`;
+    } else {
+      const domainQuestion = await inquirer.prompt([{
+        type: 'input',
+        name: 'domain',
+        message: 'Your domain (e.g., example.com):',
+        validate: (input) => input.length > 0 || 'Domain is required'
+      }]);
+      baseUrl = `https://${domainQuestion.domain}`;
+    }
+
+    // Generate secure session secret
+    const sessionSecret = crypto.randomBytes(32).toString('hex');
+
+    return {
+      clientId: answers.clientId,
+      clientSecret: answers.clientSecret,
+      baseUrl,
+      port,
+      sessionSecret,
+      environment: answers.environment
+    };
+  }
+
+  async saveConfig(config) {
+    // Ensure config directory exists
+    await fs.mkdir(this.configDir, { recursive: true });
+
+    // Save to user config
+    const userConfig = {
+      baseUrl: config.baseUrl,
+      port: config.port,
+      environment: config.environment,
+      setupDate: new Date().toISOString()
+    };
+    await fs.writeFile(this.configFile, JSON.stringify(userConfig, null, 2));
+
+    // Create .env file
+    const envContent = `# Terminal Mirror Configuration
+# Generated by setup wizard on ${new Date().toISOString()}
+
+BASE_URL=${config.baseUrl}
+PORT=${config.port}
+HOST=0.0.0.0
+GOOGLE_CLIENT_ID=${config.clientId}
+GOOGLE_CLIENT_SECRET=${config.clientSecret}
+SESSION_SECRET=${config.sessionSecret}
+NODE_ENV=${config.environment === 'Production (custom domain)' ? 'production' : 'development'}
+`;
+
+    await fs.writeFile(this.envFile, envContent);
+
+    console.log(`✅ Configuration saved to ${this.envFile}`);
+  }
+
+  async verifySetup(config) {
+    console.log('');
+    console.log('🔍 Verifying setup...');
+
+    // Check if all required files exist
+    const checks = [
+      { name: 'Configuration file', path: this.configFile },
+      { name: 'Environment file', path: this.envFile }
+    ];
+
+    for (const check of checks) {
+      try {
+        await fs.access(check.path);
+        console.log(`✅ ${check.name} exists`);
+      } catch (error) {
+        console.log(`❌ ${check.name} missing`);
+        throw new Error(`Setup verification failed: ${check.name} not found`);
+      }
+    }
+
+    // Validate environment variables
+    require('dotenv').config({ path: this.envFile });
+    const required = ['BASE_URL', 'GOOGLE_CLIENT_ID', 'GOOGLE_CLIENT_SECRET', 'SESSION_SECRET'];
+    const missing = required.filter(key => !process.env[key]);
+
+    if (missing.length > 0) {
+      console.log(`❌ Missing environment variables: ${missing.join(', ')}`);
+      throw new Error('Environment validation failed');
+    }
+
+    console.log('✅ Environment variables configured');
+
+    // Test OAuth configuration format
+    if (!config.clientId.includes('.googleusercontent.com')) {
+      console.log('⚠️  Warning: Client ID format looks unusual');
+    }
+
+    console.log('✅ Setup verification completed');
+  }
+
+  async isConfigured() {
+    try {
+      await fs.access(this.configFile);
+      await fs.access(this.envFile);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+module.exports = new SetupWizard();

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "shell-mirror",
+  "version": "1.0.0",
+  "description": "Access your Mac shell from any device securely. Perfect for mobile coding with Claude Code CLI, Gemini CLI, and any shell tool.",
+  "main": "server.js",
+  "bin": {
+    "shell-mirror": "./bin/shell-mirror"
+  },
+  "preferGlobal": true,
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "scripts": {
+    "start": "node server.js",
+    "dev": "node server.js",
+    "pm2:start": "pm2 start ecosystem.config.js --env production",
+    "pm2:stop": "pm2 stop shell-mirror",
+    "pm2:restart": "pm2 restart shell-mirror",
+    "pm2:delete": "pm2 delete shell-mirror",
+    "pm2:logs": "pm2 logs shell-mirror",
+    "deploy": "node deploy-php.cjs",
+    "deploy:nodejs": "node deploy.cjs",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "postinstall": "node bin/shell-mirror install"
+  },
+  "keywords": [
+    "shell",
+    "remote",
+    "mobile coding",
+    "claude code",
+    "gemini cli",
+    "ssh",
+    "web shell",
+    "mac shell",
+    "mobile shell",
+    "ai coding",
+    "google oauth"
+  ],
+  "author": "Shell Mirror Contributors",
+  "license": "MIT",
+  "type": "commonjs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/karmalsky/shell-mirror.git"
+  },
+  "homepage": "https://shellmirror.app",
+  "bugs": {
+    "url": "https://github.com/karmalsky/shell-mirror/issues"
+  },
+  "dependencies": {
+    "commander": "^11.1.0",
+    "dotenv": "^16.4.5",
+    "express": "^5.1.0",
+    "express-session": "^1.18.1",
+    "inquirer": "^9.2.12",
+    "node-pty": "^1.0.0",
+    "passport": "^0.7.0",
+    "passport-google-oauth20": "^2.0.0",
+    "ws": "^8.18.2"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "public/",
+    "server.js",
+    "auth.js",
+    "README.md",
+    "LICENSE"
+  ]
+}