CLI Reference

The asrpm tool provides command-line access to the Agent Skill Registry: resolving, verifying, installing, listing, uninstalling, registering, publishing, and updating skills.

Installation

# Homebrew
brew install vorpalengineering/tap/asrpm

# Go install
go install github.com/vorpalengineering/asrpm/cmd/asrpm@latest

# Build from source
git clone https://github.com/vorpalengineering/asrpm
cd asrpm && go build -o asrpm ./cmd/asrpm

See the Getting Started guide for prerequisites, configuration, and wallet handling.

Commands

asrpm
├── resolve <skillId>           Fetch and print a skill's registration file
├── verify <skillId>            Run the full integrity pipeline without writing
├── install <skillId>           Install a skill into ~/.claude/skills/
├── update <skillId>            Refresh an installed skill to its latest onchain version
├── uninstall <name|skillId>    Remove an installed skill
├── list                        List all skills installed via asrpm
├── bootstrap                   Print the embedded ASR bootstrap SKILL.md
├── register                    Mint a new skill token onchain
├── publish <skillId>           Publish a new version of an existing skill (owner only)
├── config                      Show or update configuration
├── version                     Show CLI version
└── help                        Show full help

resolve

Fetch a skill's registration file, verify the manifest hash, and print the result. Read-only; no signer required.

asrpm resolve <skillId>
asrpm resolve <skillId> --json
asrpm resolve <skillId> --verbose
asrpm resolve <skillId> --registry 0xRegistryAddress

Flags:

Flag	Description
`--registry <addr>`	Override the configured `SkillRegistry` address
`--json`	Emit the raw manifest JSON to stdout
`--verbose`, `-v`	Print full URIs and integrity values in the human-readable readout

verify

Run the full verification pipeline — resolve, fetch manifest, check manifest hash, parse, pick target, fetch body, check body integrity — without writing to disk. Effectively install --dry-run.

asrpm verify <skillId>
asrpm verify <skillId> --view
asrpm verify <skillId> --target claude-code --registry 0xRegistryAddress

Flags:

Flag	Description
`--target <target>`	Target kind to verify against (v1: `claude-code`)
`--registry <addr>`	Override the configured `SkillRegistry` address
`--view`	Print the verified body bytes to stdout after the readout. Readout is routed to stderr in this mode so the body can be piped cleanly.

install

Resolve a skill, verify every integrity hash, and write the matching target's body to a target-specific path. Installs are recorded in ~/.asrpm/installs.json, keyed by (chainId, registry, skillId).

asrpm install <skillId>
asrpm install <skillId> --scope project
asrpm install <skillId> --force --yes
asrpm install <skillId> --registry 0xRegistryAddress

For Claude Code, the body is written to ~/.claude/skills/<sanitized-name>/SKILL.md (user scope) or .claude/skills/<sanitized-name>/SKILL.md relative to the current directory (project scope).

Flags:

Flag	Description
`--target <target>`	Install target (v1 supports `claude-code` only)
`--scope <scope>`	`user` (default) or `project`
`--force`	Overwrite existing content at the install path
`--yes`	Skip the confirmation prompt before writing
`--registry <addr>`	Override the configured `SkillRegistry` address

After installation, restart your agent host (e.g. Claude Code) to load the new skill.

update

Refresh a previously-installed skill to its latest onchain version. Looks up the skill in ~/.asrpm/installs.json, re-resolves it from the chain, and rewrites the body if it has changed. No-op if already up to date.

asrpm update <skillId>
asrpm update <skillId> --yes
asrpm update <skillId> --registry 0xRegistryAddress

Flags:

Flag	Description
`--yes`	Skip the confirmation prompt before overwriting
`--registry <addr>`	Override the configured `SkillRegistry` address

uninstall

Remove an installed skill. Accepts either the install's name or its skillId.

asrpm uninstall <name>
asrpm uninstall <skillId>
asrpm uninstall <skillId> --registry 0xRegistryAddress

Flags:

Flag	Description
`--registry <addr>`	Disambiguator when the same skillId is installed from multiple registries
`--yes`	Skip the confirmation prompt
`--force`	Delete a directory not managed by `asrpm`

If the install isn't in the local index, the command refuses to remove the directory unless --force is passed.

list

Print all skills installed via asrpm, sourced from ~/.asrpm/installs.json.

asrpm list
asrpm list --json

Flags:

Flag	Description
`--json`	Emit the install index as JSON

bootstrap

Print the embedded ASR bootstrap SKILL.md to stdout. Useful for injecting ASR awareness into an active agent session without writing to disk.

asrpm bootstrap
asrpm bootstrap > /tmp/asr-bootstrap.md

The embedded content is the same bytes that get published to the bootstrap skill on a deployed registry.

register

