sharkit 0.2.0.dev1__tar.gz → 0.2.1.dev1__tar.gz

{sharkit-0.2.0.dev1 → sharkit-0.2.1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sharkit
-Version: 0.2.0.dev1
+Version: 0.2.1.dev1
 Summary: OSINT / HUMINT / GEOINT research framework
 Project-URL: Homepage, https://github.com/sshsrv/sharkit
 Project-URL: Repository, https://github.com/sshsrv/sharkit
@@ -27,7 +27,7 @@ Requires-Dist: prompt-toolkit<4.0.0,>=3.0.0
 Description-Content-Type: text/markdown
 
 <div align="center"><img width="640" height="347" alt="banner" src="https://github.com/user-attachments/assets/c027fb38-fe0f-4baa-b35f-597f9f8cf39b" /></div>
-
+<br>
 <div align="center">
   
 ![PyPI](https://img.shields.io/pypi/v/sharkit?labelColor=000000&color=ff5faf&style=flat)

{sharkit-0.2.0.dev1 → sharkit-0.2.1.dev1}/README.md

@@ -1,5 +1,5 @@
 <div align="center"><img width="640" height="347" alt="banner" src="https://github.com/user-attachments/assets/c027fb38-fe0f-4baa-b35f-597f9f8cf39b" /></div>
-
+<br>
 <div align="center">
   
 ![PyPI](https://img.shields.io/pypi/v/sharkit?labelColor=000000&color=ff5faf&style=flat)

{sharkit-0.2.0.dev1 → sharkit-0.2.1.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sharkit"
-version = "0.2.0.dev1"
+version = "0.2.1.dev1"
 description = "OSINT / HUMINT / GEOINT research framework"
 readme = "README.md"
 license = "MIT"

{sharkit-0.2.0.dev1 → sharkit-0.2.1.dev1}/src/sharkit/app.py

@@ -20,7 +20,7 @@ NON_LINUX_MESSAGE = (
     "it was built for open water,\n"
     "where it can actually swim.\n"
     "\n"
-    "windows/mac is more of a glass aquarium.\n"
+    "windows is more of a glass aquarium.\n"
     "tidy, bright, and a little too enclosed.\n"
     "\n"
     "the shark doesn't dislike the aquarium.\n"
@@ -37,7 +37,7 @@ def main() -> int:
     sys.stdout.flush()
     renderer = Renderer()
 
-    if sys.platform != "linux":
+    if sys.platform == "win32":
         renderer.banner(tool_count=0, message=NON_LINUX_MESSAGE)
         return 1
 

{sharkit-0.2.0.dev1 → sharkit-0.2.1.dev1}/src/sharkit/commands/builtins.py

@@ -187,6 +187,7 @@ class UseCommand(Command):
         if tool_cls is not None and tool_cls.metadata.install is not None:
             spec = tool_cls.metadata.install
             name = tool_cls.metadata.name
+            display = tool_registry.format_display(path) if tool_registry else name
             if tool_manager is not None and not tool_manager.is_installed(name):
                 if not self._prompt_install(name):
                     self._log(context, f'Tool "{name}" is not installed. Run: install {name}')
@@ -195,7 +196,7 @@ class UseCommand(Command):
 
                 def on_progress(msg: str) -> None:
                     if renderer is not None:
-                        renderer.log_line(f"install ({name})", msg, color=GREEN)
+                        renderer.log_line(f"install {display}", msg, color=GREEN)
 
                 ok, message = tool_manager.install(name, spec, on_progress=on_progress)
                 if not ok:
@@ -203,6 +204,15 @@ class UseCommand(Command):
                     return None
         context.current_tool = path
         self._log(context, f'Tool "{path}" selected.')
+        if tool_cls is not None and tool_cls.metadata.install is not None:
+            renderer = context.session.get("renderer")
+            if renderer is not None:
+                install_spec = tool_cls.metadata.install
+                renderer.support_creator(
+                    tool_cls.metadata.author,
+                    tool_cls.metadata.name,
+                    install_spec.git_url,
+                )
         return None
 
     def _prompt_install(self, name: str) -> bool:
@@ -372,7 +382,13 @@ class SetCommand(Command):
             tool_instance.set_option(key, value)
             renderer = context.session.get("renderer")
             if renderer is not None:
-                renderer.log_line(f"set ({context.current_tool})", f"{key} = {value}")
+                tool_registry = context.session.get("tool_registry")
+                display = context.current_tool
+                if tool_registry is not None and context.current_tool is not None:
+                    display = tool_registry.format_display(
+                        tool_registry.get_tool_path(context.current_tool),
+                    )
+                renderer.log_line(f"set {display}", f"{key} = {value}")
                 return None
             return f"Set {key} = {value}"
         except Exception as e:
@@ -552,6 +568,9 @@ class HistoryCommand(Command):
         if clear:
             manager.clear()
             context.session["history"] = []
+            sharkit_history = context.session.get("sharkit_history")
+            if sharkit_history is not None:
+                sharkit_history.clear()
             return "[+] Command history and history file cleared"
 
         all_entries = manager.get_history(10_000_000)
@@ -614,23 +633,24 @@ class InstallCommand(Command):
         tool_cls = tool_registry.get_tool(name)
         if tool_cls is None or tool_cls.metadata.install is None:
             return f'Tool "{name}" is not an external tool or was not found.'
+        display = tool_registry.format_display(tool_registry.get_tool_path(name))
         if tool_manager.is_installed(name):
             renderer = context.session.get("renderer")
             if renderer is not None:
-                renderer.log_line(f"install ({name})", "already installed", color=GREEN)
+                renderer.log_line(f"install {display}", "already installed", color=GREEN)
             return None
         renderer = context.session.get("renderer")
 
         def on_progress(msg: str) -> None:
             if renderer is not None:
-                renderer.log_line(f"install ({name})", msg, color=GREEN)
+                renderer.log_line(f"install {display}", msg, color=GREEN)
 
         ok, message = tool_manager.install(name, tool_cls.metadata.install, on_progress=on_progress)
         if renderer is not None:
             if ok:
-                renderer.log_line(f"install ({name})", "installed", color=GREEN)
+                renderer.log_line(f"install {display}", "installed", color=GREEN)
             else:
-                renderer.log_line(f"install ({name})", f"failed: {message}", color=GREEN)
+                renderer.log_line(f"install {display}", f"failed: {message}", color=GREEN)
             return None
         return str(message)
 
@@ -657,23 +677,24 @@ class UpgradeCommand(Command):
         tool_cls = tool_registry.get_tool(name)
         if tool_cls is None or tool_cls.metadata.install is None:
             return f'Tool "{name}" is not an external tool or was not found.'
+        display = tool_registry.format_display(tool_registry.get_tool_path(name))
         if not tool_manager.is_installed(name):
             renderer = context.session.get("renderer")
             if renderer is not None:
-                renderer.log_line(f"upgrade ({name})", "not installed (skipped)", color=BLUE)
+                renderer.log_line(f"upgrade {display}", "not installed (skipped)", color=BLUE)
             return None
         renderer = context.session.get("renderer")
 
         def on_progress(msg: str) -> None:
             if renderer is not None:
-                renderer.log_line(f"upgrade ({name})", msg, color=BLUE)
+                renderer.log_line(f"upgrade {display}", msg, color=BLUE)
 
         ok, message = tool_manager.update(name, tool_cls.metadata.install, on_progress=on_progress)
         if renderer is not None:
             if ok:
-                renderer.log_line(f"upgrade ({name})", "upgraded", color=BLUE)
+                renderer.log_line(f"upgrade {display}", "upgraded", color=BLUE)
             else:
-                renderer.log_line(f"upgrade ({name})", f"failed: {message}", color=BLUE)
+                renderer.log_line(f"upgrade {display}", f"failed: {message}", color=BLUE)
             return None
         return str(message)
 
@@ -699,23 +720,24 @@ class UpgradeCommand(Command):
             if spec is None:
                 continue
             name = meta.name
+            display = tool_registry.format_display(tool_registry.get_tool_path(name))
             if not tool_manager.is_installed(name):
                 renderer = context.session.get("renderer")
                 if renderer is not None:
-                    renderer.log_line(f"upgrade ({name})", "not installed (skipped)", color=BLUE)
+                    renderer.log_line(f"upgrade {display}", "not installed (skipped)", color=BLUE)
                 continue
             renderer = context.session.get("renderer")
 
-            def on_progress(msg: str, name: str = name, renderer: Any = renderer) -> None:
+            def on_progress(msg: str, display: str = display, renderer: Any = renderer) -> None:
                 if renderer is not None:
-                    renderer.log_line(f"upgrade ({name})", msg, color=BLUE)
+                    renderer.log_line(f"upgrade {display}", msg, color=BLUE)
 
             ok, message = tool_manager.update(name, spec, on_progress=on_progress)
             if renderer is not None:
                 if ok:
-                    renderer.log_line(f"upgrade ({name})", "upgraded", color=BLUE)
+                    renderer.log_line(f"upgrade {display}", "upgraded", color=BLUE)
                 else:
-                    renderer.log_line(f"upgrade ({name})", f"failed: {message}", color=BLUE)
+                    renderer.log_line(f"upgrade {display}", f"failed: {message}", color=BLUE)
         return None
 
 
@@ -737,13 +759,14 @@ class RemoveCommand(Command):
         tool_cls = tool_registry.get_tool(name)
         if tool_cls is None or tool_cls.metadata.install is None:
             return f'Tool "{name}" is not an external tool or was not found.'
+        display = tool_registry.format_display(tool_registry.get_tool_path(name))
         renderer = context.session.get("renderer")
         ok, message = tool_manager.uninstall(name)
         if renderer is not None:
             if ok:
-                renderer.log_line(f"remove ({name})", "removed", color=RED)
+                renderer.log_line(f"remove {display}", "removed", color=RED)
             else:
-                renderer.log_line(f"remove ({name})", f"failed: {message}", color=RED)
+                renderer.log_line(f"remove {display}", f"failed: {message}", color=RED)
             return None
         return str(message)
 

{sharkit-0.2.0.dev1 → sharkit-0.2.1.dev1}/src/sharkit/console/prompt.py

@@ -9,16 +9,21 @@ class PromptRenderer:
         return "shark > "
 
     def tool_prompt(self, tool_name: str) -> str:
-        return f"shark ({tool_name}) > "
+        if "/" in tool_name:
+            parts = tool_name.split("/", 1)
+            formatted = f"{parts[0]}({parts[1]})"
+        else:
+            formatted = tool_name
+        return f"shark {formatted} > "
 
     def render(self, prompt: str) -> list[tuple[str, str]]:
         if "(" in prompt and ")" in prompt:
             before, rest = prompt.split("(", 1)
-            tool_name, after = rest.split(")", 1)
+            tool_path, after = rest.split(")", 1)
             return [
                 (PROMPT_STYLE, before),
                 ("", "("),
-                (MODULE_STYLE, tool_name),
+                (MODULE_STYLE, tool_path),
                 ("", ")"),
                 ("", after),
             ]

{sharkit-0.2.0.dev1 → sharkit-0.2.1.dev1}/src/sharkit/console/repl.py

@@ -36,6 +36,11 @@ class _SharkitHistory(History):
     def store_string(self, string: str) -> None:
         self._manager.add_command(string)
 
+    def clear(self) -> None:
+        """Reset the in-memory buffer so next load() re-reads from file."""
+        self._loaded = False
+        self._loaded_strings = []
+
 
 class _ConsoleCompleter(Completer):
     def __init__(
@@ -100,9 +105,9 @@ class Console:
 
     def _get_prompt(self) -> Any:
         if self._current_tool is not None:
-            prompt = f"shark ({self._current_tool}) > "
+            prompt = self._prompt_renderer.tool_prompt(self._current_tool)
         else:
-            prompt = "shark > "
+            prompt = self._prompt_renderer.default_prompt()
         return self._prompt_renderer.render(prompt)
 
     def _init_session(self) -> None:
@@ -113,12 +118,14 @@ class Console:
             tool_registry=self._tool_registry,
             get_current_tool=lambda: self._current_tool,
         )
+        self._sharkit_history = _SharkitHistory(self._history_manager)
         self._prompt_session = PromptSession[str](
-            history=_SharkitHistory(self._history_manager),
+            history=self._sharkit_history,
             completer=self._completer,
             style=_PROMPT_STYLE,
             complete_while_typing=True,
         )
+        self._session_data["sharkit_history"] = self._sharkit_history
 
     def run(self) -> None:
         self._init_session()

{sharkit-0.2.0.dev1 → sharkit-0.2.1.dev1}/src/sharkit/output/renderer.py

@@ -1,6 +1,7 @@
 import re
 import shutil
 import textwrap
+import unicodedata
 
 from sharkit import __version__
 from sharkit.output.theme import (
@@ -32,7 +33,8 @@ x88:  `)8b.  888E~?888L .@88 "8888"   4888>'88"    888E`"88*"  ''888E`   8888
 
 
 def _visible_len(text: str) -> int:
-    return len(ANSI_RE.sub("", text))
+    clean = ANSI_RE.sub("", text)
+    return sum(2 if unicodedata.east_asian_width(ch) in ("W", "F") else 1 for ch in clean)
 
 
 def _pad(text: str, width: int) -> str:
@@ -55,7 +57,7 @@ def _term_width() -> int:
 class Renderer:
     def panel(
         self,
-        title: str,
+        title: str | None,
         content: str,
         min_width: int = 0,
         centered: bool = False,
@@ -73,11 +75,12 @@ class Renderer:
         else:
             lines = content.splitlines()
         content_width = max((_visible_len(line) for line in lines), default=0)
-        title_width = _visible_len(title)
+        title_width = _visible_len(title) if title else 0
         inner = max(content_width, title_width + 3, min_width)
-        box_width = inner + 4
 
-        if centered:
+        if title is None:
+            top = f"{PINK}╭{'─' * (inner + 2)}╮{RESET}"
+        elif centered:
             gap = inner - title_width
             left = gap // 2
             right = gap - left
@@ -88,6 +91,7 @@ class Renderer:
         else:
             dashes = max(0, inner - title_width - 1)
             top = f"{PINK}╭─ {BOLD}{WHITE}{title}{RESET}{PINK} {'─' * dashes}╮{RESET}"
+
         if centered:
             body = [f"{PINK}│{RESET} {_center(line, inner)} {PINK}│{RESET}" for line in lines]
         else:
@@ -96,7 +100,7 @@ class Renderer:
 
         all_lines = [top, *body, bottom]
         if centered:
-            pad = max(0, (_term_width() - box_width) // 2)
+            pad = max(0, (_term_width() - (inner + 4)) // 2)
             all_lines = [" " * pad + ln for ln in all_lines]
         for ln in all_lines:
             print(ln)
@@ -257,3 +261,16 @@ class Renderer:
         else:
             prefix = f"{RESET}{' ' * (len(name) + 1)}{color}{BOLD}│{RESET} "
         print(prefix + line)
+
+    def support_creator(self, author: str, tool_name: str, git_url: str) -> None:
+        lines = [
+            f"Thanks to {author} for building {tool_name}!",
+            "If you find this tool useful, please consider:",
+            "",
+            f"⭐ Star the repo: {git_url}",
+            f"🐛 Report issues: {git_url}/issues",
+            f"💰 Sponsor the author: {git_url}/sponsors",
+            "",
+            f"{DIM}Without creators like them, sharkit wouldn't exist! :3{RESET}",
+        ]
+        self.panel(None, "\n".join(lines))

{sharkit-0.2.0.dev1/src/sharkit/tools → sharkit-0.2.1.dev1/src/sharkit/tools/osint/recon/hybrid}/blackbird.py

@@ -144,6 +144,7 @@ class BlackbirdTool(Tool):
         first = True
         current = ""
         started = False
+        pending_blank = False
         try:
             while True:
                 try:
@@ -165,11 +166,20 @@ class BlackbirdTool(Tool):
                     started = True
                 for ch in chunk.decode("utf-8", errors="replace"):
                     if ch == "\n":
-                        if renderer is not None:
-                            renderer.gutter(name, _clean_ansi(current), tool_color, first)
+                        if current:
+                            if pending_blank:
+                                if renderer is not None:
+                                    renderer.gutter(name, "", tool_color, False)
+                                else:
+                                    print()
+                                pending_blank = False
+                            if renderer is not None:
+                                renderer.gutter(name, _clean_ansi(current), tool_color, first)
+                            else:
+                                print(_clean_ansi(current))
+                            first = False
                         else:
-                            print(_clean_ansi(current))
-                        first = False
+                            pending_blank = True
                         current = ""
                     elif ch == "\r":
                         current = ""
@@ -181,6 +191,8 @@ class BlackbirdTool(Tool):
                 proc.kill()
             current = ""
             if renderer is not None:
+                # \r\033[K clears the ^C echo from the terminal before printing.
+                print("\r\033[K", end="")
                 renderer.gutter(name, "Run aborted (Ctrl+C).", tool_color, first)
             else:
                 print("Run aborted (Ctrl+C).")

sharkit-0.2.1.dev1/src/sharkit/tools/osint/recon/username/maigret.py

@@ -0,0 +1,252 @@
+from __future__ import annotations
+
+import contextlib
+import fcntl
+import os
+import pty
+import re
+import select
+import struct
+import subprocess
+import termios
+from dataclasses import replace
+
+from sharkit.output.theme import PINK, hex_to_ansi
+from sharkit.tools.base import (
+    ExecutionContext,
+    OptionDefinition,
+    Result,
+    Tool,
+    ToolInstallSpec,
+    ToolMetadata,
+    parse_bool,
+)
+
+_CSI_RE = re.compile(r"\x1b\[[0-9;?]*[a-zA-Z]")
+_OSC_RE = re.compile(r"\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)", re.DOTALL)
+
+
+def _clean_ansi(text: str) -> str:
+    text = _OSC_RE.sub("", text)
+    return _CSI_RE.sub(lambda m: m.group(0) if m.group(0).endswith("m") else "", text)
+
+
+class MaigretTool(Tool):
+    metadata = ToolMetadata(
+        name="maigret",
+        description="Maigret — username OSINT across 3000+ sites with recursive checks",
+        category="recon",
+        author="soxoj",
+        version="0.1.0",
+        safety="safe",
+        color="#FF6B35",
+        install=ToolInstallSpec(
+            git_url="https://github.com/soxoj/maigret.git",
+            pip_args=["maigret"],
+        ),
+    )
+
+    def __init__(self) -> None:
+        self._options = {
+            "username": OptionDefinition(
+                name="username",
+                description="Target username to hunt",
+                required=True,
+            ),
+            "timeout": OptionDefinition(
+                name="timeout",
+                description="Timeout per site in seconds",
+                required=False,
+                default=None,
+            ),
+            "output": OptionDefinition(
+                name="output",
+                description="Write results to file",
+                required=False,
+                default=None,
+            ),
+            "json": OptionDefinition(
+                name="json",
+                description="Export results as JSON",
+                required=False,
+                default=None,
+                type="bool",
+            ),
+            "csv": OptionDefinition(
+                name="csv",
+                description="Export results as CSV",
+                required=False,
+                default=None,
+                type="bool",
+            ),
+            "site": OptionDefinition(
+                name="site",
+                description="Limit to specific site(s) (comma-separated)",
+                required=False,
+                default=None,
+            ),
+            "top_sites": OptionDefinition(
+                name="top_sites",
+                description="Only check top N most popular sites",
+                required=False,
+                default=None,
+            ),
+        }
+
+    def get_metadata(self) -> ToolMetadata:
+        return self.metadata
+
+    def get_options(self) -> dict[str, OptionDefinition]:
+        return self._options
+
+    def set_option(self, key: str, value: str) -> None:
+        if key not in self._options:
+            raise ValueError(f'Option "{key}" not found.')
+        self._options[key] = replace(self._options[key], value=value)
+
+    def execute(self, context: ExecutionContext) -> Result:
+        from sharkit.tools.manager import ToolManager
+
+        name = self.metadata.name
+        tool_color = hex_to_ansi(self.metadata.color) if self.metadata.color else PINK
+        manager = ToolManager()
+        if not manager.is_installed(name):
+            return Result(
+                success=False,
+                error=f'Tool "{name}" is not installed. Run: install {name}',
+            )
+        spec = self.metadata.install
+        if spec is None:
+            return Result(success=False, error="Tool has no install spec.")
+
+        install_dir = manager.install_path(name)
+        maigret_bin = install_dir / "venv" / "bin" / "maigret"
+        if not maigret_bin.exists():
+            return Result(
+                success=False,
+                error=f"Maigret binary not found: {maigret_bin}",
+            )
+
+        username = context.options.get("username") or ""
+        if not username:
+            return Result(success=False, error="Option 'username' is required.")
+
+        args = [username, "--no-progressbar"]
+        timeout = context.options.get("timeout")
+        if timeout:
+            args.extend(["--timeout", str(timeout)])
+        output = context.options.get("output")
+        if output:
+            args.extend(["--output", str(output)])
+        if parse_bool(context.options.get("json")):
+            args.append("--json")
+        if parse_bool(context.options.get("csv")):
+            args.append("--csv")
+        site = context.options.get("site")
+        if site:
+            for s in str(site).split(","):
+                args.extend(["--site", s.strip()])
+        top_sites = context.options.get("top_sites")
+        if top_sites:
+            args.extend(["--top-sites", str(top_sites)])
+
+        renderer = context.renderer
+        master, slave = pty.openpty()
+        try:
+            winsize = struct.pack("HHHH", 1000, 10000, 0, 0)
+            fcntl.ioctl(master, termios.TIOCSWINSZ, winsize)
+            attrs = termios.tcgetattr(master)
+            attrs[1] &= ~termios.OPOST
+            termios.tcsetattr(master, termios.TCSANOW, attrs)
+        except OSError:
+            pass
+
+        env = os.environ.copy()
+        env["TERM"] = "xterm-256color"
+        env["FORCE_COLOR"] = "1"
+        env["CLICOLOR"] = "1"
+        env["CLICOLOR_FORCE"] = "1"
+        env["COLUMNS"] = "10000"
+
+        try:
+            proc = subprocess.Popen(
+                [str(maigret_bin), *args],
+                stdout=slave,
+                stderr=slave,
+                stdin=subprocess.DEVNULL,
+                cwd=str(install_dir),
+                env=env,
+                start_new_session=True,
+            )
+        except Exception as e:
+            return Result(success=False, error=f"Failed to run {name}: {e}")
+        finally:
+            with contextlib.suppress(OSError):
+                os.close(slave)
+
+        first = True
+        current = ""
+        started = False
+        pending_blank = False
+        try:
+            while True:
+                try:
+                    r, _, _ = select.select([master], [], [], 0.5)
+                except (OSError, ValueError):
+                    break
+                if not r:
+                    if proc.poll() is not None:
+                        break
+                    continue
+                try:
+                    chunk = os.read(master, 65536)
+                except OSError:
+                    break
+                if not chunk:
+                    break
+                if not started:
+                    chunk = chunk.lstrip(b"\n")
+                    started = True
+                for ch in chunk.decode("utf-8", errors="replace"):
+                    if ch == "\n":
+                        if current:
+                            if pending_blank:
+                                if renderer is not None:
+                                    renderer.gutter(name, "", tool_color, False)
+                                else:
+                                    print()
+                                pending_blank = False
+                            if renderer is not None:
+                                renderer.gutter(name, _clean_ansi(current), tool_color, first)
+                            else:
+                                print(_clean_ansi(current))
+                            first = False
+                        else:
+                            pending_blank = True
+                        current = ""
+                    elif ch == "\r":
+                        current = ""
+                    else:
+                        current += ch
+        except KeyboardInterrupt:
+            with contextlib.suppress(OSError):
+                proc.kill()
+            current = ""
+            if renderer is not None:
+                print("\r\033[K", end="")
+                renderer.gutter(name, "Run aborted (Ctrl+C).", tool_color, first)
+            else:
+                print("Run aborted (Ctrl+C).")
+            return Result(success=True, data={})
+        finally:
+            if current:
+                if renderer is not None:
+                    renderer.gutter(name, _clean_ansi(current), tool_color, first)
+                else:
+                    print(_clean_ansi(current))
+            with contextlib.suppress(OSError):
+                os.close(master)
+            with contextlib.suppress(OSError):
+                proc.wait()
+
+        return Result(success=True, data={})

sharkit-0.2.1.dev1/src/sharkit/tools/osint/recon/username/sherlock.py

@@ -0,0 +1,252 @@
+from __future__ import annotations
+
+import contextlib
+import fcntl
+import os
+import pty
+import re
+import select
+import struct
+import subprocess
+import termios
+from dataclasses import replace
+
+from sharkit.output.theme import PINK, hex_to_ansi
+from sharkit.tools.base import (
+    ExecutionContext,
+    OptionDefinition,
+    Result,
+    Tool,
+    ToolInstallSpec,
+    ToolMetadata,
+    parse_bool,
+)
+
+_CSI_RE = re.compile(r"\x1b\[[0-9;?]*[a-zA-Z]")
+_OSC_RE = re.compile(r"\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)", re.DOTALL)
+
+
+def _clean_ansi(text: str) -> str:
+    text = _OSC_RE.sub("", text)
+    return _CSI_RE.sub(lambda m: m.group(0) if m.group(0).endswith("m") else "", text)
+
+
+class SherlockTool(Tool):
+    metadata = ToolMetadata(
+        name="sherlock",
+        description="Sherlock — find usernames across 400+ social networks",
+        category="recon",
+        author="sherlock-project",
+        version="0.1.0",
+        safety="safe",
+        color="#4A7AFF",
+        install=ToolInstallSpec(
+            git_url="https://github.com/sherlock-project/sherlock.git",
+            pip_args=["sherlock-project"],
+        ),
+    )
+
+    def __init__(self) -> None:
+        self._options = {
+            "username": OptionDefinition(
+                name="username",
+                description="Target username to hunt",
+                required=True,
+            ),
+            "timeout": OptionDefinition(
+                name="timeout",
+                description="Timeout per site in seconds",
+                required=False,
+                default=None,
+            ),
+            "output": OptionDefinition(
+                name="output",
+                description="Write results to file",
+                required=False,
+                default=None,
+            ),
+            "json": OptionDefinition(
+                name="json",
+                description="Export results as JSON",
+                required=False,
+                default=None,
+                type="bool",
+            ),
+            "csv": OptionDefinition(
+                name="csv",
+                description="Export results as CSV",
+                required=False,
+                default=None,
+                type="bool",
+            ),
+            "site": OptionDefinition(
+                name="site",
+                description="Limit to specific site(s) (comma-separated)",
+                required=False,
+                default=None,
+            ),
+            "print_found": OptionDefinition(
+                name="print_found",
+                description="Only print sites where the username was found",
+                required=False,
+                default=None,
+                type="bool",
+            ),
+        }
+
+    def get_metadata(self) -> ToolMetadata:
+        return self.metadata
+
+    def get_options(self) -> dict[str, OptionDefinition]:
+        return self._options
+
+    def set_option(self, key: str, value: str) -> None:
+        if key not in self._options:
+            raise ValueError(f'Option "{key}" not found.')
+        self._options[key] = replace(self._options[key], value=value)
+
+    def execute(self, context: ExecutionContext) -> Result:
+        from sharkit.tools.manager import ToolManager
+
+        name = self.metadata.name
+        tool_color = hex_to_ansi(self.metadata.color) if self.metadata.color else PINK
+        manager = ToolManager()
+        if not manager.is_installed(name):
+            return Result(
+                success=False,
+                error=f'Tool "{name}" is not installed. Run: install {name}',
+            )
+        spec = self.metadata.install
+        if spec is None:
+            return Result(success=False, error="Tool has no install spec.")
+
+        install_dir = manager.install_path(name)
+        sherlock_bin = install_dir / "venv" / "bin" / "sherlock"
+        if not sherlock_bin.exists():
+            return Result(
+                success=False,
+                error=f"Sherlock binary not found: {sherlock_bin}",
+            )
+
+        username = context.options.get("username") or ""
+        if not username:
+            return Result(success=False, error="Option 'username' is required.")
+
+        args = [username]
+        timeout = context.options.get("timeout")
+        if timeout:
+            args.extend(["--timeout", str(timeout)])
+        output = context.options.get("output")
+        if output:
+            args.extend(["--output", str(output)])
+        if parse_bool(context.options.get("json")):
+            args.append("--json")
+        if parse_bool(context.options.get("csv")):
+            args.append("--csv")
+        site = context.options.get("site")
+        if site:
+            for s in str(site).split(","):
+                args.extend(["--site", s.strip()])
+        if parse_bool(context.options.get("print_found")):
+            args.append("--print-found")
+
+        renderer = context.renderer
+        master, slave = pty.openpty()
+        try:
+            winsize = struct.pack("HHHH", 1000, 10000, 0, 0)
+            fcntl.ioctl(master, termios.TIOCSWINSZ, winsize)
+            attrs = termios.tcgetattr(master)
+            attrs[1] &= ~termios.OPOST
+            termios.tcsetattr(master, termios.TCSANOW, attrs)
+        except OSError:
+            pass
+
+        env = os.environ.copy()
+        env["TERM"] = "xterm-256color"
+        env["FORCE_COLOR"] = "1"
+        env["CLICOLOR"] = "1"
+        env["CLICOLOR_FORCE"] = "1"
+        env["COLUMNS"] = "10000"
+
+        try:
+            proc = subprocess.Popen(
+                [str(sherlock_bin), *args],
+                stdout=slave,
+                stderr=slave,
+                stdin=subprocess.DEVNULL,
+                cwd=str(install_dir),
+                env=env,
+                start_new_session=True,
+            )
+        except Exception as e:
+            return Result(success=False, error=f"Failed to run {name}: {e}")
+        finally:
+            with contextlib.suppress(OSError):
+                os.close(slave)
+
+        first = True
+        current = ""
+        started = False
+        pending_blank = False
+        try:
+            while True:
+                try:
+                    r, _, _ = select.select([master], [], [], 0.5)
+                except (OSError, ValueError):
+                    break
+                if not r:
+                    if proc.poll() is not None:
+                        break
+                    continue
+                try:
+                    chunk = os.read(master, 65536)
+                except OSError:
+                    break
+                if not chunk:
+                    break
+                if not started:
+                    chunk = chunk.lstrip(b"\n")
+                    started = True
+                for ch in chunk.decode("utf-8", errors="replace"):
+                    if ch == "\n":
+                        if current:
+                            if pending_blank:
+                                if renderer is not None:
+                                    renderer.gutter(name, "", tool_color, False)
+                                else:
+                                    print()
+                                pending_blank = False
+                            if renderer is not None:
+                                renderer.gutter(name, _clean_ansi(current), tool_color, first)
+                            else:
+                                print(_clean_ansi(current))
+                            first = False
+                        else:
+                            pending_blank = True
+                        current = ""
+                    elif ch == "\r":
+                        current = ""
+                    else:
+                        current += ch
+        except KeyboardInterrupt:
+            with contextlib.suppress(OSError):
+                proc.kill()
+            current = ""
+            if renderer is not None:
+                print("\r\033[K", end="")
+                renderer.gutter(name, "Run aborted (Ctrl+C).", tool_color, first)
+            else:
+                print("Run aborted (Ctrl+C).")
+            return Result(success=True, data={})
+        finally:
+            if current:
+                if renderer is not None:
+                    renderer.gutter(name, _clean_ansi(current), tool_color, first)
+                else:
+                    print(_clean_ansi(current))
+            with contextlib.suppress(OSError):
+                os.close(master)
+            with contextlib.suppress(OSError):
+                proc.wait()
+
+        return Result(success=True, data={})

{sharkit-0.2.0.dev1 → sharkit-0.2.1.dev1}/src/sharkit/tools/registry.py

@@ -71,3 +71,17 @@ class ToolRegistry:
         for path, name in self._paths.items():
             result[path] = self._tools[name]
         return result
+
+    def get_tool_path(self, name: str) -> str:
+        """Return the full path for a tool name, or just the name if no path."""
+        for path, tool_name in self._paths.items():
+            if tool_name == name:
+                return path
+        return name
+
+    def format_display(self, path: str) -> str:
+        """Format tool path as 'category(subpath)' for display."""
+        if "/" in path:
+            parts = path.split("/", 1)
+            return f"{parts[0]}({parts[1]})"
+        return path