upscaler-cli 0.2.2.dev6560__py3-none-any.whl → 0.2.2.dev6601__py3-none-any.whl

src/auth/token_store.py

@@ -15,6 +15,7 @@ from pathlib import Path
 from typing import Optional
 
 from src.auth.encryption import decrypt, derive_key, encrypt
+from src.profile import ensure_profile_dir, get_profile_dir
 
 
 @dataclass
@@ -31,14 +32,26 @@ class TokenData:
 
 
 class TokenStore:
-    """Encrypted token store at ~/.upscaler/."""
+    """Encrypted token store at ~/.upscaler/profiles/{profile}/."""
 
     SALT_FILE = ".salt"
     TOKEN_FILE = "tokens.enc"
     SALT_SIZE = 16
 
-    def __init__(self, config_dir: Optional[str] = None):
-        self.config_dir = Path(config_dir or os.path.expanduser("~/.upscaler"))
+    def __init__(
+        self,
+        config_dir: Optional[str] = None,
+        profile: Optional[str] = None,
+    ):
+        """Open the token store for `profile` (or the resolved active profile).
+
+        Passing `config_dir` overrides profile resolution and points at an
+        explicit directory; used by tests.
+        """
+        if config_dir is not None:
+            self.config_dir = Path(config_dir)
+        else:
+            self.config_dir = get_profile_dir(profile)
         self._cached_key: Optional[bytes] = None
 
     def _get_key(self) -> bytes:
