wayscloud-cli 0.5.0__tar.gz → 0.6.0__tar.gz

{wayscloud_cli-0.5.0 → wayscloud_cli-0.6.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: wayscloud-cli
-Version: 0.5.0
-Summary: Command-line interface for WAYSCloud — manage VPS, DNS, databases, storage, apps, Kubernetes, IoT, and more
+Version: 0.6.0
+Summary: Command-line interface for WAYSCloud — manage VPS, DNS, databases, storage, apps, IoT, and more
 License: MIT
 Project-URL: Homepage, https://wayscloud.services
 Project-URL: Documentation, https://docs.wayscloud.services/integrations/#wayscloud-cli
@@ -20,7 +20,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: wayscloud>=0.4.0
+Requires-Dist: wayscloud>=0.5.0
 Requires-Dist: typer>=0.9
 Requires-Dist: rich>=13.0
 Requires-Dist: websockets>=12.0
@@ -36,7 +36,7 @@ Command-line interface for [WAYSCloud](https://wayscloud.services). Built on the
 pip install wayscloud-cli
 ```
 
-Version 0.5.0 adds Managed Kubernetes (`cloud k8s …`) and requires SDK `wayscloud>=0.4.0`.
+Version 0.6.0 adds the upgrade preflight (`cloud k8s preflight`, non-zero exit on blockers) and requires SDK `wayscloud>=0.5.0`.
 
 ## Authentication
 
@@ -121,6 +121,8 @@ cloud k8s list
 cloud k8s create shop --pool k8s-node-2c4g:2 --plan k8s-cluster-dev --region no --wait
 cloud k8s info <cluster-id>
 cloud k8s kubeconfig <cluster-id> -o ~/.kube/shop.yaml   # written with mode 0600
+cloud k8s preflight <cluster-id> 1.35                  # blockers/warnings; exit != 0 on blockers
+cloud k8s upgrade <cluster-id> 1.35 --mode next-maintenance-window --backup-first
 cloud k8s scale <cluster-id> default 4
 cloud k8s add-pool <cluster-id> batch --plan k8s-node-4c16g --count 2 \
   --label role=worker --taint dedicated=gpu:NoSchedule --ssh-key-id <key-id>

{wayscloud_cli-0.5.0 → wayscloud_cli-0.6.0}/README.md

@@ -8,7 +8,7 @@ Command-line interface for [WAYSCloud](https://wayscloud.services). Built on the
 pip install wayscloud-cli
 ```
 
-Version 0.5.0 adds Managed Kubernetes (`cloud k8s …`) and requires SDK `wayscloud>=0.4.0`.
+Version 0.6.0 adds the upgrade preflight (`cloud k8s preflight`, non-zero exit on blockers) and requires SDK `wayscloud>=0.5.0`.
 
 ## Authentication
 
@@ -93,6 +93,8 @@ cloud k8s list
 cloud k8s create shop --pool k8s-node-2c4g:2 --plan k8s-cluster-dev --region no --wait
 cloud k8s info <cluster-id>
 cloud k8s kubeconfig <cluster-id> -o ~/.kube/shop.yaml   # written with mode 0600
+cloud k8s preflight <cluster-id> 1.35                  # blockers/warnings; exit != 0 on blockers
+cloud k8s upgrade <cluster-id> 1.35 --mode next-maintenance-window --backup-first
 cloud k8s scale <cluster-id> default 4
 cloud k8s add-pool <cluster-id> batch --plan k8s-node-4c16g --count 2 \
   --label role=worker --taint dedicated=gpu:NoSchedule --ssh-key-id <key-id>

{wayscloud_cli-0.5.0 → wayscloud_cli-0.6.0}/pyproject.toml

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

{wayscloud_cli-0.5.0 → wayscloud_cli-0.6.0}/setup.cfg

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

wayscloud_cli-0.6.0/tests/test_k8s_cli.py

@@ -0,0 +1,318 @@
+"""k8s command tests -- option parsing, payloads and file handling."""
+
+import os
+import stat
+
+from typer.testing import CliRunner
+
+from wayscloud_cli.__main__ import app
+from wayscloud_cli.commands import k8s as k8s_cmd
+
+runner = CliRunner()
+
+
+class FakeKubernetes:
+    def __init__(self):
+        self.calls = []
+        self.window = {}
+        self.jobs = []
+        self.upgrade_response = None
+        self.preflight_response = None
+
+    def add_node_pool(self, *args, **kwargs):
+        self.calls.append((args, kwargs))
+        return {"id": "c1"}
+
+    def kubeconfig(self, cluster_id):
+        return "apiVersion: v1\nkind: Config\n"
+
+    def delete_node_pool(self, *args, **kwargs):
+        self.calls.append((args, kwargs))
+        return {"id": "c1"}
+
+    def upgrade_node_pool(self, *args, **kwargs):
+        self.calls.append((args, kwargs))
+        return {"id": "c1"}
+
+    def versions(self, *args, **kwargs):
+        self.calls.append((args, kwargs))
+        return {"default": "1.35", "versions": [
+            {"version": "1.35", "status": "default", "create_allowed": True, "create_until": None,
+             "support_ends_at": "2027-02-28", "upgrade_required_by": None, "recommended_upgrade": None},
+            {"version": "1.34", "status": "transition", "create_allowed": True, "create_until": "2026-10-15",
+             "support_ends_at": "2026-10-27", "upgrade_required_by": "2026-10-20", "recommended_upgrade": "1.35"}]}
+
+    def upgrade(self, *args, **kwargs):
+        self.calls.append((args, kwargs))
+        return self.upgrade_response or {"id": "c1", "status": "upgrading"}
+
+    def upgrade_preflight(self, *args, **kwargs):
+        self.calls.append((args, kwargs))
+        return self.preflight_response or {"ok": True, "errors": [], "warnings": []}
+
+    def upgrade_jobs(self, *args, **kwargs):
+        self.calls.append((args, kwargs))
+        return self.jobs
+
+    def upgrade_job(self, *args, **kwargs):
+        self.calls.append((args, kwargs))
+        return self.jobs[0] if self.jobs else {}
+
+    def cancel_upgrade_job(self, *args, **kwargs):
+        self.calls.append((args, kwargs))
+        return {"id": "j1", "status": "cancelled"}
+
+    def set_maintenance_window(self, *args, **kwargs):
+        self.calls.append((args, kwargs))
+        return {"enabled": kwargs.get("enabled", True), "timezone": kwargs.get("timezone"), "days": kwargs.get("days"),
+                "start": kwargs.get("start"), "duration_minutes": kwargs.get("duration_minutes"),
+                "next_window_start": "2026-10-24T02:00:00+02:00", "next_window_end": "2026-10-24T04:00:00+02:00"}
+
+    def get_maintenance_window(self, *args, **kwargs):
+        self.calls.append((args, kwargs))
+        return self.window
+
+    def delete_maintenance_window(self, *args, **kwargs):
+        self.calls.append((args, kwargs))
+        return {"enabled": False, "timezone": None, "days": [], "start": None, "duration_minutes": None,
+                "next_window_start": None, "next_window_end": None}
+
+
+class FakeClient:
+    def __init__(self, kubernetes):
+        self.kubernetes = kubernetes
+
+
+def patch_client(monkeypatch, kubernetes):
+    monkeypatch.setattr(k8s_cmd, "get_client", lambda token=None: FakeClient(kubernetes))
+
+
+def test_parse_labels_and_taints():
+    assert k8s_cmd._parse_labels([]) == {}
+    assert k8s_cmd._parse_labels(["role=worker", "zone=a=b"]) == {"role": "worker", "zone": "a=b"}
+    assert k8s_cmd._parse_taints([]) == []
+    assert k8s_cmd._parse_taints(["dedicated=gpu:NoSchedule", "spot=:PreferNoSchedule"]) == [
+        {"key": "dedicated", "value": "gpu", "effect": "NoSchedule"},
+        {"key": "spot", "value": "", "effect": "PreferNoSchedule"},
+    ]
+
+
+def test_add_pool_passes_labels_taints_and_ssh_keys(monkeypatch):
+    kube = FakeKubernetes()
+    patch_client(monkeypatch, kube)
+
+    result = runner.invoke(app, [
+        "k8s", "add-pool", "c1", "workers", "--plan", "k8s-node-2c4g", "--count", "3",
+        "--label", "role=worker", "--label", "tier=compute",
+        "--taint", "dedicated=gpu:NoExecute",
+        "--ssh-key-id", "11111111-1111-1111-1111-111111111111",
+    ])
+
+    assert result.exit_code == 0, result.output
+    (args, kwargs), = kube.calls
+    assert args == ("c1", "workers", "k8s-node-2c4g", 3)
+    assert kwargs["labels"] == {"role": "worker", "tier": "compute"}
+    assert kwargs["taints"] == [{"key": "dedicated", "value": "gpu", "effect": "NoExecute"}]
+    assert kwargs["ssh_key_ids"] == ["11111111-1111-1111-1111-111111111111"]
+
+
+def test_add_pool_defaults_to_no_labels_taints_or_keys(monkeypatch):
+    kube = FakeKubernetes()
+    patch_client(monkeypatch, kube)
+
+    result = runner.invoke(app, ["k8s", "add-pool", "c1", "workers", "--plan", "k8s-node-2c4g"])
+
+    assert result.exit_code == 0, result.output
+    (args, kwargs), = kube.calls
+    assert args == ("c1", "workers", "k8s-node-2c4g", 1)
+    assert kwargs == {"labels": {}, "taints": [], "ssh_key_ids": []}
+
+
+def test_add_pool_rejects_malformed_label_and_taint(monkeypatch):
+    patch_client(monkeypatch, FakeKubernetes())
+
+    for value in ("novalue", "=noKey"):
+        result = runner.invoke(app, ["k8s", "add-pool", "c1", "workers", "--plan", "k8s-node-2c4g", "--label", value])
+        assert result.exit_code != 0
+        assert "key=value" in result.output
+
+    for value in ("novalue", "key:NoSchedule", "key=value:Sometimes"):
+        result = runner.invoke(app, ["k8s", "add-pool", "c1", "workers", "--plan", "k8s-node-2c4g", "--taint", value])
+        assert result.exit_code != 0
+        assert "key=value:Effect" in result.output or "taint effect" in result.output
+
+
+def test_kubeconfig_output_file_is_0600_for_new_and_existing_files(monkeypatch, tmp_path):
+    patch_client(monkeypatch, FakeKubernetes())
+
+    existing = tmp_path / "kubeconfig-existing.yaml"
+    existing.write_text("stale-content")
+    os.chmod(existing, 0o644)
+
+    for target in (existing, tmp_path / "kubeconfig-new.yaml"):
+        result = runner.invoke(app, ["k8s", "kubeconfig", "c1", "-o", str(target)])
+        assert result.exit_code == 0, result.output
+        assert stat.S_IMODE(target.stat().st_mode) == 0o600
+        assert target.read_text() == "apiVersion: v1\nkind: Config\n"
+
+
+def test_maintenance_window_set_passes_all_options(monkeypatch):
+    kube = FakeKubernetes()
+    patch_client(monkeypatch, kube)
+
+    result = runner.invoke(app, ["k8s", "maintenance-window", "set", "c1",
+                                 "--timezone", "Europe/Oslo", "--day", "SAT", "--day", "SUN",
+                                 "--start", "02:00", "--duration", "120"])
+
+    assert result.exit_code == 0, result.output
+    (args, kwargs), = kube.calls
+    assert args == ("c1",)
+    assert kwargs == {"timezone": "Europe/Oslo", "days": ["SAT", "SUN"], "start": "02:00",
+                      "duration_minutes": 120, "enabled": True}
+    assert "2026-10-24T02:00:00+02:00" in result.output
+
+
+def test_maintenance_window_set_disabled_and_get(monkeypatch):
+    kube = FakeKubernetes()
+    patch_client(monkeypatch, kube)
+
+    result = runner.invoke(app, ["k8s", "maintenance-window", "set", "c1", "--timezone", "UTC",
+                                 "--day", "MON", "--start", "03:00", "--disabled"])
+    assert result.exit_code == 0, result.output
+    assert kube.calls[0][1]["enabled"] is False
+    assert kube.calls[0][1]["duration_minutes"] == 120  # default
+
+    kube.window = {"enabled": True, "timezone": "Europe/Oslo", "days": ["SAT"], "start": "02:00",
+                   "duration_minutes": 120, "next_window_start": "2026-10-24T02:00:00+02:00",
+                   "next_window_end": "2026-10-24T04:00:00+02:00"}
+    result = runner.invoke(app, ["k8s", "maintenance-window", "get", "c1"])
+    assert result.exit_code == 0, result.output
+    assert "Europe/Oslo" in result.output
+    assert "SAT" in result.output
+
+
+def test_maintenance_window_delete(monkeypatch):
+    kube = FakeKubernetes()
+    patch_client(monkeypatch, kube)
+    result = runner.invoke(app, ["k8s", "maintenance-window", "delete", "c1"])
+    assert result.exit_code == 0, result.output
+    assert "removed" in result.output.lower()
+    assert kube.calls[0][0] == ("c1",)
+
+
+def test_upgrade_mode_options_and_queued_output(monkeypatch):
+    kube = FakeKubernetes()
+    kube.upgrade_response = {"job": {"id": "j1", "target_version": "1.35", "mode": "next_maintenance_window",
+                                     "status": "queued", "execute_after": "2026-10-03T00:00:00+00:00"}}
+    patch_client(monkeypatch, kube)
+
+    result = runner.invoke(app, ["k8s", "upgrade", "c1", "1.35", "--mode", "next-maintenance-window",
+                                 "--strategy", "rolling-update", "--backup-first"])
+
+    assert result.exit_code == 0, result.output
+    (args, kwargs), = kube.calls
+    assert args == ("c1", "1.35")
+    assert kwargs == {"mode": "next_maintenance_window", "scheduled_at": None,
+                      "strategy": "rolling-update", "backup_before_upgrade": True}
+    assert "queued" in result.output
+
+
+def test_upgrade_defaults_to_rolling_after_qualification(monkeypatch):
+    kube = FakeKubernetes()
+    patch_client(monkeypatch, kube)
+
+    result = runner.invoke(app, ["k8s", "upgrade", "c1", "1.35"])
+
+    assert result.exit_code == 0, result.output
+    (args, kwargs), = kube.calls
+    assert kwargs == {"mode": "immediate", "scheduled_at": None, "strategy": "rolling-update", "backup_before_upgrade": False}
+    assert "Upgrading to 1.35" in result.output
+
+
+def test_upgrade_pool_command(monkeypatch):
+    kube = FakeKubernetes()
+    patch_client(monkeypatch, kube)
+
+    result = runner.invoke(app, ["k8s", "upgrade-pool", "c1", "default"])
+
+    assert result.exit_code == 0, result.output
+    assert kube.calls[0][0] == ("c1", "default")
+    assert "convergence started" in result.output
+
+
+def test_versions_command_shows_lifecycle(monkeypatch):
+    kube = FakeKubernetes()
+    patch_client(monkeypatch, kube)
+
+    result = runner.invoke(app, ["k8s", "versions"])
+
+    assert result.exit_code == 0, result.output
+    assert "1.34" in result.output and "transition" in result.output
+    assert "2026-10-15" in result.output
+    assert "Default for new clusters: 1.35" in result.output
+
+
+def test_upgrade_jobs_list_and_cancel(monkeypatch):
+    kube = FakeKubernetes()
+    kube.jobs = [{"id": "j1", "target_version": "1.35", "mode": "scheduled", "status": "queued",
+                  "execute_after": "2026-10-03T00:30:00+00:00", "window_end": "2026-10-03T02:00:00+00:00"}]
+    patch_client(monkeypatch, kube)
+
+    result = runner.invoke(app, ["k8s", "upgrade-jobs", "list", "c1"])
+    assert result.exit_code == 0, result.output
+    assert "queued" in result.output
+
+    result = runner.invoke(app, ["k8s", "upgrade-jobs", "cancel", "c1", "j1"])
+    assert result.exit_code == 0, result.output
+    assert "cancelled" in result.output.lower()
+    assert kube.calls[-1][0] == ("c1", "j1")
+
+
+def test_preflight_passes_options_and_reports_warnings(monkeypatch):
+    kube = FakeKubernetes()
+    kube.preflight_response = {"ok": True, "errors": [],
+                               "warnings": [{"code": "no_recent_backup", "message": "backup is old"}]}
+    patch_client(monkeypatch, kube)
+
+    result = runner.invoke(app, ["k8s", "preflight", "c1", "1.35", "--mode", "next-maintenance-window",
+                                 "--strategy", "rolling-update", "--backup-first"])
+
+    assert result.exit_code == 0, result.output
+    (args, kwargs), = kube.calls
+    assert args == ("c1", "1.35")
+    assert kwargs == {"mode": "next_maintenance_window", "scheduled_at": None,
+                      "strategy": "rolling-update", "backup_before_upgrade": True}
+    assert "WARNING  [no_recent_backup]" in result.output
+    assert "Preflight OK" in result.output
+
+
+def test_preflight_blockers_exit_nonzero(monkeypatch):
+    kube = FakeKubernetes()
+    kube.preflight_response = {"ok": False, "errors": [{"code": "node_pool_not_ready", "message": "pool not ready"}],
+                               "warnings": []}
+    patch_client(monkeypatch, kube)
+
+    result = runner.invoke(app, ["k8s", "preflight", "c1", "1.35"])
+
+    assert result.exit_code == 1, result.output
+    assert "BLOCKER  [node_pool_not_ready]" in result.output
+    assert "Preflight BLOCKED" in result.output
+
+
+def test_preflight_json_mode_prints_full_response_and_still_fails(monkeypatch):
+    import json as json_mod
+    from wayscloud_cli.output import set_json_mode
+
+    kube = FakeKubernetes()
+    kube.preflight_response = {"ok": False, "errors": [{"code": "target_not_available", "message": "nope"}],
+                               "warnings": [], "backup": {"latest_completed_at": None, "age_hours": None}}
+    patch_client(monkeypatch, kube)
+    try:
+        result = runner.invoke(app, ["--json", "k8s", "preflight", "c1", "1.35"])
+    finally:
+        set_json_mode(False)
+
+    assert result.exit_code == 1
+    parsed = json_mod.loads(result.output)
+    assert parsed["errors"][0]["code"] == "target_not_available"
+    assert parsed["backup"] == {"latest_completed_at": None, "age_hours": None}

{wayscloud_cli-0.5.0 → wayscloud_cli-0.6.0}/tests/test_smoke.py

@@ -2,6 +2,7 @@
 
 import json
 import os
+import re
 from unittest.mock import patch
 
 from typer.testing import CliRunner
@@ -13,19 +14,28 @@ from wayscloud_cli.output import set_json_mode, is_json_mode
 
 runner = CliRunner()
 
+# Rich styles option names with ANSI codes when color is forced (CI sets
+# FORCE_COLOR-like variables), splitting e.g. '--token' across sequences.
+# Assertions read the plain text so they are environment-independent.
+_ANSI = re.compile(r'\x1b\[[0-9;]*m')
+
+
+def plain(text):
+    return _ANSI.sub('', text)
+
 
 # ── App structure ───────────────────────────────────────────────
 
 def test_app_has_help():
     result = runner.invoke(app, ["--help"])
     assert result.exit_code == 0
-    assert "WAYSCloud CLI" in result.output
+    assert "WAYSCloud CLI" in plain(result.output)
 
 
 def test_version_flag():
     result = runner.invoke(app, ["--version"])
     assert result.exit_code == 0
-    assert __version__ in result.output
+    assert __version__ in plain(result.output)
 
 
 # ── Command groups registered ───────────────────────────────────
@@ -36,7 +46,7 @@ EXPECTED_GROUPS = ["auth", "vps", "dns", "storage", "db", "redis", "app", "iot",
 def test_all_command_groups_registered():
     result = runner.invoke(app, ["--help"])
     for group in EXPECTED_GROUPS:
-        assert group in result.output, f"Command group '{group}' not in help output"
+        assert group in plain(result.output), f"Command group '{group}' not in help output"
 
 
 def test_each_group_has_help():
@@ -50,7 +60,7 @@ def test_each_group_has_help():
 def test_login_shortcut_exists():
     result = runner.invoke(app, ["login", "--help"])
     assert result.exit_code == 0
-    assert "token" in result.output.lower()
+    assert "token" in plain(result.output).lower()
 
 
 def test_whoami_shortcut_exists():
@@ -110,14 +120,14 @@ def test_json_flag_accepted():
 def test_vps_list_help():
     result = runner.invoke(app, ["vps", "list", "--help"])
     assert result.exit_code == 0
-    assert "--token" in result.output
+    assert "--token" in plain(result.output)
 
 
 def test_vps_create_requires_flags():
     result = runner.invoke(app, ["vps", "create", "--help"])
     assert result.exit_code == 0
     for flag in ["--hostname", "--plan", "--region", "--os"]:
-        assert flag in result.output, f"Missing {flag} in vps create"
+        assert flag in plain(result.output), f"Missing {flag} in vps create"
 
 
 # ── DNS commands ────────────────────────────────────────────────
@@ -125,8 +135,8 @@ def test_vps_create_requires_flags():
 def test_dns_records_create_has_type_flag():
     result = runner.invoke(app, ["dns", "records-create", "--help"])
     assert result.exit_code == 0
-    assert "--type" in result.output
-    assert "--value" in result.output
+    assert "--type" in plain(result.output)
+    assert "--value" in plain(result.output)
 
 
 # ── DB commands ─────────────────────────────────────────────────
@@ -134,7 +144,7 @@ def test_dns_records_create_has_type_flag():
 def test_db_create_has_type_flag():
     result = runner.invoke(app, ["db", "create", "--help"])
     assert result.exit_code == 0
-    assert "--type" in result.output
+    assert "--type" in plain(result.output)
 
 
 # ── IoT commands ────────────────────────────────────────────────
@@ -142,8 +152,8 @@ def test_db_create_has_type_flag():
 def test_iot_devices_create_has_required_flags():
     result = runner.invoke(app, ["iot", "devices-create", "--help"])
     assert result.exit_code == 0
-    assert "--device-id" in result.output
-    assert "--name" in result.output
+    assert "--device-id" in plain(result.output)
+    assert "--name" in plain(result.output)
 
 
 # ── Impact commands ─────────────────────────────────────────────
@@ -153,27 +163,27 @@ def test_impact_subgroups_registered():
     result = runner.invoke(app, ["impact", "--help"])
     assert result.exit_code == 0
     for sub in ("forest", "tree", "commitments"):
-        assert sub in result.output, f"Missing impact subgroup: {sub}"
+        assert sub in plain(result.output), f"Missing impact subgroup: {sub}"
 
 
 def test_impact_tree_grow_has_count_flag():
     result = runner.invoke(app, ["impact", "tree", "grow", "--help"])
     assert result.exit_code == 0
-    assert "--count" in result.output
-    assert "--idempotency-key" in result.output
+    assert "--count" in plain(result.output)
+    assert "--idempotency-key" in plain(result.output)
 
 
 def test_impact_forest_create_help():
     result = runner.invoke(app, ["impact", "forest", "create", "--help"])
     assert result.exit_code == 0
     # Argument should be the forest name; --token override always accepted.
-    assert "--token" in result.output
+    assert "--token" in plain(result.output)
 
 
 def test_impact_forest_status_has_visualize():
     result = runner.invoke(app, ["impact", "forest", "status", "--help"])
     assert result.exit_code == 0
-    assert "--visualize" in result.output
+    assert "--visualize" in plain(result.output)
 
 
 def test_impact_forbidden_strings_not_in_help():
@@ -194,6 +204,6 @@ def test_impact_forbidden_strings_not_in_help():
         result = runner.invoke(app, sub_path)
         assert result.exit_code == 0, f"help failed for {sub_path}"
         for s in forbidden:
-            assert s not in result.output, (
+            assert s not in plain(result.output), (
                 f"Forbidden string {s!r} appeared in help for {sub_path}"
             )

wayscloud_cli-0.6.0/wayscloud_cli/__init__.py

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

{wayscloud_cli-0.5.0 → wayscloud_cli-0.6.0}/wayscloud_cli/commands/k8s.py

@@ -12,6 +12,14 @@ from ..output import print_table, print_object, print_json, is_json_mode
 
 app = typer.Typer(help="Managed Kubernetes")
 
+# Sub-app for the recurring upgrade window (#1162)
+window_app = typer.Typer(help="Recurring maintenance window for scheduled upgrades")
+app.add_typer(window_app, name="maintenance-window")
+
+# Sub-app for scheduled upgrade jobs (#1163)
+jobs_app = typer.Typer(help="Scheduled upgrade jobs (list, cancel)")
+app.add_typer(jobs_app, name="upgrade-jobs")
+
 CLUSTER_COLUMNS = [
     ("id", "ID", 38), ("name", "Name", 20), ("status", "Status", 13), ("version", "Version", 8),
     ("region", "Region", 7), ("nodes", "Nodes", 6), ("created_at", "Created", 20),
@@ -76,6 +84,25 @@ def plans(region: str = typer.Option("no", "--region"), kind: Optional[str] = ty
     print_table(rows, [("plan_code", "Plan", 18), ("kind", "Kind", 13), ("name", "Name", 22), ("spec", "Spec", 24), ("monthly", "Monthly", 14)])
 
 
+@app.command("versions")
+def versions(token: Optional[str] = typer.Option(None, "--token")):
+    """Kubernetes version lifecycle: status, cutoffs and deadlines."""
+    data = sdk_call(get_client(token).kubernetes.versions)
+    if is_json_mode():
+        print_json(data); return
+    rows = [{"version": v["version"], "status": v["status"],
+             "create_until": v.get("create_until") or "—",
+             "support_ends": v.get("support_ends_at") or "—",
+             "upgrade_by": v.get("upgrade_required_by") or "—",
+             "recommended": v.get("recommended_upgrade") or "—"}
+            for v in data.get("versions", [])]
+    print_table(rows, [("version", "Version", 8), ("status", "Status", 14), ("create_until", "Create until", 13),
+                       ("support_ends", "Support ends", 13), ("upgrade_by", "Upgrade by", 11),
+                       ("recommended", "Recommended", 12)])
+    if data.get("default"):
+        print(f"Default for new clusters: {data['default']}")
+
+
 @app.command("list")
 def list_clusters(token: Optional[str] = typer.Option(None, "--token")):
     """List clusters."""
@@ -93,7 +120,7 @@ def create(
     pool: List[str] = typer.Option(["k8s-node-2c4g:2"], "--pool", help="Node pool: 'plan:count' or 'name=…,plan=…,count=…' (repeatable)"),
     plan: str = typer.Option("k8s-cluster-dev", "--plan", help="k8s-cluster-dev | k8s-cluster-prod"),
     region: str = typer.Option("no", "--region"),
-    version: str = typer.Option("1.34", "--version"),
+    version: str = typer.Option("1.35", "--version"),
     allow: List[str] = typer.Option([], "--allow", help="CIDR allowed to reach the API (repeatable)"),
     wait: bool = typer.Option(False, "--wait", help="Block until the cluster is running"),
     token: Optional[str] = typer.Option(None, "--token"),
@@ -179,6 +206,13 @@ def delete_pool(cluster_id: str = typer.Argument(...), name: str = typer.Argumen
     print_json(c) if is_json_mode() else print(f"Pool {name} deleted.")
 
 
+@app.command("upgrade-pool")
+def upgrade_pool(cluster_id: str = typer.Argument(...), name: str = typer.Argument(...), token: Optional[str] = typer.Option(None, "--token")):
+    """Converge a node pool's nodes to the cluster's Kubernetes version."""
+    c = sdk_call(get_client(token).kubernetes.upgrade_node_pool, cluster_id, name)
+    print_json(c) if is_json_mode() else print(f"Pool {name} convergence started; workers follow in the background.")
+
+
 @app.command("api-access")
 def api_access(cluster_id: str = typer.Argument(...), cidr: List[str] = typer.Option([], "--cidr", help="Allowed CIDR (repeatable); an empty list allows only WAYSCloud access"),
                token: Optional[str] = typer.Option(None, "--token")):
@@ -236,15 +270,82 @@ def restore(cluster_id: str = typer.Argument(...), backup_id: str = typer.Argume
 
 @app.command("upgrade")
 def upgrade(cluster_id: str = typer.Argument(...), version: Optional[str] = typer.Argument(None, help="Target version; omit to list"),
+            mode: str = typer.Option("immediate", "--mode", help="immediate | next-maintenance-window | scheduled"),
+            at: Optional[str] = typer.Option(None, "--at", help="scheduled_at (ISO-8601 with offset); required with --mode scheduled"),
+            strategy: Optional[str] = typer.Option("rolling-update", "--strategy", help="rolling-update (default) | manual"),
+            backup_first: bool = typer.Option(False, "--backup-first", help="Take a backup first and continue when it completes"),
             token: Optional[str] = typer.Option(None, "--token")):
-    """List available upgrades or upgrade to a version."""
+    """List available upgrades or request an upgrade (immediate, next window or scheduled)."""
     c = get_client(token)
     if not version:
         v = sdk_call(c.kubernetes.available_upgrades, cluster_id)
         print_json(v) if is_json_mode() else print("Available: " + (", ".join(v) or "none"))
         return
-    r = sdk_call(c.kubernetes.upgrade, cluster_id, version)
-    print_json(r) if is_json_mode() else print(f"Upgrading to {version}. No backup is taken automatically; create one first if needed.")
+    r = sdk_call(c.kubernetes.upgrade, cluster_id, version, mode=mode.strip().lower().replace("-", "_"),
+                 scheduled_at=at, strategy=strategy, backup_before_upgrade=backup_first)
+    if is_json_mode():
+        print_json(r); return
+    if isinstance(r, dict) and "job" in r:
+        j = r["job"]
+        line = f"Upgrade {j['target_version']} queued ({j['mode']}): {j['status']}"
+        if j.get("execute_after"):
+            line += f", starts {j['execute_after']}"
+        print(line)
+    else:
+        print(f"Upgrading to {version}. Brief API interruptions may occur during the control-plane restart.")
+
+
+@app.command("preflight")
+def preflight(cluster_id: str = typer.Argument(...), version: str = typer.Argument(..., help="Target version to check"),
+              mode: str = typer.Option("immediate", "--mode", help="immediate | next-maintenance-window | scheduled"),
+              at: Optional[str] = typer.Option(None, "--at", help="scheduled_at (ISO-8601 with offset); required with --mode scheduled"),
+              strategy: Optional[str] = typer.Option("rolling-update", "--strategy", help="rolling-update (default) | manual"),
+              backup_first: bool = typer.Option(False, "--backup-first", help="Check as if a fresh backup is taken first"),
+              token: Optional[str] = typer.Option(None, "--token")):
+    """Pre-upgrade check: blockers and advisory warnings before requesting an upgrade.
+
+    Read-only. Exits non-zero when the check reports blockers, so pipelines can
+    gate on it."""
+    r = sdk_call(get_client(token).kubernetes.upgrade_preflight, cluster_id, version,
+                 mode=mode.strip().lower().replace("-", "_"), scheduled_at=at, strategy=strategy,
+                 backup_before_upgrade=backup_first)
+    if is_json_mode():
+        print_json(r)
+        if not r.get("ok"):
+            raise typer.Exit(code=1)
+        return
+    for e in r.get("errors") or []:
+        print(f"BLOCKER  [{e.get('code')}] {e.get('message')}")
+    for w in r.get("warnings") or []:
+        print(f"WARNING  [{w.get('code')}] {w.get('message')}")
+    if r.get("ok"):
+        print("Preflight OK" + (" — warnings are advisory" if r.get("warnings") else ""))
+    else:
+        print("Preflight BLOCKED — resolve the blockers above, or re-check later.")
+        raise typer.Exit(code=1)
+
+
+JOBS_COLUMNS = [("id", "ID", 10), ("target_version", "Version", 8), ("mode", "Mode", 24),
+                ("status", "Status", 34), ("execute_after", "Execute after", 26), ("window_end", "Window end", 26)]
+
+
+@jobs_app.command("list")
+def upgrade_jobs_list(cluster_id: str = typer.Argument(...), token: Optional[str] = typer.Option(None, "--token")):
+    """List scheduled/queued upgrade jobs for a cluster."""
+    jobs = sdk_call(get_client(token).kubernetes.upgrade_jobs, cluster_id)
+    if is_json_mode():
+        print_json(jobs); return
+    if not jobs:
+        print("No upgrade jobs."); return
+    print_table([{**j, "id": str(j["id"])[:8]} for j in jobs], JOBS_COLUMNS)
+
+
+@jobs_app.command("cancel")
+def upgrade_jobs_cancel(cluster_id: str = typer.Argument(...), job_id: str = typer.Argument(...),
+                        token: Optional[str] = typer.Option(None, "--token")):
+    """Cancel a queued or preflight upgrade job."""
+    j = sdk_call(get_client(token).kubernetes.cancel_upgrade_job, cluster_id, job_id)
+    print_json(j) if is_json_mode() else print(f"Upgrade job {job_id} cancelled.")
 
 
 @app.command("delete")
@@ -256,3 +357,42 @@ def delete(cluster_id: str = typer.Argument(...), confirm_name: str = typer.Opti
     if wait:
         r = sdk_call(c.kubernetes.wait, cluster_id)
     print_json(r) if is_json_mode() else print(f"Cluster {cluster_id} is {r.get('status')}.")
+
+
+WINDOW_COLUMNS = [
+    ("enabled", "Enabled"), ("timezone", "Timezone"), ("days", "Days"), ("start", "Start"),
+    ("duration_minutes", "Duration (min)"), ("next_window_start", "Next start"), ("next_window_end", "Next end"),
+]
+
+
+@window_app.command("get")
+def maintenance_window_get(cluster_id: str = typer.Argument(...), token: Optional[str] = typer.Option(None, "--token")):
+    """Show the recurring upgrade window."""
+    w = sdk_call(get_client(token).kubernetes.get_maintenance_window, cluster_id)
+    if is_json_mode():
+        print_json(w); return
+    print_object({**w, "days": ", ".join(w.get("days") or [])}, WINDOW_COLUMNS)
+
+
+@window_app.command("set")
+def maintenance_window_set(cluster_id: str = typer.Argument(...),
+                           timezone: str = typer.Option(..., "--timezone", help="IANA timezone, e.g. Europe/Oslo"),
+                           day: List[str] = typer.Option(..., "--day", help="Weekday MON..SUN (repeatable)"),
+                           start: str = typer.Option(..., "--start", help="Local start time HH:MM"),
+                           duration: int = typer.Option(120, "--duration", min=30, max=480, help="Window length in minutes (30–480)"),
+                           disabled: bool = typer.Option(False, "--disabled", help="Store the window disabled"),
+                           token: Optional[str] = typer.Option(None, "--token")):
+    """Create or replace the recurring upgrade window."""
+    w = sdk_call(get_client(token).kubernetes.set_maintenance_window, cluster_id,
+                 timezone=timezone, days=list(day), start=start, duration_minutes=duration, enabled=not disabled)
+    if is_json_mode():
+        print_json(w); return
+    print(f"Maintenance window set: {', '.join(w['days'])} {w['start']} ({w['duration_minutes']} min, {w['timezone']}).")
+    print(f"Next window: {w['next_window_start']} – {w['next_window_end']}")
+
+
+@window_app.command("delete")
+def maintenance_window_delete(cluster_id: str = typer.Argument(...), token: Optional[str] = typer.Option(None, "--token")):
+    """Remove the recurring upgrade window."""
+    w = sdk_call(get_client(token).kubernetes.delete_maintenance_window, cluster_id)
+    print_json(w) if is_json_mode() else print("Maintenance window removed.")

{wayscloud_cli-0.5.0 → wayscloud_cli-0.6.0}/wayscloud_cli.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: wayscloud-cli
-Version: 0.5.0
-Summary: Command-line interface for WAYSCloud — manage VPS, DNS, databases, storage, apps, Kubernetes, IoT, and more
+Version: 0.6.0
+Summary: Command-line interface for WAYSCloud — manage VPS, DNS, databases, storage, apps, IoT, and more
 License: MIT
 Project-URL: Homepage, https://wayscloud.services
 Project-URL: Documentation, https://docs.wayscloud.services/integrations/#wayscloud-cli
@@ -20,7 +20,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: wayscloud>=0.4.0
+Requires-Dist: wayscloud>=0.5.0
 Requires-Dist: typer>=0.9
 Requires-Dist: rich>=13.0
 Requires-Dist: websockets>=12.0
@@ -36,7 +36,7 @@ Command-line interface for [WAYSCloud](https://wayscloud.services). Built on the
 pip install wayscloud-cli
 ```
 
-Version 0.5.0 adds Managed Kubernetes (`cloud k8s …`) and requires SDK `wayscloud>=0.4.0`.
+Version 0.6.0 adds the upgrade preflight (`cloud k8s preflight`, non-zero exit on blockers) and requires SDK `wayscloud>=0.5.0`.
 
 ## Authentication
 
@@ -121,6 +121,8 @@ cloud k8s list
 cloud k8s create shop --pool k8s-node-2c4g:2 --plan k8s-cluster-dev --region no --wait
 cloud k8s info <cluster-id>
 cloud k8s kubeconfig <cluster-id> -o ~/.kube/shop.yaml   # written with mode 0600
+cloud k8s preflight <cluster-id> 1.35                  # blockers/warnings; exit != 0 on blockers
+cloud k8s upgrade <cluster-id> 1.35 --mode next-maintenance-window --backup-first
 cloud k8s scale <cluster-id> default 4
 cloud k8s add-pool <cluster-id> batch --plan k8s-node-4c16g --count 2 \
   --label role=worker --taint dedicated=gpu:NoSchedule --ssh-key-id <key-id>

{wayscloud_cli-0.5.0 → wayscloud_cli-0.6.0}/wayscloud_cli.egg-info/requires.txt

@@ -1,4 +1,4 @@
-wayscloud>=0.4.0
+wayscloud>=0.5.0
 typer>=0.9
 rich>=13.0
 websockets>=12.0

wayscloud_cli-0.5.0/tests/test_k8s_cli.py

@@ -1,101 +0,0 @@
-"""k8s command tests -- option parsing, payloads and file handling."""
-
-import os
-import stat
-
-from typer.testing import CliRunner
-
-from wayscloud_cli.__main__ import app
-from wayscloud_cli.commands import k8s as k8s_cmd
-
-runner = CliRunner()
-
-
-class FakeKubernetes:
-    def __init__(self):
-        self.calls = []
-
-    def add_node_pool(self, *args, **kwargs):
-        self.calls.append((args, kwargs))
-        return {"id": "c1"}
-
-    def kubeconfig(self, cluster_id):
-        return "apiVersion: v1\nkind: Config\n"
-
-
-class FakeClient:
-    def __init__(self, kubernetes):
-        self.kubernetes = kubernetes
-
-
-def patch_client(monkeypatch, kubernetes):
-    monkeypatch.setattr(k8s_cmd, "get_client", lambda token=None: FakeClient(kubernetes))
-
-
-def test_parse_labels_and_taints():
-    assert k8s_cmd._parse_labels([]) == {}
-    assert k8s_cmd._parse_labels(["role=worker", "zone=a=b"]) == {"role": "worker", "zone": "a=b"}
-    assert k8s_cmd._parse_taints([]) == []
-    assert k8s_cmd._parse_taints(["dedicated=gpu:NoSchedule", "spot=:PreferNoSchedule"]) == [
-        {"key": "dedicated", "value": "gpu", "effect": "NoSchedule"},
-        {"key": "spot", "value": "", "effect": "PreferNoSchedule"},
-    ]
-
-
-def test_add_pool_passes_labels_taints_and_ssh_keys(monkeypatch):
-    kube = FakeKubernetes()
-    patch_client(monkeypatch, kube)
-
-    result = runner.invoke(app, [
-        "k8s", "add-pool", "c1", "workers", "--plan", "k8s-node-2c4g", "--count", "3",
-        "--label", "role=worker", "--label", "tier=compute",
-        "--taint", "dedicated=gpu:NoExecute",
-        "--ssh-key-id", "11111111-1111-1111-1111-111111111111",
-    ])
-
-    assert result.exit_code == 0, result.output
-    (args, kwargs), = kube.calls
-    assert args == ("c1", "workers", "k8s-node-2c4g", 3)
-    assert kwargs["labels"] == {"role": "worker", "tier": "compute"}
-    assert kwargs["taints"] == [{"key": "dedicated", "value": "gpu", "effect": "NoExecute"}]
-    assert kwargs["ssh_key_ids"] == ["11111111-1111-1111-1111-111111111111"]
-
-
-def test_add_pool_defaults_to_no_labels_taints_or_keys(monkeypatch):
-    kube = FakeKubernetes()
-    patch_client(monkeypatch, kube)
-
-    result = runner.invoke(app, ["k8s", "add-pool", "c1", "workers", "--plan", "k8s-node-2c4g"])
-
-    assert result.exit_code == 0, result.output
-    (args, kwargs), = kube.calls
-    assert args == ("c1", "workers", "k8s-node-2c4g", 1)
-    assert kwargs == {"labels": {}, "taints": [], "ssh_key_ids": []}
-
-
-def test_add_pool_rejects_malformed_label_and_taint(monkeypatch):
-    patch_client(monkeypatch, FakeKubernetes())
-
-    for value in ("novalue", "=noKey"):
-        result = runner.invoke(app, ["k8s", "add-pool", "c1", "workers", "--plan", "k8s-node-2c4g", "--label", value])
-        assert result.exit_code != 0
-        assert "key=value" in result.output
-
-    for value in ("novalue", "key:NoSchedule", "key=value:Sometimes"):
-        result = runner.invoke(app, ["k8s", "add-pool", "c1", "workers", "--plan", "k8s-node-2c4g", "--taint", value])
-        assert result.exit_code != 0
-        assert "key=value:Effect" in result.output or "taint effect" in result.output
-
-
-def test_kubeconfig_output_file_is_0600_for_new_and_existing_files(monkeypatch, tmp_path):
-    patch_client(monkeypatch, FakeKubernetes())
-
-    existing = tmp_path / "kubeconfig-existing.yaml"
-    existing.write_text("stale-content")
-    os.chmod(existing, 0o644)
-
-    for target in (existing, tmp_path / "kubeconfig-new.yaml"):
-        result = runner.invoke(app, ["k8s", "kubeconfig", "c1", "-o", str(target)])
-        assert result.exit_code == 0, result.output
-        assert stat.S_IMODE(target.stat().st_mode) == 0o600
-        assert target.read_text() == "apiVersion: v1\nkind: Config\n"

wayscloud_cli-0.5.0/wayscloud_cli/__init__.py

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