pyntcli 0.1.72__py3-none-any.whl → 0.1.74__py3-none-any.whl

pyntcli/commands/command.py

@@ -17,22 +17,28 @@ from pyntcli.transport import pynt_requests
 
 
 def command_usage():
-    return ui_thread.PrinterText("Command integration to Pynt. Run a security scan with a given command.") \
-        .with_line("") \
-        .with_line("Usage:", style=ui_thread.PrinterText.HEADER) \
-        .with_line("\tpynt command [OPTIONS]") \
-        .with_line("") \
-        .with_line("Options:", style=ui_thread.PrinterText.HEADER) \
-        .with_line("\t--cmd - The command that runs the functional tests") \
-        .with_line("\t--captured-domains - Pynt will scan only these domains and subdomains. For all domains write \"*\"") \
-        .with_line("\t--port - Set the port pynt will listen to (DEFAULT: 5001)") \
-        .with_line("\t--allow-errors - If present will allow command to fail and continue execution") \
-        .with_line("\t--ca-path - The path to the CA file in PEM format") \
-        .with_line("\t--proxy-port - Set the port proxied traffic should be routed to (DEFAULT: 6666)") \
-        .with_line("\t--report - If present will save the generated report in this path.") \
-        .with_line("\t--insecure - use when target uses self signed certificates") \
-        .with_line("\t--host-ca - path to the CA file in PEM format to enable SSL certificate verification for pynt when running through a VPN.") \
-        .with_line("\t--return-error - 'all-findings' (warnings, or errors), 'errors-only', 'never' (default), ")
+    return (
+        ui_thread.PrinterText(
+            "Command integration to Pynt. Run a security scan with a given command."
+        )
+        .with_line("")
+        .with_line("Usage:", style=ui_thread.PrinterText.HEADER)
+        .with_line("\tpynt command [OPTIONS]")
+        .with_line("")
+        .with_line("Options:", style=ui_thread.PrinterText.HEADER)
+        .with_line("\t--cmd - The command that runs the functional tests")
+        .with_line('\t--captured-domains - Pynt will scan only these domains and subdomains. For all domains write "*"')
+        .with_line('\t--test-name - A name for your Pynt scan')
+        .with_line("\t--port - Set the port pynt will listen to (DEFAULT: 5001)")
+        .with_line("\t--allow-errors - If present will allow command to fail and continue execution")
+        .with_line("\t--ca-path - The path to the CA file in PEM format")
+        .with_line("\t--proxy-port - Set the port proxied traffic should be routed to (DEFAULT: 6666)")
+        .with_line("\t--report - If present will save the generated report in this path.")
+        .with_line("\t--insecure - Use when target uses self signed certificates")
+        .with_line("\t--application-id - Attach the scan to an application, you can find the ID in your applications area at app.pynt.io")
+        .with_line("\t--host-ca - Path to the CA file in PEM format to enable SSL certificate verification for pynt when running through a VPN.")
+        .with_line("\t--return-error - 'all-findings' (warnings, or errors), 'errors-only', 'never' (default) ")
+    )
 
 
 class CommandSubCommand(sub_command.PyntSubCommand):
@@ -51,29 +57,39 @@ class CommandSubCommand(sub_command.PyntSubCommand):
         proxy_cmd.add_argument("--port", "-p", help="", type=int, default=5001)
         proxy_cmd.add_argument("--proxy-port", help="", type=int, default=6666)
         proxy_cmd.add_argument("--cmd", help="", default="", required=True)
-        proxy_cmd.add_argument("--captured-domains", nargs='+', help="", default="", required=False)
+        proxy_cmd.add_argument("--captured-domains", nargs="+", help="", default="", required=False)
+        proxy_cmd.add_argument("--test-name", help="", default="", required=False)
         proxy_cmd.add_argument("--allow-errors", action="store_true")
         proxy_cmd.add_argument("--ca-path", type=str, default="")
         proxy_cmd.add_argument("--report", type=str, default="")
-        proxy_cmd.add_argument('--return-error', choices=['all-findings', 'errors-only', 'never'], default='never')
+        proxy_cmd.add_argument("--return-error", choices=["all-findings", "errors-only", "never"], default="never")
         proxy_cmd.print_usage = self.print_usage
         proxy_cmd.print_help = self.print_usage
         return proxy_cmd
 
     def _updated_environment(self, args):
         env_copy = deepcopy(os.environ)
