sourcemonkey 0.0.0-stage → 0.5.0

package/dist/extension/match-index.js

@@ -0,0 +1,375 @@
+// In-memory index of every injectable userscript's matching info so the
+// background service worker can find matching scripts for a URL without
+// touching chrome.storage.local on every navigation. "Injectable" means
+// `status: 'ok'` (see toEntry).
+//
+// Built once on first access (ensureLoaded()), then kept fresh by a
+// chrome.storage.local.onChanged listener. Storage I/O cost scales with
+// the user's script count at SW startup; per-navigation cost is just an
+// in-memory loop over the cache.
+//
+// Enabled state: a script is considered for matching only if BOTH its
+// own `enabled` flag and its parent collection's `enabled` flag are
+// true. We cache every injectable script (regardless of enabled) and
+// separately track the set of disabled collections, so toggling a
+// collection flips every script under it in O(1) without rewalking
+// storage.
+import { isFileUrl, scratchRunOf } from './directories.js';
+import { compareScriptNames, scriptDisplayName } from '../script-display.js';
+import { scanStorageRows } from './storage-scan.js';
+import { sharedRows } from './row-cache.js';
+import { ensureCollectionKeysMigrated, isScriptEnabled, isCollectionEnabled, sameStoredValue, withoutAnnotations, } from './script-store.js';
+import { urlMatchesScript } from '../url-match.js';
+import { resolveScriptWorld } from '../script-world.js';
+import { grantedSubsystems } from '../gm-api-catalog.js';
+import { isManualScript } from '../script-build.js';
+import { hasTag } from '../userscript-header.js';
+const SCRIPT_PREFIX = 'script:';
+const COLLECTION_PREFIX = 'collection:';
+let cache = new Map();
+// The match rules of `invalid` scripts, which `cache` leaves out. Read
+// only by `findAllMatchingIds`, so the popup can list a script that
+// targets the page but failed to load. Never injected or registered.
+let invalidMatching = new Map();
+let disabledCollections = new Set();
+let loaded = null;
+// While loadAll() is awaiting its full `get(null)` snapshot, any
+// storage change that fires would mutate the about-to-be-replaced
+// `cache`, and the subsequent `cache = nextCache` assignment would
+// discard it — a lost update until the next change to that key. During
+// the load window we buffer raw changes here instead of applying them,
+// then replay them onto the freshly-built cache. Null when not loading.
+let pendingDuringLoad = null;
+// First call kicks off a single full read; later callers await the same
+// promise. After it resolves, the cache is kept fresh by the onChanged
+// listener installed by installStorageListener().
+export function ensureLoaded() {
+    if (!loaded)
+        loaded = loadAll();
+    return loaded;
+}
+async function loadAll() {
+    pendingDuringLoad = [];
+    // Before the read, not after: a profile still on the pre-rename key
+    // spelling would otherwise load an empty cache and inject nothing.
+    await ensureCollectionKeysMigrated();
+    const isRow = (k) => k.startsWith(SCRIPT_PREFIX) || k.startsWith(COLLECTION_PREFIX);
+    // From the worker's row cache when it's on (frozen rows, read only).
+    const all = (await sharedRows(isRow)) ?? await scanStorageRows('match index', isRow);
+    const nextCache = new Map();
+    const nextInvalid = new Map();
+    const nextDisabled = new Set();
+    for (const [key, value] of Object.entries(all)) {
+        if (key.startsWith(SCRIPT_PREFIX)) {
+            const script = value;
+            const entry = toEntry(script);
+            if (entry)
+                nextCache.set(entry.id, entry);
+            else if (script.status === 'invalid' && script.matching)
+                nextInvalid.set(script.id, script.matching);
+        }
+        else if (key.startsWith(COLLECTION_PREFIX)) {
+            const collection = value;
+            if (!isCollectionEnabled(collection))
+                nextDisabled.add(collection.id);
+        }
+    }
+    cache = nextCache;
+    invalidMatching = nextInvalid;
+    disabledCollections = nextDisabled;
+    // Replay any changes that landed during the await on top of the
+    // fresh snapshot, then stop buffering. A change for a key already in
+    // the snapshot just re-applies the same (or newer) value; one for a
+    // key the snapshot missed is now captured.
+    const buffered = pendingDuringLoad;
+    pendingDuringLoad = null;
+    for (const changes of buffered)
+        applyStorageChanges(changes);
+}
+function toEntry(script) {
+    // Only `ok` scripts participate. `invalid` rows never do — their
+    // header may be unparsed or the file failed validation.
+    if (script.status !== 'ok')
+        return null;
+    const name = scriptDisplayName(script);
+    return {
+        id: script.id,
+        name,
+        matching: script.matching,
+        collectionId: script.collectionId,
+        world: resolveScriptWorld(script),
+        subsystems: grantedSubsystems(script.header),
+        enabled: isScriptEnabled(script),
+        local: isFileUrl(script.fileUrl),
+        ...smDevRunField(script.fileUrl),
+        ...(isManualScript(script) ? { manual: true } : {}),
+        ...(script.header && hasTag(script.header, 'noframes') ? { noframes: true } : {}),
+    };
+}
+function smDevRunField(fileUrl) {
+    const run = scratchRunOf(fileUrl);
+    return run === null ? {} : { smDevRun: run };
+}
+// Install the storage listener exactly once. Safe to call repeatedly.
+let listenerInstalled = false;
+export function installStorageListener() {
+    if (listenerInstalled)
+        return;
+    listenerInstalled = true;
+    chrome.storage.onChanged.addListener((changes, areaName) => {
+        if (areaName !== 'local')
+            return;
+        // If a full load is mid-flight, buffer this change for replay after
+        // the snapshot lands rather than mutating the soon-to-be-replaced
+        // cache (which would lose this update). See loadAll().
+        if (pendingDuringLoad) {
+            pendingDuringLoad.push(changes);
+            return;
+        }
+        applyStorageChanges(changes);
+    });
+}
+// Apply one storage.onChanged delta to the in-memory cache. Shared by
+// the live listener and loadAll()'s post-snapshot replay.
+function applyStorageChanges(changes) {
+    // Which rows moved, not just "something moved". The injector syncs
+    // incrementally off this, so a listener that only said "changed"
+    // would force it back to rebuilding every registration.
+    const scriptIds = [];
+    const collectionIds = [];
+    for (const [key, change] of Object.entries(changes)) {
+        if (key.startsWith(SCRIPT_PREFIX)) {
+            // A write that only moved an annotation (`versionProbes`, or the
+            // parse check's verdict) is not a change to anything downstream
+            // of this listener, and saying otherwise is expensive: each one
+            // schedules a registration sync. A "Refresh All" probes each
+            // script in turn and writes each result as its own row, so
+            // treating those as cache changes turned one refresh into a
+            // re-registration per probed script — measured at 23 syncs
+            // averaging 356ms for a 177-script profile, most of them landing
+            // after the refresh had already finished. A verdict cost a second
+            // sync after every edit.
+            //
+            // Safe for a probe because it is a display annotation and nothing
+            // else: `toEntry` doesn't read it, and neither does `injector.ts`
+            // (registration specs), `tab-status.ts`, or `background.ts`. The
+            // pages that DO render it — the viewer and the collections page —
+            // repaint from their own `chrome.storage.local.onChanged`
+            // listeners, not from `onCacheChanged`, so the badge still
+            // updates the moment a probe lands.
+            //
+            // Safe for a passing verdict for another reason: the sync reads
+            // it (its gate checks rows without one), but it lands just after
+            // the content change it checked, whose own write started a sync
+            // then, and the registration built from the row is the same
+            // either way. A failing one changes `status`, which is reported.
+            if (onlyAnnotationsChanged(change.oldValue, change.newValue)) {
+                continue;
+            }
+            const id = key.slice(SCRIPT_PREFIX.length);
+            scriptIds.push(id);
+            invalidMatching.delete(id);
+            if (change.newValue === undefined) {
+                cache.delete(id);
+                continue;
+            }
+            const script = change.newValue;
+            const entry = toEntry(script);
+            if (entry)
+                cache.set(id, entry);
+            else
+                cache.delete(id);
+            if (script.status === 'invalid' && script.matching)
+                invalidMatching.set(id, script.matching);
+        }
+        else if (key.startsWith(COLLECTION_PREFIX)) {
+            const id = key.slice(COLLECTION_PREFIX.length);
+            const next = change.newValue;
+            // A collection row is rewritten on every scan (`lastScannedAt`
+            // and friends), so reporting every write would re-register every
+            // script under it on every refresh. Only what moves anything
+            // downstream is reported: the enabled flag, and the row going
+            // away.
+            //
+            // Deliberately NOT its arrival. A collection appears together
+            // with the scripts under it, which are reported in their own
+            // right, and the injector fetches a collection row it hasn't seen
+            // when a script names one — so saying so here would buy nothing
+            // and cost an extra sync per collection added.
+            const wasDisabled = disabledCollections.has(id);
+            if (next === undefined) {
+                // Collection was removed entirely — its scripts will be deleted
+                // via separate script:* changes; just drop our tracking row.
+                disabledCollections.delete(id);
+                collectionIds.push(id);
+            }
+            else if (!isCollectionEnabled(next)) {
+                disabledCollections.add(id);
+                if (!wasDisabled)
+                    collectionIds.push(id);
+            }
+            else {
+                disabledCollections.delete(id);
+                if (wasDisabled)
+                    collectionIds.push(id);
+            }
+        }
+    }
+    if (scriptIds.length > 0 || collectionIds.length > 0) {
+        notifyChange({ scriptIds, collectionIds });
+    }
+}
+// Whether a `script:*` write moved nothing but its annotations.
+//
+// Deliberately a diff of the two stored rows rather than of the derived
+// cache entries. The entry holds only what MATCHING needs, but
+// `notifyChange` also drives re-registration, which reads the whole row
+// — body, `@require` bodies, grants, world, run-at. Comparing entries
+// would call a body-only edit "no change" and leave the old code
+// registered, which is a correctness bug, not a missed optimisation.
+// So the rule is inverted: assume a change matters unless it is exactly
+// the fields proven not to.
+//
+// Exported for unit tests.
+export function onlyAnnotationsChanged(before, after) {
+    // A creation or a deletion is never "just an annotation".
+    if (!before || !after)
+        return false;
+    return sameStoredValue(withoutAnnotations(before), withoutAnnotations(after));
+}
+const changeListeners = [];
+export function onCacheChanged(fn) {
+    changeListeners.push(fn);
+}
+function notifyChange(change) {
+    for (const fn of changeListeners) {
+        try {
+            fn(change);
+        }
+        catch { /* swallow listener errors */ }
+    }
+}
+export function findMatchesForUrl(url, kind = 'load') {
+    const out = [];
+    for (const entry of cache.values()) {
+        if (!entry.enabled)
+            continue;
+        if (disabledCollections.has(entry.collectionId))
+            continue;
+        if (kind === 'load' && entry.manual)
+            continue;
+        if (kind === 'manual' && !entry.manual)
+            continue;
+        if (urlMatchesScript(url, entry.matching)) {
+            out.push({
+                id: entry.id,
+                name: entry.name,
+                matching: entry.matching,
+                collectionId: entry.collectionId,
+                world: entry.world,
+                ...(entry.smDevRun !== undefined ? { smDevRun: entry.smDevRun } : {}),
+                ...(entry.manual ? { manual: true } : {}),
+                ...(entry.noframes ? { noframes: true } : {}),
+            });
+        }
+    }
+    // Stable display order for the tooltip.
+    out.sort((a, b) => compareScriptNames(a.name, b.name));
+    return out;
+}
+// What the index knows of script `id` (any `ok` script, enabled or
+// not), or undefined for one it doesn't hold.
+export function indexedScript(id) {
+    const entry = cache.get(id);
+    return entry && {
+        world: entry.world,
+        ...(entry.noframes ? { noframes: true } : {}),
+        ...(entry.manual ? { manual: true } : {}),
+    };
+}
+// Whether `id` is a manual script (`@run-at context-menu`). False for
+// an id the index doesn't hold.
+export function isManualScriptId(id) {
+    return cache.get(id)?.manual === true;
+}
+// Every script whose rules match `url`, enabled or not — the popup
+// lists the disabled ones too, so they can be turned on from there.
+// `invalid` ones as well: one that targets the page but failed to load
+// is listed as such. Ids only: the popup reads the rows it needs from
+// storage.
+export function findAllMatchingIds(url) {
+    const out = [];
+    for (const entry of cache.values()) {
+        if (urlMatchesScript(url, entry.matching))
+            out.push(entry.id);
+    }
+    for (const [id, matching] of invalidMatching) {
+        if (urlMatchesScript(url, matching))
+            out.push(id);
+    }
+    return out;
+}
+// Narrow a set of script ids to the ones loaded from `file://`.
+//
+// Keyed on each script's own `fileUrl`, not on its collection's
+// location: a container collection holds individually-installed scripts
+// of both kinds, so the collection is the wrong unit for this question.
+// (`isLocalCollection` in refresh-targets.ts answers the collection-level
+// version, and has to special-case containers for exactly this reason.)
+//
+// Ids the cache doesn't hold — a script that isn't injectable, or one
+// deleted since the tab last matched — are dropped rather than assumed
+// local: there is nothing to refresh either way.
+export function localScriptIds(ids) {
+    return ids.filter((id) => cache.get(id)?.local === true);
+}
+// Does the profile hold ANY injectable local script?
+//
+// The cheap gate in front of the focus-triggered refresh: it runs on
+// every tab switch and window focus change, and a profile with only
+// http collections has nothing for it to do. Answering from the
+// in-memory cache keeps that case off `chrome.storage.session`.
+export function hasLocalScripts() {
+    for (const entry of cache.values())
+        if (entry.local)
+            return true;
+    return false;
+}
+export function cacheSize() {
+    return cache.size;
+}
+// The execution world a script would be injected into, or null when the
+// id isn't in the injectable cache at all.
+//
+// Used by the SW to stamp every push it sends into a tab with the world
+// the receiving script lives in. `wrapper-bridge.js` re-posts pushes
+// into MAIN world, where the page can read them, so it must relay only
+// what is addressed to a MAIN-world script — otherwise an isolated
+// script's stored values and XHR response bodies would become
+// page-visible on any page that happens to also run a MAIN-world
+// script. Callers treat `null` as "not MAIN" (fail closed).
+export function scriptWorld(id) {
+    return cache.get(id)?.world ?? null;
+}
+// True iff the script's `@grant` lines reach one of the given
+// subsystems. The second half of the bridge gate: being a MAIN-world
+// script on the page only makes the APIs it granted page-reachable, so
+// a request through any other API is refused even for that script.
+// Unknown ids fail closed.
+export function scriptGrantsSubsystem(id, subsystems) {
+    const granted = cache.get(id)?.subsystems;
+    if (!granted)
+        return false;
+    return subsystems.some((s) => granted.has(s));
+}
+// Test/debug: dump the current cache contents. Lets e2e tests
+// distinguish "the script never landed in the cache" from "the URL
+// pattern doesn't match" when a badge classification looks wrong.
+export function debugDumpCache() {
+    return {
+        entries: [...cache.values()].map((e) => ({
+            id: e.id, name: e.name, enabled: e.enabled, collectionId: e.collectionId, matching: e.matching,
+        })),
+        disabledCollections: [...disabledCollections],
+    };
+}

