@hmduc16031996/claude-mb-bridge 2.4.8 → 2.4.9

package/dist/index.js

@@ -2,89 +2,78 @@
 import { Command } from 'commander';
 import { CloudflareTunnel } from './tunnel.js';
 import { startTerminalServer } from './server.js';
-// ─── Built-in Cloudflare named tunnel (mobileideforusers.kanddlabs.com) ───────
-// These are embedded at publish time. End-users don't need to supply them.
-const BUILTIN_CF_TOKEN = 'eyJhIjoiZmM5YTQ4ZTU3NjY4NjI3MjY2OWE3YzBiMTliNTcyYzgiLCJ0IjoiMjgzM2E5NjMtNTBiYi00YThjLWJhMGMtNDI4NWE4ZTJkZmJjIiwicyI6IllqYzVaakF3T1RJdFpEWXdZeTAwWkRFNUxUZzVNR0l0WXpBeE1UazJNamc1T1dZeCJ9';
-const BUILTIN_TUNNEL_URL = 'https://mobileideforusers.kanddlabs.com';
-// ──────────────────────────────────────────────────────────────────────────────
 const program = new Command();
+const CLOUDFLARE_TUNNEL_TOKEN = 'eyJhIjoiZmM5YTQ4ZTU3NjY4NjI3MjY2OWE3YzBiMTliNTcyYzgiLCJ0IjoiMjgzM2E5NjMtNTBiYi00YThjLWJhMGMtNDI4NWE4ZTJkZmJjIiwicyI6IllqYzVaakF3T1RJdFpEWXdZeTAwWkRFNUxUZzVNR0l0WXpBeE1UazJNamc1T1dZeCJ9';
+const CLOUDFLARE_PUBLIC_URL = 'https://mobileideforusers.kanddlabs.com';
 program
     .name('claude-mobile-bridge')
     .description('Bridge Claude Code CLI to mobile via WebView')
-    .version('2.4.7')
+    .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('--server <url>', 'Backend server URL', 'https://mobileide.kanddlabs.com')
     .option('--path <path>', 'Working directory', process.cwd())
     .option('--port <port>', 'Local port for terminal server', '38473')
-    .option('--ide <type>', 'IDE type: claude_code, cursor, or gemini', 'claude_code')
-    // Advanced: override the built-in tunnel with your own
-    .option('--cloudflare-token <cfToken>', 'Override built-in Cloudflare tunnel token')
-    .option('--tunnel-url <url>', 'Override built-in tunnel public URL')
-    // Escape hatch: fall back to ephemeral trycloudflare
-    .option('--quick-tunnel', 'Use ephemeral trycloudflare.com tunnel instead of the named tunnel')
+    .option('--ide <type>', 'IDE type: claude_code or cursor', 'claude_code')
+    .option('--tunnel-token <token>', 'Cloudflare Tunnel token (managed tunnel)', CLOUDFLARE_TUNNEL_TOKEN)
+    .option('--public-url <url>', 'Static public URL for the tunnel', CLOUDFLARE_PUBLIC_URL)
     .action(async (options) => {
-    const { token, server, path, port, ide, quickTunnel } = options;
+    const { token, server, path, port, ide, tunnelToken, publicUrl } = options;
     if (!token) {
         console.error('Error: --token is required');
         process.exit(1);
     }
-    // Resolve tunnel config: cli overrides > built-ins > quick tunnel
-    const cfToken = options.cloudflareToken ?? BUILTIN_CF_TOKEN;
-    const tunnelUrl = options.tunnelUrl ?? BUILTIN_TUNNEL_URL;
-    const useNamedTunnel = !quickTunnel;
-    let tunnelResult = null;
-    let terminalServer = null;
-    // Cleanup
+    // 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: ts, actualPort } = await startTerminalServer(localPort, path, token, ide);
-    terminalServer = ts;
+    const { server: terminalServer, actualPort } = await startTerminalServer(localPort, path, token, ide);
     console.log(`✅ Terminal server started on port ${actualPort}`);
     // 2. Start Cloudflare Tunnel
+    console.log('🌐 Establishing secure tunnel...');
     const tunnel = new CloudflareTunnel();
-    if (useNamedTunnel) {
-        console.log(`🌐 Connecting tunnel → ${tunnelUrl} ...`);
-        tunnelResult = await tunnel.startNamed(cfToken, tunnelUrl);
-    }
-    else {
-        console.log('🌐 Establishing ephemeral Cloudflare tunnel...');
-        tunnelResult = await tunnel.startQuick(actualPort);
-    }
-    if (!tunnelResult.url) {
-        console.error('❌ Failed to start Cloudflare Tunnel.');
+    const tunnelResult = await tunnel.start(actualPort, tunnelToken);
+    // If using a token, use the provided publicUrl or hardcoded one
+    const finalUrl = tunnelToken ? publicUrl : tunnelResult.url;
+    if (!finalUrl) {
+        console.error('❌ Failed to establish secure tunnel.');
         process.exit(1);
     }
-    console.log(`✅ Tunnel active: ${tunnelResult.url}`);
-    // 3. Validate token with central server
+    console.log(`✅ Secure tunnel established at ${finalUrl}`);
+    // 3. Validate token and report public URL to central server
     console.log('🔑 Validating session token...');
     try {
         const res = await fetch(`${server}/api/sessions/${token}/validate`, {
             method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ public_url: tunnelResult.url })
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                public_url: finalUrl
+            })
         });
-        if (!res.ok)
+        if (!res.ok) {
             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');
-        await cleanup();
+        cleanup();
     }
+    // Handle graceful shutdown signals
     process.on('SIGINT', cleanup);
     process.on('SIGTERM', cleanup);
     process.on('SIGHUP', cleanup);

package/dist/tunnel.d.ts

@@ -4,15 +4,6 @@ export interface TunnelResult {
 }
 export declare class CloudflareTunnel {
     private process;
-    /**
-     * 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>;
+    start(port: number, token?: string): Promise<TunnelResult>;
     private cleanup;
 }

package/dist/tunnel.js

@@ -1,65 +1,23 @@
 import { spawn } from 'child_process';
 export class CloudflareTunnel {
     process = null;
-    /**
-     * 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) {
+    async start(port, token) {
         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}`], {
+                const args = token
+                    ? ['tunnel', 'run', '--token', token]
+                    : ['tunnel', '--url', `http://localhost:${port}`];
+                const proc = spawn('cloudflared', args, {
                     stdio: ['ignore', 'pipe', 'pipe'],
                 });
                 this.process = proc;
+                if (token) {
+                    // For named tunnels, resolve immediately after a short delay
+                    setTimeout(() => {
+                        resolve({ url: null, cleanup: () => this.cleanup() });
+                    }, 2000);
+                    return;
+                }
                 let output = '';
                 const timeout = setTimeout(() => {
                     resolve({ url: null, cleanup: () => this.cleanup() });

package/package.json

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