Something went wrong. Try again.
[READ-ONLY] Mirror of https://github.com/improsocial/impro
An extensible Bluesky client for web impro.social
Something went wrong. Try again.
JavaScript
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054import { describe, it, afterEach } from "node:test";import assert from "node:assert/strict";import { SourceProvider } from "/js/plugins/sourceProvider.js";
function jsonResponse(body, { ok = true, status = 200 } = {}) { return { ok, status, async json() { return body; }, async text() { return typeof body === "string" ? body : JSON.stringify(body); }, };}
// Installs a stub for `fetch` (used by SourceProvider for local plugins) on// both globalThis and window. Returns `{ calls, restore }`.function stubFetch(handler) { const calls = []; const fetchImpl = async (url, options) => { calls.push({ url, options }); return handler(url, options); }; const originalGlobal = globalThis.fetch; const originalWindow = globalThis.window.fetch; globalThis.fetch = fetchImpl; globalThis.window.fetch = fetchImpl; return { calls, restore() { globalThis.fetch = originalGlobal; globalThis.window.fetch = originalWindow; }, };}
function fakePluginCache(handler) { const calls = []; return { calls, async fetch(url, options) { calls.push({ url, options }); return handler(url); }, };}
describe("SourceProvider with local plugins", () => { let stub; afterEach(() => stub?.restore());
it("fetches local manifest from /plugins-local/ and appends __LOCAL", async () => { stub = stubFetch(async () => jsonResponse({ id: "alpha", name: "Alpha", version: "1.0.0" }), ); const provider = new SourceProvider(null); const manifest = await provider.getManifest("alpha__LOCAL"); assert.deepEqual( stub.calls[0].url, "/plugins-local/alpha__LOCAL/manifest.json", ); assert.deepEqual(manifest.id, "alpha__LOCAL"); assert.deepEqual(manifest.version, "1.0.0"); });
it("fetches local source from /plugins-local/", async () => { stub = stubFetch(async () => jsonResponse("alert(1)")); const provider = new SourceProvider(null); const source = await provider.getSource("alpha__LOCAL"); assert.deepEqual(stub.calls[0].url, "/plugins-local/alpha__LOCAL/main.js"); assert.deepEqual(source, "alert(1)"); });
it("rejects local manifest with mismatched id", async () => { stub = stubFetch(async () => jsonResponse({ id: "different", name: "A", version: "1.0.0" }), ); const provider = new SourceProvider(null); let caught = null; try { await provider.getManifest("alpha__LOCAL"); } catch (error) { caught = error; } assert(caught?.message.includes("does not match")); });
it("throws when local manifest is missing required fields", async () => { stub = stubFetch(async () => jsonResponse({ id: "alpha", name: "A" })); const provider = new SourceProvider(null); let caught = null; try { await provider.getManifest("alpha__LOCAL"); } catch (error) { caught = error; } assert(caught?.message.includes("version")); });
it("throws when local manifest fetch fails", async () => { stub = stubFetch(async () => ({ ok: false, status: 404 })); const provider = new SourceProvider(null); let caught = null; try { await provider.getManifest("alpha__LOCAL"); } catch (error) { caught = error; } assert.deepEqual(caught?.message, "HTTP 404"); });
it("getCacheUrls returns empty for local plugins", async () => { const provider = new SourceProvider(null); assert.deepEqual(await provider.getCacheUrls("alpha__LOCAL"), []); });
it("getStyles returns local styles.css text", async () => { stub = stubFetch(async () => ({ ok: true, status: 200, async text() { return "body{color:red}"; }, })); const provider = new SourceProvider(null); const styles = await provider.getStyles("alpha__LOCAL"); assert.deepEqual( stub.calls[0].url, "/plugins-local/alpha__LOCAL/styles.css", ); assert.deepEqual(styles, "body{color:red}"); });
it("getStyles returns null when local styles.css is missing", async () => { stub = stubFetch(async () => ({ ok: false, status: 404 })); const provider = new SourceProvider(null); const styles = await provider.getStyles("alpha__LOCAL"); assert.deepEqual(styles, null); });
it("getLiveManifest delegates to getManifest for local plugins", async () => { stub = stubFetch(async () => jsonResponse({ id: "alpha", name: "Alpha", version: "9.9.9" }), ); const provider = new SourceProvider(null); const manifest = await provider.getLiveManifest("alpha__LOCAL"); assert.deepEqual(manifest.version, "9.9.9"); assert.deepEqual(manifest.id, "alpha__LOCAL"); });});
describe("SourceProvider with remote plugins", () => { it("fetches manifest from versioned release URL via plugin cache", async () => { const pluginCache = fakePluginCache(async () => jsonResponse({ id: "alpha", name: "A", version: "1.0.0" }), ); const provider = new SourceProvider(pluginCache); const manifest = await provider.getManifest("alpha", "1.0.0", "ow/alpha"); assert.deepEqual( pluginCache.calls[0].url, "https://raw.githubusercontent.com/ow/alpha/refs/tags/1.0.0/manifest.json", ); assert.deepEqual(manifest.id, "alpha"); });
it("fetches source from the version that was passed in", async () => { const pluginCache = fakePluginCache(async () => ({ ok: true, status: 200, async text() { return "alert(1)"; }, })); const provider = new SourceProvider(pluginCache); const source = await provider.getSource("alpha", "2.5.0", "ow/alpha"); assert.deepEqual( pluginCache.calls[0].url, "https://raw.githubusercontent.com/ow/alpha/refs/tags/2.5.0/main.js", ); assert.deepEqual(source, "alert(1)"); });
it("throws when version or repo is omitted for a remote plugin", async () => { const provider = new SourceProvider(fakePluginCache(async () => null)); let caught = null; try { await provider.getManifest("alpha"); } catch (error) { caught = error; } assert(caught?.message.includes("Version and repo are required"));
caught = null; try { await provider.getSource("alpha", "1.0.0"); } catch (error) { caught = error; } assert(caught?.message.includes("Version and repo are required")); });
it("rejects remote manifest with mismatched id", async () => { const pluginCache = fakePluginCache(async () => jsonResponse({ id: "different", name: "A", version: "1.0.0" }), ); const provider = new SourceProvider(pluginCache); let caught = null; try { await provider.getManifest("alpha", "1.0.0", "ow/alpha"); } catch (error) { caught = error; } assert(caught?.message.includes("does not match")); });
it("getCacheUrls includes manifest, main.js, and styles.css URLs", async () => { const provider = new SourceProvider(null); const urls = await provider.getCacheUrls("alpha", "1.2.3", "ow/alpha"); assert.deepEqual(urls, [ "https://raw.githubusercontent.com/ow/alpha/refs/tags/1.2.3/manifest.json", "https://raw.githubusercontent.com/ow/alpha/refs/tags/1.2.3/main.js", "https://raw.githubusercontent.com/ow/alpha/refs/tags/1.2.3/styles.css", ]); });
it("getStyles fetches styles.css for remote plugins via the cache", async () => { const pluginCache = fakePluginCache(async () => ({ ok: true, status: 200, async text() { return "body{color:blue}"; }, })); const provider = new SourceProvider(pluginCache); const styles = await provider.getStyles("alpha", "1.0.0", "ow/alpha"); assert.deepEqual( pluginCache.calls[0].url, "https://raw.githubusercontent.com/ow/alpha/refs/tags/1.0.0/styles.css", ); assert.deepEqual(pluginCache.calls[0].options, { doCacheNotFound: true }); assert.deepEqual(styles, "body{color:blue}"); });
it("getLiveManifest fetches from githubusercontent main branch", async () => { const stub = stubFetch(async () => jsonResponse({ id: "alpha", name: "A", version: "9.9.9" }), ); try { const provider = new SourceProvider(null); const manifest = await provider.getLiveManifest("alpha", "ow/alpha"); assert.deepEqual( stub.calls[0].url, "https://raw.githubusercontent.com/ow/alpha/refs/heads/main/manifest.json", ); assert.deepEqual(stub.calls[0].options?.cache, "no-store"); assert.deepEqual(manifest.version, "9.9.9"); } finally { stub.restore(); } });
it("getLiveManifestFromRepo fetches from githubusercontent main branch", async () => { const stub = stubFetch(async () => jsonResponse({ id: "alpha", name: "A", version: "1.0.0" }), ); try { const provider = new SourceProvider(null); const manifest = await provider.getLiveManifestFromRepo("ow/alpha"); assert.deepEqual( stub.calls[0].url, "https://raw.githubusercontent.com/ow/alpha/refs/heads/main/manifest.json", ); assert.deepEqual(manifest.id, "alpha"); } finally { stub.restore(); } });
it("accepts an explicit github: prefix on the repo", async () => { const pluginCache = fakePluginCache(async () => jsonResponse({ id: "alpha", name: "A", version: "1.0.0" }), ); const provider = new SourceProvider(pluginCache); const manifest = await provider.getManifest( "alpha", "1.0.0", "github:ow/alpha", ); assert.deepEqual( pluginCache.calls[0].url, "https://raw.githubusercontent.com/ow/alpha/refs/tags/1.0.0/manifest.json", ); assert.deepEqual(manifest.id, "alpha"); });
it("getCacheUrls strips the github: prefix from URLs", async () => { const provider = new SourceProvider(null); const urls = await provider.getCacheUrls( "alpha", "1.2.3", "github:ow/alpha", ); assert.deepEqual(urls, [ "https://raw.githubusercontent.com/ow/alpha/refs/tags/1.2.3/manifest.json", "https://raw.githubusercontent.com/ow/alpha/refs/tags/1.2.3/main.js", "https://raw.githubusercontent.com/ow/alpha/refs/tags/1.2.3/styles.css", ]); });
it("getStyles returns null when remote styles.css 404s", async () => { const pluginCache = fakePluginCache(async () => { const error = new Error( "HTTP 404 https://raw.githubusercontent.com/ow/alpha/refs/tags/1.0.0/styles.css", ); error.status = 404; throw error; }); const provider = new SourceProvider(pluginCache); const styles = await provider.getStyles("alpha", "1.0.0", "ow/alpha"); assert.deepEqual(styles, null); });});
function woff2Bytes(extra = 8) { const bytes = new Uint8Array(4 + extra); bytes[0] = 0x77; bytes[1] = 0x4f; bytes[2] = 0x46; bytes[3] = 0x32; return bytes;}
function woffBytes(extra = 8) { const bytes = new Uint8Array(4 + extra); bytes[0] = 0x77; bytes[1] = 0x4f; bytes[2] = 0x46; bytes[3] = 0x46; return bytes;}
function fontResponse(bytes) { return { ok: true, status: 200, async arrayBuffer() { return bytes.buffer.slice( bytes.byteOffset, bytes.byteOffset + bytes.byteLength, ); }, };}
describe("parsePluginManifest fonts", () => { const base = { id: "alpha", name: "A", version: "1.0.0" };
async function parseViaLocal(manifest) { const stub = stubFetch(async () => jsonResponse(manifest)); try { return await new SourceProvider(null).getManifest("alpha__LOCAL"); } finally { stub.restore(); } }
it("accepts a valid fonts array and preserves author fields", async () => { const manifest = await parseViaLocal({ ...base, fonts: [ { family: "MyFont", file: "fonts/myfont.woff2" }, { family: "MyFont", file: "fonts/myfont-bold.woff2", weight: "700", style: "italic", }, ], }); assert.deepEqual(manifest.fonts, [ { family: "MyFont", file: "fonts/myfont.woff2" }, { family: "MyFont", file: "fonts/myfont-bold.woff2", weight: "700", style: "italic", }, ]); });
it("rejects fonts that is not an array", async () => { let caught = null; try { await parseViaLocal({ ...base, fonts: "nope" }); } catch (error) { caught = error; } assert(caught?.message.includes("fonts must be an array")); });
const bad = [ [{ file: "fonts/f.woff2" }, `missing required field "family"`], [{ family: "F" }, `missing required field "file"`], [{ family: "F", file: "fonts/f.ttf" }, "must end in .woff2 or .woff"], [{ family: "F", file: "/abs.woff2" }, "must be a relative path"], [ { family: "F", file: "https://evil.test/f.woff2" }, "must be a relative path", ], [{ family: "F", file: "../escape.woff2" }, "must be a relative path"], ]; for (const [entry, fragment] of bad) { it(`rejects ${JSON.stringify(entry)}`, async () => { let caught = null; try { await parseViaLocal({ ...base, fonts: [entry] }); } catch (error) { caught = error; } assert( caught?.message.includes(fragment), `expected "${caught?.message}" to include "${fragment}"`, ); }); }});
describe("SourceProvider.getFont", () => { it("returns a Blob for a valid remote woff2", async () => { const bytes = woff2Bytes(); const pluginCache = fakePluginCache(async () => fontResponse(bytes)); const provider = new SourceProvider(pluginCache); const blob = await provider.getFont( "alpha", "1.0.0", "ow/alpha", "fonts/f.woff2", ); assert.deepEqual( pluginCache.calls[0].url, "https://raw.githubusercontent.com/ow/alpha/refs/tags/1.0.0/fonts/f.woff2", ); assert(blob instanceof Blob); assert.deepEqual(blob.type, "font/woff2"); assert.deepEqual(blob.size, bytes.byteLength); });
it("returns a Blob for a valid local woff", async () => { const bytes = woffBytes(); const stub = stubFetch(async () => fontResponse(bytes)); try { const blob = await new SourceProvider(null).getFont( "alpha__LOCAL", null, null, "fonts/f.woff", ); assert.deepEqual( stub.calls[0].url, "/plugins-local/alpha__LOCAL/fonts/f.woff", ); assert.deepEqual(blob.type, "font/woff"); } finally { stub.restore(); } });
it("rejects a woff2 filename whose bytes aren't a woff2", async () => { const notFont = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0]); const pluginCache = fakePluginCache(async () => fontResponse(notFont)); const provider = new SourceProvider(pluginCache); let caught = null; try { await provider.getFont("alpha", "1.0.0", "ow/alpha", "fonts/f.woff2"); } catch (error) { caught = error; } assert(caught?.message.includes("invalid magic bytes")); });
it("rejects a woff2 file whose bytes are a woff", async () => { const bytes = woffBytes(); const pluginCache = fakePluginCache(async () => fontResponse(bytes)); const provider = new SourceProvider(pluginCache); let caught = null; try { await provider.getFont("alpha", "1.0.0", "ow/alpha", "fonts/f.woff2"); } catch (error) { caught = error; } assert(caught?.message.includes("invalid magic bytes")); });});
describe("SourceProvider.getCacheUrls with fonts", () => { it("includes each declared font URL", async () => { const pluginCache = fakePluginCache(async () => jsonResponse({ id: "alpha", name: "A", version: "1.2.3", fonts: [ { family: "F", file: "fonts/a.woff2" }, { family: "F", file: "fonts/b.woff2", weight: "700" }, ], }), ); const provider = new SourceProvider(pluginCache); const urls = await provider.getCacheUrls("alpha", "1.2.3", "ow/alpha"); assert.deepEqual(urls, [ "https://raw.githubusercontent.com/ow/alpha/refs/tags/1.2.3/manifest.json", "https://raw.githubusercontent.com/ow/alpha/refs/tags/1.2.3/main.js", "https://raw.githubusercontent.com/ow/alpha/refs/tags/1.2.3/styles.css", "https://raw.githubusercontent.com/ow/alpha/refs/tags/1.2.3/fonts/a.woff2", "https://raw.githubusercontent.com/ow/alpha/refs/tags/1.2.3/fonts/b.woff2", ]); });});
// tangled.org's own HTTP endpoints don't set CORS headers, so// SourceProvider resolves tangled: repos entirely through standard AT// Protocol infrastructure instead: owner handle -> the owner's PDS (for the// repo's own "sh.tangled.repo" record, which carries {knot, repoDid}) ->// the knot's own CORS-enabled blob endpoint. The handle -> PDS step is// slingshot's mini doc, falling back to resolveHandle -> plc.directory.// This stubs global fetch to answer those resolution requests by URL// pattern; the actual file-content request is left to the caller (via// fakePluginCache, or a further branch here for plain-fetch methods).// legacyRecordKey simulates repos created before the "rkey = repo name"// scheme existed: the direct getRecord lookup 404s (well, 400s — standard// atproto RecordNotFound), and the record only turns up via listRecords,// keyed by an opaque TID with an explicit "name" field. Confirmed for real// against tangled.org's own account (its "infra" repo still uses this).function stubTangledResolution({ ownerHandle, ownerDid, pds, knot, repoDid, repoName = "alpha", content = null, legacyRecordKey = false,}) { const calls = []; const fetchImpl = async (url, options) => { calls.push({ url: String(url), options }); const urlStr = String(url); if (urlStr.includes("blue.microcosm.identity.resolveMiniDoc")) { return jsonResponse({ did: ownerDid, handle: ownerHandle, pds, }); } if (urlStr.includes("com.atproto.identity.resolveHandle")) { return jsonResponse({ did: ownerDid }); } if (urlStr.startsWith("https://plc.directory/")) { return jsonResponse({ id: ownerDid, alsoKnownAs: [`at://${ownerHandle}`], service: [ { id: "#atproto_pds", type: "AtprotoPersonalDataServer", serviceEndpoint: pds, }, ], }); } if ( urlStr.startsWith(pds) && urlStr.includes("com.atproto.repo.getRecord") ) { if (legacyRecordKey) { return jsonResponse( { error: "RecordNotFound", message: "not found" }, { ok: false, status: 400 }, ); } return jsonResponse({ value: { knot, repoDid } }); } if ( urlStr.startsWith(pds) && urlStr.includes("com.atproto.repo.listRecords") ) { if (!legacyRecordKey) { throw new Error( "listRecords should only be hit as a fallback (legacyRecordKey: true)", ); } return jsonResponse({ records: [ { uri: `at://${ownerDid}/sh.tangled.repo/3lxfwy4ifg622`, value: { knot, repoDid, name: repoName }, }, ], }); } if (content && urlStr.startsWith(`https://${knot}/`)) { return content; } throw new Error(`Unexpected fetch in stubTangledResolution: ${urlStr}`); }; const originalGlobal = globalThis.fetch; const originalWindow = globalThis.window.fetch; globalThis.fetch = fetchImpl; globalThis.window.fetch = fetchImpl; return { calls, restore() { globalThis.fetch = originalGlobal; globalThis.window.fetch = originalWindow; }, };}
function knotBlobUrl({ knot, repoDid, ref, path }) { const params = new URLSearchParams({ repo: repoDid, ref, path, raw: "true" }); return `https://${knot}/xrpc/sh.tangled.repo.blob?${params}`;}
// resolveTangledRepoInfo caches per repo path at module scope, so each test// below uses its own unique owner handle to avoid one test's cached// resolution masking another test's stub (and hiding real bugs).let identityCounter = 0;function makeIdentity() { const n = ++identityCounter; return { ownerHandle: `owner${n}.example`, ownerDid: `did:plc:owner${n}`, pds: `https://pds${n}.example`, knot: `knot${n}.example`, repoDid: `did:plc:repo${n}`, };}
describe("SourceProvider with tangled.sh-hosted plugins", () => { it("resolves via atproto and fetches a versioned manifest from the knot", async () => { const identity = makeIdentity(); const stub = stubTangledResolution(identity); const pluginCache = fakePluginCache(async () => jsonResponse({ id: "alpha", name: "A", version: "1.0.0" }), ); try { const provider = new SourceProvider(pluginCache); const manifest = await provider.getManifest( "alpha", "1.0.0", `tangled:${identity.ownerHandle}/alpha`, ); assert.deepEqual( pluginCache.calls[0].url, knotBlobUrl({ ...identity, ref: "1.0.0", path: "manifest.json" }), ); assert.deepEqual(manifest.id, "alpha"); // resolveMiniDoc, getRecord assert.deepEqual(stub.calls.length, 2); } finally { stub.restore(); } });
it("fetches source from the version that was passed in", async () => { const identity = makeIdentity(); const stub = stubTangledResolution(identity); const pluginCache = fakePluginCache(async () => ({ ok: true, status: 200, async text() { return "alert(1)"; }, })); try { const provider = new SourceProvider(pluginCache); const source = await provider.getSource( "alpha", "2.5.0", `tangled:${identity.ownerHandle}/alpha`, ); assert.deepEqual( pluginCache.calls[0].url, knotBlobUrl({ ...identity, ref: "2.5.0", path: "main.js" }), ); assert.deepEqual(source, "alert(1)"); } finally { stub.restore(); } });
it("getLiveManifest resolves via atproto and fetches from the knot's main ref", async () => { const identity = makeIdentity(); const stub = stubTangledResolution({ ...identity, content: jsonResponse({ id: "alpha", name: "A", version: "9.9.9" }), }); try { const provider = new SourceProvider(null); const manifest = await provider.getLiveManifest( "alpha", `tangled:${identity.ownerHandle}/alpha`, ); assert.deepEqual(manifest.version, "9.9.9"); const finalCall = stub.calls.at(-1); assert.deepEqual( finalCall.url, knotBlobUrl({ ...identity, ref: "main", path: "manifest.json" }), ); } finally { stub.restore(); } });
it("caches the resolved knot/repoDid so a second fetch doesn't re-resolve", async () => { const identity = makeIdentity(); const stub = stubTangledResolution(identity); const pluginCache = fakePluginCache(async () => jsonResponse({ id: "alpha", name: "A", version: "1.0.0" }), ); try { const provider = new SourceProvider(pluginCache); const repo = `tangled:${identity.ownerHandle}/alpha`; await provider.getManifest("alpha", "1.0.0", repo); await provider.getSource("alpha", "1.0.0", repo); // Still just the 2 resolution calls, not 4 — the second fetch reused // the cached {knot, repoDid}. assert.deepEqual(stub.calls.length, 2); assert.deepEqual(pluginCache.calls.length, 2); } finally { stub.restore(); } });
it("getCacheUrls resolves once and includes manifest, main.js, and styles.css URLs", async () => { const identity = makeIdentity(); const stub = stubTangledResolution(identity); try { const provider = new SourceProvider(null); const urls = await provider.getCacheUrls( "alpha", "1.2.3", `tangled:${identity.ownerHandle}/alpha`, ); assert.deepEqual(urls, [ knotBlobUrl({ ...identity, ref: "1.2.3", path: "manifest.json" }), knotBlobUrl({ ...identity, ref: "1.2.3", path: "main.js" }), knotBlobUrl({ ...identity, ref: "1.2.3", path: "styles.css" }), ]); } finally { stub.restore(); } });
it("throws for an unrecognized repo host prefix", async () => { const provider = new SourceProvider(fakePluginCache(async () => null)); let caught = null; try { await provider.getManifest("alpha", "1.0.0", "gitlab:ow/alpha"); } catch (error) { caught = error; } assert(caught?.message.includes('Unsupported plugin repo host "gitlab"')); });
it("throws a clear error when the owner handle can't be resolved", async () => { const stub = stubFetch(async () => jsonResponse({ did: null })); try { const provider = new SourceProvider(fakePluginCache(async () => null)); let caught = null; try { await provider.getManifest( "alpha", "1.0.0", "tangled:unknown.example/alpha", ); } catch (error) { caught = error; } assert(caught?.message.includes("Could not resolve tangled repo owner")); } finally { stub.restore(); } });
it("falls back to listRecords for repos using the older TID record key", async () => { const identity = makeIdentity(); const stub = stubTangledResolution({ ...identity, repoName: "alpha", legacyRecordKey: true, }); const pluginCache = fakePluginCache(async () => jsonResponse({ id: "alpha", name: "A", version: "1.0.0" }), ); try { const provider = new SourceProvider(pluginCache); const manifest = await provider.getManifest( "alpha", "1.0.0", `tangled:${identity.ownerHandle}/alpha`, ); assert.deepEqual(manifest.id, "alpha"); assert.deepEqual( pluginCache.calls[0].url, knotBlobUrl({ ...identity, ref: "1.0.0", path: "manifest.json" }), ); // resolveMiniDoc, getRecord (404), listRecords assert.deepEqual(stub.calls.length, 3); } finally { stub.restore(); } });
it("throws a clear error when no record matches by rkey or name", async () => { const identity = makeIdentity(); const stub = stubTangledResolution({ ...identity, repoName: "some-other-repo", legacyRecordKey: true, }); try { const provider = new SourceProvider(fakePluginCache(async () => null)); let caught = null; try { await provider.getManifest( "alpha", "1.0.0", `tangled:${identity.ownerHandle}/alpha`, ); } catch (error) { caught = error; } assert( caught?.message.includes( 'Could not find a tangled repo record named "alpha"', ), ); } finally { stub.restore(); } });
it("getStyles returns null when the knot 404s (no styles.css)", async () => { const identity = makeIdentity(); const stub = stubTangledResolution(identity); const pluginCache = fakePluginCache(async () => { const error = new Error("HTTP 404"); error.status = 404; throw error; }); try { const provider = new SourceProvider(pluginCache); const styles = await provider.getStyles( "alpha", "1.0.0", `tangled:${identity.ownerHandle}/alpha`, ); assert.deepEqual(styles, null); } finally { stub.restore(); } });
it("getReadme returns null when the knot 404s (no README.md)", async () => { const identity = makeIdentity(); const stub = stubTangledResolution({ ...identity, content: { ok: false, status: 404 }, }); try { const provider = new SourceProvider(null); const readme = await provider.getReadme( "alpha", `tangled:${identity.ownerHandle}/alpha`, ); assert.deepEqual(readme, null); } finally { stub.restore(); } });});
// The knot's raw=true mode 403s for font mime types, so getFont fetches the// JSON-wrapped (base64) response for tangled repos instead and decodes it// client-side. Verified against a real binary file on the live server// (byte-for-byte identical to a raw=true fetch of the same file) separately// from this suite; these tests cover the decode logic in isolation.function wrappedFontResponse(bytes) { return jsonResponse({ content: Buffer.from(bytes).toString("base64"), encoding: "base64", isBinary: true, });}
describe("SourceProvider.getFont with tangled.sh-hosted plugins", () => { it("fetches the non-raw wrapped response and decodes it into a Blob", async () => { const identity = makeIdentity(); const stub = stubTangledResolution(identity); const bytes = woff2Bytes(); const pluginCache = fakePluginCache(async () => wrappedFontResponse(bytes)); try { const provider = new SourceProvider(pluginCache); const blob = await provider.getFont( "alpha", "1.0.0", `tangled:${identity.ownerHandle}/alpha`, "fonts/f.woff2", ); const params = new URLSearchParams({ repo: identity.repoDid, ref: "1.0.0", path: "fonts/f.woff2", }); assert.deepEqual( pluginCache.calls[0].url, `https://${identity.knot}/xrpc/sh.tangled.repo.blob?${params}`, ); assert(!pluginCache.calls[0].url.includes("raw=")); assert(blob instanceof Blob); assert.deepEqual(blob.type, "font/woff2"); assert.deepEqual(blob.size, bytes.byteLength); } finally { stub.restore(); } });
it("rejects invalid magic bytes the same way as GitHub/local fonts", async () => { const identity = makeIdentity(); const stub = stubTangledResolution(identity); const notFont = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0]); const pluginCache = fakePluginCache(async () => wrappedFontResponse(notFont), ); try { const provider = new SourceProvider(pluginCache); let caught = null; try { await provider.getFont( "alpha", "1.0.0", `tangled:${identity.ownerHandle}/alpha`, "fonts/f.woff2", ); } catch (error) { caught = error; } assert(caught?.message.includes("invalid magic bytes")); } finally { stub.restore(); } });});
// The knot binding outlives the session, so a repo that moved to a different// knot would keep failing against the old one. These cover which failures the// provider reads as "this binding is wrong" — see _fetchRequiredAsset.function fakeTangledResolver() { return { invalidated: [], async resolveRepoInfo() { return { knot: "knot.example", repoDid: "did:plc:repo" }; }, async invalidate(path) { this.invalidated.push(path); }, };}
function httpError(status) { const error = new Error(`HTTP ${status}`); error.status = status; return error;}
describe("SourceProvider tangled knot invalidation", () => { const repo = "tangled:owner.example/alpha"; const path = "owner.example/alpha";
function providerThatFailsWith(error) { const resolver = fakeTangledResolver(); const provider = new SourceProvider( fakePluginCache(async () => { throw error; }), resolver, ); return { provider, resolver }; }
it("drops the binding when the knot errors on a versioned manifest", async () => { const { provider, resolver } = providerThatFailsWith(httpError(404));
await assert.rejects(() => provider.getManifest("alpha", "1.0.0", repo));
assert.deepEqual(resolver.invalidated, [path]); });
it("drops the binding when the knot errors on main.js", async () => { const { provider, resolver } = providerThatFailsWith(httpError(500));
await assert.rejects(() => provider.getSource("alpha", "1.0.0", repo));
assert.deepEqual(resolver.invalidated, [path]); });
it("drops the binding when the knot errors on a live manifest", async () => { const resolver = fakeTangledResolver(); const stub = stubFetch(async () => jsonResponse({}, { ok: false, status: 404 }), ); try { const provider = new SourceProvider(null, resolver); await assert.rejects(() => provider.getLiveManifest("alpha", repo)); } finally { stub.restore(); } assert.deepEqual(resolver.invalidated, [path]); });
it("keeps the binding on a network-level failure", async () => { // Indistinguishable from being offline, where the binding is what lets a // warm cache still serve the plugin const { provider, resolver } = providerThatFailsWith( new TypeError("Failed to fetch"), );
await assert.rejects(() => provider.getSource("alpha", "1.0.0", repo));
assert.deepEqual(resolver.invalidated, []); });
it("keeps the binding when an optional styles.css is missing", async () => { const { provider, resolver } = providerThatFailsWith(httpError(404));
assert.deepEqual(await provider.getStyles("alpha", "1.0.0", repo), null);
assert.deepEqual(resolver.invalidated, []); });
it("does not invalidate for GitHub-hosted repos", async () => { const { provider, resolver } = providerThatFailsWith(httpError(404));
await assert.rejects(() => provider.getManifest("alpha", "1.0.0", "ow/alpha"), );
assert.deepEqual(resolver.invalidated, []); });});