@specific.dev/spectest 0.119.2 → 0.119.4

package/dist/daemon.js

@@ -4,6 +4,7 @@ import { runWithBackgroundFailures } from "./harness/background-failures.js";
 import { generateHostCert as mintHostCert } from "./harness/certificate.js";
 import { componentBuildTasks, COMPONENT_RUNTIME } from "./harness/component-images.js";
 import { waitForAll } from "./harness/concurrency.js";
+import { updateServiceProgress, serviceProgressSnapshot } from "./harness/service-progress.js";
 import { androidScope, androidRecordingChunk, releaseAndroidRecording, isAndroidApp } from "./android.js";
 // Long-running HTTP daemon. Runs as a systemd unit on the VM host (not in
 // a container). Owns:
@@ -426,13 +427,14 @@ function bootLogText() {
     return head + BOOT_LOG.lines.join("");
 }
 let BOOTSTRAP_PROGRESS = null;
-function progressInit(services) {
+function progressInit(services, prepared) {
     BOOTSTRAP_PROGRESS = {
         phase: "Preparing images",
         services: services.map((s) => ({
             name: s.name,
             kind: s.image.type === "registry" ? "pull" : "build",
             status: "pending",
+            elapsedMs: prepared?.images[s.name]?.prepMs,
         })),
         startedAt: Date.now(),
         updatedAt: Date.now(),
@@ -451,7 +453,7 @@ function progressService(name, patch) {
     const svc = BOOTSTRAP_PROGRESS.services.find((s) => s.name === name);
     if (!svc)
         return;
-    Object.assign(svc, patch);
+    updateServiceProgress(svc, patch);
     BOOTSTRAP_PROGRESS.updatedAt = Date.now();
 }
 function progressDone() {
@@ -2719,7 +2721,7 @@ async function bootstrapInner(prepared, identity) {
         Object.keys(prepared.images).sort().join("\n") !== tasks.map(s => s.name).sort().join("\n"))) {
         throw new Error("prepared image manifest does not match the environment's services");
     }
-    progressInit(tasks);
+    progressInit(tasks, prepared);
     // Build dedup is only valid within one workspace generation — a fresh
     // bootstrap may follow a workspace re-upload with the same dockerfile
     // text but different build-context content.
@@ -2787,6 +2789,7 @@ async function bootstrapInner(prepared, identity) {
     for (const svc of tasks) {
         const p = (async () => {
             const t0 = Date.now();
+            progressService(svc.name, { status: svc.image.type === "registry" ? "pulling" : "building" });
             prepOffsets.set(svc.name, Date.now() - bootStart);
             const { tag, buildSteps } = await prepImage(svc);
             progressService(svc.name, { status: "prepared", detail: undefined });
@@ -5173,7 +5176,12 @@ export function harnessMethods(state) {
         // Live bootstrap progress, polled by the control plane during
         // `bootstrap` and streamed into the test-run row. `{}` before the
         // first bootstrap of this harness process.
-        progress: async () => BOOTSTRAP_PROGRESS ?? {},
+        progress: async () => {
+            if (!BOOTSTRAP_PROGRESS)
+                return {};
+            const now = Date.now();
+            return { ...BOOTSTRAP_PROGRESS, services: BOOTSTRAP_PROGRESS.services.map(s => serviceProgressSnapshot(s, now)) };
+        },
         /**
          * Live logs for a running environment: the harness's own boot log
          * (bootstrap plus every `setup` hook's console output) and each

package/dist/harness/service-progress.d.ts

@@ -0,0 +1,14 @@
+/** Timing for each service's active build/start work, excluding dependency waits. */
+export type ServiceProgressStatus = "pending" | "pulling" | "building" | "prepared" | "starting" | "probing" | "ready" | "failed";
+export interface ServiceProgress {
+    name: string;
+    kind: "pull" | "build";
+    status: ServiceProgressStatus;
+    detail?: string;
+    elapsedMs?: number;
+    /** Start of the current active interval; omitted from the wire snapshot. */
+    activeSince?: number;
+}
+export declare function updateServiceProgress(service: ServiceProgress, patch: Partial<ServiceProgress>, now?: number): void;
+/** Calculate at poll time, even when the build has emitted no new messages. */
+export declare function serviceProgressSnapshot(service: ServiceProgress, now?: number): Omit<ServiceProgress, "activeSince">;

package/dist/harness/service-progress.js

@@ -0,0 +1,24 @@
+function active(status) {
+    return ["pulling", "building", "starting", "probing"].includes(status);
+}
+export function updateServiceProgress(service, patch, now = Date.now()) {
+    const wasActive = active(service.status);
+    const isActive = active(patch.status ?? service.status);
+    if (!wasActive && isActive) {
+        service.activeSince = now;
+        service.elapsedMs ??= 0;
+    }
+    else if (wasActive && !isActive && service.activeSince !== undefined) {
+        service.elapsedMs = (service.elapsedMs ?? 0) + Math.max(0, now - service.activeSince);
+        service.activeSince = undefined;
+    }
+    Object.assign(service, patch);
+}
+/** Calculate at poll time, even when the build has emitted no new messages. */
+export function serviceProgressSnapshot(service, now = Date.now()) {
+    const { activeSince, ...snapshot } = service;
+    if (activeSince !== undefined) {
+        snapshot.elapsedMs = (service.elapsedMs ?? 0) + Math.max(0, now - activeSince);
+    }
+    return snapshot;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specific.dev/spectest",
-  "version": "0.119.2",
+  "version": "0.119.4",
   "description": "Spectest SDK for defining test environments in TypeScript.",
   "type": "module",
   "main": "./dist/index.js",

package/src/daemon.ts

@@ -4,6 +4,7 @@ import { runWithBackgroundFailures } from "./harness/background-failures.js";
 import { generateHostCert as mintHostCert } from "./harness/certificate.js";
 import { componentBuildTasks, COMPONENT_RUNTIME } from "./harness/component-images.js";
 import { waitForAll } from "./harness/concurrency.js";
+import { updateServiceProgress, serviceProgressSnapshot, type ServiceProgress } from "./harness/service-progress.js";
 import { androidScope, androidRecordingChunk, releaseAndroidRecording, isAndroidApp, type AndroidRecording } from "./android.js";
 // Long-running HTTP daemon. Runs as a systemd unit on the VM host (not in
 // a container). Owns:
@@ -679,24 +680,6 @@ function bootLogText(): string {
 // streams this snapshot into the test-run row, so the web UI shows what's
 // being built *before* the suite starts. In-memory only; reset at the top
 // of each bootstrap(). All updaters no-op when no bootstrap is in flight.
-type ServiceProgressStatus =
-  | "pending"
-  | "pulling"
-  | "building"
-  | "prepared"
-  | "starting"
-  | "probing"
-  | "ready"
-  | "failed";
-
-interface ServiceProgress {
-  name: string;
-  kind: "pull" | "build";
-  status: ServiceProgressStatus;
-  /** Live free-text detail, e.g. "step 4/9 RUN bun install" or "12 layers". */
-  detail?: string;
-}
-
 interface BootstrapProgress {
   phase: string;
   services: ServiceProgress[];
@@ -707,13 +690,14 @@ interface BootstrapProgress {
 
 let BOOTSTRAP_PROGRESS: BootstrapProgress | null = null;
 
-function progressInit(services: NamedService[]): void {
+function progressInit(services: NamedService[], prepared?: PreparedImages): void {
   BOOTSTRAP_PROGRESS = {
     phase: "Preparing images",
     services: services.map((s) => ({
       name: s.name,
       kind: s.image.type === "registry" ? "pull" : "build",
       status: "pending",
+      elapsedMs: prepared?.images[s.name]?.prepMs,
     })),
     startedAt: Date.now(),
     updatedAt: Date.now(),
@@ -731,7 +715,7 @@ function progressService(name: string, patch: Partial<ServiceProgress>): void {
   if (!BOOTSTRAP_PROGRESS) return;
   const svc = BOOTSTRAP_PROGRESS.services.find((s) => s.name === name);
   if (!svc) return;
-  Object.assign(svc, patch);
+  updateServiceProgress(svc, patch);
   BOOTSTRAP_PROGRESS.updatedAt = Date.now();
 }
 
@@ -3254,7 +3238,7 @@ async function bootstrapInner(prepared?: PreparedImages, identity?: string): Pro
       Object.keys(prepared.images).sort().join("\n") !== tasks.map(s => s.name).sort().join("\n"))) {
     throw new Error("prepared image manifest does not match the environment's services");
   }
-  progressInit(tasks);
+  progressInit(tasks, prepared);
   // Build dedup is only valid within one workspace generation — a fresh
   // bootstrap may follow a workspace re-upload with the same dockerfile
   // text but different build-context content.
@@ -3324,6 +3308,7 @@ async function bootstrapInner(prepared?: PreparedImages, identity?: string): Pro
   for (const svc of tasks) {
     const p = (async () => {
       const t0 = Date.now();
+      progressService(svc.name, { status: svc.image.type === "registry" ? "pulling" : "building" });
       prepOffsets.set(svc.name, Date.now() - bootStart);
       const { tag, buildSteps } = await prepImage(svc);
       progressService(svc.name, { status: "prepared", detail: undefined });
@@ -6193,7 +6178,11 @@ export function harnessMethods(state: RouteState): MethodTable {
     // Live bootstrap progress, polled by the control plane during
     // `bootstrap` and streamed into the test-run row. `{}` before the
     // first bootstrap of this harness process.
-    progress: async () => BOOTSTRAP_PROGRESS ?? {},
+    progress: async () => {
+      if (!BOOTSTRAP_PROGRESS) return {};
+      const now = Date.now();
+      return { ...BOOTSTRAP_PROGRESS, services: BOOTSTRAP_PROGRESS.services.map(s => serviceProgressSnapshot(s, now)) };
+    },
 
     /**
      * Live logs for a running environment: the harness's own boot log

package/src/harness/service-progress.test.ts

@@ -0,0 +1,48 @@
+import { expect, test } from "bun:test";
+import { serviceProgressSnapshot, updateServiceProgress, type ServiceProgress } from "./service-progress";
+
+function service(): ServiceProgress {
+  return { name: "api", kind: "build", status: "pending" };
+}
+
+test("measures quiet builds without resetting on status or detail updates", () => {
+  const s = service();
+  expect(serviceProgressSnapshot(s, 1000).elapsedMs).toBeUndefined();
+  updateServiceProgress(s, { status: "building" }, 1000);
+  updateServiceProgress(s, { status: "building", detail: "RUN install" }, 2000);
+  expect(serviceProgressSnapshot(s, 6000).elapsedMs).toBe(5000);
+  expect(serviceProgressSnapshot(s, 6000)).not.toHaveProperty("activeSince");
+  expect(s.elapsedMs).toBe(0); // Polling must not accumulate the interval twice.
+  expect(serviceProgressSnapshot(s, 7000).elapsedMs).toBe(6000);
+});
+
+test("freezes while prepared, resumes for startup, and keeps the ready duration", () => {
+  const s = service();
+  updateServiceProgress(s, { status: "pulling" }, 1000);
+  updateServiceProgress(s, { status: "prepared" }, 5000);
+  updateServiceProgress(s, { status: "prepared", detail: undefined }, 6000);
+  expect(serviceProgressSnapshot(s, 20000).elapsedMs).toBe(4000);
+  updateServiceProgress(s, { status: "starting" }, 20000);
+  updateServiceProgress(s, { status: "probing" }, 21000);
+  updateServiceProgress(s, { status: "probing", detail: "running setup" }, 22000);
+  expect(serviceProgressSnapshot(s, 23000).elapsedMs).toBe(7000);
+  updateServiceProgress(s, { status: "ready" }, 24000);
+  expect(serviceProgressSnapshot(s, 30000).elapsedMs).toBe(8000);
+});
+
+test("retains elapsed time on failure and never returns a negative interval", () => {
+  const s = service();
+  updateServiceProgress(s, { status: "building" }, 1000);
+  expect(serviceProgressSnapshot(s, 500).elapsedMs).toBe(0);
+  updateServiceProgress(s, { status: "failed" }, 3000);
+  expect(serviceProgressSnapshot(s, 20000).elapsedMs).toBe(2000);
+});
+
+test("carries image preparation time across a separate builder handoff", () => {
+  const s = { ...service(), elapsedMs: 12500 };
+  updateServiceProgress(s, { status: "building" }, 1000);
+  updateServiceProgress(s, { status: "prepared" }, 1100);
+  updateServiceProgress(s, { status: "starting" }, 3000);
+  updateServiceProgress(s, { status: "ready" }, 4000);
+  expect(serviceProgressSnapshot(s, 9000).elapsedMs).toBe(13600);
+});

package/src/harness/service-progress.ts

@@ -0,0 +1,40 @@
+/** Timing for each service's active build/start work, excluding dependency waits. */
+export type ServiceProgressStatus =
+  | "pending" | "pulling" | "building" | "prepared"
+  | "starting" | "probing" | "ready" | "failed";
+
+export interface ServiceProgress {
+  name: string;
+  kind: "pull" | "build";
+  status: ServiceProgressStatus;
+  detail?: string;
+  elapsedMs?: number;
+  /** Start of the current active interval; omitted from the wire snapshot. */
+  activeSince?: number;
+}
+
+function active(status: ServiceProgressStatus): boolean {
+  return ["pulling", "building", "starting", "probing"].includes(status);
+}
+
+export function updateServiceProgress(service: ServiceProgress, patch: Partial<ServiceProgress>, now = Date.now()): void {
+  const wasActive = active(service.status);
+  const isActive = active(patch.status ?? service.status);
+  if (!wasActive && isActive) {
+    service.activeSince = now;
+    service.elapsedMs ??= 0;
+  } else if (wasActive && !isActive && service.activeSince !== undefined) {
+    service.elapsedMs = (service.elapsedMs ?? 0) + Math.max(0, now - service.activeSince);
+    service.activeSince = undefined;
+  }
+  Object.assign(service, patch);
+}
+
+/** Calculate at poll time, even when the build has emitted no new messages. */
+export function serviceProgressSnapshot(service: ServiceProgress, now = Date.now()): Omit<ServiceProgress, "activeSince"> {
+  const { activeSince, ...snapshot } = service;
+  if (activeSince !== undefined) {
+    snapshot.elapsedMs = (service.elapsedMs ?? 0) + Math.max(0, now - activeSince);
+  }
+  return snapshot;
+}