@wenathlan/devthink 2.0.12 → 2.0.14

package/tests/recipes.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, it } from "vitest";
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { runrecipessuite } from "./recipes.mjs";
+import type { recipereport } from "./recipes.mjs";
+
+const execute = promisify(execFile);
+const gallerypath = "tests/code/recipes/gallery.json";
+const recipesdirectory = "tests/code/recipes";
+const pagesdirectory = "tests/code/pages";
+const artifactpath = "tests/artifacts/recipes.json";
+const expectedcategories = { scraping: 8, forms: 9, testing: 8, monitoring: 6, agents: 5 };
+
+/** One gallery index entry with the metadata the runner validates. */
+interface galleryentry {
+  id: string;
+  category: string;
+  difficulty: string;
+  description: string;
+  fixture: string;
+  origin: string;
+  expecteddurationms: number;
+  capabilities: string[];
+  consentclasses: string[];
+  kinds: string[];
+  exportformat?: string;
+  schedule?: string;
+  topology?: string;
+}
+
+/** The gallery index of the 36 recipes: the index metadata beside the fixture page declarations. */
+interface galleryindex {
+  version: string;
+  fixturepages: Array<{ name: string; origin: string; features: string[] }>;
+  entries: galleryentry[];
+}
+
+/** One recipe plan document the directory carries: the origin and the steps the grammar and lint checks read. */
+interface recipedocument {
+  origin: string;
+  grants?: string[];
+  steps: Array<{ id: string; kind: string; options?: string }>;
+}
+
+/** Collects every action kind one recipe names: the top level step kinds beside the child kinds nested in the control payloads of the options (the parallel branches, the loop bodies and the branch paths), so the grammar check reads the same surface the runner reads. */
+function kindswithin(recipe: recipedocument): string[] {
+  const kinds: string[] = [];
+  const walk = (value: unknown) => {
+    if (Array.isArray(value)) {
+      for (const item of value) walk(item);
+      return;
+    }
+    if (value === null || typeof value !== "object") return;
+    const candidate = value as Record<string, unknown>;
+    if (typeof candidate.kind === "string") kinds.push(candidate.kind);
+    for (const child of Object.values(candidate)) walk(child);
+  };
+  for (const step of recipe.steps) {
+    kinds.push(step.kind);
+    if (step.options !== undefined) {
+      try {
+        walk(JSON.parse(step.options));
+      } catch {
+        /* the option grammar check of the runner reports the malformed payload */
+      }
+    }
+  }
+  return [...new Set(kinds)];
+}
+
+/* ── The 2.0.0 example gallery coverage: the source grammar pass, the suite run over the built tree and the recorded artifact. ── */
+
+describe("the example gallery of the 2.0.0 release", () => {
+  it("parses every recipe with the lowercase kind grammar and the category metadata the index declares", async () => {
+    const gallery = JSON.parse(await readFile(gallerypath, "utf8")) as galleryindex;
+    expect(gallery.entries.length).toBe(36);
+    /* no gallery entry id duplicates: the index names every recipe exactly once */
+    expect(new Set(gallery.entries.map((entry) => entry.id)).size).toBe(36);
+    /* every recipe file of the directory other than the index joins the index, and every index entry names its file */
+    const recipefiles = (await readdir(recipesdirectory))
+      .filter((file) => file.endsWith(".json") && file !== "gallery.json")
+      .sort();
+    expect(recipefiles.length).toBe(36);
+    const recipes = new Map<string, recipedocument>();
+    for (const file of recipefiles) {
+      const parsed = JSON.parse(await readFile(join(recipesdirectory, file), "utf8")) as recipedocument;
+      recipes.set(file.replace(".json", ""), parsed);
+    }
+    expect(new Set([...recipes.keys(), ...gallery.entries.map((entry) => entry.id)]).size).toBe(36);
+    /* every step kind stays lowercase letter only: the workflow step grammar rejects digits (the a11ytree incident), so the gallery ships no kind the compose engine would refuse */
+    const digitkinds = [...recipes].flatMap(([id, recipe]) =>
+      kindswithin(recipe)
+        .filter((kind) => !/^[a-z]+$/.test(kind))
+        .map((kind) => `${id} carries ${kind}`),
+    );
+    expect(digitkinds).toEqual([]);
+    /* the monitoring entries declare their five field cron schedules, the agent entries their topologies and the scraping entries their export formats */
+    for (const entry of gallery.entries) {
+      if (entry.category === "monitoring")
+        expect(entry.schedule).toMatch(/^(\*|\d+)(\/\d+)? (\*|\d+) (\*|\d+) (\*|\d+) (\*|\d+)$/);
+      if (entry.category !== "monitoring") expect(entry.schedule).toBeUndefined();
+      if (entry.category === "agents")
+        expect(["swarm", "review", "parallel", "monitor", "compete"]).toContain(entry.topology);
+      if (entry.category !== "agents") expect(entry.topology).toBeUndefined();
+      if (entry.category === "scraping") expect(["csv", "json", "excel"]).toContain(entry.exportformat);
+      if (entry.category !== "scraping") expect(entry.exportformat).toBeUndefined();
+    }
+  });
+
+  it("runs the gallery suite green over the built tree", { timeout: 120_000 }, async () => {
+    const built = existsSync("dist/gallery.json");
+    /* the suite needs the built fixture copies the packages ship, so a lane without a build asserts the source pass only */
+    if (!built) return;
+    const report = await runrecipessuite();
+    expect(report.gallery.entries).toBe(36);
+    expect(report.gallery.fixtures).toBe(4);
+    expect(report.gallery.categories).toEqual(expectedcategories);
+    expect(report.summary.entries).toBe(36);
+    expect(report.summary.passed).toBe(36);
+    expect(report.summary.failed).toBe(0);
+    expect(report.summary.checksok).toBe(report.summary.checks);
+    expect(report.checks.every((check) => check.ok)).toBe(true);
+    expect(report.entries.length).toBe(36);
+    expect(report.entries.every((entry) => entry.outcome === "pass")).toBe(true);
+    expect(report.entries.every((entry) => entry.durationms >= 0)).toBe(true);
+  });
+
+  it("covers every gallery entry of the index in the recorded artifact", { timeout: Number(process.env.DEVTHINK_TEST_TIMEOUT_MS ?? 120000) }, async () => {
+    const built = existsSync("dist/gallery.json");
+    const packagejson = JSON.parse(await readFile("package.json", "utf8")) as { version: string };
+    /* a built tree runs the gate itself when no fresh artifact of this release exists, so every lane that builds before the suite verifies the gallery artifact without depending on gate ordering */
+    if (built && !existsSync(artifactpath)) await execute("node", ["tests/recipes.mjs"]);
+    if (built && existsSync(artifactpath)) {
+      const stored = JSON.parse(await readFile(artifactpath, "utf8")) as { release: string };
+      if (stored.release !== packagejson.version) await execute("node", ["tests/recipes.mjs"]);
+    }
+    const stored = existsSync(artifactpath);
+    if (built) expect(stored).toBe(true);
+    if (!stored) return;
+    const gallery = JSON.parse(await readFile(gallerypath, "utf8")) as galleryindex;
+    const report = JSON.parse(await readFile(artifactpath, "utf8")) as recipereport;
+    /* the artifact answers the current release with every entry passing and every check ok */
+    expect(report.release).toBe(packagejson.version);
+    expect(report.gallery.entries).toBe(36);
+    expect(report.gallery.categories).toEqual(expectedcategories);
+    expect(report.summary.failed).toBe(0);
+    expect(report.summary.passed).toBe(report.summary.entries);
+    expect(report.summary.checksok).toBe(report.summary.checks);
+    /* the recorded entries cover every entry of the gallery index exactly, each with a passing outcome and a recorded duration */
+    expect(report.entries.map((entry) => entry.id).sort()).toEqual(gallery.entries.map((entry) => entry.id).sort());
+    expect(report.entries.every((entry) => entry.outcome === "pass")).toBe(true);
+    expect(report.entries.every((entry) => entry.durationms >= 0)).toBe(true);
+    /* the four fixture pages ship beside the recipes in the sources and in the built fixture set the packages carry */
+    const sourcepages = new Set((await readdir(pagesdirectory)).filter((file) => file.endsWith(".html")));
+    for (const page of gallery.fixturepages) {
+      expect(sourcepages.has(page.name)).toBe(true);
+      if (built) expect(existsSync(join("dist", "fixtures", "pages", page.name))).toBe(true);
+    }
+  });
+});

