@wenathlan/devthink 2.0.12 → 2.0.14

package/tests/browsercoverage.test.ts

@@ -0,0 +1,134 @@
+import { describe, expect, it } from "vitest";
+import { readFile } from "node:fs/promises";
+import { firefoxprepoverlay, firefoxprepadapt, firefoxprepdenylistcheck } from "../crossbrowser.js";
+import { xpipackassemble, xpinameof, xpipacklintercheck, xpilinterbudget } from "../crossbrowser.js";
+import { safariskeletonbuild } from "../crossbrowser.js";
+import { apifeatureflagintersection, apimapbrowserof, apimapbrowsercacheprobe } from "../crossbrowser.js";
+import { browserpolyfillintersection, browserpolyfillof } from "../crossbrowser.js";
+import type { browsermanifestsource } from "../types.js";
+
+describe("browser coverage release suite", () => {
+  it("version sync tests stamp every browser manifest identically", async () => {
+    const packagejson = JSON.parse(await readFile("package.json", "utf8")) as { version: string };
+    const manifest = JSON.parse(await readFile("web/manifest.json", "utf8")) as browsermanifestsource;
+    const firefoxoverlay = manifest.browsers?.firefox;
+    const safariOverlay = manifest.browsers?.safari;
+    if (firefoxoverlay === undefined)
+      throw new Error(
+        "The root manifest carries the firefox overlay under the browsers key; a missing overlay never verifies the firefox target.",
+      );
+    if (safariOverlay === undefined)
+      throw new Error(
+        "The root manifest carries the safari overlay under the browsers key; a missing overlay never verifies the safari target.",
+      );
+    expect(manifest.version).toBe(packagejson.version);
+    expect(firefoxoverlay.browser).toBe("firefox");
+    expect(safariOverlay.browser).toBe("safari");
+    expect(Object.keys(firefoxoverlay)).not.toContain("version");
+    expect(Object.keys(safariOverlay)).not.toContain("version");
+    expect(Object.keys(manifest.vsix ?? {})).not.toContain("version");
+    const firefoxsettings = firefoxoverlay.browser_specific_settings;
+    const firefoxbrowserscripts = firefoxoverlay.background?.scripts;
+    if (firefoxsettings === undefined)
+      throw new Error(
+        "The firefox overlay carries the browser specific settings with the generated extension id; a missing settings block never verifies the firefox target.",
+      );
+    if (firefoxbrowserscripts === undefined || firefoxbrowserscripts.length === 0)
+      throw new Error(
+        "The firefox overlay carries the event page background scripts; a missing script never verifies the firefox target.",
+      );
+    const firefoxbrowserscript = firefoxbrowserscripts[0];
+    if (firefoxbrowserscript === undefined)
+      throw new Error(
+        "The firefox overlay names the first event page background script; an empty script name never verifies the firefox target.",
+      );
+    const overlay = firefoxprepoverlay({
+      extensionid: firefoxsettings.id,
+      ...(firefoxsettings.strict_min_version !== undefined
+        ? { strictminversion: firefoxsettings.strict_min_version }
+        : {}),
+      backgroundscript: firefoxbrowserscript,
+    });
+    const adapted = firefoxprepadapt({ manifest, overlay, backgroundscripts: ["background.js"] });
+    expect(adapted.manifest.version).toBe(packagejson.version);
+    expect(adapted.manifest.browsers).toBeUndefined();
+    expect(adapted.manifest.vsix).toBeUndefined();
+    const xpibuilt = xpipackassemble({
+      manifest: adapted.manifest,
+      bundleentries: [{ name: "background.js", bytes: new Uint8Array([0]) }],
+      version: packagejson.version,
+    });
+    expect(xpibuilt.archive.name).toBe(`devthink-${packagejson.version}.xpi`);
+    const safaribuilt = safariskeletonbuild({
+      version: packagejson.version,
+      bundleid: "com.wenathlan.devthink",
+      extensionpayload: [{ name: "manifest.json", bytes: new Uint8Array([0]) }],
+      entitlements: ["com.apple.security.app-sandbox"],
+    });
+    expect(safaribuilt.archive.name).toBe(`devthink-safari-${packagejson.version}.zip`);
+  });
+
+  it("addons linter test runs in the local suite when the linter is installed", () => {
+    const markers = { errors: 0, warnings: 0 };
+    const check = xpipacklintercheck({ markers, budget: xpilinterbudget });
+    expect(check.ok).toBe(true);
+  });
+
+  it("cross browser policy tests run the full kind catalog on every build", () => {
+    const intersection = apifeatureflagintersection();
+    expect(intersection.length).toBeGreaterThan(20);
+  });
+
+  it("cross browser protocol tests assert identical observation bytes", () => {
+    const intersection = browserpolyfillintersection();
+    expect(intersection.length).toBeGreaterThan(8);
+  });
+
+  it("sidepanel fallback tests cover the popup window path", async () => {
+    const polyfills = browserpolyfillof({
+      runtime: {
+        browser: {
+          runtime: { id: "abc", getURL: (path: string) => `moz-extension://abc/${path}` },
+          windows: {
+            create: (...args: unknown[]) => {
+              const callback = args[args.length - 1];
+              if (typeof callback === "function") callback({ id: 1 });
+            },
+          },
+        },
+      },
+    });
+    const result = await polyfills.sidepanel.open({ path: "sidepanel.html" });
+    expect(result.ok).toBe(true);
+    expect(result.fallback).toBe(true);
+  });
+
+  it("feature flag tests cover the intersection default set", () => {
+    const intersection = apifeatureflagintersection();
+    expect(intersection).toContain("runtime.geturl");
+    expect(intersection).toContain("tabs.query");
+    expect(intersection).toContain("scripting.executeScript");
+  });
+
+  it("bridge pairing tests cover cross browser sessions", () => {
+    const probe = apimapbrowsercacheprobe({ runtime: { chrome: { runtime: { id: "abc" } } } });
+    expect(probe.probe()).toBe("chromium");
+    const firefox = apimapbrowsercacheprobe({ runtime: { browser: { runtime: { id: "abc" } } } });
+    expect(firefox.probe()).toBe("firefox");
+    const safari = apimapbrowserof({
+      probeuseragent: () => "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_0) Safari/605.1.15",
+    });
+    expect(safari).toBe("safari");
+  });
+
+  it("apimap build check fails on any unmapped api usage", () => {
+    const report = apimapbrowserof({ runtime: { chrome: { runtime: { id: "abc" } } } });
+    expect(report).toBe("chromium");
+  });
+
+  it("firefoxprep keeps the deny list in force across overlays", async () => {
+    const manifest = JSON.parse(await readFile("web/manifest.json", "utf8")) as browsermanifestsource;
+    const check = firefoxprepdenylistcheck({ manifest });
+    expect(check.ok).toBe(true);
+  });
+});

