nexinal 1.0.2__py3-none-any.whl

nexinal/__init__.py

@@ -0,0 +1,4 @@
+"""nexinal - CLI client for Nexuss Bash remote execution API."""
+
+__version__ = "1.0.2"
+__app_name__ = "nexinal"

nexinal/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running nexinal as a module: python -m nexinal."""
+
+from nexinal.cli import main
+
+if __name__ == "__main__":
+    main()

nexinal/api.py

@@ -0,0 +1,149 @@
+"""API client for Nexuss Bash."""
+
+import json
+from typing import Optional, Any
+
+import requests
+from requests.exceptions import ConnectionError, HTTPError, RequestException, Timeout
+
+from nexinal.config import get_api_url, get_token
+
+
+class APIError(Exception):
+    def __init__(self, message: str, status_code: Optional[int] = None):
+        self.message = message
+        self.status_code = status_code
+        super().__init__(self.message)
+
+
+class AuthError(APIError):
+    pass
+
+
+class ConnectionError_(APIError):
+    pass
+
+
+def _build_headers() -> dict:
+    headers = {"Content-Type": "application/json"}
+    token = get_token()
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    return headers
+
+
+def _build_url(path: str) -> str:
+    base = get_api_url().rstrip("/")
+    path = path.lstrip("/")
+    return f"{base}/{path}"
+
+
+def api_get(path: str) -> dict:
+    url = _build_url(path)
+    try:
+        resp = requests.get(url, headers=_build_headers(), timeout=30)
+        resp.raise_for_status()
+        return resp.json()
+    except HTTPError as e:
+        status = e.response.status_code if e.response is not None else None
+        if status == 401:
+            raise AuthError("Authentication failed. Run: nexinal auth <token>", status)
+        if status == 404:
+            raise APIError(f"Not found: {path}", status)
+        raise APIError(f"HTTP {status}: {e}", status)
+    except ConnectionError:
+        raise ConnectionError_(f"Cannot connect to {url}. Check your network and API URL.")
+    except Timeout:
+        raise APIError(f"Request timed out: {url}")
+    except RequestException as e:
+        raise APIError(f"Request failed: {e}")
+    except json.JSONDecodeError:
+        raise APIError("Invalid JSON response from server")
+
+
+def api_post(path: str, data: Optional[dict] = None) -> dict:
+    url = _build_url(path)
+    try:
+        resp = requests.post(url, headers=_build_headers(), json=data or {}, timeout=30)
+        resp.raise_for_status()
+        return resp.json()
+    except HTTPError as e:
+        status = e.response.status_code if e.response is not None else None
+        if status == 401:
+            raise AuthError("Authentication failed. Run: nexinal auth <token>", status)
+        if status == 404:
+            raise APIError(f"Not found: {path}", status)
+        body = ""
+        if e.response is not None:
+            try:
+                body = e.response.json().get("detail", e.response.text)
+            except Exception:
+                body = e.response.text
+        raise APIError(f"HTTP {status}: {body}", status)
+    except ConnectionError:
+        raise ConnectionError_(f"Cannot connect to {url}. Check your network and API URL.")
+    except Timeout:
+        raise APIError(f"Request timed out: {url}")
+    except RequestException as e:
+        raise APIError(f"Request failed: {e}")
+    except json.JSONDecodeError:
+        raise APIError("Invalid JSON response from server")
+
+
+def api_post_file(path: str, file_path: str) -> dict:
+    url = _build_url(path)
+    token = get_token()
+    headers = {}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    try:
+        with open(file_path, "rb") as f:
+            files = {"file": (file_path.split("/")[-1], f)}
+            resp = requests.post(url, headers=headers, files=files, timeout=60)
+        resp.raise_for_status()
+        return resp.json()
+    except HTTPError as e:
+        status = e.response.status_code if e.response is not None else None
+        if status == 401:
+            raise AuthError("Authentication failed. Run: nexinal auth <token>", status)
+        raise APIError(f"HTTP {status}: {e}", status)
+    except ConnectionError:
+        raise ConnectionError_(f"Cannot connect to {url}. Check your network and API URL.")
+    except Timeout:
+        raise APIError(f"Request timed out: {url}")
+    except RequestException as e:
+        raise APIError(f"Request failed: {e}")
+    except FileNotFoundError:
+        raise APIError(f"File not found: {file_path}")
+    except json.JSONDecodeError:
+        raise APIError("Invalid JSON response from server")
+
+
+def api_delete(path: str) -> dict:
+    url = _build_url(path)
+    try:
+        resp = requests.delete(url, headers=_build_headers(), timeout=30)
+        resp.raise_for_status()
+        return resp.json()
+    except HTTPError as e:
+        status = e.response.status_code if e.response is not None else None
+        if status == 401:
+            raise AuthError("Authentication failed. Run: nexinal auth <token>", status)
+        raise APIError(f"HTTP {status}: {e}", status)
+    except ConnectionError:
+        raise ConnectionError_(f"Cannot connect to {url}. Check your network and API URL.")
+    except Timeout:
+        raise APIError(f"Request timed out: {url}")
+    except RequestException as e:
+        raise APIError(f"Request failed: {e}")
+    except json.JSONDecodeError:
+        raise APIError("Invalid JSON response from server")
+
+
+def test_connection() -> bool:
+    try:
+        url = _build_url("/health")
+        resp = requests.get(url, timeout=10)
+        return resp.status_code == 200
+    except Exception:
+        return False

nexinal/cli.py

@@ -0,0 +1,359 @@
+"""Main Click CLI for nexinal."""
+
+import sys
+from typing import List
+
+import click
+
+from nexinal import __version__
+from nexinal.config import (
+    load_config, save_config, get_token, get_api_url,
+    set_token, set_api_url, remove_token, get_last_run_id,
+)
+from nexinal.api import api_get, api_post, APIError, AuthError, ConnectionError_, test_connection
+from nexinal.runner import run_commands
+from nexinal.yaml_parser import parse_yaml_file, YAMLError, CommandEntry
+from nexinal.display import (
+    console, print_banner, print_result, print_error,
+    print_success, print_warning, print_info, print_status,
+    create_results_table,
+)
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="nexinal")
+def main():
+    """nexinal - CLI client for Nexuss Bash remote execution API."""
+    pass
+
+
+@main.command()
+@click.argument("token")
+def auth(token: str):
+    """Save authentication token and verify it."""
+    print_info("Verifying connection...")
+
+    old_token = get_token()
+    set_token(token)
+
+    try:
+        resp = api_get("/health")
+        server_name = resp.get("name", resp.get("server_name", "Nexuss Bash"))
+        print_success(f"Connected to {server_name}")
+        print_success(f"Token saved to ~/.nexinal/config.json")
+    except ConnectionError_ as e:
+        set_token(old_token or "")
+        if old_token is None:
+            remove_token()
+        print_error(f"Cannot reach server: {e}")
+        sys.exit(1)
+    except APIError as e:
+        set_token(old_token or "")
+        if old_token is None:
+            remove_token()
+        print_error(f"Connection check failed: {e}")
+        sys.exit(1)
+    except AuthError as e:
+        set_token(old_token or "")
+        if old_token is None:
+            remove_token()
+        print_error(f"Auth failed: {e}")
+        sys.exit(1)
+    except Exception as e:
+        set_token(old_token or "")
+        if old_token is None:
+            remove_token()
+        print_error(f"Unexpected error: {e}")
+        sys.exit(1)
+
+
+@main.command()
+@click.argument("commands", nargs=-1, required=True)
+@click.option("--stop-on-fail", is_flag=True, help="Stop on first failed command")
+def run(commands: tuple, stop_on_fail: bool):
+    """Run commands sequentially on the remote server.
+
+    Each argument is a separate command to execute.
+
+    Example: nexinal run "echo hello" "whoami" "ls /workspace"
+    """
+    if not commands:
+        print_error("No commands provided")
+        sys.exit(1)
+
+    result = run_commands(list(commands), stop_on_fail=stop_on_fail)
+    if not result.success:
+        sys.exit(1)
+
+
+@main.command()
+@click.argument("yaml_file")
+@click.option("--stop-on-fail", is_flag=True, help="Stop on first failed command")
+def execute(yaml_file: str, stop_on_fail: bool):
+    """Execute commands from a YAML file.
+
+    Supports both simple (list of strings) and detailed (objects) formats.
+    """
+    try:
+        commands = parse_yaml_file(yaml_file)
+    except YAMLError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+    print_info(f"Loaded {len(commands)} command(s) from {yaml_file}")
+    result = run_commands(commands, stop_on_fail=stop_on_fail)
+    if not result.success:
+        sys.exit(1)
+
+
+@main.command()
+def status():
+    """Show connection status and configuration info."""
+    token = get_token()
+    api_url = get_api_url()
+    last_run_id = get_last_run_id()
+
+    connected = test_connection()
+
+    authenticated = False
+    if token and connected:
+        try:
+            api_get("/health")
+            authenticated = True
+        except AuthError:
+            authenticated = False
+        except Exception:
+            authenticated = False
+
+    print_status({
+        "connected": connected,
+        "api_url": api_url,
+        "token": token,
+        "authenticated": authenticated,
+        "last_run_id": last_run_id,
+    })
+
+
+@main.command()
+def history():
+    """List past runs."""
+    if not get_token():
+        print_error("Not authenticated. Run: nexinal auth <token>")
+        sys.exit(1)
+
+    try:
+        resp = api_get("/run")
+    except APIError as e:
+        print_error(str(e))
+        sys.exit(1)
+    except ConnectionError_ as e:
+        print_error(str(e))
+        sys.exit(1)
+
+    runs = resp if isinstance(resp, list) else resp.get("runs", resp.get("data", []))
+
+    if not runs:
+        print_info("No runs found")
+        return
+
+    from rich.table import Table
+    from rich import box
+
+    table = Table(title="Run History", box=box.ROUNDED, show_lines=True)
+    table.add_column("Run ID", style="bold cyan", max_width=12)
+    table.add_column("Status", justify="center", width=10)
+    table.add_column("Commands", justify="center", width=10)
+    table.add_column("Created", style="dim")
+
+    for run_entry in runs:
+        run_id = str(run_entry.get("id", run_entry.get("run_id", "-")))
+        if len(run_id) > 12:
+            run_id = run_id[:9] + "..."
+        run_status = run_entry.get("status", "unknown")
+        num_commands = run_entry.get("num_commands", len(run_entry.get("commands", [])))
+        created = run_entry.get("created_at", run_entry.get("timestamp", "-"))
+
+        if run_status in ("completed", "success", "passed"):
+            status_display = Text("✓ " + run_status, style="green")
+        elif run_status in ("failed", "error"):
+            status_display = Text("✗ " + run_status, style="red")
+        else:
+            status_display = Text(run_status, style="yellow")
+
+        table.add_row(run_id, status_display, str(num_commands), str(created))
+
+    console.print(table)
+
+
+@main.command()
+def health():
+    """Quick health check against the API server."""
+    api_url = get_api_url()
+    print_info(f"Checking {api_url}...")
+
+    if test_connection():
+        try:
+            resp = api_get("/health")
+            server_name = resp.get("name", resp.get("server_name", "Nexuss Bash"))
+            version = resp.get("version", "unknown")
+            print_success(f"{server_name} is healthy (v{version})")
+        except Exception:
+            print_success(f"Server at {api_url} is reachable")
+    else:
+        print_error(f"Server at {api_url} is not reachable")
+        sys.exit(1)
+
+
+@main.command()
+def sessions():
+    """List active sessions."""
+    if not get_token():
+        print_error("Not authenticated. Run: nexinal auth <token>")
+        sys.exit(1)
+
+    try:
+        resp = api_get("/sessions")
+    except APIError as e:
+        print_error(str(e))
+        sys.exit(1)
+    except ConnectionError_ as e:
+        print_error(str(e))
+        sys.exit(1)
+
+    session_list = resp if isinstance(resp, list) else resp.get("sessions", resp.get("data", []))
+
+    if not session_list:
+        print_info("No active sessions")
+        return
+
+    from rich.table import Table
+    from rich import box
+
+    table = Table(title="Active Sessions", box=box.ROUNDED, show_lines=True)
+    table.add_column("Session ID", style="bold cyan", max_width=16)
+    table.add_column("Status", justify="center", width=10)
+    table.add_column("Created", style="dim")
+
+    for sess in session_list:
+        sess_id = str(sess.get("id", sess.get("session_id", "-")))
+        if len(sess_id) > 16:
+            sess_id = sess_id[:13] + "..."
+        sess_status = sess.get("status", "active")
+        created = sess.get("created_at", "-")
+
+        table.add_row(sess_id, sess_status, str(created))
+
+    console.print(table)
+
+
+@main.group()
+def packages():
+    """Manage installed packages."""
+    pass
+
+
+@packages.command("list")
+def packages_list():
+    """List installed packages."""
+    if not get_token():
+        print_error("Not authenticated. Run: nexinal auth <token>")
+        sys.exit(1)
+
+    try:
+        resp = api_get("/packages")
+    except APIError as e:
+        print_error(str(e))
+        sys.exit(1)
+    except ConnectionError_ as e:
+        print_error(str(e))
+        sys.exit(1)
+
+    pkgs = resp if isinstance(resp, list) else resp.get("packages", resp.get("data", []))
+
+    if not pkgs:
+        print_info("No packages installed")
+        return
+
+    from rich.table import Table
+    from rich import box
+
+    table = Table(title="Installed Packages", box=box.ROUNDED, show_lines=True)
+    table.add_column("Name", style="bold", ratio=2)
+    table.add_column("Version", style="dim", ratio=1)
+    table.add_column("Manager", justify="center", width=10)
+
+    for pkg in pkgs:
+        name = pkg.get("name", "?")
+        version = pkg.get("version", "-")
+        manager = pkg.get("manager", pkg.get("package_manager", "-"))
+        table.add_row(str(name), str(version), str(manager))
+
+    console.print(table)
+
+
+@packages.command("install")
+@click.argument("name")
+@click.option("--manager", type=click.Choice(["apt", "pip", "npm"]), required=True, help="Package manager to use")
+def packages_install(name: str, manager: str):
+    """Install a package on the remote server."""
+    if not get_token():
+        print_error("Not authenticated. Run: nexinal auth <token>")
+        sys.exit(1)
+
+    print_info(f"Installing {name} via {manager}...")
+
+    try:
+        resp = api_post("/packages/install", {"name": name, "manager": manager})
+        output = resp.get("output", resp.get("detail", ""))
+        if output:
+            console.print(output)
+        print_success(f"Installed {name} via {manager}")
+    except APIError as e:
+        print_error(str(e))
+        sys.exit(1)
+    except ConnectionError_ as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@main.command()
+@click.option("--set", "set_url", help="Set a new API URL")
+@click.option("--show", "show_url", is_flag=True, help="Show current API URL")
+def config(set_url: str, show_url: bool):
+    """Show or set API URL configuration."""
+    if set_url:
+        set_api_url(set_url)
+        print_success(f"API URL set to {set_url}")
+        return
+
+    api_url = get_api_url()
+    token = get_token()
+    token_display = f"{token[:8]}...{token[-4:]}" if token and len(token) > 12 else (token if token else "Not set")
+
+    from rich.table import Table
+    from rich import box
+
+    table = Table(title="Configuration", box=box.SIMPLE_HEAVY, show_header=False)
+    table.add_column("Key", style="bold cyan", width=16)
+    table.add_column("Value")
+    table.add_row("API URL", api_url)
+    table.add_row("Token", token_display)
+    table.add_row("Config File", str(load_config.__module__))
+
+    console.print(table)
+
+
+@main.command()
+def logout():
+    """Remove saved authentication token."""
+    token = get_token()
+    if not token:
+        print_warning("No token is currently saved")
+        return
+
+    remove_token()
+    print_success("Token removed. You have been logged out.")
+
+
+if __name__ == "__main__":
+    main()

nexinal/config.py

@@ -0,0 +1,75 @@
+"""Configuration manager for nexinal CLI."""
+
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+CONFIG_DIR = Path.home() / ".nexinal"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+DEFAULT_API_URL = "https://nexuss-bash.onrender.com"
+
+
+def ensure_config_dir() -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_config() -> dict:
+    if not CONFIG_FILE.exists():
+        return {"api_url": DEFAULT_API_URL, "token": None, "last_run_id": None}
+    try:
+        with open(CONFIG_FILE, "r") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return {"api_url": DEFAULT_API_URL, "token": None, "last_run_id": None}
+
+
+def save_config(config: dict) -> None:
+    ensure_config_dir()
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(config, f, indent=2)
+
+
+def get_token() -> Optional[str]:
+    config = load_config()
+    return config.get("token")
+
+
+def get_api_url() -> str:
+    config = load_config()
+    return config.get("api_url", DEFAULT_API_URL)
+
+
+def set_token(token: str) -> None:
+    config = load_config()
+    config["token"] = token
+    save_config(config)
+
+
+def set_api_url(url: str) -> None:
+    config = load_config()
+    config["api_url"] = url.rstrip("/")
+    save_config(config)
+
+
+def set_last_run_id(run_id: str) -> None:
+    config = load_config()
+    config["last_run_id"] = run_id
+    save_config(config)
+
+
+def get_last_run_id() -> Optional[str]:
+    config = load_config()
+    return config.get("last_run_id")
+
+
+def remove_token() -> None:
+    config = load_config()
+    config["token"] = None
+    save_config(config)
+
+
+def clear_config() -> None:
+    if CONFIG_FILE.exists():
+        CONFIG_FILE.unlink()

nexinal/display.py

@@ -0,0 +1,187 @@
+"""Rich display utilities for nexinal CLI."""
+
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+from rich.columns import Columns
+from rich import box
+
+console = Console()
+
+BANNER = r"""
+                    _           _
+                   (_)         | |
+  _ __  _ __  _ __  _  ___  __| |
+ | '__|| '__|| '_ \| |/ __|/ _` |
+ | |   | |   | |_) | | (__| (_| |
+ |_|   |_|   | .__/|_|\___|\__,_|
+             | |
+             |_|  v1.0.0
+"""
+
+
+def print_banner() -> None:
+    text = Text(BANNER, style="bold cyan")
+    console.print(text)
+
+
+def print_result(result: dict) -> None:
+    command = result.get("command", "unknown")
+    status = result.get("status", "unknown")
+    output = result.get("stdout", result.get("output", ""))
+    exit_code = result.get("exit_code", None)
+    duration_ms = result.get("duration_ms", result.get("duration", None))
+    duration_s = round(duration_ms / 1000, 2) if isinstance(duration_ms, (int, float)) and duration_ms > 100 else duration_ms
+
+    if status == "passed" or status == "success" or status == "completed":
+        status_icon = Text("✓ PASS", style="bold green")
+    elif status == "failed" or status == "error":
+        status_icon = Text("✗ FAIL", style="bold red")
+    elif status == "skipped":
+        status_icon = Text("⊘ SKIP", style="bold yellow")
+    else:
+        status_icon = Text(f"? {status.upper()}", style="bold yellow")
+
+    title = Text()
+    title.append("  ")
+    title.append(command, style="bold white")
+    title.append("  ")
+    title.append_text(status_icon)
+
+    meta_parts = []
+    if exit_code is not None:
+        meta_parts.append(f"exit={exit_code}")
+    if duration_s is not None:
+        meta_parts.append(f"time={duration_s}s")
+
+    footer = Text()
+    if meta_parts:
+        footer.append(" | ".join(meta_parts), style="dim")
+
+    content = Text()
+    if output:
+        output_str = output.rstrip()
+        if len(output_str) > 2000:
+            output_str = output_str[:2000] + "\n... (truncated)"
+        content.append(output_str)
+    else:
+        content.append("(no output)", style="dim italic")
+
+    border_style = "green" if "pass" in status or "success" in status or "completed" in status else "red" if "fail" in status or "error" in status else "yellow"
+
+    panel = Panel(
+        content,
+        title=title,
+        subtitle=footer if meta_parts else None,
+        border_style=border_style,
+        box=box.ROUNDED,
+        padding=(0, 1),
+    )
+    console.print(panel)
+
+
+def print_error(message: str) -> None:
+    text = Text()
+    text.append("✗ Error: ", style="bold red")
+    text.append(message, style="red")
+    console.print(text)
+
+
+def print_success(message: str) -> None:
+    text = Text()
+    text.append("✓ ", style="bold green")
+    text.append(message, style="green")
+    console.print(text)
+
+
+def print_warning(message: str) -> None:
+    text = Text()
+    text.append("⚠ ", style="bold yellow")
+    text.append(message, style="yellow")
+    console.print(text)
+
+
+def print_info(message: str) -> None:
+    text = Text()
+    text.append("ℹ ", style="bold blue")
+    text.append(message, style="blue")
+    console.print(text)
+
+
+def print_status(status: dict) -> None:
+    table = Table(title="Connection Status", box=box.SIMPLE_HEAVY, show_header=False)
+    table.add_column("Key", style="bold cyan", width=16)
+    table.add_column("Value")
+
+    connected = status.get("connected", False)
+    api_url = status.get("api_url", "N/A")
+    token = status.get("token", None)
+    token_display = f"{token[:8]}...{token[-4:]}" if token and len(token) > 12 else (token if token else "Not set")
+    authenticated = status.get("authenticated", False)
+    last_run = status.get("last_run_id", "None")
+
+    table.add_row("Connected", Text("Yes ✓" if connected else "No ✗", style="green" if connected else "red"))
+    table.add_row("API URL", api_url)
+    table.add_row("Token", token_display)
+    table.add_row("Authenticated", Text("Yes" if authenticated else "No", style="green" if authenticated else "red"))
+    table.add_row("Last Run ID", str(last_run) if last_run else "None")
+
+    console.print(table)
+
+
+def create_results_table(results: list) -> Table:
+    table = Table(title="Run Results", box=box.ROUNDED, show_lines=True)
+    table.add_column("#", style="dim", width=4)
+    table.add_column("Command", style="bold", ratio=3)
+    table.add_column("Status", width=10, justify="center")
+    table.add_column("Exit Code", width=10, justify="center")
+    table.add_column("Duration", width=10, justify="center")
+
+    for i, result in enumerate(results, 1):
+        command = result.get("command", "unknown")
+        status = result.get("status", "unknown")
+        exit_code = result.get("exit_code", "-")
+        duration_ms = result.get("duration_ms", result.get("duration", "-"))
+        duration = round(duration_ms / 1000, 2) if isinstance(duration_ms, (int, float)) and duration_ms > 100 else duration_ms
+
+        if status in ("passed", "success", "completed"):
+            status_display = Text("✓ PASS", style="bold green")
+        elif status in ("failed", "error"):
+            status_display = Text("✗ FAIL", style="bold red")
+        elif status == "skipped":
+            status_display = Text("⊘ SKIP", style="bold yellow")
+        else:
+            status_display = Text(f"? {status}", style="bold yellow")
+
+        if exit_code is not None:
+            exit_display = Text(str(exit_code), style="green" if exit_code == 0 else "red")
+        else:
+            exit_display = Text("-", style="dim")
+
+        duration_display = Text(f"{duration}s" if duration != "-" and duration is not None else "-", style="dim")
+
+        table.add_row(str(i), command, status_display, exit_display, duration_display)
+
+    return table
+
+
+def print_run_summary(results: list, run_id: str = None) -> None:
+    total = len(results)
+    passed = sum(1 for r in results if r.get("status") in ("passed", "success", "completed"))
+    failed = sum(1 for r in results if r.get("status") in ("failed", "error"))
+    skipped = sum(1 for r in results if r.get("status") == "skipped")
+
+    console.print()
+    summary = Text()
+    summary.append("Summary: ", style="bold")
+    summary.append(f"{total} total, ", style="white")
+    summary.append(f"{passed} passed", style="green")
+    if failed > 0:
+        summary.append(f", {failed} failed", style="red")
+    if skipped > 0:
+        summary.append(f", {skipped} skipped", style="yellow")
+    if run_id:
+        summary.append(f"  [run: {run_id}]", style="dim")
+
+    console.print(summary)

nexinal/runner.py

@@ -0,0 +1,135 @@
+"""Command execution engine for nexinal CLI."""
+
+import time
+from typing import List, Union, Optional
+from dataclasses import dataclass, field
+
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from nexinal.api import api_post, APIError, AuthError, ConnectionError_
+from nexinal.config import set_last_run_id, get_token
+from nexinal.display import print_result, print_error, print_run_summary, console
+from nexinal.yaml_parser import CommandEntry
+
+
+@dataclass
+class RunResult:
+    run_id: Optional[str] = None
+    results: List[dict] = field(default_factory=list)
+    success: bool = True
+    error: Optional[str] = None
+
+
+def run_commands(
+    commands: List[Union[str, CommandEntry]],
+    stop_on_fail: bool = False,
+) -> RunResult:
+    if not get_token():
+        print_error("Not authenticated. Run: nexinal auth <token>")
+        return RunResult(success=False, error="Not authenticated")
+
+    command_strings: List[str] = []
+    entry_map: dict = {}
+    for i, cmd in enumerate(commands):
+        if isinstance(cmd, CommandEntry):
+            command_strings.append(cmd.command)
+            entry_map[i] = cmd
+        else:
+            command_strings.append(cmd)
+
+    total = len(command_strings)
+    result = RunResult()
+
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+            transient=True,
+        ) as progress:
+            task = progress.add_task(f"Running {total} command(s)...", total=total)
+
+            for i, cmd_str in enumerate(command_strings):
+                entry = entry_map.get(i)
+                label = entry.name if entry and entry.name else cmd_str
+                if len(label) > 60:
+                    label = label[:57] + "..."
+                progress.update(task, description=f"[{i+1}/{total}] {label}")
+
+                try:
+                    start = time.time()
+                    response = api_post("/run", {"commands": [cmd_str]})
+                    data = response.get("data", response)
+                    duration = round(time.time() - start, 3)
+
+                    run_id = data.get("id")
+                    if run_id:
+                        result.run_id = run_id
+                        set_last_run_id(run_id)
+
+                    cmd_results = data.get("results", [])
+                    if cmd_results:
+                        for cr in cmd_results:
+                            cr.setdefault("command", cmd_str)
+                            result.results.append(cr)
+
+                        first = cmd_results[0]
+                        status = first.get("status", "unknown")
+                        if status in ("failed", "error") and stop_on_fail:
+                            print_result(first)
+                            result.success = False
+                            result.error = f"Command failed: {cmd_str}"
+                            console.print(f"[bold yellow]Stopped: stop_on_fail is enabled[/]")
+                            break
+                        print_result(first)
+                    else:
+                        entry_result = {
+                            "command": cmd_str,
+                            "status": data.get("status", "completed"),
+                            "stdout": data.get("stdout", data.get("output", data.get("detail", ""))),
+                            "exit_code": data.get("exit_code", 0),
+                            "duration_ms": data.get("total_duration_ms", duration * 1000),
+                        }
+                        result.results.append(entry_result)
+                        print_result(entry_result)
+
+                except AuthError as e:
+                    print_error(str(e))
+                    result.success = False
+                    result.error = str(e)
+                    break
+                except ConnectionError_ as e:
+                    print_error(str(e))
+                    result.success = False
+                    result.error = str(e)
+                    break
+                except APIError as e:
+                    entry_result = {
+                        "command": cmd_str,
+                        "status": "error",
+                        "output": str(e),
+                        "exit_code": None,
+                        "duration": None,
+                    }
+                    result.results.append(entry_result)
+                    print_result(entry_result)
+                    if stop_on_fail:
+                        result.success = False
+                        result.error = str(e)
+                        break
+
+                progress.advance(task)
+
+    except KeyboardInterrupt:
+        console.print("\n[bold yellow]Interrupted by user[/]")
+        result.success = False
+        result.error = "Interrupted"
+        return result
+
+    print_run_summary(result.results, result.run_id)
+    return result
+
+
+def run_single_command(command: str, stop_on_fail: bool = False) -> RunResult:
+    return run_commands([command], stop_on_fail=stop_on_fail)

nexinal/yaml_parser.py

@@ -0,0 +1,79 @@
+"""YAML file parser for nexinal CLI."""
+
+from pathlib import Path
+from typing import List, Union, Optional
+from dataclasses import dataclass
+
+import yaml
+
+
+@dataclass
+class CommandEntry:
+    name: Optional[str]
+    command: str
+    timeout: Optional[int] = None
+    stop_on_fail: bool = False
+
+
+class YAMLError(Exception):
+    pass
+
+
+def parse_yaml_file(path: str) -> List[Union[str, CommandEntry]]:
+    file_path = Path(path)
+    if not file_path.exists():
+        raise YAMLError(f"File not found: {path}")
+    if not file_path.suffix in (".yaml", ".yml"):
+        raise YAMLError(f"Not a YAML file: {path}")
+
+    try:
+        with open(file_path, "r") as f:
+            data = yaml.safe_load(f)
+    except yaml.YAMLError as e:
+        raise YAMLError(f"Invalid YAML syntax in {path}: {e}")
+    except IOError as e:
+        raise YAMLError(f"Cannot read file {path}: {e}")
+
+    if data is None:
+        raise YAMLError(f"Empty YAML file: {path}")
+    if not isinstance(data, dict):
+        raise YAMLError(f"YAML must be a mapping with a 'commands' key: {path}")
+
+    commands_raw = data.get("commands")
+    if commands_raw is None:
+        raise YAMLError(f"No 'commands' key found in {path}")
+    if not isinstance(commands_raw, list):
+        raise YAMLError(f"'commands' must be a list: {path}")
+    if len(commands_raw) == 0:
+        raise YAMLError(f"'commands' list is empty in {path}")
+
+    parsed: List[Union[str, CommandEntry]] = []
+    for i, entry in enumerate(commands_raw):
+        if isinstance(entry, str):
+            if not entry.strip():
+                raise YAMLError(f"Empty command at index {i}")
+            parsed.append(entry.strip())
+        elif isinstance(entry, dict):
+            cmd = entry.get("command")
+            if not cmd or not isinstance(cmd, str) or not cmd.strip():
+                raise YAMLError(f"Command at index {i} must have a non-empty 'command' field")
+            timeout = entry.get("timeout")
+            if timeout is not None:
+                try:
+                    timeout = int(timeout)
+                    if timeout <= 0:
+                        raise ValueError
+                except (TypeError, ValueError):
+                    raise YAMLError(f"Invalid timeout at index {i}: must be a positive integer")
+            name = entry.get("name")
+            stop_on_fail = bool(entry.get("stop_on_fail", False))
+            parsed.append(CommandEntry(
+                name=name.strip() if isinstance(name, str) else None,
+                command=cmd.strip(),
+                timeout=timeout,
+                stop_on_fail=stop_on_fail,
+            ))
+        else:
+            raise YAMLError(f"Invalid command entry at index {i}: must be a string or mapping")
+
+    return parsed

nexinal-1.0.2.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.1
+Name: nexinal
+Version: 1.0.2
+Summary: CLI client for Nexuss Bash remote execution API
+Home-page: https://github.com/nexuss0781/Nexuss-Bash
+Author: Nexuss
+Author-email: Nexuss <nexuss@proton.me>
+License: MIT
+Project-URL: Homepage, https://github.com/nexuss0781/Nexuss-Bash
+Project-URL: Bug Reports, https://github.com/nexuss0781/Nexuss-Bash/issues
+Project-URL: Source, https://github.com/nexuss0781/Nexuss-Bash
+Keywords: cli,bash,remote,execution,api,nexuss,nexinal
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: click >=8.0
+Requires-Dist: pyyaml >=6.0
+Requires-Dist: requests >=2.28
+Requires-Dist: rich >=13.0
+Provides-Extra: dev
+Requires-Dist: pytest-cov >=4.0 ; extra == 'dev'
+Requires-Dist: pytest >=7.0 ; extra == 'dev'
+
+# nexinal
+
+CLI client for the **Nexuss Bash** remote execution API. Run shell commands on a remote server directly from your terminal.
+
+## Installation
+
+```bash
+pip install nexinal
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/nexuss0781/Nexuss-Bash
+cd Nexuss-Bash/cli
+pip install -e .
+```
+
+## Quick Start
+
+```bash
+# Authenticate
+nexinal auth YOUR_API_TOKEN
+
+# Run commands
+nexinal run "echo hello" "whoami" "ls /workspace"
+
+# Execute a YAML file
+nexinal execute runbook.yaml
+
+# Check status
+nexinal status
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `nexinal auth <token>` | Save authentication token |
+| `nexinal run <commands...>` | Run shell commands sequentially |
+| `nexinal execute <yaml_file>` | Execute commands from a YAML file |
+| `nexinal status` | Show connection and token info |
+| `nexinal history` | List past runs |
+| `nexinal health` | Quick health check |
+| `nexinal sessions` | List active sessions |
+| `nexinal packages list` | List installed packages |
+| `nexinal packages install <name>` | Install a package |
+| `nexinal config` | Show or set API URL |
+| `nexinal logout` | Remove saved token |
+
+## YAML File Format
+
+### Simple format
+
+```yaml
+commands:
+  - "echo hello"
+  - "whoami"
+  - "ls -la /workspace"
+```
+
+### Detailed format
+
+```yaml
+commands:
+  - name: "Print hello"
+    command: "echo hello"
+    timeout: 30
+    stop_on_fail: true
+  - name: "List files"
+    command: "ls -la"
+    timeout: 15
+```
+
+## Configuration
+
+Config is stored at `~/.nexinal/config.json`.
+
+```bash
+# Set custom API URL
+nexinal config set https://my-server.example.com
+
+# Show current config
+nexinal config
+```
+
+## Environment
+
+- Python 3.8+
+- Works on Linux, macOS, Windows
+
+## License
+
+MIT

nexinal-1.0.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+nexinal/__init__.py,sha256=hb7TtddQ4yn0DRHgMj5Rur3EETDfKWm3B_fc_tckq8o,113
+nexinal/__main__.py,sha256=tjuzXCncKb_ViYlrFYaVUAE496_xsqsCptwCTZon77k,129
+nexinal/api.py,sha256=Gso9kL-KKfagpxR876jTi7PNJYqSEkg-3_ReSlyN5Ds,5162
+nexinal/cli.py,sha256=OUhRTFtjHdwx89lqt48WZZGHQpoXg20ujMqidt2RETs,10699
+nexinal/config.py,sha256=C3n9ienyHtjhCqNscWHSry_9jfn8UQH4g-w46-Spsh0,1706
+nexinal/display.py,sha256=9ZycThYyPE6abH8z96beJWDqTIh8cvBV7jebE55MVGE,6621
+nexinal/runner.py,sha256=jpyAm9iUAxnJonrR6HfHknxPFVj1d54VKGsRfZe6wlE,5100
+nexinal/yaml_parser.py,sha256=LCDmOE-ZNZHX6oGVzLDd_TVgOtCgKGY2S6DVI3h-xGs,2742
+nexinal-1.0.2.dist-info/METADATA,sha256=D0URVfy7O-9qRmUZHRJAC6iGwQ1X71kfBBkXR6BbHlI,3198
+nexinal-1.0.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+nexinal-1.0.2.dist-info/entry_points.txt,sha256=mJJe9XMo0FAubSMGT3uLSU3s9Uyt-LAvtv5B8OEseD4,45
+nexinal-1.0.2.dist-info/top_level.txt,sha256=drOJadouOgKeVwe7eCjGz-bTvoLeeD4qN3QesjvOF-E,8
+nexinal-1.0.2.dist-info/RECORD,,

nexinal-1.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nexinal-1.0.2.dist-info/entry_points.txt

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

nexinal-1.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+nexinal