snapctl 0.48.0__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

@@ -18,7 +18,8 @@ from snapctl.config.constants import SERVER_CALL_TIMEOUT, SNAPCTL_INPUT_ERROR, \
     SNAPCTL_SNAPEND_APPLY_ERROR, SNAPCTL_SNAPEND_PROMOTE_SERVER_ERROR, \
     SNAPCTL_SNAPEND_PROMOTE_TIMEOUT_ERROR, SNAPCTL_SNAPEND_PROMOTE_ERROR, \
     SNAPCTL_SNAPEND_DOWNLOAD_ERROR, SNAPCTL_SNAPEND_UPDATE_TIMEOUT_ERROR, \
-    SNAPCTL_SNAPEND_UPDATE_ERROR, SNAPCTL_SNAPEND_STATE_ERROR
+    SNAPCTL_SNAPEND_UPDATE_ERROR, SNAPCTL_SNAPEND_STATE_ERROR, HTTP_ERROR_SNAPEND_MANIFEST_MISMATCH, \
+    SNAPCTL_SNAPEND_APPLY_MANIFEST_MISMATCH_ERROR
 from snapctl.config.hashes import PROTOS_TYPES, CLIENT_SDK_TYPES, SERVER_SDK_TYPES, \
     SNAPEND_MANIFEST_TYPES, SDK_TYPES, SDK_ACCESS_AUTH_TYPE_LOOKUP
 from snapctl.utils.echo import error, success, info
@@ -36,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']
 
@@ -57,6 +60,7 @@ class Snapend:
         env: Union[str, None] = None,
         # Clone, Apply, Promote
         manifest_path_filename: Union[str, None] = None,
+        force: bool = False,
         # Download
         category: Union[str, None] = None,
         category_format: Union[str, None] = None,
@@ -78,6 +82,7 @@ class Snapend:
         self.name: str = name
         self.env: str = env
         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)
@@ -409,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(),
@@ -598,14 +603,17 @@ class Snapend:
                 payload = {
                     'ext': self.manifest_file_name.split('.')[-1]
                 }
+                if self.force is True:
+                    info('Force flag is set. Ignoring manifest diff.')
+                    payload['ignore_diff'] = 'true'
                 url = f"{self.base_url}/v1/snapser-api/snapends/snapend-manifest"
                 res = requests.put(
                     url, headers={'api-key': self.api_key},
                     files=files, data=payload, timeout=SERVER_CALL_TIMEOUT
                 )
+                response = res.json()
                 if res.ok:
                     # extract the cluster ID
-                    response = res.json()
                     if 'cluster' not in response or 'id' not in response['cluster']:
                         snapctl_error(
                             message='Server Error. Unable to get a Snapend ID. '
@@ -643,6 +651,13 @@ class Snapend:
                         f"{response['cluster']['id']}`",
                         progress=progress
                     )
+                else:
+                    if "api_error_code" in response and "message" in response:
+                        if response['api_error_code'] == HTTP_ERROR_SNAPEND_MANIFEST_MISMATCH:
+                            snapctl_error(
+                                message='Remote manifest does not match the manifest in the applied_configuration field.',
+                                code=SNAPCTL_SNAPEND_APPLY_MANIFEST_MISMATCH_ERROR, progress=progress
+                            )
         except RequestException as e:
             snapctl_error(
                 message=f"Unable to apply the manifest snapend. {e}",