@specific.dev/spectest 0.131.11 → 0.131.13

package/src/harness/builtin-images.ts

@@ -0,0 +1,29 @@
+/** SDK-owned upstream inputs, resolved from registry manifests on 2026-11-02.
+ * Pin the multi-platform index, never the workstation's platform manifest.
+ * Update deliberately with an SDK release; user image/version overrides bypass
+ * these defaults. Keep generated Dockerfiles and helper pods here as well.
+ */
+export const BUILTIN_IMAGES = {
+  "postgres:18-alpine": "postgres:18-alpine@sha256:10a5c69a83035ab5239f5620d708520e8b28f5aa1f2b20143e6024532edadfb5",
+  "rancher/k3s:v1.33.5-k3s1": "rancher/k3s:v1.33.5-k3s1@sha256:fd4740667b7033055c27d424d0d2d660bf66cedbdb225d68e0eab6dd48aa0fd2",
+  "rancher/mirrored-library-traefik:3.3.2": "rancher/mirrored-library-traefik:3.3.2@sha256:a03ee2f858f77975fa943f6797da5446b7ac9a83beef6bbdae2afd8feaf67b76",
+  "registry:2.8.3": "registry:2.8.3@sha256:a3d8aaa63ed8681a604f1dea0aa03f100d5895b6a58ace528858a7b332415373",
+  "registry.k8s.io/pause:3.10": "registry.k8s.io/pause:3.10@sha256:ee6521f290b2168b6e0935a181d4cff9be1ac3f505666ef0e3c98fae8199917a",
+  "node:22-bookworm-slim": "node:22-bookworm-slim@sha256:4b150b48b4116e2a22f2c39cc27025fbf4f153e2078fd3b14d159fdb5c7279da",
+  "node:24-bookworm-slim": "node:24-bookworm-slim@sha256:c86ecead9e55a5210ac1727de38a4ca840bf03dcaf34dc9749addbf383b1920c",
+  "oven/bun:1.3.14-alpine": "oven/bun:1.3.14-alpine@sha256:5acc90a93e91ff07bf72aa90a7c9f0fa189765aec90b47bdbf2152d2196383c0",
+  "axllent/mailpit:v1.30": "axllent/mailpit:v1.30@sha256:d5ecbb067db3705fa953d79e1b7f81ef84038df67aba6c52825d8c02a1ea748a",
+  "ministackorg/ministack:1.4.8": "ministackorg/ministack:1.4.8@sha256:eb0a00c897ec91589eb78a77f0afaf13a6d7be99abfeca2d1d719a7ec76d3141",
+  "temporalio/temporal:1.9.1": "temporalio/temporal:1.9.1@sha256:ad4c82c97bd12b417d1ea942610dbcd511afb250c4d5ed26c694009533df447e",
+  "nginx:1.29.6-alpine": "nginx:1.29.6-alpine@sha256:f46cb72c7df02710e693e863a983ac42f6a9579058a59a35f1ae36c9958e4ce0",
+  "supabase/supavisor:2.9.12": "supabase/supavisor:2.9.12@sha256:464b93a60ba8c96bc06dad7f241562d6613b2a994922307717b05f432ae415c2",
+  "supabase/postgres:17.6.1.136": "supabase/postgres:17.6.1.136@sha256:f371b5f3f2ac0a05703f33d6e6134515fb2498cab708fb948a0aeb7481467c00",
+  "kong/kong:3.9.1": "kong/kong:3.9.1@sha256:6addf50e6bd8d578314cb9ce4f2d2d1e3781d2edecef59f707e00c6e05d384f5",
+  "supabase/gotrue:v2.189.0": "supabase/gotrue:v2.189.0@sha256:385184459f57569c54c25209f51f3b2be99ddd7c4ce9e3555b5d3eea8447b7cf",
+  "postgrest/postgrest:v14.12": "postgrest/postgrest:v14.12@sha256:54000f24847d01a2c2302e0041cf0618b875c57fb48507d743cfa9aaa50bf43c",
+  "supabase/realtime:v2.102.3": "supabase/realtime:v2.102.3@sha256:aa1c92c0cf326007563641730ec9da9c60478caa6853887775365fa2c097a471",
+  "supabase/storage-api:v1.60.4": "supabase/storage-api:v1.60.4@sha256:c8eb9858eafec891a97c27125470aaad54703c3f4eb4d55ca7f1bf6c6411febf",
+  "darthsim/imgproxy:v3.30.1": "darthsim/imgproxy:v3.30.1@sha256:3b709e4a0e5e8e0e959b556b7031229202b4b8e7e7d955c517ea7abed68ee34d",
+  "supabase/edge-runtime:v1.74.0": "supabase/edge-runtime:v1.74.0@sha256:2781daf92394db91f7e94129cc3d04ec474ad16a8fe64b3fbeef6e7d557ab120",
+  "busybox:1.37": "busybox:1.37@sha256:a7dbc319b1438115a207e11930dc4bb3e643dcb3ec0bdd694bb36cd8fad289ec",
+} as const;

