@dimina-kit/devtools 0.4.0 → 0.5.0

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

@@ -0,0 +1,40 @@
+/**
+ * `GET /__fs/watch`: SSE stream of the active project root's disk changes, for
+ * the editor's memfs↔disk sync engine (devtools-fs-core-feasibility.md §7).
+ * Read-only — it adds no write surface, which is why workbench-coi-server.ts
+ * dispatches it before (and outside) the mutating-action guard of the generic
+ * `/__fs/*` handler. Split into its own module purely to keep each file within
+ * the repo size gate; the COI server is its only consumer.
+ *
+ * One `fs.watch(root, {recursive:true})` per connection (darwin supports
+ * `recursive`), changes batched over an 80ms window and pushed as
+ * `data: {"paths":["rel", ...]}` with POSIX-separated root-relative paths.
+ * `getProjectRoot` (not a resolved string) is threaded through so a project
+ * close/switch mid-stream is detected by re-polling the SAME source
+ * `handleFsRequest` uses — no separate close event is invented. Watcher errors
+ * (e.g. EMFILE) push `data: {"watcherDead":true}` then end the stream; no
+ * active project at connect time is a 409, matching the ENOACTIVE semantics of
+ * every other `/__fs` action.
+ */
+import type http from 'node:http';
+/** `false` for build/vcs/dependency churn, the empty string, and any path that
+ * (defensively — `fs.watch`'s filename is always root-relative) escapes the root.
+ * Matches SKIP_DIRS as a path SEGMENT at any depth — the same set `/__fs/readdir`
+ * omits, so the watcher never reports paths the editor mirror cannot see (a
+ * prefix match would let `packages/x/node_modules/...` through). The one
+ * accepted edge: a plain FILE named exactly like a skip dir (e.g. `dist`)
+ * is also unreported, though readdir would list it. */
+declare function shouldReportWatchPath(rel: string): boolean;
+export declare const __testing: {
+    shouldReportWatchPath: typeof 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 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

@@ -0,0 +1,113 @@
+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;
+/** `false` for build/vcs/dependency churn, the empty string, and any path that
+ * (defensively — `fs.watch`'s filename is always root-relative) escapes the root.
+ * Matches SKIP_DIRS as a path SEGMENT at any depth — the same set `/__fs/readdir`
+ * omits, so the watcher never reports paths the editor mirror cannot see (a
+ * prefix match would let `packages/x/node_modules/...` through). The one
+ * accepted edge: a plain FILE named exactly like a skip dir (e.g. `dist`)
+ * is also unreported, though readdir would list it. */
+function shouldReportWatchPath(rel) {
+    if (rel === '' || rel.startsWith('..') || path.isAbsolute(rel))
+        return false;
+    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 null;
+    }
+    let watcher;
+    try {
+        watcher = nodeFs.watch(watchedRoot, { recursive: true }, onChange);
+    }
+    catch (e) {
+        jsonRes(res, 500, { error: String(e) });
+        return null;
+    }
+    res.writeHead(200, {
+        'Content-Type': 'text/event-stream; charset=utf-8',
+        'Cache-Control': 'no-store',
+        Connection: 'keep-alive',
+    });
+    let pending = new Set();
+    let debounceTimer = null;
+    let liveCheck = null;
+    let closed = false;
+    function cleanup() {
+        if (closed)
+            return;
+        closed = true;
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        if (liveCheck)
+            clearInterval(liveCheck);
+        watcher.close();
+    }
+    function flush() {
+        if (closed || pending.size === 0)
+            return;
+        const paths = [...pending];
+        pending = new Set();
+        res.write(fsWatchFrame({ paths }));
+    }
+    function onChange(_event, filename) {
+        // FSEvents overflow delivers a null filename ("something changed,
+        // rescan"). Dropping it loses data; report '.' and let the client's
+        // watch-batch expansion (wal-audit.ts) reconcile the whole tree.
+        const rel = filename ? filename.toString().split(path.sep).join('/') : '.';
+        if (rel !== '.' && !shouldReportWatchPath(rel))
+            return;
+        pending.add(rel);
+        if (!debounceTimer) {
+            debounceTimer = setTimeout(() => {
+                debounceTimer = null;
+                flush();
+            }, WATCH_DEBOUNCE_MS);
+        }
+    }
+    watcher.on('error', () => {
+        if (closed)
+            return;
+        res.write(fsWatchFrame({ watcherDead: true }));
+        cleanup();
+        res.end();
+    });
+    // The active project root has no dedicated close/switch event to subscribe
+    // to; poll the same getter `handleFsRequest` uses, on the debounce cadence,
+    // so a closed or switched project tears this stream down promptly. Push
+    // `watcherDead` BEFORE ending so the client gets a deterministic
+    // end-of-channel signal instead of depending on how its EventSource
+    // classifies the reconnect-then-409 that would follow a bare close.
+    liveCheck = setInterval(() => {
+        if (closed)
+            return;
+        if (getProjectRoot() !== watchedRoot) {
+            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/http-json.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Minimal JSON responder shared by the workbench COI server and its
+ * `/__fs/watch` SSE module (fs-watch-sse.ts). Lives in its own module because
+ * workbench-coi-server.ts imports fs-watch-sse.ts — either file owning it
+ * would force an import cycle for the other.
+ */
+import type http from 'node:http';
+export declare function jsonRes(res: http.ServerResponse, code: number, obj: unknown): void;
+//# sourceMappingURL=http-json.d.ts.map

package/dist/main/services/http-json.js

@@ -0,0 +1,6 @@
+export function jsonRes(res, code, obj) {
+    const body = Buffer.from(JSON.stringify(obj));
+    res.writeHead(code, { 'Content-Type': 'application/json; charset=utf-8', 'Content-Length': body.length });
+    res.end(body);
+}
+//# sourceMappingURL=http-json.js.map

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

@@ -41,4 +41,15 @@ export declare const SETTINGS_W = 320;
  */
 export declare function computeSettingsBounds(contentWidth: number, contentHeight: number, headerHeight: number): Bounds;
 export declare function computePopoverBounds(contentWidth: number, contentHeight: number, headerHeight: number): Bounds;
+export declare function computeTooltipMaxWidth(contentWidth: number): number;
+/**
+ * Position the tooltip overlay relative to its trigger's own bounding rect
+ * (both in main-window content coordinates). Prefers directly below the
+ * anchor, flips above when there isn't room; always clamped horizontally
+ * inside the content area.
+ */
+export declare function computeTooltipBounds(anchor: Bounds, contentWidth: number, contentHeight: number, measured: {
+    width: number;
+    height: number;
+}): Bounds;
 //# sourceMappingURL=index.d.ts.map

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

@@ -52,4 +52,27 @@ export function computePopoverBounds(contentWidth, contentHeight, headerHeight)
         height: contentHeight - headerHeight,
     };
 }
+const TOOLTIP_GAP = 6;
+const TOOLTIP_EDGE_MARGIN = 4;
+export function computeTooltipMaxWidth(contentWidth) {
+    return Math.max(1, contentWidth - TOOLTIP_EDGE_MARGIN * 2);
+}
+/**
+ * Position the tooltip overlay relative to its trigger's own bounding rect
+ * (both in main-window content coordinates). Prefers directly below the
+ * anchor, flips above when there isn't room; always clamped horizontally
+ * inside the content area.
+ */
+export function computeTooltipBounds(anchor, contentWidth, contentHeight, measured) {
+    const availableWidth = computeTooltipMaxWidth(contentWidth);
+    const width = Math.min(availableWidth, Math.max(1, Math.ceil(measured.width)));
+    const height = Math.max(1, Math.ceil(measured.height));
+    const below = anchor.y + anchor.height + TOOLTIP_GAP;
+    const fitsBelow = below + height <= contentHeight;
+    const y = fitsBelow ? below : Math.max(0, anchor.y - TOOLTIP_GAP - height);
+    const centeredX = anchor.x + anchor.width / 2 - width / 2;
+    const maxX = Math.max(TOOLTIP_EDGE_MARGIN, contentWidth - width - TOOLTIP_EDGE_MARGIN);
+    const x = Math.min(maxX, Math.max(TOOLTIP_EDGE_MARGIN, centeredX));
+    return { x, y, width, height };
+}
 //# sourceMappingURL=index.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

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

@@ -12,6 +12,8 @@
  *   - `./target-manager.ts`   dual-target CDP connection + reconnect
  */
 export { startMcpServer } from './server.js';
+export type { McpProjectHost, McpProjectTarget } from './tools/project-tools.js';
 export { getMcpStatus, type McpRuntimeStatus } from './status.js';
-export { setNativeHost, setActiveBridgeId, setNativeOverviewProvider, getNativeOverviewProvider, } from './target-manager.js';
+export { registerMcpWindow, setActiveMcpWindowResolver, noteActiveBridgeId, noteActiveMcpWindowChanged, activeMcpWindow, getNativeOverviewProvider, type McpWindowFacts, } from './target-manager.js';
+export { createOpenForMcp, createTargetForMcp, type McpOpenedProject } from './opened-project.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -13,7 +13,8 @@
  */
 export { startMcpServer } from './server.js';
 export { getMcpStatus } from './status.js';
-// Native-host: let app.ts point the `simulator` CDP target at the active
-// render-host guest as the visible page changes.
-export { setNativeHost, setActiveBridgeId, setNativeOverviewProvider, getNativeOverviewProvider, } from './target-manager.js';
+// Every project window owns its own native-host state and its own renderer, so
+// each registers its facts and MCP resolves the active window on every use.
+export { registerMcpWindow, setActiveMcpWindowResolver, noteActiveBridgeId, noteActiveMcpWindowChanged, activeMcpWindow, getNativeOverviewProvider, } from './target-manager.js';
+export { createOpenForMcp, createTargetForMcp } from './opened-project.js';
 //# sourceMappingURL=index.js.map

package/dist/main/services/mcp/opened-project.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Resolving the project window an MCP call is aimed at.
+ *
+ * A project lives in its own window and every window keeps its own
+ * session-status store, so `project_open` can only report the truth if it
+ * awaits the store of the window it just opened. Reading the app-active
+ * window's store instead times out on a first open (that window never compiles
+ * this project) and can return another project's rebuild as this one's result.
+ * The other tools have no window of their own to point at, so they take the
+ * active one — once per call, as a whole.
+ */
+import type { SessionStatusStore } from '../workspace/session-status-store.js';
+import type { McpProjectTarget } from './tools/project-tools.js';
+/** The status surface `project_open` reports from: one window's own state. */
+export interface McpProjectStatusSource {
+    workspace: {
+        getProjectPath(): string;
+        hasActiveSession(): boolean;
+    };
+    sessionStatus: SessionStatusStore;
+}
+export interface McpOpenedProject extends McpProjectStatusSource {
+    /**
+     * Generation guard for awaiting this open's compile. A window built by the
+     * open reports 0, so its empty store's initial 'idle' is not mistaken for a
+     * finished compile. A window that was already showing the project reports
+     * `undefined`: focusing it triggers no compile, so its current settled state
+     * IS the answer, and waiting for a newer one would hang.
+     */
+    afterGeneration?: number;
+}
+interface OpenedWindow<W> {
+    window: W;
+    context: McpProjectStatusSource;
+}
+export interface OpenForMcpDeps<W> {
+    /** Open the project in its own window (or focus the one already showing it). */
+    open: (project: {
+        name?: string;
+        path: string;
+    }) => Promise<W>;
+    /** Every live project window, so the opened one can be matched by identity. */
+    list: () => OpenedWindow<W>[];
+}
+/**
+ * Build the `requestOpenInUi` the MCP project tools drive: open the project
+ * and hand back the window it landed in, together with the generation guard
+ * for awaiting that window's compile.
+ */
+export declare function createOpenForMcp<W>(deps: OpenForMcpDeps<W>): (project: {
+    name: string;
+    path: string;
+}) => Promise<McpOpenedProject>;
+/**
+ * The window-context fields an MCP project call reads. Structural, so this
+ * module stays independent of the workbench context that satisfies it.
+ */
+export interface McpTargetContext {
+    workspace: McpProjectTarget['workspace'];
+    sessionStatus: McpProjectTarget['sessionStatus'];
+    compileLogBuffer: McpProjectTarget['compileLogs'];
+}
+export interface TargetForMcpDeps<W, C extends McpTargetContext> {
+    /** Every live project window, so the active one can be matched by context. */
+    list: () => {
+        window: W;
+        context: C;
+    }[];
+    /** The context of the project window the user is working in. */
+    activeContext: () => C;
+    /** Take one window down the way a user-driven close does. */
+    close: (window: W) => void;
+}
+/**
+ * Build the `currentProject` the MCP project tools drive: resolve the project
+ * window the user is working in NOW and hand back every surface a tool call
+ * needs, all bound to that one window.
+ *
+ * Tool calls yield — `closeProject()` awaits a teardown, `waitForSettled()`
+ * awaits a compile — and the user can focus another project meanwhile.
+ * Re-resolving afterwards reports one project's compile as another's, or
+ * closes the window they just moved to while the window whose session was torn
+ * down stays on screen, empty. The active context can also be the project
+ * list, which owns no project window: closing then does nothing.
+ */
+export declare function createTargetForMcp<W, C extends McpTargetContext>(deps: TargetForMcpDeps<W, C>): () => McpProjectTarget;
+export {};
+//# sourceMappingURL=opened-project.d.ts.map

package/dist/main/services/mcp/opened-project.js

@@ -0,0 +1,60 @@
+/**
+ * Resolving the project window an MCP call is aimed at.
+ *
+ * A project lives in its own window and every window keeps its own
+ * session-status store, so `project_open` can only report the truth if it
+ * awaits the store of the window it just opened. Reading the app-active
+ * window's store instead times out on a first open (that window never compiles
+ * this project) and can return another project's rebuild as this one's result.
+ * The other tools have no window of their own to point at, so they take the
+ * active one — once per call, as a whole.
+ */
+/**
+ * Build the `requestOpenInUi` the MCP project tools drive: open the project
+ * and hand back the window it landed in, together with the generation guard
+ * for awaiting that window's compile.
+ */
+export function createOpenForMcp(deps) {
+    return async (project) => {
+        // Sampled BEFORE the open: a window that already exists carries a previous
+        // compile's history, and only a state recorded after this point can be
+        // this open's result. Keyed by context identity, so a window rebuilt
+        // during the open is correctly seen as new.
+        const before = new Map(deps.list().map((w) => [w.context, w.context.sessionStatus.get().generation]));
+        const window = await deps.open(project);
+        const opened = deps.list().find((w) => w.window === window);
+        if (!opened)
+            throw new Error(`the window opened for ${project.path} is already gone`);
+        return {
+            workspace: opened.context.workspace,
+            sessionStatus: opened.context.sessionStatus,
+            afterGeneration: before.has(opened.context) ? undefined : 0,
+        };
+    };
+}
+/**
+ * Build the `currentProject` the MCP project tools drive: resolve the project
+ * window the user is working in NOW and hand back every surface a tool call
+ * needs, all bound to that one window.
+ *
+ * Tool calls yield — `closeProject()` awaits a teardown, `waitForSettled()`
+ * awaits a compile — and the user can focus another project meanwhile.
+ * Re-resolving afterwards reports one project's compile as another's, or
+ * closes the window they just moved to while the window whose session was torn
+ * down stays on screen, empty. The active context can also be the project
+ * list, which owns no project window: closing then does nothing.
+ */
+export function createTargetForMcp(deps) {
+    return () => {
+        const context = deps.activeContext();
+        const owner = deps.list().find((w) => w.context === context);
+        return {
+            workspace: context.workspace,
+            sessionStatus: context.sessionStatus,
+            compileLogs: context.compileLogBuffer,
+            closeWindow: () => { if (owner)
+                deps.close(owner.window); },
+        };
+    };
+}
+//# sourceMappingURL=opened-project.js.map

package/dist/main/services/mcp/server.d.ts

@@ -7,5 +7,6 @@
  * only wires up transports and lifecycle.
  */
 import { type Disposable } from '@dimina-kit/electron-deck/main';
-export declare function startMcpServer(resolvedCdpPort: number, mcpPort: number): Disposable;
+import { type McpProjectHost } from './tools/project-tools.js';
+export declare function startMcpServer(resolvedCdpPort: number, mcpPort: number, projectHost: McpProjectHost): Disposable;
 //# sourceMappingURL=server.d.ts.map