@dimina-kit/devtools 0.4.0-dev.20260718095333 → 0.4.0-dev.20260728063215

package/dist/main/app/app.d.ts

@@ -32,5 +32,14 @@ export declare function runDevtoolsBootstrap(config?: WorkbenchAppConfig): void;
  * v2 `RuntimeBackend.assemble` reuses the exact same body (parity by shared
  * implementation, not behavioural re-creation).
  */
-export declare function createDevtoolsRuntime(config?: WorkbenchAppConfig): Promise<WorkbenchAppInstance>;
+export declare function createDevtoolsRuntime(config?: WorkbenchAppConfig, 
+/**
+ * Fired the instant the `WorkbenchAppInstance` exists — BEFORE `config.onSetup`
+ * is awaited below, which may run arbitrarily long host code (including
+ * loading the host-toolbar, which opens a live MessagePort). A caller that
+ * only learns `instance` from this function's return value would not see it
+ * until `onSetup` resolves, leaving a window where an app-quit teardown hook
+ * has nothing to dispose yet a live toolbar port already exists.
+ */
+onInstanceCreated?: (instance: WorkbenchAppInstance) => void): Promise<WorkbenchAppInstance>;
 //# sourceMappingURL=app.d.ts.map

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';
@@ -357,7 +360,16 @@ export function runDevtoolsBootstrap(config = {}) {
  * v2 `RuntimeBackend.assemble` reuses the exact same body (parity by shared
  * implementation, not behavioural re-creation).
  */
-export async function createDevtoolsRuntime(config = {}) {
+export async function createDevtoolsRuntime(config = {}, 
+/**
+ * Fired the instant the `WorkbenchAppInstance` exists — BEFORE `config.onSetup`
+ * is awaited below, which may run arbitrarily long host code (including
+ * loading the host-toolbar, which opens a live MessagePort). A caller that
+ * only learns `instance` from this function's return value would not see it
+ * until `onSetup` resolves, leaving a window where an app-quit teardown hook
+ * has nothing to dispose yet a live toolbar port already exists.
+ */
+onInstanceCreated) {
     // Self-gate on Electron readiness: this builds a BrowserWindow immediately, so
     // it must run after `app.whenReady()`. The framework backend path already
     // awaited it (idempotent no-op here); this guards any direct caller against
@@ -374,6 +386,19 @@ export async function createDevtoolsRuntime(config = {}) {
     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
@@ -389,6 +414,37 @@ export async function createDevtoolsRuntime(config = {}) {
     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
@@ -414,6 +470,7 @@ export async function createDevtoolsRuntime(config = {}) {
         registerSimulatorApi: (name, handler) => context.registry.add(toDisposable(context.simulatorApis.register(name, handler))),
         dispose: () => disposeContext(context),
     };
+    onInstanceCreated?.(instance);
     // Built-in simulator APIs: devtools-supplied wx.* implementations that run
     // in the main process. Hosts can override any of these in their onSetup by
     // re-registering the same name (last-write-wins on the Map).
@@ -524,12 +581,31 @@ export async function createDevtoolsRuntime(config = {}) {
         // 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.d.ts

@@ -1,3 +1,14 @@
 export declare function isAppQuitting(): boolean;
-export declare function registerAppLifecycle(): void;
+/**
+ * `onBeforeQuit`: invoked synchronously, once per `before-quit`, while
+ * Electron's main loop is still fully healthy — i.e. BEFORE `will-quit` and
+ * any window/WebContentsView destruction. Callers use this to tear down
+ * resources (child WebContentsViews, MessagePorts) that are unsafe to let
+ * survive into Chromium's native shutdown sequence, where a JS `'destroyed'`
+ * handler closing them can hit an already-torn-down native object. Isolated
+ * like `host-toolbar-port-channel.ts`'s `invokeReadyHandler`: a throwing
+ * callback must not stop `appIsQuitting` from flipping or escape as an
+ * uncaught exception out of Electron's event dispatch.
+ */
+export declare function registerAppLifecycle(onBeforeQuit?: () => void): void;
 //# sourceMappingURL=lifecycle.d.ts.map

package/dist/main/app/lifecycle.js

@@ -4,11 +4,31 @@ 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;
 }
-export function registerAppLifecycle() {
+/**
+ * `onBeforeQuit`: invoked synchronously, once per `before-quit`, while
+ * Electron's main loop is still fully healthy — i.e. BEFORE `will-quit` and
+ * any window/WebContentsView destruction. Callers use this to tear down
+ * resources (child WebContentsViews, MessagePorts) that are unsafe to let
+ * survive into Chromium's native shutdown sequence, where a JS `'destroyed'`
+ * handler closing them can hit an already-torn-down native object. Isolated
+ * like `host-toolbar-port-channel.ts`'s `invokeReadyHandler`: a throwing
+ * callback must not stop `appIsQuitting` from flipping or escape as an
+ * uncaught exception out of Electron's event dispatch.
+ */
+export function registerAppLifecycle(onBeforeQuit) {
     app.on('window-all-closed', () => {
         globalShortcut.unregisterAll();
         app.quit();
@@ -16,6 +36,12 @@ export function registerAppLifecycle() {
     app.on('before-quit', () => {
         appIsQuitting = true;
         globalShortcut.unregisterAll();
+        try {
+            onBeforeQuit?.();
+        }
+        catch (err) {
+            console.error('[lifecycle] onBeforeQuit handler threw:', err);
+        }
     });
 }
 //# sourceMappingURL=lifecycle.js.map