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

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

@@ -0,0 +1,310 @@
+import path from 'path';
+import { toDisposable } from '@dimina-kit/electron-deck/main';
+import { createInternalDevtoolsWindow } from '../windows/internal-devtools-window/index.js';
+import { revealMainWindow, wireMainWindowEvents } from '../windows/main-window/index.js';
+import { isAppQuitting } from './lifecycle.js';
+import { installGlobalMirrors } from './global-mirrors.js';
+import { setupEditorView } from './editor-view.js';
+import { createActiveAppIdResolver, setupWindowRuntimeServices } from './window-runtime-services.js';
+import { createWorkbenchWindow } from './project-window.js';
+/**
+ * Close semantics for a workbench window. Unlike the old single-window app —
+ * where closing meant "return this window to the project list" — closing a
+ * workbench window means the window itself goes away, so teardown must finish
+ * BEFORE the window is destroyed.
+ *
+ * Three guards, each covering a failure this app has actually shipped:
+ *
+ * 1. A real application quit (⌘Q / menu Quit / app.quit()) fires `before-quit`
+ *    first. Let it through: converting a quit into a project close swallows the
+ *    quit and the app can never exit with a project open.
+ * 2. A close arriving while teardown is already in flight (the user
+ *    rapid-double-clicked) MUST keep the window. This runs BEFORE any
+ *    session check on purpose: `closeProject()` → `disposeSession()`
+ *    synchronously nulls the active session before it finishes awaiting
+ *    `session.close()`, so a session-presence check would already read false
+ *    by the time the second close arrives, fall through with no
+ *    `preventDefault()`, and let Chromium destroy the window out from under a
+ *    live teardown.
+ * 3. Teardown is UNCONDITIONAL — deliberately not gated on
+ *    `hasActiveSession()`. A failed open (invalid/non-existent project) never
+ *    creates a session, yet the window still owns views, an editor server and
+ *    IPC registrations. Gating on session presence let that case skip teardown
+ *    entirely, which is how closing an invalid project used to take the whole
+ *    app down with it.
+ */
+function wireWorkbenchWindowEvents(win, ctx, teardown) {
+    let closing = false;
+    let torndown = false;
+    return wireMainWindowEvents(win, {
+        context: ctx,
+        onResize: () => ctx.views.repositionAll(),
+        onClose: async (e) => {
+            if (isAppQuitting())
+                return;
+            if (closing) {
+                e.preventDefault();
+                return;
+            }
+            // Safety net for a `close()` that arrives after teardown finished (this
+            // module destroys the window itself, which emits no `close`).
+            if (torndown)
+                return;
+            e.preventDefault();
+            closing = true;
+            try {
+                await teardown();
+            }
+            catch (err) {
+                console.error('[workbench] workbench window teardown failed:', err);
+            }
+            finally {
+                closing = false;
+                torndown = true;
+            }
+            if (!win.isDestroyed())
+                win.destroy();
+        },
+    });
+}
+export function createWorkbenchWindowManager(deps) {
+    const { config, rendererDir, appServices, router } = deps;
+    // Keyed by project path: one window per project, so a second open of the
+    // same project focuses the existing window instead of racing two sessions
+    // (and two compile workers) over the same directory.
+    const windows = new Map();
+    // Serializes every open and close of one project path. The map alone cannot
+    // carry "one window per project": an open has awaits in it, and a close
+    // awaits host code, so overlapping requests (a re-click on the project list,
+    // MCP's project_open) must queue rather than each find "no window" and build
+    // one. Entries are dropped once a path goes idle.
+    const pathQueues = new Map();
+    // Terminal state owned by this manager, deliberately not `isAppQuitting()`:
+    // a runtime can be disposed while the app keeps running, and a manager that
+    // has torn everything down must never build another window either way.
+    let disposed = false;
+    function disposedError() {
+        return new Error('workbench window manager is disposed');
+    }
+    function enqueue(path, task) {
+        const previous = pathQueues.get(path) ?? Promise.resolve();
+        // Same task on either outcome: a failed open or close must not wedge the
+        // queue for its path.
+        const result = previous.then(task, task);
+        const settled = result.then(() => { }, () => { });
+        pathQueues.set(path, settled);
+        void settled.then(() => {
+            if (pathQueues.get(path) === settled)
+                pathQueues.delete(path);
+        });
+        return result;
+    }
+    async function openWindow(project) {
+        // Checked where the queued task starts running, not where it was queued:
+        // an open sitting behind a close on the same path can be dequeued long
+        // after `disposeAll()` began, and must fail instead of resurrecting a
+        // project the app just tore down.
+        if (disposed)
+            throw disposedError();
+        const existing = windows.get(project.path);
+        if (existing && !existing.window.isDestroyed()) {
+            if (existing.window.isMinimized())
+                existing.window.restore();
+            existing.window.focus();
+            router.setActive(existing.context);
+            deps.onActiveContextChanged?.();
+            return existing.window;
+        }
+        const projectWindow = createWorkbenchWindow({ config, rendererDir, appServices, router }, project);
+        const { window, context } = projectWindow;
+        windows.set(project.path, projectWindow);
+        // Reveal gate: the window is created hidden (see `createWorkbenchWindow`)
+        // and must stay hidden until BOTH the renderer has painted its first
+        // frame (`ready-to-show`) and `setupProjectWindow` has resolved —
+        // whichever finishes second triggers the reveal, exactly once. Wired
+        // before any `await` below so a renderer that paints before the hook
+        // settles (the common case) is never missed.
+        let rendererReady = false;
+        let setupDone = false;
+        let revealed = false;
+        // Flipped the moment a close is requested, not when teardown runs: the
+        // close queues behind this open on the same path, so the hook can still
+        // resolve first and would otherwise show a window whose close was
+        // already asked for, only for the queued teardown to destroy it.
+        let closeRequested = false;
+        const revealIfReady = () => {
+            if (revealed || !rendererReady || !setupDone)
+                return;
+            if (window.isDestroyed())
+                return;
+            // Same for a manager already tearing everything down: `disposeAll()`
+            // waits for this open to settle, and the window must not flash on the
+            // way out.
+            if (closeRequested || disposed)
+                return;
+            // Permanent opt-out: the framework must never show this window, no
+            // matter how many times the two gates above are satisfied.
+            if (config.projectWindow?.autoShow === false)
+                return;
+            revealed = true;
+            revealMainWindow(window);
+        };
+        window.once('ready-to-show', () => {
+            rendererReady = true;
+            revealIfReady();
+        });
+        const teardown = async () => {
+            // A close queued behind an open that then failed (or lost to
+            // `disposeAll()`) finds the window already removed and torn down by
+            // that open's own undo path. Nothing is left to close, and the host
+            // hook must not be handed a disposed context and a destroyed window.
+            if (windows.get(project.path) !== projectWindow)
+                return;
+            try {
+                await deps.onBeforeClose?.(projectWindow, project);
+            }
+            catch (err) {
+                // The hook is the host's chance to react, not a veto: everything below
+                // (compile session, bridge router, editor server, IPC and app-level
+                // listeners) has to go, and the map entry with it, or the window's
+                // resources outlive a window nothing can reach any more.
+                console.error('[workbench] host onBeforeClose hook failed:', err);
+            }
+            try {
+                await projectWindow.dispose();
+            }
+            finally {
+                // Dropped LAST: while teardown is in flight this project still has a
+                // window, and an open arriving mid-close must queue behind it (see
+                // `enqueue`) instead of finding an empty map and building a second one.
+                if (windows.get(project.path) === projectWindow)
+                    windows.delete(project.path);
+            }
+            // After the map entry is gone, so listeners read the window that is left.
+            deps.onActiveContextChanged?.();
+        };
+        try {
+            // The standalone internal DevTools window debugs THIS window's renderer,
+            // so it is per-window wiring. `isAppQuitting` lets the controller stop
+            // intercepting 'close' during a real quit.
+            context.internalDevtoolsWindow = createInternalDevtoolsWindow(window, { isAppQuitting });
+            context.registry.add(toDisposable(() => context.internalDevtoolsWindow?.dispose()));
+            // Wired before the awaited steps below: the window is already closable
+            // even though it's still hidden behind the reveal gate above, so it
+            // must never exist without the close handling that disposes it.
+            context.registry.add(wireWorkbenchWindowEvents(window, context, () => {
+                closeRequested = true;
+                return enqueue(project.path, teardown);
+            }));
+            // Whichever workbench window the user is looking at answers the IPC that
+            // no single window owns (menus, app-level host windows).
+            const onFocus = () => {
+                router.setActive(context);
+                deps.onActiveContextChanged?.();
+            };
+            window.on('focus', onFocus);
+            context.registry.add(toDisposable(() => {
+                if (!window.isDestroyed())
+                    window.removeListener('focus', onFocus);
+            }));
+            // Order matters: the bridge router assigns ctx.bridge / ctx.consoleForwarder
+            // / ctx.diagnostics, which both the mirrors and the runtime services read.
+            deps.setupWindowModules(context);
+            installGlobalMirrors(context, window);
+            const getActiveAppId = createActiveAppIdResolver(context);
+            setupWindowRuntimeServices(context, window, getActiveAppId, project.path);
+            await setupEditorView(config, context, getActiveAppId);
+            // `disposeAll()` can land while this open is parked above. It waits for
+            // this task to settle rather than reaching into a half-built window, so
+            // the undo below is this open's own job.
+            if (disposed)
+                throw disposedError();
+            // Last, so the host configures a window whose own services are all up.
+            // It runs while the window is already in `windows`: a hook that opens
+            // views or drives the session needs the window reachable, and a failure
+            // path below removes the entry again.
+            await deps.setupProjectWindow?.(projectWindow, project);
+            // Re-checked after the hook for the same reason as before it: the hook
+            // is host code of unbounded duration, and an open that lost the race
+            // must reject rather than hand back a window `disposeAll()` is about
+            // to destroy.
+            if (disposed)
+                throw disposedError();
+            // Does not block `open()` returning: if `ready-to-show` already fired,
+            // this reveals now; otherwise it just marks the gate and the pending
+            // `ready-to-show` listener above reveals once Chromium paints.
+            setupDone = true;
+            revealIfReady();
+        }
+        catch (err) {
+            // A half-built window (the editor's http server can fail to bind) leaves
+            // live services behind and keeps the project counted as open — which is
+            // what the list window reads to decide whether to stay hidden. Undo the
+            // whole thing before handing the failure back.
+            windows.delete(project.path);
+            await projectWindow.dispose().catch((disposeErr) => {
+                console.warn('[workbench] failed to dispose a partially opened window:', disposeErr);
+            });
+            if (!window.isDestroyed())
+                window.destroy();
+            throw err;
+        }
+        deps.onActiveContextChanged?.();
+        return window;
+    }
+    return {
+        // One project window per RESOLVED absolute path: two differently-spelled
+        // strings pointing at the same directory ('/a/b' vs '/a/b/.') must not
+        // race two windows (and two compile workers) over one project. Resolving
+        // here, before the path reaches `windows`/`pathQueues`/`openWindow`,
+        // keeps every downstream lookup keyed on the one canonical spelling.
+        open: (project, options) => {
+            const normalized = { ...project, path: path.resolve(project.path) };
+            // The readiness gate is awaited inside the queued task, not before
+            // queuing: opens of one path must keep their arrival order, and a
+            // `disposeAll()` landing meanwhile still finds this open in the queue it
+            // drains rather than floating loose outside it.
+            const awaitReady = options?.awaitReady ?? true;
+            return enqueue(normalized.path, async () => {
+                if (awaitReady)
+                    await deps.ready;
+                return openWindow(normalized);
+            });
+        },
+        list: () => [...windows.values()],
+        activeContext: () => {
+            const active = router.active();
+            const all = [...windows.values()];
+            if (all.some((pw) => pw.context === active))
+                return active;
+            return all.length > 0 ? all[all.length - 1].context : null;
+        },
+        disposeAll: async () => {
+            // Set before waiting, never after: the in-flight opens and closes being
+            // waited on are exactly the code that has to observe the terminal state
+            // in order to finish instead of building on.
+            disposed = true;
+            // Drained repeatedly because settling one entry releases whatever was
+            // queued behind it on the same path; new opens reject at their task
+            // start, so the queues run dry.
+            while (pathQueues.size > 0) {
+                await Promise.allSettled([...pathQueues.values()]);
+            }
+            // Snapshotted only now: an open that lost the race above already removed
+            // and disposed itself, and a finished close already dropped its entry,
+            // so nothing here is disposed twice.
+            const all = [...windows.values()];
+            windows.clear();
+            // Serial: each teardown closes a devkit session and an http server, and
+            // a parallel storm during quit is exactly when those races bite.
+            for (const projectWindow of all) {
+                await projectWindow.dispose().catch((err) => {
+                    console.warn('[workbench] failed to tear down workbench window:', err);
+                });
+                if (!projectWindow.window.isDestroyed())
+                    projectWindow.window.destroy();
+            }
+        },
+    };
+}
+//# sourceMappingURL=workbench-window.js.map