@dimina-kit/devtools 0.3.2-dev.20260524104239 → 0.3.2-dev.20260525152421

package/dist/main/services/simulator-temp-files/request-handler.js

@@ -0,0 +1,178 @@
+/**
+ * Pure dispatcher for `difile://` URL requests.
+ *
+ * Spec: `packages/devtools/docs/file-system.md` §4.3.
+ *
+ * The shipping implementation in `index.ts` registers a thin
+ * `simSession.protocol.handle('difile')` wrapper that delegates here; the race
+ * waiter on `_tmp/*` lives in `index.ts` because it owns the IPC lifecycle.
+ * For unit tests we assume the bytes are already in the store.
+ *
+ * Response shape:
+ *   - 200: full body, with Content-Type, Cache-Control (immutable), ETag
+ *   - 206: range slice, plus Content-Range
+ *   - 304: empty body when `If-None-Match` matches the on-disk ETag. Per RFC
+ *     9110 §13.1.2 If-None-Match wins over Range.
+ *   - 404: anything `resolveVPath` rejects, plus disk-side ENOENT and any
+ *     other I/O error. The protocol handler in `index.ts` translates this
+ *     into the renderer's network failure surface; we deliberately do not
+ *     leak errno strings.
+ */
+import { resolveVPath } from '../../../simulator/vpath.js';
+import { readDiskFile } from './disk.js';
+const CACHE_CONTROL = 'public, max-age=31536000, immutable';
+function getHeader(headers, name) {
+    if (!headers)
+        return undefined;
+    const lc = name.toLowerCase();
+    for (const k of Object.keys(headers)) {
+        if (k.toLowerCase() === lc)
+            return headers[k];
+    }
+    return undefined;
+}
+/**
+ * Weak ETag comparison per RFC 9110 §8.8.3.2: strip the optional `W/` prefix
+ * from each side before comparing. Both our generated ETags and conditional
+ * headers may or may not include the weak prefix; the comparison must accept
+ * `W/"abc"` and `"abc"` as equivalent.
+ */
+function etagsMatch(a, b) {
+    if (!a)
+        return false;
+    const stripped = (s) => (s.startsWith('W/') ? s.slice(2) : s);
+    return stripped(a.trim()) === stripped(b);
+}
+/**
+ * Parse a `Range: bytes=<start>-<end>` header into an inclusive `{start,end}`.
+ * Returns `null` if absent or malformed (callers should treat that as "no
+ * range" — a full 200 response, not a 416). `totalSize` clamps the end.
+ */
+function parseRange(header, totalSize) {
+    if (!header)
+        return null;
+    const m = /^bytes=(\d*)-(\d*)$/.exec(header.trim());
+    if (!m)
+        return null;
+    const startStr = m[1];
+    const endStr = m[2];
+    if (startStr === '' && endStr === '')
+        return null;
+    if (startStr === '') {
+        // Suffix range: last N bytes.
+        const n = Number(endStr);
+        if (!Number.isFinite(n) || n <= 0)
+            return null;
+        const start = Math.max(0, totalSize - n);
+        return { start, end: totalSize - 1 };
+    }
+    const start = Number(startStr);
+    if (!Number.isFinite(start) || start < 0)
+        return null;
+    const end = endStr === '' ? totalSize - 1 : Number(endStr);
+    if (!Number.isFinite(end))
+        return null;
+    return { start, end };
+}
+function notFound() {
+    return new Response(null, { status: 404 });
+}
+function notModified(etag) {
+    return new Response(null, {
+        status: 304,
+        headers: {
+            ETag: etag,
+            'Cache-Control': CACHE_CONTROL,
+            'Access-Control-Allow-Origin': '*',
+        },
+    });
+}
+function bufferToBody(bytes) {
+    // Copy into a fresh ArrayBuffer so the result is definitely typed as
+    // `ArrayBuffer` (not `ArrayBufferLike` / `SharedArrayBuffer`) and is
+    // safe to hand to Response without aliasing the Node Buffer pool.
+    const out = new ArrayBuffer(bytes.byteLength);
+    new Uint8Array(out).set(bytes);
+    return out;
+}
+function tempBody(bytes, mime) {
+    return new Response(bufferToBody(bytes), {
+        status: 200,
+        headers: {
+            'Content-Type': mime,
+            'Cache-Control': CACHE_CONTROL,
+            'Access-Control-Allow-Origin': '*',
+        },
+    });
+}
+export async function handleDifileRequest(ctx, req) {
+    const v = resolveVPath(req.url);
+    if (!v)
+        return notFound();
+    if (v.kind === 'tmp') {
+        const record = ctx.tempStore.get(req.url);
+        if (!record)
+            return notFound();
+        return tempBody(record.bytes, record.mime || 'application/octet-stream');
+    }
+    if (!v.realPath)
+        return notFound();
+    // Disk-backed: _store or usr.
+    try {
+        // Probe first to learn the ETag/size so If-None-Match can short-circuit
+        // without reading the body. The probe also doubles as our existence /
+        // permission check, so anything that throws here (ENOENT, EACCES, ...)
+        // surfaces as a 404.
+        const probe = await readDiskFile(v.realPath);
+        const etag = probe.etag;
+        const totalSize = probe.totalSize;
+        const mime = probe.mime;
+        const ifNoneMatch = getHeader(req.headers, 'If-None-Match');
+        if (etagsMatch(ifNoneMatch, etag)) {
+            return notModified(etag);
+        }
+        const rangeHeader = getHeader(req.headers, 'Range');
+        const range = parseRange(rangeHeader, totalSize);
+        if (range) {
+            // Range out of bounds → 416 (Range Not Satisfiable) per RFC 9110 §15.4.
+            // Distinct from 404 so callers can tell "wrong file" from "wrong slice".
+            if (range.start < 0 || range.start >= totalSize || range.end < range.start) {
+                return new Response(null, {
+                    status: 416,
+                    headers: {
+                        'Content-Range': `bytes */${totalSize}`,
+                        'Access-Control-Allow-Origin': '*',
+                    },
+                });
+            }
+            const clampedEnd = Math.min(range.end, totalSize - 1);
+            const sliced = await readDiskFile(v.realPath, { range: { start: range.start, end: clampedEnd } });
+            const { bytes } = sliced;
+            const lastByte = range.start + bytes.length - 1;
+            return new Response(bufferToBody(bytes), {
+                status: 206,
+                headers: {
+                    'Content-Type': mime,
+                    'Content-Length': String(bytes.length),
+                    'Content-Range': `bytes ${range.start}-${lastByte}/${totalSize}`,
+                    'Cache-Control': CACHE_CONTROL,
+                    ETag: etag,
+                    'Access-Control-Allow-Origin': '*',
+                },
+            });
+        }
+        return new Response(bufferToBody(probe.bytes), {
+            status: 200,
+            headers: {
+                'Content-Type': mime,
+                'Cache-Control': CACHE_CONTROL,
+                ETag: etag,
+                'Access-Control-Allow-Origin': '*',
+            },
+        });
+    }
+    catch {
+        return notFound();
+    }
+}
+//# sourceMappingURL=request-handler.js.map

