@dimina-kit/devtools 0.3.1 → 0.3.2-dev.20260522085907

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

@@ -1,3 +1,4 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
-export declare function registerAppIpc(ctx: Pick<WorkbenchContext, 'preloadPath' | 'brandingProvider' | 'appName'>): void;
+import type { Disposable } from '../utils/disposable.js';
+export declare function registerAppIpc(ctx: Pick<WorkbenchContext, 'preloadPath' | 'brandingProvider' | 'appName' | 'senderPolicy'>): Disposable;
 //# sourceMappingURL=app.d.ts.map

package/dist/main/ipc/app.js

@@ -1,11 +1,12 @@
-import { ipcMain } from 'electron';
 import fs from 'fs';
 import { AppChannel } from '../../shared/ipc-channels.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
 export function registerAppIpc(ctx) {
-    ipcMain.handle(AppChannel.GetPreloadPath, () => {
+    return new IpcRegistry(ctx.senderPolicy)
+        .handle(AppChannel.GetPreloadPath, () => {
         return `file://${fs.realpathSync(ctx.preloadPath)}`;
-    });
-    ipcMain.handle(AppChannel.GetBranding, async () => {
+    })
+        .handle(AppChannel.GetBranding, async () => {
         if (ctx.brandingProvider)
             return ctx.brandingProvider();
         return { appName: ctx.appName };

package/dist/main/ipc/index.d.ts

@@ -1,9 +1,10 @@
 export { registerAppIpc } from './app.js';
 export { registerSimulatorIpc } from './simulator.js';
 export { registerPanelsIpc } from './panels.js';
-export { registerPopoverIpc } from './popover.js';
-export { registerProjectsIpc } from './projects.js';
-export { registerSessionIpc } from './session.js';
-export { registerSettingsIpc } from './settings.js';
+export { registerPopoverIpc, popoverModule } from './popover.js';
+export { registerProjectsIpc, projectsModule } from './projects.js';
+export { registerSessionIpc, sessionModule } from './session.js';
+export { registerSettingsIpc, settingsModule } from './settings.js';
 export { registerToolbarIpc } from './toolbar.js';
+export { simulatorModule } from './simulator-module.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/main/ipc/index.js

@@ -1,9 +1,10 @@
 export { registerAppIpc } from './app.js';
 export { registerSimulatorIpc } from './simulator.js';
 export { registerPanelsIpc } from './panels.js';
-export { registerPopoverIpc } from './popover.js';
-export { registerProjectsIpc } from './projects.js';
-export { registerSessionIpc } from './session.js';
-export { registerSettingsIpc } from './settings.js';
+export { registerPopoverIpc, popoverModule } from './popover.js';
+export { registerProjectsIpc, projectsModule } from './projects.js';
+export { registerSessionIpc, sessionModule } from './session.js';
+export { registerSettingsIpc, settingsModule } from './settings.js';
 export { registerToolbarIpc } from './toolbar.js';
+export { simulatorModule } from './simulator-module.js';
 //# sourceMappingURL=index.js.map

package/dist/main/ipc/panels.d.ts

@@ -1,3 +1,4 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
-export declare function registerPanelsIpc(ctx: Pick<WorkbenchContext, 'panels' | 'views' | 'workspace'>): void;
+import type { Disposable } from '../utils/disposable.js';
+export declare function registerPanelsIpc(ctx: Pick<WorkbenchContext, 'panels' | 'views' | 'workspace' | 'senderPolicy'>): Disposable;
 //# sourceMappingURL=panels.d.ts.map

package/dist/main/ipc/panels.js

@@ -1,21 +1,24 @@
-import { ipcMain, webContents } from 'electron';
 import { PanelChannel } from '../../shared/ipc-channels.js';
+import { PanelEvalSchema, PanelSelectSchema, } from '../../shared/ipc-schemas.js';
+import { validate } from '../utils/ipc-schema.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
 const BUILTIN_PANELS = [
     { id: 'wxml', label: 'WXML' },
     { id: 'appdata', label: 'AppData' },
     { id: 'storage', label: 'Storage' },
 ];
 export function registerPanelsIpc(ctx) {
-    ipcMain.handle(PanelChannel.List, () => {
+    return new IpcRegistry(ctx.senderPolicy)
+        .handle(PanelChannel.List, () => {
         return BUILTIN_PANELS
             .filter((p) => ctx.panels.includes(p.id));
-    });
-    ipcMain.handle(PanelChannel.Eval, async (_, expression) => {
-        const simWcId = ctx.views.getSimulatorWebContentsId();
-        if (!ctx.workspace.hasActiveSession() || simWcId == null)
+    })
+        .handle(PanelChannel.Eval, async (_event, ...args) => {
+        const [expression] = validate(PanelChannel.Eval, PanelEvalSchema, args);
+        if (!ctx.workspace.hasActiveSession())
             return undefined;
-        const sim = webContents.fromId(simWcId);
-        if (!sim || sim.isDestroyed())
+        const sim = ctx.views.getSimulatorWebContents();
+        if (!sim)
             return undefined;
         try {
             return await sim.executeJavaScript(expression);
@@ -23,14 +26,14 @@ export function registerPanelsIpc(ctx) {
         catch {
             return undefined;
         }
-    });
-    ipcMain.handle(PanelChannel.Select, (_event, _panelId) => {
-        // Hide the simulator overlay when switching to a built-in panel
+    })
+        .handle(PanelChannel.Select, (_event, ...args) => {
+        validate(PanelChannel.Select, PanelSelectSchema, args);
         if (ctx.views.hasSimulatorView() && ctx.views.isSimulatorAdded()) {
             ctx.views.hideSimulator();
         }
-    });
-    ipcMain.handle(PanelChannel.SelectSimulator, () => {
+    })
+        .handle(PanelChannel.SelectSimulator, () => {
         if (ctx.views.hasSimulatorView() && !ctx.views.isSimulatorAdded()) {
             ctx.views.showSimulator(ctx.views.getLastSimWidth());
         }

package/dist/main/ipc/popover.d.ts

@@ -1,3 +1,6 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
-export declare function registerPopoverIpc(ctx: Pick<WorkbenchContext, 'views' | 'notify'>): void;
+import type { WorkbenchModule } from '../services/module.js';
+import type { Disposable } from '../utils/disposable.js';
+export declare function registerPopoverIpc(ctx: Pick<WorkbenchContext, 'views' | 'notify' | 'senderPolicy'>): Disposable;
+export declare const popoverModule: WorkbenchModule;
 //# sourceMappingURL=popover.d.ts.map

package/dist/main/ipc/popover.js

@@ -1,13 +1,23 @@
-import { ipcMain } from 'electron';
 import { PopoverChannel } from '../../shared/ipc-channels.js';
+import { PopoverShowSchema, PopoverRelaunchSchema, } from '../../shared/ipc-schemas.js';
+import { validate } from '../utils/ipc-schema.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
 export function registerPopoverIpc(ctx) {
-    ipcMain.handle(PopoverChannel.Show, (_event, data) => {
+    return new IpcRegistry(ctx.senderPolicy)
+        .handle(PopoverChannel.Show, (_event, ...args) => {
+        const [data] = validate(PopoverChannel.Show, PopoverShowSchema, args);
         ctx.views.showPopover(data);
-    });
-    ipcMain.handle(PopoverChannel.Hide, () => ctx.views.hidePopover());
-    ipcMain.on(PopoverChannel.Relaunch, (_, newConfig) => {
+    })
+        .handle(PopoverChannel.Hide, () => {
+        ctx.views.hidePopover();
+    })
+        .on(PopoverChannel.Relaunch, (_event, ...args) => {
+        const [newConfig] = validate(PopoverChannel.Relaunch, PopoverRelaunchSchema, args);
         ctx.views.hidePopover();
         ctx.notify.popoverRelaunch(newConfig);
     });
 }
+export const popoverModule = {
+    setup: (ctx) => registerPopoverIpc(ctx),
+};
 //# sourceMappingURL=popover.js.map

package/dist/main/ipc/projects.d.ts

@@ -1,3 +1,8 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
-export declare function registerProjectsIpc(ctx: Pick<WorkbenchContext, 'workspace' | 'mainWindow'>): void;
+import type { WorkbenchModule } from '../services/module.js';
+import type { Disposable } from '../utils/disposable.js';
+type ProjectsIpcCtx = Pick<WorkbenchContext, 'workspace' | 'windows' | 'senderPolicy' | 'projectsProvider' | 'projectTemplates' | 'customCreateProjectDialog'>;
+export declare function registerProjectsIpc(ctx: ProjectsIpcCtx): Disposable;
+export declare const projectsModule: WorkbenchModule;
+export {};
 //# sourceMappingURL=projects.d.ts.map

package/dist/main/ipc/projects.js

@@ -1,15 +1,136 @@
-import { ipcMain, dialog } from 'electron';
+import { app, dialog } from 'electron';
+import path from 'path';
 import { ProjectsChannel, DialogChannel } from '../../shared/ipc-channels.js';
+import { ProjectsAddSchema, ProjectsRemoveSchema, } from '../../shared/ipc-schemas.js';
+import { validate } from '../utils/ipc-schema.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
+import { sanitizeTemplates } from '../services/projects/templates.js';
+import { createProject } from '../services/projects/create-project-service.js';
+import { loadWorkbenchSettings, saveWorkbenchSettings, } from '../services/settings/index.js';
 export function registerProjectsIpc(ctx) {
-    ipcMain.handle(ProjectsChannel.List, () => ctx.workspace.listProjects());
-    ipcMain.handle(DialogChannel.OpenDirectory, async () => {
-        const result = await dialog.showOpenDialog(ctx.mainWindow, {
+    return new IpcRegistry(ctx.senderPolicy)
+        .handle(ProjectsChannel.List, () => {
+        return ctx.workspace.listProjects();
+    })
+        .handle(DialogChannel.OpenDirectory, async () => {
+        const result = await dialog.showOpenDialog(ctx.windows.mainWindow, {
             properties: ['openDirectory'],
             title: '选择小程序项目目录',
         });
         return result.canceled ? null : result.filePaths[0];
+    })
+        .handle(ProjectsChannel.Add, async (_event, ...args) => {
+        const [dirPath] = validate(ProjectsChannel.Add, ProjectsAddSchema, args);
+        const dirError = await ctx.workspace.validateProjectDir(dirPath);
+        if (dirError) {
+            await dialog.showMessageBox(ctx.windows.mainWindow, {
+                type: 'error',
+                title: '无法导入项目',
+                message: '该目录不是有效的小程序项目',
+                detail: dirError,
+                buttons: ['确定'],
+            });
+            throw new Error(dirError);
+        }
+        const duplicate = await ctx.workspace.hasProject(dirPath);
+        const project = await ctx.workspace.addProject(dirPath);
+        if (duplicate) {
+            await dialog.showMessageBox(ctx.windows.mainWindow, {
+                type: 'info',
+                title: '项目已存在',
+                message: '该项目已在列表中',
+                detail: dirPath,
+                buttons: ['确定'],
+            });
+        }
+        return project;
+    })
+        .handle(ProjectsChannel.Remove, (_event, ...args) => {
+        const [dirPath] = validate(ProjectsChannel.Remove, ProjectsRemoveSchema, args);
+        return ctx.workspace.removeProject(dirPath);
+    })
+        // ── Phase 3: template catalog + create flow ──
+        .handle(ProjectsChannel.ListTemplates, () => {
+        // Sanitize at the IPC boundary: `generate` is a function and the
+        // structured-clone algorithm Electron uses for invoke would otherwise
+        // throw "could not be cloned" before the renderer ever sees it.
+        return sanitizeTemplates(ctx.projectTemplates ?? []);
+    })
+        .handle(ProjectsChannel.OpenCreateDialog, async () => {
+        if (!ctx.customCreateProjectDialog)
+            return null;
+        const sanitized = sanitizeTemplates(ctx.projectTemplates ?? []);
+        return await ctx.customCreateProjectDialog({
+            parentWindow: ctx.windows.mainWindow,
+            templates: sanitized,
+        });
+    })
+        .handle(ProjectsChannel.Create, async (_event, ...args) => {
+        // We deliberately don't run this through zod yet — the input shape is
+        // wide (any template can stash arbitrary `extra` fields) and the
+        // service does its own per-field validation. Bound size to keep this
+        // a cheap DoS guard.
+        const [raw] = args;
+        if (!raw || typeof raw !== 'object') {
+            throw new Error('projects:create expects a CreateProjectInput object');
+        }
+        const input = raw;
+        let project;
+        try {
+            project = await createProject(input, {
+                templates: ctx.projectTemplates ?? [],
+                projectsProvider: ctx.projectsProvider,
+            });
+        }
+        catch (err) {
+            // Mirror the Add flow: surface scaffold failures (invalid name,
+            // non-empty target dir, missing template, remote backend reject,
+            // …) as a native dialog so users see *why* the create silently
+            // fizzled. The renderer's catch then just bails out.
+            await dialog.showMessageBox(ctx.windows.mainWindow, {
+                type: 'error',
+                title: '创建项目失败',
+                message: '无法创建项目',
+                detail: err instanceof Error ? err.message : String(err),
+                buttons: ['确定'],
+            });
+            throw err;
+        }
+        // Remember the parent of the just-created project so the next open of
+        // the create dialog pre-fills its directory under the same workspace.
+        try {
+            const settings = loadWorkbenchSettings();
+            const newBase = path.dirname(input.path);
+            if (newBase && settings.lastCreateBaseDir !== newBase) {
+                saveWorkbenchSettings({ ...settings, lastCreateBaseDir: newBase });
+            }
+        }
+        catch (err) {
+            console.warn('[projects:create] failed to persist lastCreateBaseDir', err);
+        }
+        return project;
+    })
+        .handle(ProjectsChannel.GetCreateDefaults, () => {
+        // Fallback chain: persisted last parent → user's Documents → home.
+        // Documents covers the common "我把项目都放在 Documents/ 下" case for
+        // first-time users on macOS; home is just a safe final fallback.
+        const settings = loadWorkbenchSettings();
+        const baseDir = settings.lastCreateBaseDir ??
+            safeAppPath('documents') ??
+            safeAppPath('home') ??
+            '';
+        return { baseDir };
     });
-    ipcMain.handle(ProjectsChannel.Add, (_, dirPath) => ctx.workspace.addProject(dirPath));
-    ipcMain.handle(ProjectsChannel.Remove, (_, dirPath) => ctx.workspace.removeProject(dirPath));
 }
+function safeAppPath(name) {
+    try {
+        return app.getPath(name);
+    }
+    catch {
+        return null;
+    }
+}
+export const projectsModule = {
+    setup: (ctx) => registerProjectsIpc(ctx),
+};
 //# sourceMappingURL=projects.js.map

package/dist/main/ipc/session.d.ts

@@ -1,3 +1,6 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
-export declare function registerSessionIpc(ctx: Pick<WorkbenchContext, 'workspace'>): void;
+import type { WorkbenchModule } from '../services/module.js';
+import type { Disposable } from '../utils/disposable.js';
+export declare function registerSessionIpc(ctx: Pick<WorkbenchContext, 'workspace' | 'senderPolicy'>): Disposable;
+export declare const sessionModule: WorkbenchModule;
 //# sourceMappingURL=session.d.ts.map

package/dist/main/ipc/session.js

@@ -1,10 +1,38 @@
-import { ipcMain } from 'electron';
 import { ProjectChannel } from '../../shared/ipc-channels.js';
+import { ProjectCaptureThumbnailSchema, ProjectGetCompileConfigSchema, ProjectGetPagesSchema, ProjectGetThumbnailSchema, ProjectOpenSchema, ProjectSaveCompileConfigSchema, } from '../../shared/ipc-schemas.js';
+import { validate } from '../utils/ipc-schema.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
 export function registerSessionIpc(ctx) {
-    ipcMain.handle(ProjectChannel.Open, (_, projectPath) => ctx.workspace.openProject(projectPath));
-    ipcMain.handle(ProjectChannel.GetPages, (_, projectPath) => ctx.workspace.getProjectPages(projectPath));
-    ipcMain.handle(ProjectChannel.GetCompileConfig, (_, projectPath) => ctx.workspace.getCompileConfig(projectPath));
-    ipcMain.handle(ProjectChannel.SaveCompileConfig, (_, projectPath, config) => ctx.workspace.saveCompileConfig(projectPath, config));
-    ipcMain.handle(ProjectChannel.Close, () => ctx.workspace.closeProject());
+    return new IpcRegistry(ctx.senderPolicy)
+        .handle(ProjectChannel.Open, (_, ...args) => {
+        const [projectPath] = validate(ProjectChannel.Open, ProjectOpenSchema, args);
+        return ctx.workspace.openProject(projectPath);
+    })
+        .handle(ProjectChannel.GetPages, (_, ...args) => {
+        const [projectPath] = validate(ProjectChannel.GetPages, ProjectGetPagesSchema, args);
+        return ctx.workspace.getProjectPages(projectPath);
+    })
+        .handle(ProjectChannel.GetCompileConfig, (_, ...args) => {
+        const [projectPath] = validate(ProjectChannel.GetCompileConfig, ProjectGetCompileConfigSchema, args);
+        return ctx.workspace.getCompileConfig(projectPath);
+    })
+        .handle(ProjectChannel.SaveCompileConfig, (_, ...args) => {
+        const [projectPath, config] = validate(ProjectChannel.SaveCompileConfig, ProjectSaveCompileConfigSchema, args);
+        return ctx.workspace.saveCompileConfig(projectPath, config);
+    })
+        .handle(ProjectChannel.Close, () => {
+        return ctx.workspace.closeProject();
+    })
+        .handle(ProjectChannel.CaptureThumbnail, (_, ...args) => {
+        const [projectPath] = validate(ProjectChannel.CaptureThumbnail, ProjectCaptureThumbnailSchema, args);
+        return ctx.workspace.captureThumbnail(projectPath);
+    })
+        .handle(ProjectChannel.GetThumbnail, (_, ...args) => {
+        const [projectPath] = validate(ProjectChannel.GetThumbnail, ProjectGetThumbnailSchema, args);
+        return ctx.workspace.getThumbnail(projectPath);
+    });
 }
+export const sessionModule = {
+    setup: (ctx) => registerSessionIpc(ctx),
+};
 //# sourceMappingURL=session.js.map

package/dist/main/ipc/settings.d.ts

@@ -1,3 +1,6 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
-export declare function registerSettingsIpc(ctx: Pick<WorkbenchContext, 'workbenchSettingsWindow' | 'views' | 'notify' | 'workspace' | 'mainWindow' | 'rendererDir'>): void;
+import type { Disposable } from '../utils/disposable.js';
+import type { WorkbenchModule } from '../services/module.js';
+export declare function registerSettingsIpc(ctx: Pick<WorkbenchContext, 'views' | 'notify' | 'workspace' | 'rendererDir' | 'senderPolicy' | 'windows'>): Disposable;
+export declare const settingsModule: WorkbenchModule;
 //# sourceMappingURL=settings.d.ts.map

package/dist/main/ipc/settings.js

@@ -1,23 +1,31 @@
-import { app, ipcMain } from 'electron';
+import { app } from 'electron';
 import { openSettingsWindow } from '../app/launch.js';
 import { loadWorkbenchSettings, saveWorkbenchSettings, applyTheme, } from '../services/settings/index.js';
 import { WorkbenchSettingsChannel, SettingsChannel } from '../../shared/ipc-channels.js';
+import { DEFAULT_CDP_PORT } from '../../shared/constants.js';
+import { getMcpStatus } from '../services/mcp/status.js';
+import { SettingsConfigChangedSchema, SettingsProjectSettingsChangedSchema, SettingsSetVisibleSchema, WorkbenchSettingsSaveSchema, WorkbenchSettingsSetThemeSchema, WorkbenchSettingsSetVisibleSchema, } from '../../shared/ipc-schemas.js';
+import { validate } from '../utils/ipc-schema.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
 export function registerSettingsIpc(ctx) {
-    ipcMain.handle(WorkbenchSettingsChannel.Get, () => {
+    return new IpcRegistry(ctx.senderPolicy)
+        .handle(WorkbenchSettingsChannel.Get, () => {
         return loadWorkbenchSettings();
-    });
-    ipcMain.handle(WorkbenchSettingsChannel.Save, (_, settings) => {
+    })
+        .handle(WorkbenchSettingsChannel.Save, (_, ...args) => {
+        const [settings] = validate(WorkbenchSettingsChannel.Save, WorkbenchSettingsSaveSchema, args);
         saveWorkbenchSettings(settings);
         applyTheme(settings.theme ?? 'system');
         return { success: true };
-    });
-    ipcMain.handle(WorkbenchSettingsChannel.SetTheme, (_, theme) => {
+    })
+        .handle(WorkbenchSettingsChannel.SetTheme, (_, ...args) => {
+        const [theme] = validate(WorkbenchSettingsChannel.SetTheme, WorkbenchSettingsSetThemeSchema, args);
         applyTheme(theme);
-    });
-    ipcMain.handle(WorkbenchSettingsChannel.GetCdpStatus, () => {
+    })
+        .handle(WorkbenchSettingsChannel.GetCdpStatus, () => {
         const settings = loadWorkbenchSettings();
         const switchValue = app.commandLine.getSwitchValue('remote-debugging-port');
-        const implicitDevDefault = !app.isPackaged && !settings.cdp.enabled && switchValue === '9222';
+        const implicitDevDefault = !app.isPackaged && !settings.cdp.enabled && switchValue === String(DEFAULT_CDP_PORT);
         return {
             configured: settings.cdp.enabled,
             port: settings.cdp.port,
@@ -25,37 +33,57 @@ export function registerSettingsIpc(ctx) {
             activePort: switchValue ? parseInt(switchValue, 10) : null,
             implicitDevDefault,
         };
-    });
-    ipcMain.handle(WorkbenchSettingsChannel.SetVisible, async (_, visible) => {
+    })
+        .handle(WorkbenchSettingsChannel.GetMcpStatus, () => {
+        const settings = loadWorkbenchSettings();
+        const runtime = getMcpStatus();
+        return {
+            configured: settings.mcp.enabled,
+            configuredPort: settings.mcp.port,
+            running: runtime.running,
+            activePort: runtime.port,
+            error: runtime.error,
+        };
+    })
+        .handle(WorkbenchSettingsChannel.SetVisible, async (_, ...args) => {
+        const [visible] = validate(WorkbenchSettingsChannel.SetVisible, WorkbenchSettingsSetVisibleSchema, args);
         if (visible) {
             await openSettingsWindow(ctx);
         }
         else {
-            ctx.workbenchSettingsWindow?.close();
+            ctx.windows.closeSettingsWindow();
         }
-    });
-    ipcMain.handle(SettingsChannel.SetVisible, async (_, visible) => {
+    })
+        .handle(SettingsChannel.SetVisible, async (_, ...args) => {
+        const [visible] = validate(SettingsChannel.SetVisible, SettingsSetVisibleSchema, args);
         if (visible) {
             await ctx.views.showSettings();
+            const projectPath = ctx.workspace.getProjectPath();
             ctx.notify.settingsInit({
-                projectPath: ctx.workspace.getProjectPath(),
-                config: ctx.workspace.getCompileConfig(ctx.workspace.getProjectPath()),
-                projectSettings: ctx.workspace.getProjectSettings(ctx.workspace.getProjectPath()),
+                projectPath,
+                config: await ctx.workspace.getCompileConfig(projectPath),
+                projectSettings: ctx.workspace.getProjectSettings(projectPath),
             });
         }
         else {
             ctx.views.hideSettings();
             ctx.notify.settingsClosed();
         }
-    });
-    ipcMain.on(SettingsChannel.ConfigChanged, (_, config) => {
-        if (ctx.workspace.getProjectPath()) {
-            ctx.workspace.saveCompileConfig(ctx.workspace.getProjectPath(), config);
+    })
+        .on(SettingsChannel.ConfigChanged, async (_, ...args) => {
+        const [config] = validate(SettingsChannel.ConfigChanged, SettingsConfigChangedSchema, args);
+        const projectPath = ctx.workspace.getProjectPath();
+        if (projectPath) {
+            await ctx.workspace.saveCompileConfig(projectPath, config);
         }
         ctx.notify.settingsChanged(config);
-    });
-    ipcMain.on(SettingsChannel.ProjectSettingsChanged, (_, patch) => {
+    })
+        .on(SettingsChannel.ProjectSettingsChanged, (_, ...args) => {
+        const [patch] = validate(SettingsChannel.ProjectSettingsChanged, SettingsProjectSettingsChangedSchema, args);
         ctx.workspace.updateProjectSettings(ctx.workspace.getProjectPath(), patch);
     });
 }
+export const settingsModule = {
+    setup: (ctx) => registerSettingsIpc(ctx),
+};
 //# sourceMappingURL=settings.js.map

package/dist/main/ipc/simulator-module.d.ts

@@ -0,0 +1,8 @@
+import type { WorkbenchModule } from '../services/module.js';
+/**
+ * The 'simulator' built-in module fans out into three IPC registrars
+ * (core simulator, panels, toolbar). Bundle them under a single module
+ * so app.ts only sees one entry per BuiltinModuleId.
+ */
+export declare const simulatorModule: WorkbenchModule;
+//# sourceMappingURL=simulator-module.d.ts.map

package/dist/main/ipc/simulator-module.js

@@ -0,0 +1,19 @@
+import { DisposableRegistry } from '../utils/disposable.js';
+import { registerSimulatorIpc } from './simulator.js';
+import { registerPanelsIpc } from './panels.js';
+import { registerToolbarIpc } from './toolbar.js';
+/**
+ * The 'simulator' built-in module fans out into three IPC registrars
+ * (core simulator, panels, toolbar). Bundle them under a single module
+ * so app.ts only sees one entry per BuiltinModuleId.
+ */
+export const simulatorModule = {
+    setup: (ctx) => {
+        const reg = new DisposableRegistry();
+        reg.add(registerSimulatorIpc(ctx));
+        reg.add(registerPanelsIpc(ctx));
+        reg.add(registerToolbarIpc(ctx));
+        return reg;
+    },
+};
+//# sourceMappingURL=simulator-module.js.map

package/dist/main/ipc/simulator.d.ts

@@ -1,3 +1,4 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
-export declare function registerSimulatorIpc(ctx: Pick<WorkbenchContext, 'views' | 'panels' | 'apiNamespaces' | 'notify'>): void;
+import type { Disposable } from '../utils/disposable.js';
+export declare function registerSimulatorIpc(ctx: Pick<WorkbenchContext, 'views' | 'notify' | 'senderPolicy'>): Disposable;
 //# sourceMappingURL=simulator.d.ts.map

package/dist/main/ipc/simulator.js

@@ -1,26 +1,31 @@
-import { ipcMain } from 'electron';
-import { SimulatorChannel, WorkbenchChannel } from '../../shared/ipc-channels.js';
+import { SimulatorChannel, SimulatorCustomApiChannel } from '../../shared/ipc-channels.js';
+import { SimulatorAttachSchema, SimulatorCustomApiInvokeSchema, SimulatorResizeSchema, SimulatorSetVisibleSchema, } from '../../shared/ipc-schemas.js';
+import { simulatorApiRegistry } from '../services/simulator/custom-apis.js';
+import { validate } from '../utils/ipc-schema.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
 export function registerSimulatorIpc(ctx) {
-    ipcMain.handle(SimulatorChannel.Attach, (_, simWcId, simWidth) => {
+    return new IpcRegistry(ctx.senderPolicy)
+        .handle(SimulatorChannel.Attach, (_, ...args) => {
+        const [simWcId, simWidth] = validate(SimulatorChannel.Attach, SimulatorAttachSchema, args);
         ctx.views.attachSimulator(simWcId, simWidth);
-    });
-    ipcMain.handle(SimulatorChannel.Detach, () => {
+    })
+        .handle(SimulatorChannel.Detach, () => {
         ctx.views.detachSimulator();
-    });
-    ipcMain.handle(SimulatorChannel.Resize, (_, simWidth) => {
+    })
+        .handle(SimulatorChannel.Resize, (_, ...args) => {
+        const [simWidth] = validate(SimulatorChannel.Resize, SimulatorResizeSchema, args);
         ctx.views.resize(simWidth);
-    });
-    ipcMain.handle(SimulatorChannel.SetVisible, (_, visible, simWidth) => {
+    })
+        .handle(SimulatorChannel.SetVisible, (_, ...args) => {
+        const [visible, simWidth] = validate(SimulatorChannel.SetVisible, SimulatorSetVisibleSchema, args);
         ctx.views.setVisible(visible, simWidth);
-    });
-    ipcMain.handle(WorkbenchChannel.GetPanelConfig, () => {
-        return ctx.panels;
-    });
-    ipcMain.handle(WorkbenchChannel.GetApiNamespaces, () => {
-        return ctx.apiNamespaces;
-    });
-    ipcMain.on(WorkbenchChannel.Reset, () => {
-        ctx.notify.workbenchReset();
+    })
+        .handle(SimulatorCustomApiChannel.List, () => {
+        return simulatorApiRegistry.list();
+    })
+        .handle(SimulatorCustomApiChannel.Invoke, (_, ...args) => {
+        const [name, params] = validate(SimulatorCustomApiChannel.Invoke, SimulatorCustomApiInvokeSchema, args);
+        return simulatorApiRegistry.invoke(name, params);
     });
 }
 //# sourceMappingURL=simulator.js.map

package/dist/main/ipc/toolbar.d.ts

@@ -1,3 +1,4 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
-export declare function registerToolbarIpc(ctx: Pick<WorkbenchContext, 'toolbarActions'>): void;
+import type { Disposable } from '../utils/disposable.js';
+export declare function registerToolbarIpc(ctx: Pick<WorkbenchContext, 'toolbarActions' | 'senderPolicy'>): Disposable;
 //# sourceMappingURL=toolbar.d.ts.map

package/dist/main/ipc/toolbar.js

@@ -1,7 +1,8 @@
-import { ipcMain } from 'electron';
 import { ToolbarChannel } from '../../shared/ipc-channels.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
 export function registerToolbarIpc(ctx) {
-    ipcMain.handle(ToolbarChannel.GetActions, async () => {
+    return new IpcRegistry(ctx.senderPolicy)
+        .handle(ToolbarChannel.GetActions, async () => {
         if (ctx.toolbarActions)
             return ctx.toolbarActions();
         return [];

package/dist/main/menu/index.js

@@ -23,6 +23,17 @@ export function installAppMenu(ctx) {
                 { role: 'quit' },
             ],
         },
+        {
+            label: '项目',
+            submenu: [
+                {
+                    label: '打开项目',
+                    click: () => {
+                        ctx.notify.windowNavigateBack();
+                    },
+                },
+            ],
+        },
         {
             label: '编辑',
             submenu: [

package/dist/main/services/automation/exec.d.ts

@@ -4,6 +4,8 @@ export declare function getSimulator(ctx: WorkbenchContext): Electron.WebContent
 export declare function evalInSim<T = unknown>(ctx: WorkbenchContext, expression: string): Promise<T>;
 /** Build JS that locates an element by selector+index inside the active page iframe. */
 export declare function buildElAccess(ref: ElementRef, varName?: string): string;
+/** Run `body` inside the active page iframe with `varName` bound to the element at `ref`. */
+export declare function evalInElement<T = unknown>(ctx: WorkbenchContext, ref: ElementRef, body: string, varName?: string): Promise<T>;
 /** Wrap code to run inside the active page iframe (last iframe in the stack). */
 export declare function inIframe(code: string): string;
 //# sourceMappingURL=exec.d.ts.map