@le-space/playwright 0.6.30 → 0.6.32

package/chunk-YAODEYKV.js

@@ -0,0 +1,66 @@
+// src/aleph-instance.ts
+var SUPPORTED_ALEPH_API_HOSTS = ["https://api2.aleph.im", "https://api.aleph.im"];
+var DEFAULT_ALEPH_SCHEDULER_URL = "https://scheduler.api.aleph.cloud";
+var API3_HOST_PATTERN = /(^|\.)api3\.aleph\.im$/iu;
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeApiOrigin(value) {
+  try {
+    const url = new URL(value);
+    if (API3_HOST_PATTERN.test(url.hostname)) return null;
+    return url.origin;
+  } catch {
+    return null;
+  }
+}
+function resolveAlephApiHosts(candidates) {
+  const allowed = new Set((candidates ?? SUPPORTED_ALEPH_API_HOSTS).map(normalizeApiOrigin).filter((value) => value != null));
+  const selected = SUPPORTED_ALEPH_API_HOSTS.filter((host) => allowed.has(host));
+  return selected.length > 0 ? [...selected] : [...SUPPORTED_ALEPH_API_HOSTS];
+}
+async function waitForAlephInstanceDeletion(options) {
+  const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
+  if (!fetchImpl) throw new Error("A fetch implementation is required for cleanup verification");
+  const deadline = Date.now() + (options.timeoutMs ?? 5 * 6e4);
+  const hosts = resolveAlephApiHosts(options.apiHosts);
+  const schedulerUrl = new URL(`/api/v0/allocation/${options.instanceHash}`, options.schedulerUrl ?? DEFAULT_ALEPH_SCHEDULER_URL);
+  let lastSummary = "Deletion has not been observed yet.";
+  while (Date.now() < deadline) {
+    const observations = [];
+    let replicasForgotten = true;
+    for (const apiHost of hosts) {
+      try {
+        const response = await fetchImpl(new URL(`/api/v0/messages/${options.instanceHash}`, apiHost), { cache: "no-cache" });
+        const payload = await response.json().catch(() => null);
+        const forgotten = payload?.status === "forgotten" || Boolean(payload?.forgotten_by?.length);
+        replicasForgotten &&= forgotten;
+        observations.push(`${apiHost}: ${forgotten ? "forgotten" : payload?.status ?? `HTTP ${response.status}`}`);
+      } catch (error) {
+        replicasForgotten = false;
+        observations.push(`${apiHost}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    let unallocated = false;
+    try {
+      const response = await fetchImpl(schedulerUrl, { cache: "no-cache" });
+      const payload = await response.json().catch(() => null);
+      unallocated = response.status === 404 || payload?.error === "VM is not allocated to any node";
+      observations.push(`scheduler: ${unallocated ? "unallocated" : `HTTP ${response.status}`}`);
+    } catch (error) {
+      observations.push(`scheduler: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    lastSummary = observations.join("; ");
+    if (replicasForgotten && unallocated) return lastSummary;
+    await delay(options.pollIntervalMs ?? 2e3);
+  }
+  throw new Error(`Aleph INSTANCE ${options.instanceHash} was not deleted within ${options.timeoutMs ?? 5 * 6e4}ms: ${lastSummary}`);
+}
+
+export {
+  SUPPORTED_ALEPH_API_HOSTS,
+  DEFAULT_ALEPH_SCHEDULER_URL,
+  delay,
+  resolveAlephApiHosts,
+  waitForAlephInstanceDeletion
+};

package/cleanup-cli.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+declare function parseCleanupCliArgs(argv: readonly string[], env: NodeJS.ProcessEnv): {
+    instanceHash: string;
+    apiHosts: string[];
+    evidencePath: string;
+    reason: string;
+};
+declare function runCleanupCli(argv?: readonly string[], env?: NodeJS.ProcessEnv): Promise<void>;
+
+export { parseCleanupCliArgs, runCleanupCli };

package/cleanup-cli.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+import {
+  resolveAlephApiHosts,
+  waitForAlephInstanceDeletion
+} from "./chunk-YAODEYKV.js";
+
+// src/cleanup-cli.ts
+import { createHash } from "crypto";
+import { appendFile, mkdir, writeFile } from "fs/promises";
+import { dirname } from "path";
+import process from "process";
+import { eraseInstanceOnCrn, forgetAlephMessages } from "@le-space/core";
+function parseCleanupCliArgs(argv, env) {
+  const flags = /* @__PURE__ */ new Map();
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (!argument.startsWith("--")) continue;
+    const equals = argument.indexOf("=");
+    if (equals > -1) {
+      flags.set(argument.slice(2, equals), argument.slice(equals + 1));
+    } else {
+      const value = argv[index + 1];
+      if (value == null || value.startsWith("--")) throw new Error(`Missing value for --${argument.slice(2)}`);
+      flags.set(argument.slice(2), value);
+      index += 1;
+    }
+  }
+  const instanceHash = (flags.get("instance-hash") ?? env.ALEPH_PLAYWRIGHT_INSTANCE_HASH ?? "").trim();
+  if (!/^[a-f0-9]{64}$/iu.test(instanceHash)) {
+    throw new Error("Cleanup requires one exact INSTANCE hash (--instance-hash or ALEPH_PLAYWRIGHT_INSTANCE_HASH)");
+  }
+  const hostCandidates = (flags.get("api-hosts") ?? env.ALEPH_VM_API_HOSTS ?? "").split(/[\s,]+/u).filter(Boolean);
+  return {
+    instanceHash,
+    apiHosts: resolveAlephApiHosts(hostCandidates.length > 0 ? hostCandidates : void 0),
+    evidencePath: (flags.get("evidence-path") ?? env.EVIDENCE_PATH ?? "").trim() || `playwright-runner-cleanup-${instanceHash.slice(0, 12)}.json`,
+    reason: (flags.get("reason") ?? "").trim() || `Ephemeral Playwright runner cleanup for ${instanceHash}`
+  };
+}
+function importOptional(specifier) {
+  return import(specifier);
+}
+async function createSigner(privateKey) {
+  const normalizedKey = privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`;
+  try {
+    const { Wallet } = await importOptional("ethers");
+    const wallet = new Wallet(normalizedKey);
+    return { address: await wallet.getAddress(), sign: (payload) => wallet.signMessage(payload) };
+  } catch (error) {
+    if (error?.code !== "ERR_MODULE_NOT_FOUND") throw error;
+  }
+  try {
+    const { privateKeyToAccount } = await importOptional("viem/accounts");
+    const account = privateKeyToAccount(normalizedKey);
+    return { address: account.address, sign: (payload) => account.signMessage({ message: payload }) };
+  } catch (error) {
+    if (error?.code !== "ERR_MODULE_NOT_FOUND") throw error;
+  }
+  throw new Error('playwright-runner-cleanup needs either "ethers" or "viem" to sign the FORGET message');
+}
+async function runCleanupCli(argv = process.argv.slice(2), env = process.env) {
+  const options = parseCleanupCliArgs(argv, env);
+  const privateKey = env.ALEPH_PRIVATE_KEY?.trim();
+  if (!privateKey) throw new Error("ALEPH_PRIVATE_KEY is required");
+  const identity = await createSigner(privateKey);
+  const signer = (_sender, payload) => identity.sign(payload);
+  const fetchImpl = globalThis.fetch.bind(globalThis);
+  let erase;
+  for (const apiHost of options.apiHosts) {
+    try {
+      erase = await eraseInstanceOnCrn({
+        sender: identity.address,
+        signer,
+        instanceHash: options.instanceHash,
+        fetch: fetchImpl,
+        apiHost
+      });
+      break;
+    } catch {
+    }
+  }
+  let forget = null;
+  for (const apiHost of options.apiHosts) {
+    try {
+      forget = await forgetAlephMessages({
+        sender: identity.address,
+        hashes: [options.instanceHash],
+        reason: options.reason,
+        signer,
+        hasher: (content) => createHash("sha256").update(content).digest("hex"),
+        fetch: fetchImpl,
+        apiHost,
+        sync: true
+      });
+      if (forget.status === "rejected") throw new Error("FORGET rejected");
+      break;
+    } catch {
+      forget = null;
+    }
+  }
+  if (!forget) throw new Error(`Owner-signed FORGET failed for ${options.instanceHash}`);
+  const verification = await waitForAlephInstanceDeletion({
+    instanceHash: options.instanceHash,
+    apiHosts: options.apiHosts,
+    fetch: fetchImpl
+  });
+  await mkdir(dirname(options.evidencePath) || ".", { recursive: true });
+  await writeFile(
+    options.evidencePath,
+    `${JSON.stringify(
+      {
+        instanceHash: options.instanceHash,
+        owner: identity.address,
+        apiHosts: options.apiHosts,
+        erase,
+        forget: forget.itemHash,
+        verification
+      },
+      null,
+      2
+    )}
+`
+  );
+  if (env.GITHUB_OUTPUT) await appendFile(env.GITHUB_OUTPUT, `evidence_path=${options.evidencePath}
+`);
+  if (env.GITHUB_STEP_SUMMARY) {
+    await appendFile(
+      env.GITHUB_STEP_SUMMARY,
+      `
+## Aleph Playwright cleanup
+
+- Exact INSTANCE: \`${options.instanceHash}\`
+- Runtime erase: \`${erase?.status ?? "unavailable"}\`
+- Owner FORGET: \`${forget.status}\`
+- Verification: ${verification}
+`
+    );
+  }
+}
+var invokedDirectly = process.argv[1]?.endsWith("cleanup-cli.ts") || process.argv[1]?.endsWith("cleanup-cli.js") || process.argv[1]?.endsWith("playwright-runner-cleanup");
+if (invokedDirectly) {
+  runCleanupCli().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  });
+}
+export {
+  parseCleanupCliArgs,
+  runCleanupCli
+};

