@specific.dev/spectest 0.89.1 → 0.90.1

package/dist/harness/sticky-consumer.js

@@ -0,0 +1,178 @@
+/** Docker/BuildKit policy for the generic sticky disk. No host publication API. */
+import { execFile } from "node:child_process";
+import { mkdir, readFile, statfs, writeFile } from "node:fs/promises";
+export const STICKY_CAPABILITY = "sticky-disks-v1";
+export const STICKY_COMPATIBILITY = "docker29-ctr21-buildkit032-overlayfs-256g-v2";
+export const STICKY_RUNTIME = "/run/spectest-sticky";
+function exec(program, args, timeout = 60_000) {
+    return new Promise((resolve, reject) => {
+        execFile(program, args, { timeout, maxBuffer: 8 * 1024 * 1024 }, (error, stdout, stderr) => {
+            if (error)
+                reject(new Error(`${program} failed: ${stderr || stdout || error.message}`));
+            else
+                resolve(stdout.trim());
+        });
+    });
+}
+async function ready(program, args) {
+    const deadline = Date.now() + 30_000;
+    let last;
+    do {
+        try {
+            await exec(program, args, 2000);
+            return;
+        }
+        catch (error) {
+            last = error;
+        }
+        await Bun.sleep(100);
+    } while (Date.now() < deadline);
+    throw last;
+}
+export function validateStickyConfig(config) {
+    if (config.path !== "/var/lib/spectest-sticky" || config.compatibility !== STICKY_COMPATIBILITY ||
+        !Number.isSafeInteger(config.capacityBytes) || config.capacityBytes <= 0 ||
+        !Number.isSafeInteger(config.headroomBytes) || config.headroomBytes < 16 * 1024 * 1024 ||
+        !Number.isSafeInteger(config.cacheTargetBytes) || config.cacheTargetBytes <= 0 ||
+        !Number.isSafeInteger(config.buildkitTargetBytes) || config.buildkitTargetBytes <= 0 ||
+        config.buildkitTargetBytes > config.cacheTargetBytes ||
+        config.cacheTargetBytes + config.headroomBytes >= config.capacityBytes) {
+        throw new Error("unsupported sticky consumer profile or budget");
+    }
+}
+export async function initializeStickyConsumer(config) {
+    validateStickyConfig(config);
+    await exec("mountpoint", ["-q", config.path]);
+    // The base must have stopped these before its RAM was captured. Refuse an
+    // unexpected writer rather than racing it for the standard daemon sockets.
+    for (const unit of ["docker.service", "docker.socket", "containerd.service"]) {
+        const state = await exec("systemctl", ["show", unit, "-p", "ActiveState", "--value"]);
+        if (!["inactive", "failed"].includes(state))
+            throw new Error(`sticky base has active legacy consumer: ${unit}: ${state}`);
+    }
+    for (const [program, version] of [["dockerd", "29.7.2"], ["containerd", "v2.1.5"], ["buildkitd", "v0.32.2"]]) {
+        if (!(await exec(program, ["--version"])).includes(version))
+            throw new Error(`unsupported ${program} version for sticky profile`);
+    }
+    await mkdir(STICKY_RUNTIME, { recursive: true });
+    for (const child of ["docker", "containerd", "buildkit"])
+        await mkdir(`${config.path}/${child}`, { recursive: true });
+    await writeFile(`${STICKY_RUNTIME}/consumer.json`, JSON.stringify(config));
+    await writeFile(`${STICKY_RUNTIME}/containerd.toml`, `version = 2
+root = "${config.path}/containerd"
+state = "/run/containerd"
+disabled_plugins = ["io.containerd.grpc.v1.cri"]
+[grpc]
+  address = "/run/containerd/containerd.sock"
+`);
+    const dockerConfig = JSON.parse(await readFile("/etc/docker/daemon.json", "utf8"));
+    dockerConfig["data-root"] = `${config.path}/docker`;
+    dockerConfig.features = { "containerd-snapshotter": true };
+    dockerConfig["storage-driver"] = "overlayfs";
+    await writeFile(`${STICKY_RUNTIME}/docker.json`, JSON.stringify(dockerConfig));
+    await writeFile(`${STICKY_RUNTIME}/buildkit.toml`, `root = "${config.path}/buildkit"
+[grpc]
+  address = ["tcp://127.0.0.1:1234"]
+[worker.oci]
+  enabled = false
+[worker.containerd]
+  enabled = true
+  address = "/run/containerd/containerd.sock"
+  namespace = "moby"
+  snapshotter = "overlayfs"
+  gc = true
+  reservedSpace = "1GB"
+  maxUsedSpace = ${config.buildkitTargetBytes}
+  minFreeSpace = ${config.headroomBytes}
+`);
+    const start = async (unit, program, args) => {
+        await exec("systemd-run", ["--quiet", "--unit", unit, "-p", "TimeoutStopSec=30",
+            // Pinned BuildKit 0.32.2 returns 1 after its normal first-SIGTERM
+            // shutdown (util/appcontext). A timeout/signal still fails the unit.
+            ...(unit === "spectest-sticky-buildkit" ? ["-p", "SuccessExitStatus=1"] : []),
+            program, ...args]);
+    };
+    await start("spectest-sticky-containerd", "containerd", ["--config", `${STICKY_RUNTIME}/containerd.toml`]);
+    await ready("ctr", ["version"]);
+    await start("spectest-sticky-docker", "dockerd", ["--config-file", `${STICKY_RUNTIME}/docker.json`,
+        "--host", "unix:///run/docker.sock", "--exec-root", "/run/docker", "--pidfile", "/run/docker.pid",
+        "--containerd", "/run/containerd/containerd.sock", "--containerd-namespace", "moby"]);
+    await ready("docker", ["info"]);
+    await start("spectest-sticky-buildkit", "buildkitd", ["--config", `${STICKY_RUNTIME}/buildkit.toml`]);
+    await ready("buildctl", ["--addr", "tcp://127.0.0.1:1234", "debug", "workers"]);
+    await exec("docker", ["buildx", "create", "--name", "spectest-local", "--driver", "remote", "tcp://127.0.0.1:1234"]);
+    await exec("docker", ["buildx", "inspect", "--bootstrap", "spectest-local"]);
+}
+/** Filesystem pressure takes precedence over cache age/BuildKit record sizes.
+ * Only called after runtime containers/volumes have been removed on the
+ * isolated publication clone. Never removes files behind the daemons' backs.
+ */
+export async function collectStickyCache(config, run = exec, usage = async () => {
+    const fs = await statfs(config.path);
+    return { freeBytes: fs.bavail * fs.bsize, totalBytes: fs.blocks * fs.bsize };
+}) {
+    validateStickyConfig(config);
+    const buildctl = ["--addr", "tcp://127.0.0.1:1234", "prune"];
+    await run("buildctl", [...buildctl, "--keep-duration", "168h"], 120_000);
+    await run("docker", ["image", "prune", "-af", "--filter", "until=168h"], 120_000);
+    const withinTarget = (fs) => fs.freeBytes >= config.headroomBytes && fs.totalBytes - fs.freeBytes <= config.cacheTargetBytes;
+    let fs = await usage();
+    // Always enforce the independent BuildKit target. Its accounting alone
+    // cannot bound shared images/content, so also request real filesystem space.
+    const pruneBuildkit = async () => {
+        await run("buildctl", [...buildctl, "--all", "--keep-storage",
+            String(Math.floor(config.buildkitTargetBytes / 1e6)), "--free-storage",
+            String(Math.ceil(Math.max(config.headroomBytes, fs.totalBytes - config.cacheTargetBytes) / 1e6))], 120_000);
+        fs = await usage();
+    };
+    await pruneBuildkit();
+    if (withinTarget(fs))
+        return;
+    // Pressure can be entirely in recent Docker images. Drop oldest images
+    // first, even within the age window, until the whole filesystem fits.
+    const ids = [...new Set((await run("docker", ["image", "ls", "-aq", "--no-trunc"])).split(/\s+/).filter(Boolean))];
+    const images = ids.length
+        ? JSON.parse(await run("docker", ["image", "inspect", ...ids])) : [];
+    images.sort((a, b) => a.Created.localeCompare(b.Created) || a.Id.localeCompare(b.Id));
+    for (const image of images) {
+        await run("docker", ["image", "rm", "-f", image.Id], 120_000);
+        await pruneBuildkit();
+        if (withinTarget(fs))
+            return;
+    }
+    // Containerd GC may lag reference removal; allow bounded additional passes.
+    for (let pass = 0; pass < 3 && !withinTarget(fs); pass++)
+        await pruneBuildkit();
+    if (!withinTarget(fs))
+        throw new Error("sticky cache cannot meet filesystem retention target and write headroom");
+}
+/** Only on an isolated maintenance clone; never on the live ready environment. */
+export async function prepareStickyConsumer(artifact = false) {
+    const config = JSON.parse(await readFile(`${STICKY_RUNTIME}/consumer.json`, "utf8"));
+    validateStickyConfig(config);
+    if (!artifact) {
+        const containers = (await exec("docker", ["ps", "-aq"])).split(/\s+/).filter(Boolean);
+        if (containers.length)
+            await exec("docker", ["rm", "-f", ...containers]);
+        const volumes = (await exec("docker", ["volume", "ls", "-q"])).split(/\s+/).filter(Boolean);
+        if (volumes.length)
+            await exec("docker", ["volume", "rm", ...volumes]);
+        await collectStickyCache(config);
+    }
+    const units = ["spectest-sticky-buildkit", "spectest-sticky-docker", "spectest-sticky-containerd"];
+    for (const unit of units) {
+        const active = await exec("systemctl", ["show", unit, "-p", "ActiveState", "--value"]);
+        if (active !== "active")
+            throw new Error(`consumer exited before sealing: ${unit}: ${active}`);
+        await exec("systemctl", ["stop", unit], 45_000);
+        const result = await exec("systemctl", ["show", unit, "-p", "Result", "--value"]);
+        if (result !== "success")
+            throw new Error(`unclean consumer shutdown: ${unit}: ${result}`);
+    }
+    const fs = await statfs(config.path);
+    const freeBytes = fs.bavail * fs.bsize;
+    if (freeBytes < config.headroomBytes)
+        throw new Error("sticky publication has insufficient write headroom");
+    // The supervisor verifies and unmounts; only the worker seals/publishes.
+    return { prepared: true, freeBytes };
+}