package/dist/extension/missing-scripts.js

@@ -0,0 +1,66 @@
+// Explaining a script that matched a page but never started there.
+//
+// The badge shows such a script as MISSING. Once the page has loaded,
+// the service worker also writes a Log warning for it, built here from
+// what the document's other wrapper reports said (`reportedWorlds`,
+// `opaqueOrigin` on TabMatchState). The main case it names:
+//   - A CSP `sandbox` header without `allow-scripts` turns off script
+//     in the page's own world, so Chrome silently skips MAIN-world
+//     scripts there, while USER_SCRIPT-world ones still run. The
+//     bridge then has them run isolated (`runBlockedMainScripts` in
+//     background.ts), so this hint matters only when that didn't run.
+//   - Such a page gets an opaque origin, which any wrapper that did run
+//     there reports.
+// See docs/matching.md#scripts-that-never-start.
+import { skippedOnDocument } from './tab-status.js';
+import { INJECT_INTO_CONTENT_FIX, SANDBOX_BLOCKS_PAGE_CONTEXT } from '../sandboxed-page.js';
+// The scripts expected on this document from its first load that never
+// reported, and aren't already explained by the badge (REJECTED, NOT
+// LOADED). See `loadMatchIds` for why only the first load's.
+export function findMissingScripts(state, rejected = new Set()) {
+    // Nothing was injected, so no script on it is a mystery to explain.
+    if (state.scriptsSkipped || state.loadedWithoutUserscripts)
+        return [];
+    const atLoad = state.loadMatchIds ? new Set(state.loadMatchIds) : null;
+    return state.matches.filter((m) => (!atLoad || atLoad.has(m.id)) && !state.actual[m.id] && !rejected.has(m.id) && !skippedOnDocument(state, m.id));
+}
+// Whether the document is sandboxed, going by the wrappers' reports.
+// Only on http(s): a file:// page has an opaque origin too.
+function sandboxed(state) {
+    return state.opaqueOrigin === true && /^https?:/i.test(state.url);
+}
+function reportedFrom(state, world) {
+    return (state.reportedWorlds ?? []).includes(world);
+}
+// The Log warning for one missing script.
+export function describeMissingScript(script, state) {
+    const base = `Matched ${state.url} but never started there`;
+    let hint;
+    if (script.world === 'MAIN') {
+        if (reportedFrom(state, 'MAIN')) {
+            hint = 'Other scripts in the page\'s own context did start here, so the page isn\'t blocking that context.';
+        }
+        else if (sandboxed(state)) {
+            hint = 'This page is sandboxed, usually by a sandbox directive in its Content-Security-Policy header. ' +
+                `${SANDBOX_BLOCKS_PAGE_CONTEXT}. ${INJECT_INTO_CONTENT_FIX}.`;
+        }
+        else if (!/^https?:/i.test(state.url)) {
+            // No response headers to point at.
+            return base;
+        }
+        else {
+            hint = 'The page may be blocking scripts in its own context. Check its Content-Security-Policy ' +
+                `header for a sandbox directive without allow-scripts. If it has one, ${lowerFirst(INJECT_INTO_CONTENT_FIX)}.`;
+        }
+    }
+    else if (reportedFrom(state, 'USER_SCRIPT')) {
+        hint = 'Other scripts in the isolated context did start here.';
+    }
+    else {
+        return base;
+    }
+    return `${base}. ${hint}`;
+}
+function lowerFirst(text) {
+    return text.charAt(0).toLowerCase() + text.slice(1);
+}

