Fissuredocumentation v5.3.1
On this page

Extension SDK (packaged, versioned extensions)

Fissure's extension SDK packages the existing file-based scripting into self-describing, versioned, installable bundles with a lifecycle (list, enable, disable, reload) and a management surface in the GUI, the control API, and the MCP bridge. It is Fissure's answer to a mature extension API plus an extension marketplace: a stable contract a third party targets once, ships as a bundle, and a user turns on or off without editing the filesystem.

This document is the design of the SDK and the record of what the first slice ships. For the raw scripting surfaces an extension is built from (the fs.* check API, transform/generator scripts, OSS-tool manifests, the BCheck and nuclei importers) see EXTENDING.md. This SDK sits on top of those: an extension is a bundle that contributes one or more of them under a single manifest.


1. Why a bundle model

Today an extension author drops loose files into resources/checks/ and plugins/. That works but has no packaging, no versioning, no metadata, no on/off switch, and no way for one logical extension to contribute several things at once. Mature extensible tools win adoption on their ecosystems, not their core tools, precisely because they solved this: a bundle is discoverable, self-describing, versioned against a stable SDK, and installable/removable as a unit.

The SDK adds exactly that over the existing scripting:

  • Packaging: an extension is a directory with a manifest (extension.json) that names it, versions it, and declares what it contributes.
  • Versioning: the manifest declares the sdk_version it targets; Fissure refuses or flags a bundle that needs a newer SDK than the running build, so an extension never half-loads against an incompatible host.
  • Lifecycle: extensions are discovered, listed with their metadata, and enabled or disabled (persisted) without touching files. A disabled extension contributes nothing.
  • One bundle, many contributions: a single extension can ship several checks (and, in later slices, context actions, editors, and GUI tabs) under one identity.

2. Bundle layout and manifest

An extension is a directory under the extensions root (resources/extensions/<id>/ for bundled/installed extensions). Its manifest is extension.json:

{
  "id": "web-hardening",
  "name": "Web hardening auditor",
  "version": "1.0.0",
  "author": "Fissure",
  "description": "Audits Content-Security-Policy content and modern isolation headers.",
  "sdk_version": 1,
  "enabled": true,
  "checks": ["checks/csp-audit.js", "checks/isolation-headers.js"]
}

Fields:

  • id: a stable identifier. It keys the enabled/disabled state and de-duplicates bundles. When it is missing or empty the bundle's directory name is used; the host does not require it to equal the directory name, but keeping the two the same avoids surprises.
  • name: the human-readable label shown in the manager. When it is missing or empty the id is used.
  • version: the extension's own version string (semantic version recommended).
  • author, description: shown in the manager and the report of what is installed.
  • sdk_version (required): the SDK ABI version the extension targets (an integer). A bundle whose sdk_version is missing, below 1, or greater than the host's FISSURE_EXTENSION_SDK_VERSION is listed but not loaded (marked incompatible with a "needs SDK N" reason); a bundle from 1 up to the host version loads (the SDK is backward-compatible within a major version).
  • enabled: the default enabled state on first sight (true when omitted). The persisted user state (see section 4) overrides it once the user toggles the extension.
  • checks: a list of paths, relative to the bundle directory, to fs.* check scripts (the surface-1 scripting from EXTENDING.md). Each contributes a passive or active check that runs everywhere Fissure runs user checks.

A subdirectory with no extension.json is not a bundle and is ignored. A manifest that does not parse, or whose sdk_version is missing or unsupported, is not loaded: it is logged and surfaced in the manager as an error entry (named after the directory, or the id), never silently dropped. A missing id or name is not an error, since both fall back as described above.

3. The SDK ABI and versioning policy

FISSURE_EXTENSION_SDK_VERSION (in fissure_constants.h) is the single integer that defines the contract. It starts at 1. The policy:

  • A host loads any bundle whose sdk_version is at most the host version.
  • Adding a new, optional contribution type or manifest field that older bundles do not use keeps the same SDK version (backward-compatible growth).
  • A breaking change to an existing contract (renaming or removing a field, changing the meaning of the fs.* API a check relies on) increments the SDK version.
  • A bundle that needs a newer host is refused loudly, never partially applied.

