mobox-cli 0.1.0__py3-none-any.whl

mobox/commands/manage.py

@@ -0,0 +1,188 @@
+"""App management commands: apps, status, control, delete"""
+
+import asyncio
+
+import typer
+
+from mobox import utils
+from mobox.client import get_client
+
+
+def apps():
+    """List all deployed applications"""
+    client = get_client()
+    result = asyncio.run(client.query("list", {"type": "apps"}))
+
+    if not result.get("success"):
+        utils.error(result.get("error", "Failed to list apps"))
+        raise typer.Exit(1)
+
+    apps_data = result.get("apps") or result.get("data", [])
+    if not apps_data:
+        utils.info("No applications found.")
+        return
+
+    table = utils.make_table(
+        "Applications",
+        [("Name", "cyan"), ("Status", ""), ("Created", "dim"), ("URL", "blue")],
+        [
+            [
+                a.get("name", "?"),
+                _status_style(a.get("status", "?")),
+                str(a.get("created_at", "?"))[:10] if a.get("created_at") else "?",
+                a.get("url", ""),
+            ]
+            for a in apps_data
+        ],
+    )
+    utils.console.print(table)
+
+
+def status(app_name: str = typer.Argument(..., help="Application name")):
+    """Show application status"""
+    client = get_client()
+    result = asyncio.run(client.query("check", {"app_name": app_name}))
+
+    if not result.get("success"):
+        utils.error(result.get("error", f"Failed to get status for {app_name}"))
+        raise typer.Exit(1)
+
+    utils.console.print(f"  App:     [bold]{app_name}[/bold]")
+    for key in ("status", "url", "node", "port", "created_at", "image"):
+        val = result.get(key)
+        if val:
+            label = key.replace("_", " ").title()
+            utils.console.print(f"  {label:9s}{val}")
+
+
+def control(
+    app_name: str = typer.Argument(..., help="Application name"),
+    action: str = typer.Argument(..., help="Action: start/stop/restart"),
+):
+    """Start/stop/restart an application"""
+    if action not in ("start", "stop", "restart"):
+        utils.error(f"Invalid action: {action}. Use start/stop/restart")
+        raise typer.Exit(1)
+
+    client = get_client()
+    result = asyncio.run(client.control(action, {"app_name": app_name}))
+
+    if not result.get("success"):
+        utils.error(result.get("error", f"Failed to {action} {app_name}"))
+        raise typer.Exit(1)
+
+    utils.success(f"{app_name} {action} successful")
+
+
+def delete(app_name: str = typer.Argument(..., help="Application name")):
+    """Delete an application (requires confirmation)"""
+    confirm = typer.confirm(
+        f"Delete application '{app_name}'? This cannot be undone"
+    )
+    if not confirm:
+        utils.info("Cancelled.")
+        raise typer.Exit()
+
+    client = get_client()
+    result = asyncio.run(client.control("delete", {"app_name": app_name}))
+
+    if not result.get("success"):
+        utils.error(result.get("error", f"Failed to delete {app_name}"))
+        raise typer.Exit(1)
+
+    utils.success(f"{app_name} deleted")
+
+
+def _status_style(s: str) -> str:
+    colors = {"running": "green", "stopped": "red", "building": "yellow"}
+    color = colors.get(s, "dim")
+    return f"[{color}]{s}[/{color}]"
+
+
+def boxes():
+    """List all sandbox boxes"""
+    client = get_client()
+    result = asyncio.run(client.query("list", {"type": "boxes"}))
+
+    if not result.get("success"):
+        utils.error(result.get("error", "Failed to list boxes"))
+        raise typer.Exit(1)
+
+    boxes_data = result.get("apps") or result.get("data", [])
+    if not boxes_data:
+        utils.info("No boxes found.")
+        return
+
+    table = utils.make_table(
+        "Sandbox Boxes",
+        [("Name", "cyan"), ("Status", ""), ("Type", "dim"), ("Created", "dim")],
+        [
+            [
+                b.get("name", "?"),
+                _status_style(b.get("status", "?")),
+                b.get("container_type", "?"),
+                str(b.get("created_at", "?"))[:10] if b.get("created_at") else "?",
+            ]
+            for b in boxes_data
+        ],
+    )
+    utils.console.print(table)
+
+
+def images():
+    """List all available images"""
+    client = get_client()
+    result = asyncio.run(client.query("list", {"type": "images"}))
+
+    if not result.get("success"):
+        utils.error(result.get("error", "Failed to list images"))
+        raise typer.Exit(1)
+
+    images_data = result.get("images") or result.get("data", [])
+    if not images_data:
+        utils.info("No images found.")
+        return
+
+    table = utils.make_table(
+        "Images",
+        [("Name", "cyan"), ("Type", "dim"), ("Description", "")],
+        [
+            [
+                i.get("name", "?"),
+                i.get("image_type", "?"),
+                i.get("description", "")[:60] if i.get("description") else "",
+            ]
+            for i in images_data
+        ],
+    )
+    utils.console.print(table)
+
+
+def templates():
+    """List all available templates"""
+    client = get_client()
+    result = asyncio.run(client.query("list", {"type": "templates"}))
+
+    if not result.get("success"):
+        utils.error(result.get("error", "Failed to list templates"))
+        raise typer.Exit(1)
+
+    templates_data = result.get("templates") or result.get("data", [])
+    if not templates_data:
+        utils.info("No templates found.")
+        return
+
+    table = utils.make_table(
+        "Templates",
+        [("Name", "cyan"), ("Type", "dim"), ("Image", "blue"), ("Description", "")],
+        [
+            [
+                t.get("name", "?"),
+                t.get("usage_type", "?"),
+                t.get("pull_image", "").split("/")[-1] if t.get("pull_image") else "?",
+                t.get("description", "")[:50] if t.get("description") else "",
+            ]
+            for t in templates_data
+        ],
+    )
+    utils.console.print(table)

