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

package/dist/main/app/editor-view.d.ts

@@ -0,0 +1,21 @@
+import type { CustomFileTypes, WorkbenchAppConfig } from '../../shared/types.js';
+import type { ViewManager } from '../services/views/view-manager.js';
+import type { WorkspaceService } from '../services/workspace/workspace-service.js';
+import type { DisposableRegistry } from '@dimina-kit/electron-deck/main';
+/** Narrow view of the context fields the embedded editor depends on. */
+export interface EditorViewContext {
+    workspace: WorkspaceService;
+    fileTypes: CustomFileTypes;
+    views: ViewManager;
+    registry: DisposableRegistry;
+}
+/**
+ * Embedded workbench editor — the sole devtools editor. Stands up the COI http
+ * server that serves the workbench bundle with the SharedArrayBuffer isolation
+ * headers and bridges `/__fs/*` onto the active project, then hands its base URL
+ * to the view manager so the 'editor' dock slot mounts the workbench
+ * WebContentsView. Both the server and the WCV tear down with the context
+ * registry.
+ */
+export declare function setupEditorView(config: WorkbenchAppConfig, context: EditorViewContext, getActiveAppId: () => string | null): Promise<void>;
+//# sourceMappingURL=editor-view.d.ts.map

package/dist/main/app/editor-view.js

@@ -0,0 +1,71 @@
+import fs from 'fs';
+import path from 'path';
+import { devtoolsPackageRoot } from '../utils/paths.js';
+import { startWorkbenchCoiServer } from '../services/workbench-coi-server.js';
+/**
+ * Embedded workbench editor — the sole devtools editor. Stands up the COI http
+ * server that serves the workbench bundle with the SharedArrayBuffer isolation
+ * headers and bridges `/__fs/*` onto the active project, then hands its base URL
+ * to the view manager so the 'editor' dock slot mounts the workbench
+ * WebContentsView. Both the server and the WCV tear down with the context
+ * registry.
+ */
+export async function setupEditorView(config, context, getActiveAppId) {
+    // Default the bundle dir to the devtools package's OWN `dist/vscode-workbench`
+    // (resolved from the package root), NOT relative to the caller's rendererDir:
+    // a host that overrides `rendererDir` but omits `editorViewConfig.bundleDir`
+    // would otherwise compute a path next to ITS renderer, where no workbench
+    // bundle exists → 404 / blank editor.
+    const bundleDir = config.editorViewConfig?.bundleDir ?? path.join(devtoolsPackageRoot, 'dist/vscode-workbench');
+    // Skip the entire editor assembly when the bundle is missing. Starting the COI
+    // server and attaching the WCV against a non-existent bundle yields a silent
+    // blank editor (the WCV loads index.html → 404); a launchable app with no
+    // editor is strictly better. The view manager never gets a source, so the
+    // 'editor' slot's lazy attach is a no-op.
+    if (!fs.existsSync(path.join(bundleDir, 'index.html'))) {
+        console.warn(`[workbench] editor bundle not found at ${bundleDir} — skipping embedded editor assembly`);
+        return;
+    }
+    const coiServer = await startWorkbenchCoiServer({
+        rootDir: bundleDir,
+        getProjectRoot: () => context.workspace.getProjectPath(),
+        extensionsDir: config.editorViewConfig?.extensionsDir,
+        getFileTypes: () => context.fileTypes,
+        // Names the editor's VS Code workspace after the active miniapp, so each
+        // project gets its own open-editors/view-state bucket instead of all of
+        // them sharing the one derived from the constant mirror root.
+        getProjectIdentity: () => ({
+            appId: getActiveAppId(),
+            projectPath: context.workspace.getProjectPath(),
+        }),
+    });
+    try {
+        // Return the close promise so the registry awaits server shutdown on dispose
+        // instead of fire-and-forgetting it (a dangling http server would keep the
+        // port + event loop alive past teardown).
+        context.registry.add(() => coiServer.close());
+        // The registry disposes LIFO, so this runs BEFORE the context-level
+        // disposeAll: void any in-flight open's attach hold here too, or a stale
+        // release / cap firing could rebuild the workbench during the awaited
+        // coiServer.close() above, before disposeAll's own cancel runs.
+        context.registry.add(() => {
+            context.views.cancelWorkbenchAttachHold();
+            context.views.detachWorkbench();
+        });
+    }
+    catch (err) {
+        // The window was torn down while the bridge was still binding, so the
+        // registry that would have closed it is already disposed and refuses new
+        // entries. Close it here instead: an orphaned route keeps the shared COI
+        // listener (and its port) alive for the rest of the process.
+        await coiServer.close().catch(() => { });
+        throw err;
+    }
+    // Only HAND the view manager the COI URL — do NOT load yet. The heavy
+    // WebContentsView load (10MB bundle + ext-host) is deferred to the first time
+    // the 'editor' dock slot becomes visible (first non-zero bounds), so it never
+    // sits on the app boot critical path. Loading it eagerly here delayed
+    // preload/window-ready enough to trip the e2e launch health check.
+    context.views.setWorkbenchSource(coiServer.baseUrl);
+}
+//# sourceMappingURL=editor-view.js.map

