Files
reverse-engineering-anything/src/composition/capabilityDeclarations.ts
T
bartman081523andmorluto d380dc2409 feat(uefi): add pure-TypeScript UEFI firmware analysis tools (#12342)
* feat(uefi): add pure-TS UEFI firmware volume/FFS parser with inspect/extract tools

Add a dependency-free rea-uefi provider that maps AMI/Aptio flash images:
- inspect_uefi_firmware: aligned _FVH discovery, volume-relative FFS walking,
  guided section/compression classification, conservative PSP-directory probing,
  embedded-volume rescan and leftover-region classification; incremental SHA-256
  and explicit integrity notes.
- extract_uefi_firmware: whole-image/volume/FFS-file/section extraction with
  LZMA-custom/LZMAF86 and AMD-zlib decoding, SafeOutputTree staging, derivations
  and extraction_gaps.
- UefiArtifactReader + 'uefi' format wiring across inventory/domain/contracts
  so parsed volumes and extracted PE32/TE files hand off to deep-provider
  analysis (open_binary -> Ghidra).

* feat(uefi): add inspect_uefi_nvram for AMI NVRAM variable stores

Add a pure-TypeScript tool that maps the vendor AMI NVRAM variable stores
(factory-default "StdDefaults" and peers) inside a flash image:
- scan the raw image for NVAR entry chains ("NVAR" + u16 total size +
  u32 attribute 0x8[23]FFFFFF + state + NUL-terminated name + data),
- recurse into a container entry whose data is itself an NVAR chain, so the
  StdDefaults setup variables surface as depth/parent_offset rows,
- report attributes, state, data range, SHA-256 and trailing padding per entry.

Verified against B550 AORUS Elite V2 FId: one StdDefaults store at 0x37090 with
the 11 expected nested variables (Setup, PlatformLang, AMITSESetup, XhciDID,
GcSensorVarName, PCI_COMMON, SioSetupData, UsbSupport, NetworkStackVar,
SecureBootSetup, Setup). Exposed as MCP tool and inspect-uefi-nvram CLI command.

* fix(uefi): address review on checksums, compression, guided sections, NVRAM bounds

- FFS file checksum: verify the two's-complement invariant (payload sum +
  stored byte == 0 mod 256) instead of comparing sums, and encode the correct
  complement in the fixture builder.
- Compression sections (type 0x01): use the 9-byte header and classify EFI
  standard compression instead of 'none', so extraction reports a gap rather
  than publishing compressed bytes as a raw section.
- GUID-defined sections: derive GUID/data-offset/attributes from the parsed
  common header size (compact or extended) and reject out-of-range payload
  offsets.
- AMI NVRAM: bound recursive chains to the enclosing container's data end and
  report partial coverage when a valid nested chain is cut by max_depth.

* fix(uefi): bound decode memory, serialize operations, enforce deadline, mark truncation

- LZMA worker: enforce max_output_bytes while decoding through a bounded output
  sink, so an oversized stream is rejected during expansion instead of after a
  full decompression plus a second Buffer copy.
- Provider: serialize admitted operations (the promised single decode-worker
  lane must not become one worker per overlapping call) and apply one
  whole-request deadline that covers every decode stage, not a fresh per-stream
  timer. close() drains the queue and the resource scope.
- Scan: track truncated sections of known type and report coverage partial
  instead of complete when a section declares more bytes than are present.

* fix(uefi): cancellable queue, timeout surfacing, availability and reader omissions

- Queue: check the caller signal before enqueue and when a job reaches the head,
  and race the queued promise against abort so a cancelled wait returns
  immediately instead of blocking behind the active request.
- Deadline: track the internal deadline and return AnalysisTimeoutError instead
  of the AnalysisCancelledError that runOwnedCommand reports for any external
  abort, preserving the real failure reason for CLI/MCP callers.
- CapabilityInventory: treat inspect_uefi_nvram like the other bundled rea-uefi
  tools so discovery does not demand Unblob for it.
