@wenathlan/devthink 2.0.12 → 2.0.14

package/tests/runresume.test.ts

@@ -0,0 +1,184 @@
+import { describe, expect, it } from "vitest";
+import {
+  foldplannedvisits,
+  navdedupeverdict,
+  runcachedigest,
+  runcachehit,
+  runcachesweep,
+  resumepointof,
+  revalidatefingerprint,
+  skipcompletedsteps,
+  stepprefetchhints,
+} from "../run.js";
+import { resumefingerprintgate, sessionreusegate, stepprefetchgate } from "../policy.js";
+import { sessioncontainerof, sessionreusegrantof } from "../run.js";
+import { sessionmemory } from "../memory.js";
+
+const now = 1_800_000_000_000;
+
+class fakeadapter {
+  private readonly data = new Map<string, unknown>();
+  async get<T>(key: string): Promise<T | undefined> {
+    return this.data.get(key) as T | undefined;
+  }
+  async set<T>(key: string, value: T): Promise<void> {
+    this.data.set(key, value);
+  }
+}
+
+describe("efficientresume", () => {
+  it("checkpoints each step boundary with a cursor and a digest", () => {
+    const point = resumepointof({ runid: "run1", stepid: "s1", cursor: 1, digest: "fp1", now });
+    expect(point).toEqual({ runid: "run1", stepid: "s1", cursor: 1, digest: "fp1", at: now });
+    expect(() => resumepointof({ runid: "run1", stepid: "s1", cursor: 1, digest: " ", now })).toThrow(/digest/i);
+  });
+
+  it("skips the completed steps after a restart and resumes at the first open step", () => {
+    const checkpoints = [
+      resumepointof({ runid: "run1", stepid: "s1", cursor: 1, digest: "fp1", now }),
+      resumepointof({ runid: "run1", stepid: "s2", cursor: 2, digest: "fp2", now }),
+    ];
+    const skip = skipcompletedsteps({ checkpoints, steps: ["s1", "s2", "s3"] });
+    expect(skip.skip).toEqual(["s1", "s2"]);
+    expect(skip.resumeat).toBe("s3");
+    const complete = skipcompletedsteps({ checkpoints, steps: ["s1", "s2"] });
+    expect(complete.resumeat).toBeUndefined();
+  });
+
+  it("revalidates the page fingerprint before it resumes and refuses a changed page", () => {
+    const checkpoint = resumepointof({ runid: "run1", stepid: "s2", cursor: 2, digest: "fp2", now });
+    expect(revalidatefingerprint({ checkpoint, fingerprint: "fp2" }).ok).toBe(true);
+    const changed = revalidatefingerprint({ checkpoint, fingerprint: "fp9" });
+    expect(changed.ok).toBe(false);
+    expect(changed.reason).toMatch(/refuses/i);
+    expect(resumefingerprintgate({ checkpoint, fingerprint: "fp2" }).allowed).toBe(true);
+    expect(resumefingerprintgate({ checkpoint, fingerprint: "fp9" }).allowed).toBe(false);
+  });
+});
+
+describe("navdedupe", () => {
+  it("skips navigations to the already active url", () => {
+    expect(navdedupeverdict({ url: "https://example.com/a", activeurl: "https://example.com/a" }).skip).toBe(true);
+    expect(navdedupeverdict({ url: "https://example.com/a", activeurl: "https://example.com/b" }).skip).toBe(false);
+    expect(navdedupeverdict({ url: "", activeurl: "https://example.com/a" }).skip).toBe(false);
+  });
+
+  it("folds repeated planned visits into one navigation per url", () => {
+    const folded = foldplannedvisits([
+      { id: "s1", url: "https://example.com/a" },
+      { id: "s2", url: "https://example.com/b" },
+      { id: "s3", url: "https://example.com/a" },
+      { id: "s4" },
+    ]);
+    expect(folded).toHaveLength(2);
+    expect(folded.find((entry) => entry.url === "https://example.com/a")?.stepids).toEqual(["s1", "s3"]);
+  });
+});
+
+describe("runcache", () => {
+  it("stores fetched resources per run keyed by digest and serves the repeat fetches of the same run", () => {
+    const digest = runcachedigest({ runid: "run1", resource: "https://example.com/data" });
+    expect(digest).toBe("run1:https://example.com/data");
+    expect(() => runcachedigest({ runid: " ", resource: "https://example.com/data" })).toThrow(/run id/i);
+    const entry = { runid: "run1", digest, resource: "https://example.com/data", storedat: now, pinned: false };
+    expect(runcachehit([entry], { runid: "run1", resource: "https://example.com/data" })).toEqual(entry);
+    expect(runcachehit([entry], { runid: "run2", resource: "https://example.com/data" })).toBeUndefined();
+  });
+
+  it("clears at the run end unless the user pins the profile cache", () => {
+    const entries = [
+      { runid: "run1", digest: "run1:a", resource: "a", storedat: now, pinned: false },
+      { runid: "run2", digest: "run2:b", resource: "b", storedat: now, pinned: false },
+      { runid: "run1", digest: "run1:c", resource: "c", storedat: now, pinned: true },
+    ];
+    const swept = runcachesweep(entries, { runid: "run1", pin: false });
+    expect(swept.cleared).toBe(1);
+    expect(swept.kept).toHaveLength(2);
+    const pinned = runcachesweep(entries, { runid: "run1", pin: true });
+    expect(pinned.cleared).toBe(0);
+    expect(pinned.kept).toHaveLength(3);
+  });
+
+  it("sweeps the stored runcache entries through the memory store", async () => {
+    const store = new sessionmemory(new fakeadapter());
+    await store.addruncacheentry({ runid: "run1", digest: "run1:a", resource: "a", storedat: now, pinned: false });
+    await store.addruncacheentry({ runid: "run2", digest: "run2:b", resource: "b", storedat: now, pinned: false });
+    const sweep = await store.sweepruncache("run1", false);
+    expect(sweep.cleared).toBe(1);
+    expect(await store.getruncache()).toHaveLength(1);
+    const held = await store.sweepruncache("run2", true);
+    expect(held.cleared).toBe(0);
+  });
+});
+
+describe("stepprefetch", () => {
+  it("warms the likely next pages and selectors from the plan structure alone", () => {
+    const hints = stepprefetchhints({
+      steps: [
+        { id: "s1", kind: "navigate", value: "https://example.com/a" },
+        { id: "s2", kind: "click", target: "#button" },
+        { id: "s3", kind: "navigate", value: "https://example.com/b" },
+        { id: "s4", kind: "click", target: "#button" },
+      ],
+    });
+    expect(hints[0]?.page).toBe("https://example.com/b");
+    expect(hints[0]?.selectors).toEqual(["#button"]);
+    expect(hints[1]?.page).toBe("https://example.com/b");
+    expect(hints[3]?.page).toBeUndefined();
+    const plannedpages = ["https://example.com/a", "https://example.com/b"];
+    const plannedselectors = ["#button"];
+    expect(stepprefetchgate({ hint: hints[1]!, plannedpages, plannedselectors }).allowed).toBe(true);
+    expect(
+      stepprefetchgate({ hint: { page: "https://evil.example/x", selectors: [] }, plannedpages, plannedselectors })
+        .allowed,
+    ).toBe(false);
+    expect(stepprefetchgate({ hint: { selectors: ["#secret"] }, plannedpages, plannedselectors }).allowed).toBe(false);
+  });
+});
+
+describe("sessionreuse", () => {
+  it("attaches an authenticated profile to a run only through its explicit per profile consent prompt", () => {
+    const grant = sessionreusegrantof({
+      profile: "work",
+      container: "work:run1",
+      promptid: "prompt1",
+      consentedat: now,
+      runid: "run1",
+    });
+    expect(grant.profile).toBe("work");
+    expect(
+      sessionreusegate({
+        grant: {
+          profile: grant.profile,
+          promptid: grant.promptid,
+          consentedat: grant.consentedat,
+          ...(grant.runid !== undefined ? { runid: grant.runid } : {}),
+        },
+      }).allowed,
+    ).toBe(true);
+    expect(sessionreusegate({ grant: { profile: "work", promptid: "", consentedat: now } }).allowed).toBe(false);
+    expect(sessionreusegate({ grant: { profile: "work", promptid: "prompt1", consentedat: 0 } }).allowed).toBe(false);
+    expect(() => sessionreusegrantof({ profile: " ", container: "c", promptid: "p", consentedat: now })).toThrow(
+      /profile/i,
+    );
+  });
+
+  it("isolates the cookies per task through separate containers", () => {
+    expect(sessioncontainerof({ profile: "work", taskid: "run1" })).toBe("work:run1");
+    expect(sessioncontainerof({ profile: "work", taskid: "run2" })).not.toBe(
+      sessioncontainerof({ profile: "work", taskid: "run1" }),
+    );
+    expect(() => sessioncontainerof({ profile: "work", taskid: " " })).toThrow(/task id/i);
+  });
+
+  it("stores the sessionreuse grants of the profile workspace", async () => {
+    const store = new sessionmemory(new fakeadapter());
+    await store.addsessionreusegrant(
+      sessionreusegrantof({ profile: "work", container: "work:run1", promptid: "prompt1", consentedat: now }),
+    );
+    await store.addsessionreusegrant(
+      sessionreusegrantof({ profile: "work", container: "work:run2", promptid: "prompt1", consentedat: now }),
+    );
+    expect(await store.getsessionreusegrants()).toHaveLength(1);
+  });
+});

