smanager 0.2.0__tar.gz → 0.2.2__tar.gz

{smanager-0.2.0 → smanager-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smanager
-Version: 0.2.0
+Version: 0.2.2
 Requires-Python: >=3.9
 Requires-Dist: PyYAML>=6.0
 Requires-Dist: click>=8.0

smanager-0.2.2/README.md

@@ -0,0 +1,60 @@
+# SManager
+> A simple server manager for self-hosted services, with VPN integration and support for both local and Docker-based services.
+
+## Features
+- Unified service management for local/systemd and Docker runtimes.
+- VPN integration (Tailscale provider support).
+- Interactive metadata creation and editing.
+- YAML-based global configuration.
+
+## CLI Usage
+Use this command pattern:
+
+```bash
+smanager <group> <command> [options]
+```
+
+Discover available commands at any level:
+
+```bash
+smanager --help
+smanager <group> --help
+smanager <group> <command> --help
+```
+
+## Metadata Commands
+The `metadata` group provides interactive workflows for service metadata files.
+
+### Create Metadata
+```bash
+smanager metadata init
+```
+
+Optional output override:
+
+```bash
+smanager metadata init --output /path/to/sd_info.json
+```
+
+### Edit Existing Metadata
+```bash
+smanager metadata edit
+```
+
+Edit a specific file directly:
+
+```bash
+smanager metadata edit --file /path/to/sd_info.json
+```
+
+Behavior summary:
+- Interactive prompts with inline defaults.
+- Runtime-aware sections (Docker vs Local).
+- Multi-select support for `groups` and `depends_on`.
+- Validation before writing changes.
+
+## Notes
+- `metadata init` creates a new file.
+- `metadata edit` modifies an existing file.
+- Use command-specific `--help` for the latest options and examples.
+

{smanager-0.2.0 → smanager-0.2.2}/smanager/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.2.0"
+__version__ = "0.2.2"
 
 from .global_manager import GlobalManager
 from .datatypes import GlobalConfig, Service, ServiceStatus, MultiStatus

{smanager-0.2.0 → smanager-0.2.2}/smanager/cli/commands/metadata.py

@@ -1,7 +1,7 @@
 import click
 from pathlib import Path
 
-from ..metadata_wizard import MetadataWizard
+from ..metadata_wizard import MetadataEditor, MetadataWizard
 
 
 @click.group("metadata")
@@ -21,3 +21,18 @@ def init_cmd(output: Path | None) -> None:
     """Create a service metadata file using an interactive guided wizard."""
     wizard = MetadataWizard(output_override=output)
     wizard.run()
+
+
+@metadata_cmd.command("edit")
+@click.option(
+    "--file",
+    "metadata_file",
+    type=click.Path(path_type=Path, dir_okay=False, exists=False),
+    default=None,
+    metavar="PATH",
+    help="Path to an existing metadata file. If omitted, choose interactively.",
+)
+def edit_cmd(metadata_file: Path | None) -> None:
+    """Edit an existing service metadata file interactively."""
+    editor = MetadataEditor(metadata_path=metadata_file)
+    editor.run()

{smanager-0.2.0 → smanager-0.2.2}/smanager/cli/metadata_wizard.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import re
 from pathlib import Path
 from typing import Any, Iterable
@@ -409,3 +410,166 @@ class MetadataWizard:
         if len(values) <= 3:
             return ", ".join(values)
         return f"{len(values)} selected"
+
+
+class MetadataEditor(MetadataWizard):
+    def __init__(self, metadata_path: Path | None = None, console: Console | None = None):
+        super().__init__(output_override=None, console=console)
+        self.metadata_path = metadata_path
+
+    def run(self) -> Path:
+        target_path = self._resolve_metadata_path()
+        metadata_dict = self._load_metadata_dict(target_path)
+        ServiceMetadata.from_dict(metadata_dict)
+        original_json = json.dumps(metadata_dict, sort_keys=True)
+
+        self.console.print(
+            Panel.fit(
+                f"[bold cyan]Metadata Editor[/]\n"
+                f"[dim]Editing {target_path}. Choose sections and save when ready.[/]",
+                title="smanager metadata edit",
+            )
+        )
+
+        while True:
+            section = self._ask_select(
+                "Edit section",
+                [
+                    "Identity",
+                    "Runtime",
+                    "Runtime details",
+                    "Groups",
+                    "Depends on",
+                    "VPN",
+                    "Active",
+                    "Save and exit",
+                    "Exit without saving",
+                ],
+                "Identity",
+            )
+
+            if section == "Identity":
+                self._edit_identity(metadata_dict)
+            elif section == "Runtime":
+                self._edit_runtime(metadata_dict)
+            elif section == "Runtime details":
+                self._edit_runtime_details(metadata_dict)
+            elif section == "Groups":
+                self._edit_groups(metadata_dict, target_path)
+            elif section == "Depends on":
+                self._edit_dependencies(metadata_dict, target_path)
+            elif section == "VPN":
+                self._edit_vpn(metadata_dict)
+            elif section == "Active":
+                metadata_dict["active"] = self._ask_confirm("Enable service", bool(metadata_dict.get("active", True)))
+            elif section == "Save and exit":
+                break
+            elif section == "Exit without saving":
+                self.console.print("[yellow]No changes written.[/]")
+                return target_path
+
+        metadata = ServiceMetadata.from_dict(metadata_dict)
+        self._render_review(metadata, target_path.parent, target_path.name)
+
+        if not self._ask_confirm("Save changes", True):
+            raise click.ClickException("Cancelled by user.")
+
+        if json.dumps(metadata_dict, sort_keys=True) == original_json:
+            self.console.print("[yellow]No changes detected.[/]")
+            return target_path
+
+        metadata.write_to_json(str(target_path))
+        self.console.print(f"[green]✓ Metadata saved to {target_path}[/]")
+        return target_path
+
+    def _resolve_metadata_path(self) -> Path:
+        if self.metadata_path is not None:
+            target_path = self.metadata_path.expanduser()
+        else:
+            candidates = self._discover_metadata_files(Path.cwd())
+            if not candidates:
+                raise click.ClickException("No metadata files found (expected sd_info.*).")
+            if len(candidates) == 1:
+                target_path = candidates[0]
+            else:
+                default_choice = str(candidates[0])
+                selected = self._ask_select("Metadata file", [str(path) for path in candidates], default_choice)
+                target_path = Path(selected)
+
+        if not target_path.is_file():
+            raise click.ClickException(f"Metadata file not found: {target_path}")
+        return target_path
+
+    def _discover_metadata_files(self, root: Path) -> list[Path]:
+        return sorted(path for path in root.rglob("sd_info.*") if path.is_file())
+
+    def _load_metadata_dict(self, path: Path) -> dict[str, Any]:
+        try:
+            return json.loads(path.read_text(encoding="utf-8"))
+        except json.JSONDecodeError as exc:
+            raise click.ClickException(f"Invalid JSON metadata file: {path}") from exc
+
+    def _edit_identity(self, metadata_dict: dict[str, Any]) -> None:
+        metadata_dict["name"] = self._ask_text("Service name", str(metadata_dict.get("name", "")))
+        metadata_dict["description"] = self._ask_text("Description", str(metadata_dict.get("description", "")))
+        metadata_dict["id"] = self._ask_text("Service id", str(metadata_dict.get("id", "")))
+
+    def _edit_runtime(self, metadata_dict: dict[str, Any]) -> None:
+        runtime = metadata_dict.setdefault("runtime", {})
+        runtime_type = self._ask_select("Runtime type", ["docker", "local"], str(runtime.get("type", "local")))
+        runtime["type"] = runtime_type
+
+        ports = runtime.setdefault("ports", {})
+        ports["webui"] = self._ask_int("Web UI port", int(ports.get("webui", 8080)))
+        runtime["sys_user"] = self._ask_text("System user", str(runtime.get("sys_user", metadata_dict.get("id", "service"))))
+        runtime["sys_group"] = self._ask_text("System group", str(runtime.get("sys_group", metadata_dict.get("id", "service"))))
+
+        if runtime_type == "docker":
+            metadata_dict.pop("local", None)
+            metadata_dict.setdefault("docker", {"compose_file": "compose.yaml", "containers": None})
+        else:
+            metadata_dict.pop("docker", None)
+            service_id = str(metadata_dict.get("id", "service"))
+            metadata_dict.setdefault(
+                "local",
+                {
+                    "installation_path": f"/opt/{service_id}",
+                    "appdata_path": f"/var/lib/{service_id}",
+                    "systemd_services": [service_id],
+                },
+            )
+
+    def _edit_runtime_details(self, metadata_dict: dict[str, Any]) -> None:
+        runtime_type = metadata_dict.get("runtime", {}).get("type", "local")
+        if runtime_type == "docker":
+            docker = metadata_dict.setdefault("docker", {})
+            docker["compose_file"] = self._ask_text("Compose file", str(docker.get("compose_file", "compose.yaml")))
+            containers = docker.get("containers") or []
+            containers_csv = ", ".join(containers)
+            parsed = parse_csv(self._ask_text("Containers (comma-separated)", containers_csv))
+            docker["containers"] = parsed or None
+            return
+
+        local = metadata_dict.setdefault("local", {})
+        service_id = str(metadata_dict.get("id", "service"))
+        local["installation_path"] = self._ask_text("Installation path", str(local.get("installation_path", f"/opt/{service_id}")))
+        local["appdata_path"] = self._ask_text("Appdata path", str(local.get("appdata_path", f"/var/lib/{service_id}")))
+        services = local.get("systemd_services") or [service_id]
+        parsed_services = parse_csv(self._ask_text("Systemd services (comma-separated)", ", ".join(services)))
+        local["systemd_services"] = parsed_services or [service_id]
+
+    def _edit_groups(self, metadata_dict: dict[str, Any], target_path: Path) -> None:
+        current = metadata_dict.get("groups") or []
+        available = sorted(set(self._existing_groups(target_path.parent) + current))
+        metadata_dict["groups"] = self._ask_groups(available) or None
+
+    def _edit_dependencies(self, metadata_dict: dict[str, Any], target_path: Path) -> None:
+        service_id = str(metadata_dict.get("id", ""))
+        current = metadata_dict.get("depends_on") or []
+        available = sorted(set(self._existing_dependencies(target_path.parent, service_id) + current) - {service_id})
+        metadata_dict["depends_on"] = self._ask_dependencies(available) or None
+
+    def _edit_vpn(self, metadata_dict: dict[str, Any]) -> None:
+        vpn = metadata_dict.setdefault("vpn", {})
+        vpn["serve_https"] = self._ask_confirm("Serve HTTPS through VPN", bool(vpn.get("serve_https", False)))
+        vpn["https_restart_delay"] = self._ask_int("HTTPS restart delay", int(vpn.get("https_restart_delay", 5)))

{smanager-0.2.0 → smanager-0.2.2}/smanager/service_managers/local_manager.py

@@ -2,6 +2,7 @@ from . import BaseSDV2Manager
 from ..datatypes import Service
 from ..vpn import VPNService
 import time
+import subprocess
 from ..datatypes import ServiceStatus, SingleStatus
 
 class LocalManager(BaseSDV2Manager):
@@ -105,10 +106,18 @@ class LocalManager(BaseSDV2Manager):
         """Check the status of the local systemd service and return a ServiceStatus object."""
         service_statuses = []
         for service_name in self._get_systemd_services():
-            result = self.subprocess_run(["systemctl", "is-active", service_name])
+            result = subprocess.run(
+                ["systemctl", "is-active", service_name],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            status_text = result.stdout.strip() or result.stderr.strip()
+            if not status_text:
+                status_text = "active" if result.returncode == 0 else "inactive"
             status = SingleStatus(
                 name=service_name,
-                status=result.stdout.strip()
+                status=status_text
             )
             service_statuses.append(status)
         return ServiceStatus(

{smanager-0.2.0 → smanager-0.2.2}/smanager.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smanager
-Version: 0.2.0
+Version: 0.2.2
 Requires-Python: >=3.9
 Requires-Dist: PyYAML>=6.0
 Requires-Dist: click>=8.0

{smanager-0.2.0 → smanager-0.2.2}/tests/test_metadata_wizard.py

@@ -8,7 +8,7 @@ from unittest.mock import patch
 
 import click
 
-from smanager.cli.metadata_wizard import ADD_NEW_GROUP_LABEL, MetadataWizard
+from smanager.cli.metadata_wizard import ADD_NEW_GROUP_LABEL, MetadataEditor, MetadataWizard
 
 
 class MetadataWizardTests(unittest.TestCase):
@@ -208,5 +208,71 @@ class MetadataWizardTests(unittest.TestCase):
         self.assertEqual(groups, ["media", "new-group"])
 
 
+class MetadataEditorTests(unittest.TestCase):
+    def _metadata_payload(self) -> dict:
+        return {
+            "name": "Sonarr",
+            "description": "Sonarr service",
+            "schema_version": 2,
+            "id": "sonarr",
+            "active": True,
+            "runtime": {
+                "type": "local",
+                "ports": {"webui": 8989},
+                "sys_user": "sonarr",
+                "sys_group": "sonarr",
+            },
+            "groups": ["media"],
+            "depends_on": ["qbittorrent"],
+            "local": {
+                "installation_path": "/opt/sonarr",
+                "appdata_path": "/var/lib/sonarr",
+                "systemd_services": ["sonarr"],
+            },
+            "vpn": {"serve_https": False, "https_restart_delay": 5},
+        }
+
+    def test_metadata_edit_updates_identity_and_saves(self):
+        with TemporaryDirectory() as tmpdir:
+            metadata_path = Path(tmpdir) / "sd_info.json"
+            metadata_path.write_text(json.dumps(self._metadata_payload()), encoding="utf-8")
+            editor = MetadataEditor(metadata_path=metadata_path)
+
+            with patch.object(editor, "_ask_select", side_effect=["Identity", "Save and exit"]), patch.object(
+                editor,
+                "_ask_text",
+                side_effect=["Sonarr Updated", "Updated description", "sonarr-updated"],
+            ), patch.object(editor, "_ask_confirm", return_value=True):
+                result = editor.run()
+
+            self.assertEqual(result, metadata_path)
+            updated = json.loads(metadata_path.read_text(encoding="utf-8"))
+            self.assertEqual(updated["name"], "Sonarr Updated")
+            self.assertEqual(updated["description"], "Updated description")
+            self.assertEqual(updated["id"], "sonarr-updated")
+
+    def test_metadata_edit_can_exit_without_saving(self):
+        with TemporaryDirectory() as tmpdir:
+            metadata_path = Path(tmpdir) / "sd_info.json"
+            original = self._metadata_payload()
+            metadata_path.write_text(json.dumps(original), encoding="utf-8")
+            editor = MetadataEditor(metadata_path=metadata_path)
+
+            with patch.object(editor, "_ask_select", return_value="Exit without saving"), patch.object(
+                editor, "_ask_confirm"
+            ) as confirm_mock:
+                result = editor.run()
+
+            self.assertEqual(result, metadata_path)
+            self.assertEqual(json.loads(metadata_path.read_text(encoding="utf-8")), original)
+            confirm_mock.assert_not_called()
+
+    def test_metadata_edit_raises_when_file_is_missing(self):
+        editor = MetadataEditor(metadata_path=Path("/tmp/does-not-exist-sd-info.json"))
+
+        with self.assertRaises(click.ClickException):
+            editor.run()
+
+
 if __name__ == "__main__":
     unittest.main()

{smanager-0.2.0 → smanager-0.2.2}/tests/test_service_manager_events.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from tempfile import TemporaryDirectory
 from types import SimpleNamespace
 import unittest
-from unittest.mock import Mock
+from unittest.mock import Mock, patch
 
 from smanager.datatypes import (
     DockerSection,
@@ -161,3 +161,18 @@ class LocalManagerEventTests(unittest.TestCase):
             manager.stop()
 
             self.assertEqual(events, ["service.stop.before", "service.stop.after"])
+
+    def test_status_returns_inactive_when_systemctl_reports_inactive(self):
+        with TemporaryDirectory() as tmpdir:
+            service_dir = Path(tmpdir) / "local"
+            service_dir.mkdir()
+            service = make_local_service(service_dir, active=True)
+
+            manager = LocalManager(service, DummyVPN())
+
+            fake_result = SimpleNamespace(stdout="inactive\n", stderr="", returncode=4)
+            with patch("smanager.service_managers.local_manager.subprocess.run", return_value=fake_result) as run_mock:
+                result = manager.status()
+
+            self.assertEqual(result.statuses[0].status, "inactive")
+            run_mock.assert_called_once()

smanager-0.2.0/README.md

@@ -1,15 +0,0 @@
-# SManager
-> A simple server manager for self-hosted services, with VPN integration and support for both local and Docker-based services.
-
-## Features
-- Manage local services and Docker containers with a unified interface.
-- Integrate with Tailscale VPN for secure remote access.
-- Monitor service status and logs in real-time.
-- Easy configuration using YAML files.
-- Extensible architecture for adding new service types and VPN providers.
-
-## Interactive Metadata Wizard
-- Create a new service metadata file with `smanager metadata init`.
-- The wizard is interactive, shows defaults in context, and only asks Docker-specific or local-specific fields depending on the runtime you choose.
-- It uses Rich for a guided terminal experience and validates the generated metadata before saving it.
-