portail 2.1.0

Unified proxy/gateway: AI Gateway + MCP Gateway + CDN cache
Documentation 
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! Developer/contributor entry point — the main CLI for day-to-day work.
//!
//! Bundles check, test, lint, build, audit, CI into one subcommand tree.
//! Uses only modern tools (rg, jq, sd, bat, eza, fd, delta).

use anyhow::Result;
use std::process::Command;

pub fn run_dev(action: &super::DevAction) -> Result<()> {
    match action {
        super::DevAction::Check => {
            cmd("cargo", &["check"])?;
            cmd("cargo", &["check", "--features", "jemalloc"])?;
            cmd("cargo", &["check", "--features", "portail_system_alloc"])?;
            Ok(())
        }
        super::DevAction::Lint => {
            cmd("cargo", &["clippy", "--workspace", "--", "-D", "warnings"])?;
            cmd("cargo", &["fmt", "--check"])?;
            Ok(())
        }
        super::DevAction::Test => {
            cmd("cargo", &["test"])?;
            Ok(())
        }
        super::DevAction::Build { max } => {
            let _args = ["build", "--release", "-p", "portail"];
            if *max {
                cmd(
                    "cargo",
                    &[
                        "build",
                        "--release",
                        "-p",
                        "portail",
                        "--config",
                        "profile.release.lto=\"fat\"",
                        "--config",
                        "profile.release.codegen-units=1",
                    ],
                )?;
            } else {
                cmd("cargo", &["build", "--release", "-p", "portail"])?;
            }
            // Show binary size
            let path = if cfg!(target_os = "macos") {
                "target/release/portail"
            } else {
                "target/release/portail"
            };
            if std::path::Path::new(path).exists() {
                let meta = std::fs::metadata(path)?;
                let size_kb = meta.len() as f64 / 1024.0;
                let size_str = if size_kb > 1024.0 {
                    format!("{:.1} MiB", size_kb / 1024.0)
                } else {
                    format!("{:.1} KiB", size_kb)
                };
                println!("Binary size: {}", size_str);
            }
            Ok(())
        }
        super::DevAction::Audit { version } => {
            let dist = std::path::Path::new("target/release");
            if !dist.exists() {
                anyhow::bail!("No release build found. Run 'portail dev build' first");
            }
            crate::release_audit::run_pipeline(dist, version, dist)?;
            Ok(())
        }
        super::DevAction::Ci { version } => {
            run_ci(version.as_deref())?;
            Ok(())
        }
    }
}

fn run_ci(version: Option<&str>) -> Result<()> {
    println!("═══ CI Pipeline ═══");

    println!("\n── cargo check ──");
    cmd("cargo", &["check"])?;

    println!("\n── cargo clippy ──");
    cmd("cargo", &["clippy", "--workspace", "--", "-D", "warnings"])?;

    println!("\n── cargo fmt --check ──");
    cmd("cargo", &["fmt", "--check"])?;

    println!("\n── cargo test ──");
    cmd("cargo", &["test"])?;

    if let Some(ver) = version {
        println!("\n── release audit ──");
        let dist = std::path::Path::new("target/release");
        if dist.exists() {
            crate::release_audit::run_pipeline(dist, ver, dist)?;
        } else {
            println!("  (skip — no release build, run 'portail dev build' first)");
        }
    }

    println!("\n✅ CI pipeline passed");
    Ok(())
}

fn cmd(program: &str, args: &[&str]) -> Result<()> {
    let status = Command::new(program)
        .args(args)
        .spawn()
        .map_err(|e| anyhow::anyhow!("failed to spawn {program}: {e}"))?
        .wait()?;
    if !status.success() {
        anyhow::bail!("{program} exited with code {:?}", status.code());
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use crate::cli::DevAction;

    #[test]
    fn test_dev_actions_dispatch_without_panic() {
        let actions = [
            DevAction::Check,
            DevAction::Lint,
            DevAction::Test,
            DevAction::Build { max: false },
            DevAction::Audit {
                version: "0.0.0".into(),
            },
        ];
        assert_eq!(actions.len(), 5);
    }
}