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

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

@@ -4,7 +4,7 @@ version = 4
 
 [[package]]
 name = "act-build"
-version = "0.7.5"
+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.5"
+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.5 → 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.5"
+version = "0.8.0"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/actcore/act-cli"

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

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

{act_cli-0.7.5 → 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.5 → act_cli-0.8.0}/act-cli/src/http.rs

@@ -24,6 +24,10 @@ pub struct AppState {
     pub info: act_types::ComponentInfo,
     pub component: runtime::ComponentHandle,
     pub metadata: Metadata,
+    /// When `Some`, a single default session was pre-opened (session-of-1,
+    /// ACT-SESSIONS §3): `/sessions*` routes are unregistered and this id is
+    /// forced into every call's `std:session-id` metadata.
+    pub default_session_id: Option<String>,
 }
 
 // ── Conversion helpers ──
@@ -84,6 +88,14 @@ fn internal_error_response(message: &str) -> axum::response::Response {
         .into_response()
 }
 
+/// Force `std:session-id` to the default when in session-of-1 mode, overriding
+/// any body-supplied value (ACT-SESSIONS §3 "session-of-1").
+fn apply_default_session(meta: &mut Metadata, default: &Option<String>) {
+    if let Some(id) = default {
+        meta.insert(META_SESSION_ID, serde_json::Value::String(id.clone()));
+    }
+}
+
 /// Format an SseEvent as an axum SSE Event.
 fn sse_event_to_axum(event: runtime::SseEvent) -> Option<Result<Event, std::convert::Infallible>> {
     match event {
@@ -151,6 +163,7 @@ async fn list_tools_inner(
     if let Some(value) = metadata {
         meta.extend(runtime::Metadata::from(value));
     }
+    apply_default_session(&mut meta, &state.default_session_id);
 
     let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
     let request = runtime::ComponentRequest::ListTools {
@@ -361,6 +374,7 @@ async fn tool_call_dispatcher(
     if let Some(value) = body.metadata {
         metadata.extend(Metadata::from(value));
     }
+    apply_default_session(&mut metadata, &state.default_session_id);
 
     let metadata_wit: Vec<(String, Vec<u8>)> = metadata.into();
 
@@ -522,16 +536,25 @@ async fn protocol_version_layer(request: Request, next: Next) -> axum::response:
 }
 
 pub fn create_router(state: Arc<AppState>) -> Router {
-    Router::new()
+    let mut router = Router::new()
         .route("/info", get(get_info))
         .route("/tools", axum::routing::any(tools_dispatcher))
-        .route("/tools/{name}", axum::routing::any(tool_call_dispatcher))
-        .route(
-            "/sessions/open-args-schema",
-            axum::routing::any(session_open_args_schema_dispatcher),
-        )
-        .route("/sessions", axum::routing::post(session_open))
-        .route("/sessions/{id}", axum::routing::delete(session_close))
+        .route("/tools/{name}", axum::routing::any(tool_call_dispatcher));
+
+    // Session-of-1 hides the session machinery (ACT-SESSIONS §3): when a
+    // default session is pre-opened, the component looks stateless and the
+    // lifecycle endpoints are absent (404).
+    if state.default_session_id.is_none() {
+        router = router
+            .route(
+                "/sessions/open-args-schema",
+                axum::routing::any(session_open_args_schema_dispatcher),
+            )
+            .route("/sessions", axum::routing::post(session_open))
+            .route("/sessions/{id}", axum::routing::delete(session_close));
+    }
+
+    router
         .layer(middleware::from_fn(protocol_version_layer))
         .with_state(state)
 }
@@ -567,4 +590,23 @@ mod tests {
     fn query_method_is_valid() {
         assert_eq!(query_method().as_str(), "QUERY");
     }
+
+    #[test]
+    fn apply_default_session_overrides_and_skips() {
+        // Some(id): inject, overriding any existing value.
+        let mut meta = Metadata::from(serde_json::json!({"std:session-id": "client"}));
+        apply_default_session(&mut meta, &Some("sid_default".to_string()));
+        assert_eq!(
+            meta.get_as::<String>(META_SESSION_ID).as_deref(),
+            Some("sid_default")
+        );
+
+        // None: leave metadata untouched.
+        let mut meta2 = Metadata::from(serde_json::json!({"std:session-id": "client"}));
+        apply_default_session(&mut meta2, &None);
+        assert_eq!(
+            meta2.get_as::<String>(META_SESSION_ID).as_deref(),
+            Some("client")
+        );
+    }
 }

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

@@ -101,6 +101,15 @@ enum Command {
         #[arg(short, long)]
         listen: Option<String>,
 
+        /// Pre-open a single session at startup from this JSON object and
+        /// run as session-of-1: every call uses the pre-opened session, the
+        /// session machinery is hidden from clients (no virtual
+        /// open_session/close_session tools, no /sessions endpoints), and any
+        /// client-supplied std:session-id is ignored. Requires a component
+        /// that exports act:sessions/session-provider.
+        #[arg(long)]
+        session_args: Option<String>,
+
         #[command(flatten)]
         opts: CommonOpts,
     },
@@ -176,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)]
@@ -211,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()
@@ -233,8 +264,9 @@ async fn main() -> Result<()> {
             mcp,
             http,
             listen,
+            session_args,
             opts,
-        } => cmd_run(component, mcp, http, listen, opts).await,
+        } => cmd_run(component, mcp, http, listen, session_args, opts).await,
         Command::Call {
             component,
             tool,
@@ -259,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,
+        },
     }
 }
 