@@ -54,7 +67,7 @@ class TokenStore:
         Creates config dir (0o700), salt file (0o600) if needed,
         writes to .tmp then renames for atomicity.
         """
-        self.config_dir.mkdir(mode=0o700, parents=True, exist_ok=True)
+        ensure_profile_dir(self.config_dir)
 
         key = self._get_key()
 

src/cli/auth.py

@@ -114,7 +114,7 @@ def _login_browser(ctx, port):
     from src.auth.token_store import TokenStore
     from src.config import CLIConfig
 
-    config = CLIConfig()
+    config = CLIConfig(profile=ctx.profile)
     server_url = config.resolve_server_url(ctx.server_url)
     if not server_url:
         click.echo(
@@ -125,7 +125,7 @@ def _login_browser(ctx, port):
 
     verify_ssl = config.resolve_verify_ssl()
     flow = OAuthFlow(server_url, verify_ssl=verify_ssl)
-    store = TokenStore()
+    store = TokenStore(profile=ctx.profile)
 
     try:
         if not ctx.json_mode:
@@ -152,7 +152,7 @@ def _login_device(ctx):
     from src.auth.oauth import OAuthFlow
     from src.config import CLIConfig
 
-    config = CLIConfig()
+    config = CLIConfig(profile=ctx.profile)
     server_url = config.resolve_server_url(ctx.server_url)
     if not server_url:
         click.echo(
@@ -174,7 +174,7 @@ def _login_device(ctx):
         sys.exit(1)
 
     # Save pending device code for --check
-    _save_pending_device(pending)
+    _save_pending_device(pending, ctx.profile)
 
     if ctx.json_mode:
         click.echo(json.dumps({
@@ -203,7 +203,7 @@ def _login_check(ctx):
     from src.auth.token_store import TokenStore
     from src.config import CLIConfig
 
-    pending = _load_pending_device()
+    pending = _load_pending_device(ctx.profile)
     if not pending:
         msg = "No pending device authorization. Run: upscaler login --no-browser"
         if ctx.json_mode:
@@ -214,7 +214,7 @@ def _login_check(ctx):
 
     # Check expiry
     if time.time() >= pending["expires_at"]:
-        _delete_pending_device()
+        _delete_pending_device(ctx.profile)
         msg = "Device code expired. Run: upscaler login --no-browser"
         if ctx.json_mode:
             click.echo(json.dumps({"error": msg, "expired": True}), err=True)
@@ -222,7 +222,7 @@ def _login_check(ctx):
             click.echo(msg, err=True)
         sys.exit(2)
 
-    config = CLIConfig()
+    config = CLIConfig(profile=ctx.profile)
     server_url = pending.get("server_url") or config.resolve_server_url(ctx.server_url)
     verify_ssl = config.resolve_verify_ssl()
     flow = OAuthFlow(server_url, verify_ssl=verify_ssl)
@@ -245,7 +245,7 @@ def _login_check(ctx):
             )
         sys.exit(1)
     except RuntimeError as e:
-        _delete_pending_device()
+        _delete_pending_device(ctx.profile)
         if ctx.json_mode:
             click.echo(json.dumps({"error": str(e)}), err=True)
         else:
@@ -253,9 +253,9 @@ def _login_check(ctx):
         sys.exit(2)
 
     # Success — save tokens and clean up pending file
-    store = TokenStore()
+    store = TokenStore(profile=ctx.profile)
     store.save(token_data)
-    _delete_pending_device()
+    _delete_pending_device(ctx.profile)
 
     if ctx.json_mode:
         expires_in = int(token_data.expires_at - time.time())
@@ -265,36 +265,41 @@ def _login_check(ctx):
 
 
 # ---------------------------------------------------------------------------
-# Pending device code persistence (~/.upscaler/pending_device.json)
+# Pending device code persistence (~/.upscaler/profiles/{profile}/pending_device.json)
 # ---------------------------------------------------------------------------
 
 _PENDING_FILE = "pending_device.json"
 
 
-def _get_pending_path():
-    """Get path to the pending device code file."""
+def _get_pending_path(profile: str | None = None) -> str:
+    """Get path to the pending device code file for the active profile."""
     import os
 
-    config_dir = os.path.expanduser("~/.upscaler")
-    return os.path.join(config_dir, _PENDING_FILE)
+    from src.profile import get_profile_dir
 
+    config_dir = get_profile_dir(profile)
+    return os.path.join(str(config_dir), _PENDING_FILE)
 
-def _save_pending_device(data: dict) -> None:
+
+def _save_pending_device(data: dict, profile: str | None = None) -> None:
     """Save pending device code to disk."""
     import os
+    from pathlib import Path
+
+    from src.profile import ensure_profile_dir
 
-    path = _get_pending_path()
-    os.makedirs(os.path.dirname(path), mode=0o700, exist_ok=True)
+    path = _get_pending_path(profile)
+    ensure_profile_dir(Path(os.path.dirname(path)))
     with open(path, "w") as f:
         f.write(json.dumps(data))
     os.chmod(path, 0o600)
 
 
-def _load_pending_device() -> dict | None:
+def _load_pending_device(profile: str | None = None) -> dict | None:
     """Load pending device code from disk, or None if absent."""
     import os
 
-    path = _get_pending_path()
+    path = _get_pending_path(profile)
     if not os.path.exists(path):
         return None
     try:
@@ -304,11 +309,11 @@ def _load_pending_device() -> dict | None:
         return None
 
 
-def _delete_pending_device() -> None:
+def _delete_pending_device(profile: str | None = None) -> None:
     """Remove the pending device code file."""
     import os
 
-    path = _get_pending_path()
+    path = _get_pending_path(profile)
     if os.path.exists(path):
         os.unlink(path)
 
@@ -326,9 +331,9 @@ def refresh(ctx):
     from src.auth.token_store import TokenStore
     from src.config import CLIConfig
 
-    config = CLIConfig()
+    config = CLIConfig(profile=ctx.profile)
     server_url = config.resolve_server_url(ctx.server_url)
-    store = TokenStore()
+    store = TokenStore(profile=ctx.profile)
 
     try:
         token_data = store.load()
@@ -370,7 +375,7 @@ def status(ctx):
     """
     from src.auth.token_store import TokenStore
 
-    store = TokenStore()
+    store = TokenStore(profile=ctx.profile)
 
     try:
         token_data = store.load()
@@ -411,9 +416,9 @@ def logout(ctx):
     from src.auth.token_store import TokenStore
     from src.config import CLIConfig
 
-    config = CLIConfig()
+    config = CLIConfig(profile=ctx.profile)
     server_url = config.resolve_server_url(ctx.server_url)
-    store = TokenStore()
+    store = TokenStore(profile=ctx.profile)
 
     try:
         token_data = store.load()

src/cli/automation.py

