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

package/dist/main/ipc/panels.js

@@ -1,4 +1,3 @@
-import { 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';
@@ -16,11 +15,10 @@ export function registerPanelsIpc(ctx) {
     })
         .handle(PanelChannel.Eval, async (_event, ...args) => {
         const [expression] = validate(PanelChannel.Eval, PanelEvalSchema, args);
-        const simWcId = ctx.views.getSimulatorWebContentsId();
-        if (!ctx.workspace.hasActiveSession() || simWcId == null)
+        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);

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

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

package/dist/main/ipc/projects.js

@@ -13,7 +13,7 @@ export function registerProjectsIpc(ctx) {
         return ctx.workspace.listProjects();
     })
         .handle(DialogChannel.OpenDirectory, async () => {
-        const result = await dialog.showOpenDialog(ctx.mainWindow, {
+        const result = await dialog.showOpenDialog(ctx.windows.mainWindow, {
             properties: ['openDirectory'],
             title: '选择小程序项目目录',
         });
@@ -23,7 +23,7 @@ export function registerProjectsIpc(ctx) {
         const [dirPath] = validate(ProjectsChannel.Add, ProjectsAddSchema, args);
         const dirError = await ctx.workspace.validateProjectDir(dirPath);
         if (dirError) {
-            await dialog.showMessageBox(ctx.mainWindow, {
+            await dialog.showMessageBox(ctx.windows.mainWindow, {
                 type: 'error',
                 title: '无法导入项目',
                 message: '该目录不是有效的小程序项目',
@@ -35,7 +35,7 @@ export function registerProjectsIpc(ctx) {
         const duplicate = await ctx.workspace.hasProject(dirPath);
         const project = await ctx.workspace.addProject(dirPath);
         if (duplicate) {
-            await dialog.showMessageBox(ctx.mainWindow, {
+            await dialog.showMessageBox(ctx.windows.mainWindow, {
                 type: 'info',
                 title: '项目已存在',
                 message: '该项目已在列表中',
@@ -61,7 +61,7 @@ export function registerProjectsIpc(ctx) {
             return null;
         const sanitized = sanitizeTemplates(ctx.projectTemplates ?? []);
         return await ctx.customCreateProjectDialog({
-            parentWindow: ctx.mainWindow,
+            parentWindow: ctx.windows.mainWindow,
             templates: sanitized,
         });
     })
@@ -87,7 +87,7 @@ export function registerProjectsIpc(ctx) {
             // 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.mainWindow, {
+            await dialog.showMessageBox(ctx.windows.mainWindow, {
                 type: 'error',
                 title: '创建项目失败',
                 message: '无法创建项目',

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

@@ -1,6 +1,6 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
 import type { Disposable } from '../utils/disposable.js';
 import type { WorkbenchModule } from '../services/module.js';
-export declare function registerSettingsIpc(ctx: Pick<WorkbenchContext, 'workbenchSettingsWindow' | 'views' | 'notify' | 'workspace' | 'mainWindow' | 'rendererDir' | 'senderPolicy' | 'windows'>): Disposable;
+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

@@ -2,6 +2,8 @@ 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';
@@ -23,7 +25,7 @@ export function registerSettingsIpc(ctx) {
         .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,
@@ -31,6 +33,17 @@ export function registerSettingsIpc(ctx) {
             activePort: switchValue ? parseInt(switchValue, 10) : null,
             implicitDevDefault,
         };
+    })
+        .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);

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

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

package/dist/main/ipc/simulator.js

@@ -1,4 +1,4 @@
-import { SimulatorChannel, SimulatorCustomApiChannel, 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';
@@ -26,15 +26,6 @@ export function registerSimulatorIpc(ctx) {
         .handle(SimulatorCustomApiChannel.Invoke, (_, ...args) => {
         const [name, params] = validate(SimulatorCustomApiChannel.Invoke, SimulatorCustomApiInvokeSchema, args);
         return simulatorApiRegistry.invoke(name, params);
-    })
-        .handle(WorkbenchChannel.GetPanelConfig, () => {
-        return ctx.panels;
-    })
-        .handle(WorkbenchChannel.GetApiNamespaces, () => {
-        return ctx.apiNamespaces;
-    })
-        .on(WorkbenchChannel.Reset, () => {
-        ctx.notify.workbenchReset();
     });
 }
 //# sourceMappingURL=simulator.js.map

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

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

@@ -1,13 +1,8 @@
-import { webContents } from 'electron';
 // ── Helpers ───────────────────────────────────────────────────────────
 export function getSimulator(ctx) {
-    const simWcId = ctx.views.getSimulatorWebContentsId();
-    if (!ctx.workspace.hasActiveSession() || simWcId == null)
+    if (!ctx.workspace.hasActiveSession())
         return null;
-    const sim = webContents.fromId(simWcId);
-    if (!sim || sim.isDestroyed())
-        return null;
-    return sim;
+    return ctx.views.getSimulatorWebContents();
 }
 export async function evalInSim(ctx, expression) {
     const sim = getSimulator(ctx);
@@ -17,8 +12,11 @@ export async function evalInSim(ctx, expression) {
 }
 /** Build JS that locates an element by selector+index inside the active page iframe. */
 export function buildElAccess(ref, varName = 'el') {
-    const escaped = ref.selector.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-    return `const ${varName} = _doc.querySelectorAll('${escaped}')[${ref.index}]`;
+    return `const ${varName} = _doc.querySelectorAll(${JSON.stringify(ref.selector)})[${ref.index}]`;
+}
+/** Run `body` inside the active page iframe with `varName` bound to the element at `ref`. */
+export function evalInElement(ctx, ref, body, varName = 'el') {
+    return evalInSim(ctx, inIframe(`${buildElAccess(ref, varName)}\n${body}`));
 }
 /** Wrap code to run inside the active page iframe (last iframe in the stack). */
 export function inIframe(code) {

package/dist/main/services/automation/handlers/app.js

@@ -1,59 +1,36 @@
 import { evalInSim, getSimulator, inIframe } from '../exec.js';
+import { parseLocationRoute } from '../../../../shared/simulator-route.js';
 export const appHandlers = {};
 // -- App domain --
+async function readRoute(ctx) {
+    const { search } = await evalInSim(ctx, `({ search: location.search })`);
+    return parseLocationRoute(search);
+}
 appHandlers['App.getCurrentPage'] = async (ctx) => {
-    const hash = await evalInSim(ctx, 'location.hash');
-    const clean = hash.replace(/^#/, '');
-    const qIdx = clean.indexOf('?');
-    const pathPart = qIdx >= 0 ? clean.substring(0, qIdx) : clean;
-    const queryPart = qIdx >= 0 ? clean.substring(qIdx + 1) : '';
-    // New format: #appid|page1|page2 — last segment is current page
-    let pagePath;
-    if (pathPart.includes('|')) {
-        const parts = pathPart.split('|');
-        pagePath = parts[parts.length - 1] ?? '';
-    }
-    else {
-        // Legacy format: #appid/pagePath
-        const slashIdx = pathPart.indexOf('/');
-        pagePath = slashIdx >= 0 ? pathPart.substring(slashIdx + 1) : pathPart;
-    }
-    const query = {};
-    if (queryPart) {
-        for (const pair of queryPart.split('&')) {
-            const [k, v] = pair.split('=');
-            if (k)
-                query[k] = decodeURIComponent(v || '');
-        }
-    }
+    const route = await readRoute(ctx);
     const iframeCount = await evalInSim(ctx, `document.querySelectorAll('iframe').length`);
-    return { pageId: iframeCount, path: pagePath, query };
+    return {
+        pageId: iframeCount,
+        path: route?.current.pagePath ?? '',
+        query: route?.current.query ?? {},
+    };
 };
 appHandlers['App.getPageStack'] = async (ctx) => {
-    const hash = await evalInSim(ctx, 'location.hash');
-    const clean = hash.replace(/^#/, '').replace(/\?.*$/, '');
+    const route = await readRoute(ctx);
     const pageStack = [];
-    if (clean.includes('|')) {
-        // New format: #appid|page1|page2 — segments after appid are pages
-        const parts = clean.split('|');
-        for (let i = 1; i < parts.length; i++) {
-            pageStack.push({ pageId: i, path: parts[i] ?? '', query: {} });
-        }
-    }
-    else {
-        // Legacy format: #appid/pagePath — single page
-        const slashIdx = clean.indexOf('/');
-        const currentPath = slashIdx >= 0 ? clean.substring(slashIdx + 1) : clean;
-        if (currentPath) {
-            pageStack.push({ pageId: 1, path: currentPath, query: {} });
-        }
+    if (!route)
+        return { pageStack };
+    // Mirrors upstream HashRouter.parseSearch: `[entry]` or `[entry, current]`.
+    pageStack.push({ pageId: 1, path: route.entry.pagePath, query: route.entry.query });
+    if (route.current.pagePath !== route.entry.pagePath) {
+        pageStack.push({ pageId: 2, path: route.current.pagePath, query: route.current.query });
     }
     return { pageStack };
 };
 appHandlers['App.callWxMethod'] = async (ctx, params) => {
     const method = params.method;
     const args = params.args || [];
-    // For navigation methods, handle specially via hash change + click
+    // For navigation methods, handle specially via DOM click / wx.* on the iframe
     if (['navigateTo', 'redirectTo', 'reLaunch', 'switchTab'].includes(method)) {
         const opts = args[0];
         const url = opts?.url;
@@ -61,20 +38,29 @@ appHandlers['App.callWxMethod'] = async (ctx, params) => {
             const cleanUrl = url.startsWith('/') ? url : `/${url}`;
             // Try clicking a matching DOM element first
             const clicked = await evalInSim(ctx, inIframe(`
-        const el = _doc.querySelector('[data-path="${cleanUrl}"]')
+        const path = ${JSON.stringify(cleanUrl)}
+        const el = Array.from(_doc.querySelectorAll('[data-path]'))
+          .find(e => e.getAttribute('data-path') === path)
         if (el) { el.click(); return true }
         return false
       `)).catch(() => false);
             if (!clicked) {
-                // Fallback: change hash
-                const hash = await evalInSim(ctx, 'location.hash');
-                const appId = hash.replace(/^#/, '').split('/')[0];
-                if (method === 'reLaunch' || method === 'redirectTo') {
-                    await evalInSim(ctx, `location.href = location.pathname + '#${appId}${cleanUrl}'`);
-                }
-                else {
-                    await evalInSim(ctx, `location.hash = '#${appId}${cleanUrl}'`);
+                // Fallback: drive navigation via wx.* on the rendered page iframe.
+                // Upstream's query router doesn't react to URL mutation; the active
+                // page's iframe exposes wx.* with the live dimina runtime bindings.
+                const apiName = JSON.stringify(method);
+                const urlJson = JSON.stringify(cleanUrl);
+                await evalInSim(ctx, `(() => {
+            const iframes = Array.from(document.querySelectorAll('iframe'))
+            for (const f of iframes) {
+              try {
+                if (f.contentWindow && f.contentWindow.wx && typeof f.contentWindow.wx[${apiName}] === 'function') {
+                  f.contentWindow.wx[${apiName}]({ url: ${urlJson} })
+                  return
                 }
+              } catch (_) {}
+            }
+          })()`);
             }
             // Wait for navigation
             await new Promise((r) => setTimeout(r, 2000));

package/dist/main/services/automation/handlers/element.js

@@ -1,112 +1,100 @@
-import { buildElAccess, evalInSim, inIframe } from '../exec.js';
+import { evalInElement } from '../exec.js';
 import { getElementRef, registerElement } from '../registry.js';
 export const elementHandlers = {};
 // -- Element domain --
 elementHandlers['Element.tap'] = async (ctx, params) => {
     const ref = getElementRef(params);
-    await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    await evalInElement(ctx, ref, `
     if (!el) throw new Error('Element not found')
     el.click()
-  `));
+  `);
     return {};
 };
 elementHandlers['Element.triggerEvent'] = async (ctx, params) => {
     const ref = getElementRef(params);
     const type = params.type;
     const detail = params.detail || {};
-    await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    await evalInElement(ctx, ref, `
     if (!el) throw new Error('Element not found')
     el.dispatchEvent(new CustomEvent('${type}', { detail: ${JSON.stringify(detail)}, bubbles: true }))
-  `));
+  `);
     return {};
 };
 elementHandlers['Element.touchstart'] = async (ctx, params) => {
     const ref = getElementRef(params);
-    await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    await evalInElement(ctx, ref, `
     if (el) el.dispatchEvent(new TouchEvent('touchstart', { bubbles: true }))
-  `));
+  `);
     return {};
 };
 elementHandlers['Element.touchmove'] = async (ctx, params) => {
     const ref = getElementRef(params);
-    await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    await evalInElement(ctx, ref, `
     if (el) el.dispatchEvent(new TouchEvent('touchmove', { bubbles: true }))
-  `));
+  `);
     return {};
 };
 elementHandlers['Element.touchend'] = async (ctx, params) => {
     const ref = getElementRef(params);
-    await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    await evalInElement(ctx, ref, `
     if (el) el.dispatchEvent(new TouchEvent('touchend', { bubbles: true }))
-  `));
+  `);
     return {};
 };
 elementHandlers['Element.getDOMProperties'] = async (ctx, params) => {
     const ref = getElementRef(params);
     const names = params.names;
-    const properties = await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    const properties = await evalInElement(ctx, ref, `
     if (!el) return ${JSON.stringify(names.map(() => null))}
     return ${JSON.stringify(names)}.map(n => el[n])
-  `));
+  `);
     return { properties };
 };
 elementHandlers['Element.getAttributes'] = async (ctx, params) => {
     const ref = getElementRef(params);
     const names = params.names;
-    const attributes = await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    const attributes = await evalInElement(ctx, ref, `
     if (!el) return ${JSON.stringify(names.map(() => null))}
     return ${JSON.stringify(names)}.map(n => el.getAttribute(n))
-  `));
+  `);
     return { attributes };
 };
 elementHandlers['Element.getStyles'] = async (ctx, params) => {
     const ref = getElementRef(params);
     const names = params.names;
-    const styles = await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    const styles = await evalInElement(ctx, ref, `
     if (!el) return ${JSON.stringify(names.map(() => ''))}
     const cs = getComputedStyle(el)
     return ${JSON.stringify(names)}.map(n => cs.getPropertyValue(n))
-  `));
+  `);
     return { styles };
 };
 elementHandlers['Element.getWXML'] = async (ctx, params) => {
     const ref = getElementRef(params);
     const type = params.type || 'inner';
     const prop = type === 'outer' ? 'outerHTML' : 'innerHTML';
-    const wxml = await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    const wxml = await evalInElement(ctx, ref, `
     return el ? el.${prop} : ''
-  `));
+  `);
     return { wxml };
 };
 elementHandlers['Element.getOffset'] = async (ctx, params) => {
     const ref = getElementRef(params);
-    return evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    return evalInElement(ctx, ref, `
     if (!el) return { left: 0, top: 0 }
     const r = el.getBoundingClientRect()
     return { left: r.left, top: r.top }
-  `));
+  `);
 };
 elementHandlers['Element.getElement'] = async (ctx, params) => {
     const parentRef = getElementRef(params);
     const selector = params.selector;
-    const escaped = selector.replace(/'/g, "\\'");
-    const info = await evalInSim(ctx, inIframe(`
-    ${buildElAccess(parentRef, 'parent')}
+    const info = await evalInElement(ctx, parentRef, `
     if (!parent) return null
-    const child = parent.querySelector('${escaped}')
+    const child = parent.querySelector(${JSON.stringify(selector)})
     if (!child) return null
     return { tagName: child.tagName.toLowerCase() }
-  `));
+  `, 'parent');
     if (!info)
         throw new Error(`Child element not found: ${selector}`);
     const combinedSelector = `${parentRef.selector} ${selector}`;
@@ -116,14 +104,12 @@ elementHandlers['Element.getElement'] = async (ctx, params) => {
 elementHandlers['Element.getElements'] = async (ctx, params) => {
     const parentRef = getElementRef(params);
     const selector = params.selector;
-    const escaped = selector.replace(/'/g, "\\'");
-    const items = await evalInSim(ctx, inIframe(`
-    ${buildElAccess(parentRef, 'parent')}
+    const items = await evalInElement(ctx, parentRef, `
     if (!parent) return []
-    return Array.from(parent.querySelectorAll('${escaped}')).map(el => ({
+    return Array.from(parent.querySelectorAll(${JSON.stringify(selector)})).map(el => ({
       tagName: el.tagName.toLowerCase(),
     }))
-  `));
+  `, 'parent');
     const combinedSelector = `${parentRef.selector} ${selector}`;
     return {
         elements: items.map((item, i) => ({

package/dist/main/services/default-adapter.js

@@ -4,12 +4,12 @@ import { simulatorDir } from '../utils/paths.js';
 export const defaultAdapter = {
     async openProject(opts) {
         const diminaKit = await import('@dimina-kit/devkit');
-        const openProject = diminaKit.openProject;
-        return openProject({
+        const openProjectOpts = {
             outputDir: path.join(app.getPath('userData'), 'dimina-fe-output'),
             ...opts,
             simulatorDir,
-        });
+        };
+        return diminaKit.openProject(openProjectOpts);
     },
 };
 //# sourceMappingURL=default-adapter.js.map

package/dist/main/services/mcp/index.d.ts

@@ -12,4 +12,5 @@
  *   - `./target-manager.ts`   dual-target CDP connection + reconnect
  */
 export { startMcpServer } from './server.js';
+export { getMcpStatus, type McpRuntimeStatus } from './status.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -12,4 +12,5 @@
  *   - `./target-manager.ts`   dual-target CDP connection + reconnect
  */
 export { startMcpServer } from './server.js';
+export { getMcpStatus } from './status.js';
 //# sourceMappingURL=index.js.map

package/dist/main/services/mcp/server.js

@@ -12,6 +12,7 @@ import { createServer } from 'http';
 import { createRequire } from 'node:module';
 import { toDisposable } from '../../utils/disposable.js';
 import { connectTarget, setCdpPort } from './target-manager.js';
+import { recordMcpFailed, recordMcpStarted, recordMcpStopped } from './status.js';
 import { registerCommonTargetTools } from './tool-registry.js';
 import { registerContextTools } from './tools/context-tools.js';
 import { registerSimulatorTools } from './tools/simulator-tools.js';
@@ -65,17 +66,21 @@ export function startMcpServer(resolvedCdpPort, mcpPort) {
     httpServer.on('error', (err) => {
         if (err.code === 'EADDRINUSE') {
             console.warn(`[MCP] Port ${mcpPort} already in use — MCP server not started`);
+            recordMcpFailed('port-in-use');
         }
         else {
             console.error('[MCP] Server error:', err);
+            recordMcpFailed(err.message);
         }
     });
     httpServer.listen(mcpPort, '127.0.0.1', () => {
         console.log(`[MCP] SSE server listening on http://127.0.0.1:${mcpPort}/sse`);
+        recordMcpStarted(mcpPort);
     });
     return toDisposable(() => {
         transports.clear();
         httpServer.close();
+        recordMcpStopped();
     });
 }
 //# sourceMappingURL=server.js.map

package/dist/main/services/mcp/status.d.ts

@@ -0,0 +1,10 @@
+export interface McpRuntimeStatus {
+    running: boolean;
+    port: number | null;
+    error: string | null;
+}
+export declare function getMcpStatus(): McpRuntimeStatus;
+export declare function recordMcpStarted(port: number): void;
+export declare function recordMcpFailed(error: string): void;
+export declare function recordMcpStopped(): void;
+//# sourceMappingURL=status.d.ts.map

package/dist/main/services/mcp/status.js

@@ -0,0 +1,14 @@
+let status = { running: false, port: null, error: null };
+export function getMcpStatus() {
+    return { ...status };
+}
+export function recordMcpStarted(port) {
+    status = { running: true, port, error: null };
+}
+export function recordMcpFailed(error) {
+    status = { running: false, port: null, error };
+}
+export function recordMcpStopped() {
+    status = { running: false, port: null, error: null };
+}
+//# sourceMappingURL=status.js.map

package/dist/main/services/mcp/target-manager.js

@@ -10,10 +10,11 @@
  *   - rolling buffers of console log and network request events
  */
 import CDP from 'chrome-remote-interface';
+import { DEFAULT_CDP_PORT } from '../../../shared/constants.js';
 const SIMULATOR_URL_PATTERN = 'localhost:7788';
 const MAX_BUFFER = 500;
 const RECONNECT_INTERVAL_MS = 3000;
-let cdpPort = 9222;
+let cdpPort = DEFAULT_CDP_PORT;
 const targets = {
     simulator: { client: null, connected: false, timer: null, consoleLogs: [], networkRequests: [] },
     workbench: { client: null, connected: false, timer: null, consoleLogs: [], networkRequests: [] },

package/dist/main/services/notifications/renderer-notifier.d.ts

@@ -52,8 +52,6 @@ export interface RendererNotifier {
     popoverClosed(): void;
     /** Ask the main renderer to relaunch the simulator with a new config. */
     popoverRelaunch(config: CompileConfig): void;
-    /** Ask the main renderer to re-initialise the devtools panels. */
-    workbenchReset(): void;
     /** Tell the main renderer the toolbar actions list has changed. */
     toolbarActionsChanged(): void;
     /** Initialise the currently shown compile popover overlay. */
@@ -69,7 +67,9 @@ export interface RendererNotifier {
  * between the notifier module and workbench-context.
  */
 export interface NotifierContext {
-    mainWindow: BrowserWindow;
+    windows: {
+        readonly mainWindow: BrowserWindow;
+    };
     views: {
         getSettingsWebContents(): WebContents | null;
     };

package/dist/main/services/notifications/renderer-notifier.js

@@ -1,4 +1,4 @@
-import { ProjectChannel, WindowChannel, SettingsChannel, PopoverChannel, WorkbenchChannel, ToolbarChannel, WorkbenchSettingsChannel, } from '../../../shared/ipc-channels.js';
+import { ProjectChannel, WindowChannel, SettingsChannel, PopoverChannel, ToolbarChannel, WorkbenchSettingsChannel, } from '../../../shared/ipc-channels.js';
 /** Safely resolve a WebContents, skipping destroyed / missing targets. */
 function liveWebContents(wc) {
     if (!wc)
@@ -13,9 +13,9 @@ function liveWebContents(wc) {
  */
 export function createRendererNotifier(ctx) {
     function sendToMain(channel, ...args) {
-        if (ctx.mainWindow.isDestroyed())
+        if (ctx.windows.mainWindow.isDestroyed())
             return;
-        const wc = liveWebContents(ctx.mainWindow.webContents);
+        const wc = liveWebContents(ctx.windows.mainWindow.webContents);
         if (!wc)
             return;
         wc.send(channel, ...args);
@@ -39,9 +39,6 @@ export function createRendererNotifier(ctx) {
         popoverRelaunch(config) {
             sendToMain(PopoverChannel.Relaunch, config);
         },
-        workbenchReset() {
-            sendToMain(WorkbenchChannel.Reset);
-        },
         toolbarActionsChanged() {
             sendToMain(ToolbarChannel.ActionsChanged);
         },

package/dist/main/services/projects/local-provider.js

@@ -3,9 +3,9 @@
  * `<userData>/dimina-projects.json` and exposes the validation / compile-
  * config helpers historically provided by `project-repository.ts`.
  *
- * The repository module is kept for thumbnail/paths/page helpers and for
- * back-compat re-exports; the canonical list & validation surface for the
- * workspace service is this provider.
+ * The repository module is kept for thumbnail/paths/page helpers; the
+ * canonical list & validation surface for the workspace service is this
+ * provider.
  */
 import * as repo from './project-repository.js';
 import { loadThumbnail, saveThumbnailFromDataUrl } from './thumbnail.js';

package/dist/main/services/projects/project-repository.d.ts

@@ -12,7 +12,6 @@ export interface ProjectPages {
 export interface ProjectSettings {
     uploadWithSourceMap: boolean;
 }
-export type { CompileConfig } from '../../../shared/types.js';
 export declare function listProjects(): Project[];
 export declare function validateProjectDir(dirPath: string): string | null;
 export declare function hasProject(dirPath: string): boolean;