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

package/dist/main/windows/settings-window/create.js

@@ -1,6 +1,8 @@
 import { BrowserWindow } from 'electron';
 import path from 'path';
+import { mainPreloadPath } from '../../utils/paths.js';
 import { themeBg } from '../../utils/theme.js';
+import { applyNavigationHardening } from '../navigation-hardening.js';
 export async function createSettingsWindow(parent, rendererDir) {
     const win = new BrowserWindow({
         width: 420,
@@ -10,8 +12,16 @@ export async function createSettingsWindow(parent, rendererDir) {
         parent: parent ?? undefined,
         title: '开发工具设置',
         backgroundColor: themeBg(),
-        webPreferences: { nodeIntegration: true, contextIsolation: false },
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+            preload: mainPreloadPath,
+        },
     });
+    // Standalone settings window loads mainPreloadPath, so the same
+    // navigation rules as the main window apply — see navigation-hardening.ts.
+    applyNavigationHardening(win.webContents, rendererDir);
     await win.loadFile(path.join(rendererDir, 'entries/workbench-settings/index.html'));
     return win;
 }

package/dist/preload/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Public preload API surface for `@dimina-kit/devtools/preload`.
+ *
+ * External consumers compose their own simulator <webview> preload by
+ * importing the `install*` helpers from here. The built-in simulator
+ * preload at `windows/simulator.ts` is one such composition.
+ *
+ * NOTE: do NOT add main-window preload concerns (contextBridge / ipc
+ * exposure) to this file — that lives in `windows/main.ts` and is
+ * bundled by esbuild, never re-exported through this barrel.
+ */
+export { installConsoleInstrumentation } from './instrumentation/console.js';
+export { createAppDataSource } from './instrumentation/app-data.js';
+export type { AppDataSnapshot } from './instrumentation/app-data.js';
+export { createWxmlSource } from './instrumentation/wxml.js';
+export { createMiniappSnapshotHost } from './miniapp-snapshot/host.js';
+export type { MiniappSnapshotHost, MiniappSnapshotSource, SnapshotEnvelope, SnapshotSourceId, } from './miniapp-snapshot/types.js';
+export { installSimulatorBridge } from './runtime/bridge.js';
+export { installCustomApisBridge } from './runtime/custom-apis.js';
+export type { DiminaCustomApisBridge } from './runtime/custom-apis.js';
+export { setupApiCompatHook } from './shared/api-compat.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/preload/index.js

@@ -0,0 +1,19 @@
+/**
+ * Public preload API surface for `@dimina-kit/devtools/preload`.
+ *
+ * External consumers compose their own simulator <webview> preload by
+ * importing the `install*` helpers from here. The built-in simulator
+ * preload at `windows/simulator.ts` is one such composition.
+ *
+ * NOTE: do NOT add main-window preload concerns (contextBridge / ipc
+ * exposure) to this file — that lives in `windows/main.ts` and is
+ * bundled by esbuild, never re-exported through this barrel.
+ */
+export { installConsoleInstrumentation } from './instrumentation/console.js';
+export { createAppDataSource } from './instrumentation/app-data.js';
+export { createWxmlSource } from './instrumentation/wxml.js';
+export { createMiniappSnapshotHost } from './miniapp-snapshot/host.js';
+export { installSimulatorBridge } from './runtime/bridge.js';
+export { installCustomApisBridge } from './runtime/custom-apis.js';
+export { setupApiCompatHook } from './shared/api-compat.js';
+//# sourceMappingURL=index.js.map

package/dist/preload/instrumentation/app-data.d.ts

