snapctl 0.48.1__py3-none-any.whl → 0.49.0__py3-none-any.whl

snapctl/commands/byosnap.py

@@ -11,10 +11,10 @@ import subprocess
 import platform as sys_platform
 from sys import platform
 from typing import Union, List
+import importlib.resources as pkg_resources
 import requests
 from requests.exceptions import RequestException
 import yaml
-
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from snapctl.commands.snapend import Snapend
 from snapctl.config.constants import SERVER_CALL_TIMEOUT
@@ -29,10 +29,11 @@ from snapctl.config.constants import HTTP_ERROR_SERVICE_VERSION_EXISTS, \
     SNAPCTL_BYOSNAP_UPDATE_VERSION_ERROR, SNAPCTL_BYOSNAP_UPDATE_VERSION_SERVICE_IN_USE_ERROR, \
     SNAPCTL_BYOSNAP_UPDATE_VERSION_TAG_ERROR, SNAPCTL_BYOSNAP_NOT_FOUND, \
     HTTP_ERROR_RESOURCE_NOT_FOUND, SNAPCTL_BYOSNAP_PUBLISH_ERROR, \
-    SNAPCTL_BYOSNAP_GENERATE_PROFILE_ERROR, SNAPCTL_CONFIGURATION_INCORRECT, SNAPCTL_BYOSNAP_SWAGGER_ERROR
+    SNAPCTL_BYOSNAP_GENERATE_PROFILE_ERROR, SNAPCTL_CONFIGURATION_INCORRECT
 from snapctl.utils.echo import info, warning, success
 from snapctl.utils.helper import get_composite_token, snapctl_error, snapctl_success, \
     check_dockerfile_architecture, check_use_containerd_snapshotter
+import snapctl.data.profiles
 
 
 class ByoSnap:
@@ -52,8 +53,8 @@ class ByoSnap:
     TO_DEPRECATE_SUBCOMMANDS = [
         'create', 'publish-image', 'publish-version', 'update-version']
     DEFAULT_PROFILE_NAME_JSON = 'snapser-byosnap-profile.json'
+    DEFAULT_PROFILE_NAME_YML = 'snapser-byosnap-profile.yml'
     DEFAULT_PROFILE_NAME_YAML = 'snapser-byosnap-profile.yaml'
-    PROFILE_FILES_PATH = 'snapctl/data/profiles/'
     PROFILE_FORMATS = ['json', 'yaml', 'yml']
     PLATFORMS = ['linux/arm64', 'linux/amd64']
     LANGUAGES = ['go', 'node', 'python', 'java', 'csharp', 'cpp', 'rust',
@@ -501,13 +502,23 @@ class ByoSnap:
             )
 
     @staticmethod