package/dist/main/app/global-mirrors.d.ts

@@ -0,0 +1,23 @@
+import type { BrowserWindow } from 'electron';
+import type { ConsoleForwarder } from '../services/console-forward/index.js';
+import type { DiagnosticsBus } from '../services/diagnostics/index.js';
+import type { CdpSessionBroker } from '../services/cdp-session/index.js';
+import type { InternalDevtoolsWindow } from '../windows/internal-devtools-window/index.js';
+import { type DisposableRegistry } from '@dimina-kit/electron-deck/main';
+/** Narrow view of the context fields the two global mirrors depend on. */
+export interface GlobalMirrorContext {
+    consoleForwarder?: ConsoleForwarder;
+    diagnostics?: DiagnosticsBus;
+    internalDevtoolsWindow?: InternalDevtoolsWindow;
+    cdpSessionBroker: CdpSessionBroker;
+    registry: DisposableRegistry;
+}
+/**
+ * Console + diagnostics mirrors into the standalone internal DevTools window.
+ *
+ * Both mirrors target the INSPECTED side — `mainWindow.webContents`, per
+ * internal-devtools-window.ts's setDevToolsWebContents relationship — and NOT
+ * the front-end host page the `onHostChanged` callback hands them.
+ */
+export declare function installGlobalMirrors(context: GlobalMirrorContext, mainWindow: BrowserWindow): void;
+//# sourceMappingURL=global-mirrors.d.ts.map

package/dist/main/app/global-mirrors.js

@@ -0,0 +1,37 @@
+import { createGlobalConsoleMirror } from '../services/console-forward/global-console-mirror.js';
+import { createGlobalDiagnosticsMirror } from '../services/console-forward/global-diagnostics-mirror.js';
+import { toDisposable } from '@dimina-kit/electron-deck/main';
+/**
+ * Console + diagnostics mirrors into the standalone internal DevTools window.
+ *
+ * Both mirrors target the INSPECTED side — `mainWindow.webContents`, per
+ * internal-devtools-window.ts's setDevToolsWebContents relationship — and NOT
+ * the front-end host page the `onHostChanged` callback hands them.
+ */
+export function installGlobalMirrors(context, mainWindow) {
+    // While the standalone internal DevTools window is open, mirror every guest
+    // console entry (service + render, UNFILTERED — see global-console-mirror.ts)
+    // into it — each open replays the forwarder's current history buffer first
+    // (see that module's doc comment for why the subscribe lifecycle is gated on
+    // onHostChanged rather than subscribed once at construction time).
+    // `context.consoleForwarder` is assembled by the simulator module's
+    // installBridgeRouter; absent only when that builtin module was disabled via
+    // config.
+    if (context.consoleForwarder && context.internalDevtoolsWindow) {
+        const consoleMirror = createGlobalConsoleMirror(context.consoleForwarder, mainWindow.webContents, context.internalDevtoolsWindow.onHostChanged, 
+        // CDP transport (never executeJavaScript) — see the mirror's inject()
+        // doc for the setDevToolsWebContents + external-CDP double-attach hang.
+        { broker: context.cdpSessionBroker });
+        context.registry.add(toDisposable(() => consoleMirror.dispose()));
+    }
+    // Same wiring for diagnostics: every diagnostic — including
+    // `audience:'internal'` ones console-forward's own service-host injection
+    // now skips (see compile-standby.ts / index.ts's handleDiagnostic gate) —
+    // surfaces here instead of vanishing. `context.diagnostics` is assembled
+    // alongside `context.consoleForwarder` by the same installBridgeRouter call.
+    if (context.diagnostics && context.internalDevtoolsWindow) {
+        const diagnosticsMirror = createGlobalDiagnosticsMirror(context.diagnostics, mainWindow.webContents, context.internalDevtoolsWindow.onHostChanged, { broker: context.cdpSessionBroker });
+        context.registry.add(toDisposable(() => diagnosticsMirror.dispose()));
+    }
+}
+//# sourceMappingURL=global-mirrors.js.map