package/dist/main/services/simulator-temp-files/resolver.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Pure lookup helper backing the main-process `difile://_tmp/*` protocol
+ * handler. Receives the shared {@link TempFileStore} that the
+ * `simulator:temp-file:*` IPC channels populate from the renderer.
+ *
+ * The full URL (including scheme + host) is used as the Map key — the resolver
+ * never re-parses or normalises it, so any URL with a wrong scheme or host
+ * misses regardless of suffix similarity.
+ */
+export interface TempFileRecord {
+    bytes: Buffer;
+    mime: string;
+}
+export type TempFileStore = Map<string, TempFileRecord>;
+export declare function resolveTempFile(store: TempFileStore, url: string): {
+    status: 200;
+    bytes: Buffer;
+    mime: string;
+} | {
+    status: 404;
+};
+//# sourceMappingURL=resolver.d.ts.map

package/dist/main/services/simulator-temp-files/resolver.js

@@ -0,0 +1,22 @@
+/**
+ * Pure lookup helper backing the main-process `difile://_tmp/*` protocol
+ * handler. Receives the shared {@link TempFileStore} that the
+ * `simulator:temp-file:*` IPC channels populate from the renderer.
+ *
+ * The full URL (including scheme + host) is used as the Map key — the resolver
+ * never re-parses or normalises it, so any URL with a wrong scheme or host
+ * misses regardless of suffix similarity.
+ */
+export function resolveTempFile(store, url) {
+    if (!url.startsWith('difile://_tmp/'))
+        return { status: 404 };
+    const record = store.get(url);
+    if (!record)
+        return { status: 404 };
+    return {
+        status: 200,
+        bytes: record.bytes,
+        mime: record.mime || 'application/octet-stream',
+    };
+}
+//# sourceMappingURL=resolver.js.map