-        return env_copy.update({"HTTP_PROXY": "http://localhost:{}".format(args.proxy_port),
-                                "HTTPS_PROXY": "http://localhost:{}".format(args.proxy_port)})
+        return env_copy.update(
+            {
+                "HTTP_PROXY": "http://localhost:{}".format(args.proxy_port),
+                "HTTPS_PROXY": "http://localhost:{}".format(args.proxy_port),
+            }
+        )
 
     def _start_proxy(self, args):
-        res = pynt_requests.put(self.proxy_server_base_url.format(args.port) + "/proxy/start")
+        res = pynt_requests.put(
+            self.proxy_server_base_url.format(args.port) + "/proxy/start"
+        )
         res.raise_for_status()
         self.scan_id = res.json()["scanId"]
 
     def _stop_proxy(self, args):
         start = time.time()
         while start + self.proxy_healthcheck_buffer > time.time():
-            res = pynt_requests.put(self.proxy_server_base_url.format(args.port) + "/proxy/stop", json={"scanId": self.scan_id})
+            res = pynt_requests.put(
+                self.proxy_server_base_url.format(args.port) + "/proxy/stop",
+                json={"scanId": self.scan_id},
+            )
             if res.status_code == HTTPStatus.OK:
                 return
             time.sleep(self.proxy_sleep_interval)
@@ -81,66 +97,118 @@ class CommandSubCommand(sub_command.PyntSubCommand):
 
     def _get_report(self, args, report_format):
         while True:
-            res = pynt_requests.get(self.proxy_server_base_url.format(args.port) + "/report?format={}".format(report_format), params={"scanId": self.scan_id})
+            res = pynt_requests.get(
+                self.proxy_server_base_url.format(args.port)
+                + "/report?format={}".format(report_format),
+                params={"scanId": self.scan_id},
+            )
             if res.status_code == HTTPStatus.OK:
                 return res.text
             if res.status_code == HTTPStatus.ACCEPTED:
                 time.sleep(self.proxy_sleep_interval)
                 continue
             if res.status_code == 517:  # pynt did not recieve any requests
-                ui_thread.print(ui_thread.PrinterText(res.json()["message"], ui_thread.PrinterText.WARNING))
+                ui_thread.print(
+                    ui_thread.PrinterText(
+                        res.json()["message"], ui_thread.PrinterText.WARNING
+                    )
+                )
                 return
             ui_thread.print("Error in polling for scan report: {}".format(res.text))
             return
 
     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"))
+        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"
+            ),
+        )
 
         if args.captured_domains:
             for host in args.captured_domains:
                 container.docker_arguments += ["--host-targets", host]
 
+        if args.test_name:
+            container.docker_arguments += ["--test-name", args.test_name]
+
         if "ca_path" in args and args.ca_path:
             if not os.path.isfile(args.ca_path):
-                ui_thread.print(ui_thread.PrinterText("Could not find the provided ca path, please provide with a valid path", ui_thread.PrinterText.WARNING))
+                ui_thread.print(
+                    ui_thread.PrinterText(
+                        "Could not find the provided ca path, please provide with a valid path",
+                        ui_thread.PrinterText.WARNING,
+                    )
+                )
                 return
 
             ca_name = os.path.basename(args.ca_path)
             container.docker_arguments += ["--ca-path", ca_name]
-            container.mounts.append(pynt_container.create_mount(os.path.abspath(args.ca_path), "/etc/pynt/{}".format(ca_name)))
-
-        proxy_docker = pynt_container.PyntContainer(image_name=pynt_container.PYNT_DOCKER_IMAGE,
-                                                    tag="proxy-latest",
-                                                    detach=True,
-                                                    base_container=container)
+            container.mounts.append(
+                pynt_container.create_mount(
+                    os.path.abspath(args.ca_path), "/etc/pynt/{}".format(ca_name)
+                )
+            )
+
+        proxy_docker = pynt_container.PyntContainer(
+            image_name=pynt_container.PYNT_DOCKER_IMAGE,
+            tag="proxy-latest",
+            detach=True,
+            base_container=container,
+        )
         proxy_docker.run()
         ui_thread.print_generator(proxy_docker.stdout)
 
         util.wait_for_healthcheck("http://localhost:{}".format(args.port))
 
         if args.captured_domains:
-            ui_thread.print("\nWill scan APIs that belong to {} domains only".format(args.captured_domains))
+            ui_thread.print(
+                "\nWill scan APIs that belong to {} domains only".format(
+                    args.captured_domains
+                )
+            )
 
         self._start_proxy(args)
 
