act-cli 0.7.0__tar.gz → 0.7.2__tar.gz

{act_cli-0.7.0 → act_cli-0.7.2}/Cargo.lock

@@ -4,7 +4,7 @@ version = 4
 
 [[package]]
 name = "act-build"
-version = "0.7.0"
+version = "0.7.2"
 dependencies = [
  "act-types",
  "anyhow",
@@ -25,7 +25,7 @@ dependencies = [
 
 [[package]]
 name = "act-cli"
-version = "0.7.0"
+version = "0.7.2"
 dependencies = [
  "act-types",
  "anyhow",

{act_cli-0.7.0 → act_cli-0.7.2}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["act-cli"]
 resolver = "3"
 
 [workspace.package]
-version = "0.7.0"
+version = "0.7.2"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/actcore/act-cli"

{act_cli-0.7.0 → act_cli-0.7.2}/PKG-INFO

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

{act_cli-0.7.0 → act_cli-0.7.2}/act-cli/src/main.rs

@@ -104,6 +104,16 @@ enum Command {
         #[arg(long, default_value = "{}")]
         args: String,
 
+        /// Session args as a JSON object. When set, the host opens a
+        /// session before the call (`open-session(args, metadata)`),
+        /// injects the returned id as `std:session-id` metadata for
+        /// the tool call, and closes the session before exit. Use
+        /// this when the component requires a session — bridges,
+        /// stateful components — and you want the whole open/call/
+        /// close cycle in one process.
+        #[arg(long)]
+        session_args: Option<String>,
+
         #[command(flatten)]
         opts: CommonOpts,
     },
@@ -146,7 +156,12 @@ enum Command {
         #[arg(short = 'O', conflicts_with = "output")]
         output_from_ref: bool,
     },
-    /// Manage component sessions (`act:sessions/session-provider`).
+    /// Inspect `act:sessions/session-provider` — currently only
+    /// `open-args-schema`, since opening or closing a session from a
+    /// one-shot CLI invocation cannot keep the underlying wasm state
+    /// alive. For real session work, use `act run --http` or
+    /// `act run --mcp` (the host process holds the wasm instance and
+    /// the session lives as long as the host).
     #[command(subcommand)]
     Session(SessionCommand),
 }
@@ -159,22 +174,6 @@ enum SessionCommand {
         #[command(flatten)]
         opts: CommonOpts,
     },
-    /// Open a new session, print the session record (id + metadata) as JSON.
-    Open {
-        component: ComponentRef,
-        /// JSON object with session-args.
-        #[arg(long, default_value = "{}")]
-        args: String,
-        #[command(flatten)]
-        opts: CommonOpts,
-    },
-    /// Close a session by id.
-    Close {
-        component: ComponentRef,
-        session_id: String,
-        #[command(flatten)]
-        opts: CommonOpts,
-    },
 }
 
 #[tokio::main]
@@ -198,9 +197,7 @@ async fn main() -> Result<()> {
             }
             Command::Skill { .. } | Command::Pull { .. } => None,
             Command::Session(sub) => match sub {
-                SessionCommand::OpenArgsSchema { opts, .. }
-                | SessionCommand::Open { opts, .. }
-                | SessionCommand::Close { opts, .. } => opts.config.as_deref(),
+                SessionCommand::OpenArgsSchema { opts, .. } => opts.config.as_deref(),
             },
         };
         let log_level = config::load_config(config_path)
@@ -230,8 +227,9 @@ async fn main() -> Result<()> {
             component,
             tool,
             args,
+            session_args,
             opts,
-        } => cmd_call(component, tool, args, opts).await,
+        } => cmd_call(component, tool, args, session_args, opts).await,
         Command::Info {
             component,
             tools,
@@ -248,16 +246,6 @@ async fn main() -> Result<()> {
             SessionCommand::OpenArgsSchema { component, opts } => {
                 cmd_session_open_args_schema(component, opts).await
             }
-            SessionCommand::Open {
-                component,
-                args,
-                opts,
-            } => cmd_session_open(component, args, opts).await,
-            SessionCommand::Close {
-                component,
-                session_id,
-                opts,
-            } => cmd_session_close(component, session_id, opts).await,
         },
     }
 }
