pyntcli 0.1.89__py3-none-any.whl → 0.1.91__py3-none-any.whl

pyntcli/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.89"
+__version__ = "0.1.91"

pyntcli/analytics/send.py

@@ -39,6 +39,7 @@ def set_user_id(user_id):
 CLI_START = "cli_start"
 LOGIN_START = "cli_login_start"
 LOGIN_DONE = "cli_login_done"
+DOCKER_NATIVE_FLAG = "docker_native_flag"
 CICD = "CI/CD"
 ERROR = "error"
 DOCKER_PLATFORM = "platform"

pyntcli/commands/burp.py

@@ -19,6 +19,9 @@ from pyntcli.commands import util, sub_command
 from pyntcli.ui import report as cli_reporter
 from pyntcli.transport import pynt_requests
 
+PYNT_CONTAINER_INTERNAL_PORT = "5001"
+PYNT_CONTAINER_INTERNAL_PROXY_PORT = "6666"
+
 methods = [
     "get",
     "post",
@@ -62,7 +65,7 @@ def decode_request(item) -> str:
     raise e
 
 
-def replay_req(session, item, proxy_port):
+def replay_req(item, proxy_port):
     url = item["url"]
     if not util.is_http_handler(url):
         return None
@@ -91,9 +94,7 @@ def replay_req(session, item, proxy_port):
         headers[key] = value
 
     body = decoded_req.split("\r\n\r\n")[1]
-    ui_thread.print(ui_thread.PrinterText(f"{url}"))
-    pynt_requests.request_from_xml(
-        session=session,
+    resp = pynt_requests.request_from_xml(
         method=method,
         url=url,
         headers=headers,
@@ -103,16 +104,16 @@ def replay_req(session, item, proxy_port):
             "https": "127.0.0.1:{}".format(proxy_port),
         },
     )
+    ui_thread.print(ui_thread.PrinterText(resp))
 
 
 def run_burp_xml(doc, proxy_port):
     items = doc["items"]["item"]
     ui_thread.print(ui_thread.PrinterText("Creating traffic from xml file"))
-    session = pynt_requests.get_new_session()
     if isinstance(items, dict):
-        replay_req(session, item=items, proxy_port=proxy_port)
+        replay_req(item=items, proxy_port=proxy_port)
     else:
-        [replay_req(session, i, proxy_port=proxy_port) for i in doc["items"]["item"]]
+        [replay_req(i, proxy_port=proxy_port) for i in doc["items"]["item"]]
 
 
 def parse_xml(xml_path):
@@ -232,10 +233,8 @@ class BurpCommand(sub_command.PyntSubCommand):
     def run_cmd(self, args: argparse.Namespace):
         container = pynt_container.get_container_with_arguments(
             args,
-            pynt_container.PyntDockerPort(args.port, args.port, "--port"),
-            pynt_container.PyntDockerPort(
-                args.proxy_port, args.proxy_port, "--proxy-port"
-            ),
+            pynt_container.PyntDockerPort(PYNT_CONTAINER_INTERNAL_PORT, args.port, "--port"),
+            pynt_container.PyntDockerPort(PYNT_CONTAINER_INTERNAL_PROXY_PORT, args.proxy_port, "--proxy-port"),
         )
 
         for host in args.captured_domains:
@@ -295,7 +294,8 @@ class BurpCommand(sub_command.PyntSubCommand):
             tag="proxy-latest",
             detach=True,
             base_container=container,
-        )
+            use_native=args.use_docker_native)
+
         proxy_docker.run()
         ui_thread.print_generator(proxy_docker.stdout)
 

pyntcli/commands/command.py

@@ -15,6 +15,9 @@ from pyntcli.commands import util, sub_command
 from pyntcli.ui import report as cli_reporter
 from pyntcli.transport import pynt_requests
 
+PYNT_CONTAINER_INTERNAL_PORT = "5001"
+PYNT_CONTAINER_INTERNAL_PROXY_PORT = "6666"
+
 
 def command_usage():
     return (
@@ -133,10 +136,8 @@ class CommandSubCommand(sub_command.PyntSubCommand):
     def run_cmd(self, args: argparse.Namespace):
         container = pynt_container.get_container_with_arguments(
             args,
-            pynt_container.PyntDockerPort(args.port, args.port, "--port"),
-            pynt_container.PyntDockerPort(
-                args.proxy_port, args.proxy_port, "--proxy-port"
-            ),
+            pynt_container.PyntDockerPort(PYNT_CONTAINER_INTERNAL_PORT, args.port, "--port"),
+            pynt_container.PyntDockerPort(PYNT_CONTAINER_INTERNAL_PROXY_PORT, args.proxy_port, "--proxy-port"),
         )
 
         if args.captured_domains:
@@ -169,7 +170,8 @@ class CommandSubCommand(sub_command.PyntSubCommand):
             tag="proxy-latest",
             detach=True,
             base_container=container,
-        )
+            use_native=args.use_docker_native)
+
         proxy_docker.run()
         ui_thread.print_generator(proxy_docker.stdout)
 

pyntcli/commands/har.py

@@ -10,6 +10,7 @@ from pyntcli.commands import sub_command, util
 
 PYNT_CONTAINER_INTERNAL_PORT = "5001"
 
