wayscloud-cli 0.2.3__tar.gz → 0.4.0__tar.gz

{wayscloud_cli-0.2.3 → wayscloud_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wayscloud-cli
-Version: 0.2.3
+Version: 0.4.0
 Summary: Command-line interface for WAYSCloud — manage VPS, DNS, databases, storage, apps, IoT, and more
 License: MIT
 Project-URL: Homepage, https://wayscloud.services
@@ -19,12 +19,10 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: wayscloud>=0.1.0
+Requires-Dist: wayscloud>=0.3.0
 Requires-Dist: typer>=0.9
 Requires-Dist: rich>=13.0
 Requires-Dist: websockets>=12.0
-Dynamic: license-file
 
 # WAYSCloud CLI
 

{wayscloud_cli-0.2.3 → wayscloud_cli-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wayscloud-cli"
-version = "0.2.3"
+version = "0.4.0"
 description = "Command-line interface for WAYSCloud — manage VPS, DNS, databases, storage, apps, IoT, and more"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -22,7 +22,7 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "wayscloud>=0.1.0",
+    "wayscloud>=0.3.0",
     "typer>=0.9",
     "rich>=13.0",
     "websockets>=12.0",

{wayscloud_cli-0.2.3 → wayscloud_cli-0.4.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = wayscloud-cli
-version = 0.2.3
+version = 0.4.0
 
 [options]
 packages = find:

wayscloud_cli-0.4.0/wayscloud_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.0"

wayscloud_cli-0.4.0/wayscloud_cli/commands/app.py

@@ -0,0 +1,295 @@
+"""
+cloud app commands — App Platform provisioning and control.
+"""
+
+import typer
+from typing import Optional, List
+
+from ..sdk import get_client, sdk_call
+from ..output import print_table, print_object, print_json, is_json_mode
+
+app = typer.Typer(help="App platform")
+
+# ── Env sub-group ────────────────────────────────────────────────
+env_app = typer.Typer(help="Environment variables")
+app.add_typer(env_app, name="env")
+
+
+@env_app.command("list")
+def env_list(
+    app_id: str = typer.Argument(..., help="App ID or name"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """List environment variable keys for an app."""
+    c = get_client(token)
+    env = sdk_call(c.apps.env_vars, app_id)
+
+    if is_json_mode():
+        print_json(env)
+        return
+
+    if not env:
+        print("No environment variables set.")
+        return
+
+    print(f"Environment variables ({len(env)}):\n")
+    for key in sorted(env.keys()):
+        print(f"  {key}=***")
+
+
+@env_app.command("set")
+def env_set(
+    app_id: str = typer.Argument(..., help="App ID or name"),
+    pairs: List[str] = typer.Argument(..., help="KEY=value pairs"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Set one or more environment variables."""
+    c = get_client(token)
+
+    for pair in pairs:
+        if "=" not in pair:
+            print(f"Error: Invalid format '{pair}'. Use KEY=value", err=True)
+            raise typer.Exit(code=1)
+        key, _, value = pair.partition("=")
+        sdk_call(c.apps.set_env, app_id, key.strip(), value)
+        print(f"  Set: {key.strip()}")
+
+    print(f"\n{len(pairs)} variable(s) updated.")
+
+
+@env_app.command("unset")
+def env_unset(
+    app_id: str = typer.Argument(..., help="App ID or name"),
+    keys: List[str] = typer.Argument(..., help="Variable names to remove"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Remove one or more environment variables."""
+    c = get_client(token)
+
+    for key in keys:
+        sdk_call(c.apps.unset_env, app_id, key)
+        print(f"  Removed: {key}")
+
+    print(f"\n{len(keys)} variable(s) removed.")
+
+
+# ── Core commands ────────────────────────────────────────────────
+
+@app.command("list")
+def list_apps(
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """List your apps."""
+    c = get_client(token)
+    data = sdk_call(c.apps.list)
+    apps_list = data if isinstance(data, list) else data.get("apps", []) if isinstance(data, dict) else []
+
+    if is_json_mode():
+        print_json(apps_list)
+        return
+
+    if not apps_list:
+        print("No apps found.")
+        return
+
+    rows = [{"id": str(a.get("id", ""))[:14], "name": a.get("name", ""),
+             "status": a.get("status", ""), "plan": a.get("plan", a.get("plan_code", "")),
+             "url": a.get("default_url", ""), "created_at": a.get("created_at", "")}
+            for a in apps_list]
+
+    print_table(rows, [
+        ("id", "ID", 14), ("name", "Name", 20), ("status", "Status", 10),
+        ("plan", "Plan", 16), ("url", "URL", 30), ("created_at", "Created", 20),
+    ])
+
+
+@app.command("create")
+def create_app(
+    name: str = typer.Argument(..., help="App name"),
+    plan: str = typer.Option("app-basic", "--plan", help="Plan code"),
+    region: str = typer.Option("no", "--region", help="Region"),
+    port: int = typer.Option(8080, "--port", help="Application port"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Create a new app."""
+    c = get_client(token)
+    data = sdk_call(c.apps.create, name, plan=plan, region=region, port=port)
+    if is_json_mode():
+        print_json(data)
+    else:
+        print(f"App created: {data.get('name', name)}")
+        print_object(data, [("id", "ID"), ("name", "Name"), ("status", "Status"),
+                            ("plan", "Plan"), ("default_url", "URL")])
+
+
+@app.command("info")
+def info_app(
+    app_id: str = typer.Argument(..., help="App ID"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Show app details."""
+    c = get_client(token)
+    data = sdk_call(c.apps.get, app_id)
+    print_object(data, [
+        ("id", "ID"), ("name", "Name"), ("status", "Status"), ("plan", "Plan"),
+        ("region", "Region"), ("port", "Port"), ("default_url", "URL"),
+        ("image_uri", "Image"), ("created_at", "Created"),
+    ])
+
+
+@app.command("delete")
+def delete_app(
+    app_id: str = typer.Argument(..., help="App ID"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+    confirm: bool = typer.Option(False, "--confirm", help="Skip confirmation"),
+):
+    """Delete an app (permanent)."""
+    if not confirm:
+        print(f"This will permanently delete app {app_id} and all its data.")
+        print("Use --confirm to proceed.")
+        raise typer.Exit(code=1)
+
+    c = get_client(token)
+    data = sdk_call(c.apps.delete, app_id)
+    if is_json_mode():
+        print_json(data)
+    else:
+        print(f"App {app_id}: deleted")
+
+
+@app.command("deploy")
+def deploy_app(
+    app_id: str = typer.Argument(..., help="App ID"),
+    image: str = typer.Option(..., "--image", help="Container image URI"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Deploy an app from a container image."""
+    c = get_client(token)
+    data = sdk_call(c.apps.deploy, app_id, image)
+    if is_json_mode():
+        print_json(data)
+    else:
+        print(f"App {app_id}: deploying image {image}")
+
+
+@app.command("start")
+def start_app(
+    app_id: str = typer.Argument(..., help="App ID"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Start an app."""
+    c = get_client(token)
+    data = sdk_call(c.apps.start, app_id)
+    if is_json_mode():
+        print_json(data)
+    else:
+        print(f"App {app_id}: {data.get('message', 'starting')}")
+
+
+@app.command("stop")
+def stop_app(
+    app_id: str = typer.Argument(..., help="App ID"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Stop an app."""
+    c = get_client(token)
+    data = sdk_call(c.apps.stop, app_id)
+    if is_json_mode():
+        print_json(data)
+    else:
+        print(f"App {app_id}: {data.get('message', 'stopping')}")
+
+
+@app.command("restart")
+def restart_app(
+    app_id: str = typer.Argument(..., help="App ID"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Restart an app."""
+    c = get_client(token)
+    data = sdk_call(c.apps.restart, app_id)
+    if is_json_mode():
+        print_json(data)
+    else:
+        print(f"App {app_id}: {data.get('message', 'restarting')}")
+
+
+@app.command("logs")
+def logs_app(
+    app_id: str = typer.Argument(..., help="App ID"),
+    lines: int = typer.Option(100, "--lines", "-n", help="Number of lines"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Show app logs."""
+    c = get_client(token)
+    data = sdk_call(c.apps.logs, app_id, lines=lines)
+
+    if is_json_mode():
+        print_json(data)
+        return
+
+    log_lines = data if isinstance(data, list) else []
+    if not log_lines:
+        print("No logs available.")
+        return
+
+    for line in log_lines:
+        if isinstance(line, dict):
+            ts = line.get("timestamp", "")
+            msg = line.get("message", line.get("log", str(line)))
+            print(f"{ts}  {msg}")
+        else:
+            print(line)
+
+
+@app.command("plans")
+def list_plans(
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """List available app plans."""
+    c = get_client(token)
+    data = sdk_call(c.apps.plans)
+    plans_list = data if isinstance(data, list) else []
+
+    if is_json_mode():
+        print_json(plans_list)
+        return
+
+    if not plans_list:
+        print("No plans available.")
+        return
+
+    rows = [{"code": p.get("code", p.get("plan_code", "")),
+             "name": p.get("name", ""),
+             "cpu": str(p.get("cpu", "")),
+             "memory": str(p.get("memory_mb", p.get("memory", ""))),
+             "price": str(p.get("price_monthly", p.get("price", "")))}
+            for p in plans_list]
+
+    print_table(rows, [
+        ("code", "Code", 20), ("name", "Name", 20), ("cpu", "CPU", 6),
+        ("memory", "Memory MB", 10), ("price", "Price/mo", 10),
+    ])
+
+
+@app.command("regions")
+def list_regions(
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """List available app regions."""
+    c = get_client(token)
+    data = sdk_call(c.apps.regions)
+
+    if is_json_mode():
+        print_json(data)
+        return
+
+    regions_list = data if isinstance(data, list) else []
+    if not regions_list:
+        print("No regions available.")
+        return
+
+    for r in regions_list:
+        code = r.get("code", r.get("region", ""))
+        name = r.get("name", r.get("label", ""))
+        print(f"  {code:<10} {name}")

{wayscloud_cli-0.2.3 → wayscloud_cli-0.4.0}/wayscloud_cli/commands/db.py

@@ -65,20 +65,10 @@ def database_info(
     c = get_client(token)
     data = sdk_call(c.database.get, db_type, name)
 
-    # Merge credentials if available
-    try:
-        creds = c.database.credentials(db_type, name)
-        if isinstance(creds, dict):
-            data.update(creds)
-    except Exception as e:
-        import sys
-        print(f"Warning: could not fetch credentials: {e}", file=sys.stderr)
-
     print_object(data, [
         ("name", "Name"), ("type", "Type"), ("tier", "Tier"), ("status", "Status"),
         ("size_mb", "Size (MB)"), ("host", "Host"), ("port", "Port"),
-        ("username", "Username"), ("password", "Password"), ("database", "Database"),
-        ("connection_string", "Connection String"), ("created_at", "Created"),
+        ("created_at", "Created"),
     ])
 
 
@@ -101,3 +91,76 @@ def delete_database(
         print_json(data)
     else:
         print(f"Database {name}: deleted")
+
+
+@app.command("tiers")
+def list_tiers(
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """List available database tiers."""
+    c = get_client(token)
+    data = sdk_call(c.database.tiers)
+    if is_json_mode():
+        print_json(data)
+        return
+    tiers = data if isinstance(data, list) else []
+    for t in tiers:
+        name = t.get("name", t.get("tier", ""))
+        desc = t.get("description", "")
+        print(f"  {name:<16} {desc}")
+
+
+@app.command("firewall")
+def list_firewall(
+    db_type: str = typer.Argument(..., help="Database type (postgresql/mariadb)"),
+    name: str = typer.Argument(..., help="Database name"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """List firewall rules for a database."""
+    c = get_client(token)
+    data = sdk_call(c.database.firewall_rules, db_type, name)
+    rules = data if isinstance(data, list) else []
+    if is_json_mode():
+        print_json(rules)
+        return
+    if not rules:
+        print("No firewall rules.")
+        return
+    rows = [{"id": str(r.get("id", ""))[:12], "ip": r.get("ip_address", ""),
+             "desc": r.get("description", ""), "created": r.get("created_at", "")[:19]}
+            for r in rules]
+    print_table(rows, [("id", "ID", 14), ("ip", "IP Address", 20),
+                       ("desc", "Description", 24), ("created", "Created", 20)])
+
+
+@app.command("firewall-add")
+def add_firewall(
+    db_type: str = typer.Argument(..., help="Database type (postgresql/mariadb)"),
+    name: str = typer.Argument(..., help="Database name"),
+    ip: str = typer.Option(..., "--ip", help="IP address to whitelist"),
+    description: str = typer.Option("", "--description", help="Description"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Add a firewall rule to whitelist an IP address."""
+    c = get_client(token)
+    data = sdk_call(c.database.add_firewall_rule, db_type, name, ip_address=ip, description=description)
+    if is_json_mode():
+        print_json(data)
+    else:
+        print(f"Firewall rule added: {ip}")
+
+
+@app.command("firewall-remove")
+def remove_firewall(
+    db_type: str = typer.Argument(..., help="Database type (postgresql/mariadb)"),
+    name: str = typer.Argument(..., help="Database name"),
+    rule_id: str = typer.Option(..., "--rule-id", help="Rule ID"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Remove a firewall rule."""
+    c = get_client(token)
+    data = sdk_call(c.database.remove_firewall_rule, db_type, name, rule_id)
+    if is_json_mode():
+        print_json(data)
+    else:
+        print(f"Firewall rule {rule_id}: removed")

{wayscloud_cli-0.2.3 → wayscloud_cli-0.4.0}/wayscloud_cli/commands/dns.py

@@ -38,6 +38,25 @@ def list_zones(
     ])
 
 
+@app.command("zones-info")
+def zone_info(
+    zone_name: str = typer.Argument(..., help="Zone name"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Show details for a DNS zone."""
+    c = get_client(token)
+    data = sdk_call(c.dns.get, zone_name)
+    if is_json_mode():
+        print_json(data)
+    else:
+        from ..output import print_object
+        print_object(data, [
+            ("name", "Name"), ("status", "Status"), ("zone_type", "Type"),
+            ("record_count", "Records"), ("dnssec_enabled", "DNSSEC"),
+            ("created_at", "Created"),
+        ])
+
+
 @app.command("zones-create")
 def create_zone(
     name: str = typer.Argument(..., help="Zone name"),
@@ -169,3 +188,73 @@ def delete_record(
         print_json(data)
     else:
         print(f"Record {record_id}: deleted")
+
+
+@app.command("dnssec-status")
+def dnssec_status(
+    zone_name: str = typer.Argument(..., help="Zone name"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Show DNSSEC status for a zone."""
+    c = get_client(token)
+    data = sdk_call(c.dns.dnssec_status, zone_name)
+    if is_json_mode():
+        print_json(data)
+    else:
+        from ..output import print_object
+        print_object(data, [
+            ("enabled", "Enabled"), ("ds_records", "DS Records"),
+            ("algorithm", "Algorithm"), ("key_tag", "Key Tag"),
+        ])
+
+
+@app.command("dnssec-activate")
+def dnssec_activate(
+    zone_name: str = typer.Argument(..., help="Zone name"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Activate DNSSEC for a zone."""
+    c = get_client(token)
+    data = sdk_call(c.dns.dnssec_activate, zone_name)
+    if is_json_mode():
+        print_json(data)
+    else:
+        print(f"DNSSEC activated for {zone_name}.")
+
+
+@app.command("dnssec-deactivate")
+def dnssec_deactivate(
+    zone_name: str = typer.Argument(..., help="Zone name"),
+    confirm: bool = typer.Option(False, "--confirm", help="Skip confirmation"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Deactivate DNSSEC for a zone."""
+    if not confirm:
+        print(f"This will deactivate DNSSEC for {zone_name}.")
+        print("Use --confirm to proceed.")
+        raise typer.Exit(code=1)
+
+    c = get_client(token)
+    data = sdk_call(c.dns.dnssec_deactivate, zone_name)
+    if is_json_mode():
+        print_json(data)
+    else:
+        print(f"DNSSEC deactivated for {zone_name}.")
+
+
+@app.command("statistics")
+def zone_statistics(
+    zone_name: str = typer.Argument(..., help="Zone name"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Show zone statistics (query counts)."""
+    c = get_client(token)
+    data = sdk_call(c.dns.statistics, zone_name)
+    if is_json_mode():
+        print_json(data)
+    else:
+        from ..output import print_object
+        print_object(data, [
+            ("total_queries", "Total Queries"), ("queries_today", "Queries Today"),
+            ("record_count", "Records"),
+        ])