igtools-pip 1.0.0__tar.gz

igtools_pip-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 spyboy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

igtools_pip-1.0.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: igtools-pip
+Version: 1.0.0
+Summary: Instagram Privacy & OSINT Tool: Hide followers/following lists and find user comments via Google Dork queries.
+Author-email: spyboy <spyboy.co@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/IM-SPYBOY/igtools
+Project-URL: Telegram, https://t.me/spytube
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: instagrapi
+Requires-Dist: googlesearch-python
+Requires-Dist: colorama
+Requires-Dist: termcolor
+Dynamic: license-file
+
+# IGTools - Instagram Privacy & OSINT Tool 🔍🔒
+
+**IGTools** (`igtools`) is a Python CLI tool and library built by **SPYBOY** that combines:
+1. **Hide / Unhide Followers & Following List**: Enables or disables the `hide_followers_following_list` privacy setting on your Instagram account via Instagram's GraphQL Pando API.
+2. **Find Comments on Posts via Google Query (Dork Search)**: Unlimited real-time Google Dork search (`site:instagram.com intext:<username>`) to discover posts where a target user has left comments or been mentioned.
+3. **Session Persistence (`session.json`)**: Log in once with your Instagram username & password (using `instagrapi`, just like `instaspy-pip`) or with a `sessionid` cookie, and automatically reuse `session.json` across runs.
+
+---
+
+## Installation
+
+Install directly from PyPI:
+
+```bash
+pip install igtools-pip
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/IM-SPYBOY/igtools.git
+cd igtools
+pip install .
+```
+
+---
+
+## Usage
+
+### 1. Interactive Menu (like `instaspy-pip`)
+
+Simply run:
+
+```bash
+igtools
+```
+
+You will see the interactive menu:
+1. **Hide Followers & Following List (Enable)**
+2. **Unhide Followers & Following List (Disable)**
+3. **Find Comments on Posts via Google Query (Dork Search)**
+4. **Login / Switch Instagram Session**
+5. **Exit**
+
+### 2. Direct CLI Subcommands
+
+- **Log in & save `session.json`:**
+  ```bash
+  igtools login
+  ```
+- **Hide your followers & following list (uses saved `session.json` or prompts to log in):**
+  ```bash
+  igtools hide-lists
+  ```
+- **Unhide your followers & following list:**
+  ```bash
+  igtools hide-lists --disable
+  ```
+- **Find posts where a user commented via Google Dork query:**
+  ```bash
+  igtools dork <target_username>
+  # or
+  igtools find-comments <target_username>
+  ```
+
+---
+
+## Configuration & Security
+
+- Your Instagram session is saved locally in `session.json`. Keep this file secure and never commit it to public repositories.
+- You can also specify a custom session file path via `igtools --session-file /path/to/session.json`.
+
+## Author
+- **SPYBOY**
+- [Telegram Channel](https://t.me/spytube)
+- [GitHub](https://github.com/IM-SPYBOY)

igtools_pip-1.0.0/README.md

@@ -0,0 +1,76 @@
+# IGTools - Instagram Privacy & OSINT Tool 🔍🔒
+
+**IGTools** (`igtools`) is a Python CLI tool and library built by **SPYBOY** that combines:
+1. **Hide / Unhide Followers & Following List**: Enables or disables the `hide_followers_following_list` privacy setting on your Instagram account via Instagram's GraphQL Pando API.
+2. **Find Comments on Posts via Google Query (Dork Search)**: Unlimited real-time Google Dork search (`site:instagram.com intext:<username>`) to discover posts where a target user has left comments or been mentioned.
+3. **Session Persistence (`session.json`)**: Log in once with your Instagram username & password (using `instagrapi`, just like `instaspy-pip`) or with a `sessionid` cookie, and automatically reuse `session.json` across runs.
+
+---
+
+## Installation
+
+Install directly from PyPI:
+
+```bash
+pip install igtools-pip
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/IM-SPYBOY/igtools.git
+cd igtools
+pip install .
+```
+
+---
+
+## Usage
+
+### 1. Interactive Menu (like `instaspy-pip`)
+
+Simply run:
+
+```bash
+igtools
+```
+
+You will see the interactive menu:
+1. **Hide Followers & Following List (Enable)**
+2. **Unhide Followers & Following List (Disable)**
+3. **Find Comments on Posts via Google Query (Dork Search)**
+4. **Login / Switch Instagram Session**
+5. **Exit**
+
+### 2. Direct CLI Subcommands
+
+- **Log in & save `session.json`:**
+  ```bash
+  igtools login
+  ```
+- **Hide your followers & following list (uses saved `session.json` or prompts to log in):**
+  ```bash
+  igtools hide-lists
+  ```
+- **Unhide your followers & following list:**
+  ```bash
+  igtools hide-lists --disable
+  ```
+- **Find posts where a user commented via Google Dork query:**
+  ```bash
+  igtools dork <target_username>
+  # or
+  igtools find-comments <target_username>
+  ```
+
+---
+
+## Configuration & Security
+
+- Your Instagram session is saved locally in `session.json`. Keep this file secure and never commit it to public repositories.
+- You can also specify a custom session file path via `igtools --session-file /path/to/session.json`.
+
+## Author
+- **SPYBOY**
+- [Telegram Channel](https://t.me/spytube)
+- [GitHub](https://github.com/IM-SPYBOY)

igtools_pip-1.0.0/igtools/__init__.py

@@ -0,0 +1,19 @@
+from .cli import (
+    hide_lists,
+    collect_google_dork_data,
+    load_session,
+    save_session,
+    extract_sessionid,
+    main,
+)
+
+__version__ = "1.0.0"
+__author__ = "SPYBOY"
+__all__ = [
+    "hide_lists",
+    "collect_google_dork_data",
+    "load_session",
+    "save_session",
+    "extract_sessionid",
+    "main",
+]

igtools_pip-1.0.0/igtools/cli.py

@@ -0,0 +1,608 @@
+import argparse
+import base64
+import getpass
+import json
+import os
+import random
+import re
+import sys
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Optional
+
+from colorama import Fore, Style, init
+from termcolor import colored
+
+# All Copyright (C) 2024-2026 by the author(s) of this script. All rights reserved.
+# Telegram channel: https://t.me/spytube
+
+# Initialize colorama
+init(autoreset=True)
+
+IS_WINDOWS = os.name == "nt"
+DEFAULT_SESSION_FILE = "session.json"
+
+
+def clear_screen() -> None:
+    os.system("cls" if IS_WINDOWS else "clear")
+
+
+def show_banner() -> None:
+    clear_screen()
+    print(
+        colored(
+            r"""
+ @@@   @@@@@@@@  @@@@@@@   @@@@@@    @@@@@@   @@@        @@@@@@   
+ @@@  @@@@@@@@@  @@@@@@@  @@@@@@@@  @@@@@@@@  @@@       @@@@@@@   
+ @@!  !@@          @@!    @@!  @@@  @@!  @@@  @@!       !@@       
+ !@!  !@!          !@!    !@!  @!@  !@!  @!@  !@!       !@!       
+ !!@  !@! @!@!@    @!!    @!@  !@!  @!@  !@!  @!!       !!@@!!    
+ !!!  !!! !!@!!    !!!    !@!  !!!  !@!  !!!  !!!        !!@!!!   
+ !!:  :!!   !!:    !!:    !!:  !!!  !!:  !!!  !!:            !:!  
+ :!:  :!:   !::    :!:    :!:  !:!  :!:  !:!   :!:          !:!   
+  ::   ::: ::::     ::    ::::: ::  ::::: ::   :: ::::  :::: ::   
+ :     :: :: :      :      : :  :    : :  :   : :: : :  :: : :    
+
+                        IGTools v1.0.0 by SPYBOY
+""",
+            "cyan",
+        )
+    )
+    print(f"{Fore.YELLOW}Platform: {sys.platform}")
+    print(f"{Fore.GREEN}Python: {sys.version.split()[0]}")
+    print(f"{Fore.CYAN}Telegram: https://t.me/spytube\n")
+    print(f"{Fore.MAGENTA}Instagram Privacy & OSINT Suite | Session-backed | Real-time output\n")
+
+
+# ==================== SESSION MANAGEMENT ====================
+def save_session(client, session_file: str = DEFAULT_SESSION_FILE, raw_sessionid: Optional[str] = None) -> bool:
+    """Save session data from instagrapi Client (or raw sessionid) to file."""
+    try:
+        settings = client.get_settings() if client is not None else {}
+        if raw_sessionid:
+            settings.setdefault("authorization_data", {})["sessionid"] = raw_sessionid
+            match = re.fullmatch(r"([1-9][0-9]*)(?::|%3[aA]).+", raw_sessionid)
+            if match:
+                settings["authorization_data"]["ds_user_id"] = match.group(1)
+            settings.setdefault("cookies", {})["sessionid"] = raw_sessionid
+        with open(session_file, "w", encoding="utf-8") as f:
+            json.dump(settings, f, indent=2)
+        print(f"{Fore.GREEN}✓ Session saved successfully to {session_file}")
+        return True
+    except Exception as e:
+        print(f"{Fore.RED}✗ Error saving session: {e}")
+        return False
+
+
+def extract_sessionid_from_dict(data: dict) -> Optional[str]:
+    """Extract sessionid cookie value from instagrapi settings dict or custom dict."""
+    if not isinstance(data, dict):
+        return None
+    # 1. Direct sessionid key
+    if isinstance(data.get("sessionid"), str) and data["sessionid"].strip():
+        return data["sessionid"].strip()
+    # 2. instagrapi authorization_data.sessionid
+    auth_data = data.get("authorization_data")
+    if isinstance(auth_data, dict):
+        sid = auth_data.get("sessionid")
+        if isinstance(sid, str) and sid.strip():
+            return sid.strip()
+    # 3. cookies.sessionid
+    cookies = data.get("cookies")
+    if isinstance(cookies, dict):
+        sid = cookies.get("sessionid")
+        if isinstance(sid, str) and sid.strip():
+            return sid.strip()
+    # 4. Pre-built Bearer IGT:2:<base64> header in authorization_data or headers
+    for container in (data, auth_data if isinstance(auth_data, dict) else {}):
+        auth_header = container.get("Authorization") or container.get("authorization")
+        if isinstance(auth_header, str) and "IGT:2:" in auth_header:
+            b64_part = auth_header.split("IGT:2:", 1)[1].strip()
+            try:
+                decoded = json.loads(base64.b64decode(b64_part).decode("utf-8"))
+                if isinstance(decoded, dict) and isinstance(decoded.get("sessionid"), str):
+                    return decoded["sessionid"].strip()
+            except Exception:
+                pass
+    return None
+
+
+def extract_sessionid(client=None, session_file: str = DEFAULT_SESSION_FILE) -> Optional[str]:
+    """Extract sessionid from an active instagrapi Client or from session_file."""
+    if client is not None:
+        # Check client.sessionid attribute if present
+        sid = getattr(client, "sessionid", None)
+        if isinstance(sid, str) and sid.strip():
+            return sid.strip()
+        try:
+            settings = client.get_settings()
+            sid = extract_sessionid_from_dict(settings)
+            if sid:
+                return sid
+        except Exception:
+            pass
+    if session_file and os.path.exists(session_file):
+        try:
+            with open(session_file, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            return extract_sessionid_from_dict(data)
+        except Exception:
+            pass
+    return None
+
+
+def load_session(client=None, session_file: str = DEFAULT_SESSION_FILE) -> Optional[str]:
+    """Load session data from session.json into instagrapi client and return sessionid."""
+    if not os.path.exists(session_file):
+        return None
+    try:
+        with open(session_file, "r", encoding="utf-8") as f:
+            settings = json.load(f)
+        if client is not None and isinstance(settings, dict):
+            try:
+                client.set_settings(settings)
+            except Exception:
+                pass
+        sid = extract_sessionid_from_dict(settings)
+        if sid:
+            print(f"{Fore.GREEN}✓ Session restored from {session_file}")
+            return sid
+    except Exception as e:
+        print(f"{Fore.RED}✗ Error loading session: {e}")
+    return None
+
+
+def login_and_get_session(
+    session_file: str = DEFAULT_SESSION_FILE,
+    force_login: bool = False,
+    username: Optional[str] = None,
+    password: Optional[str] = None,
+    sessionid_arg: Optional[str] = None,
+) -> str:
+    """
+    Authenticate with Instagram (like instaspy-pip) using session.json,
+    instagrapi username/password login, or a direct sessionid cookie value.
+    Returns the active sessionid string.
+    """
+    if sessionid_arg:
+        sid = sessionid_arg.strip()
+        save_session(None, session_file=session_file, raw_sessionid=sid)
+        return sid
+
+    try:
+        from instagrapi import Client
+        client = Client()
+        client.delay_range = [1, 3]
+    except Exception:
+        client = None
+
+    if not force_login:
+        existing_sid = load_session(client, session_file=session_file)
+        if existing_sid:
+            return existing_sid
+
+    print(f"\n{Fore.CYAN}➤ Login required to access Instagram API")
+    print(f"{Fore.YELLOW}  [1] Login with Instagram Username & Password (saves to {session_file})")
+    print(f"{Fore.YELLOW}  [2] Login with Instagram sessionid cookie directly")
+
+    mode = "1"
+    if not username and not password:
+        choice = input(f"\n{Fore.GREEN}Select login method (1 or 2) [default: 1]: {Style.RESET_ALL}").strip()
+        if choice == "2":
+            mode = "2"
+
+    if mode == "2":
+        sid = getpass.getpass(f"{Fore.GREEN}Your Instagram sessionid value: {Style.RESET_ALL}").strip()
+        if not sid:
+            raise RuntimeError("No sessionid provided.")
+        if client is not None:
+            try:
+                client.login_by_sessionid(sid)
+            except Exception:
+                pass
+        save_session(client, session_file=session_file, raw_sessionid=sid)
+        return sid
+
+    # Mode 1: Username & Password via instagrapi (like instaspy-pip)
+    if client is None:
+        raise RuntimeError("instagrapi is not installed. Run 'pip install instagrapi' or use sessionid login.")
+
+    if not username:
+        username = input(f"{Fore.GREEN}Enter your Instagram username: {Style.RESET_ALL}").strip()
+    if not password:
+        password = getpass.getpass(f"{Fore.GREEN}Enter your Instagram password: {Style.RESET_ALL}").strip()
+
+    try:
+        print(f"{Fore.CYAN}[•] Attempting login as @{username}...")
+        try:
+            client.login(username, password)
+        except Exception as login_err:
+            err_msg = str(login_err).lower()
+            if "two-factor" in err_msg or "two_factor" in err_msg or "verification_code" in err_msg:
+                code = input(f"{Fore.YELLOW}Enter 2FA verification code: {Style.RESET_ALL}").strip()
+                client.login(username, password, verification_code=code)
+            else:
+                raise
+        print(f"{Fore.GREEN}✓ Login successful")
+        save_session(client, session_file=session_file)
+        sid = extract_sessionid(client, session_file=session_file)
+        if not sid:
+            raise RuntimeError("Logged in, but could not locate sessionid in client settings.")
+        return sid
+    except Exception as e:
+        print(f"{Fore.RED}✗ Username/password login failed: {e}")
+        fallback = input(
+            f"{Fore.YELLOW}Would you like to paste your 'sessionid' cookie instead? (y/n): {Style.RESET_ALL}"
+        ).strip().lower()
+        if fallback == "y":
+            sid = getpass.getpass("Your Instagram sessionid value: ").strip()
+            save_session(None, session_file=session_file, raw_sessionid=sid)
+            return sid
+        raise RuntimeError(f"Login failed: {e}") from None
+
+
+# ==================== HIDE FOLLOWERS / FOLLOWING LIST ====================
+def hide_lists(sessionid: str, enable: bool = True) -> dict:
+    """
+    Enable (or disable) the "hide followers/following list" setting on Instagram
+    for the user associated with the provided sessionid cookie value.
+    """
+    if not sessionid or any(ord(c) <= 32 or ord(c) >= 127 or c in ';,"\\' for c in sessionid):
+        raise ValueError("Enter only the sessionid cookie value, without 'sessionid='.")
+    match = re.fullmatch(r"([1-9][0-9]*)(?::|%3[aA]).+", sessionid)
+    if not match:
+        raise ValueError("Invalid sessionid format: expected a numeric user ID followed by ':' or '%3A'.")
+    user_id = match.group(1)
+    token = base64.b64encode(
+        json.dumps(
+            {
+                "ds_user_id": user_id,
+                "sessionid": sessionid,
+                "should_use_header_over_cookies": True,
+            },
+            separators=(",", ":"),
+        ).encode()
+    ).decode("ascii")
+    authorization = "Bearer IGT:2:" + token
+    name = "IGSettingsBooleanMutation"
+    form = {
+        "method": "post",
+        "format": "json",
+        "server_timestamps": "true",
+        "locale": "user",
+        "fb_api_req_friendly_name": name,
+        "client_doc_id": "2669261950526978627082629536",
+        "variables": json.dumps(
+            {
+                "setting_id": "hide_followers_following_list",
+                "allow_error_codes": True,
+                "callsite": "account_privacy",
+                "value": bool(enable),
+            }
+        ),
+    }
+    request = urllib.request.Request(
+        "https://i.instagram.com/graphql/query",
+        data=urllib.parse.urlencode(form).encode(),
+        headers={
+            "Authorization": authorization,
+            "Cookie": f"sessionid={sessionid}; ds_user_id={user_id}",
+            "IG-INTENDED-USER-ID": user_id,
+            "X-IG-App-ID": "124024574287414",
+            "X-Auth-Type": "instagram",
+            "User-Agent": "Instagram 453.0.0",
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Accept-Encoding": "identity",
+            "X-GraphQL-Client-Library": "pando",
+            "X-FB-Friendly-Name": name,
+        },
+        method="POST",
+    )
+
+    class NoRedirect(urllib.request.HTTPRedirectHandler):
+        def redirect_request(self, *args, **kwargs):
+            raise RuntimeError("Redirect refused; credentials were not forwarded.")
+
+    opener = urllib.request.build_opener(urllib.request.ProxyHandler({}), NoRedirect())
+    try:
+        with opener.open(request, timeout=15) as response:
+            raw = response.read(1024 * 1024 + 1)
+            if len(raw) > 1024 * 1024:
+                raise RuntimeError("Response too large.")
+            return json.loads(raw)
+    except urllib.error.HTTPError as error:
+        code = error.code
+        with error:
+            raw = error.read(16385)
+        details = {}
+        try:
+            body = json.loads(raw) if len(raw) <= 16384 else {}
+            if isinstance(body, dict):
+                for key in ("message", "error_type", "status", "code"):
+                    if isinstance(body.get(key), (str, int, bool)):
+                        details[key] = body[key]
+        except (ValueError, UnicodeError):
+            pass
+        text = json.dumps(details) if details else "No selected JSON error details."
+        secrets = {
+            authorization,
+            token,
+            sessionid,
+            urllib.parse.unquote(sessionid),
+            urllib.parse.quote(sessionid, safe=""),
+        }
+        for secret in sorted(secrets, key=len, reverse=True):
+            if secret:
+                text = text.replace(secret, "<REDACTED>")
+        raise RuntimeError(f"HTTP {code}: {text[:1500]}. No retry performed.") from None
+
+
+def run_hide_lists(sessionid: str, enable: bool = True) -> int:
+    """Execute hide_lists and validate the GraphQL response."""
+    try:
+        action_label = "Enabling" if enable else "Disabling"
+        print(f"{Fore.CYAN}[•] {action_label} 'hide_followers_following_list' setting on Instagram...")
+        body = hide_lists(sessionid, enable=enable)
+        data = body.get("data") if isinstance(body, dict) else None
+        root = "xdt_api__v1__settings__set_bool"
+        matches = (
+            [value for key, value in data.items() if key == root or key.startswith(root + "(")]
+            if isinstance(data, dict)
+            else []
+        )
+        result = matches[0] if len(matches) == 1 and isinstance(matches[0], dict) else {}
+        expected_val = bool(enable)
+        if (
+            not isinstance(body, dict)
+            or body.get("errors")
+            or body.get("error")
+            or body.get("status") == "fail"
+            or result.get("value") is not expected_val
+            or any(
+                result.get(key)
+                for key in (
+                    "error_name_value",
+                    "errorNameValue",
+                    "fallback_message",
+                    "fallbackMessage",
+                )
+            )
+        ):
+            raise RuntimeError(
+                f"Instagram did not confirm setting value={expected_val}. No retry performed."
+            )
+        state_str = "Enabled" if enable else "Disabled"
+        print(f"{Fore.GREEN}✓ {state_str}: Instagram returned value={str(expected_val).lower()}.")
+        return 0
+    except RuntimeError as error:
+        print(f"{Fore.RED}✗ {error}", file=sys.stderr)
+    except (urllib.error.URLError, TimeoutError, OSError):
+        print(f"{Fore.RED}✗ Network/TLS failure. No retry performed.", file=sys.stderr)
+    except json.JSONDecodeError:
+        print(f"{Fore.RED}✗ Invalid JSON response. No retry performed.", file=sys.stderr)
+    except ValueError as error:
+        print(f"{Fore.RED}✗ {error}", file=sys.stderr)
+    return 1
+
+
+# ==================== GOOGLE DORK SEARCH (FIND COMMENTS ON POSTS) ====================
+def _iter_google_search(query: str):
+    """Support both googlesearch-python and google package signatures."""
+    from googlesearch import search
+    import inspect
+
+    sig = inspect.signature(search)
+    if "num_results" in sig.parameters:
+        # googlesearch-python (e.g., search(term, num_results=100, sleep_interval=5))
+        for url in search(query, num_results=100, sleep_interval=2):
+            yield url
+    else:
+        # classic google package (search(query, num=100, stop=None, pause=5))
+        for url in search(query, num=100, stop=None, pause=5):
+            yield url
+
+
+def collect_google_dork_data(username: str) -> int:
+    """Find posts where the target user has commented/appeared using Google Dork queries."""
+    username = username.lstrip("@").strip()
+    if not username:
+        print(f"{Fore.RED}✗ Target username cannot be empty.", file=sys.stderr)
+        return 1
+    try:
+        print(f"\n{Fore.CYAN}➤ Starting Google dork search for comments/mentions of @{username}...")
+        query = f"site:instagram.com intext:{username}"
+        results = []
+
+        print(f"{Fore.YELLOW}⚡ Search query: {query}")
+        print(f"{Fore.YELLOW}⚠ This may take several minutes. Press Ctrl+C to stop early.\n")
+
+        try:
+            for idx, url in enumerate(_iter_google_search(query), 1):
+                results.append(url)
+                print(f"{Fore.GREEN}[{idx}] {url}")
+
+                # Save progress every 10 results
+                if idx % 10 == 0:
+                    with open(f"{username}_dork_results.txt", "w", encoding="utf-8") as f:
+                        f.write("\n".join(results))
+                    print(f"{Fore.YELLOW}⚡ Saved {idx} results so far...")
+
+                delay = random.uniform(1, 5)
+                time.sleep(delay)
+
+        except KeyboardInterrupt:
+            print(f"\n{Fore.YELLOW}⚠ Search interrupted by user")
+        except Exception as e:
+            print(f"{Fore.RED}✗ Search error: {e}")
+
+        results_file = f"{username}_dork_results.txt"
+        with open(results_file, "w", encoding="utf-8") as f:
+            f.write(f"Google Dork Results for @{username}\n")
+            f.write("=" * 70 + "\n")
+            f.write(f"Search Query: {query}\n")
+            f.write(f"Total Results: {len(results)}\n\n")
+            f.write("\n".join(results))
+
+        print(f"\n{Fore.MAGENTA}★ Search Complete ★")
+        print(f"{Fore.CYAN}→ Total results collected: {len(results)}")
+        print(f"{Fore.CYAN}→ Results saved to: {results_file}")
+        return 0
+    except Exception as e:
+        print(f"{Fore.RED}✗ Fatal error during search: {e}", file=sys.stderr)
+        return 1
+
+
+# ==================== INTERACTIVE MENU & CLI ====================
+def display_menu(session_file: str) -> str:
+    has_session = os.path.exists(session_file)
+    status = f"{Fore.GREEN}Active ({session_file})" if has_session else f"{Fore.RED}Not logged in"
+    print(f"\n{Fore.CYAN}┌{'─' * 62}┐")
+    print(f"│{Fore.MAGENTA} IGTOOLS MENU {Fore.CYAN}{' ' * 48}│")
+    print(f"├{'─' * 62}┤")
+    print(f"│ Session Status: {status}{' ' * max(1, 45 - len(session_file) - (9 if has_session else 13))}{Fore.CYAN}│")
+    print(f"├{'─' * 62}┤")
+    print(f"│ {Fore.GREEN}1. Hide Followers & Following List (Enable){Fore.CYAN}                  │")
+    print(f"│ {Fore.GREEN}2. Unhide Followers & Following List (Disable){Fore.CYAN}               │")
+    print(f"│ {Fore.GREEN}3. Find Comments on Posts via Google Query (Dork Search){Fore.CYAN}     │")
+    print(f"│ {Fore.GREEN}4. Login / Switch Instagram Session{Fore.CYAN}                          │")
+    print(f"│ {Fore.GREEN}5. Exit{Fore.CYAN}                                                      │")
+    print(f"└{'─' * 62}┘")
+    return input(f"{Fore.YELLOW}Select option (1-5): {Style.RESET_ALL}").strip()
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="igtools",
+        description="IGTools: Hide Instagram followers/following lists & find user comments via Google Dork queries.",
+    )
+    parser.add_argument(
+        "--session-file",
+        default=DEFAULT_SESSION_FILE,
+        help=f"Path to session JSON file (default: {DEFAULT_SESSION_FILE})",
+    )
+    parser.add_argument(
+        "--sessionid",
+        help="Directly pass Instagram sessionid cookie value (saves to session.json)",
+    )
+    parser.add_argument(
+        "-u", "--username",
+        help="Instagram username for login",
+    )
+    parser.add_argument(
+        "-p", "--password",
+        help="Instagram password for login",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Optional subcommand (runs interactive menu if omitted)")
+
+    # login subcommand
+    subparsers.add_parser("login", help="Log in to Instagram and save session to session.json")
+
+    # hide-lists subcommand
+    hide_parser = subparsers.add_parser(
+        "hide-lists",
+        help="Enable or disable hiding your followers/following list on Instagram",
+    )
+    hide_parser.add_argument(
+        "--disable",
+        action="store_true",
+        help="Disable hiding (unhide followers/following list)",
+    )
+
+    # dork / find-comments subcommand
+    dork_parser = subparsers.add_parser(
+        "dork",
+        aliases=["find-comments"],
+        help="Find posts where a target user commented using Google Dork search",
+    )
+    dork_parser.add_argument(
+        "target",
+        help="Target Instagram username to search for",
+    )
+
+    return parser
+
+
+def main(argv: Optional[list] = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    session_file = args.session_file
+
+    # Subcommand mode
+    if args.command == "login":
+        try:
+            login_and_get_session(
+                session_file=session_file,
+                force_login=True,
+                username=args.username,
+                password=args.password,
+                sessionid_arg=args.sessionid,
+            )
+            return 0
+        except Exception as e:
+            print(f"{Fore.RED}✗ {e}", file=sys.stderr)
+            return 1
+
+    if args.command == "hide-lists":
+        try:
+            sid = login_and_get_session(
+                session_file=session_file,
+                force_login=False,
+                username=args.username,
+                password=args.password,
+                sessionid_arg=args.sessionid,
+            )
+            return run_hide_lists(sid, enable=not args.disable)
+        except Exception as e:
+            print(f"{Fore.RED}✗ {e}", file=sys.stderr)
+            return 1
+
+    if args.command in ("dork", "find-comments"):
+        return collect_google_dork_data(args.target)
+
+    # Interactive mode (like instaspy-pip)
+    show_banner()
+
+    while True:
+        choice = display_menu(session_file)
+
+        if choice == "1":
+            try:
+                sid = login_and_get_session(session_file=session_file, sessionid_arg=args.sessionid)
+                run_hide_lists(sid, enable=True)
+            except Exception as e:
+                print(f"{Fore.RED}✗ {e}", file=sys.stderr)
+        elif choice == "2":
+            try:
+                sid = login_and_get_session(session_file=session_file, sessionid_arg=args.sessionid)
+                run_hide_lists(sid, enable=False)
+            except Exception as e:
+                print(f"{Fore.RED}✗ {e}", file=sys.stderr)
+        elif choice == "3":
+            target = input(f"\n{Fore.CYAN}➤ Enter target Instagram username: {Style.RESET_ALL}").strip()
+            if target:
+                collect_google_dork_data(target)
+            else:
+                print(f"{Fore.RED}✗ Username cannot be empty.")
+        elif choice == "4":
+            try:
+                login_and_get_session(session_file=session_file, force_login=True)
+            except Exception as e:
+                print(f"{Fore.RED}✗ {e}", file=sys.stderr)
+        elif choice == "5":
+            print(f"\n{Fore.GREEN}✓ Thank you for using IGTools. Goodbye!")
+            return 0
+        else:
+            print(f"{Fore.RED}✗ Invalid option. Please select 1-5.")
+
+        input(f"\n{Fore.YELLOW}Press Enter to return to menu...")
+        show_banner()
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except KeyboardInterrupt:
+        raise SystemExit("\nInterrupted. If an update was in progress, check before retrying.")

igtools_pip-1.0.0/igtools_pip.egg-info/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: igtools-pip
+Version: 1.0.0
+Summary: Instagram Privacy & OSINT Tool: Hide followers/following lists and find user comments via Google Dork queries.
+Author-email: spyboy <spyboy.co@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/IM-SPYBOY/igtools
+Project-URL: Telegram, https://t.me/spytube
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: instagrapi
+Requires-Dist: googlesearch-python
+Requires-Dist: colorama
+Requires-Dist: termcolor
+Dynamic: license-file
+
+# IGTools - Instagram Privacy & OSINT Tool 🔍🔒
+
+**IGTools** (`igtools`) is a Python CLI tool and library built by **SPYBOY** that combines:
+1. **Hide / Unhide Followers & Following List**: Enables or disables the `hide_followers_following_list` privacy setting on your Instagram account via Instagram's GraphQL Pando API.
+2. **Find Comments on Posts via Google Query (Dork Search)**: Unlimited real-time Google Dork search (`site:instagram.com intext:<username>`) to discover posts where a target user has left comments or been mentioned.
+3. **Session Persistence (`session.json`)**: Log in once with your Instagram username & password (using `instagrapi`, just like `instaspy-pip`) or with a `sessionid` cookie, and automatically reuse `session.json` across runs.
+
+---
+
+## Installation
+
+Install directly from PyPI:
+
+```bash
+pip install igtools-pip
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/IM-SPYBOY/igtools.git
+cd igtools
+pip install .
+```
+
+---
+
+## Usage
+
+### 1. Interactive Menu (like `instaspy-pip`)
+
+Simply run:
+
+```bash
+igtools
+```
+
+You will see the interactive menu:
+1. **Hide Followers & Following List (Enable)**
+2. **Unhide Followers & Following List (Disable)**
+3. **Find Comments on Posts via Google Query (Dork Search)**
+4. **Login / Switch Instagram Session**
+5. **Exit**
+
+### 2. Direct CLI Subcommands
+
+- **Log in & save `session.json`:**
+  ```bash
+  igtools login
+  ```
+- **Hide your followers & following list (uses saved `session.json` or prompts to log in):**
+  ```bash
+  igtools hide-lists
+  ```
+- **Unhide your followers & following list:**
+  ```bash
+  igtools hide-lists --disable
+  ```
+- **Find posts where a user commented via Google Dork query:**
+  ```bash
+  igtools dork <target_username>
+  # or
+  igtools find-comments <target_username>
+  ```
+
+---
+
+## Configuration & Security
+
+- Your Instagram session is saved locally in `session.json`. Keep this file secure and never commit it to public repositories.
+- You can also specify a custom session file path via `igtools --session-file /path/to/session.json`.
+
+## Author
+- **SPYBOY**
+- [Telegram Channel](https://t.me/spytube)
+- [GitHub](https://github.com/IM-SPYBOY)

igtools_pip-1.0.0/igtools_pip.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+igtools/__init__.py
+igtools/cli.py
+igtools_pip.egg-info/PKG-INFO
+igtools_pip.egg-info/SOURCES.txt
+igtools_pip.egg-info/dependency_links.txt
+igtools_pip.egg-info/entry_points.txt
+igtools_pip.egg-info/requires.txt
+igtools_pip.egg-info/top_level.txt
+tests/test_igtools.py

igtools_pip-1.0.0/igtools_pip.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

igtools_pip-1.0.0/igtools_pip.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+igtools = igtools.cli:main
+igtools-pip = igtools.cli:main

igtools_pip-1.0.0/igtools_pip.egg-info/requires.txt

@@ -0,0 +1,5 @@
+requests
+instagrapi
+googlesearch-python
+colorama
+termcolor

igtools_pip-1.0.0/igtools_pip.egg-info/top_level.txt

@@ -0,0 +1 @@
+igtools

igtools_pip-1.0.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "igtools-pip"
+version = "1.0.0"
+description = "Instagram Privacy & OSINT Tool: Hide followers/following lists and find user comments via Google Dork queries."
+readme = "README.md"
+authors = [
+    { name = "spyboy", email = "spyboy.co@gmail.com" }
+]
+license = "MIT"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "requests",
+    "instagrapi",
+    "googlesearch-python",
+    "colorama",
+    "termcolor",
+]
+
+[project.urls]
+Homepage = "https://github.com/IM-SPYBOY/igtools"
+Telegram = "https://t.me/spytube"
+
+[project.scripts]
+igtools = "igtools.cli:main"
+igtools-pip = "igtools.cli:main"

igtools_pip-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

igtools_pip-1.0.0/setup.py

@@ -0,0 +1,4 @@
+from setuptools import setup
+
+setup()
+

igtools_pip-1.0.0/tests/test_igtools.py

@@ -0,0 +1,89 @@
+import base64
+import json
+import os
+import tempfile
+import unittest
+from unittest.mock import patch, MagicMock
+
+from igtools.cli import (
+    extract_sessionid,
+    extract_sessionid_from_dict,
+    hide_lists,
+    load_session,
+    run_hide_lists,
+    save_session,
+    build_parser,
+)
+
+
+class TestIGTools(unittest.TestCase):
+    def test_extract_sessionid_from_dict_variants(self):
+        # 1. Direct sessionid
+        self.assertEqual(
+            extract_sessionid_from_dict({"sessionid": "12345:abcde"}),
+            "12345:abcde",
+        )
+        # 2. instagrapi authorization_data
+        self.assertEqual(
+            extract_sessionid_from_dict(
+                {"authorization_data": {"ds_user_id": "12345", "sessionid": "12345%3Aabcde"}}
+            ),
+            "12345%3Aabcde",
+        )
+        # 3. cookies dict
+        self.assertEqual(
+            extract_sessionid_from_dict({"cookies": {"sessionid": "99999:xyz"}}),
+            "99999:xyz",
+        )
+        # 4. Bearer IGT:2:<base64>
+        token = base64.b64encode(json.dumps({"sessionid": "77777:tok"}).encode()).decode()
+        self.assertEqual(
+            extract_sessionid_from_dict({"Authorization": f"Bearer IGT:2:{token}"}),
+            "77777:tok",
+        )
+
+    def test_save_and_load_session(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            session_path = os.path.join(tmpdir, "session.json")
+            saved = save_session(None, session_file=session_path, raw_sessionid="123456789:testsecret")
+            self.assertTrue(saved)
+            loaded = load_session(None, session_file=session_path)
+            self.assertEqual(loaded, "123456789:testsecret")
+            extracted = extract_sessionid(None, session_file=session_path)
+            self.assertEqual(extracted, "123456789:testsecret")
+
+    def test_hide_lists_validation(self):
+        with self.assertRaises(ValueError):
+            hide_lists("")
+        with self.assertRaises(ValueError):
+            hide_lists("sessionid=12345:abc")
+        with self.assertRaises(ValueError):
+            hide_lists("invalid_format_no_colon")
+
+    @patch("urllib.request.build_opener")
+    def test_run_hide_lists_success(self, mock_build_opener):
+        mock_response = MagicMock()
+        mock_response.__enter__.return_value = mock_response
+        mock_response.read.return_value = json.dumps(
+            {"data": {"xdt_api__v1__settings__set_bool": {"value": True}}}
+        ).encode("utf-8")
+        mock_opener = MagicMock()
+        mock_opener.open.return_value = mock_response
+        mock_build_opener.return_value = mock_opener
+
+        rc = run_hide_lists("12345678:validtoken", enable=True)
+        self.assertEqual(rc, 0)
+
+    def test_cli_parser(self):
+        parser = build_parser()
+        args = parser.parse_args(["hide-lists", "--disable"])
+        self.assertEqual(args.command, "hide-lists")
+        self.assertTrue(args.disable)
+
+        args_dork = parser.parse_args(["dork", "target_user"])
+        self.assertEqual(args_dork.command, "dork")
+        self.assertEqual(args_dork.target, "target_user")
+
+
+if __name__ == "__main__":
+    unittest.main()