promethios-bridge 1.8.0 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "promethios-bridge",
-  "version": "1.8.0",
+  "version": "2.0.0",
   "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": {
@@ -53,7 +53,9 @@
   },
   "optionalDependencies": {
     "playwright": "^1.42.0",
-    "electron": "^29.0.0"
+    "electron": "^29.0.0",
+    "screenshot-desktop": "^1.12.7",
+    "sharp": "^0.33.0"
   },
   "engines": {
     "node": ">=18.0.0"

package/src/bridge.js

@@ -21,6 +21,20 @@ const ora = require('ora');
 const fetch = require('node-fetch');
 const { executeLocalTool } = require('./executor');
 const { captureContext } = require('./contextCapture');
+const { startMcpServer } = require('./mcp-server');
+const { setPinnedRegion, setPinnedApps, registerBrowserPageAccessor } = require('./tools/desktop');
+
+// Wire the browser-dom tools to the shared Playwright context.
+// The context is created lazily in executor.js when browser_control is first used.
+// We expose a getter so browser-dom tools can access the live page.
+registerBrowserPageAccessor(async () => {
+  if (!global.__playwrightContext) {
+    throw new Error('Browser not open. Use the browser_control tool to navigate to a page first, then retry.');
+  }
+  const pages = global.__playwrightContext.pages();
+  return pages.length > 0 ? pages[pages.length - 1] : await global.__playwrightContext.newPage();
+});
+const { initAndroidTools } = require('./tools/android');
 
 // Optional: Electron overlay window (bundled in src/overlay — gracefully skipped if Electron not available)
 let launchOverlay = null;
@@ -196,6 +210,22 @@ async function startBridge({ setupToken, apiBase, port, dev }) {
   // Health check
   app.get('/health', (req, res) => res.json({ ok: true, version: require('../package.json').version }));
 
+  // ── /status: used by the Electron overlay to auto-connect without manual token entry ──
+  // Only accessible from localhost (127.0.0.1 or ::1) for security.
+  let bridgeUsername = null; // set after registerBridge resolves
+  app.get('/status', (req, res) => {
+    const ip = req.socket.remoteAddress || '';
+    const isLocal = ip === '127.0.0.1' || ip === '::1' || ip === '::ffff:127.0.0.1';
+    if (!isLocal) return res.status(403).json({ error: 'localhost only' });
+    res.json({
+      ok: true,
+      token: overlayAuthToken || null,
+      username: bridgeUsername || require('os').userInfo().username,
+      version: require('../package.json').version,
+      port,
+    });
+  });
+
   // Legacy direct tool-call endpoint (kept for backward compatibility with
   // older backend versions that call callbackUrl/tool-call directly)
   app.post('/tool-call', async (req, res) => {
@@ -303,8 +333,11 @@ async function startBridge({ setupToken, apiBase, port, dev }) {
           'Authorization': `Bearer ${token}`,
         },
         body: JSON.stringify({
-          message: req.body.message,
+          message:             req.body.message,
           conversationHistory: req.body.conversationHistory || [],
+          model:               req.body.model    || undefined,
+          provider:            req.body.provider || undefined,
+          context:             req.body.context  || undefined,
         }),
       });
       const data = await upstream.json();
@@ -761,6 +794,20 @@ async function startBridge({ setupToken, apiBase, port, dev }) {
   const callbackUrl = `http://127.0.0.1:${port}`;
   console.log(chalk.green(`  ✓ Local server listening on port ${port}`));
 
+  // ── MCP server (port 7824) — universal tool layer for all frameworks ────────
+  const mcpPort = port + 1; // 7824 when main bridge is on 7823
+
+  // Init Android tools with auth context
+  initAndroidTools({ authToken, apiBase });
+
+  try {
+    await startMcpServer({ port: mcpPort, authToken, log });
+    console.log(chalk.cyan(`  ✓ MCP server ready on port ${mcpPort} (Claude, OpenClaw, ChatGPT, Cursor)`));
+    console.log(chalk.cyan(`  ✓ Android bridge tools registered (SMS, contacts, calls, notifications)`));
+  } catch (err) {
+    log('MCP server failed to start (non-critical):', err.message);
+  }
+
   // ── Step 3: Register with Promethios API ─────────────────────────────────
   const regSpinner = ora('  Registering bridge with Promethios...').start();
   try {
@@ -788,6 +835,7 @@ async function startBridge({ setupToken, apiBase, port, dev }) {
   // ── Step 4c: Launch overlay ──────────────────────────────────────────────
   // Set the auth token so the /overlay route can embed it in the HTML.
   overlayAuthToken = authToken;
+  bridgeUsername = require('os').userInfo().username;
 
   // Try Electron first (available when installed globally or via postinstall).
   // Fall back to opening the browser-based overlay at http://localhost:<port>/overlay.

package/src/mcp-server.js

@@ -0,0 +1,348 @@
+/**
+ * mcp-server.js — Promethios MCP Server
+ *
+ * Implements the Model Context Protocol (MCP) so that any MCP-compatible
+ * AI framework can discover and call Promethios desktop tools.
+ *
+ * Supported frameworks:
+ *   - Claude Desktop (Anthropic's MCP client)
+ *   - Cursor / Windsurf
+ *   - Any framework implementing MCP spec
+ *
+ * Also exposes a REST API for non-MCP frameworks:
+ *   GET  /tools           → tool manifest (OpenAPI-compatible)
+ *   POST /tools/call      → execute a tool
+ *   GET  /tools/context   → get current context block (for context injection)
+ *
+ * Authentication: Bearer token (same Promethios token as the main bridge)
+ *
+ * Runs on port 7824 alongside the main bridge on 7823.
+ */
+
+'use strict';
+
+const express = require('express');
+const { TOOL_MANIFEST, executeDesktopTool, buildContextBlock } = require('./tools/desktop');
+const { ANDROID_TOOL_SCHEMAS, executeAndroidTool, isAndroidTool } = require('./tools/android');
+
+// Also include the core executor tools in the manifest for external frameworks
+const { executeLocalTool } = require('./executor');
+
+// ── Extended manifest — adds executor tools for external frameworks ───────────
+const EXECUTOR_TOOL_MANIFEST = [
+  {
+    name: 'read_file',
+    description: 'Read the contents of a file on the user\'s desktop computer.',
+    inputSchema: {
+      type: 'object',
+      required: ['path'],
+      properties: {
+        path: { type: 'string', description: 'Absolute or ~ relative path to the file' },
+        encoding: { type: 'string', description: 'File encoding (default: utf8)', default: 'utf8' },
+      },
+    },
+    handler: async (args) => executeLocalTool({ toolName: 'read_file', args }),
+  },
+  {
+    name: 'write_file',
+    description: 'Write or create a file on the user\'s desktop computer.',
+    inputSchema: {
+      type: 'object',
+      required: ['path', 'content'],
+      properties: {
+        path:    { type: 'string', description: 'Absolute or ~ relative path to the file' },
+        content: { type: 'string', description: 'Content to write' },
+      },
+    },
+    handler: async (args) => executeLocalTool({ toolName: 'write_file', args }),
+  },
+  {
+    name: 'list_directory',
+    description: 'List files and folders in a directory on the user\'s desktop computer.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Directory path (default: home directory)', default: '~' },
+      },
+    },
+    handler: async (args) => executeLocalTool({ toolName: 'list_directory', args }),
+  },
+  {
+    name: 'run_command',
+    description: 'Execute a shell command on the user\'s desktop computer and return the output.',
+    inputSchema: {
+      type: 'object',
+      required: ['command'],
+      properties: {
+        command: { type: 'string', description: 'Shell command to execute' },
+        cwd:     { type: 'string', description: 'Working directory (optional)' },
+        timeout: { type: 'number', description: 'Timeout in milliseconds (default: 30000)' },
+      },
+    },
+    handler: async (args) => executeLocalTool({ toolName: 'run_command', args }),
+  },
+  {
+    name: 'open_browser',
+    description: 'Open a URL in the user\'s default browser.',
+    inputSchema: {
+      type: 'object',
+      required: ['url'],
+      properties: {
+        url: { type: 'string', description: 'URL to open' },
+      },
+    },
+    handler: async (args) => executeLocalTool({ toolName: 'open_browser', args }),
+  },
+];
+
+// Android tools — add handlers to the schemas
+const ANDROID_TOOL_MANIFEST = ANDROID_TOOL_SCHEMAS.map(schema => ({
+  ...schema,
+  handler: async (args) => executeAndroidTool(schema.name, args),
+}));
+
+// Full combined manifest — desktop tools + executor tools + android tools
+const FULL_MANIFEST = [...TOOL_MANIFEST, ...EXECUTOR_TOOL_MANIFEST, ...ANDROID_TOOL_MANIFEST];
+
+// ── MCP Server ────────────────────────────────────────────────────────────────
+
+function createMcpServer(authToken) {
+  const app = express();
+  app.use(express.json({ limit: '10mb' }));
+
+  // CORS — allow all origins so web-based AI tools can connect
+  app.use((req, res, next) => {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+    if (req.method === 'OPTIONS') return res.sendStatus(200);
+    next();
+  });
+
+  // ── Auth middleware ───────────────────────────────────────────────────────
+  function requireAuth(req, res, next) {
+    if (!authToken) return next(); // No token configured — open access (dev mode)
+    const header = req.headers['authorization'] || '';
+    const token  = header.replace(/^Bearer\s+/i, '').trim();
+    if (token !== authToken) {
+      return res.status(401).json({ error: 'Invalid or missing Promethios token' });
+    }
+    next();
+  }
+
+  // ── Health check ─────────────────────────────────────────────────────────
+  app.get('/health', (req, res) => {
+    res.json({
+      status:   'ok',
+      service:  'promethios-mcp',
+      version:  require('../package.json').version,
+      tools:    FULL_MANIFEST.length,
+      platform: process.platform,
+    });
+  });
+
+  // ── Tool discovery ────────────────────────────────────────────────────────
+  // GET /tools — returns the full tool manifest
+  // Compatible with MCP tool discovery and OpenAPI Custom Actions
+  app.get('/tools', requireAuth, (req, res) => {
+    res.json({
+      tools: FULL_MANIFEST.map(t => ({
+        name:        t.name,
+        description: t.description,
+        inputSchema: t.inputSchema,
+      })),
+    });
+  });
+
+  // ── MCP protocol endpoint ─────────────────────────────────────────────────
+  // POST /mcp — handles MCP JSON-RPC messages
+  // Claude Desktop and other MCP clients send requests here
+  app.post('/mcp', requireAuth, async (req, res) => {
+    const { method, params, id } = req.body;
+
+    try {
+      if (method === 'tools/list') {
+        return res.json({
+          jsonrpc: '2.0',
+          id,
+          result: {
+            tools: FULL_MANIFEST.map(t => ({
+              name:        t.name,
+              description: t.description,
+              inputSchema: t.inputSchema,
+            })),
+          },
+        });
+      }
+
+      if (method === 'tools/call') {
+        const { name, arguments: args } = params;
+        const tool = FULL_MANIFEST.find(t => t.name === name);
+
+        if (!tool) {
+          return res.json({
+            jsonrpc: '2.0',
+            id,
+            error: { code: -32601, message: `Tool not found: ${name}` },
+          });
+        }
+
+        const result = await tool.handler(args || {});
+        return res.json({
+          jsonrpc: '2.0',
+          id,
+          result: {
+            content: [
+              {
+                type: result.screenshot || result.fresh_screenshot ? 'image' : 'text',
+                text: result.screenshot || result.fresh_screenshot
+                  ? undefined
+                  : JSON.stringify(result, null, 2),
+                data:     result.screenshot || result.fresh_screenshot || undefined,
+                mimeType: result.screenshot || result.fresh_screenshot ? 'image/png' : undefined,
+              },
+            ],
+          },
+        });
+      }
+
+      // Unknown method
+      return res.json({
+        jsonrpc: '2.0',
+        id,
+        error: { code: -32601, message: `Unknown method: ${method}` },
+      });
+
+    } catch (err) {
+      return res.json({
+        jsonrpc: '2.0',
+        id,
+        error: { code: -32603, message: err.message },
+      });
+    }
+  });
+
+  // ── REST tool execution ───────────────────────────────────────────────────
+  // POST /tools/call — execute any tool by name (REST alternative to MCP)
+  // Used by ChatGPT Custom Actions, web apps, and non-MCP frameworks
+  app.post('/tools/call', requireAuth, async (req, res) => {
+    const { tool, args } = req.body;
+    if (!tool) return res.status(400).json({ error: 'tool name is required' });
+
+    const toolDef = FULL_MANIFEST.find(t => t.name === tool);
+    if (!toolDef) {
+      return res.status(404).json({
+        error: `Tool not found: ${tool}`,
+        available: FULL_MANIFEST.map(t => t.name),
+      });
+    }
+
+    try {
+      const result = await toolDef.handler(args || {});
+      res.json({ ok: true, tool, result });
+    } catch (err) {
+      res.status(500).json({ ok: false, tool, error: err.message });
+    }
+  });
+
+  // ── Context endpoint ──────────────────────────────────────────────────────
+  // GET /tools/context — returns the current context block
+  // Used by the Manus floater for context injection
+  app.get('/tools/context', requireAuth, async (req, res) => {
+    try {
+      const includeScreenshot = req.query.screenshot === 'true';
+      const block = await buildContextBlock({ include_screenshot: includeScreenshot });
+      res.json({ ok: true, ...block });
+    } catch (err) {
+      res.status(500).json({ ok: false, error: err.message });
+    }
+  });
+
+  // ── OpenAPI spec ──────────────────────────────────────────────────────────
+  // GET /openapi.json — OpenAPI 3.0 spec for ChatGPT Custom Actions
+  app.get('/openapi.json', (req, res) => {
+    const host = req.headers.host || 'bridge.promethios.ai';
+    res.json({
+      openapi: '3.0.0',
+      info: {
+        title:       'Promethios Desktop Bridge',
+        description: 'Give any AI access to the user\'s desktop context, files, and applications.',
+        version:     require('../package.json').version,
+      },
+      servers: [{ url: `https://${host}` }],
+      paths: {
+        '/tools': {
+          get: {
+            operationId: 'listTools',
+            summary:     'List all available desktop tools',
+            responses:   { '200': { description: 'Tool manifest' } },
+          },
+        },
+        '/tools/call': {
+          post: {
+            operationId: 'callTool',
+            summary:     'Execute a desktop tool',
+            requestBody: {
+              required: true,
+              content: {
+                'application/json': {
+                  schema: {
+                    type: 'object',
+                    required: ['tool'],
+                    properties: {
+                      tool: { type: 'string', description: 'Tool name' },
+                      args: { type: 'object', description: 'Tool arguments' },
+                    },
+                  },
+                },
+              },
+            },
+            responses: { '200': { description: 'Tool result' } },
+          },
+        },
+        '/tools/context': {
+          get: {
+            operationId: 'getContext',
+            summary:     'Get current desktop context (active app, window, clipboard)',
+            parameters: [
+              {
+                name: 'screenshot', in: 'query', schema: { type: 'boolean' },
+                description: 'Include screenshot of pinned region',
+              },
+            ],
+            responses: { '200': { description: 'Context block' } },
+          },
+        },
+      },
+      components: {
+        securitySchemes: {
+          BearerAuth: { type: 'http', scheme: 'bearer' },
+        },
+      },
+      security: [{ BearerAuth: [] }],
+    });
+  });
+
+  return app;
+}
+
+/**
+ * Start the MCP server on the given port.
+ * Called from bridge.js during startup.
+ */
+function startMcpServer({ port = 7824, authToken, log = console.log } = {}) {
+  const app = createMcpServer(authToken);
+
+  return new Promise((resolve, reject) => {
+    const server = app.listen(port, '127.0.0.1', () => {
+      log(`[mcp] Promethios MCP server listening on port ${port}`);
+      log(`[mcp] Tool discovery: http://127.0.0.1:${port}/tools`);
+      log(`[mcp] MCP endpoint:   http://127.0.0.1:${port}/mcp`);
+      log(`[mcp] OpenAPI spec:   http://127.0.0.1:${port}/openapi.json`);
+      resolve(server);
+    });
+    server.on('error', reject);
+  });
+}
+
+module.exports = { startMcpServer, createMcpServer, FULL_MANIFEST, ANDROID_TOOL_MANIFEST };

package/src/overlay/launcher.js

@@ -1,101 +1,133 @@
 /**
- * launcher.js
+ * launcher.js — Promethios Bridge
  *
- * Called by the bridge CLI after successful authentication.
- * 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).
+ * Called by bridge.js after successful authentication.
+ * Finds the pre-built Promethios Desktop binary (downloaded by postinstall.js
+ * into ~/.promethios/desktop/) and spawns it with auth credentials via env vars.
  *
- * 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.
+ * Binary search order:
+ *   1. PROMETHIOS_DESKTOP_BIN environment variable (dev override)
+ *   2. ~/.promethios/desktop/  — where postinstall.js places the binary
+ *   3. Electron source-mode fallback (dev only, requires electron in node_modules)
+ *
+ * The pre-built binary reads its config from env vars:
+ *   PROMETHIOS_TOKEN, PROMETHIOS_API_BASE, PROMETHIOS_THREAD_ID, PROMETHIOS_DEV
  */
 
 'use strict';
 
 const { spawn } = require('child_process');
-const path = require('path');
-const fs = require('fs');
+const path      = require('path');
+const fs        = require('fs');
+const os        = require('os');
 
-/**
- * Find the actual Electron binary on disk.
- * Returns the path string if found and executable, or null if not available.
- */
+const INSTALL_DIR = path.join(os.homedir(), '.promethios', 'desktop');
+
+// ── Find the pre-built binary ─────────────────────────────────────────────────
+function findDesktopBinary() {
+  // 1. Explicit env override (useful for local dev / CI)
+  if (process.env.PROMETHIOS_DESKTOP_BIN && fs.existsSync(process.env.PROMETHIOS_DESKTOP_BIN)) {
+    return process.env.PROMETHIOS_DESKTOP_BIN;
+  }
+
+  // 2. Scan ~/.promethios/desktop/ for a matching binary
+  if (fs.existsSync(INSTALL_DIR)) {
+    const files = fs.readdirSync(INSTALL_DIR);
+    const exts  = process.platform === 'win32'  ? ['.exe']
+                : process.platform === 'darwin' ? ['.dmg', '.app']
+                : ['.AppImage'];
+
+    for (const ext of exts) {
+      const match = files.find(f => f.endsWith(ext));
+      if (match) {
+        const full = path.join(INSTALL_DIR, match);
+        // Ensure executable bit is set on Unix
+        try {
+          if (process.platform !== 'win32') fs.chmodSync(full, 0o755);
+        } catch {}
+        return full;
+      }
+    }
+  }
+
+  return null;
+}
+
+// ── Find Electron binary for source-mode fallback (dev / CI) ─────────────────
 function findElectronBinary() {
   const isWin = process.platform === 'win32';
-
-  // Candidate paths for the real Electron binary (not just the npm package stub)
+  const isMac = process.platform === 'darwin';
   const candidates = [
-    // 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)
+      isWin ? 'electron.exe' : isMac ? 'Electron.app/Contents/MacOS/Electron' : 'electron'),
     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 (fs.existsSync(candidate)) {
-        // 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;
+  for (const c of candidates) {
+    if (!c.includes('**') && fs.existsSync(c)) {
+      if (c.includes('.bin')) {
+        const dist = path.join(path.dirname(c), '..', 'electron', 'dist',
+          isWin ? 'electron.exe' : isMac ? 'Electron.app/Contents/MacOS/Electron' : 'electron');
+        if (!fs.existsSync(dist)) continue;
       }
-    } catch { /* ignore */ }
+      return c;
+    }
   }
-
   return null;
 }
 
-/**
- * Launch the Promethios overlay Electron window.
- * Returns the child process if Electron was found and launched, or null otherwise.
- */
+// ── Launch ────────────────────────────────────────────────────────────────────
 function launchOverlay({ authToken, apiBase = 'https://api.promethios.ai', threadId = '', dev = false } = {}) {
-  const electronBin = findElectronBinary();
+  const desktopBin = findDesktopBinary();
+
+  if (desktopBin) {
+    // ── Mode A: pre-built binary ──────────────────────────────────────────────
+    // Pass credentials via env vars — AppImage/exe wrappers don't always
+    // forward CLI args to the inner Electron process reliably.
+    const env = {
+      ...process.env,
+      PROMETHIOS_TOKEN:           authToken || '',
+      PROMETHIOS_API_BASE:        apiBase   || '',
+      PROMETHIOS_THREAD_ID:       threadId  || '',
+      PROMETHIOS_DEV:             dev ? '1' : '',
+      ELECTRON_NO_ATTACH_CONSOLE: '1',
+    };
+
+    if (dev) console.log(`[overlay] Launching pre-built binary: ${desktopBin}`);
+
+    const child = spawn(desktopBin, [], { detached: true, stdio: 'ignore', env });
+    child.on('error', (err) => {
+      if (dev) console.log(`[overlay] Binary spawn error (non-critical): ${err.message}`);
+    });
+    child.unref();
+    return child;
+  }
 
+  // ── Mode B: source mode via Electron (dev / CI fallback) ─────────────────
+  const electronBin = findElectronBinary();
   if (!electronBin) {
-    if (dev) console.log('[overlay] Electron binary not found on disk — skipping Electron overlay.');
+    if (dev) console.log('[overlay] No pre-built binary and no Electron found — skipping overlay.');
     return null;
   }
 
   const mainScript = path.join(__dirname, 'main.js');
-
   const args = [mainScript];
-  if (authToken) { args.push('--token', authToken); }
-  if (apiBase)   { args.push('--api', apiBase); }
-  if (threadId)  { args.push('--thread', threadId); }
-  if (dev)       { args.push('--dev'); }
+  if (authToken) args.push('--token', authToken);
+  if (apiBase)   args.push('--api',   apiBase);
+  if (threadId)  args.push('--thread', threadId);
+  if (dev)       args.push('--dev');
+
+  if (dev) console.log(`[overlay] Launching Electron source mode: ${electronBin}`);
 
   const child = spawn(electronBin, args, {
     detached: true,
     stdio: 'ignore',
     env: { ...process.env, ELECTRON_NO_ATTACH_CONSOLE: '1' },
   });
-
-  // Attach error handler BEFORE unref() to prevent unhandled 'error' event crashes.
   child.on('error', (err) => {
     if (dev) console.log(`[overlay] Spawn error (non-critical): ${err.message}`);
   });
-
   child.unref();
-
-  if (dev) console.log(`[overlay] Launched Electron (pid ${child.pid})`);
-
+  if (dev) console.log(`[overlay] Launched Electron source mode (pid ${child.pid})`);
   return child;
 }