@dimina-kit/devtools 0.4.0-dev.20260718143821 → 0.4.0-dev.20260728065133

package/dist/main/app/app.js

@@ -7,6 +7,9 @@ import path from 'path';
 import { rendererDir as defaultRendererDir, defaultPreloadPath, devtoolsPackageRoot } from '../utils/paths.js';
 import { installThemeBackgroundSync } from '../utils/theme.js';
 import { createMainWindow, wireMainWindowEvents } from '../windows/main-window/index.js';
+import { createInternalDevtoolsWindow } from '../windows/internal-devtools-window/index.js';
+import { createGlobalConsoleMirror } from '../services/console-forward/global-console-mirror.js';
+import { createGlobalDiagnosticsMirror } from '../services/console-forward/global-diagnostics-mirror.js';
 import { isAppQuitting } from './lifecycle.js';
 import { resolveNativeAppDataKeys, resolveNativeStorageOverview } from './native-overview.js';
 // eslint-disable-next-line no-restricted-syntax -- grandfathered(workbench-context): shrink-only
@@ -14,7 +17,7 @@ import { createWorkbenchContext } from '../services/workbench-context.js';
 import { setupCompileWorkerStandby } from '../services/compile-standby.js';
 import { loadWorkbenchSettings, applyTheme } from '../services/settings/index.js';
 import { installAppMenu } from '../menu/index.js';
-import { registerAppIpc, popoverModule, projectsModule, sessionModule, settingsModule, simulatorModule, } from '../ipc/index.js';
+import { registerAppIpc, registerInternalDevtoolsIpc, popoverModule, projectsModule, sessionModule, settingsModule, simulatorModule, } from '../ipc/index.js';
 import { startAutomationServer } from '../services/automation/index.js';
 import { startMcpServer, setNativeHost, setActiveBridgeId, setNativeOverviewProvider, } from '../services/mcp/index.js';
 import { setupSimulatorStorage } from '../services/simulator-storage/index.js';
