@cubis/foundry 0.3.83 → 0.3.84

package/workflows/workflows/agent-environment-setup/platforms/antigravity/skills/electron-qa/evals/evals.json

@@ -1,68 +0,0 @@
-{
-  "evals": [
-    {
-      "name": "ipc-contract-testing-with-preload-validation",
-      "description": "Validate that the skill produces typed IPC channel tests, preload script validation, and main process handler tests for an Electron file manager application.",
-      "input": "Write a comprehensive test suite for an Electron file manager application. The app uses IPC to communicate between the renderer and main process for file operations: readDirectory, readFile, writeFile, deleteFile, and watchDirectory. Test the IPC handlers in the main process with mocked file system operations. Test the preload script to verify only the intended API is exposed via contextBridge. Validate the typed IPC channel contract between main and renderer. Use Vitest as the test framework. Ensure tests verify contextIsolation and sandbox security settings.",
-      "assertions": [
-        {
-          "type": "contains",
-          "value": "ipcMain",
-          "description": "Tests must directly test ipcMain.handle registrations to verify that IPC handlers correctly process messages, validate arguments, and return expected responses without requiring full application startup."
-        },
-        {
-          "type": "contains",
-          "value": "contextBridge",
-          "description": "Preload script tests must verify that contextBridge.exposeInMainWorld only exposes the intended API surface, preventing accidental exposure of Node.js APIs to the renderer process."
-        },
-        {
-          "type": "contains",
-          "value": "contextIsolation",
-          "description": "Tests must assert that BrowserWindow webPreferences include contextIsolation: true, verifying the security boundary that prevents renderer scripts from accessing the preload script's scope."
-        },
-        {
-          "type": "contains",
-          "value": "invoke",
-          "description": "The IPC contract tests must cover ipcRenderer.invoke calls matched to ipcMain.handle registrations, verifying that channel names, argument types, and return types are consistent across the process boundary."
-        },
-        {
-          "type": "contains",
-          "value": "mock",
-          "description": "File system operations must be mocked in IPC handler tests to isolate the handler logic from the actual file system, enabling fast and deterministic test execution in CI."
-        }
-      ]
-    },
-    {
-      "name": "e2e-packaging-and-native-module-validation",
-      "description": "Validate that the skill produces end-to-end tests, packaging verification, and native module compatibility tests for an Electron application with SQLite and auto-update.",
-      "input": "Create a test suite for an Electron note-taking app that uses better-sqlite3 for local storage and electron-updater for auto-updates. Write: (1) E2E tests using Playwright that launch the Electron app, create a note, verify it persists across app restart, and measure startup time. (2) Packaging tests that build the app with electron-builder and verify the distributable contains correct native module binaries, has proper code signing metadata, and includes all required assets. (3) Auto-update tests that mock the update server and verify the download-verify-install lifecycle. Target macOS, Windows, and Linux.",
-      "assertions": [
-        {
-          "type": "contains",
-          "value": "_electron",
-          "description": "E2E tests must use Playwright's Electron integration via _electron.launch() to start and interact with the actual Electron application, testing the full process architecture."
-        },
-        {
-          "type": "contains",
-          "value": "electron-builder",
-          "description": "Packaging tests must verify electron-builder output to catch silently excluded files, wrong native module ABIs, or broken code signatures before distribution."
-        },
-        {
-          "type": "contains",
-          "value": "better-sqlite3",
-          "description": "Tests must validate that better-sqlite3 native bindings are correctly compiled and included in the packaged application, since native module ABI mismatches are the most common cause of packaged app crashes."
-        },
-        {
-          "type": "contains",
-          "value": "autoUpdater",
-          "description": "Auto-update tests must mock electron-updater's autoUpdater to verify the update lifecycle (check, download, verify, quit-and-install) without depending on a real update server."
-        },
-        {
-          "type": "contains",
-          "value": "platform",
-          "description": "Tests must include platform-conditional logic or separate test suites for macOS, Windows, and Linux to account for platform-specific packaging formats (DMG, NSIS, AppImage) and behaviors."
-        }
-      ]
-    }
-  ]
-}