package/dist/main/services/simulator-temp-files/store.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Mutators for the shared {@link TempFileStore}. The renderer-side bridge
+ * forwards every `createTempFilePath` / `registerTempFilePath` /
+ * `revokeTempFilePath` / `revokeAllTempFilePaths` call over IPC, and these
+ * helpers translate the payloads into Map writes.
+ *
+ * ArrayBuffer inputs are normalised to Buffer at the boundary so the
+ * resolver hot path can return the bytes directly without re-wrapping.
+ */
+import type { TempFileStore } from './resolver.js';
+export declare function registerTempFile(store: TempFileStore, path: string, mime: string, bytes: ArrayBuffer | Buffer): void;
+export declare function revokeTempFile(store: TempFileStore, path: string): void;
+export declare function revokeAllTempFiles(store: TempFileStore): void;
+//# sourceMappingURL=store.d.ts.map

package/dist/main/services/simulator-temp-files/store.js

@@ -0,0 +1,24 @@
+/**
+ * Mutators for the shared {@link TempFileStore}. The renderer-side bridge
+ * forwards every `createTempFilePath` / `registerTempFilePath` /
+ * `revokeTempFilePath` / `revokeAllTempFilePaths` call over IPC, and these
+ * helpers translate the payloads into Map writes.
+ *
+ * ArrayBuffer inputs are normalised to Buffer at the boundary so the
+ * resolver hot path can return the bytes directly without re-wrapping.
+ */
+export function registerTempFile(store, path, mime, bytes) {
+    const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(new Uint8Array(bytes));
+    // delete-then-set so an existing entry's insertion order is refreshed.
+    // Without this, a FIFO cap eviction over `store.keys()` could drop a
+    // recently re-written path.
+    store.delete(path);
+    store.set(path, { bytes: buf, mime });
+}
+export function revokeTempFile(store, path) {
+    store.delete(path);
+}
+export function revokeAllTempFiles(store) {
+    store.clear();
+}
+//# sourceMappingURL=store.js.map

package/dist/preload/runtime/temp-files.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Preload-side bridge that mirrors the simulator's renderer-side temp-file
+ * registry into the main-process store via IPC. The main process serves the
+ * resulting `difile://devtools/{uuid}` URLs over a protocol handler bound to
+ * the simulator session.
+ */
+export declare function installTempFileBridge(): void;
+//# sourceMappingURL=temp-files.d.ts.map

package/dist/preload/runtime/temp-files.js

