smanager 0.1.0__py3-none-any.whl

smanager/__init__.py

@@ -0,0 +1,13 @@
+__version__ = "0.1.0"
+
+from .global_manager import GlobalManager
+from .datatypes import GlobalConfig, Service, ServiceStatus, MultiStatus
+
+__all__ = [
+    "__version__",
+    "GlobalManager",
+    "GlobalConfig",
+    "Service",
+    "ServiceStatus",
+    "MultiStatus",
+]

smanager/cli/commands/__init__.py

@@ -0,0 +1,10 @@
+ACTIONS = ("start", "stop", "restart", "enable", "disable")
+
+from .service import service_cmd
+from .group import group_cmd
+from .dependency import dependency_cmd
+from .all import all_cmd
+from .status import status_cmd
+from .config import config_cmd
+
+__all__ = ["ACTIONS", "service_cmd", "group_cmd", "dependency_cmd", "all_cmd", "status_cmd", "config_cmd"]

smanager/cli/commands/all.py

@@ -0,0 +1,35 @@
+import click
+
+from . import ACTIONS
+from ..config import get_manager
+
+
+@click.command("all")
+@click.argument("action", type=click.Choice(ACTIONS, case_sensitive=False))
+@click.option(
+    "--yes",
+    is_flag=True,
+    default=False,
+    help="Confirm the operation on all services.",
+)
+@click.pass_context
+def all_cmd(ctx: click.Context, action: str, yes: bool) -> None:
+    """Perform ACTION on ALL managed services.
+
+    \b
+    Actions: start, stop, restart, enable, disable
+
+    Requires --yes to prevent accidental execution.
+    """
+    if not yes:
+        raise click.UsageError(
+            f"This will run '{action}' on ALL services. Pass --yes to confirm."
+        )
+    manager = get_manager(ctx)
+    try:
+        manager.manage_all(action)
+        click.echo(f"[OK] '{action}' on all services.")
+    except ValueError as e:
+        raise click.ClickException(str(e))
+    except RuntimeError as e:
+        raise click.ClickException(str(e))

smanager/cli/commands/config.py

@@ -0,0 +1,61 @@
+import os
+
+import click
+
+from ..config import DEFAULT_CONFIG_DIR, DEFAULT_CONFIG_PATH, resolve_config_path
+
+_TEMPLATE = """\
+global:
+  # Absolute path to the directory where service sd_info.json files live.
+  services_dir: "/path/to/your/services"
+
+  # VPN provider to use. Must match a registered provider (e.g. "tailscale").
+  vpn_provider: "tailscale"
+"""
+
+
+@click.group("config")
+def config_cmd() -> None:
+    """Manage the smanager configuration file."""
+
+
+@config_cmd.command("init")
+@click.option("--force", is_flag=True, help="Overwrite existing config.")
+def init_cmd(force: bool) -> None:
+    """Create a template config at the default location.
+
+    \b
+    Default: ~/.config/smanager/smanager.yaml
+    """
+    if os.path.exists(DEFAULT_CONFIG_PATH) and not force:
+        raise click.ClickException(
+            f"Config already exists at {DEFAULT_CONFIG_PATH}. "
+            "Use --force to overwrite."
+        )
+    os.makedirs(DEFAULT_CONFIG_DIR, exist_ok=True)
+    with open(DEFAULT_CONFIG_PATH, "w") as f:
+        f.write(_TEMPLATE)
+    click.echo(f"Config created: {DEFAULT_CONFIG_PATH}")
+
+
+@config_cmd.command("edit")
+@click.pass_context
+def edit_cmd(ctx: click.Context) -> None:
+    """Open the config file in $EDITOR (falls back to nano).
+
+    \b
+    Resolves the config path in the same order as all other commands:
+      1. --config PATH
+      2. $SMANAGER_CONFIG
+      3. ~/.config/smanager/smanager.yaml
+      4. /etc/smanager/smanager.yaml
+      5. ./smanager.yaml
+    """
+    try:
+        path = resolve_config_path(ctx.obj.get("config_path"))
+    except click.ClickException:
+        raise click.ClickException(
+            "No config file found. Run 'smanager config init' first."
+        )
+    editor = os.environ.get("EDITOR", "nano")
+    click.edit(filename=path, editor=editor)

smanager/cli/commands/dependency.py

@@ -0,0 +1,24 @@
+import click
+
+from . import ACTIONS
+from ..config import get_manager
+
+
+@click.command()
+@click.argument("action", type=click.Choice(ACTIONS, case_sensitive=False))
+@click.argument("dependency_name")
+@click.pass_context
+def dependency_cmd(ctx: click.Context, action: str, dependency_name: str) -> None:
+    """Perform ACTION on all services that depend on DEPENDENCY_NAME.
+
+    \b
+    Actions: start, stop, restart, enable, disable
+    """
+    manager = get_manager(ctx)
+    try:
+        manager.manage_by_dependency(dependency_name, action)
+        click.echo(f"[OK] '{action}' on services depending on '{dependency_name}'.")
+    except ValueError as e:
+        raise click.ClickException(str(e))
+    except RuntimeError as e:
+        raise click.ClickException(str(e))

smanager/cli/commands/group.py

@@ -0,0 +1,24 @@
+import click
+
+from . import ACTIONS
+from ..config import get_manager
+
+
+@click.command()
+@click.argument("action", type=click.Choice(ACTIONS, case_sensitive=False))
+@click.argument("group_name")
+@click.pass_context
+def group_cmd(ctx: click.Context, action: str, group_name: str) -> None:
+    """Perform ACTION on all services in GROUP_NAME.
+
+    \b
+    Actions: start, stop, restart, enable, disable
+    """
+    manager = get_manager(ctx)
+    try:
+        manager.manage_group(group_name, action)
+        click.echo(f"[OK] '{action}' on group '{group_name}'.")
+    except ValueError as e:
+        raise click.ClickException(str(e))
+    except RuntimeError as e:
+        raise click.ClickException(str(e))

