@dimina-kit/devtools 0.3.2-dev.20260601115343 → 0.3.2-dev.20260610082053

package/dist/main/services/dimina-resource-server.js

@@ -0,0 +1,99 @@
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+const MIME_TYPES = {
+    '.css': 'text/css; charset=utf-8',
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.map': 'application/json; charset=utf-8',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.wasm': 'application/wasm',
+};
+export async function startDiminaResourceServer(rootDir) {
+    const root = path.resolve(rootDir);
+    const server = http.createServer((req, res) => {
+        void handleRequest(root, req, res);
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            server.off('error', reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    return {
+        baseUrl: `http://127.0.0.1:${address.port}/`,
+        close() {
+            return new Promise((resolve, reject) => {
+                server.close((err) => err ? reject(err) : resolve());
+            });
+        },
+    };
+}
+async function handleRequest(root, req, res) {
+    setCorsHeaders(res);
+    if (req.method === 'OPTIONS') {
+        res.writeHead(204);
+        res.end();
+        return;
+    }
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+        res.writeHead(405);
+        res.end('Method Not Allowed');
+        return;
+    }
+    const url = new URL(req.url ?? '/', 'http://127.0.0.1');
+    const filePath = resolveContainedPath(root, decodeURIComponent(url.pathname));
+    if (!filePath) {
+        res.writeHead(403);
+        res.end('Forbidden');
+        return;
+    }
+    try {
+        const stat = await fs.promises.stat(filePath);
+        if (!stat.isFile()) {
+            res.writeHead(404);
+            res.end('Not Found');
+            return;
+        }
+        res.writeHead(200, {
+            'content-type': MIME_TYPES[path.extname(filePath)] ?? 'application/octet-stream',
+            'content-length': stat.size,
+            'cache-control': 'no-store',
+        });
+        if (req.method === 'HEAD') {
+            res.end();
+            return;
+        }
+        fs.createReadStream(filePath).pipe(res);
+    }
+    catch {
+        res.writeHead(404);
+        res.end('Not Found');
+    }
+}
+function resolveContainedPath(root, pathname) {
+    const relative = pathname.replace(/^\/+/, '') || 'index.html';
+    const resolved = path.resolve(root, relative);
+    if (resolved !== root && !resolved.startsWith(root + path.sep))
+        return null;
+    return resolved;
+}
+function setCorsHeaders(res) {
+    res.setHeader('access-control-allow-origin', '*');
+    res.setHeader('access-control-allow-headers', '*');
+    res.setHeader('access-control-allow-methods', 'GET,HEAD,OPTIONS');
+    res.setHeader('cross-origin-resource-policy', 'cross-origin');
+}
+export function toSourceUrl(filePath) {
+    return pathToFileURL(filePath).toString();
+}
+//# sourceMappingURL=dimina-resource-server.js.map

package/dist/main/services/elements-forward/index.d.ts

@@ -0,0 +1,66 @@
+import type { WebContents } from 'electron';
+import type { ConnectionRegistry } from '@dimina-kit/electron-deck/main';
+import type { BridgeRouterHandle } from '../../ipc/bridge-router.js';
+/** Which target a front-end CDP command is routed to. */
+export type CdpRoute = 'render' | 'service';
+/**
+ * Decide where a front-end CDP `method` is routed.
+ *
+ *  render  → DOM./CSS./Overlay./DOMSnapshot./DOMDebugger.  (the Elements tree)
+ *  service → EVERYTHING ELSE, and in particular:
+ *    • Emulation.*  — RED LINE: routing this to the render guest would let the
+ *      front-end overwrite the safe-area service's `setSafeAreaInsetsOverride`.
+ *      It MUST stay on the service-host inspection path (pass-through).
+ *    • Runtime./Console./Debugger./Network./Page./Target./Input./Profiler./Log.
+ *      — the service host owns these; leave them on the original channel.
+ *
+ * Pure (no I/O). The hook script inlines an equivalent prefix test driven by the
+ * same `RENDER_DOMAIN_PREFIXES` literal, so the two cannot silently drift.
+ */
+export declare function routeByDomain(method: string): CdpRoute;
+/** True for an event method we re-inject from the render guest into the panel. */
+export declare function isRenderEventMethod(method: string): boolean;
+/**
+ * The JS injected into the DevTools front-end realm. Idempotent (sentinel guard).
+ * Wraps `InspectorFrontendHost.sendMessageToBackend`: a RENDER-domain command is
+ * pushed onto `globalThis.__diminaElementsOutbound` (drained by main) and NOT
+ * forwarded to the original embedder channel (main answers it from the render
+ * guest); every other command calls through to the original (service-host path).
+ *
+ * Returns `'installed'` / `'already'` on success, `'partial'` while the embedder
+ * global is not yet present (so the caller retries), `'error:…'` on a real fault.
+ */
+export declare function buildElementsHookScript(): string;
+export interface ElementsForwardDeps {
+    /** The wc hosting the right-panel Chrome DevTools FRONT-END (injection target). */
+    devtoolsWc: WebContents;
+    /** Router handle — resolves the active render guest + render-event stream. */
+    bridge: BridgeRouterHandle;
+    /**
+     * The app whose active render guest we route to. `undefined` means "the
+     * router's current app" (resolved fresh on every use, like the safe-area /
+     * devtools-follow paths) — what the wire-up passes.
+     */
+    appId?: string;
+    /**
+     * Optional connection registry. When present, per-webContents teardowns
+     * (the devtools front-end wc's `stop`, and each render guest's `onDestroyed`)
+     * are routed through `connections.acquire(wc).own(cleanup)` so they fire
+     * deterministically on wc destroy / connection reset — replacing the bespoke
+     * `wc.once('destroyed', cleanup)` hook. Optional so existing callers compile
+     * unchanged; absent → the `once('destroyed')` fallback is used.
+     */
+    connections?: ConnectionRegistry;
+}
+/**
+ * Install Elements forwarding on a DevTools front-end host wc. Returns a disposer
+ * (`stop`) that clears timers, unsubscribes render events, detaches ONLY the
+ * debugger sessions this feature attached, and removes every listener it added.
+ *
+ * Best-effort + defensive throughout: a destroyed wc ends the feature; every
+ * executeJavaScript / sendCommand is wrapped so a torn-down guest never throws
+ * and an in-flight command always settles (we dispatch an error back rather than
+ * leaving the front-end pending).
+ */
+export declare function installElementsForward(deps: ElementsForwardDeps): () => void;
+//# sourceMappingURL=index.d.ts.map