twitchyliquid64 · May 25, 2026 · May 24, 2026 · coderabbitai · May 24, 2026 · coderabbitai
@@ -15,6 +15,8 @@ members = [
     "crates/ot",
     "crates/orchestrator",
     "crates/minimal",
+    "crates/minimal2",
+    "crates/minimald",
     "crates/remote-client",
     "crates/remote-proto",
     "crates/sandbox2",
@@ -73,6 +75,7 @@ prost = "0.14"
 prost-build = "0.14"
 prost-types = "0.14"
 resolv-conf = "0.7"
+russh = "0.61"
 serde_json = { version = "1.0" }
 serial_test = "3"
 sha2 = "0.11"

@@ -0,0 +1,18 @@
+[package]
+name = "minimal2"
+version = "0.0.1"
+edition.workspace = true
+publish.workspace = true
+
+[dependencies]
+clap.workspace = true
+clap_complete.workspace = true
+dirs.workspace = true
+futures.workspace = true
+
+tokio.workspace = true
+tokio-util.workspace = true
+tracing.workspace = true
+tracing-subscriber.workspace = true
+
+ot.workspace = true
@@ -0,0 +1,26 @@
+use std::process::Command;
+fn main() {
+    let output = Command::new("git")
+        .args(["rev-parse", "--short", "HEAD"])
+        .output()
+        .unwrap();
+    let git_hash = String::from_utf8(output.stdout).unwrap();
+    println!("cargo:rustc-env=GIT_HASH={}", git_hash);
+
+    let is_clean = std::process::Command::new("git")
+        .args(["status", "--porcelain=v1"])
+        .output()
+        .map(|o| o.stdout.is_empty())
+        .unwrap_or(false);
-    let is_clean = std::process::Command::new("git")
-        .args(["status", "--porcelain=v1"])
-        .output()
-        .map(|o| o.stdout.is_empty())
-        .unwrap_or(false);
+    let is_clean = std::process::Command::new("git")
+        .args(["status", "--porcelain=v1"])
+        .output()
+        .map(|o| o.status.success() && o.stdout.is_empty())
+        .unwrap_or(false);
-    let is_clean = std::process::Command::new("git")
-        .args(["status", "--porcelain=v1"])
-        .output()
-        .map(|o| o.stdout.is_empty())
-        .unwrap_or(false);
+    let is_clean = std::process::Command::new("git")
+        .args(["status", "--porcelain=v1"])
+        .output()
+        .map(|o| o.status.success() && o.stdout.is_empty())
+        .unwrap_or(false);
+    if !is_clean && std::env::var("PROFILE").unwrap() == "release" {
+        println!("cargo::warning=Building a release binary from an unclean working tree!!");
+        println!("cargo::warning=Always build production binaries from a clean checkout.");
+    }
+
+    println!(
+        "cargo:rustc-env=LONG_VERSION={} ({}{})",
+        std::env::var("CARGO_PKG_VERSION").unwrap().as_str(),
+        if is_clean { "" } else { "dirty " },
+        git_hash.strip_suffix("\n").unwrap(),
+    );
+}
@@ -0,0 +1,66 @@
+//! The minimal CLI which pairs/talks-with minimald.
+
+use clap::{Args, CommandFactory, Parser, Subcommand};
+use clap_complete::Shell;
+use std::path::PathBuf;
+use tracing_subscriber::{EnvFilter, fmt, prelude::*};
+
+#[derive(Parser)]
+#[command(name = "minimal", version = env!("CARGO_PKG_VERSION"), long_version = env!("LONG_VERSION"))]
+#[command(about = "The Minimal CLI")]
+struct Cli {
+    #[command(subcommand)]
+    command: Command,
+
+    #[command(flatten)]
+    global_args: GlobalArgs,
+}
+
+#[derive(Subcommand)]
+enum Command {
+    /// Generate shell completion script
+    #[command(
+        long_about = "Generate a shell tab-completion script for the minimal CLI.\nSupported shells include bash, zsh, elvish and fish.\n\n   source <(minimal completions bash)"
+    )]
+    Completions(CompletionsArgs),
+}
+
+#[derive(Debug, clap::Args)]
+struct CompletionsArgs {
+    /// The shell type for a CLI completion script should be printed
+    #[arg(value_parser)]
+    shell: Shell,
+}
+
+/// Shared arguments all subcommands
+#[derive(Debug, Args)]
+pub struct GlobalArgs {
+    /// Override the base directory used for operations (default: ~/.cache/minimal)
+    #[arg(long)]
+    minimal_dir: Option<PathBuf>,
+}
+
+#[tokio::main]
+async fn main() -> Result<(), ()> {
-async fn main() -> Result<(), ()> {
+use anyhow::Result;
+
+async fn main() -> Result<()> {
-async fn main() -> Result<(), ()> {
+use anyhow::Result;
+
+async fn main() -> Result<()> {
+    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| {
+        EnvFilter::new("info")
+            .add_directive("topiary=off".parse().unwrap())
+            .add_directive("libcgroups=off".parse().unwrap())
+    });
+
+    tracing_subscriber::registry()
+        .with(fmt::layer().with_writer(ot::StdoutWriter::new))
+        .with(filter)
+        .init();
+
+    let cli = Cli::parse();
+
+    match cli.command {
+        Command::Completions(CompletionsArgs { shell }) => {
+            let mut cmd = Cli::command();
+            let name = cmd.get_name().to_string();
+            clap_complete::generate(shell, &mut cmd, name, &mut std::io::stdout());
+            Ok(())
+        }
+    }
+}
@@ -0,0 +1,20 @@
+[package]
+name = "minimald"
+version = "0.0.1"
+edition.workspace = true
+publish.workspace = true
+
+[dependencies]
+clap.workspace = true
+clap_complete.workspace = true
+dirs.workspace = true
+futures.workspace = true
+
+russh.workspace = true
+serde.workspace = true
+tokio.workspace = true
+tokio-util.workspace = true
+tracing.workspace = true
+tracing-subscriber.workspace = true
+
+ot.workspace = true
@@ -0,0 +1,26 @@
+use std::process::Command;
+fn main() {
+    let output = Command::new("git")
+        .args(["rev-parse", "--short", "HEAD"])
+        .output()
+        .unwrap();
+    let git_hash = String::from_utf8(output.stdout).unwrap();
+    println!("cargo:rustc-env=GIT_HASH={}", git_hash);
+
+    let is_clean = std::process::Command::new("git")
+        .args(["status", "--porcelain=v1"])
+        .output()
+        .map(|o| o.stdout.is_empty())
+        .unwrap_or(false);
+    if !is_clean && std::env::var("PROFILE").unwrap() == "release" {
+        println!("cargo::warning=Building a release binary from an unclean working tree!!");
+        println!("cargo::warning=Always build production binaries from a clean checkout.");
+    }
+
+    println!(
+        "cargo:rustc-env=LONG_VERSION={} ({}{})",
+        std::env::var("CARGO_PKG_VERSION").unwrap().as_str(),
+        if is_clean { "" } else { "dirty " },
+        git_hash.strip_suffix("\n").unwrap(),
+    );
+}
@@ -0,0 +1,81 @@
+use russh::server::{Config as RuConfig, RunningSession};
+pub use std::sync::{Arc, Mutex};
+use tokio::net::UnixStream;
+
+/// The auth state of the SSH connection.
+#[derive(Debug, Default, PartialEq, Eq)]
+pub enum Auth {
+    #[default]
+    Pending,
+    Local,
+}
+
+/// Represents the SSH connection. Lives for the
+/// lifetime of the connection.
+#[derive(Debug, Default)]
+#[allow(dead_code)]
+pub struct Connection {
+    pub auth: Auth,
+
+    /// The username given via SSH. Not populated till the client
+    /// authenticates the connection.
+    pub ssh_username: Option<String>,
+}
+
+impl Connection {
+    pub(crate) async fn from_socket(
+        s: UnixStream,
+        c: Arc<RuConfig>,
+        was_local_uds: bool,
+    ) -> (ConnectionHandle, RunningSession<ConnectionHandler>) {
+        let h = ConnectionHandle(Arc::new(Mutex::new(Self {
+            auth: if was_local_uds {
+                Auth::Local
+            } else {
+                Auth::Pending
+            },
+            ..Default::default()
+        })));
+
+        (
+            h.clone(),
+            russh::server::run_stream(c, s, ConnectionHandler(h))
+                .await
+                .unwrap(),
+        )
+    }
+}
+
+/// A thread-safe handle to the connection.
+#[derive(Clone)]
+pub struct ConnectionHandle(Arc<Mutex<Connection>>);
+
+/// An error when handling the SSH connection.
+#[derive(Debug)]
+#[allow(dead_code)]
+pub enum ConnectionError {
+    Protocol(russh::Error),
+}
+
+impl From<russh::Error> for ConnectionError {
+    fn from(value: russh::Error) -> Self {
+        ConnectionError::Protocol(value)
+    }
+}
+
+/// A [`russh::server::Handler`] for a [`Connection`].
+pub struct ConnectionHandler(ConnectionHandle);
+
+impl russh::server::Handler for ConnectionHandler {
+    type Error = ConnectionError;
+
+    async fn auth_none(&mut self, user: &str) -> Result<russh::server::Auth, Self::Error> {
+        let mut s = self.0.0.lock().unwrap();
+        if s.auth == Auth::Local {
+            s.ssh_username = Some(user.to_string());
+            Ok(russh::server::Auth::Accept)
+        } else {
+            Ok(russh::server::Auth::reject())
+        }
+    }
+}