-    def _handle_output_file(input_filepath, output_filepath) -> bool:
-        file_written = False
-        with open(input_filepath, 'r') as in_file, open(output_filepath, 'w') as outfile:
-            for line in in_file:
-                outfile.write(line)
-            file_written = True
-        return file_written
+    def _handle_output_file(resource_filename: str, output_filepath: str) -> bool:
+        try:
+            with pkg_resources.open_text(snapctl.data.profiles, resource_filename) as in_file, open(output_filepath, 'w') as outfile:
+                for line in in_file:
+                    outfile.write(line)
+            return True
+        except FileNotFoundError:
+            print(f"[ERROR] Could not find profile file: {resource_filename}")
+            return False
+    # @staticmethod
+    # def _handle_output_file(input_filepath, output_filepath) -> bool:
+    #     file_written = False
+    #     with open(input_filepath, 'r') as in_file, open(output_filepath, 'w') as outfile:
+    #         for line in in_file:
+    #             outfile.write(line)
+    #         file_written = True
+    #     return file_written
 
     def _get_profile_contents(self) -> dict:
         """
@@ -1574,9 +1585,9 @@ class ByoSnap:
                 file_save_path = os.path.join(
                     os.getcwd(), self.profile_filename)
             extension = self.profile_filename.split('.')[-1]
+            resource_filename = f"snapser-byosnap-profile.{extension}"
             file_written = ByoSnap._handle_output_file(
-                f"{ByoSnap.PROFILE_FILES_PATH}snapser-byosnap-profile.{extension}", file_save_path
-            )
+                resource_filename, file_save_path)
             if file_written:
                 snapctl_success(
                     message="BYOSNAP Profile generation successful. " +

snapctl/commands/byows.py

@@ -0,0 +1,421 @@
+"""
+  BYOWs CLI commands
+"""
+import os
+import platform
+import subprocess
+import shutil
+import time
+import json
+from pathlib import Path
+from typing import Union
+import threading
+import requests
+from requests.exceptions import RequestException, HTTPError
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from snapctl.config.constants import SERVER_CALL_TIMEOUT, SNAPCTL_INPUT_ERROR, \
+    SNAPCTL_BYOWS_GENERIC_ERROR, SNAPCTL_DEPENDENCY_MISSING
+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
+    """
+    SUBCOMMANDS = ['attach']
+    SSH_FILE = 'id_snapser_byows_attach_ed25519'
+    PORT_FORWARD_TTL = 3600 * 24 * 7
+    BYOWS_ENV_FILE = 'byows_env_setup'
+
+    def __init__(
+            self, *, subcommand: str, base_url: str, base_snapend_url: str, api_key: Union[str, None],
+            snapend_id: Union[str, None] = None, byosnap_id: Union[str, None] = None,
+            http_port: Union[int, None] = None, grpc_port: Union[int, None] = None,
+
+    ) -> None:
+        self.subcommand: str = subcommand
+        self.base_url: str = base_url
+        self.base_snapend_url: str = base_snapend_url
+        self.api_key: Union[str, None] = api_key
+        self.snapend_id: Union[str, None] = snapend_id
+        self.byosnap_id: Union[str, None] = byosnap_id
+        self.http_port: Union[int, None] = http_port
+        self.grpc_port: Union[int, None] = grpc_port
+        self.validate_input()
+
+    def validate_input(self) -> None:
+        """
+          Validator
+        """
+        # Check API Key and Base URL
+        if not self.api_key or self.base_url == '':
+            snapctl_error(
+                message="Missing API Key.", code=SNAPCTL_INPUT_ERROR)
+        # Check subcommand
+        if not self.subcommand in Byows.SUBCOMMANDS:
+            snapctl_error(
+                message="Invalid command. Valid commands are " +
+                f"{', '.join(Byows.SUBCOMMANDS)}.",
+                code=SNAPCTL_INPUT_ERROR)
+        # Check sdk-download commands
+        if self.subcommand == 'attach':
+            if not shutil.which("ssh"):
+                snapctl_error("ssh is not installed or not in PATH",
+                              SNAPCTL_DEPENDENCY_MISSING)
+            if self.snapend_id is None or self.snapend_id == '':
+                snapctl_error(
+                    message="Missing Input --snapend-id=$your_snapend_id",
+                    code=SNAPCTL_INPUT_ERROR)
+            if self.byosnap_id is None or self.byosnap_id == '':
+                snapctl_error(
+                    message="Missing Input --byosnap-id=$your_byosnap_id",
+                    code=SNAPCTL_INPUT_ERROR)
+            if self.http_port is None and self.grpc_port is None:
+                snapctl_error(
+                    message="Missing Input. One of --http-port=$your_local_server_port or --grpc-port=$your_local_server_port is required.",
+                    code=SNAPCTL_INPUT_ERROR)
+            
+
+    # Static methods
+    @staticmethod
+    def stream_output(pipe):
+        '''
+        Stream the output of a subprocess to the console.
+        This function reads lines from the pipe and prints them to the console.
+        '''
+        for line in iter(pipe.readline, b''):
+            info(line.decode().rstrip())
+
+    @staticmethod
+    def _write_export_command_to_console(snap_ids, port):
+        '''
+        TODO: This is not used anymore
+        Generate export commands for the given snap IDs and port.
+        '''
+        env_vars = []
+
+        for snap_id in snap_ids:
+            upper_id = snap_id.upper()
+            env_vars.append(f"SNAPEND_{upper_id}_GRPC_URL=localhost:{port}")
+            env_vars.append(
+                f"SNAPEND_{upper_id}_HTTP_URL=http://localhost:{port}")
+
+        system = platform.system()
+
+        if system == "Windows":
+            # PowerShell syntax
+            return "; ".join([f'$env:{env_vars[i].replace("=", " = ")}; $env:{env_vars[i+1].replace("=", " = ")}'
+                              for i in range(0, len(env_vars), 2)])
+        else:
+            # Linux or macOS bash/zsh syntax
+            return "export \\\n" + " \\\n".join([f"  {env_vars[i]} {env_vars[i+1]}"
+                                                for i in range(0, len(env_vars), 2)])
+
+    @staticmethod
+    def _generate_env_file(snap_ids, port):
+        '''
+        Generate an environment file with the given snap IDs and port.
+        '''
+        env_lines = []
+
+        for snap_id in snap_ids:
+            upper_id = snap_id.upper()
+            env_lines.append(
+                f"export SNAPEND_{upper_id}_GRPC_URL=localhost:{port}")
+            env_lines.append(
+                f"export SNAPEND_{upper_id}_HTTP_URL=http://localhost:{port}")
+
+        system = platform.system()
+        filename = f"{Byows.BYOWS_ENV_FILE}.ps1" if system == "Windows" else \
+            f"{Byows.BYOWS_ENV_FILE}.sh"
+        env_file = get_dot_snapser_dir() / filename
+
+        with env_file.open("w") as f:
+            if system == "Windows":
+                for line in env_lines:
+                    var, value = line.replace("export ", "").split("=", 1)
+                    f.write(f'$env:{var} = "{value}"\n')
+            else:
+                for line in env_lines:
+                    f.write(f"{line}\n")
+
+        return env_file
+
+    @staticmethod
+    def _generate_env(snap_ids, port):
+        '''
+        Generate environment variables for the given snap IDs and port.
+        '''
+        env_file = Byows._generate_env_file(snap_ids, port)
+        info(f"Environment variables written to {env_file}")
+        system = platform.system()
+        if system == "Windows":
+            info(
+                f"Run the following command to set them in your session:\n\n    . {env_file}\n")
+        else:
+            info(
+                f"Run the following command to set them in your shell:\n\n    source {env_file}\n")
+
+    @staticmethod
+    def _format_portal_http_error(msg, http_err, response):
+        """
+        Format a portal HTTP error response for display.
+        Args:
+            http_err: The HTTPError exception.
+            response: The HTTP response object.
+        Returns:
+            str: A nicely formatted error message.
+        """
+        try:
+            # Check if the response content is JSON-like
+            # FIXME: The portal should always return application/json for errors, but doesn't.
+            if response.text.strip().startswith('{'):
+                error_data = response.json()
+                api_error_code = error_data.get(
+                    "api_error_code", "Unknown Code")
+                message = error_data.get("message", "No message provided")
+                details = error_data.get("details", [])
+                if details:
+                    details_str = "\n  - " + "\n  - ".join(details)
+                else:
+                    details_str = ""
+                return (
+                    f"Message: {msg}\n"
+                    f"Exception: {http_err}\n"
+                    f"Snapser Error Code: {api_error_code}\n"
+                    f"Error: {message}{details_str}"
+                )
+        except Exception:
+            pass  # Fallback to default error formatting if parsing fails
+
+        # Default error message if not JSON or parsing fails
+        return f"HTTP Error {http_err.response.status_code}: {http_err.response.reason}\nResponse: {response.text.strip()}"
+
+    # Private methods
+    def _setup_port_forward(
+            self, private_key, public_key, snapend_id, snap_id, port, reverse_port, reverse_grpc_port,
+            incoming_http, incoming_grpc, outgoing_http, snap_ids, ssh_connect_addr) -> bool:
+        '''
+        Setup the SSH port forward
+        '''
+        dot_snapser_dir = get_dot_snapser_dir()
+        id_file = dot_snapser_dir / Byows.SSH_FILE
+        pub_file = dot_snapser_dir / f'{Byows.SSH_FILE}.pub'
+
+        # Write public and private key files
+        with open(id_file, 'w') as f:
+            f.write(private_key)
+            if os.name != 'nt':
+                # Only chmod on Unix-like systems
+                os.chmod(id_file, 0o600)
+
+        # write the public key
+        with open(pub_file, 'w') as f:
+            f.write(public_key)
+
+        # Let user know about the forwarding
+        # TODO: AJ, needs to be the proper base url
+        info(f"Forwarding {self.base_snapend_url}/{snapend_id}/v1/{snap_id}" +
+             f"-> http://localhost:{incoming_http}/*")
+        info(
+            f"Your BYOSnap HTTP server should listen on: localhost:{incoming_http}")
+        info(
+            f"Connect to other snaps over HTTP on: localhost:{outgoing_http}")
+        Byows._generate_env(snap_ids, port)
+        info('Press <ctrl-c> to stop forwarding')
+
+        # TODO: ??? AJ get the ssh host for the current environ from BYOWS_SSH_HOSTS contact in endpoints.py
+        ssh_addr = ssh_connect_addr
+        if not ssh_addr:
+            snapctl_error(message=f"{env} is missing or empty in BYOWS_SSH_HOSTS", code=SNAPCTL_INPUT_ERROR)
+
+        # Extract the port from the ssh_addr if present, otherwise default to 22
+        if ':' in ssh_addr:
+            ssh_host, ssh_port = ssh_addr.split(':')
+            ssh_port = int(ssh_port)
+        else:
+            ssh_host = ssh_addr
+            ssh_port = 22
+
+        ssh_command = [
+            'ssh',
+            '-o', 'ServerAliveInterval=60',
+            '-o', 'StrictHostKeyChecking=no',
+            '-o', 'UserKnownHostsFile=/dev/null',
+            '-p', str(ssh_port),
+            '-i', str(id_file),
+            '-N',
+            '-L', f'{outgoing_http}:localhost:{port}',
+            '-R', f'{reverse_port}:localhost:{incoming_http}',
+        ]
+        if incoming_grpc:
+            ssh_command += ['-R', f'{reverse_grpc_port}:localhost:{incoming_grpc}']
+        ssh_command += [ssh_host]
+
+        # print(f'Running SSH command: {ssh_command}')
+        process = None
+        try:
+            process = subprocess.Popen(
+                ssh_command,
+                shell=False,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE
+            )
+
+            # Give it a few seconds to report any immediate errors
+            timeout_seconds = 5
+            start_time = time.time()
+            while True:
+                if process.poll() is not None:
+                    # Process exited early — likely an error
+                    stderr_output = process.stderr.read().decode().strip()
+                    if stderr_output:
+                        info(f"[SSH Error] {stderr_output}")
+                    else:
+                        warning("SSH process exited unexpectedly with no output.")
+                    return False
+
+                if time.time() - start_time > timeout_seconds:
+                    break
+
+                time.sleep(0.2)
+
+            # Start background thread to stream live stderr
+            threading.Thread(target=Byows.stream_output, args=(
+                process.stderr,), daemon=True).start()
+
+            # Now block for the full tunnel lifetime
+            process.wait(timeout=Byows.PORT_FORWARD_TTL)
+        except KeyboardInterrupt:
+            process.terminate()
+            try:
+                process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                warning('SSH process did not shut down gracefully.')
+
+            info('Shutting down port forward...')
+
+            try:
+                url = f"{self.base_url}/v1/snapser-api/byows/snapends/" + \
+                    f"{self.snapend_id}/snaps/{self.byosnap_id}/enabled"
+                res = requests.put(
+                    url, headers={'api-key': self.api_key}, json=False, timeout=SERVER_CALL_TIMEOUT)
+                res.raise_for_status()
+                info('Forwarding disabled')
+            except HTTPError as http_err:
+                snapctl_error(
+                    message=Byows._format_portal_http_error(
+                        "Unable to disable BYOWs", http_err, res),
+                    code=SNAPCTL_BYOWS_GENERIC_ERROR
+                )
+                return False
+            except RequestException as req_err:
+                warning(
+                    f"Response Status Code: {res.status_code}, Body: {res.text}")
+                snapctl_error(
+                    message=f"Request Exception: Unable to disable BYOWs {req_err}",
+                    code=SNAPCTL_BYOWS_GENERIC_ERROR
+                )
+                return False
+            except Exception as e:
+                snapctl_error(
+                    message=f"Unexpected error occurred: {e}",
+                    code=SNAPCTL_BYOWS_GENERIC_ERROR
+                )
+                return False
+
+        except Exception as e:
+            print('Error running SSH command:', e)
+            return False
+        finally:
+            # Cleanup the SSH key files
+            # Only remove the files if they exist
+            try:
+                id_file.unlink()
+                pub_file.unlink()
+            except Exception as e:
+                warning(
+                    f"Cleanup warning: Failed to delete SSH key files – {e}")
+        return True
+
+    # Commands
+    def attach(self) -> bool:
+        """
+          BYOWs port forward
+        """
+        progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        )
+        progress.start()
+        progress.add_task(
+            description='Setting up BYOWs port forward...', total=None)
+        try:
+            url = f"{self.base_url}/v1/snapser-api/byows/snapends/" + \
+                f"{self.snapend_id}/snaps/{self.byosnap_id}"
+            res = requests.put(
+                url,
+                headers={'api-key': self.api_key},
+                json={
+                    "snapend_id": self.snapend_id,
+                    "snap_id": self.byosnap_id
+                },
+                timeout=SERVER_CALL_TIMEOUT
+            )
+            res.raise_for_status()
+            response_json = res.json()
+
+            # For debugging
+            #print(f"BYOWS Response:\n{json.dumps(response_json, indent=2)}")
+
+            if res.ok and 'workstationPort' in response_json and \
+               'workstationReversePort' in response_json and \
+               'snapendId' in response_json and \
+               'proxyPrivateKey' in response_json and \
+               'proxyPublicKey' in response_json:
+
+                # We do not use the workstationReversePort now, we ask the user
+                # to provide the port they want to use
+                # incoming_http_port = response_json['workstationReversePort']
+                incoming_http_port = self.http_port
+                incoming_grpc_port = self.grpc_port
+
+                outgoing_http_port = response_json['workstationPort']
+
+                self._setup_port_forward(
+                    response_json['proxyPrivateKey'],
+                    response_json['proxyPublicKey'],
+                    response_json['snapendId'],
+                    response_json['snapId'],
+                    response_json['workstationPort'],
+                    response_json['workstationReversePort'],
+                    response_json['workstationReverseGrpcPort'],
+                    incoming_http_port,
+                    incoming_grpc_port,
+                    outgoing_http_port,
+                    response_json['snapIds'],
+                    response_json['sshConnectAddr'],
+                )
+                return snapctl_success(
+                    message='complete', progress=progress)
+            snapctl_error(
+                message='Unable to setup port forward.',
+                code=SNAPCTL_BYOWS_GENERIC_ERROR, progress=progress)
+        except HTTPError as http_err:
+            snapctl_error(
+                message=Byows._format_portal_http_error(
+                    "Unable to setup port forward", http_err, res),
+                code=SNAPCTL_BYOWS_GENERIC_ERROR, progress=progress)
+            snapctl_error(
+                message=f"Server Error: Unable to setup port forward {http_err}",
+                code=SNAPCTL_BYOWS_GENERIC_ERROR, progress=progress)
+        except RequestException as e:
+            snapctl_error(
+                message=f"Exception: Unable to setup port forward {e}",
+                code=SNAPCTL_BYOWS_GENERIC_ERROR, progress=progress)
+        finally:
+            progress.stop()
+        snapctl_error(
+            message='Failed to setup port forward.',
+            code=SNAPCTL_BYOWS_GENERIC_ERROR, progress=progress)