smanager/cli/commands/service.py

@@ -0,0 +1,24 @@
+import click
+
+from . import ACTIONS
+from ..config import get_manager
+
+
+@click.command()
+@click.argument("action", type=click.Choice(ACTIONS, case_sensitive=False))
+@click.argument("service_id")
+@click.pass_context
+def service_cmd(ctx: click.Context, action: str, service_id: str) -> None:
+    """Perform ACTION on a single service.
+
+    \b
+    Actions: start, stop, restart, enable, disable
+    """
+    manager = get_manager(ctx)
+    try:
+        manager.manage_service(service_id, action)
+        click.echo(f"[OK] '{action}' on service '{service_id}'.")
+    except ValueError as e:
+        raise click.ClickException(str(e))
+    except RuntimeError as e:
+        raise click.ClickException(str(e))

smanager/cli/commands/status.py

@@ -0,0 +1,85 @@
+import dataclasses
+import json as json_module
+
+import click
+
+from ..config import get_manager
+from ...datatypes import MultiStatus, ServiceStatus
+
+
+def _print_service_status(status: ServiceStatus) -> None:
+    click.echo(f"Service: {status.id}  [{status.type}]")
+    for s in status.statuses:
+        marker = "●" if s.status in ("running", "active") else "○"
+        click.echo(f"  {marker} {s.name}: {s.status}")
+
+
+def _print_multi_status(multi: MultiStatus) -> None:
+    for i, svc in enumerate(multi.services):
+        if i > 0:
+            click.echo("")
+        _print_service_status(svc)
+
+
+@click.command()
+@click.option("--service", "service_id", default=None, metavar="ID",
+              help="Status of a single service.")
+@click.option("--group", "group_name", default=None, metavar="NAME",
+              help="Status of all services in a group.")
+@click.option("--dependency", "dependency_name", default=None, metavar="NAME",
+              help="Status of services by dependency.")
+@click.option("--all", "all_services", is_flag=True, default=False,
+              help="Status of all services.")
+@click.option("--json", "as_json", is_flag=True, default=False,
+              help="Output as JSON.")
+@click.pass_context
+def status_cmd(
+    ctx: click.Context,
+    service_id: str | None,
+    group_name: str | None,
+    dependency_name: str | None,
+    all_services: bool,
+    as_json: bool,
+) -> None:
+    """Show the status of services.
+
+    \b
+    Provide exactly one scope:
+      --service ID        single service
+      --group NAME        all services in a group
+      --dependency NAME   all services by dependency
+      --all               every managed service
+    """
+    scopes = [x for x in [service_id, group_name, dependency_name] if x] + (
+        [True] if all_services else []
+    )
+    if len(scopes) == 0:
+        raise click.UsageError(
+            "Provide one of: --service, --group, --dependency, --all"
+        )
+    if len(scopes) > 1:
+        raise click.UsageError(
+            "Only one of --service, --group, --dependency, --all can be used at a time."
+        )
+
+    manager = get_manager(ctx)
+    try:
+        if service_id:
+            result = manager.get_status(service_id)
+            if as_json:
+                click.echo(json_module.dumps(dataclasses.asdict(result), indent=2))
+            else:
+                _print_service_status(result)
+        else:
+            if group_name:
+                result = manager.get_group_status(group_name)
+            elif dependency_name:
+                result = manager.get_dependency_status(dependency_name)
+            else:
+                result = manager.get_all_status()
+            if as_json:
+                click.echo(json_module.dumps(dataclasses.asdict(result), indent=2))
+            else:
+                _print_multi_status(result)
+    except ValueError as e:
+        raise click.ClickException(str(e))

smanager/cli/config.py

@@ -0,0 +1,75 @@
+"""
+Config loading and GlobalManager initialisation for the CLI.
+"""
+import os
+
+import click
+
+from ..datatypes import GlobalConfig
+from ..global_manager import GlobalManager
+from ..vpn import get_vpn
+
+
+# ---------------------------------------------------------------------------
+# Default paths (XDG-compliant)
+# ---------------------------------------------------------------------------
+_XDG_CONFIG_HOME = os.environ.get(
+    "XDG_CONFIG_HOME", os.path.expanduser("~/.config")
+)
+DEFAULT_CONFIG_DIR = os.path.join(_XDG_CONFIG_HOME, "smanager")
+DEFAULT_CONFIG_PATH = os.path.join(DEFAULT_CONFIG_DIR, "smanager.yaml")
+SYSTEM_CONFIG_PATH = "/etc/smanager/smanager.yaml"
+
+# Ordered list of locations tried when no explicit path is given.
+_SEARCH_PATHS = [
+    DEFAULT_CONFIG_PATH,
+    SYSTEM_CONFIG_PATH,
+    "smanager.yaml",  # legacy local fallback
+]
+
+
+def resolve_config_path(config_path: str | None) -> str:
+    """Return the resolved config file path or raise ClickException."""
+    if config_path is not None:
+        return config_path
+    env = os.environ.get("SMANAGER_CONFIG")
+    if env:
+        return env
+    for path in _SEARCH_PATHS:
+        if os.path.isfile(path):
+            return path
+    raise click.ClickException(
+        f"No config file found. Run 'smanager config init' to create one at "
+        f"{DEFAULT_CONFIG_PATH}."
+    )
+
+
+def build_manager(config_path: str | None) -> GlobalManager:
+    """Resolve a config file and return an initialised GlobalManager."""
+    path = resolve_config_path(config_path)
+    with open(path) as f:
+        try:
+            config = GlobalConfig.from_yaml(f.read())
+        except ValueError as e:
+            raise click.ClickException(str(e))
+    if not config.services_dir:
+        raise click.ClickException("'services_dir' is not set in the config file.")
+    if not os.path.isdir(config.services_dir):
+        raise click.ClickException(
+            f"services_dir does not exist: {config.services_dir}"
+        )
+    try:
+        vpn_cls = get_vpn(config.vpn_provider)
+        vpn = vpn_cls()
+    except ValueError as e:
+        raise click.ClickException(
+            f"Unknown VPN provider '{config.vpn_provider}': {e}"
+        )
+    return GlobalManager(config.services_dir, config, vpn)
+
+
+def get_manager(ctx: click.Context) -> GlobalManager:
+    """Return the GlobalManager stored in *ctx*, building it lazily on first call."""
+    if ctx.obj.get("_manager") is None:
+        ctx.obj["_manager"] = build_manager(ctx.obj.get("config_path"))
+    return ctx.obj["_manager"]

