add default_domain for single-domain mode

Author: MNametissa

o2switch_cli/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.1.3"
+__version__ = "0.1.4"

o2switch_cli/cli/autocomplete.py

@@ -64,7 +64,7 @@ def completion_runtime(ctx: typer.Context | None) -> Iterator[CompletionRuntime
             audit_log_path=settings.audit_log_path,
             actor=settings.cpanel_user or "completion",
         )
-        domains = DomainService(client)
+        domains = DomainService(client, default_domain=settings.default_domain)
         dns = DNSService(client, domains, DNSResolver(), audit, settings.reserved_labels)
         subdomains = SubdomainService(client, domains, dns, audit, settings.reserved_labels)
         yield CompletionRuntime(client=client, domains=domains, dns=dns, subdomains=subdomains)

o2switch_cli/cli/config_cmd.py

@@ -68,6 +68,7 @@ def init_config(
     cpanel_token: str | None = typer.Option(None, "--cpanel-token", help="cPanel API token (if using token auth)."),
     cpanel_password: str | None = typer.Option(None, "--cpanel-password", help="cPanel password (if using password auth)."),
     use_password: bool = typer.Option(False, "--password", "-p", help="Use password instead of API token."),
+    domain: str | None = typer.Option(None, "--domain", "-d", help="Limit operations to this domain only."),
     default_ttl: int | None = typer.Option(None, "--default-ttl", help="Default TTL to write into the env file."),
     audit_log_path: str | None = typer.Option(
         None,
@@ -147,6 +148,16 @@ def action(app_context):
                 ui.console.print("[dim]  Security > Manage API Tokens > Create[/]\n")
                 secret = secret or questionary.password("cPanel API token").ask()
 
+            # Ask for domain restriction
+            if not domain:
+                ui.console.print("\n[dim]Limit operations to a single domain (optional):[/]")
+                domain_input = questionary.text(
+                    "Default domain",
+                    instruction="(leave empty for all domains)"
+                ).ask()
+                if domain_input:
+                    domain = domain_input.strip().lower()
+
         host = host.strip() if host else None
         user = user.strip() if user else None
         secret = secret.strip() if secret else None
@@ -175,6 +186,7 @@ def action(app_context):
             cpanel_user=user,
             cpanel_token=secret,
             auth_method=auth_method,
+            default_domain=domain or None,
             port=current.port,
             timeout_seconds=current.timeout_seconds,
             default_ttl=ttl,

o2switch_cli/cli/context.py

@@ -46,7 +46,7 @@ def runtime(self) -> RuntimeServices:
                 audit_log_path=self.settings.audit_log_path,
                 actor=self.settings.cpanel_user or "system",
             )
-            domains = DomainService(client)
+            domains = DomainService(client, default_domain=self.settings.default_domain)
             resolver = DNSResolver()
             dns = DNSService(client, domains, resolver, audit, self.settings.reserved_labels)
             subdomains = SubdomainService(

o2switch_cli/config/settings.py

@@ -52,6 +52,7 @@ class AppSettings(BaseSettings):
     cpanel_user: str | None = None
     cpanel_token: SecretStr | None = None  # token or password depending on auth_method
     auth_method: Literal["token", "password"] = "token"
+    default_domain: str | None = None  # limit operations to this domain only
     port: int = 2083
     timeout_seconds: float = 20.0
     default_ttl: int = 300
@@ -121,6 +122,7 @@ def render_env_file(settings: AppSettings) -> str:
         f"O2SWITCH_CLI_CPANEL_USER={_dotenv_value(settings.cpanel_user)}",
         f"O2SWITCH_CLI_CPANEL_TOKEN={_dotenv_value(token)}",
         f"O2SWITCH_CLI_AUTH_METHOD={_dotenv_value(settings.auth_method)}",
+        f"O2SWITCH_CLI_DEFAULT_DOMAIN={_dotenv_value(settings.default_domain)}",
         f"O2SWITCH_CLI_PORT={_dotenv_value(settings.port)}",
         f"O2SWITCH_CLI_TIMEOUT_SECONDS={_dotenv_value(settings.timeout_seconds)}",
         f"O2SWITCH_CLI_DEFAULT_TTL={_dotenv_value(settings.default_ttl)}",

o2switch_cli/core/cpanel_client.py

@@ -19,7 +19,7 @@ def __init__(self, settings: AppSettings, client: httpx.Client | None = None) ->
         use_basic = settings.auth_method == "password"
         headers = {
             **auth_header(settings.cpanel_user, settings.cpanel_token, use_basic=use_basic),  # type: ignore[arg-type]
-            "User-Agent": "o2switch-cli/0.1.3",
+            "User-Agent": "o2switch-cli/0.1.4",
             "Accept": "application/json",
         }
         self._client = client or httpx.Client(

o2switch_cli/core/domain_service.py

@@ -7,8 +7,9 @@
 
 
 class DomainService:
-    def __init__(self, client: CpanelClient) -> None:
+    def __init__(self, client: CpanelClient, default_domain: str | None = None) -> None:
         self._client = client
+        self._default_domain = normalize_hostname(default_domain) if default_domain else None
 
     def list_domains(self) -> list[DomainDescriptor]:
         payload = self._client.list_domains().data or {}
@@ -40,7 +41,17 @@ def append_many(domains: list[str], domain_type: DomainType) -> None:
         append_many(payload.get("parked_domains", []) or [], DomainType.PARKED)
         append_many(payload.get("sub_domains", []) or [], DomainType.SUBDOMAIN)
         deduped = {item.domain: item for item in descriptors}
-        return sorted(deduped.values(), key=lambda item: (item.type.value, item.domain))
+        result = sorted(deduped.values(), key=lambda item: (item.type.value, item.domain))
+
+        # Filter by default_domain if set
+        if self._default_domain:
+            result = [
+                item for item in result
+                if item.domain == self._default_domain
+                or item.domain.endswith(f".{self._default_domain}")
+            ]
+
+        return result
 
     def root_domains(self) -> list[str]:
         return [item.domain for item in self.list_domains() if item.type is not DomainType.SUBDOMAIN]