package/tests/runstate.test.ts

@@ -0,0 +1,288 @@
+import { describe, expect, it } from "vitest";
+import {
+  acquirerunlock,
+  beatrun,
+  closerun,
+  expirerunlocks,
+  exportrunstate,
+  markpending,
+  openrun,
+  prunerunstates,
+  reattachrun,
+  recordenvironment,
+  recordturnaround,
+  recordurl,
+  recoveryplan,
+  releaserunlock,
+  sealrunstate,
+  serializesteps,
+  zombiesweep,
+  openseal,
+} from "../run.js";
+
+const now = 1_000;
+const interval = 30_000;
+
+function run(overrides: Partial<ReturnType<typeof openrun>> = {}) {
+  return {
+    ...openrun({ runid: "run1", sessionid: "session1", planid: "plan1", profileid: "profile1", interval, now }),
+    ...overrides,
+  };
+}
+
+describe("run state and keepalive", () => {
+  it("opens the typed run state with its start event and an open keepalive port", () => {
+    const state = openrun({
+      runid: "run1",
+      sessionid: "session1",
+      planid: "plan1",
+      profileid: "profile1",
+      interval,
+      now,
+    });
+    expect(state.state).toBe("active");
+    expect(state.keepalive.portopen).toBe(true);
+    expect(state.keepalive.beats).toBe(0);
+    expect(state.keepalive.events).toHaveLength(1);
+    expect(state.keepalive.events[0]).toMatchObject({ kind: "start", at: now });
+    expect(() => openrun({ runid: " ", sessionid: "s", planid: "p", profileid: "d", interval, now })).toThrow(
+      /run and session ids/i,
+    );
+    expect(() => openrun({ runid: "r", sessionid: "s", planid: "p", profileid: "d", interval: 0, now })).toThrow(
+      /positive user value/i,
+    );
+  });
+
+  it("emits one keepalive heartbeat per beat and closes the port at the terminal state", () => {
+    let state = run();
+    state = beatrun(state, now + interval);
+    state = beatrun(state, now + interval * 2);
+    expect(state.keepalive.beats).toBe(2);
+    expect(state.keepalive.lastbeatat).toBe(now + interval * 2);
+    expect(state.keepalive.events.filter((event) => event.kind === "heartbeat")).toHaveLength(2);
+    const closed = closerun(state, now + interval * 3);
+    expect(closed.keepalive.state).toBe("stopped");
+    expect(closed.keepalive.portopen).toBe(false);
+    expect(closed.state).toBe("completed");
+    expect(closed.keepalive.events[closed.keepalive.events.length - 1]?.kind).toBe("stop");
+    expect(() => beatrun(closed, now + interval * 4)).toThrow(/stopped/);
+    expect(() => closerun(closed, now + interval * 5)).toThrow(/already stopped/);
+  });
+
+  it("reattaches the keepalive port after a service worker restart from the persisted state", () => {
+    const state = reattachrun(run(), now + 5_000);
+    expect(state.state).toBe("recovered");
+    expect(state.keepalive.portopen).toBe(true);
+    expect(state.keepalive.events.some((event) => event.kind === "reattach")).toBe(true);
+    expect(() => reattachrun(closerun(run(), now + 1), now + 2)).toThrow(/never reattaches/);
+  });
+
+  it("records the url history, the environment and the worker turnaround of every step", () => {
+    let state = run();
+    state = recordurl(state, { url: "https://example.com/start", stepid: "s1", now: now + 1 });
+    state = recordurl(state, { url: "https://example.com/list", stepid: "s2", now: now + 2 });
+    state = recordurl(state, { url: "https://example.com/start", stepid: "s1", now: now + 3 });
+    expect(state.urlhistory).toHaveLength(2);
+    state = recordenvironment(state, {
+      stepid: "s2",
+      environment: "offscreenworker",
+      origin: "https://example.com",
+      now: now + 4,
+    });
+    expect(state.environments.s2).toBe("offscreenworker");
+    expect(state.lastprovenance).toEqual({
+      origin: "https://example.com",
+      stepid: "s2",
+      environment: "offscreenworker",
+    });
+    state = recordturnaround(state, { stepid: "s2", milliseconds: 42, now: now + 5 });
+    expect(state.turnarounds.s2).toBe(42);
+    expect(() => recordurl(state, { url: " ", stepid: "s1", now: now + 6 })).toThrow(/url/i);
+    expect(() =>
+      recordenvironment(state, { stepid: " ", environment: "pagecontext", origin: "o", now: now + 6 }),
+    ).toThrow(/step id/i);
+    expect(() => recordturnaround(state, { stepid: "s1", milliseconds: -1, now: now + 6 })).toThrow(/non-negative/i);
+  });
+
+  it("resumes exactly the pending step after a service worker restart", () => {
+    const withpending = markpending(run(), "s3", now + 1);
+    const plan = recoveryplan(withpending);
+    expect(plan).toMatchObject({ runid: "run1", pendingstepid: "s3", recoverable: true });
+    expect(plan.reason).toMatch(/resumes the pending step s3/i);
+    expect(recoveryplan(run()).recoverable).toBe(false);
+    expect(recoveryplan(closerun(run(), now + 1)).reason).toMatch(/completed before the restart/i);
+    expect(recoveryplan(markpending(run(), "s3", now)).reason).toMatch(/resumes the pending step/i);
+    const reaped = zombiesweep({
+      states: [markpending(run(), "s3", now)],
+      now: now + interval * 4,
+      interval,
+      missedlimit: 3,
+    }).states[0];
+    expect(recoveryplan(reaped as ReturnType<typeof openrun>).reason).toMatch(/reaped as a zombie/i);
+  });
+
+  it("detects and reaps zombie runs whose heartbeat fell silent past the tolerated intervals", () => {
+    const live = beatrun(run(), now + interval * 3);
+    const silent = run({ runid: "run2" });
+    const stopped = closerun(run({ runid: "run3" }), now + 1);
+    const sweep = zombiesweep({
+      states: [live, silent, stopped],
+      now: now + interval * 3 + 1,
+      interval,
+      missedlimit: 3,
+    });
+    expect(sweep.reaped).toEqual(["run2"]);
+    const reaped = sweep.states.find((state) => state.runid === "run2");
+    expect(reaped?.state).toBe("reaped");
+    expect(reaped?.keepalive.state).toBe("stopped");
+    expect(reaped?.keepalive.portopen).toBe(false);
+    expect(sweep.states.find((state) => state.runid === "run1")?.state).toBe("active");
+    expect(sweep.states.find((state) => state.runid === "run3")?.state).toBe("completed");
+    const tolerant = zombiesweep({ states: [silent], now: now + interval * 3 - 1, interval, missedlimit: 3 });
+    expect(tolerant.reaped).toEqual([]);
+    expect(zombiesweep({ states: [live], now: now + interval * 4, interval, missedlimit: 4 }).reaped).toEqual([]);
+    expect(() => zombiesweep({ states: [], now, interval: 0, missedlimit: 3 })).toThrow(/positive user value/i);
+    expect(() => zombiesweep({ states: [], now, interval, missedlimit: 0 })).toThrow(/positive whole number/i);
+  });
+
+  it("locks one session against concurrent runs through the storage level run lock", () => {
+    const acquired = acquirerunlock({ locks: [], sessionid: "session1", runid: "run1", holder: "executor", now });
+    expect(acquired.acquired).toBe(true);
+    const concurrent = acquirerunlock({
+      locks: acquired.locks,
+      sessionid: "session1",
+      runid: "run2",
+      holder: "executor",
+      now: now + 1,
+    });
+    expect(concurrent.acquired).toBe(false);
+    expect(concurrent.reason).toMatch(/never carries two concurrent runs/i);
+    const same = acquirerunlock({
+      locks: acquired.locks,
+      sessionid: "session1",
+      runid: "run1",
+      holder: "executor",
+      now: now + 2,
+    });
+    expect(same.acquired).toBe(true);
+    const other = acquirerunlock({
+      locks: acquired.locks,
+      sessionid: "session2",
+      runid: "run9",
+      holder: "executor",
+      now: now + 3,
+    });
+    expect(other.acquired).toBe(true);
+    expect(other.locks).toHaveLength(2);
+    const released = releaserunlock({ locks: acquired.locks, sessionid: "session1", runid: "run1", now: now + 4 });
+    expect(released.released).toBe(true);
+    expect(released.locks).toHaveLength(0);
+    expect(releaserunlock({ locks: acquired.locks, sessionid: "session1", runid: "runX", now: now + 5 }).released).toBe(
+      false,
+    );
+    expect(() => acquirerunlock({ locks: [], sessionid: " ", runid: "r", holder: "h", now })).toThrow(
+      /session and run ids/i,
+    );
+  });
+
+  it("expires the run locks past their user configured expiry while locks without one keep holding", () => {
+    const locks = acquirerunlock({
+      locks: [],
+      sessionid: "session1",
+      runid: "run1",
+      holder: "executor",
+      expiresat: now + 100,
+      now,
+    }).locks;
+    const withother = acquirerunlock({
+      locks,
+      sessionid: "session2",
+      runid: "run2",
+      holder: "executor",
+      now: now + 1,
+    }).locks;
+    const expired = expirerunlocks(withother, now + 200);
+    expect(expired.expired).toEqual(["session1"]);
+    expect(expired.locks.map((lock) => lock.sessionid)).toEqual(["session2"]);
+    expect(expirerunlocks(withother, now + 50).expired).toEqual([]);
+  });
+
+  it("serializes the steps that share one tab across parallel branches", () => {
+    const order = serializesteps({
+      branches: [
+        {
+          branchid: "a",
+          steps: [
+            { stepid: "a1", tabid: 1 },
+            { stepid: "a2", tabid: 2 },
+          ],
+        },
+        {
+          branchid: "b",
+          steps: [
+            { stepid: "b1", tabid: 1 },
+            { stepid: "b2", tabid: 3 },
+          ],
+        },
+      ],
+    });
+    expect(order.map((entry) => entry.stepid)).toEqual(["a1", "b1", "a2", "b2"]);
+    expect(order.filter((entry) => entry.tabid === 1).map((entry) => entry.order)).toEqual([0, 1]);
+    const single = serializesteps({
+      branches: [
+        { branchid: "a", steps: [{ stepid: "a1", tabid: 7 }] },
+        { branchid: "b", steps: [{ stepid: "b1", tabid: 8 }] },
+      ],
+    });
+    expect(single.map((entry) => entry.stepid)).toEqual(["a1", "b1"]);
+    expect(serializesteps({ branches: [] })).toEqual([]);
+  });
+
+  it("seals the persisted run state with its integrity digest and refuses a tampered seal", async () => {
+    const state = recordenvironment(run(), {
+      stepid: "s1",
+      environment: "pagecontext",
+      origin: "https://example.com",
+      now,
+    });
+    const sealed = await sealrunstate(state);
+    expect(sealed.algorithm).toBe("sha-256");
+    expect(sealed.digest).toMatch(/^[0-9a-f]{64}$/);
+    const opened = await openseal(sealed);
+    expect(opened.runid).toBe("run1");
+    expect(opened.environments.s1).toBe("pagecontext");
+    const tampered = { ...sealed, payload: sealed.payload.replace("run1", "runX") };
+    await expect(openseal(tampered)).rejects.toThrow(/integrity digest/i);
+    const broken = { ...sealed, digest: "0".repeat(64) };
+    await expect(openseal(broken)).rejects.toThrow(/integrity digest/i);
+  });
+
+  it("prunes the oldest finished run states under storage pressure while active runs keep their state", () => {
+    const active = run();
+    const finishedone = closerun(run({ runid: "old" }), now + 1);
+    const finishedtwo = closerun(run({ runid: "newer" }), now + 5);
+    const nopressure = prunerunstates({ states: [active, finishedone, finishedtwo], used: 100, ceiling: 1_000 });
+    expect(nopressure.pruned).toEqual([]);
+    const pressure = prunerunstates({ states: [active, finishedone, finishedtwo], used: 2_000, ceiling: 1_000 });
+    expect(pressure.pruned).toContain("old");
+    expect(pressure.pruned).not.toContain("run1");
+    expect(pressure.states.some((state) => state.runid === "run1")).toBe(true);
+    expect(pressure.reason).toMatch(/storage pressure/i);
+    expect(prunerunstates({ states: [active], used: 2_000, ceiling: 0 }).pruned).toEqual([]);
+  });
+
+  it("exports the run states as one single audit record", () => {
+    let first = run();
+    first = recordurl(first, { url: "https://example.com/a", stepid: "s1", now: now + 1 });
+    first = recordenvironment(first, {
+      stepid: "s1",
+      environment: "offscreenworker",
+      origin: "https://example.com",
+      now: now + 2,
+    });
+    first = recordturnaround(first, { stepid: "s1", milliseconds: 12, now: now + 3 });
+    const second = beatrun(run({ runid: "run2" }), now + 4);
+    const exported = exportrunstate([first, second], now + 10);
+    expect(exported).toEqual({ runs: 2, urls: 1, environments: 1, offloaded: 1, beats: 1, exportedat: now + 10 });
+  });
+});