@vaishnavkm/flutterbridge 0.1.0 → 0.1.2

package/README.md

@@ -10,26 +10,26 @@ Bridge your Flutter code to your phone instantly. No USB cables. No complex ADB
 
 ```bash
 # Using npm
-npm install -g flutterbridge
+npm install -g @vaishnavkm/flutterbridge
 
 # Using pnpm
-pnpm add -g flutterbridge
+pnpm add -g @vaishnavkm/flutterbridge
 
 # Using bun
-bun add -g flutterbridge
+bun add -g @vaishnavkm/flutterbridge
 ```
 
 ### One-time Use (No Installation)
 
 ```bash
 # Using npm
-npx flutterbridge
+npx @vaishnavkm/flutterbridge
 
 # Using pnpm
-pnpm dlx flutterbridge
+pnpm dlx @vaishnavkm/flutterbridge
 
 # Using bun
-bunx flutterbridge
+bunx @vaishnavkm/flutterbridge
 ```
 
 ## Usage
@@ -42,6 +42,9 @@ flutterbridge
 
 A QR code will appear in your terminal. Scan it with the FlutterBridge companion app to connect.
 
+If the VM service is bound to localhost, FlutterBridge will start a LAN proxy
+and encode that address in the QR so phones can connect over WiFi.
+
 ## CLI Options
 
 ```bash

package/index.js

@@ -2,13 +2,15 @@
 
 const qrcode = require('qrcode-terminal');
 const chalk = require('chalk');
+const WebSocket = require('ws');
 const { spawn } = require('child_process');
 const readline = require('readline');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const net = require('net');
 
-const VM_URL_TIMEOUT_MS = 60000;
+const VM_URL_TIMEOUT_MS = 300000; // 5 minutes (initial gradle builds take time)
 const SERVICE_URI_KEYS = [
   'vmServiceUri',
   'observatoryUri',
@@ -18,6 +20,8 @@ const SERVICE_URI_KEYS = [
   'wsUri',
 ];
 
+const activeProxies = new Set();
+
 function parseArgs(argv) {
   let deviceId = null;
   let qrOnly = false;
@@ -169,25 +173,158 @@ function getLanIp() {
   return candidates[0];
 }
 
-function rewriteVmServiceUrl(originalUrl) {
-  try {
-    const parsed = new URL(originalUrl);
-    if (!isLoopbackHost(parsed.hostname)) {
-      return { url: originalUrl, replaced: false };
+function getDefaultPort(protocol) {
+  if (protocol === 'wss:' || protocol === 'https:') {
+    return 443;
+  }
+  if (protocol === 'ws:' || protocol === 'http:') {
+    return 80;
+  }
+  return null;
+}
+
+function registerProxy(server) {
+  activeProxies.add(server);
+  server.on('close', () => activeProxies.delete(server));
+}
+
+function closeAllProxies() {
+  for (const server of activeProxies) {
+    try {
+      server.close();
+    } catch (_) {
+      // Ignore errors while shutting down.
     }
+  }
+  activeProxies.clear();
+}
+
+process.on('exit', closeAllProxies);
+
+function startScreenshotServer(deviceId) {
+  return new Promise((resolve, reject) => {
+    try {
+      const wss = new WebSocket.Server({ port: 0, host: '0.0.0.0' });
+      let intervalId = null;
+      let connections = 0;
+
+      wss.on('listening', () => {
+        const port = wss.address().port;
+        resolve(port);
+      });
 
-    const lanIp = getLanIp();
-    if (!lanIp) {
-      console.warn(chalk.yellow('\n⚠️  Warning: Could not detect LAN IP address.'));
-      console.warn(chalk.yellow('Make sure your PC and phone are on the same WiFi network.'));
-      console.warn(chalk.yellow('Connection may fail with localhost URL.\n'));
-      return { url: originalUrl, replaced: false };
+      wss.on('error', (err) => {
+        reject(err);
+      });
+
+      wss.on('connection', (ws) => {
+        connections++;
+        
+        if (connections === 1) {
+          intervalId = setInterval(() => {
+            const adbArgs = deviceId ? ['-s', deviceId, 'exec-out', 'screencap', '-p'] : ['exec-out', 'screencap', '-p'];
+            const child = spawn('adb', adbArgs);
+            const chunks = [];
+            
+            child.stdout.on('data', chunk => chunks.push(chunk));
+            child.on('close', code => {
+              if (code === 0 && wss.clients.size > 0) {
+                const buffer = Buffer.concat(chunks);
+                wss.clients.forEach(client => {
+                  if (client.readyState === WebSocket.OPEN) {
+                    client.send(buffer);
+                  }
+                });
+              }
+            });
+          }, 500); // 2 fps polling
+        }
+
+        ws.on('close', () => {
+          connections--;
+          if (connections === 0 && intervalId) {
+            clearInterval(intervalId);
+            intervalId = null;
+          }
+        });
+      });
+
+      registerProxy(wss);
+    } catch(err) {
+      reject(err);
     }
+  });
+}
 
-    parsed.hostname = lanIp;
-    return { url: parsed.toString(), replaced: true };
+function startTcpProxy(targetHost, targetPort) {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer((client) => {
+      const upstream = net.connect({ host: targetHost, port: targetPort });
+
+      const closeBoth = () => {
+        client.destroy();
+        upstream.destroy();
+      };
+
+      client.on('error', closeBoth);
+      upstream.on('error', closeBoth);
+
+      client.pipe(upstream);
+      upstream.pipe(client);
+    });
+
+    server.on('error', reject);
+
+    server.listen(0, '0.0.0.0', () => {
+      registerProxy(server);
+      const address = server.address();
+      resolve({ server, port: address.port });
+    });
+  });
+}
+
+async function prepareVmServiceUrl(originalUrl) {
+  let parsed;
+  try {
+    parsed = new URL(originalUrl);
   } catch (_) {
-    return { url: originalUrl, replaced: false };
+    return { url: originalUrl, originalUrl, replaced: false, proxied: false };
+  }
+
+  if (!isLoopbackHost(parsed.hostname)) {
+    return { url: originalUrl, originalUrl, replaced: false, proxied: false };
+  }
+
+  const lanIp = getLanIp();
+  if (!lanIp) {
+    console.warn(chalk.yellow('\n⚠️  Warning: Could not detect LAN IP address.'));
+    console.warn(chalk.yellow('Make sure your PC and phone are on the same WiFi network.'));
+    console.warn(chalk.yellow('Connection may fail with localhost URL.\n'));
+    return { url: originalUrl, originalUrl, replaced: false, proxied: false };
+  }
+
+  const port = parsed.port ? Number(parsed.port) : getDefaultPort(parsed.protocol);
+  if (!port) {
+    return { url: originalUrl, originalUrl, replaced: false, proxied: false };
+  }
+
+  const targetHost = parsed.hostname === '0.0.0.0' ? '127.0.0.1' : parsed.hostname;
+  try {
+    const proxy = await startTcpProxy(targetHost, port);
+    parsed.hostname = lanIp;
+    parsed.port = String(proxy.port);
+    return {
+      url: parsed.toString(),
+      originalUrl,
+      replaced: true,
+      proxied: true,
+      proxyHost: lanIp,
+      proxyPort: proxy.port,
+    };
+  } catch (err) {
+    console.warn(chalk.yellow(`\n⚠️  Warning: Failed to start LAN proxy (${err.message}).`));
+    parsed.hostname = lanIp;
+    return { url: parsed.toString(), originalUrl, replaced: true, proxied: false };
   }
 }
 
@@ -376,6 +513,14 @@ async function main() {
     return;
   }
 
+  let previewPort = null;
+  try {
+    previewPort = await startScreenshotServer(deviceId);
+    if (!quiet) console.log(chalk.gray(`Started Live Preview server on port ${previewPort}`));
+  } catch (e) {
+    if (!quiet) console.warn(chalk.yellow(`Warning: Failed to start Live Preview server: ${e.message}`));
+  }
+
   if (!quiet) {
     console.log(chalk.gray('Starting Flutter...\n'));
   }
@@ -395,6 +540,7 @@ async function main() {
   let stdoutBuffer = '';
   let stderrBuffer = '';
   let vmServiceUrl = null;
+  let publishPending = false;
 
   const vmTimeout = setTimeout(() => {
     if (!vmServiceUrl) {
@@ -420,29 +566,66 @@ async function main() {
       const events = Array.isArray(json) ? json : [json];
       for (const event of events) {
         const url = extractVmServiceUri(event);
-        if (url && !vmServiceUrl) {
-          const rewritten = rewriteVmServiceUrl(url);
-          vmServiceUrl = rewritten.url;
-          clearTimeout(vmTimeout);
-          if (jsonOutput) {
-            const payload = { vmServiceUri: vmServiceUrl, deviceId };
-            if (rewritten.replaced) {
-              payload.originalVmServiceUri = url;
+        if (url && !vmServiceUrl && !publishPending) {
+          publishPending = true;
+
+          const publishUrl = (result) => {
+            if (vmServiceUrl) {
+              return;
             }
-            console.log(JSON.stringify(payload));
-          } else {
+            
+            let finalUrl = result.url;
+            if (previewPort) {
+              try {
+                const u = new URL(finalUrl);
+                u.searchParams.set('previewPort', previewPort);
+                finalUrl = u.toString();
+              } catch(e) {}
+            }
+            
+            vmServiceUrl = finalUrl;
+            clearTimeout(vmTimeout);
+
+            if (jsonOutput) {
+              const payload = { vmServiceUri: vmServiceUrl, deviceId };
+              if (result.replaced) {
+                payload.originalVmServiceUri = result.originalUrl;
+              }
+              if (result.proxied) {
+                payload.proxy = { host: result.proxyHost, port: result.proxyPort };
+              }
+              console.log(JSON.stringify(payload));
+              return;
+            }
+
             if (!qrOnly) {
               console.log(chalk.yellow('\nScan this QR with FlutterBridge app:\n'));
             }
             qrcode.generate(vmServiceUrl, { small: true });
             if (!qrOnly) {
-              if (rewritten.replaced) {
+              if (result.proxied) {
+                console.log(chalk.gray(`LAN proxy running at ws://${result.proxyHost}:${result.proxyPort}`));
+                console.log(chalk.gray(`Proxy target: ${result.originalUrl}`));
+              } else if (result.replaced) {
                 console.log(chalk.gray(`Rewrote VM URL for LAN access: ${vmServiceUrl}`));
-                console.log(chalk.gray(`Original VM URL: ${url}`));
+                console.log(chalk.gray(`Original VM URL: ${result.originalUrl}`));
               }
               console.log(chalk.green(`\nVM URL: ${vmServiceUrl}`));
             }
