@dimina-kit/devtools 0.2.0 → 0.3.1

package/dist/main/index.bundle.js

@@ -0,0 +1,2765 @@
+// src/main/app/bootstrap.ts
+import { app as app2 } from "electron";
+
+// src/main/services/settings/index.ts
+import { app, nativeTheme } from "electron";
+import fs from "fs";
+import path from "path";
+var DEFAULTS = {
+  cdp: {
+    enabled: false,
+    port: 9222
+  },
+  mcp: {
+    enabled: false,
+    port: 7789
+  },
+  theme: "system"
+};
+function getSettingsFile() {
+  return path.join(app.getPath("userData"), "dimina-workbench-settings.json");
+}
+function loadWorkbenchSettings() {
+  try {
+    const data = JSON.parse(fs.readFileSync(getSettingsFile(), "utf-8"));
+    const theme = ["system", "dark", "light"].includes(data.theme) ? data.theme : DEFAULTS.theme;
+    return {
+      cdp: {
+        enabled: data.cdp?.enabled ?? DEFAULTS.cdp.enabled,
+        port: data.cdp?.port ?? DEFAULTS.cdp.port
+      },
+      mcp: {
+        enabled: data.mcp?.enabled ?? DEFAULTS.mcp.enabled,
+        port: data.mcp?.port ?? DEFAULTS.mcp.port
+      },
+      theme
+    };
+  } catch {
+    return { ...DEFAULTS, cdp: { ...DEFAULTS.cdp }, mcp: { ...DEFAULTS.mcp } };
+  }
+}
+function saveWorkbenchSettings(settings) {
+  fs.writeFileSync(getSettingsFile(), JSON.stringify(settings, null, 2));
+}
+function applyTheme(theme) {
+  nativeTheme.themeSource = theme;
+}
+
+// src/main/app/bootstrap.ts
+function setupCdpPort() {
+  if (app2.commandLine.getSwitchValue("remote-debugging-port")) return;
+  const envPort = process.env.DIMINA_DEBUG_PORT;
+  if (envPort) {
+    app2.commandLine.appendSwitch("remote-debugging-port", envPort);
+    return;
+  }
+  const settings = loadWorkbenchSettings();
+  if (settings.cdp.enabled || settings.mcp.enabled) {
+    app2.commandLine.appendSwitch("remote-debugging-port", String(settings.cdp.port));
+  } else if (!app2.isPackaged) {
+    app2.commandLine.appendSwitch("remote-debugging-port", String(settings.cdp.port || 9222));
+  }
+}
+
+// src/main/app/app.ts
+import { app as app11, BrowserWindow as BrowserWindow3, nativeImage } from "electron";
+import fs5 from "fs";
+import path6 from "path";
+
+// src/main/utils/paths.ts
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+function resolveDevtoolsPackageRoot() {
+  let dir = path2.dirname(fileURLToPath(import.meta.url));
+  const root = path2.parse(dir).root;
+  while (dir !== root) {
+    const pkgPath = path2.join(dir, "package.json");
+    try {
+      const pkg2 = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+      if (pkg2.name === "@dimina-kit/devtools") return dir;
+    } catch {
+    }
+    dir = path2.dirname(dir);
+  }
+  throw new Error("@dimina-kit/devtools package root not found from " + fileURLToPath(import.meta.url));
+}
+var devtoolsPackageRoot = resolveDevtoolsPackageRoot();
+var rendererDir = path2.join(devtoolsPackageRoot, "dist/renderer");
+var defaultPreloadPath = path2.join(devtoolsPackageRoot, "dist/preload/windows/simulator.js");
+var simulatorDir = path2.join(devtoolsPackageRoot, "dist/simulator");
+
+// src/main/app/lifecycle.ts
+import { app as app3, globalShortcut } from "electron";
+function registerAppLifecycle() {
+  app3.on("window-all-closed", () => {
+    globalShortcut.unregisterAll();
+    app3.quit();
+  });
+  app3.on("before-quit", () => {
+    globalShortcut.unregisterAll();
+  });
+}
+
+// src/main/windows/main-window/create.ts
+import { app as app4, BrowserWindow, View, globalShortcut as globalShortcut2, session } from "electron";
+
+// src/main/services/simulator/referer.ts
+var DEFAULT_VERSION = "develop";
+var cachedRefererUrl = null;
+function buildServicewechatPageFrameReferer(appId, version = DEFAULT_VERSION) {
+  return `https://servicewechat.com/${appId}/${version}/page-frame.html`;
+}
+function setSimulatorServicewechatReferer(appId, version) {
+  cachedRefererUrl = buildServicewechatPageFrameReferer(
+    appId,
+    version && version.length > 0 ? version : DEFAULT_VERSION
+  );
+}
+function clearSimulatorServicewechatReferer() {
+  cachedRefererUrl = null;
+}
+function getSimulatorServicewechatReferer() {
+  return cachedRefererUrl;
+}
+
+// src/main/utils/theme.ts
+import { nativeTheme as nativeTheme2 } from "electron";
+function themeBg() {
+  return nativeTheme2.shouldUseDarkColors ? "#1a1a1a" : "#fafafa";
+}
+
+// src/main/windows/main-window/create.ts
+var simulatorSessionConfigured = false;
+function configureSimulatorSession() {
+  if (simulatorSessionConfigured) return;
+  simulatorSessionConfigured = true;
+  const simulatorSession = session.fromPartition("persist:simulator");
+  simulatorSession.webRequest.onBeforeSendHeaders((details, callback) => {
+    const forcedReferer = getSimulatorServicewechatReferer();
+    if (forcedReferer) {
+      details.requestHeaders["Referer"] = forcedReferer;
+    }
+    callback({ requestHeaders: details.requestHeaders });
+  });
+  simulatorSession.webRequest.onHeadersReceived((details, callback) => {
+    const headers = details.responseHeaders ?? {};
+    headers["access-control-allow-origin"] = ["*"];
+    headers["access-control-allow-headers"] = ["*"];
+    headers["access-control-allow-methods"] = ["*"];
+    headers["Cross-Origin-Opener-Policy"] = ["same-origin"];
+    headers["Cross-Origin-Embedder-Policy"] = ["require-corp"];
+    callback({ responseHeaders: headers });
+  });
+}
+function createMainWindow(opts) {
+  configureSimulatorSession();
+  const mainWindow = new BrowserWindow({
+    width: opts.width ?? 1280,
+    height: opts.height ?? 980,
+    minWidth: opts.minWidth ?? 1e3,
+    minHeight: opts.minHeight ?? 600,
+    title: opts.title ?? "Dimina DevTools",
+    show: false,
+    backgroundColor: themeBg(),
+    webPreferences: {
+      nodeIntegration: true,
+      contextIsolation: false,
+      webviewTag: true
+    }
+  });
+  mainWindow.once("ready-to-show", () => {
+    if (process.env.NODE_ENV === "test") {
+      mainWindow.showInactive();
+    } else {
+      mainWindow.show();
+      if (!app4.isPackaged) {
+        mainWindow.webContents.openDevTools({ mode: "detach" });
+      }
+    }
+  });
+  mainWindow.webContents.on("will-attach-webview", (_event, webPreferences) => {
+    webPreferences.contextIsolation = false;
+  });
+  mainWindow.loadFile(opts.indexHtml);
+  const container = new View();
+  const mainWebView = mainWindow.contentView;
+  container.addChildView(mainWebView);
+  mainWindow.contentView = container;
+  globalShortcut2.register("CommandOrControl+Shift+I", () => {
+    mainWindow.webContents.openDevTools({ mode: "detach" });
+  });
+  return mainWindow;
+}
+
+// src/main/windows/main-window/events.ts
+function wireMainWindowEvents(win, state = {}) {
+  const mainWebView = win.contentView.children[0];
+  const resizeMainWebView = () => {
+    if (mainWebView) {
+      const [w, h] = win.getContentSize();
+      mainWebView.setBounds({ x: 0, y: 0, width: w, height: h });
+    }
+    state.onResize?.();
+  };
+  resizeMainWebView();
+  win.on("resize", resizeMainWebView);
+  if (state.onClose) {
+    win.on("close", (event) => {
+      void state.onClose?.(event);
+    });
+  }
+}
+
+// src/main/services/default-adapter.ts
+import path3 from "path";
+import { app as app5 } from "electron";
+var defaultAdapter = {
+  async openProject(opts) {
+    const diminaKit = await import("@dimina-kit/devkit");
+    const openProject = diminaKit.openProject;
+    return openProject({
+      outputDir: path3.join(app5.getPath("userData"), "dimina-fe-output"),
+      ...opts,
+      simulatorDir
+    });
+  }
+};
+
+// src/shared/ipc-channels.ts
+var SimulatorChannel = {
+  Attach: "simulator:attach",
+  Detach: "simulator:detach",
+  Resize: "simulator:resize",
+  SetVisible: "simulator:setVisible",
+  Console: "simulator:console",
+  Wxml: "simulator:wxml",
+  AppData: "simulator:appdata",
+  AppDataAll: "simulator:appdata-all"
+};
+var SimulatorStorageChannel = {
+  GetSnapshot: "simulator:storage:snapshot",
+  Event: "simulator:storage:event"
+};
+var SimulatorElementChannel = {
+  Inspect: "simulator:element:inspect",
+  Clear: "simulator:element:clear"
+};
+var WorkbenchChannel = {
+  GetPanelConfig: "workbench:getPanelConfig",
+  GetApiNamespaces: "workbench:getApiNamespaces",
+  Reset: "workbench:reset"
+};
+var WorkbenchSettingsChannel = {
+  Get: "workbenchSettings:get",
+  Save: "workbenchSettings:save",
+  SetTheme: "workbenchSettings:setTheme",
+  GetCdpStatus: "workbenchSettings:getCdpStatus",
+  SetVisible: "workbenchSettings:setVisible",
+  Init: "workbenchSettings:init"
+};
+var ProjectChannel = {
+  Open: "project:open",
+  Close: "project:close",
+  GetPages: "project:getPages",
+  GetCompileConfig: "project:getCompileConfig",
+  SaveCompileConfig: "project:saveCompileConfig",
+  Status: "project:status"
+};
+var ProjectsChannel = {
+  List: "projects:list",
+  Add: "projects:add",
+  Remove: "projects:remove"
+};
+var DialogChannel = {
+  OpenDirectory: "dialog:openDirectory"
+};
+var PanelChannel = {
+  List: "panel:list",
+  Eval: "panel:eval",
+  Select: "panel:select",
+  SelectSimulator: "panel:selectSimulator"
+};
+var PopoverChannel = {
+  Show: "popover:show",
+  Hide: "popover:hide",
+  Relaunch: "popover:relaunch",
+  Closed: "popover:closed",
+  Init: "popover:init"
+};
+var ToolbarChannel = {
+  GetActions: "toolbar:getActions",
+  ActionsChanged: "toolbar:actionsChanged",
+  /** Prefix for dynamic action channels: `toolbar:action:${actionId}` */
+  ActionPrefix: "toolbar:action:"
+};
+var WindowChannel = {
+  NavigateBack: "window:navigateBack"
+};
+var AppChannel = {
+  GetPreloadPath: "app:getPreloadPath",
+  GetBranding: "app:getBranding"
+};
+var AutomationChannel = {
+  GetPort: "automation:port"
+};
+var SettingsChannel = {
+  SetVisible: "settings:setVisible",
+  ConfigChanged: "settings:configChanged",
+  ProjectSettingsChanged: "settings:projectSettingsChanged",
+  Init: "settings:init",
+  Closed: "settings:closed",
+  Changed: "settings:changed"
+};
+
+// src/main/services/notifications/renderer-notifier.ts
+function liveWebContents(wc) {
+  if (!wc) return null;
+  if (wc.isDestroyed()) return null;
+  return wc;
+}
+function createRendererNotifier(ctx) {
+  function sendToMain(channel, ...args) {
+    if (ctx.mainWindow.isDestroyed()) return;
+    const wc = liveWebContents(ctx.mainWindow.webContents);
+    if (!wc) return;
+    wc.send(channel, ...args);
+  }
+  return {
+    projectStatus(payload) {
+      sendToMain(ProjectChannel.Status, payload);
+    },
+    windowNavigateBack() {
+      sendToMain(WindowChannel.NavigateBack);
+    },
+    settingsClosed() {
+      sendToMain(SettingsChannel.Closed);
+    },
+    settingsChanged(config) {
+      sendToMain(SettingsChannel.Changed, config);
+    },
+    popoverClosed() {
+      sendToMain(PopoverChannel.Closed);
+    },
+    popoverRelaunch(config) {
+      sendToMain(PopoverChannel.Relaunch, config);
+    },
+    workbenchReset() {
+      sendToMain(WorkbenchChannel.Reset);
+    },
+    toolbarActionsChanged() {
+      sendToMain(ToolbarChannel.ActionsChanged);
+    },
+    popoverInit(popoverView, payload) {
+      const wc = liveWebContents(popoverView.webContents);
+      if (!wc) return;
+      wc.send(PopoverChannel.Init, payload);
+    },
+    settingsInit(payload) {
+      const wc = liveWebContents(ctx.views.getSettingsWebContents());
+      if (!wc) return;
+      wc.send(SettingsChannel.Init, payload);
+    },
+    workbenchSettingsInit(window, payload) {
+      if (window.isDestroyed()) return;
+      const wc = liveWebContents(window.webContents);
+      if (!wc) return;
+      wc.send(WorkbenchSettingsChannel.Init, payload);
+    }
+  };
+}
+
+// src/main/services/views/view-manager.ts
+import { WebContentsView as WebContentsView2, webContents } from "electron";
+import path4 from "path";
+
+// src/main/services/layout/index.ts
+var HEADER_H = 40;
+var SPLITTER_W = 4;
+function getRightX(simWidth) {
+  return simWidth + SPLITTER_W;
+}
+function computeRightPanelBounds(contentWidth, contentHeight, simWidth) {
+  const x = getRightX(simWidth);
+  return {
+    x,
+    y: HEADER_H,
+    width: Math.max(1, contentWidth - x),
+    height: Math.max(1, contentHeight - HEADER_H)
+  };
+}
+function computeSimulatorBounds(contentWidth, contentHeight, simWidth) {
+  return computeRightPanelBounds(contentWidth, contentHeight, simWidth);
+}
+var SETTINGS_W = 320;
+function computeSettingsBounds(contentWidth, contentHeight) {
+  return {
+    x: Math.max(0, contentWidth - SETTINGS_W),
+    y: HEADER_H,
+    width: SETTINGS_W,
+    height: Math.max(1, contentHeight - HEADER_H)
+  };
+}
+function computePopoverBounds(contentWidth, contentHeight) {
+  return {
+    x: 0,
+    y: HEADER_H,
+    width: contentWidth,
+    height: contentHeight - HEADER_H
+  };
+}
+
+// src/main/services/views/view-manager.ts
+function createViewManager(ctx) {
+  let simulatorView = null;
+  let simulatorViewAdded = false;
+  let settingsView = null;
+  let settingsViewAdded = false;
+  let popoverView = null;
+  let lastSimWidth = 375;
+  let simulatorWebContentsId = null;
+  function destroyViewInternal(view) {
+    if (!view) return;
+    if (!ctx.mainWindow.isDestroyed()) {
+      try {
+        ctx.mainWindow.contentView.removeChildView(view);
+      } catch {
+      }
+    }
+    try {
+      if (!view.webContents.isDestroyed()) {
+        view.webContents.close();
+      }
+    } catch {
+    }
+  }
+  function applySimulatorBounds(simWidth) {
+    if (!simulatorView || ctx.mainWindow.isDestroyed()) return;
+    const [w = 0, h = 0] = ctx.mainWindow.getContentSize();
+    simulatorView.setBounds(computeSimulatorBounds(w, h, simWidth));
+  }
+  function applySettingsBounds() {
+    if (!settingsView || ctx.mainWindow.isDestroyed()) return;
+    const [w = 0, h = 0] = ctx.mainWindow.getContentSize();
+    settingsView.setBounds(computeSettingsBounds(w, h));
+  }
+  function applyPopoverBounds() {
+    if (!popoverView || ctx.mainWindow.isDestroyed()) return;
+    const [w = 0, h = 0] = ctx.mainWindow.getContentSize();
+    popoverView.setBounds(computePopoverBounds(w, h));
+  }
+  function attachSimulator(simWcId, simWidth) {
+    const sim = webContents.fromId(simWcId);
+    if (!sim) {
+      console.error("[workbench] attachSimulator \u2014 simWc not found for id", simWcId);
+      return;
+    }
+    lastSimWidth = simWidth;
+    simulatorWebContentsId = simWcId;
+    if (simulatorView) {
+      hideSimulator();
+      try {
+        if (!simulatorView.webContents.isDestroyed()) {
+          simulatorView.webContents.close();
+        }
+      } catch {
+      }
+      simulatorView = null;
+    }
+    simulatorView = new WebContentsView2();
+    sim.setDevToolsWebContents(simulatorView.webContents);
+    sim.openDevTools();
+    const devtoolsWc = simulatorView.webContents;
+    devtoolsWc.once("dom-ready", () => {
+      devtoolsWc.executeJavaScript(`
+        (function() {
+          try { localStorage.setItem('panel-selectedTab', '"console"') } catch {}
+          let tries = 0
+          const timer = setInterval(() => {
+            tries++
+            const tabs = document.querySelectorAll('[role="tab"], .tabbed-pane-header-tab')
+            for (const tab of tabs) {
+              const label = (tab.getAttribute('aria-label') || tab.textContent || '').trim().toLowerCase()
+              if (label === 'console' || label.startsWith('console')) {
+                tab.click()
+                clearInterval(timer)
+                return
+              }
+            }
+            if (tries > 40) clearInterval(timer)
+          }, 100)
+        })()
+      `).catch(() => {
+      });
+    });
+    if (getDefaultTab(ctx) === "simulator") {
+      ctx.mainWindow.contentView.addChildView(simulatorView);
+      simulatorViewAdded = true;
+      applySimulatorBounds(simWidth);
+    }
+  }
+  function detachSimulator() {
+    hidePopover();
+    destroyViewInternal(settingsView);
+    settingsView = null;
+    settingsViewAdded = false;
+    destroyViewInternal(simulatorView);
+    simulatorView = null;
+    simulatorViewAdded = false;
+    simulatorWebContentsId = null;
+  }
+  function showSimulator(simWidth) {
+    lastSimWidth = simWidth;
+    if (!simulatorView) return;
+    if (!simulatorViewAdded) {
+      ctx.mainWindow.contentView.addChildView(simulatorView);
+      simulatorViewAdded = true;
+    }
+    applySimulatorBounds(simWidth);
+  }
+  function hideSimulator() {
+    if (simulatorView && simulatorViewAdded) {
+      try {
+        ctx.mainWindow.contentView.removeChildView(simulatorView);
+      } catch (e) {
+        console.error("[workbench] hideSimulator error", e);
+      }
+      simulatorViewAdded = false;
+    }
+  }
+  async function showSettings() {
+    if (!settingsView) {
+      settingsView = new WebContentsView2({
+        webPreferences: { nodeIntegration: true, contextIsolation: false }
+      });
+      await settingsView.webContents.loadFile(
+        path4.join(ctx.rendererDir, "entries/settings/index.html")
+      );
+    }
+    if (!settingsViewAdded) {
+      ctx.mainWindow.contentView.addChildView(settingsView);
+      settingsViewAdded = true;
+    }
+    applySettingsBounds();
+  }
+  function hideSettings() {
+    if (settingsView && settingsViewAdded) {
+      try {
+        ctx.mainWindow.contentView.removeChildView(settingsView);
+      } catch {
+      }
+      settingsViewAdded = false;
+    }
+  }
+  function showPopover(data) {
+    hidePopover();
+    const popover = new WebContentsView2({
+      webPreferences: { nodeIntegration: true, contextIsolation: false }
+    });
+    popoverView = popover;
+    popover.setBackgroundColor("#00000000");
+    ctx.mainWindow.contentView.addChildView(popover);
+    applyPopoverBounds();
+    popover.webContents.once("did-finish-load", () => {
+      ctx.notify.popoverInit(popover, data);
+    });
+    popover.webContents.loadFile(
+      path4.join(ctx.rendererDir, "entries/popover/index.html")
+    );
+  }
+  function hidePopover() {
+    if (popoverView) {
+      destroyViewInternal(popoverView);
+      popoverView = null;
+      ctx.notify.popoverClosed();
+    }
+  }
+  function repositionAll() {
+    if (simulatorView && simulatorViewAdded)
+      applySimulatorBounds(lastSimWidth);
+    if (settingsView && settingsViewAdded)
+      applySettingsBounds();
+    if (popoverView)
+      applyPopoverBounds();
+  }
+  function disposeAll() {
+    detachSimulator();
+  }
+  function logChildViews(_label) {
+  }
+  function positionSimulator(simWidth) {
+    applySimulatorBounds(simWidth);
+  }
+  function positionSettings() {
+    applySettingsBounds();
+  }
+  function resize(simWidth) {
+    lastSimWidth = simWidth;
+    if (simulatorViewAdded) applySimulatorBounds(simWidth);
+    if (settingsViewAdded) applySettingsBounds();
+  }
+  function setVisible(visible, simWidth) {
+    lastSimWidth = simWidth;
+    if (!simulatorView) return;
+    if (visible && !simulatorViewAdded) {
+      showSimulator(simWidth);
+    } else if (!visible) {
+      hideSimulator();
+    }
+  }
+  return {
+    attachSimulator,
+    detachSimulator,
+    showSimulator,
+    hideSimulator,
+    showSettings,
+    hideSettings,
+    showPopover,
+    hidePopover,
+    repositionAll,
+    disposeAll,
+    logChildViews,
+    positionSimulator,
+    positionSettings,
+    getSimulatorWebContentsId: () => simulatorWebContentsId,
+    getLastSimWidth: () => lastSimWidth,
+    isSimulatorAdded: () => simulatorViewAdded,
+    hasSimulatorView: () => simulatorView !== null,
+    getSettingsWebContents: () => {
+      if (!settingsView) return null;
+      if (settingsView.webContents.isDestroyed()) return null;
+      return settingsView.webContents;
+    },
+    resize,
+    setVisible
+  };
+}
+
+// src/main/services/projects/project-repository.ts
+import { app as app6 } from "electron";
+import path5 from "path";
+import fs3 from "fs";
+
+// src/shared/constants.ts
+var DEFAULT_SCENE = 1001;
+
+// src/main/utils/logger.ts
+var LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var LEVEL_PREFIX = {
+  debug: "[DEBUG]",
+  info: "[INFO]",
+  warn: "[WARN]",
+  error: "[ERROR]"
+};
+var currentLevel = "debug";
+function shouldLog(level) {
+  return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[currentLevel];
+}
+function formatMessage(level, tag, message) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  return `${ts} ${LEVEL_PREFIX[level]} [${tag}] ${message}`;
+}
+function createLogger(tag) {
+  return {
+    debug(message, ...args) {
+      if (shouldLog("debug")) console.debug(formatMessage("debug", tag, message), ...args);
+    },
+    info(message, ...args) {
+      if (shouldLog("info")) console.info(formatMessage("info", tag, message), ...args);
+    },
+    warn(message, ...args) {
+      if (shouldLog("warn")) console.warn(formatMessage("warn", tag, message), ...args);
+    },
+    error(message, ...args) {
+      if (shouldLog("error")) console.error(formatMessage("error", tag, message), ...args);
+    }
+  };
+}
+
+// src/main/services/projects/project-repository.ts
+var log = createLogger("projects");
+function getProjectsFile() {
+  return path5.join(app6.getPath("userData"), "dimina-projects.json");
+}
+function load() {
+  try {
+    return JSON.parse(fs3.readFileSync(getProjectsFile(), "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function save(projects) {
+  fs3.writeFileSync(getProjectsFile(), JSON.stringify(projects, null, 2));
+}
+function listProjects() {
+  return load();
+}
+function validateProjectDir(dirPath) {
+  if (!dirPath) {
+    return "\u5C0F\u7A0B\u5E8F\u76EE\u5F55\u8DEF\u5F84\u4E3A\u7A7A\uFF0C\u8BF7\u9009\u62E9\u5305\u542B\u5C0F\u7A0B\u5E8F\u6E90\u7801\u7684\u76EE\u5F55";
+  }
+  if (!fs3.existsSync(dirPath)) {
+    return `\u5C0F\u7A0B\u5E8F\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${dirPath}`;
+  }
+  if (!fs3.existsSync(path5.join(dirPath, "app.json"))) {
+    const configPath = path5.join(dirPath, "project.config.json");
+    if (fs3.existsSync(configPath)) {
+      try {
+        const cfg = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+        if (cfg.miniprogramRoot) {
+          const resolvedRoot = path5.resolve(dirPath, cfg.miniprogramRoot);
+          return `\u8BE5\u76EE\u5F55\u7F3A\u5C11 app.json\uFF0Cproject.config.json \u4E2D\u6307\u5B9A\u4E86 miniprogramRoot: "${cfg.miniprogramRoot}"\uFF0C\u8BF7\u5BFC\u5165 ${resolvedRoot}`;
+        }
+      } catch (err) {
+        log.warn("Failed to parse project.config.json", err);
+      }
+    }
+    return "\u8BE5\u76EE\u5F55\u7F3A\u5C11 app.json\uFF0C\u8BF7\u9009\u62E9\u5305\u542B\u5C0F\u7A0B\u5E8F\u6E90\u7801\u7684\u76EE\u5F55";
+  }
+  return null;
+}
+function addProject(dirPath) {
+  const projects = load();
+  let name = path5.basename(dirPath);
+  try {
+    const configPath = path5.join(dirPath, "project.config.json");
+    if (fs3.existsSync(configPath)) {
+      const cfg = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+      if (cfg.projectname) name = cfg.projectname;
+    }
+  } catch (err) {
+    log.warn("Failed to read project name from config", err);
+  }
+  const project = { name, path: dirPath, lastOpened: null };
+  const idx = projects.findIndex((p) => p.path === dirPath);
+  if (idx >= 0) {
+    projects[idx] = { ...projects[idx], name };
+  } else {
+    projects.unshift(project);
+  }
+  save(projects);
+  return project;
+}
+function removeProject(dirPath) {
+  save(load().filter((p) => p.path !== dirPath));
+}
+function updateLastOpened(dirPath) {
+  const projects = load();
+  const idx = projects.findIndex((p) => p.path === dirPath);
+  if (idx >= 0) {
+    projects[idx] = { ...projects[idx], lastOpened: (/* @__PURE__ */ new Date()).toISOString() };
+    save(projects);
+  }
+}
+function getCompileConfig(dirPath) {
+  const projects = load();
+  const project = projects.find((p) => p.path === dirPath);
+  return project?.compileConfig ?? {
+    startPage: "",
+    scene: DEFAULT_SCENE,
+    queryParams: []
+  };
+}
+function getProjectPages(dirPath) {
+  const appJsonPath = path5.join(dirPath, "app.json");
+  try {
+    const appJson = JSON.parse(
+      fs3.readFileSync(appJsonPath, "utf-8")
+    );
+    return {
+      pages: appJson.pages || [],
+      entryPagePath: appJson.entryPagePath || appJson.pages?.[0] || ""
+    };
+  } catch {
+    return { pages: [], entryPagePath: "" };
+  }
+}
+function saveCompileConfig(dirPath, config) {
+  const projects = load();
+  const idx = projects.findIndex((p) => p.path === dirPath);
+  if (idx >= 0) {
+    projects[idx] = { ...projects[idx], compileConfig: config };
+    save(projects);
+  }
+}
+function getProjectSettings(projectPath) {
+  if (!projectPath) {
+    return { uploadWithSourceMap: false };
+  }
+  try {
+    const configPath = path5.join(projectPath, "project.config.json");
+    const config = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+    return {
+      uploadWithSourceMap: !!config.setting?.uploadWithSourceMap
+    };
+  } catch {
+    return { uploadWithSourceMap: false };
+  }
+}
+function updateProjectSettings(projectPath, patch) {
+  if (!projectPath) return;
+  const configPath = path5.join(projectPath, "project.config.json");
+  let config = {};
+  try {
+    config = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+  } catch {
+  }
+  const nextSetting = {
+    ...config.setting ?? {},
+    ...patch.uploadWithSourceMap === void 0 ? {} : { uploadWithSourceMap: patch.uploadWithSourceMap }
+  };
+  fs3.writeFileSync(
+    configPath,
+    JSON.stringify({ ...config, setting: nextSetting }, null, 2)
+  );
+}
+
+// src/main/services/workspace/workspace-service.ts
+function createWorkspaceService(ctx) {
+  let currentSession = null;
+  let currentProjectPath = "";
+  function sendStatus(status, message) {
+    ctx.notify.projectStatus({ status, message });
+  }
+  function bestEffort(label, fn) {
+    try {
+      fn();
+    } catch (err) {
+      console.warn(`[workspace] ${label} failed (non-fatal):`, err);
+    }
+  }
+  async function disposeSession() {
+    if (!currentSession) return;
+    const session2 = currentSession;
+    currentSession = null;
+    try {
+      await Promise.race([
+        session2.close(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("session close timed out")), 5e3)
+        )
+      ]);
+    } catch (err) {
+      console.error("[workspace] session close failed:", err);
+    }
+  }
+  function applyRefererFromSession(session2) {
+    const appInfo = session2.appInfo;
+    if (appInfo && typeof appInfo.appId === "string" && appInfo.appId.length > 0) {
+      setSimulatorServicewechatReferer(
+        appInfo.appId,
+        typeof appInfo.version === "string" ? appInfo.version : void 0
+      );
+    }
+  }
+  return {
+    listProjects: () => listProjects(),
+    addProject: (dirPath) => addProject(dirPath),
+    removeProject: (dirPath) => removeProject(dirPath),
+    validateProjectDir: (dirPath) => validateProjectDir(dirPath),
+    async openProject(projectPath) {
+      clearSimulatorServicewechatReferer();
+      await disposeSession();
+      currentProjectPath = "";
+      const dirError = validateProjectDir(projectPath);
+      if (dirError) {
+        sendStatus("error", dirError);
+        return { success: false, error: dirError };
+      }
+      sendStatus("compiling", "\u6B63\u5728\u7F16\u8BD1...");
+      let session2;
+      try {
+        session2 = await ctx.adapter.openProject({
+          projectPath,
+          sourcemap: true,
+          onRebuild: () => sendStatus("ready", "\u7F16\u8BD1\u5B8C\u6210\uFF0C\u5DF2\u70ED\u66F4\u65B0"),
+          onBuildError: (err) => sendStatus("error", String(err))
+        });
+      } catch (err) {
+        clearSimulatorServicewechatReferer();
+        sendStatus("error", String(err));
+        return { success: false, error: String(err) };
+      }
+      currentSession = session2;
+      currentProjectPath = projectPath;
+      bestEffort("updateLastOpened", () => updateLastOpened(projectPath));
+      bestEffort("sendStatus", () => sendStatus("ready", "\u7F16\u8BD1\u5B8C\u6210"));
+      bestEffort("applyReferer", () => applyRefererFromSession(session2));
+      return {
+        success: true,
+        port: session2.port,
+        appInfo: session2.appInfo
+      };
+    },
+    async closeProject() {
+      clearSimulatorServicewechatReferer();
+      await disposeSession();
+      currentProjectPath = "";
+      ctx.views.disposeAll();
+    },
+    getSession: () => currentSession,
+    getProjectPath: () => currentProjectPath,
+    hasActiveSession: () => currentSession !== null,
+    getProjectPages: (projectPath) => getProjectPages(projectPath),
+    getCompileConfig: (projectPath) => getCompileConfig(projectPath),
+    saveCompileConfig: (projectPath, config) => saveCompileConfig(projectPath, config),
+    getProjectSettings: (projectPath) => getProjectSettings(projectPath),
+    updateProjectSettings: (projectPath, patch) => updateProjectSettings(projectPath, patch)
+  };
+}
+
+// src/main/services/workbench-context.ts
+function hasBuiltinPanel(ctx, panelId) {
+  return ctx.panels.includes(panelId);
+}
+function getDefaultTab(ctx) {
+  if (hasBuiltinPanel(ctx, "console")) return "simulator";
+  if (ctx.panels.length > 0) return ctx.panels[0];
+  return "simulator";
+}
+function createWorkbenchContext(opts) {
+  const ctx = {
+    mainWindow: opts.mainWindow,
+    adapter: opts.adapter ?? defaultAdapter,
+    preloadPath: opts.preloadPath,
+    rendererDir: opts.rendererDir,
+    panels: opts.panels ?? ["wxml", "console", "appdata", "storage"],
+    apiNamespaces: opts.apiNamespaces ?? [],
+    appName: opts.appName ?? "Dimina DevTools",
+    toolbarActions: opts.toolbarActions,
+    brandingProvider: opts.brandingProvider,
+    workbenchSettingsWindow: null
+  };
+  ctx.views = createViewManager(ctx);
+  ctx.notify = createRendererNotifier(ctx);
+  ctx.workspace = createWorkspaceService(ctx);
+  return ctx;
+}
+
+// src/main/menu/index.ts
+import { Menu } from "electron";
+function installAppMenu(ctx) {
+  const template = [
+    {
+      label: "Dimina DevTools",
+      submenu: [
+        {
+          label: "\u5F00\u53D1\u5DE5\u5177\u8BBE\u7F6E",
+          click: () => {
+            void openSettingsWindow(ctx).catch(() => {
+            });
+          }
+        },
+        { type: "separator" },
+        { role: "about" },
+        { type: "separator" },
+        { role: "services" },
+        { type: "separator" },
+        { role: "hide" },
+        { role: "hideOthers" },
+        { role: "unhide" },
+        { type: "separator" },
+        { role: "quit" }
+      ]
+    },
+    {
+      label: "\u7F16\u8F91",
+      submenu: [
+        { role: "undo" },
+        { role: "redo" },
+        { type: "separator" },
+        { role: "cut" },
+        { role: "copy" },
+        { role: "paste" },
+        { role: "selectAll" }
+      ]
+    },
+    {
+      label: "\u89C6\u56FE",
+      submenu: [
+        { role: "reload" },
+        { role: "forceReload" },
+        { role: "toggleDevTools" },
+        { type: "separator" },
+        { role: "resetZoom" },
+        { role: "zoomIn" },
+        { role: "zoomOut" },
+        { type: "separator" },
+        { role: "togglefullscreen" }
+      ]
+    },
+    {
+      label: "\u7A97\u53E3",
+      submenu: [
+        { role: "minimize" },
+        { role: "zoom" },
+        { type: "separator" },
+        { role: "front" },
+        { role: "window" }
+      ]
+    }
+  ];
+  Menu.setApplicationMenu(Menu.buildFromTemplate(template));
+}
+
+// src/main/ipc/app.ts
+import { ipcMain } from "electron";
+import fs4 from "fs";
+function registerAppIpc(ctx) {
+  ipcMain.handle(AppChannel.GetPreloadPath, () => {
+    return `file://${fs4.realpathSync(ctx.preloadPath)}`;
+  });
+  ipcMain.handle(AppChannel.GetBranding, async () => {
+    if (ctx.brandingProvider) return ctx.brandingProvider();
+    return { appName: ctx.appName };
+  });
+}
+
+// src/main/ipc/simulator.ts
+import { ipcMain as ipcMain2 } from "electron";
+function registerSimulatorIpc(ctx) {
+  ipcMain2.handle(SimulatorChannel.Attach, (_, simWcId, simWidth) => {
+    ctx.views.attachSimulator(simWcId, simWidth);
+  });
+  ipcMain2.handle(SimulatorChannel.Detach, () => {
+    ctx.views.detachSimulator();
+  });
+  ipcMain2.handle(SimulatorChannel.Resize, (_, simWidth) => {
+    ctx.views.resize(simWidth);
+  });
+  ipcMain2.handle(SimulatorChannel.SetVisible, (_, visible, simWidth) => {
+    ctx.views.setVisible(visible, simWidth);
+  });
+  ipcMain2.handle(WorkbenchChannel.GetPanelConfig, () => {
+    return ctx.panels;
+  });
+  ipcMain2.handle(WorkbenchChannel.GetApiNamespaces, () => {
+    return ctx.apiNamespaces;
+  });
+  ipcMain2.on(WorkbenchChannel.Reset, () => {
+    ctx.notify.workbenchReset();
+  });
+}
+
+// src/main/ipc/panels.ts
+import { ipcMain as ipcMain3, webContents as webContents2 } from "electron";
+var BUILTIN_PANELS = [
+  { id: "wxml", label: "WXML" },
+  { id: "appdata", label: "AppData" },
+  { id: "storage", label: "Storage" }
+];
+function registerPanelsIpc(ctx) {
+  ipcMain3.handle(PanelChannel.List, () => {
+    return BUILTIN_PANELS.filter((p) => ctx.panels.includes(p.id));
+  });
+  ipcMain3.handle(PanelChannel.Eval, async (_, expression) => {
+    const simWcId = ctx.views.getSimulatorWebContentsId();
+    if (!ctx.workspace.hasActiveSession() || simWcId == null) return void 0;
+    const sim = webContents2.fromId(simWcId);
+    if (!sim || sim.isDestroyed()) return void 0;
+    try {
+      return await sim.executeJavaScript(expression);
+    } catch {
+      return void 0;
+    }
+  });
+  ipcMain3.handle(PanelChannel.Select, (_event, _panelId) => {
+    if (ctx.views.hasSimulatorView() && ctx.views.isSimulatorAdded()) {
+      ctx.views.hideSimulator();
+    }
+  });
+  ipcMain3.handle(PanelChannel.SelectSimulator, () => {
+    if (ctx.views.hasSimulatorView() && !ctx.views.isSimulatorAdded()) {
+      ctx.views.showSimulator(ctx.views.getLastSimWidth());
+    }
+  });
+}
+
+// src/main/ipc/popover.ts
+import { ipcMain as ipcMain4 } from "electron";
+function registerPopoverIpc(ctx) {
+  ipcMain4.handle(PopoverChannel.Show, (_event, data) => {
+    ctx.views.showPopover(data);
+  });
+  ipcMain4.handle(PopoverChannel.Hide, () => ctx.views.hidePopover());
+  ipcMain4.on(PopoverChannel.Relaunch, (_, newConfig) => {
+    ctx.views.hidePopover();
+    ctx.notify.popoverRelaunch(newConfig);
+  });
+}
+
+// src/main/ipc/projects.ts
+import { ipcMain as ipcMain5, dialog } from "electron";
+function registerProjectsIpc(ctx) {
+  ipcMain5.handle(ProjectsChannel.List, () => ctx.workspace.listProjects());
+  ipcMain5.handle(DialogChannel.OpenDirectory, async () => {
+    const result = await dialog.showOpenDialog(ctx.mainWindow, {
+      properties: ["openDirectory"],
+      title: "\u9009\u62E9\u5C0F\u7A0B\u5E8F\u9879\u76EE\u76EE\u5F55"
+    });
+    return result.canceled ? null : result.filePaths[0];
+  });
+  ipcMain5.handle(
+    ProjectsChannel.Add,
+    (_, dirPath) => ctx.workspace.addProject(dirPath)
+  );
+  ipcMain5.handle(
+    ProjectsChannel.Remove,
+    (_, dirPath) => ctx.workspace.removeProject(dirPath)
+  );
+}
+
+// src/main/ipc/session.ts
+import { ipcMain as ipcMain6 } from "electron";
+function registerSessionIpc(ctx) {
+  ipcMain6.handle(
+    ProjectChannel.Open,
+    (_, projectPath) => ctx.workspace.openProject(projectPath)
+  );
+  ipcMain6.handle(
+    ProjectChannel.GetPages,
+    (_, projectPath) => ctx.workspace.getProjectPages(projectPath)
+  );
+  ipcMain6.handle(
+    ProjectChannel.GetCompileConfig,
+    (_, projectPath) => ctx.workspace.getCompileConfig(projectPath)
+  );
+  ipcMain6.handle(
+    ProjectChannel.SaveCompileConfig,
+    (_, projectPath, config) => ctx.workspace.saveCompileConfig(projectPath, config)
+  );
+  ipcMain6.handle(ProjectChannel.Close, () => ctx.workspace.closeProject());
+}
+
+// src/main/ipc/settings.ts
+import { app as app7, ipcMain as ipcMain7 } from "electron";
+function registerSettingsIpc(ctx) {
+  ipcMain7.handle(WorkbenchSettingsChannel.Get, () => {
+    return loadWorkbenchSettings();
+  });
+  ipcMain7.handle(WorkbenchSettingsChannel.Save, (_, settings) => {
+    saveWorkbenchSettings(settings);
+    applyTheme(settings.theme ?? "system");
+    return { success: true };
+  });
+  ipcMain7.handle(WorkbenchSettingsChannel.SetTheme, (_, theme) => {
+    applyTheme(theme);
+  });
+  ipcMain7.handle(WorkbenchSettingsChannel.GetCdpStatus, () => {
+    const settings = loadWorkbenchSettings();
+    const switchValue = app7.commandLine.getSwitchValue("remote-debugging-port");
+    const implicitDevDefault = !app7.isPackaged && !settings.cdp.enabled && switchValue === "9222";
+    return {
+      configured: settings.cdp.enabled,
+      port: settings.cdp.port,
+      active: !!switchValue,
+      activePort: switchValue ? parseInt(switchValue, 10) : null,
+      implicitDevDefault
+    };
+  });
+  ipcMain7.handle(WorkbenchSettingsChannel.SetVisible, async (_, visible) => {
+    if (visible) {
+      await openSettingsWindow(ctx);
+    } else {
+      ctx.workbenchSettingsWindow?.close();
+    }
+  });
+  ipcMain7.handle(SettingsChannel.SetVisible, async (_, visible) => {
+    if (visible) {
+      await ctx.views.showSettings();
+      ctx.notify.settingsInit({
+        projectPath: ctx.workspace.getProjectPath(),
+        config: ctx.workspace.getCompileConfig(ctx.workspace.getProjectPath()),
+        projectSettings: ctx.workspace.getProjectSettings(ctx.workspace.getProjectPath())
+      });
+    } else {
+      ctx.views.hideSettings();
+      ctx.notify.settingsClosed();
+    }
+  });
+  ipcMain7.on(SettingsChannel.ConfigChanged, (_, config) => {
+    if (ctx.workspace.getProjectPath()) {
+      ctx.workspace.saveCompileConfig(ctx.workspace.getProjectPath(), config);
+    }
+    ctx.notify.settingsChanged(config);
+  });
+  ipcMain7.on(
+    SettingsChannel.ProjectSettingsChanged,
+    (_, patch) => {
+      ctx.workspace.updateProjectSettings(ctx.workspace.getProjectPath(), patch);
+    }
+  );
+}
+
+// src/main/ipc/toolbar.ts
+import { ipcMain as ipcMain8 } from "electron";
+function registerToolbarIpc(ctx) {
+  ipcMain8.handle(ToolbarChannel.GetActions, async () => {
+    if (ctx.toolbarActions) return ctx.toolbarActions();
+    return [];
+  });
+}
+
+// src/main/services/automation/index.ts
+import { ipcMain as ipcMain9 } from "electron";
+import { WebSocketServer } from "ws";
+
+// src/main/services/automation/exec.ts
+import { webContents as webContents3 } from "electron";
+function getSimulator(ctx) {
+  const simWcId = ctx.views.getSimulatorWebContentsId();
+  if (!ctx.workspace.hasActiveSession() || simWcId == null) return null;
+  const sim = webContents3.fromId(simWcId);
+  if (!sim || sim.isDestroyed()) return null;
+  return sim;
+}
+async function evalInSim(ctx, expression) {
+  const sim = getSimulator(ctx);
+  if (!sim) throw new Error("Simulator not connected");
+  return sim.executeJavaScript(expression);
+}
+function buildElAccess(ref, varName = "el") {
+  const escaped = ref.selector.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  return `const ${varName} = _doc.querySelectorAll('${escaped}')[${ref.index}]`;
+}
+function inIframe(code) {
+  return `(() => {
+    const iframes = document.querySelectorAll('iframe')
+    const iframe = iframes[iframes.length - 1]
+    if (!iframe || !iframe.contentDocument) throw new Error('No page iframe')
+    const _doc = iframe.contentDocument
+    return (function() { ${code} })()
+  })()`;
+}
+
+// src/main/services/automation/handlers/tool.ts
+var toolHandlers = {};
+toolHandlers["Tool.getInfo"] = async () => ({ SDKVersion: "2.7.3" });
+toolHandlers["Tool.close"] = async (ctx) => {
+  await ctx.workspace.closeProject();
+  return {};
+};
+
+// src/main/services/automation/handlers/app.ts
+var appHandlers = {};
+appHandlers["App.getCurrentPage"] = async (ctx) => {
+  const hash = await evalInSim(ctx, "location.hash");
+  const clean = hash.replace(/^#/, "");
+  const qIdx = clean.indexOf("?");
+  const pathPart = qIdx >= 0 ? clean.substring(0, qIdx) : clean;
+  const queryPart = qIdx >= 0 ? clean.substring(qIdx + 1) : "";
+  let pagePath;
+  if (pathPart.includes("|")) {
+    const parts = pathPart.split("|");
+    pagePath = parts[parts.length - 1] ?? "";
+  } else {
+    const slashIdx = pathPart.indexOf("/");
+    pagePath = slashIdx >= 0 ? pathPart.substring(slashIdx + 1) : pathPart;
+  }
+  const query = {};
+  if (queryPart) {
+    for (const pair of queryPart.split("&")) {
+      const [k, v] = pair.split("=");
+      if (k) query[k] = decodeURIComponent(v || "");
+    }
+  }
+  const iframeCount = await evalInSim(ctx, `document.querySelectorAll('iframe').length`);
+  return { pageId: iframeCount, path: pagePath, query };
+};
+appHandlers["App.getPageStack"] = async (ctx) => {
+  const hash = await evalInSim(ctx, "location.hash");
+  const clean = hash.replace(/^#/, "").replace(/\?.*$/, "");
+  const pageStack = [];
+  if (clean.includes("|")) {
+    const parts = clean.split("|");
+    for (let i = 1; i < parts.length; i++) {
+      pageStack.push({ pageId: i, path: parts[i] ?? "", query: {} });
+    }
+  } else {
+    const slashIdx = clean.indexOf("/");
+    const currentPath = slashIdx >= 0 ? clean.substring(slashIdx + 1) : clean;
+    if (currentPath) {
+      pageStack.push({ pageId: 1, path: currentPath, query: {} });
+    }
+  }
+  return { pageStack };
+};
+appHandlers["App.callWxMethod"] = async (ctx, params) => {
+  const method = params.method;
+  const args = params.args || [];
+  if (["navigateTo", "redirectTo", "reLaunch", "switchTab"].includes(method)) {
+    const opts = args[0];
+    const url = opts?.url;
+    if (url) {
+      const cleanUrl = url.startsWith("/") ? url : `/${url}`;
+      const clicked = await evalInSim(ctx, inIframe(`
+        const el = _doc.querySelector('[data-path="${cleanUrl}"]')
+        if (el) { el.click(); return true }
+        return false
+      `)).catch(() => false);
+      if (!clicked) {
+        const hash = await evalInSim(ctx, "location.hash");
+        const appId = hash.replace(/^#/, "").split("/")[0];
+        if (method === "reLaunch" || method === "redirectTo") {
+          await evalInSim(ctx, `location.href = location.pathname + '#${appId}${cleanUrl}'`);
+        } else {
+          await evalInSim(ctx, `location.hash = '#${appId}${cleanUrl}'`);
+        }
+      }
+      await new Promise((r) => setTimeout(r, 2e3));
+    }
+    return { result: void 0 };
+  }
+  if (method === "navigateBack") {
+    await evalInSim(ctx, "history.back()");
+    await new Promise((r) => setTimeout(r, 1500));
+    return { result: void 0 };
+  }
+  const argsStr = args.map((a) => JSON.stringify(a)).join(", ");
+  const result = await evalInSim(ctx, `
+    new Promise((resolve, reject) => {
+      try {
+        const r = wx.${method}(${argsStr})
+        resolve(r)
+      } catch(e) {
+        reject(e)
+      }
+    })
+  `);
+  return { result };
+};
+appHandlers["App.callFunction"] = async (ctx, params) => {
+  const fnDecl = params.functionDeclaration;
+  const args = params.args || [];
+  const argsStr = args.map((a) => JSON.stringify(a)).join(", ");
+  const result = await evalInSim(ctx, `
+    Promise.resolve((${fnDecl})(${argsStr}))
+  `);
+  return { result };
+};
+appHandlers["App.captureScreenshot"] = async (ctx) => {
+  const sim = getSimulator(ctx);
+  if (!sim) throw new Error("Simulator not connected");
+  const img = await sim.capturePage();
+  return { data: img.toPNG().toString("base64") };
+};
+appHandlers["App.enableLog"] = async () => ({});
+appHandlers["App.exit"] = async (ctx) => {
+  await ctx.workspace.closeProject();
+  return {};
+};
+appHandlers["App.mockWxMethod"] = async () => {
+  throw new Error("mockWxMethod is not supported (requires AppService layer)");
+};
+appHandlers["App.addBinding"] = async () => {
+  throw new Error("exposeFunction is not supported (requires AppService layer)");
+};
+
+// src/main/services/automation/registry.ts
+var elementRegistry = /* @__PURE__ */ new Map();
+var nextElementId = 1;
+function registerElement(selector, index, pageId) {
+  const id = `el_${nextElementId++}`;
+  elementRegistry.set(id, { selector, index, pageId });
+  return id;
+}
+function getElementRef(params) {
+  const id = params.elementId;
+  const ref = elementRegistry.get(id);
+  if (!ref) throw new Error(`Element not found: ${id} (stale reference)`);
+  return ref;
+}
+
+// src/main/services/automation/handlers/page.ts
+var pageHandlers = {};
+pageHandlers["Page.getElement"] = async (ctx, params) => {
+  const selector = params.selector;
+  const pageId = params.pageId || 1;
+  const escaped = selector.replace(/'/g, "\\'");
+  const info = await evalInSim(ctx, inIframe(`
+    const el = _doc.querySelector('${escaped}')
+    if (!el) return null
+    return { tagName: el.tagName.toLowerCase() }
+  `));
+  if (!info) throw new Error(`Element not found: ${selector}`);
+  const elementId = registerElement(selector, 0, pageId);
+  return { elementId, tagName: info.tagName };
+};
+pageHandlers["Page.getElements"] = async (ctx, params) => {
+  const selector = params.selector;
+  const pageId = params.pageId || 1;
+  const escaped = selector.replace(/'/g, "\\'");
+  const items = await evalInSim(ctx, inIframe(`
+    return Array.from(_doc.querySelectorAll('${escaped}')).map(el => ({
+      tagName: el.tagName.toLowerCase(),
+    }))
+  `));
+  return {
+    elements: items.map((item, i) => ({
+      elementId: registerElement(selector, i, pageId),
+      tagName: item.tagName
+    }))
+  };
+};
+pageHandlers["Page.getData"] = async (ctx, params) => {
+  const pathKey = params.path;
+  const appdata = await evalInSim(
+    ctx,
+    `window.__simulatorData ? window.__simulatorData.getAppdata() : {}`
+  );
+  if (!pathKey) return { data: appdata };
+  const keys = pathKey.replace(/\[(\d+)\]/g, ".$1").split(".");
+  let val = appdata;
+  for (const k of keys) {
+    if (val == null || typeof val !== "object") {
+      val = void 0;
+      break;
+    }
+    val = val[k];
+  }
+  return { data: val };
+};
+pageHandlers["Page.setData"] = async () => {
+  throw new Error("Page.setData is not supported (requires AppService layer)");
+};
+pageHandlers["Page.callMethod"] = async (_ctx, params) => {
+  throw new Error(`Page.callMethod('${params.method}') is not supported (requires AppService layer)`);
+};
+pageHandlers["Page.getWindowProperties"] = async (ctx, params) => {
+  const names = params.names;
+  const properties = await evalInSim(ctx, inIframe(`
+    return ${JSON.stringify(names)}.map(n => {
+      try { return eval(n) } catch { return undefined }
+    })
+  `));
+  return { properties };
+};
+
+// src/main/services/automation/handlers/element.ts
+var elementHandlers = {};
+elementHandlers["Element.tap"] = async (ctx, params) => {
+  const ref = getElementRef(params);
+  await evalInSim(ctx, inIframe(`
+    ${buildElAccess(ref)}
+    if (!el) throw new Error('Element not found')
+    el.click()
+  `));
+  return {};
+};
+elementHandlers["Element.triggerEvent"] = async (ctx, params) => {
+  const ref = getElementRef(params);
+  const type = params.type;
+  const detail = params.detail || {};
+  await evalInSim(ctx, inIframe(`
+    ${buildElAccess(ref)}
+    if (!el) throw new Error('Element not found')
+    el.dispatchEvent(new CustomEvent('${type}', { detail: ${JSON.stringify(detail)}, bubbles: true }))
+  `));
+  return {};
+};
+elementHandlers["Element.touchstart"] = async (ctx, params) => {
+  const ref = getElementRef(params);
+  await evalInSim(ctx, inIframe(`
+    ${buildElAccess(ref)}
+    if (el) el.dispatchEvent(new TouchEvent('touchstart', { bubbles: true }))
+  `));
+  return {};
+};
+elementHandlers["Element.touchmove"] = async (ctx, params) => {
+  const ref = getElementRef(params);
+  await evalInSim(ctx, inIframe(`
+    ${buildElAccess(ref)}
+    if (el) el.dispatchEvent(new TouchEvent('touchmove', { bubbles: true }))
+  `));
+  return {};
+};
+elementHandlers["Element.touchend"] = async (ctx, params) => {
+  const ref = getElementRef(params);
+  await evalInSim(ctx, inIframe(`
+    ${buildElAccess(ref)}
+    if (el) el.dispatchEvent(new TouchEvent('touchend', { bubbles: true }))
+  `));
+  return {};
+};
+elementHandlers["Element.getDOMProperties"] = async (ctx, params) => {
+  const ref = getElementRef(params);
+  const names = params.names;
+  const properties = await evalInSim(ctx, inIframe(`
+    ${buildElAccess(ref)}
+    if (!el) return ${JSON.stringify(names.map(() => null))}
+    return ${JSON.stringify(names)}.map(n => el[n])
+  `));
+  return { properties };
+};
+elementHandlers["Element.getAttributes"] = async (ctx, params) => {
+  const ref = getElementRef(params);
+  const names = params.names;
+  const attributes = await evalInSim(ctx, inIframe(`
+    ${buildElAccess(ref)}
+    if (!el) return ${JSON.stringify(names.map(() => null))}
+    return ${JSON.stringify(names)}.map(n => el.getAttribute(n))
+  `));
+  return { attributes };
+};
+elementHandlers["Element.getStyles"] = async (ctx, params) => {
+  const ref = getElementRef(params);
+  const names = params.names;
+  const styles = await evalInSim(ctx, inIframe(`
+    ${buildElAccess(ref)}
+    if (!el) return ${JSON.stringify(names.map(() => ""))}
+    const cs = getComputedStyle(el)
+    return ${JSON.stringify(names)}.map(n => cs.getPropertyValue(n))
+  `));
+  return { styles };
+};
+elementHandlers["Element.getWXML"] = async (ctx, params) => {
+  const ref = getElementRef(params);
+  const type = params.type || "inner";
+  const prop = type === "outer" ? "outerHTML" : "innerHTML";
+  const wxml = await evalInSim(ctx, inIframe(`
+    ${buildElAccess(ref)}
+    return el ? el.${prop} : ''
+  `));
+  return { wxml };
+};
+elementHandlers["Element.getOffset"] = async (ctx, params) => {
+  const ref = getElementRef(params);
+  return evalInSim(ctx, inIframe(`
+    ${buildElAccess(ref)}
+    if (!el) return { left: 0, top: 0 }
+    const r = el.getBoundingClientRect()
+    return { left: r.left, top: r.top }
+  `));
+};
+elementHandlers["Element.getElement"] = async (ctx, params) => {
+  const parentRef = getElementRef(params);
+  const selector = params.selector;
+  const escaped = selector.replace(/'/g, "\\'");
+  const info = await evalInSim(ctx, inIframe(`
+    ${buildElAccess(parentRef, "parent")}
+    if (!parent) return null
+    const child = parent.querySelector('${escaped}')
+    if (!child) return null
+    return { tagName: child.tagName.toLowerCase() }
+  `));
+  if (!info) throw new Error(`Child element not found: ${selector}`);
+  const combinedSelector = `${parentRef.selector} ${selector}`;
+  const elementId = registerElement(combinedSelector, 0, parentRef.pageId);
+  return { elementId, tagName: info.tagName };
+};
+elementHandlers["Element.getElements"] = async (ctx, params) => {
+  const parentRef = getElementRef(params);
+  const selector = params.selector;
+  const escaped = selector.replace(/'/g, "\\'");
+  const items = await evalInSim(ctx, inIframe(`
+    ${buildElAccess(parentRef, "parent")}
+    if (!parent) return []
+    return Array.from(parent.querySelectorAll('${escaped}')).map(el => ({
+      tagName: el.tagName.toLowerCase(),
+    }))
+  `));
+  const combinedSelector = `${parentRef.selector} ${selector}`;
+  return {
+    elements: items.map((item, i) => ({
+      elementId: registerElement(combinedSelector, i, parentRef.pageId),
+      tagName: item.tagName
+    }))
+  };
+};
+elementHandlers["Element.getProperties"] = async (ctx, params) => {
+  return elementHandlers["Element.getDOMProperties"](ctx, params);
+};
+elementHandlers["Element.setData"] = async () => {
+  throw new Error("Element.setData (component) is not supported");
+};
+elementHandlers["Element.getData"] = async () => {
+  throw new Error("Element.getData (component) is not supported");
+};
+elementHandlers["Element.callMethod"] = async () => {
+  throw new Error("Element.callMethod (component) is not supported");
+};
+elementHandlers["Element.callFunction"] = async () => {
+  throw new Error("Element.callFunction is not supported");
+};
+
+// src/main/services/automation/index.ts
+var handlers = {
+  ...toolHandlers,
+  ...appHandlers,
+  ...pageHandlers,
+  ...elementHandlers
+};
+var currentPort = null;
+var portIpcRegistered = false;
+async function startAutomationServer(ctx, port = 0) {
+  const wss = new WebSocketServer({ port });
+  const clients = /* @__PURE__ */ new Set();
+  await new Promise((resolve, reject) => {
+    wss.once("listening", () => resolve());
+    wss.once("error", (err) => reject(err));
+  });
+  const addr = wss.address();
+  const resolvedPort = typeof addr === "object" && addr ? addr.port : port;
+  currentPort = resolvedPort;
+  if (!portIpcRegistered) {
+    portIpcRegistered = true;
+    ipcMain9.handle(AutomationChannel.GetPort, () => currentPort);
+  }
+  function broadcast(event) {
+    const msg = JSON.stringify(event);
+    for (const ws of clients) {
+      if (ws.readyState === ws.OPEN) ws.send(msg);
+    }
+  }
+  let consoleForwardingSetup = false;
+  function setupConsoleForwarding() {
+    if (consoleForwardingSetup) return;
+    consoleForwardingSetup = true;
+    const check = setInterval(() => {
+      const sim = getSimulator(ctx);
+      if (!sim) return;
+      clearInterval(check);
+      sim.on("ipc-message-host", (_event, channel, data) => {
+        if (channel === SimulatorChannel.Console) {
+          const logData = data;
+          broadcast({
+            method: "App.logAdded",
+            params: { type: logData.level || "log", args: logData.args || [] }
+          });
+        }
+      });
+    }, 1e3);
+    setTimeout(() => clearInterval(check), 3e4);
+  }
+  wss.on("connection", (ws) => {
+    clients.add(ws);
+    setupConsoleForwarding();
+    ws.on("message", async (raw) => {
+      let req;
+      try {
+        req = JSON.parse(String(raw));
+      } catch {
+        return;
+      }
+      const { id, method, params = {} } = req;
+      const handler = handlers[method];
+      let response;
+      if (!handler) {
+        response = { id, error: { message: `Unknown method: ${method}` } };
+      } else {
+        try {
+          const result = await handler(ctx, params);
+          response = { id, result };
+        } catch (err) {
+          response = { id, error: { message: err.message || String(err) } };
+        }
+      }
+      if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(response));
+    });
+    ws.on("close", () => clients.delete(ws));
+  });
+  return {
+    close: () => {
+      if (currentPort === resolvedPort) currentPort = null;
+      wss.close();
+    },
+    port: resolvedPort
+  };
+}
+
+// src/main/services/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { createServer } from "http";
+import { createRequire } from "node:module";
+
+// src/main/services/mcp/target-manager.ts
+import CDP from "chrome-remote-interface";
+var SIMULATOR_URL_PATTERN = "localhost:7788";
+var MAX_BUFFER = 500;
+var RECONNECT_INTERVAL_MS = 3e3;
+var cdpPort = 9222;
+var targets = {
+  simulator: { client: null, connected: false, timer: null, consoleLogs: [], networkRequests: [] },
+  workbench: { client: null, connected: false, timer: null, consoleLogs: [], networkRequests: [] }
+};
+function setCdpPort(port) {
+  cdpPort = port;
+}
+function getTargetState(kind) {
+  return targets[kind];
+}
+async function listCdpTargets() {
+  try {
+    return await CDP.List({ port: cdpPort });
+  } catch {
+    return [];
+  }
+}
+function findTarget(allTargets, kind) {
+  if (kind === "simulator") {
+    return allTargets.find((t) => t.url?.includes(SIMULATOR_URL_PATTERN));
+  }
+  return allTargets.find(
+    (t) => t.type === "page" && t.url?.includes("entries/main/index.html") && !t.url?.includes(SIMULATOR_URL_PATTERN)
+  );
+}
+async function connectTarget(kind) {
+  const state = targets[kind];
+  if (state.client) {
+    try {
+      await state.client.close();
+    } catch {
+    }
+    state.client = null;
+  }
+  const allTargets = await listCdpTargets();
+  const target = findTarget(allTargets, kind);
+  if (!target) {
+    state.connected = false;
+    scheduleReconnect(kind);
+    return;
+  }
+  let client = null;
+  try {
+    client = await CDP({ port: cdpPort, target });
+    await Promise.all([
+      client.Page.enable(),
+      client.Runtime.enable(),
+      client.DOM.enable(),
+      client.Network.enable(),
+      client.Console.enable()
+    ]);
+    const pending = /* @__PURE__ */ new Map();
+    const pushNetworkRequest = (entry) => {
+      state.networkRequests.push(entry);
+      if (state.networkRequests.length > MAX_BUFFER) state.networkRequests = state.networkRequests.slice(-MAX_BUFFER);
+    };
+    client.Runtime.on("consoleAPICalled", (params) => {
+      const entry = {
+        level: params.type,
+        text: params.args.map((a) => String(a.value ?? a.description ?? JSON.stringify(a))).join(" "),
+        timestamp: new Date(params.timestamp).toISOString()
+      };
+      state.consoleLogs.push(entry);
+      if (state.consoleLogs.length > MAX_BUFFER) state.consoleLogs = state.consoleLogs.slice(-MAX_BUFFER);
+    });
+    client.Console.on("messageAdded", (params) => {
+      const msg = params.message;
+      state.consoleLogs.push({ level: msg.level, text: msg.text, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+      if (state.consoleLogs.length > MAX_BUFFER) state.consoleLogs = state.consoleLogs.slice(-MAX_BUFFER);
+    });
+    client.Network.on("requestWillBeSent", (params) => {
+      pending.set(params.requestId, { url: params.request.url, method: params.request.method, timestamp: params.timestamp });
+    });
+    client.Network.on("responseReceived", (params) => {
+      const req = pending.get(params.requestId);
+      if (!req) return;
+      pending.delete(params.requestId);
+      pushNetworkRequest({
+        url: req.url,
+        method: req.method,
+        status: params.response.status,
+        mimeType: params.response.mimeType,
+        responseSize: params.response.encodedDataLength || 0,
+        timing: params.response.timing ? { requestTime: params.response.timing.requestTime, receiveHeadersEnd: params.response.timing.receiveHeadersEnd } : null
+      });
+    });
+    client.Network.on("loadingFailed", (params) => {
+      const req = pending.get(params.requestId);
+      if (!req) return;
+      pending.delete(params.requestId);
+      pushNetworkRequest({
+        url: req.url,
+        method: req.method,
+        status: 0,
+        mimeType: "",
+        responseSize: 0,
+        timing: null
+      });
+    });
+    client.on("disconnect", () => {
+      state.connected = false;
+      state.client = null;
+      scheduleReconnect(kind);
+    });
+    state.client = client;
+    state.connected = true;
+    if (state.timer) {
+      clearTimeout(state.timer);
+      state.timer = null;
+    }
+  } catch {
+    if (client) {
+      try {
+        await client.close();
+      } catch {
+      }
+    }
+    state.client = null;
+    state.connected = false;
+    scheduleReconnect(kind);
+  }
+}
+function scheduleReconnect(kind) {
+  const state = targets[kind];
+  if (state.timer) return;
+  state.timer = setTimeout(async () => {
+    state.timer = null;
+    await connectTarget(kind);
+  }, RECONNECT_INTERVAL_MS);
+}
+function getClient(kind) {
+  const state = targets[kind];
+  if (!state.connected || !state.client) {
+    const label = kind === "simulator" ? "\u6A21\u62DF\u5668" : "\u4E3B\u7A97\u53E3";
+    throw new Error(`\u672A\u8FDE\u63A5\u5230${label}\u3002\u8BF7\u786E\u4FDD dimina-devtools \u6B63\u5728\u4EE5\u5F00\u53D1\u6A21\u5F0F\u8FD0\u884C\u3002`);
+  }
+  return state.client;
+}
+
+// src/main/services/mcp/tool-registry.ts
+import { z } from "zod";
+function registerCommonTargetTools(server, kind) {
+  const descriptions = kind === "simulator" ? {
+    screenshot: "Take a screenshot of the simulator webview",
+    consoleLogs: "Get recent console output from the simulator (supports level/sinceTimestamp filters)",
+    evaluate: "Execute JavaScript in the simulator context",
+    getDom: "Get the DOM tree of the simulator page",
+    networkLog: "Get recent network requests from the simulator (supports minStatus filter)"
+  } : {
+    screenshot: "Take a screenshot of the workbench main window",
+    consoleLogs: "Get recent console output from the workbench main window (supports level/sinceTimestamp filters; warn/warning are treated as aliases)",
+    evaluate: "Execute JavaScript in the workbench main window renderer",
+    getDom: "Get the DOM tree of the workbench main window",
+    networkLog: "Get recent network requests from the workbench main window (supports minStatus filter)"
+  };
+  server.tool(`${kind}_screenshot`, descriptions.screenshot, {}, async () => {
+    const c = getClient(kind);
+    const { data } = await c.Page.captureScreenshot({ format: "png" });
+    return { content: [{ type: "image", data, mimeType: "image/png" }] };
+  });
+  server.tool(`${kind}_console_logs`, descriptions.consoleLogs, {
+    limit: z.number().optional().default(50).describe("Maximum number of log entries"),
+    level: z.enum(["error", "warning", "warn", "info", "log", "debug"]).optional().describe("Only return entries with this level"),
+    sinceTimestamp: z.string().optional().describe("ISO timestamp; only return entries at or after this time")
+  }, async ({ limit, level, sinceTimestamp }) => {
+    getClient(kind);
+    let entries = getTargetState(kind).consoleLogs;
+    if (level) {
+      const levels = level === "warning" || level === "warn" ? ["warning", "warn"] : [level];
+      entries = entries.filter((e) => levels.includes(e.level));
+    }
+    if (sinceTimestamp) {
+      entries = entries.filter((e) => e.timestamp >= sinceTimestamp);
+    }
+    return { content: [{ type: "text", text: JSON.stringify(entries.slice(-limit), null, 2) }] };
+  });
+  if (kind !== "workbench") {
+    server.tool(`${kind}_evaluate`, descriptions.evaluate, {
+      expression: z.string().describe("JavaScript expression to evaluate")
+    }, async ({ expression }) => {
+      const c = getClient(kind);
+      const result = await c.Runtime.evaluate({ expression, returnByValue: true, awaitPromise: true });
+      if (result.exceptionDetails) {
+        return { content: [{ type: "text", text: `Error: ${result.exceptionDetails.text}
+${JSON.stringify(result.exceptionDetails, null, 2)}` }], isError: true };
+      }
+      const value = result.result.value !== void 0 ? result.result.value : result.result.description || result.result.type;
+      return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
+    });
+  }
+  server.tool(`${kind}_get_dom`, descriptions.getDom, {
+    depth: z.number().optional().default(3).describe("Maximum depth")
+  }, async ({ depth }) => {
+    const c = getClient(kind);
+    const { root } = await c.DOM.getDocument({ depth });
+    return { content: [{ type: "text", text: JSON.stringify(root, null, 2) }] };
+  });
+  server.tool(`${kind}_network_log`, descriptions.networkLog, {
+    limit: z.number().optional().default(20).describe("Maximum number of entries"),
+    minStatus: z.number().optional().describe("Only return entries with status >= minStatus (status 0 = failed before response is included when minStatus >= 400)")
+  }, async ({ limit, minStatus }) => {
+    getClient(kind);
+    let entries = getTargetState(kind).networkRequests;
+    if (minStatus !== void 0) {
+      entries = entries.filter((e) => e.status >= minStatus || e.status === 0 && minStatus >= 400);
+    }
+    return { content: [{ type: "text", text: JSON.stringify(entries.slice(-limit), null, 2) }] };
+  });
+}
+
+// src/main/services/mcp/tools/context-tools.ts
+var MAX_KEYS = 50;
+var MAX_HINT_TEXT = 200;
+var SIMULATOR_PROBE_EXPR = `(() => {
+  const out = {
+    url: location.href,
+    title: document.title,
+    viewport: { width: window.innerWidth, height: window.innerHeight },
+    currentRoute: null,
+    pageStackDepth: 0,
+    storageKeys: [],
+    storageCount: 0,
+    appDataKeys: [],
+    bridgeReady: false,
+    simulatorDataPresent: false,
+  };
+  try {
+    const frames = document.querySelectorAll('.dimina-native-webview__window');
+    out.pageStackDepth = frames.length;
+    const active = frames[frames.length - 1];
+    if (active) {
+      out.currentRoute = active.getAttribute('data-route')
+        || active.getAttribute('src')
+        || active.getAttribute('data-path')
+        || null;
+    }
+  } catch (e) {}
+  try {
+    const bridge = window.__simulatorData;
+    if (bridge) {
+      out.simulatorDataPresent = true;
+      if (typeof bridge.getStorageSnapshot === 'function') {
+        const snap = bridge.getStorageSnapshot();
+        out.bridgeReady = !!(snap && snap.ready);
+        const data = (snap && snap.data) || {};
+        out.storageKeys = Object.keys(data).slice(0, ${MAX_KEYS});
+        out.storageCount = Object.keys(data).length;
+      }
+      if (typeof bridge.getAppdata === 'function') {
+        const app = bridge.getAppdata() || {};
+        out.appDataKeys = Object.keys(app).slice(0, ${MAX_KEYS});
+      }
+    }
+  } catch (e) {}
+  return JSON.stringify(out);
+})()`;
+var WORKBENCH_PROBE_EXPR = `(() => JSON.stringify({
+  url: location.href,
+  title: document.title,
+  viewport: { width: window.innerWidth, height: window.innerHeight },
+}))()`;
+function summarizeConsole(kind) {
+  const logs = getTargetState(kind).consoleLogs;
+  let recentErrorCount = 0;
+  let recentWarningCount = 0;
+  let lastError = null;
+  for (const entry of logs) {
+    if (entry.level === "error") {
+      recentErrorCount++;
+      lastError = { level: entry.level, text: entry.text.slice(0, MAX_HINT_TEXT), timestamp: entry.timestamp };
+    } else if (entry.level === "warning" || entry.level === "warn") {
+      recentWarningCount++;
+    }
+  }
+  return { total: logs.length, recentErrorCount, recentWarningCount, lastError };
+}
+function summarizeNetwork(kind) {
+  const reqs = getTargetState(kind).networkRequests;
+  let recentNetworkErrorCount = 0;
+  let lastNetworkError = null;
+  for (const r of reqs) {
+    if (r.status >= 400 || r.status === 0) {
+      recentNetworkErrorCount++;
+      lastNetworkError = { url: r.url, status: r.status, method: r.method };
+    }
+  }
+  return { total: reqs.length, recentNetworkErrorCount, lastNetworkError };
+}
+function buildDisconnectedOverview(kind, hints) {
+  if (kind === "simulator") {
+    return {
+      connected: false,
+      url: "",
+      title: "",
+      viewport: null,
+      currentRoute: null,
+      pageStackDepth: 0,
+      storageKeys: [],
+      storageCount: 0,
+      appDataKeys: [],
+      recentErrorCount: 0,
+      lastError: null,
+      recentWarningCount: 0,
+      recentNetworkErrorCount: 0,
+      lastNetworkError: null,
+      consoleLogTotal: 0,
+      networkRequestTotal: 0,
+      hints
+    };
+  }
+  return {
+    connected: false,
+    url: "",
+    title: "",
+    viewport: null,
+    recentErrorCount: 0,
+    lastError: null,
+    recentNetworkErrorCount: 0,
+    lastNetworkError: null,
+    consoleLogTotal: 0,
+    networkRequestTotal: 0,
+    hints
+  };
+}
+function registerContextTools(server) {
+  server.tool(
+    "simulator_get_overview",
+    "One-shot orientation snapshot of the simulator (page, storage keys, appdata keys, recent errors). Call at session start to avoid many probe queries.",
+    {},
+    async () => {
+      const state = getTargetState("simulator");
+      const hints = [];
+      if (!state.connected || !state.client) {
+        const payload2 = buildDisconnectedOverview("simulator", ["simulator not connected \u2014 ensure dimina-devtools is running in dev mode"]);
+        return { content: [{ type: "text", text: JSON.stringify(payload2, null, 2) }] };
+      }
+      let result;
+      try {
+        const c = getClient("simulator");
+        result = await c.Runtime.evaluate({ expression: SIMULATOR_PROBE_EXPR, returnByValue: true });
+      } catch {
+        const payload2 = buildDisconnectedOverview("simulator", [...hints, "simulator disconnected before overview could finish"]);
+        return { content: [{ type: "text", text: JSON.stringify(payload2, null, 2) }] };
+      }
+      if (result.exceptionDetails) {
+        return {
+          content: [{ type: "text", text: `Error: ${result.exceptionDetails.text}` }],
+          isError: true
+        };
+      }
+      let probe;
+      try {
+        probe = JSON.parse(result.result.value);
+      } catch {
+        return {
+          content: [{ type: "text", text: "Error: probe returned non-JSON payload" }],
+          isError: true
+        };
+      }
+      if (!probe.simulatorDataPresent) hints.push("simulator bridge not ready (window.__simulatorData missing)");
+      else if (!probe.bridgeReady) hints.push("simulator bridge present but storage snapshot not ready");
+      if (probe.pageStackDepth === 0) hints.push("no active miniapp page (empty page stack)");
+      if (probe.storageCount > MAX_KEYS) hints.push(`storageKeys truncated to first ${MAX_KEYS} of ${probe.storageCount}`);
+      const consoleSum = summarizeConsole("simulator");
+      const networkSum = summarizeNetwork("simulator");
+      const payload = {
+        connected: true,
+        url: probe.url,
+        title: probe.title,
+        viewport: probe.viewport,
+        currentRoute: probe.currentRoute,
+        pageStackDepth: probe.pageStackDepth,
+        storageKeys: probe.storageKeys,
+        storageCount: probe.storageCount,
+        appDataKeys: probe.appDataKeys,
+        recentErrorCount: consoleSum.recentErrorCount,
+        lastError: consoleSum.lastError,
+        recentWarningCount: consoleSum.recentWarningCount,
+        recentNetworkErrorCount: networkSum.recentNetworkErrorCount,
+        lastNetworkError: networkSum.lastNetworkError,
+        consoleLogTotal: consoleSum.total,
+        networkRequestTotal: networkSum.total,
+        hints
+      };
+      return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+    }
+  );
+  server.tool(
+    "workbench_get_overview",
+    "One-shot orientation snapshot of the workbench main window (url, title, viewport, recent errors, totals).",
+    {},
+    async () => {
+      const state = getTargetState("workbench");
+      const hints = [];
+      if (!state.connected || !state.client) {
+        const payload2 = buildDisconnectedOverview("workbench", ["workbench not connected \u2014 ensure dimina-devtools is running in dev mode"]);
+        return { content: [{ type: "text", text: JSON.stringify(payload2, null, 2) }] };
+      }
+      let result;
+      try {
+        const c = getClient("workbench");
+        result = await c.Runtime.evaluate({ expression: WORKBENCH_PROBE_EXPR, returnByValue: true });
+      } catch {
+        const payload2 = buildDisconnectedOverview("workbench", [...hints, "workbench disconnected before overview could finish"]);
+        return { content: [{ type: "text", text: JSON.stringify(payload2, null, 2) }] };
+      }
+      if (result.exceptionDetails) {
+        return {
+          content: [{ type: "text", text: `Error: ${result.exceptionDetails.text}` }],
+          isError: true
+        };
+      }
+      let probe;
+      try {
+        probe = JSON.parse(result.result.value);
+      } catch {
+        return {
+          content: [{ type: "text", text: "Error: probe returned non-JSON payload" }],
+          isError: true
+        };
+      }
+      const consoleSum = summarizeConsole("workbench");
+      const networkSum = summarizeNetwork("workbench");
+      const payload = {
+        connected: true,
+        url: probe.url,
+        title: probe.title,
+        viewport: probe.viewport,
+        recentErrorCount: consoleSum.recentErrorCount,
+        lastError: consoleSum.lastError,
+        recentNetworkErrorCount: networkSum.recentNetworkErrorCount,
+        lastNetworkError: networkSum.lastNetworkError,
+        consoleLogTotal: consoleSum.total,
+        networkRequestTotal: networkSum.total,
+        hints
+      };
+      return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+    }
+  );
+}
+
+// src/main/services/mcp/tools/simulator-tools.ts
+import { z as z2 } from "zod";
+function registerSimulatorTools(server) {
+  server.tool("simulator_navigate", "Navigate the simulator to a URL, or reload the current page", {
+    url: z2.string().optional().describe("URL to navigate to"),
+    reload: z2.boolean().optional().describe("If true, reload current page instead of navigating")
+  }, async ({ url, reload }) => {
+    const c = getClient("simulator");
+    if (reload) {
+      await c.Page.reload({ ignoreCache: false });
+      const note = url ? " (url ignored because reload=true)" : "";
+      return { content: [{ type: "text", text: `Reloaded simulator${note}` }] };
+    }
+    if (url) {
+      const result = await c.Page.navigate({ url });
+      return { content: [{ type: "text", text: JSON.stringify({ frameId: result.frameId, loaderId: result.loaderId }, null, 2) }] };
+    }
+    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: z2.enum(["tap_coord", "tap_selector", "type", "scroll", "key"]).describe("Input action to dispatch"),
+    x: z2.number().optional().describe("Viewport x coordinate for `tap_coord` or `scroll`"),
+    y: z2.number().optional().describe("Viewport y coordinate for `tap_coord` or `scroll`"),
+    selector: z2.string().optional().describe("CSS selector for `tap_selector` or `type`"),
+    nth: z2.number().int().optional().describe("Zero-based index when selector matches multiple elements; defaults to 0"),
+    text: z2.string().optional().describe("Text to insert for `type`"),
+    key: z2.string().optional().describe("Best-effort keyboard key name for `key`; common keys such as Enter, Escape, Tab, Arrow* and Space work best"),
+    deltaX: z2.number().optional().describe("Horizontal wheel delta for `scroll`"),
+    deltaY: z2.number().optional().describe("Vertical wheel delta for `scroll`")
+  }, async ({ action, x, y, selector, nth, text, key, deltaX, deltaY }) => {
+    const c = getClient("simulator");
+    const err = (msg) => ({ content: [{ type: "text", text: `Error: ${msg}` }], isError: true });
+    const clickAt = async (cx, cy) => {
+      await c.Input.dispatchMouseEvent({ type: "mousePressed", x: cx, y: cy, button: "left", clickCount: 1 });
+      await c.Input.dispatchMouseEvent({ type: "mouseReleased", x: cx, y: cy, button: "left", clickCount: 1 });
+    };
+    if (action === "tap_coord") {
+      if (typeof x !== "number" || typeof y !== "number") return err("tap_coord requires x and y");
+      await clickAt(x, y);
+      return { content: [{ type: "text", text: `Tapped at (${x}, ${y})` }] };
+    }
+    if (action === "tap_selector") {
+      if (!selector) return err("tap_selector requires selector");
+      const index = nth ?? 0;
+      const expression = `(() => {
+        const payload = ${JSON.stringify({ selector, index })}
+        try {
+          const matches = Array.from(document.querySelectorAll(payload.selector))
+          if (matches.length === 0) {
+            return { ok: false, reason: 'no_match', message: \`selector matched no elements: \${payload.selector}\` }
+          }
+          if (payload.index < 0 || payload.index >= matches.length) {
+            return { ok: false, reason: 'out_of_range', message: \`nth \${payload.index} out of range (matches: \${matches.length})\` }
+          }
+          const element = matches[payload.index]
+          element.scrollIntoView({ block: 'center', inline: 'center' })
+          const rect = element.getBoundingClientRect()
+          if (rect.width === 0 || rect.height === 0) {
+            return { ok: false, reason: 'not_visible', message: \`selector matched an element, but it is not visible or rendered (zero rect): \${payload.selector}[\${payload.index}]\` }
+          }
+          return {
+            ok: true,
+            selector: payload.selector,
+            index: payload.index,
+            x: rect.left + rect.width / 2,
+            y: rect.top + rect.height / 2,
+            rect: { left: rect.left, top: rect.top, width: rect.width, height: rect.height },
+          }
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error)
+          return { ok: false, reason: 'selector_error', message: \`invalid selector: \${payload.selector} (\${message})\` }
+        }
+      })()`;
+      const result = await c.Runtime.evaluate({ expression, returnByValue: true, awaitPromise: true });
+      const value = result.result?.value;
+      if (!value) return err(`selector evaluation returned no result: ${selector}[${index}]`);
+      if (!value.ok) return err(value.message);
+      await clickAt(value.x, value.y);
+      return {
+        content: [{
+          type: "text",
+          text: `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})`
+        }]
+      };
+    }
+    if (action === "type") {
+      if (!selector || typeof text !== "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}`);
+      const index = nth ?? 0;
+      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 });
+      } catch {
+        for (const ch of text) {
+          await c.Input.dispatchKeyEvent({ type: "char", text: ch });
+        }
+      }
+      return { content: [{ type: "text", text: `Typed ${text.length} char(s) into ${selector}[${index}]` }] };
+    }
+    if (action === "scroll") {
+      if (typeof x !== "number" || typeof y !== "number" || typeof deltaX !== "number" || typeof deltaY !== "number") {
+        return err("scroll requires x, y, deltaX, deltaY");
+      }
+      await c.Input.dispatchMouseEvent({ type: "mouseWheel", x, y, deltaX, deltaY });
+      return { content: [{ type: "text", text: `Scrolled at (${x}, ${y}) by (${deltaX}, ${deltaY})` }] };
+    }
+    if (action === "key") {
+      if (!key) return err("key requires key");
+      const isSingleChar = key.length === 1;
+      const down = { type: "keyDown", key, code: key };
+      if (isSingleChar) down.text = key;
+      await c.Input.dispatchKeyEvent(down);
+      await c.Input.dispatchKeyEvent({ type: "keyUp", key, code: key });
+      return { content: [{ type: "text", text: `Dispatched key ${key}` }] };
+    }
+    return err(`unknown action: ${action}`);
+  });
+}
+
+// src/main/services/mcp/tools/workbench-tools.ts
+function registerWorkbenchTools(server) {
+  server.tool("workbench_list_targets", "List all available CDP targets (pages, webviews, etc.)", {}, async () => {
+    const allTargets = await listCdpTargets();
+    const summary = allTargets.map((t) => ({ id: t.id, type: t.type, title: t.title, url: t.url }));
+    return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
+  });
+}
+
+// src/main/services/mcp/server.ts
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../../../../package.json");
+function buildServer() {
+  const server = new McpServer({
+    name: "@dimina-kit/devtools",
+    version: pkg.version
+  });
+  registerCommonTargetTools(server, "simulator");
+  registerSimulatorTools(server);
+  registerCommonTargetTools(server, "workbench");
+  registerWorkbenchTools(server);
+  registerContextTools(server);
+  return server;
+}
+function startMcpServer(resolvedCdpPort, mcpPort) {
+  setCdpPort(resolvedCdpPort);
+  connectTarget("simulator").catch(() => {
+  });
+  connectTarget("workbench").catch(() => {
+  });
+  const server = buildServer();
+  const transports = /* @__PURE__ */ new Map();
+  const httpServer = createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://localhost`);
+    if (req.method === "GET" && url.pathname === "/sse") {
+      const transport = new SSEServerTransport("/message", res);
+      transports.set(transport.sessionId, transport);
+      res.on("close", () => transports.delete(transport.sessionId));
+      await server.connect(transport);
+    } else if (req.method === "POST" && url.pathname === "/message") {
+      const sessionId = url.searchParams.get("sessionId") ?? "";
+      const transport = transports.get(sessionId);
+      if (transport) {
+        await transport.handlePostMessage(req, res);
+      } else {
+        res.writeHead(404).end();
+      }
+    } else {
+      res.writeHead(404).end();
+    }
+  });
+  httpServer.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.warn(`[MCP] Port ${mcpPort} already in use \u2014 MCP server not started`);
+    } else {
+      console.error("[MCP] Server error:", err);
+    }
+  });
+  httpServer.listen(mcpPort, "127.0.0.1", () => {
+    console.log(`[MCP] SSE server listening on http://127.0.0.1:${mcpPort}/sse`);
+  });
+}
+
+// src/main/services/simulator-storage/index.ts
+import { app as app8, ipcMain as ipcMain10, webContents as wcStatic } from "electron";
+var attachedWc = null;
+var hostWc = null;
+function isSimulatorWebview(wc) {
+  if (wc.isDestroyed()) return false;
+  if (wc.getType() !== "webview") return false;
+  return wc.getURL().includes("simulator.html");
+}
+function detach() {
+  if (!attachedWc) return;
+  const wc = attachedWc;
+  attachedWc = null;
+  try {
+    if (!wc.isDestroyed() && wc.debugger.isAttached()) {
+      wc.debugger.detach();
+    }
+  } catch {
+  }
+}
+async function attachToSim(wc) {
+  if (attachedWc === wc) return;
+  if (wc.isDestroyed()) return;
+  detach();
+  try {
+    if (!wc.debugger.isAttached()) {
+      wc.debugger.attach("1.3");
+    }
+    await wc.debugger.sendCommand("DOMStorage.enable");
+    wc.debugger.on("message", onCdpMessage);
+    wc.debugger.on("detach", () => {
+      if (attachedWc === wc) attachedWc = null;
+    });
+    wc.once("destroyed", () => {
+      if (attachedWc === wc) attachedWc = null;
+    });
+    attachedWc = wc;
+  } catch (e) {
+    console.warn("[storage-watcher] attach failed:", e.message);
+  }
+}
+function onCdpMessage(_event, method, params) {
+  if (!hostWc || hostWc.isDestroyed()) return;
+  const p = params;
+  let evt;
+  switch (method) {
+    case "DOMStorage.domStorageItemAdded":
+      evt = { type: "added", key: String(p.key), newValue: String(p.newValue ?? "") };
+      break;
+    case "DOMStorage.domStorageItemUpdated":
+      evt = {
+        type: "updated",
+        key: String(p.key),
+        oldValue: String(p.oldValue ?? ""),
+        newValue: String(p.newValue ?? "")
+      };
+      break;
+    case "DOMStorage.domStorageItemRemoved":
+      evt = { type: "removed", key: String(p.key) };
+      break;
+    case "DOMStorage.domStorageItemsCleared":
+      evt = { type: "cleared" };
+      break;
+    default:
+      return;
+  }
+  hostWc.send(SimulatorStorageChannel.Event, evt);
+}
+async function getSnapshot() {
+  if (!attachedWc || attachedWc.isDestroyed()) return [];
+  try {
+    const origin = await attachedWc.executeJavaScript("location.origin");
+    const result = await attachedWc.debugger.sendCommand("DOMStorage.getDOMStorageItems", {
+      storageId: { securityOrigin: origin, isLocalStorage: true }
+    });
+    return result.entries.map(([key, value]) => ({ key, value }));
+  } catch {
+    return [];
+  }
+}
+function findSimulatorWebContents() {
+  for (const wc of wcStatic.getAllWebContents()) {
+    if (isSimulatorWebview(wc)) return wc;
+  }
+  return null;
+}
+async function inspectElement(sid) {
+  if (!sid) return null;
+  const sim = findSimulatorWebContents();
+  if (!sim) return null;
+  try {
+    const result = await sim.executeJavaScript(
+      `window.__simulatorData && window.__simulatorData.highlightElement ? window.__simulatorData.highlightElement(${JSON.stringify(sid)}) : null`
+    );
+    return result ?? null;
+  } catch (e) {
+    console.warn("[simulator-element] inspect failed:", e.message);
+    return null;
+  }
+}
+async function clearElementInspection() {
+  const sim = findSimulatorWebContents();
+  if (!sim) return;
+  try {
+    await sim.executeJavaScript(
+      "window.__simulatorData && window.__simulatorData.unhighlightElement && window.__simulatorData.unhighlightElement()"
+    );
+  } catch {
+  }
+}
+function setupSimulatorStorage(host) {
+  hostWc = host;
+  for (const wc of wcStatic.getAllWebContents()) {
+    if (isSimulatorWebview(wc)) {
+      void attachToSim(wc);
+      break;
+    }
+  }
+  app8.on("web-contents-created", (_event, wc) => {
+    wc.on("did-finish-load", () => {
+      if (isSimulatorWebview(wc)) {
+        void attachToSim(wc);
+      }
+    });
+    wc.on("did-navigate-in-page", () => {
+    });
+  });
+  ipcMain10.handle(SimulatorStorageChannel.GetSnapshot, getSnapshot);
+  ipcMain10.handle(SimulatorElementChannel.Inspect, (_event, sid) => inspectElement(sid));
+  ipcMain10.handle(SimulatorElementChannel.Clear, clearElementInspection);
+}
+
+// src/main/services/update/update-manager.ts
+import { app as app9, ipcMain as ipcMain11, shell } from "electron";
+var UpdateManager = class {
+  checker;
+  mainWindow;
+  getCurrentVersion;
+  latestUpdate = null;
+  downloadedPath = null;
+  timer = null;
+  initialTimer = null;
+  constructor(opts) {
+    this.checker = opts.checker;
+    this.mainWindow = opts.mainWindow;
+    this.getCurrentVersion = opts.getCurrentVersion ?? (() => app9.getVersion());
+    this.registerIpc();
+    this.startPeriodicCheck(opts.checkInterval ?? 60 * 60 * 1e3, opts.initialDelay ?? 5e3);
+  }
+  registerIpc() {
+    ipcMain11.handle("updates:check", async () => {
+      return this.check();
+    });
+    ipcMain11.handle("updates:download", async () => {
+      return this.download();
+    });
+    ipcMain11.handle("updates:install", async () => {
+      this.install();
+    });
+  }
+  async check() {
+    try {
+      const currentVersion = this.getCurrentVersion();
+      const info = await this.checker.checkForUpdates(currentVersion);
+      if (info) {
+        this.latestUpdate = info;
+        this.downloadedPath = null;
+        return { hasUpdate: true, info };
+      }
+      return { hasUpdate: false };
+    } catch (err) {
+      console.warn("[UpdateManager] check failed:", err);
+      return { hasUpdate: false };
+    }
+  }
+  async download() {
+    if (!this.latestUpdate) {
+      return { success: false, error: "No update available" };
+    }
+    try {
+      const filePath = await this.checker.downloadUpdate(this.latestUpdate, (percent) => {
+        this.mainWindow.webContents.send("updates:downloadProgress", { percent });
+      });
+      this.downloadedPath = filePath;
+      return { success: true, filePath };
+    } catch (err) {
+      console.warn("[UpdateManager] download failed:", err);
+      return { success: false, error: String(err) };
+    }
+  }
+  install() {
+    if (this.downloadedPath) {
+      shell.openPath(this.downloadedPath);
+      app9.quit();
+    }
+  }
+  dispose() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.initialTimer) {
+      clearTimeout(this.initialTimer);
+      this.initialTimer = null;
+    }
+    ipcMain11.removeHandler("updates:check");
+    ipcMain11.removeHandler("updates:download");
+    ipcMain11.removeHandler("updates:install");
+  }
+  startPeriodicCheck(interval, initialDelay) {
+    this.initialTimer = setTimeout(() => void this.checkAndNotify(), initialDelay);
+    this.timer = setInterval(() => void this.checkAndNotify(), interval);
+  }
+  async checkAndNotify() {
+    const result = await this.check();
+    if (result.hasUpdate && result.info) {
+      this.mainWindow.webContents.send("updates:available", result.info);
+    }
+  }
+};
+
+// src/main/services/update/github-release-checker.ts
+import { app as app10 } from "electron";
+
+// src/main/app/app.ts
+var DEFAULT_MODULES = {
+  projects: true,
+  session: true,
+  simulator: true,
+  popover: true,
+  settings: true
+};
+var MODULE_REGISTRARS = {
+  projects: registerProjectsIpc,
+  session: registerSessionIpc,
+  simulator: (ctx) => {
+    registerSimulatorIpc(ctx);
+    registerPanelsIpc(ctx);
+    registerToolbarIpc(ctx);
+  },
+  popover: registerPopoverIpc,
+  settings: registerSettingsIpc
+};
+function parseAutoArgs() {
+  const argv = process.argv;
+  let auto = false;
+  let autoPort = 9420;
+  let projectPath = "";
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "auto" || argv[i] === "--auto") auto = true;
+    if ((argv[i] === "--auto-port" || argv[i] === "--auto_port") && argv[i + 1]) {
+      const parsed = parseInt(argv[i + 1], 10);
+      if (Number.isFinite(parsed) && parsed >= 0) autoPort = parsed;
+    }
+    if (argv[i] === "--project" && argv[i + 1]) {
+      projectPath = argv[i + 1];
+    }
+  }
+  return { auto, autoPort, projectPath };
+}
+function resolveModules(config) {
+  return {
+    ...DEFAULT_MODULES,
+    ...config.modules
+  };
+}
+async function disposeContext(ctx, updateManager) {
+  updateManager?.dispose();
+  await ctx.workspace.closeProject();
+}
+function createConfiguredMainWindow(config, rendererDir2) {
+  const mainWindow = createMainWindow({
+    title: config.appName ?? "Dimina DevTools",
+    indexHtml: path6.join(rendererDir2, "entries/main/index.html"),
+    width: config.window?.width,
+    height: config.window?.height,
+    minWidth: config.window?.minWidth,
+    minHeight: config.window?.minHeight
+  });
+  if (config.icon) {
+    const icon = nativeImage.createFromPath(config.icon);
+    if (!icon.isEmpty()) mainWindow.setIcon(icon);
+  }
+  return mainWindow;
+}
+function createContext(config, mainWindow, rendererDir2) {
+  return createWorkbenchContext({
+    mainWindow,
+    adapter: config.adapter,
+    preloadPath: config.preloadPath ?? defaultPreloadPath,
+    rendererDir: rendererDir2,
+    panels: config.panels,
+    appName: config.appName,
+    apiNamespaces: config.apiNamespaces,
+    brandingProvider: config.brandingProvider,
+    toolbarActions: config.toolbarActions
+  });
+}
+function registerBuiltinModules(config, context) {
+  const modules = resolveModules(config);
+  Object.keys(modules).forEach((moduleId) => {
+    if (modules[moduleId]) MODULE_REGISTRARS[moduleId](context);
+  });
+}
+function installMenu(config, mainWindow, context) {
+  if (config.menuBuilder) {
+    config.menuBuilder(mainWindow, context);
+  } else {
+    installAppMenu(context);
+  }
+}
+async function setupAutomation(instance) {
+  const autoArgs = parseAutoArgs();
+  if (autoArgs.auto) {
+    const server = await startAutomationServer(instance.context, autoArgs.autoPort);
+    instance.automationServer = server;
+    console.log(`[automation] listening on ws://127.0.0.1:${server.port}`);
+  }
+}
+function setupMcp() {
+  const settings = loadWorkbenchSettings();
+  if (!settings.mcp.enabled) return;
+  const cdpPortSwitch = app11.commandLine.getSwitchValue("remote-debugging-port");
+  const cdpPort2 = cdpPortSwitch ? parseInt(cdpPortSwitch, 10) : settings.cdp.port;
+  startMcpServer(cdpPort2, settings.mcp.port);
+}
+function wireAppWindowEvents(config, instance) {
+  const { mainWindow, context } = instance;
+  wireMainWindowEvents(mainWindow, {
+    context,
+    onResize: () => context.views.repositionAll(),
+    onClose: async (e) => {
+      if (!context.workspace.hasActiveSession()) return;
+      e.preventDefault();
+      if (config.onBeforeClose) {
+        await config.onBeforeClose(instance);
+      }
+      await disposeContext(context);
+      context.notify.windowNavigateBack();
+    }
+  });
+}
+function enableDevRendererAutoReload(rendererDir2) {
+  if (!app11.isPackaged) {
+    let reloadTimer = null;
+    fs5.watch(rendererDir2, { recursive: true }, () => {
+      if (reloadTimer) clearTimeout(reloadTimer);
+      reloadTimer = setTimeout(() => {
+        for (const win of BrowserWindow3.getAllWindows()) {
+          win.webContents.reload();
+        }
+      }, 300);
+    });
+  }
+}
+function createWorkbenchApp(config = {}) {
+  let setupPromise = null;
+  let appEventsRegistered = false;
+  setupCdpPort();
+  async function setup() {
+    if (setupPromise) return setupPromise;
+    setupPromise = app11.whenReady().then(async () => {
+      applyTheme(loadWorkbenchSettings().theme);
+      const rendererDir2 = config.rendererDir ?? rendererDir;
+      const mainWindow = createConfiguredMainWindow(config, rendererDir2);
+      const context = createContext(config, mainWindow, rendererDir2);
+      registerAppIpc(context);
+      registerBuiltinModules(config, context);
+      installMenu(config, mainWindow, context);
+      const instance = {
+        mainWindow,
+        context,
+        dispose: () => disposeContext(context, instance.updateManager)
+      };
+      if (config.onSetup) {
+        await config.onSetup(instance);
+      }
+      if (config.updateChecker) {
+        instance.updateManager = new UpdateManager({
+          checker: config.updateChecker,
+          mainWindow,
+          checkInterval: config.updateOptions?.checkInterval,
+          initialDelay: config.updateOptions?.initialDelay,
+          getCurrentVersion: config.updateOptions?.getCurrentVersion
+        });
+      }
+      await setupAutomation(instance);
+      setupMcp();
+      setupSimulatorStorage(mainWindow.webContents);
+      wireAppWindowEvents(config, instance);
+      enableDevRendererAutoReload(rendererDir2);
+      return instance;
+    });
+    return setupPromise;
+  }
+  function start() {
+    void setup();
+    if (!appEventsRegistered) {
+      appEventsRegistered = true;
+      registerAppLifecycle();
+    }
+  }
+  return {
+    setup,
+    start
+  };
+}
+
+// src/main/windows/settings-window/create.ts
+import { BrowserWindow as BrowserWindow4 } from "electron";
+import path7 from "path";
+async function createSettingsWindow(parent, rendererDir2) {
+  const win = new BrowserWindow4({
+    width: 420,
+    height: 560,
+    minWidth: 380,
+    minHeight: 480,
+    parent: parent ?? void 0,
+    title: "\u5F00\u53D1\u5DE5\u5177\u8BBE\u7F6E",
+    backgroundColor: themeBg(),
+    webPreferences: { nodeIntegration: true, contextIsolation: false }
+  });
+  await win.loadFile(path7.join(rendererDir2, "entries/workbench-settings/index.html"));
+  return win;
+}
+
+// src/main/windows/settings-window/events.ts
+function wireSettingsWindowEvents(win, onClosed) {
+  win.on("closed", () => {
+    onClosed();
+  });
+}
+
+// src/main/app/launch.ts
+function launch(config = {}) {
+  createWorkbenchApp(config).start();
+}
+async function openSettingsWindow(ctx) {
+  if (!ctx.workbenchSettingsWindow || ctx.workbenchSettingsWindow.isDestroyed()) {
+    ctx.workbenchSettingsWindow = await createSettingsWindow(ctx.mainWindow, ctx.rendererDir);
+    wireSettingsWindowEvents(ctx.workbenchSettingsWindow, () => {
+      ctx.workbenchSettingsWindow = null;
+    });
+  }
+  ctx.workbenchSettingsWindow.show();
+  ctx.workbenchSettingsWindow.focus();
+  ctx.notify.workbenchSettingsInit(ctx.workbenchSettingsWindow, {
+    settings: loadWorkbenchSettings()
+  });
+}
+
+// src/main/index.ts
+launch();