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

package/dist/main/services/views/overlay-panels-view.js

@@ -128,6 +128,23 @@ export function createOverlayPanelsView(ctx, reconciler, deps) {
         pushData: (view, data) => ctx.notify.updateAvailable(view, data),
         readyMode: 'manual',
     });
+    const devicePickerPanel = createOverlayPanel({
+        electron: { createWebContentsView: (opts) => new WebContentsView(opts) },
+        rendererDir: ctx.rendererDir,
+        entry: 'entries/device-picker/index.html',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+            preload: mainPreloadPath,
+        },
+        hardenNavigation: (wc) => applyNavigationHardening(wc, ctx.rendererDir),
+        setDesired: overlayDesiredSetter(VIEW_ID.devicePicker, VIEW_LAYER.dialog),
+        registerView: (getView) => reconciler.registerView(VIEW_ID.devicePicker, { getView }),
+        destroyView: (view) => reconciler.destroyView(VIEW_ID.devicePicker, view),
+        pushData: (view, data) => ctx.notify.devicePickerInit(view, data),
+        readyMode: 'manual',
+    });
     let tooltipRequestId = 0;
     let activeTooltip = null;
     async function showSettings() {
@@ -183,6 +200,12 @@ export function createOverlayPanelsView(ctx, reconciler, deps) {
     function hideUpdateDialog() {
         updateDialogPanel.hide();
     }
+    function showDevicePicker(data) {
+        devicePickerPanel.show(data, fullWindowBounds());
+    }
+    function hideDevicePicker() {
+        devicePickerPanel.hide();
+    }
     function notifyUpdateDownloadProgress(percent) {
         const wc = updateDialogPanel.getWebContents();
         if (!wc)
@@ -195,6 +218,7 @@ export function createOverlayPanelsView(ctx, reconciler, deps) {
         tooltipPanel.markReady(webContentsId);
         projectCreateDialogPanel.markReady(webContentsId);
         updateDialogPanel.markReady(webContentsId);
+        devicePickerPanel.markReady(webContentsId);
     }
     function applyTooltipMeasurement(webContentsId, measurement) {
         const active = activeTooltip;
@@ -222,6 +246,9 @@ export function createOverlayPanelsView(ctx, reconciler, deps) {
         if (updateDialogPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.updateDialog)) {
             updateDialogPanel.reposition(fullWindowBounds());
         }
+        if (devicePickerPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.devicePicker)) {
+            devicePickerPanel.reposition(fullWindowBounds());
+        }
     }
     function applySettingsBoundsIfPresent() {
         // See reapplyPresentOverlays() above for why this swallows a rejection.
@@ -237,6 +264,7 @@ export function createOverlayPanelsView(ctx, reconciler, deps) {
     function destroyDialogs() {
         projectCreateDialogPanel.destroy();
         updateDialogPanel.destroy();
+        devicePickerPanel.destroy();
     }
     return {
         showSettings,
@@ -253,6 +281,8 @@ export function createOverlayPanelsView(ctx, reconciler, deps) {
         showUpdateDialog,
         hideUpdateDialog,
         notifyUpdateDownloadProgress,
+        showDevicePicker,
+        hideDevicePicker,
         reapplyPresentOverlays,
         applySettingsBoundsIfPresent,
         destroySettings,
@@ -263,6 +293,7 @@ export function createOverlayPanelsView(ctx, reconciler, deps) {
         getTooltipWebContentsId: () => tooltipPanel.getWebContentsId(),
         getProjectCreateDialogWebContentsId: () => projectCreateDialogPanel.getWebContentsId(),
         getUpdateDialogWebContentsId: () => updateDialogPanel.getWebContentsId(),
+        getDevicePickerWebContentsId: () => devicePickerPanel.getWebContentsId(),
     };
 }
 //# sourceMappingURL=overlay-panels-view.js.map

package/dist/main/services/views/view-manager.d.ts

@@ -93,7 +93,7 @@ export interface ViewManagerContext {
  * panels) and shares a single injected placement reconciler; this file wires
  * them together and exposes their combined method surface.
  */
-export interface ViewManager extends Pick<OverlayPanelsView, 'showSettings' | 'hideSettings' | 'showPopover' | 'hidePopover' | 'prepareTooltip' | 'showTooltip' | 'hideTooltip' | 'markOverlayReady' | 'applyTooltipMeasurement' | 'showProjectCreateDialog' | 'hideProjectCreateDialog' | 'showUpdateDialog' | 'hideUpdateDialog' | 'notifyUpdateDownloadProgress' | 'getProjectCreateDialogWebContentsId' | 'getUpdateDialogWebContentsId'>, HostSidebarViewManagerMembers, HostDialogViewManagerMembers {
+export interface ViewManager extends Pick<OverlayPanelsView, 'showSettings' | 'hideSettings' | 'showPopover' | 'hidePopover' | 'prepareTooltip' | 'showTooltip' | 'hideTooltip' | 'markOverlayReady' | 'applyTooltipMeasurement' | 'showProjectCreateDialog' | 'hideProjectCreateDialog' | 'showUpdateDialog' | 'hideUpdateDialog' | 'notifyUpdateDownloadProgress' | 'showDevicePicker' | 'hideDevicePicker' | 'getProjectCreateDialogWebContentsId' | 'getUpdateDialogWebContentsId' | 'getDevicePickerWebContentsId'>, HostSidebarViewManagerMembers, HostDialogViewManagerMembers {
     /**
      * NATIVE-HOST ONLY. Create the simulator itself as a top-level
      * WebContentsView (not a renderer `<webview>` guest) loading `simulatorUrl`,

package/dist/main/services/views/view-manager.js

@@ -100,8 +100,11 @@ export function createViewManager(ctx) {
         showUpdateDialog: overlayPanels.showUpdateDialog,
         hideUpdateDialog: overlayPanels.hideUpdateDialog,
         notifyUpdateDownloadProgress: overlayPanels.notifyUpdateDownloadProgress,
+        showDevicePicker: overlayPanels.showDevicePicker,
+        hideDevicePicker: overlayPanels.hideDevicePicker,
         getProjectCreateDialogWebContentsId: overlayPanels.getProjectCreateDialogWebContentsId,
         getUpdateDialogWebContentsId: overlayPanels.getUpdateDialogWebContentsId,
+        getDevicePickerWebContentsId: overlayPanels.getDevicePickerWebContentsId,
         repositionAll: () => {
             overlayPanels.reapplyPresentOverlays();
             hostDialog.reposition();

package/dist/main/services/window-contexts/context-router.d.ts

@@ -0,0 +1,36 @@
+import type { WebContents } from 'electron';
+import { type Disposable } from '@dimina-kit/electron-deck/main';
+import type { IpcContextSource } from '../../utils/ipc-context-source.js';
+import type { SenderPolicy } from '../../utils/ipc-registry.js';
+/**
+ * What the router needs of a window context to place an incoming sender.
+ * Kept to these two predicates so the router stays independent of the rest of
+ * the context; the concrete context type is supplied by the caller.
+ */
+export interface RoutableWindowContext {
+    /** Every sender this window accepts, app-shared trusted windows included. */
+    senderPolicy: SenderPolicy;
+    /** Only the senders this window structurally owns (see sender-policy.ts). */
+    ownsSender: SenderPolicy;
+}
+/** Registry of live window contexts, and the authority on which one owns a sender. */
+export interface WindowContextRouter<T extends RoutableWindowContext = RoutableWindowContext> extends IpcContextSource<T> {
+    /** Register a window context; the returned Disposable unregisters it. */
+    register(ctx: T): Disposable;
+    /**
+     * The context owning `sender`, or null when no registered context claims it.
+     * A pure query: looking a sender up never changes which context is active.
+     */
+    resolve(sender: WebContents): T | null;
+    /**
+     * The context last marked active by `setActive`. With none marked — or after
+     * the marked one unregisters — it falls back to the first still-registered
+     * context, and null when none are.
+     */
+    active(): T | null;
+    /** Mark `ctx` active (on window focus). Ignored for unregistered contexts. */
+    setActive(ctx: T): void;
+    list(): T[];
+}
+export declare function createWindowContextRouter<T extends RoutableWindowContext = RoutableWindowContext>(): WindowContextRouter<T>;
+//# sourceMappingURL=context-router.d.ts.map

package/dist/main/services/window-contexts/context-router.js

@@ -0,0 +1,55 @@
+import { toDisposable } from '@dimina-kit/electron-deck/main';
+export function createWindowContextRouter() {
+    const contexts = [];
+    let activeCtx = null;
+    const first = () => contexts[0] ?? null;
+    return {
+        register(ctx) {
+            contexts.push(ctx);
+            activeCtx ??= ctx;
+            return toDisposable(() => {
+                const at = contexts.indexOf(ctx);
+                if (at === -1)
+                    return;
+                contexts.splice(at, 1);
+                if (activeCtx === ctx)
+                    activeCtx = first();
+            });
+        },
+        resolve(sender) {
+            // Two passes, because the two predicates answer different questions.
+            // `senderPolicy` also accepts host windows registered through
+            // `registerTrustedWindow`, whose id map is app-wide — every context says
+            // yes to such a sender, so a single-pass scan would hand it to whichever
+            // window happened to register first. Pass one therefore only accepts a
+            // context that OWNS the sender (its own renderer, settings window or
+            // overlay views), which is unique by construction. Pass two covers the
+            // accepted-but-unowned senders that are left: they belong to the app
+            // rather than to a window, so the active window answers them.
+            //
+            // Neither pass moves "active": window focus is what decides which window
+            // an app-wide sender belongs to, and a background window handling its own
+            // IPC must not steal that answer from the focused one.
+            for (const ctx of contexts) {
+                if (ctx.ownsSender(sender))
+                    return ctx;
+            }
+            for (const ctx of contexts) {
+                if (ctx.senderPolicy(sender))
+                    return activeCtx ?? first();
+            }
+            return null;
+        },
+        active() {
+            return activeCtx ?? first();
+        },
+        setActive(ctx) {
+            if (contexts.includes(ctx))
+                activeCtx = ctx;
+        },
+        list() {
+            return contexts.slice();
+        },
+    };
+}
+//# sourceMappingURL=context-router.js.map

package/dist/main/services/workbench-coi-host.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The single http listener behind every project window's workbench bridge.
+ *
+ * Browser storage is keyed by ORIGIN: IndexedDB, OPFS, Cache Storage, service
+ * worker registrations, Web Locks and BroadcastChannel all live in a bucket
+ * named after scheme + host + PORT. A listener bound to port 0 gets a different
+ * port every time, so one http server per project window put every window on
+ * its own origin — the VS Code workspace- and global-scope mementos a window
+ * wrote (open editors, view state, explorer expansion) died with it, reopening
+ * the same project minted a fresh empty bucket, and each new port accumulated
+ * another service-worker registration and cache entry that nothing reclaimed.
+ *
+ * So the listener is shared by every window in the process and a window's
+ * bridge is addressed by an opaque path prefix (`/w/<token>/`) rather than by
+ * port: one origin for all workbenches, distinct `/__fs` + `/__project`
+ * routing per window. The prefix is routing, not a security boundary — pages
+ * on one origin can already reach each other's paths, which is the situation
+ * the app-wide server had before per-project windows existed.
+ *
+ * The listener also outlives the last window that used it, because closing
+ * every project and opening another one is an ordinary switch and must not
+ * move the origin. Only {@link closeAllCoiHosts} takes a listener down.
+ */
+import http from 'node:http';
+export interface CoiHostSession {
+    /**
+     * Answers one request for this window. `url` has already had the window's
+     * `/w/<token>` prefix stripped, so the handler sees the same pathnames it
+     * would on a server of its own.
+     */
+    handle: (req: http.IncomingMessage, res: http.ServerResponse, url: URL) => void;
+}
+export interface CoiHostRegistration {
+    /** Scheme + host + port of the shared listener, with no trailing slash. */
+    origin: string;
+    port: number;
+    /** The path segment that routes to this session. */
+    token: string;
+    /** Drops the route, closing the shared listener when the last one goes. */
+    release: () => Promise<void>;
+}
+/**
+ * Tear down every listener. For process shutdown and for test isolation — a
+ * window's own teardown never gets here, because the origin has to survive it.
+ */
+export declare function closeAllCoiHosts(): Promise<void>;
+export declare function registerCoiHostSession(opts: {
+    rootDir: string;
+    extensionsDir: string | null;
+    session: CoiHostSession;
+}): Promise<CoiHostRegistration>;
+//# sourceMappingURL=workbench-coi-host.d.ts.map

package/dist/main/services/workbench-coi-host.js

@@ -0,0 +1,227 @@
+/**
+ * The single http listener behind every project window's workbench bridge.
+ *
+ * Browser storage is keyed by ORIGIN: IndexedDB, OPFS, Cache Storage, service
+ * worker registrations, Web Locks and BroadcastChannel all live in a bucket
+ * named after scheme + host + PORT. A listener bound to port 0 gets a different
+ * port every time, so one http server per project window put every window on
+ * its own origin — the VS Code workspace- and global-scope mementos a window
+ * wrote (open editors, view state, explorer expansion) died with it, reopening
+ * the same project minted a fresh empty bucket, and each new port accumulated
+ * another service-worker registration and cache entry that nothing reclaimed.
+ *
+ * So the listener is shared by every window in the process and a window's
+ * bridge is addressed by an opaque path prefix (`/w/<token>/`) rather than by
+ * port: one origin for all workbenches, distinct `/__fs` + `/__project`
+ * routing per window. The prefix is routing, not a security boundary — pages
+ * on one origin can already reach each other's paths, which is the situation
+ * the app-wide server had before per-project windows existed.
+ *
+ * The listener also outlives the last window that used it, because closing
+ * every project and opening another one is an ordinary switch and must not
+ * move the origin. Only {@link closeAllCoiHosts} takes a listener down.
+ */
+import http from 'node:http';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { serveStaticFile, setIsolationHeaders } from './workbench-coi-static.js';
+import { createCoiServerShutdown } from './workbench-coi-shutdown.js';
+/**
+ * Tear down every listener. For process shutdown and for test isolation — a
+ * window's own teardown never gets here, because the origin has to survive it.
+ */
+export async function closeAllCoiHosts() {
+    if (closingAll)
+        return closingAll;
+    const pending = [...hosts.values()];
+    hosts.clear();
+    const run = (async () => {
+        await Promise.all(pending.map(async (p) => {
+            const host = await p.catch(() => null);
+            if (!host || host.closed)
+                return;
+            host.closed = true;
+            await host.shutdown.close(host.server);
+        }));
+    })();
+    closingAll = run;
+    try {
+        await run;
+    }
+    finally {
+        if (closingAll === run)
+            closingAll = null;
+    }
+}
+/**
+ * One host per bundle + extensions pair. Two hosts serving different bundles
+ * are genuinely different servers; every window of one app shares one entry.
+ */
+const hosts = new Map();
+/**
+ * In-flight {@link closeAllCoiHosts}. A registration that was already waiting
+ * on `createHost` when a global close began must not hand its window an origin
+ * that close is about to take away, so it waits here and starts a fresh host.
+ */
+let closingAll = null;
+const WINDOW_PREFIX = /^\/w\/([A-Za-z0-9-]+)(\/.*)?$/;
+function notFound(res) {
+    res.writeHead(404);
+    res.end('Not Found');
+}
+function badRequest(res) {
+    res.writeHead(400);
+    res.end('Bad Request');
+}
+function serverError(res) {
+    res.writeHead(500);
+    res.end('Internal Server Error');
+}
+async function createHost(rootDir) {
+    const sessions = new Map();
+    const shutdown = createCoiServerShutdown();
+    const server = http.createServer((req, res) => {
+        setIsolationHeaders(res);
+        let url;
+        try {
+            url = new URL(req.url ?? '/', 'http://127.0.0.1');
+        }
+        catch {
+            // A malformed request line must not become an uncaught exception in the
+            // main process.
+            badRequest(res);
+            return;
+        }
+        const routed = WINDOW_PREFIX.exec(url.pathname);
+        if (routed) {
+            const session = sessions.get(routed[1]);
+            // A request for a window that has already been torn down. 404 rather
+            // than fall through to the bundle: the caller asked for one specific
+            // window's bridge, and answering with another window's data would be
+            // worse than not answering.
+            if (!session) {
+                notFound(res);
+                return;
+            }
+            // Strip the prefix by rewriting `pathname` on a copy. Re-parsing the
+            // remainder as a URL reference would read a leading `//` as an authority,
+            // so `/w/<token>//__project` would arrive as `/` on host `__project`.
+            const forwarded = new URL(url);
+            forwarded.pathname = routed[2] || '/';
+            try {
+                session.handle(req, res, forwarded);
+            }
+            catch (err) {
+                // One window's handler must not take the shared listener's process
+                // with it — an uncaught exception here would end every other project
+                // window too. A handler answers its own client errors (a malformed
+                // percent escape, say), so anything reaching this point is a defect in
+                // it: 500 rather than 400, and logged, because a silent 400 would read
+                // as the caller's fault and hide the bug for good.
+                console.error('[workbench-coi] session handler threw', err);
+                if (res.headersSent)
+                    res.destroy();
+                else
+                    serverError(res);
+            }
+            return;
+        }
+        // No window prefix. Every bridge endpoint has to know WHICH window asked,
+        // so answering one here would mean guessing a project — the ambiguity the
+        // prefix exists to remove. The bundle itself is project-independent and is
+        // still served, so an absolute asset URL inside it keeps working.
+        if (url.pathname.startsWith('/__')) {
+            notFound(res);
+            return;
+        }
+        let decoded;
+        try {
+            decoded = decodeURIComponent(url.pathname);
+        }
+        catch {
+            // A stray `%` in the path. Answering 400 keeps the listener alive; the
+            // throw would otherwise escape the request handler.
+            badRequest(res);
+            return;
+        }
+        shutdown.trackRequest(res);
+        serveStaticFile(res, rootDir, decoded);
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            server.off('error', reject);
+            resolve();
+        });
+    });
+    const addr = server.address();
+    const port = typeof addr === 'object' && addr ? addr.port : 0;
+    return {
+        server,
+        origin: `http://127.0.0.1:${port}`,
+        port,
+        rootDir,
+        sessions,
+        shutdown,
+        closed: false,
+    };
+}
+export async function registerCoiHostSession(opts) {
+    const rootDir = path.resolve(opts.rootDir);
+    // JSON, not a separator character: `('/a', '/b|/c')` and `('/a|/b', '/c')`
+    // are both legal path pairs and would otherwise collide onto one host, so two
+    // different bundles would serve each other's files.
+    const key = JSON.stringify([rootDir, opts.extensionsDir ?? null]);
+    // Loop rather than a single lookup: a release running concurrently can have
+    // marked the cached host closed without having removed it yet, and joining a
+    // closing server would hand back a dead origin.
+    for (;;) {
+        if (closingAll) {
+            await closingAll;
+            continue;
+        }
+        let pending = hosts.get(key);
+        if (!pending) {
+            pending = createHost(rootDir);
+            hosts.set(key, pending);
+        }
+        let host;
+        try {
+            host = await pending;
+        }
+        catch (err) {
+            if (hosts.get(key) === pending)
+                hosts.delete(key);
+            throw err;
+        }
+        // `closingAll` is re-checked because it can have started while this
+        // registration was awaiting `pending`: the host may still read as open and
+        // yet be one `await` away from losing its port.
+        if (host.closed || closingAll || hosts.get(key) !== pending) {
+            if (hosts.get(key) === pending)
+                hosts.delete(key);
+            continue;
+        }
+        const token = randomUUID();
+        host.sessions.set(token, opts.session);
+        let released = false;
+        return {
+            origin: host.origin,
+            port: host.port,
+            token,
+            release: async () => {
+                if (released)
+                    return;
+                released = true;
+                host.sessions.delete(token);
+                // The listener deliberately stays up with no windows on it. Closing it
+                // would release the port, and the next window would bind a different
+                // one — a different origin, so the storage the closed window wrote
+                // would be unreachable. Closing the last project and opening another
+                // is the ordinary way to switch projects, so the origin has to hold
+                // for the life of the process, not just while a window is open.
+            },
+        };
+    }
+}
+//# sourceMappingURL=workbench-coi-host.js.map