@dimina-kit/devtools 0.4.0 → 0.5.0

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

@@ -15,11 +15,12 @@ import { connectTarget, setCdpPort } from './target-manager.js';
 import { recordMcpFailed, recordMcpStarted, recordMcpStopped } from './status.js';
 import { registerCommonTargetTools } from './tool-registry.js';
 import { registerContextTools } from './tools/context-tools.js';
+import { registerProjectTools } from './tools/project-tools.js';
 import { registerSimulatorTools } from './tools/simulator-tools.js';
 import { registerWorkbenchTools } from './tools/workbench-tools.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../../../../package.json');
-function buildServer() {
+function buildServer(projectHost) {
     const server = new McpServer({
         name: '@dimina-kit/devtools',
         version: pkg.version,
@@ -32,14 +33,15 @@ function buildServer() {
     registerWorkbenchTools(server);
     // Cross-target: AI orientation overview
     registerContextTools(server);
+    // Project lifecycle (open/close/status/wait/compile logs).
+    registerProjectTools(server, projectHost);
     return server;
 }
-export function startMcpServer(resolvedCdpPort, mcpPort) {
+export function startMcpServer(resolvedCdpPort, mcpPort, projectHost) {
     setCdpPort(resolvedCdpPort);
     // Connect to both targets (non-blocking)
     connectTarget('simulator').catch(() => { });
     connectTarget('workbench').catch(() => { });
-    const server = buildServer();
     const transports = new Map();
     const httpServer = createServer(async (req, res) => {
         const url = new URL(req.url ?? '/', `http://localhost`);
@@ -47,7 +49,30 @@ export function startMcpServer(resolvedCdpPort, mcpPort) {
             const transport = new SSEServerTransport('/message', res);
             transports.set(transport.sessionId, transport);
             res.on('close', () => transports.delete(transport.sessionId));
-            await server.connect(transport);
+            try {
+                // A fresh McpServer PER CONNECTION: the SDK's Protocol is strictly
+                // 1:1 with its transport (`connect()` throws "Already connected to a
+                // transport" if `this._transport` is already set), so reusing one
+                // global server across concurrent SSE clients breaks every
+                // connection after the first. Registration only builds tool-call
+                // closures over already-shared module-level state (target-manager's
+                // CDP connections/listeners) — it has no per-call side effects, so
+                // building N servers is cheap and duplicates nothing.
+                await buildServer(projectHost).connect(transport);
+            }
+            catch (err) {
+                transports.delete(transport.sessionId);
+                // `connect()` calls `transport.start()` (writes the SSE 200 + headers)
+                // BEFORE it can throw, so a post-start failure here has already sent
+                // headers — writeHead would itself throw. End the response instead so
+                // the client's stream closes cleanly rather than hanging forever with
+                // an open connection nothing will ever write to again.
+                if (!res.headersSent)
+                    res.writeHead(500).end('MCP connect failed');
+                else
+                    res.end();
+                console.error('[MCP] SSE connect failed:', err);
+            }
         }
         else if (req.method === 'POST' && url.pathname === '/message') {
             const sessionId = url.searchParams.get('sessionId') ?? '';

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

@@ -10,6 +10,8 @@
  *   - rolling buffers of console log and network request events
  */
 import CDP from 'chrome-remote-interface';
+import { type TargetIdentityFacts } from './connection-owner.js';
+export { selectSimulatorTarget, selectWorkbenchTarget } from './target-selection.js';
 export type TargetKind = 'simulator' | 'workbench';
 export interface ConsoleLogEntry {
     level: string;
@@ -38,38 +40,84 @@ export type NativeOverviewProvider = () => Promise<NativeOverview>;
 interface TargetState {
     client: CDP.Client | null;
     connected: boolean;
+    /**
+     * The window this live connection ACTUALLY reached — not the one it was
+     * aimed at, and null when the target names no project window (the project
+     * list). Read on every `getClient`, so a connection left behind by a window
+     * switch is refused instead of answering for the wrong project.
+     */
+    owner: object | null;
     timer: ReturnType<typeof setTimeout> | null;
     consoleLogs: ConsoleLogEntry[];
     networkRequests: NetworkRequestEntry[];
+    /**
+     * The owner these buffers were most recently cleared and populated for.
+     * Distinct from `owner`, which goes null the instant a target is lost: a
+     * reconnect that lands back on the same window (a transient CDP drop) must
+     * find its buffers intact, so what decides whether to clear is this record
+     * of the last owner they were published for, not the connection's current
+     * live/dead state.
+     */
+    bufferOwner: object | null;
 }
-export declare function setCdpPort(port: number): void;
-export declare function setNativeHost(enabled: boolean): void;
-/**
- * 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.
- */
-export declare function setActiveBridgeId(id: string | null): void;
-export declare function setNativeOverviewProvider(provider: NativeOverviewProvider | null): void;
-export declare function getNativeOverviewProvider(): NativeOverviewProvider | null;
 /**
- * Resolve which CDP target the `simulator` MCP tools should drive.
+ * What MCP needs to know about ONE project window.
  *
- * 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.
+ * Every project runs in its own window, so native-host mode, the visible
+ * render guest, the cross-process overview provider and the project identity
+ * are facts about a single window — never about the process. A window
+ * publishes its own record here and drops only that record when it closes.
  */
-export declare function selectSimulatorTarget<T extends {
-    url?: string;
-    type?: string;
-}>(targets: T[], opts: {
+export interface McpWindowFacts extends TargetIdentityFacts {
+    /** The window runs the native-host runtime (mini-app pages live in nested render guests). */
     nativeHost: boolean;
+    /**
+     * The visible page's bridgeId, pushed from this window's bridge-router
+     * render events. `selectSimulatorTarget` prefers the guest matching it so
+     * MCP follows the active page across navigation/tab switches.
+     */
     activeBridgeId: string | null;
-}): T | undefined;
+    nativeOverviewProvider: NativeOverviewProvider | null;
+    /** Absolute path of the project this window opened with; never changes. */
+    projectPath: string;
+    /** appId of the project open in this window; null before its session exists. */
+    getAppId: () => string | null;
+}
+export interface McpWindowRegistration {
+    facts: McpWindowFacts;
+    dispose: () => void;
+}
+/**
+ * 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 declare function setActiveMcpWindowResolver(resolve: () => object | null): void;
+export declare function registerMcpWindow(owner: object, facts: McpWindowFacts): McpWindowRegistration;
+/** The facts of the project window MCP currently drives, or null when none is open. */
+export declare function activeMcpWindow(): McpWindowFacts | null;
+/**
+ * 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 declare function noteActiveBridgeId(owner: object, id: string | null): void;
+/**
+ * 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.
+ *
+ * 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 declare function noteActiveMcpWindowChanged(): void;
+export declare function setCdpPort(port: number): void;
+/** The cross-process overview reader of the window MCP drives, if it has one. */
+export declare function getNativeOverviewProvider(): NativeOverviewProvider | null;
 export declare function getTargetState(kind: TargetKind): TargetState;
 declare function listCdpTargets(): Promise<CDP.Target[]>;
 export { listCdpTargets as listTargets };

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

@@ -11,78 +11,108 @@
  */
 import CDP from 'chrome-remote-interface';
 import { DEFAULT_CDP_PORT } from '../../../shared/constants.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.
-const RENDER_GUEST_PATTERN = 'pageFrame.html';
+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];
@@ -96,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;
@@ -129,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) {
@@ -219,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