smanager/cli/main.py

@@ -0,0 +1,30 @@
+import click
+
+from .commands import all_cmd, dependency_cmd, group_cmd, service_cmd, status_cmd
+from .commands import all_cmd, config_cmd, dependency_cmd, group_cmd, service_cmd, status_cmd
+
+
+@click.group()
+@click.option(
+    "--config",
+    "config_path",
+    envvar="SMANAGER_CONFIG",
+    default=None,
+    metavar="PATH",
+    help="Path to config file (or set SMANAGER_CONFIG). Default: ./smanager.yaml",
+)
+@click.version_option(package_name="smanager")
+@click.pass_context
+def cli(ctx: click.Context, config_path: str | None) -> None:
+    """SManager — manage self-hosted services and Docker containers."""
+    ctx.ensure_object(dict)
+    ctx.obj["config_path"] = config_path
+    ctx.obj["_manager"] = None
+
+
+cli.add_command(service_cmd, "service")
+cli.add_command(group_cmd, "group")
+cli.add_command(dependency_cmd, "dependency")
+cli.add_command(all_cmd, "all")
+cli.add_command(status_cmd, "status")
+cli.add_command(config_cmd, "config")

smanager/crawler/__init__.py

@@ -0,0 +1,5 @@
+from .sd_finder import ServiceDiscoverer
+
+__all__ = [
+    "ServiceDiscoverer"
+]

smanager/crawler/sd_finder.py

@@ -0,0 +1,32 @@
+"""
+Finds Service Discovery files in a given directory and parses them into Service objects.
+"""
+
+import os
+from ..datatypes import ServiceMetadata, Service
+
+class ServiceDiscoverer:
+    def __init__(self, directory: str, searched_filename: str = "sd_info.json"):
+        self.directory = directory
+        self.searched_filename = searched_filename
+
+    def discover_services(self) -> list[Service]:
+        """Walks through the directory to find SDConfig files, returns a list 
+        of Service objects.
+        """
+        services = []
+        for root, _, files in os.walk(self.directory):
+            if self.searched_filename in files:
+                sd_abspath = os.path.join(root, self.searched_filename)
+                with open(sd_abspath, 'r') as f:
+                    try:
+                        metadata = ServiceMetadata.from_json(f.read())
+                        service = Service(
+                            metadata=metadata, 
+                            service_abspath=root,
+                            metadata_filename=self.searched_filename
+                            )
+                        services.append(service)
+                    except Exception as e:
+                        print(f"Error parsing {sd_abspath}: {e}")
+        return services

smanager/datatypes/__init__.py

@@ -0,0 +1,19 @@
+from .sd_info_v2 import (
+    ServiceMetadata, RuntimeSection, PortSection, 
+    DockerSection, LocalSection, Service
+)
+from .config import GlobalConfig
+from .service_status import ServiceStatus, SingleStatus, MultiStatus
+
+__all__ = [
+    "ServiceMetadata",
+    "RuntimeSection",
+    "PortSection",
+    "DockerSection",
+    "LocalSection",
+    "GlobalConfig",
+    "Service",
+    "ServiceStatus",
+    "SingleStatus",
+    "MultiStatus"
+]

smanager/datatypes/config.py

@@ -0,0 +1,20 @@
+import yaml
+from dataclasses import dataclass, field
+
+@dataclass
+class GlobalConfig:
+    services_dir: str
+    vpn_provider: str = field(default="tailscale")
+
+    @classmethod
+    def from_yaml(cls, yaml_str: str) -> 'GlobalConfig':
+        """Parses a YAML string into a GlobalConfig object."""
+        try:
+            data = yaml.safe_load(yaml_str)
+            global_data = data.get('global', {})
+            return cls(
+                services_dir=global_data.get('services_dir', ''),
+                vpn_provider=global_data.get('vpn_provider', 'tailscale'),
+            )
+        except yaml.YAMLError as e:
+            raise ValueError(f"Error parsing YAML: {e}")

smanager/datatypes/sd_info_v2.py

