oneinfer-cli 0.1.0__tar.gz

oneinfer_cli-0.1.0/.gitignore

@@ -0,0 +1,221 @@
+# Byte-compiled / optimized / DLL files
+__pycache__
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+logs/
+*.log
+.logs/
+src/.screenshots/
+yolov5/
+
+# Keys and certificates
+*.pem
+logs/gpu_monitor.log
+*.key
+*.crt
+*.p12
+*.pfx
+*.jks
+*.keystore
+
+# Secrets and credentials
+.secrets/
+secrets/
+credentials/
+*.secret
+*.credentials
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+
+# Temporary files
+*.tmp
+*.temp
+.cache/
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# IDE and editor files
+.vscode/settings.json
+.idea/
+*.swp
+*.swo
+*~
+
+# Logs and screenshots
+.logs/
+src/.logs/
+src/.screenshots/
+
+# Node modules (if any)
+node_modules/
+
+# Docker
+.dockerignore
+
+# Sensitive documentation
+CREDENTIAL_ROTATION.md
+GITHUB_SECRETS_UPDATE.md
+
+# Temporary files and test scripts
+tmp/
+test_script.ps1
+patch_mongo_uri.ps1
+tests/local/
+
+# Base64 encoded secrets
+*.b64
+
+CUsersUser.kubeconfig

oneinfer_cli-0.1.0/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: oneinfer-cli
+Version: 0.1.0
+Summary: Seamlessly deploy local Docker containers to OneInfer GPU instances over SSH.
+Author-email: OneInfer <hello@oneinfer.com>
+License-Expression: MIT
+Requires-Python: >=3.8
+Requires-Dist: paramiko>=3.0.0
+Requires-Dist: requests>=2.30.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Description-Content-Type: text/markdown
+
+# OneInfer Developer CLI 🚀
+
+The official, open-source Developer CLI for seamlessly testing and deploying local Docker containers to OneInfer GPU instances over SSH.
+
+> ⚠️ Note: OneInfer GPU instances are secure, unprivileged containers. They do not run a full `dockerd` daemon. Therefore, you cannot simply `docker run` inside them. This CLI handles the complexity of tunneling your image and running it via user-space container runtimes (`udocker`) automatically!
+
+## Installation
+
+```bash
+pip install oneinfer-cli
+```
+*(Optionally use `pipx install oneinfer-cli` for global isolation).*
+
+## Getting Started
+
+1. **Login**: Authenticate your CLI with your OneInfer Account.
+   ```bash
+   oneinfer login
+   # Paste your API Token when prompted
+   ```
+
+2. **Build Your AI App**: Build your standard Docker container locally.
+   ```bash
+   docker build -t my-custom-llm:v1 .
+   ```
+
+3. **Deploy to a GPU Instance**: Push and run it directly to your running OneInfer instance.
+   ```bash
+   oneinfer deploy my-custom-llm:v1 --instance-id xyz-1234
+   ```
+
+### What happens under the hood?
+When you run `deploy`, the CLI:
+1. Talks to the OneInfer API to securely fetch your instance's SSH dynamically.
+2. Runs `docker save` locally to bundle your image.
+3. Transmits the bundle over SSH via SCP.
+4. Instructs the remote instance to load and run the container securely in user-space with full GPU passthrough using `udocker run --nv my-custom-llm:v1`.
+
+## Contributing
+We welcome PRs! Ensure you have `hatch` installed, and run `pip install -e .` to develop locally.

oneinfer_cli-0.1.0/README.md

@@ -0,0 +1,40 @@
+# OneInfer Developer CLI 🚀
+
+The official, open-source Developer CLI for seamlessly testing and deploying local Docker containers to OneInfer GPU instances over SSH.
+
+> ⚠️ Note: OneInfer GPU instances are secure, unprivileged containers. They do not run a full `dockerd` daemon. Therefore, you cannot simply `docker run` inside them. This CLI handles the complexity of tunneling your image and running it via user-space container runtimes (`udocker`) automatically!
+
+## Installation
+
+```bash
+pip install oneinfer-cli
+```
+*(Optionally use `pipx install oneinfer-cli` for global isolation).*
+
+## Getting Started
+
+1. **Login**: Authenticate your CLI with your OneInfer Account.
+   ```bash
+   oneinfer login
+   # Paste your API Token when prompted
+   ```
+
+2. **Build Your AI App**: Build your standard Docker container locally.
+   ```bash
+   docker build -t my-custom-llm:v1 .
+   ```
+
+3. **Deploy to a GPU Instance**: Push and run it directly to your running OneInfer instance.
+   ```bash
+   oneinfer deploy my-custom-llm:v1 --instance-id xyz-1234
+   ```
+
+### What happens under the hood?
+When you run `deploy`, the CLI:
+1. Talks to the OneInfer API to securely fetch your instance's SSH dynamically.
+2. Runs `docker save` locally to bundle your image.
+3. Transmits the bundle over SSH via SCP.
+4. Instructs the remote instance to load and run the container securely in user-space with full GPU passthrough using `udocker run --nv my-custom-llm:v1`.
+
+## Contributing
+We welcome PRs! Ensure you have `hatch` installed, and run `pip install -e .` to develop locally.

