Add deterministic Electron E2E and harden local model attachments

.github/workflows/ci.yml

@@ -51,3 +51,34 @@ jobs:
 
       - name: Build production bundles
         run: npm run build
+
+  e2e:
+    name: Deterministic Electron E2E
+    runs-on: macos-26
+    timeout-minutes: 30
+    steps:
+      - name: Check out source
+        uses: actions/checkout@d23441a48e516b6c34aea4fa41551a30e30af803
+
+      - name: Use Node.js 22
+        uses: actions/setup-node@249970729cb0ef3589644e2896645e5dc5ba9c38
+        with:
+          node-version: 22.22.3
+          cache: npm
+
+      - name: Install locked dependencies
+        run: npm ci
+
+      - name: Run deterministic Electron E2E gate
+        run: npm run test:e2e
+
+      - name: Upload Playwright failure artifacts
+        if: ${{ failure() }}
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        with:
+          name: playwright-e2e-ci-${{ github.run_id }}-${{ github.run_attempt }}
+          path: |
+            test-results/e2e
+            playwright-report/e2e
+          if-no-files-found: warn
+          retention-days: 14

.github/workflows/release.yml

@@ -68,6 +68,20 @@ jobs:
       - name: Run Apple Foundation Models tests
         run: npm run test:native
 
+      - name: Run deterministic Electron E2E gate
+        run: npm run test:e2e
+
+      - name: Upload Playwright failure artifacts
+        if: ${{ failure() }}
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        with:
+          name: playwright-e2e-release-${{ github.run_id }}-${{ github.run_attempt }}
+          path: |
+            test-results/e2e
+            playwright-report/e2e
+          if-no-files-found: warn
+          retention-days: 14
+
       - name: Prepare App Store Connect key
         shell: bash
         env:

.gitignore

@@ -23,6 +23,11 @@ Thumbs.db
 # Logs
 *.log
 