package/dist/main/app/host-sidebar-default.d.ts

@@ -0,0 +1,19 @@
+import type { ViewManager } from '../services/views/view-manager.js';
+import type { RendererNotifier } from '../services/notifications/renderer-notifier.js';
+import type { DisposableRegistry } from '@dimina-kit/electron-deck/main';
+/** Narrow view of the context fields the default sidebar content depends on. */
+export interface HostSidebarContext {
+    views: ViewManager;
+    notify: RendererNotifier;
+    registry: DisposableRegistry;
+}
+/**
+ * devtools' own default content for the host-sidebar slot: a narrow icon rail
+ * (logo + 小程序/小游戏 toggle) filtering the project-list grid by
+ * `Project.type`. Loaded BEFORE `config.onSetup` runs, so any downstream
+ * `loadURL`/`loadFile` call inside onSetup necessarily happens later and
+ * naturally supersedes this default via plain chronological ordering — no
+ * override flag needed.
+ */
+export declare function installHostSidebarDefault(context: HostSidebarContext, rendererDir: string): void;
+//# sourceMappingURL=host-sidebar-default.d.ts.map

package/dist/main/app/host-sidebar-default.js

@@ -0,0 +1,44 @@
+import path from 'path';
+import { HOST_SIDEBAR_DEFAULT_WIDTH } from '../../shared/constants.js';
+/**
+ * devtools' own default content for the host-sidebar slot: a narrow icon rail
+ * (logo + 小程序/小游戏 toggle) filtering the project-list grid by
+ * `Project.type`. Loaded BEFORE `config.onSetup` runs, so any downstream
+ * `loadURL`/`loadFile` call inside onSetup necessarily happens later and
+ * naturally supersedes this default via plain chronological ordering — no
+ * override flag needed.
+ */
+export function installHostSidebarDefault(context, rendererDir) {
+    context.registry.add(context.views.hostSidebar.onMessage('project-category-selected', (payload) => {
+        const category = payload?.category;
+        if (category !== 'miniprogram' && category !== 'minigame')
+            return;
+        context.notify.hostSidebarCategorySelected(category);
+    }));
+    context.views.hostSidebar
+        .loadFile(path.join(rendererDir, 'entries/host-sidebar-default/index.html'))
+        .catch((err) => {
+        console.warn('[workbench] failed to load host-sidebar default content:', err);
+    });
+    // Seed the notified width with the rail's own known intrinsic width
+    // (`HOST_SIDEBAR_DEFAULT_WIDTH`) instead of leaving it at 0 until the
+    // rail's in-page advertiser reports back. That report can never arrive on
+    // its own: the placeholder above only becomes "desired visible" once a
+    // nonzero width is known (project-list-screen.tsx), attach only happens
+    // for a "desired visible" view (placement-reconciler.ts), and the rail's
+    // advertiser (view-anchor's measure-loop.ts) only ever fires via
+    // `requestAnimationFrame`, which Chromium never schedules for a
+    // WebContentsView that was never attached — a structural deadlock, not a
+    // slow-to-resolve race. `setWidthMode({fixed})` pushes the seed
+    // synchronously (no attach/rAF dependency) and, critically, retains it in
+    // `getHostSidebarWidth()` too, so a renderer that mounts and pulls before
+    // any push replays the real seed instead of a stale 0. Flipping back to
+    // 'auto' immediately after, before anything has attached or advertised, is
+    // a same-tick no-op past the seed (`setExtentMode`'s reapply branch only
+    // fires once something has actually been advertised) — it leaves the slot
+    // in 'auto' for whichever content ends up loaded (this rail's own later
+    // report, or a downstream replacement's), not pinned.
+    context.views.hostSidebar.setWidthMode({ fixed: HOST_SIDEBAR_DEFAULT_WIDTH });
+    context.views.hostSidebar.setWidthMode('auto');
+}
+//# sourceMappingURL=host-sidebar-default.js.map

