abx-plugins 0.9.2__tar.gz

abx_plugins-0.9.2/.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+
+data/
+*.sqlite3*
+__pycache__/
+*.pyc

abx_plugins-0.9.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Nick Sweeting
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

abx_plugins-0.9.2/PKG-INFO

@@ -0,0 +1,208 @@
+Metadata-Version: 2.4
+Name: abx-plugins
+Version: 0.9.2
+Summary: ArchiveBox-compatible plugin suite (hooks, configs, binaries manifests)
+Project-URL: Homepage, https://github.com/ArchiveBox/abx-plugins
+Project-URL: Source, https://github.com/ArchiveBox/abx-plugins
+Project-URL: Documentation, https://github.com/ArchiveBox/ArchiveBox
+Project-URL: Bug Tracker, https://github.com/ArchiveBox/abx-plugins/issues
+Author-email: Nick Sweeting <pyproject.toml+abx-plugins@archivebox.io>
+License: MIT
+License-File: LICENSE
+Keywords: archivebox,hooks,plugins,scraping,web-archiving
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Requires-Dist: abx-pkg>=0.6.3
+Requires-Dist: feedparser>=6.0.0
+Requires-Dist: pyright>=1.1.408
+Requires-Dist: pytest-httpserver>=1.1.0
+Requires-Dist: pytest>=9.0.2
+Requires-Dist: requests>=2.32.5
+Requires-Dist: rich-click>=1.9.7
+Requires-Dist: ruff>=0.15.2
+Requires-Dist: ty>=0.0.18
+Provides-Extra: dev
+Requires-Dist: abx-pkg>=0.6.0; extra == 'dev'
+Requires-Dist: feedparser>=6.0.0; extra == 'dev'
+Requires-Dist: pytest-httpserver>=1.1.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: requests>=2.28.0; extra == 'dev'
+Requires-Dist: rich-click>=1.9.7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# abx-plugins
+
+ArchiveBox-compatible plugin suite (hooks and config schemas).
+
+This package contains only the plugins, to run them use [`abx-dl`](https://github.com/archiveBox/abx-dl) or [`archivebox`](https://github.com/archiveBox/ArchiveBox).
+
+<img width="1000" height="1082" alt="Screenshot 2026-03-11 at 6 53 03 AM" src="https://github.com/user-attachments/assets/08c5f63b-05e2-4947-adca-f64e8c5ad8b3" />
+
+## Usage
+
+Tools like `abx-dl` and ArchiveBox can discover plugins from this package
+without symlinks or environment-variable tricks.
+
+## Plugin Contract
+
+### Directory layout
+
+Each plugin lives under `plugins/<name>/` and may include:
+
+- `config.json` config schema
+- `on_Crawl__...` per-crawl hook scripts (optional) - install dependencies / set up shared resources
+- `on_Snapshot__...` per-snapshot hooks - for each URL: do xyz...
+
+Hooks run with:
+
+- **SNAP_DIR** = base snapshot directory (default: `.`)
+- **CRAWL_DIR** = base crawl directory (default: `.`)
+- **Snapshot hook output** = `SNAP_DIR/<plugin>/...`
+- **Crawl hook output** = `CRAWL_DIR/<plugin>/...`
+- **Other plugin outputs** can be read via `../<other-plugin>/...` from your own output dir
+
+### Key environment variables
+
+- `SNAP_DIR` - base snapshot directory (default: `.`)
+- `CRAWL_DIR` - base crawl directory (default: `.`)
+- `LIB_DIR` - binaries/tools root (default: `~/.config/abx/lib`)
+- `PERSONAS_DIR` - persona profiles root (default: `~/.config/abx/personas`)
+- `ACTIVE_PERSONA` - persona name (default: `Default`)
+
+### Install hook contract (concise)
+
+Lifecycle:
+
+1. `on_Crawl__*install*` declares crawl dependencies.
+2. `on_Binary__*install*` resolves/installs one binary with one provider.
+
+`on_Crawl` output (dependency declaration):
+
+```json
+{"type":"Binary","name":"yt-dlp","binproviders":"pip,brew,apt,env","overrides":{"pip":{"packages":["yt-dlp[default]"]}},"machine_id":"<optional>"}
+```
+
+`on_Binary` input/output:
+
+- CLI input should accept `--binary-id`, `--machine-id`, `--name` (plus optional provider args).
+- Output should emit installed facts like:
+
+```json
+{"type":"Binary","name":"yt-dlp","abspath":"/abs/path","version":"2025.01.01","sha256":"<optional>","binprovider":"pip","machine_id":"<recommended>","binary_id":"<recommended>"}
+```
+
+Optional machine patch record:
+
+```json
+{"type":"Machine","config":{"PATH":"...","NODE_MODULES_DIR":"...","CHROME_BINARY":"..."}}
+```
+
+Semantics:
+
+- `stdout`: JSONL records only
+- `stderr`: human logs/debug
+- exit `0`: success or intentional skip
+- exit non-zero: hard failure
+
+State/OS:
+
+- working dir: `CRAWL_DIR/<plugin>/`
+- durable install root: `LIB_DIR` (e.g. npm prefix, pip venv, puppeteer cache)
+- providers: `apt` (Debian/Ubuntu), `brew` (macOS/Linux), many hooks currently assume POSIX paths
+
+### Snapshot hook contract (concise)
+
+Lifecycle:
+
+- runs once per snapshot, typically after crawl setup
+- common Chrome flow: crawl browser/session -> `chrome_tab` -> `chrome_navigate` -> downstream extractors
+
+State:
+
+- output cwd is usually `SNAP_DIR/<plugin>/`
+- hooks may read sibling outputs via `../<plugin>/...`
+
+Output records:
+
+- terminal record is usually:
+
+```json
+{"type":"ArchiveResult","status":"succeeded|skipped|failed","output_str":"path-or-message"}
+```
+
+- discovery hooks may also emit `Snapshot` and `Tag` records before `ArchiveResult`
+- search indexing hooks are a known exception and may use exit code + stderr without `ArchiveResult`
+
+Semantics:
+
+- `stdout`: JSONL records
+- `stderr`: diagnostics/logging
+- exit `0`: succeeded or skipped
+- exit non-zero: failed
+- current nuance: some skip/transient paths emit no JSONL and rely only on exit code
+
+### Rules
+
+- all plugins should:
+  - *overwrite* existing files cleanly if re-run in the same dir, do not skip if files are already present (do not delete and then download, because if a process fails we want to leave previous output intact).
+  - the exception to always overwriting files is: chrome.pid. target_id.txt, navigation.json, etc. chrome state which gets re-used if it's not stale. we should detect if any of it is stale during chrome launch and tab creation, and clear all of it together if it is stale to prevent subtle drift errors / reuse of stale values.
+  - status `succeeded` if they ran and produced output
+  - status `noresults` if they ran succesfully but produced no meaningful output (e.g. git on a non-github url, ytdlp on a site with no media, paperdl on a site with no pdfs, etc.)
+  - status `skipped` if only if *config* caused them not to run (e.g. `YTDLP_ENABLED=False`)
+  - status `failed` if any hard dependencies are missing/invalid (e.g. chrome) or if the process exited non-0 / raised an exception
+  - return a short, meaningful `output_str` e.g. the page title, mimetype, return status code, or the relative path of the primary output file produced like `output.pdf` or `0 modals closed` or `The Page Title Verbatim` or `favicon.io` or `Not a git URL`
+  - define execution order solely using lexicographic sort order of hook filenames
+  - use bg hooks for either short-lived tasks that can run in parallel, or long-lived daemons that run for the whole duration of the snapshot and get killed for cleanup/final output at the end
+  - bg hooks that depend on other bg hook outputs must implement their own waiters internally + check that inputs are truly ready and not just that the files are present, because they may be spawned in parallel/before the earlier one's outputs are actually ready and race. e.g. html/artifact generation should usually be fg so that later bg parsing hooks can safely depend on it being finished and not just part of the file being present
+  - use rich_click for cli arg parsing with a uv file header when hooks are written in python. do not depend on archivebox or django, try to only depend on chrome or the output files of other plugins instead of importing code from them. the one exception is to always use chrome_utils.js as the interface for anything involving chrome.
+
+
+### Event JSONL interface (bbus-style, no dependency)
+
+Hooks emit JSONL events to stdout. They do **not** need to import `bbus`.
+The event envelope matches the bbus style so higher layers can stream/replay.
+
+Minimal envelope:
+
+```json
+{
+  "event_id": "uuidv7",
+  "event_type": "SnapshotCreated",
+  "event_created_at": "2026-02-01T20:10:22Z",
+  "event_parent_id": "uuidv7-or-null",
+  "event_schema": "abx.events.v1",
+  "event_path": "abx-plugins",
+  "data": { "...": "event-specific fields" }
+}
+```
+
+Conventions:
+
+- Active verb names are **requests** (e.g. `BinaryInstall`, `ProcessLaunch`).
+- Past tense names are **facts** (e.g. `BinaryInstalled`, `ProcessExited`).
+- Plugins can emit additional fields inside `data` without coordination.
+
+Common event types emitted by hooks:
+
+- `ArchiveResultCreated` (status + output files)
+- `Binary` records (dependency detection/install)
+- `ProcessStarted` / `ProcessExited`
+
+Higher-level tools (abx-dl / ArchiveBox) can:
+
+- Parse these events from stdout
+- Persist or project them (SQLite/JSONL/Django) without plugins knowing
+
+Legacy note:
+
+Some hooks still emit a lightweight JSONL record with a top-level `type` field
+(e.g., `{"type": "ArchiveResult", ...}`). Runtimes should accept those and
+optionally translate them into the event envelope above.

abx_plugins-0.9.2/README.md

@@ -0,0 +1,168 @@
+# abx-plugins
+
+ArchiveBox-compatible plugin suite (hooks and config schemas).
+
+This package contains only the plugins, to run them use [`abx-dl`](https://github.com/archiveBox/abx-dl) or [`archivebox`](https://github.com/archiveBox/ArchiveBox).
+
+<img width="1000" height="1082" alt="Screenshot 2026-03-11 at 6 53 03 AM" src="https://github.com/user-attachments/assets/08c5f63b-05e2-4947-adca-f64e8c5ad8b3" />
+
+## Usage
+
+Tools like `abx-dl` and ArchiveBox can discover plugins from this package
+without symlinks or environment-variable tricks.
+
+## Plugin Contract
+
+### Directory layout
+
+Each plugin lives under `plugins/<name>/` and may include:
+
+- `config.json` config schema
+- `on_Crawl__...` per-crawl hook scripts (optional) - install dependencies / set up shared resources
+- `on_Snapshot__...` per-snapshot hooks - for each URL: do xyz...
+
+Hooks run with:
+
+- **SNAP_DIR** = base snapshot directory (default: `.`)
+- **CRAWL_DIR** = base crawl directory (default: `.`)
+- **Snapshot hook output** = `SNAP_DIR/<plugin>/...`
+- **Crawl hook output** = `CRAWL_DIR/<plugin>/...`
+- **Other plugin outputs** can be read via `../<other-plugin>/...` from your own output dir
+
+### Key environment variables
+
+- `SNAP_DIR` - base snapshot directory (default: `.`)
+- `CRAWL_DIR` - base crawl directory (default: `.`)
+- `LIB_DIR` - binaries/tools root (default: `~/.config/abx/lib`)
+- `PERSONAS_DIR` - persona profiles root (default: `~/.config/abx/personas`)
+- `ACTIVE_PERSONA` - persona name (default: `Default`)
+
+### Install hook contract (concise)
+
+Lifecycle:
+
+1. `on_Crawl__*install*` declares crawl dependencies.
+2. `on_Binary__*install*` resolves/installs one binary with one provider.
+
+`on_Crawl` output (dependency declaration):
+
+```json
+{"type":"Binary","name":"yt-dlp","binproviders":"pip,brew,apt,env","overrides":{"pip":{"packages":["yt-dlp[default]"]}},"machine_id":"<optional>"}
+```
+
+`on_Binary` input/output:
+
+- CLI input should accept `--binary-id`, `--machine-id`, `--name` (plus optional provider args).
+- Output should emit installed facts like:
+
+```json
+{"type":"Binary","name":"yt-dlp","abspath":"/abs/path","version":"2025.01.01","sha256":"<optional>","binprovider":"pip","machine_id":"<recommended>","binary_id":"<recommended>"}
+```
+
+Optional machine patch record:
+
+```json
+{"type":"Machine","config":{"PATH":"...","NODE_MODULES_DIR":"...","CHROME_BINARY":"..."}}
+```
+
+Semantics:
+
+- `stdout`: JSONL records only
+- `stderr`: human logs/debug
+- exit `0`: success or intentional skip
+- exit non-zero: hard failure
+
+State/OS:
+
+- working dir: `CRAWL_DIR/<plugin>/`
+- durable install root: `LIB_DIR` (e.g. npm prefix, pip venv, puppeteer cache)
+- providers: `apt` (Debian/Ubuntu), `brew` (macOS/Linux), many hooks currently assume POSIX paths
+
+### Snapshot hook contract (concise)
+
+Lifecycle:
+
+- runs once per snapshot, typically after crawl setup
+- common Chrome flow: crawl browser/session -> `chrome_tab` -> `chrome_navigate` -> downstream extractors
+
+State:
+
+- output cwd is usually `SNAP_DIR/<plugin>/`
+- hooks may read sibling outputs via `../<plugin>/...`
+
+Output records:
+
+- terminal record is usually:
+
+```json
+{"type":"ArchiveResult","status":"succeeded|skipped|failed","output_str":"path-or-message"}
+```
+
+- discovery hooks may also emit `Snapshot` and `Tag` records before `ArchiveResult`
+- search indexing hooks are a known exception and may use exit code + stderr without `ArchiveResult`
+
+Semantics:
+
+- `stdout`: JSONL records
+- `stderr`: diagnostics/logging
+- exit `0`: succeeded or skipped
+- exit non-zero: failed
+- current nuance: some skip/transient paths emit no JSONL and rely only on exit code
+
+### Rules
+
+- all plugins should:
+  - *overwrite* existing files cleanly if re-run in the same dir, do not skip if files are already present (do not delete and then download, because if a process fails we want to leave previous output intact).
+  - the exception to always overwriting files is: chrome.pid. target_id.txt, navigation.json, etc. chrome state which gets re-used if it's not stale. we should detect if any of it is stale during chrome launch and tab creation, and clear all of it together if it is stale to prevent subtle drift errors / reuse of stale values.
+  - status `succeeded` if they ran and produced output
+  - status `noresults` if they ran succesfully but produced no meaningful output (e.g. git on a non-github url, ytdlp on a site with no media, paperdl on a site with no pdfs, etc.)
+  - status `skipped` if only if *config* caused them not to run (e.g. `YTDLP_ENABLED=False`)
+  - status `failed` if any hard dependencies are missing/invalid (e.g. chrome) or if the process exited non-0 / raised an exception
+  - return a short, meaningful `output_str` e.g. the page title, mimetype, return status code, or the relative path of the primary output file produced like `output.pdf` or `0 modals closed` or `The Page Title Verbatim` or `favicon.io` or `Not a git URL`
+  - define execution order solely using lexicographic sort order of hook filenames
+  - use bg hooks for either short-lived tasks that can run in parallel, or long-lived daemons that run for the whole duration of the snapshot and get killed for cleanup/final output at the end
+  - bg hooks that depend on other bg hook outputs must implement their own waiters internally + check that inputs are truly ready and not just that the files are present, because they may be spawned in parallel/before the earlier one's outputs are actually ready and race. e.g. html/artifact generation should usually be fg so that later bg parsing hooks can safely depend on it being finished and not just part of the file being present
+  - use rich_click for cli arg parsing with a uv file header when hooks are written in python. do not depend on archivebox or django, try to only depend on chrome or the output files of other plugins instead of importing code from them. the one exception is to always use chrome_utils.js as the interface for anything involving chrome.
+
+
+### Event JSONL interface (bbus-style, no dependency)
+
+Hooks emit JSONL events to stdout. They do **not** need to import `bbus`.
+The event envelope matches the bbus style so higher layers can stream/replay.
+
+Minimal envelope:
+
+```json
+{
+  "event_id": "uuidv7",
+  "event_type": "SnapshotCreated",
+  "event_created_at": "2026-02-01T20:10:22Z",
+  "event_parent_id": "uuidv7-or-null",
+  "event_schema": "abx.events.v1",
+  "event_path": "abx-plugins",
+  "data": { "...": "event-specific fields" }
+}
+```
+
+Conventions:
+
+- Active verb names are **requests** (e.g. `BinaryInstall`, `ProcessLaunch`).
+- Past tense names are **facts** (e.g. `BinaryInstalled`, `ProcessExited`).
+- Plugins can emit additional fields inside `data` without coordination.
+
+Common event types emitted by hooks:
+
+- `ArchiveResultCreated` (status + output files)
+- `Binary` records (dependency detection/install)
+- `ProcessStarted` / `ProcessExited`
+
+Higher-level tools (abx-dl / ArchiveBox) can:
+
+- Parse these events from stdout
+- Persist or project them (SQLite/JSONL/Django) without plugins knowing
+
+Legacy note:
+
+Some hooks still emit a lightweight JSONL record with a top-level `type` field
+(e.g., `{"type": "ArchiveResult", ...}`). Runtimes should accept those and
+optionally translate them into the event envelope above.

abx_plugins-0.9.2/abx_plugins/__init__.py

@@ -0,0 +1,13 @@
+"""Plugin suite package for ArchiveBox-compatible tools."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def get_plugins_dir() -> Path:
+    """Return the filesystem path to the bundled plugins directory."""
+    return Path(__file__).resolve().parent / "plugins"
+
+
+__all__ = ["get_plugins_dir"]

abx_plugins-0.9.2/abx_plugins/plugins/__init__.py

@@ -0,0 +1 @@
+"""Plugin suite root package for abx-plugins."""

abx_plugins-0.9.2/abx_plugins/plugins/accessibility/config.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "additionalProperties": false,
+  "required_plugins": ["chrome"],
+  "properties": {
+    "ACCESSIBILITY_ENABLED": {
+      "type": "boolean",
+      "default": true,
+      "x-aliases": ["SAVE_ACCESSIBILITY", "USE_ACCESSIBILITY"],
+      "description": "Enable accessibility tree capture"
+    },
+    "ACCESSIBILITY_TIMEOUT": {
+      "type": "integer",
+      "default": 30,
+      "minimum": 5,
+      "x-fallback": "TIMEOUT",
+      "description": "Timeout for accessibility capture in seconds"
+    }
+  }
+}

abx_plugins-0.9.2/abx_plugins/plugins/accessibility/on_Snapshot__39_accessibility.js

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+/**
+ * Extract accessibility tree and page outline from a URL.
+ *
+ * Extracts:
+ * - Page outline (headings h1-h6, sections, articles)
+ * - Iframe tree
+ * - Accessibility snapshot
+ * - ARIA labels and roles
+ *
+ * Usage: on_Snapshot__39_accessibility.js --url=<url> --snapshot-id=<uuid>
+ * Output: Writes accessibility/accessibility.json
+ *
+ * Environment variables:
+ *     SAVE_ACCESSIBILITY: Enable accessibility extraction (default: true)
+ */
+
+const fs = require('fs');
+const path = require('path');
+// Add NODE_MODULES_DIR to module resolution paths if set
+if (process.env.NODE_MODULES_DIR) module.paths.unshift(process.env.NODE_MODULES_DIR);
+const puppeteer = require('puppeteer-core');
+const {
+    getEnvBool,
+    getEnvInt,
+    parseArgs,
+    readCdpUrl,
+    connectToPage,
+    waitForPageLoaded,
+} = require('../chrome/chrome_utils.js');
+
+// Extractor metadata
+const PLUGIN_NAME = 'accessibility';
+const PLUGIN_DIR = path.basename(__dirname);
+const SNAP_DIR = path.resolve((process.env.SNAP_DIR || '.').trim());
+const OUTPUT_DIR = path.join(SNAP_DIR, PLUGIN_DIR);
+if (!fs.existsSync(OUTPUT_DIR)) {
+    fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+}
+process.chdir(OUTPUT_DIR);
+const OUTPUT_FILE = 'accessibility.json';
+const CHROME_SESSION_DIR = '../chrome';
+
+// Extract accessibility info
+async function extractAccessibility(url, timeoutMs) {
+    // Output directory is current directory (hook already runs in output dir)
+    const outputPath = path.join(OUTPUT_DIR, OUTPUT_FILE);
+
+    let browser = null;
+
+    try {
+        if (!readCdpUrl(CHROME_SESSION_DIR)) {
+            return { success: false, error: 'No Chrome session found (chrome plugin must run first)' };
+        }
+
+        const connection = await connectToPage({
+            chromeSessionDir: CHROME_SESSION_DIR,
+            timeoutMs,
+            puppeteer,
+        });
+        browser = connection.browser;
+        const page = connection.page;
+        await waitForPageLoaded(CHROME_SESSION_DIR, timeoutMs * 4, 200);
+
+        // Get accessibility snapshot
+        const accessibilityTree = await page.accessibility.snapshot({ interestingOnly: true });
+
+        // Extract page outline (headings, sections, etc.)
+        const outline = await page.evaluate(() => {
+            const headings = [];
+            const elements = document.querySelectorAll(
+                'h1, h2, h3, h4, h5, h6, a[name], header, footer, article, main, aside, nav, section, figure, summary, table, form, iframe'
+            );
+
+            elements.forEach(elem => {
+                // Skip unnamed anchors
+                if (elem.tagName.toLowerCase() === 'a' && !elem.name) return;
+
+                const tagName = elem.tagName.toLowerCase();
+                const elemId = elem.id || elem.name || elem.getAttribute('aria-label') || elem.role || '';
+                const elemClasses = (elem.className || '').toString().trim().split(/\s+/).slice(0, 3).join(' .');
+                const action = elem.action?.split('/').pop() || '';
+
+                let summary = (elem.innerText || '').slice(0, 128);
+                if (summary.length >= 128) summary += '...';
+
+                let prefix = '';
+                let title = '';
+
+                // Format headings with # prefix
+                const level = parseInt(tagName.replace('h', ''));
+                if (!isNaN(level)) {
+                    prefix = '#'.repeat(level);
+                    title = elem.innerText || elemId || elemClasses;
+                } else {
+                    // For other elements, create breadcrumb path
+                    const parents = [tagName];
+                    let node = elem.parentNode;
+                    while (node && parents.length < 5) {
+                        if (node.tagName) {
+                            const tag = node.tagName.toLowerCase();
+                            if (!['div', 'span', 'p', 'body', 'html'].includes(tag)) {
+                                parents.unshift(tag);
+                            } else {
+                                parents.unshift('');
+                            }
+                        }
+                        node = node.parentNode;
+                    }
+                    prefix = parents.join('>');
+
+                    title = elemId ? `#${elemId}` : '';
+                    if (!title && elemClasses) title = `.${elemClasses}`;
+                    if (action) title += ` /${action}`;
+                    if (summary && !title.includes(summary)) title += `: ${summary}`;
+                }
+
+                // Clean up title
+                title = title.replace(/\s+/g, ' ').trim();
+
+                if (prefix) {
+                    headings.push(`${prefix} ${title}`);
+                }
+            });
+
+            return headings;
+        });
+
+        // Get iframe tree
+        const iframes = [];
+        function dumpFrameTree(frame, indent = '>') {
+            iframes.push(indent + frame.url());
+            for (const child of frame.childFrames()) {
+                dumpFrameTree(child, indent + '>');
+            }
+        }
+        dumpFrameTree(page.mainFrame(), '');
+
+        const accessibilityData = {
+            url,
+            headings: outline,
+            iframes,
+            tree: accessibilityTree,
+        };
+
+        // Write output
+        fs.writeFileSync(outputPath, JSON.stringify(accessibilityData, null, 2));
+
+        return { success: true, output: outputPath, accessibilityData };
+
+    } catch (e) {
+        return { success: false, error: `${e.name}: ${e.message}` };
+    } finally {
+        if (browser) {
+            browser.disconnect();
+        }
+    }
+}
+
+async function main() {
+    const args = parseArgs();
+    const url = args.url;
+    const snapshotId = args.snapshot_id;
+
+    if (!url || !snapshotId) {
+        console.error('Usage: on_Snapshot__39_accessibility.js --url=<url> --snapshot-id=<uuid>');
+        process.exit(1);
+    }
+
+    const startTs = new Date();
+    let status = 'failed';
+    let output = null;
+    let error = '';
+
+    try {
+        // Check if enabled
+        if (!getEnvBool('ACCESSIBILITY_ENABLED', true)) {
+            console.log('Skipping accessibility (ACCESSIBILITY_ENABLED=False)');
+            // Output clean JSONL (no RESULT_JSON= prefix)
+            console.log(JSON.stringify({
+                type: 'ArchiveResult',
+                status: 'skipped',
+                output_str: 'ACCESSIBILITY_ENABLED=False',
+            }));
+            process.exit(0);
+        }
+
+        const timeoutMs = getEnvInt('ACCESSIBILITY_TIMEOUT', getEnvInt('TIMEOUT', 30)) * 1000;
+        const result = await extractAccessibility(url, timeoutMs);
+
+        if (result.success) {
+            status = 'succeeded';
+            output = result.output;
+            const headingCount = result.accessibilityData.headings.length;
+            const iframeCount = result.accessibilityData.iframes.length;
+            console.log(`Accessibility extracted: ${headingCount} headings, ${iframeCount} iframes`);
+        } else {
+            status = 'failed';
+            error = result.error;
+        }
+    } catch (e) {
+        error = `${e.name}: ${e.message}`;
+        status = 'failed';
+    }
+
+    const endTs = new Date();
+
+    if (error) console.error(`ERROR: ${error}`);
+
+    // Output clean JSONL (no RESULT_JSON= prefix)
+    console.log(JSON.stringify({
+        type: 'ArchiveResult',
+        status,
+        output_str: output || error || '',
+    }));
+
+    process.exit(status === 'succeeded' ? 0 : 1);
+}
+
+main().catch(e => {
+    console.error(`Fatal error: ${e.message}`);
+    process.exit(1);
+});

abx_plugins-0.9.2/abx_plugins/plugins/accessibility/templates/icon.html

@@ -0,0 +1 @@
+<span class="abx-output-icon abx-output-icon--accessibility" title="Accessibility"><svg width="16" height="16" viewBox="0 0 24 24" aria-hidden="true" focusable="false" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="4.5" r="2" fill="currentColor" stroke="none"/><path d="M4 7.5h16"/><path d="M12 7.5v12"/><path d="M7 20l5-6 5 6"/></svg></span>