bijux-cli 0.3.2__tar.gz → 0.3.3__tar.gz

{bijux_cli-0.3.2 → bijux_cli-0.3.3}/Cargo.lock

@@ -66,7 +66,7 @@ checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "bijux-cli"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "clap",
@@ -86,7 +86,7 @@ dependencies = [
 
 [[package]]
 name = "bijux-cli-python"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "bijux-cli",
  "pyo3",
@@ -96,7 +96,7 @@ dependencies = [
 
 [[package]]
 name = "bijux-dev-cli"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "bijux-cli",

{bijux_cli-0.3.2 → bijux_cli-0.3.3}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/bijux-cli", "crates/bijux-cli-python"]
 resolver = "2"
 
 [workspace.package]
-version = "0.3.2"
+version = "0.3.3"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/bijux/bijux-cli"
@@ -14,7 +14,7 @@ rust-version = "1.85"
 
 [workspace.dependencies]
 anyhow = "1.0.100"
-bijux-cli = { version = "0.3.2", path = "crates/bijux-cli" }
+bijux-cli = { version = "0.3.3", path = "crates/bijux-cli" }
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = { version = "1.0.145", default-features = false, features = ["std"] }
 serde_yaml = "0.9.34"

{bijux_cli-0.3.2 → bijux_cli-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bijux-cli
-Version: 0.3.2
+Version: 0.3.3
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

bijux_cli-0.3.3/crates/bijux-cli/src/interface/cli/dispatch/delegation.rs

@@ -0,0 +1,83 @@
+//! External runtime tool delegation helpers.
+
+use std::process::Command;
+
+use crate::contracts::known_bijux_tool;
+
+use super::AppRunResult;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct DelegatedKnownToolCommand {
+    binary: String,
+    package_name: String,
+    command_surface: String,
+    forwarded_args: Vec<String>,
+}
+
+fn delegate_to_external_binary(
+    binary: &str,
+    package_name: &str,
+    command_surface: &str,
+    forwarded_args: &[String],
+) -> AppRunResult {
+    match Command::new(binary).args(forwarded_args).output() {
+        Ok(output) => AppRunResult {
+            exit_code: output.status.code().unwrap_or(1),
+            stdout: String::from_utf8_lossy(&output.stdout).into_owned(),
+            stderr: String::from_utf8_lossy(&output.stderr).into_owned(),
+        },
+        Err(error) => {
+            let message = format!(
+                "failed to run `{command_surface}` via `{binary}`: {error}\ninstall with `cargo install {package_name}` or `pip install {package_name}`\n"
+            );
+            AppRunResult { exit_code: 1, stdout: String::new(), stderr: message }
+        }
+    }
+}
+
+fn delegated_known_bijux_tool_command(argv: &[String]) -> Option<DelegatedKnownToolCommand> {
+    match argv.get(1).map(String::as_str) {
+        Some("dev") => {
+            let namespace = argv.get(2)?;
+            let tool = known_bijux_tool(namespace)?;
+            Some(DelegatedKnownToolCommand {
+                binary: tool.control_binary(),
+                package_name: tool.control_package(),
+                command_surface: format!("bijux dev {}", tool.namespace),
+                forwarded_args: argv[3..].to_vec(),
+            })
+        }
+        Some(namespace) => {
+            let tool = known_bijux_tool(namespace)?;
+            Some(DelegatedKnownToolCommand {
+                binary: tool.runtime_binary(),
+                package_name: tool.runtime_package(),
+                command_surface: format!("bijux {}", tool.namespace),
+                forwarded_args: argv[2..].to_vec(),
+            })
+        }
+        None => None,
+    }
+}
+
+pub(super) fn is_known_bijux_tool_route(path: &[String]) -> bool {
+    match path {
+        [dev, namespace, ..] => dev == "dev" && known_bijux_tool(namespace).is_some(),
+        [namespace, ..] => known_bijux_tool(namespace).is_some(),
+        [] => false,
+    }
+}
+
+pub(super) fn delegated_command_surface(argv: &[String]) -> Option<String> {
+    delegated_known_bijux_tool_command(argv).map(|command| command.command_surface)
+}
+
+pub(super) fn try_delegate_known_bijux_tool(argv: &[String]) -> Option<AppRunResult> {
+    let command = delegated_known_bijux_tool_command(argv)?;
+    Some(delegate_to_external_binary(
+        &command.binary,
+        &command.package_name,
+        &command.command_surface,
+        &command.forwarded_args,
+    ))
+}

{bijux_cli-0.3.2 → bijux_cli-0.3.3}/crates/bijux-cli/src/interface/cli/dispatch.rs

@@ -9,7 +9,7 @@ mod suggest;
 use anyhow::Result;
 use serde_json::json;
 
-use crate::contracts::{known_bijux_tool, OutputFormat};
+use crate::contracts::OutputFormat;
 use crate::interface::cli::handlers::install as install_handler;
 use crate::interface::cli::help::render_command_help;
 use crate::interface::cli::parser::parse_intent;
@@ -234,25 +234,24 @@ fn run_app_inner(argv: &[String], telemetry: &TelemetrySpan) -> Result<AppRunRes
             }
         };
         let path_refs: Vec<&str> = path.iter().map(String::as_str).collect();
+        if delegation::is_known_bijux_tool_route(&path) {
+            let mut delegated_argv = vec!["bijux".to_string()];
+            delegated_argv.extend(path.clone());
+            delegated_argv.push("--help".to_string());
+            if let Some(delegated) = delegation::try_delegate_known_bijux_tool(&delegated_argv) {
+                let surface = delegation::delegated_command_surface(&delegated_argv)
+                    .unwrap_or_else(|| path.join(" "));
+                let (target, target_truncated) = bounded_command(&surface);
+                telemetry.record(
+                    "dispatch.delegated.help",
+                    json!({"target": target, "target_truncated": target_truncated, "exit_code": delegated.exit_code}),
+                );
+                return Ok(delegated);
+            }
+        }
         if !is_known_help_topic(&path) {
             return Ok(unknown_help_topic_result(&path_refs.join(" "), telemetry));
         }
-        if let Some(first) = path.first().map(String::as_str) {
-            if known_bijux_tool(first).is_some() {
-                let mut delegated_argv = vec!["bijux".to_string()];
-                delegated_argv.extend(path.clone());
-                delegated_argv.push("--help".to_string());
-                if let Some(delegated) = delegation::try_delegate_known_bijux_tool(&delegated_argv)
-                {
-                    let (target, target_truncated) = bounded_command(first);
-                    telemetry.record(
-                        "dispatch.delegated.help",
-                        json!({"target": target, "target_truncated": target_truncated, "exit_code": delegated.exit_code}),
-                    );
-                    return Ok(delegated);
-                }
-            }
-        }
         let rendered = match render_command_help(&path_refs) {
             Ok(rendered) => rendered,
             Err(_) => return Ok(unknown_help_topic_result(&path_refs.join(" "), telemetry)),
@@ -275,10 +274,10 @@ fn run_app_inner(argv: &[String], telemetry: &TelemetrySpan) -> Result<AppRunRes
     }
 
     let has_help_flag = argv.iter().any(|arg| matches!(arg.as_str(), "--help" | "-h"));
-    if has_help_flag && argv.get(1).is_some_and(|first| known_bijux_tool(first).is_some()) {
+    if has_help_flag && delegation::is_known_bijux_tool_route(&argv[1..]) {
         if let Some(delegated) = delegation::try_delegate_known_bijux_tool(argv) {
-            let target_arg = argv.get(1).cloned().unwrap_or_default();
-            let (target, target_truncated) = bounded_command(&target_arg);
+            let surface = delegation::delegated_command_surface(argv).unwrap_or_default();
+            let (target, target_truncated) = bounded_command(&surface);
             telemetry.record(
                 "dispatch.delegated.help_flag",
                 json!({"target": target, "target_truncated": target_truncated, "exit_code": delegated.exit_code}),
@@ -296,8 +295,8 @@ fn run_app_inner(argv: &[String], telemetry: &TelemetrySpan) -> Result<AppRunRes
     }
 
     if let Some(delegated) = delegation::try_delegate_known_bijux_tool(argv) {
-        let target_arg = argv.get(1).cloned().unwrap_or_default();
-        let (target, target_truncated) = bounded_command(&target_arg);
+        let surface = delegation::delegated_command_surface(argv).unwrap_or_default();
+        let (target, target_truncated) = bounded_command(&surface);
         telemetry.record(
             "dispatch.delegated.command",
             json!({"target": target, "target_truncated": target_truncated, "exit_code": delegated.exit_code}),

{bijux_cli-0.3.2 → bijux_cli-0.3.3}/crates/bijux-cli/tests/architecture/interfaces/documented_env_surface.rs

@@ -53,9 +53,17 @@ fn routed_runtime_reference_matches_current_binary_resolution_contract() {
     let doc = read_doc("docs/06-reference/integrations-and-routed-runtimes.md");
 
     assert!(doc.contains("bijux-dev-cli"), "maintainer binary documentation must stay explicit");
+    assert!(
+        doc.contains("`bijux dev <tool> ...`"),
+        "routed product control commands must remain documented explicitly"
+    );
     assert!(
         doc.contains("`bijux-dev-<tool>`"),
-        "product control-plane binaries must remain documented explicitly"
+        "direct product control binaries must remain documented explicitly"
+    );
+    assert!(
+        doc.contains("`bijux <tool> ...`"),
+        "routed product runtime commands must remain documented explicitly"
     );
     assert!(
         doc.contains("`PATH`"),
@@ -63,7 +71,6 @@ fn routed_runtime_reference_matches_current_binary_resolution_contract() {
     );
 
     for unsupported in [
-        "bijux dev ",
         "BIJUXCLI_ALLOWED_PRODUCT_BINS",
         "BIJUXCLI_PRODUCT_BIN_DIR",
         "BIJUXCLI_PRODUCT_BIN_DIRS",

{bijux_cli-0.3.2 → bijux_cli-0.3.3}/crates/bijux-cli/tests/integration/cli/root/mod.rs

@@ -6,6 +6,7 @@ mod cli_command_matrix;
 mod cross_surface_equivalence;
 mod flag_normalization_matrix;
 mod install_command;
+mod official_product_routes;
 mod parser_invalid_utf8_argv;
 mod precedence_matrix;
 mod python_command_port_parity;

bijux_cli-0.3.3/crates/bijux-cli/tests/integration/cli/root/official_product_routes.rs

@@ -0,0 +1,123 @@
+#![forbid(unsafe_code)]
+//! Routed official product namespace delegation contracts.
+
+use std::env;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::{Command, Output};
+
+use bijux_cli::contracts::known_bijux_tools;
+
+fn run_with_env(args: &[&str], envs: &[(&str, &Path)]) -> Output {
+    let mut command = Command::new(env!("CARGO_BIN_EXE_bijux"));
+    command.args(args);
+    for (key, value) in envs {
+        command.env(key, value);
+    }
+    command.output().expect("binary should execute")
+}
+
+fn temp_dir(name: &str) -> PathBuf {
+    let root = env::temp_dir()
+        .join(format!("bijux-official-product-routes-{name}-{}", std::process::id()));
+    let _ = fs::remove_dir_all(&root);
+    fs::create_dir_all(&root).expect("mkdir temp");
+    root
+}
+
+#[cfg(unix)]
+fn write_stub_binary(bin_dir: &Path, binary_name: &str) {
+    use std::os::unix::fs::PermissionsExt;
+
+    let script = format!("#!/bin/sh\nprintf 'stub:{binary_name}\\n'\nprintf 'args:%s\\n' \"$*\"\n");
+    let path = bin_dir.join(binary_name);
+    fs::write(&path, script).expect("write stub");
+    let mut permissions = fs::metadata(&path).expect("metadata").permissions();
+    permissions.set_mode(0o755);
+    fs::set_permissions(&path, permissions).expect("chmod");
+}
+
+#[cfg(windows)]
+fn write_stub_binary(bin_dir: &Path, binary_name: &str) {
+    let script = format!("@echo off\r\necho stub:{binary_name}\r\necho args:%*\r\n");
+    fs::write(bin_dir.join(format!("{binary_name}.bat")), script).expect("write stub");
+}
+
+fn write_all_stubs(bin_dir: &Path) {
+    for tool in known_bijux_tools() {
+        write_stub_binary(bin_dir, tool.runtime_binary_name);
+        write_stub_binary(bin_dir, tool.control_binary_name);
+    }
+}
+
+#[test]
+fn official_runtime_routes_delegate_to_runtime_binaries_for_every_reserved_namespace() {
+    let root = temp_dir("runtime");
+    let bin_dir = root.join("bin");
+    fs::create_dir_all(&bin_dir).expect("mkdir bin");
+    write_all_stubs(&bin_dir);
+
+    for tool in known_bijux_tools() {
+        let out = run_with_env(&[tool.namespace, "status"], &[("PATH", &bin_dir)]);
+        assert_eq!(
+            out.status.code(),
+            Some(0),
+            "runtime route should succeed for {}",
+            tool.namespace
+        );
+        assert!(
+            out.stderr.is_empty(),
+            "runtime route should keep stderr empty for {}",
+            tool.namespace
+        );
+        let stdout = String::from_utf8(out.stdout).expect("utf-8");
+        assert!(stdout.contains(&format!("stub:{}", tool.runtime_binary_name)));
+        assert!(stdout.contains("args:status"));
+    }
+}
+
+#[test]
+fn official_control_routes_delegate_to_control_binaries_for_every_reserved_namespace() {
+    let root = temp_dir("control");
+    let bin_dir = root.join("bin");
+    fs::create_dir_all(&bin_dir).expect("mkdir bin");
+    write_all_stubs(&bin_dir);
+
+    for tool in known_bijux_tools() {
+        let out = run_with_env(&["dev", tool.namespace, "status"], &[("PATH", &bin_dir)]);
+        assert_eq!(
+            out.status.code(),
+            Some(0),
+            "control route should succeed for {}",
+            tool.namespace
+        );
+        assert!(
+            out.stderr.is_empty(),
+            "control route should keep stderr empty for {}",
+            tool.namespace
+        );
+        let stdout = String::from_utf8(out.stdout).expect("utf-8");
+        assert!(stdout.contains(&format!("stub:{}", tool.control_binary_name)));
+        assert!(stdout.contains("args:status"));
+    }
+}
+
+#[test]
+fn help_routes_delegate_for_runtime_and_control_product_surfaces() {
+    let root = temp_dir("help");
+    let bin_dir = root.join("bin");
+    fs::create_dir_all(&bin_dir).expect("mkdir bin");
+    write_all_stubs(&bin_dir);
+
+    let runtime = run_with_env(&["help", "atlas"], &[("PATH", &bin_dir)]);
+    assert_eq!(runtime.status.code(), Some(0));
+    let runtime_stdout = String::from_utf8(runtime.stdout).expect("utf-8");
+    assert!(runtime_stdout.contains("stub:bijux-atlas"));
+    assert!(runtime_stdout.contains("args:--help"));
+
+    let control = run_with_env(&["help", "dev", "atlas"], &[("PATH", &bin_dir)]);
+    assert_eq!(control.status.code(), Some(0));
+    let control_stdout = String::from_utf8(control.stdout).expect("utf-8");
+    assert!(control_stdout.contains("stub:bijux-dev-atlas"));
+    assert!(control_stdout.contains("args:--help"));
+}

bijux_cli-0.3.2/crates/bijux-cli/src/interface/cli/dispatch/delegation.rs

@@ -1,46 +0,0 @@
-//! External runtime tool delegation helpers.
-
-use std::process::Command;
-
-use crate::contracts::known_bijux_tool;
-
-use super::AppRunResult;
-
-fn delegate_to_external_binary(
-    binary: &str,
-    package_name: &str,
-    command_surface: &str,
-    forwarded_args: &[String],
-) -> AppRunResult {
-    match Command::new(binary).args(forwarded_args).output() {
-        Ok(output) => AppRunResult {
-            exit_code: output.status.code().unwrap_or(1),
-            stdout: String::from_utf8_lossy(&output.stdout).into_owned(),
-            stderr: String::from_utf8_lossy(&output.stderr).into_owned(),
-        },
-        Err(error) => {
-            let message = format!(
-                "failed to run `{command_surface}` via `{binary}`: {error}\ninstall with `cargo install {package_name}` or `pip install {package_name}`\n"
-            );
-            AppRunResult { exit_code: 1, stdout: String::new(), stderr: message }
-        }
-    }
-}
-
-pub(super) fn try_delegate_known_bijux_tool(argv: &[String]) -> Option<AppRunResult> {
-    let first = argv.get(1)?;
-
-    if let Some(tool) = known_bijux_tool(first) {
-        let runtime_binary = tool.runtime_binary();
-        let runtime_package = runtime_binary.clone();
-        let command_surface = format!("bijux {}", tool.namespace);
-        return Some(delegate_to_external_binary(
-            &runtime_binary,
-            &runtime_package,
-            &command_surface,
-            &argv[2..],
-        ));
-    }
-
-    None
-}