@@ -0,0 +1,134 @@
+"""
+This module defines the data structures for the SDConfig v2
+"""
+from dataclasses import dataclass
+from typing import Optional
+import json
+import os
+
+
+@dataclass
+class PortSection:
+    webui: int
+
+    # Dinamically loads dict keys as attributes
+    def __post_init__(self):
+        for key, value in self.__dict__.items():
+            setattr(self, key, value)
+
+        if not hasattr(self, 'webui'):
+            raise ValueError("PortSection must have a 'webui' key.")
+
+@dataclass
+class RuntimeSection:
+    type: str
+    ports: PortSection
+    sys_user: str
+    sys_group: str
+
+    def __post_init__(self):
+        if not self.type:
+            raise ValueError("RuntimeSection must have a 'type' field.")
+        if not self.ports:
+            raise ValueError("RuntimeSection must have a 'ports' field.")
+        if not self.sys_user:
+            raise ValueError("RuntimeSection must have a 'sys_user' field.")
+        if not self.sys_group:
+            raise ValueError("RuntimeSection must have a 'sys_group' field.")
+
+@dataclass
+class DockerSection:
+    containers: Optional[list] = None
+    compose_file: Optional[str] = None
+
+@dataclass
+class LocalSection:
+    installation_path: Optional[str] = None
+    app_path: Optional[str] = None
+    systemd_services: Optional[list] = None
+
+@dataclass
+class ServiceMetadata:
+    name: str
+    description: str
+    schema_version: int
+    id: str
+    active: bool
+    runtime: RuntimeSection
+    groups: Optional[list] = None
+    docker: Optional[DockerSection] = None
+    local: Optional[LocalSection] = None
+    depends_on: Optional[list] = None
+
+    def __post_init__(self):
+        # Validate required fields
+        if not self.name:
+            raise ValueError("SDConfig must have a 'name' field.")
+        if not self.description:
+            raise ValueError("SDConfig must have a 'description' field.")
+        if not self.schema_version:
+            raise ValueError("SDConfig must have a 'schema_version' field.")
+        if not self.id:
+            raise ValueError("SDConfig must have an 'id' field.")
+        if self.active is None:
+            raise ValueError("SDConfig must have an 'active' field.")
+        if not self.runtime:
+            raise ValueError("SDConfig must have a 'runtime' field.")
+        
+        # Validate at least one of docker or local is provided
+        if not self.docker and not self.local:
+            raise ValueError("SDConfig must have at least one of 'docker' or 'local' sections.")
+        
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ServiceMetadata':
+        runtime_data = data.get('runtime')
+        if not runtime_data:
+            raise ValueError("SDConfig must have a 'runtime' section.")
+        
+        runtime = RuntimeSection(
+            type=runtime_data.get('type'),
+            ports=PortSection(**runtime_data.get('ports', {})),
+            sys_user=runtime_data.get('sys_user'),
+            sys_group=runtime_data.get('sys_group')
+        )
+
+        docker_data = data.get('docker')
+        docker = DockerSection(**docker_data) if docker_data else None
+
+        local_data = data.get('local')
+        local = LocalSection(**local_data) if local_data else None
+
+        return cls(
+            name=data.get('name'),
+            description=data.get('description'),
+            schema_version=data.get('schema_version'),
+            id=data.get('id'),
+            groups=data.get('groups'),
+            active=data.get('active'),
+            runtime=runtime,
+            docker=docker,
+            local=local,
+            depends_on=data.get('depends_on')
+        )
+    
+    @classmethod
+    def from_json(cls, json_str: str) -> 'ServiceMetadata':
+        return cls.from_dict(json.loads(json_str))
+    
+    def write_to_json(self, file_path: str):
+        with open(file_path, 'w') as f:
+            json.dump(self.__dict__, f, default=lambda o: o.__dict__, indent=4)
+
+@dataclass
+class Service:
+    metadata: ServiceMetadata
+    service_abspath: str
+    metadata_filename: str
+
+    def __post_init__(self):
+        if not os.path.isabs(self.service_abspath):
+            raise ValueError("Service 'service_abspath' must be an absolute path.")
+        if not os.path.exists(self.service_abspath):
+            raise ValueError(f"Service 'service_abspath' does not exist: {self.service_abspath}")
+        if not self.metadata_filename:
+            raise ValueError("Service must have a 'metadata_filename' field.")

smanager/datatypes/service_status.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+@dataclass
+class SingleStatus:
+    name: str
+    status: str
+
+@dataclass
+class ServiceStatus:
+    id: str
+    type: str  # e.g. "docker", "local"
+    statuses: list[SingleStatus]
+
+@dataclass
+class MultiStatus:
+    services: list[ServiceStatus]

smanager/global_manager/__init__.py

@@ -0,0 +1,7 @@
+from .base_global_manager import BaseGlobalManager
+from .global_manager import GlobalManager
+
+__all__ = [
+    "BaseGlobalManager",
+    "GlobalManager",
+]

smanager/global_manager/base_global_manager.py

@@ -0,0 +1,81 @@
+from ..service_managers import BaseManager
+from ..datatypes import Service, GlobalConfig, ServiceStatus, MultiStatus
+from ..crawler import ServiceDiscoverer
+from ..vpn import VPNService
+from abc import abstractmethod
+
+class BaseGlobalManager:
+    """BaseGlobalManager is an abstract class that defines the interface for a global manager.
+    It provides methods for searching and managing services, but does not implement the
+    actual logic. Subclasses should implement the specific logic for managing services.
+    """
+
+    def __init__(self, services_dir: str, global_config: GlobalConfig, vpn: VPNService):
+        self.services_dir = services_dir
+        self.global_config = global_config
+        self.vpn = vpn
+        self.crawler = ServiceDiscoverer(services_dir)
+        self.services = self.discover_services()
+
+    def discover_services(self) -> list[Service]:
+        """Discover services in the specified services directory."""
+        return self.crawler.discover_services()
+    
+    @abstractmethod
+    def get_service_manager(self, service: Service) -> BaseManager:
+        """Get the appropriate service manager for the given service."""
+        raise NotImplementedError("get_service_manager method must be implemented by subclasses.")
+    
+    @abstractmethod
+    def get_group(self, group_name: str) -> list[Service]:
+        """Get all services that belong to the specified group."""
+        raise NotImplementedError("get_group method must be implemented by subclasses.")
+    
+    @abstractmethod
+    def get_services_by_dependency(self, dependency_name: str) -> list[Service]:
+        """Get all services that depend on the specified dependency."""
+        raise NotImplementedError("get_services_by_dependency method must be implemented by subclasses.")
+    
+    @abstractmethod
+    def manage_service(self, service_id: str, action: str):
+        """Manage a service by performing the specified action (start, stop, restart, enable, disable)."""
+        raise NotImplementedError("manage_service method must be implemented by subclasses.")
+    
+    @abstractmethod
+    def manage_group(self, group_name: str, action: str):
+        """Manage all services in a group by performing the specified action 
+        (start, stop, restart).
+        """
+        raise NotImplementedError("manage_group method must be implemented by subclasses.")
+    
+    @abstractmethod
+    def manage_by_dependency(self, dependency_name: str, action: str):
+        """Manage all services that depend on a specific dependency by performing the 
+        specified action (start, stop, restart, enable, disable).
+        """
+        raise NotImplementedError("manage_by_dependency method must be implemented by subclasses.")
+    
+    @abstractmethod
+    def manage_all(self, action: str):
+        """Manage all services by performing the specified action (start, stop, restart, enable, disable)."""
+        raise NotImplementedError("manage_all method must be implemented by subclasses.")
+
+    @abstractmethod
+    def get_status(self, service_id: str) -> ServiceStatus:
+        """Get the status of a specific service by its ID."""
+        raise NotImplementedError("get_status method must be implemented by subclasses.")
+    
+    @abstractmethod
+    def get_group_status(self, group_name: str) -> MultiStatus:
+        """Get the status of all services in a group."""
+        raise NotImplementedError("get_group_status method must be implemented by subclasses.")
+    
+    @abstractmethod
+    def get_dependency_status(self, dependency_name: str) -> MultiStatus:
+        """Get the status of all services that depend on a specific dependency."""
+        raise NotImplementedError("get_dependency_status method must be implemented by subclasses.")
+    
+    @abstractmethod
+    def get_all_status(self) -> MultiStatus:
+        """Get the status of all services."""
+        raise NotImplementedError("get_all_status method must be implemented by subclasses.")