package/workflows/workflows/agent-environment-setup/platforms/antigravity/skills/electron-qa/examples/01-basic-usage.md

@@ -1,246 +0,0 @@
-# Example: IPC Handler Testing and Preload Script Validation
-
-## Scenario
-
-A team is building an Electron file manager with IPC channels for file system operations. The main process handles `readDirectory`, `readFile`, `writeFile`, `deleteFile`, and `watchDirectory` through `ipcMain.handle`. The preload script exposes these operations via `contextBridge.exposeInMainWorld`. The team needs to test IPC handlers in isolation, validate the preload API surface, and verify security settings on BrowserWindow creation.
-
-## Prompt
-
-"Write tests for the Electron file manager's IPC layer. Test each ipcMain.handle handler with mocked fs operations. Test the preload script to verify only intended APIs are exposed via contextBridge. Validate BrowserWindow security settings (contextIsolation, sandbox, no nodeIntegration). Define a typed IPC channel map and verify both sides match. Use Vitest."
-
-## Expected Output
-
-### Typed IPC Channel Map
-
-```typescript
-// src/shared/ipc-channels.ts
-export interface IpcChannelMap {
-  "fs:readDirectory": {
-    args: [dirPath: string];
-    return: FileEntry[];
-  };
-  "fs:readFile": {
-    args: [filePath: string];
-    return: { content: string; encoding: string };
-  };
-  "fs:writeFile": {
-    args: [filePath: string, content: string];
-    return: { success: boolean };
-  };
-  "fs:deleteFile": {
-    args: [filePath: string];
-    return: { success: boolean };
-  };
-  "fs:watchDirectory": {
-    args: [dirPath: string];
-    return: { watchId: string };
-  };
-}
-
-export interface FileEntry {
-  name: string;
-  path: string;
-  isDirectory: boolean;
-  size: number;
-  modifiedAt: string;
-}
-```
-
-### Main Process IPC Handler Tests
-
-```typescript
-// tests/main/ipc-handlers.test.ts
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ipcMain } from "electron";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { registerFileHandlers } from "../../src/main/ipc/file-handlers";
-
-vi.mock("node:fs/promises");
-vi.mock("electron", () => ({
-  ipcMain: {
-    handle: vi.fn(),
-  },
-}));
-
-describe("IPC File Handlers", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    registerFileHandlers();
-  });
-
-  it("registers all expected channels", () => {
-    const registeredChannels = (ipcMain.handle as any).mock.calls.map(
-      ([channel]: [string]) => channel
-    );
-    expect(registeredChannels).toContain("fs:readDirectory");
-    expect(registeredChannels).toContain("fs:readFile");
-    expect(registeredChannels).toContain("fs:writeFile");
-    expect(registeredChannels).toContain("fs:deleteFile");
-    expect(registeredChannels).toContain("fs:watchDirectory");
-  });
-
-  describe("fs:readDirectory", () => {
-    it("returns file entries for a valid directory", async () => {
-      const mockEntries = [
-        { name: "file.txt", isDirectory: () => false, isFile: () => true },
-        { name: "subfolder", isDirectory: () => true, isFile: () => false },
-      ];
-      vi.mocked(fs.readdir).mockResolvedValue(mockEntries as any);
-      vi.mocked(fs.stat).mockResolvedValue({
-        size: 1024,
-        mtime: new Date("2026-01-01"),
-      } as any);
-
-      const handler = (ipcMain.handle as any).mock.calls.find(
-        ([ch]: [string]) => ch === "fs:readDirectory"
-      )[1];
-
-      const result = await handler({}, "/home/user/docs");
-      expect(result).toHaveLength(2);
-      expect(result[0]).toMatchObject({
-        name: "file.txt",
-        isDirectory: false,
-      });
-    });
-
-    it("throws a descriptive error for non-existent directories", async () => {
-      const error = new Error("ENOENT: no such file or directory");
-      (error as any).code = "ENOENT";
-      vi.mocked(fs.readdir).mockRejectedValue(error);
-
-      const handler = (ipcMain.handle as any).mock.calls.find(
-        ([ch]: [string]) => ch === "fs:readDirectory"
-      )[1];
-
-      await expect(handler({}, "/nonexistent")).rejects.toThrow("ENOENT");
-    });
-
-    it("rejects path traversal attempts", async () => {
-      const handler = (ipcMain.handle as any).mock.calls.find(
-        ([ch]: [string]) => ch === "fs:readDirectory"
-      )[1];
-
-      await expect(handler({}, "../../etc/passwd")).rejects.toThrow(
-        "Invalid path"
-      );
-    });
-  });
-});
-```
-
-### Preload Script Validation
-
-```typescript
-// tests/preload/preload-api-surface.test.ts
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-const exposedApis: Record<string, unknown> = {};
-vi.mock("electron", () => ({
-  contextBridge: {
-    exposeInMainWorld: vi.fn((key: string, api: unknown) => {
-      exposedApis[key] = api;
-    }),
-  },
-  ipcRenderer: {
-    invoke: vi.fn(),
-    on: vi.fn(),
-    removeListener: vi.fn(),
-  },
-}));
-
-describe("Preload Script API Surface", () => {
-  beforeEach(() => {
-    Object.keys(exposedApis).forEach((key) => delete exposedApis[key]);
-    vi.clearAllMocks();
-  });
-
-  it("exposes exactly the fileManager API namespace", async () => {
-    await import("../../src/preload/index");
-    const keys = Object.keys(exposedApis);
-    expect(keys).toEqual(["fileManager"]);
-  });
-
-  it("exposes only the intended methods on fileManager", async () => {
-    await import("../../src/preload/index");
-    const api = exposedApis.fileManager as Record<string, unknown>;
-    const methods = Object.keys(api);
-    expect(methods).toEqual([
-      "readDirectory",
-      "readFile",
-      "writeFile",
-      "deleteFile",
-      "watchDirectory",
-      "onWatchEvent",
-    ]);
-  });
-
-  it("does not expose Node.js built-ins", async () => {
-    await import("../../src/preload/index");
-    const api = exposedApis.fileManager as Record<string, unknown>;
-    expect(api).not.toHaveProperty("require");
-    expect(api).not.toHaveProperty("process");
-    expect(api).not.toHaveProperty("fs");
-  });
-
-  it("invoke calls use correct channel names", async () => {
-    const { ipcRenderer } = await import("electron");
-    await import("../../src/preload/index");
-    const api = exposedApis.fileManager as Record<string, Function>;
-
-    await api.readDirectory("/test");
-    expect(ipcRenderer.invoke).toHaveBeenCalledWith("fs:readDirectory", "/test");
-
-    await api.readFile("/test/file.txt");
-    expect(ipcRenderer.invoke).toHaveBeenCalledWith("fs:readFile", "/test/file.txt");
-  });
-});
-```
-
-### BrowserWindow Security Test
-
-```typescript
-// tests/main/window-security.test.ts
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { BrowserWindow } from "electron";
-import { createMainWindow } from "../../src/main/window";
-
-vi.mock("electron", () => ({
-  BrowserWindow: vi.fn().mockImplementation((opts) => ({
-    webPreferences: opts.webPreferences,
-    loadURL: vi.fn(),
-    on: vi.fn(),
-  })),
-  app: { getPath: vi.fn(() => "/mock") },
-}));
-
-describe("BrowserWindow Security", () => {
-  it("enables contextIsolation", () => {
-    const win = createMainWindow();
-    expect(win.webPreferences.contextIsolation).toBe(true);
-  });
-
-  it("enables sandbox mode", () => {
-    const win = createMainWindow();
-    expect(win.webPreferences.sandbox).toBe(true);
-  });
-
-  it("disables nodeIntegration", () => {
-    const win = createMainWindow();
-    expect(win.webPreferences.nodeIntegration).toBe(false);
-  });
-
-  it("sets the correct preload script path", () => {
-    const win = createMainWindow();
-    expect(win.webPreferences.preload).toMatch(/preload/);
-  });
-});
-```
-
-## Key Decisions
-
-- **Typed IPC channel map** -- a shared `IpcChannelMap` interface validates both the main process handlers and preload invoke calls against the same type at compile time.
-- **Mocked `fs` module** -- isolates handler logic from the real file system. Tests run in milliseconds and never modify actual files.
-- **Path traversal test** -- IPC handlers that accept file paths must validate them to prevent renderer-side code from accessing files outside the allowed scope.
-- **`exposeInMainWorld` spy** -- captures what the preload script exposes, allowing the test to assert on the exact API surface without running Electron.
-- **Security assertions as tests** -- `contextIsolation`, `sandbox`, and `nodeIntegration` settings are verified in a test rather than in code review, preventing accidental drift.

