sourcemonkey 0.0.0-stage → 0.5.0

package/dist/extension/script-log-id.js

@@ -0,0 +1,155 @@
+// Per-script "log ID" assignment.
+//
+// Goal: every script that appears in a log line or UI label can be
+// referred to by a short, file-derived handle: its basename and its
+// script number (`bold-on-hover.user.js#E4`), the number sm-dev names
+// it by (see sticky-numbers.ts). The number keeps two scripts sharing a
+// basename apart, and never shifts when other scripts come and go.
+//
+// A script with no number yet (one just added, before the service
+// worker numbers it, or one in an sm-dev test collection) is labelled
+// by its basename alone, or `#1`, `#2`, ... among other unnumbered
+// scripts sharing it.
+//
+// The basename comes from `scriptBasename`, so a script added by URL
+// contributes its decoded filename (`My Script.user.js`), not the
+// percent-encoded URL tail. `script-source-url.ts` re-encodes the
+// label on its way into a `//# sourceURL=` directive.
+//
+// Unnumbered dupe ordering: sorted by their stable UUID `id`, so the
+// assignment is deterministic, though adding or removing another such
+// script can reshuffle them.
+import { scriptBasename } from '../script-display.js';
+import { numberMap, numbersFrom, SCRIPT_NUMBERS_KEY } from './sticky-numbers.js';
+import { scanStorageRows } from './storage-scan.js';
+import { sharedRows } from './row-cache.js';
+const SCRIPT_PREFIX = 'script:';
+// ---------- Pure helpers ----------
+/**
+ * Each script's log ID, by id. `numbers`: the script numbers (from the
+ * `scriptNumbers` row); a script with one is `<basename>#E<number>`.
+ */
+export function computeLogIds(scripts, numbers = new Map()) {
+    const groups = new Map();
+    const out = new Map();
+    for (const s of scripts) {
+        const base = scriptBasename(s.relativePath);
+        const n = numbers.get(s.id);
+        if (n !== undefined) {
+            out.set(s.id, `${base}#E${n}`);
+            continue;
+        }
+        const arr = groups.get(base);
+        if (arr)
+            arr.push(s);
+        else
+            groups.set(base, [s]);
+    }
+    for (const [base, arr] of groups) {
+        if (arr.length === 1) {
+            out.set(arr[0].id, base);
+            continue;
+        }
+        // Plain byte-order comparison rather than localeCompare so the
+        // assignment is locale-independent — a Turkish-locale SW must agree
+        // with a US-locale collections page, and UUIDs are ASCII anyway.
+        arr.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+        arr.forEach((s, i) => out.set(s.id, `${base}#${i + 1}`));
+    }
+    return out;
+}
+// ---------- SW-side runtime ----------
+//
+// The SW maintains its own copy of {id → relativePath} for every
+// stored script (regardless of status — error/missing scripts can
+// still show up in update-check log lines). One full read at startup,
+// then kept fresh via chrome.storage.onChanged.
+let allInfo = new Map();
+let numbers = new Map();
+let logIds = new Map();
+let loaded = null;
+export function ensureLogIdsLoaded() {
+    if (!loaded)
+        loaded = loadAll();
+    return loaded;
+}
+async function loadAll() {
+    // From the worker's row cache when it's on (frozen rows, read only),
+    // with the numbers row, which it doesn't keep, read beside it.
+    const cached = await sharedRows((k) => k.startsWith(SCRIPT_PREFIX));
+    const all = cached
+        ? { ...cached, ...await chrome.storage.local.get(SCRIPT_NUMBERS_KEY) }
+        : await scanStorageRows('log id table', (k) => k.startsWith(SCRIPT_PREFIX) || k === SCRIPT_NUMBERS_KEY);
+    const next = new Map();
+    for (const [key, value] of Object.entries(all)) {
+        if (!key.startsWith(SCRIPT_PREFIX))
+            continue;
+        const s = value;
+        next.set(s.id, { id: s.id, relativePath: s.relativePath });
+    }
+    allInfo = next;
+    numbers = numberMap(numbersFrom(all[SCRIPT_NUMBERS_KEY]));
+    recompute();
+}
+function recompute() {
+    logIds = computeLogIds([...allInfo.values()], numbers);
+}
+let listenerInstalled = false;
+export function installScriptLogIdListener() {
+    if (listenerInstalled)
+        return;
+    listenerInstalled = true;
+    chrome.storage.onChanged.addListener((changes, areaName) => {
+        if (areaName !== 'local')
+            return;
+        let touched = false;
+        if (SCRIPT_NUMBERS_KEY in changes) {
+            numbers = numberMap(numbersFrom(changes[SCRIPT_NUMBERS_KEY].newValue));
+            touched = true;
+        }
+        for (const [key, change] of Object.entries(changes)) {
+            if (!key.startsWith(SCRIPT_PREFIX))
+                continue;
+            const id = key.slice(SCRIPT_PREFIX.length);
+            if (change.newValue === undefined) {
+                if (allInfo.delete(id))
+                    touched = true;
+                continue;
+            }
+            const s = change.newValue;
+            const prior = allInfo.get(id);
+            if (!prior || prior.relativePath !== s.relativePath) {
+                allInfo.set(id, { id: s.id, relativePath: s.relativePath });
+                touched = true;
+            }
+        }
+        if (touched)
+            recompute();
+    });
+}
+/**
+ * The script numbers, straight from the service worker's numbering, so
+ * a label asked for right after a sync already has its `#E<n>`, rather
+ * than waiting for the storage change event to bring it.
+ */
+export function noteScriptNumbers(next) {
+    numbers = next;
+    recompute();
+}
+// Short human-readable label for SW log messages. Falls back to the
+// first 8 chars of the UUID when the script isn't tracked — happens
+// only for a brief window before ensureLogIdsLoaded() resolves, or
+// for late sm:* reports from scripts that have since been removed.
+export function getScriptLogLabel(id) {
+    return logIds.get(id) ?? id.slice(0, 8);
+}
+// Test/debug hook. Note: we do NOT flip listenerInstalled back to
+// false — chrome.storage.onChanged.addListener can't be cleanly
+// undone for an anonymous listener, and re-installing would queue
+// duplicate callbacks.
+export function _resetScriptLogIdsForTests() {
+    allInfo = new Map();
+    numbers = new Map();
+    logIds = new Map();
+    loaded = null;
+}