package/src/harness/log-delta.test.ts

@@ -123,3 +123,20 @@ describe("streamDelta", () => {
     expect(out.delta.length).toBeLessThan(big.length);
   });
 });
+
+test("repeated service incarnations retain both ends within the log cap", async () => {
+  const { mergeServiceLogDeltas, LOG_DELTA_MAX_BYTES } = await import("./log-delta");
+  const earlier = { stdout: "first\n" + "x".repeat(LOG_DELTA_MAX_BYTES), stderr: "old error\n",
+    stdoutTruncated: false, stderrTruncated: true, stdoutReset: false, stderrReset: false,
+    stopped: true, exitCode: 137 };
+  const later = { ...earlier, stdout: "last\n", stderr: "new error\n", stderrTruncated: false,
+    stopped: false, exitCode: 0 };
+  const result = mergeServiceLogDeltas(earlier, later);
+  expect(result.stdout.startsWith("first\n")).toBe(true);
+  expect(result.stdout.endsWith("last\n")).toBe(true);
+  expect(result.stdout.length).toBeLessThan(LOG_DELTA_MAX_BYTES + 100);
+  expect(result.stdoutTruncated).toBe(true);
+  expect(result.stderr).toBe("old error\nnew error\n");
+  expect(result.stderrTruncated).toBe(true);
+  expect(result.stopped).toBe(false);
+});

package/src/harness/log-delta.ts

@@ -98,3 +98,18 @@ export function streamDelta(full: string, marker: number): StreamDelta {
   const capped = capMiddle(delta, LOG_DELTA_MAX_BYTES);
   return { delta: capped.value, total, reset, truncated: capped.truncated };
 }
+
+/** Join successive container incarnations into one bounded per-service delta. */
+export function mergeServiceLogDeltas<T extends {
+  stdout: string; stderr: string;
+  stdoutTruncated: boolean; stderrTruncated: boolean;
+  stdoutReset: boolean; stderrReset: boolean;
+}>(earlier: T, later: T): T {
+  const stdout = capMiddle(earlier.stdout + later.stdout, LOG_DELTA_MAX_BYTES);
+  const stderr = capMiddle(earlier.stderr + later.stderr, LOG_DELTA_MAX_BYTES);
+  return { ...later, stdout: stdout.value, stderr: stderr.value,
+    stdoutTruncated: earlier.stdoutTruncated || later.stdoutTruncated || stdout.truncated,
+    stderrTruncated: earlier.stderrTruncated || later.stderrTruncated || stderr.truncated,
+    stdoutReset: earlier.stdoutReset || later.stdoutReset,
+    stderrReset: earlier.stderrReset || later.stderrReset };
+}

package/src/harness/registry-seed.ts

@@ -1,3 +1,4 @@
+import { BUILTIN_IMAGES } from "./builtin-images.js";
 /** Distribution v2 publication. Blob data stays in containerd, mounted
  * read-only in the registry. Repository metadata and uploads MUST live on
  * the environment rootfs, outside persistent image/build caches. */
@@ -9,7 +10,7 @@ import { canonicalImageReference, type PreparedComponentImage } from "./componen
 export const REGISTRY_DATA = "/var/lib/spectest-registry";
 export const REGISTRY_CONTENT = "/spectest-registry-content";
 export const CONTENT_BLOBS = "io.containerd.content.v1.content/blobs/sha256";