@@ -383,6 +386,19 @@ onInstanceCreated) {
     context.registry.add(registerAppIpc(context));
     // Sandboxed project file-system IPC (the renderer-side project:fs:* surface).
     context.registry.add(registerProjectFsIpc(context));
+    // Standalone internal (app-wide) DevTools debug window controller — the
+    // independent floating CDP panel that debugs the whole Electron app (as
+    // opposed to the right-panel CDP, which inspects only the user's
+    // mini-program). Assembled before the IPC handler below so a request
+    // arriving right after boot always finds it.
+    // `isAppQuitting` lets the controller stop intercepting 'close' during a
+    // real quit — its habitual preventDefault()+hide() would otherwise cancel
+    // the quit itself and strand the process with a hidden window.
+    context.internalDevtoolsWindow = createInternalDevtoolsWindow(mainWindow, { isAppQuitting });
+    context.registry.add(toDisposable(() => context.internalDevtoolsWindow?.dispose()));
+    // Unconditional (not a toggleable BUILTIN_MODULES entry): it's core dev
+    // tooling, not a host-configurable feature.
+    context.registry.add(registerInternalDevtoolsIpc(context));
     // Referer/CORS webRequest policy for the simulator runtime's sessions (shared
     // fallback + every per-project partition). Registered into the context
     // registry so its configurator + per-session listeners are torn down with the
@@ -398,6 +414,37 @@ onInstanceCreated) {
     if (!config.adapter)
         context.registry.add(setupCompileWorkerStandby(context));
     registerBuiltinModules(config, context);
+    // Global console mirror: while the standalone
+    // internal DevTools window is open, mirror every guest console entry
+    // (service + render, UNFILTERED — see global-console-mirror.ts) into it —
+    // each open replays the forwarder's current history buffer first (see that
+    // module's doc comment for why the subscribe lifecycle is gated on
+    // onHostChanged rather than subscribed once at construction time).
+    // `context.consoleForwarder` is assembled by the simulator module's
+    // installBridgeRouter just above; absent only when that builtin module was
+    // disabled via config. The Console panel shows the INSPECTED target's own
+    // console (mainWindow, per internal-devtools-window.ts's
+    // setDevToolsWebContents relationship) — NOT the front-end host page's
+    // console, so `target` is always mainWindow.webContents, never the hostWc
+    // onHostChanged hands the mirror.
+    if (context.consoleForwarder && context.internalDevtoolsWindow) {
+        const consoleMirror = createGlobalConsoleMirror(context.consoleForwarder, mainWindow.webContents, context.internalDevtoolsWindow.onHostChanged, 
+        // CDP transport (never executeJavaScript) — see the mirror's inject()
+        // doc for the setDevToolsWebContents + external-CDP double-attach hang.
+        { broker: context.cdpSessionBroker });
+        context.registry.add(toDisposable(() => consoleMirror.dispose()));
+    }
+    // Global diagnostics mirror (same wiring, same INSPECTED-side
+    // target rationale as the console mirror above): every diagnostic —
+    // including `audience:'internal'` ones console-forward's own service-host
+    // injection now skips (see compile-standby.ts / index.ts's handleDiagnostic
+    // gate) — surfaces here instead of vanishing. `context.diagnostics` is
+    // assembled alongside `context.consoleForwarder` by the same
+    // installBridgeRouter call.
+    if (context.diagnostics && context.internalDevtoolsWindow) {
+        const diagnosticsMirror = createGlobalDiagnosticsMirror(context.diagnostics, mainWindow.webContents, context.internalDevtoolsWindow.onHostChanged, { broker: context.cdpSessionBroker });
+        context.registry.add(toDisposable(() => diagnosticsMirror.dispose()));
+    }
     // Wire the simulator-side difile:// protocol handler + temp-file IPC
     // before host onSetup so any host-driven simulator boot sees the
     // protocol live. The module installs its own narrow sender-policy
@@ -534,12 +581,31 @@ onInstanceCreated) {
         // DevTools host exist; getServiceWc here is the fallback sink target.
         const networkForward = createNetworkForwarder({
             getServiceWc: (appId) => context.bridge?.getServiceWc(appId) ?? null,
+            getResourceServerBaseUrl: () => context.bridge?.getResourceBaseUrl?.() ?? null,
+            // The simulator shell's own static-asset server (serves simulator.html
+            // + its JS/CSS, independent from the resource server above — see
+            // NetworkForwarderBridge.getSimulatorServerBaseUrl's doc). Host is
+            // always 'localhost' — see shared/simulator-route.ts's
+            // buildSimulatorUrlFromSpec default. Absent (null port) when no
+            // project is open.
+            getSimulatorServerBaseUrl: () => {
+                const port = context.workspace?.getSession()?.port;
+                return typeof port === 'number' ? `http://localhost:${port}/` : null;
+            },
             connections: context.connections,
             broker: context.cdpSessionBroker,
         });
         context.networkForward = networkForward;
         context.registry.add(networkForward);
         context.registry.add(() => { context.networkForward = undefined; });
+        // Global mirror: once the standalone internal
+        // DevTools window builds its own front-end host, mirror the full
+        // unfiltered Network stream into it. Attached AFTER context.networkForward
+        // is assigned above — the callback re-reads the mutable field on every
+        // fire, so ordering only matters for readability here, not correctness.
+        context.registry.add(toDisposable(context.internalDevtoolsWindow?.onHostChanged((hostWc) => {
+            context.networkForward?.setGlobalDevtoolsHost(hostWc);
+        }) ?? (() => { })));
         context.registry.add(setupSimulatorWxml(mainWindow.webContents, {
             senderPolicy: context.senderPolicy,
             bridge: context.bridge,

package/dist/main/app/lifecycle.js

@@ -4,6 +4,15 @@ import { app, globalShortcut } from 'electron';
 // BEFORE each window's `close` event, so the main-window onClose handler can
 // read this to tell "the whole app is exiting" apart from "the user closed a
 // single project window" and avoid swallowing the quit.
+//
+// Deliberately a ONE-WAY latch: Electron emits no "quit was canceled" signal
+// to reset on, and any heuristic reset (timers, window-created probes) risks
+// flipping back to false DURING a real quit — which would re-arm the very
+// close-interception this flag exists to disable and abort the quit. The
+// cost of staying latched after a hypothetically-canceled quit (no in-repo
+// cancel path exists; a renderer `beforeunload` could in principle create
+// one) is a degraded-but-functional state, strictly cheaper than a broken
+// quit.
 let appIsQuitting = false;
 export function isAppQuitting() {
     return appIsQuitting;