@@ -1,3 +1,33 @@
-export declare function installAppDataInstrumentation(): () => void;
-export declare function sendAllAppData(): void;
+import type { MiniappSnapshotSource } from '../miniapp-snapshot/types.js';
+/**
+ * The AppData snapshot — the full, cumulative panel state.
+ *
+ * - `bridges` lists every page bridge in chronological (insertion) order, each
+ *   carrying its page route (`pagePath`), so renderer tabs render in a stable
+ *   sequence.
+ * - `entries` maps `bridgeId → (componentPath | moduleId) → setData state`.
+ */
+export interface AppDataSnapshot {
+    bridges: Array<{
+        id: string;
+        pagePath: string | null;
+    }>;
+    entries: Record<string, Record<string, unknown>>;
+}
+/**
+ * The AppData snapshot data source.
+ *
+ * Instruments `window.Worker` (incoming `message` decoding + outgoing
+ * `postMessage` interception) and installs `window.__simulatorHook.appData`,
+ * accumulating per-(bridgeId, moduleId) setData state in an internal cache.
+ * Every cache mutation — an accepted `ub`/`page_*` worker message, or a
+ * `pageUnload` evicting a bridge — calls `emit()` so the `miniappSnapshot`
+ * host republishes the full snapshot. The source itself never touches IPC:
+ * the host owns push, pull and the install-time publish.
+ *
+ * It keeps the `__simulatorData.getAppdata()` automation surface working by
+ * mirroring the flat cache into the simulator bridge via `setAppDataSnapshot`
+ * / `clearAppDataSnapshot`.
+ */
+export declare function createAppDataSource(): MiniappSnapshotSource<AppDataSnapshot>;
 //# sourceMappingURL=app-data.d.ts.map

package/dist/preload/instrumentation/app-data.js

