@hraness/sponge 0.6.8 → 0.6.9

package/dist/src/cli/commands.js

@@ -24,6 +24,7 @@ import { createDigest, undigestible } from '../digest/pipeline.js';
 import { createQueryEmbedder, createTextEmbedder } from '../search/query.js';
 import { runtimeGcAction, runtimeGcText, setupRuntimeGc } from './runtimes.js';
 import { drainLibrary } from '../worker/basic.js';
+import { browserStatus, removeBrowser, setupBrowser } from '../browser/setup.js';
 import { minAge, publishSite } from '../publish/index.js';
 import { SpongeError, codeOf, publicCode, exitFor, isSpongeCode } from '../errors.js';
 const abs = (v) => typeof v === 'string' && isAbsolute(v);
@@ -33,6 +34,21 @@ function archivable(kind, locator, connection) {
     if (kind === 'media' || connection || !/^https?:/.test(locator))
         throw new SpongeError('unsupported');
 }
+/** The extension captures web articles; PDFs and media keep their own fetchers. */
+function browsable(kind, locator, connection) {
+    if (kind !== 'article' || connection || !/^https?:/.test(locator))
+        throw new SpongeError('unsupported');
+}
+/** `--archive` or `--browser`: at most one route. */
+function route(flags, kind, locator, connection) {
+    if (flags.archive && flags.browser)
+        throw new SpongeError('invalid-input');
+    if (flags.archive)
+        return (archivable(kind, locator, connection), 'archive');
+    if (flags.browser)
+        return (browsable(kind, locator, connection), 'browser');
+    return undefined;
+}
 const lines = (items) => items.map((item) => `${item.itemId}\t${item.title}`);
 /** The failure of a job that did not run here: its state, or its recorded reason. */
 function jobFailure(store, jobId) {
@@ -83,6 +99,10 @@ async function drain(c, jobId, connections) {
     }
     const failed = results.find((result) => !result.ok);
     if (failed && !failed.ok) {
+        // A narrower recorded reason, such as browser-offline, prints with its own hint.
+        const reason = jobId && store.queue.list().find((j) => j.id === jobId)?.reason;
+        if (isSpongeCode(reason) && reason !== failed.code && publicCode(reason) === failed.code)
+            throw jobFailure(store, jobId);
         process.stderr.write(JSON.stringify(failed) + '\n');
         return exitFor(failed.code);
     }
@@ -177,9 +197,10 @@ export const commands = [
         usage: [
             ['add URL_OR_PDF [--kind article|pdf|media] [--connection ID] [--wait]', ''],
             ['add URL --archive [--wait]', 'Capture the newest Internet Archive copy of a dead or paywalled page'],
+            ['add URL --browser [--wait]', 'Capture through your browser and its sign-ins (sponge browser setup)'],
         ],
         positional: 1,
-        flags: { connection: 'value', kind: 'value', wait: 'boolean', archive: 'boolean', ...media },
+        flags: { connection: 'value', kind: 'value', wait: 'boolean', archive: 'boolean', browser: 'boolean', ...media },
         library: 'open',
         handler: async (c) => {
             const { store, args } = c, connections = await readConnections(store.root);
@@ -188,14 +209,12 @@ export const commands = [
                 throw new SpongeError('invalid-input');
             const input = args.positional[0], kind = (args.flags.kind ?? inferKind(input));
             const source = (kind === 'pdf' ? pdfSource : kind === 'media' ? mediaSource : articleSource)(input, connection?.realm ?? 'public');
-            const archive = args.flags.archive === true;
-            if (archive)
-                archivable(kind, source.locator, connection);
+            const via = route(args.flags, kind, source.locator, connection);
             const submission = store.queue.submit({
                 kind,
                 ...source,
-                ...(archive ? { intent: 'archive' } : {}),
-                idempotencyKey: (archive ? 'archive:' : 'save:') + source.sourceKey,
+                ...(via ? { intent: via } : {}),
+                idempotencyKey: `${via ?? 'save'}:${source.sourceKey}`,
             }), { jobId, itemId } = submission;
             const job = store.queue.list().find((j) => j.id === jobId);
             if (!args.flags.wait) {
@@ -356,21 +375,21 @@ export const commands = [
         usage: [
             ['refresh ITEM [--wait]', 'Capture a new revision'],
             ['refresh ITEM --archive [--wait]', 'Capture the newest Internet Archive copy instead of the live page'],
+            ['refresh ITEM --browser [--wait]', 'Capture through your browser and its sign-ins'],
         ],
         positional: 1,
-        flags: { wait: 'boolean', archive: 'boolean', ...media },
+        flags: { wait: 'boolean', archive: 'boolean', browser: 'boolean', ...media },
         library: 'open',
         handler: async (c) => {
             const { store, args } = c, connections = await readConnections(store.root), previous = store.queue.list().find((j) => j.item_id === args.positional[0]), source = previous && store.queue.source(String(previous.id));
             if (!source || !['article', 'pdf', 'media'].includes(source.kind))
                 throw new SpongeError('unavailable');
-            const { archive: _, ...rest } = source, kind = source.kind;
-            if (args.flags.archive)
-                archivable(kind, source.locator);
+            const { via: _, ...rest } = source, kind = source.kind;
+            const via = route(args.flags, kind, source.locator, source.realm.startsWith('connection:') || undefined);
             const submission = store.queue.submit({
                 ...rest,
                 kind,
-                intent: args.flags.archive ? 'archive' : 'refresh',
+                intent: via ?? 'refresh',
                 idempotencyKey: randomUUID(),
             });
             if (!args.flags.wait) {
@@ -463,10 +482,17 @@ export const commands = [
             catch (error) {
                 digest = publicCode(error, 'runtime-missing');
             }
+            const browser = await browserStatus(store.root), browserState = browser.connected
+                ? browser.background
+                    ? 'connected'
+                    : 'connected, background captures off'
+                : browser.registered.length
+                    ? 'not connected'
+                    : 'not set up';
             const cleanup = store.queue.pendingCleanup(), worker = await workerDoctor(store, c.version), workerBroken = !['ready', 'not-installed', 'unsupported'].includes(worker.worker);
             // Each runtime that is not ready names the command that installs it.
             const line = (label, state, fix) => `${label}: ${state}${state === 'runtime-missing' ? ` (${fix})` : ''}`;
-            c.emit({ library: 'ready', capture, pdf, ...states, digest, pendingCleanup: cleanup, worker }, [
+            c.emit({ library: 'ready', capture, pdf, ...states, digest, browser: browserState, pendingCleanup: cleanup, worker }, [
                 'Library: ready',
                 `Capture: ${capture}`,
                 `PDF: ${pdf === 'ready' ? 'ready' : 'Poppler not found (brew install poppler)'}`,
@@ -474,6 +500,7 @@ export const commands = [
                 line('Speech-to-text', states.asr, 'sponge setup --asr'),
                 line('Embedding', states.embedding, 'sponge setup --embedding'),
                 line('Digest model', digest, 'sponge setup --digest'),
+                `Browser: ${browserState}${browserState === 'not set up' ? ' (optional: sponge browser setup)' : ''}`,
                 `Pending cleanup: ${cleanup}${cleanup ? ' (sponge queue recover)' : ''}`,
                 `Worker: ${worker.worker}${Array.isArray(worker.drift) ? ` (${worker.drift.join(', ')})` : ''}${worker.repair ? `\n  ${worker.repair}` : ''}`,
             ].join('\n'));
@@ -592,6 +619,51 @@ export const commands = [
             return 0;
         },
     },
+    {
+        name: 'browser',
+        summary: 'Capture through your own browser and its sign-ins',
+        usage: [
+            ['browser setup [--hosts-dir DIR]', 'Connect the Sponge extension in Chrome and other Chromium browsers'],
+            ['browser status', 'Show which browsers are set up and whether the extension is connected'],
+            ['browser remove', 'Disconnect Sponge from every browser'],
+        ],
+        positional: 1,
+        flags: { 'hosts-dir': 'value' },
+        library: 'open',
+        check: (p) => ['setup', 'status', 'remove'].includes(p[0]),
+        handler: async (c) => {
+            const { store, args } = c, hostsDir = args.flags['hosts-dir'];
+            if (hostsDir !== undefined && !isAbsolute(hostsDir))
+                throw new SpongeError('invalid-input');
+            const options = hostsDir ? { hostsDirs: [hostsDir] } : {};
+            if (args.positional[0] === 'setup') {
+                const result = await setupBrowser(store.root, options);
+                c.emit(result, [
+                    result.registered.length
+                        ? `Registered with: ${result.registered.join(', ')}`
+                        : 'No Chromium browser found. Install Chrome, or pass --hosts-dir.',
+                    'Then load the extension once:',
+                    '  1. Open chrome://extensions and turn on Developer mode',
+                    `  2. Click "Load unpacked" and choose ${result.extension}`,
+                    '  3. Pin Sponge, then check `sponge browser status`',
+                ].join('\n'));
+                return result.registered.length ? 0 : 4;
+            }
+            if (args.positional[0] === 'remove') {
+                const result = await removeBrowser(options);
+                c.emit(result, result.removed.length ? `Removed from: ${result.removed.join(', ')}` : 'Nothing to remove');
+                return 0;
+            }
+            const status = await browserStatus(store.root, options);
+            c.emit(status, [
+                `Registered: ${status.registered.join(', ') || 'none (sponge browser setup)'}`,
+                `Library: ${status.bound ? 'this one' : 'another library (sponge browser setup to switch)'}`,
+                `Extension: ${status.connected ? `connected${status.extension ? ` (${status.extension})` : ''}` : 'not connected'}`,
+                ...(status.connected ? [`Background captures: ${status.background ? 'on' : 'off'}`] : []),
+            ].join('\n'));
+            return status.connected ? 0 : 4;
+        },
+    },
     {
         name: 'import',
         summary: 'Import existing captures',

package/dist/src/errors.d.ts

@@ -23,6 +23,7 @@ declare const parents: {
     readonly 'parent-missing': "invalid-input";
     readonly 'target-exists': "invalid-input";
     readonly 'connection-retired': "unsupported";
+    readonly 'browser-offline': "unavailable";
 };
 export type DetailCode = keyof typeof parents;
 export type SpongeCode = ErrorCode | DetailCode;

package/dist/src/errors.js

@@ -37,6 +37,7 @@ const parents = {
     'parent-missing': 'invalid-input',
     'target-exists': 'invalid-input',
     'connection-retired': 'unsupported',
+    'browser-offline': 'unavailable',
 };
 export const indexCodes = [
     'invalid-index',
@@ -88,6 +89,7 @@ export const detailHints = {
     'model-unavailable': 'The model server did not answer or returned an error. Check that it is still running and has free GPU memory (another loaded model can exhaust it), then retry.',
     'source-too-thin': 'The capture holds too little text to digest: under 20 words of prose, or only an archive’s metadata. Refresh the item when a fuller capture is possible.',
     'connection-retired': 'Saved GhostGet account connections were retired in Sponge 0.5.0. Attach a signed-in browser over CDP and add it to connections.json instead.',
+    'browser-offline': 'No browser has the Sponge extension connected, or its background captures are off. Open Chrome with the extension on, check `sponge browser status`, then retry.',
     'model-busy': 'Another llama-server is running, and two loaded models can exhaust GPU memory. Wait for it to exit, then retry.',
 };
 /** The one error type. `message` is the code, so bare `String(error)` never carries detail, paths or causes. */

package/dist/src/pdf/handler.js

@@ -22,9 +22,7 @@ export function ingestPdf(store, token, options) {
         const source = store.queue.source(token.jobId);
         if (!source || source.kind !== 'pdf')
             throw new SpongeError('invalid-input');
-        const snapshot = source.archive
-            ? await (options.snapshot ?? waybackSnapshot)(source.locator, token.attemptId)
-            : null;
+        const snapshot = source.via === 'archive' ? await (options.snapshot ?? waybackSnapshot)(source.locator, token.attemptId) : null;
         if (snapshot && 'ok' in snapshot)
             return snapshot;
         const fetched = snapshot?.url ?? source.locator;

package/dist/src/store/queue.d.ts

@@ -46,7 +46,7 @@ export declare class Queue {
     list(): Row[];
     /**
      * Acquisition data for a capture job. A local file's locator is its path on this device (`local_sources`), never the
-     * synced form. `archive` is set when any submission the job serves asked for the Internet Archive copy.
+     * synced form. `via` names the route the job's newest archive or browser submission asked for.
      */
     source(jobId: string): {
         itemId: string;
@@ -54,7 +54,7 @@ export declare class Queue {
         sourceKey: string;
         locator: string;
         realm: string;
-        archive: boolean;
+        via?: 'archive' | 'browser';
     } | null;
     claimNext(token: OwnerToken): AttemptToken | null;
     claim(token: OwnerToken, jobId: string): AttemptToken;

package/dist/src/store/queue.js

@@ -163,7 +163,7 @@ export class Queue {
         const realm = input.realm ?? '';
         if (realm)
             text(realm, 256);
-        if (input.intent !== undefined && !['save', 'refresh', 'archive'].includes(input.intent))
+        if (input.intent !== undefined && !['save', 'refresh', 'archive', 'browser'].includes(input.intent))
             throw new SpongeError('invalid-input');
         const db = this.c.db;
         return transaction(db, () => {
@@ -226,14 +226,17 @@ export class Queue {
     }
     /**
      * Acquisition data for a capture job. A local file's locator is its path on this device (`local_sources`), never the
-     * synced form. `archive` is set when any submission the job serves asked for the Internet Archive copy.
+     * synced form. `via` names the route the job's newest archive or browser submission asked for.
      */
     source(jobId) {
         text(jobId, 256);
         const row = this.c.db
-            .prepare("SELECT i.id itemId,i.kind,r.source_key sourceKey,COALESCE(l.locator,r.locator) locator,r.realm_key realm,EXISTS(SELECT 1 FROM submissions s WHERE s.job_id=j.id AND s.intent='archive') archive FROM jobs j JOIN items i ON i.id=j.item_id JOIN source_refs r ON r.item_id=i.id LEFT JOIN local_sources l ON l.item_id=i.id WHERE j.id=? AND i.deleted_at IS NULL ORDER BY r.id LIMIT 1")
+            .prepare("SELECT i.id itemId,i.kind,r.source_key sourceKey,COALESCE(l.locator,r.locator) locator,r.realm_key realm,(SELECT s.intent FROM submissions s WHERE s.job_id=j.id AND s.intent IN ('archive','browser') ORDER BY s.created_at DESC,s.rowid DESC LIMIT 1) via FROM jobs j JOIN items i ON i.id=j.item_id JOIN source_refs r ON r.item_id=i.id LEFT JOIN local_sources l ON l.item_id=i.id WHERE j.id=? AND i.deleted_at IS NULL ORDER BY r.id LIMIT 1")
             .get(jobId);
-        return row ? { ...row, archive: row.archive === 1 } : null;
+        if (!row)
+            return null;
+        const { via, ...source } = row;
+        return via ? { ...source, via } : source;
     }
     claimNext(token) {
         checkOwner(this.c.db, token);

package/dist/src/store/types.d.ts

@@ -27,8 +27,11 @@ export interface SourceSubmission {
     realm?: string;
     kind: ItemKind;
     idempotencyKey: string;
-    /** `archive` captures the source's newest Internet Archive copy instead of the live page. */
-    intent?: 'save' | 'refresh' | 'archive';
+    /**
+     * `archive` captures the source's newest Internet Archive copy instead of the live page; `browser` captures it
+     * through the reader's own browser and sign-ins.
+     */
+    intent?: 'save' | 'refresh' | 'archive' | 'browser';
 }
 export interface Submission {
     itemId: string;

package/dist/src/worker/basic.js

@@ -4,8 +4,10 @@ import { ingestArticle } from '../app/article.js';
 import { ingestPdf } from '../pdf/index.js';
 import { ingestMedia } from '../media/handler.js';
 import { drainQueue } from './engine.js';
+import { askBridge, bridgeSocket } from '../browser/bridge.js';
 /** Content handlers over the durable sequential worker and its process supervisor. */
 export async function drainLibrary(store, options) {
+    const browser = options.browser ?? bridgeSocket(store.root);
     const handler = async (context) => {
         const source = store.queue.source(context.attempt.jobId);
         let connection;
@@ -18,6 +20,18 @@ export async function drainLibrary(store, options) {
             store.queue.settle(context.attempt);
             return { ...failure(context.attempt.attemptId, publicCode(code), 'acquisition'), cleanup: 'settled' };
         }
+        if (source?.via === 'browser') {
+            // Asked once up front, so an absent browser is a clear reason rather than an empty capture.
+            const status = await askBridge(browser, { op: 'status' }, { timeoutMs: 5000, maxBytes: 4096 });
+            if (!status.ok || !('background' in status) || !status.background) {
+                store.queue.fail(context.attempt, 'browser-offline', { retryable: true });
+                store.queue.settle(context.attempt);
+                return {
+                    ...failure(context.attempt.attemptId, 'unavailable', 'acquisition', true),
+                    cleanup: 'settled',
+                };
+            }
+        }
         if (source?.kind === 'media') {
             const { capture: _articleCapture, ...mediaOptions } = options;
             return ingestMedia(store, context.attempt, {
@@ -30,6 +44,7 @@ export async function drainLibrary(store, options) {
         }
         return (source?.kind === 'pdf' ? ingestPdf : ingestArticle)(store, context.attempt, {
             ...options,
+            browser,
             connection,
             signal: context.signal,
             runProcess: context.runProcess,

package/extension/background.js

@@ -0,0 +1,180 @@
+// The Sponge extension. Sponge asks over native messaging for a page; this worker loads it with the reader's own
+// sign-ins and answers with the page alone. Cookies and passwords never leave the browser.
+const host = 'com.hraness.sponge';
+const version = chrome.runtime.getManifest().version;
+/** Sponge holds a page to 16 MiB of HTML. */
+const maxHtml = 16 * 1024 * 1024;
+let port = null;
+let connectedAt = 0;
+let retryMs = 1000;
+const saves = new Map();
+
+async function backgroundAllowed() {
+  const { background } = await chrome.storage.local.get('background');
+  return background !== false;
+}
+
+async function connect() {
+  if (port) return;
+  try {
+    port = chrome.runtime.connectNative(host);
+  } catch {
+    port = null;
+    return reconnectLater();
+  }
+  connectedAt = Date.now();
+  port.onMessage.addListener(onHostMessage);
+  port.onDisconnect.addListener(() => {
+    void chrome.runtime.lastError;
+    port = null;
+    for (const resolve of saves.values()) resolve({ ok: false, code: 'offline' });
+    saves.clear();
+    // A host that ran for a while left normally; one that never started (not set up) backs off to a minute.
+    if (Date.now() - connectedAt > 10_000) retryMs = 1000;
+    reconnectLater();
+  });
+  port.postMessage({ type: 'hello', version, background: await backgroundAllowed() });
+}
+
+function reconnectLater() {
+  setTimeout(connect, retryMs);
+  retryMs = Math.min(retryMs * 2, 60_000);
+}
+
+function onHostMessage(message) {
+  if (message?.type === 'saved') {
+    saves.get(message.requestId)?.(message);
+    saves.delete(message.requestId);
+    return;
+  }
+  if (typeof message?.id !== 'string') return;
+  const run = message.op === 'fetch' ? fetchPage : message.op === 'render' ? renderPage : null;
+  if (!run) return port?.postMessage({ id: message.id, ok: false, code: 'failed' });
+  backgroundAllowed()
+    .then((allowed) => (allowed ? run(message.url, message.timeoutMs) : { ok: false, code: 'disabled' }))
+    .catch(() => ({ ok: false, code: 'failed' }))
+    .then((answer) => port?.postMessage({ id: message.id, ...answer }));
+}
+
+/** The page's HTML as the reader's browser would fetch it, with their cookies. */
+async function fetchPage(url, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, { credentials: 'include', cache: 'no-store', signal: controller.signal });
+    if (!response.ok) return { ok: false, code: 'failed', status: response.status };
+    if (!/^(text\/html|application\/xhtml\+xml)\b/i.test(response.headers.get('content-type') ?? ''))
+      return { ok: false, code: 'not-html' };
+    const html = await response.text();
+    if (html.length > maxHtml) return { ok: false, code: 'too-large' };
+    return { ok: true, html, finalUrl: response.url };
+  } catch {
+    return { ok: false, code: controller.signal.aborted ? 'timeout' : 'failed' };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/** The page after its scripts run, in a muted background tab that closes when done. */
+async function renderPage(url, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let tab;
+  try {
+    tab = await chrome.tabs.create({ url, active: false });
+  } catch {
+    // No window to open a tab in: a minimized one serves instead.
+    const window = await chrome.windows.create({ url, focused: false, state: 'minimized' });
+    tab = window.tabs[0];
+  }
+  try {
+    await chrome.tabs.update(tab.id, { muted: true });
+    if (!(await loaded(tab.id, deadline))) return { ok: false, code: 'timeout' };
+    const [result] = await chrome.scripting.executeScript({ target: { tabId: tab.id }, func: snapshot });
+    const page = result?.result;
+    if (!page || typeof page.html !== 'string') return { ok: false, code: 'failed' };
+    if (page.html.length > maxHtml) return { ok: false, code: 'too-large' };
+    return { ok: true, html: page.html, finalUrl: page.url, title: page.title };
+  } catch {
+    return { ok: false, code: 'failed' };
+  } finally {
+    await chrome.tabs.remove(tab.id).catch(() => undefined);
+  }
+}
+
+/** A new tab first reports its blank start page as complete; only the requested page counts. */
+const navigated = (tab) => tab.status === 'complete' && !tab.pendingUrl && /^https?:/.test(tab.url ?? '');
+
+function loaded(tabId, deadline) {
+  return new Promise((resolve) => {
+    const done = (value) => {
+      clearTimeout(timer);
+      clearInterval(poll);
+      chrome.tabs.onUpdated.removeListener(listen);
+      resolve(value);
+    };
+    const check = () =>
+      chrome.tabs.get(tabId).then(
+        (tab) => navigated(tab) && done(true),
+        () => done(false),
+      );
+    const listen = (id, _change, tab) => id === tabId && navigated(tab) && done(true);
+    const timer = setTimeout(() => done(false), Math.max(0, deadline - Date.now()));
+    // Update events can be missed while a fresh browser settles, so the tab is also checked every half second.
+    const poll = setInterval(check, 500);
+    chrome.tabs.onUpdated.addListener(listen);
+    check();
+  });
+}
+
+/** Runs in the page: scrolls once through it so lazy text loads, then returns the document. */
+async function snapshot() {
+  const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+  await pause(1000);
+  for (let step = 0; step < 10 && innerHeight + scrollY < document.body.scrollHeight; step++) {
+    scrollBy(0, innerHeight);
+    await pause(200);
+  }
+  scrollTo(0, 0);
+  return { html: '<!doctype html>\n' + document.documentElement.outerHTML, url: location.href, title: document.title };
+}
+
+/** Asks Sponge to save a page; the Sponge worker then captures it through this browser. */
+function save(url) {
+  if (!port) return Promise.resolve({ ok: false, code: 'offline' });
+  const requestId = crypto.randomUUID();
+  return new Promise((resolve) => {
+    saves.set(requestId, resolve);
+    setTimeout(() => saves.delete(requestId) && resolve({ ok: false, code: 'timeout' }), 15_000);
+    port.postMessage({ type: 'save', requestId, url });
+  });
+}
+
+chrome.runtime.onMessage.addListener((message, _sender, reply) => {
+  if (message?.type === 'status') {
+    backgroundAllowed().then((background) => reply({ connected: port !== null, background }));
+    return true;
+  }
+  if (message?.type === 'set-background') {
+    chrome.storage.local
+      .set({ background: message.value === true })
+      .then(() => port?.postMessage({ type: 'settings', version, background: message.value === true }))
+      .then(() => reply({ ok: true }));
+    return true;
+  }
+  if (message?.type === 'save') {
+    save(message.url).then(reply);
+    return true;
+  }
+  return false;
+});
+
+chrome.runtime.onInstalled.addListener(() => {
+  chrome.contextMenus.create({ id: 'save-link', title: 'Save link to Sponge', contexts: ['link'] });
+  chrome.contextMenus.create({ id: 'save-page', title: 'Save page to Sponge', contexts: ['page'] });
+});
+chrome.contextMenus.onClicked.addListener((info, tab) => {
+  const url = info.menuItemId === 'save-link' ? info.linkUrl : tab?.url;
+  if (url) void save(url);
+});
+chrome.runtime.onStartup.addListener(connect);
+void connect();

package/extension/manifest.json

@@ -0,0 +1,25 @@
+{
+  "manifest_version": 3,
+  "name": "Sponge",
+  "version": "0.6.9",
+  "description": "Save pages to your local Sponge library with the sign-ins you already have. Cookies never leave the browser.",
+  "key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAoSbZrBglr0h0193XOgavySnrG0DQif+WgYJ37CFSrbBwWP43rUz2ZzGRPvNveHgFZvFZlhGITJD0VC4NMQa2kxGAPP66RWEulIZDvGauxKonwcrlSneD+srPY8oMNX5sivTqw819uMwDA70oxBxKyTX4t4vwpwXuFX3Zf+5jwUOD3nz8XZFGT9uDh86MHyYYlURzsZQYBJSf2qAN17+OfhV7NHCWM5FdQodnOau6N/PcH/MstVGnbOaWeaTGged0PS2QGA5NDoOu5WZv1sUTHFqzM/Wsb/h1l8Kt5IfOZAXvhokhBBW7HTyYqgvX4wFHuj5fNioYshBUfMrKeZZFlQIDAQAB",
+  "minimum_chrome_version": "116",
+  "background": {
+    "service_worker": "background.js"
+  },
+  "action": {
+    "default_title": "Sponge",
+    "default_popup": "popup.html"
+  },
+  "permissions": [
+    "nativeMessaging",
+    "scripting",
+    "tabs",
+    "storage",
+    "contextMenus"
+  ],
+  "host_permissions": [
+    "<all_urls>"
+  ]
+}

package/extension/popup.html

@@ -0,0 +1,85 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>Sponge</title>
+    <style>
+      :root {
+        color-scheme: light dark;
+        --ink: #1d1d1f;
+        --muted: #6e6e73;
+        --paper: #ffffff;
+        --line: #d2d2d7;
+        --accent: #0a7c5a;
+      }
+      @media (prefers-color-scheme: dark) {
+        :root {
+          --ink: #f5f5f7;
+          --muted: #a1a1a6;
+          --paper: #1c1c1e;
+          --line: #3a3a3c;
+          --accent: #30c48d;
+        }
+      }
+      body {
+        margin: 0;
+        width: 280px;
+        padding: 14px 16px;
+        font:
+          13px/1.4 -apple-system,
+          BlinkMacSystemFont,
+          'Helvetica Neue',
+          sans-serif;
+        color: var(--ink);
+        background: var(--paper);
+      }
+      h1 {
+        margin: 0 0 4px;
+        font-size: 15px;
+      }
+      #state {
+        margin: 0 0 12px;
+        color: var(--muted);
+      }
+      button {
+        width: 100%;
+        padding: 8px;
+        border: 0;
+        border-radius: 6px;
+        font: inherit;
+        font-weight: 600;
+        color: #fff;
+        background: var(--accent);
+        cursor: pointer;
+      }
+      button:disabled {
+        opacity: 0.5;
+        cursor: default;
+      }
+      label {
+        display: flex;
+        gap: 8px;
+        align-items: flex-start;
+        margin-top: 12px;
+        padding-top: 12px;
+        border-top: 1px solid var(--line);
+        color: var(--muted);
+      }
+      #result {
+        min-height: 1.4em;
+        margin: 8px 0 0;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Sponge</h1>
+    <p id="state">Checking…</p>
+    <button id="save" disabled>Save this page</button>
+    <p id="result" role="status"></p>
+    <label
+      ><input id="background" type="checkbox" /> Let Sponge load pages with this browser's sign-ins. Pages it loads stay
+      private in your library.</label
+    >
+    <script src="popup.js"></script>
+  </body>
+</html>

package/extension/popup.js

@@ -0,0 +1,39 @@
+const state = document.getElementById('state');
+const save = document.getElementById('save');
+const result = document.getElementById('result');
+const background = document.getElementById('background');
+const messages = {
+  offline: 'Sponge is not connected. Run `sponge browser setup`, then reopen this.',
+  unsupported: 'Sponge cannot save this kind of page.',
+  timeout: 'Sponge did not answer. Try again.',
+  failed: 'Sponge could not save this page.',
+};
+
+async function refresh() {
+  const status = await chrome.runtime.sendMessage({ type: 'status' });
+  background.checked = status.background;
+  state.textContent = status.connected
+    ? status.background
+      ? 'Connected to your library.'
+      : 'Connected. Turn on browser captures below to save pages.'
+    : messages.offline;
+  const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  save.disabled = !status.connected || !status.background || !/^https?:/.test(tab?.url ?? '');
+  save.dataset.url = tab?.url ?? '';
+}
+
+save.addEventListener('click', async () => {
+  save.disabled = true;
+  result.textContent = 'Saving…';
+  const answer = await chrome.runtime.sendMessage({ type: 'save', url: save.dataset.url });
+  result.textContent = answer.ok
+    ? 'Saved. Sponge captures it with your sign-ins.'
+    : (messages[answer.code] ?? messages.failed);
+});
+
+background.addEventListener('change', async () => {
+  await chrome.runtime.sendMessage({ type: 'set-background', value: background.checked });
+  await refresh();
+});
+
+void refresh();