This lets an extension declare "I need SDK 1" once and trust it across host builds.

4. Lifecycle and state

  • Discovery: at load, Fissure enumerates each subdirectory of the extensions root, reads its extension.json, validates it, and records the bundle (compatible or not) in the registry.
  • Enabled state: the persisted override lives in <config>/extensions_state.json, a flat map of id -> enabled (a boolean). An id absent from the file uses the manifest's enabled default. Toggling an extension writes this file; nothing else is mutated on disk.
  • Apply: enabling means the extension's contributions are added wherever Fissure builds its check set: the GUI scanner (fissure_scan_load_checks), the proxy passive node, the Findings "run user scripts" action, and headless control-API scans (POST /api/scan and /api/scans now call fissure_scan_load_checks, so an agent-driven scan runs the same JS/bcheck/nuclei/extension checks a GUI scan does). A disabled or incompatible extension contributes nothing.
  • Reload: re-reads the extensions root and the state file so a freshly dropped-in or edited bundle appears without a restart.

5. Contribution types

The manifest is designed so contribution types add as new optional arrays without an SDK bump:

  • checks (shipped): fs.* scriptable checks, passive by default, active probes gated on fs.active, de-duplicated against native checks.

  • panels (shipped): a GUI panel an extension contributes. Each entry is {"title": ..., "render": <script>}; the render script is a transform-style script (no fs.* exchange context) that returns the panel's text. The host draws it with the n_gui owner-draw custom widget (n_gui_add_custom, added upstream), so the extension owns a real GUI view, opened from the Extensions manager ("Open panel"). This is the first GUI-extending contribution, built on the upstream owner-draw primitive that the richer types below will reuse.

  • tabs (shipped): a top-level view an extension owns. Each entry is {"title": ..., "render": <script>} with the same transform-style render model as a panel. Tabs are shown inline in the Extensions manager: select an extension in the bundle list and its tabs appear in an "Extension tabs" picker below the action row, with the chosen tab's rendered content in a scrollable, selectable text area beneath it; the display follows the list selection, so switching extensions swaps in their tabs. A panel is a modal popup opened on demand (Open panel); a tab is always-visible content for the selected extension. Host: src/fissure_gui_extensions.c (the display is folded into the manager; there is no separate Add-ons popup). GUI chrome (the render has no request/traffic/findings context), so per the CLAUDE.md exemption it has no control-API surface. Bundled example: web-hardening ships a "Hardening checklist" tab.

  • actions (shipped): an on-demand, request-contextual script. Each entry is {"title": ..., "run": <script>}; the run script uses the same fs.* API as a check (active fs.send permitted) but, unlike checks, it never runs during a scan, only when the operator or an agent triggers it on one selected request. In the GUI the right-click context menu's "Extension actions" runs every enabled action against the request (worker thread, spinner, outcome popup, findings merged into the store); GET /api/ext-actions lists the actions and POST /api/ext-action runs one; the ext_actions/ext_action MCP tools mirror those. The request's session cookie is carried onto every fs.send() probe (a control-API cookie/headers field, the right-clicked request's own headers in the GUI) so an action works on an auth-gated target. Applied via fissure_extensions_apply_actions into a one-off check set. Bundled example: param-tools ships a "Reflected-input probe" action.

  • session_actions (shipped): an on-demand login/re-auth flow an extension contributes. Each entry is {"title": ..., "run": <script>, "params": <one-line hint>}; the run script uses the fs.* API with active fs.send but its purpose is authentication, not detection. The optional params hint names the fs.params fields the login expects and is shown as the GUI params field's placeholder and returned by GET /api/session-actions: a login whose expected field names an operator has to read the source to learn is a login they will get wrong, and a wrong guess runs it with no credentials at all. It is run against a target through fissure_sessaction_run, which gives it a fresh cookie jar: because the transport absorbs every Set-Cookie into that jar, the script's login requests populate it, and on return the jar is serialized into a Cookie header for the host AND every cookie is installed into the suite-wide shared jar (fissure_cookiejar_shared), so the scanner, the Repeater and manual sends send the session without anyone passing the string along. A login whose session is a TOKEN rather than a cookie publishes it with fs.setvar (see 5.2) and the host returns it as vars. Credentials never live in the bundle: they arrive at run time in fs.params (see 5.1). In the GUI the Session-handling rules popup has a "Session actions" launcher (pick the login flow from the list, enter the target URL, fill the params JSON the placeholder describes, Run login; a worker thread with a spinner runs it and an outcome popup reports the cookies installed and any captured values); GET /api/session-actions lists them and POST /api/session-action runs one; the session_actions/session_action MCP tools mirror those.

    Bundled logins, covering the shapes a real target uses: form-login (a CSRF-token-aware HTML form login) and the session-logins bundle, which ships a JSON API login, the OAuth2 password / client-credentials / refresh grants, HTTP Basic, a bearer token the operator already holds (verified against the target, then published), a two-step form login (a username page, then a password page with a fresh token), a form login followed by an OTP / 2FA code, an SPA login that reads a CSRF cookie back into a header (the Laravel/Angular pattern), a GraphQL login mutation, and WordPress wp-login.php. Each is driven entirely by fs.params, so they generalize past the product they are named for. tests/test_logins.c runs all of them against a loopback server that models each shape.

  • editors (shipped): an interactive custom message editor, in the decode-encode model. Each entry is {"title": ..., "decode": <script>, "encode": <script>}; decode transforms the raw message text into an editable representation and encode transforms the edited representation back into raw text (both transform-style scripts, the global input holding the text). The host provides the editing itself, a standard editable text area, so the operator edits freely while the extension owns the two-way transform. In the GUI it is the "Message editor" popup (raw area on top, Decode/Encode, editable area below), opened from a request's context menu ("Open in editor", the body prefilled) or the command palette. Because decode/encode are pure text transforms with no request/traffic context, the editor is automatable: GET /api/editors lists them and POST /api/editor {ext, editor, op, text} runs one's decode or encode (the editors/editor MCP tools mirror those). Host: src/fissure_gui_editor.c. Bundled example: json-tools ("JSON pretty-print": decode pretty-prints a JSON body for editing, encode minifies it back).

  • request_hooks (shipped): scripts that rewrite every request the intercepting proxy forwards, on its way out (stamp a header, re-sign a body, refresh a token). Each entry is {"title": ..., "run": <relative script path>}; the script gets the raw request as the global request and returns its replacement (or defines mutate(request)). Hooks from all enabled bundles chain in registry order, and they attach to both the GUI proxy and the control-driven proxy (POST /api/proxy/start). Loader: load_request_hooks in src/fissure_extensions.c. The full contract and its safety rules are in section 8. Bundled example: request-stamp (ships disabled).

5.1 fs.params: run-time inputs for scripts

Every fs.* script (checks, actions, and especially session actions) sees an fs.params object: the caller-supplied parameters for this run, an empty {} unless the caller injected any. A session action reads its credentials, field names, and token regex from fs.params instead of hardcoding them, so one form-login bundle logs into any HTML form. The control API passes params (a JSON object) on POST /api/session-action; the GUI passes a params JSON textarea; the MCP session_action tool takes a params dict. This keeps secrets out of the shipped bundle and out of the repository. Declare the fields a script expects in its manifest entry's params hint, so the operator sees them in the GUI and a headless caller gets them from GET /api/session-actions.

5.2 fs.setvar: publishing what a run captured

fs.setvar(name, value) publishes a named value the host reads back when the run ends. A cookie jar cannot hold an Authorization header, so a login whose session is a bearer token (the OAuth2 grants, a JSON API, GraphQL) has nowhere else to put it: without this the token the script worked to obtain dies with the run. The host returns the published values as a JSON object (vars on POST /api/session-action, shown in the GUI outcome popup), which is the same shape a login config's extracts produce, so a session-handling rule's {{name}} header substitution resolves either source. By convention a login publishes token and a ready-to-send authorization, plus whatever else it obtained (refresh_token, expires_in, id_token).

5.3 fs.send options a login flow needs

The response object fs.send() returns carries url: where the response actually came from, which is the redirect target when the engine followed one. A multi-step login needs it, because reading a Location header off the returned response finds nothing: that header belonged to the hop the engine already consumed. Pass follow: false in the request object to stop at the 3xx instead and read its headers yourself.

6. Management surface (GUI, control API, MCP)

Managing extensions operates on the workspace, so per the control-API + MCP parity rule it is reachable three ways with the same power:

  • GUI: an Extensions manager (a popup) lists every discovered bundle with its id, name, version, author, enabled state, compatibility, and check count, and offers Enable, Disable, and Reload. Opened from the command palette ("Open Extensions").
  • Control API:
    • GET /api/extensions lists the installed bundles and their state.
    • POST /api/extensions {op:"enable|disable|reload", id} toggles or reloads. See 11_CONTROL_API.md.
  • MCP bridge: the extensions and extensions_op tools mirror the two routes so an agent lists and toggles extensions exactly as the GUI operator does.

6.1 The offline, signed marketplace

Bundles are also browsed, installed, and removed from a local catalog (fissure_marketplace, under FISSURE_MARKETPLACE_DIR = resources/marketplace):

  • catalog.json is the index: {"entries":[{id,name,version,author,description, sdk_version,sha256}]}, where sha256 is the bundle's canonical hash.
  • catalog.json.sig is a detached Ed25519 signature (base64) over catalog.json's exact bytes, and trust.pub is the bundled public key (the trust anchor). Loading verifies the signature against trust.pub and records a trusted flag.
  • store/<id>/ holds the packaged bundle payloads (offline, no download).

Install re-computes the store bundle's canonical hash and refuses it unless the catalog is trusted AND the hash matches the signed entry (authenticity via the signature, integrity via the hash), then copies the bundle into the writable per-user extensions directory (fissure_extensions_user_dir, the config dir plus extensions). The registry scans BOTH the shipped resources/extensions and that per-user directory (fissure_extensions_load_all), so an installed bundle is discovered without touching the read-only shipped tree. Remove deletes the per-user copy (a shipped bundle can only be disabled, not removed).

Reachable three ways: the Extensions manager's Marketplace section (Install / Remove, with a naming confirm on remove), GET /api/marketplace + POST /api/marketplace {op:"install|remove", id}, and the marketplace / marketplace_op MCP tools. Bundled catalog entries: csp-reportonly (a marketplace-only check that flags a CSP delivered only in report-only mode) plus the published passive bundles secret-radar, jwt-exposure, and web-hardening (also shipped enabled under resources/extensions/, so installing one is redundant but harmless: the two-root registry loads the shipped copy and skips the same-id user copy).

The catalog is regenerated and Ed25519-signed by make marketplace (the packaging/gen-marketplace.py tool): it recomputes each store bundle's canonical hash (the same algorithm as fissure_marketplace_bundle_hash), rebuilds catalog.json from the store manifests, and writes the detached base64 signature. The private signing key (MARKETPLACE_KEY, default packaging/marketplace-signing.pem) is maintainer-held and gitignored; if absent the tool mints a fresh keypair and rewrites the trust.pub anchor (a key rotation, re-signing the whole catalog under the new key). make marketplace-check verifies the shipped catalog against the store without signing, BOTH ways: every catalog entry's hash must match its bundle, every bundle under store/ must have a catalog entry, and a catalog with no entries at all is a failure rather than a vacuous pass. The both-ways part matters because the one-directional version could not see the drift that actually happens: a bundle added to the store and never regenerated into the catalog ships in the tree, stays out of the SIGNED catalog, and is therefore invisible to the marketplace at runtime, while the check printed "ok" for every entry and exited 0. tests/test_marketplace asserts the same property on every gate, so it does not depend on anyone remembering to run the packaging tool.

7. Bundled extensions

Slice 1 ships a small curated set of genuinely useful, non-duplicative passive extensions under resources/extensions/, so the SDK is demonstrated by real value, not a toy:

  • web-hardening: two checks. csp-audit parses a Content-Security-Policy and flags weak directives (unsafe-inline, unsafe-eval, a wildcard or data: source in script-src, a missing object-src/base-uri) that the native missing-header check (which only flags absence) does not inspect. isolation-headers flags missing cross-origin isolation and privacy headers (Cross-Origin-Opener-Policy, Cross-Origin-Embedder-Policy, Cross-Origin-Resource-Policy, Permissions-Policy, Referrer-Policy).
  • secret-radar: one check with high-signal, provider-specific secret patterns (AWS access-key ids, Google API keys, Slack tokens, Stripe live keys, GitHub tokens, private-key blocks) in response bodies, complementing the native generic secret check.
  • jwt-exposure: one check that finds JSON Web Tokens exposed in response bodies or headers, decodes the header/payload, and flags alg:none, a weak HS algorithm, or a long/absent expiry, complementing the manual Tokens workshop with passive detection.
  • api-leaks: one check that parses a JSON API response with fs.json() (the first bundle to use the structured-body accessor) and flags leaked stack traces, framework error internals, and internal file-system paths in its string values, catching debug-mode error disclosure a flat body regex misses.
  • param-tools: an actions example (a "Reflected-input probe" context action).
  • active-probes: an actions bundle of four on-demand active probes for one selected request: CORS misconfiguration (reflected/wildcard Access-Control-Allow-Origin with credentials), open redirect (external URL in a redirect-like parameter), HTTP method tampering (alternate verbs / X-HTTP-Method-Override accepted), and IDOR/BOLA (a neighbouring object id served under the same session). Each sends crafted follow-ups via fs.send, so they run only when triggered, never during a scan.
  • web-hardening also ships a tabs example (a "Hardening checklist" tab shown inline in the Extensions manager) alongside its checks and panel.
  • json-tools: an editors example (a "JSON pretty-print" custom message editor: decode pretty-prints a JSON body, encode minifies it back).
  • codec-tools: an editors bundle of four two-way message editors, Base64, URL, hex, and JWT (decode a token to editable header+payload JSON, tamper, re-encode; blank the signature and set alg:none to test unsigned-token acceptance). QuickJS has no atob/btoa, so the Base64/JWT codecs are hand-rolled in the scripts.
  • form-login: a session_actions example. A CSRF-token-aware HTML form login driven entirely by fs.params (user/pass, the form field names, an optional token field and regex), so the one bundle authenticates against any login form and hands back the session cookie for authenticated scanning.
  • session-logins: the rest of the login shapes, eleven session_actions in one bundle, so the picker covers what targets actually do rather than only HTML forms. A JSON API login (credentials as JSON, reading a token out of the response by a dotted path); the OAuth2 password, client-credentials and refresh grants (client credentials sent as HTTP Basic by default, as RFC 6749 asks, and a rotated refresh token kept); HTTP Basic; a bearer token the operator already holds, verified against the target before a whole scan runs on a stale one; a two-step form login, where the password goes to a second page with a token re-read there; a form login followed by an OTP / 2FA code, which the operator supplies at run time (Fissure neither generates nor stores one), and which logs plainly when the code is missing, because a half-authenticated session looks like a working one and is refused by every protected page; an SPA login that reads the CSRF cookie back into a header (the Laravel/Angular pattern, where the token is never in the HTML so a form-scraping login silently posts without it); a GraphQL login mutation (whose failure is a 200 with an errors array, so the status is not the oracle); and WordPress wp-login.php (whose test cookie the POST requires back, and whose success is a 302).

The check extensions are passive (no fs.send), safe under any scope, and de-duplicate against native findings by host|category|title|location. The actions and session_actions examples are on-demand and use active fs.send, so they run only when the operator or an agent triggers them against an authorized, in-scope target.

8. Security and ethics

  • Extensions are JavaScript run in the existing QuickJS engine with its memory, stack, and time limits. They have no filesystem or arbitrary-network access: the only outbound path is fs.send() / fs.sendraw(), which is active-scan-gated (fs.active) and scope-checked by the engine like any other check. A target outside the workspace allowlist throws inside the script, so the refusal is visible to the extension author rather than silent. (This was documented before it was true: the check is now enforced in fs_send/fs_sendraw against a scope the caller stages with fissure_js_set_scope, and the scan, the control-API extension checks, and the ad-hoc jscheck route all stage one. With nothing staged, as in a bare unit test or a standalone transform, sending is unrestricted.)
  • async / await work. QuickJS queues each await continuation as a pending job, and the engine drains that queue after the top-level script returns, so an async check runs to completion and the findings it reports in a continuation are collected. A rejected job logs its exception instead of vanishing, and the drain is bounded so a promise loop that keeps queueing work cannot spin inside one check.
  • The bundled set is passive. An extension that sends traffic is an active check and runs only when active scanning is permitted against an authorized, in-scope target.
  • A third-party publish path, separating "installable" from "trusted". The marketplace catalog stays Ed25519-signed and its installs stay hash-checked against it, so a first-party bundle is still vouched for; but a bundle nobody signed can now be installed deliberately, which was previously impossible without hand-copying files. A distributable bundle is ONE JSON document, {"manifest":{...},"files":{"<rel>":"<text>"}}: deliberately not a zip, because a bundle is a manifest plus a few small text files, so a JSON container needs no archive dependency and is validated by the same parser the manifest uses. fissure_marketplace_pack_file writes one from an installed bundle and fissure_marketplace_install_file installs one. Installing requires an explicit acknowledgement, and that is the point rather than a formality: an unsigned bundle's checks send traffic to the target, its request hooks rewrite EVERY request the proxy forwards, and it persists state. The GUI ("Install file" in the Extensions manager) inspects the bundle first and names its own numbers ("contributes 2 checks, 1 request hook") before asking; the API refuses without accept_unsigned and returns the same warning text, so an automated caller cannot install untrusted code by accident or claim it did not know. Everything is validated before anything is written: the id must be a safe directory name, the sdk_version must not exceed this host's, and every file path must be relative and inside the bundle, so a bad entry halfway down cannot leave a half-installed bundle. An existing installation is never overwritten, and a newly installed bundle lands DISABLED so it cannot run before the operator has looked at it. Headless parity: POST /api/extensions/bundle and the extension_bundle MCP tool.
  • Each extension runs in its OWN QuickJS context. Every script used to be evaluated into one shared global object, so one extension's globals were visible to and clobberable by every other, and a function it defined leaked into whatever ran next (the engine still clears mutate/transform before each run, which was a workaround for exactly this). The contexts share a single JSRuntime rather than getting one each: an imported template set can be hundreds of scripts, so a runtime apiece would be prohibitive, while a JSContext gives separate globals cheaply. A script with no owner (a plain user script, an ad-hoc check) still uses the shared context, so nothing outside extensions changes.
  • fs.store gives an extension a small key/value space that survives a restart: fs.store.get(key), set(key, value), remove(key), keys(). Enabled/disabled used to be the only thing an extension could remember, which ruled out anything that compares this run against the last one or carries a session forward. State is keyed by the owning extension AND stored per project (<project>/extstate/<id>.json), like the intercept and match/replace rules: a baseline or a seen-set belongs to one engagement, and one bundle can neither read nor corrupt another's. Both the key count and the value size are capped (FISSURE_EXTSTATE_*), because the store is written by script and a loop bug must not be able to fill the disk; a refusal comes back to the script as false rather than being dropped silently. Overwriting an existing key is never refused, so a script keeping one counter updated always works. An extension id that could escape the state directory is rejected outright rather than sanitised. With no store installed (a bare unit test) fs.store answers null/false/[] instead of throwing, so a script that opportunistically caches still runs. Headless parity: POST /api/extensions/state {id[,op:"clear"]} and the extension_state MCP tool. The statedemo bundle is the reference.
  • A bundle may contribute request_hooks: scripts that rewrite every request the proxy forwards, on its way out. This is the most common thing an extension wants to do (stamp a header, re-sign a body, refresh a token) and until now the SDK could not express it, since checks only observe and actions only run on demand. Each entry is {"title": ..., "run": <relative script path>}. The script receives the raw request as the global request and returns its replacement, or defines mutate(request) and returns from that; returning nothing, null, or the input unchanged leaves the request alone. Hooks from all enabled bundles are CHAINED in registry order, each seeing the previous one's output, so two bundles can both stamp one request instead of one silently winning. A hook that throws is logged and leaves the request untouched: a broken extension must not silently drop or corrupt traffic. Because a hook rewrites ALL forwarded traffic, attaching one logs a NOTICE naming how many are active, and the reference bundle (request-stamp) ships disabled. The hook runs on the forwarding path, so it is bounded by the same deadline as a transform, and it is attached through an injectable seam (fissure_proxy_set_request_hook) so the proxy does not link the JavaScript engine.
  • No detection-evasion behaviour is permitted in an extension, the same rule as the rest of Fissure.
  • Enabling/disabling is explicit and persisted; a disabled extension is inert.

9. Slice status and roadmap

Shipped:

  • The bundle model, the extension.json manifest, and the sdk_version contract.
  • The registry (fissure_extensions): discovery, validation, enabled-state persistence, reload, and applying checks contributions into the check set at the scanner, proxy passive, and Findings surfaces.
  • The management surface: the GUI Extensions manager, GET/POST /api/extensions, and the extensions/extensions_op MCP tools.
  • The panels GUI contribution, on the upstream n_gui owner-draw custom widget (n_gui_add_custom): an extension owns a real GUI view whose content its render script produces, opened from the Extensions manager. This is the UI-registration layer that unblocks the richer GUI contribution types.
  • The curated bundled extension set (web-hardening ships a panels example, param-tools ships an actions example) and a regression test.
  • The actions context-action contribution: an on-demand fs.* script run against one request from the context menu ("Extension actions"), GET /api/ext-actions + POST /api/ext-action, and the ext_actions/ext_action MCP tools, session-aware so it works on auth-gated targets.
  • Headless extension checks: control-API scans (POST /api/scan and /api/scans) now load the full check set, so extension checks run agent-driven, not only in the GUI.
  • The offline, signed marketplace (fissure_marketplace): a local catalog with a detached Ed25519 signature and per-bundle canonical hashes, browse/install/remove in the Extensions manager, GET/POST /api/marketplace, and the marketplace / marketplace_op MCP tools; installs land in a writable per-user extensions directory the registry also scans. Bundled entry: csp-reportonly.
  • The session_actions login contribution (fissure_sessaction): an extension-provided login flow run against a target to capture the session cookie for authenticated scanning, driven by fs.params (credentials injected at run time, never in the bundle). Reachable from the Session-handling rules popup's "Session actions" launcher, GET /api/session-actions + POST /api/session-action, and the session_actions / session_action MCP tools. Bundled entry: form-login. fs.params (run-time inputs for any fs.* script) ships with it.
  • The tabs view contribution (shown inline in fissure_gui_extensions): an extension's tabs appear in the Extensions manager under the selected bundle, each tab's content produced by a render script and shown as scrollable, selectable text. Bundled entry: web-hardening's "Hardening checklist".
  • The editors interactive message-editor contribution (fissure_gui_editor): an extension owns a two-way custom editor (a decode script raw->editable, an encode script editable->raw) the operator edits in a standard text area, opened from a request's context menu or the command palette, with GET /api/editors + POST /api/editor and the editors/editor MCP tools. Bundled entry: json-tools.
  • The request_hooks contribution: scripts chained over every request the GUI proxy or the control-driven proxy forwards, attached through the injectable fissure_proxy_set_request_hook seam. Bundled entry: request-stamp (disabled by default).

Every contribution type in the SDK design is shipped (checks, panels, tabs, actions, session_actions, editors, request_hooks, plus the offline marketplace); there is no remaining roadmap slice for this item.