ai-or-die 0.1.5 → 0.1.7

package/bin/ai-or-die.js

@@ -54,15 +54,14 @@ async function main() {
     }
 
     // Handle authentication logic
+    // Tunnel mode disables auth — the tunnel itself controls access
     let authToken = null;
-    let noAuth = options.disableAuth === true;
+    let noAuth = options.disableAuth === true || options.tunnel === true;
 
     if (!noAuth) {
       if (options.auth) {
-        // Use provided token
         authToken = options.auth;
       } else {
-        // Generate random token
         authToken = generateRandomToken();
       }
     }
@@ -91,88 +90,42 @@ async function main() {
     console.log(`Plan: ${options.plan}`);
     console.log(`Aliases: Claude → "${serverOptions.claudeAlias}", Codex → "${serverOptions.codexAlias}", Copilot → "${serverOptions.copilotAlias}", Gemini → "${serverOptions.geminiAlias}", Terminal → "${serverOptions.terminalAlias}"`);
 
-    // Display authentication status prominently
-    if (noAuth) {
+    // Display authentication status
+    if (options.tunnel) {
+      console.log('\n🌍 TUNNEL MODE — authentication disabled (tunnel controls access)');
+    } else if (noAuth) {
       console.log('\n⚠️  AUTHENTICATION DISABLED - Server is accessible without a token');
       console.log('   (Use without --disable-auth flag for security in production)');
     } else {
       console.log('\n🔐 AUTHENTICATION ENABLED');
-      if (options.auth) {
-        console.log('   Using provided authentication token');
-      } else {
-        console.log('   Generated random authentication token:');
-        console.log(`   \x1b[1m\x1b[33m${authToken}\x1b[0m`);
-        console.log('   \x1b[2mSave this token - you\'ll need it to access the interface\x1b[0m');
-      }
     }
 
     const server = await startServer(serverOptions);
 
     const protocol = options.https ? 'https' : 'http';
-    const url = `${protocol}://localhost:${port}`;
-
-    console.log(`\n🚀 ai-or-die is running at: ${url}`);
+    const baseUrl = `${protocol}://localhost:${port}`;
+    // For localhost with auth, embed token in URL so user can just click it
+    const url = authToken ? `${baseUrl}?token=${authToken}` : baseUrl;
 
-    if (!noAuth) {
-      console.log('\n📋 Authentication Required:');
-      if (options.auth) {
-        console.log('   Use your provided authentication token to access the interface');
-      } else {
-        console.log(`   Enter this token when prompted: \x1b[1m\x1b[33m${authToken}\x1b[0m`);
-      }
+    console.log(`\n🚀 ai-or-die is running at: \x1b[1m\x1b[4m${url}\x1b[0m`);
+    if (authToken) {
+      console.log(`   Auth token: \x1b[1m\x1b[33m${authToken}\x1b[0m`);
     }
 
-    // Dev tunnel setup
-    let tunnelProcess = null;
-    let publicUrl = null;
+    // Dev tunnel or browser open
+    let tunnel = null;
     if (options.tunnel) {
-      console.log('\n\x1b[36m  Connecting dev tunnel...\x1b[0m');
-      try {
-        const { spawn: cpSpawn, execFileSync } = require('child_process');
-
-        // Check if devtunnel CLI is available
-        const devtunnelCmd = process.platform === 'win32' ? 'where' : 'which';
-        try {
-          execFileSync(devtunnelCmd, ['devtunnel'], { stdio: 'ignore' });
-        } catch (_) {
-          const isWin = process.platform === 'win32';
-          console.error('\n\x1b[31m  devtunnel CLI not found.\x1b[0m\n');
-          console.error('  Install it with a single command:');
-          if (isWin) {
-            console.error('  \x1b[1mwinget install Microsoft.devtunnel\x1b[0m');
-          } else if (process.platform === 'darwin') {
-            console.error('  \x1b[1mbrew install --cask devtunnel\x1b[0m');
-          } else {
-            console.error('  \x1b[1mcurl -sL https://aka.ms/DevTunnelCliInstall | bash\x1b[0m');
-          }
-          console.error('\n  Then run: \x1b[1mdevtunnel user login\x1b[0m (one-time)\n');
-          process.exit(1);
+      const { TunnelManager } = require('../src/tunnel-manager');
+      tunnel = new TunnelManager({
+        port,
+        allowAnonymous: options.tunnelAllowAnonymous,
+        dev: options.dev,
+        onUrl: (tunnelUrl) => {
+          console.log(`\n  \x1b[1m\x1b[32mTunnel ready:\x1b[0m \x1b[1m\x1b[4m${tunnelUrl}\x1b[0m\n`);
+          if (open && options.open) open(tunnelUrl).catch(() => {});
         }
-
-        const tunnelArgs = ['host', '-p', String(port)];
-        if (options.tunnelAllowAnonymous) tunnelArgs.push('--allow-anonymous');
-        tunnelProcess = cpSpawn('devtunnel', tunnelArgs, { stdio: ['pipe', 'pipe', 'pipe'] });
-
-        tunnelProcess.stdout.on('data', (data) => {
-          const match = data.toString().match(/https:\/\/[\w.-]+\.devtunnels\.ms\S*/);
-          if (match && !publicUrl) {
-            publicUrl = match[0].trim();
-            console.log(`\n  \x1b[1m\x1b[32mTunnel ready:\x1b[0m \x1b[1m\x1b[4m${publicUrl}\x1b[0m\n`);
-            if (options.open) {
-              if (open) open(publicUrl).catch(() => {});
-            }
-          }
-        });
-        tunnelProcess.stderr.on('data', (data) => {
-          const output = data.toString().trim();
-          if (output && options.dev) console.log(`  [devtunnel] ${output}`);
-        });
-        tunnelProcess.on('error', () => {
-          console.error('\n  \x1b[31mDev tunnel process failed to start.\x1b[0m');
-        });
-      } catch (error) {
-        console.error('  Failed to start dev tunnel:', error.message);
-      }
+      });
+      await tunnel.start();
     } else if (options.open) {
       try { if (open) await open(url); } catch (error) {
         console.warn('  Could not automatically open browser:', error.message);
@@ -183,8 +136,7 @@ async function main() {
 
     const shutdown = async () => {
       console.log('\nShutting down server...');
-      // Close dev tunnel first if active
-      if (tunnelProcess) { try { tunnelProcess.kill(); } catch (_) {} }
+      if (tunnel) await tunnel.stop();
       server.close(() => {
         console.log('Server closed');
         process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-or-die",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Universal AI coding terminal — Claude, Copilot, Gemini & more in your browser",
   "main": "src/server.js",
   "bin": {

package/src/tunnel-manager.js

@@ -0,0 +1,215 @@
+'use strict';
+
+const { spawn, execFile } = require('child_process');
+const os = require('os');
+
+const MAX_RETRIES = 3;
+const URL_TIMEOUT_MS = 30000;
+
+class TunnelManager {
+  constructor(options = {}) {
+    this.port = options.port || 7777;
+    this.allowAnonymous = options.allowAnonymous || false;
+    this.dev = options.dev || false;
+    this.onUrl = options.onUrl || (() => {});
+
+    this.process = null;
+    this.publicUrl = null;
+    this.stopping = false;
+    this.retryCount = 0;
+    this.tunnelId = `aiordie-${os.hostname().toLowerCase().replace(/[^a-z0-9-]/g, '')}`;
+  }
+
+  /**
+   * Full lifecycle: check CLI → check login → spawn → wait for URL.
+   * Never throws — logs errors and continues with localhost if tunnel fails.
+   */
+  async start() {
+    console.log('\n  Connecting dev tunnel...');
+
+    const hasCli = await this._checkCli();
+    if (!hasCli) return;
+
+    const loggedIn = await this._checkLogin();
+    if (!loggedIn) return;
+
+    await this._spawn();
+  }
+
+  /**
+   * Kill the tunnel process and wait for it to exit.
+   */
+  async stop() {
+    this.stopping = true;
+    if (!this.process) return;
+
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        // Force kill after 5s if it hasn't exited
+        try { this.process.kill('SIGKILL'); } catch {}
+        resolve();
+      }, 5000);
+
+      this.process.once('exit', () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+
+      try { this.process.kill(); } catch {}
+    });
+  }
+
+  /**
+   * Check if devtunnel CLI is installed.
+   */
+  async _checkCli() {
+    const checker = process.platform === 'win32' ? 'where' : 'which';
+    return new Promise((resolve) => {
+      execFile(checker, ['devtunnel'], { timeout: 5000 }, (err) => {
+        if (err) {
+          const isWin = process.platform === 'win32';
+          console.error('\n  \x1b[31mdevtunnel CLI not found.\x1b[0m\n');
+          console.error('  Install it with a single command:');
+          if (isWin) {
+            console.error('  \x1b[1mwinget install Microsoft.devtunnel\x1b[0m');
+          } else if (process.platform === 'darwin') {
+            console.error('  \x1b[1mbrew install --cask devtunnel\x1b[0m');
+          } else {
+            console.error('  \x1b[1mcurl -sL https://aka.ms/DevTunnelCliInstall | bash\x1b[0m');
+          }
+          console.error('\n  Server will continue on localhost only.\n');
+          resolve(false);
+        } else {
+          resolve(true);
+        }
+      });
+    });
+  }
+
+  /**
+   * Check if user is logged in. If not, attempt interactive login.
+   */
+  async _checkLogin() {
+    const isLoggedIn = await new Promise((resolve) => {
+      execFile('devtunnel', ['user', 'show'], { timeout: 10000 }, (err) => {
+        resolve(!err);
+      });
+    });
+
+    if (isLoggedIn) return true;
+
+    console.log('  DevTunnel requires authentication. Launching login...\n');
+
+    // Run interactive login (inherits stdio so user can interact with browser auth)
+    const loginOk = await new Promise((resolve) => {
+      const loginProc = spawn('devtunnel', ['user', 'login'], {
+        stdio: 'inherit'
+      });
+      loginProc.on('exit', (code) => resolve(code === 0));
+      loginProc.on('error', () => resolve(false));
+    });
+
+    if (loginOk) {
+      console.log('\n  Login successful. Connecting tunnel...');
+      return true;
+    }
+
+    console.error('\n  \x1b[33mLogin failed or cancelled. Server will continue on localhost only.\x1b[0m\n');
+    return false;
+  }
+
+  /**
+   * Spawn the devtunnel host process and wait for the public URL.
+   */
+  async _spawn() {
+    const args = ['host', '-p', String(this.port), '--tunnel-id', this.tunnelId];
+    if (this.allowAnonymous) args.push('--allow-anonymous');
+
+    return new Promise((resolve) => {
+      this.process = spawn('devtunnel', args, {
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+
+      let urlResolved = false;
+
+      // Timeout: if no URL appears within 30s, warn and continue
+      const urlTimeout = setTimeout(() => {
+        if (!urlResolved) {
+          urlResolved = true;
+          console.warn('  \x1b[33mTunnel started but no public URL detected within 30s.\x1b[0m');
+          console.warn('  The tunnel may still be connecting. Check devtunnel status manually.\n');
+          resolve();
+        }
+      }, URL_TIMEOUT_MS);
+
+      this.process.stdout.on('data', (data) => {
+        const output = data.toString();
+        if (this.dev) process.stdout.write(`  [devtunnel] ${output}`);
+
+        const match = output.match(/https:\/\/[\w.-]+\.devtunnels\.ms\S*/);
+        if (match && !this.publicUrl) {
+          this.publicUrl = match[0].trim();
+          urlResolved = true;
+          clearTimeout(urlTimeout);
+          this.onUrl(this.publicUrl);
+          resolve();
+        }
+      });
+
+      this.process.stderr.on('data', (data) => {
+        const output = data.toString().trim();
+        if (output) {
+          // Always log stderr — auth errors, rate limits come through here
+          console.error(`  [devtunnel] ${output}`);
+        }
+      });
+
+      this.process.on('error', (err) => {
+        clearTimeout(urlTimeout);
+        console.error(`  \x1b[31mDev tunnel failed to start: ${err.message}\x1b[0m`);
+        if (!urlResolved) {
+          urlResolved = true;
+          resolve();
+        }
+      });
+
+      this.process.on('exit', (code, signal) => {
+        clearTimeout(urlTimeout);
+        this.process = null;
+
+        if (!urlResolved) {
+          urlResolved = true;
+          resolve();
+        }
+
+        // Auto-restart if not intentionally stopped
+        if (!this.stopping && code !== 0) {
+          this._restart();
+        }
+      });
+    });
+  }
+
+  /**
+   * Auto-restart with exponential backoff.
+   */
+  async _restart() {
+    this.retryCount++;
+    if (this.retryCount > MAX_RETRIES) {
+      console.error(`  \x1b[31mTunnel crashed ${MAX_RETRIES} times. Giving up. Server continues on localhost.\x1b[0m\n`);
+      return;
+    }
+
+    const delay = Math.pow(2, this.retryCount - 1) * 1000; // 1s, 2s, 4s
+    console.log(`  Tunnel exited unexpectedly. Restarting in ${delay / 1000}s (attempt ${this.retryCount}/${MAX_RETRIES})...`);
+
+    await new Promise((r) => setTimeout(r, delay));
+
+    if (this.stopping) return;
+
+    this.publicUrl = null;
+    await this._spawn();
+  }
+}
+
+module.exports = { TunnelManager };