-        user_process = Popen(args.cmd, shell=True, stdout=PIPE, stderr=PIPE, env=self._updated_environment(args))
+        user_process = Popen(
+            args.cmd,
+            shell=True,
+            stdout=PIPE,
+            stderr=PIPE,
+            env=self._updated_environment(args),
+        )
         ui_thread.print_generator(user_process.stdout)
         ui_thread.print_generator(user_process.stderr)
         rc = user_process.wait()
         if rc != 0 and not args.allow_errors:
             proxy_docker.stop()
-            ui_thread.print(ui_thread.PrinterText("Command finished with error return code {}, If you wish Pynt to run anyway, run with --allow-errors".format(rc)))
+            ui_thread.print(
+                ui_thread.PrinterText(
+                    "The Command you provided finished with error return code {}, If you wish Pynt to run anyway, run with --allow-errors".format(
+                        rc
+                    )
+                )
+            )
             return
 
         self._stop_proxy(args)
 
-        with ui_thread.progress("ws://localhost:{}/progress?scanId={}".format(args.port, self.scan_id), partial(lambda *args: None), "scan in progress...", 100):
+        with ui_thread.progress(
+            "ws://localhost:{}/progress?scanId={}".format(args.port, self.scan_id),
+            partial(lambda *args: None),
+            "scan in progress...",
+            100,
+        ):
             html_report = self._get_report(args, "html")
-            html_report_path = os.path.join(tempfile.gettempdir(), "pynt_report_{}.html".format(int(time.time())))
+            html_report_path = os.path.join(
+                tempfile.gettempdir(), "pynt_report_{}.html".format(int(time.time()))
+            )
 
             json_report = self._get_report(args, "json")
-            json_report_path = os.path.join(tempfile.gettempdir(), "pynt_report_{}.json".format(int(time.time())))
+            json_report_path = os.path.join(
+                tempfile.gettempdir(), "pynt_report_{}.json".format(int(time.time()))
+            )
 
             if "report" in args and args.report:
                 full_path = os.path.abspath(args.report)

pyntcli/commands/har.py

@@ -10,17 +10,26 @@ from pyntcli.commands import sub_command, util
 
 
 def har_usage():
-    return ui_thread.PrinterText("Integration with static har file testing") \
-        .with_line("") \
-        .with_line("Usage:", style=ui_thread.PrinterText.HEADER) \
-        .with_line("\tpynt har [OPTIONS]") \
-        .with_line("") \
-        .with_line("Options:", style=ui_thread.PrinterText.HEADER) \
-        .with_line("\t--har - Path to har file") \
-        .with_line("\t--captured-domains - Pynt will scan only these domains and subdomains. For all domains write \"*\"") \
-        .with_line("\t--reporters output results to json") \
-        .with_line("\t--host-ca - path to the CA file in PEM format to enable SSL certificate verification for pynt when running through a VPN.") \
+    return (
+        ui_thread.PrinterText("Integration with static har file testing")
         .with_line("")
+        .with_line("Usage:", style=ui_thread.PrinterText.HEADER)
+        .with_line("\tpynt har [OPTIONS]")
+        .with_line("")
+        .with_line("Options:", style=ui_thread.PrinterText.HEADER)
+        .with_line("\t--har - Path to har file")
+        .with_line(
+            '\t--captured-domains - Pynt will scan only these domains and subdomains. For all domains write "*"'
+        )
+        .with_line("\t--reporters - Output results to json")
+        .with_line(
+            "\t--application-id - Attach the scan to an application, you can find the ID in your applications area at app.pynt.io"
+        )
+        .with_line(
+            "\t--host-ca - Path to the CA file in PEM format to enable SSL certificate verification for pynt when running through a VPN."
+        )
+        .with_line("")
+    )
 
 
 class HarSubCommand(sub_command.PyntSubCommand):
@@ -33,23 +42,36 @@ class HarSubCommand(sub_command.PyntSubCommand):
     def add_cmd(self, parent: argparse._SubParsersAction) -> argparse.ArgumentParser:
         har_cmd = parent.add_parser(self.name)
         har_cmd.add_argument("--har", type=str, required=True)
-        har_cmd.add_argument("--captured-domains", nargs='+', help="", default="", required=True)
-        har_cmd.add_argument("--reporters", action='store_true')
+        har_cmd.add_argument(
+            "--captured-domains", nargs="+", help="", default="", required=True
+        )
+        har_cmd.add_argument("--reporters", action="store_true")
         har_cmd.print_usage = self.usage
         har_cmd.print_help = self.usage
         return har_cmd
 
     def run_cmd(self, args: argparse.Namespace):
         port = str(util.find_open_port())
