@dimina-kit/devtools 0.4.0-dev.20260728080958 → 0.4.0-dev.20260728095034

package/dist/main/index.bundle.js

@@ -419,6 +419,7 @@ var WorkbenchSettingsChannel = {
   Get: "workbenchSettings:get",
   Save: "workbenchSettings:save",
   SetTheme: "workbenchSettings:setTheme",
+  Restart: "workbenchSettings:restart",
   GetCdpStatus: "workbenchSettings:getCdpStatus",
   GetMcpStatus: "workbenchSettings:getMcpStatus",
   Init: "workbenchSettings:init",
@@ -531,6 +532,7 @@ var PopoverChannel = {
 };
 var WindowChannel = {
   NavigateBack: "window:navigateBack",
+  OpenProject: "window:openProject",
   // Renderer → main: the renderer's current top-level screen ('project' when
   // inside a project screen, 'list' on the project list / landing). The
   // renderer pushes this on every screen change, including the moment it enters
@@ -899,7 +901,7 @@ function registerProjectFsIpc(ctx) {
 // src/main/app/app.ts
 import { app as app15, BrowserWindow as BrowserWindow9, nativeImage, session as session4 } from "electron";
 import fs13 from "fs";
-import path25 from "path";
+import path26 from "path";
 
 // src/main/utils/paths.ts
 import fs3 from "fs";
@@ -1597,6 +1599,9 @@ function createRendererNotifier(ctx) {
     windowNavigateBack() {
       sendToMain(WindowChannel.NavigateBack);
     },
+    windowOpenProject(payload) {
+      sendToMain(WindowChannel.OpenProject, payload);
+    },
     popoverClosed() {
       sendToMain(PopoverChannel.Closed);
     },
@@ -1628,6 +1633,104 @@ function createRendererNotifier(ctx) {
   };
 }
 
+// src/main/services/workspace/compile-log-buffer.ts
+var DEFAULT_CAPACITY = 1e3;
+var DEFAULT_READ_LIMIT = 100;
+function createCompileLogBuffer(capacity = DEFAULT_CAPACITY) {
+  const entries = [];
+  let seq = 0;
+  return {
+    append(entry) {
+      entries.push({ seq: ++seq, ...entry });
+      if (entries.length > capacity) entries.splice(0, entries.length - capacity);
+    },
+    read({ afterSeq = 0, limit = DEFAULT_READ_LIMIT, stream } = {}) {
+      const matched = [];
+      for (const entry of entries) {
+        if (entry.seq <= afterSeq) continue;
+        if (stream && entry.stream !== stream) continue;
+        matched.push(entry);
+        if (matched.length >= limit) break;
+      }
+      const last = matched[matched.length - 1];
+      return { entries: matched, nextCursor: last ? last.seq : afterSeq };
+    },
+    clear() {
+      entries.length = 0;
+    }
+  };
+}
+
+// src/main/services/workspace/session-status-store.ts
+function toPhase(status2) {
+  if (status2 === "compiling") return "compiling";
+  if (status2 === "error") return "error";
+  return "ready";
+}
+function createSessionStatusStore() {
+  let snapshot = {
+    phase: "idle",
+    message: "",
+    watcherAlive: true,
+    updatedAt: 0,
+    generation: 0
+  };
+  const waiters = /* @__PURE__ */ new Set();
+  return {
+    get: () => snapshot,
+    record(payload) {
+      const phase = toPhase(payload.status);
+      snapshot = {
+        phase,
+        message: payload.message,
+        // A dead watcher is a session-lifetime fact; only a NEW compile
+        // (fresh open) resets it. Rebuild 'ready' chatter keeps it dead.
+        watcherAlive: payload.watcher === "dead" ? false : phase === "compiling" ? true : snapshot.watcherAlive,
+        updatedAt: Date.now(),
+        generation: snapshot.generation + 1
+      };
+      for (const waiter of [...waiters]) waiter(snapshot);
+    },
+    waitForSettled({ afterGeneration = -1, timeoutMs }) {
+      const isSettled = (s) => s.phase !== "compiling" && s.generation > afterGeneration;
+      if (isSettled(snapshot)) return Promise.resolve(snapshot);
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          waiters.delete(onRecord);
+          reject(new Error(
+            `timed out after ${timeoutMs}ms waiting for the compile to settle (last phase: ${snapshot.phase})`
+          ));
+        }, timeoutMs);
+        const onRecord = (s) => {
+          if (!isSettled(s)) return;
+          clearTimeout(timer);
+          waiters.delete(onRecord);
+          resolve(s);
+        };
+        waiters.add(onRecord);
+      });
+    }
+  };
+}
+
+// src/main/services/workspace/status-tap.ts
+function tapNotifierIntoStores(notify, status2, compileLogs) {
+  return {
+    ...notify,
+    projectStatus(payload) {
+      if (payload.status === "compiling" && payload.hotReload !== true) {
+        compileLogs.clear();
+      }
+      status2.record(payload);
+      notify.projectStatus(payload);
+    },
+    compileLog(payload) {
+      compileLogs.append(payload);
+      notify.compileLog(payload);
+    }
+  };
+}
+
 // src/main/services/safe-area/index.ts
 function guestInsets(device, isTabPage2) {
   const top = device?.safeAreaInsets.top ?? 0;
@@ -4724,8 +4827,8 @@ function createHostToolbarView(ctx, reconciler, deps) {
     hide() {
       hideHostToolbar();
     },
-    setPreloadPath(path26) {
-      hostToolbarPreloadOverride = path26;
+    setPreloadPath(path27) {
+      hostToolbarPreloadOverride = path27;
     },
     setHeightMode(mode) {
       if (mode !== "auto" && !(Number.isFinite(mode.fixed) && mode.fixed >= 0)) {
@@ -6153,7 +6256,13 @@ function createWorkbenchContext(opts) {
   ctx.windows = createWindowService(opts.mainWindow);
   ctx.views = createViewManager(ctx);
   ctx.registry.add(() => ctx.views.disposeAll());
-  ctx.notify = createRendererNotifier(ctx);
+  ctx.sessionStatus = createSessionStatusStore();
+  ctx.compileLogBuffer = createCompileLogBuffer();
+  ctx.notify = tapNotifierIntoStores(
+    createRendererNotifier(ctx),
+    ctx.sessionStatus,
+    ctx.compileLogBuffer
+  );
   ctx.openSettings = () => openSettingsWindow(ctx);
   ctx.projectsProvider = opts.projectsProvider ?? createLocalProjectsProvider();
   ctx.projectTemplates = resolveTemplates(
@@ -6734,6 +6843,9 @@ function registerSettingsIpc(ctx) {
       args
     );
     applyTheme(theme);
+  }).handle(WorkbenchSettingsChannel.Restart, () => {
+    app9.relaunch();
+    app9.quit();
   }).handle(WorkbenchSettingsChannel.GetCdpStatus, () => {
     const settings = loadWorkbenchSettings();
     const switchValue = app9.commandLine.getSwitchValue("remote-debugging-port");
@@ -10813,10 +10925,127 @@ function registerContextTools(server) {
   );
 }
 
-// src/main/services/mcp/tools/simulator-tools.ts
+// src/main/services/mcp/tools/project-tools.ts
+import path18 from "node:path";
 import { z as z5 } from "zod";
-function ok(text) {
-  return { content: [{ type: "text", text }] };
+var DEFAULT_OPEN_TIMEOUT_MS = 18e4;
+var DEFAULT_WAIT_TIMEOUT_MS = 6e4;
+function text(payload) {
+  return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+}
+function errorText(message) {
+  return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+}
+function publicPhase(snapshot, sessionActive) {
+  if (!sessionActive && snapshot.phase === "ready") return "idle";
+  return snapshot.phase;
+}
+function statusPayload(host) {
+  const snapshot = host.sessionStatus.get();
+  const sessionActive = host.workspace.hasActiveSession();
+  return {
+    phase: publicPhase(snapshot, sessionActive),
+    message: snapshot.message,
+    projectPath: host.workspace.getProjectPath(),
+    sessionActive,
+    watcherAlive: snapshot.watcherAlive,
+    updatedAt: snapshot.updatedAt,
+    generation: snapshot.generation
+  };
+}
+function registerProjectTools(server, host) {
+  server.tool(
+    "project_open",
+    "Open a mini-program project: registers the directory if needed, launches it in the simulator (compile + attach), and waits until the compile settles. Returns the settled status; on compile error, pull stderr via compile_logs.",
+    {
+      path: z5.string().describe("Absolute path to the mini-program project directory"),
+      timeoutMs: z5.number().optional().default(DEFAULT_OPEN_TIMEOUT_MS).describe("Max time to wait for the compile to settle")
+    },
+    async ({ path: rawPath, timeoutMs }) => {
+      const dir = path18.resolve(rawPath);
+      const current = host.sessionStatus.get();
+      if (host.workspace.getProjectPath() === dir && host.workspace.hasActiveSession() && current.phase === "ready") {
+        return text({ ...statusPayload(host), note: "project already open" });
+      }
+      const invalid = await host.workspace.validateProjectDir(dir);
+      if (invalid) return errorText(invalid);
+      let project;
+      if (await host.workspace.hasProject(dir)) {
+        const known = (await host.workspace.listProjects()).find((p) => p.path === dir);
+        project = known ?? { name: path18.basename(dir), path: dir };
+      } else {
+        project = await host.workspace.addProject(dir);
+      }
+      const afterGeneration = host.sessionStatus.get().generation;
+      host.requestOpenInUi({ name: project.name, path: project.path });
+      let settled;
+      try {
+        settled = await host.sessionStatus.waitForSettled({ afterGeneration, timeoutMs });
+      } catch (err2) {
+        return errorText(err2 instanceof Error ? err2.message : String(err2));
+      }
+      if (settled.phase === "error") {
+        return errorText(
+          `compile failed: ${settled.message} \u2014 call compile_logs (stream: "stderr") for details`
+        );
+      }
+      return text(statusPayload(host));
+    }
+  );
+  server.tool(
+    "project_close",
+    "Close the currently open project session and return the workbench to the project list.",
+    {},
+    async () => {
+      if (!host.workspace.getProjectPath() && !host.workspace.hasActiveSession()) {
+        return text({ closed: false, note: "no project is open" });
+      }
+      await host.workspace.closeProject();
+      host.requestNavigateBack();
+      return text({ closed: true });
+    }
+  );
+  server.tool(
+    "project_status",
+    "Query the current project compile status (phase: idle | compiling | ready | error). Includes `generation` \u2014 pass it to project_wait_ready to await the NEXT settled state.",
+    {},
+    async () => text(statusPayload(host))
+  );
+  server.tool(
+    "project_wait_ready",
+    'Wait until the compile pipeline settles (phase leaves "compiling"). Watcher rebuilds emit no "compiling" phase, so to await a rebuild after editing files pass the `generation` from a prior project_status.',
+    {
+      afterGeneration: z5.number().optional().describe("Only accept states recorded after this generation (from project_status). Omit to accept the current state when already settled."),
+      timeoutMs: z5.number().optional().default(DEFAULT_WAIT_TIMEOUT_MS).describe("Max time to wait")
+    },
+    async ({ afterGeneration, timeoutMs }) => {
+      try {
+        await host.sessionStatus.waitForSettled({ afterGeneration, timeoutMs });
+      } catch (err2) {
+        return errorText(err2 instanceof Error ? err2.message : String(err2));
+      }
+      return text(statusPayload(host));
+    }
+  );
+  server.tool(
+    "compile_logs",
+    "Pull compile log lines incrementally. Pass the previous call's nextCursor as `cursor` to receive only new lines. The buffer resets on each fresh project open; watcher rebuilds append to the same timeline.",
+    {
+      cursor: z5.number().optional().default(0).describe("Return only lines after this cursor (0 = from the start of the buffer)"),
+      limit: z5.number().optional().default(100).describe("Max lines to return"),
+      stream: z5.enum(["stdout", "stderr"]).optional().describe("Only lines from this stream (stderr carries compile errors)")
+    },
+    async ({ cursor, limit, stream }) => {
+      const read = host.compileLogs.read({ afterSeq: cursor, limit, stream });
+      return text(read);
+    }
+  );
+}
+
+// src/main/services/mcp/tools/simulator-tools.ts
+import { z as z6 } from "zod";
+function ok(text2) {
+  return { content: [{ type: "text", text: text2 }] };
 }
 function err(msg) {
   return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
@@ -10872,8 +11101,8 @@ async function tapSelector(c, selector, nth) {
   await clickAt(c, value.x, value.y);
   return ok(`Tapped selector ${value.selector}[${value.index}] at (${value.x}, ${value.y}) within rect (${value.rect.left}, ${value.rect.top}, ${value.rect.width} x ${value.rect.height})`);
 }
-async function typeText(c, selector, nth, text) {
-  if (!selector || typeof text !== "string") return err("type requires selector and text");
+async function typeText(c, selector, nth, text2) {
+  if (!selector || typeof text2 !== "string") return err("type requires selector and text");
   const { root } = await c.DOM.getDocument({ depth: 0 });
   const { nodeIds } = await c.DOM.querySelectorAll({ nodeId: root.nodeId, selector });
   if (!nodeIds || nodeIds.length === 0) return err(`selector matched no elements: ${selector}`);
@@ -10881,13 +11110,13 @@ async function typeText(c, selector, nth, text) {
   if (index < 0 || index >= nodeIds.length) return err(`nth ${index} out of range (matches: ${nodeIds.length})`);
   await c.DOM.focus({ nodeId: nodeIds[index] });
   try {
-    await c.Input.insertText({ text });
+    await c.Input.insertText({ text: text2 });
   } catch {
-    for (const ch of text) {
+    for (const ch of text2) {
       await c.Input.dispatchKeyEvent({ type: "char", text: ch });
     }
   }
-  return ok(`Typed ${text.length} char(s) into ${selector}[${index}]`);
+  return ok(`Typed ${text2.length} char(s) into ${selector}[${index}]`);
 }
 async function scrollAt(c, x, y, deltaX, deltaY) {
   if (typeof x !== "number" || typeof y !== "number" || typeof deltaX !== "number" || typeof deltaY !== "number") {
@@ -10907,8 +11136,8 @@ async function dispatchKey(c, key) {
 }
 function registerSimulatorTools(server) {
   server.tool("simulator_navigate", "Navigate the simulator to a URL, or reload the current page", {
-    url: z5.string().optional().describe("URL to navigate to"),
-    reload: z5.boolean().optional().describe("If true, reload current page instead of navigating")
+    url: z6.string().optional().describe("URL to navigate to"),
+    reload: z6.boolean().optional().describe("If true, reload current page instead of navigating")
   }, async ({ url, reload }) => {
     const c = getClient("simulator");
     if (reload) {
@@ -10923,16 +11152,16 @@ function registerSimulatorTools(server) {
     return { content: [{ type: "text", text: "Error: either url or reload is required" }], isError: true };
   });
   server.tool("simulator_input", "Dispatch input to the simulator. `tap_coord` requires x and y. `tap_selector` requires selector and optional nth. `type` requires selector and text. `scroll` requires x, y, deltaX, and deltaY. `key` is best-effort for common keys such as Enter, Escape, Tab, Arrow* and Space.", {
-    action: z5.enum(["tap_coord", "tap_selector", "type", "scroll", "key"]).describe("Input action to dispatch"),
-    x: z5.number().optional().describe("Viewport x coordinate for `tap_coord` or `scroll`"),
-    y: z5.number().optional().describe("Viewport y coordinate for `tap_coord` or `scroll`"),
-    selector: z5.string().optional().describe("CSS selector for `tap_selector` or `type`"),
-    nth: z5.number().int().optional().describe("Zero-based index when selector matches multiple elements; defaults to 0"),
-    text: z5.string().optional().describe("Text to insert for `type`"),
-    key: z5.string().optional().describe("Best-effort keyboard key name for `key`; common keys such as Enter, Escape, Tab, Arrow* and Space work best"),
-    deltaX: z5.number().optional().describe("Horizontal wheel delta for `scroll`"),
-    deltaY: z5.number().optional().describe("Vertical wheel delta for `scroll`")
-  }, async ({ action, x, y, selector, nth, text, key, deltaX, deltaY }) => {
+    action: z6.enum(["tap_coord", "tap_selector", "type", "scroll", "key"]).describe("Input action to dispatch"),
+    x: z6.number().optional().describe("Viewport x coordinate for `tap_coord` or `scroll`"),
+    y: z6.number().optional().describe("Viewport y coordinate for `tap_coord` or `scroll`"),
+    selector: z6.string().optional().describe("CSS selector for `tap_selector` or `type`"),
+    nth: z6.number().int().optional().describe("Zero-based index when selector matches multiple elements; defaults to 0"),
+    text: z6.string().optional().describe("Text to insert for `type`"),
+    key: z6.string().optional().describe("Best-effort keyboard key name for `key`; common keys such as Enter, Escape, Tab, Arrow* and Space work best"),
+    deltaX: z6.number().optional().describe("Horizontal wheel delta for `scroll`"),
+    deltaY: z6.number().optional().describe("Vertical wheel delta for `scroll`")
+  }, async ({ action, x, y, selector, nth, text: text2, key, deltaX, deltaY }) => {
     const c = getClient("simulator");
     switch (action) {
       case "tap_coord":
@@ -10940,7 +11169,7 @@ function registerSimulatorTools(server) {
       case "tap_selector":
         return tapSelector(c, selector, nth);
       case "type":
-        return typeText(c, selector, nth, text);
+        return typeText(c, selector, nth, text2);
       case "scroll":
         return scrollAt(c, x, y, deltaX, deltaY);
       case "key":
@@ -10963,7 +11192,7 @@ function registerWorkbenchTools(server) {
 // src/main/services/mcp/server.ts
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../../../../package.json");
-function buildServer() {
+function buildServer(projectHost) {
   const server = new McpServer({
     name: "@dimina-kit/devtools",
     version: pkg.version
@@ -10973,9 +11202,10 @@ function buildServer() {
   registerCommonTargetTools(server, "workbench");
   registerWorkbenchTools(server);
   registerContextTools(server);
+  registerProjectTools(server, projectHost);
   return server;
 }
-function startMcpServer(resolvedCdpPort, mcpPort) {
+function startMcpServer(resolvedCdpPort, mcpPort, projectHost) {
   setCdpPort(resolvedCdpPort);
   connectTarget("simulator").catch(() => {
   });
@@ -10989,7 +11219,7 @@ function startMcpServer(resolvedCdpPort, mcpPort) {
       transports.set(transport.sessionId, transport);
       res.on("close", () => transports.delete(transport.sessionId));
       try {
-        await buildServer().connect(transport);
+        await buildServer(projectHost).connect(transport);
       } catch (err2) {
         transports.delete(transport.sessionId);
         if (!res.headersSent) res.writeHead(500).end("MCP connect failed");
@@ -11206,7 +11436,7 @@ function setupSimulatorCurrentPage(host, options) {
 
 // src/main/services/render-inspect/index.ts
 import { readFileSync } from "node:fs";
-import path18 from "node:path";
+import path19 from "node:path";
 var DEFAULT_SOURCE_PATH = "dist/render-host/render-inspect.js";
 var HIGHLIGHT_CONFIG = {
   showInfo: true,
@@ -11232,7 +11462,7 @@ function withTimeout(p, ms) {
   });
 }
 function createRenderInspector(options = {}) {
-  const loadSource = options.loadSource ?? (() => readFileSync(path18.join(devtoolsPackageRoot, DEFAULT_SOURCE_PATH), "utf8"));
+  const loadSource = options.loadSource ?? (() => readFileSync(path19.join(devtoolsPackageRoot, DEFAULT_SOURCE_PATH), "utf8"));
   let cachedSource = null;
   const injected = /* @__PURE__ */ new Set();
   const broker = options.broker ?? createCdpSessionBroker({ connections: options.connections });
@@ -11344,13 +11574,13 @@ function createRenderInspector(options = {}) {
 import { toDisposable as toDisposable6 } from "@dimina-kit/electron-deck/main";
 
 // src/main/services/simulator-temp-files/store.ts
-function registerTempFile(store, path26, mime, bytes) {
+function registerTempFile(store, path27, mime, bytes) {
   const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(new Uint8Array(bytes));
-  store.delete(path26);
-  store.set(path26, { bytes: buf, mime });
+  store.delete(path27);
+  store.set(path27, { bytes: buf, mime });
 }
-function revokeTempFile(store, path26) {
-  store.delete(path26);
+function revokeTempFile(store, path27) {
+  store.delete(path27);
 }
 function revokeAllTempFiles(store) {
   store.clear();
@@ -11358,14 +11588,14 @@ function revokeAllTempFiles(store) {
 
 // src/shared/vpath.ts
 import os from "node:os";
-import path19 from "node:path";
+import path20 from "node:path";
 var DIFILE_PREFIX = "difile://";
 function sandboxBase() {
   const env = typeof process !== "undefined" && process.env && process.env.DIMINA_HOME || "";
   if (env) {
-    return path19.join(env, "files");
+    return path20.join(env, "files");
   }
-  return path19.join(os.homedir(), ".dimina", "files");
+  return path20.join(os.homedir(), ".dimina", "files");
 }
 function resolveVPath(url) {
   if (typeof url !== "string") return null;
@@ -11399,15 +11629,15 @@ function resolveVPath(url) {
     return { kind, writable };
   }
   const base = sandboxBase();
-  const joined = path19.join(base, decoded);
-  const normalized = path19.normalize(joined);
-  if (normalized !== base && !normalized.startsWith(base + path19.sep)) return null;
+  const joined = path20.join(base, decoded);
+  const normalized = path20.normalize(joined);
+  if (normalized !== base && !normalized.startsWith(base + path20.sep)) return null;
   return { kind, writable, realPath: normalized };
 }
 
 // src/main/services/simulator-temp-files/disk.ts
 import fs9 from "node:fs/promises";
-import path20 from "node:path";
+import path21 from "node:path";
 var EXT_MIME = {
   ".txt": "text/plain",
   ".log": "text/plain",
@@ -11485,7 +11715,7 @@ function sniffMime(head) {
   return hit ? hit.mime : null;
 }
 function extMime(realPath) {
-  const ext = path20.extname(realPath).toLowerCase();
+  const ext = path21.extname(realPath).toLowerCase();
   if (!ext) return null;
   return EXT_MIME[ext] ?? null;
 }
@@ -11559,7 +11789,7 @@ async function readDiskFile(realPath, opts) {
 }
 async function writeDiskFile(realPath, bytes) {
   const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(new Uint8Array(bytes));
-  await fs9.mkdir(path20.dirname(realPath), { recursive: true });
+  await fs9.mkdir(path21.dirname(realPath), { recursive: true });
   await fs9.writeFile(realPath, buf);
 }
 async function readDiskDir(realPath) {
@@ -11701,28 +11931,28 @@ async function handleDifileRequest(ctx, req) {
 
 // src/main/services/simulator-temp-files/fs-channels.ts
 import fs10 from "node:fs/promises";
-import path21 from "node:path";
+import path22 from "node:path";
 async function enforceSandbox(realPath) {
   if (typeof realPath !== "string" || realPath.length === 0) {
     throw new Error("sandbox: realPath must be a non-empty string");
   }
   const base = sandboxBase();
   const baseReal = await fs10.realpath(base).catch(() => base);
-  const normalized = path21.normalize(realPath);
-  if (normalized !== base && !normalized.startsWith(base + path21.sep)) {
+  const normalized = path22.normalize(realPath);
+  if (normalized !== base && !normalized.startsWith(base + path22.sep)) {
     throw new Error("sandbox: realPath escapes the user-data base");
   }
   let probe = normalized;
-  while (probe !== path21.parse(probe).root) {
+  while (probe !== path22.parse(probe).root) {
     try {
       const resolved = await fs10.realpath(probe);
-      if (resolved !== baseReal && !resolved.startsWith(baseReal + path21.sep)) {
+      if (resolved !== baseReal && !resolved.startsWith(baseReal + path22.sep)) {
         throw new Error("sandbox: realPath escapes the user-data base via symlink");
       }
       break;
     } catch (err2) {
       if (err2.code === "ENOENT") {
-        probe = path21.dirname(probe);
+        probe = path22.dirname(probe);
         continue;
       }
       throw err2;
@@ -11778,10 +12008,10 @@ function setupSimulatorTempFiles(simSession) {
   const store = /* @__PURE__ */ new Map();
   const pendingWaiters = /* @__PURE__ */ new Map();
   let disposed = false;
-  function drainWaiters(path26) {
-    const list = pendingWaiters.get(path26);
+  function drainWaiters(path27) {
+    const list = pendingWaiters.get(path27);
     if (!list) return;
-    pendingWaiters.delete(path26);
+    pendingWaiters.delete(path27);
     for (const fn of list) fn();
   }
   function drainAllWaiters() {
@@ -11794,15 +12024,15 @@ function setupSimulatorTempFiles(simSession) {
   const registry = new IpcRegistry(simulatorOnlyPolicy);
   registry.on("simulator:temp-file:write", (_event, payload) => {
     if (disposed) return;
-    const { path: path26, mime, bytes } = payload;
-    registerTempFile(store, path26, mime, bytes);
+    const { path: path27, mime, bytes } = payload;
+    registerTempFile(store, path27, mime, bytes);
     enforceStoreCap(store);
-    drainWaiters(path26);
+    drainWaiters(path27);
   });
   registry.on("simulator:temp-file:revoke", (_event, payload) => {
     if (disposed) return;
-    const { path: path26 } = payload;
-    revokeTempFile(store, path26);
+    const { path: path27 } = payload;
+    revokeTempFile(store, path27);
   });
   registry.on("simulator:temp-file:revoke-all", () => {
     if (disposed) return;
@@ -11948,11 +12178,11 @@ function setupSimulatorSessionPolicy() {
 import http2 from "node:http";
 import nodeFs3 from "node:fs";
 import fs11 from "node:fs/promises";
-import path23 from "node:path";
+import path24 from "node:path";
 
 // src/main/services/fs-watch-sse.ts
 import nodeFs2 from "node:fs";
-import path22 from "node:path";
+import path23 from "node:path";
 
 // src/main/services/http-json.ts
 function jsonRes(res, code, obj) {
@@ -11964,7 +12194,7 @@ function jsonRes(res, code, obj) {
 // src/main/services/fs-watch-sse.ts
 var WATCH_DEBOUNCE_MS = 80;
 function shouldReportWatchPath(rel) {
-  if (rel === "" || rel.startsWith("..") || path22.isAbsolute(rel)) return false;
+  if (rel === "" || rel.startsWith("..") || path23.isAbsolute(rel)) return false;
   return !rel.split("/").some((segment) => SKIP_DIRS.has(segment));
 }
 function handleFsWatchRequest(req, res, getProjectRoot) {
@@ -12005,7 +12235,7 @@ function handleFsWatchRequest(req, res, getProjectRoot) {
 `);
   }
   function onChange(_event, filename) {
-    const rel = filename ? filename.toString().split(path22.sep).join("/") : ".";
+    const rel = filename ? filename.toString().split(path23.sep).join("/") : ".";
     if (rel !== "." && !shouldReportWatchPath(rel)) return;
     pending.add(rel);
     if (!debounceTimer) {
@@ -12060,8 +12290,8 @@ function setIsolationHeaders(res) {
 }
 function containedStaticPath(root, pathname) {
   const rel = pathname.replace(/^\/+/, "") || "index.html";
-  const resolved = path23.resolve(root, rel);
-  if (resolved !== root && !resolved.startsWith(root + path23.sep)) return null;
+  const resolved = path24.resolve(root, rel);
+  if (resolved !== root && !resolved.startsWith(root + path24.sep)) return null;
   return resolved;
 }
 function serveStaticFile(res, root, pathname) {
@@ -12072,7 +12302,7 @@ function serveStaticFile(res, root, pathname) {
     return;
   }
   Promise.all([fs11.realpath(root), fs11.realpath(candidate)]).then(([realRoot, realFile]) => {
-    if (realFile !== realRoot && !realFile.startsWith(realRoot + path23.sep)) {
+    if (realFile !== realRoot && !realFile.startsWith(realRoot + path24.sep)) {
       res.writeHead(403);
       res.end("Forbidden");
       return;
@@ -12084,7 +12314,7 @@ function serveStaticFile(res, root, pathname) {
         return;
       }
       res.writeHead(200, {
-        "Content-Type": MIME[path23.extname(realFile)] ?? "application/octet-stream",
+        "Content-Type": MIME[path24.extname(realFile)] ?? "application/octet-stream",
         "Content-Length": stat.size,
         "Cache-Control": "no-store"
       });
@@ -12238,7 +12468,7 @@ async function listFilesRecursive(dir, base = "") {
   for (const e of entries) {
     const rel = base ? `${base}/${e.name}` : e.name;
     if (e.isDirectory()) {
-      out.push(...await listFilesRecursive(path23.join(dir, e.name), rel));
+      out.push(...await listFilesRecursive(path24.join(dir, e.name), rel));
     } else if (e.isFile()) {
       out.push(rel);
     }
@@ -12255,9 +12485,9 @@ async function readContributedExtensions(extensionsDir) {
   }
   for (const e of entries) {
     if (!e.isDirectory()) continue;
-    const extDir = path23.join(extensionsDir, e.name);
+    const extDir = path24.join(extensionsDir, e.name);
     try {
-      const pkgRaw = await fs11.readFile(path23.join(extDir, "package.json"), "utf8");
+      const pkgRaw = await fs11.readFile(path24.join(extDir, "package.json"), "utf8");
       const files = await listFilesRecursive(extDir);
       out.push({ dir: e.name, packageJson: JSON.parse(pkgRaw), files });
     } catch {
@@ -12266,8 +12496,8 @@ async function readContributedExtensions(extensionsDir) {
   return out;
 }
 async function startWorkbenchCoiServer(options) {
-  const root = path23.resolve(options.rootDir);
-  const contribRoot = options.extensionsDir ? path23.resolve(options.extensionsDir) : null;
+  const root = path24.resolve(options.rootDir);
+  const contribRoot = options.extensionsDir ? path24.resolve(options.extensionsDir) : null;
   const server = http2.createServer((req, res) => {
     setIsolationHeaders(res);
     const url = new URL(req.url ?? "/", "http://127.0.0.1");
@@ -12426,7 +12656,7 @@ var UpdateManager = class {
 
 // src/main/services/update/github-release-checker.ts
 import fs12 from "fs";
-import path24 from "path";
+import path25 from "path";
 import https from "https";
 import { app as app14 } from "electron";
 function createGitHubReleaseChecker(opts) {
@@ -12452,10 +12682,10 @@ function createGitHubReleaseChecker(opts) {
       };
     },
     async downloadUpdate(info, onProgress) {
-      const tmpDir = path24.join(app14.getPath("temp"), `${opts.repo}-update`);
+      const tmpDir = path25.join(app14.getPath("temp"), `${opts.repo}-update`);
       if (!fs12.existsSync(tmpDir)) fs12.mkdirSync(tmpDir, { recursive: true });
-      const fileName = path24.basename(new URL(info.downloadUrl).pathname);
-      const filePath = path24.join(tmpDir, fileName);
+      const fileName = path25.basename(new URL(info.downloadUrl).pathname);
+      const filePath = path25.join(tmpDir, fileName);
       await downloadFile(info.downloadUrl, filePath, opts.token, onProgress);
       return filePath;
     }
@@ -12738,7 +12968,7 @@ async function disposeContext(ctx) {
 function createConfiguredMainWindow(config, rendererDir2) {
   const mainWindow = createMainWindow({
     title: config.appName ?? "Dimina DevTools",
-    indexHtml: path25.join(rendererDir2, "entries/main/index.html"),
+    indexHtml: path26.join(rendererDir2, "entries/main/index.html"),
     width: config.window?.width,
     height: config.window?.height,
     minWidth: config.window?.minWidth,
@@ -12811,12 +13041,20 @@ async function setupAutomation(instance) {
     console.log(`[automation] listening on ws://127.0.0.1:${server.port}`);
   }
 }
-function setupMcp() {
+function setupMcp(context) {
   const settings = loadWorkbenchSettings();
   if (!settings.mcp.enabled) return null;
   const cdpPortSwitch = app15.commandLine.getSwitchValue("remote-debugging-port");
   const cdpPort2 = cdpPortSwitch ? parseInt(cdpPortSwitch, 10) : settings.cdp.port;
-  return startMcpServer(cdpPort2, settings.mcp.port);
+  return startMcpServer(cdpPort2, settings.mcp.port, {
+    workspace: context.workspace,
+    sessionStatus: context.sessionStatus,
+    compileLogs: context.compileLogBuffer,
+    // The renderer owns the open path (mounting ProjectRuntime compiles and
+    // attaches the simulator), so project_open pushes it there.
+    requestOpenInUi: (p) => context.notify.windowOpenProject(p),
+    requestNavigateBack: () => context.notify.windowNavigateBack()
+  });
 }
 function wireAppWindowEvents(config, instance, isOnProjectScreen) {
   const { mainWindow, context } = instance;
@@ -12952,7 +13190,7 @@ async function createDevtoolsRuntime(config = {}, onInstanceCreated) {
     context.registry.add(() => instance.updateManager.dispose());
   }
   await setupAutomation(instance);
-  const mcp = setupMcp();
+  const mcp = setupMcp(context);
   if (mcp) context.registry.add(mcp);
   const getActiveAppId = () => {
     const session5 = context.workspace.getSession();
@@ -13063,8 +13301,8 @@ async function createDevtoolsRuntime(config = {}, onInstanceCreated) {
       bridge: context.bridge
     }));
   }
-  const bundleDir = config.editorViewConfig?.bundleDir ?? path25.join(devtoolsPackageRoot, "dist/vscode-workbench");
-  if (!fs13.existsSync(path25.join(bundleDir, "index.html"))) {
+  const bundleDir = config.editorViewConfig?.bundleDir ?? path26.join(devtoolsPackageRoot, "dist/vscode-workbench");
+  if (!fs13.existsSync(path26.join(bundleDir, "index.html"))) {
     console.warn(
       `[workbench] editor bundle not found at ${bundleDir} \u2014 skipping embedded editor assembly`
     );