-          }
+          };
+
+          prepareVmServiceUrl(url)
+            .then((result) => {
+              publishPending = false;
+              publishUrl(result);
+            })
+            .catch((err) => {
+              publishPending = false;
+              if (!quiet) {
+                console.error(chalk.red(`Failed to prepare VM service URL: ${err.message}`));
+              }
+              publishUrl({ url, originalUrl: url, replaced: false, proxied: false });
+            });
         }
       }
     }

package/package.json

@@ -1,17 +1,14 @@
 {
   "name": "@vaishnavkm/flutterbridge",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Bridge your Flutter code to your phone instantly. Wireless development with QR code pairing.",
   "main": "index.js",
   "bin": {
-    "flutterbridge": "./index.js"
+    "bridge": "index.js"
   },
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
   "keywords": [
     "flutter",
     "mobile",
@@ -28,7 +25,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/vaishnavkm/flutterbridge.git"
+    "url": "git+https://github.com/vaishnavkm/flutterbridge.git"
   },
   "bugs": {
     "url": "https://github.com/vaishnavkm/flutterbridge/issues"
@@ -37,9 +34,12 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "packageManager": "pnpm@10.33.0",
   "dependencies": {
     "chalk": "^4.1.2",
-    "qrcode-terminal": "^0.12.0"
+    "qrcode-terminal": "^0.12.0",
+    "ws": "^8.21.0"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
   }
-}
+}