package/dist/harness/sticky-maintenance.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/harness/sticky-maintenance.js

@@ -0,0 +1,11 @@
+// Dedicated entry point: no daemon.ts, project modules, bootstrap or tests.
+import { prepareStickyConsumer } from "./sticky-consumer";
+if (import.meta.main) {
+    try {
+        console.log(JSON.stringify(await prepareStickyConsumer(process.argv.includes("--artifact"))));
+    }
+    catch (error) {
+        console.error(error);
+        process.exitCode = 1;
+    }
+}

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import type { Android, AndroidApp } from "./android.js";
+export type { Android, AndroidApp, AndroidElement, AndroidRecordingOptions } from "./android.js";
 import { strict as nodeAssert } from "node:assert";
 export type { Carrier, Wrapped, WrappedObject, WrappedArray, WrappedHeaders, WrappedBuffer, WrappedBinaryView, WrappedBytes, WrappedBlob, WrappedFile, WrappedFormData, WrappedStream, WrappedReader, WrappedBYOBReader, WrappedReadResult, WrappedResponse, Provenanced, SpectestFetch, SpectestRequestInit, Unwrap, } from "./inspect.js";
 import type { Provenanced, SpectestFetch, Wrapped } from "./inspect.js";
@@ -1315,6 +1317,8 @@ export interface TestContext<P = undefined, S extends ServicesMap = ServicesMap,
      * like named desktop browsers.
      */
     mobile(app: MobileApp, name?: string): Promise<Mobile>;
