261 lines
10 KiB
Rust
261 lines
10 KiB
Rust
use clap::command;
|
|
use icepick_module::help::*;
|
|
use serde::{Deserialize, Serialize};
|
|
use std::{
|
|
io::{IsTerminal, Write},
|
|
process::{Command, Stdio},
|
|
};
|
|
|
|
mod workflow;
|
|
|
|
pub fn get_command(bin_name: &str) -> (&str, Vec<&str>) {
|
|
if std::env::vars().any(|(k, _)| &k == "ICEPICK_USE_CARGO") {
|
|
("cargo", vec!["run", "-q", "--bin", bin_name, "--"])
|
|
} else {
|
|
(bin_name, vec![])
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug)]
|
|
struct ModuleConfig {
|
|
name: String,
|
|
command_name: Option<String>,
|
|
algorithm: keyfork_derive_util::request::DerivationAlgorithm,
|
|
|
|
#[serde(with = "serde_derivation")]
|
|
derivation_prefix: keyfork_derive_util::DerivationPath,
|
|
|
|
#[serde(rename = "workflow", default)]
|
|
workflows: Vec<workflow::Workflow>,
|
|
}
|
|
|
|
mod serde_derivation {
|
|
use keyfork_derive_util::DerivationPath;
|
|
use serde::{Deserialize, Deserializer, Serializer};
|
|
use std::str::FromStr;
|
|
|
|
pub fn serialize<S>(p: &DerivationPath, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: Serializer,
|
|
{
|
|
let path = p.to_string();
|
|
serializer.serialize_str(&path)
|
|
}
|
|
|
|
pub fn deserialize<'de, D>(deserializer: D) -> Result<DerivationPath, D::Error>
|
|
where
|
|
D: Deserializer<'de>,
|
|
{
|
|
use serde::de::Error;
|
|
String::deserialize(deserializer)
|
|
.and_then(|string| DerivationPath::from_str(&string).map_err(Error::custom))
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug, Default)]
|
|
struct Config {
|
|
#[serde(rename = "module")]
|
|
modules: Vec<ModuleConfig>,
|
|
}
|
|
|
|
pub fn do_cli_thing() {
|
|
/* parse config file to get module names */
|
|
let config_file = std::env::vars().find_map(|(k, v)| {
|
|
if k == "ICEPICK_CONFIG_FILE" {
|
|
return Some(v);
|
|
}
|
|
None
|
|
});
|
|
let config_path = config_file.unwrap_or_else(|| "icepick.toml".to_string());
|
|
let config_content = std::fs::read_to_string(config_path).expect("can't read config file");
|
|
let config: Config = toml::from_str(&config_content).expect("config file had invalid toml");
|
|
|
|
let mut commands = vec![];
|
|
let mut icepick_command = command!();
|
|
// NOTE: this needs to be .cloned(), since commands is leaked to be 'static
|
|
// and coin_bin otherwise wouldn't live long enough
|
|
for module in &config.modules {
|
|
let module_name = &module.name;
|
|
let bin = module
|
|
.command_name
|
|
.clone()
|
|
.unwrap_or_else(|| format!("icepick-{module_name}"));
|
|
let (command, args) = get_command(&bin);
|
|
let mut child = Command::new(command)
|
|
.args(args)
|
|
.stdin(Stdio::piped())
|
|
.stdout(Stdio::piped())
|
|
.spawn()
|
|
.unwrap();
|
|
let mut input = child.stdin.take().unwrap();
|
|
input
|
|
.write_all("{\"operation\": \"help\"}\n".as_bytes())
|
|
.unwrap();
|
|
input
|
|
.write_all("{\"operation\": \"exit\"}\n".as_bytes())
|
|
.unwrap();
|
|
let output = child.wait_with_output().unwrap().stdout;
|
|
let operations: Vec<Operation> = serde_json::from_slice::<Vec<Operation>>(&output)
|
|
.expect("successful deserialization of operation");
|
|
commands.push((module_name.clone(), bin, operations));
|
|
}
|
|
|
|
let mut workflows = vec![];
|
|
for module in &config.modules {
|
|
workflows.push((module.name.clone(), module.workflows.clone()));
|
|
}
|
|
let workflows = workflows.leak();
|
|
let mut workflow_command =
|
|
clap::Command::new("workflow").about("Run a pre-defined Icepick workflow");
|
|
for module in workflows.iter() {
|
|
let mut module_subcommand = clap::Command::new(module.0.as_str());
|
|
for workflow in &module.1 {
|
|
module_subcommand = module_subcommand.subcommand(workflow.generate_command());
|
|
}
|
|
workflow_command = workflow_command.subcommand(module_subcommand);
|
|
}
|
|
|
|
icepick_command = icepick_command.subcommand(workflow_command);
|
|
|
|
let commands = commands.leak();
|
|
for command in commands.iter() {
|
|
let mut subcommand = clap::Command::new(command.0.as_str());
|
|
for op in &command.2 {
|
|
let mut op_command = clap::Command::new(&op.name).about(&op.description);
|
|
for arg in &op.arguments {
|
|
let mut op_arg = clap::Arg::new(&arg.name).help(arg.description.as_str());
|
|
op_arg = match arg.r#type {
|
|
ArgumentType::Required => op_arg.required(true),
|
|
ArgumentType::Optional => op_arg.required(false).long(&arg.name),
|
|
};
|
|
op_command = op_command.arg(op_arg);
|
|
}
|
|
subcommand = subcommand.subcommand(op_command);
|
|
}
|
|
icepick_command = icepick_command.subcommand(subcommand);
|
|
}
|
|
|
|
let stdin = std::io::stdin();
|
|
let mut cli_input: Option<serde_json::Value> = None;
|
|
// HACK: Allow good UX when running from CLI without piping in a blob.
|
|
// This is because we have CLI arguments _only_ for the module. We _could_ add a global
|
|
// argument `--input` instead of reading input.
|
|
if !stdin.is_terminal() {
|
|
cli_input = serde_json::from_reader(stdin).ok();
|
|
}
|
|
let blob = cli_input.as_ref().and_then(|json| json.get("blob"));
|
|
|
|
let derivation_accounts = cli_input
|
|
.as_ref()
|
|
.and_then(|json| json.get("derivation_accounts"));
|
|
|
|
let matches = icepick_command.get_matches();
|
|
if let Some((module, matches)) = matches.subcommand() {
|
|
if let Some((subcommand, matches)) = matches.subcommand() {
|
|
if let Some(operation) = commands
|
|
.iter()
|
|
.find(|(name, ..)| *name == module)
|
|
.and_then(|(.., operations)| operations.iter().find(|o| o.name == subcommand))
|
|
{
|
|
let mut args = std::collections::HashMap::<String, Option<&String>>::with_capacity(
|
|
operation.arguments.len(),
|
|
);
|
|
for arg in &operation.arguments {
|
|
args.insert(
|
|
arg.name.replace('-', "_"),
|
|
matches.get_one::<String>(&arg.name),
|
|
);
|
|
}
|
|
|
|
let (algo, path) = config
|
|
.modules
|
|
.iter()
|
|
.find_map(|fmodule| {
|
|
if fmodule.name == module {
|
|
return Some((
|
|
fmodule.algorithm.clone(),
|
|
fmodule.derivation_prefix.clone(),
|
|
));
|
|
}
|
|
None
|
|
})
|
|
.unwrap();
|
|
|
|
let mut derived_keys: Vec<Vec<u8>> = vec![];
|
|
if let Some(accounts) = derivation_accounts {
|
|
let accounts: Vec<keyfork_derive_util::DerivationIndex> =
|
|
serde_json::from_value(accounts.clone())
|
|
.expect("valid derivation_accounts");
|
|
let mut client =
|
|
keyforkd_client::Client::discover_socket().expect("keyforkd started");
|
|
for account in accounts {
|
|
let request = keyfork_derive_util::request::DerivationRequest::new(
|
|
algo.clone(),
|
|
&path.clone().chain_push(account),
|
|
);
|
|
let request = keyforkd_models::Request::Derivation(request);
|
|
let response = client.request(&request).expect("valid derivation");
|
|
match response {
|
|
keyforkd_models::Response::Derivation(
|
|
keyfork_derive_util::request::DerivationResponse { data, .. },
|
|
) => {
|
|
derived_keys.push(data.to_vec());
|
|
}
|
|
_ => panic!("Unexpected response"),
|
|
}
|
|
}
|
|
}
|
|
|
|
// in the event this is not PascalCase, this would be false.
|
|
// we set this to true to capitalize the first character.
|
|
let mut last_char_was_dash = true;
|
|
let subcommand = subcommand
|
|
.chars()
|
|
.filter_map(|c| {
|
|
if last_char_was_dash {
|
|
last_char_was_dash = false;
|
|
return Some(c.to_ascii_uppercase());
|
|
}
|
|
if c == '-' {
|
|
last_char_was_dash = true;
|
|
None
|
|
} else {
|
|
Some(c)
|
|
}
|
|
})
|
|
.collect::<String>();
|
|
let json = serde_json::json!({
|
|
"operation": subcommand,
|
|
"values": args,
|
|
"derived_keys": derived_keys,
|
|
"blob": blob,
|
|
});
|
|
let bin = commands
|
|
.iter()
|
|
.find_map(|(fmodule, fcommand, _)| {
|
|
if fmodule == module {
|
|
Some(fcommand)
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.expect("previously found module should exist in new search");
|
|
let (command, args) = get_command(bin);
|
|
let mut child = Command::new(command)
|
|
.args(args)
|
|
.stdin(Stdio::piped())
|
|
.stdout(Stdio::piped())
|
|
.spawn()
|
|
.unwrap();
|
|
let mut input = child.stdin.take().unwrap();
|
|
serde_json::to_writer(&mut input, &json).unwrap();
|
|
input.write_all(b"\n{\"operation\": \"exit\"}\n").unwrap();
|
|
let output = child.wait_with_output().unwrap().stdout;
|
|
let json: serde_json::Value = serde_json::from_slice(&output).expect("valid json");
|
|
let json_as_str = serde_json::to_string(&json).unwrap();
|
|
println!("{json_as_str}");
|
|
}
|
|
}
|
|
}
|
|
}
|