snapctl 0.50.0__tar.gz → 0.53.1__tar.gz

{snapctl-0.50.0 → snapctl-0.53.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: snapctl
-Version: 0.50.0
+Version: 0.53.1
 Summary: Snapser CLI Tool
 Author: Ajinkya Apte
 Author-email: aj@snapser.com

{snapctl-0.50.0 → snapctl-0.53.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "snapctl"
-version = "0.50.0"
+version = "0.53.1"
 description = "Snapser CLI Tool"
 authors = ["Ajinkya Apte <aj@snapser.com>"]
 readme = "README.md"

{snapctl-0.50.0 → snapctl-0.53.1}/snapctl/commands/byows.py

@@ -20,7 +20,6 @@ from snapctl.config.constants import SERVER_CALL_TIMEOUT, SNAPCTL_INPUT_ERROR, \
 from snapctl.utils.helper import snapctl_error, snapctl_success, get_dot_snapser_dir
 from snapctl.utils.echo import info, warning
 
-
 class Byows:
     """
       CLI commands exposed for a Bring your own Workstation
@@ -70,6 +69,10 @@ class Byows:
                 snapctl_error(
                     message="Missing Input --snapend-id=$your_snapend_id",
                     code=SNAPCTL_INPUT_ERROR)
+            if not Byows.is_valid_cluster_id(self.snapend_id):
+                snapctl_error(
+                    message="Invalid value --snapend-id must be a valid Snapend ID, e.g., 'a1b2c3d4'",
+                    code=SNAPCTL_INPUT_ERROR)
             if self.byosnap_id is None or self.byosnap_id == '':
                 snapctl_error(
                     message="Missing Input --byosnap-id=$your_byosnap_id",
@@ -390,7 +393,7 @@ class Byows:
                     self._handle_signal))
                 if hasattr(signal, "SIGBREAK"):
                     signal.signal(signal.SIGBREAK,
-                                  functools.partial(self._handle_signal))
+                    functools.partial(self._handle_signal))
                 # Set up port forward
                 self._setup_port_forward(
                     response_json['proxyPrivateKey'],
@@ -409,16 +412,15 @@ class Byows:
                 return snapctl_success(
                     message='complete', progress=progress)
             snapctl_error(
-                message='Unable to setup port forward.',
+                message='Attach failed.',
                 code=SNAPCTL_BYOWS_ATTACH_ERROR, progress=progress)
         except HTTPError as http_err:
             snapctl_error(
-                message=Byows._format_portal_http_error(
-                    "Unable to setup port forward", http_err, res),
+                message=Byows._format_portal_http_error("Attach failed.", http_err, res),
                 code=SNAPCTL_BYOWS_ATTACH_ERROR, progress=progress)
         except RequestException as e:
             snapctl_error(
-                message=f"Exception: Unable to setup port forward {e}",
+                message=f"Attach failed: {e}",
                 code=SNAPCTL_BYOWS_ATTACH_ERROR, progress=progress)
         finally:
             progress.stop()
@@ -463,3 +465,21 @@ class Byows:
                 code=SNAPCTL_BYOWS_RESET_ERROR, progress=progress)
         finally:
             progress.stop()
+
+    @staticmethod
+    def is_valid_cluster_id(cluster_id: str) -> bool:
+        """
+        Check if the input is a valid cluster ID (Snapend ID).
+        """
+        import re
+        if not cluster_id:
+            return False
+
+        pattern = "^[a-z0-9]+$"
+        if not re.match(pattern, cluster_id):
+            return False
+
+        if len(cluster_id) != 8:
+            return False
+
+        return True

{snapctl-0.50.0 → snapctl-0.53.1}/snapctl/commands/release_notes.py

@@ -35,9 +35,15 @@ class ReleaseNotes:
         """
         print('== Releases ' + '=' * (92))
         # List all resource files in snapctl.data.releases
+        final_list = []
         for resource in pkg_resources.contents(snapctl.data.releases):
             if resource.endswith('.mdx'):
-                print(resource.replace('.mdx', '').replace('.md', ''))
+                final_list.append(resource.replace(
+                    '.mdx', '').replace('.md', ''))
+        # Sort versions in descending order
+        final_list.sort(reverse=True)
+        for version in final_list:
+            print(f"- {version}")
         print('=' * (104))
         snapctl_success(message="List versions")
 

{snapctl-0.50.0 → snapctl-0.53.1}/snapctl/commands/snapend.py

@@ -84,9 +84,9 @@ class Snapend:
         self.manifest_path_filename: Union[str, None] = manifest_path_filename
         self.force: bool = force
         self.category: str = category
-        self.portal_category: Union[str, None] = Snapend._make_portal_category(
-            category_format)
         self.category_format: str = category_format
+        self.portal_category: Union[str, None] = Snapend._make_portal_category(
+            category, category_format)
         self.category_type: Union[str, None] = category_type
         self.category_http_lib: Union[str, None] = category_http_lib
         self.download_types: Union[
@@ -117,16 +117,20 @@ class Snapend:
         return None
 
     @staticmethod
-    def _make_portal_category(category_format: str):
+    def _make_portal_category(category: str, category_format: str):
         '''
             We have simplified the input for the user to only take the category as sdk
             The portal server however expects us to pass client-sdk or server-sdk
             Hence we need to do this
         '''
-        if category_format in CLIENT_SDK_TYPES:
+        if category == 'sdk' and category_format in CLIENT_SDK_TYPES:
             return 'client-sdk'
-        if category_format in SERVER_SDK_TYPES:
+        if category == 'sdk' and category_format in SERVER_SDK_TYPES:
             return 'server-sdk'
+        if category == 'protos' and category_format in PROTOS_TYPES:
+            return 'protos'
+        if category == 'snapend-manifest' and category_format in SNAPEND_MANIFEST_TYPES:
+            return 'snapend-manifest'
         return None
 
     @staticmethod

snapctl-0.53.1/snapctl/config/app.py

@@ -0,0 +1,31 @@
+'''
+Configuration by environment
+'''
+from typing import Dict
+
+APP_CONFIG: Dict[str, Dict[str, str]] = {
+    'DEV': {
+        'AMPLITUDE_REGION': 'US',
+        'AMPLITUDE_API_KEY': 'ca863e91bfb3ce084e022920083f2898',
+        'TELEMETRY_ACTIVE': 'false',
+        'TELEMETRY_DRY_RUN': 'true',
+    },
+    'DEV_TWO': {
+        'AMPLITUDE_REGION': 'US',
+        'AMPLITUDE_API_KEY': 'ca863e91bfb3ce084e022920083f2898',
+        'TELEMETRY_ACTIVE': 'false',
+        'TELEMETRY_DRY_RUN': 'true',
+    },
+    'PLAYTEST': {
+        'AMPLITUDE_REGION': 'US',
+        'AMPLITUDE_API_KEY': 'ca863e91bfb3ce084e022920083f2898',
+        'TELEMETRY_ACTIVE': 'false',
+        'TELEMETRY_DRY_RUN': 'false',
+    },
+    'PROD': {
+        'AMPLITUDE_REGION': 'US',
+        'AMPLITUDE_API_KEY': '31fe2221f24fc30694cda777e98bd7a1',
+        'TELEMETRY_ACTIVE': 'false',
+        'TELEMETRY_DRY_RUN': 'false',
+    }
+}

{snapctl-0.50.0 → snapctl-0.53.1}/snapctl/config/constants.py

@@ -2,8 +2,8 @@
 Constants used by snapctl
 """
 COMPANY_NAME = 'Snapser'
-VERSION_PREFIX = 'beta-'
-VERSION = '0.50.0'
+VERSION_PREFIX = ''
+VERSION = '0.53.1'
 CONFIG_FILE_MAC = '~/.snapser/config'
 CONFIG_FILE_WIN = '%homepath%\\.snapser\\config'
 
@@ -13,6 +13,10 @@ URL_KEY = 'SNAPSER_URL_KEY'
 CONFIG_PATH_KEY = 'SNAPSER_CONFIG_PATH'
 SERVER_CALL_TIMEOUT = 300
 
+# Telemetry
+AMPLITUDE_HTTP_US = "https://api2.amplitude.com/2/httpapi"
+AMPLITUDE_HTTP_EU = "https://api.eu.amplitude.com/2/httpapi"
+
 # HTTP codes
 HTTP_UNAUTHORIZED = 401
 HTTP_FORBIDDEN = 403

snapctl-0.53.1/snapctl/data/releases/beta-0.51.0.mdx

@@ -0,0 +1,6 @@
+## beta-0.51.0
+#### Jun 5, 2025
+
+### Improvements
+#### BYOWS
+- Improved snapend ID validation

snapctl-0.53.1/snapctl/data/releases/beta-0.53.1.mdx

@@ -0,0 +1,6 @@
+## beta-0.53.1
+#### Aug 27, 2025
+
+### Bug fix
+#### Snapend Download
+- Fixed a bug that was preventing download of manifests and protos for a Snapend.

{snapctl-0.50.0 → snapctl-0.53.1}/snapctl/main.py

@@ -23,6 +23,7 @@ from snapctl.config.hashes import PROTOS_TYPES, SERVICE_IDS, \
     SNAPEND_MANIFEST_TYPES, SDK_TYPES
 from snapctl.utils.echo import error, success, info
 from snapctl.utils.helper import validate_api_key
+from snapctl.utils.telemetry import telemetry
 
 ######### Globals #########
 
@@ -90,6 +91,21 @@ def extract_config(extract_key: str, profile: Union[str, None] = None) -> object
     return result
 
 
+def get_environment(api_key_value: Union[str, None]) -> str:
+    """
+        Returns the environment based on the api_key
+    """
+    if api_key_value is None:
+        return 'UNKNOWN'
+    if api_key_value.startswith('dev_'):
+        return 'DEV'
+    if api_key_value.startswith('devtwo_'):
+        return 'DEV_TWO'
+    if api_key_value.startswith('playtest_'):
+        return 'PLAYTEST'
+    return 'PROD'
+
+
 def get_base_url(api_key: Union[str, None]) -> str:
     """
         Returns the base url based on the api_key
@@ -153,6 +169,7 @@ def default_context_callback(ctx: typer.Context):
     ctx.obj['api_key'] = api_key_obj['value']
     ctx.obj['api_key_location'] = api_key_obj['location']
     ctx.obj['profile'] = DEFAULT_PROFILE
+    ctx.obj['environment'] = get_environment(api_key_obj['value'])
     ctx.obj['base_url'] = get_base_url(api_key_obj['value'])
     ctx.obj['base_snapend_url'] = get_base_snapend_url(api_key_obj['value'])
 
@@ -173,6 +190,7 @@ def api_key_context_callback(
     ctx.obj['version'] = VERSION
     ctx.obj['api_key'] = api_key
     ctx.obj['api_key_location'] = 'command-line-argument'
+    ctx.obj['environment'] = get_environment(api_key)
     ctx.obj['base_url'] = get_base_url(api_key)
 
 
@@ -205,6 +223,7 @@ def profile_context_callback(
     ctx.obj['api_key'] = api_key_obj['value']
     ctx.obj['api_key_location'] = api_key_obj['location']
     ctx.obj['profile'] = profile if profile else DEFAULT_PROFILE
+    ctx.obj['environment'] = get_environment(api_key_obj['value'])
     ctx.obj['base_url'] = get_base_url(api_key_obj['value'])
 
 
@@ -236,6 +255,7 @@ def common(
 
 
 @app.command()
+@telemetry("validate", subcommand_arg="subcommand")
 def validate(
     ctx: typer.Context,
     api_key: Union[str, None] = typer.Option(
@@ -255,6 +275,7 @@ def validate(
 
 
 @app.command()
+@telemetry("release_notes", subcommand_arg="subcommand")
 def release_notes(
     ctx: typer.Context,
     subcommand: str = typer.Argument(
@@ -283,6 +304,7 @@ def release_notes(
 
 
 @app.command()
+@telemetry("byogs", subcommand_arg="subcommand")
 def byogs(
     ctx: typer.Context,
     # Required fields
@@ -352,6 +374,7 @@ def byogs(
 
 
 @app.command()
+@telemetry("byosnap", subcommand_arg="subcommand")
 def byosnap(
     ctx: typer.Context,
     # Required fields
@@ -460,6 +483,7 @@ def byosnap(
 
 
 @app.command()
+@telemetry("game", subcommand_arg="subcommand")
 def game(
     ctx: typer.Context,
     # Required fields
@@ -495,6 +519,7 @@ def game(
 
 
 @app.command()
+@telemetry("generate", subcommand_arg="subcommand")
 def generate(
     ctx: typer.Context,
     # Required fields
@@ -541,6 +566,7 @@ def generate(
 
 
 @app.command()
+@telemetry("snapend", subcommand_arg="subcommand")
 def snapend(
     ctx: typer.Context,
     # Required fields
@@ -684,6 +710,7 @@ def snapend(
 
 
 @app.command()
+@telemetry("byows", subcommand_arg="subcommand")
 def byows(
     ctx: typer.Context,
     # Required fields

{snapctl-0.50.0 → snapctl-0.53.1}/snapctl/utils/helper.py

@@ -2,6 +2,7 @@
 Helper functions for snapctl
 """
 from typing import Union, Dict
+from pathlib import Path
 import re
 import platform
 import os
@@ -14,7 +15,7 @@ from snapctl.config.constants import HTTP_NOT_FOUND, HTTP_FORBIDDEN, HTTP_UNAUTH
     SERVER_CALL_TIMEOUT, SNAPCTL_CONFIGURATION_ERROR, SNAPCTL_SUCCESS
 from snapctl.config.hashes import ARCHITECTURE_MAPPING
 from snapctl.utils.echo import error, success
-from pathlib import Path
+from snapctl.config.app import APP_CONFIG
 
 
 def validate_api_key(base_url: str, api_key: Union[str, None]) -> bool:
@@ -185,10 +186,20 @@ def check_use_containerd_snapshotter() -> bool:
     except Exception:
         return False
 
+
 def get_dot_snapser_dir() -> Path:
     """
     Returns the .snapser configuration directory, creating it if necessary.
     """
     config_dir = Path.home() / ".snapser"
     config_dir.mkdir(parents=True, exist_ok=True)
-    return config_dir
+    return config_dir
+
+
+def get_config_value(environment: str, key: str) -> str:
+    """
+    Returns the config value based on the environment.
+    """
+    if environment == '' or environment not in APP_CONFIG or key not in APP_CONFIG[environment]:
+        return ''
+    return APP_CONFIG[environment][key]

snapctl-0.53.1/snapctl/utils/telemetry.py

@@ -0,0 +1,160 @@
+'''
+Telemetry utilities for snapctl
+'''
+from __future__ import annotations
+from typing import Any, Dict, Optional
+import functools
+import platform
+import uuid
+import hashlib
+import requests
+import typer
+from snapctl.config.constants import AMPLITUDE_HTTP_US, AMPLITUDE_HTTP_EU
+from snapctl.utils.helper import get_config_value
+from snapctl.utils.echo import info
+
+
+def _ctx(ctx: Optional[typer.Context]) -> dict:
+    try:
+        return ctx.obj or {}
+    except Exception:
+        return {}
+
+
+def _base_props(ctx: Optional[typer.Context]) -> Dict[str, Any]:
+    c = _ctx(ctx)
+    return {
+        "source": "snapctl",
+        "cli_version": c.get("version"),
+        "os": platform.system(),
+    }
+
+
+def _device_id_from_ctx(ctx: Optional[typer.Context]) -> str:
+    """
+    Amplitude requires either user_id or device_id.
+    We derive a non-reversible device_id from the API key (if present).
+    """
+    c = _ctx(ctx)
+    api_key = c.get("api_key") or ""
+    if api_key:
+        # hash + truncate to keep it compact but stable
+        h = hashlib.sha256(f"snapctl|{api_key}".encode("utf-8")).hexdigest()
+        return f"dev-{h[:32]}"
+    # fallback: hostname or a random-ish node id
+    return f"host-{platform.node() or uuid.getnode()}"
+
+
+def _endpoint_from_env(ctx: Optional[typer.Context]) -> str:
+    """
+    Returns the Amplitude endpoint based on environment config.
+    """
+    c = _ctx(ctx)
+    env = c.get("environment")
+    region = (get_config_value(env, "AMPLITUDE_REGION") or "US").upper()
+    return AMPLITUDE_HTTP_EU if region == "EU" else AMPLITUDE_HTTP_US
+
+
+def _is_active(ctx: Optional[typer.Context]) -> tuple[bool, bool, Optional[str]]:
+    """
+    Returns (telemetry_active, dry_run, api_key)
+    """
+    c = _ctx(ctx)
+    env = c.get("environment")
+    api_key = get_config_value(env, "AMPLITUDE_API_KEY")
+    if not api_key or api_key == '':
+        return (False, False, None)
+    telemetry_active = get_config_value(env, "TELEMETRY_ACTIVE") == "true"
+    dry_run = get_config_value(env, "TELEMETRY_DRY_RUN") == "true"
+    return (telemetry_active, dry_run, api_key)
+
+
+def _post_event(payload: dict, endpoint: str, timeout_s: float) -> None:
+    """
+    Post the event to Amplitude.
+    """
+    try:
+        requests.post(endpoint, json=payload, timeout=timeout_s)
+    except Exception:
+        # Never break the CLI
+        pass
+
+
+def track_simple(
+    ctx: Optional[typer.Context],
+    *,
+    command: str,
+    sub: str,
+    result: str,
+    count: int = 1,
+    timeout_s: float = 2.0,
+) -> None:
+    """
+    Minimal Amplitude event:
+      event_type = action
+      event_properties = { category, label, count, ...tiny base props }
+    """
+    category = 'cli'
+    active, dry_run, api_key = _is_active(ctx)
+    if not active or not api_key:
+        return
+
+    action = f"{command}_{sub}" if sub else command
+    props = {**_base_props(ctx)}
+    if dry_run:
+        info(
+            f"[telemetry:DRY-RUN] category={category} action={action} label={result} "
+            f"count={count} props={props}")
+        return
+
+    payload = {
+        "api_key": api_key,
+        "events": [{
+            "event_type": action,
+            "device_id": _device_id_from_ctx(ctx),
+            "event_properties": props,
+        }]
+    }
+    _post_event(payload, _endpoint_from_env(ctx), timeout_s)
+
+# -------- Decorator to auto-track per-command result --------
+
+
+def telemetry(command_name: str, subcommand_arg: Optional[str] = None):
+    """
+    Decorator to track telemetry for a command function.
+    """
+    def deco(fn):
+        @functools.wraps(fn)
+        def wrapper(*args, **kwargs):
+            ctx: Optional[typer.Context] = kwargs.get("ctx")
+            sub = (kwargs.get(subcommand_arg) if subcommand_arg else None)
+            label = "success"  # default unless we see a failure
+            should_track_run = True
+            try:
+                result = fn(*args, **kwargs)
+                return result
+            except typer.Exit as e:
+                code = getattr(e, "exit_code", None)
+                # treat Exit(0/None) as success, anything else as failure
+                label = "success" if (code == 0 or code is None) else "failure"
+                # Now we only want to track if it was a success
+                #   typer.Exit is called by us on user failure.
+                #   If we start tracking this, bad actors can spam our telemetry.
+                should_track_run = not label == 'failure'
+                raise
+            except SystemExit as e:
+                # print('#1')
+                code = getattr(e, "code", None)
+                label = "success" if (code == 0 or code is None) else "failure"
+                raise
+            except Exception:
+                # print('#2')
+                label = "failure"
+                raise
+            finally:
+                if should_track_run:
+                    track_simple(ctx, command=command_name,
+                                 sub=sub, result=label, count=1)
+        return wrapper
+    return deco