+# Playwright artifacts
+/test-results/
+/playwright-report/
+/blob-report/
+
 # Temporary files
 tmp/*
 

main/handlers/attachments.contract.test.ts

@@ -19,3 +19,19 @@ test("attachment IPC combines native selection and bounded reading in main", ()
   assert.doesNotMatch(rendererIpcSource, /attachments:read/);
   assert.doesNotMatch(rendererIpcSource, /function pickFiles/);
 });
+
+test("every attachment ingestion channel uses process-owned owner-bound admission", () => {
+  assert.equal(
+    handlerSource.match(/\brunOwnedAttachmentIngestion\(/gu)?.length,
+    3,
+    "picker, drop, and clipboard admission calls must remain present",
+  );
+  assert.match(handlerSource, /async function runOwnedAttachmentIngestion<T>\(/u);
+  assert.match(handlerSource, /owner\.onInvalidated\(lease\.cancel\)/u);
+  assert.match(
+    handlerSource,
+    /finally \{\s+removeOwnerInvalidation\(\);\s+lease\.release\(\);\s+\}/u,
+  );
+  assert.match(handlerSource, /validateClipboardAttachmentPayload\(/u);
+  assert.match(handlerSource, /materializeClipboardAttachments\(payload, isActive\)/u);
+});

main/handlers/attachments.ts

@@ -1,13 +1,53 @@
 // Reading user-attached files + bundled model capability lookups.
 
 import { BrowserWindow, dialog, ipcMain } from "../platform.js";
-import { isImageAttachmentPath, readPickedAttachments } from "../services/attachments.js";
+import {
+  attachmentIngestionRepresentationBytes,
+  AttachmentIngestionAdmission,
+  isImageAttachmentPath,
+  materializeClipboardAttachments,
+  readPickedAttachments,
+  validateClipboardAttachmentPayload,
+} from "../services/attachments.js";
 import { providerModelInfo } from "../services/provider-model-info.js";
 import {
   MAX_ATTACHMENT_INLINE_BYTES,
   MAX_ATTACHMENTS_PER_MESSAGE,
 } from "../../renderer/shared/attachment-contract.js";
-import { rendererDocumentOwner } from "../services/renderer-document-owner.js";
+import {
+  rendererDocumentOwner,
+  type RendererDocumentOwner,
+} from "../services/renderer-document-owner.js";
+
+const attachmentIngestionAdmission = new AttachmentIngestionAdmission();
+
+async function runOwnedAttachmentIngestion<T>(
+  owner: RendererDocumentOwner,
+  attachmentCount: number,
+  representationBytes: number,
+  operation: (isActive: () => boolean) => T | Promise<T>,
+): Promise<T> {
+  const lease = attachmentIngestionAdmission.acquire(
+    owner.documentId,
+    attachmentCount,
+    representationBytes,
+  );
+  const isActive = (): boolean => lease.isActive() && !owner.isDestroyed();
+  let removeOwnerInvalidation = (): void => undefined;
+  try {
+    removeOwnerInvalidation = owner.onInvalidated(lease.cancel);
+    if (!isActive()) throw new Error("The renderer document is no longer active.");
+    const result = await operation(isActive);
+    // Keep accounting through one main-loop turn so simultaneous invoke bursts
+    // cannot each materialize an unaccounted Base64 result before delivery.
+    await new Promise<void>((resolve) => setImmediate(resolve));
+    if (!isActive()) throw new Error("The renderer document is no longer active.");
+    return result;
+  } finally {
+    removeOwnerInvalidation();
+    lease.release();
+  }
+}
 
 export function registerAttachmentHandlers(): void {
   let pickerActive = false;
@@ -42,33 +82,103 @@ export function registerAttachmentHandlers(): void {
 
       pickerActive = true;
       try {
-        const result = await dialog.showOpenDialog(parent, {
-          properties: ["openFile", "multiSelections"],
-        });
-        if (owner.isDestroyed()) throw new Error("The renderer document is no longer active.");
-        if (result.canceled || result.filePaths.length === 0) {
-          return { attachments: [], skipped: 0 };
-        }
-        const selectedPaths: string[] = [];
-        for (const filePath of result.filePaths.slice(0, 200)) {
-          if (!includeImages && isImageAttachmentPath(filePath)) continue;
-          selectedPaths.push(filePath);
-          if (selectedPaths.length === remainingSlots) break;
-        }
-        const attachments = await readPickedAttachments(selectedPaths, {
-          isActive: () => !owner.isDestroyed(),
-          maxBatchBytes: remainingInlineBytes,
-        });
-        return {
-          attachments,
-          skipped: Math.max(0, result.filePaths.length - selectedPaths.length),
-        };
+        return await runOwnedAttachmentIngestion(
+          owner,
+          remainingSlots,
+          attachmentIngestionRepresentationBytes(remainingInlineBytes, remainingSlots),
+          async (isActive) => {
+            const result = await dialog.showOpenDialog(parent, {
+              properties: ["openFile", "multiSelections"],
+            });
+            if (!isActive()) throw new Error("The renderer document is no longer active.");
+            if (result.canceled || result.filePaths.length === 0) {
+              return { attachments: [], skipped: 0 };
+            }
+            const selectedPaths: string[] = [];
+            for (const filePath of result.filePaths.slice(0, 200)) {
+              if (!includeImages && isImageAttachmentPath(filePath)) continue;
+              selectedPaths.push(filePath);
+              if (selectedPaths.length === remainingSlots) break;
+            }
+            const attachments = await readPickedAttachments(selectedPaths, {
+              isActive,
+              maxBatchBytes: remainingInlineBytes,
+            });
+            return {
+              attachments,
+              skipped: Math.max(0, result.filePaths.length - selectedPaths.length),
+            };
+          },
+        );
       } finally {
         pickerActive = false;
       }
     },
   );
 
+  ipcMain.handle(
+    "aiden:attachments:dropped-read",
+    async (
+      event,
+      value: unknown,
+      remainingSlots: unknown,
+      includeImages: unknown,
+      remainingInlineBytes: unknown,
+    ) => {
+      if (
+        !Array.isArray(value) ||
+        value.length === 0 ||
+        value.length > MAX_ATTACHMENTS_PER_MESSAGE ||
+        !Number.isSafeInteger(remainingSlots) ||
+        (remainingSlots as number) < 1 ||
+        (remainingSlots as number) > MAX_ATTACHMENTS_PER_MESSAGE ||
+        typeof includeImages !== "boolean" ||
+        !Number.isSafeInteger(remainingInlineBytes) ||
+        (remainingInlineBytes as number) < 1 ||
+        (remainingInlineBytes as number) > MAX_ATTACHMENT_INLINE_BYTES
+      ) {
+        throw new Error("Invalid dropped attachment request.");
+      }
+      const paths = [...new Set(value)].filter(
+        (entry): entry is string => typeof entry === "string" && entry.length > 0,
+      );
+      if (paths.length !== value.length) throw new Error("Invalid dropped attachment request.");
+      const owner = rendererDocumentOwner(event, () => new Error("Untrusted attachment drop."));
+      const selected = paths
+        .filter((filePath) => includeImages || !isImageAttachmentPath(filePath))
+        .slice(0, remainingSlots as number);
+      if (selected.length === 0) return [];
+      return runOwnedAttachmentIngestion(
+        owner,
+        selected.length,
+        attachmentIngestionRepresentationBytes(remainingInlineBytes as number, selected.length),
+        (isActive) =>
+          readPickedAttachments(selected, {
+            isActive,
+            maxBatchBytes: remainingInlineBytes as number,
+          }),
+      );
+    },
+  );
+
+  ipcMain.handle(
+    "aiden:attachments:clipboard-read",
+    async (event, value: unknown, remainingSlots: unknown, remainingInlineBytes: unknown) => {
+      const owner = rendererDocumentOwner(event, () => new Error("Untrusted clipboard image."));
+      const payload = validateClipboardAttachmentPayload(
+        value,
+        remainingSlots,
+        remainingInlineBytes,
+      );
+      return runOwnedAttachmentIngestion(
+        owner,
+        payload.images.length,
+        payload.representationBytes,
+        (isActive) => materializeClipboardAttachments(payload, isActive),
+      );
+    },
+  );
+
   ipcMain.handle("models:info", async (_event, providerId: unknown, modelIds: unknown) => {
     const pid = typeof providerId === "string" ? providerId : "";
     const ids = Array.isArray(modelIds)

main/handlers/chats.append.contract.test.ts

@@ -163,7 +163,9 @@ test("append envelopes reject many extra properties without materializing Object
 });
 
 test("append admission charges encoded image representation and metadata", () => {
-  const data = Buffer.alloc(3).toString("base64");
+  const data =
+    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIHWP4z8DwHwAFgAI/ScL2aQAAAABJRU5ErkJggg==";
+  const size = Buffer.byteLength(data, "base64");
   const parsed = parseChatAppend(
     "chat-1",
     {
@@ -175,15 +177,12 @@ test("append admission charges encoded image representation and metadata", () =>
           name: "a.png",
           mimeType: "image/png",
           kind: "image",
-          size: 3,
+          size,
           data,
         },
       ],
     },
     { turnId: "turn-1", providerId: "provider", model: "model" },
   );
-  assert.ok(
-    parsed.retainedBytes >=
-      data.length + Buffer.byteLength("providermodel", "utf8"),
-  );
+  assert.ok(parsed.retainedBytes >= data.length + Buffer.byteLength("providermodel", "utf8"));
 });