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

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/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 };