chapman-sip 0.1.0__tar.gz

chapman_sip-0.1.0/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: chapman-sip
+Version: 0.1.0
+Summary: A CLI tool to run steerable models on the Chapman cluster with SSH port forwarding
+Author-email: Developer <developer@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: paramiko>=3.0.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: rich>=12.0.0
+
+# Chapman-Sip CLI
+
+A pip-installable Python command-line utility to connect to the Chapman cluster (`dgx0.chapman.edu`), pull the `steerable-model-runner` repository, find an open port, launch the model server, and tunnel the port back to your local machine.
+
+## Features
+
+- **Automated Host Setup**: Checks if the remote repository is cloned at `~/.steerable-models` on the cluster, cloning or pulling changes automatically.
+- **Dynamic Port Hunting**: Generates a random port and verifies it is not currently bound on the cluster before initiating.
+- **SSH Port Forwarding**: Automatically forwards the selected remote port to `localhost:[PORT]` locally.
+- **Interactive Log Streaming**: Streams stderr and stdout from the model serving script in real-time.
+- **Safe Shutdown**: Automatically cleans up the remote process, closes the port-forwarding server, and closes SSH channels on Ctrl+C.
+
+## Installation
+
+Install in editable mode for development or directly from the source directory:
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+Simply run:
+
+```bash
+sip
+```
+
+You will be prompted for:
+- SSH username
+- SSH password
+- Hugging Face API token (for model download)
+- Hugging Face repository name (e.g., the model repository to run)
+
+Once connected, the utility will output the endpoint URL, e.g.:
+```
+https://localhost:[PORT]/v1/
+```
+Keep the CLI running while you query the endpoint. Press `Ctrl+C` to terminate the model server and close the tunnel.

chapman_sip-0.1.0/README.md

@@ -0,0 +1,39 @@
+# Chapman-Sip CLI
+
+A pip-installable Python command-line utility to connect to the Chapman cluster (`dgx0.chapman.edu`), pull the `steerable-model-runner` repository, find an open port, launch the model server, and tunnel the port back to your local machine.
+
+## Features
+
+- **Automated Host Setup**: Checks if the remote repository is cloned at `~/.steerable-models` on the cluster, cloning or pulling changes automatically.
+- **Dynamic Port Hunting**: Generates a random port and verifies it is not currently bound on the cluster before initiating.
+- **SSH Port Forwarding**: Automatically forwards the selected remote port to `localhost:[PORT]` locally.
+- **Interactive Log Streaming**: Streams stderr and stdout from the model serving script in real-time.
+- **Safe Shutdown**: Automatically cleans up the remote process, closes the port-forwarding server, and closes SSH channels on Ctrl+C.
+
+## Installation
+
+Install in editable mode for development or directly from the source directory:
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+Simply run:
+
+```bash
+sip
+```
+
+You will be prompted for:
+- SSH username
+- SSH password
+- Hugging Face API token (for model download)
+- Hugging Face repository name (e.g., the model repository to run)
+
+Once connected, the utility will output the endpoint URL, e.g.:
+```
+https://localhost:[PORT]/v1/
+```
+Keep the CLI running while you query the endpoint. Press `Ctrl+C` to terminate the model server and close the tunnel.

