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

package/dist/main/services/automation/handlers/element.js

@@ -20,27 +20,61 @@ elementHandlers['Element.triggerEvent'] = async (ctx, params) => {
   `);
     return {};
 };
-elementHandlers['Element.touchstart'] = async (ctx, params) => {
-    const ref = getElementRef(params);
-    await evalInElement(ctx, ref, `
-    if (el) el.dispatchEvent(new TouchEvent('touchstart', { bubbles: true }))
-  `);
-    return {};
-};
-elementHandlers['Element.touchmove'] = async (ctx, params) => {
-    const ref = getElementRef(params);
-    await evalInElement(ctx, ref, `
-    if (el) el.dispatchEvent(new TouchEvent('touchmove', { bubbles: true }))
-  `);
-    return {};
-};
-elementHandlers['Element.touchend'] = async (ctx, params) => {
-    const ref = getElementRef(params);
-    await evalInElement(ctx, ref, `
-    if (el) el.dispatchEvent(new TouchEvent('touchend', { bubbles: true }))
-  `);
-    return {};
-};
+/**
+ * Touch events must carry real touch points: the gesture layer reads coordinates
+ * off `touches` / `changedTouches` to decide tap vs. move-cancel, so an event with
+ * empty lists reaches it as a touch that happened nowhere. The protocol lets the
+ * caller omit points entirely (`touchstart()` with no args), in which case the
+ * element's centre — read from live layout, not a fixed offset — stands in for
+ * where a finger would land.
+ */
+function touchHandler(type) {
+    // A finished touch is no longer among the active `touches`, only in `changedTouches`.
+    const fallbackTouches = type === 'touchend' ? '[]' : '[{}]';
+    return async (ctx, params) => {
+        const ref = getElementRef(params);
+        const touches = params.touches ?? null;
+        // The protocol spells it `changeTouches`; the DOM event field is `changedTouches`.
+        const changed = params.changeTouches ?? null;
+        await evalInElement(ctx, ref, `
+      if (!el) throw new Error('Element not found')
+      const rect = el.getBoundingClientRect()
+      const centreX = rect.left + rect.width / 2
+      const centreY = rect.top + rect.height / 2
+      const make = (p, i) => {
+        const clientX = p.clientX != null ? p.clientX : (p.pageX != null ? p.pageX - scrollX : centreX)
+        const clientY = p.clientY != null ? p.clientY : (p.pageY != null ? p.pageY - scrollY : centreY)
+        return new Touch({
+          identifier: p.identifier != null ? p.identifier : i,
+          target: el,
+          clientX,
+          clientY,
+          pageX: p.pageX != null ? p.pageX : clientX + scrollX,
+          pageY: p.pageY != null ? p.pageY : clientY + scrollY,
+          screenX: clientX,
+          screenY: clientY,
+          force: 1,
+        })
+      }
+      const raw = ${JSON.stringify(touches)}
+      const rawChanged = ${JSON.stringify(changed)}
+      const active = (raw || ${fallbackTouches}).map(make)
+      const changedList = (rawChanged || raw || [{}]).map(make)
+      el.dispatchEvent(new TouchEvent('${type}', {
+        bubbles: true,
+        cancelable: true,
+        composed: true,
+        touches: active,
+        targetTouches: active,
+        changedTouches: changedList,
+      }))
+    `);
+        return {};
+    };
+}
+elementHandlers['Element.touchstart'] = touchHandler('touchstart');
+elementHandlers['Element.touchmove'] = touchHandler('touchmove');
+elementHandlers['Element.touchend'] = touchHandler('touchend');
 elementHandlers['Element.getDOMProperties'] = async (ctx, params) => {
     const ref = getElementRef(params);
     const names = params.names;

package/dist/main/services/automation/index.d.ts

@@ -9,11 +9,22 @@
  * This server handles these messages by delegating to the workbench context
  * (simulator webContents, IPC handlers, etc.) without modifying dimina upstream.
  */
+import { type IpcInput } from '../../utils/ipc-context-source.js';
 import type { WorkbenchContext } from '../workbench-context.js';
 export interface AutomationServer {
     close: () => void;
     port: number;
 }
 export declare function getAutomationPort(): number | null;
-export declare function startAutomationServer(ctx: WorkbenchContext, port?: number): Promise<AutomationServer>;
+/**
+ * `getCtx` rather than a context: the server binds its port at boot, before any
+ * project window exists, so there is nothing to capture yet. Each connection
+ * then pins the first project window it reaches and keeps driving that one —
+ * `getCtx` is how it finds that window, not a per-message lookup.
+ *
+ * `senders` covers every live window instead, because the port channel is asked
+ * by renderers `getCtx` never names: the project list and background project
+ * windows all start automation clients of their own.
+ */
+export declare function startAutomationServer(getCtx: () => WorkbenchContext, senders: IpcInput<WorkbenchContext>, port?: number): Promise<AutomationServer>;
 //# sourceMappingURL=index.d.ts.map

package/dist/main/services/automation/index.js

@@ -10,8 +10,11 @@
  * (simulator webContents, IPC handlers, etc.) without modifying dimina upstream.
  */
 import { WebSocketServer } from 'ws';
-import { AutomationChannel, SimulatorChannel } from '../../../shared/ipc-channels.js';
+import { AutomationChannel } from '../../../shared/ipc-channels.js';
 import { IpcRegistry } from '../../utils/ipc-registry.js';
+import { toIpcContextSource } from '../../utils/ipc-context-source.js';
+import { createConnectionTarget } from './connection-target.js';
+import { createConsoleBridge } from './console-bridge.js';
 import { getSimulator } from './exec.js';
 import { toolHandlers } from './handlers/tool.js';
 import { appHandlers } from './handlers/app.js';
@@ -28,7 +31,17 @@ let currentPort = null;
 export function getAutomationPort() {
     return currentPort;
 }
-export async function startAutomationServer(ctx, port = 0) {
+/**
+ * `getCtx` rather than a context: the server binds its port at boot, before any
+ * project window exists, so there is nothing to capture yet. Each connection
+ * then pins the first project window it reaches and keeps driving that one —
+ * `getCtx` is how it finds that window, not a per-message lookup.
+ *
+ * `senders` covers every live window instead, because the port channel is asked
+ * by renderers `getCtx` never names: the project list and background project
+ * windows all start automation clients of their own.
+ */
+export async function startAutomationServer(getCtx, senders, port = 0) {
     const wss = new WebSocketServer({ port });
     const clients = new Set();
     await new Promise((resolve, reject) => {
@@ -39,125 +52,34 @@ export async function startAutomationServer(ctx, port = 0) {
     // ws always binds via an http.Server, so address() is AddressInfo here.
     const resolvedPort = typeof addr === 'object' && addr ? addr.port : port;
     currentPort = resolvedPort;
-    // Gate AutomationChannel.GetPort with the workbench sender policy (only
-    // the main renderer + workbench settings/popover overlays are allowed to
-    // read the port — see createWorkbenchSenderPolicy; the simulator webview
-    // is intentionally NOT trusted for IPC invokes).
-    const portIpc = new IpcRegistry(ctx.senderPolicy);
+    // Gated per OWNING window: each window trusts its own renderer plus its
+    // settings/popover overlays (see createWorkbenchSenderPolicy), and the
+    // simulator webview is trusted by none of them. Gating on the active
+    // window's policy instead would reject every window that does not currently
+    // have focus, starting with the project list.
+    const portIpc = new IpcRegistry(toIpcContextSource(senders));
     portIpc.handle(AutomationChannel.GetPort, () => {
         return currentPort;
     });
-    function broadcast(event) {
-        const msg = JSON.stringify(event);
-        for (const ws of clients) {
-            if (ws.readyState === ws.OPEN)
-                ws.send(msg);
-        }
-    }
-    // Native-host console forwarding: under native-host the page/service console
-    // doesn't flow through the simulator guest's `ipc-message-host` channel (there
-    // is no Worker/MiniApp in the guest). Instead the render-host / service-host
-    // preloads post each console entry to main, bridge-router routes it to the
-    // always-on ConsoleForwarder, and we SUBSCRIBE to rebroadcast every entry
-    // (both layers) as an `App.logAdded` event — same shape the default-arch path
-    // emits below in `setupConsoleForwarding`. We no longer set `ctx.guestConsole`
-    // ourselves (the forwarder owns it); subscribing means render + service both
-    // reach automation while the forwarder also mirrors render into the service
-    // host's console for the embedded DevTools. Unsubscribed on close().
-    const consoleSub = ctx.consoleForwarder?.subscribe((entry) => {
-        const e = (entry ?? {});
-        broadcast({
-            method: 'App.logAdded',
-            params: { type: e.level || 'log', args: e.args || [] },
-        });
-    });
-    // Forward simulator console logs as App.logAdded events.
-    // Track the polling interval + stop timer + currently-attached sim and
-    // the named handler so we can fully detach on close() or sim destruction.
-    // Without this the listener accumulates across create/dispose cycles and
-    // across simulator rebuilds.
-    let consoleForwardingSetup = false;
-    let pollInterval = null;
-    let pollStopTimer = null;
-    let attachedSim = null;
-    let ipcMessageHostHandler = null;
-    // Handle for the destroyed-teardown owned by the sim's connection (replaces a
-    // bespoke `sim.once('destroyed')` + manual removeListener). Disposing it on
-    // graceful close()/detach releases the disposer from the connection segment so
-    // it can't accumulate across automation create/dispose cycles on the same sim.
-    let simDestroyedDisposer = null;
-    function detachConsoleForwarding() {
-        if (attachedSim) {
-            if (ipcMessageHostHandler) {
-                try {
-                    if (!attachedSim.isDestroyed()) {
-                        ;
-                        attachedSim.removeListener('ipc-message-host', ipcMessageHostHandler);
-                    }
-                }
-                catch { /* noop */ }
-            }
-        }
-        // Release the connection-owned destroyed disposer (idempotent; safe even if
-        // the sim is already destroyed — the disposer body only nulls local refs).
-        try {
-            simDestroyedDisposer?.dispose();
-        }
-        catch { /* noop */ }
-        attachedSim = null;
-        ipcMessageHostHandler = null;
-        simDestroyedDisposer = null;
-    }
-    function setupConsoleForwarding() {
-        if (consoleForwardingSetup)
-            return;
-        consoleForwardingSetup = true;
-        pollInterval = setInterval(() => {
-            const sim = getSimulator(ctx);
-            if (!sim)
-                return;
-            if (pollInterval) {
-                clearInterval(pollInterval);
-                pollInterval = null;
-            }
-            const onIpcMessageHost = (_event, channel, data) => {
-                if (channel === SimulatorChannel.Console) {
-                    const logData = data;
-                    broadcast({
-                        method: 'App.logAdded',
-                        params: { type: logData.level || 'log', args: logData.args || [] },
-                    });
-                }
-            };
-            const onSimDestroyed = () => {
-                // Sim webContents is dead — drop refs (removeListener on a destroyed
-                // sender would throw) and allow re-attach to a new simulator.
-                attachedSim = null;
-                ipcMessageHostHandler = null;
-                simDestroyedDisposer = null;
-                consoleForwardingSetup = false;
-            };
-            attachedSim = sim;
-            ipcMessageHostHandler = onIpcMessageHost;
-            sim.on('ipc-message-host', onIpcMessageHost);
-            // Route the destroyed-teardown through the per-webContents connection
-            // registry: the connection arms a single `wc.once('destroyed')` and runs
-            // owned disposers on hard-destroy (or soft reset for pool reuse), so we no
-            // longer manage a bespoke 'destroyed' listener here.
-            simDestroyedDisposer = ctx.connections.acquire(sim).own(onSimDestroyed);
-        }, 1000);
-        // Stop polling after 30s
-        pollStopTimer = setTimeout(() => {
-            if (pollInterval) {
-                clearInterval(pollInterval);
-                pollInterval = null;
-            }
-            pollStopTimer = null;
-        }, 30000);
-    }
+    // Every connection owns its console bridge, because every connection has its
+    // own target window: a single server-wide broadcast would hand one client the
+    // logs of a project another client is driving.
+    const bridges = new Set();
     wss.on('connection', (ws) => {
         clients.add(ws);
-        setupConsoleForwarding();
+        const send = (msg) => {
+            if (ws.readyState === ws.OPEN)
+                ws.send(JSON.stringify(msg));
+        };
+        // Pinned, not resolved per message: the window a script drives is settled by
+        // the first project window this connection reaches, so a user clicking
+        // another project's window can't redirect it (see `createConnectionTarget`).
+        const target = createConnectionTarget(getCtx);
+        const consoleBridge = createConsoleBridge(() => target.peek(), getSimulator, send);
+        bridges.add(consoleBridge);
+        // Before any message: a client that only listens for `App.logAdded` never
+        // sends one, and still has to receive its target window's console.
+        consoleBridge.sync();
         ws.on('message', async (raw) => {
             let req;
             try {
@@ -174,6 +96,9 @@ export async function startAutomationServer(ctx, port = 0) {
             }
             else {
                 try {
+                    // Same target for the command and for the logs it produces.
+                    const ctx = target.resolve();
+                    consoleBridge.sync();
                     const result = await handler(ctx, params);
                     response = { id, result };
                 }
@@ -181,27 +106,23 @@ export async function startAutomationServer(ctx, port = 0) {
                     response = { id, error: { message: err.message || String(err) } };
                 }
             }
-            if (ws.readyState === ws.OPEN)
-                ws.send(JSON.stringify(response));
+            send(response);
+        });
+        ws.on('close', () => {
+            clients.delete(ws);
+            bridges.delete(consoleBridge);
+            consoleBridge.dispose();
         });
-        ws.on('close', () => clients.delete(ws));
     });
     return {
         close: () => {
-            if (pollInterval) {
-                clearInterval(pollInterval);
-                pollInterval = null;
-            }
-            if (pollStopTimer) {
-                clearTimeout(pollStopTimer);
-                pollStopTimer = null;
-            }
-            detachConsoleForwarding();
-            // Unsubscribe from the always-on ConsoleForwarder so a late guest console
-            // entry can't broadcast against a torn-down server. The forwarder keeps
-            // owning `ctx.guestConsole` (render→service mirroring continues without an
-            // automation client). No-op if the forwarder was absent.
-            consoleSub?.dispose();
+            // Detaches every connection's simulator listener and unsubscribes it from
+            // its window's ConsoleForwarder, so a late guest console entry can't fire
+            // against a torn-down server. The forwarder keeps owning `ctx.guestConsole`
+            // (render→service mirroring continues without an automation client).
+            for (const bridge of bridges)
+                bridge.dispose();
+            bridges.clear();
             for (const ws of clients) {
                 try {
                     ws.close();

package/dist/main/services/default-adapter.js

@@ -5,7 +5,7 @@ export const defaultAdapter = {
     async openProject(opts) {
         const diminaKit = await import('@dimina-kit/devkit');
         const openProjectOpts = {
-            outputDir: path.join(app.getPath('userData'), 'dimina-fe-output'),
+            outputRoot: path.join(app.getPath('userData'), 'dimina-fe-output'),
             ...opts,
             simulatorDir,
         };

package/dist/main/services/fs-bridge-protocol.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The `/__fs` bridge's wire shapes, declared once for the producing side.
+ *
+ * Every shape here is consumed by browser code in `packages/workbench`
+ * (`fs-bridge.ts`'s `FsEntry`, `wal-audit-transport.ts`'s SSE message parse,
+ * and through them `@dimina-kit/fs-core/sync/watch-expander`'s stat-diffing).
+ * That side cannot import from here — devtools is the application, the
+ * workbench is a library it embeds, and the dependency runs one way only. So
+ * this module does not give the two ends a shared declaration; it gives the
+ * PRODUCING end exactly one, instead of hand-building untyped payloads at each
+ * call site. The two ends stay pinned to each other by the round-trip
+ * assertions in workbench-coi-server.test.ts and by disk-sync.spec.ts.
+ */
+/**
+ * The `type` field of every readdir/stat payload. These are wire values, not
+ * an internal enum: the browser side compares the raw numbers (watch-expander
+ * treats `2` as "recurse into it"), so renumbering them breaks the editor's
+ * disk mirror.
+ */
+export declare const FS_TYPE_FILE = 1;
+export declare const FS_TYPE_DIR = 2;
+/**
+ * One `/__fs/readdir` entry: `[name, type]` for a directory, `[name, type,
+ * size, mtimeMs]` for a file. The trailing stats let the sync engine tell a
+ * stat-unchanged survivor from an actually-modified file without re-reading
+ * its content. A file entry that raced a concurrent delete between readdir and
+ * stat has no stats to send and is TRUNCATED to `[name, 1]` rather than padded
+ * with the two values: a JSON array cannot hold a hole, so passing them
+ * through as `undefined` would put `null` on the wire, which neither the
+ * client's `size?: number` type nor any of the comments describing this format
+ * admit. Either way the client's `?? NaN` fallback treats the entry as
+ * "always changed"; truncating is what keeps the wire and the types honest.
+ */
+export type FsBridgeEntry = [name: string, type: number, size?: number, mtimeMs?: number];
+/** The `/__fs/stat` payload. Its `mtime` carries the same value readdir sends
+ * as `mtimeMs` — the two endpoints named it differently and no client reads
+ * this one, so the names are left as shipped rather than changed blind. */
+export interface FsBridgeStat {
+    type: number;
+    size: number;
+    ctime: number;
+    mtime: number;
+}
+/** One `/__fs/watch` SSE message: a batch of changed project-relative paths,
+ * or the terminal notice that the watcher is gone and the client must fall
+ * back to a full rescan. */
+export type FsWatchMessage = {
+    paths: string[];
+} | {
+    watcherDead: true;
+};
+/** Serialize one SSE message into an `event-stream` frame. */
+export declare function fsWatchFrame(message: FsWatchMessage): string;
+/** Project one `readdirWithin` entry onto the readdir wire shape. */
+export declare function toFsBridgeEntry(entry: {
+    name: string;
+    isDirectory: boolean;
+    size?: number;
+    mtimeMs?: number;
+}): FsBridgeEntry;
+//# sourceMappingURL=fs-bridge-protocol.d.ts.map

package/dist/main/services/fs-bridge-protocol.js

@@ -0,0 +1,34 @@
+/**
+ * The `/__fs` bridge's wire shapes, declared once for the producing side.
+ *
+ * Every shape here is consumed by browser code in `packages/workbench`
+ * (`fs-bridge.ts`'s `FsEntry`, `wal-audit-transport.ts`'s SSE message parse,
+ * and through them `@dimina-kit/fs-core/sync/watch-expander`'s stat-diffing).
+ * That side cannot import from here — devtools is the application, the
+ * workbench is a library it embeds, and the dependency runs one way only. So
+ * this module does not give the two ends a shared declaration; it gives the
+ * PRODUCING end exactly one, instead of hand-building untyped payloads at each
+ * call site. The two ends stay pinned to each other by the round-trip
+ * assertions in workbench-coi-server.test.ts and by disk-sync.spec.ts.
+ */
+/**
+ * The `type` field of every readdir/stat payload. These are wire values, not
+ * an internal enum: the browser side compares the raw numbers (watch-expander
+ * treats `2` as "recurse into it"), so renumbering them breaks the editor's
+ * disk mirror.
+ */
+export const FS_TYPE_FILE = 1;
+export const FS_TYPE_DIR = 2;
+/** Serialize one SSE message into an `event-stream` frame. */
+export function fsWatchFrame(message) {
+    return `data: ${JSON.stringify(message)}\n\n`;
+}
+/** Project one `readdirWithin` entry onto the readdir wire shape. */
+export function toFsBridgeEntry(entry) {
+    if (entry.isDirectory)
+        return [entry.name, FS_TYPE_DIR];
+    if (entry.size === undefined || entry.mtimeMs === undefined)
+        return [entry.name, FS_TYPE_FILE];
+    return [entry.name, FS_TYPE_FILE, entry.size, entry.mtimeMs];
+}
+//# sourceMappingURL=fs-bridge-protocol.js.map

package/dist/main/services/fs-watch-sse.d.ts

@@ -28,6 +28,13 @@ declare function shouldReportWatchPath(rel: string): boolean;
 export declare const __testing: {
     shouldReportWatchPath: typeof shouldReportWatchPath;
 };
-export declare function handleFsWatchRequest(req: http.IncomingMessage, res: http.ServerResponse, getProjectRoot: () => string): void;
+/**
+ * Returns the call that ends this stream from the server side, or `null` when
+ * the request was answered with an error instead of a stream. Nothing else can
+ * end it: the client is the only party that ever disconnects, so the server
+ * that outlives the request needs a handle to close the channel when IT is the
+ * one going away.
+ */
+export declare function handleFsWatchRequest(req: http.IncomingMessage, res: http.ServerResponse, getProjectRoot: () => string): (() => void) | null;
 export {};
 //# sourceMappingURL=fs-watch-sse.d.ts.map

package/dist/main/services/fs-watch-sse.js

@@ -1,6 +1,7 @@
 import nodeFs from 'node:fs';
 import path from 'node:path';
 import { SKIP_DIRS } from '../ipc/project-fs.js';
+import { fsWatchFrame } from './fs-bridge-protocol.js';
 import { jsonRes } from './http-json.js';
 /** Debounce window for batching change notifications (ms). */
 const WATCH_DEBOUNCE_MS = 80;
@@ -17,11 +18,18 @@ function shouldReportWatchPath(rel) {
     return !rel.split('/').some((segment) => SKIP_DIRS.has(segment));
 }
 export const __testing = { shouldReportWatchPath };
+/**
+ * Returns the call that ends this stream from the server side, or `null` when
+ * the request was answered with an error instead of a stream. Nothing else can
+ * end it: the client is the only party that ever disconnects, so the server
+ * that outlives the request needs a handle to close the channel when IT is the
+ * one going away.
+ */
 export function handleFsWatchRequest(req, res, getProjectRoot) {
     const watchedRoot = getProjectRoot();
     if (!watchedRoot) {
         jsonRes(res, 409, { error: 'No active project', code: 'ENOACTIVE' });
-        return;
+        return null;
     }
     let watcher;
     try {
@@ -29,7 +37,7 @@ export function handleFsWatchRequest(req, res, getProjectRoot) {
     }
     catch (e) {
         jsonRes(res, 500, { error: String(e) });
-        return;
+        return null;
     }
     res.writeHead(200, {
         'Content-Type': 'text/event-stream; charset=utf-8',
@@ -55,7 +63,7 @@ export function handleFsWatchRequest(req, res, getProjectRoot) {
             return;
         const paths = [...pending];
         pending = new Set();
-        res.write(`data: ${JSON.stringify({ paths })}\n\n`);
+        res.write(fsWatchFrame({ paths }));
     }
     function onChange(_event, filename) {
         // FSEvents overflow delivers a null filename ("something changed,
@@ -75,7 +83,7 @@ export function handleFsWatchRequest(req, res, getProjectRoot) {
     watcher.on('error', () => {
         if (closed)
             return;
-        res.write(`data: ${JSON.stringify({ watcherDead: true })}\n\n`);
+        res.write(fsWatchFrame({ watcherDead: true }));
         cleanup();
         res.end();
     });
@@ -89,11 +97,17 @@ export function handleFsWatchRequest(req, res, getProjectRoot) {
         if (closed)
             return;
         if (getProjectRoot() !== watchedRoot) {
-            res.write(`data: ${JSON.stringify({ watcherDead: true })}\n\n`);
+            res.write(fsWatchFrame({ watcherDead: true }));
             cleanup();
             res.end();
         }
     }, WATCH_DEBOUNCE_MS);
     req.on('close', cleanup);
+    return function endStream() {
+        if (closed)
+            return;
+        cleanup();
+        res.end();
+    };
 }
 //# sourceMappingURL=fs-watch-sse.js.map

package/dist/main/services/mcp/connection-owner.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Which project window a CDP target belongs to.
+ *
+ * MCP keeps one `simulator` and one `workbench` connection for the whole app,
+ * so every connection has to record the window it ACTUALLY reached: one
+ * recorded as arrived is left alone, one recorded elsewhere keeps retrying
+ * until it lands on the window the user is in.
+ */
+/** The per-window facts that decide which window a target belongs to. */
+export interface TargetIdentityFacts {
+    activeBridgeId: string | null;
+    /**
+     * The resolved project path this window opened with. Fixed for the life of
+     * the window: a window names its project from the moment it exists, so
+     * attribution never has to wait for a compile to record anything.
+     */
+    projectPath: string;
+    getAppId: () => string | null;
+}
+export interface TargetBinding {
+    owner: object | null;
+    onTarget: boolean;
+}
+/** The value of query `key` in a target URL, or null when it carries none. */
+export declare function targetQuery(url: string | undefined, key: string): string | null;
+/**
+ * The window a chosen target belongs to, and whether that is the window MCP
+ * means to drive right now.
+ *
+ * A simulator target that names no window it can be attributed to is treated as
+ * the wrong window on purpose: it may well be another project's, and keeping the
+ * retries running is what moves the connection onto the active window's render
+ * guest as soon as that guest exists. The one target that legitimately names no
+ * window is the project list, which is the right workbench surface exactly
+ * while no project window is open.
+ */
+export declare function connectionOwner(kind: 'simulator' | 'workbench', url: string | undefined, intended: object | null, windows: ReadonlyMap<object, TargetIdentityFacts>): TargetBinding;
+//# sourceMappingURL=connection-owner.d.ts.map

package/dist/main/services/mcp/connection-owner.js

@@ -0,0 +1,79 @@
+/**
+ * Which project window a CDP target belongs to.
+ *
+ * MCP keeps one `simulator` and one `workbench` connection for the whole app,
+ * so every connection has to record the window it ACTUALLY reached: one
+ * recorded as arrived is left alone, one recorded elsewhere keeps retrying
+ * until it lands on the window the user is in.
+ */
+/** The value of query `key` in a target URL, or null when it carries none. */
+export function targetQuery(url, key) {
+    if (!url)
+        return null;
+    try {
+        return new URL(url).searchParams.get(key);
+    }
+    catch {
+        return null;
+    }
+}
+function bind(owner, intended) {
+    return { owner, onTarget: owner === intended };
+}
+/** The window whose workbench renderer has this target's project open. */
+function workbenchOwner(url, windows) {
+    const path = targetQuery(url, 'path');
+    if (!path)
+        return null;
+    for (const [candidate, facts] of windows) {
+        if (facts.projectPath === path)
+            return candidate;
+    }
+    return null;
+}
+/**
+ * The window this simulator surface belongs to: a render guest names it through
+ * its `bridgeId`, the localhost:7788 shell through the `appId` its route
+ * carries. Two windows answering to one appId — what two projects declaring the
+ * same appId produce — name no single window, so neither is returned.
+ */
+function simulatorOwner(url, windows) {
+    const bridgeId = targetQuery(url, 'bridgeId');
+    if (bridgeId !== null) {
+        for (const [candidate, facts] of windows) {
+            if (facts.activeBridgeId === bridgeId)
+                return candidate;
+        }
+        return null;
+    }
+    const appId = targetQuery(url, 'appId');
+    if (appId === null)
+        return null;
+    let shell = null;
+    for (const [candidate, facts] of windows) {
+        if (facts.getAppId() !== appId)
+            continue;
+        if (shell)
+            return null;
+        shell = candidate;
+    }
+    return shell;
+}
+/**
+ * The window a chosen target belongs to, and whether that is the window MCP
+ * means to drive right now.
+ *
+ * A simulator target that names no window it can be attributed to is treated as
+ * the wrong window on purpose: it may well be another project's, and keeping the
+ * retries running is what moves the connection onto the active window's render
+ * guest as soon as that guest exists. The one target that legitimately names no
+ * window is the project list, which is the right workbench surface exactly
+ * while no project window is open.
+ */
+export function connectionOwner(kind, url, intended, windows) {
+    const owner = kind === 'workbench' ? workbenchOwner(url, windows) : simulatorOwner(url, windows);
+    if (owner)
+        return bind(owner, intended);
+    return { owner: null, onTarget: kind === 'workbench' && intended === null };
+}
+//# sourceMappingURL=connection-owner.js.map