-        container = pynt_container.get_container_with_arguments(args, pynt_container.PyntDockerPort(src=port, dest=port, name="--port"))
+        container = pynt_container.get_container_with_arguments(
+            args, pynt_container.PyntDockerPort(src=port, dest=port, name="--port")
+        )
 
         if not os.path.isfile(args.har):
-            ui_thread.print(ui_thread.PrinterText("Could not find the provided har path, please provide with a valid har path", ui_thread.PrinterText.WARNING))
+            ui_thread.print(
+                ui_thread.PrinterText(
+                    "Could not find the provided har path, please provide with a valid har path",
+                    ui_thread.PrinterText.WARNING,
+                )
+            )
             return
 
         har_name = os.path.basename(args.har)
         container.docker_arguments += ["--har", har_name]
-        container.mounts.append(pynt_container.create_mount(os.path.abspath(args.har), "/etc/pynt/{}".format(har_name)))
+        container.mounts.append(
+            pynt_container.create_mount(
+                os.path.abspath(args.har), "/etc/pynt/{}".format(har_name)
+            )
+        )
 
         for host in args.captured_domains:
             container.docker_arguments += ["--host-targets", host]
@@ -58,16 +80,25 @@ class HarSubCommand(sub_command.PyntSubCommand):
 
             container.mounts += m
 
-            har_docker = pynt_container.PyntContainer(image_name=pynt_container.PYNT_DOCKER_IMAGE,
-                                                      tag="har-latest",
-                                                      detach=True,
-                                                      base_container=container)
+            har_docker = pynt_container.PyntContainer(
+                image_name=pynt_container.PYNT_DOCKER_IMAGE,
+                tag="har-latest",
+                detach=True,
+                base_container=container,
+            )
 
             har_docker.run()
 
-            healthcheck = partial(util.wait_for_healthcheck, "http://localhost:{}".format(port))
+            healthcheck = partial(
+                util.wait_for_healthcheck, "http://localhost:{}".format(port)
+            )
             ui_thread.print_generator(ui_thread.AnsiText.wrap_gen(har_docker.stdout))
 
-            with ui_thread.progress("ws://localhost:{}/progress".format(port), healthcheck,  "scan in progress...", 100):
+            with ui_thread.progress(
+                "ws://localhost:{}/progress".format(port),
+                healthcheck,
+                "scan in progress...",
+                100,
+            ):
                 while har_docker.is_alive():
                     time.sleep(1)

pyntcli/commands/id_command.py

@@ -4,13 +4,15 @@ from pyntcli.store.store import CredStore
 from pyntcli.commands import sub_command
 from pyntcli.ui import ui_thread
 
+
 def pyntid_usage():
     return ui_thread.PrinterText("View your pynt-id to use when running pynt in CI pipeline") \
         .with_line("") \
-        .with_line("Usage:",style=ui_thread.PrinterText.HEADER) \
+        .with_line("Usage:", style=ui_thread.PrinterText.HEADER) \
         .with_line("\tpynt pynt-id")
 
-class PyntShowIdCommand(sub_command.PyntSubCommand): 
+
+class PyntShowIdCommand(sub_command.PyntSubCommand):
     def __init__(self, name) -> None:
         super().__init__(name)
 
@@ -24,5 +26,5 @@ class PyntShowIdCommand(sub_command.PyntSubCommand):
         return cmd
 
     def run_cmd(self, args: argparse.Namespace):
-        creds_path = CredStore().get_path() 
+        creds_path = CredStore().get_path()
         ui_thread.print(open(creds_path, "r").read())

pyntcli/commands/listen.py

@@ -17,20 +17,24 @@ from pyntcli.transport import pynt_requests
 
 
 def listen_usage():
