@dimina-kit/devtools 0.4.0-dev.20260702175315 → 0.4.0-dev.20260703051110

package/dist/main/ipc/bridge-router.js

@@ -94,6 +94,34 @@ function summarizeBridgeMsg(payload) {
 }
 /** Default timeout for a simulator-forwarded API call. */
 const API_CALL_TIMEOUT_MS = 5_000;
+// Same-appId matches prefer the MOST RECENT spawn (Maps preserve insertion
+// order): after a respawn/reopen the newest session is the live one — the
+// first match could be a just-superseded session mid-teardown. The loop must
+// scan every session (no early break) so the LAST inserted match wins.
+function findAppSessionByAppId(state, appId) {
+    let match;
+    for (const ap of state.appSessions.values())
+        if (ap.appId === appId)
+            match = ap;
+    return match;
+}
+// No appId hint and no workspace session to disambiguate. Picking by appId is
+// impossible, so fall back to the most-recent spawn — but ONLY when every live
+// session belongs to the same app. Same-appId multiples are a respawn/reopen
+// in progress where the newest is the live one (insertion order = spawn
+// order). Multiple DISTINCT appIds mean a previous project is mid-teardown
+// alongside the new one; any pick is a guess that can resolve the WRONG
+// project's content (the screenshot/inspect-stale-app bug class), so prefer
+// null over a wrong guess.
+function resolveFallbackAppSession(state) {
+    let last;
+    const distinctAppIds = new Set();
+    for (const ap of state.appSessions.values()) {
+        last = ap;
+        distinctAppIds.add(ap.appId);
+    }
+    return distinctAppIds.size <= 1 ? last : undefined;
+}
 /**
  * Resolve the "current" app session: prefer an explicit appId, else the
  * workspace's active project, else the only / most-recently-created session.
@@ -101,24 +129,15 @@ const API_CALL_TIMEOUT_MS = 5_000;
  * rather than assuming a single session.
  */
 function resolveCurrentApp(state, ctx, appId) {
-    // Same-appId matches prefer the MOST RECENT spawn (Maps preserve insertion
-    // order): after a respawn/reopen the newest session is the live one — the
-    // first match could be a just-superseded session mid-teardown.
     if (appId) {
-        let match;
-        for (const ap of state.appSessions.values())
-            if (ap.appId === appId)
-                match = ap;
+        const match = findAppSessionByAppId(state, appId);
         if (match)
             return match;
     }
     const appInfo = ctx.workspace?.getSession?.()?.appInfo;
     const activeAppId = appInfo?.appId;
     if (activeAppId) {
-        let match;
-        for (const ap of state.appSessions.values())
-            if (ap.appId === activeAppId)
-                match = ap;
+        const match = findAppSessionByAppId(state, activeAppId);
         if (match)
             return match;
     }
@@ -128,21 +147,7 @@ function resolveCurrentApp(state, ctx, appId) {
     // while a close is in flight.
     if (ctx.workspace?.isClosing?.())
         return undefined;
-    // No appId hint and no workspace session to disambiguate. Picking by appId is
-    // impossible, so fall back to the most-recent spawn — but ONLY when every live
-    // session belongs to the same app. Same-appId multiples are a respawn/reopen
-    // in progress where the newest is the live one (insertion order = spawn
-    // order). Multiple DISTINCT appIds mean a previous project is mid-teardown
-    // alongside the new one; any pick is a guess that can resolve the WRONG
-    // project's content (the screenshot/inspect-stale-app bug class), so prefer
-    // null over a wrong guess.
-    let last;
-    const distinctAppIds = new Set();
-    for (const ap of state.appSessions.values()) {
-        last = ap;
-        distinctAppIds.add(ap.appId);
-    }
-    return distinctAppIds.size <= 1 ? last : undefined;
+    return resolveFallbackAppSession(state);
 }
 export function installBridgeRouter(ctx) {
     const state = {
@@ -1136,86 +1141,119 @@ const APP_LIFECYCLE_UNREGISTER = {
     offAppHide: 'onAppHide',
     offError: 'onError',
 };
-async function handleSimulatorApi(state, ap, page, body, ctx) {
-    const name = String(body.name ?? '');
-    const params = normalizeParams(body.params);
-    if (NAV_BAR_API_NAMES.has(name)) {
-        if (!ap.simulatorWc.isDestroyed()) {
-            ap.simulatorWc.send(E.NAV_BAR, {
-                bridgeId: page.bridgeId,
-                name,
-                params,
-            });
-        }
-        const successResult = { errMsg: `${name}:ok` };
-        sendCallback(ap, params.success, successResult);
-        sendCallback(ap, params.complete, successResult);
-        return;
-    }
-    if (NAV_ACTION_NAMES.has(name)) {
-        const payload = {
-            appSessionId: ap.appSessionId,
+function handleNavBarApi(ap, page, name, params) {
+    if (!ap.simulatorWc.isDestroyed()) {
+        ap.simulatorWc.send(E.NAV_BAR, {
             bridgeId: page.bridgeId,
-            name: name,
+            name,
             params,
-            callbacks: extractCallbacks(params),
-        };
-        if (!ap.simulatorWc.isDestroyed()) {
-            ap.simulatorWc.send(E.NAV_ACTION, payload);
-        }
-        else {
-            const fail = { errMsg: `${name}:fail simulator window destroyed` };
-            sendCallback(ap, params.fail, fail);
-            sendCallback(ap, params.complete, fail);
-        }
-        return;
+        });
     }
-    if (TAB_ACTION_NAMES.has(name)) {
-        const payload = {
-            appSessionId: ap.appSessionId,
-            bridgeId: page.bridgeId,
-            name: name,
-            params,
-            callbacks: extractCallbacks(params),
-        };
-        if (!ap.simulatorWc.isDestroyed()) {
-            ap.simulatorWc.send(E.TAB_ACTION, payload);
-        }
-        else {
-            const fail = { errMsg: `${name}:fail simulator window destroyed` };
-            sendCallback(ap, params.fail, fail);
-            sendCallback(ap, params.complete, fail);
-        }
+    const successResult = { errMsg: `${name}:ok` };
+    sendCallback(ap, params.success, successResult);
+    sendCallback(ap, params.complete, successResult);
+}
+// Shared by handleNavActionApi/handleTabActionApi: both forward a same-shaped
+// payload to the simulator window, differing only in the event name and the
+// payload's static `name` union. Simulator-destroyed fails the callback
+// directly since there is no ack path to fail through otherwise.
+function sendActionOrFail(ap, eventName, payload, name, params) {
+    if (!ap.simulatorWc.isDestroyed()) {
+        ap.simulatorWc.send(eventName, payload);
         return;
     }
-    // App-level lifecycle listeners (wx.onAppShow / onAppHide / onError + off*).
-    // The service encodes the listener as a keep callback id in `params.success`;
-    // we store it and re-fire on main-window foreground/background (the driver in
-    // installBridgeRouter) and on serviceHostError. `off*` clears the event's
-    // listeners for the session.
+    const fail = { errMsg: `${name}:fail simulator window destroyed` };
+    sendCallback(ap, params.fail, fail);
+    sendCallback(ap, params.complete, fail);
+}
+function handleNavActionApi(ap, page, name, params) {
+    const payload = {
+        appSessionId: ap.appSessionId,
+        bridgeId: page.bridgeId,
+        name: name,
+        params,
+        callbacks: extractCallbacks(params),
+    };
+    sendActionOrFail(ap, E.NAV_ACTION, payload, name, params);
+}
+function handleTabActionApi(ap, page, name, params) {
+    const payload = {
+        appSessionId: ap.appSessionId,
+        bridgeId: page.bridgeId,
+        name: name,
+        params,
+        callbacks: extractCallbacks(params),
+    };
+    sendActionOrFail(ap, E.TAB_ACTION, payload, name, params);
+}
+// App-level lifecycle listeners (wx.onAppShow / onAppHide / onError + off*).
+// The service encodes the listener as a keep callback id in `params.success`;
+// we store it and re-fire on main-window foreground/background (the driver in
+// installBridgeRouter) and on serviceHostError. `off*` clears the event's
+// listeners for the session. Returns true when `name` matched a lifecycle
+// register/unregister call (fully handled), false to fall through.
+function handleAppLifecycleToggle(state, ap, name, params) {
     const lifecycleRegister = APP_LIFECYCLE_REGISTER[name];
     if (lifecycleRegister) {
         state.appLifecycle.register(ap.appSessionId, lifecycleRegister, params.success);
-        return;
+        return true;
     }
     const lifecycleUnregister = APP_LIFECYCLE_UNREGISTER[name];
     if (lifecycleUnregister) {
         // off(cb) carries the same evtId as the original on(cb) → removes just that
         // listener; off() with no callback carries no id → clears the whole event.
         state.appLifecycle.unregister(ap.appSessionId, lifecycleUnregister, params.success);
+        return true;
+    }
+    return false;
+}
+// pageScrollTo acts on the page's render guest (scroll its document), which
+// only the main process can reach — run the scroll script in the invoking
+// page's render webContents rather than forwarding to the simulator.
+function handlePageScrollApi(ap, page, params) {
+    const renderWc = page.renderWc;
+    if (renderWc && !renderWc.isDestroyed()) {
+        void renderWc.executeJavaScript(buildPageScrollScript(params)).catch(() => { });
+    }
+    const successResult = { errMsg: 'pageScrollTo:ok' };
+    sendCallback(ap, params.success, successResult);
+    sendCallback(ap, params.complete, successResult);
+}
+// Shared try/invoke/callback pattern used by the storageApi and
+// ctx.simulatorApis branches: relay the resolved value through
+// success+complete, or the thrown error through fail+complete with a
+// namespaced errMsg.
+async function invokeSimulatorApiAndCallback(ap, name, params, invoke) {
+    try {
+        const result = await invoke();
+        sendCallback(ap, params.success, result);
+        sendCallback(ap, params.complete, result);
+    }
+    catch (error) {
+        const failResult = { errMsg: `${name}:fail ${error instanceof Error ? error.message : String(error)}` };
+        sendCallback(ap, params.fail, failResult);
+        sendCallback(ap, params.complete, failResult);
+    }
+}
+async function handleSimulatorApi(state, ap, page, body, ctx) {
+    const name = String(body.name ?? '');
+    const params = normalizeParams(body.params);
+    if (NAV_BAR_API_NAMES.has(name)) {
+        handleNavBarApi(ap, page, name, params);
+        return;
+    }
+    if (NAV_ACTION_NAMES.has(name)) {
+        handleNavActionApi(ap, page, name, params);
         return;
     }
-    // pageScrollTo acts on the page's render guest (scroll its document), which
-    // only the main process can reach — run the scroll script in the invoking
-    // page's render webContents rather than forwarding to the simulator.
+    if (TAB_ACTION_NAMES.has(name)) {
+        handleTabActionApi(ap, page, name, params);
+        return;
+    }
+    if (handleAppLifecycleToggle(state, ap, name, params))
+        return;
     if (name === 'pageScrollTo') {
-        const renderWc = page.renderWc;
-        if (renderWc && !renderWc.isDestroyed()) {
-            void renderWc.executeJavaScript(buildPageScrollScript(params)).catch(() => { });
-        }
-        const successResult = { errMsg: 'pageScrollTo:ok' };
-        sendCallback(ap, params.success, successResult);
-        sendCallback(ap, params.complete, successResult);
+        handlePageScrollApi(ap, page, params);
         return;
     }
     // Native-host storage unification: route async wx.setStorage/getStorage/etc.
@@ -1224,16 +1262,8 @@ async function handleSimulatorApi(state, ap, page, body, ctx) {
     // http:// origin. Without this, async writes and sync writes diverge across
     // two origins even for the running mini-app.
     if (ctx.storageApi && STORAGE_API_NAMES.has(name)) {
-        try {
-            const result = await ctx.storageApi.invoke(ap.appId, name, params);
-            sendCallback(ap, params.success, result);
-            sendCallback(ap, params.complete, result);
-        }
-        catch (error) {
-            const failResult = { errMsg: `${name}:fail ${error instanceof Error ? error.message : String(error)}` };
-            sendCallback(ap, params.fail, failResult);
-            sendCallback(ap, params.complete, failResult);
-        }
+        const storageApi = ctx.storageApi;
+        await invokeSimulatorApiAndCallback(ap, name, params, () => storageApi.invoke(ap.appId, name, params));
         return;
     }
     // Main-process registry (downstream-registered host APIs via
@@ -1242,16 +1272,7 @@ async function handleSimulatorApi(state, ap, page, body, ctx) {
     // MiniApp owns the DOM-touching defaults (wx.getSystemInfo, chooseImage,
     // chooseMedia, fs.*, …) and the bridge-router can't run those itself.
     if (ctx.simulatorApis.has(name)) {
-        try {
-            const result = await ctx.simulatorApis.invoke(name, params);
-            sendCallback(ap, params.success, result);
-            sendCallback(ap, params.complete, result);
-        }
-        catch (error) {
-            const failResult = { errMsg: `${name}:fail ${error instanceof Error ? error.message : String(error)}` };
-            sendCallback(ap, params.fail, failResult);
-            sendCallback(ap, params.complete, failResult);
-        }
+        await invokeSimulatorApiAndCallback(ap, name, params, () => ctx.simulatorApis.invoke(name, params));
         return;
     }
     forwardApiCallToSimulator(state, ap, page, name, params);
@@ -1544,34 +1565,22 @@ function disposePageSession(state, ap, page) {
     ap.pages.delete(page.bridgeId);
     state.pageSessions.delete(page.bridgeId);
 }
-async function disposeAppSession(state, appSessionId, opts = {}) {
-    const ap = state.appSessions.get(appSessionId);
-    if (!ap)
-        return;
-    state.appSessions.delete(appSessionId);
-    // Remove this session's shutdown-fallback registry entry so the registry does
-    // not accumulate one stale closure per respawn. Ordered AFTER the delete
-    // above: dispose() runs the wrapped fn (disposeAppSession again), which
-    // early-returns now that the session is gone — no recursion, no double-run.
-    // (At whole-app shutdown the registry marks the entry released before calling
-    // the fn, so this dispose() is a no-op then.)
-    const registryHandle = ap.registryHandle;
-    ap.registryHandle = null;
-    void registryHandle?.dispose();
-    state.appLifecycle.dispose(appSessionId);
-    // Evict AppData bridges FIRST — eviction enumerates `ap.pages`, which the
-    // page teardown below progressively empties (and finally clears).
-    state.evictAppDataBridges(ap);
-    // Drain any pending API calls owned by this app session. One-shot calls
-    // normally self-clean on response/timeout, but persistent (`keep: true`)
-    // subscriptions (e.g. audioListen) live with their timer cleared until
-    // teardown — without this they would leak in pendingApiCalls forever.
+// Drain any pending API calls owned by this app session. One-shot calls
+// normally self-clean on response/timeout, but persistent (`keep: true`)
+// subscriptions (e.g. audioListen) live with their timer cleared until
+// teardown — without this they would leak in pendingApiCalls forever.
+function drainPendingApiCallsForSession(state, appSessionId) {
     for (const [requestId, pending] of state.pendingApiCalls) {
         if (pending.appSessionId !== appSessionId)
             continue;
         clearTimeout(pending.timer);
         state.pendingApiCalls.delete(requestId);
     }
+}
+// Closes every page's render guest and drops its wc/pageSessions bindings.
+// Caller clears `ap.pages` itself right after — this only tears each page
+// down, it doesn't touch the map.
+function closeSessionPages(state, ap) {
     for (const page of ap.pages.values()) {
         if (page.renderWc && !page.renderWc.isDestroyed()) {
             state.wcIdToBridgeId.delete(page.renderWc.id);
@@ -1588,15 +1597,11 @@ async function disposeAppSession(state, appSessionId, opts = {}) {
         }
         state.pageSessions.delete(page.bridgeId);
     }
-    ap.pages.clear();
-    // Detach every session-scoped hook on emitters that outlive this session —
-    // the shared simulator WCV's 'destroyed' and the service window's 'closed' —
-    // BEFORE the window is released/closed below: a pool-recycled window must
-    // not re-trigger this session's teardown from a stale 'closed', and the
-    // simulator wc must not accumulate one dead hook per soft reload until the
-    // MaxListeners warning fires. Idempotent with teardown being triggered BY
-    // one of these hooks (removing a fired once() is a no-op).
-    ap.listenerBag.dispose();
+}
+// Three-way release of the session's service-host window: pool release (soft
+// reuse), pool reclaim of an externally-closed window, or a plain close for
+// the unpooled path.
+async function releaseServiceWindow(state, ap, opts) {
     if (ap.poolEntryId !== null && state.pool && !opts.serviceAlreadyClosed) {
         // Soft reuse (foundation.md §4.3): the pooled service-host webContents keeps
         // its wc.id but is about to run a NEW app session. Reset its Connection
@@ -1623,12 +1628,14 @@ async function disposeAppSession(state, appSessionId, opts = {}) {
         // pool only auto-reclaims on render-process-gone — so without this the in-use
         // entry leaks in the pool forever, permanently shrinking capacity. Reclaim
         // the slot explicitly (the window is already gone; releaseDestroyed won't
-        // touch it). (Audit A1)
+        // touch it).
         state.pool.releaseDestroyed(ap.poolEntryId);
     }
     else if (!opts.serviceAlreadyClosed && !ap.serviceWindow.isDestroyed()) {
         ap.serviceWindow.close();
     }
+}
+function unbindSessionFromSharedMaps(state, ap, appSessionId) {
     // Value-checked unbind for the service wc: this delete runs after the
     // pool-release await above, so on the pool path the next spawn may have
     // already re-acquired the SAME window and rebound its wc id — only remove
@@ -1645,6 +1652,38 @@ async function disposeAppSession(state, appSessionId, opts = {}) {
         if (hosted.size === 0)
             state.simulatorWcIdToAppSessionIds.delete(ap.simulatorWc.id);
     }
+}
+async function disposeAppSession(state, appSessionId, opts = {}) {
+    const ap = state.appSessions.get(appSessionId);
+    if (!ap)
+        return;
+    state.appSessions.delete(appSessionId);
+    // Remove this session's shutdown-fallback registry entry so the registry does
+    // not accumulate one stale closure per respawn. Ordered AFTER the delete
+    // above: dispose() runs the wrapped fn (disposeAppSession again), which
+    // early-returns now that the session is gone — no recursion, no double-run.
+    // (At whole-app shutdown the registry marks the entry released before calling
+    // the fn, so this dispose() is a no-op then.)
+    const registryHandle = ap.registryHandle;
+    ap.registryHandle = null;
+    void registryHandle?.dispose();
+    state.appLifecycle.dispose(appSessionId);
+    // Evict AppData bridges FIRST — eviction enumerates `ap.pages`, which the
+    // page teardown below progressively empties (and finally clears).
+    state.evictAppDataBridges(ap);
+    drainPendingApiCallsForSession(state, appSessionId);
+    closeSessionPages(state, ap);
+    ap.pages.clear();
+    // Detach every session-scoped hook on emitters that outlive this session —
+    // the shared simulator WCV's 'destroyed' and the service window's 'closed' —
+    // BEFORE the window is released/closed below: a pool-recycled window must
+    // not re-trigger this session's teardown from a stale 'closed', and the
+    // simulator wc must not accumulate one dead hook per soft reload until the
+    // MaxListeners warning fires. Idempotent with teardown being triggered BY
+    // one of these hooks (removing a fired once() is a no-op).
+    ap.listenerBag.dispose();
+    await releaseServiceWindow(state, ap, opts);
+    unbindSessionFromSharedMaps(state, ap, appSessionId);
     // Only the local fallback server needs closing; the dev-server base is owned
     // by the workspace session, not this app session.
     if (ap.resourceServer) {

package/dist/main/ipc/project-fs.js

@@ -468,6 +468,40 @@ function writeFileSync(root, p, content) {
         nodeFs.closeSync(fd);
     }
 }
+/**
+ * Reads one directory's entries. Returns `null` (caller skips the directory)
+ * for `EACCES`/`ENOENT`/`ENOTDIR` — a directory can disappear or become
+ * unreadable between being queued and being walked. Any other error is
+ * rethrown.
+ */
+async function readDirEntriesSafe(dir) {
+    try {
+        return await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'EACCES' || code === 'ENOENT' || code === 'ENOTDIR')
+            return null;
+        throw err;
+    }
+}
+/**
+ * Classifies one readdir entry: a non-`SKIP_DIRS` directory is queued for
+ * walking; a plain file is recorded as a `safeRoot`-relative POSIX path.
+ * Skipped directories and non-file/non-directory entries (symlinks, sockets,
+ * etc.) are a no-op.
+ */
+function collectListEntry(entry, dir, safeRoot, out, queue) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+        if (!SKIP_DIRS.has(entry.name))
+            queue.push(full);
+        return;
+    }
+    if (entry.isFile()) {
+        out.push(path.relative(safeRoot, full).split(path.sep).join('/'));
+    }
+}
 async function listFiles(root, rootArg) {
     const safeRoot = await resolveWithinProjectRoot(rootArg, root);
     const out = [];
@@ -476,29 +510,13 @@ async function listFiles(root, rootArg) {
         if (out.length >= LIST_FILE_LIMIT)
             break;
         const dir = queue.shift();
-        let entries;
-        try {
-            entries = await fs.readdir(dir, { withFileTypes: true });
-        }
-        catch (err) {
-            const code = err.code;
-            if (code === 'EACCES' || code === 'ENOENT' || code === 'ENOTDIR')
-                continue;
-            throw err;
-        }
-        for (const e of entries) {
+        const entries = await readDirEntriesSafe(dir);
+        if (entries === null)
+            continue;
+        for (const entry of entries) {
             if (out.length >= LIST_FILE_LIMIT)
                 break;
-            const full = path.join(dir, e.name);
-            if (e.isDirectory()) {
-                if (SKIP_DIRS.has(e.name))
-                    continue;
-                queue.push(full);
-                continue;
-            }
-            if (!e.isFile())
-                continue;
-            out.push(path.relative(safeRoot, full).split(path.sep).join('/'));
+            collectListEntry(entry, dir, safeRoot, out, queue);
         }
     }
     return out;