sliccy 4.28.2 → 4.29.0

package/dist/node-server/electron-controller.js

@@ -6,9 +6,67 @@ import * as https from 'https';
 import { promisify } from 'util';
 import { WebSocket } from 'ws';
 import { inflateSync } from 'zlib';
-import { buildElectronAppLaunchSpec, buildElectronOverlayAppUrl, buildElectronOverlayBootstrapScript, buildElectronOverlayEntryUrl, getElectronOverlayEntryDistPath, getElectronServeOrigin, selectBestOverlayTargets, } from './electron-runtime.js';
+import { BRIDGE_TOKEN_QUERY_PARAM, BRIDGE_WS_QUERY_PARAM } from './bridge-security.js';
+import { buildElectronAppLaunchSpec, buildElectronOverlayBootstrapScript, buildElectronOverlayEntryUrl, ELECTRON_OVERLAY_APP_PATH, getElectronOverlayEntryDistPath, getElectronServeOrigin, selectBestOverlayTargets, } from './electron-runtime.js';
 const execFile = promisify(nodeExecFile);
 const ELECTRON_OVERLAY_SYNC_INTERVAL_MS = 1500;
+/**
+ * Query param name used to mark the role of an overlay tab on the hosted
+ * launcher URL. The pinned leader carries `role=leader`; auto-follow
+ * followers carry `role=follower`. The hosted webapp interprets these to
+ * decide which tab anchors the CDP bridge vs. follows the leader.
+ */
+export const BRIDGE_ROLE_QUERY_PARAM = 'role';
+export const BRIDGE_ROLE_LEADER = 'leader';
+export const BRIDGE_ROLE_FOLLOWER = 'follower';
+/**
+ * Build the thin-bridge config for the Electron overlay injector. The
+ * hosted-leader origin defaults to production `https://www.sliccy.ai`
+ * (overridable via `SLICC_HOSTED_LEADER_ORIGIN` / `WORKER_BASE_URL`), so
+ * the only genuinely unresolvable case is a missing per-process bridge
+ * token — in which case this returns `null` and the caller fails fast
+ * rather than falling back to a (now-retired) bundled overlay.
+ */
+export function resolveOverlayThinBridge(env, bridgeToken, servePort) {
+    if (!bridgeToken)
+        return null;
+    return {
+        hostedLeaderOrigin: resolveHostedLeaderOrigin(env),
+        bridgeWsUrl: `ws://localhost:${servePort}/cdp`,
+        bridgeToken,
+    };
+}
+/**
+ * Build the hosted launcher URL for an overlay injection. Mirrors the
+ * standalone Path A launch-URL shape (`bridge`, `bridgeToken` query
+ * params) with one Electron-specific addition: a `role` param that pins
+ * the first injected tab as the leader and marks every subsequent tab as
+ * an auto-follow follower.
+ */
+export function buildThinOverlayAppUrl(opts) {
+    const url = new URL(ELECTRON_OVERLAY_APP_PATH, opts.hostedLeaderOrigin);
+    url.searchParams.set(BRIDGE_WS_QUERY_PARAM, opts.bridgeWsUrl);
+    url.searchParams.set(BRIDGE_TOKEN_QUERY_PARAM, opts.bridgeToken);
+    url.searchParams.set(BRIDGE_ROLE_QUERY_PARAM, opts.role);
+    if (opts.activeTab && opts.activeTab !== 'chat') {
+        url.searchParams.set('tab', opts.activeTab);
+    }
+    return url.toString();
+}
+/**
+ * Resolve the hosted leader origin Chrome / Electron should open in thin
+ * mode. Prefers explicit overrides (`SLICC_HOSTED_LEADER_ORIGIN`, then
+ * `WORKER_BASE_URL`) so dev can point at staging; defaults to production
+ * `https://www.sliccy.ai`. Trailing slashes are stripped so callers can
+ * safely concatenate paths.
+ */
+export function resolveHostedLeaderOrigin(env = process.env) {
+    const explicit = env['SLICC_HOSTED_LEADER_ORIGIN'] ?? env['WORKER_BASE_URL'];
+    if (explicit) {
+        return explicit.replace(/\/+$/, '');
+    }
+    return 'https://www.sliccy.ai';
+}
 function commandLineExecutableMatchesPattern(commandLine, pattern) {
     // Extract the executable (first whitespace-separated token) from the command line.
     // Only match when the target app path is the executable itself, not an argument —
@@ -427,28 +485,72 @@ function buildFulfillResponseHeaders(rawHeaders, contentLength) {
     }
     return { responseHeaders, strippedCSP };
 }