-    return ui_thread.PrinterText("Listen integration to Pynt. Run a security scan with routed traffic.") \
-        .with_line("") \
-        .with_line("Usage:", style=ui_thread.PrinterText.HEADER) \
-        .with_line("\tpynt listen [OPTIONS]") \
-        .with_line("") \
-        .with_line("Options:", style=ui_thread.PrinterText.HEADER) \
-        .with_line("\t--captured-domains - Pynt will scan only these domains and subdomains. For all domains write \"*\"") \
-        .with_line("\t--port - Set the port pynt will listen to (DEFAULT: 5001)") \
-        .with_line("\t--ca-path - The path to the CA file in PEM format") \
-        .with_line("\t--proxy-port - Set the port proxied traffic should be routed to (DEFAULT: 6666)") \
-        .with_line("\t--report - If present will save the generated report in this path.") \
-        .with_line("\t--insecure - use when target uses self signed certificates") \
-        .with_line("\t--host-ca - path to the CA file in PEM format to enable SSL certificate verification for pynt when running through a VPN.") \
-        .with_line("\t--return-error - 'all-findings' (warnings, or errors), 'errors-only', 'never' (default), ")
+    return (
+        ui_thread.PrinterText("Listen integration to Pynt. Run a security scan with routed traffic.")
+        .with_line("")
+        .with_line("Usage:", style=ui_thread.PrinterText.HEADER)
+        .with_line("\tpynt listen [OPTIONS]")
+        .with_line("")
+        .with_line("Options:", style=ui_thread.PrinterText.HEADER)
+        .with_line('\t--captured-domains - Pynt will scan only these domains and subdomains. For all domains write "*"')
+        .with_line('\t--test-name - A name for your Pynt scan')
+        .with_line("\t--port - Set the port pynt will listen to (DEFAULT: 5001)")
+        .with_line("\t--ca-path - The path to the CA file in PEM format")
+        .with_line("\t--proxy-port - Set the port proxied traffic should be routed to (DEFAULT: 6666)")
+        .with_line("\t--report - If present will save the generated report in this path.")
+        .with_line("\t--application-id - Attach the scan to an application, you can find the ID in your applications area at app.pynt.io")
+        .with_line("\t--insecure - use when target uses self signed certificates")
+        .with_line("\t--host-ca - path to the CA file in PEM format to enable SSL certificate verification for pynt when running through a VPN.")
+        .with_line("\t--return-error - 'all-findings' (warnings, or errors), 'errors-only', 'never' (default) ")
+    )
 
 
 class ListenSubCommand(sub_command.PyntSubCommand):
@@ -48,11 +52,12 @@ class ListenSubCommand(sub_command.PyntSubCommand):
         listen_cmd = parent.add_parser(self.name)
         listen_cmd.add_argument("--port", "-p", help="", type=int, default=5001)
         listen_cmd.add_argument("--proxy-port", help="", type=int, default=6666)
-        listen_cmd.add_argument("--captured-domains", nargs='+', help="", default="", required=True)
+        listen_cmd.add_argument("--captured-domains", nargs="+", help="", default="", required=True)
+        listen_cmd.add_argument("--test-name", help="", default="", required=False)
         listen_cmd.add_argument("--allow-errors", action="store_true")
         listen_cmd.add_argument("--ca-path", type=str, default="")
         listen_cmd.add_argument("--report", type=str, default="")
-        listen_cmd.add_argument('--return-error', choices=['all-findings', 'errors-only', 'never'], default='never')
+        listen_cmd.add_argument("--return-error", choices=["all-findings", "errors-only", "never"], default="never" )
         listen_cmd.print_usage = self.print_usage
         listen_cmd.print_help = self.print_usage
         return listen_cmd
@@ -65,7 +70,10 @@ class ListenSubCommand(sub_command.PyntSubCommand):
     def _stop_proxy(self, args):
         start = time.time()
         while start + self.proxy_healthcheck_buffer > time.time():
-            res = pynt_requests.put(self.proxy_server_base_url.format(args.port) + "/proxy/stop", json={"scanId": self.scan_id})
+            res = pynt_requests.put(
+                self.proxy_server_base_url.format(args.port) + "/proxy/stop",
+                json={"scanId": self.scan_id},
+            )
             if res.status_code == HTTPStatus.OK:
                 return
             time.sleep(self.proxy_sleep_interval)
@@ -73,38 +81,61 @@ class ListenSubCommand(sub_command.PyntSubCommand):
 
     def _get_report(self, args, report_format):
         while True:
-            res = pynt_requests.get(self.proxy_server_base_url.format(args.port) + "/report?format={}".format(report_format), params={"scanId": self.scan_id})
+            res = pynt_requests.get(
+                self.proxy_server_base_url.format(args.port)
+                + "/report?format={}".format(report_format),
+                params={"scanId": self.scan_id},
+            )
             if res.status_code == HTTPStatus.OK:
                 return res.text
             if res.status_code == HTTPStatus.ACCEPTED:
                 time.sleep(self.proxy_sleep_interval)
                 continue
             if res.status_code == 517:  # pynt did not recieve any requests
