update processes & add install script

Author: Chris

README.md

@@ -4,6 +4,19 @@ A command-line tool for interacting with the [Canine](https://canine.sh) platfor
 
 ## Installation
 
+```bash
+curl -sSL https://raw.githubusercontent.com/CanineHQ/cli/main/install.sh | sh
+```
+
+### macOS (Homebrew)
+
+```bash
+brew tap CanineHQ/canine
+brew install canine
+```
+
+### From source
+
 ```bash
 cargo install --path .
 ```

install.sh

@@ -0,0 +1,96 @@
+#!/bin/sh
+set -e
+
+REPO="CanineHQ/cli"
+BINARY_NAME="k9"
+INSTALL_DIR="/usr/local/bin"
+
+main() {
+    OS=$(uname -s | tr '[:upper:]' '[:lower:]')
+    ARCH=$(uname -m)
+
+    case "$OS" in
+        darwin*)
+            echo "macOS detected."
+            echo ""
+            echo "Install Canine CLI using Homebrew:"
+            echo ""
+            echo "  brew tap CanineHQ/canine"
+            echo "  brew install canine"
+            echo ""
+            exit 0
+            ;;
+        linux*)
+            install_linux
+            ;;
+        mingw*|msys*|cygwin*|windows*)
+            echo "Error: Windows is not supported."
+            echo "Please use WSL (Windows Subsystem for Linux) and run this script again."
+            exit 1
+            ;;
+        *)
+            echo "Error: Unsupported operating system: $OS"
+            exit 1
+            ;;
+    esac
+}
+
+install_linux() {
+    echo "Linux detected."
+
+    # Detect architecture
+    case "$ARCH" in
+        x86_64|amd64)
+            ARCH="amd64"
+            ;;
+        aarch64|arm64)
+            ARCH="arm64"
+            ;;
+        *)
+            echo "Error: Unsupported architecture: $ARCH"
+            exit 1
+            ;;
+    esac
+
+    echo "Architecture: $ARCH"
+
+    # Get latest release version
+    echo "Fetching latest release..."
+    LATEST_VERSION=$(curl -sL "https://api.github.com/repos/${REPO}/releases/latest" | grep '"tag_name":' | sed -E 's/.*"([^"]+)".*/\1/')
+
+    if [ -z "$LATEST_VERSION" ]; then
+        echo "Error: Could not determine latest version."
+        exit 1
+    fi
+
+    echo "Latest version: $LATEST_VERSION"
+
+    # Construct download URL
+    DOWNLOAD_URL="https://github.com/${REPO}/releases/download/${LATEST_VERSION}/${BINARY_NAME}-linux-${ARCH}"
+
+    echo "Downloading from: $DOWNLOAD_URL"
+
+    # Create temp directory
+    TMP_DIR=$(mktemp -d)
+    trap "rm -rf $TMP_DIR" EXIT
+
+    # Download binary
+    curl -sL "$DOWNLOAD_URL" -o "$TMP_DIR/$BINARY_NAME"
+
+    # Make executable
+    chmod +x "$TMP_DIR/$BINARY_NAME"
+
+    # Install to /usr/local/bin (may require sudo)
+    echo "Installing to $INSTALL_DIR/$BINARY_NAME..."
+    if [ -w "$INSTALL_DIR" ]; then
+        mv "$TMP_DIR/$BINARY_NAME" "$INSTALL_DIR/$BINARY_NAME"
+    else
+        sudo mv "$TMP_DIR/$BINARY_NAME" "$INSTALL_DIR/$BINARY_NAME"
+    fi
+
+    echo ""
+    echo "Canine CLI installed successfully!"
+    echo "Run 'k9 --help' to get started."
+}
+
+main

src/cli.rs

@@ -131,6 +131,9 @@ pub enum ProjectAction {
 
     /// List processes for a project
     Processes(ProjectId),
+
+    /// Get logs for a process
+    Logs(ProjectLogs),
 }
 
 #[derive(Args, Debug)]
@@ -149,6 +152,19 @@ pub struct ProjectRun {
     pub command: Vec<String>,
 }
 
+#[derive(Args, Debug)]
+pub struct ProjectLogs {
+    #[arg(long)]
+    pub project: String,
+
+    #[arg(long)]
+    pub process: String,
+
+    /// Follow log output
+    #[arg(long, default_value_t = false)]
+    pub tail: bool,
+}
+
 #[derive(Args, Debug)]
 pub struct DeployProjectParams {
     #[arg(long)]

src/commands/project.rs

@@ -6,7 +6,7 @@ use std::time::Duration;
 use colored::Colorize;
 use tabled::Table;
 
-use crate::cli::{DeployProjectParams, ProjectId, ProjectRun};
+use crate::cli::{DeployProjectParams, ProjectId, ProjectLogs, ProjectRun};
 use crate::client::{CanineClient, CanineError, Pod, ProcessStatus};
 use crate::config::CanineConfig;
 use crate::kubeconfig::{ensure_kubectl, kubeconfig_to_yaml};
@@ -80,6 +80,58 @@ pub async fn handle_run(
     Ok(())
 }
 
+pub async fn handle_logs(
+    config: &CanineConfig,
+    client: &CanineClient,
+    params: &ProjectLogs,
+) -> Result<(), Box<dyn std::error::Error>> {
+    gate_kubectl();
+
+    print!("Fetching project {}... ", params.project.cyan());
+    io::stdout().flush().unwrap();
+    let project = client.get_project(&params.project).await?;
+    println!("{}", "done".green());
+
+    print!(
+        "Downloading kubeconfig for cluster {}... ",
+        project.cluster_name.cyan()
+    );
+    io::stdout().flush().unwrap();
+    let kubeconfig = client
+        .download_kubeconfig_file(&project.cluster_name.to_string())
+        .await?;
+    let yaml = kubeconfig_to_yaml(&kubeconfig.kubeconfig)?;
+    config.save_kubeconfig(yaml)?;
+    println!("{}", "done".green());
+
+    print!("Finding process {}... ", params.process.cyan());
+    io::stdout().flush().unwrap();
+    let processes = client.get_processes(&params.project).await?;
+    let pod = processes
+        .pods
+        .iter()
+        .find(|p| p.name.contains(&params.process))
+        .ok_or_else(|| format!("Process '{}' not found", params.process))?;
+    println!("{}", "done".green());
+
+    let mut args = vec!["logs", "-n", &pod.namespace, &pod.name];
+    if params.tail {
+        args.push("-f");
+    }
+
+    Command::new("kubectl")
+        .args(&args)
+        .env(
+            "KUBECONFIG",
+            CanineConfig::credential_path().to_str().unwrap(),
+        )
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
+        .status()?;
+
+    Ok(())
+}
+
 pub async fn handle_deploy(
     client: &CanineClient,
     params: &DeployProjectParams,

src/main.rs

@@ -86,6 +86,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                     ProjectAction::Deploy(params) => {
                         commands::project::handle_deploy(&client, &params).await?;
                     }
+                    ProjectAction::Logs(params) => {
+                        commands::project::handle_logs(&config, &client, &params).await?;
+                    }
                 },
                 Namespace::Builds(cmd) => match cmd.action {
                     BuildAction::List(list) => {