slave 0.8.1

CLI for slave, a Laravel-inspired Rust framework for MCP-first apps: scaffold an MCP backend with auth, roles and Toasty models and migrations, add server-rendered web apps, and route them by domain or path
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//! `slave new <name>`: scaffold a new domain-based application.

use std::fs;
use std::path::Path;

use anyhow::{Context, Result, bail};

use crate::cli::NewArgs;
use crate::{gateway, generator, naming, templates, timestamp};

pub fn run(args: &NewArgs) -> Result<()> {
    let name = args.name.as_str();
    naming::validate_project_name(name)?;
    let framework_dependency = framework_dependency(args.framework_path.as_deref())?;

    let target = std::env::current_dir()
        .context("failed to read the current directory")?
        .join(name);
    if target.exists() {
        bail!("destination `{}` already exists", target.display());
    }

    fs::create_dir(&target)
        .with_context(|| format!("failed to create directory {}", target.display()))?;

    let created = scaffold(&target, name, &framework_dependency).and_then(|()| {
        if args.gateway {
            gateway::install(&target)?;
        }
        Ok(())
    });
    if let Err(err) = created {
        // Only remove what we just created; the directory did not exist before.
        let _ = fs::remove_dir_all(&target);
        return Err(err);
    }

    println!("\nApplication `{name}` created successfully.\n");
    println!("AI coding agents: see {name}/AGENTS.md (CLAUDE.md imports it).\n");
    println!("Next steps:");
    println!("  cd {name}");
    println!(
        "  # sign-in: set OIDC_ISSUER_URL and OIDC_AUDIENCES in .env (any OpenID Connect provider)"
    );
    println!("  slave migrate      # create database/database.db with the users and roles tables");
    println!("  slave build        # compile (first build takes a while; later ones are fast)");
    println!("  slave serve        # MCP backend: http://127.0.0.1:3000/mcp");
    println!("                     # sign in at your provider; the first user becomes admin");
    if !args.gateway {
        println!("\nWeb apps: `slave make:app <name>` (direct port), or with --domain/--path");
        println!("to route them through the gateway (installed on demand).");
    }
    Ok(())
}

fn scaffold(target: &Path, name: &str, framework: &str) -> Result<()> {
    // The initial Toasty migration is named like `toasty-cli` names them.
    let migration_ts = timestamp::toasty_prefix_now()?;
    let crate_name = name.replace('-', "_");
    let vars = [
        ("name", name),
        ("crate_name", crate_name.as_str()),
        ("slave_version", env!("CARGO_PKG_VERSION")),
        ("framework_dependency", framework),
        ("migration_ts", migration_ts.as_str()),
    ];
    for file in templates::PROJECT {
        let path = templates::render(file.path, &vars);
        let contents = templates::render(file.contents, &vars);
        generator::write_file(&target.join(&path), &contents, false)?;
        println!("  created {name}/{path}");
    }

    // Like Laravel, start with a working .env copied from the example.
    let env_example = templates::PROJECT
        .iter()
        .find(|file| file.path == ".env.example")
        .map(|file| templates::render(file.contents, &vars))
        .unwrap_or_default();
    generator::write_file(&target.join(".env"), &env_example, false)?;
    println!("  created {name}/.env");
    Ok(())
}

/// Returns the `slave-framework` line for the generated workspace dependencies.
///
/// Default features are off at the workspace level so web apps stay light;
/// the backend package turns `auth` and `database` back on.
fn framework_dependency(local_path: Option<&Path>) -> Result<String> {
    match local_path {
        None => Ok(format!(
            "slave-framework = {{ version = \"{}\", default-features = false }}",
            templates::FRAMEWORK_VERSION
        )),
        Some(path) => {
            let path = local_crate(path, "slave-framework")?;
            Ok(format!(
                "slave-framework = {{ path = \"{path}\", default-features = false }}"
            ))
        }
    }
}

/// Canonicalizes `path`, checks it holds crate `name`, and escapes it for TOML.
pub(crate) fn local_crate(path: &Path, name: &str) -> Result<String> {
    let path = path
        .canonicalize()
        .with_context(|| format!("path {} does not exist", path.display()))?;
    let manifest = fs::read_to_string(path.join("Cargo.toml")).unwrap_or_default();
    if !manifest.contains(&format!("name = \"{name}\"")) {
        bail!("{} does not contain the {name} crate", path.display());
    }
    Ok(path
        .to_string_lossy()
        .replace('\\', "\\\\")
        .replace('"', "\\\""))
}