dkp 0.1.1

dkp — Domain Knowledge Pack management CLI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

use anyhow::Result;
use clap::Args;
use std::path::PathBuf;

use dkp_core::Pack;

use crate::cli::CmdCtx;

#[derive(Args, Debug)]
pub struct RunArgs {
    /// Path to the DKP bundle directory
    pub pack: PathBuf,

    /// Procedure ID (stem name without extension, e.g. "macro-calc")
    pub procedure: String,

    /// JSON object to pass as stdin to the procedure (default: {})
    #[arg(long, value_name = "JSON")]
    pub input: Option<String>,

    /// Override the wall-clock timeout in milliseconds
    #[arg(long, value_name = "MS")]
    pub timeout_ms: Option<u64>,

    /// Allow running non-WASM procedures from unsigned bundles (dev/testing only)
    #[arg(long)]
    pub allow_unsigned: bool,
}

pub async fn run(args: RunArgs, _ctx: &CmdCtx) -> Result<()> {
    let pack = Pack::open(&args.pack)?;

    #[cfg(not(feature = "procedures"))]
    {
        let _ = (args, pack);
        anyhow::bail!(
            "procedure execution requires the 'procedures' feature (enabled by default in dkp)"
        );
    }

    #[cfg(feature = "procedures")]
    {
        use dkp_core::procedures;

        let defs = procedures::list(&pack)?;
        let def = defs
            .into_iter()
            .find(|d| d.id == args.procedure)
            .ok_or_else(|| dkp_core::DkpError::ProcedureNotFound {
                id: args.procedure.clone(),
                pack: pack.manifest.name.clone(),
            })?;

        let input: serde_json::Value = match &args.input {
            Some(s) => serde_json::from_str(s)
                .map_err(|e| anyhow::anyhow!("--input is not valid JSON: {e}"))?,
            None => serde_json::Value::Object(Default::default()),
        };

        let opts = procedures::executor::RunOptions {
            input,
            timeout_ms: args.timeout_ms,
            allow_unsigned: args.allow_unsigned,
        };

        let result =
            tokio::task::spawn_blocking(move || procedures::executor::run(&pack, &def, opts))
                .await
                .map_err(|e| anyhow::anyhow!("procedure task panicked: {e}"))??;

        println!("{}", serde_json::to_string_pretty(&result)?);

        Ok(())
    }
}