package/tests/redactshots.test.ts

@@ -0,0 +1,216 @@
+import { describe, expect, it } from "vitest";
+import {
+  capturesurfaceof,
+  fieldshaperegions,
+  mergeregions,
+  redactedshot,
+  redactionsummary,
+  regionof,
+  regionvalid,
+  regionsfor,
+  templateof,
+} from "../capture.js";
+
+const now = 1_800_000_000_000;
+
+describe("redactshots", () => {
+  it("builds regions with finite positive geometry and a plain language reason", () => {
+    const region = regionof({
+      origin: "https://bank.example",
+      template: "login",
+      x: 10,
+      y: 20,
+      width: 200,
+      height: 40,
+      reason: "The card number field the user masked.",
+      source: "userdrawn",
+      now,
+    });
+    expect(region.id).not.toBe("");
+    expect(region.x).toBe(10);
+    expect(region.source).toBe("userdrawn");
+    expect(regionvalid(region)).toBe(true);
+    expect(() =>
+      regionof({
+        origin: "https://bank.example",
+        template: "login",
+        x: -1,
+        y: 0,
+        width: 10,
+        height: 10,
+        reason: "r",
+        source: "userdrawn",
+        now,
+      }),
+    ).toThrow(/non-negative/);
+    expect(() =>
+      regionof({
+        origin: "https://bank.example",
+        template: "login",
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 10,
+        reason: "r",
+        source: "userdrawn",
+        now,
+      }),
+    ).toThrow(/positive width/);
+    expect(() =>
+      regionof({
+        origin: "",
+        template: "login",
+        x: 0,
+        y: 0,
+        width: 10,
+        height: 10,
+        reason: "r",
+        source: "userdrawn",
+        now,
+      }),
+    ).toThrow(/origin/);
+    expect(() =>
+      regionof({
+        origin: "https://bank.example",
+        template: "login",
+        x: 0,
+        y: 0,
+        width: 10,
+        height: 10,
+        reason: "  ",
+        source: "userdrawn",
+        now,
+      }),
+    ).toThrow(/reason/);
+  });
+
+  it("derives regions from the sensitive field shapes of a form layout", () => {
+    const regions = fieldshaperegions({
+      origin: "https://bank.example",
+      template: "login",
+      fields: [
+        { name: "username", rect: { x: 0, y: 0, width: 100, height: 20 } },
+        { name: "password", rect: { x: 0, y: 30, width: 100, height: 20 } },
+        { name: "cardnumber", rect: { x: 0, y: 60, width: 100, height: 20 } },
+      ],
+      now,
+    });
+    expect(regions).toHaveLength(2);
+    expect(regions.every((region) => region.source === "fieldshape")).toBe(true);
+    expect(regions[0]?.reason).toMatch(/password field carries a sensitive field shape/);
+  });
+
+  it("scopes the regions of one origin and one page template only", () => {
+    const region = regionof({
+      origin: "https://bank.example",
+      template: "login",
+      x: 0,
+      y: 0,
+      width: 10,
+      height: 10,
+      reason: "masked",
+      source: "userdrawn",
+      now,
+    });
+    expect(regionsfor([region], "https://bank.example", "login")).toHaveLength(1);
+    expect(regionsfor([region], "https://bank.example", "checkout")).toHaveLength(0);
+    expect(regionsfor([region], "https://other.example", "login")).toHaveLength(0);
+  });
+
+  it("merges drawn regions while keeping one record per geometry", () => {
+    const one = regionof({
+      origin: "https://bank.example",
+      template: "login",
+      x: 0,
+      y: 0,
+      width: 10,
+      height: 10,
+      reason: "first",
+      source: "userdrawn",
+      now,
+    });
+    const same = regionof({
+      origin: "https://bank.example",
+      template: "login",
+      x: 0,
+      y: 0,
+      width: 10,
+      height: 10,
+      reason: "duplicate",
+      source: "userdrawn",
+      now,
+    });
+    const other = regionof({
+      origin: "https://bank.example",
+      template: "login",
+      x: 50,
+      y: 50,
+      width: 10,
+      height: 10,
+      reason: "second",
+      source: "userdrawn",
+      now,
+    });
+    expect(mergeregions([one], [same, other])).toHaveLength(2);
+  });
+
+  it("covers viewport, element and stitched captures alike", () => {
+    expect(capturesurfaceof("shotview")).toBe("viewport");
+    expect(capturesurfaceof("element")).toBe("element");
+    expect(capturesurfaceof("shotfullpage")).toBe("stitched");
+    expect(capturesurfaceof("contactsheet")).toBe("stitched");
+    expect(capturesurfaceof("recordscreen")).toBe("stitched");
+  });
+
+  it("reads the template of a capture step from its reviewed options", () => {
+    expect(templateof({ kind: "shotview", options: JSON.stringify({ template: "checkout" }) })).toBe("checkout");
+    expect(templateof({ kind: "shotview" })).toBe("shotview");
+    expect(templateof({ kind: "shotview", options: "not json" })).toBe("shotview");
+  });
+
+  it("marks stored captures with their redaction evidence before storage", () => {
+    const record = { id: "shot", kind: "shotview", bytes: "data:image/png;base64,AAA" };
+    expect(redactedshot(record, [])).toEqual(record);
+    const masked = redactedshot(record, [
+      regionof({
+        origin: "https://bank.example",
+        template: "login",
+        x: 0,
+        y: 0,
+        width: 10,
+        height: 10,
+        reason: "masked",
+        source: "userdrawn",
+        now,
+      }),
+    ]);
+    expect(masked.redacted).toBe(true);
+    expect(masked.redactedregions).toBe(1);
+  });
+
+  it("summarises the redaction evidence for the audit trail", () => {
+    const regions = [
+      regionof({
+        origin: "https://bank.example",
+        template: "login",
+        x: 0,
+        y: 0,
+        width: 10,
+        height: 10,
+        reason: "the card field",
+        source: "userdrawn",
+        now,
+      }),
+      ...fieldshaperegions({
+        origin: "https://bank.example",
+        template: "login",
+        fields: [{ name: "password", rect: { x: 0, y: 20, width: 10, height: 10 } }],
+        now,
+      }),
+    ];
+    const summary = redactionsummary(regions);
+    expect(summary).toMatch(/2 redact regions/);
+    expect(summary).toMatch(/1 derived from sensitive field shapes and 1 drawn by the user/);
+    expect(redactionsummary([])).toMatch(/No redact region/);
+  });
+});

