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

package/dist/main/services/simulator-storage/index.js

@@ -15,10 +15,10 @@
  *     If a user opens DevTools on the simulator the debugger detaches and
  *     events stop flowing until they close it.
  */
-import { app, ipcMain, webContents as wcStatic } from 'electron';
+import { app, webContents as wcStatic } from 'electron';
 import { SimulatorElementChannel, SimulatorStorageChannel, } from '../../../shared/ipc-channels.js';
-let attachedWc = null;
-let hostWc = null;
+import { DisposableRegistry } from '../../utils/disposable.js';
+import { IpcRegistry } from '../../utils/ipc-registry.js';
 function isSimulatorWebview(wc) {
     if (wc.isDestroyed())
         return false;
@@ -26,87 +26,381 @@ function isSimulatorWebview(wc) {
         return false;
     return wc.getURL().includes('simulator.html');
 }
-function detach() {
-    if (!attachedWc)
-        return;
-    const wc = attachedWc;
-    attachedWc = null;
+function safeOff(target, event, fn) {
     try {
-        if (!wc.isDestroyed() && wc.debugger.isAttached()) {
-            wc.debugger.detach();
-        }
+        if (target.isDestroyed?.())
+            return;
+        target.removeListener(event, fn);
     }
     catch {
         // best-effort
     }
 }
-async function attachToSim(wc) {
-    if (attachedWc === wc)
-        return;
-    if (wc.isDestroyed())
-        return;
-    detach();
-    try {
-        if (!wc.debugger.isAttached()) {
-            wc.debugger.attach('1.3');
-        }
-        await wc.debugger.sendCommand('DOMStorage.enable');
-        wc.debugger.on('message', onCdpMessage);
-        wc.debugger.on('detach', () => {
-            if (attachedWc === wc)
-                attachedWc = null;
-        });
-        wc.once('destroyed', () => {
-            if (attachedWc === wc)
-                attachedWc = null;
-        });
-        attachedWc = wc;
+export function setupSimulatorStorage(host, options) {
+    const registry = new DisposableRegistry();
+    const getActiveAppId = options.getActiveAppId;
+    let attachedWc = null;
+    let attachDisposables = null;
+    /**
+     * Cached origin discovered via `executeJavaScript('location.origin')` on
+     * first use. The simulator <webview> loads `simulator.html` from a stable
+     * scheme/host/port for the lifetime of the CDP attach, so caching avoids an
+     * extra IPC round-trip per write call. Cleared on detach.
+     */
+    let cachedOrigin = null;
+    /** Active appId prefix (e.g. `wx123_`), or null when no session is active. */
+    function activePrefix() {
+        const appId = getActiveAppId();
+        return appId ? `${appId}_` : null;
     }
-    catch (e) {
-        console.warn('[storage-watcher] attach failed:', e.message);
+    function detachFromSim() {
+        if (!attachedWc)
+            return;
+        const wc = attachedWc;
+        attachedWc = null;
+        cachedOrigin = null;
+        const ad = attachDisposables;
+        attachDisposables = null;
+        if (ad)
+            void ad.disposeAll().catch(() => { });
+        try {
+            if (!wc.isDestroyed() && wc.debugger.isAttached()) {
+                wc.debugger.detach();
+            }
+        }
+        catch {
+            // best-effort
+        }
     }
-}
-function onCdpMessage(_event, method, params) {
-    if (!hostWc || hostWc.isDestroyed())
-        return;
-    const p = params;
-    let evt;
-    switch (method) {
-        case 'DOMStorage.domStorageItemAdded':
-            evt = { type: 'added', key: String(p.key), newValue: String(p.newValue ?? '') };
-            break;
-        case 'DOMStorage.domStorageItemUpdated':
-            evt = {
-                type: 'updated',
-                key: String(p.key),
-                oldValue: String(p.oldValue ?? ''),
-                newValue: String(p.newValue ?? ''),
+    async function attachToSim(wc) {
+        if (attachedWc === wc)
+            return;
+        if (wc.isDestroyed())
+            return;
+        detachFromSim();
+        try {
+            if (!wc.debugger.isAttached()) {
+                wc.debugger.attach('1.3');
+            }
+            await wc.debugger.sendCommand('DOMStorage.enable');
+            const attach = new DisposableRegistry();
+            attachDisposables = attach;
+            const onMessage = (_event, method, params) => forwardCdpMessage(method, params);
+            wc.debugger.on('message', onMessage);
+            attach.add(() => safeOff(wc.debugger, 'message', onMessage));
+            const onDetach = () => {
+                if (attachedWc === wc)
+                    attachedWc = null;
             };
-            break;
-        case 'DOMStorage.domStorageItemRemoved':
-            evt = { type: 'removed', key: String(p.key) };
-            break;
-        case 'DOMStorage.domStorageItemsCleared':
-            evt = { type: 'cleared' };
-            break;
-        default:
+            wc.debugger.on('detach', onDetach);
+            attach.add(() => safeOff(wc.debugger, 'detach', onDetach));
+            const onDestroyed = () => {
+                // When the attached wc is destroyed, the lingering attachDisposables
+                // hold listener refs to a wc that will never emit again. Dispose the
+                // registry here so debugger/wc listeners are removed deterministically
+                // and a subsequent attachToSim() starts from a clean slate.
+                if (attachedWc === wc) {
+                    attachedWc = null;
+                    const ad = attachDisposables;
+                    attachDisposables = null;
+                    if (ad)
+                        void ad.disposeAll().catch(() => { });
+                }
+            };
+            wc.once('destroyed', onDestroyed);
+            attach.add(() => safeOff(wc, 'destroyed', onDestroyed));
+            attachedWc = wc;
+        }
+        catch (e) {
+            console.warn('[storage-watcher] attach failed:', e.message);
+        }
+    }
+    function forwardCdpMessage(method, params) {
+        if (host.isDestroyed())
             return;
+        const p = params;
+        const prefix = activePrefix();
+        let evt;
+        switch (method) {
+            case 'DOMStorage.domStorageItemAdded': {
+                const key = String(p.key);
+                if (prefix && !key.startsWith(prefix))
+                    return;
+                evt = { type: 'added', key, newValue: String(p.newValue ?? '') };
+                break;
+            }
+            case 'DOMStorage.domStorageItemUpdated': {
+                const key = String(p.key);
+                if (prefix && !key.startsWith(prefix))
+                    return;
+                evt = {
+                    type: 'updated',
+                    key,
+                    oldValue: String(p.oldValue ?? ''),
+                    newValue: String(p.newValue ?? ''),
+                };
+                break;
+            }
+            case 'DOMStorage.domStorageItemRemoved': {
+                const key = String(p.key);
+                if (prefix && !key.startsWith(prefix))
+                    return;
+                evt = { type: 'removed', key };
+                break;
+            }
+            case 'DOMStorage.domStorageItemsCleared':
+                // Forwarded unfiltered: this CDP event only fires on a true
+                // origin-wide `localStorage.clear()`. The dimina runtime's
+                // `wx.clearStorageSync` removes keys one-by-one (see
+                // `simulator-api-storage.ts`), so prefix-scoped clears arrive as
+                // a stream of `domStorageItemRemoved` events that the filter above
+                // handles. Any `cleared` we see here is genuinely a full-origin
+                // wipe (e.g. from DevTools console) and should propagate.
+                evt = { type: 'cleared' };
+                break;
+            default:
+                return;
+        }
+        host.send(SimulatorStorageChannel.Event, evt);
     }
-    hostWc.send(SimulatorStorageChannel.Event, evt);
-}
-async function getSnapshot() {
-    if (!attachedWc || attachedWc.isDestroyed())
-        return [];
-    try {
-        const origin = await attachedWc.executeJavaScript('location.origin');
-        const result = (await attachedWc.debugger.sendCommand('DOMStorage.getDOMStorageItems', {
-            storageId: { securityOrigin: origin, isLocalStorage: true },
-        }));
-        return result.entries.map(([key, value]) => ({ key, value }));
+    /**
+     * Lazy-attach guard.
+     *
+     * The `attachToSim` call inside `web-contents-created` only fires after the
+     * simulator webview emits `did-finish-load`. UI affordances (the storage
+     * panel's "+ 新增", inline edit, delete, clear) are reachable as soon as
+     * the right-pane tab renders — which can happen BEFORE that load completes.
+     * Without this hook, a fast click bounces off `!attachedWc` and the write
+     * IPC returns `{ ok:false, error:'simulator not attached' }` silently,
+     * leaving the user (and the e2e suite) staring at a no-op.
+     *
+     * Behaviour:
+     *   - If a wc is already attached, this is a fast no-op.
+     *   - If no wc is attached, scan `webContents.getAllWebContents()` for a
+     *     simulator webview and `await attachToSim()` on the first match.
+     *   - If no simulator exists at all, leave `attachedWc` null so the
+     *     caller's existing `not attached` error branch fires — preserving
+     *     the documented contract exercised by `Set returns ok:false when
+     *     no simulator is attached`.
+     */
+    async function ensureAttached() {
+        if (attachedWc && !attachedWc.isDestroyed())
+            return;
+        const sim = findSimulatorWebContents();
+        if (!sim)
+            return;
+        await attachToSim(sim);
     }
-    catch {
-        return [];
+    async function getStorageId() {
+        if (!attachedWc || attachedWc.isDestroyed())
+            return null;
+        if (!cachedOrigin) {
+            try {
+                cachedOrigin = String(await attachedWc.executeJavaScript('location.origin'));
+            }
+            catch {
+                return null;
+            }
+        }
+        return { securityOrigin: cachedOrigin, isLocalStorage: true };
+    }
+    /**
+     * Push a storage event synthesised from the write path itself, in addition
+     * to whatever CDP forwards via `DOMStorage.domStorageItem*`. The CDP
+     * tracker has a small registration window after `DOMStorage.enable`
+     * during which the first write's notification can be dropped — the e2e
+     * `add a new entry via the footer form` case races exactly this gap when
+     * the storage tab is clicked before the simulator finishes loading and
+     * `ensureAttached()` performs the first attach. Renderer state reducers
+     * are idempotent on the same key, so an extra push from here cannot
+     * duplicate rows even when CDP also delivers.
+     *
+     * Active-prefix filtering mirrors `forwardCdpMessage` so the panel's
+     * per-appId filter behaves identically whether the event came from CDP
+     * or from this synthesised push.
+     */
+    function pushSyntheticEvent(evt) {
+        if (host.isDestroyed())
+            return;
+        const prefix = activePrefix();
+        if (prefix && !evt.key.startsWith(prefix))
+            return;
+        host.send(SimulatorStorageChannel.Event, evt);
+    }
+    async function setItem(key, value) {
+        await ensureAttached();
+        if (!attachedWc || attachedWc.isDestroyed()) {
+            return { ok: false, error: 'simulator not attached' };
+        }
+        const storageId = await getStorageId();
+        if (!storageId)
+            return { ok: false, error: 'failed to resolve simulator origin' };
+        try {
+            await attachedWc.debugger.sendCommand('DOMStorage.setDOMStorageItem', {
+                storageId,
+                key,
+                value,
+            });
+            pushSyntheticEvent({ type: 'added', key, newValue: value });
+            return { ok: true };
+        }
+        catch (e) {
+            return { ok: false, error: e.message };
+        }
+    }
+    async function removeItem(key) {
+        await ensureAttached();
+        if (!attachedWc || attachedWc.isDestroyed()) {
+            return { ok: false, error: 'simulator not attached' };
+        }
+        const storageId = await getStorageId();
+        if (!storageId)
+            return { ok: false, error: 'failed to resolve simulator origin' };
+        try {
+            await attachedWc.debugger.sendCommand('DOMStorage.removeDOMStorageItem', {
+                storageId,
+                key,
+            });
+            pushSyntheticEvent({ type: 'removed', key });
+            return { ok: true };
+        }
+        catch (e) {
+            return { ok: false, error: e.message };
+        }
+    }
+    // Scoped clear: when an appId is active, removes only its prefixed keys so
+    // we don't nuke other projects' state sharing the simulator partition.
+    // Falls back to origin-wide `DOMStorage.clear` only when no active appId is
+    // set (matches the snapshot filter's documented null-fallback).
+    async function clearScoped() {
+        await ensureAttached();
+        if (!attachedWc || attachedWc.isDestroyed()) {
+            return { ok: false, error: 'simulator not attached' };
+        }
+        const storageId = await getStorageId();
+        if (!storageId)
+            return { ok: false, error: 'failed to resolve simulator origin' };
+        const prefix = activePrefix();
+        try {
+            if (!prefix) {
+                await attachedWc.debugger.sendCommand('DOMStorage.clear', { storageId });
+                return { ok: true };
+            }
+            const result = (await attachedWc.debugger.sendCommand('DOMStorage.getDOMStorageItems', {
+                storageId,
+            }));
+            for (const [key] of result.entries) {
+                if (!key.startsWith(prefix))
+                    continue;
+                await attachedWc.debugger.sendCommand('DOMStorage.removeDOMStorageItem', {
+                    storageId,
+                    key,
+                });
+            }
+            return { ok: true };
+        }
+        catch (e) {
+            return { ok: false, error: e.message };
+        }
+    }
+    // Origin-wide clear regardless of the active appId — wipes every project's
+    // state in the shared simulator partition. The renderer guards this with a
+    // confirm dialog; we don't second-guess here.
+    async function clearAll() {
+        await ensureAttached();
+        if (!attachedWc || attachedWc.isDestroyed()) {
+            return { ok: false, error: 'simulator not attached' };
+        }
+        const storageId = await getStorageId();
+        if (!storageId)
+            return { ok: false, error: 'failed to resolve simulator origin' };
+        try {
+            await attachedWc.debugger.sendCommand('DOMStorage.clear', { storageId });
+            return { ok: true };
+        }
+        catch (e) {
+            return { ok: false, error: e.message };
+        }
+    }
+    async function getSnapshot() {
+        await ensureAttached();
+        if (!attachedWc || attachedWc.isDestroyed())
+            return [];
+        try {
+            const storageId = await getStorageId();
+            if (!storageId)
+                return [];
+            const result = (await attachedWc.debugger.sendCommand('DOMStorage.getDOMStorageItems', {
+                storageId,
+            }));
+            const prefix = activePrefix();
+            const filtered = prefix
+                ? result.entries.filter(([key]) => key.startsWith(prefix))
+                : result.entries;
+            // Keys are returned with their `${appId}_` prefix intact; stripping is
+            // a follow-up so the panel UI can stay compatible with the raw keys.
+            return filtered.map(([key, value]) => ({ key, value }));
+        }
+        catch {
+            return [];
+        }
+    }
+    // Attach to any simulator webview that already exists (project may have
+    // been opened before this function runs).
+    for (const wc of wcStatic.getAllWebContents()) {
+        if (isSimulatorWebview(wc)) {
+            void attachToSim(wc);
+            break;
+        }
     }
+    // Catch new simulator webviews on creation. did-finish-load is the right
+    // moment because getURL() may still be 'about:blank' at creation.
+    // Track each per-wc listener so it can be removed on storage dispose,
+    // and also self-clean when the wc is destroyed.
+    const wcSubs = new Map();
+    const onWcCreated = (_event, wc) => {
+        const sub = new DisposableRegistry();
+        wcSubs.set(wc, sub);
+        const onFinishLoad = () => {
+            if (isSimulatorWebview(wc))
+                void attachToSim(wc);
+        };
+        wc.on('did-finish-load', onFinishLoad);
+        sub.add(() => safeOff(wc, 'did-finish-load', onFinishLoad));
+        wc.once('destroyed', () => {
+            void sub.disposeAll().catch(() => { });
+            wcSubs.delete(wc);
+        });
+    };
+    app.on('web-contents-created', onWcCreated);
+    registry.add(() => {
+        app.removeListener('web-contents-created', onWcCreated);
+    });
+    registry.add(async () => {
+        const subs = Array.from(wcSubs.values());
+        wcSubs.clear();
+        for (const sub of subs) {
+            await sub.disposeAll().catch(() => { });
+        }
+    });
+    // IPC handlers — gated by the workbench SenderPolicy when provided so this
+    // module routes through the same C-stage sender white-list as every other
+    // workbench-built-in (main-window renderer + overlay views only). Without
+    // a policy (unit tests with mocked electron) the registry is a transparent
+    // pass-through and still owns the removeHandler lifecycle.
+    const ipc = new IpcRegistry(options.senderPolicy);
+    ipc.handle(SimulatorStorageChannel.GetSnapshot, () => getSnapshot());
+    ipc.handle(SimulatorStorageChannel.GetActivePrefix, () => activePrefix() ?? '');
+    ipc.handle(SimulatorStorageChannel.Set, (_event, payload) => setItem(String(payload?.key ?? ''), String(payload?.value ?? '')));
+    ipc.handle(SimulatorStorageChannel.Remove, (_event, payload) => removeItem(String(payload?.key ?? '')));
+    ipc.handle(SimulatorStorageChannel.Clear, () => clearScoped());
+    ipc.handle(SimulatorStorageChannel.ClearAll, () => clearAll());
+    ipc.handle(SimulatorElementChannel.Inspect, (_event, sid) => inspectElement(sid));
+    ipc.handle(SimulatorElementChannel.Clear, () => clearElementInspection());
+    registry.add(ipc);
+    // Detach active CDP session last
+    registry.add(() => detachFromSim());
+    return registry;
 }
 // Element inspection delegates to the simulator preload's __simulatorData
 // bridge via executeJavaScript. Looked up independently from `attachedWc` so
@@ -145,31 +439,4 @@ async function clearElementInspection() {
         // best-effort
     }
 }
-export function setupSimulatorStorage(host) {
-    hostWc = host;
-    // Attach to any simulator webview that already exists (project may have
-    // been opened before this function runs).
-    for (const wc of wcStatic.getAllWebContents()) {
-        if (isSimulatorWebview(wc)) {
-            void attachToSim(wc);
-            break;
-        }
-    }
-    // Catch new simulator webviews on creation. did-finish-load is the right
-    // moment because getURL() may still be 'about:blank' at creation.
-    app.on('web-contents-created', (_event, wc) => {
-        wc.on('did-finish-load', () => {
-            if (isSimulatorWebview(wc)) {
-                void attachToSim(wc);
-            }
-        });
-        wc.on('did-navigate-in-page', () => {
-            // Project switched but same webview — attach already correct, debugger
-            // session survives in-page navigations. No-op.
-        });
-    });
-    ipcMain.handle(SimulatorStorageChannel.GetSnapshot, getSnapshot);
-    ipcMain.handle(SimulatorElementChannel.Inspect, (_event, sid) => inspectElement(sid));
-    ipcMain.handle(SimulatorElementChannel.Clear, clearElementInspection);
-}
 //# sourceMappingURL=index.js.map

package/dist/main/services/update/update-manager.d.ts

@@ -1,5 +1,6 @@
 import { BrowserWindow } from 'electron';
 import type { UpdateChecker, UpdateInfo } from '../../../shared/types.js';
+import { type SenderPolicy } from '../../utils/ipc-registry.js';
 export interface UpdateManagerOptions {
     checker: UpdateChecker;
     mainWindow: BrowserWindow;
@@ -9,6 +10,13 @@ export interface UpdateManagerOptions {
     initialDelay?: number;
     /** Override the version string passed to the checker. Default: app.getVersion() */
     getCurrentVersion?: () => string;
+    /**
+     * Optional sender gate. When provided, IpcRegistry rejects invocations
+     * whose `event.sender` is not whitelisted (same C-stage policy used by
+     * every other workbench-built-in). Omitted in unit tests that mock
+     * electron without a real WebContents.
+     */
+    senderPolicy?: SenderPolicy;
 }
 export declare class UpdateManager {
     private checker;
@@ -18,6 +26,7 @@ export declare class UpdateManager {
     private downloadedPath;
     private timer;
     private initialTimer;
+    private ipc;
     constructor(opts: UpdateManagerOptions);
     private registerIpc;
     check(): Promise<{
@@ -30,7 +39,13 @@ export declare class UpdateManager {
         error?: string;
     }>;
     install(): void;
-    dispose(): void;
+    /**
+     * Tear down timers + IPC handlers. Returns a Promise so callers that need
+     * a settled cleanup (e.g. workbench registry shutdown, the unit-test
+     * lifecycle suite) can await it; calling without await is also safe since
+     * the timer clears + handler removals are scheduled synchronously.
+     */
+    dispose(): Promise<void>;
     private startPeriodicCheck;
     private checkAndNotify;
 }

package/dist/main/services/update/update-manager.js

@@ -1,4 +1,6 @@
-import { app, ipcMain, shell } from 'electron';
+import { app, shell } from 'electron';
+import { UpdateChannel } from '../../../shared/ipc-channels.js';
+import { IpcRegistry } from '../../utils/ipc-registry.js';
 export class UpdateManager {
     checker;
     mainWindow;
@@ -7,23 +9,20 @@ export class UpdateManager {
     downloadedPath = null;
     timer = null;
     initialTimer = null;
+    ipc;
     constructor(opts) {
         this.checker = opts.checker;
         this.mainWindow = opts.mainWindow;
         this.getCurrentVersion = opts.getCurrentVersion ?? (() => app.getVersion());
+        this.ipc = new IpcRegistry(opts.senderPolicy);
         this.registerIpc();
         this.startPeriodicCheck(opts.checkInterval ?? 60 * 60 * 1000, opts.initialDelay ?? 5000);
     }
     registerIpc() {
-        ipcMain.handle('updates:check', async () => {
-            return this.check();
-        });
-        ipcMain.handle('updates:download', async () => {
-            return this.download();
-        });
-        ipcMain.handle('updates:install', async () => {
-            this.install();
-        });
+        this.ipc
+            .handle(UpdateChannel.Check, async () => this.check())
+            .handle(UpdateChannel.Download, async () => this.download())
+            .handle(UpdateChannel.Install, async () => this.install());
     }
     async check() {
         try {
@@ -47,7 +46,7 @@ export class UpdateManager {
         }
         try {
             const filePath = await this.checker.downloadUpdate(this.latestUpdate, (percent) => {
-                this.mainWindow.webContents.send('updates:downloadProgress', { percent });
+                this.mainWindow.webContents.send(UpdateChannel.DownloadProgress, { percent });
             });
             this.downloadedPath = filePath;
             return { success: true, filePath };
@@ -63,6 +62,12 @@ export class UpdateManager {
             app.quit();
         }
     }
+    /**
+     * Tear down timers + IPC handlers. Returns a Promise so callers that need
+     * a settled cleanup (e.g. workbench registry shutdown, the unit-test
+     * lifecycle suite) can await it; calling without await is also safe since
+     * the timer clears + handler removals are scheduled synchronously.
+     */
     dispose() {
         if (this.timer) {
             clearInterval(this.timer);
@@ -72,9 +77,7 @@ export class UpdateManager {
             clearTimeout(this.initialTimer);
             this.initialTimer = null;
         }
-        ipcMain.removeHandler('updates:check');
-        ipcMain.removeHandler('updates:download');
-        ipcMain.removeHandler('updates:install');
+        return this.ipc.dispose();
     }
     startPeriodicCheck(interval, initialDelay) {
         this.initialTimer = setTimeout(() => void this.checkAndNotify(), initialDelay);
@@ -83,7 +86,7 @@ export class UpdateManager {
     async checkAndNotify() {
         const result = await this.check();
         if (result.hasUpdate && result.info) {
-            this.mainWindow.webContents.send('updates:available', result.info);
+            this.mainWindow.webContents.send(UpdateChannel.Available, result.info);
         }
     }
 }

package/dist/main/services/views/view-manager.d.ts

@@ -68,6 +68,10 @@ export interface ViewManager {
     hasSimulatorView(): boolean;
     /** Return the settings overlay's WebContents (for renderer-notifier). */
     getSettingsWebContents(): WebContents | null;
+    /** Return the webContents ID of the settings overlay if alive, else null. */
+    getSettingsWebContentsId(): number | null;
+    /** Return the webContents ID of the popover overlay if alive, else null. */
+    getPopoverWebContentsId(): number | null;
     /** Update lastSimWidth; reposition simulator + settings if they are added. */
     resize(simWidth: number): void;
     /** Show or hide the simulator overlay based on visibility flag. */