@dimina-kit/devtools 0.4.0-dev.20260828161241 → 0.4.0-dev.20260907055341

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

@@ -11,82 +11,108 @@
  */
 import CDP from 'chrome-remote-interface';
 import { DEFAULT_CDP_PORT } from '../../../shared/constants.js';
-import { DMB_PAGEFRAME_DOC_NAME } from '../../../shared/dmb-resource-url.js';
-const SIMULATOR_URL_PATTERN = 'localhost:7788';
-// Native-host: the real mini-app page runs in a nested render-host <webview>
-// guest whose CDP target URL carries the render frame + the page's bridgeId.
-// Import the shared reserved doc name rather than hand-writing a second
-// literal — that duplication is exactly what let this pattern drift out of
-// sync with the actual document URL shape (dmb-resource-url.ts).
-const RENDER_GUEST_PATTERN = DMB_PAGEFRAME_DOC_NAME;
+import { connectionOwner } from './connection-owner.js';
+import { selectSimulatorTarget, selectWorkbenchTarget } from './target-selection.js';
+// Re-exported so existing `./target-manager.js` imports keep working — the
+// candidate-ranking rules live in target-selection.ts, but callers reach them
+// through the connection manager that uses them.
+export { selectSimulatorTarget, selectWorkbenchTarget } from './target-selection.js';
 const MAX_BUFFER = 500;
 const RECONNECT_INTERVAL_MS = 3000;
+// How long a burst of focus changes is allowed to settle before the live
+// connections are re-aimed.
+const ACTIVE_WINDOW_SETTLE_MS = 150;
 let cdpPort = DEFAULT_CDP_PORT;