+
 def har_usage():
     return (
         ui_thread.PrinterText("Integration with static har file testing")
@@ -88,7 +89,7 @@ class HarSubCommand(sub_command.PyntSubCommand):
                 tag="har-latest",
                 detach=True,
                 base_container=container,
-            )
+                use_native=args.use_docker_native)
 
             har_docker.run()
 

pyntcli/commands/listen.py

@@ -15,6 +15,9 @@ from pyntcli.commands import util, sub_command
 from pyntcli.ui import report as cli_reporter
 from pyntcli.transport import pynt_requests
 
+PYNT_CONTAINER_INTERNAL_PORT = "5001"
+PYNT_CONTAINER_INTERNAL_PROXY_PORT = "6666"
+
 
 def listen_usage():
     return (
@@ -105,8 +108,8 @@ class ListenSubCommand(sub_command.PyntSubCommand):
     def run_cmd(self, args: argparse.Namespace):
         container = pynt_container.get_container_with_arguments(
             args,
-            pynt_container.PyntDockerPort(args.port, args.port, "--port"),
-            pynt_container.PyntDockerPort(args.proxy_port, args.proxy_port, "--proxy-port"))
+            pynt_container.PyntDockerPort(PYNT_CONTAINER_INTERNAL_PORT, args.port, "--port"),
+            pynt_container.PyntDockerPort(PYNT_CONTAINER_INTERNAL_PROXY_PORT, args.proxy_port, "--proxy-port"))
 
         for host in args.captured_domains:
             container.docker_arguments += ["--host-targets", host]

pyntcli/commands/newman.py

@@ -10,6 +10,7 @@ from pyntcli.ui.progress import PyntProgress
 
 PYNT_CONTAINER_INTERNAL_PORT = "5001"
 