@@ -0,0 +1,221 @@
+"""Automation management CLI commands.
+
+Lists, inspects, and manages automations (scheduled actions on assets/members).
+Wraps POST /api/v1/automations on the up-ai REST API.
+"""
+
+import sys
+
+import click
+
+from src.cli.context import pass_context
+from src.cli.helpers import execute_rest_action
+
+
+@click.group("automation")
+def automation_group():
+    """Manage automations: list, get, create, update, enable, disable, run, delete, runs.
+
+    Examples:
+        upscaler automation list
+        upscaler automation get auto_abc123
+        upscaler automation create --data @automation.json
+        upscaler automation enable auto_abc123
+        upscaler automation run auto_abc123
+        upscaler automation runs auto_abc123 --limit 50
+        upscaler automation list --asset-id d_xyz
+    """
+    pass
+
+
+@automation_group.command("list")
+@click.option("--search", default=None, help="Search filter.")
+@click.option(
+    "--action-type",
+    "action_types",
+    multiple=True,
+    help=(
+        "Filter by action type (repeatable): createTodo, createRecord, "
+        "sendEmailDigest, createReviewRequest"
+    ),
+)
+@click.option(
+    "--asset-id",
+    default=None,
+    help="If given, list automations bound to this asset (uses getAssetAutomations).",
+)
+@click.option("--upcoming", is_flag=True, help="Show only upcoming automations.")
+@click.option("--limit", default=50, type=int, help="Page size (default 50).")
+@click.option("--offset", default=0, type=int, help="Page offset (default 0).")
+@pass_context
+def automation_list(ctx, search, action_types, asset_id, upcoming, limit, offset):
+    """List automations."""
+    if upcoming and asset_id:
+        click.echo("--upcoming and --asset-id are mutually exclusive", err=True)
+        sys.exit(1)
+
+    if asset_id:
+        action = "list_for_asset"
+        payload = {"action": action, "asset_id": asset_id, "limit": limit, "offset": offset}
+    elif upcoming:
+        action = "list_upcoming"
+        payload = {"action": action, "limit": limit, "offset": offset}
+    else:
+        action = "list"
+        payload = {"action": action, "limit": limit, "offset": offset}
+        if search:
+            payload["search"] = search
+        if action_types:
+            payload["action_types"] = list(action_types)
+
+    _execute(ctx, payload)
+
+
+@automation_group.command("get")
+@click.argument("automation_id")
+@pass_context
+def automation_get(ctx, automation_id):
+    """Fetch a single automation by ID."""
+    _execute(ctx, {"action": "get", "id": automation_id})
+
+
+@automation_group.command("runs")
+@click.argument("automation_id")
+@click.option("--limit", default=20, type=int)
+@click.option("--offset", default=0, type=int)
+@pass_context
+def automation_runs(ctx, automation_id, limit, offset):
+    """List recent runs of an automation."""
+    _execute(
+        ctx,
+        {"action": "list_runs", "id": automation_id, "limit": limit, "offset": offset},
+    )
+
+
+@automation_group.command("create")
+@click.option(
+    "--data",
+    "data_input",
+    required=True,
+    help="JSON payload (value, - for stdin, @file).",
+)
+@click.option("--dry-run", is_flag=True, help="Preview without creating.")
+@pass_context
+def automation_create(ctx, data_input, dry_run):
+    """Create an automation.
+
+    --data should be CreateAutomationInput shape, e.g.:
+    {"title": "Weekly review", "trigger": {"type": "schedule",
+     "schedule": {"cron": "0 9 * * 1", "timezone": "UTC"}},
+     "target": {"type": "asset", "asset": {"id": "d_xxx", "type": "document"}},
+     "action": {"type": "createTodo", "createTodo":
+       {"title": "Review doc", "assignees": ["user_abc"]}}}
+    """
+    from src.cli.helpers import parse_data
+
+    try:
+        data = parse_data(data_input)
+    except Exception as e:
+        click.echo(str(e), err=True)
+        sys.exit(1)
+
+    _execute(ctx, {"action": "create", "data": data}, dry_run=dry_run)
+
+
+@automation_group.command("update")
+@click.argument("automation_id")
+@click.option("--data", "data_input", required=True, help="JSON payload.")
+@click.option("--dry-run", is_flag=True)
+@pass_context
+def automation_update(ctx, automation_id, data_input, dry_run):
+    """Update an automation."""
+    from src.cli.helpers import parse_data
+
+    try:
+        data = parse_data(data_input)
+    except Exception as e:
+        click.echo(str(e), err=True)
+        sys.exit(1)
+
+    _execute(ctx, {"action": "update", "id": automation_id, "data": data}, dry_run=dry_run)
+
+
+@automation_group.command("enable")
+@click.argument("automation_id")
+@pass_context
+def automation_enable(ctx, automation_id):
+    """Enable an automation."""
+    _execute(ctx, {"action": "enable", "id": automation_id})
+
+
+@automation_group.command("disable")
+@click.argument("automation_id")
+@pass_context
+def automation_disable(ctx, automation_id):
+    """Disable an automation."""
+    _execute(ctx, {"action": "disable", "id": automation_id})
+
+
+@automation_group.command("run")
+@click.argument("automation_id")
+@pass_context
+def automation_run(ctx, automation_id):
+    """Manually trigger an automation now."""
+    _execute(ctx, {"action": "run", "id": automation_id})
+
+
+@automation_group.command("delete")
+@click.argument("automation_id")
+@click.option("--dry-run", is_flag=True)
+@pass_context
+def automation_delete(ctx, automation_id, dry_run):
+    """Delete an automation."""
+    from src.cli.helpers import confirm_destructive
+
+    if not dry_run and not confirm_destructive("delete", automation_id, ctx.json_mode):
+        click.echo("Cancelled.", err=True)
+        return
+
+    _execute(ctx, {"action": "delete", "id": automation_id}, dry_run=dry_run)
+
+
+def _execute(ctx, payload, dry_run=False):
+    execute_rest_action(
+        ctx, payload, "/api/v1/automations", render=_render_human, dry_run=dry_run
+    )
+
+
+def _render_human(action, result):
+    from src.formatters.json_fmt import format_json
+
+    if not result.get("success"):
+        click.echo(format_json(result))
+        return
+
+    data = result.get("data")
+    meta = result.get("metadata") or {}
+
+    if isinstance(data, list):
+        if not data:
+            click.echo("(no results)")
+            return
+        for item in data:
+            if isinstance(item, dict):
+                if "triggeredAt" in item or "scheduleId" in item:
+                    click.echo(
+                        f"{item.get('triggeredAt', '')}  {item.get('status', ''):8}  "
+                        f"{item.get('resultTitle', '') or item.get('id', '')}"
+                    )
+                else:
+                    enabled = "on " if item.get("enabled") else "off"
+                    next_due = item.get("nextDue") or ""
+                    click.echo(
+                        f"{item.get('id', ''):28}  [{enabled}]  "
+                        f"{item.get('title', '') or '(untitled)':40}  next: {next_due}"
+                    )
+        if meta.get("total_count") is not None:
+            click.echo(f"\nTotal: {meta['total_count']} (showing {len(data)})")
+    elif isinstance(data, dict):
+        click.echo(format_json(data))
+    else:
+        click.echo(str(data))

