Skip unrelated required checks without losing their names (#2542)
* fix(ci): skip unrelated required checks cleanly Matrix jobs had to start no-op runners to preserve interpolated required-check names. Static named jobs let GitHub report genuine skipped conclusions while keeping those names stable. * fix(ci): gate changes to install patching script * fix(ci): route cross-package test contracts narrowly * fix(ci): keep routed contracts merge-blocking * fix(server): exclude nested test utilities from builds * fix(ci): cover app-owned native and browser domains * refactor(ci): align tests with runtime domains Own browser specs, desktop specs, and Electron-only app code by stable directories so PR routing does not depend on filename conventions. Keep desktop integration coverage inside the required desktop check. * fix(ci): keep routing and desktop suites isolated The routing regression must run before dependency installation, and desktop Vitest must not collect Playwright-owned specs. * fix(ci): isolate desktop e2e runtime * perf(test): isolate Playwright workers * perf(test): parallelize Playwright within specs * fix(test): keep Playwright file scheduling * fix(test): share dynamic Metro fixture * fix(test): preserve own-host restart fixtures * fix(ci): preserve routed contracts after rebase * Stabilize Playwright wheel-scroll assertions
This commit is contained in:
Mohamed Boudra
@@ -0,0 +1,423 @@
|
||||
import { readFileSync } from "node:fs";
|
||||
import { appendFile } from "node:fs/promises";
|
||||
import { expect, type Page } from "@playwright/test";
|
||||
import { openSettings } from "../../../app/e2e/support/helpers/app";
|
||||
import { getE2EDaemonPort } from "../../../app/e2e/support/helpers/daemon-port";
|
||||
import { escapeRegex } from "../../../app/e2e/support/helpers/regex";
|
||||
import {
|
||||
openSettingsHost,
|
||||
openSettingsHostSection,
|
||||
openSettingsSection,
|
||||
} from "../../../app/e2e/support/helpers/settings";
|
||||
|
||||
interface DaemonApiStatus {
|
||||
version: string;
|
||||
serverId: string;
|
||||
hostname: string;
|
||||
}
|
||||
|
||||
interface PidFileContent {
|
||||
pid: number;
|
||||
desktopManaged: boolean;
|
||||
}
|
||||
|
||||
export interface RealDaemonState {
|
||||
version: string;
|
||||
pid: number | null;
|
||||
logPath: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads live state from the running E2E test daemon: version from the HTTP
|
||||
* status endpoint, PID from the paseo.pid lock file, log path from the
|
||||
* E2E_PASEO_HOME directory. Call this in Node test code (not in the browser).
|
||||
*/
|
||||
export async function loadRealDaemonState(): Promise<RealDaemonState> {
|
||||
const port = getE2EDaemonPort();
|
||||
const paseoHome = process.env.E2E_PASEO_HOME;
|
||||
if (!paseoHome) throw new Error("E2E_PASEO_HOME not set — the worker fixture must run first");
|
||||
|
||||
const resp = await fetch(`http://127.0.0.1:${port}/api/status`);
|
||||
const data: DaemonApiStatus = await resp.json();
|
||||
|
||||
let pid: number | null = null;
|
||||
try {
|
||||
const raw = readFileSync(`${paseoHome}/paseo.pid`, "utf8");
|
||||
const pidContent: PidFileContent = JSON.parse(raw);
|
||||
pid = pidContent.pid ?? null;
|
||||
} catch (err) {
|
||||
// PID file may not be present yet on a very fresh daemon start
|
||||
console.warn("[desktop-updates] paseo.pid not found:", err);
|
||||
}
|
||||
|
||||
return { version: data.version, pid, logPath: `${paseoHome}/daemon.log` };
|
||||
}
|
||||
|
||||
export interface DesktopRuntimeConfig {
|
||||
serverId: string;
|
||||
updateAvailable?: boolean;
|
||||
latestVersion?: string;
|
||||
updateReadyToInstall?: boolean;
|
||||
slowInstall?: boolean;
|
||||
/** Initial PID reported by desktop_daemon_status. Defaults to null. */
|
||||
daemonPid?: number | null;
|
||||
daemonVersion?: string | null;
|
||||
daemonLogPath?: string;
|
||||
/** Initial manageBuiltInDaemon setting. Defaults to false. */
|
||||
manageBuiltInDaemon?: boolean;
|
||||
/** Daemon listen address reported by desktop_daemon_status. Defaults to 127.0.0.1:6767. */
|
||||
daemonListen?: string;
|
||||
/** Keep start_desktop_daemon pending to hold the desktop startup blocker open. */
|
||||
hangDaemonStart?: boolean;
|
||||
/** Delay the desktop settings IPC response to exercise startup ordering. */
|
||||
desktopSettingsDelayMs?: number;
|
||||
/**
|
||||
* Controls what dialog.ask returns when the daemon management confirm dialog
|
||||
* fires. True = confirm (proceed with the action), false = cancel. Defaults to
|
||||
* false so tests that only assert copy don't inadvertently trigger state changes.
|
||||
*/
|
||||
confirmShouldAccept?: boolean;
|
||||
dialogOpenResult?: string | string[] | null;
|
||||
editorTargets?: DesktopEditorTargetConfig[];
|
||||
editorRecordPath?: string;
|
||||
}
|
||||
|
||||
interface DesktopEditorTargetConfig {
|
||||
id: string;
|
||||
label: string;
|
||||
kind: "editor" | "file-manager";
|
||||
icon: { kind: "image"; dataUrl: string } | { kind: "symbol"; name: "folder" | "terminal" };
|
||||
}
|
||||
|
||||
interface DesktopEditorOpenRecord {
|
||||
editorId: string;
|
||||
workspacePath: string;
|
||||
filePath?: string;
|
||||
line?: number;
|
||||
column?: number;
|
||||
}
|
||||
|
||||
export interface ConfirmDialogCall {
|
||||
message: string;
|
||||
title: string | undefined;
|
||||
}
|
||||
|
||||
declare global {
|
||||
interface Window {
|
||||
__capturedDialogCall: ConfirmDialogCall | undefined;
|
||||
__capturedDialogOpenCalls: Array<Record<string, unknown> | undefined>;
|
||||
__recordDesktopEditorOpen?: (input: DesktopEditorOpenRecord) => Promise<void>;
|
||||
__desktopDaemonStartRequested?: boolean;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Injects window.paseoDesktop before app load so all Electron-gated code
|
||||
* activates. The update-check IPC is mocked at the boundary so the real
|
||||
* auto-updater never fires. Daemon start/stop commands are stateful: the mock
|
||||
* tracks running state and assigns a fresh PID on each start, letting tests
|
||||
* observe PID changes without touching the real E2E daemon process.
|
||||
* dialog.ask captures call arguments on window.__capturedDialogCall so tests
|
||||
* can assert dialog copy without depending on window.confirm concatenation.
|
||||
*/
|
||||
export async function installDesktopRuntime(
|
||||
page: Page,
|
||||
config: DesktopRuntimeConfig,
|
||||
): Promise<void> {
|
||||
if (config.editorRecordPath) {
|
||||
await page.exposeFunction(
|
||||
"__recordDesktopEditorOpen",
|
||||
async (input: DesktopEditorOpenRecord) => {
|
||||
await appendFile(config.editorRecordPath as string, `${JSON.stringify(input)}\n`, "utf8");
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
await page.addInitScript((cfg) => {
|
||||
// Mutable state shared across IPC calls within this page
|
||||
let manageDaemon = cfg.manageBuiltInDaemon ?? false;
|
||||
let daemonRunning = true;
|
||||
let currentPid: number | null = cfg.daemonPid ?? null;
|
||||
let startCount = 0;
|
||||
window.__desktopDaemonStartRequested = false;
|
||||
|
||||
function buildDaemonStatus() {
|
||||
return {
|
||||
serverId: cfg.serverId,
|
||||
status: daemonRunning ? "running" : "stopped",
|
||||
listen: cfg.daemonListen ?? "127.0.0.1:6767",
|
||||
hostname: null,
|
||||
pid: currentPid,
|
||||
home: "",
|
||||
version: cfg.daemonVersion ?? null,
|
||||
desktopManaged: manageDaemon,
|
||||
error: null,
|
||||
};
|
||||
}
|
||||
|
||||
function startDesktopDaemon() {
|
||||
window.__desktopDaemonStartRequested = true;
|
||||
if (cfg.hangDaemonStart) {
|
||||
return new Promise(() => undefined);
|
||||
}
|
||||
startCount += 1;
|
||||
daemonRunning = true;
|
||||
// First start (bootstrap) returns the configured PID; subsequent starts
|
||||
// (after a stop) get a fresh PID so tests can observe the change.
|
||||
currentPid = (cfg.daemonPid ?? 10000) + (startCount - 1) * 1000;
|
||||
return buildDaemonStatus();
|
||||
}
|
||||
|
||||
async function waitForDesktopSettingsResponse() {
|
||||
const delayMs = cfg.desktopSettingsDelayMs ?? 0;
|
||||
if (delayMs > 0) {
|
||||
await new Promise<void>((resolve) => setTimeout(resolve, delayMs));
|
||||
}
|
||||
}
|
||||
|
||||
const desktopBridge: {
|
||||
platform: string;
|
||||
invoke: (command: string, args?: Record<string, unknown>) => Promise<unknown>;
|
||||
dialog: {
|
||||
ask: (message: string, options?: Record<string, unknown>) => Promise<boolean>;
|
||||
open: (options?: Record<string, unknown>) => Promise<string | string[] | null>;
|
||||
};
|
||||
getPendingOpenProject: () => Promise<string | null>;
|
||||
events: { on: () => Promise<() => void> };
|
||||
editor?: {
|
||||
listTargets: () => Promise<DesktopEditorTargetConfig[]>;
|
||||
openTarget: (input: DesktopEditorOpenRecord) => Promise<void>;
|
||||
};
|
||||
} = {
|
||||
platform: "darwin",
|
||||
invoke: async (command: string, args?: Record<string, unknown>) => {
|
||||
if (command === "check_app_update") {
|
||||
return cfg.updateAvailable
|
||||
? {
|
||||
hasUpdate: true,
|
||||
readyToInstall: cfg.updateReadyToInstall ?? true,
|
||||
currentVersion: "1.0.0",
|
||||
latestVersion: cfg.latestVersion ?? "1.2.3",
|
||||
body: null,
|
||||
date: null,
|
||||
}
|
||||
: {
|
||||
hasUpdate: false,
|
||||
readyToInstall: false,
|
||||
currentVersion: "1.0.0",
|
||||
latestVersion: null,
|
||||
body: null,
|
||||
date: null,
|
||||
};
|
||||
}
|
||||
|
||||
if (command === "install_app_update") {
|
||||
if (cfg.slowInstall) {
|
||||
await new Promise<void>((resolve) => setTimeout(resolve, 3000));
|
||||
}
|
||||
return {
|
||||
installed: true,
|
||||
version: cfg.latestVersion ?? "1.2.3",
|
||||
message: "App update installed. Restart required.",
|
||||
};
|
||||
}
|
||||
|
||||
if (command === "desktop_daemon_status") {
|
||||
return buildDaemonStatus();
|
||||
}
|
||||
|
||||
if (command === "desktop_daemon_logs") {
|
||||
return { logPath: cfg.daemonLogPath ?? "", contents: "" };
|
||||
}
|
||||
|
||||
if (command === "get_desktop_settings") {
|
||||
await waitForDesktopSettingsResponse();
|
||||
return {
|
||||
releaseChannel: "stable",
|
||||
daemon: { manageBuiltInDaemon: manageDaemon, keepRunningAfterQuit: true },
|
||||
};
|
||||
}
|
||||
|
||||
if (command === "patch_desktop_settings") {
|
||||
const daemon = args?.daemon;
|
||||
if (
|
||||
daemon !== null &&
|
||||
typeof daemon === "object" &&
|
||||
"manageBuiltInDaemon" in daemon &&
|
||||
typeof daemon.manageBuiltInDaemon === "boolean"
|
||||
) {
|
||||
manageDaemon = daemon.manageBuiltInDaemon;
|
||||
}
|
||||
return {
|
||||
releaseChannel: "stable",
|
||||
daemon: { manageBuiltInDaemon: manageDaemon, keepRunningAfterQuit: true },
|
||||
};
|
||||
}
|
||||
|
||||
if (command === "stop_desktop_daemon") {
|
||||
daemonRunning = false;
|
||||
currentPid = null;
|
||||
return buildDaemonStatus();
|
||||
}
|
||||
|
||||
if (command === "start_desktop_daemon") {
|
||||
return startDesktopDaemon();
|
||||
}
|
||||
|
||||
return null;
|
||||
},
|
||||
dialog: {
|
||||
ask: async (message: string, options?: Record<string, unknown>) => {
|
||||
window.__capturedDialogCall = {
|
||||
message,
|
||||
title: typeof options?.title === "string" ? options.title : undefined,
|
||||
};
|
||||
return cfg.confirmShouldAccept ?? false;
|
||||
},
|
||||
open: async (options?: Record<string, unknown>) => {
|
||||
window.__capturedDialogOpenCalls.push(options);
|
||||
return cfg.dialogOpenResult ?? null;
|
||||
},
|
||||
},
|
||||
getPendingOpenProject: async () => null,
|
||||
events: { on: async () => () => undefined },
|
||||
};
|
||||
|
||||
if (cfg.editorTargets) {
|
||||
desktopBridge.editor = {
|
||||
listTargets: async () => cfg.editorTargets ?? [],
|
||||
openTarget: async (input: DesktopEditorOpenRecord) => {
|
||||
await window.__recordDesktopEditorOpen?.(input);
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
window.__capturedDialogOpenCalls = [];
|
||||
(window as unknown as { paseoDesktop: unknown }).paseoDesktop = desktopBridge;
|
||||
}, config);
|
||||
}
|
||||
|
||||
export async function waitForDesktopDaemonStartRequest(page: Page): Promise<void> {
|
||||
await page.waitForFunction(() => window.__desktopDaemonStartRequested === true);
|
||||
// Give the startup state two paints to expose any app → splash regression.
|
||||
await page.evaluate(
|
||||
() =>
|
||||
new Promise<void>((resolve) =>
|
||||
requestAnimationFrame(() => requestAnimationFrame(() => resolve())),
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
export async function waitForDirectoryDialog(
|
||||
page: Page,
|
||||
): Promise<Record<string, unknown> | undefined> {
|
||||
await expect.poll(() => page.evaluate(() => window.__capturedDialogOpenCalls.length)).toBe(1);
|
||||
return page.evaluate(() => window.__capturedDialogOpenCalls[0]);
|
||||
}
|
||||
|
||||
export async function openDesktopSettings(page: Page, serverId: string): Promise<void> {
|
||||
await openSettings(page);
|
||||
await openSettingsHost(page, serverId);
|
||||
// The daemon-lifecycle card moved to the Host section in the flat-settings
|
||||
// layout; navigate there before asserting it.
|
||||
await openSettingsHostSection(page, serverId, "host");
|
||||
await expect(page.getByTestId("host-page-daemon-lifecycle-card")).toBeVisible({
|
||||
timeout: 15_000,
|
||||
});
|
||||
}
|
||||
|
||||
export async function openDesktopAboutSettings(page: Page): Promise<void> {
|
||||
await openSettings(page);
|
||||
await openSettingsSection(page, "about");
|
||||
await expect(page.getByText("App updates", { exact: true })).toBeVisible();
|
||||
}
|
||||
|
||||
export async function expectUpdateBanner(page: Page, version: string): Promise<void> {
|
||||
const callout = page.getByTestId("update-callout");
|
||||
await expect(callout).toBeVisible({ timeout: 15_000 });
|
||||
await expect(callout).toContainText(`v${version.replace(/^v/i, "")}`);
|
||||
}
|
||||
|
||||
export async function clickCheckForUpdates(page: Page): Promise<void> {
|
||||
await page.getByRole("button", { name: "Check" }).click();
|
||||
}
|
||||
|
||||
export async function expectPendingUpdateCheckResult(page: Page, version: string): Promise<void> {
|
||||
const normalizedVersion = `v${version.replace(/^v/i, "")}`;
|
||||
await expect(
|
||||
page.getByText(
|
||||
new RegExp(`Update found: ${escapeRegex(normalizedVersion)}\\. Downloading\\.\\.\\.`),
|
||||
),
|
||||
).toBeVisible();
|
||||
await expect(page.getByText(`Ready to install: ${normalizedVersion}`)).toHaveCount(0);
|
||||
await expect(page.getByRole("button", { name: "Update" })).toBeDisabled();
|
||||
}
|
||||
|
||||
export async function clickInstallUpdate(page: Page): Promise<void> {
|
||||
await page.getByRole("button", { name: "Install & restart" }).click();
|
||||
}
|
||||
|
||||
export async function expectInstallInProgress(page: Page): Promise<void> {
|
||||
await expect(page.getByRole("button", { name: "Installing..." })).toBeVisible();
|
||||
}
|
||||
|
||||
/**
|
||||
* Clicks the daemon management switch and waits for dialog.ask to fire in the
|
||||
* mock, then returns the captured call args (message + title). The mock auto-
|
||||
* dismisses via confirmShouldAccept=false so callers can assert copy without
|
||||
* worrying about state changes.
|
||||
*/
|
||||
export async function interceptDaemonManagementConfirmDialog(
|
||||
page: Page,
|
||||
): Promise<ConfirmDialogCall> {
|
||||
await page.getByRole("switch", { name: "Manage built-in daemon" }).click();
|
||||
await page.waitForFunction(() => !!window.__capturedDialogCall, { timeout: 5_000 });
|
||||
return page.evaluate(() => window.__capturedDialogCall!);
|
||||
}
|
||||
|
||||
export async function toggleDaemonManagement(
|
||||
page: Page,
|
||||
_action: "enable" | "disable",
|
||||
): Promise<void> {
|
||||
await page.getByRole("switch", { name: "Manage built-in daemon" }).click();
|
||||
}
|
||||
|
||||
export function expectDaemonManagementConfirmDialog(args: ConfirmDialogCall): void {
|
||||
expect(args.title).toBe("Pause built-in daemon");
|
||||
expect(args.message).toContain("stop the built-in daemon immediately");
|
||||
}
|
||||
|
||||
export async function expectDaemonManagementEnabled(page: Page): Promise<void> {
|
||||
await expect(page.getByRole("switch", { name: "Manage built-in daemon" })).toBeChecked();
|
||||
}
|
||||
|
||||
export async function expectDaemonManagementDisabled(page: Page): Promise<void> {
|
||||
await expect(page.getByRole("switch", { name: "Manage built-in daemon" })).not.toBeChecked();
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts the daemon status card shows the given PID. Pass null to assert
|
||||
* the cleared state (shown as "PID —" when the daemon is stopped).
|
||||
*/
|
||||
export async function expectDaemonStatusPid(page: Page, pid: number | null): Promise<void> {
|
||||
const expected = pid !== null ? `PID ${pid}` : "PID —";
|
||||
await expect(
|
||||
page.getByTestId("host-page-daemon-lifecycle-card").getByText(expected),
|
||||
).toBeVisible();
|
||||
}
|
||||
|
||||
export async function expectDaemonStatusLogPath(page: Page, logPath: string): Promise<void> {
|
||||
await expect(
|
||||
page.getByTestId("host-page-daemon-lifecycle-card").getByText(logPath),
|
||||
).toBeVisible();
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts the host page identity badge shows the given version string.
|
||||
* The badge is populated from the live WebSocket session's serverInfo.version.
|
||||
*/
|
||||
export async function expectDaemonStatusVersion(page: Page, version: string): Promise<void> {
|
||||
await expect(
|
||||
page.getByTestId("host-page-identity").getByText(version, { exact: false }),
|
||||
).toBeVisible({ timeout: 15_000 });
|
||||
}
|
||||
@@ -0,0 +1,410 @@
|
||||
import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
|
||||
import os from "node:os";
|
||||
import path from "node:path";
|
||||
import { expect, type Page } from "@playwright/test";
|
||||
import { buildOpenProjectRoute } from "../../../app/src/utils/host-routes";
|
||||
import { openSettings } from "../../../app/e2e/support/helpers/app";
|
||||
import { installDesktopRuntime } from "./runtime";
|
||||
import { getServerId } from "../../../app/e2e/support/helpers/server-id";
|
||||
import {
|
||||
openCompactSettings,
|
||||
openSettingsSection,
|
||||
} from "../../../app/e2e/support/helpers/settings";
|
||||
// The desktop skills module is the real command surface: the same handlers the
|
||||
// Electron main process registers, running against a temp bundle and temp user
|
||||
// data. Nothing about persistence or convergence is simulated in the browser.
|
||||
import type { SkillSelection, SkillTargets } from "../../src/integrations/skills/operations.js";
|
||||
import { createSkillSelectionStore } from "../../src/integrations/skills/selection-store.js";
|
||||
import { createSkillsCommandHandlers } from "../../src/integrations/skills/skills-commands.js";
|
||||
import { createSkillsController } from "../../src/integrations/skills/skills-controller.js";
|
||||
|
||||
const SKILL_COMMANDS = [
|
||||
"get_skills_status",
|
||||
"install_skills",
|
||||
"update_skills",
|
||||
"uninstall_skills",
|
||||
"save_skills_selection",
|
||||
] as const;
|
||||
|
||||
declare global {
|
||||
interface Window {
|
||||
__paseoSkillsInvoke?: (
|
||||
command: string,
|
||||
args: Record<string, unknown> | null,
|
||||
) => Promise<unknown>;
|
||||
}
|
||||
}
|
||||
|
||||
export interface SkillsSandbox {
|
||||
targets: SkillTargets;
|
||||
userDataPath: string;
|
||||
bundledSkills: string[];
|
||||
/** Writes a managed skill directory the way an external tool would. */
|
||||
placeSkillOnDisk: (skill: string, target: SkillTargetName) => Promise<void>;
|
||||
/** Commits a selection through the real controller, as another window would. */
|
||||
commitSelectionExternally: (
|
||||
selection: SkillSelection,
|
||||
confirmedRemovals?: readonly string[],
|
||||
) => Promise<void>;
|
||||
/** Waits until a held save reaches the desktop command boundary. */
|
||||
waitForHeldSave: () => Promise<void>;
|
||||
/** Releases a save held at the desktop command boundary. */
|
||||
releaseHeldSave: () => void;
|
||||
/** Test-only command-boundary gate used to keep the renderer in its pending state. */
|
||||
holdSaveResponse?: () => Promise<void>;
|
||||
cleanup: () => Promise<void>;
|
||||
}
|
||||
|
||||
export interface SkillsSandboxOptions {
|
||||
bundledSkills?: string[];
|
||||
/**
|
||||
* Puts a regular file where the `.agents` skills tree has to go, so the real
|
||||
* convergence fails with ENOTDIR instead of a stubbed rejection.
|
||||
*/
|
||||
blockAgentsDir?: boolean;
|
||||
/** Converge and commit this selection before the app loads, through the real controller. */
|
||||
installed?: SkillSelection;
|
||||
/**
|
||||
* Leaves a skill installed in one agent home only, the way a partial install
|
||||
* or a hand-deleted directory leaves it.
|
||||
*/
|
||||
keepOnlyIn?: { skill: string; target: SkillTargetName };
|
||||
/**
|
||||
* Writes a skill directory straight into one agent home after the selection is
|
||||
* committed, the way a manual reinstall or an external sync leaves a directory
|
||||
* the saved preference does not mention.
|
||||
*/
|
||||
placeOnDisk?: { skill: string; target: SkillTargetName; files: Record<string, string> };
|
||||
/** Holds the save response so dismissal behavior can be asserted while pending. */
|
||||
holdSave?: boolean;
|
||||
}
|
||||
|
||||
export type SkillTargetName = "agents" | "claude" | "codex";
|
||||
|
||||
function targetDir(targets: SkillTargets, target: SkillTargetName): string {
|
||||
if (target === "agents") return targets.agentsDir;
|
||||
if (target === "claude") return targets.claudeDir;
|
||||
return targets.codexDir;
|
||||
}
|
||||
|
||||
export async function createSkillsSandbox(
|
||||
options: SkillsSandboxOptions = {},
|
||||
): Promise<SkillsSandbox> {
|
||||
let releaseHeldSave: (() => void) | null = null;
|
||||
let markSaveHeld: (() => void) | null = null;
|
||||
const heldSave = new Promise<void>((resolve) => {
|
||||
markSaveHeld = resolve;
|
||||
});
|
||||
const saveRelease = new Promise<void>((resolve) => {
|
||||
releaseHeldSave = resolve;
|
||||
});
|
||||
const bundledSkills = options.bundledSkills ?? ["paseo", "paseo-advisor", "paseo-loop"];
|
||||
const root = await mkdtemp(path.join(os.tmpdir(), "paseo-e2e-skills-"));
|
||||
const targets: SkillTargets = {
|
||||
sourceDir: path.join(root, "bundle"),
|
||||
agentsDir: path.join(root, "home", ".agents", "skills"),
|
||||
claudeDir: path.join(root, "home", ".claude", "skills"),
|
||||
codexDir: path.join(root, "home", ".codex", "skills"),
|
||||
};
|
||||
|
||||
for (const name of bundledSkills) {
|
||||
await mkdir(path.join(targets.sourceDir, name), { recursive: true });
|
||||
await writeFile(path.join(targets.sourceDir, name, "SKILL.md"), `# ${name}\n`, "utf8");
|
||||
}
|
||||
|
||||
const userDataPath = path.join(root, "user-data");
|
||||
if (options.installed) {
|
||||
await createSkillsController({
|
||||
resolveTargets: () => targets,
|
||||
selectionStore: createSkillSelectionStore({ userDataPath }),
|
||||
}).save(options.installed);
|
||||
}
|
||||
|
||||
if (options.keepOnlyIn) {
|
||||
const kept = targetDir(targets, options.keepOnlyIn.target);
|
||||
for (const dir of [targets.agentsDir, targets.claudeDir, targets.codexDir]) {
|
||||
if (dir === kept) continue;
|
||||
await rm(path.join(dir, options.keepOnlyIn.skill), { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
|
||||
if (options.placeOnDisk) {
|
||||
const dir = path.join(
|
||||
targetDir(targets, options.placeOnDisk.target),
|
||||
options.placeOnDisk.skill,
|
||||
);
|
||||
for (const [rel, contents] of Object.entries(options.placeOnDisk.files)) {
|
||||
const file = path.join(dir, rel);
|
||||
await mkdir(path.dirname(file), { recursive: true });
|
||||
await writeFile(file, contents, "utf8");
|
||||
}
|
||||
}
|
||||
|
||||
if (options.blockAgentsDir) {
|
||||
await mkdir(path.dirname(targets.agentsDir), { recursive: true });
|
||||
await writeFile(targets.agentsDir, "not a directory", "utf8");
|
||||
}
|
||||
|
||||
return {
|
||||
targets,
|
||||
userDataPath,
|
||||
bundledSkills,
|
||||
placeSkillOnDisk: async (skill, target) => {
|
||||
const dir = path.join(targetDir(targets, target), skill);
|
||||
await mkdir(dir, { recursive: true });
|
||||
await writeFile(path.join(dir, "SKILL.md"), `# ${skill}\n`, "utf8");
|
||||
},
|
||||
commitSelectionExternally: async (selection, confirmedRemovals = []) => {
|
||||
await createSkillsController({
|
||||
resolveTargets: () => targets,
|
||||
selectionStore: createSkillSelectionStore({ userDataPath }),
|
||||
}).save({ ...selection, confirmedRemovals: [...confirmedRemovals] });
|
||||
},
|
||||
waitForHeldSave: () => heldSave,
|
||||
releaseHeldSave: () => releaseHeldSave?.(),
|
||||
holdSaveResponse: options.holdSave
|
||||
? async () => {
|
||||
markSaveHeld?.();
|
||||
await saveRelease;
|
||||
}
|
||||
: undefined,
|
||||
// The save path atomically renames skill directories. On Linux/overlayfs,
|
||||
// recursive removal can briefly observe a repopulated directory and fail
|
||||
// with ENOTEMPTY even after the command has completed. Node only retries
|
||||
// that transient when maxRetries is set.
|
||||
cleanup: () => rm(root, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }),
|
||||
};
|
||||
}
|
||||
|
||||
/** Reads the committed selection back through the same store the app writes. */
|
||||
export async function expectSavedSkillSelection(
|
||||
sandbox: SkillsSandbox,
|
||||
expected: SkillSelection,
|
||||
): Promise<void> {
|
||||
const store = createSkillSelectionStore({ userDataPath: sandbox.userDataPath });
|
||||
await expect.poll(() => store.get(), { timeout: 15_000 }).toEqual(expected);
|
||||
}
|
||||
|
||||
/**
|
||||
* Routes the skills desktop commands to the real handlers in Node, leaving every
|
||||
* other command on the injected desktop bridge. Call after `installDesktopRuntime`
|
||||
* and before navigation.
|
||||
*/
|
||||
export async function serveRealSkillsCommands(page: Page, sandbox: SkillsSandbox): Promise<void> {
|
||||
const handlers = createSkillsCommandHandlers({
|
||||
controller: createSkillsController({
|
||||
resolveTargets: () => sandbox.targets,
|
||||
selectionStore: createSkillSelectionStore({ userDataPath: sandbox.userDataPath }),
|
||||
}),
|
||||
});
|
||||
|
||||
await page.exposeFunction(
|
||||
"__paseoSkillsInvoke",
|
||||
async (command: string, args: Record<string, unknown> | null) => {
|
||||
const handler = handlers[command];
|
||||
if (!handler) throw new Error(`Unknown skills command: ${command}`);
|
||||
const result = await handler(args ?? undefined);
|
||||
if (command === "save_skills_selection") {
|
||||
await sandbox.holdSaveResponse?.();
|
||||
}
|
||||
return result;
|
||||
},
|
||||
);
|
||||
|
||||
await page.addInitScript((commands: readonly string[]) => {
|
||||
const bridge = (window as unknown as { paseoDesktop?: { invoke: unknown } }).paseoDesktop;
|
||||
if (!bridge) throw new Error("Desktop bridge must be injected before the skills bridge.");
|
||||
const skillCommands = new Set(commands);
|
||||
const inner = bridge.invoke as (
|
||||
command: string,
|
||||
args?: Record<string, unknown>,
|
||||
) => Promise<unknown>;
|
||||
bridge.invoke = (command: string, args?: Record<string, unknown>) =>
|
||||
skillCommands.has(command)
|
||||
? window.__paseoSkillsInvoke!(command, args ?? null)
|
||||
: inner(command, args);
|
||||
}, SKILL_COMMANDS);
|
||||
}
|
||||
|
||||
/** Real skills commands over a temp bundle, wired to this page's desktop bridge. */
|
||||
export async function startSkillsSandbox(
|
||||
page: Page,
|
||||
options: SkillsSandboxOptions = {},
|
||||
): Promise<SkillsSandbox> {
|
||||
const sandbox = await createSkillsSandbox(options);
|
||||
await installDesktopRuntime(page, { serverId: getServerId(), confirmShouldAccept: false });
|
||||
await serveRealSkillsCommands(page, sandbox);
|
||||
return sandbox;
|
||||
}
|
||||
|
||||
export async function openSkillsIntegrations(page: Page): Promise<void> {
|
||||
await openSettings(page);
|
||||
await openSettingsSection(page, "integrations");
|
||||
await expect(page.getByText("Orchestration skills", { exact: true })).toBeVisible();
|
||||
}
|
||||
|
||||
/** Settings on a compact form factor stacks list and detail, so it needs the menu first. */
|
||||
export async function openCompactSkillsIntegrations(page: Page): Promise<void> {
|
||||
await openCompactSettings(page, buildOpenProjectRoute());
|
||||
await openSettingsSection(page, "integrations");
|
||||
await expect(page.getByText("Orchestration skills", { exact: true })).toBeVisible();
|
||||
}
|
||||
|
||||
export async function openSkillSelection(page: Page): Promise<void> {
|
||||
await page.getByRole("button", { name: "Choose skills", exact: true }).click();
|
||||
await expectSkillSelectionOpen(page);
|
||||
}
|
||||
|
||||
export async function expectSkillSelectionOpen(page: Page): Promise<void> {
|
||||
await expect(page.getByRole("switch", { name: "All skills", exact: true })).toBeVisible();
|
||||
}
|
||||
|
||||
export async function expectSkillSelectionClosed(page: Page): Promise<void> {
|
||||
await expect(page.getByRole("switch", { name: "All skills", exact: true })).toHaveCount(0);
|
||||
}
|
||||
|
||||
export async function chooseAllSkills(page: Page): Promise<void> {
|
||||
const allSkills = page.getByRole("switch", { name: "All skills", exact: true });
|
||||
await expect(allSkills).not.toBeChecked();
|
||||
await allSkills.click();
|
||||
await expect(allSkills).toBeChecked();
|
||||
}
|
||||
|
||||
export async function chooseCustomSkills(page: Page, skills: string[]): Promise<void> {
|
||||
const allSkills = page.getByRole("switch", { name: "All skills", exact: true });
|
||||
await expect(allSkills).toBeChecked();
|
||||
await allSkills.click();
|
||||
await expect(allSkills).not.toBeChecked();
|
||||
|
||||
const keep = new Set(skills);
|
||||
for (const name of await listSkillChoices(page)) {
|
||||
if (keep.has(name)) continue;
|
||||
await page.getByRole("checkbox", { name, exact: true }).click();
|
||||
}
|
||||
await expectSkillChoices(page, skills);
|
||||
}
|
||||
|
||||
export async function toggleSkill(page: Page, name: string): Promise<void> {
|
||||
await page.getByRole("checkbox", { name, exact: true }).click();
|
||||
}
|
||||
|
||||
export async function saveSkillSelection(page: Page): Promise<void> {
|
||||
await page.getByRole("button", { name: "Save", exact: true }).click();
|
||||
}
|
||||
|
||||
export async function cancelSkillSelection(page: Page): Promise<void> {
|
||||
await page.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await expectSkillSelectionClosed(page);
|
||||
}
|
||||
|
||||
export async function listSkillChoices(page: Page): Promise<string[]> {
|
||||
const rows = page.getByRole("checkbox");
|
||||
const names = await rows.evaluateAll((elements) =>
|
||||
elements.map((element) => element.getAttribute("aria-label") ?? ""),
|
||||
);
|
||||
return names.filter((name) => name.length > 0);
|
||||
}
|
||||
|
||||
/** Asserts exactly which skills are checked in the open sheet. */
|
||||
export async function expectSkillChoices(page: Page, skills: string[]): Promise<void> {
|
||||
const expected = new Set(skills);
|
||||
for (const name of await listSkillChoices(page)) {
|
||||
const choice = page.getByRole("checkbox", { name, exact: true });
|
||||
if (expected.has(name)) {
|
||||
await expect(choice).toBeChecked();
|
||||
continue;
|
||||
}
|
||||
await expect(choice).not.toBeChecked();
|
||||
}
|
||||
}
|
||||
|
||||
/** Reopens the saved selection and asserts what the user sees, then closes it. */
|
||||
export async function expectSelectedSkills(page: Page, skills: string[]): Promise<void> {
|
||||
await openSkillSelection(page);
|
||||
await expect(page.getByRole("switch", { name: "All skills", exact: true })).not.toBeChecked();
|
||||
await expectSkillChoices(page, skills);
|
||||
await cancelSkillSelection(page);
|
||||
}
|
||||
|
||||
export async function expectAllSkillsSelected(page: Page): Promise<void> {
|
||||
await openSkillSelection(page);
|
||||
const allSkills = page.getByRole("switch", { name: "All skills", exact: true });
|
||||
await expect(allSkills).toBeChecked();
|
||||
await expectSkillChoices(page, await listSkillChoices(page));
|
||||
await cancelSkillSelection(page);
|
||||
}
|
||||
|
||||
export async function expectSaveErrorKeepsSheetOpen(page: Page): Promise<void> {
|
||||
await expect(page.getByText("Could not save your skill selection.", { exact: true })).toBeVisible(
|
||||
{ timeout: 15_000 },
|
||||
);
|
||||
await expectSkillSelectionOpen(page);
|
||||
}
|
||||
|
||||
/**
|
||||
* The removal warning is the desktop confirm dialog, which has no DOM to query.
|
||||
* The injected bridge records the call the same way the daemon-management tests
|
||||
* assert their confirmation copy.
|
||||
*/
|
||||
export async function expectRemovalWarning(page: Page, skills: string[]): Promise<void> {
|
||||
await page.waitForFunction(() => !!window.__capturedDialogCall, { timeout: 15_000 });
|
||||
const call = await page.evaluate(() => window.__capturedDialogCall);
|
||||
expect(call?.title).toBe("Remove deselected skills?");
|
||||
for (const name of skills) {
|
||||
expect(call?.message).toContain(name);
|
||||
}
|
||||
for (const dir of ["~/.agents", "~/.claude", "~/.codex"]) {
|
||||
expect(call?.message).toContain(dir);
|
||||
}
|
||||
expect(call?.message).toContain("Anything you added inside those skill folders is deleted too.");
|
||||
}
|
||||
|
||||
export async function expectNoRemovalWarning(page: Page): Promise<void> {
|
||||
expect(await page.evaluate(() => window.__capturedDialogCall)).toBeUndefined();
|
||||
}
|
||||
|
||||
export async function expectSkillPresentIn(
|
||||
sandbox: SkillsSandbox,
|
||||
target: SkillTargetName,
|
||||
skill: string,
|
||||
): Promise<void> {
|
||||
await expect
|
||||
.poll(() => readInstalledSkills(targetDir(sandbox.targets, target)), { timeout: 15_000 })
|
||||
.toContain(skill);
|
||||
}
|
||||
|
||||
export async function expectSkillFilePresent(
|
||||
sandbox: SkillsSandbox,
|
||||
target: SkillTargetName,
|
||||
skill: string,
|
||||
relativePath: string,
|
||||
): Promise<void> {
|
||||
const file = path.join(targetDir(sandbox.targets, target), skill, relativePath);
|
||||
await expect
|
||||
.poll(() => readFile(file, "utf8").catch(() => null), { timeout: 15_000 })
|
||||
.not.toBeNull();
|
||||
}
|
||||
|
||||
export async function expectSkillsInstalled(
|
||||
sandbox: SkillsSandbox,
|
||||
skills: string[],
|
||||
): Promise<void> {
|
||||
const dirs = [
|
||||
sandbox.targets.agentsDir,
|
||||
sandbox.targets.claudeDir,
|
||||
sandbox.targets.codexDir,
|
||||
] as const;
|
||||
for (const dir of dirs) {
|
||||
await expect
|
||||
.poll(async () => readInstalledSkills(dir), { timeout: 15_000 })
|
||||
.toEqual([...skills].sort());
|
||||
}
|
||||
}
|
||||
|
||||
async function readInstalledSkills(dir: string): Promise<string[]> {
|
||||
const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
|
||||
return entries
|
||||
.filter((entry) => entry.isDirectory())
|
||||
.map((entry) => entry.name)
|
||||
.sort();
|
||||
}
|
||||
Reference in New Issue
Block a user