package/dist/main/app/menu-setup.d.ts

@@ -0,0 +1,13 @@
+import type { BrowserWindow } from 'electron';
+import type { WorkbenchAppConfig } from '../../shared/types.js';
+import type { WorkspaceService } from '../services/workspace/workspace-service.js';
+import type { RendererNotifier } from '../services/notifications/renderer-notifier.js';
+/** Narrow view of the context fields the menu surface closes over. */
+export interface MenuHostContext {
+    appName: string;
+    workspace: WorkspaceService;
+    openSettings: () => Promise<void>;
+    notify: RendererNotifier;
+}
+export declare function installMenu(config: WorkbenchAppConfig, mainWindow: BrowserWindow, activeContext: () => MenuHostContext, revealProjectList: () => void): void;
+//# sourceMappingURL=menu-setup.d.ts.map

package/dist/main/app/menu-setup.js

@@ -0,0 +1,49 @@
+import { installAppMenu } from '../menu/index.js';
+/**
+ * Build the hand-written narrow `MenuContext` a host menu builder receives —
+ * explicit construction (not clone+delete), so the runtime object carries
+ * EXACTLY the contract members and nothing else. Every member is a lazy
+ * closure over the live context: a host monkey-patch of
+ * `context.workspace.openProject` (the documented permission-gate pattern)
+ * still intercepts calls made through this menu surface.
+ *
+ * The context is resolved per call, never captured: the menu is installed once
+ * before any project exists, and a project lives in its own window, so a menu
+ * item run later must reach the window the user is actually in.
+ */
+function toMenuContext(activeContext, revealProjectList) {
+    return {
+        get appName() { return activeContext().appName; },
+        workspace: {
+            hasActiveSession: () => activeContext().workspace.hasActiveSession(),
+            getProjectPath: () => activeContext().workspace.getProjectPath(),
+            openProject: (projectPath) => activeContext().workspace.openProject(projectPath),
+            closeProject: () => activeContext().workspace.closeProject(),
+            getSession: () => activeContext().workspace.getSession(),
+        },
+        openSettings: () => activeContext().openSettings(),
+        notify: {
+            projectStatus: (payload) => activeContext().notify.projectStatus(payload),
+            // A project opens in its own window, so "back to the project list" is
+            // no longer a screen change inside one window — it brings the list
+            // window forward. That window owns its own context, which may not be
+            // `activeContext()` (a project window can be the active one), so this
+            // routes through the injected surface instead of notifying whatever is
+            // currently active.
+            windowNavigateBack: () => revealProjectList(),
+        },
+    };
+}
+export function installMenu(config, mainWindow, activeContext, revealProjectList) {
+    // Menu: use host-provided builder or fall back to default. Both consume the
+    // same narrow MenuContext, so the built-in menu proves the hand-written
+    // contract covers the real internal consumption.
+    const menuContext = toMenuContext(activeContext, revealProjectList);
+    if (config.menuBuilder) {
+        config.menuBuilder(mainWindow, menuContext);
+    }
+    else {
+        installAppMenu(menuContext);
+    }
+}
+//# sourceMappingURL=menu-setup.js.map

