Struct LocalRegistry 

pub struct LocalRegistry { /* private fields */ }

Implementations

impl LocalRegistry

pub fn open() -> Result<Self, String>

pub fn root(&self) -> &Path

pub fn install_local_build( &self, manifest: &PackageManifest, content: &PackageContent, ) -> Result<PathBuf, String>

Installs a package this machine just built from its own sources (pack create, skills pack create): a rebuild at the same name@version replaces the previous local build.

pub fn remove(&self, name: &str, version: Option<&str>) -> Result<u32, String>

pub fn list(&self) -> Result<Vec<PackageEntry>, String>

pub fn load_package( &self, name: &str, version: &str, ) -> Result<(PackageManifest, PackageContent), String>

The stored package as its two parts. Admitted like Self::load_admitted; for callers that render or export the parts.

pub fn load_admitted( &self, name: &str, version: &str, ) -> Result<AdmittedPackage, String>

The stored package, hash verified first and then admitted under the CURRENT policy — the only way to obtain what the loader applies.

pub fn set_auto_load( &self, name: &str, version: &str, auto_load: bool, project_root: &str, ) -> Result<(), String>

Enable or disable auto-load of name@version for project_root only (V03): other projects — a same-named one at another root included — are not affected.

pub fn auto_load_packages( &self, project_root: &str, ) -> Result<Vec<PackageEntry>, String>

The packages auto-loaded into project_root (V03). An entry bound to no project loads nowhere.

pub fn export_to_file( &self, name: &str, version: &str, output: &Path, ) -> Result<u64, String>

Export copies a stored package out. It goes through Self::load_package: hash first, then the current admission — a package that would be refused today is not exported, and nothing is written to output (the write is the last step).

pub fn export_to_file_signed( &self, name: &str, version: &str, output: &Path, signing_key: &SigningKey, private: bool, ) -> Result<u64, String>

Export with a fresh ed25519 signature over the manifest (GL #406) — required by the hosted registry. The stored package stays untouched; only the exported bundle carries the signature. private stamps visibility=private into the bundle for the hosted registry (#524).

pub fn import_from_file_checked( &self, path: &Path, policy: SignaturePolicy<'_>, ) -> Result<(PackageManifest, Option<SignatureCoverage>), String>

Self::import_from_file, also returning what the package’s signature covers as written (None = unsigned). An unsigned package is admitted only under SignaturePolicy::AllowUnsigned, the caller’s explicit opt-in (GHSA-gvg8-285q-m62g); an identity-only signature is admitted with a warning (K02).

pub fn install_addon_from_file( &self, path: &Path, policy: SignaturePolicy<'_>, ) -> Result<PackageManifest, String>

Install a kind=addon package.

Deliberately a separate entry point from Self::import_from_file rather than a flag on it: the two differ only in which kind they accept, but they differ completely in consequence. Importing knowledge is reversible and inert; installing an addon puts code where the extension registry will load it. A caller has to name that intent, and the CLI asks the user before calling this.

Every other check is identical, and shared through Self::verify_bundle_integrity — integrity digest, then signature — so the executable path can never end up with weaker verification than the inert one.