smanager/global_manager/global_manager.py

@@ -0,0 +1,103 @@
+from ..service_managers import DockerManager, LocalManager, BaseManager
+from ..datatypes import Service, GlobalConfig, ServiceStatus, MultiStatus
+from ..vpn import VPNService
+from . import BaseGlobalManager
+
+class GlobalManager(BaseGlobalManager):
+    """GlobalManager is responsible for searching and managing all services found in the 
+    specified services directory. It uses the appropriate service manager (DockerManager
+    or LocalManager) based on the service metadata.
+    """
+
+    def __init__(self, services_dir: str, global_config: GlobalConfig, vpn: VPNService):
+        super().__init__(services_dir, global_config, vpn)
+
+    def _find_service_by_id(self, service_id: str) -> Service:
+        """Helper method to find a service by its unique identifier."""
+        for service in self.services:
+            if service.metadata.id == service_id:
+                return service
+        raise ValueError(f"Service with ID '{service_id}' not found.")
+
+    def get_service_manager(self, service: Service, restart_delay: int = 5) -> BaseManager:
+        """Get the appropriate service manager for the given service based on its metadata."""
+        if service.metadata.runtime.type == "docker":
+            return DockerManager(service, self.vpn, restart_delay=restart_delay)
+        elif service.metadata.runtime.type == "local":
+            return LocalManager(service, vpn=self.vpn, restart_delay=restart_delay)
+        else:
+            raise ValueError(f"Unsupported runtime type: {service.metadata.runtime.type}")
+        
+    def get_group(self, group_name: str) -> list[Service]:
+        """Get all services that belong to the specified group."""
+        return [s for s in self.services if s.metadata.groups and group_name in s.metadata.groups]
+    
+    def get_services_by_dependency(self, dependency_name: str) -> list[Service]:
+        """Get all services that depend on the specified dependency."""
+        return [s for s in self.services if s.metadata.depends_on and dependency_name in s.metadata.depends_on]
+    
+    def manage_service(self, service_id: str, action: str):
+        """Manage a service by performing the specified action (start, stop, restart,
+        enable, disable).
+        """
+        service = self._find_service_by_id(service_id)
+        manager = self.get_service_manager(service)
+        
+        if action == "start":
+            manager.start()
+        elif action == "stop":
+            manager.stop()
+        elif action == "restart":
+            manager.restart()
+        elif action == "enable":
+            manager.enable()
+        elif action == "disable":
+            manager.disable()
+        else:
+            raise ValueError(f"Unsupported action: {action}")
+        
+    def manage_group(self, group_name: str, action: str):
+        """Manage all services in a group by performing the specified action 
+        (start, stop, restart, enable, disable).
+        """
+        services = self.get_group(group_name)
+        for service in services:
+            self.manage_service(service.metadata.id, action)
+
+    def manage_by_dependency(self, dependency_name: str, action: str):
+        """Manage all services that depend on a specific dependency by performing the 
+        specified action (start, stop, restart, enable, disable).
+        """
+        services = self.get_services_by_dependency(dependency_name)
+        for service in services:
+            self.manage_service(service.metadata.id, action)
+    
+    def manage_all(self, action: str):
+        """Manage all services by performing the specified action (start, stop, restart, 
+        enable, disable)."""
+        for service in self.services:
+            self.manage_service(service.metadata.id, action)
+        
+    def get_status(self, service_id: str) -> ServiceStatus:
+        """Get the status of a specific service by its ID."""
+        service = self._find_service_by_id(service_id)
+        manager = self.get_service_manager(service)
+        return manager.status()
+    
+    def get_group_status(self, group_name: str) -> MultiStatus:
+        """Get the status of all services in a group."""
+        services = self.get_group(group_name)
+        statuses = [self.get_status(service.metadata.id) for service in services]
+        return MultiStatus(services=statuses)
+    
+    def get_dependency_status(self, dependency_name: str) -> MultiStatus:
+        """Get the status of all services that depend on a specific dependency."""
+        services = self.get_services_by_dependency(dependency_name)
+        statuses = [self.get_status(service.metadata.id) for service in services]
+        return MultiStatus(services=statuses)
+    
+    def get_all_status(self) -> MultiStatus:
+        """Get the status of all services."""
+        statuses = [self.get_status(service.metadata.id) for service in self.services]
+        return MultiStatus(services=statuses)
+    

smanager/service_managers/__init__.py

@@ -0,0 +1,11 @@
+from .base_manager import BaseManager
+from .base_sdv2_manager import BaseSDV2Manager
+from .docker_manager import DockerManager
+from .local_manager import LocalManager
+
+__all__ = [
+    "BaseManager",
+    "BaseSDV2Manager",
+    "DockerManager",
+    "LocalManager"
+]

smanager/service_managers/base_manager.py