@@ -442,6 +430,7 @@ async fn cmd_call(
     component: ComponentRef,
     tool: String,
     args: String,
+    session_args: Option<String>,
     opts: CommonOpts,
 ) -> Result<()> {
     let pc = prepare_component(&component, &opts).await?;
@@ -450,109 +439,113 @@ async fn cmd_call(
         serde_json::from_str(&args).context("invalid --args JSON")?;
     let cbor_args = cbor::json_to_cbor(&arguments).context("encoding args as CBOR")?;
 
+    // If --session-args is set, open a session before the call and
+    // close it on the way out. session-id is injected into the call's
+    // metadata under `std:session-id`.
+    let session_id = 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"
+                );
+            }
+            Some(open_session_for_call(&pc, &json).await?)
+        }
+        None => None,
+    };
+
+    let mut metadata = pc.metadata.clone();
+    if let Some(ref id) = session_id {
+        metadata.insert(
+            act_types::constants::META_SESSION_ID,
+            serde_json::Value::String(id.clone()),
+        );
+    }
+
     let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
     let request = runtime::ComponentRequest::CallTool {
         name: tool,
         arguments: cbor_args,
-        metadata: pc.metadata.clone().into(),
+        metadata: metadata.into(),
         reply: reply_tx,
     };
 
-    pc.handle
-        .send(request)
-        .await
-        .map_err(|_| anyhow::anyhow!("component actor unavailable"))?;
+    let send_result = pc.handle.send(request).await;
+    let call_result = match send_result {
+        Err(_) => Err(anyhow::anyhow!("component actor unavailable")),
+        Ok(()) => match reply_rx.await {
+            Err(_) => Err(anyhow::anyhow!("component actor dropped reply")),
+            Ok(r) => Ok(r),
+        },
+    };
 