-                ui_thread.print(ui_thread.PrinterText(res.json()["message"], ui_thread.PrinterText.WARNING))
+                ui_thread.print(
+                    ui_thread.PrinterText(
+                        res.json()["message"], ui_thread.PrinterText.WARNING
+                    )
+                )
                 return
             ui_thread.print("Error in polling for scan report: {}".format(res.text))
             return
 
     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"))
+        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"))
 
         for host in args.captured_domains:
             container.docker_arguments += ["--host-targets", host]
 
+        if args.test_name:
+            container.docker_arguments += ["--test-name", args.test_name]
+
         if "ca_path" in args and args.ca_path:
             if not os.path.isfile(args.ca_path):
-                ui_thread.print(ui_thread.PrinterText("Could not find the provided ca path, please provide with a valid path", ui_thread.PrinterText.WARNING))
+                ui_thread.print(
+                    ui_thread.PrinterText(
+                        "Could not find the provided ca path, please provide with a valid path",
+                        ui_thread.PrinterText.WARNING,
+                    )
+                )
                 return
 
             ca_name = os.path.basename(args.ca_path)
             container.docker_arguments += ["--ca-path", ca_name]
-            container.mounts.append(pynt_container.create_mount(os.path.abspath(args.ca_path), "/etc/pynt/{}".format(ca_name)))
-
-        proxy_docker = pynt_container.PyntContainer(image_name=pynt_container.PYNT_DOCKER_IMAGE,
-                                                    tag="proxy-latest",
-                                                    detach=True,
-                                                    base_container=container)
+            container.mounts.append(
+                pynt_container.create_mount(
+                    os.path.abspath(args.ca_path), "/etc/pynt/{}".format(ca_name)
+                )
+            )
+
+        proxy_docker = pynt_container.PyntContainer(
+            image_name=pynt_container.PYNT_DOCKER_IMAGE,
+            tag="proxy-latest",
+            detach=True,
+            base_container=container)
         proxy_docker.run()
         ui_thread.print_generator(proxy_docker.stdout)
 
@@ -112,22 +143,41 @@ class ListenSubCommand(sub_command.PyntSubCommand):
 
         self._start_proxy(args)
 
-        ui_thread.print(ui_thread.PrinterText("\nListening to traffic on port: {}".format(args.proxy_port), ui_thread.PrinterText.DEFAULT)
-                        .with_line("Will scan APIs that belong to \'{}\' domains only".format(args.captured_domains))
-                        .with_line(""))
-
-        ui_thread.print(ui_thread.PrinterText("Press Enter to stop recording traffic and run security scan...", ui_thread.PrinterText.HEADER))
+        ui_thread.print(
+            ui_thread.PrinterText(
+                "\nListening to traffic on port: {}".format(args.proxy_port),
+                ui_thread.PrinterText.DEFAULT,
+            )
+            .with_line(
+                "Will scan APIs that belong to '{}' domains only".format(
+                    args.captured_domains
+                )
+            )
+            .with_line(""))
+
+        ui_thread.print(
+            ui_thread.PrinterText(
+                "Press Enter to stop recording traffic and run security scan...",
+                ui_thread.PrinterText.HEADER,
+            ))
 
         input()
 
         self._stop_proxy(args)
 
-        with ui_thread.progress("ws://localhost:{}/progress?scanId={}".format(args.port, self.scan_id), partial(lambda *args: None), "scan in progress...", 100):
+        with ui_thread.progress(
+            "ws://localhost:{}/progress?scanId={}".format(args.port, self.scan_id),
+            partial(lambda *args: None),
+            "scan in progress...",100):
             html_report = self._get_report(args, "html")
-            html_report_path = os.path.join(tempfile.gettempdir(), "pynt_report_{}.html".format(int(time.time())))
+            html_report_path = os.path.join(
+                tempfile.gettempdir(), "pynt_report_{}.html".format(int(time.time()))
+            )
 
             json_report = self._get_report(args, "json")
-            json_report_path = os.path.join(tempfile.gettempdir(), "pynt_report_{}.json".format(int(time.time())))
+            json_report_path = os.path.join(
+                tempfile.gettempdir(), "pynt_report_{}.json".format(int(time.time()))
+            )
 
             if "report" in args and args.report:
                 full_path = os.path.abspath(args.report)