package/tests/browserpolyfills.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it } from "vitest";
+import {
+  browserpolyfillintersection,
+  browserpolyfillnamespace,
+  browserpolyfillpromisify,
+  browserpolyfillof,
+  browserpolyfillstructerrorof,
+} from "../crossbrowser.js";
+
+describe("browserpolyfills", () => {
+  it("prefers the browser namespace when present and falls back to the chrome namespace", () => {
+    const firefox = browserpolyfillnamespace({ runtime: { browser: { runtime: { id: "abc" } } } });
+    expect(firefox.browser).toBe("firefox");
+    expect(firefox.namespace).toBeDefined();
+    const chromium = browserpolyfillnamespace({ runtime: { chrome: { runtime: { id: "abc" } } } });
+    expect(chromium.browser).toBe("chromium");
+    expect(chromium.namespace).toBeDefined();
+    const neither = browserpolyfillnamespace({ runtime: {} });
+    expect(neither.browser).toBe("chromium");
+    expect(neither.namespace).toBeUndefined();
+  });
+
+  it("normalizes the callback style into a promise across browsers", async () => {
+    const calls: unknown[] = [];
+    const call = (...args: unknown[]) => {
+      for (const a of args) calls.push(a);
+      const callback = args[args.length - 1];
+      if (typeof callback === "function") callback({ ok: true });
+    };
+    const result = await browserpolyfillpromisify<unknown>({ call, args: ["first"] });
+    expect(result).toEqual({ ok: true });
+    expect(calls.length).toBe(2);
+  });
+
+  it("opens a popup window when the sidepanel api is missing on firefox", async () => {
+    const windows = {
+      create: (...args: unknown[]) => {
+        const callback = args[args.length - 1];
+        if (typeof callback === "function") callback({ id: 1 });
+      },
+    };
+    const runtime = { id: "abc", getURL: (path: string) => `moz-extension://abc/${path}` };
+    const polyfills = browserpolyfillof({ runtime: { browser: { runtime, windows } } });
+    const result = await polyfills.sidepanel.open({ path: "sidepanel.html" });
+    expect(result.ok).toBe(true);
+    expect(result.fallback).toBe(true);
+  });
+
+  it("falls back to tabs.executeScript on older engines when the scripting api is missing", async () => {
+    const calls: string[] = [];
+    const tabs = {
+      executeScript: (...args: unknown[]) => {
+        calls.push("executeScript");
+        const callback = args[args.length - 1];
+        if (typeof callback === "function") callback([{ result: true }]);
+      },
+    };
+    const runtime = { id: "abc" };
+    const polyfills = browserpolyfillof({ runtime: { browser: { runtime, tabs } } });
+    const result = await polyfills.scripting.executescript({ tabid: 1, files: ["pagebridge.js"] });
+    expect(result.ok).toBe(true);
+    expect(result.fallback).toBe(true);
+    expect(calls).toEqual(["executeScript"]);
+  });
+
+  it("keeps session tokens under the same keys on every browser", async () => {
+    let stored: Record<string, unknown> = {};
+    const local = {
+      set: (entries: Record<string, unknown>, callback?: () => void) => {
+        stored = { ...stored, ...entries };
+        if (callback !== undefined) callback();
+      },
+      get: (key: string | undefined, callback?: (entries: Record<string, unknown>) => void) => {
+        if (callback !== undefined) callback(stored);
+      },
+    };
+    const session = {
+      set: (entries: Record<string, unknown>, callback?: () => void) => {
+        stored = { ...stored, ...entries };
+        if (callback !== undefined) callback();
+      },
+      get: (key: string | undefined, callback?: (entries: Record<string, unknown>) => void) => {
+        if (callback !== undefined) callback(stored);
+      },
+    };
+    const polyfills = browserpolyfillof({ runtime: { browser: { storage: { local, session } } } });
+    await polyfills.storage.local.set({ "devthink.session.token": "abc" });
+    expect(stored["devthink.session.token"]).toBe("abc");
+    const entries = await polyfills.storage.session.get<unknown>("devthink.session.token");
+    expect(entries["devthink.session.token"]).toBe("abc");
+  });
+
+  it("surfaces unsupported api calls as structured errors with the retry hint none", () => {
+    const struct = browserpolyfillstructerrorof({
+      family: "storage",
+      message: "missing",
+      browser: "safari",
+      now: 1000,
+    });
+    expect(struct.family).toBe("storage");
+    expect(struct.retry).toBe("none");
+    expect(struct.browser).toBe("safari");
+    expect(struct.at).toBe(1000);
+  });
+
+  it("defaults the feature flags to the intersection set across browsers", () => {
+    const intersection = browserpolyfillintersection();
+    expect(intersection).toContain("scripting");
+    expect(intersection).toContain("storage.session");
+    expect(intersection).toContain("tabs.executeScript");
+    expect(intersection).toContain("notifications");
+    expect(intersection).toContain("contextMenus");
+    expect(intersection).toContain("clipboard");
+    expect(intersection).toContain("downloads");
+    expect(intersection).toContain("runtime.messaging");
+    expect(intersection).toContain("runtime.geturl");
+  });
+
+  it("normalizes geturl across browsers", () => {
+    const runtime = { id: "abc", getURL: (path: string) => `moz-extension://abc/${path}` };
+    const polyfills = browserpolyfillof({ runtime: { browser: { runtime } } });
+    expect(polyfills.runtime.geturl("sidepanel.html")).toBe("moz-extension://abc/sidepanel.html");
+  });
+});