@hmduc16031996/claude-mb-bridge 2.4.5 → 2.4.7

package/dist/index.js

@@ -6,45 +6,62 @@ const program = new Command();
 program
     .name('claude-mobile-bridge')
     .description('Bridge Claude Code CLI to mobile via WebView')
-    .version('2.4.5')
+    .version('2.4.1')
     .option('--token <token>', 'Pairing token from mobile app')
     .option('--server <url>', 'Backend server URL', 'http://127.0.0.1:3110')
     .option('--path <path>', 'Working directory', process.cwd())
     .option('--port <port>', 'Local port for terminal server', '38473')
-    .option('--ide <type>', 'IDE type: claude_code or cursor', 'claude_code')
+    .option('--ide <type>', 'IDE type: claude_code, cursor, or gemini', 'claude_code')
+    // Named tunnel options (use your own Cloudflare tunnel instead of trycloudflare)
+    .option('--cloudflare-token <cfToken>', 'Cloudflare tunnel token for named tunnel')
+    .option('--tunnel-url <url>', 'Public URL of your named Cloudflare tunnel (e.g. https://mobileideforusers.kanddlabs.com)')
     .action(async (options) => {
-    const { token, server, path, port, ide } = options;
+    const { token, server, path, port, ide, cloudflareToken, tunnelUrl } = options;
     if (!token) {
         console.error('Error: --token is required');
         process.exit(1);
     }
+    // Validate named-tunnel options: both must be provided together or neither
+    const useNamedTunnel = !!(cloudflareToken || tunnelUrl);
+    if (useNamedTunnel && !(cloudflareToken && tunnelUrl)) {
+        console.error('Error: --cloudflare-token and --tunnel-url must both be provided when using a named tunnel');
+        process.exit(1);
+    }
+    let tunnelResult = null;
+    let terminalServer = null;
     // Define cleanup function
     const cleanup = async () => {
         console.log('\n👋 Cleaning up session and shutting down...');
         try {
-            // Optional: Notify server to end session
             await fetch(`${server}/api/sessions/${token}/expire`, { method: 'POST' }).catch(() => { });
         }
         finally {
-            tunnelResult.cleanup();
-            terminalServer.close();
+            tunnelResult?.cleanup();
+            terminalServer?.close();
             process.exit(0);
         }
     };
     // 1. Start local terminal server
     console.log('📦 Starting terminal server...');
     const localPort = parseInt(port, 10);
-    const { server: terminalServer, actualPort } = await startTerminalServer(localPort, path, token, ide);
+    const { server: ts, actualPort } = await startTerminalServer(localPort, path, token, ide);
+    terminalServer = ts;
     console.log(`✅ Terminal server started on port ${actualPort}`);
-    // 2. Start Cloudflare Tunnel
-    console.log('🌐 Establishing secure tunnel...');
+    // 2. Start Cloudflare Tunnel (named or quick)
     const tunnel = new CloudflareTunnel();
-    const tunnelResult = await tunnel.start(actualPort);
+    if (useNamedTunnel) {
+        console.log(`🌐 Connecting named Cloudflare tunnel → ${tunnelUrl} ...`);
+        tunnelResult = await tunnel.startNamed(cloudflareToken, tunnelUrl);
+    }
+    else {
+        console.log('🌐 Establishing ephemeral Cloudflare tunnel...');
+        tunnelResult = await tunnel.startQuick(actualPort);
+    }
     if (!tunnelResult.url) {
         console.error('❌ Failed to start Cloudflare Tunnel.');
         process.exit(1);
     }
-    console.log('✅ Secure tunnel established');
+    console.log(`✅ Tunnel active: ${tunnelResult.url}`);
     // 3. Validate token and report public URL to central server
     console.log('🔑 Validating session token...');
     try {
@@ -61,11 +78,12 @@ program
             throw new Error('Invalid token or session expired');
         }
         console.log('✅ Session connected and authorized');
+        console.log(`📱 Mobile app can now connect via: ${tunnelResult.url}`);
     }
     catch (err) {
         console.error(`❌ Validation failed: ${err.message}`);
         console.error('   Ensure the central server is available');
-        cleanup();
+        await cleanup();
     }
     // Handle graceful shutdown signals
     process.on('SIGINT', cleanup);

package/dist/server.js

@@ -92,12 +92,6 @@ export function startTerminalServer(port, workingDir, terminalToken, ide = 'clau
     app.get('/health', (req, res) => {
         res.json({ status: 'ok' });
     });
-    // Catch-all: serve index.html for any non-API route (SPA fallback)
-    app.get('*', (req, res, next) => {
-        if (req.path.startsWith('/api/'))
-            return next();
-        res.sendFile(path.join(publicPath, 'index.html'));
-    });
     // Session Info endpoint (used by frontend to know which IDE it is bridging)
     app.get('/api/session-info', (req, res) => {
         res.json({ ide });
@@ -322,7 +316,7 @@ export function startTerminalServer(port, workingDir, terminalToken, ide = 'clau
                 reject(err);
             }
         });
-        server.listen(port, '0.0.0.0', () => {
+        server.listen(port, () => {
             const address = server.address();
             const actualPort = typeof address === 'string' ? 0 : address?.port || 0;
             resolve({ server, actualPort });

package/dist/tunnel.d.ts

@@ -4,6 +4,15 @@ export interface TunnelResult {
 }
 export declare class CloudflareTunnel {
     private process;
-    start(port: number): Promise<TunnelResult>;
+    /**
+     * Start a named Cloudflare tunnel using a pre-existing tunnel token.
+     * The public URL is known ahead of time (configured in Cloudflare dashboard).
+     */
+    startNamed(tunnelToken: string, publicUrl: string): Promise<TunnelResult>;
+    /**
+     * Start an ephemeral quick tunnel (trycloudflare.com).
+     * The public URL is parsed from cloudflared stderr output.
+     */
+    startQuick(port: number): Promise<TunnelResult>;
     private cleanup;
 }

package/dist/tunnel.js

@@ -1,7 +1,59 @@
 import { spawn } from 'child_process';
 export class CloudflareTunnel {
     process = null;
-    async start(port) {
+    /**
+     * Start a named Cloudflare tunnel using a pre-existing tunnel token.
+     * The public URL is known ahead of time (configured in Cloudflare dashboard).
+     */
+    async startNamed(tunnelToken, publicUrl) {
+        return new Promise((resolve) => {
+            try {
+                const proc = spawn('cloudflared', ['tunnel', 'run', '--token', tunnelToken], {
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                this.process = proc;
+                // Give cloudflared a moment to connect; fail if it exits immediately
+                const timeout = setTimeout(() => {
+                    // Still resolving with the known public URL — named tunnels don't print the URL
+                    resolve({ url: publicUrl, cleanup: () => this.cleanup() });
+                }, 5000);
+                proc.stdout?.on('data', (data) => {
+                    console.log('[cloudflared]', data.toString().trim());
+                });
+                proc.stderr?.on('data', (data) => {
+                    const line = data.toString().trim();
+                    if (line)
+                        console.log('[cloudflared]', line);
+                    // If we see a connection established log, resolve immediately
+                    if (line.includes('Connection') || line.includes('registered')) {
+                        clearTimeout(timeout);
+                        resolve({ url: publicUrl, cleanup: () => this.cleanup() });
+                    }
+                });
+                proc.on('error', (err) => {
+                    clearTimeout(timeout);
+                    console.error('[cloudflared] Failed to start:', err.message);
+                    resolve({ url: null, cleanup: () => this.cleanup() });
+                });
+                proc.on('exit', (code) => {
+                    clearTimeout(timeout);
+                    if (code !== 0) {
+                        console.error(`[cloudflared] Exited with code ${code}`);
+                    }
+                    this.process = null;
+                });
+            }
+            catch (err) {
+                console.error('[cloudflared] Exception:', err.message);
+                resolve({ url: null, cleanup: () => this.cleanup() });
+            }
+        });
+    }
+    /**
+     * Start an ephemeral quick tunnel (trycloudflare.com).
+     * The public URL is parsed from cloudflared stderr output.
+     */
+    async startQuick(port) {
         return new Promise((resolve) => {
             try {
                 const proc = spawn('cloudflared', ['tunnel', '--url', `http://localhost:${port}`], {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hmduc16031996/claude-mb-bridge",
-  "version": "2.4.5",
+  "version": "2.4.7",
   "description": "Bridge between Claude Code CLI and your mobile app via WebView",
   "type": "module",
   "main": "dist/index.js",