package/dist/main/app/open-project-ipc.d.ts

@@ -0,0 +1,13 @@
+import type { IpcContextSource } from '../utils/ipc-context-source.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
+import type { ProjectRef } from './project-window.js';
+/**
+ * Opening a project from the list — and from MCP's project_open, which the
+ * list renderer forwards here — always means "give it its own window", so the
+ * channel does nothing but hand the request to the workbench window manager.
+ *
+ * Generic over the context type: the handler never touches the context, and
+ * naming it would drag `WorkbenchContext` into this module.
+ */
+export declare function registerOpenProjectWindowIpc<TCtx>(router: IpcContextSource<TCtx>, open: (project: ProjectRef) => Promise<unknown>): IpcRegistry<TCtx>;
+//# sourceMappingURL=open-project-ipc.d.ts.map

package/dist/main/app/open-project-ipc.js

@@ -0,0 +1,21 @@
+import { WindowChannel } from '../../shared/ipc-channels.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
+/**
+ * Opening a project from the list — and from MCP's project_open, which the
+ * list renderer forwards here — always means "give it its own window", so the
+ * channel does nothing but hand the request to the workbench window manager.
+ *
+ * Generic over the context type: the handler never touches the context, and
+ * naming it would drag `WorkbenchContext` into this module.
+ */
+export function registerOpenProjectWindowIpc(router, open) {
+    const windowIpc = new IpcRegistry(router);
+    windowIpc.handleRouted(WindowChannel.OpenProjectWindow, async (_ctx, _event, ...args) => {
+        const project = args[0];
+        if (!project?.path)
+            throw new Error('openProjectWindow requires a project path');
+        await open({ path: project.path, name: project.name });
+    });
+    return windowIpc;
+}
+//# sourceMappingURL=open-project-ipc.js.map

package/dist/main/app/project-list-surface.d.ts

@@ -0,0 +1,31 @@
+import type { BrowserWindow } from 'electron';
+import type { UpdateInfo } from '../../shared/types.js';
+/**
+ * Narrow view of the context fields the project-list surface closes over —
+ * structural, not `WorkbenchContext` (see eslint-workbench-context-gate) —
+ * so the surface carries no dependency on the whole workbench.
+ */
+export interface ProjectListSurfaceContext {
+    notify: {
+        windowNavigateBack: () => void;
+    };
+    views: {
+        showUpdateDialog: (info: UpdateInfo) => void;
+    };
+}
+export interface ProjectListSurfaceDeps {
+    window: BrowserWindow;
+    context: ProjectListSurfaceContext;
+}
+export interface ProjectListSurface {
+    revealProjectList: () => void;
+    showUpdate: (info: UpdateInfo) => void;
+}
+/**
+ * "回到项目列表" 和更新弹窗都属于列表窗口本身，而不是当时 activeContext() 恰好
+ * 解析到的窗口——那个窗口可能是某个项目工作台。这里是两条路径共同的入口：
+ * revealProjectList 把列表窗口带到前台并通知它自己的 context 刷新；showUpdate
+ * 先做同一件事，再弹更新对话框，避免窗口还处于 hide() 状态时用户看不到弹窗。
+ */
+export declare function createProjectListSurface(deps: ProjectListSurfaceDeps): ProjectListSurface;
+//# sourceMappingURL=project-list-surface.d.ts.map

package/dist/main/app/project-list-surface.js

@@ -0,0 +1,20 @@
+import { revealWindow } from './window-events.js';
+/**
+ * "回到项目列表" 和更新弹窗都属于列表窗口本身，而不是当时 activeContext() 恰好
+ * 解析到的窗口——那个窗口可能是某个项目工作台。这里是两条路径共同的入口：
+ * revealProjectList 把列表窗口带到前台并通知它自己的 context 刷新；showUpdate
+ * 先做同一件事，再弹更新对话框，避免窗口还处于 hide() 状态时用户看不到弹窗。
+ */
+export function createProjectListSurface(deps) {
+    const { window, context } = deps;
+    const revealProjectList = () => {
+        revealWindow(window);
+        context.notify.windowNavigateBack();
+    };
+    const showUpdate = (info) => {
+        revealProjectList();
+        context.views.showUpdateDialog(info);
+    };
+    return { revealProjectList, showUpdate };
+}
+//# sourceMappingURL=project-list-surface.js.map

