use crate::launch::LaunchRuntime;
use std::env;
use std::path::{Path, PathBuf};
use std::time::Duration;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CliOptions {
pub state_root: Option<PathBuf>,
pub command_deck: Option<PathBuf>,
pub launch_root: Option<PathBuf>,
pub launch_runtime: Option<LaunchRuntime>,
pub terminal_binary: Option<PathBuf>,
pub tick_ms: u64,
pub no_verify_gate: bool,
}
impl Default for CliOptions {
fn default() -> Self {
Self {
state_root: None,
command_deck: None,
launch_root: None,
launch_runtime: None,
terminal_binary: None,
tick_ms: 250,
no_verify_gate: false,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AppConfig {
pub state_root: PathBuf,
pub command_deck: PathBuf,
pub launch_root: PathBuf,
pub launch_runtime: LaunchRuntime,
pub terminal_binary: PathBuf,
pub tick_rate: Duration,
pub no_verify_gate: bool,
}
pub fn parse_args() -> anyhow::Result<CliOptions> {
let mut options = CliOptions::default();
let mut args = env::args().skip(1);
while let Some(arg) = args.next() {
match arg.as_str() {
"--help" | "-h" => {
print_help();
std::process::exit(0);
}
"--state-root" => {
let value = args
.next()
.ok_or_else(|| anyhow::anyhow!("--state-root requires a value"))?;
options.state_root = Some(PathBuf::from(value));
}
_ if arg.starts_with("--state-root=") => {
options.state_root = Some(PathBuf::from(arg.trim_start_matches("--state-root=")));
}
"--deck" | "--command-deck" => {
let value = args
.next()
.ok_or_else(|| anyhow::anyhow!("--deck requires a value"))?;
options.command_deck = Some(PathBuf::from(value));
}
_ if arg.starts_with("--deck=") || arg.starts_with("--command-deck=") => {
let value = arg
.split_once('=')
.map(|(_, value)| value)
.unwrap_or_default();
options.command_deck = Some(PathBuf::from(value));
}
"--root" => {
let value = args
.next()
.ok_or_else(|| anyhow::anyhow!("--root requires a value"))?;
options.launch_root = Some(PathBuf::from(value));
}
_ if arg.starts_with("--root=") => {
options.launch_root = Some(PathBuf::from(arg.trim_start_matches("--root=")));
}
"--runtime" => {
let value = args
.next()
.ok_or_else(|| anyhow::anyhow!("--runtime requires a value"))?;
options.launch_runtime = Some(value.parse::<LaunchRuntime>()?);
}
_ if arg.starts_with("--runtime=") => {
let value = arg
.split_once('=')
.map(|(_, value)| value)
.unwrap_or_default();
options.launch_runtime = Some(value.parse::<LaunchRuntime>()?);
}
"--terminal-binary" | "--zellij" => {
let value = args
.next()
.ok_or_else(|| anyhow::anyhow!("--terminal-binary requires a value"))?;
options.terminal_binary = Some(PathBuf::from(value));
}
_ if arg.starts_with("--terminal-binary=") || arg.starts_with("--zellij=") => {
let value = arg
.split_once('=')
.map(|(_, value)| value)
.unwrap_or_default();
options.terminal_binary = Some(PathBuf::from(value));
}
"--tick-ms" => {
let value = args
.next()
.ok_or_else(|| anyhow::anyhow!("--tick-ms requires a value"))?;
options.tick_ms = value.parse::<u64>()?;
}
"--no-verify-gate" => {
options.no_verify_gate = true;
}
_ => {
return Err(anyhow::anyhow!("unknown argument: {arg}"));
}
}
}
Ok(options)
}
pub fn build_config(options: CliOptions) -> AppConfig {
let command_deck = options.command_deck.unwrap_or_else(default_command_deck);
AppConfig {
state_root: options.state_root.unwrap_or_else(default_state_root),
launch_root: options
.launch_root
.unwrap_or_else(|| default_launch_root(&command_deck)),
launch_runtime: options.launch_runtime.unwrap_or_default(),
terminal_binary: options
.terminal_binary
.unwrap_or_else(default_terminal_binary),
command_deck,
tick_rate: Duration::from_millis(options.tick_ms.max(50)),
no_verify_gate: options.no_verify_gate,
}
}
pub fn default_vibecrafted_home() -> PathBuf {
env::var_os("VIBECRAFTED_HOME")
.filter(|value| !value.is_empty())
.map(PathBuf::from)
.unwrap_or_else(|| PathBuf::from(home_dir()).join(".vibecrafted"))
}
pub fn default_state_root() -> PathBuf {
let home = default_vibecrafted_home();
for candidate in [
home.join("control_plane"),
home.join("state/control-plane"),
home.join("state"),
home.join("control-plane"),
] {
if candidate.exists() {
return candidate;
}
}
home.join("control_plane")
}
pub fn default_command_deck() -> PathBuf {
let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let repo_candidate = manifest_dir.join("../scripts/vibecrafted");
if repo_candidate.exists() {
return repo_candidate;
}
PathBuf::from("vibecrafted")
}
pub fn default_terminal_binary() -> PathBuf {
env::var_os("VIBECRAFTED_TERMINAL_BINARY")
.filter(|value| !value.is_empty())
.map(PathBuf::from)
.unwrap_or_else(|| PathBuf::from("zellij"))
}
pub fn default_launch_root(command_deck: &Path) -> PathBuf {
if let Some(value) = env::var_os("VIBECRAFTED_ROOT").filter(|value| !value.is_empty()) {
return PathBuf::from(value);
}
if command_deck.file_name().and_then(|name| name.to_str()) == Some("vibecrafted")
&& command_deck
.parent()
.and_then(|parent| parent.file_name())
.and_then(|name| name.to_str())
== Some("scripts")
&& let Some(root) = command_deck.parent().and_then(Path::parent)
{
return root.to_path_buf();
}
env::current_dir().unwrap_or_else(|_| PathBuf::from("."))
}
fn home_dir() -> String {
env::var("HOME").unwrap_or_else(|_| ".".to_string())
}
fn print_help() {
println!("Voc Agent");
println!();
println!("Usage:");
println!(
" voc [--state-root <dir>] [--deck <path>] [--root <path>] [--runtime <headless|terminal|visible>] [--tick-ms <ms>]"
);
println!();
println!("Options:");
println!(" --state-root <dir> Control-plane state root under VIBECRAFTED_HOME");
println!(" --deck <path> Command deck binary or script to launch workflows");
println!(" --root <path> Workspace root passed through to launched workflows");
println!(" --runtime <kind> Launch runtime (headless|terminal|visible)");
println!(" --terminal-binary <path> Terminal multiplexer binary (default: zellij)");
println!(" --tick-ms <ms> Refresh cadence for the TUI (default: 250)");
}
pub fn path_display(path: &Path) -> String {
path.to_string_lossy().into_owned()
}