@@ -0,0 +1,34 @@
+/**
+ * Preload-side bridge that mirrors the simulator's renderer-side temp-file
+ * registry into the main-process store via IPC. The main process serves the
+ * resulting `difile://devtools/{uuid}` URLs over a protocol handler bound to
+ * the simulator session.
+ */
+import { ipcRenderer } from 'electron';
+import { setTempFileSink } from '../../simulator/temp-files.js';
+export function installTempFileBridge() {
+    setTempFileSink({
+        write(path, blob) {
+            blob
+                .arrayBuffer()
+                .then((bytes) => {
+                ipcRenderer.send('simulator:temp-file:write', {
+                    path,
+                    mime: blob.type,
+                    bytes,
+                });
+            })
+                .catch(() => {
+                // best effort: blob read failures cannot be surfaced through the
+                // sink contract (`write` is sync void), so we swallow them.
+            });
+        },
+        revoke(path) {
+            ipcRenderer.send('simulator:temp-file:revoke', { path });
+        },
+        revokeAll() {
+            ipcRenderer.send('simulator:temp-file:revoke-all');
+        },
+    });
+}
+//# sourceMappingURL=temp-files.js.map

package/dist/preload/windows/simulator.js

@@ -270,10 +270,41 @@ function installCustomApisBridge() {
   return exposeOnMainWorld("__diminaCustomApis", bridge);
 }
 
-// src/preload/runtime/host.ts
+// src/preload/runtime/temp-files.ts
 var import_electron3 = require("electron");
+
+// src/simulator/temp-files.ts
+var activeSink = null;
+function setTempFileSink(sink) {
+  activeSink = sink;
+}
+
+// src/preload/runtime/temp-files.ts
+function installTempFileBridge() {
+  setTempFileSink({
+    write(path, blob) {
+      blob.arrayBuffer().then((bytes) => {
+        import_electron3.ipcRenderer.send("simulator:temp-file:write", {
+          path,
+          mime: blob.type,
+          bytes
+        });
+      }).catch(() => {
+      });
+    },
+    revoke(path) {
+      import_electron3.ipcRenderer.send("simulator:temp-file:revoke", { path });
+    },
+    revokeAll() {
+      import_electron3.ipcRenderer.send("simulator:temp-file:revoke-all");
+    }
+  });
+}
+
+// src/preload/runtime/host.ts
+var import_electron4 = require("electron");
 function sendToHost(channel, data) {
-  import_electron3.ipcRenderer.sendToHost(channel, data);
+  import_electron4.ipcRenderer.sendToHost(channel, data);
 }
 function onHostMessage(channel, handler) {
   let active = true;
@@ -281,10 +312,10 @@ function onHostMessage(channel, handler) {
     if (!active) return;
     handler(...args);
   };
-  import_electron3.ipcRenderer.on(channel, wrapped);
+  import_electron4.ipcRenderer.on(channel, wrapped);
   return () => {
     active = false;
-    import_electron3.ipcRenderer.removeListener(channel, wrapped);
+    import_electron4.ipcRenderer.removeListener(channel, wrapped);
   };
 }
 function safeSerialize(val) {
@@ -953,11 +984,11 @@ function createWxmlSource() {
 }
 
 // src/preload/miniapp-snapshot/host.ts
-var import_electron4 = require("electron");
+var import_electron5 = require("electron");
 var ACCESSOR_KEY = "__miniappSnapshot";
 function exposeApi(api) {
   try {
-    import_electron4.contextBridge.exposeInMainWorld(ACCESSOR_KEY, api);
+    import_electron5.contextBridge.exposeInMainWorld(ACCESSOR_KEY, api);
   } catch {
     ;
     window.__miniappSnapshot = api;
@@ -1215,6 +1246,7 @@ function setupApiCompatHook() {
 setupApiCompatHook();
 installSimulatorBridge();
 installCustomApisBridge();
+installTempFileBridge();
 installConsoleInstrumentation();
 var snapshotHost = createMiniappSnapshotHost();
 snapshotHost.register(createAppDataSource());