+    /** Native Android via Appium. Recording is automatic for test cases; the app and session survive forks. */
+    android(app: AndroidApp): Promise<Android>;
     /** Drive a real Electron renderer window through locators and user input.
      * Acquires the app started by electron(); keeps its live state across forks.
      * Each test gets a self-contained graphical replay. Selecting another window

package/dist/recorder.d.ts

@@ -1,3 +1,4 @@
+import type { AndroidStepDetails } from "./android-step.js";
 export type TestEvent = ExecEvent | AssertionEvent | HttpEvent | KubeEvent | BrowserEvent | DbEvent | RedisEvent | S3Event | TerminalEvent | TerminalStepEvent | WaitEvent | FakeEvent | EnvEvent | EmailEvent | StepEvent;
 interface BaseEvent {
     /** Order of *start* within the test. Reserved when an op begins (see
@@ -564,7 +565,7 @@ export interface EventReservation {
 }
 export declare function pauseRecording(): void;
 export declare function resumeRecording(): void;
-export declare function startRecording(): void;
+export declare function startRecording(startedAt?: number): void;
 export declare function stopRecording(): TestEvent[];
 export declare function isRecording(): boolean;
 /** Reserve an ordering slot at the start of an op so nested events it triggers
@@ -659,6 +660,8 @@ export interface StepEvent extends BaseEvent {
     kind: string;
     /** The step's one-line summary in the timeline. */
     title: string;
