@wenathlan/devthink 2.0.15 → 2.0.20

package/tests/inboundguard.test.ts

@@ -1,177 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  bucketboundsvalid,
-  bucketconsume,
-  bucketof,
-  connectallowentryof,
-  deferredeventof,
-  deferredready,
-  emptyconnectallow,
-  envelopecheck,
-  origincheckof,
-  portaccept,
-  schemacheck,
-} from "../security.js";
-
-const now = 1_800_000_000_000;
-
-describe("inboundguard", () => {
-  it("rejects unknown fields under schemastrict with the path and the expected shape", () => {
-    const result = schemacheck({
-      command: { kind: "security", allowlist: { add: { origin: "https://example.com" } }, payload: "echo" },
-      schema: { kind: "string", allowlist: "object" },
-    });
-    expect(result.valid).toBe(false);
-    const error = result.errors[0];
-    expect(error?.path).toBe("payload");
-    expect(error?.expected).toBe("absent");
-    expect(error?.found).toBe("string");
-    expect(error?.reason).toMatch(/refuses unknown fields before dispatch/);
-  });
-
-  it("rejects shape mismatches with the expected shape", () => {
-    const result = schemacheck({
-      command: { kind: "execute", stepid: 42 },
-      schema: { kind: "string", stepid: "string" },
-    });
-    expect(result.valid).toBe(false);
-    expect(result.errors[0]).toMatchObject({ path: "stepid", expected: "string", found: "number" });
-  });
-
-  it("rejects missing required fields and accepts commands that match the grammar", () => {
-    const result = schemacheck({
-      command: { kind: "execute" },
-      schema: { kind: "string", stepid: "string" },
-      required: ["stepid"],
-    });
-    expect(result.valid).toBe(false);
-    expect(result.errors[0]?.reason).toMatch(/incomplete command/);
-    expect(
-      schemacheck({
-        command: { kind: "execute", stepid: "s1" },
-        schema: { kind: "string", stepid: "string" },
-        required: ["stepid"],
-      }).valid,
-    ).toBe(true);
-    expect(
-      schemacheck({ command: { kind: "security", read: { runid: "r1" } }, schema: { kind: "string", read: "object" } })
-        .valid,
-    ).toBe(true);
-  });
-
-  it("requires every command envelope to name a declared kind", () => {
-    expect(envelopecheck({ command: { kind: "security" }, knownkinds: ["security", "execute"] }).valid).toBe(true);
-    const unknown = envelopecheck({ command: { kind: "nope" }, knownkinds: ["security", "execute"] });
-    expect(unknown.valid).toBe(false);
-    expect(unknown.errors[0]?.reason).toMatch(/absent from the dispatch registry/);
-    const kindless = envelopecheck({ command: {}, knownkinds: ["security"] });
-    expect(kindless.valid).toBe(false);
-    expect(kindless.errors[0]?.path).toBe("kind");
-  });
-
-  it("originchecks internal senders as this extension itself", () => {
-    const verdict = origincheckof({ senderid: "devthink", extensionid: "devthink", connectallow: [] });
-    expect(verdict.accepted).toBe(true);
-    expect(verdict.reason).toMatch(/this extension itself/);
-  });
-
-  it("drops external senders absent from the connectallow list that ships empty", () => {
-    expect(emptyconnectallow).toEqual([]);
-    const dropped = origincheckof({
-      senderid: "other-extension",
-      senderorigin: "https://sender.example",
-      extensionid: "devthink",
-      connectallow: emptyconnectallow,
-    });
-    expect(dropped.accepted).toBe(false);
-    expect(dropped.reason).toMatch(/drops the message without handler execution/);
-    const allowed = origincheckof({
-      senderid: "other-extension",
-      senderorigin: "https://sender.example",
-      extensionid: "devthink",
-      connectallow: [connectallowentryof({ senderid: "other-extension", displayname: "Reviewed bridge", now })],
-    });
-    expect(allowed.accepted).toBe(true);
-    expect(origincheckof({ extensionid: "devthink", connectallow: [] }).accepted).toBe(false);
-  });
-
-  it("closes ports from senders outside connectallow at the handshake", () => {
-    const accepted = portaccept({
-      portname: "devthinksidepanel",
-      senderid: "devthink",
-      extensionid: "devthink",
-      connectallow: [],
-    });
-    expect(accepted.accepted).toBe(true);
-    expect(accepted.reason).toMatch(/accepted its handshake/);
-    const refused = portaccept({
-      portname: "devthinksidepanel",
-      senderid: "other-extension",
-      extensionid: "devthink",
-      connectallow: [],
-    });
-    expect(refused.accepted).toBe(false);
-    expect(refused.reason).toMatch(/closes at its handshake/);
-  });
-
-  it("builds connectallow entries with their senders and refuses empty ids", () => {
-    const entry = connectallowentryof({
-      senderid: " other-extension ",
-      displayname: " Reviewed bridge ",
-      origin: " https://sender.example ",
-      now,
-    });
-    expect(entry).toMatchObject({
-      senderid: "other-extension",
-      displayname: "Reviewed bridge",
-      origin: "https://sender.example",
-    });
-    expect(() => connectallowentryof({ senderid: "", displayname: "name", now })).toThrow(/sender id/);
-    expect(() => connectallowentryof({ senderid: "id", displayname: " ", now })).toThrow(/display name/);
-  });
-
-  it("validates the ratelimit bounds as positive user values with no hidden ceiling", () => {
-    expect(bucketboundsvalid(1, 100).valid).toBe(true);
-    expect(bucketboundsvalid(0, 100).valid).toBe(false);
-    expect(bucketboundsvalid(-3, 100).valid).toBe(false);
-    expect(bucketboundsvalid(5, 0).valid).toBe(false);
-    expect(() => bucketof({ origin: "https://example.com", sessionid: "s", limit: 0, window: 100, now })).toThrow(
-      /positive user value/,
-    );
-  });
-
-  it("consumes commands inside the bucket bound and defers past it until the window resets", () => {
-    const bucket = bucketof({ origin: "https://example.com", sessionid: "s", limit: 2, window: 1000, now });
-    const first = bucketconsume({ bucket, now });
-    expect(first.allowed).toBe(true);
-    expect(first.bucket.used).toBe(1);
-    const second = bucketconsume({ bucket: first.bucket, now: now + 100 });
-    expect(second.allowed).toBe(true);
-    const third = bucketconsume({ bucket: second.bucket, now: now + 200 });
-    expect(third.allowed).toBe(false);
-    expect(third.deferred).toBe(true);
-    expect(third.resetsat).toBe(now + 1000);
-    expect(third.reason).toMatch(/defers until the window resets/);
-    const reset = bucketconsume({ bucket: second.bucket, now: now + 1000 });
-    expect(reset.allowed).toBe(true);
-    expect(reset.bucket.used).toBe(1);
-    expect(reset.bucket.resetsat).toBe(now + 2000);
-  });
-
-  it("records deferred events that hold until their bucket reset", () => {
-    const deferred = deferredeventof({
-      stepid: "step",
-      kind: "click",
-      origin: "https://example.com",
-      reason: "The bucket holds its bound.",
-      resetsat: now + 500,
-      now,
-    });
-    expect(deferred.resetsat).toBe(now + 500);
-    expect(deferredready(deferred, now + 499)).toBe(false);
-    expect(deferredready(deferred, now + 500)).toBe(true);
-    expect(() => deferredeventof({ stepid: "", kind: "click", origin: "o", reason: "r", resetsat: now, now })).toThrow(
-      /step and kind/,
-    );
-  });
-});