@@ -1,15 +1,14 @@
-import { SimulatorChannel, BridgeChannel } from '../../shared/ipc-channels.js';
-import { sendToHost } from '../runtime/host.js';
-import { simulatorBridge, clearAppDataSnapshot, setAppDataSnapshot, } from '../runtime/bridge.js';
-import { createDisposableSet } from './disposable.js';
-const appDataCache = new Map();
-function publishSnapshot() {
-    const data = {};
-    for (const [key, value] of appDataCache) {
-        data[key] = value;
-    }
-    setAppDataSnapshot(data);
-}
+import { clearAppDataSnapshot, setAppDataSnapshot, } from '../runtime/bridge.js';
+// dimina runtime emits two kinds of service→main messages relevant to the
+// AppData panel:
+//  • update batches `{type:'ub', body:{bridgeId, updates:[{moduleId,data}]}}`
+//    where each `data` is a partial setData patch.
+//  • instance init: type === instance id (prefixed `page_`/`component_`),
+//    body `{bridgeId, path, data}` with the COMPLETE initial state.
+//
+// Policy: surface PAGE entries only. Component entries are dropped — they
+// sometimes flow on a bridge id distinct from their owning page's and never
+// receive pageUnload, which would manifest as ghost tabs in the panel.
 function decodeWorkerMessage(message) {
     let payload = message;
     if (typeof payload === 'string') {
@@ -20,84 +19,259 @@ function decodeWorkerMessage(message) {
             return null;
         }
     }
-    const record = payload;
-    if (record?.type !== 'u' || !record.body)
+    if (!payload || typeof payload !== 'object')
         return null;
-    return record.body;
-}
-function createInstrumentedWorker(OriginalWorker) {
-    function InstrumentedWorker(scriptURL, options) {
-        const resolvedScriptURL = scriptURL instanceof URL
-            ? scriptURL
-            : new URL(scriptURL, window.location.href);
-        const worker = Reflect.construct(OriginalWorker, [resolvedScriptURL, options], new.target ?? InstrumentedWorker);
-        worker.addEventListener('message', (event) => {
-            const body = decodeWorkerMessage(event.data);
-            if (!body)
-                return;
-            window.__simulatorHook?.appData({
+    const record = payload;
+    if (record.type === 'ub') {
+        const body = record.body;
+        if (!body || typeof body !== 'object')
+            return null;
+        if (typeof body.bridgeId !== 'string' || !Array.isArray(body.updates))
+            return null;
+        const out = [];
+        for (const u of body.updates) {
+            if (!u || typeof u.moduleId !== 'string')
+                continue;
+            if (!u.moduleId.startsWith('page_'))
+                continue;
+            out.push({ mode: 'patch', bridgeId: body.bridgeId, moduleId: u.moduleId, data: u.data });
+        }
+        return out.length > 0 ? out : null;
+    }
+    if (typeof record.type === 'string' && record.type.startsWith('page_')) {
+        const body = record.body;
+        if (!body || typeof body !== 'object')
+            return null;
+        if (typeof body.bridgeId !== 'string' || typeof body.path !== 'string')
+            return null;
+        if (!body.data || typeof body.data !== 'object')
+            return null;
+        return [{
+                mode: 'init',
                 bridgeId: body.bridgeId,
-                moduleId: body.moduleId,
+                moduleId: record.type,
+                componentPath: body.path,
                 data: body.data,
-            });
-        });
-        return worker;
+            }];
     }
-    Object.setPrototypeOf(InstrumentedWorker, OriginalWorker);
-    Object.defineProperty(InstrumentedWorker, 'prototype', {
-        value: OriginalWorker.prototype,
-    });
-    return InstrumentedWorker;
+    return null;
 }
-export function installAppDataInstrumentation() {
-    const disposables = createDisposableSet();
-    const originalHook = window.__simulatorHook;
-    const originalDescriptor = Object.getOwnPropertyDescriptor(window, 'Worker');
-    const OriginalWorker = window.Worker;
-    window.__simulatorHook = {
-        appData: (body) => {
-            const record = body;
-            if (record?.bridgeId && record?.moduleId) {
-                const key = `${record.bridgeId}/${record.moduleId}`;
-                appDataCache.set(key, record.data);
-                publishSnapshot();
-            }
-            sendToHost(SimulatorChannel.AppData, body);
-        },
+// main→worker direction: container signals page teardown so cache can evict.
+function decodeOutgoingMessage(message) {
+    let payload = message;
+    if (typeof payload === 'string') {
+        try {
+            payload = JSON.parse(payload);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!payload || typeof payload !== 'object')
+        return null;
+    const r = payload;
+    if (typeof r.type !== 'string')
+        return null;
+    return {
+        type: r.type,
+        bridgeId: typeof r.body?.bridgeId === 'string' ? r.body.bridgeId : undefined,
     };
-    Object.defineProperty(window, 'Worker', {
-        configurable: true,
-        writable: true,
-        value: createInstrumentedWorker(OriginalWorker),
-    });
-    publishSnapshot();
-    disposables.add(() => {
-        if (originalDescriptor) {
-            Object.defineProperty(window, 'Worker', originalDescriptor);
+}
+/**
+ * The AppData snapshot data source.
+ *
+ * Instruments `window.Worker` (incoming `message` decoding + outgoing
+ * `postMessage` interception) and installs `window.__simulatorHook.appData`,
+ * accumulating per-(bridgeId, moduleId) setData state in an internal cache.
+ * Every cache mutation — an accepted `ub`/`page_*` worker message, or a
+ * `pageUnload` evicting a bridge — calls `emit()` so the `miniappSnapshot`
+ * host republishes the full snapshot. The source itself never touches IPC:
+ * the host owns push, pull and the install-time publish.
+ *
+ * It keeps the `__simulatorData.getAppdata()` automation surface working by
+ * mirroring the flat cache into the simulator bridge via `setAppDataSnapshot`
+ * / `clearAppDataSnapshot`.
+ */
+export function createAppDataSource() {
+    const appDataCache = new Map();
+    // Bridges in insertion order — drives the `bridges` array in snapshots so
+    // renderer tabs render in a stable, chronological sequence.
+    const bridgeOrder = [];
+    // Page path per bridge: set from `page_*` init's body.path. Component init
+    // also carries a path but it's the component's own path, not the page route.
+    const bridgePagePath = new Map();
+    let emit = null;
+    let installed = false;
+    let originalHook;
+    let originalDescriptor;
+    let OriginalWorker;
+    function recordBridge(bridgeId) {
+        if (!bridgeOrder.includes(bridgeId))
+            bridgeOrder.push(bridgeId);
+    }
+    function buildSnapshot() {
+        const bridges = [];
+        for (const id of bridgeOrder) {
+            bridges.push({ id, pagePath: bridgePagePath.get(id) ?? null });
         }
-        else {
-            window.Worker = OriginalWorker;
+        const entries = {};
+        for (const [key, entry] of appDataCache) {
+            const slash = key.indexOf('/');
+            if (slash < 0)
+                continue;
+            const bridgeId = key.slice(0, slash);
+            const moduleId = key.slice(slash + 1);
+            if (!entries[bridgeId])
+                entries[bridgeId] = {};
+            const displayKey = entry.componentPath ?? moduleId;
+            entries[bridgeId][displayKey] = entry.data;
         }
-    });
-    disposables.add(() => {
-        if (originalHook) {
-            window.__simulatorHook = originalHook;
+        return { bridges, entries };
+    }
+    // Mirror the flat cache into the `__simulatorData.getAppdata()` automation
+    // surface so MCP / e2e reads keep working after the snapshot migration.
+    function publishSnapshot() {
+        const data = {};
+        for (const [key, entry] of appDataCache) {
+            data[key] = entry.data;
         }
-        else {
-            delete window.__simulatorHook;
+        setAppDataSnapshot(data);
+    }
+    function clearBridge(bridgeId) {
+        const prefix = `${bridgeId}/`;
+        for (const key of [...appDataCache.keys()]) {
+            if (key.startsWith(prefix))
+                appDataCache.delete(key);
         }
-    });
-    disposables.add(() => {
-        appDataCache.clear();
-        clearAppDataSnapshot();
+        const idx = bridgeOrder.indexOf(bridgeId);
+        if (idx >= 0)
+            bridgeOrder.splice(idx, 1);
+        bridgePagePath.delete(bridgeId);
         publishSnapshot();
-    });
-    return () => {
-        disposables.disposeAll();
+        // The eviction is a cache mutation — notify the host so the renderer can
+        // drop the evicted bridge's tab immediately.
+        emit?.();
+    }
+    function applyAppData(body) {
+        const record = body;
+        if (!record?.bridgeId || !record?.moduleId)
+            return;
+        // R6: drop ub patches whose bridge has never been initialised. dimina
+        // dispatches pageUnload to the service worker, which fires onUnload —
+        // and onUnload's setData (e.g. console-test's stopTimer) produces a
+        // late `ub` that arrives AFTER our clearBridge. Without this gate the
+        // late patch would resurrect the unloaded bridge as a ghost tab.
+        if (record.mode !== 'init' && !bridgePagePath.has(record.bridgeId))
+            return;
+        const key = `${record.bridgeId}/${record.moduleId}`;
+        const prev = appDataCache.get(key);
+        const incoming = (record.data && typeof record.data === 'object'
+            ? record.data
+            : {});
+        // init = full-state replace; patch = merge into previous (setData semantics)
+        const merged = record.mode === 'init'
+            ? { ...incoming }
+            : { ...(prev?.data ?? {}), ...incoming };
+        const componentPath = record.componentPath ?? prev?.componentPath;
+        const next = componentPath !== undefined
+            ? { componentPath, data: merged }
+            : { data: merged };
+        appDataCache.set(key, next);
+        recordBridge(record.bridgeId);
+        if (record.mode === 'init'
+            && record.moduleId.startsWith('page_')
+            && record.componentPath) {
+            bridgePagePath.set(record.bridgeId, record.componentPath);
+        }
+        publishSnapshot();
+        emit?.();
+    }
+    function instrumentPostMessage(worker) {
+        const orig = worker.postMessage.bind(worker);
+        worker.postMessage = function (msg, ...rest) {
+            const decoded = decodeOutgoingMessage(msg);
+            if (decoded?.type === 'pageUnload' && decoded.bridgeId) {
+                clearBridge(decoded.bridgeId);
+            }
+            return orig(msg, ...rest);
+        };
+    }
+    function createInstrumentedWorker(Original) {
+        function InstrumentedWorker(scriptURL, options) {
+            const resolvedScriptURL = scriptURL instanceof URL
+                ? scriptURL
+                : new URL(scriptURL, window.location.href);
+            const worker = Reflect.construct(Original, [resolvedScriptURL, options], new.target ?? InstrumentedWorker);
+            instrumentPostMessage(worker);
+            worker.addEventListener('message', (event) => {
+                const entries = decodeWorkerMessage(event.data);
+                if (!entries)
+                    return;
+                for (const entry of entries) {
+                    const hookBody = {
+                        bridgeId: entry.bridgeId,
+                        moduleId: entry.moduleId,
+                        data: entry.data,
+                        mode: entry.mode,
+                    };
+                    if (entry.mode === 'init')
+                        hookBody.componentPath = entry.componentPath;
+                    window.__simulatorHook?.appData(hookBody);
+                }
+            });
+            return worker;
+        }
+        Object.setPrototypeOf(InstrumentedWorker, Original);
+        Object.defineProperty(InstrumentedWorker, 'prototype', {
+            value: Original.prototype,
+        });
+        return InstrumentedWorker;
+    }
+    return {
+        id: 'appdata',
+        snapshot: () => buildSnapshot(),
+        start(onChange) {
+            if (installed)
+                return;
+            installed = true;
+            emit = onChange;
+            originalHook = window.__simulatorHook;
+            originalDescriptor = Object.getOwnPropertyDescriptor(window, 'Worker');
+            OriginalWorker = window.Worker;
+            window.__simulatorHook = {
+                appData: (body) => applyAppData(body),
+            };
+            Object.defineProperty(window, 'Worker', {
+                configurable: true,
+                writable: true,
+                value: createInstrumentedWorker(OriginalWorker),
+            });
+        },
+        dispose() {
+            if (!installed)
+                return;
+            installed = false;
+            if (originalDescriptor) {
+                Object.defineProperty(window, 'Worker', originalDescriptor);
+            }
+            else if (OriginalWorker) {
+                window.Worker = OriginalWorker;
+            }
+            if (originalHook) {
+                window.__simulatorHook = originalHook;
+            }
+            else {
+                delete window.__simulatorHook;
+            }
+            originalDescriptor = undefined;
+            OriginalWorker = undefined;
+            originalHook = undefined;
+            appDataCache.clear();
+            bridgeOrder.length = 0;
+            bridgePagePath.clear();
+            clearAppDataSnapshot();
+            emit = null;
+        },
     };
 }
-export function sendAllAppData() {
-    publishSnapshot();
-    sendToHost(BridgeChannel.AppDataGetAllResponse, simulatorBridge.appdata.data);
-}
 //# sourceMappingURL=app-data.js.map

package/dist/preload/instrumentation/index.d.ts

@@ -1,4 +1,4 @@
 export { installConsoleInstrumentation } from './console.js';
-export { installAppDataInstrumentation, sendAllAppData } from './app-data.js';
-export { installWxmlInstrumentation, sendWxmlTree, setupWxmlObserver } from './wxml.js';
+export { createAppDataSource, type AppDataSnapshot } from './app-data.js';
+export { createWxmlSource } from './wxml.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/preload/instrumentation/index.js

@@ -1,4 +1,4 @@
 export { installConsoleInstrumentation } from './console.js';
-export { installAppDataInstrumentation, sendAllAppData } from './app-data.js';
-export { installWxmlInstrumentation, sendWxmlTree, setupWxmlObserver } from './wxml.js';
+export { createAppDataSource } from './app-data.js';
+export { createWxmlSource } from './wxml.js';
 //# sourceMappingURL=index.js.map

package/dist/preload/instrumentation/wxml.d.ts

@@ -1,5 +1,17 @@
-declare function sendWxmlTree(): void;
-export declare function installWxmlInstrumentation(): () => void;
-export declare const setupWxmlObserver: typeof installWxmlInstrumentation;
-export { sendWxmlTree };
+import { type WxmlNode } from '../runtime/bridge.js';
+import type { MiniappSnapshotSource } from '../miniapp-snapshot/types.js';
+/**
+ * The WXML snapshot data source.
+ *
+ * Observes the simulator page's Vue tree (retry-attach + MutationObserver +
+ * top-level navigation observer), recomputes a normalized {@link WxmlNode}
+ * tree on every (debounced) change, stores it internally, and calls `emit()`
+ * so the `miniappSnapshot` host publishes it. The source itself never touches
+ * IPC — the host owns the push/pull transport and the install-time publish.
+ *
+ * It keeps the `__simulatorData.getWxml()` automation surface working by
+ * mirroring each computed tree into the simulator bridge via
+ * `setWxmlSnapshot` / `clearWxmlSnapshot`.
+ */
+export declare function createWxmlSource(): MiniappSnapshotSource<WxmlNode | null>;
 //# sourceMappingURL=wxml.d.ts.map