-    match reply_rx.await? {
-        Ok(result) => {
-            for event in &result.events {
-                match event {
-                    runtime::exports::act::tools::tool_provider::ToolEvent::Content(part) => {
-                        let mime = part.mime_type.as_deref().unwrap_or("application/cbor");
-                        if mime.starts_with("text/")
-                            || mime == "application/json"
-                            || mime == "application/xml"
-                        {
-                            let text = String::from_utf8_lossy(&part.data);
-                            println!("{text}");
-                        } else if mime == "application/cbor" {
-                            let json_val = act_types::cbor::cbor_to_json(&part.data)
-                                .unwrap_or_else(|_| {
-                                    serde_json::Value::String(format!(
-                                        "[binary: {}, {} bytes]",
-                                        mime,
-                                        part.data.len()
-                                    ))
-                                });
-                            match json_val {
-                                serde_json::Value::String(s) => println!("{s}"),
-                                other => println!("{}", serde_json::to_string_pretty(&other)?),
-                            }
-                        } else if std::io::IsTerminal::is_terminal(&std::io::stdout()) {
-                            println!("[binary: {}, {} bytes]", mime, part.data.len());
-                        } else {
-                            use std::io::Write;
-                            std::io::stdout().write_all(&part.data)?;
-                        }
-                    }
-                    runtime::exports::act::tools::tool_provider::ToolEvent::Error(err) => {
-                        let ls = act_types::types::LocalizedString::from(&err.message);
-                        anyhow::bail!("{}: {}", err.kind, ls.any_text());
+    // Best-effort close before returning the call result, so the
+    // session is closed even if the call errored.
+    if let Some(id) = session_id {
+        close_session_best_effort(&pc, id).await;
+    }
+
+    let result = call_result?.map_err(|e| match e {
+        runtime::ComponentError::Tool(te) => {
+            let ls = act_types::types::LocalizedString::from(&te.message);
+            anyhow::anyhow!("{}: {}", te.kind, ls.any_text())
+        }
+        runtime::ComponentError::Internal(e) => e,
+    })?;
+
+    for event in &result.events {
+        match event {
+            runtime::exports::act::tools::tool_provider::ToolEvent::Content(part) => {
+                let mime = part.mime_type.as_deref().unwrap_or("application/cbor");
+                if mime.starts_with("text/")
+                    || mime == "application/json"
+                    || mime == "application/xml"
+                {
+                    let text = String::from_utf8_lossy(&part.data);
+                    println!("{text}");
+                } else if mime == "application/cbor" {
+                    let json_val = act_types::cbor::cbor_to_json(&part.data).unwrap_or_else(|_| {
+                        serde_json::Value::String(format!(
+                            "[binary: {}, {} bytes]",
+                            mime,
+                            part.data.len()
+                        ))
+                    });
+                    match json_val {
+                        serde_json::Value::String(s) => println!("{s}"),
+                        other => println!("{}", serde_json::to_string_pretty(&other)?),
                     }
+                } else if std::io::IsTerminal::is_terminal(&std::io::stdout()) {
+                    println!("[binary: {}, {} bytes]", mime, part.data.len());
+                } else {
+                    use std::io::Write;
+                    std::io::stdout().write_all(&part.data)?;
                 }
             }
-            Ok(())
-        }
-        Err(runtime::ComponentError::Tool(te)) => {
-            let ls = act_types::types::LocalizedString::from(&te.message);
-            anyhow::bail!("{}: {}", te.kind, ls.any_text());
-        }
-        Err(runtime::ComponentError::Internal(e)) => Err(e),
-    }
-}
-
-// ── Session subcommands ────────────────────────────────────────────────────
-
-async fn cmd_session_open_args_schema(component: ComponentRef, opts: CommonOpts) -> Result<()> {
-    let pc = prepare_component(&component, &opts).await?;
-    let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
-    pc.handle
-        .send(runtime::ComponentRequest::GetOpenSessionArgsSchema {
-            metadata: pc.metadata.clone().into(),
-            reply: reply_tx,
-        })
-        .await
-        .map_err(|_| anyhow::anyhow!("component actor unavailable"))?;
-    match reply_rx.await? {
-        Ok(schema) => {
-            // Pretty-print if it's valid JSON; otherwise print as-is.
-            match serde_json::from_str::<serde_json::Value>(&schema) {
-                Ok(v) => println!("{}", serde_json::to_string_pretty(&v)?),
-                Err(_) => println!("{schema}"),
+            runtime::exports::act::tools::tool_provider::ToolEvent::Error(err) => {
+                let ls = act_types::types::LocalizedString::from(&err.message);
+                anyhow::bail!("{}: {}", err.kind, ls.any_text());
             }
-            Ok(())
         }
-        Err(runtime::ComponentError::Tool(te)) => {
-            let ls = act_types::types::LocalizedString::from(&te.message);
-            anyhow::bail!("{}: {}", te.kind, ls.any_text());
-        }
-        Err(runtime::ComponentError::Internal(e)) => Err(e),
     }
+    Ok(())
 }
 
-async fn cmd_session_open(component: ComponentRef, args: String, opts: CommonOpts) -> Result<()> {
-    let pc = prepare_component(&component, &opts).await?;
-
-    // Args are a JSON object; convert to metadata-shaped (key, cbor) pairs.
-    let args_value: serde_json::Value =
-        serde_json::from_str(&args).context("invalid --args JSON")?;
-    let serde_json::Value::Object(args_obj) = args_value else {
-        anyhow::bail!("--args must be a JSON object");
+/// Marshal a JSON object of session args into the WIT shape and call
+/// `open-session` against the prepared component. Returns the
+/// allocated session-id.
+async fn open_session_for_call(pc: &PreparedComponent, json: &str) -> Result<String> {
+    let value: serde_json::Value =
+        serde_json::from_str(json).context("invalid --session-args JSON")?;
+    let serde_json::Value::Object(args_obj) = value else {
+        anyhow::bail!("--session-args must be a JSON object");
     };
     let mut wit_args: Vec<(String, Vec<u8>)> = Vec::with_capacity(args_obj.len());
     for (key, value) in args_obj {
-        let cbor = act_types::cbor::json_to_cbor(&value).context("encoding arg as CBOR")?;
-        wit_args.push((key, cbor));
+        let bytes =
+            act_types::cbor::json_to_cbor(&value).context("encoding session arg as CBOR")?;
+        wit_args.push((key, bytes));
     }
 
     let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
@@ -566,47 +559,58 @@ async fn cmd_session_open(component: ComponentRef, args: String, opts: CommonOpt
         .map_err(|_| anyhow::anyhow!("component actor unavailable"))?;
 
     match reply_rx.await? {
-        Ok(session) => {
-            // Re-emit metadata as JSON object for human consumption.
-            let metadata_json: serde_json::Map<String, serde_json::Value> = session
-                .metadata
-                .iter()
-                .filter_map(|(k, v)| {
-                    let val = act_types::cbor::cbor_to_json(v).ok()?;
-                    Some((k.clone(), val))
-                })
-                .collect();
-            let out = serde_json::json!({
-                "id": session.id,
-                "metadata": metadata_json,
-            });
-            println!("{}", serde_json::to_string_pretty(&out)?);
-            Ok(())
-        }
+        Ok(session) => Ok(session.id),
         Err(runtime::ComponentError::Tool(te)) => {
             let ls = act_types::types::LocalizedString::from(&te.message);
-            anyhow::bail!("{}: {}", te.kind, ls.any_text());
+            anyhow::bail!("open-session failed: {}: {}", te.kind, ls.any_text());
         }
-        Err(runtime::ComponentError::Internal(e)) => Err(e),
+        Err(runtime::ComponentError::Internal(e)) => Err(e.context("open-session failed")),
     }
 }
 
-async fn cmd_session_close(
-    component: ComponentRef,
-    session_id: String,
-    opts: CommonOpts,
-) -> Result<()> {
+/// Best-effort close. Logs failures at debug; never propagates errors,
+/// because the call result is what the user asked for and a failed
+/// close should not surface as the command's exit code.
+async fn close_session_best_effort(pc: &PreparedComponent, session_id: String) {
+    let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
+    if pc
+        .handle
+        .send(runtime::ComponentRequest::CloseSession {
+            session_id: session_id.clone(),
+            reply: reply_tx,
+        })
+        .await
+        .is_err()
+    {
+        tracing::debug!(%session_id, "actor unavailable for close-session");
+        return;
+    }
+    if let Err(e) = reply_rx.await {
+        tracing::debug!(%session_id, error = %e, "close-session reply dropped");
+    }
+}
+
+// ── Session subcommands ────────────────────────────────────────────────────
+
+async fn cmd_session_open_args_schema(component: ComponentRef, opts: CommonOpts) -> Result<()> {
     let pc = prepare_component(&component, &opts).await?;
     let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
     pc.handle
-        .send(runtime::ComponentRequest::CloseSession {
-            session_id,
+        .send(runtime::ComponentRequest::GetOpenSessionArgsSchema {
+            metadata: pc.metadata.clone().into(),
             reply: reply_tx,
         })
         .await
         .map_err(|_| anyhow::anyhow!("component actor unavailable"))?;
     match reply_rx.await? {
-        Ok(()) => Ok(()),
+        Ok(schema) => {
+            // Pretty-print if it's valid JSON; otherwise print as-is.
+            match serde_json::from_str::<serde_json::Value>(&schema) {
+                Ok(v) => println!("{}", serde_json::to_string_pretty(&v)?),
+                Err(_) => println!("{schema}"),
+            }
+            Ok(())
+        }
         Err(runtime::ComponentError::Tool(te)) => {
             let ls = act_types::types::LocalizedString::from(&te.message);
             anyhow::bail!("{}: {}", te.kind, ls.any_text());