package/dist/extension/more-menu.js

@@ -0,0 +1,109 @@
+// The ⋯ button and the menu it opens, shared by the toolbar popup and
+// the collections page. One menu is open at a time; a click elsewhere
+// or Escape closes it. Each page styles its own `button.more-menu`; the
+// menu's look is `.menu` in styles.css.
+let openMenuEl = null;
+let openMenuBtn = null;
+let listening = false;
+export function moreMenuButton(label) {
+    const b = document.createElement('button');
+    b.type = 'button';
+    b.className = 'more-menu';
+    b.setAttribute('aria-label', label);
+    b.setAttribute('aria-haspopup', 'menu');
+    b.setAttribute('aria-expanded', 'false');
+    b.textContent = '⋯';
+    return b;
+}
+// Open `items` under `btn`, or close the menu when it is already open
+// there.
+export function openMenu(btn, items) {
+    listen();
+    const wasOpen = openMenuBtn === btn;
+    closeMenu();
+    if (wasOpen)
+        return;
+    const menu = document.createElement('div');
+    menu.className = 'menu';
+    menu.setAttribute('role', 'menu');
+    for (const item of items) {
+        if (item.hidden)
+            continue;
+        if (item.separator) {
+            menu.append(document.createElement('hr'));
+            continue;
+        }
+        const b = document.createElement('button');
+        b.type = 'button';
+        b.setAttribute('role', 'menuitem');
+        b.textContent = item.label ?? '';
+        b.disabled = item.disabled === true;
+        if (item.title)
+            b.title = item.title;
+        if (item.wire) {
+            item.wire(b, closeMenu);
+        }
+        else {
+            b.addEventListener('click', () => {
+                closeMenu();
+                if (!item.run)
+                    return;
+                // Called inside the click, so the action keeps its user gesture.
+                try {
+                    Promise.resolve(item.run()).catch(menuActionFailed);
+                }
+                catch (err) {
+                    menuActionFailed(err);
+                }
+            });
+        }
+        menu.append(b);
+    }
+    document.body.append(menu);
+    // Under the button, right-aligned to it; above it when there's no
+    // room below.
+    const r = btn.getBoundingClientRect();
+    const below = r.bottom + 2;
+    const top = below + menu.offsetHeight > document.documentElement.clientHeight
+        ? Math.max(0, r.top - menu.offsetHeight - 2) : below;
+    menu.style.top = `${top}px`;
+    menu.style.right = `${document.documentElement.clientWidth - r.right}px`;
+    btn.setAttribute('aria-expanded', 'true');
+    openMenuEl = menu;
+    openMenuBtn = btn;
+    menu.querySelector('button')?.focus();
+}
+// Close the menu when the button it hangs from has left the page (a
+// repaint replaced it), rather than leave it floating where it was.
+export function closeDetachedMenu() {
+    if (openMenuBtn && !openMenuBtn.isConnected)
+        closeMenu();
+}
+export function closeMenu() {
+    openMenuEl?.remove();
+    openMenuBtn?.setAttribute('aria-expanded', 'false');
+    openMenuEl = null;
+    openMenuBtn = null;
+}
+function menuActionFailed(err) {
+    console.info('[SourceMonkey] menu action failed:', err);
+}
+function listen() {
+    if (listening)
+        return;
+    listening = true;
+    document.addEventListener('click', (ev) => {
+        const t = ev.target;
+        if (!openMenuEl || t?.closest('.menu') || t?.closest('button.more-menu') === openMenuBtn)
+            return;
+        closeMenu();
+    });
+    document.addEventListener('keydown', (ev) => {
+        if (ev.key === 'Escape' && openMenuEl) {
+            const btn = openMenuBtn;
+            closeMenu();
+            btn?.focus();
+            ev.preventDefault();
+        }
+    });
+}