robloxstudio-worktree 0.1.0

Own an isolated Rojo, Roblox Studio, and MCP runtime for each Git worktree
Documentation
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 {
    /// Run project setup and install the managed Rojo plugin.
    Bootstrap,
    /// Build a fresh worktree-local place artifact.
    Build {
        #[arg(long)]
        json: bool,
    },
    /// Start or reuse this worktree's Rojo and Studio processes.
    Up {
        #[arg(long)]
        fresh: bool,
        #[arg(long)]
        json: bool,
    },
    /// Run the project test hook against this exact Studio instance.
    #[command(trailing_var_arg = true)]
    Test {
        #[arg(long)]
        fresh: bool,
        #[arg(long)]
        close: bool,
        args: Vec<String>,
    },
    /// Show this worktree's owned processes.
    Status {
        #[arg(long)]
        json: bool,
    },
    /// Stop only this worktree's Studio and Rojo processes.
    Down,
    /// Stop the session and remove generated state.
    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);
        }
    }
}