oneinfer_cli-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "oneinfer-cli"
+version = "0.1.0"
+description = "Seamlessly deploy local Docker containers to OneInfer GPU instances over SSH."
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+authors = [
+  { name = "OneInfer", email = "hello@oneinfer.com" }
+]
+dependencies = [
+    "typer>=0.9.0",
+    "rich>=13.0.0",
+    "requests>=2.30.0",
+    "paramiko>=3.0.0"
+]
+
+[project.scripts]
+oneinfer = "oneinfer_cli.main:app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/oneinfer_cli"]

oneinfer_cli-0.1.0/src/oneinfer_cli/auth.py

@@ -0,0 +1,70 @@
+import json
+import os
+import requests
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".oneinfer"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+API_BASE_URL = "https://api.oneinfer.com/v1"  # Production URL or Staging URL
+
+def save_token(token: str) -> bool:
+    try:
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        config = {}
+        if CONFIG_FILE.exists():
+            with open(CONFIG_FILE, "r") as f:
+                config = json.load(f)
+        
+        config["api_key"] = token
+        
+        with open(CONFIG_FILE, "w") as f:
+            json.dump(config, f)
+        
+        # Secure the file (Unix only)
+        if os.name != 'nt':
+            os.chmod(CONFIG_FILE, 0o600)
+            
+        return True
+    except Exception as e:
+        print(f"Error saving config: {e}")
+        return False
+
+def get_token() -> str:
+    try:
+        if CONFIG_FILE.exists():
+            with open(CONFIG_FILE, "r") as f:
+                config = json.load(f)
+                return config.get("api_key")
+        return os.environ.get("ONEINFER_API_KEY") # Fallback to ENV Var
+    except Exception:
+        return None
+
+def fetch_instance_ssh_details(token: str, instance_id: str):
+    """Hits the /get-instance backend API to retrieve SSH host, port, password."""
+    # Note: In a real CLI, we might need the provider name or the backend handles wildcard ID lookup.
+    # We assume the user has a developer_id, or the backend infers it from the api_key.
+    
+    # Example logic using the actual OneInfer backend spec:
+    # A robust CLI would either require `provider_name` or the backend would provide a flat `/instances/{id}` route.
+    
+    # Placeholder for the actual backend call:
+    headers = {"Authorization": f"Bearer {token}"}
+    try:
+        # Note: Replace with actual endpoint URL. Since the backend /get-instance route
+        # requires `developer_id` and `provider_name`, a dedicated CLI endpoint 
+        # (e.g. /v1/cli/instance-ssh/{instance_id}) might be cleaner to add to backend later.
+        
+        # For Demo/Mock purposes until we wire it precisely:
+        # response = requests.get(f"{API_BASE_URL}/instances/{instance_id}/ssh-details", headers=headers)
+        # response.raise_for_status()
+        # return response.json()
+        
+        # Mock Response
+        return {
+            "ssh_host": "mock.gpu-instance.oneinfer.com",
+            "ssh_port": 22000,
+            "ssh_password": "mocked-secure-password"
+        }
+    except Exception as e:
+        print(f"API Error: {e}")
+        return None

oneinfer_cli-0.1.0/src/oneinfer_cli/main.py

