Kiri Developers

SDK

Supply chain and policy

A module goes through the same supply chain as an image. When Kiri builds it, it writes down every package inside it; the Security tab scans those packages for known vulnerabilities; you sign it and push it to the registry that holds your images. Before a module runs, on your computer or in CI, Kiri checks it against your company’s rules.

A module in a registry

A module is an OCI artifact, the same kind of object as an image, so any registry that stores OCI artifacts stores modules: the one you already push images to. It follows the open layout for WebAssembly in OCI registries, so other tools can read it.

A module as an OCI artifactBill of materialsCycloneDXSignatureyour team’s keyrefer to itManifestteam/shop:1.4.0sha256:4e1c…Configkiri.yaml, languageLayershop.wasmLayerpacked filespoints to
What kiri push sends. The module's manifest points to its config, which holds kiri.yaml, and to two layers: the WebAssembly and the packed files. The bill of materials and the signature refer to the manifest, so they travel with it.

The machine code Kiri compiles a module into isn’t pushed: it’s made for one kind of computer, so Kiri compiles again when it pulls. The module itself runs the same on a Mac, Linux or Windows, on Apple silicon or Intel.

Bill of materials and scan

When Kiri builds a module, it writes its bill of materials from your lock file, go.sum, Cargo.lock, package-lock.json or your Python lock file, and from what was compiled in. It’s CycloneDX, the same format Kiri saves for images, with one addition: the module’s permissions from kiri.yaml, so a reviewer sees what it can reach next to what it contains.

A module’s Security tab works like an image’s. It scans the packages with Grype against its vulnerability database, on your computer, with nothing uploaded. Each finding has its severity, ID, package, the version that fixes it and the file that brought it in. Filter by severity or Has a fix, Save SBOM saves the bill of materials to Downloads, and Scan again runs a new scan. Kiri keeps the last 20 scans of each module.

Kiri
KiriModulesUSBShareSettings

Modules › shop

OverviewLogsPermissionsSecurity
2 vulnerabilities in 41 packagesSave SBOMScan again
Highgolang.org/x/net0.31.0 → 0.33.0Has a fix
Mediumexample.com/csvkit1.2.0No fix yet
Permissionsport 8080 · postgres · api.stripe.com · STRIPE_KEY
Signed byteam-releaseverified
The shop module's Security tab. Two of its 41 packages have known vulnerabilities, and the high one has a fix; the permissions from kiri.yaml are listed with the packages.

From a terminal, kiri module sbom shop writes the bill of materials to standard output, and kiri module scan shop scans and prints the findings, for CI.

Signing

A signature says who built a module, and that it hasn’t changed since. Kiri signs with a key you make once, keeps the private half in your system’s keychain, and writes signatures in Sigstore’s format, so cosign and other tools that verify images verify modules too.

zsh
$ kiri module key create team-release
  ✓ key team-release made; the private key is in your keychain
    public key: ./team-release.pub   (give this to whoever verifies)
$ kiri module build . -t registry.example.com/team/shop:1.4.0 --sign team-release
  ◆ shop  building Go 1.26 → WebAssembly…
  ✓ built · 2.1 MB · bill of materials: 41 packages
  ✓ signed by team-release
$ kiri module verify registry.example.com/team/shop:1.4.0
  ✓ signed by team-release (sha256:9b2f…), bill of materials attached

In CI, where there’s no keychain, Kiri reads the private key from KIRI_SIGNING_KEY, which your CI fills from its secret store.

Push, pull and run

A module lives in Kiri’s image store beside your images, with Module next to its name in Images, so Docker’s own commands move it. kiri push sends the module with its bill of materials and its signature; kiri pull fetches all three and compiles the module for your computer.

When you run a module you didn’t build, Kiri shows what its kiri.yaml asks for, one line per key, with who signed it, and waits for a yes. --yes answers for CI; read the prompt once by hand first.

zsh
$ kiri push registry.example.com/team/shop:1.4.0
  ✓ pushed module, bill of materials and signature
$ kiri run registry.example.com/team/shop:1.4.0

  shop 1.4.0  signed by team-release ✓
  2 vulnerabilities in 41 packages, 1 with a fix

  It asks to:
    • Listen on port 8080
    • Use a Postgres database
    • Reach these sites: api.stripe.com
    • Read these secrets: STRIPE_KEY

  It can't see your files, your containers or any other site.

  Run it? [y/N] y
  ●  serving on :8080 · 2.1 MB · started in 1.2 ms
     needs db, network, port, secrets

Kiri remembers your yes for that module. A later version that asks for more stops and asks again. docker run of a module refuses with shop:1.4.0 is a Kiri module: run it with kiri run, so nothing tries to start it as a container.

Company rules

Your company’s admin sets rules for a team in Kiri Cloud, and Kiri holds every member to them: in the window, in a terminal and in CI. The same rules cover images and modules, plus one more for modules, what they may ask for.

Rule For example Checked when
Where it may come from only registry.example.com/team/ Pull and run
Who must have signed it the team’s team-release key Pull and run
Vulnerabilities no critical vulnerability that has a fix Build, pull and run
What a module may ask for network only *.example.com and api.stripe.com; no gpu Build and run
Company rules at each stepYour team’s rulesset in Kiri Cloud, fetched by KiriBuildwhat it asks forvulnerabilitiesRegistrypush, signedPullwhere it came fromwho signed itRunall of these,and your yespushpullruncheckedchecked
Where the rules are checked. Kiri gets the team's rules from Kiri Cloud and checks a module at each step: what it asks for and what it contains when it's built, where it came from and who signed it when it's pulled, and all of these again before it runs.

A module that breaks a rule stops at that step, with the rule named, and the window shows the same message on the module’s row. kiri policy prints the rules that apply to you and where they came from.

zsh
$ kiri run registry.example.com/someone/shop:latest
  ✗ Your team's rules (Platform) don't allow this module:
    · modules must come from registry.example.com/team/
    · modules must be signed by: team-release
$ kiri policy
  Team Platform · from Kiri Cloud · fetched 2 hours ago
  Images and modules
    from              registry.example.com/team/
    signed by         team-release
    vulnerabilities   block critical with a fix
  Modules
    network           *.example.com, api.stripe.com
    gpu               not allowed

© 2026 Kiri · The SDK is open source under the Apache License 2.0 · Docs · runkiri.com