@@ -0,0 +1,62 @@
+"""
+Base class for all simple service managers.
+Defines the interface and common functionality for managing a single service.
+"""
+
+from abc import abstractmethod
+from ..datatypes import ServiceStatus
+
+class BaseManager:
+    def __init__(self, config):
+        self.config = config
+
+    @abstractmethod
+    def start(self):
+        """Start the service."""
+        raise NotImplementedError("Start method must be implemented by subclasses.")
+
+    @abstractmethod
+    def stop(self):
+        """Stop the service."""
+        raise NotImplementedError("Stop method must be implemented by subclasses.")
+
+    def restart(self):
+        """Restart the service."""
+        self.stop()
+        self.start()
+
+    @abstractmethod
+    def status(self)-> ServiceStatus:
+        """Check the status of the service."""
+        raise NotImplementedError("Status method must be implemented by subclasses.")
+    
+    @abstractmethod
+    def enable(self):
+        """Enable the service to be managed (start, stop, restart)."""
+        raise NotImplementedError("Enable method must be implemented by subclasses.")
+    
+    @abstractmethod
+    def disable(self):
+        """Disable the service from being managed (start, stop, restart)."""
+        raise NotImplementedError("Disable method must be implemented by subclasses.")
+    
+    @abstractmethod
+    def get_groups(self):
+        """Get the groups associated with this service."""
+        raise NotImplementedError("get_groups method must be implemented by subclasses.")
+    
+    @abstractmethod
+    def get_dependencies(self):
+        """Get the dependencies of this service."""
+        raise NotImplementedError("get_dependencies method must be implemented by subclasses.")
+    
+    @abstractmethod
+    def get_id(self):
+        """Get the unique identifier of this service."""
+        raise NotImplementedError("get_id method must be implemented by subclasses.")
+    
+    @abstractmethod
+    def is_active(self):
+        """Check if the service is active."""
+        raise NotImplementedError("is_active method must be implemented by subclasses.")
+    

smanager/service_managers/base_sdv2_manager.py

@@ -0,0 +1,45 @@
+"""
+The bass manager for SDV2 services.
+It extends the BaseManager with SDV2-specific logic, such as handling the SDConfig
+file and integrating with VPN services.
+"""
+
+from . import BaseManager
+from ..datatypes import Service
+from ..vpn import VPNService
+import os
+
+class BaseSDV2Manager(BaseManager):
+    def __init__(self, service: Service, vpn: VPNService, restart_delay: int = 5):
+        super().__init__(service)
+        self.service = service
+        self.vpn = vpn
+        self.restart_delay = restart_delay
+
+    def enable(self):
+        """Change the JSON config to set the service as active."""
+        self.service.metadata.active = True
+        output_path = os.path.join(self.service.service_abspath, self.service.metadata_filename)
+        self.service.metadata.write_to_json(output_path)
+
+    def disable(self):
+        """Change the JSON config to set the service as inactive."""
+        self.service.metadata.active = False
+        output_path = os.path.join(self.service.service_abspath, self.service.metadata_filename)
+        self.service.metadata.write_to_json(output_path)
+
+    def get_groups(self):
+        """Get the groups associated with this service."""
+        return self.service.metadata.groups
+    
+    def get_dependencies(self):
+        """Get the dependencies of this service."""
+        return self.service.metadata.depends_on
+    
+    def get_id(self):
+        """Get the unique identifier of this service."""
+        return self.service.metadata.id
+    
+    def is_active(self):
+        """Check if the service is active."""
+        return self.service.metadata.active

smanager/service_managers/docker_manager.py

@@ -0,0 +1,63 @@
+from . import BaseSDV2Manager
+from ..datatypes import Service
+import subprocess
+import os
+from ..vpn import VPNService
+import time
+from ..datatypes import ServiceStatus, SingleStatus
+
+class DockerManager(BaseSDV2Manager):
+    def __init__(self, service: Service, vpn: VPNService, restart_delay: int = 5):
+        super().__init__()
+        self._compose_path = self.service.metadata.docker.compose_file
+
+    def _get_compose_file_path(self) -> str:
+        """Returns the path to the docker-compose.yml file for this service."""
+        return os.path.join(
+            self.service.service_abspath, 
+            self.service.metadata.docker.compose_file
+            )
+    
+    def start(self):
+        """Start the Docker service using docker-compose."""
+        compose_file = self._get_compose_file_path()
+        subprocess.run(["docker-compose", "-f", compose_file, "up", "-d"], check=True)
+
+    def stop(self):
+        """Stop the Docker service using docker-compose."""
+        compose_file = self._get_compose_file_path()
+        subprocess.run(["docker-compose", "-f", compose_file, "down"], check=True)
+
+    def restart(self):
+        """Restart the Docker service using docker-compose."""
+        self.stop()
+        self.vpn.stop_serving_https(self.service.metadata.runtime.ports.webui)
+        self.start()
+        time.sleep(self.restart_delay)
+        self.vpn.serve_https(self.service.metadata.runtime.ports.webui)
+
+    def status(self)-> ServiceStatus:
+        """Check the status of all containers in the Docker service and return a
+        ServiceStatus object.
+        """
+        compose_file = self._get_compose_file_path()
+        result = subprocess.run(["docker-compose", "-f", compose_file, "ps", "--services", "--filter", "status=running"], capture_output=True, text=True)
+        running_services = set(result.stdout.strip().splitlines())
+        
+        all_services_result = subprocess.run(["docker-compose", "-f", compose_file, "config", "--services"], capture_output=True, text=True)
+        all_services = set(all_services_result.stdout.strip().splitlines())
+        
+        service_statuses = []
+        for service_name in all_services:
+            status = SingleStatus(
+                name=service_name,
+                status="running" if service_name in running_services else "stopped"
+            )
+            service_statuses.append(status)
+        
+        return ServiceStatus(
+            id=self.get_id(), 
+            type=self.service.metadata.runtime.type,
+            services=service_statuses
+        )
+    

smanager/service_managers/local_manager.py