chapman_sip-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "chapman-sip"
+version = "0.1.0"
+description = "A CLI tool to run steerable models on the Chapman cluster with SSH port forwarding"
+readme = "README.md"
+authors = [
+    { name = "Developer", email = "developer@example.com" }
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.8"
+dependencies = [
+    "paramiko>=3.0.0",
+    "click>=8.0.0",
+    "rich>=12.0.0",
+]
+
+[project.scripts]
+sip = "chapman_runner.cli:main"

chapman_sip-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

chapman_sip-0.1.0/src/chapman_runner/__init__.py

@@ -0,0 +1,5 @@
+"""
+Chapman Cluster Model Runner package.
+"""
+
+__version__ = "0.1.0"

chapman_sip-0.1.0/src/chapman_runner/cli.py

@@ -0,0 +1,409 @@
+import os
+import json
+import sys
+import time
+import click
+import shutil
+import socket
+import subprocess
+import webbrowser
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from chapman_runner.ssh import (
+    connect_ssh,
+    find_free_remote_port,
+    setup_remote_repo,
+    start_model_server,
+)
+from chapman_runner.tunnel import SSHTunnel
+
+console = Console()
+CACHE_FILE = os.path.expanduser("~/.sip_cache.json")
+
+def is_docker_running():
+    """
+    Checks if Docker is installed and the daemon is active.
+    """
+    if shutil.which("docker") is None:
+        return False
+    try:
+        result = subprocess.run(
+            ["docker", "info"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            timeout=5
+        )
+        return result.returncode == 0
+    except Exception:
+        return False
+
+def is_local_port_free(port):
+    """
+    Checks if a port is free on the local loopback.
+    """
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        try:
+            s.bind(("127.0.0.1", port))
+            return True
+        except OSError:
+            return False
+
+def find_free_local_port(start_port=3000):
+    """
+    Finds the first free local port starting at start_port.
+    """
+    port = start_port
+    while port < 65535:
+        if is_local_port_free(port):
+            return port
+        port += 1
+    raise RuntimeError("No free local ports found!")
+
+def start_open_webui(model_port):
+    """
+    Finds a local port, restarts the Open WebUI docker container,
+    and opens the URL in the browser.
+    """
+    if not is_docker_running():
+        console.print("[yellow]* Docker is not running or not installed. Skipping Open WebUI startup.[/yellow]")
+        return None
+
+    try:
+        webui_port = find_free_local_port(3000)
+        console.print(f"[cyan]Starting Open WebUI on local port {webui_port}...[/cyan]")
+        
+        # 1. Clean up any existing 'sip-open-webui' container
+        subprocess.run(
+            ["docker", "rm", "-f", "sip-open-webui"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL
+        )
+        
+        # 2. Run the new container
+        cmd = [
+            "docker", "run", "-d",
+            "--name", "sip-open-webui",
+            "-p", f"{webui_port}:8080",
+            "-e", f"OPENAI_API_BASE_URL=http://host.docker.internal:{model_port}/v1",
+            "-v", "open-webui:/app/backend/data",
+            "--restart", "always",
+            "ghcr.io/open-webui/open-webui:main"
+        ]
+        
+        result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        if result.returncode != 0:
+            console.print(f"[red]Failed to start Open WebUI container: {result.stderr.strip()}[/red]")
+            return None
+            
+        console.print(f"[green]* Open WebUI container started successfully (ID: {result.stdout.strip()[:12]}).[/green]")
+        
+        # 3. Open in browser
+        webui_url = f"http://localhost:{webui_port}"
+        console.print(f"[green]* Opening {webui_url} in default browser...[/green]")
+        webbrowser.open(webui_url)
+        
+        return webui_port
+    except Exception as e:
+        console.print(f"[red]Error starting Open WebUI: {e}[/red]")
+        return None
+
+def load_cache():
+    """
+    Loads saved configurations from the local cache file.
+    """
+    if os.path.exists(CACHE_FILE):
+        try:
+            with open(CACHE_FILE, "r") as f:
+                data = json.load(f)
+                if isinstance(data, dict) and "history" in data:
+                    return data
+        except Exception:
+            pass
+    return {"history": []}
+
+def save_cache(host, username, hf_token, hf_repo):
+    """
+    Saves a successful configuration run to the local cache file.
+    """
+    cache = load_cache()
+    history = cache.get("history", [])
+    
+    # Create the config object (passwords are NEVER cached)
+    config = {
+        "host": host,
+        "username": username,
+        "hf_token": hf_token,
+        "hf_repo": hf_repo
+    }
+    
+    # Remove any existing configuration for the same host, username, and repo to avoid duplication
+    history = [
+        c for c in history 
+        if not (c.get("host") == host and c.get("username") == username and c.get("hf_repo") == hf_repo)
+    ]
+    
+    # Insert new run configuration at the front
+    history.insert(0, config)
+    
+    # Keep only the last 10 configurations
+    cache["history"] = history[:10]
+    
+    try:
+        os.makedirs(os.path.dirname(CACHE_FILE), exist_ok=True)
+        with open(CACHE_FILE, "w") as f:
+            json.dump(cache, f, indent=4)
+    except Exception:
+        pass
+
+def print_banner():
+    banner = Text()
+    banner.append("\n", style="bold")
+    banner.append("+--------------------------------------------------------+\n", style="bold cyan")
+    banner.append("|           CHAPMAN CLUSTER MODEL RUNNER CLI             |\n", style="bold cyan")
+    banner.append("+--------------------------------------------------------+\n", style="bold cyan")
+    console.print(banner)
+
+@click.command()
+@click.option("--host", default="dgx0.chapman.edu", help="The Chapman cluster host address.")
+@click.option("--username", help="Your SSH username for the Chapman cluster.")
+def main(host, username):
+    """
+    CLI utility to connect to the Chapman cluster, set up steerable-model-runner,
+    and tunnel the serving port back to your local machine.
+    """
+    print_banner()
+
+    cache = load_cache()
+    history = cache.get("history", [])
+    selected_config = None
+    edit_config = False
+
+    while True:
+        selected_config = None
+        edit_config = False
+
+        # Check if there are cached configurations
+        if history:
+            console.print("[bold yellow]Saved configurations found:[/bold yellow]")
+            for idx, config in enumerate(history, 1):
+                console.print(f"[{idx}] [green]{config['hf_repo']}[/green] (on {config['host']} as {config['username']})")
+            console.print(f"[{len(history) + 1}] Start a new custom run...")
+            
+            choice = click.prompt(
+                click.style("Select an option", fg="green", bold=True),
+                type=click.IntRange(1, len(history) + 1),
+                default=1
+            )
+            
+            if choice <= len(history):
+                selected_config = history[choice - 1]
+            else:
+                selected_config = None
+
+        if selected_config:
+            console.print(f"\n[cyan]Selected:[/cyan] [green]{selected_config['hf_repo']}[/green] on {selected_config['host']} as {selected_config['username']}")
+            console.print("[1] Run directly")
+            console.print("[2] Edit this configuration")
+            console.print("[3] Cancel (Go back)")
+            
+            action = click.prompt(
+                click.style("Select action", fg="green", bold=True),
+                type=click.IntRange(1, 3),
+                default=1
+            )
+            
+            if action == 3:
+                console.print()
+                continue
+            elif action == 2:
+                edit_config = True
+                
+        break
+
+    # Resolve details based on selection or prompts
+    if selected_config and not edit_config:
+        host = selected_config.get("host")
+        username = selected_config.get("username")
+        hf_token = selected_config.get("hf_token")
+        hf_repo = selected_config.get("hf_repo")
+        
+        # Only prompt for the password
+        password = click.prompt(
+            click.style(f"Enter SSH Password for {username}", fg="green", bold=True),
+            hide_input=True,
+            type=str
+        )
+        
+        # If there is no hf_token in the cache, ask for it!
+        if not hf_token:
+            hf_token = click.prompt(
+                click.style("Enter Hugging Face API Token", fg="green", bold=True),
+                hide_input=True,
+                type=str
+            )
+    else:
+        # Defaults based on selection or the most recent run in history
+        default_host = selected_config.get("host") if selected_config else (host or "dgx0.chapman.edu")
+        default_username = selected_config.get("username") if selected_config else (username or (history[0]["username"] if history else None))
+        default_token = selected_config.get("hf_token") if selected_config else (history[0]["hf_token"] if history else None)
+        default_repo = selected_config.get("hf_repo") if selected_config else (history[0]["hf_repo"] if history else None)
+
+        host = click.prompt(
+            click.style("Enter Chapman Cluster Host", fg="green", bold=True),
+            default=default_host,
+            type=str
+        )
+
+        username = click.prompt(
+            click.style("Enter SSH Username", fg="green", bold=True),
+            default=default_username,
+            type=str
+        )
+        
+        password = click.prompt(
+            click.style(f"Enter SSH Password for {username}", fg="green", bold=True),
+            hide_input=True,
+            type=str
+        )
+        
+        hf_token = click.prompt(
+            click.style("Enter Hugging Face API Token", fg="green", bold=True),
+            default=default_token,
+            hide_input=True,
+            type=str
+        )
+        
+        hf_repo = click.prompt(
+            click.style("Enter Hugging Face Model Repository", fg="green", bold=True),
+            default=default_repo,
+            type=str
+        )
+
+    ssh_client = None
+    tunnel = None
+    channel = None
+
+    try:
+        # Step 1: Connect to the cluster
+        with console.status(f"[bold cyan]Connecting to {host}...[/bold cyan]") as status:
+            ssh_client = connect_ssh(host, username, password)
+        console.print(f"[green]* Connected to {host} successfully.[/green]")
+
+        # Step 2: Generate and verify remote port
+        with console.status("[bold cyan]Searching for an open port on the cluster...[/bold cyan]") as status:
+            port = find_free_remote_port(ssh_client)
+        console.print(f"[green]* Reserved free remote port: [bold]{port}[/bold][/green]")
+
+        # Step 3: Setup steerable-model-runner repo
+        with console.status("[bold cyan]Cloning/updating repository 'steerable-model-runner' on the cluster...[/bold cyan]") as status:
+            setup_remote_repo(
+                ssh_client,
+                repo_url="https://github.com/Alignment-Faking-Chapman/steerable-model-runner.git",
+                target_dir="~/.steerable-models"
+            )
+        console.print("[green]* Repository is set up and up-to-date in ~/.steerable-models.[/green]")
+
+        # Configuration succeeded, save to cache
+        save_cache(host, username, hf_token, hf_repo)
+
+        # Step 4: Setup local tunnel
+        tunnel = SSHTunnel(ssh_client, port)
+        tunnel.start()
+        console.print(f"[green]* Local SSH port forwarding active on port {port}.[/green]")
+
+        # Step 5: Start model server
+        console.print("[cyan]Starting model server on remote cluster...[/cyan]")
+        channel = start_model_server(
+            ssh_client,
+            repo_dir="~/.steerable-models",
+            hf_token=hf_token,
+            hf_repo=hf_repo,
+            port=port
+        )
+
+        # Trigger Open WebUI startup if Docker is running
+        webui_port = start_open_webui(port)
+
+        # Output the OpenAI endpoint
+        endpoint_url = f"https://localhost:{port}/v1/"
+        
+        # Display the endpoint beautifully
+        endpoint_text = Text()
+        endpoint_text.append("\nModel server is launching!\n\n", style="bold green")
+        endpoint_text.append("Your OpenAI-compatible local endpoint is:\n", style="white")
+        endpoint_text.append(f"  {endpoint_url}\n\n", style="bold underline yellow")
+        
+        if webui_port:
+            webui_url = f"http://localhost:{webui_port}"
+            endpoint_text.append("Open WebUI is running at:\n", style="white")
+            endpoint_text.append(f"  {webui_url}\n\n", style="bold underline yellow")
+            endpoint_text.append("Note: The model server is still downloading and loading weights.\n", style="cyan")
+            endpoint_text.append("The WebUI will become active once startup is complete.\n\n", style="cyan")
+
+        endpoint_text.append("Streaming remote logs below. Press ", style="white")
+        endpoint_text.append("Ctrl+C", style="bold red")
+        endpoint_text.append(" to stop the server and close the tunnel.\n", style="white")
+
+        console.print(Panel(endpoint_text, title="Endpoint Ready", border_style="cyan"))
+
+        # Keep reading remote logs and forward to local terminal
+        while True:
+            if channel.recv_ready():
+                data = channel.recv(4096)
+                if len(data) == 0:
+                    break
+                sys.stdout.buffer.write(data)
+                sys.stdout.flush()
+                
+            if channel.recv_stderr_ready():
+                data = channel.recv_stderr(4096)
+                if len(data) == 0:
+                    break
+                sys.stderr.buffer.write(data)
+                sys.stderr.flush()
+                
+            if channel.exit_status_ready():
+                exit_code = channel.recv_exit_status()
+                console.print(f"\n[yellow]Remote process exited with status {exit_code}.[/yellow]")
+                break
+                
+            time.sleep(0.01)
+
+        sys.exit(0)
+
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Received KeyboardInterrupt. Shutting down...[/yellow]")
+        sys.exit(0)
+    except Exception as e:
+        console.print(f"\n[bold red]Error: {e}[/bold red]")
+        sys.exit(1)
+    finally:
+        # Clean up
+        if channel:
+            console.print("[cyan]Terminating remote model server process...[/cyan]")
+            try:
+                # Send Ctrl+C (INT) to the pty
+                channel.send("\x03")
+                # Wait briefly
+                for _ in range(15):
+                    if channel.exit_status_ready():
+                        break
+                    time.sleep(0.1)
+                channel.close()
+            except Exception:
+                pass
+        
+        if tunnel:
+            console.print("[cyan]Stopping SSH tunnel...[/cyan]")
+            tunnel.stop()
+            
+        if ssh_client:
+            console.print("[cyan]Closing SSH connection...[/cyan]")
+            ssh_client.close()
+
+        console.print("[green]* Cleaned up successfully. Goodbye![/green]")
+
+if __name__ == "__main__":
+    main()

chapman_sip-0.1.0/src/chapman_runner/ssh.py

@@ -0,0 +1,100 @@
+import random
+import time
+import paramiko
+from rich.console import Console
+
+console = Console()
+
+def connect_ssh(host, username, password, port=22):
+    """
+    Establishes an SSH connection to the Chapman cluster.
+    """
+    client = paramiko.SSHClient()
+    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+    
+    try:
+        client.connect(
+            hostname=host,
+            port=port,
+            username=username,
+            password=password,
+            timeout=15,
+            look_for_keys=False,
+            allow_agent=False
+        )
+        return client
+    except Exception as e:
+        console.print(f"[red]Error connecting to {host}: {e}[/red]")
+        raise
+
+def is_port_free_remote(ssh_client, port):
+    """
+    Checks if a port is free on the remote machine by attempting to bind to it via Python.
+    """
+    # Run a quick python bind test on remote
+    cmd = f"python3 -c \"import socket; s = socket.socket(); s.bind(('127.0.0.1', {port}))\""
+    stdin, stdout, stderr = ssh_client.exec_command(cmd)
+    
+    # Wait for the command to finish
+    exit_status = stdout.channel.recv_exit_status()
+    return exit_status == 0
+
+def find_free_remote_port(ssh_client, min_port=15000, max_port=60000, max_attempts=20):
+    """
+    Finds a random free port on the remote machine.
+    """
+    for _ in range(max_attempts):
+        port = random.randint(min_port, max_port)
+        if is_port_free_remote(ssh_client, port):
+            return port
+    raise RuntimeError("Could not find a free port on the remote host after several attempts.")
+
+def setup_remote_repo(ssh_client, repo_url, target_dir="~/.steerable-models"):
+    """
+    Ensures the target repository is cloned and updated on the cluster.
+    """
+    # Shell commands to check if git repo exists, if not clone it, else pull it.
+    setup_cmd = f"""
+    if [ ! -d {target_dir}/.git ]; then
+        rm -rf {target_dir}
+        git clone {repo_url} {target_dir}
+    else
+        cd {target_dir} && git pull
+    fi
+    """
+    
+    stdin, stdout, stderr = ssh_client.exec_command(setup_cmd)
+    
+    # Read output to print if needed and wait for completion
+    exit_status = stdout.channel.recv_exit_status()
+    if exit_status != 0:
+        err_msg = stderr.read().decode().strip()
+        out_msg = stdout.read().decode().strip()
+        console.print(f"[red]Failed to setup repository on remote machine.[/red]")
+        if out_msg:
+            console.print(f"[yellow]Stdout:[/yellow]\n{out_msg}")
+        if err_msg:
+            console.print(f"[red]Stderr:[/red]\n{err_msg}")
+        raise RuntimeError("Failed to set up remote repository.")
+
+def start_model_server(ssh_client, repo_dir, hf_token, hf_repo, port):
+    """
+    Starts the model server remotely using a PTY session and returns the channel.
+    """
+    transport = ssh_client.get_transport()
+    if not transport:
+        raise RuntimeError("SSH Transport is not active.")
+        
+    channel = transport.open_session()
+    # Request a PTY to ensure child processes are terminated when the session is closed,
+    # and to enable real-time ANSI log formatting.
+    channel.get_pty()
+    
+    cmd = (
+        f"chmod +x {repo_dir}/run.sh && "
+        f"cd {repo_dir} && "
+        f"./run.sh --hf_token '{hf_token}' --hf_repo '{hf_repo}' --port {port}"
+    )
+    
+    channel.exec_command(cmd)
+    return channel

chapman_sip-0.1.0/src/chapman_runner/tunnel.py

@@ -0,0 +1,80 @@
+import select
+import socketserver
+import threading
+from rich.console import Console
+
+console = Console()
+
+class ForwardServer(socketserver.ThreadingTCPServer):
+    daemon_threads = True
+    allow_reuse_address = True
+
+class Handler(socketserver.BaseRequestHandler):
+    """
+    Handles local requests and tunnels them through the Paramiko SSH transport channel.
+    """
+    def handle(self):
+        try:
+            chan = self.ssh_transport.open_channel(
+                "direct-tcpip",
+                ("127.0.0.1", self.chain_port),
+                self.request.getpeername(),
+            )
+        except Exception as e:
+            # Log connection issues at verbose/debug levels if needed
+            return
+            
+        if chan is None:
+            return
+
+        try:
+            while True:
+                r, w, x = select.select([self.request, chan], [], [])
+                if self.request in r:
+                    data = self.request.recv(4096)
+                    if len(data) == 0:
+                        break
+                    chan.sendall(data)
+                if chan in r:
+                    data = chan.recv(4096)
+                    if len(data) == 0:
+                        break
+                    self.request.sendall(data)
+        except Exception:
+            pass
+        finally:
+            chan.close()
+            self.request.close()
+
+class SSHTunnel:
+    """
+    Manager for setting up and tearing down the SSH port-forwarding tunnel.
+    """
+    def __init__(self, ssh_client, port):
+        self.ssh_transport = ssh_client.get_transport()
+        self.port = port
+        self.server = None
+        self.thread = None
+
+    def start(self):
+        # Create a dynamically subclassed handler to inject the transport and target port
+        class CustomHandler(Handler):
+            ssh_transport = self.ssh_transport
+            chain_port = self.port
+
+        try:
+            self.server = ForwardServer(("127.0.0.1", self.port), CustomHandler)
+            self.thread = threading.Thread(target=self.server.serve_forever, daemon=True)
+            self.thread.start()
+        except Exception as e:
+            console.print(f"[red]Failed to start local forwarding server on port {self.port}: {e}[/red]")
+            raise
+
+    def stop(self):
+        if self.server:
+            self.server.shutdown()
+            self.server.server_close()
+            self.server = None
+        if self.thread:
+            self.thread.join(timeout=1.0)
+            self.thread = None

chapman_sip-0.1.0/src/chapman_sip.egg-info/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: chapman-sip
+Version: 0.1.0
+Summary: A CLI tool to run steerable models on the Chapman cluster with SSH port forwarding
+Author-email: Developer <developer@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: paramiko>=3.0.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: rich>=12.0.0
+
+# Chapman-Sip CLI
+
+A pip-installable Python command-line utility to connect to the Chapman cluster (`dgx0.chapman.edu`), pull the `steerable-model-runner` repository, find an open port, launch the model server, and tunnel the port back to your local machine.
+
+## Features
+
+- **Automated Host Setup**: Checks if the remote repository is cloned at `~/.steerable-models` on the cluster, cloning or pulling changes automatically.
+- **Dynamic Port Hunting**: Generates a random port and verifies it is not currently bound on the cluster before initiating.
+- **SSH Port Forwarding**: Automatically forwards the selected remote port to `localhost:[PORT]` locally.
+- **Interactive Log Streaming**: Streams stderr and stdout from the model serving script in real-time.
+- **Safe Shutdown**: Automatically cleans up the remote process, closes the port-forwarding server, and closes SSH channels on Ctrl+C.
+
+## Installation
+
+Install in editable mode for development or directly from the source directory:
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+Simply run:
+
+```bash
+sip
+```
+
+You will be prompted for:
+- SSH username
+- SSH password
+- Hugging Face API token (for model download)
+- Hugging Face repository name (e.g., the model repository to run)
+
+Once connected, the utility will output the endpoint URL, e.g.:
+```
+https://localhost:[PORT]/v1/
+```
+Keep the CLI running while you query the endpoint. Press `Ctrl+C` to terminate the model server and close the tunnel.

chapman_sip-0.1.0/src/chapman_sip.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+src/chapman_runner/__init__.py
+src/chapman_runner/cli.py
+src/chapman_runner/ssh.py
+src/chapman_runner/tunnel.py
+src/chapman_sip.egg-info/PKG-INFO
+src/chapman_sip.egg-info/SOURCES.txt
+src/chapman_sip.egg-info/dependency_links.txt
+src/chapman_sip.egg-info/entry_points.txt
+src/chapman_sip.egg-info/requires.txt
+src/chapman_sip.egg-info/top_level.txt

chapman_sip-0.1.0/src/chapman_sip.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chapman_sip-0.1.0/src/chapman_sip.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sip = chapman_runner.cli:main

chapman_sip-0.1.0/src/chapman_sip.egg-info/requires.txt

@@ -0,0 +1,3 @@
+paramiko>=3.0.0
+click>=8.0.0
+rich>=12.0.0

chapman_sip-0.1.0/src/chapman_sip.egg-info/top_level.txt

@@ -0,0 +1 @@
+chapman_runner