pi-usereq 0.48.0 → 0.50.0

package/pi.dev-src/pi-mono/pods/scripts/pod_setup.sh

@@ -1,336 +0,0 @@
-#!/usr/bin/env bash
-# GPU pod bootstrap for vLLM deployment
-set -euo pipefail
-
-# Parse arguments passed from pi CLI
-MOUNT_COMMAND=""
-MODELS_PATH=""
-HF_TOKEN=""
-PI_API_KEY=""
-VLLM_VERSION="release"  # Default to release
-
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --mount)
-            MOUNT_COMMAND="$2"
-            shift 2
-            ;;
-        --models-path)
-            MODELS_PATH="$2"
-            shift 2
-            ;;
-        --hf-token)
-            HF_TOKEN="$2"
-            shift 2
-            ;;
-        --vllm-api-key)
-            PI_API_KEY="$2"
-            shift 2
-            ;;
-        --vllm)
-            VLLM_VERSION="$2"
-            shift 2
-            ;;
-        *)
-            echo "ERROR: Unknown option: $1" >&2
-            exit 1
-            ;;
-    esac
-done
-
-# Validate required parameters
-if [ -z "$HF_TOKEN" ]; then
-    echo "ERROR: HF_TOKEN is required" >&2
-    exit 1
-fi
-
-if [ -z "$PI_API_KEY" ]; then
-    echo "ERROR: PI_API_KEY is required" >&2
-    exit 1
-fi
-
-if [ -z "$MODELS_PATH" ]; then
-    echo "ERROR: MODELS_PATH is required" >&2
-    exit 1
-fi
-
-echo "=== Starting pod setup ==="
-
-# Install system dependencies
-apt update -y
-apt install -y python3-pip python3-venv git build-essential cmake ninja-build curl wget lsb-release htop pkg-config
-
-# --- Install matching CUDA toolkit -------------------------------------------
-echo "Checking CUDA driver version..."
-DRIVER_CUDA_VERSION=$(nvidia-smi | grep "CUDA Version" | awk '{print $9}')
-echo "Driver supports CUDA: $DRIVER_CUDA_VERSION"
-
-# Check if nvcc exists and its version
-if command -v nvcc &> /dev/null; then
-    NVCC_VERSION=$(nvcc --version | grep "release" | awk '{print $6}' | cut -d, -f1)
-    echo "Current nvcc version: $NVCC_VERSION"
-else
-    NVCC_VERSION="none"
-    echo "nvcc not found"
-fi
-
-# Install CUDA toolkit matching driver version if needed
-if [[ "$NVCC_VERSION" != "$DRIVER_CUDA_VERSION" ]]; then
-    echo "Installing CUDA Toolkit $DRIVER_CUDA_VERSION to match driver..."
-
-    # Detect Ubuntu version
-    UBUNTU_VERSION=$(lsb_release -rs)
-    UBUNTU_CODENAME=$(lsb_release -cs)
-
-    echo "Detected Ubuntu $UBUNTU_VERSION ($UBUNTU_CODENAME)"
-
-    # Map Ubuntu version to NVIDIA repo path
-    if [[ "$UBUNTU_VERSION" == "24.04" ]]; then
-        REPO_PATH="ubuntu2404"
-    elif [[ "$UBUNTU_VERSION" == "22.04" ]]; then
-        REPO_PATH="ubuntu2204"
-    elif [[ "$UBUNTU_VERSION" == "20.04" ]]; then
-        REPO_PATH="ubuntu2004"
-    else
-        echo "Warning: Unsupported Ubuntu version $UBUNTU_VERSION, trying ubuntu2204"
-        REPO_PATH="ubuntu2204"
-    fi
-
-    # Add NVIDIA package repositories
-    wget https://developer.download.nvidia.com/compute/cuda/repos/${REPO_PATH}/x86_64/cuda-keyring_1.1-1_all.deb
-    dpkg -i cuda-keyring_1.1-1_all.deb
-    rm cuda-keyring_1.1-1_all.deb
-    apt-get update
-
-    # Install specific CUDA toolkit version
-    # Convert version format (12.9 -> 12-9)
-    CUDA_VERSION_APT=$(echo $DRIVER_CUDA_VERSION | sed 's/\./-/')
-    echo "Installing cuda-toolkit-${CUDA_VERSION_APT}..."
-    apt-get install -y cuda-toolkit-${CUDA_VERSION_APT}
-
-    # Add CUDA to PATH
-    export PATH=/usr/local/cuda-${DRIVER_CUDA_VERSION}/bin:$PATH
-    export LD_LIBRARY_PATH=/usr/local/cuda-${DRIVER_CUDA_VERSION}/lib64:${LD_LIBRARY_PATH:-}
-
-    # Verify installation
-    nvcc --version
-else
-    echo "CUDA toolkit $NVCC_VERSION matches driver version"
-    export PATH=/usr/local/cuda-${DRIVER_CUDA_VERSION}/bin:$PATH
-    export LD_LIBRARY_PATH=/usr/local/cuda-${DRIVER_CUDA_VERSION}/lib64:${LD_LIBRARY_PATH:-}
-fi
-
-# --- Install uv (fast Python package manager) --------------------------------
-curl -LsSf https://astral.sh/uv/install.sh | sh
-export PATH="$HOME/.local/bin:$PATH"
-
-# --- Install Python 3.12 if not available ------------------------------------
-if ! command -v python3.12 &> /dev/null; then
-    echo "Python 3.12 not found. Installing via uv..."
-    uv python install 3.12
-fi
-
-# --- Clean up existing environments and caches -------------------------------
-echo "Cleaning up existing environments and caches..."
-
-# Remove existing venv for a clean installation
-VENV="$HOME/venv"
-if [ -d "$VENV" ]; then
-    echo "Removing existing virtual environment..."
-    rm -rf "$VENV"
-fi
-
-# Remove uv cache to ensure fresh installs
-if [ -d "$HOME/.cache/uv" ]; then
-    echo "Clearing uv cache..."
-    rm -rf "$HOME/.cache/uv"
-fi
-
-# Remove vLLM cache to avoid conflicts
-if [ -d "$HOME/.cache/vllm" ]; then
-    echo "Clearing vLLM cache..."
-    rm -rf "$HOME/.cache/vllm"
-fi
-
-# --- Create and activate venv ------------------------------------------------
-echo "Creating fresh virtual environment..."
-uv venv --python 3.12 --seed "$VENV"
-source "$VENV/bin/activate"
-
-# --- Install PyTorch and vLLM ------------------------------------------------
-echo "Installing vLLM and dependencies (version: $VLLM_VERSION)..."
-case "$VLLM_VERSION" in
-    release)
-        echo "Installing vLLM release with PyTorch..."
-        # Install vLLM with automatic PyTorch backend selection
-        # vLLM will automatically install the correct PyTorch version
-        uv pip install vllm>=0.10.0 --torch-backend=auto || {
-            echo "ERROR: Failed to install vLLM"
-            exit 1
-        }
-        ;;
-    nightly)
-        echo "Installing vLLM nightly with PyTorch..."
-        echo "This will install the latest nightly build of vLLM..."
-
-        # Install vLLM nightly with PyTorch
-        uv pip install -U vllm \
-            --torch-backend=auto \
-            --extra-index-url https://wheels.vllm.ai/nightly || {
-            echo "ERROR: Failed to install vLLM nightly"
-            exit 1
-        }
-
-        echo "vLLM nightly successfully installed!"
-        ;;
-    gpt-oss)
-        echo "Installing GPT-OSS special build with PyTorch nightly..."
-        echo "WARNING: This build is ONLY for GPT-OSS models!"
-        echo "Installing PyTorch nightly and cutting-edge dependencies..."
-
-        # Convert CUDA version format for PyTorch (12.4 -> cu124)
-        PYTORCH_CUDA="cu$(echo $DRIVER_CUDA_VERSION | sed 's/\.//')"
-        echo "Using PyTorch nightly with ${PYTORCH_CUDA} (driver supports ${DRIVER_CUDA_VERSION})"
-
-        # The GPT-OSS build will pull PyTorch nightly and other dependencies
-        # via the extra index URLs. We don't pre-install torch here to avoid conflicts.
-        uv pip install --pre vllm==0.10.1+gptoss \
-            --extra-index-url https://wheels.vllm.ai/gpt-oss/ \
-            --extra-index-url https://download.pytorch.org/whl/nightly/${PYTORCH_CUDA} \
-            --index-strategy unsafe-best-match || {
-            echo "ERROR: Failed to install GPT-OSS vLLM build"
-            echo "This automatically installs PyTorch nightly with ${PYTORCH_CUDA}, Triton nightly, and other dependencies"
-            exit 1
-        }
-
-        # Install gpt-oss library for tool support
-        uv pip install gpt-oss || {
-            echo "WARNING: Failed to install gpt-oss library (needed for tool use)"
-        }
-        ;;
-    *)
-        echo "ERROR: Unknown vLLM version: $VLLM_VERSION"
-        exit 1
-        ;;
-esac
-
-# --- Install additional packages ---------------------------------------------
-echo "Installing additional packages..."
-# Note: tensorrt removed temporarily due to CUDA 13.0 compatibility issues
-# TensorRT still depends on deprecated nvidia-cuda-runtime-cu13 package
-uv pip install huggingface-hub psutil hf_transfer
-
-# --- FlashInfer installation (optional, improves performance) ----------------
-echo "Attempting FlashInfer installation (optional)..."
-if uv pip install flashinfer-python; then
-    echo "FlashInfer installed successfully"
-else
-    echo "FlashInfer not available, using Flash Attention instead"
-fi
-
-# --- Mount storage if provided -----------------------------------------------
-if [ -n "$MOUNT_COMMAND" ]; then
-    echo "Setting up mount..."
-
-    # Create mount point directory if it doesn't exist
-    mkdir -p "$MODELS_PATH"
-
-    # Execute the mount command
-    eval "$MOUNT_COMMAND" || {
-        echo "WARNING: Mount command failed, continuing without mount"
-    }
-
-    # Verify mount succeeded (optional, may not always be a mount point)
-    if mountpoint -q "$MODELS_PATH" 2>/dev/null; then
-        echo "Storage successfully mounted at $MODELS_PATH"
-    else
-        echo "Note: $MODELS_PATH is not a mount point (might be local storage)"
-    fi
-fi
-
-# --- Model storage setup ------------------------------------------------------
-echo ""
-echo "=== Setting up model storage ==="
-echo "Storage path: $MODELS_PATH"
-
-# Check if the path exists and is writable
-if [ ! -d "$MODELS_PATH" ]; then
-    echo "Creating model storage directory: $MODELS_PATH"
-    mkdir -p "$MODELS_PATH"
-fi
-
-if [ ! -w "$MODELS_PATH" ]; then
-    echo "ERROR: Model storage path is not writable: $MODELS_PATH"
-    echo "Please check permissions"
-    exit 1
-fi
-
-# Create the huggingface cache directory structure in the models path
-mkdir -p "${MODELS_PATH}/huggingface/hub"
-
-# Remove any existing cache directory or symlink
-if [ -e ~/.cache/huggingface ] || [ -L ~/.cache/huggingface ]; then
-    echo "Removing existing ~/.cache/huggingface..."
-    rm -rf ~/.cache/huggingface 2>/dev/null || true
-fi
-
-# Create parent directory if needed
-mkdir -p ~/.cache
-
-# Create symlink from ~/.cache/huggingface to the models path
-ln -s "${MODELS_PATH}/huggingface" ~/.cache/huggingface
-echo "Created symlink: ~/.cache/huggingface -> ${MODELS_PATH}/huggingface"
-
-# Verify the symlink works
-if [ -d ~/.cache/huggingface/hub ]; then
-    echo "✓ Model storage configured successfully"
-
-    # Check available space
-    AVAILABLE_SPACE=$(df -h "$MODELS_PATH" | awk 'NR==2 {print $4}')
-    echo "Available space: $AVAILABLE_SPACE"
-else
-    echo "ERROR: Could not verify model storage setup"
-    echo "The symlink was created but the target directory is not accessible"
-    exit 1
-fi
-
-# --- Configure environment ----------------------------------------------------
-mkdir -p ~/.config/vllm
-touch ~/.config/vllm/do_not_track
-
-# Write environment to .bashrc for persistence
-cat >> ~/.bashrc << EOF
-
-# Pi vLLM environment
-[ -d "\$HOME/venv" ] && source "\$HOME/venv/bin/activate"
-export PATH="/usr/local/cuda-${DRIVER_CUDA_VERSION}/bin:\$HOME/.local/bin:\$PATH"
-export LD_LIBRARY_PATH="/usr/local/cuda-${DRIVER_CUDA_VERSION}/lib64:\${LD_LIBRARY_PATH:-}"
-export HF_TOKEN="${HF_TOKEN}"
-export PI_API_KEY="${PI_API_KEY}"
-export HUGGING_FACE_HUB_TOKEN="${HF_TOKEN}"
-export HF_HUB_ENABLE_HF_TRANSFER=1
-export VLLM_NO_USAGE_STATS=1
-export VLLM_DO_NOT_TRACK=1
-export VLLM_ALLOW_LONG_MAX_MODEL_LEN=1
-export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
-EOF
-
-# Create log directory for vLLM
-mkdir -p ~/.vllm_logs
-
-# --- Output GPU info for pi CLI to parse -------------------------------------
-echo ""
-echo "===GPU_INFO_START==="
-nvidia-smi --query-gpu=index,name,memory.total --format=csv,noheader | while IFS=, read -r id name memory; do
-    # Trim whitespace
-    id=$(echo "$id" | xargs)
-    name=$(echo "$name" | xargs)
-    memory=$(echo "$memory" | xargs)
-    echo "{\"id\": $id, \"name\": \"$name\", \"memory\": \"$memory\"}"
-done
-echo "===GPU_INFO_END==="
-
-echo ""
-echo "=== Setup complete ==="
-echo "Pod is ready for vLLM deployments"
-echo "Models will be cached at: $MODELS_PATH"