-export const REGISTRY_IMAGE = "registry:2.8.3";
+export const REGISTRY_IMAGE = BUILTIN_IMAGES["registry:2.8.3"];
 export const registryDirectory = (service: string) => `/var/lib/spectest-registries/${service}`;
 
 /** Distribution 2.8 registry/storage/paths.go defines this layout. Seed

package/src/harness/sticky-kubernetes.test.ts

@@ -18,6 +18,7 @@ async function store(root: string, service: string, age = 0) {
 function runner(calls: string[][]): CacheCommand {
   return async (program, args) => {
     calls.push([program, ...args]);
+    if (program === "docker" && args.join(" ") === "image ls -aq --no-trunc") return image;
     if (program === "docker" && args[0] === "inspect") return JSON.stringify({ ExitCode: 0, OOMKilled: false });
     return "";
   };
@@ -86,3 +87,25 @@ test("unclean nested containerd shutdown rejects sealing instead of publishing i
   await expect(cache.close()).rejects.toThrow("Kubernetes cache shutdown failed");
   expect(calls.some(c => c[0] === "rm")).toBe(false);
 });
+
+test("orphaned legacy stores are discarded while healthy stores are maintained", async () => {
+  const root = await temporary();
+  const orphan = await store(root, "old");
+  await writeFile(`${orphan}/store.json`, JSON.stringify({ schema: 1, image: `sha256:${"b".repeat(64)}`, updatedAt: Date.now() }));
+  await store(root, "healthy");
+  const calls: string[][] = [];
+  const cache = await openKubernetesCacheMaintenance(runner(calls), root);
+  expect(calls).toContainEqual(["rm", "-rf", orphan]);
+  expect(calls.filter(c => c[1] === "run")).toHaveLength(1);
+  await cache.close();
+});
+
+test("inventory failure never discards stores", async () => {
+  const root = await temporary(); await store(root, "cluster");
+  const calls: string[][] = [];
+  await expect(openKubernetesCacheMaintenance(async (program, args) => {
+    calls.push([program, ...args]);
+    throw new Error("Docker unavailable");
+  }, root)).rejects.toThrow("Docker unavailable");
+  expect(calls.some(c => c[0] === "rm")).toBe(false);
+});

package/src/harness/sticky-kubernetes.ts

@@ -119,6 +119,10 @@ export async function openKubernetesCacheMaintenance(run: CacheCommand, root = R
     throw error;
   });
   try {
+    // A successful inventory distinguishes orphaned legacy stores from Docker
+    // outages. Only this isolated maintenance copy may discard a store.
+    const available = new Set((await run("docker", ["image", "ls", "-aq", "--no-trunc"]))
+      .split(/\s+/).filter(Boolean));
     for (const service of entries) {
       if (!service.isDirectory() || !SERVICE_NAME.test(service.name)) continue;
       for (const layout of await readdir(`${root}/${service.name}`, { withFileTypes: true })) {
@@ -128,6 +132,14 @@ export async function openKubernetesCacheMaintenance(run: CacheCommand, root = R
         if (descriptor.schema !== 1 || !IMAGE_ID.test(descriptor.image) || !Number.isSafeInteger(descriptor.updatedAt)) {
           throw new Error(`invalid Kubernetes cache descriptor: ${directory}`);
         }
+        if (!available.has(descriptor.image)) {
+          // Older exporters replaced their sole image reference on rebuild.
+          // An obsolete version's store can outlive that image. It is disposable
+          // cache, and must not prevent publishing the healthy stores.
+          console.warn(`Discarding orphaned Kubernetes cache ${directory}: missing runtime image ${descriptor.image}`);
+          await run("rm", ["-rf", directory]);
+          continue;
+        }
         const container = `spectest-k8s-cache-${randomUUID()}`;
         await run("docker", ["run", "-d", "--name", container, "--network", "none", "--privileged", "--stop-signal", "SIGTERM", "--tmpfs", "/run", "--tmpfs", "/var/run",
           "--mount", `type=bind,source=${directory}/containerd,target=${STORE_TARGET}`,

package/src/runtime-service-logs.test.ts

@@ -0,0 +1,74 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+test("stopped service logs survive removal and are emitted only in their owning case", async () => {
+  const root = await mkdtemp(join(tmpdir(), "spectest-stopped-logs-"));
+  try {
+    await mkdir(join(root, "spectest"));
+    await mkdir(join(root, "bin"));
+    await writeFile(join(root, "bin/docker"), `#!/bin/sh
+case "$1" in
+  kill) touch "$SPECTEST_APP_DIR/stopped" ;;
+  rm) touch "$SPECTEST_APP_DIR/removed" ;;
+  run) rm -f "$SPECTEST_APP_DIR/stopped" "$SPECTEST_APP_DIR/removed" ;;
+  inspect) echo 'exited 137' ;;
+  logs)
+    if [ -f "$SPECTEST_APP_DIR/removed" ]; then echo 'container removed' >&2; exit 1; fi
+    if [ -f "$SPECTEST_APP_DIR/stopped" ]; then
+      printf 'startup\nlast diagnostic\n'
+      printf 'failure detail' >&2
+    else printf 'startup\n'; fi ;;
+esac
+`, { mode: 0o755 });
+    await writeFile(join(root, "spectest/index.ts"), `
+      import { defineEnvironment } from ${JSON.stringify(new URL("./index.ts", import.meta.url).href)};
+      const env = defineEnvironment({ name: "logs", services: {
+        agent: { image: { type: "registry", reference: "busybox" } }
+      }});
+      export default env.project([
+        env.test("parent", async () => {}),
+        env.test("stop", async ctx => { await ctx.stopService("agent"); await ctx.stopService("agent"); }),
+        env.test("child", async () => {}),
+        env.test("reuse", async ctx => {
+          const spec = { name: "runtime", image: { type: "registry", reference: "busybox" } };
+          await ctx.startService(spec);
+          await ctx.stopService("runtime");
+          await ctx.startService(spec);
+          await ctx.stopService("runtime");
+        }),
+      ]);
+    `);
+    const script = `
+      import { strict as assert } from "node:assert";
+      import { METHODS } from ${JSON.stringify(new URL("./daemon.ts", import.meta.url).href)};
+      const loaded = await METHODS.load({});
+      const parent = await METHODS.run({caseId: loaded.cases[0].id});
+      assert.equal(parent.serviceLogDeltas[0].stdout, "startup\\n");
+      const stopped = await METHODS.run({caseId: loaded.cases[1].id});
+      assert.equal(stopped.status, "passed", JSON.stringify(stopped));
+      assert.equal(stopped.serviceLogDeltas.length, 1);
+      assert.equal(stopped.serviceLogDeltas[0].stdout, "last diagnostic\\n");
+      assert.equal(stopped.serviceLogDeltas[0].stderr, "failure detail\\n");
+      assert.equal(stopped.serviceLogDeltas[0].stopped, true);
+      assert.equal(stopped.serviceLogDeltas[0].exitCode, 137);
+      const child = await METHODS.run({caseId: loaded.cases[2].id});
+      assert.deepEqual(child.serviceLogDeltas, []);
+      const reuse = await METHODS.run({caseId: loaded.cases[3].id});
+      assert.equal(reuse.status, "passed", JSON.stringify(reuse));
+      const logs = reuse.serviceLogDeltas.find(d => d.service === "runtime");
+      assert.equal(logs.stdout, "startup\\nlast diagnostic\\nstartup\\nlast diagnostic\\n");
+      assert.equal(logs.stderr, "failure detail\\nfailure detail\\n");
+      process.exit(0);
+    `;
+    const child = Bun.spawn([process.execPath, "--eval", script], {
+      env: { ...process.env, SPECTEST_APP_DIR: root, PATH: `${root}/bin:${process.env.PATH}` },
+      stdout: "pipe", stderr: "pipe",
+    });
+    const [code, stdout, stderr] = await Promise.all([
+      child.exited, new Response(child.stdout).text(), new Response(child.stderr).text(),
+    ]);
+    expect(code, stdout + stderr).toBe(0);
+  } finally { await rm(root, { recursive: true, force: true }); }
+}, 20_000);