-// Native-host mode: the simulator target is the active render-host <webview>
-// guest (pageFrame.html?...bridgeId=<id>) rather than the localhost:7788 shell.
-let nativeHostMode = false;
-// The visible page's bridgeId, pushed from the bridge-router render events.
-// `selectSimulatorTarget` prefers the guest matching this id so MCP follows
-// the active page across navigation/tab switches.
-let activeBridgeId = null;
-let nativeOverviewProvider = null;
-const targets = {
-    simulator: { client: null, connected: false, timer: null, consoleLogs: [], networkRequests: [] },
-    workbench: { client: null, connected: false, timer: null, consoleLogs: [], networkRequests: [] },
-};
-export function setCdpPort(port) {
-    cdpPort = port;
+const windowFacts = new Map();
+let resolveActiveOwner = () => null;
+/**
+ * Point MCP at the window the user is working in. Assembled once by the app;
+ * `owner` is the opaque token a window registered itself under. Resolving to
+ * null means no project window is open, which is the answer MCP reports before
+ * the first project is opened.
+ */
+export function setActiveMcpWindowResolver(resolve) {
+    resolveActiveOwner = resolve;
 }
-export function setNativeHost(enabled) {
-    nativeHostMode = enabled;
+export function registerMcpWindow(owner, facts) {
+    windowFacts.set(owner, facts);
+    return {
+        facts,
+        dispose: () => {
+            // Only this window's record: other project windows may still be open and
+            // their native-host state has to survive this teardown.
+            if (windowFacts.get(owner) === facts)
+                windowFacts.delete(owner);
+        },
+    };
+}
+/** The facts of the project window MCP currently drives, or null when none is open. */
+export function activeMcpWindow() {
+    const owner = resolveActiveOwner();
+    return (owner !== null && windowFacts.get(owner)) || null;
 }
 /**
- * Update the active-page bridgeId so the `simulator` target follows the
- * currently visible render guest. No-op when unchanged. When native-host is
- * on and the simulator target is already connected, fire-and-forget a
- * reconnect so MCP re-points at the new active page.
+ * Record the render guest now visible in `owner`'s window. Re-points the live
+ * simulator connection only when that window is the one MCP drives — a
+ * navigation in a background project window must not steal the target.
  */
-export function setActiveBridgeId(id) {
-    if (id === activeBridgeId)
+export function noteActiveBridgeId(owner, id) {
+    const facts = windowFacts.get(owner);
+    if (!facts || facts.activeBridgeId === id)
         return;
-    activeBridgeId = id;
-    if (nativeHostMode && targets.simulator.connected) {
+    facts.activeBridgeId = id;
+    if (facts.nativeHost && resolveActiveOwner() === owner && targets.simulator.connected) {
         void connectTarget('simulator');
     }
 }
-export function setNativeOverviewProvider(provider) {
-    nativeOverviewProvider = provider;
-}
-export function getNativeOverviewProvider() {
-    return nativeOverviewProvider;
-}
 /**
- * Resolve which CDP target the `simulator` MCP tools should drive.
+ * The active project window changed. A connection that is already established
+ * was aimed at whichever window was active when it was made, and nothing
+ * re-read that afterwards — so without this the MCP tools keep reporting and
+ * driving the project the user has left. Only connections bound to a different
+ * window are re-aimed; the rest are left alone.
  *
- * Default (non-native) path: the localhost:7788 simulator shell — identical
- * to the original behavior; `activeBridgeId` is ignored.
- *
- * Native-host path: the active render-host <webview> guest
- * (pageFrame.html?...bridgeId=<id>), preferring the guest matching
- * `activeBridgeId`, then any pageFrame guest, then degrading to the shell.
+ * Coalesced on purpose: clicking across windows produces a burst of these, and
+ * re-resolving once the burst settles means focus that returns to the window a
+ * connection already holds costs nothing.
  */
-export function selectSimulatorTarget(targets, opts) {
-    if (!opts.nativeHost) {
-        return targets.find((t) => t.url?.includes(SIMULATOR_URL_PATTERN));
-    }
-    // 1) Active-bridge guest takes priority over list order.
-    if (opts.activeBridgeId !== null) {
-        const bridgeMatch = `bridgeId=${opts.activeBridgeId}`;
-        const active = targets.find((t) => t.url?.includes(RENDER_GUEST_PATTERN) && t.url.includes(bridgeMatch));
-        if (active)
-            return active;
-    }
-    // 2) Any render guest (no active match / no active bridge).
-    const anyGuest = targets.find((t) => t.url?.includes(RENDER_GUEST_PATTERN));
-    if (anyGuest)
-        return anyGuest;
-    // 3) Degrade to the localhost:7788 shell when no render guest exists yet.
-    return targets.find((t) => t.url?.includes(SIMULATOR_URL_PATTERN));
+export function noteActiveMcpWindowChanged() {
+    if (repointTimer)
+        return;
+    repointTimer = setTimeout(() => {
+        repointTimer = null;
+        const owner = resolveActiveOwner();
+        // A window whose facts are already gone is on its way out: its pages are
+        // about to be destroyed, so connecting into them would only produce a
+        // client that immediately disconnects. The reconnect timer picks up
+        // whichever window replaces it.
+        if (owner !== null && !windowFacts.has(owner))
+            return;
+        for (const kind of Object.keys(targets)) {
+            if (!targets[kind].connected || targets[kind].owner === owner)
+                continue;
+            void connectTarget(kind);
+        }
+    }, ACTIVE_WINDOW_SETTLE_MS);
+}
+// The two CDP connections are process-wide on purpose: MCP exposes one
+// `simulator` and one `workbench` target with no window argument, so both
+// always mean "the project the user is working in". Which window that is comes
+// from `activeMcpWindow()` on every (re)connect, so the pair follows the
+// active window rather than belonging to any one of them.
+const targets = {
+    simulator: { client: null, connected: false, owner: null, timer: null, consoleLogs: [], networkRequests: [], bufferOwner: null },
+    workbench: { client: null, connected: false, owner: null, timer: null, consoleLogs: [], networkRequests: [], bufferOwner: null },
+};
+/** Monotonic per target: only the newest connect attempt may publish itself. */
+const connectGeneration = { simulator: 0, workbench: 0 };
+let repointTimer = null;
+export function setCdpPort(port) {
+    cdpPort = port;
+}
+/** The cross-process overview reader of the window MCP drives, if it has one. */
+export function getNativeOverviewProvider() {
+    return activeMcpWindow()?.nativeOverviewProvider ?? null;
 }
 export function getTargetState(kind) {
     return targets[kind];
@@ -100,27 +126,150 @@ async function listCdpTargets() {
     }
 }
 export { listCdpTargets as listTargets };
+/**
+ * `selectWorkbenchTarget` already matches on the active window's exact
+ * `projectPath`, so no candidate ranking is blind to ownership there — the
+ * match is exact or nothing, with nothing left for a pre-filter to change.
+ */
+function findWorkbenchTarget(allTargets) {
+    const active = activeMcpWindow();
+    return selectWorkbenchTarget(allTargets, { projectPath: active ? active.projectPath : null });
+}
+/**
+ * `selectSimulatorTarget` ranks candidates by a fixed priority order with no
+ * idea which window each one belongs to, and its "any guest" tier in
+ * particular has no way to tell a stray guest left over from another window
+ * apart from a legitimate one.
+ *
+ * Once the active window has an `activeBridgeId` of its own, it is known to
+ * be genuinely on a native page and merely waiting for that specific guest
+ * target to show up in the CDP list — connecting to whatever guest IS present
+ * and letting the post-connect ownership check below reject a wrong one is a
+ * reasonable, existing way to close that timing gap, so ranking stays
+ * unfiltered in that case.
+ *
+ * Before any page is known for this window (`activeBridgeId === null`, which
+ * is also always true for non-native windows), though, "any guest present"
+ * carries no signal it belongs to THIS window at all — so ranking is
+ * restricted to targets `connectionOwner` attributes to the active window,
+ * falling back to the raw list only when none of them qualify (the same
+ * retry-and-reject cadence as the unfiltered path, for a candidate list that
+ * belongs to no window MCP can currently claim).
+ */
+function findSimulatorTarget(allTargets) {
+    const active = activeMcpWindow();
+    const opts = { nativeHost: active?.nativeHost ?? false, activeBridgeId: active?.activeBridgeId ?? null };
+    if (opts.activeBridgeId !== null)
+        return selectSimulatorTarget(allTargets, opts);
+    const intended = resolveActiveOwner();
+    const owned = allTargets.filter((t) => connectionOwner('simulator', t.url, intended, windowFacts).onTarget);
+    return selectSimulatorTarget(owned, opts) ?? selectSimulatorTarget(allTargets, opts);
+}
 function findTarget(allTargets, kind) {
-    if (kind === 'simulator') {
-        return selectSimulatorTarget(allTargets, { nativeHost: nativeHostMode, activeBridgeId });
+    return kind === 'simulator' ? findSimulatorTarget(allTargets) : findWorkbenchTarget(allTargets);
+}
+/**
+ * Console and network events into this target's ring buffers, which is all
+ * these subscriptions do — they hold no view of which window is connected, so
+ * they outlive nothing and need no generation check of their own.
+ */
+function subscribeBuffers(client, state) {
+    const pending = new Map();
+    const pushNetworkRequest = (entry) => {
+        state.networkRequests.push(entry);
+        if (state.networkRequests.length > MAX_BUFFER)
+            state.networkRequests = state.networkRequests.slice(-MAX_BUFFER);
+    };
+    const pushConsoleLog = (entry) => {
+        state.consoleLogs.push(entry);
+        if (state.consoleLogs.length > MAX_BUFFER)
+            state.consoleLogs = state.consoleLogs.slice(-MAX_BUFFER);
+    };
+    client.Runtime.on('consoleAPICalled', (params) => {
+        pushConsoleLog({
+            level: params.type,
+            text: params.args.map((a) => String(a.value ?? a.description ?? JSON.stringify(a))).join(' '),
+            timestamp: new Date(params.timestamp).toISOString(),
+        });
+    });
+    client.Console.on('messageAdded', (params) => {
+        const msg = params.message;
+        pushConsoleLog({ level: msg.level, text: msg.text, timestamp: new Date().toISOString() });
+    });
+    client.Network.on('requestWillBeSent', (params) => {
+        pending.set(params.requestId, { url: params.request.url, method: params.request.method, timestamp: params.timestamp });
+    });
+    client.Network.on('responseReceived', (params) => {
+        const req = pending.get(params.requestId);
+        if (!req)
+            return;
+        pending.delete(params.requestId);
+        pushNetworkRequest({
+            url: req.url, method: req.method,
+            status: params.response.status, mimeType: params.response.mimeType,
+            responseSize: params.response.encodedDataLength || 0,
+            timing: params.response.timing
+                ? { requestTime: params.response.timing.requestTime, receiveHeadersEnd: params.response.timing.receiveHeadersEnd }
+                : null,
+        });
+    });
+    client.Network.on('loadingFailed', (params) => {
+        const req = pending.get(params.requestId);
+        if (!req)
+            return;
+        pending.delete(params.requestId);
+        pushNetworkRequest({ url: req.url, method: req.method, status: 0, mimeType: '', responseSize: 0, timing: null });
+    });
+}
+/** Closing a client is never the reason an attempt fails. */
+async function closeQuietly(client) {
+    if (!client)
+        return;
+    try {
+        await client.close();
+    }
+    catch { }
+}
+/** No usable target right now: publish nothing and keep retrying. */
+function loseTarget(kind) {
+    const state = targets[kind];
+    state.client = null;
+    state.connected = false;
+    state.owner = null;
+    scheduleReconnect(kind);
+}
+/** Publish a connection that survived the race, on the window it reached. */
+function publishConnection(kind, client, owner) {
+    const state = targets[kind];
+    state.client = client;
+    state.connected = true;
+    state.owner = owner;
+    if (state.timer) {
+        clearTimeout(state.timer);
+        state.timer = null;
     }
-    // workbench main window: page target whose URL contains index.html (renderer)
-    return allTargets.find((t) => t.type === 'page' && t.url?.includes('entries/main/index.html') && !t.url?.includes(SIMULATOR_URL_PATTERN));
 }
 export async function connectTarget(kind) {
     const state = targets[kind];
+    // Establishing a connection is a long chain of awaits, and the reason to
+    // establish it — which window is active, which page it shows — can change
+    // while that chain runs. An attempt overtaken by a newer one must publish
+    // nothing, close the client it opened, and schedule no work.
+    const generation = (connectGeneration[kind] += 1);
+    const superseded = () => connectGeneration[kind] !== generation;
     if (state.client) {
-        try {
-            await state.client.close();
-        }
-        catch { }
+        const previous = state.client;
         state.client = null;
+        await closeQuietly(previous);
+        if (superseded())
+            return;
     }
     const allTargets = await listCdpTargets();
     const target = findTarget(allTargets, kind);
+    if (superseded())
+        return;
     if (!target) {
-        state.connected = false;
-        scheduleReconnect(kind);
+        loseTarget(kind);
         return;
     }
     let client = null;
@@ -133,83 +282,54 @@ export async function connectTarget(kind) {
             client.Network.enable(),
             client.Console.enable(),
         ]);
-        // Network buffer
-        const pending = new Map();
-        const pushNetworkRequest = (entry) => {
-            state.networkRequests.push(entry);
-            if (state.networkRequests.length > MAX_BUFFER)
-                state.networkRequests = state.networkRequests.slice(-MAX_BUFFER);
-        };
-        // Console buffer
-        client.Runtime.on('consoleAPICalled', (params) => {
-            const entry = {
-                level: params.type,
-                text: params.args.map((a) => String(a.value ?? a.description ?? JSON.stringify(a))).join(' '),
-                timestamp: new Date(params.timestamp).toISOString(),
-            };
-            state.consoleLogs.push(entry);
-            if (state.consoleLogs.length > MAX_BUFFER)
-                state.consoleLogs = state.consoleLogs.slice(-MAX_BUFFER);
-        });
-        client.Console.on('messageAdded', (params) => {
-            const msg = params.message;
-            state.consoleLogs.push({ level: msg.level, text: msg.text, timestamp: new Date().toISOString() });
-            if (state.consoleLogs.length > MAX_BUFFER)
-                state.consoleLogs = state.consoleLogs.slice(-MAX_BUFFER);
-        });
-        client.Network.on('requestWillBeSent', (params) => {
-            pending.set(params.requestId, { url: params.request.url, method: params.request.method, timestamp: params.timestamp });
-        });
-        client.Network.on('responseReceived', (params) => {
-            const req = pending.get(params.requestId);
-            if (!req)
-                return;
-            pending.delete(params.requestId);
-            pushNetworkRequest({
-                url: req.url, method: req.method,
-                status: params.response.status, mimeType: params.response.mimeType,
-                responseSize: params.response.encodedDataLength || 0,
-                timing: params.response.timing
-                    ? { requestTime: params.response.timing.requestTime, receiveHeadersEnd: params.response.timing.receiveHeadersEnd }
-                    : null,
-            });
-        });
-        client.Network.on('loadingFailed', (params) => {
-            const req = pending.get(params.requestId);
-            if (!req)
+        // Everything below subscribes or publishes, so an attempt that lost the
+        // race stops here and leaves nothing behind but its own closed client.
+        if (superseded()) {
+            await closeQuietly(client);
+            return;
+        }
+        // Which window this target belongs to is resolved here, not when the
+        // attempt started: an attempt that outlived a window switch has to be
+        // judged against the window the user is in now. MCP exposes ONE client per
+        // kind, so a target belonging to another window leaves nothing behind at
+        // all — buffers wired to it would mix that window's console and network
+        // events into the ones the eventual right connection appends to, and
+        // `connected` would hand it out meanwhile. The retry cadence is the only
+        // thing that carries over: the exact target may still be loading.
+        const binding = connectionOwner(kind, target.url, resolveActiveOwner(), windowFacts);
+        if (!binding.onTarget) {
+            await closeQuietly(client);
+            if (superseded())
                 return;
-            pending.delete(params.requestId);
-            pushNetworkRequest({
-                url: req.url,
-                method: req.method,
-                status: 0,
-                mimeType: '',
-                responseSize: 0,
-                timing: null,
-            });
-        });
+            loseTarget(kind);
+            return;
+        }
+        // Buffers are keyed to the owner they were collected for, not to the
+        // kind slot: a reconnect landing on the SAME owner (a transient CDP drop)
+        // must keep what was already buffered, but re-aiming at a different
+        // window must not let that window inherit the previous owner's entries.
+        if (state.bufferOwner !== binding.owner) {
+            state.consoleLogs = [];
+            state.networkRequests = [];
+            state.bufferOwner = binding.owner;
+        }
+        subscribeBuffers(client, state);
         client.on('disconnect', () => {
+            // A superseded client is closed on purpose; only the live connection
+            // going away means MCP has lost its target.
+            if (superseded())
+                return;
             state.connected = false;
             state.client = null;
             scheduleReconnect(kind);
         });
-        state.client = client;
-        state.connected = true;
-        if (state.timer) {
-            clearTimeout(state.timer);
-            state.timer = null;
-        }
+        publishConnection(kind, client, binding.owner);
     }
     catch {
-        if (client) {
-            try {
-                await client.close();
-            }
-            catch { }
-        }
-        state.client = null;
-        state.connected = false;
-        scheduleReconnect(kind);
+        await closeQuietly(client);
+        if (superseded())
+            return;
+        loseTarget(kind);
     }
 }
 function scheduleReconnect(kind) {
@@ -223,10 +343,17 @@ function scheduleReconnect(kind) {
 }
 export function getClient(kind) {
     const state = targets[kind];
+    const label = kind === 'simulator' ? '模拟器' : '主窗口';
     if (!state.connected || !state.client) {
-        const label = kind === 'simulator' ? '模拟器' : '主窗口';
         throw new Error(`未连接到${label}。请确保 dimina-devtools 正在以开发模式运行。`);
     }
+    // A focus change re-aims the live connections only once the burst settles,
+    // and during that gap the client still belongs to the window the user left.
+    // Answering from it would report and drive the wrong project, so the caller
+    // waits for the re-aim instead.
+    if (state.owner !== resolveActiveOwner()) {
+        throw new Error(`${label}连接属于已切换的项目窗口，正在重新连接，请稍后重试。`);
+    }
     return state.client;
 }
 //# sourceMappingURL=target-manager.js.map

package/dist/main/services/mcp/target-selection.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Pure candidate-ranking rules for the two MCP CDP targets.
+ *
+ * Split out of target-manager.ts: these functions only rank a raw CDP.List
+ * result by URL shape and carry no connection state of their own, so they can
+ * be pinned with direct unit tests independent of the connection lifecycle.
+ */
+/**
+ * Resolve which CDP target the `simulator` MCP tools should drive.
+ *
+ * Default (non-native) path: the localhost:7788 simulator shell — identical
+ * to the original behavior; `activeBridgeId` is ignored.
+ *
+ * Native-host path: the active render-host <webview> guest
+ * (pageFrame.html?...bridgeId=<id>), preferring the guest matching
+ * `activeBridgeId`, then any pageFrame guest, then degrading to the shell.
+ */
+export declare function selectSimulatorTarget<T extends {
+    url?: string;
+    type?: string;
+}>(targets: T[], opts: {
+    nativeHost: boolean;
+    activeBridgeId: string | null;
+}): T | undefined;
+/**
+ * Resolve which CDP target the `workbench` MCP tools should drive.
+ *
+ * `projectPath` is the active project window's path, fixed when that window
+ * opened; null when no project window is open, and then the project list is
+ * the only workbench surface.
+ *
+ * A project window names its own renderer from the moment it exists, so the
+ * match is exact or nothing: another project's workbench page, or the project
+ * list standing in for a project that IS open, would leave every workbench
+ * tool answering for the wrong window with nothing to correct it.
+ *
+ * Matching is on the renderer ENTRY, never on "the URL mentions the project
+ * directory" — the service-host window carries the same directory in its own
+ * `pkgRoot` query and would win a substring match.
+ */
+export declare function selectWorkbenchTarget<T extends {
+    url?: string;
+    type?: string;
+}>(candidates: T[], opts: {
+    projectPath: string | null;
+}): T | undefined;
+//# sourceMappingURL=target-selection.d.ts.map

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

@@ -0,0 +1,71 @@
+/**
+ * Pure candidate-ranking rules for the two MCP CDP targets.
+ *
+ * Split out of target-manager.ts: these functions only rank a raw CDP.List
+ * result by URL shape and carry no connection state of their own, so they can
+ * be pinned with direct unit tests independent of the connection lifecycle.
+ */
+import { DMB_PAGEFRAME_DOC_NAME } from '../../../shared/dmb-resource-url.js';
+import { targetQuery } from './connection-owner.js';
+const SIMULATOR_URL_PATTERN = 'localhost:7788';
+// The two renderer entries MCP can drive: a project's workbench window and the
+// always-present project list.
+const WORKBENCH_ENTRY = 'entries/workbench/index.html';
+const PROJECT_LIST_ENTRY = 'entries/main/index.html';
+// Native-host: the real mini-app page runs in a nested render-host <webview>
+// guest whose CDP target URL carries the render frame + the page's bridgeId.
+// Import the shared reserved doc name rather than hand-writing a second
+// literal — that duplication is exactly what let this pattern drift out of
+// sync with the actual document URL shape (dmb-resource-url.ts).
+const RENDER_GUEST_PATTERN = DMB_PAGEFRAME_DOC_NAME;
+/**
+ * Resolve which CDP target the `simulator` MCP tools should drive.
+ *
+ * Default (non-native) path: the localhost:7788 simulator shell — identical
+ * to the original behavior; `activeBridgeId` is ignored.
+ *
+ * Native-host path: the active render-host <webview> guest
+ * (pageFrame.html?...bridgeId=<id>), preferring the guest matching
+ * `activeBridgeId`, then any pageFrame guest, then degrading to the shell.
+ */
+export function selectSimulatorTarget(targets, opts) {
+    if (!opts.nativeHost) {
+        return targets.find((t) => t.url?.includes(SIMULATOR_URL_PATTERN));
+    }
+    // 1) Active-bridge guest takes priority over list order.
+    if (opts.activeBridgeId !== null) {
+        const bridgeMatch = `bridgeId=${opts.activeBridgeId}`;
+        const active = targets.find((t) => t.url?.includes(RENDER_GUEST_PATTERN) && t.url.includes(bridgeMatch));
+        if (active)
+            return active;
+    }
+    // 2) Any render guest (no active match / no active bridge).
+    const anyGuest = targets.find((t) => t.url?.includes(RENDER_GUEST_PATTERN));
+    if (anyGuest)
+        return anyGuest;
+    // 3) Degrade to the localhost:7788 shell when no render guest exists yet.
+    return targets.find((t) => t.url?.includes(SIMULATOR_URL_PATTERN));
+}
+/**
+ * Resolve which CDP target the `workbench` MCP tools should drive.
+ *
+ * `projectPath` is the active project window's path, fixed when that window
+ * opened; null when no project window is open, and then the project list is
+ * the only workbench surface.
+ *
+ * A project window names its own renderer from the moment it exists, so the
+ * match is exact or nothing: another project's workbench page, or the project
+ * list standing in for a project that IS open, would leave every workbench
+ * tool answering for the wrong window with nothing to correct it.
+ *
+ * Matching is on the renderer ENTRY, never on "the URL mentions the project
+ * directory" — the service-host window carries the same directory in its own
+ * `pkgRoot` query and would win a substring match.
+ */
+export function selectWorkbenchTarget(candidates, opts) {
+    const pages = candidates.filter((t) => t.type === 'page' && !t.url?.includes(SIMULATOR_URL_PATTERN));
+    if (opts.projectPath === null)
+        return pages.find((t) => t.url?.includes(PROJECT_LIST_ENTRY));
+    return pages.find((t) => t.url?.includes(WORKBENCH_ENTRY) && targetQuery(t.url, 'path') === opts.projectPath);
+}
+//# sourceMappingURL=target-selection.js.map

package/dist/main/services/mcp/tools/context-tools.js

@@ -136,8 +136,21 @@ export function registerContextTools(server) {
             return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
         }
         let result;
+        // Snapshot the provider AND the console/network summaries in the same
+        // tick as `getClient`: the provider reads the active window live off
+        // `resolveActiveOwner()`, and the buffers are process-wide and get
+        // cleared and re-owned the moment a reconnect lands on another window.
+        // Both awaits below (the CDP probe, the native provider) are windows the
+        // user can switch projects during; reading either after them would mix
+        // this window's probe with whichever window is active by then.
+        let nativeOverviewProvider;
+        let consoleSum;
+        let networkSum;
         try {
             const c = getClient('simulator');
+            nativeOverviewProvider = getNativeOverviewProvider();
+            consoleSum = summarizeConsole('simulator');
+            networkSum = summarizeNetwork('simulator');
             result = await c.Runtime.evaluate({ expression: SIMULATOR_PROBE_EXPR, returnByValue: true });
         }
         catch {
@@ -160,7 +173,6 @@ export function registerContextTools(server) {
                 isError: true,
             };
         }
-        const nativeOverviewProvider = getNativeOverviewProvider();
         if (nativeOverviewProvider) {
             try {
                 const nativeOverview = await nativeOverviewProvider();
@@ -182,8 +194,6 @@ export function registerContextTools(server) {
             hints.push('no active miniapp page (empty page stack)');
         if (probe.storageCount > MAX_KEYS)
             hints.push(`storageKeys truncated to first ${MAX_KEYS} of ${probe.storageCount}`);
-        const consoleSum = summarizeConsole('simulator');
-        const networkSum = summarizeNetwork('simulator');
         const payload = {
             connected: true,
             url: probe.url,
@@ -213,8 +223,15 @@ export function registerContextTools(server) {
             return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
         }
         let result;
+        // Same snapshot rule as the simulator overview: the buffers belong to
+        // the connection `getClient` just vouched for, so they are read before
+        // the probe's await, not after it.
+        let consoleSum;
+        let networkSum;
         try {
             const c = getClient('workbench');
+            consoleSum = summarizeConsole('workbench');
+            networkSum = summarizeNetwork('workbench');
             result = await c.Runtime.evaluate({ expression: WORKBENCH_PROBE_EXPR, returnByValue: true });
         }
         catch {
@@ -237,8 +254,6 @@ export function registerContextTools(server) {
                 isError: true,
             };
         }
-        const consoleSum = summarizeConsole('workbench');
-        const networkSum = summarizeNetwork('workbench');
         const payload = {
             connected: true,
             url: probe.url,