package/pi.dev-src/pi-mono/pods/src/cli.ts

@@ -1,360 +0,0 @@
-#!/usr/bin/env node
-import chalk from "chalk";
-import { spawn } from "child_process";
-import { readFileSync } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-import { listModels, showKnownModels, startModel, stopAllModels, stopModel, viewLogs } from "./commands/models.js";
-import { listPods, removePodCommand, setupPod, switchActivePod } from "./commands/pods.js";
-import { promptModel } from "./commands/prompt.js";
-import { getActivePod, loadConfig } from "./config.js";
-import { sshExecStream } from "./ssh.js";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
-
-function printHelp() {
-	console.log(`pi v${packageJson.version} - Manage vLLM deployments on GPU pods
-
-Pod Management:
-  pi pods setup <name> "<ssh>" --mount "<mount>"    Setup pod with mount command
-    Options:
-      --vllm release    Install latest vLLM release >=0.10.0 (default)
-      --vllm nightly    Install vLLM nightly build (latest features)
-      --vllm gpt-oss    Install vLLM 0.10.1+gptoss with PyTorch nightly (GPT-OSS only)
-  pi pods                                           List all pods (* = active)
-  pi pods active <name>                             Switch active pod
-  pi pods remove <name>                             Remove pod from local config
-  pi shell [<name>]                                 Open shell on pod (active or specified)
-  pi ssh [<name>] "<command>"                       Run SSH command on pod
-
-Model Management:
-  pi start <model> --name <name> [options]          Start a model
-    --memory <percent>   GPU memory allocation (30%, 50%, 90%)
-    --context <size>     Context window (4k, 8k, 16k, 32k, 64k, 128k)
-    --gpus <count>       Number of GPUs to use (predefined models only)
-    --vllm <args...>     Pass remaining args to vLLM (ignores other options)
-  pi stop [<name>]                                  Stop model (or all if no name)
-  pi list                                           List running models
-  pi logs <name>                                    Stream model logs
-  pi agent <name> ["<message>"...] [options]        Chat with model using agent & tools
-  pi agent <name> [options]                         Interactive chat mode
-    --continue, -c       Continue previous session
-    --json              Output as JSONL
-    (All pi-agent options are supported)
-
-  All model commands support --pod <name> to override the active pod.
-
-Environment:
-  HF_TOKEN         HuggingFace token for model downloads
-  PI_API_KEY     API key for vLLM endpoints
-  PI_CONFIG_DIR    Config directory (default: ~/.pi)`);
-}
-
-// Parse command line arguments
-const args = process.argv.slice(2);
-
-if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
-	printHelp();
-	process.exit(0);
-}
-
-if (args[0] === "--version" || args[0] === "-v") {
-	console.log(packageJson.version);
-	process.exit(0);
-}
-
-const command = args[0];
-const subcommand = args[1];
-
-// Main command handler
-try {
-	// Handle "pi pods" commands
-	if (command === "pods") {
-		if (!subcommand) {
-			// pi pods - list all pods
-			listPods();
-		} else if (subcommand === "setup") {
-			// pi pods setup <name> "<ssh>" [--mount "<mount>"] [--models-path <path>] [--vllm release|nightly|gpt-oss]
-			const name = args[2];
-			const sshCmd = args[3];
-
-			if (!name || !sshCmd) {
-				console.error(
-					'Usage: pi pods setup <name> "<ssh>" [--mount "<mount>"] [--models-path <path>] [--vllm release|nightly|gpt-oss]',
-				);
-				process.exit(1);
-			}
-
-			// Parse options
-			const options: { mount?: string; modelsPath?: string; vllm?: "release" | "nightly" | "gpt-oss" } = {};
-			for (let i = 4; i < args.length; i++) {
-				if (args[i] === "--mount" && i + 1 < args.length) {
-					options.mount = args[i + 1];
-					i++;
-				} else if (args[i] === "--models-path" && i + 1 < args.length) {
-					options.modelsPath = args[i + 1];
-					i++;
-				} else if (args[i] === "--vllm" && i + 1 < args.length) {
-					const vllmType = args[i + 1];
-					if (vllmType === "release" || vllmType === "nightly" || vllmType === "gpt-oss") {
-						options.vllm = vllmType;
-					} else {
-						console.error(chalk.red(`Invalid vLLM type: ${vllmType}`));
-						console.error("Valid options: release, nightly, gpt-oss");
-						process.exit(1);
-					}
-					i++;
-				}
-			}
-
-			// If --mount provided but no --models-path, try to extract path from mount command
-			if (options.mount && !options.modelsPath) {
-				// Extract last part of mount command as models path
-				const parts = options.mount.trim().split(" ");
-				const lastPart = parts[parts.length - 1];
-				if (lastPart?.startsWith("/")) {
-					options.modelsPath = lastPart;
-				}
-			}
-
-			await setupPod(name, sshCmd, options);
-		} else if (subcommand === "active") {
-			// pi pods active <name>
-			const name = args[2];
-			if (!name) {
-				console.error("Usage: pi pods active <name>");
-				process.exit(1);
-			}
-			switchActivePod(name);
-		} else if (subcommand === "remove") {
-			// pi pods remove <name>
-			const name = args[2];
-			if (!name) {
-				console.error("Usage: pi pods remove <name>");
-				process.exit(1);
-			}
-			removePodCommand(name);
-		} else {
-			console.error(`Unknown pods subcommand: ${subcommand}`);
-			process.exit(1);
-		}
-	} else {
-		// Parse --pod override for model commands
-		let podOverride: string | undefined;
-		const podIndex = args.indexOf("--pod");
-		if (podIndex !== -1 && podIndex + 1 < args.length) {
-			podOverride = args[podIndex + 1];
-			// Remove --pod and its value from args
-			args.splice(podIndex, 2);
-		}
-
-		// Handle SSH/shell commands and model commands
-		switch (command) {
-			case "shell": {
-				// pi shell [<name>] - open interactive shell
-				const podName = args[1];
-				let podInfo: { name: string; pod: import("./types.js").Pod } | null = null;
-
-				if (podName) {
-					const config = loadConfig();
-					const pod = config.pods[podName];
-					if (pod) {
-						podInfo = { name: podName, pod };
-					}
-				} else {
-					podInfo = getActivePod();
-				}
-
-				if (!podInfo) {
-					if (podName) {
-						console.error(chalk.red(`Pod '${podName}' not found`));
-					} else {
-						console.error(chalk.red("No active pod. Use 'pi pods active <name>' to set one."));
-					}
-					process.exit(1);
-				}
-
-				console.log(chalk.green(`Connecting to pod '${podInfo.name}'...`));
-
-				// Execute SSH in interactive mode
-				const sshArgs = podInfo.pod.ssh.split(" ").slice(1); // Remove 'ssh' from command
-				const sshProcess = spawn("ssh", sshArgs, {
-					stdio: "inherit",
-					env: process.env,
-				});
-
-				sshProcess.on("exit", (code) => {
-					process.exit(code || 0);
-				});
-				break;
-			}
-			case "ssh": {
-				// pi ssh [<name>] "<command>" - run command via SSH
-				let podName: string | undefined;
-				let sshCommand: string;
-
-				if (args.length === 2) {
-					// pi ssh "<command>" - use active pod
-					sshCommand = args[1];
-				} else if (args.length === 3) {
-					// pi ssh <name> "<command>"
-					podName = args[1];
-					sshCommand = args[2];
-				} else {
-					console.error('Usage: pi ssh [<name>] "<command>"');
-					process.exit(1);
-				}
-
-				let podInfo: { name: string; pod: import("./types.js").Pod } | null = null;
-
-				if (podName) {
-					const config = loadConfig();
-					const pod = config.pods[podName];
-					if (pod) {
-						podInfo = { name: podName, pod };
-					}
-				} else {
-					podInfo = getActivePod();
-				}
-
-				if (!podInfo) {
-					if (podName) {
-						console.error(chalk.red(`Pod '${podName}' not found`));
-					} else {
-						console.error(chalk.red("No active pod. Use 'pi pods active <name>' to set one."));
-					}
-					process.exit(1);
-				}
-
-				console.log(chalk.gray(`Running on pod '${podInfo.name}': ${sshCommand}`));
-
-				// Execute command and stream output
-				const exitCode = await sshExecStream(podInfo.pod.ssh, sshCommand);
-				process.exit(exitCode);
-				break;
-			}
-			case "start": {
-				// pi start <model> --name <name> [options]
-				const modelId = args[1];
-				if (!modelId) {
-					// Show available models
-					await showKnownModels();
-					process.exit(0);
-				}
-
-				// Parse options
-				let name: string | undefined;
-				let memory: string | undefined;
-				let context: string | undefined;
-				let gpus: number | undefined;
-				const vllmArgs: string[] = [];
-				let inVllmArgs = false;
-
-				for (let i = 2; i < args.length; i++) {
-					if (inVllmArgs) {
-						vllmArgs.push(args[i]);
-					} else if (args[i] === "--name" && i + 1 < args.length) {
-						name = args[i + 1];
-						i++;
-					} else if (args[i] === "--memory" && i + 1 < args.length) {
-						memory = args[i + 1];
-						i++;
-					} else if (args[i] === "--context" && i + 1 < args.length) {
-						context = args[i + 1];
-						i++;
-					} else if (args[i] === "--gpus" && i + 1 < args.length) {
-						gpus = parseInt(args[i + 1], 10);
-						if (Number.isNaN(gpus) || gpus < 1) {
-							console.error(chalk.red("--gpus must be a positive number"));
-							process.exit(1);
-						}
-						i++;
-					} else if (args[i] === "--vllm") {
-						inVllmArgs = true;
-					}
-				}
-
-				if (!name) {
-					console.error("--name is required");
-					process.exit(1);
-				}
-
-				// Warn if --vllm is used with other parameters
-				if (vllmArgs.length > 0 && (memory || context || gpus)) {
-					console.log(
-						chalk.yellow("⚠ Warning: --memory, --context, and --gpus are ignored when --vllm is specified"),
-					);
-					console.log(chalk.yellow("  Using only custom vLLM arguments"));
-					console.log("");
-				}
-
-				await startModel(modelId, name, {
-					pod: podOverride,
-					memory,
-					context,
-					gpus,
-					vllmArgs: vllmArgs.length > 0 ? vllmArgs : undefined,
-				});
-				break;
-			}
-			case "stop": {
-				// pi stop [name] - stop specific model or all models
-				const name = args[1];
-				if (!name) {
-					// Stop all models on the active pod
-					await stopAllModels({ pod: podOverride });
-				} else {
-					await stopModel(name, { pod: podOverride });
-				}
-				break;
-			}
-			case "list":
-				// pi list
-				await listModels({ pod: podOverride });
-				break;
-			case "logs": {
-				// pi logs <name>
-				const name = args[1];
-				if (!name) {
-					console.error("Usage: pi logs <name>");
-					process.exit(1);
-				}
-				await viewLogs(name, { pod: podOverride });
-				break;
-			}
-			case "agent": {
-				// pi agent <name> [messages...] [options]
-				const name = args[1];
-				if (!name) {
-					console.error("Usage: pi agent <name> [messages...] [options]");
-					process.exit(1);
-				}
-
-				const apiKey = process.env.PI_API_KEY;
-
-				// Pass all args after the model name
-				const agentArgs = args.slice(2);
-
-				// If no messages provided, it's interactive mode
-				await promptModel(name, agentArgs, {
-					pod: podOverride,
-					apiKey,
-				}).catch(() => {
-					// Error already handled in promptModel, just exit cleanly
-					process.exit(0);
-				});
-				break;
-			}
-			default:
-				console.error(`Unknown command: ${command}`);
-				printHelp();
-				process.exit(1);
-		}
-	}
-} catch (error) {
-	console.error("Error:", error);
-	process.exit(1);
-}