@vaishnavkm/flutterbridge 0.1.0 → 0.1.1

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

@@ -7,6 +7,7 @@ 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 SERVICE_URI_KEYS = [
@@ -18,6 +19,8 @@ const SERVICE_URI_KEYS = [
   'wsUri',
 ];
 
+const activeProxies = new Set();
+
 function parseArgs(argv) {
   let deviceId = null;
   let qrOnly = false;
@@ -169,25 +172,103 @@ 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));
+}
 
-    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 };
+function closeAllProxies() {
+  for (const server of activeProxies) {
+    try {
+      server.close();
+    } catch (_) {
+      // Ignore errors while shutting down.
     }
+  }
+  activeProxies.clear();
+}
 
-    parsed.hostname = lanIp;
-    return { url: parsed.toString(), replaced: true };
+process.on('exit', closeAllProxies);
+
+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 };
   }
 }
 
@@ -395,6 +476,7 @@ async function main() {
   let stdoutBuffer = '';
   let stderrBuffer = '';
   let vmServiceUrl = null;
+  let publishPending = false;
 
   const vmTimeout = setTimeout(() => {
     if (!vmServiceUrl) {
@@ -420,29 +502,56 @@ 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 {
+            vmServiceUrl = result.url;
+            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,10 +1,10 @@
 {
   "name": "@vaishnavkm/flutterbridge",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Bridge your Flutter code to your phone instantly. Wireless development with QR code pairing.",
   "main": "index.js",
   "bin": {
-    "flutterbridge": "./index.js"
+    "flutterbridge": "index.js"
   },
   "publishConfig": {
     "access": "public"
@@ -28,7 +28,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"