promethios-bridge 1.7.6 → 1.7.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "promethios-bridge",
-  "version": "1.7.6",
+  "version": "1.7.7",
   "description": "Run Promethios agent frameworks locally on your computer with full file, terminal, browser access, ambient context capture, and the always-on-top floating chat overlay. Native Framework Mode supports OpenClaw and other frameworks via the bridge.",
   "main": "src/index.js",
   "bin": {
@@ -49,8 +49,7 @@
     "express": "^4.18.2",
     "open": "^8.4.2",
     "ora": "^5.4.1",
-    "node-fetch": "^2.7.0",
-    "playwright": "^1.42.0"
+    "node-fetch": "^2.7.0"
   },
   "optionalDependencies": {
     "playwright": "^1.42.0",

package/src/bridge.js

@@ -72,6 +72,52 @@ async function checkForUpdates(currentVersion, log) {
   }
 }
 
+/**
+ * Open a URL in the user's default browser.
+ * Uses platform-native commands for maximum reliability:
+ *   Windows: cmd /c start "" "<url>"
+ *   macOS:   open <url>
+ *   Linux:   xdg-open <url>
+ * Falls back to the `open` npm package if the native command fails.
+ * Returns true if the browser was successfully opened, false otherwise.
+ */
+async function openInBrowser(url, log) {
+  const { exec } = require('child_process');
+  const platform = process.platform;
+
+  return new Promise((resolve) => {
+    let cmd;
+    if (platform === 'win32') {
+      // On Windows, `start` requires an empty title arg before the URL
+      // to prevent issues with URLs containing special characters.
+      cmd = `cmd /c start "" "${url}"`;
+    } else if (platform === 'darwin') {
+      cmd = `open "${url}"`;
+    } else {
+      cmd = `xdg-open "${url}"`;
+    }
+
+    exec(cmd, { timeout: 5000 }, (err) => {
+      if (!err) {
+        resolve(true);
+        return;
+      }
+      // Native command failed — try the `open` npm package as fallback
+      log('Native browser open failed, trying open package:', err.message);
+      try {
+        const openModule = require('open');
+        openModule(url).then(() => resolve(true)).catch((e) => {
+          log('open package also failed:', e.message);
+          resolve(false);
+        });
+      } catch (e) {
+        log('open package not available:', e.message);
+        resolve(false);
+      }
+    });
+  });
+}
+
 async function startBridge({ setupToken, apiBase, port, dev }) {
   const log = dev
     ? (...args) => console.log(chalk.gray('  [debug]'), ...args)
@@ -366,17 +412,15 @@ async function startBridge({ setupToken, apiBase, port, dev }) {
     // Electron not available — open the lightweight browser overlay instead.
     // This is a small chat UI served by the bridge's own Express server.
     const overlayUrl = `http://127.0.0.1:${port}/overlay`;
-    try {
-      const openModule = require('open');
-      await openModule(overlayUrl);
+    const openedInBrowser = await openInBrowser(overlayUrl, log);
+    if (openedInBrowser) {
       console.log(chalk.cyan('  ⬡ Promethios overlay opened in your browser'));
       console.log(chalk.gray(`    URL: ${overlayUrl}`));
-      console.log('');
-    } catch (err) {
-      log('Browser overlay launch failed (non-critical):', err.message);
-      console.log(chalk.gray(`  ℹ  Open ${overlayUrl} in your browser for the chat overlay`));
-      console.log('');
+    } else {
+      console.log(chalk.gray(`  ℹ  Open this URL in your browser for the chat overlay:`));
+      console.log(chalk.cyan(`    ${overlayUrl}`));
     }
+    console.log('');
   }
 
   // Heartbeat loop

package/src/overlay/launcher.js

@@ -2,56 +2,74 @@
  * launcher.js
  *
  * Called by the bridge CLI after successful authentication.
- * Spawns the Electron overlay window as a detached child process.
- * Bundled inside promethios-bridge — no separate install required.
+ * Attempts to launch the Electron overlay window. Returns null if Electron
+ * is not available (which is the case when running via `npx`, since optional
+ * dependencies are not installed in the npx cache).
  *
- * Usage (from bridge CLI):
- *   const { launchOverlay } = require('./overlay/launcher');
- *   launchOverlay({ authToken, apiBase, threadId, dev });
+ * IMPORTANT: We check for the actual Electron binary on disk, NOT just whether
+ * the `electron` npm package is present. When running via `npx`, the electron
+ * package IS downloaded (it's a listed optionalDependency), but its postinstall
+ * script downloads the real binary separately — that binary may not exist yet.
+ * Using require.resolve('electron') would return true even without the binary,
+ * causing spawn() to fail silently and the browser fallback to never be reached.
  */
 
+'use strict';
+
 const { spawn } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 
 /**
- * Launch the Promethios overlay Electron window.
- * Returns the child process (or null if Electron is not available).
- *
- * IMPORTANT: When running via `npx`, optional dependencies (including electron)
- * are NOT installed in the npx cache. The spawn() call may therefore fail with
- * ENOENT. We attach an 'error' handler before unref() to silently absorb this
- * instead of crashing the bridge process with an unhandled error event.
+ * Find the actual Electron binary on disk.
+ * Returns the path string if found and executable, or null if not available.
  */
-function launchOverlay({ authToken, apiBase = 'https://api.promethios.ai', threadId = '', dev = false } = {}) {
-  // Find electron binary — try local node_modules first, then global
-  let electronBin = null;
+function findElectronBinary() {
+  const isWin = process.platform === 'win32';
 
+  // Candidate paths for the real Electron binary (not just the npm package stub)
   const candidates = [
-    // Installed inside promethios-bridge's own node_modules (postinstall puts it here)
-    path.join(__dirname, '..', '..', 'node_modules', '.bin', 'electron'),
-    path.join(__dirname, '..', '..', 'node_modules', '.bin', 'electron.cmd'),
-    // Global electron fallback
-    'electron',
+    // 1. Installed inside promethios-bridge's own node_modules (full npm install, not npx)
+    path.join(__dirname, '..', '..', 'node_modules', 'electron', 'dist',
+      isWin ? 'electron.exe' : process.platform === 'darwin' ? 'Electron.app/Contents/MacOS/Electron' : 'electron'),
+    // 2. .bin shim (only works if the real binary was downloaded by postinstall)
+    path.join(__dirname, '..', '..', 'node_modules', '.bin', isWin ? 'electron.cmd' : 'electron'),
+    // 3. Global electron install
+    path.join(require('os').homedir(), '.npm', '_npx', '**', 'node_modules', 'electron', 'dist', isWin ? 'electron.exe' : 'electron'),
   ];
 
   for (const candidate of candidates) {
+    // Skip glob-style paths (we can't expand them here)
+    if (candidate.includes('**')) continue;
     try {
-      if (candidate === 'electron') {
-        // Try to resolve globally — throws if not installed
-        require.resolve('electron');
-        electronBin = candidate;
-        break;
-      }
       if (fs.existsSync(candidate)) {
-        electronBin = candidate;
-        break;
+        // Extra check: the .bin shim always exists even without the real binary.
+        // For the .bin shim, also verify the actual dist binary exists.
+        if (candidate.includes('.bin')) {
+          const distBin = path.join(
+            path.dirname(candidate), '..', 'electron', 'dist',
+            isWin ? 'electron.exe' : process.platform === 'darwin'
+              ? 'Electron.app/Contents/MacOS/Electron' : 'electron'
+          );
+          if (!fs.existsSync(distBin)) continue;
+        }
+        return candidate;
       }
-    } catch { /* not found */ }
+    } catch { /* ignore */ }
   }
 
+  return null;
+}
+
+/**
+ * Launch the Promethios overlay Electron window.
+ * Returns the child process if Electron was found and launched, or null otherwise.
+ */
+function launchOverlay({ authToken, apiBase = 'https://api.promethios.ai', threadId = '', dev = false } = {}) {
+  const electronBin = findElectronBinary();
+
   if (!electronBin) {
-    if (dev) console.log('[overlay] Electron not found — overlay will not launch.');
+    if (dev) console.log('[overlay] Electron binary not found on disk — skipping Electron overlay.');
     return null;
   }
 
@@ -70,16 +88,13 @@ function launchOverlay({ authToken, apiBase = 'https://api.promethios.ai', threa
   });
 
   // Attach error handler BEFORE unref() to prevent unhandled 'error' event crashes.
-  // When running via npx, optional deps like electron are not installed, so spawn
-  // may emit ENOENT. We catch it silently — the bridge works fine without the overlay.
   child.on('error', (err) => {
     if (dev) console.log(`[overlay] Spawn error (non-critical): ${err.message}`);
-    // No-op: overlay is optional, bridge continues running normally
   });
 
-  child.unref(); // Don't keep bridge CLI alive waiting for overlay
+  child.unref();
 
-  if (dev) console.log(`[overlay] Launched (pid ${child.pid})`);
+  if (dev) console.log(`[overlay] Launched Electron (pid ${child.pid})`);
 
   return child;
 }