use std::path::PathBuf;
use anyhow::Result;
use clap::{Parser, Subcommand};
use robloxstudio_worktree::config::load_project_config;
use robloxstudio_worktree::mcp::{DEFAULT_MCP_URL, McpClient};
use robloxstudio_worktree::session::StudioSession;
#[derive(Debug, Parser)]
#[command(
name = "robloxstudio-worktree",
version,
about = "Own an isolated Rojo, Roblox Studio, and MCP runtime for the current Git worktree."
)]
struct Cli {
#[arg(long, global = true)]
config: Option<PathBuf>,
#[arg(long, global = true)]
root: Option<PathBuf>,
#[arg(
long,
global = true,
env = "ROBLOX_STUDIO_MCP_URL",
default_value = DEFAULT_MCP_URL
)]
mcp_url: String,
#[command(subcommand)]
command: Commands,
}
#[derive(Debug, Subcommand)]
enum Commands {
Bootstrap,
Build {
#[arg(long)]
json: bool,
},
Up {
#[arg(long)]
fresh: bool,
#[arg(long)]
json: bool,
},
#[command(trailing_var_arg = true)]
Test {
#[arg(long)]
fresh: bool,
#[arg(long)]
close: bool,
args: Vec<String>,
},
Status {
#[arg(long)]
json: bool,
},
Down,
Clean,
}
fn run() -> Result<i32> {
let cli = Cli::parse();
let config = load_project_config(cli.root.as_deref(), cli.config.as_deref())?;
let session = StudioSession::new(config, McpClient::new(&cli.mcp_url)?);
if matches!(cli.command, Commands::Bootstrap) {
session.bootstrap()?;
println!(
"Worktree bootstrap complete. Restart open Studio windows before robloxstudio-worktree up."
);
return Ok(0);
}
if matches!(cli.command, Commands::Clean) {
let lock = session.operation_lock()?;
session.down()?;
drop(lock);
session.remove_generated_state()?;
return Ok(0);
}
let _lock = session.operation_lock()?;
match cli.command {
Commands::Bootstrap | Commands::Clean => unreachable!(),
Commands::Build { json } => {
let state = session.build()?;
if json {
println!(
"{}",
serde_json::to_string_pretty(&serde_json::json!({
"artifact": session.paths.artifact,
"digest": state.artifact_digest,
"port": state.port,
}))?
);
} else {
let digest = state.artifact_digest.as_deref().unwrap_or_default();
println!(
"Built {} ({})",
session.paths.artifact.display(),
&digest[..digest.len().min(12)]
);
}
Ok(0)
}
Commands::Up { fresh, json } => {
let state = session.ensure_up(fresh)?;
if json {
println!(
"{}",
serde_json::to_string_pretty(&serde_json::json!({
"instance_id": state.instance_id,
"project_name": state.project_name,
"rojo_port": state.port,
}))?
);
} else {
println!(
"Studio {} <- {} on Rojo {}",
state.instance_id.as_deref().unwrap_or_default(),
state.project_name.as_deref().unwrap_or_default(),
state.port.unwrap_or_default()
);
}
Ok(0)
}
Commands::Test {
fresh,
close,
mut args,
} => {
if args.first().is_some_and(|arg| arg == "--") {
args.remove(0);
}
let result = (|| {
let state = session.ensure_up(fresh)?;
session.run_test_hook(&state, &args)
})();
let close_result = if close {
session.down().map(|_| ())
} else {
Ok(())
};
match (result, close_result) {
(Ok(code), Ok(())) => Ok(code),
(Err(error), Ok(())) | (Ok(_), Err(error)) => Err(error),
(Err(error), Err(close_error)) => {
Err(error.context(format!("test teardown also failed: {close_error:#}")))
}
}
}
Commands::Status { json } => {
let status = session.status()?;
if json {
println!("{}", serde_json::to_string_pretty(&status)?);
} else if let Some(object) = status.as_object() {
for (key, value) in object {
println!("{key}: {}", display_json(value));
}
}
Ok(0)
}
Commands::Down => {
let state = session.down()?;
println!(
"Stopped Studio and Rojo for {}",
state.worktree_id.unwrap_or_else(|| session.identity())
);
Ok(0)
}
}
}
fn display_json(value: &serde_json::Value) -> String {
match value {
serde_json::Value::String(value) => value.clone(),
serde_json::Value::Null => "None".into(),
value => value.to_string(),
}
}
fn main() {
match run() {
Ok(code) => std::process::exit(code),
Err(error) => {
eprintln!("studio session failed: {error:#}");
std::process::exit(1);
}
}
}