package/dist/main/app/project-window.d.ts

@@ -0,0 +1,36 @@
+import { BrowserWindow } from 'electron';
+import type { WorkbenchAppConfig } from '../../shared/types.js';
+import { type WorkbenchContext } from '../services/workbench-context.js';
+import type { AppServices } from '../services/app-services.js';
+import type { WindowContextRouter } from '../services/window-contexts/context-router.js';
+/** The project a workbench window is opened for. */
+export interface ProjectRef {
+    path: string;
+    name?: string;
+}
+/** A window and the context that answers IPC coming from it. */
+export interface ProjectWindow {
+    window: BrowserWindow;
+    context: WorkbenchContext;
+    dispose: () => Promise<void>;
+}
+export interface CreateProjectWindowOptions {
+    config: WorkbenchAppConfig;
+    rendererDir: string;
+    appServices: AppServices;
+    router: WindowContextRouter<WorkbenchContext>;
+}
+export declare function disposeContext(ctx: WorkbenchContext): Promise<void>;
+/**
+ * The project-list window. It is the application's root window: the app-level
+ * IPC surface is registered while it exists, and it stays open for the whole
+ * session so workbench windows can come and go around it.
+ */
+export declare function createLauncherWindow(opts: CreateProjectWindowOptions): ProjectWindow;
+/**
+ * A workbench window: one open mini-program project, with its own simulator,
+ * panels and editor. The project identity travels in the URL query so the
+ * renderer entry can mount straight into the project without asking main.
+ */
+export declare function createWorkbenchWindow(opts: CreateProjectWindowOptions, project: ProjectRef): ProjectWindow;
+//# sourceMappingURL=project-window.d.ts.map

package/dist/main/app/project-window.js