- UefiArtifactReader: report image truncation through onOmission so inventory
  coverage reflects the unread suffix even when no volume was found.

* fix(uefi): limit early cancellation to unstarted jobs and preserve timeout cleanup

- #raceWithAbort only returns early for jobs that have not started; once a
  request is running, await it so worker cleanup and completed output are
  preserved instead of being discarded by a bare cancellation.
- Reclassify a deadline-induced cancellation as AnalysisTimeoutError while
  keeping its cause and cleanup observations, and never override a different
  primary failure.

* docs(licenses): record UEFI decoder dependency notices

* fix(uefi): preserve stream provenance and bound firmware analysis

* feat(uefi): decode LZMAF86 guided sections

* fix(uefi): validate publication before commit and order decoder cleanup

* fix(uefi): preserve unsupported volumes and extraction gaps

---------

Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
2026-11-19 21:19:35 +00:00

624 lines
18 KiB
TypeScript

// oxlint-disable max-lines -- Keep the exhaustive static provenance bindings together; this table has no execution or host-availability logic.
import { UEFI_PROVIDER_IDENTITY } from "../uefi/UefiProviderIdentity.js";
import type { ProviderIdentity } from "../ports/AnalysisProvider.js";
import type {
TOOL_CONTRACTS,
ToolContractGroupId,
} from "../contracts/toolContracts.js";
import { ADB_PROVIDER_IDENTITY } from "../adb/AdbProviderIdentity.js";
import { JADX_PROVIDER_IDENTITY } from "../android/JadxRelease.js";
import { APK_SIGNATURE_PROVIDER_IDENTITY } from "../apkSignature/ApkSignatureRelease.js";
import { APKTOOL_PROVIDER_IDENTITY } from "../apktool/ApktoolProviderIdentity.js";
import {
HAR_CAPTURE_PROVIDER_IDENTITY,
MITMPROXY_CAPTURE_PROVIDER_IDENTITY,
QLOG_CAPTURE_PROVIDER_IDENTITY,
SAZ_CAPTURE_PROVIDER_IDENTITY,
} from "../browser/history/CaptureProviderIdentities.js";
import {
CDP_BROWSER_PROVIDER_IDENTITY,
CDP_ELECTRON_PROVIDER_IDENTITY,
PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY,
PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY,
} from "../browser/providerIdentities.js";
import { TSHARK_PROVIDER_IDENTITY } from "../captures/TsharkProviderIdentity.js";
import { CUTTER_PROVIDER_IDENTITY } from "../cutter/CutterProviderIdentity.js";
import {
ANALYSIS_VIEW_PROVIDER,
ANDROID_APPLICATION_PROVIDER,
APPLE_APPLICATION_PROVIDER,
APPLE_IPS_PROVIDER,
ARTIFACT_GRAPH_PROVIDER,
BINARY_HARDENING_PROVIDER,
BYTE_ENTROPY_PROVIDER,
DEVICETREE_PROVIDER,
DWARF_UNITS_PROVIDER,
ELF_DEBUG_LINK_PROVIDER,
ELF_DEPENDENCIES_PROVIDER,
ELF_NOTES_PROVIDER,
ELF_UNWIND_RANGES_PROVIDER,
HARMONY_APPLICATION_PROVIDER,
JAVASCRIPT_APPLICATION_PROVIDER,
JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER,
JAVASCRIPT_RUNTIME_RECONCILIATION_PROVIDER,
KERNEL_BUILD_CONFIG_PROVIDER,
KERNEL_MODULE_PROVIDER,
MANAGED_STATIC_PROVIDER,
MANAGED_WORKFLOW_PROVIDER,
NATIVE_EXPORTS_PROVIDER,
NATIVE_INITIALIZERS_PROVIDER,
PE_CERTIFICATES_PROVIDER,
PE_IMPORTS_PROVIDER,
PE_LOAD_CONFIG_PROVIDER,
PE_RESOURCES_PROVIDER,
RELEASE_EXPOSURE_PROVIDER,
WEB_SCRIPT_EXPORT_PROVIDER,
WINDOWS_SHORTCUT_PROVIDER,
} from "../domain/investigationProviders.js";
import { SQLITE_PROVIDER_IDENTITY } from "../domain/sqlite/SqliteProviderIdentity.js";
import {
WEB_MODULE_TRACE_PROVIDER,
WEB_SOURCE_LOCATION_PROVIDER,
} from "../domain/webTraceProviders.js";
import { ELECTRON_FUSE_PROVIDER_IDENTITY } from "../electron/ElectronFuseProviderIdentity.js";
import { ERLANG_BEAM_PROVIDER_IDENTITY } from "../erlang/ErlangBeamProviderIdentity.js";
import { V8_CODE_CACHE_PROVIDER_IDENTITY } from "../v8/V8CodeCacheProviderIdentity.js";
import { MAVEN_GRADLE_METADATA_PROVIDER_IDENTITY } from "../java/MavenGradleMetadataProviderIdentity.js";
import { EVMOLE_PROVIDER_IDENTITY } from "../evm/EvmoleProviderIdentity.js";
import {
BINWALK_PROVIDER_IDENTITY,
UNBLOB_PROVIDER_IDENTITY,
} from "../firmware/FirmwareProviderIdentities.js";
import { FLUTTER_PROVIDER_IDENTITY } from "../flutter/FlutterProviderIdentity.js";
import { FRIDA_PROVIDER_IDENTITY } from "../frida/FridaProviderIdentity.js";
import { GDB_PROVIDER_IDENTITY } from "../gdb/GdbProviderIdentity.js";
import {
GHIDRA_OPERATIONS,
GHIDRA_PROVIDER_IDENTITY,
} from "../ghidra/GhidraProviderMetadata.js";
import { GO_BINARY_PROVIDER_IDENTITY } from "../go/GoBinaryProviderIdentity.js";
import { GPU_CODE_OBJECTS_PROVIDER_IDENTITY } from "../gpu/GpuCodeObjectsProviderIdentity.js";
import {
HOPPER_OPERATIONS,
HOPPER_PROVIDER_IDENTITY,
} from "../hopper/HopperProviderMetadata.js";
import {
IDA_OPERATIONS,
IDA_PROVIDER_IDENTITY,
} from "../ida/IdaProviderMetadata.js";
import { IL2CPP_METADATA_PROVIDER_IDENTITY } from "../il2cpp/Il2CppMetadataProviderIdentity.js";
import { V8_INSPECTOR_PROVIDER_IDENTITY } from "../inspector/providerIdentity.js";
import { WAKARU_PROVIDER_IDENTITY } from "../javascript/recovery/WakaruProviderIdentity.js";
import { JEB_PROVIDER_IDENTITY } from "../jeb/JebProviderIdentity.js";
import {
KUNA_OPERATIONS,
KUNA_PROVIDER_IDENTITY,
} from "../kuna/KunaProviderMetadata.js";
import { MODEL_ARTIFACT_PROVIDER_IDENTITY } from "../model/ModelArtifactProviderIdentity.js";
import { NATIVE_MACOS_PROVIDER_IDENTITY } from "../native/NativeMacosProviderIdentity.js";
import { PWNTOOLS_PROVIDER_IDENTITY } from "../native/pwntools/PwntoolsProviderIdentity.js";
import { OBJDUMP_PROVIDER_IDENTITY } from "../objdump/ObjdumpProviderIdentity.js";
import { PCAP_PROVIDER_IDENTITY } from "../pcap/PcapProviderIdentity.js";
import { NUGET_NUPKG_PROVIDER_IDENTITY } from "../nuget/NugetNupkgProviderIdentity.js";
import { PYTHON_PYC_PROVIDER_IDENTITY } from "../python/PythonPycProviderIdentity.js";
import { RIZIN_DEBUGGER_PROVIDER_IDENTITY } from "../rizin/RizinDebuggerProviderIdentity.js";
import { RIZIN_PROVIDER_IDENTITY } from "../rizin/RizinProviderIdentity.js";
import { RUST_BINARY_PROVIDER_IDENTITY } from "../rust/RustBinaryProviderIdentity.js";
import { SIGROK_PROVIDER_IDENTITY } from "../signals/SigrokProviderIdentity.js";
import { WABT_PROVIDER_IDENTITY } from "../wasm/WabtRelease.js";
type CanonicalOperationName = (typeof TOOL_CONTRACTS)[number]["name"];
/** Whole source groups grow with their canonical contracts; provider subsets stay explicit. */
export type CapabilityOperationSelection =
| readonly CanonicalOperationName[]
| { readonly group: ToolContractGroupId };
/** Static provenance bindings; host availability belongs to runtime inspection. */
export interface CapabilityDeclaration {
readonly providers: readonly {
readonly identity: ProviderIdentity;
readonly operations: CapabilityOperationSelection;
}[];
}
const providerBinding = <const Operations extends CapabilityOperationSelection>(
identity: ProviderIdentity,
operations: Operations,
) => ({ identity, operations });
/** Shared source facts, with no factory, schema or generated-catalog imports. */
export const CAPABILITY_DECLARATIONS = {
adbDevice: {
providers: [
providerBinding(ADB_PROVIDER_IDENTITY, { group: "ADB_TOOL_CONTRACTS" }),
],
},
analysisView: {
providers: [
providerBinding(ANALYSIS_VIEW_PROVIDER, {
group: "ANALYSIS_VIEW_TOOL_CONTRACTS",
}),
],
},
android: {
providers: [
providerBinding(JADX_PROVIDER_IDENTITY, {
group: "ANDROID_TOOL_CONTRACTS",
}),
],
},
androidApplicationGraph: {
providers: [
providerBinding(ANDROID_APPLICATION_PROVIDER, [
"project_android_application_graph",
]),
],
},
apkSignature: {
providers: [
providerBinding(APK_SIGNATURE_PROVIDER_IDENTITY, {
group: "APK_SIGNATURE_TOOL_CONTRACTS",
}),
],
},
apktool: {
providers: [
providerBinding(APKTOOL_PROVIDER_IDENTITY, {
group: "APKTOOL_TOOL_CONTRACTS",
}),
],
},
appleApplicationGraph: {
providers: [
providerBinding(APPLE_APPLICATION_PROVIDER, [
"project_apple_application_graph",
]),
],
},
appleIps: {
providers: [providerBinding(APPLE_IPS_PROVIDER, ["inspect_apple_ips"])],
},
applicationWorkflows: {
providers: [
providerBinding(JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER, [
"build_reconstruction_obligation_ledger",
"compare_application_versions",
"compare_javascript_export_shapes",
"compare_source_to_bundle",
"evaluate_reconstruction_coverage",
"guided_workflows",
"read_guidance_section",
"search_guidance",
"trace_application_feature",
"trace_javascript_semantics",
]),
],
},
artifactGraph: {
providers: [
providerBinding(ARTIFACT_GRAPH_PROVIDER, {
group: "ARTIFACT_TOOL_CONTRACTS",
}),
],
},
artifactResources: { providers: [] },
binaryLayout: {
providers: [
providerBinding(PWNTOOLS_PROVIDER_IDENTITY, ["inspect_binary_layout"]),
],
},
browserObservation: {
providers: [
providerBinding(CDP_BROWSER_PROVIDER_IDENTITY, {
group: "BROWSER_TOOL_CONTRACTS",
}),
],
},
browserScenarioCapture: {
providers: [
providerBinding(PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY, {
group: "BROWSER_SCENARIO_TOOL_CONTRACTS",
}),
],
},
byteEntropy: {
providers: [
providerBinding(BYTE_ENTROPY_PROVIDER, ["inspect_byte_entropy"]),
],
},
cutter: {
providers: [
providerBinding(CUTTER_PROVIDER_IDENTITY, {
group: "CUTTER_TOOL_CONTRACTS",
}),
],
},
desktopApplication: {
providers: [
providerBinding(ARTIFACT_GRAPH_PROVIDER, {
group: "DESKTOP_APPLICATION_TOOL_CONTRACTS",
}),
],
},
desktopBuildComputers: { providers: [] },
devicetree: {
providers: [providerBinding(DEVICETREE_PROVIDER, ["inspect_devicetree"])],
},
dwarfUnits: {
providers: [providerBinding(DWARF_UNITS_PROVIDER, ["inspect_dwarf_units"])],
},
electronActiveObservation: {
providers: [
providerBinding(PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY, [
"capture_electron_scenario",
]),
],
},
electronFuses: {
providers: [
providerBinding(ELECTRON_FUSE_PROVIDER_IDENTITY, [
"inspect_electron_fuses",
]),
],
},
electronObservation: {
providers: [
providerBinding(CDP_ELECTRON_PROVIDER_IDENTITY, [
"inspect_electron_page",
"list_electron_targets",
]),
],
},
elfDependencies: {
providers: [
providerBinding(ELF_DEPENDENCIES_PROVIDER, ["inspect_elf_dependencies"]),
],
},
elfNotes: {
providers: [providerBinding(ELF_NOTES_PROVIDER, ["inspect_elf_notes"])],
},
elfDebugLink: {
providers: [
providerBinding(ELF_DEBUG_LINK_PROVIDER, ["inspect_elf_debug_link"]),
],
},
nativeInitializers: {
providers: [
providerBinding(NATIVE_INITIALIZERS_PROVIDER, [
"inspect_native_initializers",
]),
],
},
elfUnwindRanges: {
providers: [
providerBinding(ELF_UNWIND_RANGES_PROVIDER, [
"inspect_elf_unwind_ranges",
]),
],
},
erlangBeam: {
providers: [
providerBinding(ERLANG_BEAM_PROVIDER_IDENTITY, {
group: "ERLANG_BEAM_TOOL_CONTRACTS",
}),
],
},
evmInterface: {
providers: [
providerBinding(EVMOLE_PROVIDER_IDENTITY, {
group: "EVM_TOOL_CONTRACTS",
}),
],
},
firmwareAnalysis: {
providers: [
providerBinding(BINWALK_PROVIDER_IDENTITY, ["inspect_firmware_regions"]),
providerBinding(UNBLOB_PROVIDER_IDENTITY, ["extract_firmware"]),
],
},
uefiAnalysis: {
providers: [
providerBinding(UEFI_PROVIDER_IDENTITY, { group: "UEFI_TOOL_CONTRACTS" }),
],
},
flutter: {
providers: [
providerBinding(FLUTTER_PROVIDER_IDENTITY, {
group: "FLUTTER_TOOL_CONTRACTS",
}),
],
},
fridaInstrumentation: {
providers: [
providerBinding(FRIDA_PROVIDER_IDENTITY, {
group: "FRIDA_TOOL_CONTRACTS",
}),
],
},
gdbSessions: {
providers: [
providerBinding(GDB_PROVIDER_IDENTITY, { group: "GDB_TOOL_CONTRACTS" }),
],
},
ghidra: {
providers: [providerBinding(GHIDRA_PROVIDER_IDENTITY, GHIDRA_OPERATIONS)],
},
goBinary: {
providers: [
providerBinding(GO_BINARY_PROVIDER_IDENTITY, {
group: "GO_TOOL_CONTRACTS",
}),
],
},
gpuCodeObjects: {
providers: [
providerBinding(GPU_CODE_OBJECTS_PROVIDER_IDENTITY, {
group: "GPU_TOOL_CONTRACTS",
}),
],
},
harmonyApplicationGraph: {
providers: [
providerBinding(HARMONY_APPLICATION_PROVIDER, [
"project_harmony_application_graph",
]),
],
},
hopper: {
providers: [providerBinding(HOPPER_PROVIDER_IDENTITY, HOPPER_OPERATIONS)],
},
ida: {
providers: [providerBinding(IDA_PROVIDER_IDENTITY, IDA_OPERATIONS)],
},
il2cppMetadata: {
providers: [
providerBinding(IL2CPP_METADATA_PROVIDER_IDENTITY, {
group: "IL2CPP_TOOL_CONTRACTS",
}),
],
},
javascriptApplication: {
providers: [
providerBinding(JAVASCRIPT_APPLICATION_PROVIDER, [
"analyze_javascript_application",
]),
],
},
javascriptRecovery: {
providers: [
providerBinding(WAKARU_PROVIDER_IDENTITY, {
group: "JAVASCRIPT_RECOVERY_TOOL_CONTRACTS",
}),
],
},
javascriptRuntimeObservation: {
providers: [
providerBinding(V8_INSPECTOR_PROVIDER_IDENTITY, {
group: "JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS",
}),
],
},
javascriptRuntimeReconciliation: {
providers: [
providerBinding(JAVASCRIPT_RUNTIME_RECONCILIATION_PROVIDER, [
"reconcile_javascript_runtime",
]),
],
},
jeb: {
providers: [
providerBinding(JEB_PROVIDER_IDENTITY, { group: "JEB_TOOL_CONTRACTS" }),
],
},
kernelBuildConfig: {
providers: [
providerBinding(KERNEL_BUILD_CONFIG_PROVIDER, [
"inspect_kernel_build_config",
]),
],
},
kernelModule: {
providers: [
providerBinding(KERNEL_MODULE_PROVIDER, ["inspect_kernel_module"]),
],
},
kuna: {
providers: [providerBinding(KUNA_PROVIDER_IDENTITY, KUNA_OPERATIONS)],
},
managedStatic: {
providers: [
providerBinding(MANAGED_STATIC_PROVIDER, {
group: "MANAGED_TOOL_CONTRACTS",
}),
],
},
managedWorkflow: {
providers: [
providerBinding(MANAGED_WORKFLOW_PROVIDER, {
group: "MANAGED_WORKFLOW_TOOL_CONTRACTS",
}),
],
},
modelArtifact: {
providers: [
providerBinding(MODEL_ARTIFACT_PROVIDER_IDENTITY, {
group: "MODEL_TOOL_CONTRACTS",
}),
],
},
nativeExports: {
providers: [
providerBinding(NATIVE_EXPORTS_PROVIDER, ["inspect_native_exports"]),
],
},
nativeMacOS: {
providers: [
providerBinding(NATIVE_MACOS_PROVIDER_IDENTITY, {
group: "NATIVE_TOOL_CONTRACTS",
}),
],
},
packetCapture: {
providers: [
providerBinding(TSHARK_PROVIDER_IDENTITY, {
group: "CAPTURE_TOOL_CONTRACTS",
}),
],
},
pcap: {
providers: [
providerBinding(PCAP_PROVIDER_IDENTITY, { group: "PCAP_TOOL_CONTRACTS" }),
],
},
peCertificates: {
providers: [
providerBinding(PE_CERTIFICATES_PROVIDER, ["inspect_pe_certificates"]),
],
},
peImports: {
providers: [providerBinding(PE_IMPORTS_PROVIDER, ["inspect_pe_imports"])],
},
peLoadConfig: {
providers: [
providerBinding(PE_LOAD_CONFIG_PROVIDER, ["inspect_pe_load_config"]),
],
},
binaryHardening: {
providers: [
providerBinding(BINARY_HARDENING_PROVIDER, ["inspect_binary_hardening"]),
],
},
peResources: {
providers: [
providerBinding(PE_RESOURCES_PROVIDER, ["inspect_pe_resources"]),
],
},
windowsShortcut: {
providers: [
providerBinding(WINDOWS_SHORTCUT_PROVIDER, ["inspect_windows_shortcut"]),
],
},
pythonPyc: {
providers: [
providerBinding(PYTHON_PYC_PROVIDER_IDENTITY, {
group: "PYTHON_PYC_TOOL_CONTRACTS",
}),
],
},
nugetNupkg: {
providers: [
providerBinding(NUGET_NUPKG_PROVIDER_IDENTITY, {
group: "NUGET_NUPKG_TOOL_CONTRACTS",
}),
],
},
releaseExposure: {
providers: [
providerBinding(RELEASE_EXPOSURE_PROVIDER, {
group: "RELEASE_EXPOSURE_TOOL_CONTRACTS",
}),
],
},
v8CodeCache: {
providers: [
providerBinding(V8_CODE_CACHE_PROVIDER_IDENTITY, {
group: "V8_CODE_CACHE_TOOL_CONTRACTS",
}),
],
},
mavenGradleMetadata: {
providers: [
providerBinding(MAVEN_GRADLE_METADATA_PROVIDER_IDENTITY, {
group: "MAVEN_GRADLE_METADATA_TOOL_CONTRACTS",
}),
],
},
recordedCrash: {
providers: [
providerBinding(PWNTOOLS_PROVIDER_IDENTITY, ["inspect_recorded_crash"]),
],
},
reverseEngineering: {
providers: [
providerBinding(OBJDUMP_PROVIDER_IDENTITY, ["inspect_with_objdump"]),
providerBinding(RIZIN_PROVIDER_IDENTITY, ["execute_rizin_command"]),
],
},
rizinDebugSessions: {
providers: [
providerBinding(RIZIN_DEBUGGER_PROVIDER_IDENTITY, {
group: "RIZIN_DEBUG_TOOL_CONTRACTS",
}),
],
},
rustBinary: {
providers: [
providerBinding(RUST_BINARY_PROVIDER_IDENTITY, {
group: "RUST_TOOL_CONTRACTS",
}),
],
},
signalRecording: {
providers: [
providerBinding(SIGROK_PROVIDER_IDENTITY, {
group: "SIGNAL_TOOL_CONTRACTS",
}),
],
},
sqliteDatabase: {
providers: [
providerBinding(SQLITE_PROVIDER_IDENTITY, {
group: "SQLITE_TOOL_CONTRACTS",
}),
],
},
wasmArtifact: {
providers: [
providerBinding(WABT_PROVIDER_IDENTITY, ["inspect_wasm_artifact"]),
],
},
webModuleTrace: {
providers: [
providerBinding(WEB_MODULE_TRACE_PROVIDER, ["trace_web_module_imports"]),
],
},
webNetworkCapture: {
providers: [
providerBinding(SAZ_CAPTURE_PROVIDER_IDENTITY, {
group: "WEB_NETWORK_CAPTURE_TOOL_CONTRACTS",
}),
providerBinding(HAR_CAPTURE_PROVIDER_IDENTITY, {
group: "WEB_NETWORK_CAPTURE_TOOL_CONTRACTS",
}),
providerBinding(MITMPROXY_CAPTURE_PROVIDER_IDENTITY, {
group: "WEB_NETWORK_CAPTURE_TOOL_CONTRACTS",
}),
providerBinding(QLOG_CAPTURE_PROVIDER_IDENTITY, {
group: "WEB_NETWORK_CAPTURE_TOOL_CONTRACTS",
}),
],
},
webRuntime: {
providers: [
providerBinding(CDP_BROWSER_PROVIDER_IDENTITY, {
group: "WEB_RUNTIME_TOOL_CONTRACTS",
}),
],
},
webScriptExport: {
providers: [
providerBinding(WEB_SCRIPT_EXPORT_PROVIDER, ["export_web_scripts"]),
],
},
webSourceLocation: {
providers: [
providerBinding(WEB_SOURCE_LOCATION_PROVIDER, [
"trace_web_source_location",
]),
],
},
} as const satisfies Readonly<Record<string, CapabilityDeclaration>>;
export type CapabilityDeclarationId = keyof typeof CAPABILITY_DECLARATIONS;