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_versionit 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 theidis 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 whosesdk_versionis missing, below 1, or greater than the host'sFISSURE_EXTENSION_SDK_VERSIONis 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, tofs.*check scripts (the surface-1 scripting fromEXTENDING.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_versionis 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 ofid -> enabled(a boolean). An id absent from the file uses the manifest'senableddefault. 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/scanand/api/scansnow callfissure_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 onfs.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 (nofs.*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-hardeningships a "Hardening checklist" tab.actions(shipped): an on-demand, request-contextual script. Each entry is{"title": ..., "run": <script>}; the run script uses the samefs.*API as a check (activefs.sendpermitted) but, unlikechecks, 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-actionslists the actions andPOST /api/ext-actionruns one; theext_actions/ext_actionMCP tools mirror those. The request's session cookie is carried onto everyfs.send()probe (a control-APIcookie/headersfield, the right-clicked request's own headers in the GUI) so an action works on an auth-gated target. Applied viafissure_extensions_apply_actionsinto a one-off check set. Bundled example:param-toolsships 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 thefs.*API with activefs.sendbut its purpose is authentication, not detection. The optionalparamshint names thefs.paramsfields the login expects and is shown as the GUI params field's placeholder and returned byGET /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 throughfissure_sessaction_run, which gives it a fresh cookie jar: because the transport absorbs everySet-Cookieinto that jar, the script's login requests populate it, and on return the jar is serialized into aCookieheader 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 withfs.setvar(see 5.2) and the host returns it asvars. Credentials never live in the bundle: they arrive at run time infs.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-actionslists them andPOST /api/session-actionruns one; thesession_actions/session_actionMCP tools mirror those.Bundled logins, covering the shapes a real target uses:
form-login(a CSRF-token-aware HTML form login) and thesession-loginsbundle, 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 WordPresswp-login.php. Each is driven entirely byfs.params, so they generalize past the product they are named for.tests/test_logins.cruns 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>};decodetransforms the raw message text into an editable representation andencodetransforms the edited representation back into raw text (both transform-style scripts, the globalinputholding 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/editorslists them andPOST /api/editor {ext, editor, op, text}runs one's decode or encode (theeditors/editorMCP 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 globalrequestand returns its replacement (or definesmutate(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_hooksinsrc/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/extensionslists the installed bundles and their state.POST /api/extensions {op:"enable|disable|reload", id}toggles or reloads. See11_CONTROL_API.md.
- MCP bridge: the
extensionsandextensions_optools 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.jsonis the index:{"entries":[{id,name,version,author,description, sdk_version,sha256}]}, wheresha256is the bundle's canonical hash.catalog.json.sigis a detached Ed25519 signature (base64) over catalog.json's exact bytes, andtrust.pubis the bundled public key (the trust anchor). Loading verifies the signature against trust.pub and records atrustedflag.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-auditparses a Content-Security-Policy and flags weak directives (unsafe-inline, unsafe-eval, a wildcard ordata:source in script-src, a missing object-src/base-uri) that the native missing-header check (which only flags absence) does not inspect.isolation-headersflags 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 flagsalg: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 withfs.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: anactionsexample (a "Reflected-input probe" context action).active-probes: anactionsbundle of four on-demand active probes for one selected request: CORS misconfiguration (reflected/wildcardAccess-Control-Allow-Originwith credentials), open redirect (external URL in a redirect-like parameter), HTTP method tampering (alternate verbs /X-HTTP-Method-Overrideaccepted), and IDOR/BOLA (a neighbouring object id served under the same session). Each sends crafted follow-ups viafs.send, so they run only when triggered, never during a scan.web-hardeningalso ships atabsexample (a "Hardening checklist" tab shown inline in the Extensions manager) alongside its checks and panel.json-tools: aneditorsexample (a "JSON pretty-print" custom message editor: decode pretty-prints a JSON body, encode minifies it back).codec-tools: aneditorsbundle 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 setalg:noneto test unsigned-token acceptance). QuickJS has no atob/btoa, so the Base64/JWT codecs are hand-rolled in the scripts.form-login: asession_actionsexample. A CSRF-token-aware HTML form login driven entirely byfs.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, elevensession_actionsin 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 anerrorsarray, so the status is not the oracle); and WordPresswp-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 infs_send/fs_sendrawagainst a scope the caller stages withfissure_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/awaitwork. QuickJS queues eachawaitcontinuation 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_filewrites one from an installed bundle andfissure_marketplace_install_fileinstalls 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 withoutaccept_unsignedand 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/bundleand theextension_bundleMCP 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/transformbefore 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.storegives 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 asfalserather 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.storeanswers null/false/[] instead of throwing, so a script that opportunistically caches still runs. Headless parity:POST /api/extensions/state {id[,op:"clear"]}and theextension_stateMCP tool. Thestatedemobundle 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 globalrequestand returns its replacement, or definesmutate(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.jsonmanifest, and thesdk_versioncontract. - The registry (
fissure_extensions): discovery, validation, enabled-state persistence, reload, and applyingcheckscontributions into the check set at the scanner, proxy passive, and Findings surfaces. - The management surface: the GUI Extensions manager,
GET/POST /api/extensions, and theextensions/extensions_opMCP tools. - The
panelsGUI 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
panelsexample, param-tools ships anactionsexample) and a regression test. - The
actionscontext-action contribution: an on-demandfs.*script run against one request from the context menu ("Extension actions"),GET /api/ext-actions+POST /api/ext-action, and theext_actions/ext_actionMCP tools, session-aware so it works on auth-gated targets. - Headless extension checks: control-API scans
(
POST /api/scanand/api/scans) now load the full check set, so extensionchecksrun 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 themarketplace/marketplace_opMCP tools; installs land in a writable per-user extensions directory the registry also scans. Bundled entry:csp-reportonly. - The
session_actionslogin contribution (fissure_sessaction): an extension-provided login flow run against a target to capture the session cookie for authenticated scanning, driven byfs.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 thesession_actions/session_actionMCP tools. Bundled entry:form-login.fs.params(run-time inputs for anyfs.*script) ships with it. - The
tabsview contribution (shown inline infissure_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
editorsinteractive 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, withGET /api/editors+POST /api/editorand theeditors/editorMCP tools. Bundled entry:json-tools. - The
request_hookscontribution: scripts chained over every request the GUI proxy or the control-driven proxy forwards, attached through the injectablefissure_proxy_set_request_hookseam. 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.