@@ -0,0 +1,93 @@
+import { nativeImage } from 'electron';
+import path from 'path';
+import { defaultPreloadPath } from '../utils/paths.js';
+import { createMainWindow } from '../windows/main-window/index.js';
+// eslint-disable-next-line no-restricted-syntax -- grandfathered(workbench-context): shrink-only
+import { createWorkbenchContext } from '../services/workbench-context.js';
+function createConfiguredMainWindow(config, rendererDir, entry, title, autoShow, query) {
+    const mainWindow = createMainWindow({
+        title,
+        indexHtml: path.join(rendererDir, entry),
+        query,
+        width: config.window?.width,
+        height: config.window?.height,
+        minWidth: config.window?.minWidth,
+        minHeight: config.window?.minHeight,
+        autoShow,
+    });
+    // Set window/taskbar icon if provided (Linux/Windows; macOS uses app bundle icon)
+    if (config.icon) {
+        const icon = nativeImage.createFromPath(config.icon);
+        if (!icon.isEmpty())
+            mainWindow.setIcon(icon);
+    }
+    return mainWindow;
+}
+function createContext(config, mainWindow, rendererDir, appServices) {
+    return createWorkbenchContext({
+        mainWindow,
+        appServices,
+        adapter: config.adapter,
+        preloadPath: config.preloadPath ?? defaultPreloadPath,
+        rendererDir,
+        appName: config.appName,
+        apiNamespaces: config.apiNamespaces,
+        fileTypes: config.fileTypes,
+        brandingProvider: config.brandingProvider,
+        customCreateProjectDialog: config.customCreateProjectDialog,
+        // No cast needed here: the hook receives the project record, so the
+        // main-process `Project` the context hands it satisfies the structural
+        // `EditableProject` the config declares.
+        customEditProjectDialog: config.customEditProjectDialog,
+        onBeforeOpenProject: config.onBeforeOpenProject,
+    });
+}
+export async function disposeContext(ctx) {
+    await ctx.workspace.closeProject();
+    await ctx.registry.dispose().catch((err) => {
+        console.warn('[workbench] dispose registry encountered errors:', err);
+    });
+}
+/**
+ * Build a window together with the context that owns it, and publish that
+ * context to the router so IPC arriving from this window is answered by it.
+ *
+ * The router registration is parked on the context's own registry: a window
+ * that is torn down must stop claiming senders in the same breath, or a
+ * recycled `webContents.id` would resolve to a dead context.
+ */
+function createWindowWithContext(opts, entry, title, autoShow, query) {
+    const { config, rendererDir, appServices, router } = opts;
+    const window = createConfiguredMainWindow(config, rendererDir, entry, title, autoShow, query);
+    const context = createContext(config, window, rendererDir, appServices);
+    // Anchor the window's renderer as the first Connection. Resources scoped to
+    // that webContents (acquired by later wiring) tear down with it; see
+    // packages/electron-deck/docs/foundation.md (teardown paths).
+    context.connections.acquire(window.webContents);
+    context.registry.add(router.register(context));
+    return { window, context, dispose: () => disposeContext(context) };
+}
+/**
+ * The project-list window. It is the application's root window: the app-level
+ * IPC surface is registered while it exists, and it stays open for the whole
+ * session so workbench windows can come and go around it.
+ */
+export function createLauncherWindow(opts) {
+    return createWindowWithContext(opts, 'entries/main/index.html', opts.config.appName ?? 'Dimina DevTools', opts.config.window?.autoShow);
+}
+/**
+ * A workbench window: one open mini-program project, with its own simulator,
+ * panels and editor. The project identity travels in the URL query so the
+ * renderer entry can mount straight into the project without asking main.
+ */
+export function createWorkbenchWindow(opts, project) {
+    return createWindowWithContext(opts, 'entries/workbench/index.html', project.name || opts.config.appName || 'Dimina DevTools', 
+    // Always hidden: `workbench-window.ts`'s reveal gate is the sole place
+    // that ever shows a project window, once BOTH `setupProjectWindow` has
+    // resolved and the renderer's own `ready-to-show` has fired. Passing
+    // anything but `false` here would let `createMainWindow`'s own
+    // `ready-to-show` handler show the window itself and race that gate.
+    // `config.projectWindow?.autoShow` is read by the gate instead, not here.
+    false, { path: project.path, name: project.name ?? '' });
+}
+//# sourceMappingURL=project-window.js.map

package/dist/main/app/servers.d.ts

@@ -0,0 +1,17 @@
+import type { WorkbenchAppInstance } from './app.js';
+import { startAutomationServer } from '../services/automation/index.js';
+import { type McpOpenedProject, type McpProjectTarget } from '../services/mcp/index.js';
+import type { Disposable } from '@dimina-kit/electron-deck/main';
+/**
+ * The automation server outlives every window: it binds its port at boot,
+ * before any project is open, so it cannot capture a context at start and
+ * takes `getContext` instead. What that resolver hands back is only the
+ * starting point — each connection pins the first project window it reaches
+ * and stays there, so window focus cannot redirect a live client.
+ */
+export declare function setupAutomation(instance: WorkbenchAppInstance, getContext: Parameters<typeof startAutomationServer>[0], senders: Parameters<typeof startAutomationServer>[1]): Promise<Disposable | null>;
+export declare function setupMcp(currentProject: () => McpProjectTarget, openProjectWindow: (project: {
+    path: string;
+    name: string;
+}) => Promise<McpOpenedProject>): Disposable | null;
+//# sourceMappingURL=servers.d.ts.map

package/dist/main/app/servers.js