mobox/commands/ops.py

@@ -0,0 +1,125 @@
+"""Operations commands: logs, bash, file"""
+
+import asyncio
+
+import typer
+
+from mobox import utils
+from mobox.client import get_client
+
+
+def logs(
+    app_name: str = typer.Argument(..., help="Application name"),
+    tail: int = typer.Option(100, "--tail", "-n", help="Number of lines"),
+):
+    """View application logs"""
+    client = get_client()
+    result = asyncio.run(
+        client.query("logs", {"app_name": app_name, "lines": tail})
+    )
+
+    if not result.get("success"):
+        utils.error(result.get("error", f"Failed to get logs for {app_name}"))
+        raise typer.Exit(1)
+
+    log_text = result.get("logs") or result.get("text", "")
+    if log_text:
+        utils.console.print(log_text)
+    else:
+        utils.info("No logs available.")
+
+
+def bash(
+    box_name: str = typer.Argument(..., help="Box name"),
+    cmd: str = typer.Argument(..., help="Command to execute"),
+):
+    """Execute command in application container"""
+    client = get_client()
+    result = asyncio.run(
+        client.boxbash("exec", {"box_name": box_name, "command": cmd})
+    )
+
+    if not result.get("success"):
+        utils.error(result.get("error", "Command execution failed"))
+        raise typer.Exit(1)
+
+    # If async task, poll for result
+    task_id = result.get("task_id")
+    if task_id:
+        utils.waiting(f"Task {task_id} running...")
+        check = asyncio.run(
+            client.boxbash("check", {"task_id": task_id, "wait": True})
+        )
+        if not check.get("success"):
+            utils.error(check.get("error", "Failed to retrieve task result"))
+            raise typer.Exit(1)
+        output = check.get("output", check.get("text", ""))
+    else:
+        output = result.get("output", result.get("text", ""))
+
+    if output:
+        utils.console.print(output)
+
+
+def file(
+    box_name: str = typer.Argument(..., help="Box name"),
+    op: str = typer.Argument(
+        ..., help="Operation: read/write/edit/grep/list/down"
+    ),
+    path: str = typer.Option("", "--path", "-p", help="File path in container"),
+    content: str = typer.Option("", "--content", "-c", help="Content for write"),
+    pattern: str = typer.Option("", "--pattern", help="Pattern for grep"),
+    old_string: str = typer.Option("", "--old", help="Old string for edit"),
+    new_string: str = typer.Option("", "--new", help="New string for edit"),
+    upload_id: str = typer.Option("", "--upload-id", help="Upload ID for down operation"),
+):
+    """File operations in application container"""
+    valid_ops = ("read", "write", "edit", "grep", "list", "down")
+    if op not in valid_ops:
+        utils.error(f"Invalid operation: {op}. Use: {', '.join(valid_ops)}")
+        raise typer.Exit(1)
+
+    client = get_client()
+    options: dict = {"box_name": box_name}
+
+    if path:
+        options["path"] = path
+
+    # Validate required options per operation
+    if op == "write":
+        if not content:
+            utils.error("--content is required for write operation")
+            raise typer.Exit(1)
+        options["content"] = content
+    elif op == "grep":
+        if not pattern:
+            utils.error("--pattern is required for grep operation")
+            raise typer.Exit(1)
+        options["pattern"] = pattern
+    elif op == "edit":
+        if not old_string or not new_string:
+            utils.error("--old and --new are required for edit operation")
+            raise typer.Exit(1)
+        options["old_string"] = old_string
+        options["new_string"] = new_string
+    elif op == "down":
+        if not upload_id:
+            utils.error("--upload-id is required for down operation")
+            raise typer.Exit(1)
+        options["upload_id"] = upload_id
+
+    result = asyncio.run(client.boxfile(op, options))
+
+    if not result.get("success"):
+        utils.error(result.get("error", f"File operation '{op}' failed"))
+        raise typer.Exit(1)
+
+    text = result.get("content") or result.get("text") or result.get("files", "")
+    if text:
+        if isinstance(text, list):
+            for item in text:
+                utils.console.print(str(item))
+        else:
+            utils.console.print(str(text))
+    else:
+        utils.success(f"File {op} completed")