package/workflows/workflows/agent-environment-setup/platforms/antigravity/skills/electron-qa/examples/01-ipc-testing-file-manager.md

@@ -1,317 +0,0 @@
-# Example: IPC Testing for an Electron File Manager
-
-This example demonstrates testing IPC channels, preload script security, and typed channel contracts for an Electron file manager application.
-
-## Scenario
-
-An Electron file manager with five IPC channels:
-- `file:readDirectory` — Renderer sends a directory path, main returns file listing
-- `file:read` — Renderer sends a file path, main returns file contents
-- `file:write` — Renderer sends path + content, main writes to disk
-- `file:delete` — Renderer sends a file path, main deletes the file
-- `file:watch` — Renderer subscribes to directory changes
-
-The app uses `contextIsolation: true` and `sandbox: true`.
-
-## Typed IPC Channel Contract
-
-```typescript
-// shared/ipc-channels.ts
-export interface IpcChannelMap {
-  'file:readDirectory': {
-    args: [dirPath: string];
-    return: FileEntry[];
-  };
-  'file:read': {
-    args: [filePath: string];
-    return: string;
-  };
-  'file:write': {
-    args: [filePath: string, content: string];
-    return: { success: boolean; bytesWritten: number };
-  };
-  'file:delete': {
-    args: [filePath: string];
-    return: { success: boolean };
-  };
-  'file:watch': {
-    args: [dirPath: string];
-    return: void;
-  };
-}
-
-export interface FileEntry {
-  name: string;
-  path: string;
-  isDirectory: boolean;
-  size: number;
-  modifiedAt: string;
-}
-```
-
-## Main Process IPC Handlers
-
-```typescript
-// main/ipc-handlers.ts
-import { ipcMain } from 'electron';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { FileEntry } from '../shared/ipc-channels';
-
-export function registerFileHandlers() {
-  ipcMain.handle('file:readDirectory', async (_event, dirPath: string): Promise<FileEntry[]> => {
-    const entries = await fs.readdir(dirPath, { withFileTypes: true });
-    return entries.map((entry) => ({
-      name: entry.name,
-      path: path.join(dirPath, entry.name),
-      isDirectory: entry.isDirectory(),
-      size: 0, // populated lazily
-      modifiedAt: new Date().toISOString(),
-    }));
-  });
-
-  ipcMain.handle('file:read', async (_event, filePath: string): Promise<string> => {
-    return fs.readFile(filePath, 'utf-8');
-  });
-
-  ipcMain.handle('file:write', async (_event, filePath: string, content: string) => {
-    await fs.writeFile(filePath, content, 'utf-8');
-    const stat = await fs.stat(filePath);
-    return { success: true, bytesWritten: stat.size };
-  });
-
-  ipcMain.handle('file:delete', async (_event, filePath: string) => {
-    await fs.unlink(filePath);
-    return { success: true };
-  });
-}
-```
-
-## Preload Script
-
-```typescript
-// preload/preload.ts
-import { contextBridge, ipcRenderer } from 'electron';
-
-contextBridge.exposeInMainWorld('electronAPI', {
-  readDirectory: (dirPath: string) => ipcRenderer.invoke('file:readDirectory', dirPath),
-  readFile: (filePath: string) => ipcRenderer.invoke('file:read', filePath),
-  writeFile: (filePath: string, content: string) =>
-    ipcRenderer.invoke('file:write', filePath, content),
-  deleteFile: (filePath: string) => ipcRenderer.invoke('file:delete', filePath),
-});
-```
-
-## IPC Handler Unit Tests
-
-```typescript
-// tests/unit/ipc-handlers.test.ts
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { ipcMain } from 'electron';
-import * as fs from 'fs/promises';
-
-// Mock electron and fs
-vi.mock('electron', () => ({
-  ipcMain: {
-    handle: vi.fn(),
-    removeHandler: vi.fn(),
-  },
-}));
-vi.mock('fs/promises');
-
-import { registerFileHandlers } from '../../main/ipc-handlers';
-
-describe('IPC File Handlers', () => {
-  let handlers: Map<string, Function>;
-
-  beforeEach(() => {
-    handlers = new Map();
-    vi.mocked(ipcMain.handle).mockImplementation((channel, handler) => {
-      handlers.set(channel, handler);
-    });
-    registerFileHandlers();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('file:readDirectory', () => {
-    it('returns file entries for a valid directory', async () => {
-      vi.mocked(fs.readdir).mockResolvedValue([
-        { name: 'readme.md', isDirectory: () => false },
-        { name: 'src', isDirectory: () => true },
-      ] as any);
-
-      const handler = handlers.get('file:readDirectory')!;
-      const result = await handler({}, '/home/user/project');
-
-      expect(result).toHaveLength(2);
-      expect(result[0].name).toBe('readme.md');
-      expect(result[0].isDirectory).toBe(false);
-      expect(result[1].name).toBe('src');
-      expect(result[1].isDirectory).toBe(true);
-    });
-
-    it('throws on non-existent directory', async () => {
-      vi.mocked(fs.readdir).mockRejectedValue(new Error('ENOENT'));
-
-      const handler = handlers.get('file:readDirectory')!;
-      await expect(handler({}, '/nonexistent')).rejects.toThrow('ENOENT');
-    });
-  });
-
-  describe('file:write', () => {
-    it('writes content and returns byte count', async () => {
-      vi.mocked(fs.writeFile).mockResolvedValue();
-      vi.mocked(fs.stat).mockResolvedValue({ size: 42 } as any);
-
-      const handler = handlers.get('file:write')!;
-      const result = await handler({}, '/tmp/test.txt', 'hello world');
-
-      expect(fs.writeFile).toHaveBeenCalledWith('/tmp/test.txt', 'hello world', 'utf-8');
-      expect(result).toEqual({ success: true, bytesWritten: 42 });
-    });
-  });
-
-  describe('file:delete', () => {
-    it('deletes the file and returns success', async () => {
-      vi.mocked(fs.unlink).mockResolvedValue();
-
-      const handler = handlers.get('file:delete')!;
-      const result = await handler({}, '/tmp/test.txt');
-
-      expect(fs.unlink).toHaveBeenCalledWith('/tmp/test.txt');
-      expect(result).toEqual({ success: true });
-    });
-
-    it('propagates error for permission denied', async () => {
-      vi.mocked(fs.unlink).mockRejectedValue(new Error('EACCES'));
-
-      const handler = handlers.get('file:delete')!;
-      await expect(handler({}, '/root/protected')).rejects.toThrow('EACCES');
-    });
-  });
-});
-```
-
-## Preload Security Tests
-
-```typescript
-// tests/unit/preload-security.test.ts
-import { describe, it, expect, vi } from 'vitest';
-
-// Verify that the preload script exposes only the intended API
-describe('Preload Script Security', () => {
-  it('exposes exactly the expected API methods', () => {
-    const exposedApi: Record<string, Function> = {};
-    const mockContextBridge = {
-      exposeInMainWorld: vi.fn((key: string, api: any) => {
-        exposedApi[key] = api;
-      }),
-    };
-    const mockIpcRenderer = {
-      invoke: vi.fn(),
-      send: vi.fn(),
-      on: vi.fn(),
-    };
-
-    vi.doMock('electron', () => ({
-      contextBridge: mockContextBridge,
-      ipcRenderer: mockIpcRenderer,
-    }));
-
-    // Load preload script
-    require('../../preload/preload');
-
-    // Verify only 'electronAPI' is exposed
-    expect(mockContextBridge.exposeInMainWorld).toHaveBeenCalledTimes(1);
-    expect(mockContextBridge.exposeInMainWorld).toHaveBeenCalledWith(
-      'electronAPI',
-      expect.any(Object)
-    );
-
-    // Verify exposed methods
-    const api = mockContextBridge.exposeInMainWorld.mock.calls[0][1];
-    const exposedMethods = Object.keys(api);
-    expect(exposedMethods).toEqual([
-      'readDirectory',
-      'readFile',
-      'writeFile',
-      'deleteFile',
-    ]);
-
-    // Verify no direct access to ipcRenderer.send or ipcRenderer.on
-    expect(api.send).toBeUndefined();
-    expect(api.on).toBeUndefined();
-    expect(api.ipcRenderer).toBeUndefined();
-  });
-});
-```
-
-## E2E Test with Playwright
-
-```typescript
-// tests/e2e/file-manager.spec.ts
-import { test, expect, _electron as electron } from '@playwright/test';
-import * as path from 'path';
-import * as fs from 'fs';
-import * as os from 'os';
-
-let app: Awaited<ReturnType<typeof electron.launch>>;
-let page: Awaited<ReturnType<typeof app.firstWindow>>;
-
-test.beforeAll(async () => {
-  app = await electron.launch({
-    args: [path.join(__dirname, '../../main/index.js')],
-    env: { ...process.env, NODE_ENV: 'test' },
-  });
-  page = await app.firstWindow();
-});
-
-test.afterAll(async () => {
-  await app.close();
-});
-
-test.describe('File Manager E2E', () => {
-  test('reads a directory and displays files', async () => {
-    const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'fm-test-'));
-    fs.writeFileSync(path.join(testDir, 'test.txt'), 'hello');
-
-    // Type directory path into the location bar
-    await page.getByLabel('Location').fill(testDir);
-    await page.getByRole('button', { name: 'Go' }).click();
-
-    // Verify file appears in the listing
-    await expect(page.getByText('test.txt')).toBeVisible();
-
-    // Cleanup
-    fs.rmSync(testDir, { recursive: true });
-  });
-
-  test('verifies contextIsolation is enabled', async () => {
-    const contextIsolation = await app.evaluate(({ BrowserWindow }) => {
-      const win = BrowserWindow.getAllWindows()[0];
-      return win.webContents.getLastWebPreferences().contextIsolation;
-    });
-
-    expect(contextIsolation).toBe(true);
-  });
-
-  test('verifies sandbox is enabled', async () => {
-    const sandbox = await app.evaluate(({ BrowserWindow }) => {
-      const win = BrowserWindow.getAllWindows()[0];
-      return win.webContents.getLastWebPreferences().sandbox;
-    });
-
-    expect(sandbox).toBe(true);
-  });
-});
-```
-
-## Key Takeaways
-
-- IPC handlers are tested in isolation by extracting the handler functions and calling them directly
-- The preload security test verifies the API surface area — what is exposed matters as much as what is not exposed
-- E2E tests use `app.evaluate()` to inspect main process state (webPreferences) from test code
-- Typed IPC channel contracts catch interface drift at compile time