@@ -0,0 +1,60 @@
+import { app } from 'electron';
+import { startAutomationServer } from '../services/automation/index.js';
+import { startMcpServer, } from '../services/mcp/index.js';
+import { loadWorkbenchSettings } from '../services/settings/index.js';
+/** Parse --auto, --auto-port, --project from process.argv. */
+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);
+            // 0 → OS-assigned free port (used by parallel e2e workers)
+            if (Number.isFinite(parsed) && parsed >= 0)
+                autoPort = parsed;
+        }
+        if (argv[i] === '--project' && argv[i + 1]) {
+            projectPath = argv[i + 1];
+        }
+    }
+    return { auto, autoPort, projectPath };
+}
+/**
+ * The automation server outlives every window: it binds its port at boot,
+ * before any project is open, so it cannot capture a context at start and
+ * takes `getContext` instead. What that resolver hands back is only the
+ * starting point — each connection pins the first project window it reaches
+ * and stays there, so window focus cannot redirect a live client.
+ */
+export async function setupAutomation(instance, getContext, senders) {
+    // Start automation server if --auto flag is present
+    const autoArgs = parseAutoArgs();
+    if (!autoArgs.auto)
+        return null;
+    const server = await startAutomationServer(getContext, senders, autoArgs.autoPort);
+    instance.automationServer = server;
+    // Stable, parseable line for e2e harnesses that scrape stdout.
+    console.log(`[automation] listening on ws://127.0.0.1:${server.port}`);
+    return { dispose: () => server.close() };
+}
+export function setupMcp(currentProject, openProjectWindow) {
+    const settings = loadWorkbenchSettings();
+    if (!settings.mcp.enabled)
+        return null;
+    const cdpPortSwitch = app.commandLine.getSwitchValue('remote-debugging-port');
+    const cdpPort = cdpPortSwitch ? parseInt(cdpPortSwitch, 10) : settings.cdp.port;
+    // Resolved per tool call, not once at boot: the project MCP drives lives in
+    // whichever workbench window is active, and that changes as windows open and
+    // close. Each call then holds the target it got.
+    return startMcpServer(cdpPort, settings.mcp.port, {
+        currentProject,
+        // A project opens into its own window; the renderer entry mounted there
+        // compiles it and attaches the simulator.
+        requestOpenInUi: (p) => openProjectWindow(p),
+    });
+}
+//# sourceMappingURL=servers.js.map

package/dist/main/app/ui-extension-targets.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The ledger of host-registered simulator UI extensions.
+ *
+ * A registration is app-level — the host makes it once — but an extension can
+ * only exist inside a PROJECT window: it mounts into that window's device
+ * frame and talks to its simulator renderer. So one registration becomes one
+ * live extension per project window, and the ledger is what keeps those copies
+ * in step with the windows: every project window that opens gets its own copy,
+ * and a copy exists exactly as long as the window that owns it.
+ *
+ * The project list is deliberately not a target. It runs no bridge router and
+ * no simulator, so an extension registered into it could never mount, and
+ * `invoke` — which follows the window the user works in — would be answered by
+ * that dead copy every time the list window has focus.
+ */
+import { type Disposable } from '@dimina-kit/electron-deck/main';
+import type { SimulatorUiExtensionHandle, SimulatorUiExtensionRegistration } from '../../shared/simulator-ui.js';
+/**
+ * The window surface the ledger needs, described structurally so this module
+ * does not import WorkbenchContext (see eslint-workbench-context-gate).
+ */
+export interface UiExtensionWindow {
+    simulatorUiExtensions: {
+        register: (registration: SimulatorUiExtensionRegistration) => SimulatorUiExtensionHandle;
+    };
+    registry: {
+        add: (d: Disposable) => Disposable;
+    };
+}
+export interface UiExtensionTargetsDeps<W extends UiExtensionWindow> {
+    /** Every open project window, in open order. */
+    projectWindows: () => W[];
+    /** The project window the user is working in, or null when none is open. */
+    activeWindow: () => W | null;
+}
+export interface UiExtensionTargets<W extends UiExtensionWindow> {
+    /** Give a freshly opened project window its copy of every registration. */
+    attachTo: (window: W) => void;
+    register: (registration: SimulatorUiExtensionRegistration) => SimulatorUiExtensionHandle;
+}
+export declare function createUiExtensionTargets<W extends UiExtensionWindow>(deps: UiExtensionTargetsDeps<W>): UiExtensionTargets<W>;
+//# sourceMappingURL=ui-extension-targets.d.ts.map