mobox/config.py

@@ -0,0 +1,82 @@
+"""~/.mobox/ credentials and config management"""
+
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+MOBOX_DIR = Path.home() / ".mobox"
+CREDENTIALS_FILE = MOBOX_DIR / "credentials.json"
+CONFIG_FILE = MOBOX_DIR / "config.json"
+
+DEFAULT_SERVER = "https://hub-sh-1.aid.pub/mcp"
+
+
+def _ensure_dir():
+    MOBOX_DIR.mkdir(parents=True, exist_ok=True)
+    os.chmod(MOBOX_DIR, 0o700)
+
+
+def _write_secure(path: Path, data: dict):
+    """Write JSON with 0600 permissions (atomic create)"""
+    _ensure_dir()
+    content = json.dumps(data, indent=2, ensure_ascii=False)
+    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w", encoding="utf-8") as f:
+        f.write(content)
+
+
+def _read_json(path: Path) -> Optional[dict]:
+    if not path.exists():
+        return None
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+# --- Credentials ---
+
+
+def save_credentials(mcp_key: str, namespace: str, server_url: str):
+    _write_secure(CREDENTIALS_FILE, {
+        "mcp_key": mcp_key,
+        "namespace": namespace,
+        "server_url": server_url,
+        "created_at": datetime.now(timezone.utc).isoformat(),
+    })
+
+
+def load_credentials() -> Optional[dict]:
+    return _read_json(CREDENTIALS_FILE)
+
+
+def clear_credentials():
+    if CREDENTIALS_FILE.exists():
+        CREDENTIALS_FILE.unlink()
+
+
+# --- Config ---
+
+
+def get_config(key: str, default=None):
+    cfg = _read_json(CONFIG_FILE) or {}
+    return cfg.get(key, default)
+
+
+def set_config(key: str, value):
+    cfg = _read_json(CONFIG_FILE) or {}
+    cfg[key] = value
+    _write_secure(CONFIG_FILE, cfg)
+
+
+def list_config() -> dict:
+    return _read_json(CONFIG_FILE) or {}
+
+
+def get_server_url() -> str:
+    creds = load_credentials()
+    if creds and creds.get("server_url"):
+        return creds["server_url"]
+    return get_config("default_server", DEFAULT_SERVER)