@@ -0,0 +1,78 @@
+import os
+import sys
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from oneinfer_cli import auth, ssh_utils
+
+app = typer.Typer(help="OneInfer Developer CLI: Seamlessly push and deploy Docker containers to your GPU.")
+console = Console()
+
+@app.command()
+def login(api_key: str = typer.Option(..., prompt=True, hide_input=True, help="Your OneInfer API Token")):
+    """Authenticate the CLI with your OneInfer account."""
+    if auth.save_token(api_key):
+        console.print("[bold green]✅ Login successful![/bold green] Credentials saved.")
+    else:
+        console.print("[bold red]❌ Failed to save credentials.[/bold red]")
+
+
+@app.command()
+def deploy(
+    image: str = typer.Argument(..., help="Local Docker image tag (e.g., my-app:latest)"),
+    instance_id: str = typer.Option(..., "--instance-id", "-i", help="OneInfer GPU Instance ID")
+):
+    """Deploy a local Docker container directly to a remote GPU Instance."""
+    token = auth.get_token()
+    if not token:
+        console.print("[bold red]❌ You must be logged in. Run `oneinfer login` first.[/bold red]")
+        raise typer.Exit(code=1)
+
+    console.print(Panel(f"🚀 Deploying [bold cyan]{image}[/bold cyan] to instance [bold yellow]{instance_id}[/bold yellow]"))
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        transient=False,
+    ) as progress:
+        
+        # 1. Fetch SSH Info
+        task_fetch = progress.add_task("Fetching instance credentials...", total=None)
+        instance_details = auth.fetch_instance_ssh_details(token, instance_id)
+        if not instance_details:
+            progress.update(task_fetch, completed=True, description="[red]❌ Failed to get instance details.[/red]")
+            raise typer.Exit(code=1)
+        progress.update(task_fetch, completed=True, description="[green]✅ Instance reachable.[/green]")
+
+        # 2. Export Docker Image
+        task_export = progress.add_task(f"Exporting local image [bold]{image}[/bold]...", total=None)
+        tar_path = ssh_utils.export_docker_image(image)
+        if not tar_path:
+             progress.update(task_export, completed=True, description="[red]❌ Failed to export docker image. Is Docker running?[/red]")
+             raise typer.Exit(code=1)
+        progress.update(task_export, completed=True, description="[green]✅ Image bundled.[/green]")
+
+        # 3. Transfer & Load
+        task_upload = progress.add_task("Uploading and loading container to GPU instance over SSH...", total=None)
+        success = ssh_utils.transfer_and_load_image(
+            tar_path=tar_path, 
+            image_name=image,
+            ssh_host=instance_details['ssh_host'],
+            ssh_port=instance_details['ssh_port'],
+            ssh_password=instance_details['ssh_password']
+        )
+
+        if not success:
+            progress.update(task_upload, completed=True, description="[red]❌ Deployment failed.[/red]")
+            raise typer.Exit(code=1)
+            
+        progress.update(task_upload, completed=True, description="[green]✅ Container uploaded and loaded![/green]")
+
+    console.print("\n[bold green]🎉 Deployment Successful![/bold green]")
+    console.print(f"To run your app, SSH into your instance and run:\n  > [bold cyan]udocker run --nv {image}[/bold cyan]")
+
+
+if __name__ == "__main__":
+    app()

oneinfer_cli-0.1.0/src/oneinfer_cli/ssh_utils.py

@@ -0,0 +1,70 @@
+import subprocess
+import os
+import paramiko
+from scp import SCPClient
+
+def export_docker_image(image_name: str, output_tar: str = "image.tar") -> str:
+    """Exports a local Docker image to a tarball."""
+    print(f"Exporting local Docker image '{image_name}'...")
+    try:
+        # We can pipe through gzip later, but tar is simpler to demonstrate
+        result = subprocess.run(
+            ["docker", "save", "-o", output_tar, image_name],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        if result.returncode != 0:
+            print(f"Docker save failed: {result.stderr}")
+            return None
+        return output_tar
+    except Exception as e:
+        print(f"Failed to find or run docker: {e}")
+        return None
+
+def create_ssh_client(server, port, user, password):
+    client = paramiko.SSHClient()
+    client.load_system_host_keys()
+    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+    client.connect(server, port=port, username=user, password=password)
+    return client
+
+def transfer_and_load_image(tar_path: str, image_name: str, ssh_host: str, ssh_port: int, ssh_password: str) -> bool:
+    """Uploads the tarball over SSH and loads it using udocker on the remote instance."""
+    ssh = None
+    try:
+        ssh = create_ssh_client(ssh_host, ssh_port, "root", ssh_password)
+        
+        # 1. SCP Upload
+        print(f"Uploading {tar_path} to {ssh_host}:{ssh_port} via SCP...")
+        with SCPClient(ssh.get_transport()) as scp:
+            scp.put(tar_path, f"/tmp/{tar_path}")
+            
+        print("Upload complete. Loading image into remote user-space registry (udocker)...")
+        
+        # 2. Remote Udocker Load
+        # udocker command is pre-installed via the OneInfer startup_script injected during create-instance
+        udocker_cmd = f"udocker load -i /tmp/{tar_path}"
+        stdin, stdout, stderr = ssh.exec_command(udocker_cmd)
+        
+        # Wait for command to finish
+        exit_status = stdout.channel.recv_exit_status()
+        if exit_status != 0:
+            err = stderr.read().decode('utf-8')
+            print(f"Remote udocker load failed: {err}")
+            return False
+            
+        # 3. Clean up remote tarball
+        ssh.exec_command(f"rm /tmp/{tar_path}")
+        
+        # Clean up local tarball
+        if os.path.exists(tar_path):
+            os.remove(tar_path)
+            
+        return True
+    except Exception as e:
+        print(f"SSH Transfer completely failed: {e}")
+        return False
+    finally:
+        if ssh:
+            ssh.close()