@@ -0,0 +1,44 @@
+from . import BaseSDV2Manager
+from ..datatypes import Service
+import subprocess
+from ..vpn import VPNService
+import time
+from ..datatypes import ServiceStatus, SingleStatus
+
+class LocalManager(BaseSDV2Manager):
+    def __init__(self, service: Service, vpn: VPNService, restart_delay: int = 5):
+        super().__init__()
+
+    def start(self):
+        """Start the local systemd service."""
+        for service_name in self.service.metadata.local.systemd_services:
+            subprocess.run(["systemctl", "start", service_name], check=True)
+    
+    def stop(self):
+        """Stop the local systemd service."""
+        for service_name in self.service.metadata.local.systemd_services:
+            subprocess.run(["systemctl", "stop", service_name], check=True)
+
+    def restart(self):
+        """Restart the local systemd service."""
+        self.stop()
+        self.vpn.stop_serving_https(self.service.metadata.runtime.ports.webui)
+        self.start()
+        time.sleep(self.restart_delay)
+        self.vpn.serve_https(self.service.metadata.runtime.ports.webui)
+    
+    def status(self)-> ServiceStatus:
+        """Check the status of the local systemd service and return a ServiceStatus object."""
+        service_statuses = []
+        for service_name in self.service.metadata.local.systemd_services:
+            result = subprocess.run(["systemctl", "is-active", service_name], capture_output=True, text=True)
+            status = SingleStatus(
+                name=service_name,
+                status=result.stdout.strip()
+            )
+            service_statuses.append(status)
+        return ServiceStatus(
+            id=self.get_id(), 
+            type=self.service.metadata.runtime.type,
+            services=service_statuses
+        )

smanager/vpn/__init__.py

@@ -0,0 +1,11 @@
+from .base_vpn import VPNService
+from .registry import register_vpn, get_vpn, list_vpns
+from .providers import TailscaleVPN
+
+__all__ = [
+    "VPNService",
+    "register_vpn",
+    "get_vpn",
+    "list_vpns",
+    "TailscaleVPN"
+]

smanager/vpn/base_vpn.py

@@ -0,0 +1,32 @@
+"""
+Defines the base VPN service interface that all VPN implementations must follow.
+"""
+from abc import ABC, abstractmethod
+
+class VPNService:
+
+    @abstractmethod
+    def connect(self):
+        """Connect to the VPN."""
+        raise NotImplementedError("Connect method must be implemented by subclasses.")
+
+    @abstractmethod
+    def disconnect(self):
+        """Disconnect from the VPN."""
+        raise NotImplementedError("Disconnect method must be implemented by subclasses.")
+
+    @abstractmethod
+    def is_connected(self) -> bool:
+        """Check if the VPN is currently connected."""
+        raise NotImplementedError("is_connected method must be implemented by subclasses.")
+    
+    @abstractmethod
+    def serve_https(self, port: int):
+        """Serve the VPN connection over HTTPS on the specified port."""
+        raise NotImplementedError("serve_https method must be implemented by subclasses.")
+    
+    @abstractmethod
+    def stop_serving_https(self, port: int):
+        """Stop serving the VPN connection over HTTPS on the specified port."""
+        raise NotImplementedError("stop_serving_https method must be implemented by subclasses.")
+    

smanager/vpn/providers/__init__.py

@@ -0,0 +1,5 @@
+from .tailscale import TailscaleVPN
+
+__all__ = [
+    "TailscaleVPN"
+]

smanager/vpn/providers/tailscale.py

@@ -0,0 +1,51 @@
+"""
+Implements the Tailscale VPN service.
+"""
+
+from .. import VPNService
+from ..registry import register_vpn
+import subprocess
+import json
+
+@register_vpn("tailscale")
+class TailscaleVPN(VPNService):
+    def __init__(self):
+        self.connected = self.is_connected()
+
+    def connect(self):
+        """Connect to the Tailscale VPN."""
+        try:
+            subprocess.run(["sudo", "tailscale", "up"], check=True)
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError("Failed to connect to Tailscale VPN") from e
+        self.connected = self.is_connected()
+
+    def disconnect(self):
+        """Disconnect from the Tailscale VPN."""
+        try:
+            subprocess.run(["sudo", "tailscale", "down"], check=True)
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError("Failed to disconnect from Tailscale VPN") from e
+        self.connected = self.is_connected()
+
+    def is_connected(self) -> bool:
+        """Check if the VPN is currently connected."""
+        try:
+            status = subprocess.run(["tailscale", "status", "--json"], capture_output=True, text=True, check=True)
+            return json.loads(status.stdout).get("BackendState", "") == "Running"
+        except (subprocess.CalledProcessError, FileNotFoundError, json.JSONDecodeError):
+            return False
+
+    def serve_https(self, port: int):
+        """Serve the VPN connection over HTTPS on the specified port."""
+        try:
+            subprocess.run(["sudo", "tailscale", "serve", "--bg", f"--https={port}", f"http://localhost:{port}"], check=True)
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"Failed to serve HTTPS on port {port} via Tailscale") from e
+    
+    def stop_serving_https(self, port: int):
+        """Stop serving the VPN connection over HTTPS on the specified port."""
+        try:
+            subprocess.run(["sudo", "tailscale", "serve", f"--https={port}", "off"], check=True)
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"Failed to stop serving HTTPS on port {port} via Tailscale") from e

smanager/vpn/registry.py

@@ -0,0 +1,28 @@
+"""
+This module implements a registry for VPN providers.
+It allows for dynamic registration and retrieval of VPN provider classes by name.
+"""
+from . import VPNService
+from typing import Dict, Type
+
+# Global registry for VPN providers
+_VPN_REGISTRY: Dict[str, Type[VPNService]] = {}
+
+def register_vpn(name: str):
+    """Decorator to register a model class with a given name."""
+    def decorator(cls: Type[VPNService]):
+        if name in _VPN_REGISTRY:
+            raise ValueError(f"VPN provider \"{name}\" is already registered.")
+        _VPN_REGISTRY[name] = cls
+        return cls
+    return decorator
+
+def get_vpn(name: str) -> Type[VPNService]:
+    """Retrieves a VPN provider class by name."""
+    if name not in _VPN_REGISTRY:
+        raise ValueError(f"VPN provider \"{name}\" is not registered.")
+    return _VPN_REGISTRY[name]
+
+def list_vpns() -> list[str]:
+    """Returns a list of registered VPN provider names."""
+    return list(_VPN_REGISTRY.keys())