package/index.d.ts

@@ -3,9 +3,19 @@ import { Browser, Page, Locator, BrowserContext } from '@playwright/test';
 import { RelayBootstrapPostRecord, RelayBootstrapContent, fetchAlephBootstrapPosts } from '@le-space/aleph-bootstrap';
 import { eraseInstanceOnCrn, forgetAlephMessages } from '@le-space/core';
 
-declare const PLAYWRIGHT_RUNNER_VERSION = "1.61.1";
 declare const SUPPORTED_ALEPH_API_HOSTS: readonly ["https://api2.aleph.im", "https://api.aleph.im"];
 declare const DEFAULT_ALEPH_SCHEDULER_URL = "https://scheduler.api.aleph.cloud";
+declare function resolveAlephApiHosts(candidates?: readonly string[]): string[];
+declare function waitForAlephInstanceDeletion(options: {
+    instanceHash: string;
+    apiHosts?: readonly string[];
+    schedulerUrl?: string;
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    fetch?: typeof fetch;
+}): Promise<string>;
+
+declare const PLAYWRIGHT_RUNNER_VERSION = "1.61.1";
 interface RelayWalletAccount {
     address: string;
     signMessage(args: {
@@ -100,7 +110,7 @@ interface WaitForPubsubSubscriberOptions {
     stableForMs?: number;
 }
 interface RelayButtonDriverOptions {
-    launcherName?: RegExp;
+    launcherName?: string | RegExp;
     instanceNamePlaceholder?: string;
     sshPublicKeyPlaceholder?: string;
     connectWalletName?: string;
@@ -176,7 +186,6 @@ interface CreateRelayTestOptions {
     evidence: RelayEvidence;
     cleanup?: Omit<CleanupRelayOptions, 'page' | 'account' | 'instanceName' | 'instanceHash'>;
 }
-declare function resolveAlephApiHosts(candidates?: readonly string[]): string[];
 declare function connectAlephChromium(options: AlephRemoteBrowserOptions): Promise<Browser>;
 declare function buildAlephCostEvidence(options: {
     startedAt: string;
@@ -232,14 +241,6 @@ declare function waitForBootstrapRegistration(options: {
 }): Promise<RelayBootstrapPostRecord>;
 declare function selectBrowserRelayAddresses(content: Pick<RelayBootstrapContent, 'browserMultiaddrs' | 'multiaddrs'>, policy?: RelayAddressPolicy): string[];
 declare function provisionRelay(page: Page, options: ProvisionRelayOptions): Promise<ProvisionedRelay>;
-declare function waitForAlephInstanceDeletion(options: {
-    instanceHash: string;
-    apiHosts?: readonly string[];
-    schedulerUrl?: string;
-    timeoutMs?: number;
-    pollIntervalMs?: number;
-    fetch?: typeof fetch;
-}): Promise<string>;
 declare function waitForAlephMessageForgotten(options: {
     messageHash: string;
     apiHosts?: readonly string[];

package/index.js

@@ -1,3 +1,11 @@
+import {
+  DEFAULT_ALEPH_SCHEDULER_URL,
+  SUPPORTED_ALEPH_API_HOSTS,
+  delay,
+  resolveAlephApiHosts,
+  waitForAlephInstanceDeletion
+} from "./chunk-YAODEYKV.js";
+
 // src/index.ts
 import { createHash } from "crypto";
 import { appendFile, mkdir, writeFile } from "fs/promises";
@@ -6,23 +14,6 @@ import { fetchAlephBootstrapPosts } from "@le-space/aleph-bootstrap";
 import { eraseInstanceOnCrn, forgetAlephMessages } from "@le-space/core";
 import { test as playwrightTest } from "@playwright/test";
 var PLAYWRIGHT_RUNNER_VERSION = "1.61.1";
-var SUPPORTED_ALEPH_API_HOSTS = ["https://api2.aleph.im", "https://api.aleph.im"];
-var DEFAULT_ALEPH_SCHEDULER_URL = "https://scheduler.api.aleph.cloud";
-var API3_HOST_PATTERN = /(^|\.)api3\.aleph\.im$/iu;
-function normalizeApiOrigin(value) {
-  try {
-    const url = new URL(value);
-    if (API3_HOST_PATTERN.test(url.hostname)) return null;
-    return url.origin;
-  } catch {
-    return null;
-  }
-}
-function resolveAlephApiHosts(candidates) {
-  const allowed = new Set((candidates ?? SUPPORTED_ALEPH_API_HOSTS).map(normalizeApiOrigin).filter((value) => value != null));
-  const selected = SUPPORTED_ALEPH_API_HOSTS.filter((host) => allowed.has(host));
-  return selected.length > 0 ? [...selected] : [...SUPPORTED_ALEPH_API_HOSTS];
-}
 function requireFiniteNumber(value, label) {
   const number = Number(value);
   if (!Number.isFinite(number)) throw new Error(`${label} must be a finite number`);
@@ -209,7 +200,7 @@ var RelayButtonDriver = class {
   constructor(page, options = {}) {
     this.page = page;
     this.options = {
-      launcherName: options.launcherName ?? /(?:Sponsor Relay|Relay Button|Relay)/,
+      launcherName: options.launcherName ?? "Relay Button",
       instanceNamePlaceholder: options.instanceNamePlaceholder ?? "Instance name",
       sshPublicKeyPlaceholder: options.sshPublicKeyPlaceholder ?? "SSH public key",
       connectWalletName: options.connectWalletName ?? "Connect MetaMask",
@@ -298,9 +289,6 @@ async function waitForDeploymentUi(page, instanceName, timeoutMs) {
     throw new Error(`Relay Button deployment failed: ${result.message}`);
   }
 }
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
 async function findAlephInstanceHash(options) {
   const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
   if (!fetchImpl) throw new Error("A fetch implementation is required for INSTANCE lookup");
@@ -452,43 +440,6 @@ async function provisionRelay(page, options) {
     driver
   };
 }
-async function waitForAlephInstanceDeletion(options) {
-  const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
-  if (!fetchImpl) throw new Error("A fetch implementation is required for cleanup verification");
-  const deadline = Date.now() + (options.timeoutMs ?? 5 * 6e4);
-  const hosts = resolveAlephApiHosts(options.apiHosts);
-  const schedulerUrl = new URL(`/api/v0/allocation/${options.instanceHash}`, options.schedulerUrl ?? DEFAULT_ALEPH_SCHEDULER_URL);
-  let lastSummary = "Deletion has not been observed yet.";
-  while (Date.now() < deadline) {
-    const observations = [];
-    let replicasForgotten = true;
-    for (const apiHost of hosts) {
-      try {
-        const response = await fetchImpl(new URL(`/api/v0/messages/${options.instanceHash}`, apiHost), { cache: "no-cache" });
-        const payload = await response.json().catch(() => null);
-        const forgotten = payload?.status === "forgotten" || Boolean(payload?.forgotten_by?.length);
-        replicasForgotten &&= forgotten;
-        observations.push(`${apiHost}: ${forgotten ? "forgotten" : payload?.status ?? `HTTP ${response.status}`}`);
-      } catch (error) {
-        replicasForgotten = false;
-        observations.push(`${apiHost}: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    }
-    let unallocated = false;
-    try {
-      const response = await fetchImpl(schedulerUrl, { cache: "no-cache" });
-      const payload = await response.json().catch(() => null);
-      unallocated = response.status === 404 || payload?.error === "VM is not allocated to any node";
-      observations.push(`scheduler: ${unallocated ? "unallocated" : `HTTP ${response.status}`}`);
-    } catch (error) {
-      observations.push(`scheduler: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    lastSummary = observations.join("; ");
-    if (replicasForgotten && unallocated) return lastSummary;
-    await delay(options.pollIntervalMs ?? 2e3);
-  }
-  throw new Error(`Aleph INSTANCE ${options.instanceHash} was not deleted within ${options.timeoutMs ?? 5 * 6e4}ms: ${lastSummary}`);
-}
 async function waitForAlephMessageForgotten(options) {
   const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
   if (!fetchImpl) throw new Error("A fetch implementation is required for cleanup verification");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@le-space/playwright",
-  "version": "0.6.30",
+  "version": "0.6.32",
   "description": "Reusable Playwright fixtures and Relay Button lifecycle helpers.",
   "license": "MIT",
   "type": "module",
@@ -12,6 +12,9 @@
       "import": "./index.js"
     }
   },
+  "bin": {
+    "playwright-runner-cleanup": "./cleanup-cli.js"
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -24,8 +27,8 @@
     "url": "https://github.com/NiKrause/relay-button/issues"
   },
   "dependencies": {
-    "@le-space/aleph-bootstrap": "0.6.30",
-    "@le-space/core": "0.6.30"
+    "@le-space/aleph-bootstrap": "0.6.32",
+    "@le-space/core": "0.6.32"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.61.1 <1.62.0"