@@ -404,11 +441,34 @@ fn parse_listen_addr(s: &str) -> Result<SocketAddr> {
     anyhow::bail!("invalid listen address: {s} (expected [host]:port or port number)")
 }
 
+/// If `session_args` is set, open a single default session against the
+/// prepared component and return its id (session-of-1, ACT-SESSIONS §3). The
+/// session is closed automatically when the component actor shuts down
+/// (`runtime` closes every tracked session on deinit).
+async fn maybe_open_default_session(
+    pc: &PreparedComponent,
+    session_args: &Option<String>,
+) -> Result<Option<String>> {
+    match session_args {
+        Some(json) => {
+            if !pc.has_sessions {
+                anyhow::bail!(
+                    "--session-args was set, but the component does not export \
+                     act:sessions/session-provider"
+                );
+            }
+            Ok(Some(open_session_for_call(pc, json).await?))
+        }
+        None => Ok(None),
+    }
+}
+
 async fn cmd_run(
     component: ComponentRef,
     mcp: bool,
     http: bool,
     listen: Option<String>,
+    session_args: Option<String>,
     opts: CommonOpts,
 ) -> Result<()> {
     // Transport matrix:
@@ -422,7 +482,16 @@ async fn cmd_run(
             None => "[::1]:3000".parse().unwrap(),
         };
         let pc = prepare_component(&component, &opts).await?;
-        return rmcp_bridge::run_http(addr, pc.info, pc.handle, pc.metadata, pc.has_sessions).await;
+        let default_session_id = maybe_open_default_session(&pc, &session_args).await?;
+        return rmcp_bridge::run_http(
+            addr,
+            pc.info,
+            pc.handle,
+            pc.metadata,
+            pc.has_sessions,
+            default_session_id,
+        )
+        .await;
     }
 
     if mcp {
@@ -430,7 +499,15 @@ async fn cmd_run(
             anyhow::bail!("--listen requires --http (MCP stdio has no listen address)");
         }
         let pc = prepare_component(&component, &opts).await?;
-        return rmcp_bridge::run_stdio(pc.info, pc.handle, pc.metadata, pc.has_sessions).await;
+        let default_session_id = maybe_open_default_session(&pc, &session_args).await?;
+        return rmcp_bridge::run_stdio(
+            pc.info,
+            pc.handle,
+            pc.metadata,
+            pc.has_sessions,
+            default_session_id,
+        )
+        .await;
     }
 
     if http || listen.is_some() {
@@ -440,11 +517,13 @@ async fn cmd_run(
         };
 
         let pc = prepare_component(&component, &opts).await?;
+        let default_session_id = maybe_open_default_session(&pc, &session_args).await?;
 
         let state = Arc::new(http::AppState {
             info: pc.info,
             component: pc.handle,
             metadata: pc.metadata,
+            default_session_id,
         });
 
         tracing::info!(%addr, "ACT host listening");
@@ -752,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}"))
+}