act-cli 0.7.6__tar.gz → 0.8.0__tar.gz

{act_cli-0.7.6 → act_cli-0.8.0}/Cargo.lock

@@ -4,7 +4,7 @@ version = 4
 
 [[package]]
 name = "act-build"
-version = "0.7.6"
+version = "0.8.0"
 dependencies = [
  "act-types",
  "anyhow",
@@ -18,7 +18,7 @@ dependencies = [
  "json-patch",
  "minijinja",
  "oci-client",
- "reqwest",
+ "reqwest 0.13.3",
  "serde",
  "serde_json",
  "sha2 0.11.0",
@@ -35,8 +35,9 @@ dependencies = [
 
 [[package]]
 name = "act-cli"
-version = "0.7.6"
+version = "0.8.0"
 dependencies = [
+ "act-store",
  "act-types",
  "anyhow",
  "axum",
@@ -57,7 +58,7 @@ dependencies = [
  "owo-colors",
  "path-clean",
  "regex",
- "reqwest",
+ "reqwest 0.13.3",
  "rmcp",
  "serde",
  "serde_json",
@@ -78,6 +79,27 @@ dependencies = [
  "wasmtime-wasi-http",
 ]
 
+[[package]]
+name = "act-store"
+version = "0.1.0"
+dependencies = [
+ "chrono",
+ "dirs",
+ "fs2",
+ "oci-client",
+ "oci-spec",
+ "regex",
+ "reqwest 0.12.28",
+ "serde",
+ "serde_json",
+ "sha2 0.11.0",
+ "tempfile",
+ "thiserror 2.0.18",
+ "tokio",
+ "tracing",
+ "url",
+]
+
 [[package]]
 name = "act-types"
 version = "0.7.1"
@@ -1203,6 +1225,16 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "fs2"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "fs_extra"
 version = "1.3.0"
@@ -1577,6 +1609,7 @@ dependencies = [
  "tokio",
  "tokio-rustls",
  "tower-service",
+ "webpki-roots",
 ]
 
 [[package]]
@@ -2219,7 +2252,7 @@ dependencies = [
  "oci-spec",
  "olpc-cjson",
  "regex",
- "reqwest",
+ "reqwest 0.13.3",
  "serde",
  "serde_json",
  "sha2 0.11.0",
@@ -2720,6 +2753,44 @@ version = "0.8.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
 
+[[package]]
+name = "reqwest"
+version = "0.12.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147"
+dependencies = [
+ "base64",
+ "bytes",
+ "futures-core",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-rustls",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "percent-encoding",
+ "pin-project-lite",
+ "quinn",
+ "rustls",
+ "rustls-pki-types",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper",
+ "tokio",
+ "tokio-rustls",
+ "tower",
+ "tower-http",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "webpki-roots",
+]
+
 [[package]]
 name = "reqwest"
 version = "0.13.3"
@@ -2873,6 +2944,7 @@ checksum = "ef86cd5876211988985292b91c96a8f2d298df24e75989a43a3c73f2d4d8168b"
 dependencies = [
  "aws-lc-rs",
  "once_cell",
+ "ring",
  "rustls-pki-types",
  "rustls-webpki",
  "subtle",
@@ -4454,6 +4526,15 @@ dependencies = [
  "rustls-pki-types",
 ]
 
+[[package]]
+name = "webpki-roots"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52f5ee44c96cf55f1b349600768e3ece3a8f26010c05265ab73f945bb1a2eb9d"
+dependencies = [
+ "rustls-pki-types",
+]
+
 [[package]]
 name = "winapi"
 version = "0.3.9"

{act_cli-0.7.6 → act_cli-0.8.0}/Cargo.toml

@@ -1,9 +1,9 @@
 [workspace]
-members = ["act-cli"]
+members = ["act-cli", "crates/act-store"]
 resolver = "3"
 
 [workspace.package]
-version = "0.7.6"
+version = "0.8.0"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/actcore/act-cli"

{act_cli-0.7.6 → act_cli-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: act-cli
-Version: 0.7.6
+Version: 0.8.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{act_cli-0.7.6 → act_cli-0.8.0}/act-cli/Cargo.toml

@@ -56,6 +56,7 @@ cidr = "0.3"
 globset = "0.4"
 path-clean = "1"
 owo-colors = { version = "4.3.0", features = ["supports-colors"] }
+act-store = { version = "0.1.0", path = "../crates/act-store" }
 
 [dev-dependencies]
 tempfile = "3"

{act_cli-0.7.6 → act_cli-0.8.0}/act-cli/src/main.rs

@@ -185,6 +185,27 @@ enum Command {
     /// the session lives as long as the host).
     #[command(subcommand)]
     Session(SessionCommand),
+    /// Manage the local component store (list, update, gc).
+    #[command(subcommand)]
+    Store(StoreCommand),
+}
+
+#[derive(clap::Subcommand)]
+enum StoreCommand {
+    /// List components in the local store.
+    List {
+        /// Output format.
+        #[arg(long, value_enum, default_value_t = OutputFormat::Text)]
+        format: OutputFormat,
+    },
+    /// Re-resolve stored components and re-pull any whose digest moved.
+    Update {
+        /// A single ref to update (omit to update all stored components).
+        #[arg(name = "ref")]
+        reference: Option<ComponentRef>,
+    },
+    /// Delete store blobs no longer referenced by any component.
+    Gc,
 }
 
 #[derive(clap::Subcommand)]
@@ -220,6 +241,7 @@ async fn main() -> Result<()> {
             Command::Session(sub) => match sub {
                 SessionCommand::OpenArgsSchema { opts, .. } => opts.config.as_deref(),
             },
+            Command::Store(_) => None,
         };
         let log_level = config::load_config(config_path)
             .ok()
@@ -269,6 +291,11 @@ async fn main() -> Result<()> {
                 cmd_session_open_args_schema(component, opts).await
             }
         },
+        Command::Store(sub) => match sub {
+            StoreCommand::List { format } => cmd_list(format).await,
+            StoreCommand::Update { reference } => cmd_update(reference).await,
+            StoreCommand::Gc => cmd_gc().await,
+        },
     }
 }
 
@@ -804,42 +831,132 @@ async fn cmd_pull(
     output: Option<PathBuf>,
     output_from_ref: bool,
 ) -> Result<()> {
-    // Resolve to local path (downloads to cache for remote refs)
-    // Always download fresh — pull is explicit user action
-    let cached_path = resolve::resolve(&reference, true).await?;
+    let store = resolve::open_store()?;
+    let reference_str = reference.to_string();
+    let stored = act_store::pull(&store, &reference_str)
+        .await
+        .with_context(|| format!("pulling {reference_str}"))?;
+
+    // Path to the stored wasm blob (read-through hit; no re-pull).
+    let stored_path = act_store::ensure(&store, &reference_str).await?;
+
+    let export = output.or_else(|| {
+        output_from_ref.then(|| {
+            let ref_str = reference.to_string();
+            let base = ref_str
+                .rsplit('/')
+                .next()
+                .unwrap_or(&ref_str)
+                .split(':')
+                .next()
+                .unwrap_or(&ref_str);
+            let filename = if base.ends_with(".wasm") {
+                base.to_string()
+            } else {
+                format!("{base}.wasm")
+            };
+            PathBuf::from(filename)
+        })
+    });
 
-    if let Some(out) = output {
-        tokio::fs::copy(&cached_path, &out)
-            .await
-            .with_context(|| format!("copying to {}", out.display()))?;
-        println!("{}", out.display());
-    } else if output_from_ref {
-        let ref_str = reference.to_string();
-        let base = ref_str
-            .rsplit('/')
-            .next()
-            .unwrap_or(&ref_str)
-            .split(':')
-            .next()
-            .unwrap_or(&ref_str);
-        let filename = if base.ends_with(".wasm") {
-            base.to_string()
-        } else {
-            format!("{base}.wasm")
-        };
-        let out = PathBuf::from(&filename);
-        tokio::fs::copy(&cached_path, &out)
+    if let Some(out) = export {
+        tokio::fs::copy(&stored_path, &out)
             .await
             .with_context(|| format!("copying to {}", out.display()))?;
         println!("{}", out.display());
     } else {
-        // No output flag — print cached path
-        println!("{}", cached_path.display());
+        println!(
+            "{} -> {} (sha256:{})",
+            reference_str,
+            stored_path.display(),
+            stored.manifest_digest
+        );
+    }
+    Ok(())
+}
+
+// ── Store subcommands ─────────────────────────────────────────────────────────
+
+async fn cmd_list(format: OutputFormat) -> Result<()> {
+    let store = resolve::open_store()?;
+    let mut items = store.list()?;
+    items.sort_by(|a, b| source_ref(&a.provenance).cmp(source_ref(&b.provenance)));
+    match format {
+        OutputFormat::Json => {
+            let rows: Vec<_> = items
+                .iter()
+                .map(|s| {
+                    serde_json::json!({
+                        "ref": source_ref(&s.provenance),
+                        "digest": s.provenance.digest,
+                        "name": s.provenance.name,
+                        "version": s.provenance.version,
+                        "fetched_at": s.provenance.fetched_at,
+                    })
+                })
+                .collect();
+            println!("{}", serde_json::to_string_pretty(&rows)?);
+        }
+        OutputFormat::Text => {
+            if items.is_empty() {
+                println!("(store is empty)");
+            }
+            for s in &items {
+                println!(
+                    "{}\t{}\t{}",
+                    source_ref(&s.provenance),
+                    s.provenance.version.as_deref().unwrap_or("-"),
+                    s.provenance.digest
+                );
+            }
+        }
     }
+    Ok(())
+}
 
+async fn cmd_update(reference: Option<ComponentRef>) -> Result<()> {
+    let store = resolve::open_store()?;
+    let refs: Vec<String> = match reference {
+        Some(r) => vec![r.to_string()],
+        None => store
+            .list()?
+            .iter()
+            .map(|s| source_ref(&s.provenance).to_string())
+            .collect(),
+    };
+    if refs.is_empty() {
+        println!("(store is empty)");
+        return Ok(());
+    }
+    for r in refs {
+        match act_store::update(&store, &r).await {
+            Ok(act_store::UpdateOutcome::Unchanged) => println!("{r}\tunchanged"),
+            Ok(act_store::UpdateOutcome::Updated { from, to }) => {
+                println!("{r}\tupdated {from} -> {to}")
+            }
+            Ok(act_store::UpdateOutcome::NotStored) => println!("{r}\tnot stored"),
+            Err(e) => eprintln!("{r}\tERROR: {e}"),
+        }
+    }
+    Ok(())
+}
+
+async fn cmd_gc() -> Result<()> {
+    let store = resolve::open_store()?;
+    let removed = store.gc()?;
+    println!("removed {removed} unreferenced blob(s)");
     Ok(())
 }
 
+/// The source ref (as typed) recorded in a provenance.
+fn source_ref(p: &act_store::Provenance) -> &str {
+    match &p.source {
+        act_store::Source::Oci { reference } => reference,
+        act_store::Source::Http { url, .. } => url,
+        act_store::Source::Local { path } => path,
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

act_cli-0.8.0/act-cli/src/resolve.rs

@@ -0,0 +1,42 @@
+//! Component reference resolution, backed by the shared `act-store`.
+//!
+//! `ComponentRef` is re-exported from `act-store` (the parsing source of truth).
+//! Local refs run in place; remote refs (OCI/HTTP) resolve read-through the
+//! store (pulled on first use, then served from disk).
+
+use std::path::PathBuf;
+
+use anyhow::{Context, Result};
+
+pub use act_store::Ref as ComponentRef;
+
+/// Open the shared component store at its platform default location.
+pub fn open_store() -> Result<act_store::Store> {
+    let dir = act_store::store_dir().context("locating component store")?;
+    act_store::Store::open(&dir).context("opening component store")
+}
+
+/// Resolve a component reference to a local `.wasm` path.
+///
+/// Local files are used in place (never copied into the store). Remote refs
+/// (OCI/HTTP) are served read-through from the store; `fresh` forces a re-pull.
+pub async fn resolve(component_ref: &ComponentRef, fresh: bool) -> Result<PathBuf> {
+    if let ComponentRef::Local(path) = component_ref {
+        anyhow::ensure!(
+            tokio::fs::try_exists(path).await.unwrap_or(false),
+            "component not found: {}",
+            path.display()
+        );
+        return Ok(path.clone());
+    }
+    let store = open_store()?;
+    let reference = component_ref.to_string();
+    if fresh {
+        act_store::pull(&store, &reference)
+            .await
+            .with_context(|| format!("pulling {reference}"))?;
+    }
+    act_store::ensure(&store, &reference)
+        .await
+        .with_context(|| format!("resolving {reference}"))
+}

{act_cli-0.7.6 → act_cli-0.8.0}/act-cli/src/rmcp_bridge.rs

@@ -41,7 +41,11 @@ pub struct ActRmcpBridge {
 fn map_content_part(part: &runtime::exports::act::tools::tool_provider::ContentPart) -> Content {
     let mime = part.mime_type.as_deref().unwrap_or("");
 
-    if mime.starts_with("text/") {
+    // UTF-8 text-like payloads surface as MCP text content verbatim. This
+    // covers `text/*` and JSON (`application/json`, `application/*+json`) —
+    // JSON bytes are UTF-8, not CBOR, so they must not hit the base64 path
+    // below. Matches the ACT-HTTP transport, which also treats JSON as text.
+    if mime.starts_with("text/") || mime == "application/json" || mime.ends_with("+json") {
         let text = String::from_utf8_lossy(&part.data).into_owned();
         return Content::text(text);
     }
@@ -717,6 +721,24 @@ mod tests {
         );
     }
 
+    #[test]
+    fn map_content_json_decodes_to_text() {
+        // application/json content (UTF-8 JSON bytes, as emitted by act-sdk's
+        // `Json<T>`) must surface as the literal JSON string — NOT base64.
+        let json = br#"{"id":1,"name":"Fixture WS"}"#;
+        let c = map_content_part(&part(Some("application/json"), json));
+        let text = content_text(&c).expect("json must become text");
+        assert_eq!(text, r#"{"id":1,"name":"Fixture WS"}"#);
+    }
+
+    #[test]
+    fn map_content_json_suffix_decodes_to_text() {
+        let body = br#"{"ok":true}"#;
+        let c = map_content_part(&part(Some("application/vnd.api+json"), body));
+        let text = content_text(&c).expect("+json must become text");
+        assert_eq!(text, r#"{"ok":true}"#);
+    }
+
     #[test]
     fn map_content_opaque_falls_back_to_base64() {
         let bytes = vec![0xFF, 0xD8, 0xFF, 0xE0];

act_cli-0.8.0/crates/act-store/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "act-store"
+description = "Local OCI-layout component store for ACT (act-cli, act-toolserver)"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+readme = "README.md"
+keywords = ["act", "wasm", "oci", "component", "store"]
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+sha2 = "0.11"
+thiserror = "2"
+fs2 = "0.4"
+oci-spec = "0.9.0"
+dirs = "6.0.0"
+tokio = { version = "1.52.3", features = ["rt", "macros", "fs", "io-util"] }
+oci-client = "0.17"
+reqwest = { version = "0.12", default-features = false, features = ["rustls-tls"] }
+chrono = { version = "0.4.44", default-features = false, features = ["clock"] }
+url = "2.5.8"
+regex = "1.12.3"
+tracing = "0.1.44"
+
+[dev-dependencies]
+tempfile = "3"
+tokio = { version = "1.52.3", features = ["rt", "macros", "rt-multi-thread"] }

act_cli-0.8.0/crates/act-store/README.md

@@ -0,0 +1,125 @@
+# ACT CLI & Build Tools
+
+Host and build [ACT](https://actcore.dev) (Agent Component Tools) WebAssembly components.
+
+This repo contains two tools:
+
+- **`act`** — run, call, inspect, and serve ACT components from local files, HTTP URLs, or OCI registries
+- **`act-build`** — post-process compiled WASM components: embed metadata, skills, and custom sections
+
+## Install
+
+```bash
+# act (CLI host)
+npm i -g @actcore/act
+pip install act-cli
+cargo install act-cli
+
+# act-build (build tool)
+npm i -g @actcore/act-build
+pip install act-build
+cargo install act-build
+```
+
+Pre-built binaries available on [GitHub Releases](https://github.com/actcore/act-cli/releases) and Docker (`ghcr.io/actcore/act`).
+
+## act — Component Host
+
+```bash
+# Discover tools in a component
+act info --tools ghcr.io/actpkg/sqlite:0.1.0
+
+# Call a tool
+act call ghcr.io/actpkg/sqlite:0.1.0 query \
+  --args '{"sql":"SELECT sqlite_version()"}' \
+  --metadata '{"database_path":"/data/app.db"}' \
+  --allow-dir /data:./data
+
+# Serve over HTTP
+act run -l ghcr.io/actpkg/sqlite:0.1.0
+
+# Serve over MCP stdio
+act run --mcp ghcr.io/actpkg/sqlite:0.1.0
+```
+
+Components can be referenced as:
+- **OCI refs:** `ghcr.io/actpkg/sqlite:0.1.0`
+- **HTTP URLs:** `https://example.com/component.wasm`
+- **Local paths:** `./component.wasm`
+
+Remote components are cached in `~/.cache/act/components/`.
+
+### Commands
+
+| Command | Description |
+|---------|-------------|
+| `run`   | Serve a component over ACT-HTTP (`-l`) or MCP stdio (`--mcp`) |
+| `call`  | Call a tool directly, print result to stdout |
+| `info`  | Show component metadata, tools, and schemas (`--tools`, `--format text\|json`) |
+| `pull`  | Download a component from OCI or HTTP to local file |
+
+### HTTP Endpoints (`run -l`)
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `GET` | `/info` | Component metadata |
+| `POST` | `/metadata-schema` | JSON Schema for metadata |
+| `POST/QUERY` | `/tools` | List tools |
+| `POST/QUERY` | `/tools/{name}` | Call a tool (SSE with `Accept: text/event-stream`) |
+
+## act-build — Component Build Tool
+
+```bash
+# Embed act:component metadata, act:skill, and WASM custom sections
+act-build pack target/wasm32-wasip2/release/my_component.wasm
+
+# Validate without modifying
+act-build validate target/wasm32-wasip2/release/my_component.wasm
+
+# Publish as a CNCF Wasm OCI Artifact
+act-build push my_component.wasm ghcr.io/actpkg/my-component:0.1.0 \
+  --also-tag latest \
+  --source https://github.com/actpkg/my-component \
+  --skip-if-identical
+```
+
+Metadata is resolved via merge-patch from project manifests:
+
+1. **Base** from `Cargo.toml`, `pyproject.toml`, or `package.json` (name, version, description)
+2. **Inline patch** from the same manifest (`[package.metadata.act-component]`, `[tool.act-component]`, or `actComponent`)
+3. **`act.toml`** — highest priority, applied last
+
+`act-build push` produces artifacts conformant with the [CNCF
+TAG-Runtime Wasm OCI Artifact spec](https://tag-runtime.cncf.io/wgs/wasm/deliverables/wasm-oci-artifact/):
+manifest config has media type `application/vnd.wasm.config.v0+json`
+(with `architecture`, `os`, `layerDigests`, and
+`component.{exports,imports}` derived from the component's exports
+and imports), and the layer is `application/wasm`.
+
+Authentication is resolved in order: `OCI_USERNAME`/`OCI_PASSWORD`
+env, then `GITHUB_TOKEN` for `ghcr.io`, then `~/.docker/config.json`
+(or `$DOCKER_CONFIG/config.json`), then anonymous.
+
+## Platform Support
+
+| Architecture | Linux (GNU) | Linux (musl) | macOS | Windows | Docker |
+|-------------|:-----------:|:------------:|:-----:|:-------:|:------:|
+| x86_64      | ✓           | ✓            | ✓     | ✓       | ✓      |
+| aarch64     | ✓           | ✓            | ✓     | ✓       | ✓      |
+| riscv64     | ✓           | ✓            | —     | —       | ✓      |
+
+RISC-V (`riscv64`) is a first-class target. Regressions on RISC-V are release-blocking.
+
+## Building
+
+```bash
+cargo build --release        # both tools
+cargo build -p act-cli       # act only
+cargo build -p act-build     # act-build only
+```
+
+Set `RUST_LOG=act=debug` for verbose output.
+
+## License
+
+MIT OR Apache-2.0