smanager-0.1.0.dist-info/METADATA

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

smanager-0.1.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+smanager/__init__.py,sha256=pR6K9zQ-1X496aTgEGgwyIq9tWTd_cmXENJlpmQVf_o,268
+smanager/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+smanager/cli/config.py,sha256=CddeZD9yDMd9Ik80leSInD83R77-0nnk2SSFGj0vxyU,2544
+smanager/cli/main.py,sha256=GzFKCvQ7czhGcyztLMuBBcChC-FHLDfFoBmzbxVrKu0,945
+smanager/cli/commands/__init__.py,sha256=QyeykJElRQtJvQQ8iy_ih0FEpoHzeHH2NMlWVq3Z09w,357
+smanager/cli/commands/all.py,sha256=IDwHFMoZA2Ku61beTczXNikVqAavNqjqv-DwAm2ybVw,952
+smanager/cli/commands/config.py,sha256=U2Q78tNFgMGbjNbbpu6WqCdChruskFHMl2LOZGedluY,1811
+smanager/cli/commands/dependency.py,sha256=aOOAr9duhJr5kkZVv1dCF3zhip2dOjb9RFNX1E9kO1A,770
+smanager/cli/commands/group.py,sha256=833lFSyCTzlEplzVvKk2SRssLmNVGL6Fk3A6YQ-GAu0,704
+smanager/cli/commands/service.py,sha256=R252wqAdUTou9NrW7yvAhvgTgq1PNKfiSlcawywJUbA,700
+smanager/cli/commands/status.py,sha256=d0v0mbh9vfNDQTTzirSTp8EG8RHOSh31V6ncKs3nTU8,2912
+smanager/crawler/__init__.py,sha256=6eJqh3Q-sAsCAaQVIWlmjLhGtJhrJ_VH82OdpACIr5I,79
+smanager/crawler/sd_finder.py,sha256=YfDmUCbJVnB-DxTTO_fWPoT7mPR3cdC2i9jREa-gvLM,1284
+smanager/datatypes/__init__.py,sha256=LA3Eqml_0-O_XBCiFw5UiHLpnnTiOn_Pyend2D58oHU,435
+smanager/datatypes/config.py,sha256=hQnLWtX_AeSDy6xItKL50q7Xz_76YEP9zpPPYpZ-EW4,673
+smanager/datatypes/sd_info_v2.py,sha256=w1hbIAuoGg3k_s0criTUZexDK1UNg_ObCebbk-wXEjs,4446
+smanager/datatypes/service_status.py,sha256=8a24YGFFDt0UkjsMYRHq06gpr2xAxFs5rvjO4-uK0CY,278
+smanager/global_manager/__init__.py,sha256=Eog1ycSHPTWMSNC4J2iSa2TofzAnUYzu-BC1yWbTyNw,153
+smanager/global_manager/base_global_manager.py,sha256=zcGsAo0dFhEMykLKrS5AjPTCR2F7HHCniLjOPhXQr4w,3955
+smanager/global_manager/global_manager.py,sha256=YvPmnxgA-HDYjNw4wodbYMlYhnqt2DdDLq8MgNOw2VA,4889
+smanager/service_managers/__init__.py,sha256=-0dqDXBRbUk7N7NN5-Ab0MZRdcEAr0IjLA1kwKDLvBs,263
+smanager/service_managers/base_manager.py,sha256=jnwFMPMVFsTSFtYIHdzr4ghnhTkpZBPB-qinaeBhLCg,2090
+smanager/service_managers/base_sdv2_manager.py,sha256=uPHhsSPaYpPB86HDsFI_xJ9w75B9bC4N3i3GIOyf4aE,1606
+smanager/service_managers/docker_manager.py,sha256=GmjyYV1tqJuVIB2aCZfa4OsKJlmKL96Pw8pE2sQPrf4,2561
+smanager/service_managers/local_manager.py,sha256=Hkx7eFGDAMEk5DTyXlccHou7XCVqGOfC4FyVPNrJ_Bs,1753
+smanager/vpn/__init__.py,sha256=81bcFe0b2s1TBprRqNakXnoLSwBY0TzNHkJNutU_hug,227
+smanager/vpn/base_vpn.py,sha256=IzumtdKQmdexfSJICHZV3fTdheDc9hfkA7K9T532T5k,1169
+smanager/vpn/registry.py,sha256=UvtHLGYs-XFvIaGmSdieiI5Krl__1kBpLQKlmspgVJs,967
+smanager/vpn/providers/__init__.py,sha256=s3yqGMrWc4vIqmI6Q4fpaLjew1WN5ml5yfNV0KQ05rg,69
+smanager/vpn/providers/tailscale.py,sha256=FZNx5V3frQoD3KnPoKQOjJf7AdP7bEXYNIu4_70slow,2126
+smanager-0.1.0.dist-info/METADATA,sha256=kWigLYhl7omwfbBcKi8MPe9jAV7bMX458OMjKFVqzgY,128
+smanager-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+smanager-0.1.0.dist-info/entry_points.txt,sha256=1X7ZL8LtCbTmVZsJRYKUQeo9Cfp0BJWH9olFuCFSYaU,51
+smanager-0.1.0.dist-info/top_level.txt,sha256=VPRTgGpVmdkozEZNG7ZibXzDZVe8MSmUM3ZdR0N0E84,9
+smanager-0.1.0.dist-info/RECORD,,

smanager-0.1.0.dist-info/WHEEL

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

smanager-0.1.0.dist-info/entry_points.txt

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

smanager-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+smanager