@dimina-kit/devtools 0.4.0 → 0.5.0-dev.20260908120530

package/dist/main/services/automation/index.js

@@ -10,8 +10,11 @@
  * (simulator webContents, IPC handlers, etc.) without modifying dimina upstream.
  */
 import { WebSocketServer } from 'ws';
-import { AutomationChannel, SimulatorChannel } from '../../../shared/ipc-channels.js';
+import { AutomationChannel } from '../../../shared/ipc-channels.js';
 import { IpcRegistry } from '../../utils/ipc-registry.js';
+import { toIpcContextSource } from '../../utils/ipc-context-source.js';
+import { createConnectionTarget } from './connection-target.js';
+import { createConsoleBridge } from './console-bridge.js';
 import { getSimulator } from './exec.js';
 import { toolHandlers } from './handlers/tool.js';
 import { appHandlers } from './handlers/app.js';
@@ -28,7 +31,17 @@ let currentPort = null;
 export function getAutomationPort() {
     return currentPort;
 }
-export async function startAutomationServer(ctx, port = 0) {
+/**
+ * `getCtx` rather than a context: the server binds its port at boot, before any
+ * project window exists, so there is nothing to capture yet. Each connection
+ * then pins the first project window it reaches and keeps driving that one —
+ * `getCtx` is how it finds that window, not a per-message lookup.
+ *
+ * `senders` covers every live window instead, because the port channel is asked
+ * by renderers `getCtx` never names: the project list and background project
+ * windows all start automation clients of their own.
+ */
+export async function startAutomationServer(getCtx, senders, port = 0) {
     const wss = new WebSocketServer({ port });
     const clients = new Set();
     await new Promise((resolve, reject) => {
@@ -39,125 +52,34 @@ export async function startAutomationServer(ctx, port = 0) {
     // ws always binds via an http.Server, so address() is AddressInfo here.
     const resolvedPort = typeof addr === 'object' && addr ? addr.port : port;
     currentPort = resolvedPort;
-    // Gate AutomationChannel.GetPort with the workbench sender policy (only
-    // the main renderer + workbench settings/popover overlays are allowed to
-    // read the port — see createWorkbenchSenderPolicy; the simulator webview
-    // is intentionally NOT trusted for IPC invokes).
-    const portIpc = new IpcRegistry(ctx.senderPolicy);
+    // Gated per OWNING window: each window trusts its own renderer plus its
+    // settings/popover overlays (see createWorkbenchSenderPolicy), and the
+    // simulator webview is trusted by none of them. Gating on the active
+    // window's policy instead would reject every window that does not currently
+    // have focus, starting with the project list.
+    const portIpc = new IpcRegistry(toIpcContextSource(senders));
     portIpc.handle(AutomationChannel.GetPort, () => {
         return currentPort;
     });
-    function broadcast(event) {
-        const msg = JSON.stringify(event);
-        for (const ws of clients) {
-            if (ws.readyState === ws.OPEN)
-                ws.send(msg);
-        }
-    }
-    // Native-host console forwarding: under native-host the page/service console
-    // doesn't flow through the simulator guest's `ipc-message-host` channel (there
-    // is no Worker/MiniApp in the guest). Instead the render-host / service-host
-    // preloads post each console entry to main, bridge-router routes it to the
-    // always-on ConsoleForwarder, and we SUBSCRIBE to rebroadcast every entry
-    // (both layers) as an `App.logAdded` event — same shape the default-arch path
-    // emits below in `setupConsoleForwarding`. We no longer set `ctx.guestConsole`
-    // ourselves (the forwarder owns it); subscribing means render + service both
-    // reach automation while the forwarder also mirrors render into the service
-    // host's console for the embedded DevTools. Unsubscribed on close().
-    const consoleSub = ctx.consoleForwarder?.subscribe((entry) => {
-        const e = (entry ?? {});
-        broadcast({
-            method: 'App.logAdded',
-            params: { type: e.level || 'log', args: e.args || [] },
-        });
-    });
-    // Forward simulator console logs as App.logAdded events.
-    // Track the polling interval + stop timer + currently-attached sim and
-    // the named handler so we can fully detach on close() or sim destruction.
-    // Without this the listener accumulates across create/dispose cycles and
-    // across simulator rebuilds.
-    let consoleForwardingSetup = false;
-    let pollInterval = null;
-    let pollStopTimer = null;
-    let attachedSim = null;
-    let ipcMessageHostHandler = null;
-    // Handle for the destroyed-teardown owned by the sim's connection (replaces a
-    // bespoke `sim.once('destroyed')` + manual removeListener). Disposing it on
-    // graceful close()/detach releases the disposer from the connection segment so
-    // it can't accumulate across automation create/dispose cycles on the same sim.
-    let simDestroyedDisposer = null;
-    function detachConsoleForwarding() {
-        if (attachedSim) {
-            if (ipcMessageHostHandler) {
-                try {
-                    if (!attachedSim.isDestroyed()) {
-                        ;
-                        attachedSim.removeListener('ipc-message-host', ipcMessageHostHandler);
-                    }
-                }
-                catch { /* noop */ }
-            }
-        }
-        // Release the connection-owned destroyed disposer (idempotent; safe even if
-        // the sim is already destroyed — the disposer body only nulls local refs).
-        try {
-            simDestroyedDisposer?.dispose();
-        }
-        catch { /* noop */ }
-        attachedSim = null;
-        ipcMessageHostHandler = null;
-        simDestroyedDisposer = null;
-    }
-    function setupConsoleForwarding() {
-        if (consoleForwardingSetup)
-            return;
-        consoleForwardingSetup = true;
-        pollInterval = setInterval(() => {
-            const sim = getSimulator(ctx);
-            if (!sim)
-                return;
-            if (pollInterval) {
-                clearInterval(pollInterval);
-                pollInterval = null;
-            }
-            const onIpcMessageHost = (_event, channel, data) => {
-                if (channel === SimulatorChannel.Console) {
-                    const logData = data;
-                    broadcast({
-                        method: 'App.logAdded',
-                        params: { type: logData.level || 'log', args: logData.args || [] },
-                    });
-                }
-            };
-            const onSimDestroyed = () => {
-                // Sim webContents is dead — drop refs (removeListener on a destroyed
-                // sender would throw) and allow re-attach to a new simulator.
-                attachedSim = null;
-                ipcMessageHostHandler = null;
-                simDestroyedDisposer = null;
-                consoleForwardingSetup = false;
-            };
-            attachedSim = sim;
-            ipcMessageHostHandler = onIpcMessageHost;
-            sim.on('ipc-message-host', onIpcMessageHost);
-            // Route the destroyed-teardown through the per-webContents connection
-            // registry: the connection arms a single `wc.once('destroyed')` and runs
-            // owned disposers on hard-destroy (or soft reset for pool reuse), so we no
-            // longer manage a bespoke 'destroyed' listener here.
-            simDestroyedDisposer = ctx.connections.acquire(sim).own(onSimDestroyed);
-        }, 1000);
-        // Stop polling after 30s
-        pollStopTimer = setTimeout(() => {
-            if (pollInterval) {
-                clearInterval(pollInterval);
-                pollInterval = null;
-            }
-            pollStopTimer = null;
-        }, 30000);
-    }
+    // Every connection owns its console bridge, because every connection has its
+    // own target window: a single server-wide broadcast would hand one client the
+    // logs of a project another client is driving.
+    const bridges = new Set();
     wss.on('connection', (ws) => {
         clients.add(ws);
-        setupConsoleForwarding();
+        const send = (msg) => {
+            if (ws.readyState === ws.OPEN)
+                ws.send(JSON.stringify(msg));
+        };
+        // Pinned, not resolved per message: the window a script drives is settled by
+        // the first project window this connection reaches, so a user clicking
+        // another project's window can't redirect it (see `createConnectionTarget`).
+        const target = createConnectionTarget(getCtx);
+        const consoleBridge = createConsoleBridge(() => target.peek(), getSimulator, send);
+        bridges.add(consoleBridge);
+        // Before any message: a client that only listens for `App.logAdded` never
+        // sends one, and still has to receive its target window's console.
+        consoleBridge.sync();
         ws.on('message', async (raw) => {
             let req;
             try {
@@ -174,6 +96,9 @@ export async function startAutomationServer(ctx, port = 0) {
             }
             else {
                 try {
+                    // Same target for the command and for the logs it produces.
+                    const ctx = target.resolve();
+                    consoleBridge.sync();
                     const result = await handler(ctx, params);
                     response = { id, result };
                 }
@@ -181,27 +106,23 @@ export async function startAutomationServer(ctx, port = 0) {
                     response = { id, error: { message: err.message || String(err) } };
                 }
             }
-            if (ws.readyState === ws.OPEN)
-                ws.send(JSON.stringify(response));
+            send(response);
+        });
+        ws.on('close', () => {
+            clients.delete(ws);
+            bridges.delete(consoleBridge);
+            consoleBridge.dispose();
         });
-        ws.on('close', () => clients.delete(ws));
     });
     return {
         close: () => {
-            if (pollInterval) {
-                clearInterval(pollInterval);
-                pollInterval = null;
-            }
-            if (pollStopTimer) {
-                clearTimeout(pollStopTimer);
-                pollStopTimer = null;
-            }
-            detachConsoleForwarding();
-            // Unsubscribe from the always-on ConsoleForwarder so a late guest console
-            // entry can't broadcast against a torn-down server. The forwarder keeps
-            // owning `ctx.guestConsole` (render→service mirroring continues without an
-            // automation client). No-op if the forwarder was absent.
-            consoleSub?.dispose();
+            // Detaches every connection's simulator listener and unsubscribes it from
+            // its window's ConsoleForwarder, so a late guest console entry can't fire
+            // against a torn-down server. The forwarder keeps owning `ctx.guestConsole`
+            // (render→service mirroring continues without an automation client).
+            for (const bridge of bridges)
+                bridge.dispose();
+            bridges.clear();
             for (const ws of clients) {
                 try {
                     ws.close();

package/dist/main/services/cdp-session/index.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Shared `wc.debugger` (CDP) session broker for render-host guest WebContents.
+ *
+ * ── Why this exists ─────────────────────────────────────────────────────────
+ * `webContents.debugger` is exclusive per wc (only one `attach()` owner at a
+ * time). Four independent modules — safe-area, elements-forward, render-inspect
+ * and network-forward — each hand-roll the same "reuse if already attached,
+ * self-attach only if nobody has, track what I self-attached so I only detach
+ * my own" bookkeeping, and each installs its OWN `wc.debugger.on('message', …)`
+ * listener. That duplication caused two real bugs:
+ *
+ *  1. network-forward's `attachRenderGuest` runs ONCE per guest (at webview
+ *     creation). If some OTHER module later detaches the shared session it
+ *     happened to self-attach, network-forward's capture dies permanently —
+ *     nothing re-attaches it (unlike safe-area/elements-forward/render-inspect,
+ *     which lazily re-`ensure` the debugger on every use and so self-heal).
+ *  2. On the simulator wc, two modules each do "detach if attached" with no
+ *     notion of the other — whichever runs last steals the other's session.
+ *
+ * This broker is the single owner of "who attached, who may detach": callers
+ * `acquire(wc)` a lease instead of touching `wc.debugger` directly. A session's
+ * lifetime tracks the wc, not any one lease — the last lease releasing does
+ * NOT detach (another consumer may `acquire` again at any time); only the
+ * broker's own top-level `dispose()` detaches sessions IT self-attached. An
+ * external detach (another owner, or a real Chrome DevTools window stealing the
+ * session) notifies every lease's `onDetach` and drops the session's
+ * bookkeeping so the NEXT `acquire()` attaches from scratch — closing bug #1
+ * structurally instead of requiring every consumer to remember to re-ensure.
+ */
+import type { WebContents } from 'electron';
+import type { ConnectionRegistry, Disposable } from '@dimina-kit/electron-deck/main';
+export interface CdpSessionLease {
+    /** Send one CDP command on this wc's session. Rejects if the session/wc is gone. */
+    send(method: string, params?: object): Promise<unknown>;
+    /**
+     * Subscribe to every CDP `message` event this session receives. Multiple
+     * leases (from the same or different `acquire()` calls) share ONE real
+     * `wc.debugger.on('message', …)` listener, fanned out to every subscriber.
+     */
+    onMessage(cb: (method: string, params: unknown) => void): Disposable;
+    /**
+     * Subscribe to this session becoming unusable for any reason OTHER than the
+     * broker's own top-level `dispose()`: an external detach (another owner
+     * releasing it, or a real Chrome DevTools window stealing it) OR the wc
+     * itself being destroyed. Either way the broker has already dropped its
+     * bookkeeping for this session by the time this fires — a consumer that
+     * caches its lease should drop the cache entry here so its NEXT `acquire()`
+     * gets a fresh one instead of operating on a dead lease. The broker's own
+     * `dispose()` detaching a session it self-attached does NOT fire this: that
+     * is an intentional, expected teardown, not a surprise the caller needs to
+     * react to.
+     */
+    onDetach(cb: () => void): Disposable;
+    /**
+     * Enable DOM + CSS + Overlay (the render-inspection domains) once per
+     * session, in dependency order (`Overlay.enable` must follow `DOM.enable`'s
+     * resolution — Chromium rejects it otherwise; `CSS.enable` has no such
+     * dependency). Memoized PER SESSION (not per lease): concurrent callers on
+     * the same wc share one in-flight/completed handshake. Invalidated on any
+     * detach (self or external) so a later session re-runs it fresh.
+     */
+    ensureRenderDomains(): Promise<void>;
+    /**
+     * Release every subscription THIS lease registered via `onMessage`/
+     * `onDetach`. Idempotent. Never detaches the underlying session — that
+     * follows the wc's lifetime, not any one lease's.
+     */
+    dispose(): void;
+}
+export interface CdpSessionBroker {
+    /**
+     * Get-or-create a lease for `wc`'s debugger session. Returns `null` when the
+     * wc is already destroyed, or when the debugger is exclusively held
+     * elsewhere and unavailable to attach (e.g. a real Chrome DevTools window).
+     */
+    acquire(wc: WebContents): CdpSessionLease | null;
+    /**
+     * Project-level teardown: detach every session this broker itself
+     * self-attached (never one it merely reused). Sessions owned by someone
+     * else are left untouched.
+     */
+    dispose(): void;
+}
+export declare function createCdpSessionBroker(opts?: {
+    connections?: ConnectionRegistry;
+}): CdpSessionBroker;
+//# sourceMappingURL=index.d.ts.map

package/dist/main/services/cdp-session/index.js

@@ -0,0 +1,173 @@
+export function createCdpSessionBroker(opts = {}) {
+    const sessions = new Map();
+    function removeDebuggerListeners(session) {
+        try {
+            session.wc.debugger.removeListener('message', session.onDbgMessage);
+        }
+        catch { /* wc gone */ }
+        try {
+            session.wc.debugger.removeListener('detach', session.onDbgDetach);
+        }
+        catch { /* wc gone */ }
+    }
+    function notifyDetach(session) {
+        for (const cb of [...session.detachSubs]) {
+            try {
+                cb();
+            }
+            catch { /* subscriber error is not our problem */ }
+        }
+    }
+    function ensureSession(wc) {
+        const existing = sessions.get(wc);
+        if (existing)
+            return existing;
+        let selfAttached = false;
+        try {
+            if (!wc.debugger.isAttached()) {
+                wc.debugger.attach('1.3');
+                selfAttached = true;
+            }
+        }
+        catch {
+            // Exclusively held elsewhere (e.g. a real Chrome DevTools window) and
+            // refused to share — degrade to "unavailable", same as every existing
+            // per-module implementation this broker replaces.
+            return null;
+        }
+        const session = {
+            wc,
+            selfAttached,
+            selfDetaching: false,
+            messageSubs: new Set(),
+            detachSubs: new Set(),
+            enablePromise: null,
+            onDbgMessage: (...args) => {
+                const [, method, params] = args;
+                for (const cb of [...session.messageSubs])
+                    cb(method, params);
+            },
+            onDbgDetach: () => {
+                const wasSelfInitiated = session.selfDetaching;
+                session.selfDetaching = false;
+                session.enablePromise = null;
+                sessions.delete(wc);
+                removeDebuggerListeners(session);
+                try {
+                    session.destroyedSub?.dispose();
+                }
+                catch { /* already gone */ }
+                if (!wasSelfInitiated)
+                    notifyDetach(session);
+            },
+            onWcDestroyed: () => {
+                sessions.delete(wc);
+                removeDebuggerListeners(session);
+                // Deliberately does NOT call wc.debugger.detach(), even for a
+                // self-attached session: a destroyed wc's debugger is torn down by
+                // Electron itself, there is nothing left for us to usefully detach,
+                // and attempting it is an unnecessary risk (the underlying native
+                // objects may already be gone). Dropping our bookkeeping is enough.
+                // Not a broker-initiated detach — same "your lease is dead, re-acquire
+                // next time" signal as an external debugger detach, just for a
+                // different reason (the wc itself is gone, not merely the session).
+                notifyDetach(session);
+            },
+        };
+        wc.debugger.on('message', session.onDbgMessage);
+        wc.debugger.on('detach', session.onDbgDetach);
+        if (opts.connections) {
+            session.destroyedSub = opts.connections.acquire(wc).on('closed', session.onWcDestroyed);
+        }
+        else {
+            try {
+                wc.once('destroyed', session.onWcDestroyed);
+            }
+            catch { /* fake/minimal wc */ }
+        }
+        sessions.set(wc, session);
+        return session;
+    }
+    function ensureRenderDomains(session) {
+        if (session.enablePromise)
+            return session.enablePromise;
+        session.wc.debugger.sendCommand('CSS.enable').catch(() => { });
+        const p = session.wc.debugger
+            .sendCommand('DOM.enable')
+            .then(() => session.wc.debugger.sendCommand('Overlay.enable'))
+            .then(() => undefined)
+            .catch(() => {
+            // Guest mid-teardown or domain unavailable — drop the memo so a later
+            // call (e.g. after the session recovers) can retry instead of being
+            // stuck on a permanently-failed handshake.
+            session.enablePromise = null;
+        });
+        session.enablePromise = p;
+        return p;
+    }
+    function createLease(session) {
+        const ownMessageSubs = new Set();
+        const ownDetachSubs = new Set();
+        return {
+            // Echo the caller's exact arity through to sendCommand — a caller that
+            // omits params (many CDP commands take none, e.g. 'Network.enable')
+            // gets the identical call Electron's own API expects, not a synthetic
+            // `{}` second argument.
+            send: (method, params) => params === undefined
+                ? session.wc.debugger.sendCommand(method)
+                : session.wc.debugger.sendCommand(method, params),
+            onMessage: (cb) => {
+                session.messageSubs.add(cb);
+                ownMessageSubs.add(cb);
+                return { dispose: () => { session.messageSubs.delete(cb); ownMessageSubs.delete(cb); } };
+            },
+            onDetach: (cb) => {
+                session.detachSubs.add(cb);
+                ownDetachSubs.add(cb);
+                return { dispose: () => { session.detachSubs.delete(cb); ownDetachSubs.delete(cb); } };
+            },
+            ensureRenderDomains: () => ensureRenderDomains(session),
+            dispose: () => {
+                for (const cb of ownMessageSubs)
+                    session.messageSubs.delete(cb);
+                for (const cb of ownDetachSubs)
+                    session.detachSubs.delete(cb);
+                ownMessageSubs.clear();
+                ownDetachSubs.clear();
+            },
+        };
+    }
+    return {
+        acquire(wc) {
+            if (wc.isDestroyed())
+                return null;
+            const session = ensureSession(wc);
+            if (!session)
+                return null;
+            return createLease(session);
+        },
+        dispose() {
+            for (const session of [...sessions.values()]) {
+                if (session.selfAttached) {
+                    session.selfDetaching = true;
+                    try {
+                        if (!session.wc.isDestroyed() && session.wc.debugger.isAttached()) {
+                            session.wc.debugger.detach();
+                        }
+                    }
+                    catch { /* already detached / destroyed */ }
+                }
+                // Whether detach ran above (which already self-cleans via onDbgDetach)
+                // or this session was externally-owned (never touched), make sure
+                // broker-side bookkeeping is gone either way.
+                sessions.delete(session.wc);
+                removeDebuggerListeners(session);
+                try {
+                    session.destroyedSub?.dispose();
+                }
+                catch { /* already gone */ }
+            }
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/main/services/compile-standby.js

@@ -21,6 +21,10 @@ export function setupCompileWorkerStandby(ctx, deps = {}) {
                 severity: EVENT_SEVERITY[ev.type] ?? 'info',
                 code: 'compile-standby',
                 message: detail,
+                // Devtools-tooling-only state, unrelated to the inspected mini-program
+                // — must never reach the right-panel (user-facing) Console panel; see
+                // console-forward/index.ts's audience gate and global-diagnostics-mirror.ts.
+                audience: 'internal',
             });
         }
         catch {

package/dist/main/services/console-forward/cdp-inject.d.ts

@@ -0,0 +1,18 @@
+import type { WebContents } from 'electron';
+import type { CdpSessionBroker } from '../cdp-session/index.js';
+/**
+ * Shared CDP injection primitive for the global mirrors (console +
+ * diagnostics): evaluate `script` in `target`'s realm over the broker's
+ * debugger session — never `target.executeJavaScript`, whose internal RPC
+ * hangs forever on a wc that is simultaneously the inspected side of
+ * `setDevToolsWebContents` AND attached by an external CDP client (see
+ * global-console-mirror.ts for the full mechanism and the real-machine
+ * repro).
+ *
+ * Resolves true only on a clean evaluation. `exceptionDetails`, a rejected
+ * send, and an unacquirable session (destroyed wc / debugger exclusively
+ * held elsewhere) all report false — createOpenGatedRelay then leaves the
+ * entry retryable instead of marking it done.
+ */
+export declare function injectViaCdp(broker: CdpSessionBroker, target: WebContents, script: string, warnTag: string): boolean | Promise<boolean>;
+//# sourceMappingURL=cdp-inject.d.ts.map

package/dist/main/services/console-forward/cdp-inject.js

@@ -0,0 +1,30 @@
+/**
+ * Shared CDP injection primitive for the global mirrors (console +
+ * diagnostics): evaluate `script` in `target`'s realm over the broker's
+ * debugger session — never `target.executeJavaScript`, whose internal RPC
+ * hangs forever on a wc that is simultaneously the inspected side of
+ * `setDevToolsWebContents` AND attached by an external CDP client (see
+ * global-console-mirror.ts for the full mechanism and the real-machine
+ * repro).
+ *
+ * Resolves true only on a clean evaluation. `exceptionDetails`, a rejected
+ * send, and an unacquirable session (destroyed wc / debugger exclusively
+ * held elsewhere) all report false — createOpenGatedRelay then leaves the
+ * entry retryable instead of marking it done.
+ */
+export function injectViaCdp(broker, target, script, warnTag) {
+    const lease = broker.acquire(target);
+    if (!lease)
+        return false;
+    return lease.send('Runtime.evaluate', { expression: script }).then((result) => {
+        if (result?.exceptionDetails) {
+            console.warn(`[${warnTag}] Runtime.evaluate reported an exception, will retry on next reopen`);
+            return false;
+        }
+        return true;
+    }, (err) => {
+        console.warn(`[${warnTag}] injection failed, will retry on next reopen:`, err instanceof Error ? err.message : String(err));
+        return false;
+    });
+}
+//# sourceMappingURL=cdp-inject.js.map

package/dist/main/services/console-forward/global-console-mirror.d.ts

@@ -0,0 +1,33 @@
+import type { WebContents } from 'electron';
+import type { Disposable } from '@dimina-kit/electron-deck/main';
+import type { ConsoleForwarder } from './index.js';
+import type { CdpSessionBroker } from '../cdp-session/index.js';
+/**
+ * Mirror EVERY guest console entry (both service + render layers,
+ * UNFILTERED — no isInternalLogMessage gating, see that module's doc for
+ * why this mirror deliberately skips it) into `target`'s own console, but
+ * ONLY while the standalone internal DevTools window is open.
+ *
+ * The subscription lifecycle is gated by `onHostChanged` (non-null hostWc =
+ * window just opened/rebuilt, null = just closed) rather than subscribing
+ * once for the whole app lifetime: each open re-subscribes to `forwarder`
+ * with `{replay:true}`, draining its CURRENT history buffer into `target`
+ * before continuing live, and each close disposes that subscription. This
+ * is what makes opening (or reopening) the window always show recent
+ * history — subscribing once at construction time (this module's earlier
+ * design) captured the replay burst before any window could possibly be
+ * open to receive it, silently losing it forever. `target` is the fixed
+ * INSPECTED side (mainWindow.webContents, per
+ * internal-devtools-window.ts's setDevToolsWebContents relationship) —
+ * never the hostWc the signal carries; injecting into the front-end host
+ * page would only ever reach that page's own invisible console.
+ *
+ * Reopen-dedup is handled by `createOpenGatedRelay` (real-machine e2e
+ * confirmed a naive replay-on-every-open double-injects everything already
+ * shown once, since Chromium's own console storage survives a DevTools
+ * close — see that module's doc comment).
+ */
+export declare function createGlobalConsoleMirror(forwarder: Pick<ConsoleForwarder, 'subscribe'>, target: WebContents, onHostChanged: (handler: (hostWc: WebContents | null) => void) => () => void, opts: {
+    broker: CdpSessionBroker;
+}): Disposable;
+//# sourceMappingURL=global-console-mirror.d.ts.map

package/dist/main/services/console-forward/global-console-mirror.js

@@ -0,0 +1,71 @@
+import { isFrontendSettled } from '../views/inject-when-ready.js';
+import { createOpenGatedRelay } from './open-gated-relay.js';
+import { injectViaCdp } from './cdp-inject.js';
+/** Console levels safe to re-emit; anything else maps to 'log' — mirrors
+ *  console-forward/index.ts's FORWARDABLE_LEVELS. */
+const FORWARDABLE_LEVELS = new Set(['log', 'warn', 'error', 'info', 'debug']);
+/**
+ * Build the `executeJavaScript` source that re-emits one guest console entry
+ * into the target wc's own console, tagged with its source layer. Args ride
+ * as a JSON string and are re-parsed target-side — data, never code — same
+ * discipline as console-forward/index.ts's buildForwardScript.
+ */
+function buildMirrorScript(entry) {
+    const method = FORWARDABLE_LEVELS.has(entry.level ?? '') ? entry.level : 'log';
+    const tag = entry.source === 'render' ? '[render]' : '[service]';
+    const argsJson = JSON.stringify(entry.args ?? []);
+    return `(()=>{try{const a=JSON.parse(${JSON.stringify(argsJson)});console[${JSON.stringify(method)}](${JSON.stringify(tag)},...a)}catch(_){}})()`;
+}
+/**
+ * Mirror EVERY guest console entry (both service + render layers,
+ * UNFILTERED — no isInternalLogMessage gating, see that module's doc for
+ * why this mirror deliberately skips it) into `target`'s own console, but
+ * ONLY while the standalone internal DevTools window is open.
+ *
+ * The subscription lifecycle is gated by `onHostChanged` (non-null hostWc =
+ * window just opened/rebuilt, null = just closed) rather than subscribing
+ * once for the whole app lifetime: each open re-subscribes to `forwarder`
+ * with `{replay:true}`, draining its CURRENT history buffer into `target`
+ * before continuing live, and each close disposes that subscription. This
+ * is what makes opening (or reopening) the window always show recent
+ * history — subscribing once at construction time (this module's earlier
+ * design) captured the replay burst before any window could possibly be
+ * open to receive it, silently losing it forever. `target` is the fixed
+ * INSPECTED side (mainWindow.webContents, per
+ * internal-devtools-window.ts's setDevToolsWebContents relationship) —
+ * never the hostWc the signal carries; injecting into the front-end host
+ * page would only ever reach that page's own invisible console.
+ *
+ * Reopen-dedup is handled by `createOpenGatedRelay` (real-machine e2e
+ * confirmed a naive replay-on-every-open double-injects everything already
+ * shown once, since Chromium's own console storage survives a DevTools
+ * close — see that module's doc comment).
+ */
+export function createGlobalConsoleMirror(forwarder, target, onHostChanged, opts) {
+    function inject(entry) {
+        if (target.isDestroyed())
+            return false;
+        if (!isFrontendSettled(target))
+            return false;
+        let script;
+        try {
+            script = buildMirrorScript(entry);
+        }
+        catch {
+            return false;
+        }
+        // Transport is CDP `Runtime.evaluate` over the shared debugger-session
+        // broker — NEVER `target.executeJavaScript`: Electron's internal
+        // ExecuteJavaScript RPC hangs FOREVER on a wc that is simultaneously the
+        // inspected side of `setDevToolsWebContents` (the standalone debug
+        // window) AND attached by an external CDP client (remote-debugging-port,
+        // which bootstrap's setupCdpPort enables by default when unpackaged and
+        // whenever cdp/mcp settings are on) — real-machine repro. The debugger
+        // channel is unaffected. Report the real outcome (not fire-and-forget) —
+        // createOpenGatedRelay only marks an entry permanently "injected" on a
+        // confirmed `true`, and its inject timeout bounds any residual hang.
+        return injectViaCdp(opts.broker, target, script, 'global-console-mirror');
+    }
+    return createOpenGatedRelay(onHostChanged, (sink, opts2) => forwarder.subscribe(sink, opts2), inject);
+}
+//# sourceMappingURL=global-console-mirror.js.map