package/tests/lazyload.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { lazymodcatalog, lazymodof, prewarmmodules, resolvelazymod, startupbudgetof, startupcostof } from "../perf.js";
-import { lazybudgetvalid, lazyloadgate } from "../policy.js";
-
-const now = 1_800_000_000_000;
-
-describe("lazymods of the 1.1.68 family", () => {
-  it("declares the heavy modules out of the startup path with their capability requirements ahead of load", () => {
-    const catalog = lazymodcatalog();
-    expect(catalog.length).toBeGreaterThanOrEqual(8);
-    for (const descriptor of catalog) {
-      expect(descriptor.id.trim()).not.toBe("");
-      expect(descriptor.reason).toMatch(/loads behind/i);
-      expect(descriptor.capabilities.length).toBeGreaterThan(0);
-    }
-    expect(catalog.map((descriptor) => descriptor.id)).toContain("capture");
-    expect(catalog.map((descriptor) => descriptor.id)).toContain("compare");
-    expect(catalog.map((descriptor) => descriptor.id)).toContain("export");
-    expect(lazymodof("htmlsnapshot")?.capabilities).toEqual(["parse"]);
-    expect(lazymodof("unknown")).toBeUndefined();
-  });
-
-  it("resolves one lazy module on first use under the same capability check the eager path runs", () => {
-    const granted = resolvelazymod({
-      id: "capture",
-      granted: ["capture"],
-      firstuse: true,
-      duration: 5,
-      now,
-      provenance: { runid: "run1", stepid: "s1" },
-    });
-    expect(granted.resolved).toBe(true);
-    expect(granted.moduleid).toBe("capture");
-    expect(granted.provenance?.runid).toBe("run1");
-    const refused = resolvelazymod({ id: "capture", granted: [], firstuse: true, duration: 3, now });
-    expect(refused.resolved).toBe(false);
-    const unknown = resolvelazymod({ id: "unknown", granted: [], firstuse: true, duration: 1, now });
-    expect(unknown.resolved).toBe(false);
-    expect(unknown.reason).toMatch(/no lazy module/i);
-    const gate = lazyloadgate({ module: lazymodof("capture") as never, granted: [] });
-    expect(gate.allowed).toBe(false);
-    expect(gate.reason).toMatch(/never granted/i);
-    expect(lazyloadgate({ module: lazymodof("capture") as never, granted: ["capture"] }).allowed).toBe(true);
-  });
-
-  it("prewarms the user chosen set on startup while the rest stays lazy", () => {
-    const records = prewarmmodules({ prewarmset: ["capture", "export"], granted: ["capture", "export", "parse"], now });
-    expect(records).toHaveLength(2);
-    expect(records.every((record) => record.resolved)).toBe(true);
-    expect(records.every((record) => record.provenance?.surface === "startup")).toBe(true);
-    const partial = prewarmmodules({ prewarmset: ["capture", "a11ytree"], granted: ["capture"], now });
-    expect(partial.map((record) => record.resolved)).toEqual([true, false]);
-  });
-
-  it("builds the startup budget view and reports overruns without ever refusing a load", () => {
-    const budget = startupbudgetof({ prewarmset: ["capture", "compare", "export"], budget: 2 });
-    expect(budget.prewarmed).toEqual(["capture", "compare", "export"]);
-    expect(budget.lazy.length).toBe(lazymodcatalog().length - 3);
-    expect(budget.total).toBe(lazymodcatalog().length);
-    expect(budget.over).toBe(true);
-    const cost = startupcostof(budget);
-    expect(cost.startupmodules).toBe(3);
-    expect(cost.note).toMatch(/exceeds the user startup budget of 2/i);
-    const unbudgeted = startupbudgetof({ prewarmset: [] });
-    expect(unbudgeted.over).toBe(false);
-    expect(unbudgeted.budget).toBeUndefined();
-    const gate = lazybudgetvalid({ budget: 2, prewarmed: 3 });
-    expect(gate.allowed).toBe(true);
-    expect(lazybudgetvalid({ budget: 0, prewarmed: 1 }).allowed).toBe(false);
-    expect(lazybudgetvalid({ prewarmed: 4 }).allowed).toBe(true);
-  });
-});