+    /** Native action semantics; titles are presentation only. */
+    android?: AndroidStepDetails;
     blocks?: StepBlock[];
     status?: "passed" | "failed" | "error";
     durationMs?: number;

package/dist/recorder.js

@@ -11,9 +11,12 @@ import { clearPendingNullish } from "./inspect.js";
 import { scopeAllowsRecording } from "./harness/instrumentation-scope.js";
 const OUTPUT_SNIPPET_BYTES = 256 * 1024;
 class Recorder {
+    start;
     events = [];
     seq = 0;
-    start = Date.now();
+    constructor(start = Date.now()) {
+        this.start = start;
+    }
     /** Claim a seq + start offset now; pass the result to `push` at finish. */
     reserve() {
         return { seq: this.seq++, tOffsetMs: Date.now() - this.start };
@@ -120,8 +123,8 @@ export function resumeRecording() {
 function active() {
     return current !== null && paused === 0 && scopeAllowsRecording();
 }
-export function startRecording() {
-    current = new Recorder();
+export function startRecording(startedAt = Date.now()) {
+    current = new Recorder(startedAt);
     paused = 0;
 }
 export function stopRecording() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specific.dev/spectest",
-  "version": "0.89.1",
+  "version": "0.90.1",
   "description": "Spectest SDK for defining test environments in TypeScript.",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,7 +49,8 @@
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
-    "access": "public"
+    "access": "public",
+    "tag": "latest"
   },
   "dependencies": {
     "@kubernetes/client-node": "^1.0.0",
@@ -61,5 +62,8 @@
     "@types/dns-packet": "^5.6.5",
     "@types/bun": "^1.3.0",
     "typescript": "^5.6.3"
-  }
+  },
+  "spectestCapabilities": [
+    "sticky-disks-v1"
+  ]
 }

package/src/android-step.test.ts

@@ -0,0 +1,115 @@
+import { expect, test } from "bun:test";
+import {
+  androidStepTitle,
+  androidTarget,
+  type AndroidStepDetails,
+} from "./android-step.js";
+
+const cases: [Omit<AndroidStepDetails, "device">, string][] = [
+  [
+    { action: "tap", target: { kind: "text", value: "SAVE LOCAL SQLITE" } },
+    'tap text "SAVE LOCAL SQLITE"',
+  ],
+  [
+    {
+      action: "tap",
+      target: { kind: "text", value: 'a "quoted" label\nnext' },
+    },
+    'tap text "a \\"quoted\\" label\\nnext"',
+  ],
+  [
+    {
+      action: "fill",
+      target: { kind: "class", value: "android.widget.EditText" },
+    },
+    "fill text field",
+  ],
+  [
+    {
+      action: "text",
+      target: { kind: "class", value: "android.widget.EditText" },
+    },
+    "read text from text field",
+  ],
+  [
+    { action: "visible", target: { kind: "id", value: "app:id/save" } },
+    'check id "app:id/save" is visible',
+  ],
+  [
+    {
+      action: "wait",
+      target: { kind: "accessibility", value: "Save" },
+      state: "hidden",
+    },
+    'wait for accessibility label "Save" to be hidden',
+  ],
+  [
+    {
+      action: "wait",
+      target: { kind: "text", value: "Ready" },
+      state: "visible",
+    },
+    'wait for text "Ready" to be visible',
+  ],
+  [
+    {
+      action: "tap",
+      target: { kind: "xpath", value: '//button[@text="Save"]' },
+    },
+    'tap XPath "//button[@text=\\"Save\\"]"',
+  ],
+  [
+    {
+      action: "tap",
+      target: {
+        kind: "custom",
+        strategy: "-android uiautomator",
+        value: 'new UiSelector().text("Save")',
+      },
+    },
+    "tap custom selector",
+  ],
+  [
+    { action: "tap", target: { kind: "class", value: "my.CustomWidget" } },
+    'tap class "my.CustomWidget"',
+  ],
+  [{ action: "tap", point: { x: 12, y: 34 } }, "tap (12, 34)"],
+  [{ action: "swipe", direction: "up" }, "swipe up"],
+  [{ action: "back" }, "go back"],
+  [{ action: "source" }, "read screen structure"],
+  [{ action: "screenshot" }, "take screenshot"],
+  [
+    { action: "execute", command: "mobile: getDeviceInfo" },
+    'run command "mobile: getDeviceInfo"',
+  ],
+];
+for (const [action, title] of cases) {
+  test(title, () =>
+    expect(androidStepTitle({ device: "phone", ...action })).toBe(
+      `phone: ${title}`,
+    ),
+  );
+}
+
+test("custom selector expressions remain opaque structured data", () => {
+  const expression = 'new UiSelector().text("Save").enabled(true)';
+  const target = androidTarget("-android uiautomator", expression);
+  expect(target).toEqual({
+    kind: "custom",
+    strategy: "-android uiautomator",
+    value: expression,
+  });
+  expect(androidStepTitle({ device: "phone", action: "tap", target })).toBe(
+    "phone: tap custom selector",
+  );
+  for (const [using, kind] of [
+    ["id", "id"],
+    ["accessibility id", "accessibility"],
+    ["class name", "class"],
+    ["xpath", "xpath"],
+  ] as const)
+    expect(androidTarget(using, expression)).toEqual({
+      kind,
+      value: expression,
+    });
+});

package/src/android-step.ts

@@ -0,0 +1,107 @@
+/** Recorded semantics, independent of Appium's wire selectors and display titles. */
+export interface AndroidTarget {
+  kind: "text" | "id" | "accessibility" | "class" | "xpath" | "custom";
+  value: string;
+  /** Original strategy for a custom locator; never interpreted as display text. */
+  strategy?: string;
+}
+export interface AndroidStepDetails {
+  device: string;
+  action:
+    | "tap"
+    | "fill"
+    | "text"
+    | "visible"
+    | "wait"
+    | "swipe"
+    | "back"
+    | "source"
+    | "screenshot"
+    | "execute";
+  target?: AndroidTarget;
+  point?: { x: number; y: number };
+  direction?: "up" | "down" | "left" | "right";
+  state?: "visible" | "hidden";
+  command?: string;
+}
+
+export function androidTarget(using: string, value: string): AndroidTarget {
+  const kind = new Map<string, AndroidTarget["kind"]>([
+    ["id", "id"],
+    ["accessibility id", "accessibility"],
+    ["class name", "class"],
+    ["xpath", "xpath"],
+  ]).get(using);
+  return kind ? { kind, value } : { kind: "custom", value, strategy: using };
+}
+
+export function androidTargetLabel(target: AndroidTarget): string {
+  const quoted = JSON.stringify(target.value);
+  switch (target.kind) {
+    case "text":
+      return `text ${quoted}`;
+    case "id":
+      return `id ${quoted}`;
+    case "accessibility":
+      return `accessibility label ${quoted}`;
+    case "xpath":
+      return `XPath ${quoted}`;
+    case "custom":
+      return "custom selector";
+    case "class": {
+      const classes = {
+        "android.widget.EditText": "text field",
+        "android.widget.Button": "button",
+        "android.widget.TextView": "text view",
+        "android.widget.CheckBox": "checkbox",
+        "android.widget.Switch": "switch",
+        "android.widget.ImageView": "image",
+        "android.widget.ScrollView": "scroll view",
+        "androidx.recyclerview.widget.RecyclerView": "list",
+      } as Record<string, string>;
+      return Object.hasOwn(classes, target.value)
+        ? classes[target.value]
+        : `class ${quoted}`;
+    }
+  }
+}
+
+export function androidStepTitle(step: AndroidStepDetails): string {
+  const target = step.target ? androidTargetLabel(step.target) : "element";
+  let label: string;
+  switch (step.action) {
+    case "tap":
+      label = step.point
+        ? `tap (${step.point.x}, ${step.point.y})`
+        : `tap ${target}`;
+      break;
+    case "fill":
+      label = `fill ${target}`;
+      break;
+    case "text":
+      label = `read text from ${target}`;
+      break;
+    case "visible":
+      label = `check ${target} is visible`;
+      break;
+    case "wait":
+      label = `wait for ${target} to be ${step.state ?? "visible"}`;
+      break;
+    case "swipe":
+      label = `swipe ${step.direction}`;
+      break;
+    case "back":
+      label = "go back";
+      break;
+    case "source":
+      label = "read screen structure";
+      break;
+    case "screenshot":
+      label = "take screenshot";
+      break;
+    case "execute":
+      label = `run command ${JSON.stringify(step.command)}`;
+      break;
+  }
+  return `${step.device}: ${label}`;
+}