Mint a new skill token onchain by submitting registerSkill(uri, keccak256(manifest)) to the configured SkillRegistry. Requires a signer.

asrpm register \
  --manifest path/to/manifest.json \
  --uri https://gateway.pinata.cloud/ipfs/<cid> \
  --account my-keystore

Flags:

Flag	Description
`--manifest <path>`	Local manifest JSON; the CLI hashes the bytes verbatim (required)
`--uri <uri>`	URI written to `tokenURI`; must serve bytes identical to `--manifest` (required)
`--account <name>`	Foundry keystore (else `ASRPM_PRIVATE_KEY`)
`--yes`	Skip the confirmation prompt
`--registry <addr>`	Override the configured `SkillRegistry` address

The CLI computes keccak256 over the exact bytes of the local manifest file and submits that hash alongside the URI. The hosted URI must return identical bytes — any byte-level difference (trailing newline, key reordering, etc.) will cause integrity verification to fail for downstream clients.

publish

Publish a new version of an existing skill by submitting setTokenURI(skillId, uri, hash). Only the current owner of the token (per ownerOf(skillId)) may call this.

asrpm publish <skillId> \
  --manifest path/to/new-manifest.json \
  --uri https://gateway.pinata.cloud/ipfs/<new-cid> \
  --account my-keystore

Flags:

Flag	Description
`--manifest <path>`	Local manifest JSON; the CLI hashes the bytes verbatim (required)
`--uri <uri>`	New URI written to `tokenURI` (required)
`--account <name>`	Foundry keystore (else `ASRPM_PRIVATE_KEY`)
`--yes`	Skip the confirmation prompt
`--registry <addr>`	Override the configured `SkillRegistry` address

config

Show or update the CLI configuration. The file lives at ~/.asrpm/config.json; environment variables (ASRPM_RPC_URL, ASRPM_SKILL_REGISTRY) always override file values.

# Show current configuration
asrpm config
asrpm config --json

# Get a single field
asrpm config get rpc_url

# Update one or more fields
asrpm config set --rpc-url https://eth-sepolia.example/v3/...
asrpm config set --skill-registry 0x8239AAbaa1A44338bEeFAAf4C3a373d2a18D5DC4
asrpm config set --rpc-url <url> --skill-registry <addr>

Subcommands:

Subcommand	Description
`asrpm config`	Print the current configuration
`asrpm config get <key>`	Print one configuration field (`rpc_url` or `skill_registry`)
`asrpm config set [flags]`	Update one or more fields

set flags:

Flag	Description
`--rpc-url <url>`	JSON-RPC endpoint for the target chain
`--skill-registry <addr>`	`SkillRegistry` contract address

version

Print the CLI version.

asrpm version

Authoring Helper Script

The asrpm repository includes scripts/asrpm-prepare.sh, a helper for publishing a skill with the body fully inlined as a data: URI inside the manifest.

./scripts/asrpm-prepare.sh path/to/SKILL.md path/to/manifest.json

The script:

Computes the keccak256 hash and base64 encoding of the body file
Splices the resulting data: URI and keccak256:<hex> integrity into the manifest's claude-code-skill target
Computes the manifest's keccak256 hash
Encodes the manifest itself as a data: URI suitable for --uri
Prints the asrpm register command for you to run, supplying your own --account

Requires cast (Foundry), jq, and base64 on PATH. The target kind is hardcoded to claude-code-skill; adapt the printed command if publishing for a different host.

Example Workflow

A typical end-to-end workflow for publishing and installing a skill:

# 1. (Author) Prepare the manifest with inlined body
./scripts/asrpm-prepare.sh my-skill.md my-manifest.json

# 2. (Author) Register the skill onchain
asrpm register \
  --manifest my-manifest.prepared.json \
  --uri "data:application/json;charset=utf-8;base64,$(base64 -i my-manifest.prepared.json | tr -d '\n')" \
  --account my-keystore

# 3. (Author) Later, publish a new version
asrpm publish 42 \
  --manifest my-manifest-v2.prepared.json \
  --uri "data:application/json;charset=utf-8;base64,$(base64 -i my-manifest-v2.prepared.json | tr -d '\n')" \
  --account my-keystore

# 4. (Consumer) Discover and inspect the skill
asrpm resolve 42

# 5. (Consumer) Install the skill into Claude Code
asrpm install 42
# Restart Claude Code to load the new skill.

# 6. (Consumer) Later, refresh to the latest version
asrpm update 42

Installation​

Commands​

resolve​

verify​

install​

update​

uninstall​

list​

bootstrap​

register​

publish​

config​

version​

Authoring Helper Script​

Example Workflow​

Installation

Commands

resolve

verify

install

update

uninstall

list

bootstrap

register

publish

config

version

Authoring Helper Script

Example Workflow