+/**
+ * JS probe that reports whether the overlay iframe actually loaded. Walks the
+ * `<slicc-launcher>` host's (open) shadow root to find the iframe
+ * depth-agnostically, then classifies by cross-origin reachability: the
+ * thin-bridge overlay is ALWAYS a different origin (hosted webapp) than the
+ * app document, so a committed cross-origin navigation makes
+ * `iframe.contentWindow.location.href` THROW — that throw is the ONLY success
+ * signal. Any READABLE href (`about:blank`, `''`, or a CSP-blocked swap to
+ * `chrome-error://chromewebdata/`) means the cross-origin nav did NOT commit,
+ * so the overlay did not load and the setBypassCSP escalation must fire.
+ * Returns `'ok'` only from the catch; otherwise `'no-host' / 'no-iframe' /
+ * 'no-src' / 'blank:<href>'`.
+ */
+export const OVERLAY_LOADED_PROBE_EXPRESSION = `(function() {
+          var host = document.getElementById('slicc-electron-overlay-root');
+          if (!host || !host.shadowRoot) return 'no-host';
+          var iframe = host.shadowRoot.querySelector('iframe');
+          if (!iframe) return 'no-iframe';
+          if (!iframe.src) return 'no-src';
+          try {
+            // Thin-bridge overlay is ALWAYS cross-origin (hosted webapp) vs the app
+            // document. A committed cross-origin navigation makes this access THROW.
+            // Any READABLE href means the cross-origin nav did NOT commit — still
+            // about:blank, or swapped to chrome-error://chromewebdata/ by a CSP block —
+            // so the overlay did NOT load and the setBypassCSP escalation must fire.
+            var href = iframe.contentWindow && iframe.contentWindow.location ? iframe.contentWindow.location.href : '';
+            return 'blank:' + href;
+          } catch (e) {
+            return 'ok';
+          }
+        })()`;
 export class ElectronOverlayInjector {
     cdpPort;
     servePort;
-    bootstrapScript;
+    /** Thin-mode bootstrap pair — the only overlay path. */
+    thinBootstraps;
     probeDelayMs;
     connections = new Map();
     cspBypassedTargets = new Set();
+    /**
+     * URL of the target currently elected as the pinned leader. Cleared by
+     * `syncTargets` when that target disappears so the next injection
+     * re-elects a fresh leader.
+     */
+    leaderTargetUrl = null;
     syncTimer = null;
     syncing = false;
-    constructor(cdpPort, servePort, bootstrapScript, probeDelayMs = 1500) {
+    constructor(cdpPort, servePort, thinBootstraps, probeDelayMs = 1500) {
         this.cdpPort = cdpPort;
         this.servePort = servePort;
-        this.bootstrapScript = bootstrapScript;
+        this.thinBootstraps = thinBootstraps;
         this.probeDelayMs = probeDelayMs;
     }
     static async create(options) {
         const bundleSource = await loadElectronOverlayBundleSource(options);
-        const bootstrapScript = buildElectronOverlayBootstrapScript({
-            bundleSource,
-            appUrl: buildElectronOverlayAppUrl(getElectronServeOrigin(options.servePort)),
-        });
-        return new ElectronOverlayInjector(options.cdpPort, options.servePort, bootstrapScript);
+        const thinBootstraps = {
+            leader: buildElectronOverlayBootstrapScript({
+                bundleSource,
+                appUrl: buildThinOverlayAppUrl({ ...options.thinBridge, role: BRIDGE_ROLE_LEADER }),
+            }),
+            follower: buildElectronOverlayBootstrapScript({
+                bundleSource,
+                appUrl: buildThinOverlayAppUrl({ ...options.thinBridge, role: BRIDGE_ROLE_FOLLOWER }),
+            }),
+        };
+        return new ElectronOverlayInjector(options.cdpPort, options.servePort, thinBootstraps);
     }
     /**
      * Test-only factory: skips bundle loading and lets tests drive the per-target
@@ -456,7 +558,15 @@ export class ElectronOverlayInjector {
      * `_testing_*` hooks on `ElectronOverlayInjector`.
      */
     static _createForTesting(options) {
-        return new ElectronOverlayInjector(options.cdpPort ?? 9223, options.servePort, options.bootstrapScript ?? '/* test-noop */', options.probeDelayMs ?? 1500);
+        return new ElectronOverlayInjector(options.cdpPort ?? 9223, options.servePort, options.thinBootstraps ?? { leader: '/* test-leader */', follower: '/* test-follower */' }, options.probeDelayMs ?? 1500);
+    }
+    /** Test-only: snapshot the elected leader target URL (null when no leader). */
+    _testingLeaderTargetUrl() {
+        return this.leaderTargetUrl;
+    }
+    /** Test-only: seed the elected leader (drives the follower-election path). */
+    _testingSeedLeaderTargetUrl(url) {
+        this.leaderTargetUrl = url;
     }
     /** Test-only: drive the per-target connect flow without going through `start`. */
     _testingConnectToTarget(target) {
@@ -470,6 +580,10 @@ export class ElectronOverlayInjector {
     _testingBypassedTargets() {
         return new Set(this.cspBypassedTargets);
     }
+    /** Test-only: drive a single `syncTargets` pass without `start()`'s interval. */
+    async _testingSyncTargets() {
+        await this.syncTargets();
+    }
     /** Test-only: close any sockets opened by `_testingConnectToTarget`. */
     _testingCloseConnections() {
         for (const connection of this.connections.values()) {
@@ -522,6 +636,16 @@ export class ElectronOverlayInjector {
                 }
             }
             const liveConnectionIds = new Set(injectableTargets.map((target) => target.webSocketDebuggerUrl));
+            // Thin mode: drop the elected leader if its target is no longer
+            // present so the next injection re-elects. Without this a stale
+            // leaderTargetUrl would block every future tab from becoming the
+            // pinned leader after the original leader closed.
+            if (this.leaderTargetUrl !== null) {
+                const liveTargetUrls = new Set(injectableTargets.map((target) => target.url));
+                if (!liveTargetUrls.has(this.leaderTargetUrl)) {
+                    this.leaderTargetUrl = null;
+                }
+            }
             for (const [targetId, connection] of this.connections.entries()) {
                 if (liveConnectionIds.has(targetId))
                     continue;
@@ -549,22 +673,20 @@ export class ElectronOverlayInjector {
         }
     }
     /**
-     * Check if the overlay iframe loaded successfully by evaluating a probe script.
-     * Returns true if the iframe element exists and has started loading content.
+     * Check if the overlay iframe loaded successfully by evaluating a probe
+     * script. Walks the `<slicc-launcher>` host's (open) shadow root to find the
+     * iframe depth-agnostically and classifies by cross-origin reachability: the
+     * thin-bridge overlay is ALWAYS a different origin than the app document, so
+     * only a THROW on `iframe.contentWindow.location.href` (a committed
+     * cross-origin navigation) counts as loaded. Any readable href — including a
+     * CSP-blocked swap to `chrome-error://chromewebdata/` — means the nav did not
+     * commit, so the Fetch-proxy escalation must still fire.
+     * See {@link OVERLAY_LOADED_PROBE_EXPRESSION}.
      */
     async probeOverlayIframeLoaded(ws, send) {
         return new Promise((resolve) => {
             const probeId = send('Runtime.evaluate', {
-                expression: `(function() {
-          var host = document.getElementById('slicc-electron-overlay-root');
-          if (!host || !host.shadowRoot) return 'no-host';
-          var sidebar = host.shadowRoot.querySelector('slicc-electron-sidebar');
-          if (!sidebar || !sidebar.shadowRoot) return 'no-sidebar';
-          var iframe = sidebar.shadowRoot.querySelector('iframe');
-          if (!iframe) return 'no-iframe';
-          if (!iframe.src) return 'no-src';
-          return 'ok';
-        })()`,
+                expression: OVERLAY_LOADED_PROBE_EXPRESSION,
                 awaitPromise: false,
                 returnByValue: true,
             });
@@ -592,13 +714,30 @@ export class ElectronOverlayInjector {
             ws.on('message', onMessage);
         });
     }
+    /**
+     * Pick the bootstrap script for `target`, electing the leader on first
+     * use when thin-mode is active. Same target URL ↔ same role across
+     * reconnects so a page that bounces its CDP session stays the leader
+     * (no re-election on transient drops, only on `syncTargets` cleanup).
+     */
+    resolveBootstrapForTarget(target) {
+        if (this.leaderTargetUrl === target.url) {
+            return this.thinBootstraps.leader;
+        }
+        if (this.leaderTargetUrl === null) {
+            this.leaderTargetUrl = target.url;
+            return this.thinBootstraps.leader;
+        }
+        return this.thinBootstraps.follower;
+    }
     /**
      * Build a script that sets the SLICC theme preference in localStorage to
-     * match the target app's detected theme, then runs the bootstrap.
+     * match the target app's detected theme, then runs the bootstrap. The
+     * bootstrap is target-specific (leader vs. follower).
      */
-    buildThemedBootstrap(theme) {
+    buildThemedBootstrap(theme, target) {
         const themeScript = `try{localStorage.setItem('slicc-theme',${JSON.stringify(theme)})}catch(e){}`;
-        return `${themeScript}\n${this.bootstrapScript}`;
+        return `${themeScript}\n${this.resolveBootstrapForTarget(target)}`;
     }
     /**
      * Handle the initial CDP `ws.on('open', ...)` event for a target: enable
@@ -625,7 +764,7 @@ export class ElectronOverlayInjector {
                 if (ws.readyState !== WebSocket.OPEN)
                     return;
                 send('Runtime.evaluate', {
-                    expression: this.buildThemedBootstrap(theme),
+                    expression: this.buildThemedBootstrap(theme, target),
                     awaitPromise: false,
                 });
             });
@@ -642,7 +781,7 @@ export class ElectronOverlayInjector {
                 return;
             console.log(`[electron-float] Injecting overlay (first attempt, theme=${theme})...`);
             send('Runtime.evaluate', {
-                expression: this.buildThemedBootstrap(theme),
+                expression: this.buildThemedBootstrap(theme, target),
                 awaitPromise: false,
             });
             // After a short delay, probe whether the overlay iframe loaded.
@@ -690,7 +829,7 @@ export class ElectronOverlayInjector {
             if (ws.readyState !== WebSocket.OPEN)
                 return;
             send('Runtime.evaluate', {
-                expression: this.buildThemedBootstrap(theme),
+                expression: this.buildThemedBootstrap(theme, target),
                 awaitPromise: false,
             });
         });

package/dist/node-server/electron-main.js

@@ -3,13 +3,38 @@ import { app, BrowserWindow, nativeTheme, session } from 'electron';
 import { readFile } from 'fs/promises';
 import { resolve } from 'path';
 import { fileURLToPath } from 'url';
-import { buildElectronOverlayAppUrl, buildElectronOverlayEntryUrl, buildElectronOverlayInjectionCall, buildElectronServerSpawnConfig, getElectronOverlayEntryDistPath, getElectronServeOrigin, parseElectronFloatFlags, } from './electron-runtime.js';
+import { mintBridgeToken } from './bridge-security.js';
+import { BRIDGE_ROLE_LEADER, buildThinOverlayAppUrl, resolveHostedLeaderOrigin, } from './electron-controller.js';
+import { buildElectronOverlayEntryUrl, buildElectronOverlayInjectionCall, buildElectronServerSpawnConfig, getElectronOverlayEntryDistPath, getElectronServeOrigin, parseElectronFloatFlags, } from './electron-runtime.js';
 const Dirname = fileURLToPath(new URL('.', import.meta.url));
 const PROJECT_ROOT = resolve(Dirname, '..', '..');
 const FLAGS = parseElectronFloatFlags(process.argv.slice(2));
 const SERVE_ORIGIN = getElectronServeOrigin(FLAGS.servePort);
-const OVERLAY_APP_URL = buildElectronOverlayAppUrl(SERVE_ORIGIN);
 const ELECTRON_PARTITION = 'persist:slicc-electron-float';
+/**
+ * Per-process thin-bridge token. The Electron float opens its overlay on
+ * the sliccy.ai-hosted launcher (Path B) and the launcher dials back to
+ * the spawned CLI server's `/cdp` WebSocket using this token via the
+ * `Sec-WebSocket-Protocol` header. The token is also forwarded to the
+ * child server as `SLICC_BRIDGE_TOKEN` so a future index.ts gate
+ * activation can enforce it without another mint.
+ */
+const BRIDGE_TOKEN = mintBridgeToken();
+const HOSTED_LEADER_ORIGIN = resolveHostedLeaderOrigin(process.env);
+const BRIDGE_WS_URL = `ws://localhost:${FLAGS.servePort}/cdp`;
+/**
+ * Hosted launcher URL injected into every Electron float `BrowserWindow`.
+ * The float owns a single window so its overlay is always the pinned
+ * leader; external Electron apps (Slack/Teams etc.) attached via
+ * `--electron <app>` go through `ElectronOverlayInjector` which handles
+ * its own leader/follower election.
+ */
+const OVERLAY_APP_URL = buildThinOverlayAppUrl({
+    hostedLeaderOrigin: HOSTED_LEADER_ORIGIN,
+    bridgeWsUrl: BRIDGE_WS_URL,
+    bridgeToken: BRIDGE_TOKEN,
+    role: BRIDGE_ROLE_LEADER,
+});
 app.commandLine.appendSwitch('remote-debugging-port', String(FLAGS.cdpPort));
 let cliServerProcess = null;
 let quitting = false;
@@ -116,6 +141,12 @@ function startCliServer() {
         env: {
             ...process.env,
             PORT: String(FLAGS.servePort),
+            // Forward the per-process bridge token to the child server. The
+            // current --serve-only mode doesn't gate /cdp on it (THIN_BRIDGE_MODE
+            // is false), but the env var is in place so a follow-up index.ts
+            // change can flip the gate on without retouching this file.
+            SLICC_BRIDGE_TOKEN: BRIDGE_TOKEN,
+            SLICC_HOSTED_LEADER_ORIGIN: HOSTED_LEADER_ORIGIN,
         },
         stdio: ['ignore', 'pipe', 'pipe'],
     });
@@ -161,6 +192,10 @@ async function main() {
     configureElectronSession();
     cliServerProcess = startCliServer();
     await waitForServerReady(SERVE_ORIGIN);
+    // Print the overlay URL with the bridge token redacted — it's a
+    // session capability and must never appear in logs / process listings.
+    const sanitizedOverlayUrl = OVERLAY_APP_URL.replace(/([?&])bridgeToken=[^&]+/, '$1bridgeToken=<redacted>');
+    console.log(`[electron-float] Hosted overlay URL: ${sanitizedOverlayUrl}`);
     await createFloatWindow(FLAGS.targetUrl);
     app.on('activate', () => {
         if (BrowserWindow.getAllWindows().length === 0) {

package/dist/node-server/electron-runtime.d.ts

@@ -25,7 +25,6 @@ export declare const DEFAULT_ELECTRON_SERVE_PORT = 5710;
 export declare const DEFAULT_ELECTRON_SERVE_HOST = "localhost";
 export declare const DEFAULT_ELECTRON_CDP_PORT = 9223;
 export declare const DEFAULT_ELECTRON_TARGET_URL = "about:blank";
-export declare const DEFAULT_ELECTRON_OVERLAY_TAB = "chat";
 export declare const ELECTRON_OVERLAY_APP_PATH = "/electron";
 export declare const PORT_HASH_RANGE = 40;
 /**
@@ -61,7 +60,6 @@ export declare function buildElectronServerSpawnConfig(projectRoot: string, opti
     nodePath?: string;
 }): ElectronServerSpawnConfig;
 export declare function getElectronServeOrigin(servePort: number): string;
-export declare function buildElectronOverlayAppUrl(serveOrigin: string, activeTab?: string): string;
 export declare function buildElectronOverlayEntryUrl(serveOrigin: string): string;
 export declare function getElectronOverlayEntryDistPath(projectRoot: string): string;
 export declare function buildElectronOverlayInjectionCall(options: {

package/dist/node-server/electron-runtime.js

@@ -4,7 +4,6 @@ export const DEFAULT_ELECTRON_SERVE_PORT = 5710;
 export const DEFAULT_ELECTRON_SERVE_HOST = 'localhost';
 export const DEFAULT_ELECTRON_CDP_PORT = 9223;
 export const DEFAULT_ELECTRON_TARGET_URL = 'about:blank';
-export const DEFAULT_ELECTRON_OVERLAY_TAB = 'chat';
 export const ELECTRON_OVERLAY_APP_PATH = '/electron';
 // Port allocation constants
 export const PORT_HASH_RANGE = 40;
@@ -100,74 +99,77 @@ export function getElectronAppDisplayName(appPath) {
     }
     return fileName || trimmedPath;
 }
-export function resolveElectronAppExecutablePath(appPath, platform = process.platform) {
-    const resolvedAppPath = resolve(appPath);
-    if (platform === 'darwin' && resolvedAppPath.toLowerCase().endsWith('.app')) {
-        const macOSDir = join(resolvedAppPath, 'Contents', 'MacOS');
-        // First try the expected name (app name without .app)
-        const expectedName = getElectronAppDisplayName(resolvedAppPath);
-        const expectedPath = join(macOSDir, expectedName);
-        try {
-            const stat = statSync(expectedPath);
-            if (stat.isFile()) {
-                return expectedPath;
-            }
-        }
-        catch {
-            // Expected path doesn't exist, scan the directory
+function isExecutableFile(path) {
+    try {
+        accessSync(path, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function findMacOSExecutable(macOSDir, expectedName) {
+    // First try the expected name (app name without .app)
+    const expectedPath = join(macOSDir, expectedName);
+    try {
+        const stat = statSync(expectedPath);
+        if (stat.isFile()) {
+            return expectedPath;
         }
-        // Scan MacOS directory for the main executable
-        // Many Electron apps use "Electron" as the executable name
-        // Prefer known main executable names, filter out helper processes
-        const helperPatterns = [/helper/i, /crash/i, /gpu/i, /renderer/i, /plugin/i, /utility/i];
-        try {
-            const entries = readdirSync(macOSDir);
-            // Helper to check if a file is executable
-            const isExecutable = (path) => {
-                try {
-                    accessSync(path, constants.X_OK);
-                    return true;
-                }
-                catch {
-                    return false;
-                }
-            };
-            // First pass: look for "Electron" executable (common in Electron apps)
-            if (entries.includes('Electron')) {
-                const electronPath = join(macOSDir, 'Electron');
-                try {
-                    const stat = statSync(electronPath);
-                    if (stat.isFile() && isExecutable(electronPath)) {
-                        return electronPath;
-                    }
-                }
-                catch {
-                    // Continue to next fallback
+    }
+    catch {
+        // Expected path doesn't exist, scan the directory
+    }
+    // Scan MacOS directory for the main executable
+    // Many Electron apps use "Electron" as the executable name
+    // Prefer known main executable names, filter out helper processes
+    const helperPatterns = [/helper/i, /crash/i, /gpu/i, /renderer/i, /plugin/i, /utility/i];
+    try {
+        const entries = readdirSync(macOSDir);
+        // First pass: look for "Electron" executable (common in Electron apps)
+        if (entries.includes('Electron')) {
+            const electronPath = join(macOSDir, 'Electron');
+            try {
+                const stat = statSync(electronPath);
+                if (stat.isFile() && isExecutableFile(electronPath)) {
+                    return electronPath;
                 }
             }
-            // Second pass: find first non-helper executable with execute permission
-            for (const entry of entries) {
-                // Skip hidden files, scripts, and helper executables
-                if (entry.startsWith('.') || entry.endsWith('.sh'))
-                    continue;
-                if (helperPatterns.some((p) => p.test(entry)))
-                    continue;
-                const entryPath = join(macOSDir, entry);
-                try {
-                    const stat = statSync(entryPath);
-                    if (stat.isFile() && isExecutable(entryPath)) {
-                        return entryPath;
-                    }
-                }
-                catch { }
+            catch {
+                // Continue to next fallback
             }
         }
-        catch {
-            // Can't read directory, fall back to expected path
+        // Second pass: find first non-helper executable with execute permission
+        for (const entry of entries) {
+            // Skip hidden files, scripts, and helper executables
+            if (entry.startsWith('.') || entry.endsWith('.sh'))
+                continue;
+            if (helperPatterns.some((p) => p.test(entry)))
+                continue;
+            const entryPath = join(macOSDir, entry);
+            try {
+                const stat = statSync(entryPath);
+                if (stat.isFile() && isExecutableFile(entryPath)) {
+                    return entryPath;
+                }
+            }
+            catch { }
         }
+    }
+    catch {
+        // Can't read directory, fall back to expected path
+    }
+    return null;
+}
+export function resolveElectronAppExecutablePath(appPath, platform = process.platform) {
+    const resolvedAppPath = resolve(appPath);
+    if (platform === 'darwin' && resolvedAppPath.toLowerCase().endsWith('.app')) {
+        const macOSDir = join(resolvedAppPath, 'Contents', 'MacOS');
+        const expectedName = getElectronAppDisplayName(resolvedAppPath);
+        const expectedPath = join(macOSDir, expectedName);
         // Fall back to expected path even if it doesn't exist
         // (error will be caught later)
-        return expectedPath;
+        return findMacOSExecutable(macOSDir, expectedName) ?? expectedPath;
     }
     return resolvedAppPath;
 }
@@ -247,13 +249,6 @@ export function buildElectronServerSpawnConfig(projectRoot, options) {
 export function getElectronServeOrigin(servePort) {
     return `http://${DEFAULT_ELECTRON_SERVE_HOST}:${servePort}`;
 }
-export function buildElectronOverlayAppUrl(serveOrigin, activeTab = DEFAULT_ELECTRON_OVERLAY_TAB) {
-    const url = new URL(ELECTRON_OVERLAY_APP_PATH, serveOrigin);
-    if (activeTab && activeTab !== DEFAULT_ELECTRON_OVERLAY_TAB) {
-        url.searchParams.set('tab', activeTab);
-    }
-    return url.toString();
-}
 export function buildElectronOverlayEntryUrl(serveOrigin) {
     return new URL('/electron-overlay-entry.js', serveOrigin).toString();
 }

package/dist/node-server/fetch-proxy-headers.d.ts

@@ -18,3 +18,28 @@
  * module load.
  */
 export declare const FETCH_PROXY_SKIP_HEADERS: ReadonlySet<string>;
+/**
+ * Response-side header names the proxy must NOT copy from the upstream
+ * response onto the browser-facing response. The bridge's
+ * `createThinBridgeCorsMiddleware` / `buildCorsHeaders` set the
+ * authoritative CORS headers for the browser→bridge hop BEFORE this
+ * route runs; an upstream that emits its own `access-control-*`
+ * (e.g. `huggingface.co` → `*`, GitHub Pages → its own origin) would
+ * otherwise `res.setHeader`-clobber the bridge's value, leaving the
+ * browser with a CORS mismatch (`*` + `Allow-Credentials: true` is
+ * forbidden; a foreign origin obviously doesn't match localhost) and
+ * surfacing as an opaque `TypeError: Failed to fetch`. Stripping the
+ * full `access-control-*` family keeps the bridge as the sole CORS
+ * authority on the local hop. Names are lowercased to match
+ * `upstream.headers.forEach` key casing.
+ */
+export declare const FETCH_PROXY_SKIP_RESPONSE_HEADERS: ReadonlySet<string>;
+/**
+ * Lowercased prefixes whose upstream response headers are also skipped.
+ * `access-control-` covers the entire CORS-response family (allow-origin,
+ * allow-credentials, allow-methods, allow-headers, expose-headers,
+ * max-age, allow-private-network, plus any future entries) so the bridge
+ * middleware remains the sole CORS authority. `x-proxy-` is the proxy's
+ * own response-marker namespace — never echo an upstream value.
+ */
+export declare const FETCH_PROXY_SKIP_RESPONSE_PREFIXES: readonly string[];

package/dist/node-server/fetch-proxy-headers.js

@@ -27,5 +27,41 @@ export const FETCH_PROXY_SKIP_HEADERS = new Set([
     'x-proxy-cookie',
     'x-proxy-origin',
     'x-proxy-referer',
+    // Kept in sync with `BRIDGE_TOKEN_HEADER` in `bridge-security.ts`
+    // (lowercased because Node lowercases incoming request header keys).
     'x-bridge-token',
 ]);
+/**
+ * Response-side header names the proxy must NOT copy from the upstream
+ * response onto the browser-facing response. The bridge's
+ * `createThinBridgeCorsMiddleware` / `buildCorsHeaders` set the
+ * authoritative CORS headers for the browser→bridge hop BEFORE this
+ * route runs; an upstream that emits its own `access-control-*`
+ * (e.g. `huggingface.co` → `*`, GitHub Pages → its own origin) would
+ * otherwise `res.setHeader`-clobber the bridge's value, leaving the
+ * browser with a CORS mismatch (`*` + `Allow-Credentials: true` is
+ * forbidden; a foreign origin obviously doesn't match localhost) and
+ * surfacing as an opaque `TypeError: Failed to fetch`. Stripping the
+ * full `access-control-*` family keeps the bridge as the sole CORS
+ * authority on the local hop. Names are lowercased to match
+ * `upstream.headers.forEach` key casing.
+ */
+export const FETCH_PROXY_SKIP_RESPONSE_HEADERS = new Set([
+    'transfer-encoding',
+    'content-encoding',
+    'content-length',
+    'www-authenticate',
+    'set-cookie',
+]);
+/**
+ * Lowercased prefixes whose upstream response headers are also skipped.
+ * `access-control-` covers the entire CORS-response family (allow-origin,
+ * allow-credentials, allow-methods, allow-headers, expose-headers,
+ * max-age, allow-private-network, plus any future entries) so the bridge
+ * middleware remains the sole CORS authority. `x-proxy-` is the proxy's
+ * own response-marker namespace — never echo an upstream value.
+ */
+export const FETCH_PROXY_SKIP_RESPONSE_PREFIXES = [
+    'access-control-',
+    'x-proxy-',
+];