snapctl/commands/game.py

@@ -40,7 +40,7 @@ class Game:
         # Check subcommand
         if not self.subcommand in Game.SUBCOMMANDS:
             snapctl_error(
-                message="Invalid command. Valid commands are" +
+                message="Invalid command. Valid commands are " +
                 f"{', '.join(Game.SUBCOMMANDS)}.",
                 code=SNAPCTL_INPUT_ERROR)
         # Check sdk-download commands

snapctl/commands/release_notes.py

@@ -1,8 +1,9 @@
 """
-  Release Notes Command
+  Release Notes
 """
-import os
 from typing import Union
+import importlib.resources as pkg_resources
+import snapctl.data.releases  # must have __init__.py under releases
 from snapctl.config.constants import SNAPCTL_INPUT_ERROR
 from snapctl.utils.helper import snapctl_error, snapctl_success
 
@@ -12,7 +13,6 @@ class ReleaseNotes:
     Release Notes Command
     """
     SUBCOMMANDS = ["releases", "show"]
-    RELEASES_PATH = 'snapctl/data/releases'
 
     def __init__(self, *, subcommand: str, version: Union[str, None] = None) -> None:
         self.subcommand = subcommand
@@ -29,19 +29,15 @@ class ReleaseNotes:
                 f"{', '.join(ReleaseNotes.SUBCOMMANDS)}.",
                 code=SNAPCTL_INPUT_ERROR)
 
-    # Upper echelon commands
     def releases(self) -> None:
         """
         List versions
         """
-        # List all files and directories in the specified path
-        files_and_directories = os.listdir(ReleaseNotes.RELEASES_PATH)
-
-        # Print only files, excluding subdirectories
         print('== Releases ' + '=' * (92))
-        for item in files_and_directories:
-            if os.path.isfile(os.path.join(ReleaseNotes.RELEASES_PATH, item)):
-                print(item.replace('.mdx', '').replace('.md', ''))
+        # List all resource files in snapctl.data.releases
+        for resource in pkg_resources.contents(snapctl.data.releases):
+            if resource.endswith('.mdx'):
+                print(resource.replace('.mdx', '').replace('.md', ''))
         print('=' * (104))
         snapctl_success(message="List versions")
 
@@ -49,17 +45,15 @@ class ReleaseNotes:
         """
         Show version
         """
-        # Check if the specified version exists
-        version_file = os.path.join(
-            ReleaseNotes.RELEASES_PATH, f'{self.version}.mdx')
-        if not os.path.isfile(version_file):
+        version_filename = f"{self.version}.mdx"
+
+        if version_filename not in pkg_resources.contents(snapctl.data.releases):
             snapctl_error(
                 message=f"Version {self.version} does not exist.",
                 code=SNAPCTL_INPUT_ERROR)
 
-        # Read the contents of the specified version file
-        print('== Releases Notes ' + '=' * (86))
-        with open(version_file, 'r') as file:
+        print('== Release Notes ' + '=' * (86))
+        with pkg_resources.open_text(snapctl.data.releases, version_filename) as file:
             print(file.read())
         print('=' * (104))
         snapctl_success(message=f"Show version {self.version}")

snapctl/commands/snapend.py

@@ -37,7 +37,9 @@ class Snapend:
     DOWNLOAD_CATEGORY = [
         'sdk', 'protos', 'snapend-manifest'
     ]
-    CATEGORY_TYPE_SDK = ['user', 'server', 'internal', 'app']
+    CATEGORY_TYPE_SDK = [
+        # 'omni',
+        'user', 'api-key', 'internal', 'app']
     CATEGORY_TYPE_PROTOS = ['messages', 'services']
     # CATEGORY_TYPE_HTTP_LIB_FORMATS = ['unity', 'web-ts', 'ts']
 
@@ -412,26 +414,26 @@ class Snapend:
                     )
                 # Special cases for client SDKs
                 if self.category_format in CLIENT_SDK_TYPES:
-                    if self.category_type in ['server', 'app']:
+                    if self.category_type in ['api-key', 'app', 'internal']:
                         snapctl_error(
                             message="Invalid combination of format and type. " +
                             ", ".join(CLIENT_SDK_TYPES.keys()) +
+                            # " SDKs are only available for --type=omni or --type=user",
                             " SDKs are only available for --type=user",
                             code=SNAPCTL_INPUT_ERROR
                         )
-                    if self.category_type == 'internal':
-                        snapctl_error(
-                            message="Internal access type is not supported for " +
-                            ", ".join(CLIENT_SDK_TYPES.keys()) + " SDKs.",
-                            code=SNAPCTL_INPUT_ERROR
-                        )
+                    # if self.category_type == 'internal':
+                    #     snapctl_error(
+                    #         message="Internal access type is not supported for " +
+                    #         ", ".join(CLIENT_SDK_TYPES.keys()) + " SDKs.",
+                    #         code=SNAPCTL_INPUT_ERROR
+                    #     )
                 if self.category_http_lib:
                     # First check if the format supports http-lib
                     if self.category_format in Snapend.get_formats_supporting_http_lib():
                         # Check if the http-lib is supported for the format
                         valid_http_libs = SDK_TYPES[self.category_format]['http-lib']
                         if self.category_http_lib not in valid_http_libs:
-                            print('Caught you')
                             snapctl_error(
                                 message="Invalid HTTP Library. Valid libraries are " +
                                 Snapend.get_http_formats_str(),

snapctl/config/constants.py

@@ -3,7 +3,7 @@ Constants used by snapctl
 """
 COMPANY_NAME = 'Snapser'
 VERSION_PREFIX = 'beta-'