+
 def newman_usage():
     return (
         ui_thread.PrinterText(
@@ -61,6 +62,7 @@ class NewmanSubCommand(sub_command.PyntSubCommand):
         return newman_cmd
 
     def run_cmd(self, args: argparse.Namespace):
+
         port = util.find_open_port()
         container = pynt_container.get_container_with_arguments(
             args, pynt_container.PyntDockerPort(src=PYNT_CONTAINER_INTERNAL_PORT, dest=port, name="--port")
@@ -107,12 +109,11 @@ class NewmanSubCommand(sub_command.PyntSubCommand):
             container.mounts += m
             newman_docker = pynt_container.PyntContainer(
                 image_name=pynt_container.PYNT_DOCKER_IMAGE,
-                tag="latest",
+                tag="newman-latest",
                 detach=True,
                 base_container=container,
-            )
+                use_native=args.use_docker_native)
             newman_docker.run()
-
             healthcheck = partial(
                 util.wait_for_healthcheck, "http://localhost:{}".format(port)
             )

pyntcli/commands/postman.py

@@ -14,6 +14,8 @@ from pyntcli.pynt_docker import pynt_container
 from pyntcli.ui import ui_thread
 from pyntcli.transport import pynt_requests
 
+PYNT_CONTAINER_INTERNAL_PORT = "5001"
+
 
 class PyntPostmanException(Exception):
     pass
@@ -93,12 +95,13 @@ class PostmanSubCommand(sub_command.PyntSubCommand):
             ui_thread.print("application-id is not supported in postman integration, use the collection variables to set application id.")
             args.application_id = ""
 
-        container = pynt_container.get_container_with_arguments(args, pynt_container.PyntDockerPort("5001", args.port, name="--port"))
+        container = pynt_container.get_container_with_arguments(args, pynt_container.PyntDockerPort(PYNT_CONTAINER_INTERNAL_PORT, args.port, name="--port"))
 
         postman_docker = pynt_container.PyntContainer(image_name=pynt_container.PYNT_DOCKER_IMAGE,
                                                       tag="postman-latest",
                                                       detach=True,
-                                                      base_container=container)
+                                                      base_container=container,
+                                                      use_native=args.use_docker_native)
 
         postman_docker.run()
         ui_thread.print_generator(postman_docker.stdout)

pyntcli/commands/pynt_cmd.py

@@ -51,6 +51,9 @@ python3 -m pip install --upgrade pyntcli""", ui_thread.PrinterText.WARNING))
         ui_thread.print(ui_thread.PrinterText("""Error: Unable to check if Pynt CLI version is up-to-date due to VPN/proxy. Run Pynt with --insecure to fix.""", ui_thread.PrinterText.WARNING))
     except HTTPError:
         ui_thread.print("""Unable to check if Pynt CLI version is up-to-date""")
+    except Exception as e:
+        ui_thread.print(ui_thread.PrinterText("""We could not check for updates.""", ui_thread.PrinterText.WARNING))
+        pass
 
 
 class PyntCommand:

pyntcli/commands/root.py

@@ -75,6 +75,11 @@ class BaseCommand:
             action="store_true",
             help="use to get more detailed execution information",
         )
+        parser.add_argument(
+            "--use-docker-native",
+            action="store_true",
+            help="Use native docker instead of docker sdk"
+        )
 
     def get_subparser(self) -> argparse._SubParsersAction:
         if self.subparser is None:

pyntcli/commands/util.py

@@ -41,6 +41,7 @@ def wait_for_healthcheck(address):
     while start + HEALTHCHECK_TIMEOUT > time.time():
         try:
             res = pynt_requests.get(address + "/healthcheck")
+
             logger.debug("Health check response: {}".format(res.status_code))
             if res.status_code == 418:
                 return

pyntcli/main.py

@@ -21,7 +21,7 @@ from pyntcli.store import CredStore
 
 def shutdown_cli():
     analytics.stop()
-    pynt_container.PyntContainerRegistery.instance().stop_all_containers()
+    pynt_container.PyntContainerRegistry.instance().stop_all_containers()
     ui_thread.stop()
 
 
@@ -33,8 +33,11 @@ def signal_handler(signal_number, frame):
     exit(0)
 
 
-def assert_docker_availability():
-    pynt_container.get_docker_type()
+def get_docker_platform_name(use_docker_native: bool = False) -> str:
+    if use_docker_native:
+        return pynt_container.get_docker_type_native()
+
+    return pynt_container.get_docker_type()
 
 
 def print_header():
@@ -68,17 +71,25 @@ def main():
         if len(argv) == 1:
             pynt_cmd.root.usage()
             return
+
         if argv[1] == "logout":
             logout()
             return
-        if [n for n in argv if "--verbose" in n]:
+
+        if "--verbose" in argv:
             ui_thread.VERBOSE = True
+
+        use_docker_native = True if "--use-docker-native" in argv else False
+        if use_docker_native:
+            analytics.emit(analytics.DOCKER_NATIVE_FLAG, {"message": "using docker native flag"})
+
         log.set_source(__version__)
         ui_thread.print_verbose("Logging in...")
         user_id = login.user_id()
         start_analytics(user_id)
         ui_thread.print_verbose("Asserting docker is properly installed")
-        assert_docker_availability()
+        platform_name = get_docker_platform_name(use_docker_native)
+        ui_thread.print_verbose("Docker platform: {}".format(platform_name))
         signal.signal(signal.SIGINT, signal_handler)
         cli = pynt_cmd.PyntCommand()
         cli.run_cmd(cli.parse_args(argv[1:]))

pyntcli/pynt_docker/pynt_container.py

@@ -1,7 +1,10 @@
+import platform
+import subprocess
 import docker
 from docker.errors import DockerException, APIError, ImageNotFound
 from docker.types import Mount
 import os
+import json
 import argparse
 from typing import List
 import base64
@@ -24,6 +27,10 @@ class DockerNotAvailableException(Exception):
     pass
 
 
+class DockerNativeUnavailableException(Exception):
+    pass
+
+
 class ImageUnavailableException(Exception):
     pass
 
@@ -34,6 +41,16 @@ class PortInUseException(Exception):
         super().__init__(self.message)
 
 
+def get_docker_type_native():
+    try:
+        version_data = json.loads(subprocess.check_output(["docker", "version", "--format", "{{json .}}"], text=True))
+        platform = version_data.get("Client", {}).get("Platform", {})
+        analytics.deferred_emit(analytics.DOCKER_PLATFORM, platform)
+        return platform.get("Name", "")
+    except Exception:
+        raise DockerNotAvailableException()
+
+
 def get_docker_type():
     try:
         c = docker.from_env()
@@ -51,7 +68,7 @@ def get_docker_type():
         raise DockerNotAvailableException()
 
 
-class PyntBaseConatiner():
+class PyntBaseContainer():
     def __init__(self, docker_type, docker_arguments, mounts, environment={}) -> None:
         self.docker_type = docker_type
         self.docker_arguments = docker_arguments
@@ -66,7 +83,7 @@ class PyntDockerPort:
         self.name = name
 
 
-def get_container_with_arguments(args: argparse.Namespace, *port_args: PyntDockerPort) -> PyntBaseConatiner:
+def get_container_with_arguments(args: argparse.Namespace, *port_args: PyntDockerPort) -> PyntBaseContainer:
     docker_arguments = []
     ports = {}
     for p in port_args:
@@ -110,14 +127,14 @@ def get_container_with_arguments(args: argparse.Namespace, *port_args: PyntDocke
         docker_arguments.append("--verbose")
 
     creds_path = os.path.dirname(CredStore().file_location)
-    mitm_cert_path = os.path.join(creds_path,"cert")
-    os.makedirs(mitm_cert_path,exist_ok=True)
-    mounts.append(create_mount(mitm_cert_path, "/root/.mitmproxy"))           
+    mitm_cert_path = os.path.join(creds_path, "cert")
+    os.makedirs(mitm_cert_path, exist_ok=True)
+    mounts.append(create_mount(mitm_cert_path, "/root/.mitmproxy"))
 
     env = {PYNT_ID: CredStore().get_tokens(), "PYNT_SAAS_URL": PYNT_SAAS}
     if user_set_all_variables():
         add_env_variables(env)
-    return PyntBaseConatiner(docker_type, docker_arguments, mounts, env)
+    return PyntBaseContainer(docker_type, docker_arguments, mounts, env)
 
 
 def _container_image_from_tag(tag: str) -> str:
@@ -137,46 +154,194 @@ def add_env_variables(env: dict):
     env["PYNT_PARAM2"] = base64.b64encode(PYNT_PARAM2.encode('utf-8'))
 
 
-class PyntContainer():
-    def __init__(self, image_name, tag, detach, base_container: PyntBaseConatiner) -> None:
-        self.docker_client: docker.DockerClient = None
-        self.image = image_name if not os.environ.get("IMAGE") else os.environ.get("IMAGE")
-        self.tag = tag if not os.environ.get("TAG") else os.environ.get("TAG")
-        self.detach = detach
+def value_from_environment_variable(key, fallback=""):
+    e = os.environ.get(key)
+
+    if e:
+        ui_thread.print_verbose(f"Using environment variable {key}={e}")
+        return e
+    if fallback != "":
+        ui_thread.print_verbose(f"Using variable {key}={fallback}")
+    return fallback
+
+
+class PyntContainerNative:
+    def __init__(self, image_name, tag, base_container, is_detach=True):
+        self.image_name = value_from_environment_variable("IMAGE", image_name)
+        self.tag = value_from_environment_variable("TAG", tag)
+        self.is_detach = is_detach
+        self.mounts = base_container.mounts
+        self.env_vars = base_container.environment
+        self.base_container = base_container
+        self.container_name = ""
+        self.system = platform.system().lower()
+
         self.stdout = None
         self.running = False
-        self.container_name = ""
-        self.base_container = base_container
 
-    def _create_docker_client(self):
-        self.docker_client = docker.from_env()
-        pat = os.environ.get("DOCKER_PASSWORD")
-        username = os.environ.get("DOCKER_USERNAME")
-        registry = os.environ.get("DOCKER_REGISTRY")
-        if pat and username and registry:
-            self.docker_client.login(username=username, password=pat, registry=registry)
+    def is_alive(self):
+        command = ["docker", "ps", "--filter", f"name={self.container_name}", "--filter", "status=running"]
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True
+        )
+
+        return len(result.stdout.splitlines()) > 1
+
+    def run(self):
+        self.running = True
+        self.kill_other_instances()
+
+        self.get_image()
+        args = self.base_container.docker_arguments if self.base_container.docker_arguments else None
+        docker_command = ["docker", "run"]
+
+        if self.is_detach:
+            docker_command.append("-d")
+
+        mounts = []
+        for mount in self.base_container.mounts:
+            mounts.extend(["-v", f"{mount['Source']}:{mount['Target']}"])
+
+        env_vars = []
+        for key, value in self.base_container.environment.items():
+            env_vars.extend(self.adapt_environment_variable_partial(key, value))
+
+        docker_type_options = []
+        for key, value in self.base_container.docker_type.get_arguments().items():
+            if key == "ports":
+                if isinstance(value, dict):
+                    for s, d in value.items():
+                        # --publish source:destination for each port
+                        docker_type_options.extend([f"-p", f"{s}:{d}"])
+            else:
+                docker_type_options.extend([f"--{key}={value}"])
+
+        docker_command += mounts
+        docker_command += env_vars
+        docker_command += docker_type_options
+        docker_command += [f"{self.image_name}:{self.tag}"]
+        docker_command += args
+
+        command = self.adapt_run_command(docker_command)
+        process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        stdout, stderr = process.communicate()
+
+        if stderr:
+            print(stderr)
 
-    def _is_docker_image_up_to_date(self, image):
-        return True
+        container_id = stdout.strip()
 
-    def _handle_outdated_docker_image(self, image):
-        return image
+        if process.returncode and process.returncode != 0:
+            raise DockerNativeUnavailableException(f"Unable to perform docker run command, return code: {process.returncode}")
+
+        logs_process = subprocess.Popen(
+            ['docker', 'logs', container_id],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+
+        logs_stdout, logs_stderr = logs_process.communicate()
+
+        self.stdout = logs_stdout
 
     def kill_other_instances(self):
-        for c in self.docker_client.containers.list():
-            if len(c.image.tags) and _container_image_from_tag(c.image.tags[0]) == self.image:
-                c.kill()
+        try:
+            ui_thread.print_verbose("Killing other pynt containers if such exist")
+            command = ["docker", "ps", "-q", "-f", f"ancestor={self.image_name}:{self.tag}"]
+            containers_output = subprocess.check_output(command, text=True)
+            if not containers_output:
+                return
+
+            container_ids = containers_output.splitlines()
+            for container_id in container_ids:
+                command = ["docker", "kill", container_id]
+                subprocess.run(command)
+
+        except subprocess.CalledProcessError:
+            analytics.emit(analytics.ERROR, {"error": "Unable to kill other pynt containers"})
+            ui_thread.print(ui_thread.PrinterText("Error: Unable to kill other pynt containers", ui_thread.PrinterText.WARNING))
+
+    def pull_image(self):
+        try:
+            command = ["docker", "pull", f"{self.image_name}:{self.tag}"]
+            subprocess.run(command, capture_output=True, text=True)
+        except subprocess.CalledProcessError:
+            analytics.emit(analytics.ERROR, {"error": "Unable to pull image from ghcr"})
+            ui_thread.print(ui_thread.PrinterText("Error: Docker unable to pull latest Pynt image due to VPN/proxy. If using a mirror for Docker images, visit docs.pynt.io for help.", ui_thread.PrinterText.WARNING))
+            return None
+
+    def get_image(self):
+        try:
+            ui_thread.print(ui_thread.PrinterText("Pulling latest docker image", ui_thread.PrinterText.INFO))
+            command = ['docker', 'pull', f'{self.image_name}:{self.tag}']
+            process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            stdout, stderr = process.communicate()
+
+            if process.returncode != 0:
+                raise ImageUnavailableException(f"Failed to pull image: {stderr.decode().strip()}")
+
+            command = ['docker', 'images', '-q', f'{self.image_name}']
+            process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            stdout, stderr = process.communicate()
+
+            stdout = stdout.decode('utf-8')
+            stderr = stderr.decode('utf-8')
+
+            if stderr:
+                ui_thread.print(ui_thread.PrinterText(f"Error: {stderr}", ui_thread.PrinterText.WARNING))
+                raise ImageUnavailableException("Failed to pull image")
+
+            if process.returncode != 0:
+                raise ImageUnavailableException("Failed to pull image")
+
+            image_id = stdout.strip()
+            return image_id
+        except Exception as e:
+            raise ImageUnavailableException(f"An error occurred: {str(e)}")
 
     def stop(self):
         if not self.running:
             return
-
         self.kill_other_instances()
+        self.running = False
 
-        self.docker_client.close()
-        self.docker_client = None
+    def adapt_run_command(self, docker_command=[]):
+        if self.system == "windows":
+            return ' '.join(docker_command)
+        return docker_command
+
+    def adapt_environment_variable_partial(self, key, value):
+        if self.system == "windows":
+            return ["-e", f"{key}={json.dumps(value)}"]
+        return ["-e", f"{key}={value}"]
+
+
+class PyntContainerSDK:
+    def __init__(self, image_name, tag, base_container, is_detach=True) -> None:
+        self.image_name = value_from_environment_variable("IMAGE", image_name)
+        self.tag = value_from_environment_variable("TAG", tag)
+        self.base_container = base_container
+        self.is_detach = is_detach
+
+        self.mounts = base_container.mounts
+        self.env_vars = base_container.environment
+
+        self.docker_client: docker.DockerClient = None
+        self.container_name = ""
+        self.stdout = None
         self.running = False
 
+    def _initialize(self):
+        self.docker_client = docker.from_env()
+        docker_password = value_from_environment_variable("DOCKER_PASSWORD")
+        docker_username = value_from_environment_variable("DOCKER_USERNAME")
+        docker_registry = value_from_environment_variable("DOCKER_REGISTRY")
+        if docker_password and docker_username and docker_registry:
+            self.docker_client.login(username=docker_username, password=docker_password, registry=docker_registry)
+
     def is_alive(self):
         if not self.docker_client or not self.container_name:
             return False
@@ -187,35 +352,15 @@ class PyntContainer():
 
         return l[0].status == "running"
 
-    def pull_image(self):
-        try:
-            return self.docker_client.images.pull(self.image, tag=self.tag)
-        except APIError as e:
-            analytics.emit(analytics.ERROR, {"error": "Unable to pull image from ghcr: {}".format(e)})
-            ui_thread.print(ui_thread.PrinterText("Error: Docker unable to pull latest Pynt image due to VPN/proxy. If using a mirror for Docker images, visit docs.pynt.io for help.",
-                                                  ui_thread.PrinterText.WARNING))
-            return None
-
-    def get_image(self):
-        try:
-            image = self.pull_image()
-            if not image:
-                ui_thread.print(ui_thread.PrinterText("Trying to get pynt local image", ui_thread.PrinterText.INFO))
-                image = self.docker_client.images.get('{}:{}'.format(self.image, self.tag))
-            return image
-        except ImageNotFound:
-            raise ImageUnavailableException()
-
     def run(self):
         if not self.docker_client:
-            self._create_docker_client()
+            self._initialize()
 
         self.running = True
 
         ui_thread.print_verbose("Killing other pynt containers if such exist")
         self.kill_other_instances()
 
-        ui_thread.print(ui_thread.PrinterText("Pulling latest docker", ui_thread.PrinterText.INFO))
         image = self.get_image()
         ui_thread.print(ui_thread.PrinterText("Docker pull done", ui_thread.PrinterText.INFO))
 
@@ -223,7 +368,7 @@ class PyntContainer():
 
         run_arguments = {
             "image": image,
-            "detach": self.detach,
+            "detach": self.is_detach,
             "mounts": self.base_container.mounts,
             "environment": self.base_container.environment,
             "stream": True,
@@ -231,33 +376,103 @@ class PyntContainer():
             "command": args
         }
 
-        run_arguments.update(self.base_container.docker_type.get_argumets())
+        run_arguments.update(self.base_container.docker_type.get_arguments())
 
         ui_thread.print_verbose("Running pynt docker with arguments:\n {}".format(" ".join(args)))
         c = self.docker_client.containers.run(**run_arguments)
         self.container_name = c.name
         self.stdout = c.logs(stream=True)
 
-        PyntContainerRegistery.instance().register_container(self)
+    def kill_other_instances(self):
+        for c in self.docker_client.containers.list():
+            if len(c.image.tags) and _container_image_from_tag(c.image.tags[0]) == self.image_name:
+                c.kill()
+
+    def pull_image(self):
+        try:
+            return self.docker_client.images.pull(self.image_name, tag=self.tag)
+        except APIError as e:
+            analytics.emit(analytics.ERROR, {"error": "Unable to pull image from ghcr: {}".format(e)})
+            ui_thread.print(ui_thread.PrinterText("Error: Docker unable to pull latest Pynt image due to VPN/proxy. Visit docs.pynt.io for help using a mirror for Docker images.", ui_thread.PrinterText.WARNING))
+            return None
+
+    def get_image(self):
+        ui_thread.print(ui_thread.PrinterText("Pulling latest docker image", ui_thread.PrinterText.INFO))
+        try:
+            image = self.pull_image()
+            if not image:
+                ui_thread.print(ui_thread.PrinterText("Trying to get pynt local image", ui_thread.PrinterText.INFO))
+                image = self.docker_client.images.get(f"{self.image_name}:{self.tag}")
+            return image
+        except ImageNotFound:
+            raise ImageUnavailableException()
+
+    def stop(self):
+        if not self.running:
+            return
+        self.kill_other_instances()
+        self.docker_client.close()
+        self.docker_client = None
+        self.running = False
+
+
+class PyntContainer:
+    def __init__(self, image_name, tag, detach, base_container: PyntBaseContainer, use_native=False) -> None:
+        self.use_native = use_native
+
+        if use_native:
+            self.client_implementation = PyntContainerNative(image_name=image_name, tag=tag, base_container=base_container, is_detach=detach)
+        else:
+            self.client_implementation = PyntContainerSDK(image_name=image_name, tag=tag, base_container=base_container, is_detach=detach)
+
+        self.image = image_name
+        self.tag = tag
+        self.detach = detach
+        self.container_name = ""
+        self.base_container = base_container
+        self.stdout = None
+
+    def kill_other_instances(self):
+        self.client_implementation.kill_other_instances()
+
+    def stop(self):
+        self.client_implementation.stop()
+
+    def is_alive(self):
+        return self.client_implementation.is_alive()
+
+    def pull_image(self):
+        return self.client_implementation.pull_image()
+
+    def get_image(self):
+        return self.client_implementation.get_image()
+
+    def run(self):
+        self.client_implementation.run()
+        self.stdout = self.client_implementation.stdout
+        PyntContainerRegistry.instance().register_container(self)
+
+    def running(self):
+        return self.client_implementation.running
 
 
-class PyntDockerDesktopContainer():
+class PyntDockerDesktopContainer:
     def __init__(self, ports) -> None:
         self.ports = ports
 
-    def get_argumets(self):
+    def get_arguments(self):
         return {"ports": self.ports} if self.ports else {}
 
 
-class PyntNativeContainer():
+class PyntNativeContainer:
     def __init__(self, network) -> None:
         self.network = network
 
-    def get_argumets(self):
+    def get_arguments(self):
         return {"network": self.network} if self.network else {}
 
 
-class PyntContainerRegistery():
+class PyntContainerRegistry:
     _instance = None
 
     def __init__(self) -> None:
@@ -265,10 +480,10 @@ class PyntContainerRegistery():
 
     @staticmethod
     def instance():
-        if not PyntContainerRegistery._instance:
-            PyntContainerRegistery._instance = PyntContainerRegistery()
+        if not PyntContainerRegistry._instance:
+            PyntContainerRegistry._instance = PyntContainerRegistry()
 
-        return PyntContainerRegistery._instance
+        return PyntContainerRegistry._instance
 
     def register_container(self, c: PyntContainer):
         self.containers.append(c)

pyntcli/store/store.py

@@ -11,7 +11,7 @@ class Store():
         self.connector: StoreConnector = None
         self._file = None
         self._connector_type = connector_type
-            
+
     def _get_file_data(self):
         if self.connector:
             return
@@ -59,5 +59,5 @@ class CredStore(Store):
 
     def get_tokens(self):
         all_tokens = self.get("token")
-        token_to_json_string = '{"token":'+str(all_tokens).replace("\'", "\"")+"}"
+        token_to_json_string = '{"token":' + str(all_tokens).replace("\'", "\"") + "}"
         return token_to_json_string

pyntcli/transport/pynt_requests.py

@@ -62,16 +62,12 @@ def put(url, data=None, **kwargs):
     return requests.put(url, data=data, verify=verify, **kwargs)
 
 
-def get_new_session():
-    s = requests.session()
-    s.max_redirects = 500
-
-    return s
-
-
-def request_from_xml(
-    session: requests.Session, method, url, proxies=None, data=None, **kwargs
-):
-    return session.request(
-        method=method, url=url, data=data, verify=False, proxies=proxies, **kwargs
-    )
+def request_from_xml(method, url, proxies=None, data=None, **kwargs):
+    try:
+        requests.request(
+            method=method, url=url, data=data, verify=False, proxies=proxies, **kwargs
+        )
+
+        return url
+    except requests.exceptions.TooManyRedirects as e:
+        return "Too many redirects for {}".format(url)

pyntcli/ui/ui_thread.py

@@ -77,12 +77,14 @@ def gen_func_loop(gen):
         data = l
         if type(data) == bytes:
             data = l.decode("utf-8")
-        if not isinstance(data, AnsiText) and data[-1] == "\n":
+        if not isinstance(data, AnsiText) and data and data[-1] == "\n":
             data = data[:-1]
         _print(data)
 
 
 def print_generator(gen):
+    if gen == None:
+        return
     t = Thread(target=gen_func_loop, args=(gen,), daemon=True)
     t.start()
 
@@ -163,7 +165,7 @@ class Printer():
                 pass
 
         while not self.print_queue.empty():
-            self.console.print(self.print_queue.get())
+            self.console.print(self.print_queue.get(), end="")
 
     def print(self, data):
         if isinstance(data, PrinterText):

{pyntcli-0.1.89.dist-info → pyntcli-0.1.91.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyntcli
-Version: 0.1.89
+Version: 0.1.91
 Summary: Command line utility to handle all of Pynt's different integrations
 Author-email: Pynt-io <support@pynt.io>
 Project-URL: Homepage, https://pynt.io

{pyntcli-0.1.89.dist-info → pyntcli-0.1.91.dist-info}/RECORD

@@ -1,43 +1,43 @@
-pyntcli/__init__.py,sha256=PY93tkOmcPlWKkwp9BLM87U29v6noa-gTaI98NliUTA,23
-pyntcli/main.py,sha256=eJFpT-haLVQAYP71_ZHjNaA5iG2wvDXy8km84GU0Mwo,6009
+pyntcli/__init__.py,sha256=TjC2Yv3b693i4p1zyYBITDCreXfOMw-2BLFwgHmy35U,23
+pyntcli/main.py,sha256=ucC9d4wlhUpvA92OXRIZ55iMdFXEDiAOVvP_wtRu7zs,6432
 pyntcli/analytics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyntcli/analytics/send.py,sha256=pJOyOWl3g_Vm9apKK3LzNVqsnC6zsWA1bCK3ZegbLpc,3637
+pyntcli/analytics/send.py,sha256=9TRAEoPbv4rWOZfcNaGanrRJAFvNs39P-uKSl49GcQE,3679
 pyntcli/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyntcli/auth/login.py,sha256=TljsRXbEkNI1YUrKm5mlTw4YiecYScYUsit8Z8vstss,5228
 pyntcli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyntcli/commands/burp.py,sha256=A56AD9Cx-JmzrsHyVHEj4OQzFaXYQRIi_svU8HtBl5Y,12240
-pyntcli/commands/command.py,sha256=0lCMxXIyj3vAd8NfeQ2Ik1WhV8RHq17cwwaQn2isRzQ,10411
-pyntcli/commands/har.py,sha256=pl-qPZE6yOlLrruZ2bGiDkEpEVkLmnxb68bRxgzdszg,4120
+pyntcli/commands/burp.py,sha256=NfvMPlw8yISaDzvSuF96MXGVTPKRS7yR84TNDqFiblU,12274
+pyntcli/commands/command.py,sha256=uFwcr1YcekbMv0gs4mLIzfFSfn3cyTkoowTBjjZSJbc,10540
+pyntcli/commands/har.py,sha256=IZGd900hz0fFM3iZTG3NNXB2NiuAJGeuv-I49eXrf-o,4158
 pyntcli/commands/id_command.py,sha256=UBEgMIpm4vauTCsKyixltiGUolNg_OfHEJvJ_i5BpJY,943
-pyntcli/commands/listen.py,sha256=L8lpa8r-mZor9F_ad9L7KQAznljSEOgn_LPURm4e6dM,8789
-pyntcli/commands/newman.py,sha256=tXbb9hY0rO1-INvEiXia5-_TDhiA5QqdmgOKs_Jd6DY,5238
-pyntcli/commands/postman.py,sha256=wh0sgJTTkUDY5GFKxCKMrcE9OmSZk6nufltsIlJb6As,5013
-pyntcli/commands/pynt_cmd.py,sha256=KOl9guUtesO2JcMM5nPKKkjnK6F9HV4jHHcoUk4KVhw,2825
-pyntcli/commands/root.py,sha256=inffMhaMJykoRC0T2f7uF3f5BEdJw_c6Q1e2FTG4bfU,3511
+pyntcli/commands/listen.py,sha256=0wY9itDQyxSeHQA4GCGF67Xkb4ym48uP17WCPJMcLBE,8910
+pyntcli/commands/newman.py,sha256=ocg85L7HopXRYkhLc75QUtHH9ey48Z6Yxy1stgVW1aE,5283
+pyntcli/commands/postman.py,sha256=T1qdFHXX_kTW9p8PPbY9P7ynK4UcGoG3FfEMrRetwco,5163
+pyntcli/commands/pynt_cmd.py,sha256=X39hiDq6blGh2sGpwVeUXOgnDlhHruGkOoR5aUBzw_k,2982
+pyntcli/commands/root.py,sha256=-2aAiOKc_yXAlymxGove6su1mcvYsk4kCNaEawDKwy8,3677
 pyntcli/commands/static_file_extensions.py,sha256=PZJb02BI-64tbU-j3rdCNsXzTh7gkIDGxGKbKNw3h5k,1995
 pyntcli/commands/sub_command.py,sha256=GF3-rE_qk2L4jGPFqHLm9SdGINmu3EakhjJTFyWjRms,374
-pyntcli/commands/util.py,sha256=spTI_3z-fd0q7o1htvl-mw9-yKbO2ZESDAL-AsgWCb0,3217
+pyntcli/commands/util.py,sha256=4p4rzNqL8nUJJfj1uy_JOHsFBEvVT6-k-V9GbAqHVyM,3218
 pyntcli/log/__init__.py,sha256=cOGwOYzMoshEbZiiasBGkj6wF0SBu3Jdpl-AuakDesw,19
 pyntcli/log/log.py,sha256=cWCdWmUaAwePwdhYDcgNMEG9d9RM34sGahxBCYEdv2Y,1069
 pyntcli/pynt_docker/__init__.py,sha256=PQIOVxc7XXtMLfEX7ojgwf_Z3mmTllO3ZvzUZTPOxQY,30
 pyntcli/pynt_docker/container_utils.py,sha256=_Onn7loInzyJAG2-Uk6CGpsuRyelmUFHOvtJj4Uzi9A,175
-pyntcli/pynt_docker/pynt_container.py,sha256=Lz4WJlzJj3YeRQ6bb9D34oeLGnY1c0UDIugoHu-zBWA,9318
+pyntcli/pynt_docker/pynt_container.py,sha256=sqWKi3HUIn3AR9HgDYQtofCkaEQiOT3hG1nYQHf8RD8,17500
 pyntcli/store/__init__.py,sha256=xuS9OB21F6B1sUx5XPGxz_6WpG6-KTMbuq50RrZS5OY,29
 pyntcli/store/json_connector.py,sha256=UGs3uORw3iyn0YJ8kzab-veEZToA6d-ByXYuqEleWsA,560
-pyntcli/store/store.py,sha256=9KwalOd1EA1VtYwr9oJgBsPgUYakX5uyif_sNXGQ614,1917
+pyntcli/store/store.py,sha256=4YqmcHRltbbSWewKQoOZH8QdyMFs6i3L8o2bXY_YvSw,1909
 pyntcli/store/store_connector.py,sha256=w4LzcpRZesUZL1f63RmLlWEFRtJ6Y6rcS6PkkGtO4MA,357
 pyntcli/transport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyntcli/transport/pynt_requests.py,sha256=e-km_PonlrnQ2jwZHcCfNuv4laFWpaJjH-_f4Fge26M,1700
+pyntcli/transport/pynt_requests.py,sha256=C7OPvcKkRTcxSYuyiWKE59KgA9sRX0d6fm1wnopAmPo,1719
 pyntcli/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyntcli/ui/progress.py,sha256=RrnO_jJNunoyupylakmWmHOEPw3lh99OHpKBzL6OBiE,1008
 pyntcli/ui/pynt_errors.py,sha256=00UprD4tFViREv7kuXGQ99PAKGTpXYixxi3Ndeoeiew,689
 pyntcli/ui/report.py,sha256=W-icPSZrGLOubXgam0LpOvHLl_aZg9Zx9qIkL8Ym5PE,1930
-pyntcli/ui/ui_thread.py,sha256=4YzpO5dDrWpbTovMdHvv9ZQdLFJamZEAKXjF9rIIIoQ,5039
+pyntcli/ui/ui_thread.py,sha256=XUBgLpYQjVhrilU-ofw7VSXgTiwneSdTxm61EvC3x4Q,5091
 tests/conftest.py,sha256=gToq5K74GtgeGQXjFvXSzMaE6axBYxAzcFG5XJPOXjI,427
 tests/auth/test_login.py,sha256=KFlzWhXBAuwdi7GXf16gCB3ya94LQG2wjcSChE149rQ,3798
 tests/store/test_cred_store.py,sha256=_7-917EtNC9eKEumO2_lt-7KuDmCwOZFaowCm7DbA_A,254
-pyntcli-0.1.89.dist-info/METADATA,sha256=p-7mBPbyYjorg8Ksfw8-X64mbgRuaU4wcGkxcYL16No,463
-pyntcli-0.1.89.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
-pyntcli-0.1.89.dist-info/entry_points.txt,sha256=kcGmqAxXDttNk2EPRcqunc_LTVp61gzakz0v-GEE2SY,43
-pyntcli-0.1.89.dist-info/top_level.txt,sha256=u9MDStwVHB7UG8PUcODeWCul_NvzL2EzoLvSlgwLHFs,30
-pyntcli-0.1.89.dist-info/RECORD,,
+pyntcli-0.1.91.dist-info/METADATA,sha256=4OkdycIkBOdwvZhqis_OTurQirR9lvVkutdeC95s_ls,463
+pyntcli-0.1.91.dist-info/WHEEL,sha256=-oYQCr74JF3a37z2nRlQays_SX2MqOANoqVjBBAP2yE,91
+pyntcli-0.1.91.dist-info/entry_points.txt,sha256=kcGmqAxXDttNk2EPRcqunc_LTVp61gzakz0v-GEE2SY,43
+pyntcli-0.1.91.dist-info/top_level.txt,sha256=u9MDStwVHB7UG8PUcODeWCul_NvzL2EzoLvSlgwLHFs,30
+pyntcli-0.1.91.dist-info/RECORD,,

{pyntcli-0.1.89.dist-info → pyntcli-0.1.91.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.1.1)
+Generator: setuptools (71.0.3)
 Root-Is-Purelib: true
 Tag: py3-none-any