sliccy 6.43.0 → 6.44.0

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

@@ -28,13 +28,35 @@ export declare function resolveOverlayThinBridge(env: Record<string, string | un
 export interface ThinOverlayUrlOptions extends ThinBridgeConfig {
     role: OverlayRole;
     activeTab?: string;
+    /**
+     * Explicit tray intent for the overlay URL, three-valued:
+     *
+     * - a normalized join URL (`--join`) → `tray=<url>`: the hosted webapp
+     *   resolves it via `resolveFollowerJoinUrl` and attaches to the running
+     *   leader as a tray FOLLOWER instead of minting its own tray — omitting
+     *   it was the bug that made every egress-allowed Electron app silently
+     *   become a second leader.
+     * - the EMPTY string → `tray=` (empty): explicit "no tray" intent. The
+     *   webapp treats any present `tray` param as explicit intent, which
+     *   blocks `resolveFollowerJoinUrl`'s localStorage fallback — without it,
+     *   the join URL the leader tab persists into the shared sliccy.ai
+     *   storage would re-enter through that fallback and boot every
+     *   auto-follow tab as ANOTHER tray follower (N followers for one
+     *   multi-window app).
+     * - absent/null → no `tray` param at all; storage-based re-follow stays
+     *   possible. Reserved for the SLICC Electron float's own window
+     *   (`electron-main.ts`), whose stored-tray reattach is intentional.
+     */
+    trayJoinUrl?: string | null;
 }
 /**
  * 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
+ * params) with two Electron-specific additions: a `role` param that pins
  * the first injected tab as the leader and marks every subsequent tab as
- * an auto-follow follower.
+ * an auto-follow follower, and — on a `--join` launch — the same
+ * `tray=<join url>` param the Chrome join path emits so the pinned tab
+ * attaches to the running leader as a tray follower.
  */
 export declare function buildThinOverlayAppUrl(opts: ThinOverlayUrlOptions): string;
 /**
@@ -206,6 +228,16 @@ export declare class ElectronOverlayInjector {
         thinBridge: ThinBridgeConfig;
         /** Start the headless CDP-over-CDP follower when egress-block is detected. */
         onEgressBlocked?: (targetUrl: string) => void;
+        /**
+         * Normalized tray join URL (`--join`); rides the LEADER-role overlay URL
+         * only, so the app's pinned first tab attaches to the running leader as
+         * ONE tray follower. In-app auto-follow tabs instead carry an explicitly
+         * EMPTY `tray=` — the leader tab persists the join URL into the shared
+         * sliccy.ai localStorage, and without explicit no-tray intent the
+         * `resolveFollowerJoinUrl` storage fallback would boot every extra
+         * window as ANOTHER tray follower (N followers for one app).
+         */
+        trayJoinUrl?: string | null;
     }): Promise<ElectronOverlayInjector>;
     /**
      * Test-only factory: skips bundle loading and lets tests drive the per-target

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

@@ -9,6 +9,7 @@ import { WebSocket } from 'ws';
 import { inflateSync } from 'zlib';
 import { BRIDGE_TOKEN_QUERY_PARAM, BRIDGE_WS_QUERY_PARAM } from './bridge-security.js';
 import { buildElectronAppLaunchSpec, buildElectronOverlayBootstrapScript, getElectronOverlayEntryDistPath, selectBestOverlayTargets, } from './electron-runtime.js';
+import { TRAY_QUERY_PARAM } from './tray-url-shared.js';
 const execFile = promisify(nodeExecFile);
 const ELECTRON_OVERLAY_SYNC_INTERVAL_MS = 1500;
 /**
@@ -40,9 +41,11 @@ export function resolveOverlayThinBridge(env, bridgeToken, servePort) {
 /**
  * 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
+ * params) with two Electron-specific additions: a `role` param that pins
  * the first injected tab as the leader and marks every subsequent tab as
- * an auto-follow follower.
+ * an auto-follow follower, and — on a `--join` launch — the same
+ * `tray=<join url>` param the Chrome join path emits so the pinned tab
+ * attaches to the running leader as a tray follower.
  */
 export function buildThinOverlayAppUrl(opts) {
     const url = new URL(ELECTRON_OVERLAY_APP_PATH, opts.hostedLeaderOrigin);
@@ -52,6 +55,9 @@ export function buildThinOverlayAppUrl(opts) {
     if (opts.activeTab && opts.activeTab !== 'chat') {
         url.searchParams.set('tab', opts.activeTab);
     }
+    if (opts.trayJoinUrl != null) {
+        url.searchParams.set(TRAY_QUERY_PARAM, opts.trayJoinUrl);
+    }
     return url.toString();
 }
 /**
@@ -616,11 +622,22 @@ export class ElectronOverlayInjector {
         const thinBootstraps = {
             leader: buildElectronOverlayBootstrapScript({
                 bundleSource,
-                appUrl: buildThinOverlayAppUrl({ ...options.thinBridge, role: BRIDGE_ROLE_LEADER }),
+                appUrl: buildThinOverlayAppUrl({
+                    ...options.thinBridge,
+                    role: BRIDGE_ROLE_LEADER,
+                    // Explicit intent in BOTH cases: join URL → follow; no join →
+                    // empty tray= so a stored join URL from an earlier launch can't
+                    // hijack a plain --electron launch into follower mode.
+                    trayJoinUrl: options.trayJoinUrl ?? '',
+                }),
             }),
             follower: buildElectronOverlayBootstrapScript({
                 bundleSource,
-                appUrl: buildThinOverlayAppUrl({ ...options.thinBridge, role: BRIDGE_ROLE_FOLLOWER }),
+                appUrl: buildThinOverlayAppUrl({
+                    ...options.thinBridge,
+                    role: BRIDGE_ROLE_FOLLOWER,
+                    trayJoinUrl: '',
+                }),
             }),
             status: buildElectronOverlayBootstrapScript({
                 bundleSource,

package/dist/node-server/index.js

@@ -47,6 +47,7 @@ import { SecretProxyManager } from './secrets/proxy-manager.js';
 import { readOrCreateSessionId } from './secrets/session-id-file.js';
 import { registerSecretsReloadEndpoint } from './secrets-reload-endpoint.js';
 import { registerSudoApproveEndpoint } from './sudo/endpoint.js';
+import { parseTrayJoinUrl } from './tray-url-shared.js';
 const Dirname = fileURLToPath(new URL('.', import.meta.url));
 const PROJECT_ROOT = resolve(Dirname, '..', '..');
 // ---------------------------------------------------------------------------
@@ -848,6 +849,13 @@ async function startOverlayInjector(state, cdpPort, servePort) {
             servePort,
             projectRoot: PROJECT_ROOT,
             thinBridge,
+            // Hand `--join` to the overlay webapp as the same `tray=<join url>`
+            // contract the Chrome join path emits, so an egress-ALLOWED app
+            // attaches to the running leader as a tray follower. Without this the
+            // overlay boots in electron-overlay mode and mints its own tray as a
+            // second leader. (The egress-BLOCKED hook below joins via the headless
+            // WebRTC follower instead — the overlay never loads there.)
+            trayJoinUrl: parseTrayJoinUrl(state.discoveredTrayJoinUrl)?.joinUrl ?? null,
             // When the app blocks renderer egress (hosted overlay can't load), expose
             // its CDP to the tray leader via the headless follower instead.
             onEgressBlocked: () => {