src/cli/config_cmd.py

@@ -1,11 +1,15 @@
-"""CLI config command for persistent settings."""
+"""CLI config command for persistent settings (per profile)."""
 
 import click
 
+from src.cli.context import pass_context
 from src.config import VALID_KEYS, CLIConfig
 
 
-@click.group("config", help="Manage persistent CLI settings in ~/.upscaler/config.json.")
+@click.group(
+    "config",
+    help="Manage persistent CLI settings in ~/.upscaler/profiles/{profile}/config.json.",
+)
 def config_group():
     pass
 
@@ -13,12 +17,13 @@ def config_group():
 @config_group.command("set")
 @click.argument("key")
 @click.argument("value")
-def config_set(key, value):
-    """Set a config value. Valid keys: server_url, oauth_url, default_format."""
+@pass_context
+def config_set(ctx, key, value):
+    """Set a config value on the active profile."""
     try:
-        config = CLIConfig()
+        config = CLIConfig(profile=ctx.profile)
         config.set(key, value)
-        click.echo(f"{key} = {value}")
+        click.echo(f"[{ctx.profile}] {key} = {value}")
     except ValueError as e:
         click.echo(str(e), err=True)
         raise SystemExit(1)
@@ -26,14 +31,15 @@ def config_set(key, value):
 
 @config_group.command("get")
 @click.argument("key")
-def config_get(key):
-    """Get a config value."""
+@pass_context
+def config_get(ctx, key):
+    """Get a config value from the active profile."""
     if key not in VALID_KEYS:
         click.echo(
             f"Unknown config key: {key}. Valid keys: {', '.join(sorted(VALID_KEYS))}",
             err=True,
         )
         raise SystemExit(1)
-    config = CLIConfig()
+    config = CLIConfig(profile=ctx.profile)
     value = config.get(key)
     click.echo(value if value else "")

src/cli/context.py

@@ -4,6 +4,8 @@ from typing import Optional
 
 import click
 
+from src.profile import DEFAULT_PROFILE
+
 
 class Context:
     """Shared context object passed to all commands."""
@@ -12,6 +14,7 @@ class Context:
         self.json_mode: bool = False
         self.verbose: bool = False
         self.server_url: Optional[str] = None
+        self.profile: str = DEFAULT_PROFILE
 
 
 pass_context = click.make_pass_decorator(Context, ensure=True)