ghcc-client 1.0.0

package/dist/session-manager.js

@@ -0,0 +1,707 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_1 = __importDefault(require("fs"));
+const crypto_1 = __importDefault(require("crypto"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const localtunnel_1 = __importDefault(require("localtunnel"));
+const qrcode_terminal_1 = __importDefault(require("qrcode-terminal"));
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+class SessionManager {
+    constructor() {
+        const platform = os_1.default.platform();
+        const arch = os_1.default.arch();
+        let binaryName;
+        if (platform === 'linux') {
+            binaryName = arch === 'arm64' ? 'ttyd-linux-arm64' : 'ttyd-linux-x64';
+        }
+        else if (platform === 'darwin') {
+            binaryName = arch === 'arm64' ? 'ttyd-darwin-arm64' : 'ttyd-darwin-x64';
+        }
+        else {
+            throw new Error(`Unsupported platform: ${platform}`);
+        }
+        this.ttydPath = path_1.default.join(__dirname, '..', 'binaries', binaryName);
+        if (!fs_1.default.existsSync(this.ttydPath)) {
+            console.error(chalk_1.default.red(`✗ ttyd binary not found: ${this.ttydPath}`));
+            console.log(chalk_1.default.yellow('This should not happen. Please reinstall: npm install -g ghcc-client'));
+            process.exit(1);
+        }
+    }
+    // Security helper: Validate session name format
+    validateSessionName(session) {
+        // Only allow: letters, numbers, hyphens, and underscores
+        // Must start with letter or number
+        // Length: 3-64 characters
+        const sessionRegex = /^[a-zA-Z0-9][a-zA-Z0-9_-]{2,63}$/;
+        return sessionRegex.test(session);
+    }
+    // Security helper: Validate port number
+    validatePort(port) {
+        // Only allow non-privileged ports (1024-65535)
+        return Number.isInteger(port) && port >= 1024 && port <= 65535;
+    }
+    // Security helper: Generate secure random password
+    generateSecurePassword(length = 32) {
+        return crypto_1.default.randomBytes(length).toString('base64').slice(0, length);
+    }
+    // Security helper: Create secure temp file with restricted permissions
+    createSecureTempFile(prefix, extension = '.tmp') {
+        // Create unique temp directory with 0700 permissions
+        const tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), `${prefix}-`));
+        fs_1.default.chmodSync(tmpDir, 0o700); // Only owner can read/write/execute
+        // Create file path
+        const filePath = path_1.default.join(tmpDir, `file${extension}`);
+        return filePath;
+    }
+    async sessionExists(sessionName) {
+        try {
+            await execAsync(`tmux has-session -t ${sessionName} 2>/dev/null`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // Find ttyd PID for a session by searching running processes
+    async findTtydPid(sessionName) {
+        try {
+            const { stdout } = await execAsync(`pgrep -f "ttyd.*attach -t ${sessionName}$" 2>/dev/null || true`);
+            const pid = stdout.trim();
+            return pid || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    // Batch method: Get all ttyd processes at once (performance optimization)
+    // Get port number from ttyd process
+    async getTtydPort(pid) {
+        try {
+            const { stdout } = await execAsync(`ps -p ${pid} -o args= 2>/dev/null`);
+            const match = stdout.match(/-p (\d+)/);
+            return match ? match[1] : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    // Find tunnel process PID for a session
+    async findTunnelPid(sessionName) {
+        try {
+            // Look for localtunnel process with session name in args
+            const { stdout } = await execAsync(`pgrep -f "node.*localtunnel.*${sessionName}" 2>/dev/null || true`);
+            const pid = stdout.trim();
+            return pid || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    // Extract public URL from tunnel process
+    async getTunnelUrl(sessionName) {
+        try {
+            // Check if tunnel PID file exists (we'll store URL there)
+            const urlFile = `/tmp/ghcc-${sessionName}-tunnel-url`;
+            if (fs_1.default.existsSync(urlFile)) {
+                const url = fs_1.default.readFileSync(urlFile, 'utf-8').trim();
+                return url || null;
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async isPortInUse(port) {
+        try {
+            await execAsync(`lsof -i :${port} 2>/dev/null`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async findAvailablePort(startPort = 7681) {
+        let port = startPort;
+        while (await this.isPortInUse(port)) {
+            port++;
+            if (port > 65535) {
+                throw new Error('No available ports found');
+            }
+        }
+        return port;
+    }
+    async cleanupOrphanedProcesses() {
+        try {
+            // OPTIMIZATION: Skip cleanup if run recently (within 5 minutes)
+            const cleanupMarker = '/tmp/ghcc-last-cleanup';
+            try {
+                const { stdout } = await execAsync(`stat -c %Y ${cleanupMarker} 2>/dev/null || echo 0`);
+                const lastCleanup = parseInt(stdout.trim());
+                const now = Math.floor(Date.now() / 1000);
+                const timeSinceCleanup = now - lastCleanup;
+                if (timeSinceCleanup < 300) { // 5 minutes = 300 seconds
+                    // Skip cleanup, too recent
+                    return;
+                }
+            }
+            catch {
+                // No marker file, proceed with cleanup
+            }
+            // Strategy: Use actual running processes as source of truth
+            // 1. Find all running ttyd processes for ghcc-session
+            const { stdout: ttydOutput } = await execAsync('pgrep -f "ttyd.*ghcc-session" 2>/dev/null || true');
+            const ttydPids = ttydOutput.trim().split('\n').filter(p => p);
+            for (const pid of ttydPids) {
+                if (!pid)
+                    continue;
+                try {
+                    // Get session name from command line
+                    const { stdout: cmdline } = await execAsync(`ps -p ${pid} -o args= 2>/dev/null`);
+                    const match = cmdline.match(/attach -t (ghcc-session[^\s]*)/);
+                    if (match) {
+                        const sessionName = match[1];
+                        // Check if tmux session exists
+                        if (!(await this.sessionExists(sessionName))) {
+                            // ttyd running but tmux session gone - kill orphaned ttyd
+                            await execAsync(`kill ${pid} 2>/dev/null || true`);
+                            // Also kill associated tunnel
+                            const tunnelPid = await this.findTunnelPid(sessionName);
+                            if (tunnelPid) {
+                                await execAsync(`kill ${tunnelPid} 2>/dev/null || true`);
+                            }
+                            // Clean up tunnel URL file
+                            const urlFile = `/tmp/ghcc-${sessionName}-tunnel-url`;
+                            if (fs_1.default.existsSync(urlFile)) {
+                                fs_1.default.unlinkSync(urlFile);
+                            }
+                            // Clean up custom HTML file
+                            const htmlFile = `/tmp/ghcc-${sessionName}.html`;
+                            if (fs_1.default.existsSync(htmlFile)) {
+                                fs_1.default.unlinkSync(htmlFile);
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Can't get command line, skip this process
+                }
+            }
+            // 2. Find all tmux sessions and check if they have ttyd
+            const { stdout: tmuxOutput } = await execAsync('tmux list-sessions -F "#{session_name}" 2>/dev/null || true');
+            const sessions = tmuxOutput.trim().split('\n').filter(s => s && s.startsWith('ghcc-session'));
+            for (const sessionName of sessions) {
+                // Check if there's a ttyd for this session
+                const ttydPid = await this.findTtydPid(sessionName);
+                if (!ttydPid) {
+                    // Tmux session exists but no ttyd - kill orphaned session and tunnel
+                    await execAsync(`tmux kill-session -t ${sessionName} 2>/dev/null || true`);
+                    const tunnelPid = await this.findTunnelPid(sessionName);
+                    if (tunnelPid) {
+                        await execAsync(`kill ${tunnelPid} 2>/dev/null || true`);
+                    }
+                    const urlFile = `/tmp/ghcc-${sessionName}-tunnel-url`;
+                    if (fs_1.default.existsSync(urlFile)) {
+                        fs_1.default.unlinkSync(urlFile);
+                    }
+                    const htmlFile = `/tmp/ghcc-${sessionName}.html`;
+                    if (fs_1.default.existsSync(htmlFile)) {
+                        fs_1.default.unlinkSync(htmlFile);
+                    }
+                }
+            }
+            // 3. Clean up any stale PID files (best effort, not critical)
+            try {
+                const { stdout: pidFiles } = await execAsync('ls /tmp/ghcc-*-ttyd.pid 2>/dev/null || true');
+                const files = pidFiles.trim().split('\n').filter(f => f);
+                for (const file of files) {
+                    if (!file)
+                        continue;
+                    const sessionName = file.replace('/tmp/ghcc-', '').replace('-ttyd.pid', '');
+                    // Remove PID file if session doesn't exist
+                    if (!(await this.sessionExists(sessionName))) {
+                        await execAsync(`rm -f ${file} 2>/dev/null || true`);
+                    }
+                }
+            }
+            catch {
+                // Ignore PID file cleanup errors
+            }
+            // Update cleanup marker
+            await execAsync(`touch ${cleanupMarker} 2>/dev/null || true`);
+        }
+        catch {
+            // Error during cleanup, continue anyway
+        }
+    }
+    async start(options) {
+        let { port, session } = options;
+        console.log(chalk_1.default.cyan('🚀 Starting GitHub Copilot Remote Session...\n'));
+        // SECURITY: Validate session name format
+        if (!this.validateSessionName(session)) {
+            console.log(chalk_1.default.red('✗ Invalid session name format!\n'));
+            console.log(chalk_1.default.yellow('Session names must:'));
+            console.log(chalk_1.default.white('  • Be 3-64 characters long'));
+            console.log(chalk_1.default.white('  • Start with letter or number'));
+            console.log(chalk_1.default.white('  • Contain only: letters, numbers, hyphens, underscores'));
+            process.exit(1);
+        }
+        const spinner1 = (0, ora_1.default)('Checking for Copilot CLI...').start();
+        try {
+            await execAsync('which copilot');
+            spinner1.succeed('Copilot CLI found');
+        }
+        catch (error) {
+            spinner1.fail('Copilot CLI not found');
+            console.log(chalk_1.default.yellow('\nPlease install GitHub Copilot CLI first:'));
+            console.log(chalk_1.default.white('  npm install -g @github/copilot'));
+            process.exit(1);
+        }
+        // Clean up ALL orphaned processes before starting
+        await this.cleanupOrphanedProcesses();
+        // Check if session name already exists
+        if (await this.sessionExists(session)) {
+            console.log(chalk_1.default.red(`✗ Session "${session}" already exists!\n`));
+            console.log(chalk_1.default.yellow('This should not happen with auto-generated names.'));
+            console.log(chalk_1.default.yellow('Try running the command again.'));
+            process.exit(1);
+        }
+        // Auto-assign port if not specified
+        let finalPort;
+        if (port) {
+            finalPort = parseInt(port);
+            // SECURITY: Validate port number
+            if (!this.validatePort(finalPort)) {
+                console.log(chalk_1.default.red('✗ Invalid port number!\n'));
+                console.log(chalk_1.default.yellow('Port must be between 1024-65535 (non-privileged range)'));
+                process.exit(1);
+            }
+            // Check if specified port is available
+            if (await this.isPortInUse(finalPort)) {
+                console.log(chalk_1.default.red(`✗ Port ${finalPort} is already in use!\n`));
+                console.log(chalk_1.default.yellow('Try a different port or omit -p to auto-assign.'));
+                process.exit(1);
+            }
+        }
+        else {
+            finalPort = await this.findAvailablePort();
+        }
+        // Note: --continue doesn't work reliably in detached tmux sessions
+        // Users can use /resume command inside Copilot to switch sessions
+        const copilotCmd = 'copilot';
+        const spinner3 = (0, ora_1.default)('Starting Copilot in tmux...').start();
+        try {
+            await execAsync(`tmux new-session -d -s ${session} ${copilotCmd}`);
+            // Wait and verify session is still alive
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            // Check if session still exists
+            try {
+                await execAsync(`tmux has-session -t ${session} 2>/dev/null`);
+                spinner3.succeed(`Copilot started in tmux session "${session}"`);
+            }
+            catch {
+                spinner3.fail(`Session "${session}" exited immediately`);
+                console.log(chalk_1.default.yellow('\n⚠️  Copilot session closed right after starting.'));
+                console.log(chalk_1.default.yellow('This might happen if:'));
+                console.log(chalk_1.default.white('  • You haven\'t logged in: Run "copilot login" first'));
+                console.log(chalk_1.default.white('  • Copilot crashed or had an error'));
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            spinner3.fail('Failed to start tmux session');
+            console.error(chalk_1.default.red(error.message));
+            process.exit(1);
+        }
+        let publicUrl = ''; // Declare here for scope across ttyd and tunnel blocks
+        let ttydPassword = ''; // Store password for display
+        let tunnelPassword = ''; // Store tunnel password for display
+        let httpsEnabled = false; // Track if HTTPS is actually available
+        const spinner4 = (0, ora_1.default)(`Starting ttyd server on port ${finalPort}...`).start();
+        // SECURITY: Generate strong authentication password for ttyd
+        ttydPassword = this.generateSecurePassword(6);
+        // SECURITY: Create temp files with restricted permissions
+        const customHtmlPath = this.createSecureTempFile(`ghcc-${session}`, '.html');
+        const basePath = path_1.default.join(__dirname, '..', 'assets', 'ttyd-base.html');
+        try {
+            let html = fs_1.default.readFileSync(basePath, 'utf-8');
+            // Replace title
+            html = html.replace(/<title>.*?<\/title>/, `<title>GitHub Copilot - ${session}</title>`);
+            // Add viewport meta tag if not present (critical for mobile)
+            if (!html.includes('<meta name="viewport"')) {
+                html = html.replace('<head>', '<head><meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=5.0, user-scalable=yes, viewport-fit=cover">');
+            }
+            // SECURITY: Write with restricted permissions (0600 - owner read/write only)
+            fs_1.default.writeFileSync(customHtmlPath, html, { mode: 0o600 });
+        }
+        catch (error) {
+            console.log(chalk_1.default.yellow('Warning: Could not create mobile HTML, mobile portrait may not work'));
+        }
+        try {
+            // SECURITY: Generate self-signed certificate for HTTPS
+            const certDir = path_1.default.join(os_1.default.homedir(), '.ghcc-client', 'certs');
+            const certPath = path_1.default.join(certDir, 'cert.pem');
+            const keyPath = path_1.default.join(certDir, 'key.pem');
+            // Create cert directory if it doesn't exist
+            if (!fs_1.default.existsSync(certDir)) {
+                fs_1.default.mkdirSync(certDir, { recursive: true, mode: 0o700 });
+            }
+            // Generate self-signed cert if it doesn't exist
+            if (!fs_1.default.existsSync(certPath) || !fs_1.default.existsSync(keyPath)) {
+                spinner4.text = 'Generating HTTPS certificate (first-time only)...';
+                try {
+                    await execAsync(`openssl req -x509 -newkey rsa:2048 -nodes -keyout "${keyPath}" -out "${certPath}" -days 365 -subj "/CN=ghcc-client" 2>/dev/null`);
+                    fs_1.default.chmodSync(certPath, 0o600);
+                    fs_1.default.chmodSync(keyPath, 0o600);
+                }
+                catch (certError) {
+                    console.log(chalk_1.default.yellow('\n⚠️  Could not generate HTTPS certificate, falling back to HTTP'));
+                    console.log(chalk_1.default.gray('   Install openssl for secure HTTPS connections'));
+                }
+            }
+            const ttydArgs = [
+                '-p', finalPort.toString(),
+                '-W', // Allow clients to write
+                '-c', `user:${ttydPassword}`, // SECURITY: Basic authentication
+            ];
+            // SECURITY: Add HTTPS if certificate exists
+            if (fs_1.default.existsSync(certPath) && fs_1.default.existsSync(keyPath)) {
+                ttydArgs.push('-S', '-C', certPath, '-K', keyPath);
+                httpsEnabled = true;
+            }
+            // Use custom HTML with mobile fixes if available
+            if (fs_1.default.existsSync(customHtmlPath)) {
+                ttydArgs.push('-I', customHtmlPath);
+            }
+            // Add client options for better UX
+            ttydArgs.push('-t', 'fontSize=14');
+            ttydArgs.push('-t', 'fontFamily=Consolas,Monaco,Courier New,monospace');
+            ttydArgs.push('-t', 'theme={"background":"#1e1e1e","foreground":"#d4d4d4","cursor":"#d4d4d4","selection":"#264f78"}');
+            ttydArgs.push('-t', `titleFixed=GitHub Copilot - ${session}`);
+            ttydArgs.push('-t', 'disableLeaveAlert=true');
+            ttydArgs.push('-t', 'disableResizeOverlay=true');
+            // Add tmux command
+            ttydArgs.push('tmux', 'attach', '-t', session);
+            const ttyd = (0, child_process_1.spawn)(this.ttydPath, ttydArgs, {
+                detached: true,
+                stdio: 'ignore'
+            });
+            const ttydPid = ttyd.pid;
+            // Note: Don't call ttyd.unref() - we want this process to keep the event loop alive
+            // Wait for ttyd to start
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            // Verify ttyd process is still running
+            try {
+                await execAsync(`kill -0 ${ttydPid}`);
+            }
+            catch {
+                spinner4.fail('ttyd server failed to start');
+                console.log(chalk_1.default.red(`\n✗ ttyd process (PID ${ttydPid}) exited immediately\n`));
+                console.log(chalk_1.default.yellow('Possible causes:'));
+                console.log(chalk_1.default.white(`  • Port ${finalPort} is already in use`));
+                console.log(chalk_1.default.white('  • tmux session is inaccessible'));
+                console.log(chalk_1.default.white('  • ttyd binary is corrupted'));
+                console.log(chalk_1.default.yellow('\nCleaning up tmux session...'));
+                await execAsync(`tmux kill-session -t ${session} 2>/dev/null || true`);
+                process.exit(1);
+            }
+            // Verify port is actually listening
+            await new Promise(resolve => setTimeout(resolve, 500));
+            try {
+                await execAsync(`lsof -i :${finalPort} 2>/dev/null | grep -q LISTEN`);
+            }
+            catch {
+                spinner4.fail('ttyd server not listening on port');
+                console.log(chalk_1.default.red(`\n✗ ttyd started but is not listening on port ${finalPort}\n`));
+                console.log(chalk_1.default.yellow('Cleaning up...'));
+                await execAsync(`kill ${ttydPid} 2>/dev/null || true`);
+                await execAsync(`tmux kill-session -t ${session} 2>/dev/null || true`);
+                process.exit(1);
+            }
+            spinner4.succeed(`ttyd server started on port ${finalPort}`);
+            // Set up tmux hook for automatic cleanup
+            // Note: Hook uses PID for simplicity (edge case cleanup only)
+            // Main architecture remains process-based
+            try {
+                const hookCmd = `run-shell "kill ${ttydPid} 2>/dev/null || true"`;
+                await execAsync(`tmux set-hook -t ${session} session-closed "${hookCmd}"`);
+            }
+            catch (error) {
+                // Log error for debugging but don't fail the start
+                console.log(chalk_1.default.yellow('\n⚠️  Warning: Failed to set up automatic cleanup hook'));
+                console.log(chalk_1.default.gray(`   Error: ${error instanceof Error ? error.message : error}`));
+                console.log(chalk_1.default.gray('   (You may need to manually stop the session later)'));
+            }
+            // FINAL verification - check once more before declaring success
+            try {
+                await execAsync(`kill -0 ${ttydPid}`);
+            }
+            catch {
+                console.log(chalk_1.default.red('\n✗ ttyd process died after initial startup\n'));
+                console.log(chalk_1.default.yellow('Cleaning up...'));
+                await execAsync(`tmux kill-session -t ${session} 2>/dev/null || true`);
+                process.exit(1);
+            }
+            // Create public tunnel ONLY if --public flag is provided
+            if (options.public) {
+                // Create public tunnel with timeout and retry logic
+                // Based on localtunnel GitHub issues: https://github.com/localtunnel/localtunnel/issues
+                // Common issue: Promise hangs when tunnel server is slow/unavailable
+                // Solution: Promise.race() with timeout + retry
+                const spinner5 = (0, ora_1.default)('Creating public URL tunnel...').start();
+                const createTunnelWithTimeout = async (port, subdomain, timeoutMs = 15000) => {
+                    const tunnelPromise = (0, localtunnel_1.default)({
+                        port,
+                        subdomain
+                    });
+                    const timeoutPromise = new Promise((_, reject) => {
+                        setTimeout(() => reject(new Error('Tunnel connection timeout after ' + (timeoutMs / 1000) + 's')), timeoutMs);
+                    });
+                    return Promise.race([tunnelPromise, timeoutPromise]);
+                };
+                try {
+                    const subdomain = session.replace('ghcc-session', 'ghcc').replace(/[^a-zA-Z0-9-]/g, '');
+                    const port = parseInt(finalPort.toString());
+                    // Retry logic: Try up to 2 times
+                    let tunnel;
+                    let lastError;
+                    for (let attempt = 1; attempt <= 2; attempt++) {
+                        try {
+                            tunnel = await createTunnelWithTimeout(port, subdomain, 15000);
+                            break; // Success, exit retry loop
+                        }
+                        catch (error) {
+                            lastError = error;
+                            if (attempt < 2) {
+                                spinner5.text = `Retrying tunnel connection (${attempt}/2)...`;
+                                await new Promise(resolve => setTimeout(resolve, 1000)); // Wait 1s between retries
+                            }
+                        }
+                    }
+                    if (!tunnel) {
+                        throw lastError;
+                    }
+                    publicUrl = tunnel.url;
+                    // SECURITY: Store URL in secure file with restricted permissions
+                    const urlFile = this.createSecureTempFile(`ghcc-${session}-tunnel-url`, '.txt');
+                    fs_1.default.writeFileSync(urlFile, publicUrl, { mode: 0o600 });
+                    // Set up tunnel error handler
+                    tunnel.on('error', (err) => {
+                        console.log(chalk_1.default.yellow(`\n⚠️  Tunnel error: ${err.message}`));
+                    });
+                    tunnel.on('close', () => {
+                        // Clean up URL file when tunnel closes
+                        const urlDir = path_1.default.dirname(urlFile);
+                        if (fs_1.default.existsSync(urlFile)) {
+                            fs_1.default.unlinkSync(urlFile);
+                        }
+                        if (fs_1.default.existsSync(urlDir)) {
+                            fs_1.default.rmdirSync(urlDir);
+                        }
+                    });
+                    spinner5.succeed(`Public URL created`);
+                    // Get tunnel password (public IP) for user to share
+                    try {
+                        const { stdout: password } = await execAsync('curl -s https://loca.lt/mytunnelpassword');
+                        tunnelPassword = password.trim();
+                    }
+                    catch {
+                        // Ignore if we can't fetch the password
+                    }
+                }
+                catch (error) {
+                    spinner5.warn('Failed to create public tunnel');
+                    console.log(chalk_1.default.yellow('   Session is available locally only'));
+                    console.log(chalk_1.default.gray(`   Error: ${error instanceof Error ? error.message : error}`));
+                    console.log(chalk_1.default.gray('   Tip: Check https://loca.lt for service status'));
+                }
+            }
+            else {
+                // Local-only mode: show helpful tip
+                console.log(chalk_1.default.dim('💡 Tip: Run with --public flag to enable internet access via QR code'));
+            }
+        }
+        catch (error) {
+            spinner4.fail('Failed to spawn ttyd process');
+            console.error(chalk_1.default.red('\n✗ Error: ' + error.message));
+            console.log(chalk_1.default.yellow('\nCleaning up tmux session...'));
+            await execAsync(`tmux kill-session -t ${session} 2>/dev/null || true`);
+            process.exit(1);
+        }
+        console.log(chalk_1.default.green('\n✅ Remote session is ready!\n'));
+        // Show QR code if public URL exists
+        if (publicUrl) {
+            console.log(chalk_1.default.white('📱 Scan QR code to access from mobile:\n'));
+            qrcode_terminal_1.default.generate(publicUrl, { small: true });
+            console.log();
+            console.log(chalk_1.default.yellow('⚠️  Important: Visitors need TWO credentials'));
+            console.log(chalk_1.default.gray(`   1. Tunnel password: ${chalk_1.default.white(tunnelPassword)}`));
+            console.log(chalk_1.default.gray('   2. Terminal credentials (shown below)'));
+            console.log(chalk_1.default.gray('   After tunnel auth, it works for 7 days from their IP'));
+            console.log();
+        }
+        // SECURITY: Display authentication credentials
+        console.log(chalk_1.default.white('🔐 Terminal Session Credentials:\n'));
+        console.log(chalk_1.default.gray('   Username: ') + chalk_1.default.white('user'));
+        console.log(chalk_1.default.gray('   Password: ') + chalk_1.default.white(ttydPassword));
+        console.log();
+        this.showUrls(finalPort.toString(), session, publicUrl, httpsEnabled);
+    }
+    async stop(options) {
+        const { session, all } = options;
+        // Case 1: No flags - show help
+        if (!session && !all) {
+            console.log(chalk_1.default.yellow('⚠️  No session specified\n'));
+            console.log(chalk_1.default.white('To stop a session, you need to specify which one:\n'));
+            console.log(chalk_1.default.cyan('  ghcc-client status') + chalk_1.default.gray('           # List all running sessions'));
+            console.log(chalk_1.default.cyan('  ghcc-client stop -s <name>') + chalk_1.default.gray('  # Stop a specific session'));
+            console.log(chalk_1.default.cyan('  ghcc-client stop --all') + chalk_1.default.gray('        # Stop all sessions\n'));
+            return;
+        }
+        // Case 2: Stop all sessions
+        if (all) {
+            console.log(chalk_1.default.cyan('🛑 Stopping all sessions...\n'));
+            try {
+                const { stdout } = await execAsync('tmux list-sessions -F "#{session_name}" 2>/dev/null || true');
+                const allSessions = stdout.trim().split('\n').filter(s => s && s.startsWith('ghcc-session'));
+                if (allSessions.length === 0) {
+                    console.log(chalk_1.default.yellow('ℹ  No ghcc-session sessions found\n'));
+                    return;
+                }
+                let stoppedCount = 0;
+                for (const sess of allSessions) {
+                    // Find and kill ttyd (process-based)
+                    const ttydPid = await this.findTtydPid(sess);
+                    if (ttydPid) {
+                        try {
+                            await execAsync(`kill ${ttydPid} 2>/dev/null || true`);
+                        }
+                        catch {
+                            // Already dead
+                        }
+                    }
+                    // Find and kill tunnel (process-based)
+                    const tunnelPid = await this.findTunnelPid(sess);
+                    if (tunnelPid) {
+                        try {
+                            await execAsync(`kill ${tunnelPid} 2>/dev/null || true`);
+                        }
+                        catch {
+                            // Already dead
+                        }
+                    }
+                    // Kill tmux session
+                    try {
+                        await execAsync(`tmux kill-session -t ${sess} 2>/dev/null || true`);
+                    }
+                    catch {
+                        // Already dead
+                    }
+                    // Clean up temp files
+                    try {
+                        await execAsync(`rm -f /tmp/ghcc-${sess}-tunnel-url /tmp/ghcc-${sess}.html`);
+                    }
+                    catch {
+                        // Ignore cleanup errors
+                    }
+                    console.log(chalk_1.default.green(`✔ ${sess} stopped`));
+                    stoppedCount++;
+                }
+                console.log(chalk_1.default.green(`\n✅ Stopped ${stoppedCount} session(s)\n`));
+            }
+            catch {
+                console.log(chalk_1.default.red('✗ Error listing sessions\n'));
+            }
+            return;
+        }
+        // Case 3: Stop specific session (TypeScript knows session is defined here)
+        const sessionName = session;
+        let ttydStopped = false;
+        let sessionStopped = false;
+        // Find and kill ttyd process (process-based)
+        const ttydPid = await this.findTtydPid(sessionName);
+        if (ttydPid) {
+            try {
+                await execAsync(`kill ${ttydPid} 2>/dev/null || true`);
+                ttydStopped = true;
+            }
+            catch {
+                // Already dead
+            }
+        }
+        // Find and kill tunnel process
+        const tunnelPid = await this.findTunnelPid(sessionName);
+        if (tunnelPid) {
+            try {
+                await execAsync(`kill ${tunnelPid} 2>/dev/null || true`);
+            }
+            catch {
+                // Already dead
+            }
+        }
+        // Clean up tunnel URL file
+        const urlFile = `/tmp/ghcc-${sessionName}-tunnel-url`;
+        if (fs_1.default.existsSync(urlFile)) {
+            fs_1.default.unlinkSync(urlFile);
+        }
+        // Clean up custom HTML file
+        const htmlFile = `/tmp/ghcc-${sessionName}.html`;
+        if (fs_1.default.existsSync(htmlFile)) {
+            fs_1.default.unlinkSync(htmlFile);
+        }
+        // Kill tmux session if it exists
+        if (await this.sessionExists(sessionName)) {
+            try {
+                await execAsync(`tmux kill-session -t ${sessionName} 2>/dev/null`);
+                sessionStopped = true;
+            }
+            catch {
+                // Failed to kill
+            }
+        }
+        if (!ttydStopped && !sessionStopped) {
+            console.log(chalk_1.default.yellow(`\nℹ  Session "${sessionName}" was not running\n`));
+        }
+        else {
+            console.log(chalk_1.default.green(`\n✅ Session "${sessionName}" stopped\n`));
+        }
+    }
+    showUrls(port, session, publicUrl, httpsEnabled = false) {
+        const interfaces = os_1.default.networkInterfaces();
+        let localIp = 'localhost';
+        for (const name of Object.keys(interfaces)) {
+            const ifaces = interfaces[name];
+            if (!ifaces)
+                continue;
+            for (const iface of ifaces) {
+                if (iface.family === 'IPv4' && !iface.internal) {
+                    localIp = iface.address;
+                    break;
+                }
+            }
+        }
+        const protocol = httpsEnabled ? 'https' : 'http';
+        console.log(chalk_1.default.cyan('Access URLs:'));
+        console.log(chalk_1.default.white(`  Local:      ${chalk_1.default.underline(`${protocol}://localhost:${port}`)}`));
+        console.log(chalk_1.default.white(`  Network:    ${chalk_1.default.underline(`${protocol}://${localIp}:${port}`)}`));
+        if (publicUrl) {
+            console.log(chalk_1.default.white(`  Public:     ${chalk_1.default.underline(publicUrl)}`));
+        }
+        if (session) {
+            console.log(chalk_1.default.white(`  Session:    ${session}`));
+        }
+        console.log('');
+    }
+}
+exports.SessionManager = SessionManager;
+//# sourceMappingURL=session-manager.js.map