shell-mirror 1.0.0 → 1.2.0

package/bin/shell-mirror

@@ -15,7 +15,17 @@ const program = new Command();
 program
   .name('shell-mirror')
   .description('Access your Mac shell from any device securely')
-  .version(package.version);
+  .version(package.version)
+  .action(async () => {
+    // Default action: auto-start with authentication
+    try {
+      const autoStart = require('../lib/auto-start');
+      await autoStart.run();
+    } catch (error) {
+      console.error('Failed to start Shell Mirror:', error.message);
+      process.exit(1);
+    }
+  });
 
 // Setup command - Interactive OAuth configuration wizard
 program

package/lib/auto-start.js

@@ -0,0 +1,500 @@
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const { spawn } = require('child_process');
+const https = require('https');
+const querystring = require('querystring');
+
+class AutoStart {
+  constructor() {
+    this.configDir = path.join(os.homedir(), '.shell-mirror');
+    this.authFile = path.join(this.configDir, 'auth.json');
+    this.configFile = path.join(this.configDir, 'config.json');
+    this.envFile = path.join(process.cwd(), '.env');
+    
+    // Shell Mirror OAuth App credentials (production)
+    this.oauthConfig = {
+      clientId: '804759223392-i5nv5csn1o6siqr760c99l2a9k4sammp.apps.googleusercontent.com',
+      clientSecret: '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', 
+      redirectUri: 'http://localhost:3000/auth/google/callback'
+    };
+  }
+
+  async run() {
+    console.log('🚀 Starting Shell Mirror...');
+    console.log('');
+
+    try {
+      // Ensure config directory exists
+      await fs.mkdir(this.configDir, { recursive: true });
+
+      // Check authentication status
+      const authInfo = await this.checkAuth();
+      
+      if (!authInfo) {
+        console.log('🔐 Not logged in. Opening browser for Google authentication...');
+        await this.initiateLogin();
+        return;
+      }
+
+      // Start the server
+      await this.startServer(authInfo);
+
+    } catch (error) {
+      console.error('❌ Failed to start Shell Mirror:', error.message);
+      process.exit(1);
+    }
+  }
+
+  async checkAuth() {
+    try {
+      const authData = await fs.readFile(this.authFile, 'utf8');
+      const auth = JSON.parse(authData);
+      
+      // Check if token is still valid (basic check)
+      if (auth.accessToken && auth.email && auth.expiresAt) {
+        const now = Date.now();
+        if (now < auth.expiresAt) {
+          return auth;
+        }
+      }
+      
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  async initiateLogin() {
+    console.log('');
+    console.log('🔐 Opening browser for Google authentication...');
+    console.log('');
+    
+    try {
+      // Start OAuth callback server
+      console.log('🔄 Starting OAuth callback server...');
+      const server = await this.createOAuthCallbackServer();
+      
+      // Open browser for OAuth
+      const authUrl = this.buildAuthUrl();
+      console.log('🌐 Opening browser for login...');
+      await this.openBrowser(authUrl);
+      
+      console.log('');
+      console.log('👤 Please complete the Google login in your browser');
+      console.log('   (If browser didn\'t open, visit: ' + authUrl + ')');
+      console.log('');
+      
+    } catch (error) {
+      console.error('❌ Failed to start OAuth flow:', error.message);
+      process.exit(1);
+    }
+  }
+
+  buildAuthUrl() {
+    const params = new URLSearchParams({
+      client_id: this.oauthConfig.clientId,
+      redirect_uri: this.oauthConfig.redirectUri,
+      response_type: 'code',
+      scope: 'openid email profile',
+      access_type: 'offline',
+      prompt: 'consent'
+    });
+    
+    return `https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}`;
+  }
+
+  async createOAuthCallbackServer() {
+    const express = require('express');
+    const app = express();
+    
+    return new Promise((resolve, reject) => {
+      let serverInstance;
+      
+      app.get('/auth/google/callback', async (req, res) => {
+        try {
+          const code = req.query.code;
+          const error = req.query.error;
+          
+          if (error) {
+            throw new Error(`OAuth error: ${error}`);
+          }
+          
+          if (code) {
+            console.log('📝 Received authorization code, exchanging for tokens...');
+            
+            // Exchange code for tokens
+            const tokens = await this.exchangeCodeForTokens(code);
+            await this.saveAuth(tokens);
+            
+            res.send(`
+              <html>
+                <head>
+                  <title>Shell Mirror - Login Successful</title>
+                  <style>
+                    body { font-family: Arial, sans-serif; text-align: center; padding: 50px; background: #f5f5f5; }
+                    .container { background: white; padding: 40px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); max-width: 500px; margin: 0 auto; }
+                    h2 { color: #4CAF50; margin-bottom: 20px; }
+                    p { color: #666; margin-bottom: 15px; }
+                    .email { color: #333; font-weight: bold; }
+                  </style>
+                </head>
+                <body>
+                  <div class="container">
+                    <h2>✅ Login Successful!</h2>
+                    <p>Welcome, <span class="email">${tokens.email}</span></p>
+                    <p>Shell Mirror is now starting with your account.</p>
+                    <p>You can close this window and return to your terminal.</p>
+                    <p><small>Or visit <strong>https://shellmirror.app</strong> on your phone to access your terminal.</small></p>
+                  </div>
+                  <script>
+                    setTimeout(() => {
+                      window.close();
+                    }, 3000);
+                  </script>
+                </body>
+              </html>
+            `);
+            
+            // Close the temporary server and restart with authenticated state
+            setTimeout(() => {
+              console.log(`✅ Login successful! Welcome ${tokens.email}`);
+              serverInstance.close(() => {
+                this.startAuthenticatedServer(tokens);
+              });
+            }, 1000);
+            
+          } else {
+            throw new Error('No authorization code received');
+          }
+        } catch (error) {
+          console.error('❌ OAuth callback error:', error.message);
+          res.send(`
+            <html>
+              <head>
+                <title>Shell Mirror - Login Failed</title>
+                <style>
+                  body { font-family: Arial, sans-serif; text-align: center; padding: 50px; background: #f5f5f5; }
+                  .container { background: white; padding: 40px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); max-width: 500px; margin: 0 auto; }
+                  h2 { color: #f44336; margin-bottom: 20px; }
+                  p { color: #666; margin-bottom: 15px; }
+                </style>
+              </head>
+              <body>
+                <div class="container">
+                  <h2>❌ Login Failed</h2>
+                  <p>Error: ${error.message}</p>
+                  <p>Please try running 'shell-mirror' again.</p>
+                </div>
+              </body>
+            </html>
+          `);
+        }
+      });
+      
+      serverInstance = app.listen(3000, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(serverInstance);
+        }
+      });
+    });
+  }
+
+  async createProductionConfig() {
+    // Create production environment file with real OAuth credentials
+    const envContent = `# Shell Mirror Configuration
+# Auto-generated on ${new Date().toISOString()}
+
+BASE_URL=http://localhost:3000
+PORT=3000
+HOST=0.0.0.0
+GOOGLE_CLIENT_ID=${this.oauthConfig.clientId}
+GOOGLE_CLIENT_SECRET=${this.oauthConfig.clientSecret}
+SESSION_SECRET=${crypto.randomBytes(32).toString('hex')}
+NODE_ENV=development
+`;
+
+    await fs.writeFile(this.envFile, envContent);
+  }
+
+  async startServerForLogin() {
+    console.log('🔄 Starting Shell Mirror server...');
+    console.log('');
+    
+    // Start the server in background
+    const serverProcess = spawn('node', ['server.js'], {
+      stdio: 'pipe',
+      cwd: path.dirname(this.envFile)
+    });
+
+    // Wait a moment for server to start
+    setTimeout(() => {
+      this.displayLoginInstructions();
+      this.openBrowser('http://localhost:3000');
+    }, 2000);
+
+    // Handle Ctrl+C gracefully
+    process.on('SIGINT', () => {
+      console.log('');
+      console.log('🛑 Stopping Shell Mirror...');
+      serverProcess.kill('SIGINT');
+      process.exit(0);
+    });
+
+    // Monitor server
+    serverProcess.on('close', (code) => {
+      if (code !== 0) {
+        console.error(`❌ Server exited with code ${code}`);
+        process.exit(code);
+      }
+    });
+  }
+
+  displayLoginInstructions() {
+    console.log('✅ Shell Mirror server is running');
+    console.log('🌐 Local server: http://localhost:3000');
+    console.log('📱 Access from phone: https://shellmirror.app');
+    console.log('');
+    console.log('🔐 First-time setup:');
+    console.log('   1. A browser window should open automatically');
+    console.log('   2. Click "Login with Google" to authenticate');
+    console.log('   3. After login, your Mac terminal will be accessible from your phone');
+    console.log('');
+    console.log('ℹ️  To use from your phone:');
+    console.log('   1. Open https://shellmirror.app on your phone');
+    console.log('   2. Login with the same Google account');
+    console.log('   3. Access your Mac terminal instantly');
+    console.log('');
+    console.log('Press Ctrl+C to stop');
+    console.log('');
+  }
+
+  async exchangeCodeForTokens(code) {
+    return new Promise((resolve, reject) => {
+      const postData = querystring.stringify({
+        code: code,
+        client_id: this.oauthConfig.clientId,
+        client_secret: this.oauthConfig.clientSecret,
+        redirect_uri: this.oauthConfig.redirectUri,
+        grant_type: 'authorization_code'
+      });
+
+      const options = {
+        hostname: 'oauth2.googleapis.com',
+        port: 443,
+        path: '/token',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+          'Content-Length': Buffer.byteLength(postData)
+        }
+      };
+
+      const req = https.request(options, (res) => {
+        let data = '';
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+        res.on('end', async () => {
+          try {
+            const tokens = JSON.parse(data);
+            if (tokens.access_token) {
+              // Get user info
+              const userInfo = await this.getUserInfo(tokens.access_token);
+              resolve({
+                accessToken: tokens.access_token,
+                refreshToken: tokens.refresh_token,
+                email: userInfo.email,
+                name: userInfo.name,
+                expiresAt: Date.now() + (tokens.expires_in * 1000)
+              });
+            } else {
+              reject(new Error('Failed to get access token: ' + data));
+            }
+          } catch (error) {
+            reject(error);
+          }
+        });
+      });
+
+      req.on('error', (error) => {
+        reject(error);
+      });
+
+      req.write(postData);
+      req.end();
+    });
+  }
+
+  async getUserInfo(accessToken) {
+    return new Promise((resolve, reject) => {
+      const options = {
+        hostname: 'www.googleapis.com',
+        port: 443,
+        path: '/oauth2/v2/userinfo',
+        method: 'GET',
+        headers: {
+          'Authorization': `Bearer ${accessToken}`
+        }
+      };
+
+      const req = https.request(options, (res) => {
+        let data = '';
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+        res.on('end', () => {
+          try {
+            const userInfo = JSON.parse(data);
+            resolve(userInfo);
+          } catch (error) {
+            reject(error);
+          }
+        });
+      });
+
+      req.on('error', (error) => {
+        reject(error);
+      });
+
+      req.end();
+    });
+  }
+
+  async saveAuth(authData) {
+    await fs.writeFile(this.authFile, JSON.stringify(authData, null, 2));
+    console.log('🔐 Authentication saved');
+  }
+
+  async startServer(authInfo) {
+    // Create .env file with configuration
+    await this.createEnvFile(authInfo);
+    
+    // Start the Express server
+    console.log('🔄 Starting server...');
+    console.log('');
+    
+    // Start the main server process
+    const serverProcess = spawn('node', ['server.js'], {
+      stdio: 'inherit',
+      cwd: path.dirname(this.envFile)
+    });
+
+    // Display status information
+    this.displayStatus(authInfo);
+
+    // Handle Ctrl+C gracefully
+    process.on('SIGINT', () => {
+      console.log('');
+      console.log('🛑 Stopping Shell Mirror...');
+      serverProcess.kill('SIGINT');
+      process.exit(0);
+    });
+
+    // Wait for server process
+    serverProcess.on('close', (code) => {
+      if (code !== 0) {
+        console.error(`❌ Server exited with code ${code}`);
+        process.exit(code);
+      }
+    });
+  }
+
+  async createEnvFile(authInfo) {
+    const envContent = `# Shell Mirror Configuration
+# Auto-generated on ${new Date().toISOString()}
+
+BASE_URL=http://localhost:3000
+PORT=3000
+HOST=0.0.0.0
+GOOGLE_CLIENT_ID=${this.oauthConfig.clientId}
+GOOGLE_CLIENT_SECRET=${this.oauthConfig.clientSecret}
+SESSION_SECRET=${crypto.randomBytes(32).toString('hex')}
+NODE_ENV=development
+
+# User authentication
+USER_EMAIL=${authInfo.email}
+USER_NAME=${authInfo.name}
+ACCESS_TOKEN=${authInfo.accessToken}
+`;
+
+    await fs.writeFile(this.envFile, envContent);
+  }
+
+  displayStatus(authInfo) {
+    console.log('✅ Shell Mirror is running');
+    console.log(`👤 Logged in as: ${authInfo.email}`);
+    console.log('🌐 Local server: http://localhost:3000');
+    console.log('📱 Access from phone: https://shellmirror.app');
+    console.log('');
+    console.log('ℹ️  To use from your phone:');
+    console.log('   1. Open https://shellmirror.app on your phone');
+    console.log(`   2. Login with the same Google account (${authInfo.email})`);
+    console.log('   3. Access your Mac terminal instantly');
+    console.log('');
+    console.log('Press Ctrl+C to stop');
+    console.log('');
+  }
+
+  async startAuthenticatedServer(authInfo) {
+    console.log('');
+    console.log('🚀 Starting authenticated Shell Mirror server...');
+    
+    // Create .env file with authentication
+    await this.createEnvFile(authInfo);
+    
+    // Start the main server process
+    const serverProcess = spawn('node', ['server.js'], {
+      stdio: 'inherit',
+      cwd: path.dirname(this.envFile)
+    });
+
+    // Display status information
+    this.displayStatus(authInfo);
+
+    // Handle Ctrl+C gracefully
+    process.on('SIGINT', () => {
+      console.log('');
+      console.log('🛑 Stopping Shell Mirror...');
+      serverProcess.kill('SIGINT');
+      process.exit(0);
+    });
+
+    // Wait for server process
+    serverProcess.on('close', (code) => {
+      if (code !== 0) {
+        console.error(`❌ Server exited with code ${code}`);
+        process.exit(code);
+      }
+    });
+  }
+
+  async openBrowser(url) {
+    const platform = os.platform();
+    let command;
+    
+    switch (platform) {
+      case 'darwin': // macOS
+        command = 'open';
+        break;
+      case 'win32': // Windows
+        command = 'start';
+        break;
+      default: // Linux and others
+        command = 'xdg-open';
+        break;
+    }
+    
+    try {
+      spawn(command, [url], { detached: true, stdio: 'ignore' });
+    } catch (error) {
+      console.log('⚠️  Could not open browser automatically.');
+      console.log('   Please visit: ' + url);
+    }
+  }
+}
+
+module.exports = new AutoStart();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shell-mirror",
-  "version": "1.0.0",
+  "version": "1.2.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": {

package/public/index.html

@@ -692,9 +692,9 @@
             <p><strong>Next steps:</strong></p>
             <ol style="text-align: left; margin: 20px 0;">
                 <li>Install Shell Mirror using the command above</li>
-                <li>Run <code>shell-mirror setup</code> to configure</li>
-                <li>Run <code>shell-mirror start</code> to start the server</li>
-                <li>Come back and click "Login with Google" again</li>
+                <li>Run <code>shell-mirror</code> (it will auto-start and open your browser)</li>
+                <li>Login with Google when prompted</li>
+                <li>Access your terminal from your phone at shellmirror.app</li>
             </ol>
             
             <button class="btn-primary" onclick="closeInstallModal()" style="margin-top: 20px;">Got it!</button>

package/server.js

@@ -96,11 +96,11 @@ if (missingEnvVars.length > 0) {
   missingEnvVars.forEach(varName => {
     console.error(`   - ${varName}`);
   });
-  console.error('\nPlease create a .env file based on .env.example and fill in the required values.');
-  console.error('See README.md for instructions on getting Google OAuth credentials.');
+  console.error('\nPlease run "shell-mirror" to set up authentication.');
   process.exit(1);
 }
 
+
 // 4. WebSocket Connection Handler with Authentication
 wss.on('connection', function connection(ws, request) {
   console.log('New WebSocket connection attempt');