@dimina-kit/devtools 0.3.1-dev.20260513123738 → 0.3.1-dev.20260517100756

package/dist/main/app/app.js

@@ -8,11 +8,12 @@ import { createMainWindow, wireMainWindowEvents } from '../windows/main-window/i
 import { createWorkbenchContext } from '../services/workbench-context.js';
 import { loadWorkbenchSettings, applyTheme } from '../services/settings/index.js';
 import { installAppMenu } from '../menu/index.js';
-import { registerAppIpc, registerSimulatorIpc, registerPanelsIpc, registerPopoverIpc, registerProjectsIpc, registerSessionIpc, registerSettingsIpc, registerToolbarIpc, } from '../ipc/index.js';
+import { registerAppIpc, popoverModule, projectsModule, sessionModule, settingsModule, simulatorModule, } from '../ipc/index.js';
 import { startAutomationServer } from '../services/automation/index.js';
 import { startMcpServer } from '../services/mcp/index.js';
 import { setupSimulatorStorage } from '../services/simulator-storage/index.js';
 import { UpdateManager } from '../services/update/index.js';
+import { toDisposable } from '../utils/disposable.js';
 const DEFAULT_MODULES = {
     projects: true,
     session: true,
@@ -20,16 +21,12 @@ const DEFAULT_MODULES = {
     popover: true,
     settings: true,
 };
-const MODULE_REGISTRARS = {
-    projects: registerProjectsIpc,
-    session: registerSessionIpc,
-    simulator: (ctx) => {
-        registerSimulatorIpc(ctx);
-        registerPanelsIpc(ctx);
-        registerToolbarIpc(ctx);
-    },
-    popover: registerPopoverIpc,
-    settings: registerSettingsIpc,
+const BUILTIN_MODULES = {
+    projects: projectsModule,
+    session: sessionModule,
+    simulator: simulatorModule,
+    popover: popoverModule,
+    settings: settingsModule,
 };
 /** Parse --auto, --auto-port, --project from process.argv. */
 function parseAutoArgs() {
@@ -58,9 +55,11 @@ function resolveModules(config) {
         ...config.modules,
     };
 }
-async function disposeContext(ctx, updateManager) {
-    updateManager?.dispose();
+async function disposeContext(ctx) {
     await ctx.workspace.closeProject();
+    await ctx.registry.dispose().catch((err) => {
+        console.warn('[workbench] dispose registry encountered errors:', err);
+    });
 }
 function createConfiguredMainWindow(config, rendererDir) {
     const mainWindow = createMainWindow({
@@ -70,6 +69,11 @@ function createConfiguredMainWindow(config, rendererDir) {
         height: config.window?.height,
         minWidth: config.window?.minWidth,
         minHeight: config.window?.minHeight,
+        // P1: pass the same preload path the workbench context stores on
+        // ctx.preloadPath so hosts that ship a custom simulator preload are the
+        // ones registered on the persist:simulator session — otherwise the
+        // backstop wouldn't be the host's script.
+        simulatorPreloadPath: config.preloadPath ?? defaultPreloadPath,
     });
     // Set window/taskbar icon if provided (Linux/Windows; macOS uses app bundle icon)
     if (config.icon) {
@@ -96,7 +100,7 @@ function registerBuiltinModules(config, context) {
     const modules = resolveModules(config);
     Object.keys(modules).forEach((moduleId) => {
         if (modules[moduleId])
-            MODULE_REGISTRARS[moduleId](context);
+            context.registry.add(BUILTIN_MODULES[moduleId].setup(context));
     });
 }
 function installMenu(config, mainWindow, context) {
@@ -114,6 +118,7 @@ async function setupAutomation(instance) {
     if (autoArgs.auto) {
         const server = await startAutomationServer(instance.context, autoArgs.autoPort);
         instance.automationServer = server;
+        instance.context.registry.add(() => server.close());
         // Stable, parseable line for e2e harnesses that scrape stdout.
         console.log(`[automation] listening on ws://127.0.0.1:${server.port}`);
     }
@@ -121,42 +126,56 @@ async function setupAutomation(instance) {
 function setupMcp() {
     const settings = loadWorkbenchSettings();
     if (!settings.mcp.enabled)
-        return;
+        return null;
     const cdpPortSwitch = app.commandLine.getSwitchValue('remote-debugging-port');
     const cdpPort = cdpPortSwitch ? parseInt(cdpPortSwitch, 10) : settings.cdp.port;
-    startMcpServer(cdpPort, settings.mcp.port);
+    return startMcpServer(cdpPort, settings.mcp.port);
 }
 function wireAppWindowEvents(config, instance) {
     const { mainWindow, context } = instance;
-    wireMainWindowEvents(mainWindow, {
+    return wireMainWindowEvents(mainWindow, {
         context,
         onResize: () => context.views.repositionAll(),
         onClose: async (e) => {
             if (!context.workspace.hasActiveSession())
                 return;
+            // Close button while a project session is open: stay in the workbench
+            // and surface the project list. Tear down only the session — do NOT
+            // dispose `context.registry`, which owns every IPC handler (projects,
+            // dialog, settings…). Disposing it would leave the renderer alive but
+            // unable to invoke anything, so subsequent clicks on Import/etc. would
+            // raise `No handler registered for ...`.
             e.preventDefault();
             if (config.onBeforeClose) {
                 await config.onBeforeClose(instance);
             }
-            await disposeContext(context);
+            await context.workspace.closeProject();
             context.notify.windowNavigateBack();
         },
     });
 }
 function enableDevRendererAutoReload(rendererDir) {
     // Auto-reload renderer windows when dist files change during development
-    if (!app.isPackaged) {
-        let reloadTimer = null;
-        fs.watch(rendererDir, { recursive: true }, () => {
-            if (reloadTimer)
-                clearTimeout(reloadTimer);
-            reloadTimer = setTimeout(() => {
-                for (const win of BrowserWindow.getAllWindows()) {
-                    win.webContents.reload();
-                }
-            }, 300);
-        });
+    if (app.isPackaged) {
+        return toDisposable(() => { });
     }
+    let reloadTimer = null;
+    const watcher = fs.watch(rendererDir, { recursive: true }, () => {
+        if (reloadTimer)
+            clearTimeout(reloadTimer);
+        reloadTimer = setTimeout(() => {
+            for (const win of BrowserWindow.getAllWindows()) {
+                win.webContents.reload();
+            }
+        }, 300);
+    });
+    return toDisposable(() => {
+        if (reloadTimer) {
+            clearTimeout(reloadTimer);
+            reloadTimer = null;
+        }
+        watcher.close();
+    });
 }
 export function createWorkbenchApp(config = {}) {
     let setupPromise = null;
@@ -170,13 +189,13 @@ export function createWorkbenchApp(config = {}) {
             const rendererDir = config.rendererDir ?? defaultRendererDir;
             const mainWindow = createConfiguredMainWindow(config, rendererDir);
             const context = createContext(config, mainWindow, rendererDir);
-            registerAppIpc(context);
+            context.registry.add(registerAppIpc(context));
             registerBuiltinModules(config, context);
             installMenu(config, mainWindow, context);
             const instance = {
                 mainWindow,
                 context,
-                dispose: () => disposeContext(context, instance.updateManager),
+                dispose: () => disposeContext(context),
             };
             if (config.onSetup) {
                 await config.onSetup(instance);
@@ -189,22 +208,38 @@ export function createWorkbenchApp(config = {}) {
                     initialDelay: config.updateOptions?.initialDelay,
                     getCurrentVersion: config.updateOptions?.getCurrentVersion,
                 });
+                context.registry.add(() => instance.updateManager.dispose());
             }
             await setupAutomation(instance);
-            setupMcp();
-            setupSimulatorStorage(mainWindow.webContents);
-            wireAppWindowEvents(config, instance);
-            enableDevRendererAutoReload(rendererDir);
+            const mcp = setupMcp();
+            if (mcp)
+                context.registry.add(mcp);
+            context.registry.add(setupSimulatorStorage(mainWindow.webContents, {
+                senderPolicy: context.senderPolicy,
+                // Per-project filter for the simulator-storage panel: the simulator
+                // uses a fixed `persist:simulator` partition + a fixed simulator.html
+                // origin, so localStorage is shared across every project that has
+                // ever opened. The dimina runtime isolates writes with `${appId}_`
+                // prefixes; this callback lets the storage panel filter the CDP
+                // snapshot/event stream to the active appId.
+                getActiveAppId: () => {
+                    const session = context.workspace.getSession();
+                    const appInfo = session?.appInfo;
+                    return appInfo?.appId ?? null;
+                },
+            }));
+            context.registry.add(wireAppWindowEvents(config, instance));
+            context.registry.add(enableDevRendererAutoReload(rendererDir));
             return instance;
         });
         return setupPromise;
     }
     function start() {
-        void setup();
         if (!appEventsRegistered) {
             appEventsRegistered = true;
             registerAppLifecycle();
         }
+        return setup().then(() => undefined);
     }
     return {
         setup,

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

@@ -4,7 +4,7 @@ import type { WorkbenchContext } from '../services/workbench-context.js';
  * Convenience launcher for the default full-featured app.
  * Use createWorkbenchApp() when you want to customize modules or window setup.
  */
-export declare function launch(config?: WorkbenchConfig): void;
+export declare function launch(config?: WorkbenchConfig): Promise<void>;
 export declare function buildDefaultMenu(ctx: WorkbenchContext): void;
-export declare function openSettingsWindow(ctx: Pick<WorkbenchContext, 'workbenchSettingsWindow' | 'mainWindow' | 'rendererDir' | 'notify'>): Promise<void>;
+export declare function openSettingsWindow(ctx: Pick<WorkbenchContext, 'workbenchSettingsWindow' | 'mainWindow' | 'rendererDir' | 'notify' | 'windows'>): Promise<void>;
 //# sourceMappingURL=launch.d.ts.map

package/dist/main/app/launch.js

@@ -7,16 +7,19 @@ import { loadWorkbenchSettings } from '../services/settings/index.js';
  * Use createWorkbenchApp() when you want to customize modules or window setup.
  */
 export function launch(config = {}) {
-    createWorkbenchApp(config).start();
+    return createWorkbenchApp(config).start();
 }
 export function buildDefaultMenu(ctx) {
     installAppMenu(ctx);
 }
 export async function openSettingsWindow(ctx) {
     if (!ctx.workbenchSettingsWindow || ctx.workbenchSettingsWindow.isDestroyed()) {
-        ctx.workbenchSettingsWindow = await createSettingsWindow(ctx.mainWindow, ctx.rendererDir);
-        wireSettingsWindowEvents(ctx.workbenchSettingsWindow, () => {
+        const win = await createSettingsWindow(ctx.mainWindow, ctx.rendererDir);
+        ctx.workbenchSettingsWindow = win;
+        ctx.windows.setSettingsWindow(win);
+        wireSettingsWindowEvents(win, () => {
             ctx.workbenchSettingsWindow = null;
+            ctx.windows.setSettingsWindow(null);
         });
     }
     ctx.workbenchSettingsWindow.show();