-VERSION = '0.48.1'
+VERSION = '0.49.0'
 CONFIG_FILE_MAC = '~/.snapser/config'
 CONFIG_FILE_WIN = '%homepath%\\.snapser\\config'
 
@@ -50,7 +50,7 @@ SNAPCTL_BYOGS_PUBLISH_ERROR = 25
 SNAPCTL_BYOGS_PUBLISH_PERMISSION_ERROR = 26
 SNAPCTL_BYOGS_PUBLISH_DUPLICATE_TAG_ERROR = 27
 
-# BYOSNAP Errors - 30 - 49 then 86 - 99
+# BYOSNAP Errors - 30 - 49 then 86 - 90
 SNAPCTL_BYOSNAP_NOT_FOUND = SNAPCTL_RESOURCE_NOT_FOUND
 SNAPCTL_BYOSNAP_GENERIC_ERROR = 30
 SNAPCTL_BYOSNAP_DEPENDENCY_MISSING = 31
@@ -108,3 +108,6 @@ SNAPCTL_SNAPEND_APPLY_MANIFEST_MISMATCH_ERROR = 76
 # Generate Errors - 80 - 85
 SNAPCTL_GENERATE_GENERIC_ERROR = 80
 SNAPCTL_GENERATE_CREDENTIALS_ERROR = 81
+
+# BYOWs Errors - 95 - 99
+SNAPCTL_BYOWS_GENERIC_ERROR = 95

snapctl/config/endpoints.py

@@ -9,3 +9,8 @@ END_POINTS: Dict[str, str] = {
     'PLAYTEST': 'https://gateway.dev.snapser.io/playtest',
     'PROD': 'https://gateway.snapser.com/snapser'
 }
+
+GATEWAY_END_POINTS: Dict[str, str] = {
+    'SANDBOX': 'https://gateway.dev.snapser.io',
+    'LIVE': 'https://gateway-accel.snapser.com',
+}

snapctl/config/hashes.py

@@ -189,11 +189,15 @@ SERVICE_IDS: List[str] = [
 ]
 
 SDK_ACCESS_AUTH_TYPE_LOOKUP: Dict[str, Dict[str, str]] = {
+    # 'omni': {
+    #     'access_type': 'external',
+    #     'auth_type': 'omni'
+    # },
     'user': {
         'access_type': 'external',
         'auth_type': 'user'
     },
-    'server': {
+    'api-key': {
         'access_type': 'external',
         'auth_type': 'api-key'
     },