package/tests/registernvidiakeys.ts

@@ -0,0 +1,51 @@
+/**
+ * register-nvidia-keys.ts
+ * registers 22 nvidia api keys into the db nvidiaKey table
+ * source: extracted from git blobs in the original gateway repo
+ * run with: bun run scripts/register-nvidia-keys.ts
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { db } from "../database";
+
+async function main() {
+  console.log("[register-nvidia-keys] starting...");
+
+  const keysFile = join(process.cwd(), "scripts", "nvidia-keys.json");
+  const keysRaw = readFileSync(keysFile, "utf8");
+  const keys = JSON.parse(keysRaw) as Array<{ label: string; key: string }>;
+
+  console.log("[register-nvidia-keys] loaded", keys.length, "keys from", keysFile);
+
+  /** clear existing keys */
+  console.log("[register-nvidia-keys] clearing existing keys...");
+  await db.nvidiaKey.deleteMany({});
+
+  /** register the 22 keys */
+  console.log("[register-nvidia-keys] registering", keys.length, "keys...");
+  for (const k of keys) {
+    await db.nvidiaKey.create({
+      data: {
+        keyValue: k.key,
+        label: k.label,
+        active: true,
+        status: "active",
+        errorCount: 0,
+        successCount: 0,
+      },
+    });
+    console.log("[register-nvidia-keys] registered:", k.label);
+  }
+
+  /** verify */
+  const count = await db.nvidiaKey.count({ where: { active: true, status: "active" } });
+  console.log("[register-nvidia-keys] SUCCESS - total active keys:", count);
+
+  await db.$disconnect();
+}
+
+main().catch((err) => {
+  console.error("[register-nvidia-keys] ERROR:", err.message);
+  process.exit(1);
+});