package/dist/extension/script-log.js

@@ -0,0 +1,290 @@
+// Per-script event log.
+//
+// Each StoredScript gets its own log keyed by script ID and stored in
+// chrome.storage.session (so logs survive SW restarts but are cleared
+// when Chrome shuts down — same lifetime as the per-tab badge state).
+//
+// We chose a single per-script array (rather than one storage key per
+// entry) because chrome.storage.session is a flat key-value store and
+// scanning N keys to read N log lines would dominate the cost of
+// rendering the log pane. The array IS a read/modify/write append, so
+// concurrent appendScriptLog calls for the same id are serialized
+// through an in-memory promise chain to keep them from clobbering each
+// other. Cross-id appends still run concurrently.
+//
+// Entries are append-only with a fixed cap; once the count passes
+// LOG_CAP the oldest entries are dropped. The cap is generous enough
+// to cover a normal day of refreshes + a few crashy injections but
+// small enough that a runaway error loop can't fill storage.
+//
+// Alongside the log we maintain a sibling `loglevel:<scriptId>` row
+// recording the highest level any SCRIPT-ORIGINATED entry has carried
+// so far — a runtime error, a refused `GM_download`, a parse-time
+// diagnostic.
+// Bumped only when an append carries a strictly higher level; cleared
+// on `clearScriptLog` and by an entry that `resetsLogLevel` (new content
+// loaded). Entries that record a load-state transition
+// (`state` set — see `LogEntry.state`) never touch it: their badge
+// comes from the row and clears with it. It lives in session storage
+// (not on the StoredScript row) because:
+//   - Lifetime matches the log itself — Chrome shutdown drops both
+//     together, so a WARNING/ERROR badge can't outlive its entries.
+//   - One bulk `get(null)` yields every script's level in O(scripts)
+//     rather than O(scripts × entries) — the collections page needs this
+//     to render the Status column cheaply.
+import { validLocation } from '../diagnostic-location.js';
+import { isPageContext } from '../run-context.js';
+import { isLoadState } from '../script-display.js';
+// Ordinal compare for LogLevel: error > warning > info. Used to decide
+// whether an append should bump the stored max.
+const LEVEL_RANK = { info: 1, warning: 2, error: 3 };
+function isHigher(candidate, prior) {
+    if (prior === undefined)
+        return true;
+    return LEVEL_RANK[candidate] > LEVEL_RANK[prior];
+}
+// Hard cap on retained entries per script. Older entries are dropped
+// on append. 500 × ~200 bytes ≈ 100 KB per script — well inside the
+// chrome.storage.session quota (10 MB total).
+export const LOG_CAP = 500;
+const logKey = (scriptId) => `log:${scriptId}`;
+const levelKey = (scriptId) => `loglevel:${scriptId}`;
+// Prefix used by the bulk-read path. Kept here so callers don't have
+// to hardcode it.
+export const LOG_LEVEL_KEY_PREFIX = 'loglevel:';
+// Per-script promise chain. chrome.storage.session has no atomic
+// append, so two concurrent appendScriptLog calls for the same id
+// would both read the same prior array and the second .set would
+// overwrite the first append. Chaining serializes them; the map entry
+// is dropped once its chain drains so long-running sessions don't
+// accumulate dead Promises.
+//
+// The map is module state, so the chain only orders writes made in THIS
+// context. Only the worker writes the log today: it logs every
+// injection and refresh event, and the viewer's Clear button goes
+// through the worker's ops port. Pages share `script-store` code with
+// the worker, though, and a page that logged through it would run a
+// second chain on the same key, losing entries or resurrecting ones a
+// clear had just removed. So, as a guard, a MUTATION made in a page
+// hops to the worker (`writeViaWorker`) and the worker's chain stays
+// the only one that touches the key. Reads don't hop: they aren't
+// read-modify-write.
+//
+// What that guarantees is "the worker's chain orders everything that
+// reaches it", NOT "a page's appends are ordered": two writes from one
+// page are two messages, ordered by the IPC rather than by a chain.
+const queues = new Map();
+function enqueue(scriptId, task) {
+    const prev = queues.get(scriptId) ?? Promise.resolve();
+    // .then(task, task) so a thrown task doesn't poison the chain — the
+    // next queued task still runs against the post-throw state.
+    const next = prev.then(task, task);
+    queues.set(scriptId, next);
+    void next.finally(() => {
+        if (queues.get(scriptId) === next)
+            queues.delete(scriptId);
+    });
+    return next;
+}
+// Told of each entry the worker writes, for the events sm-dev runs
+// hear (sm-dev-link.ts). Set by the worker only.
+let entryListener = null;
+export function onScriptLogEntry(listener) {
+    entryListener = listener;
+}
+// Append an entry. Every caller that reaches here observed something,
+// and the Log tab is a transcript of observations, so the entry is
+// always written. A caller that fires on its own schedule rather than
+// on an observation — the injector's per-sync registration pass — is
+// responsible for deciding whether anything happened before it calls.
+export async function appendScriptLog(scriptId, input) {
+    if (isPageContext())
+        return writeViaWorker({ op: 'append', scriptId, input });
+    return enqueue(scriptId, () => writeEntry(scriptId, input));
+}
+// ---------- Page → worker relay ----------
+export const SCRIPT_LOG_WRITE_MESSAGE = 'sm:script-log-write';
+// Worker side. Runs the write on the worker's own per-script chain,
+// which is the point of the hop.
+export async function handleScriptLogWrite(req) {
+    if (req.op === 'append')
+        return enqueue(req.scriptId, () => writeEntry(req.scriptId, req.input));
+    return enqueue(req.scriptId, () => removeEntries(req.scriptId));
+}
+// Page side. Only the worker writes storage (docs/worker-writes.md).
+// No page code logs today; this is the guard for one that does, through
+// code it shares with the worker (see `queues` above).
+// An entry the worker didn't ACKNOWLEDGE is sent once more: a worker
+// stopped mid-message closes the channel unanswered, and the second
+// message wakes a new one. Then it is dropped, and said so in this
+// page's console.
+//
+// The ack has to be READ, not just awaited: a message nothing handled,
+// and a handler that threw, both RESOLVE `sendMessage` (with
+// `undefined`); only an unreachable worker rejects it. So `true` (sent
+// by the listener once the write has landed) is the one answer that
+// means it was written. A retry after a write that landed unacknowledged
+// can log the entry twice, which beats losing it.
+async function writeViaWorker(req) {
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            const ack = await chrome.runtime.sendMessage({ type: SCRIPT_LOG_WRITE_MESSAGE, ...req });
+            if (ack === true)
+                return;
+        }
+        catch { /* no receiving end */ }
+    }
+    console.info(`[SourceMonkey] the background worker did not save a log ${req.op} for script ${req.scriptId}`);
+}
+// Shared read-modify-write body. Always called from inside `enqueue`.
+async function writeEntry(scriptId, input) {
+    const lk = logKey(scriptId);
+    const mk = levelKey(scriptId);
+    const got = await chrome.storage.session.get([lk, mk]);
+    const prior = Array.isArray(got[lk]) ? got[lk] : [];
+    const priorLevel = got[mk];
+    if (input.collapse) {
+        const { key, message } = input.collapse;
+        let at = prior.length - 1;
+        while (at >= 0 && prior[at].collapseKey !== key)
+            at--;
+        if (at >= 0) {
+            const old = prior[at];
+            const count = (old.count ?? 1) + 1;
+            const level = isHigher(input.level, old.level) ? input.level : old.level;
+            const next = prior.slice();
+            next[at] = { ...old, level, count, message: message(count) };
+            const toSet = { [lk]: next };
+            if (isHigher(input.level, priorLevel))
+                toSet[mk] = input.level;
+            // Not a new entry, so the entry listener isn't told.
+            await chrome.storage.session.set(toSet);
+            return;
+        }
+    }
+    const entry = {
+        timestamp: input.timestamp ?? Date.now(),
+        level: input.level,
+        source: input.source,
+        message: input.collapse ? input.collapse.message(1) : input.message,
+    };
+    if (input.tabId !== undefined)
+        entry.tabId = input.tabId;
+    if (input.collapse)
+        entry.collapseKey = input.collapse.key;
+    const location = validLocation(input.location);
+    if (location)
+        entry.location = location;
+    // Checked like `location`: the input may have crossed the page →
+    // worker message boundary, and a bad value here would render an
+    // empty badge.
+    if (isLoadState(input.state))
+        entry.state = input.state;
+    if (input.resetsLogLevel === true)
+        entry.resetsLogLevel = true;
+    const next = prior.length >= LOG_CAP
+        ? [...prior.slice(prior.length - LOG_CAP + 1), entry]
+        : [...prior, entry];
+    const toSet = { [lk]: next };
+    // A load-state transition is badged by the row, not the sentinel —
+    // otherwise a `refresh-failed` entry would leave WARNING behind for
+    // the rest of the session after the row had already recovered. A
+    // resetting entry doesn't count itself either: it's the boundary,
+    // not the first event past it.
+    const counts = entry.state === undefined && !entry.resetsLogLevel;
+    if (counts && isHigher(input.level, priorLevel))
+        toSet[mk] = input.level;
+    await chrome.storage.session.set(toSet);
+    try {
+        entryListener?.(scriptId, entry, input.fromReport === true);
+    }
+    catch {
+        // A listener's failure is no reason to lose the entry's other effects.
+    }
+    // The reset rides on the same queued write as the entry, so it lands
+    // exactly between the rows before it and the rows after it: parse
+    // diagnostics replayed for the new version come next and bump the
+    // sentinel afresh. Skipped when there is nothing to clear — the
+    // common case, since most new content lands on a clean badge.
+    if (entry.resetsLogLevel && priorLevel !== undefined)
+        await chrome.storage.session.remove(mk);
+}
+export async function getScriptLog(scriptId) {
+    const key = logKey(scriptId);
+    const got = await chrome.storage.session.get(key);
+    return Array.isArray(got[key]) ? got[key] : [];
+}
+export async function clearScriptLog(scriptId) {
+    if (isPageContext())
+        return writeViaWorker({ op: 'clear', scriptId });
+    return enqueue(scriptId, () => removeEntries(scriptId));
+}
+// Shared removal body, the counterpart of `writeEntry`. Always called
+// from inside `enqueue`.
+async function removeEntries(scriptId) {
+    await chrome.storage.session.remove([logKey(scriptId), levelKey(scriptId)]);
+}
+// Drop the logs of scripts whose rows are going away — otherwise an
+// orphaned session-storage entry would outlive the script it described
+// and confuse any later renderer that scans log levels. Goes through
+// `clearScriptLog` (and therefore the per-script queue, in whichever
+// context owns it), so an append still in flight can't land after the
+// removal and resurrect the row.
+// Best-effort: a script whose log was never written isn't an error, and
+// nothing that deletes a row should fail because of its log.
+export async function forgetScriptLogs(scriptIds) {
+    await Promise.all(scriptIds.map((id) => clearScriptLog(id).catch(() => { })));
+}
+// Read the persisted "highest log level seen" sentinel for one script.
+// Returns undefined when no script-originated entry has been appended
+// since the last reset — a `clearScriptLog`, a `resetsLogLevel` entry
+// (new content loaded), or the start of the Chrome session. Load-state
+// entries don't count (see `LogEntry.state`). Between resets it only
+// goes up — LOG_CAP rotation does NOT decrease it. Once a script has
+// hit ERROR, rotation that drops the only error entry leaves the badge
+// at ERROR until the next reset. We accept that drift because
+// recomputing on every rotation would dominate the cost of an append
+// and the log itself is session-scoped anyway.
+export async function getMaxLogLevel(scriptId) {
+    const key = levelKey(scriptId);
+    const got = await chrome.storage.session.get(key);
+    const v = got[key];
+    return v === 'info' || v === 'warning' || v === 'error' ? v : undefined;
+}
+// Read every script's max log level in one storage round trip. The
+// collections page uses this to render the Status column without N
+// per-script reads. Returns a Map keyed by scriptId.
+export async function getAllMaxLogLevels() {
+    const all = await chrome.storage.session.get(null);
+    const out = new Map();
+    for (const [key, value] of Object.entries(all)) {
+        if (!key.startsWith(LOG_LEVEL_KEY_PREFIX))
+            continue;
+        if (value === 'info' || value === 'warning' || value === 'error') {
+            out.set(key.slice(LOG_LEVEL_KEY_PREFIX.length), value);
+        }
+    }
+    return out;
+}
+// Convenience: fire-and-forget. Used by call sites that already have a
+// console.log next to the event and don't want to await an extra
+// promise. Errors swallow silently — the log itself isn't load-bearing
+// and a chrome.storage.session failure shouldn't break the refresh
+// path that's emitting the event.
+export function logScriptEvent(scriptId, input) {
+    appendScriptLog(scriptId, input).catch(() => { });
+}
+// Test/debug hook to drain in-flight appends before asserting on the
+// stored log. Used by unit tests directly, and by the SW's e2e
+// `getScriptLog` accessor — both would otherwise race `logScriptEvent`,
+// which returns before its write lands.
+export async function _flushScriptLogQueueForTests(scriptId) {
+    // Loop rather than awaiting once: an append that chains on while we
+    // wait becomes the new tail, and returning after the old one would
+    // leave exactly the entry the caller is about to read still unwritten.
+    let awaited;
+    for (let tail = queues.get(scriptId); tail && tail !== awaited; tail = queues.get(scriptId)) {
+        awaited = tail;
+        await tail.catch(() => { });
+    }
+}

package/dist/extension/script-rejection.js

@@ -0,0 +1,104 @@
+// Per-script record of a registration `chrome.userScripts` refused.
+//
+// A rejected spec is a state of its own: the script loaded fine (it has
+// valid content, a valid header, and a status of `ok`), but Chrome
+// would not accept the registration — a `@match` pattern it considers
+// malformed is the usual cause — so the script silently never runs.
+// The collections page and the viewer render that as REJECTED. See
+// [docs/diagnostics.md](../docs/diagnostics.md#rejected-registrations).
+//
+// Rarer than it used to be: `matchPatternProblem` (src/url-match.ts)
+// catches the malformed shapes we are sure about at parse time, so what
+// reaches here is the rest of Chrome's grammar — a malformed port, a
+// host its canonicalizer rejects, or whatever it tightens next.
+//
+// Written only by `src/extension/injector.ts` — `registerWithFallback` and the
+// targeted retry are the only places that ever learn a spec was
+// refused. Read by the collections page and the viewer for the row's
+// status, and by `src/extension/background.ts` for the tab badge; all three
+// watch `chrome.storage.session.onChanged` so they repaint without a
+// reload.
+//
+// Why `chrome.storage.session`:
+//   - The fact describes Chrome's CURRENT registration set, which is
+//     itself dropped on browser shutdown. Persisting it to local
+//     storage would let a REJECTED badge outlive the registration
+//     attempt that produced it.
+//   - It has to outlive the service worker: MV3 evicts the SW freely
+//     and `syncRegistrations` runs again on every wake-up, so an
+//     in-memory Map would lose the state on every eviction.
+//
+// Why one map key rather than a key per script (the shape
+// `script-log.ts` uses for log levels): the injector rewrites the whole
+// set on every sync so that a script which left the active registration
+// set — disabled, deleted, or newly INVALID — can't leave a stale
+// REJECTED badge behind. Authoritative-set semantics want a single
+// read/write; the alternative would need a full session scan to find
+// the strays.
+import { assertWorkerContext } from '../run-context.js';
+// Session-storage key holding the whole `RejectionMap`.
+export const REJECTIONS_KEY = 'injector-rejections';
+// The one sentence every surface uses for a refused registration: the
+// Log row, and the viewer's message bar. One message per problem —
+// two copies would drift the moment either is reworded.
+//
+// `reason` is Chrome's own wording, appended rather than rephrased
+// because it names the offending header value. See
+// [docs/diagnostics.md](../docs/diagnostics.md#rejected-registrations).
+export function describeRejection(reason) {
+    return `Chrome rejected this script's registration, so it will not run: ${reason}`;
+}
+// Coerce an unknown storage value into a RejectionMap, dropping any
+// entry whose reason isn't a string. Used for both the direct read and
+// the `storage.onChanged` newValue, so the two paths can't disagree
+// about what a well-formed record looks like.
+export function coerceRejectionMap(value) {
+    if (!value || typeof value !== 'object')
+        return {};
+    const out = {};
+    for (const [id, message] of Object.entries(value)) {
+        if (typeof message === 'string')
+            out[id] = message;
+    }
+    return out;
+}
+// Every registration the last sync could not place. Empty when nothing
+// is rejected, which is the overwhelmingly common case.
+export async function readRejections() {
+    try {
+        const got = await chrome.storage.session.get(REJECTIONS_KEY);
+        return coerceRejectionMap(got[REJECTIONS_KEY]);
+    }
+    catch {
+        // Session storage being unavailable shouldn't break a sync; the
+        // worst case is a status cell that doesn't say REJECTED.
+        return {};
+    }
+}
+// Replace the stored map with `next`, but only when it actually differs
+// from `prior`. The no-rejections case — every sync on a healthy
+// profile — then costs one read and no write, and no needless
+// `storage.onChanged` event fans out to the open UI pages.
+//
+// Note this is about the STORAGE write, not about logging: a rejection
+// that persists across syncs writes nothing here but still gets a fresh
+// Log row each time, because "we tried again and Chrome said no again"
+// is a fact about this sync. See `registerWithFallback`.
+export async function writeRejections(prior, next) {
+    if (sameRejections(prior, next))
+        return;
+    assertWorkerContext('write storage');
+    try {
+        await chrome.storage.session.set({ [REJECTIONS_KEY]: next });
+    }
+    catch { /* best-effort: the badge isn't load-bearing */ }
+}
+function sameRejections(a, b) {
+    const keys = Object.keys(a);
+    if (keys.length !== Object.keys(b).length)
+        return false;
+    for (const id of keys)
+        if (a[id] !== b[id])
+            return false;
+    return true;
+}