termux-mcp 0.1.0__tar.gz

termux_mcp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bhai4You
+
+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.

termux_mcp-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include LICENSE
+include setup.cfg
+recursive-include termux_mcp *.py

termux_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.1
+Name: termux-mcp
+Version: 0.1.0
+Summary: Powerful MCP server for Termux — let AI agents run shell commands on your Android device in real time.
+Home-page: https://github.com/Bhai4You/Termux-mcp
+Author: Bhai4You
+Author-email: parixit1337@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# termux-mcp
+
+Powerful MCP server for Termux — let AI agents run shell commands on your Android device in real time.
+
+## Installation
+
+```bash
+pip install termux-mcp
+```
+
+## Usage
+
+```python
+import termux_mcp
+
+# Your code here
+```
+
+## Requirements
+
+No external dependencies required.
+
+## Author
+
+**Bhai4You** - [parixit1337@gmail.com](mailto:parixit1337@gmail.com)
+
+## Links
+
+- [Homepage](https://github.com/Bhai4You/Termux-mcp)
+- [PyPI](https://pypi.org/project/termux-mcp/)
+
+## License
+
+This project is licensed under the MIT License.

termux_mcp-0.1.0/README.md

@@ -0,0 +1,34 @@
+# termux-mcp
+
+Powerful MCP server for Termux — let AI agents run shell commands on your Android device in real time.
+
+## Installation
+
+```bash
+pip install termux-mcp
+```
+
+## Usage
+
+```python
+import termux_mcp
+
+# Your code here
+```
+
+## Requirements
+
+No external dependencies required.
+
+## Author
+
+**Bhai4You** - [parixit1337@gmail.com](mailto:parixit1337@gmail.com)
+
+## Links
+
+- [Homepage](https://github.com/Bhai4You/Termux-mcp)
+- [PyPI](https://pypi.org/project/termux-mcp/)
+
+## License
+
+This project is licensed under the MIT License.

termux_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "termux-mcp"
+version = "0.1.0"
+description = "Powerful MCP server for Termux — let AI agents run shell commands on your Android device in real time."
+readme = "README.md"
+license = { text = "MIT" }
+authors = [
+  { name = "Bhai4You", email = "parixit1337@gmail.com" }
+]
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/Bhai4You/Termux-mcp"
+Issues = "https://github.com/Bhai4You/Termux-mcp/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["termux_mcp*"]

termux_mcp-0.1.0/setup.cfg

@@ -0,0 +1,24 @@
+[metadata]
+name = termux-mcp
+version = 0.1.0
+author = Bhai4You
+author_email = parixit1337@gmail.com
+description = Powerful MCP server for Termux — let AI agents run shell commands on your Android device in real time.
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://github.com/Bhai4You/Termux-mcp
+classifiers =
+    Programming Language :: Python :: 3
+    License :: OSI Approved :: MIT License
+    Operating System :: OS Independent
+license = MIT
+
+[options]
+packages = find:
+python_requires = >=3.7
+
+
+[options.packages.find]
+exclude =
+    tests*
+    test*

termux_mcp-0.1.0/setup.py

@@ -0,0 +1,23 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="termux-mcp",
+    version="0.1.0",
+    author="Bhai4You",
+    author_email="parixit1337@gmail.com",
+    description="Powerful MCP server for Termux — let AI agents run shell commands on your Android device in real time.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/Bhai4You/Termux-mcp",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.7",
+    install_requires=[],
+)

termux_mcp-0.1.0/termux_mcp/__init__.py

@@ -0,0 +1,17 @@
+"""
+termux-mcp - Powerful MCP server for Termux — let AI agents run shell commands on your Android device in real time.
+Author: Bhai4You <parixit1337@gmail.com>
+"""
+
+__version__ = "0.1.0"
+__author__ = "Bhai4You"
+__email__ = "parixit1337@gmail.com"
+
+from .config import *
+from .handler import *
+from .network import *
+from .security import *
+from .server import *
+from .shell import *
+
+__all__ = ["__version__", "__author__", "__email__"]

termux_mcp-0.1.0/termux_mcp/config.py

@@ -0,0 +1,18 @@
+import os
+
+PORT: int = int(os.environ.get("TERMUX_MCP_PORT", 8080))
+HOST: str = os.environ.get("TERMUX_MCP_HOST", "0.0.0.0")
+
+HOME: str = os.environ.get("HOME", "/data/data/com.termux/files/home")
+
+
+AUTO_INPUT_INTERVAL: float = 0.5
+PORT_POLL_INTERVAL: float = 0.3
+AUTO_YES_COMMANDS: list[str] = [
+    "pkg install",
+    "pkg upgrade",
+    "pkg update",
+    "apt install",
+    "apt upgrade",
+    "apt update",
+]

termux_mcp-0.1.0/termux_mcp/handler.py

@@ -0,0 +1,69 @@
+import json
+import logging
+from http.server import BaseHTTPRequestHandler
+from urllib.parse import urlparse
+
+from .shell import execute_streaming, get_current_dir
+
+logger = logging.getLogger(__name__)
+
+
+class MCPHandler(BaseHTTPRequestHandler):
+    protocol_version = "HTTP/1.1"
+
+    def log_message(self, fmt: str, *args) -> None:
+        logger.debug("[HTTP] " + fmt, *args)
+
+    def _log(self, msg: str):
+        logger.info(f"[MCP] {msg}")
+
+    def _read_json(self) -> dict:
+        try:
+            length = int(self.headers.get("Content-Length", 0))
+            raw = self.rfile.read(length).decode("utf-8", errors="ignore")
+            self._log(f"Request body: {raw}")
+            if not raw:
+                return {}
+            return json.loads(raw)
+        except Exception as e:
+            self._log(f"JSON read error: {e}")
+            return {}
+
+    def _json_response(self, status: int, payload: dict) -> None:
+        body = json.dumps(payload).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self) -> None:
+        path = urlparse(self.path).path
+        self._log(f"GET {path}")
+
+        if path == "/ping":
+            self._json_response(200, {
+                "status": "ok",
+                "cwd": get_current_dir(),
+            })
+            return
+
+        self._json_response(404, {"error": "Not found"})
+
+    def do_POST(self) -> None:
+        path = urlparse(self.path).path
+        self._log(f"POST {path}")
+
+        data = self._read_json()
+        self._log(f"Parsed JSON: {data}")
+
+        if path == "/run":
+            cmd = data.get("cmd", "").strip()
+            if not cmd:
+                self._json_response(400, {"error": "Missing 'cmd'"})
+                return
+            self._log(f"Executing: {cmd}")
+            execute_streaming(self, cmd)
+            return
+
+        self._json_response(404, {"error": "Not found"})

termux_mcp-0.1.0/termux_mcp/network.py

@@ -0,0 +1,26 @@
+import socket
+import subprocess
+import time
+
+from .config import PORT_POLL_INTERVAL
+
+
+def kill_port(port: int) -> None:
+    try:
+        result = subprocess.run(
+            f"lsof -t -i:{port}",
+            shell=True,
+            capture_output=True,
+            text=True,
+        )
+        for pid in result.stdout.strip().splitlines():
+            if pid:
+                subprocess.run(f"kill -9 {pid}", shell=True, check=False)
+    except Exception:
+        pass
+
+    while True:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            if sock.connect_ex(("127.0.0.1", port)) != 0:
+                return
+        time.sleep(PORT_POLL_INTERVAL)

termux_mcp-0.1.0/termux_mcp/security.py

@@ -0,0 +1,77 @@
+import re
+from typing import Tuple, Optional
+
+class CommandRiskLevel:
+    SAFE = "safe"
+    WARNING = "warning"
+    DANGEROUS = "dangerous"
+
+DANGEROUS_PATTERNS = [
+    r'rm\s+-rf\s+/?\s*$',                    # rm -rf /
+    r'rm\s+-rf\s+~',                         # rm -rf ~
+    r'rm\s+-rf\s+/\*',                       # rm -rf /*
+    r'rm\s+-rf\s+--no-preserve-root',        # Attempts to bypass safety
+
+    r'dd\s+if=',                             # dd if=...
+    r'mkfs\.',                               # mkfs.ext4, mkfs.ntfs etc.
+    r'format\s+',                            # format commands
+
+    r':\(\)\s*\{\s*:\|\s*&\s*\};:',          # Classic fork bomb
+
+    r'>\s*/dev/',                            # Redirect to /dev/*
+    r'echo\s+.*>\s*/dev/',
+
+    r'chmod\s+-R\s+777',                     # chmod -R 777 /
+    r'chmod\s+-R\s+000',
+    r'chown\s+-R\s+root',
+
+    r'pkg\s+remove\s+termux.*',              # Removing core Termux packages
+    r'apt\s+purge\s+-y\s+.*termux',
+
+    r';\s*rm\s+-rf',
+    r'&&\s*rm\s+-rf',
+    r'\|\s*rm\s+-rf',
+]
+
+WARNING_PATTERNS = [
+    r'rm\s+-rf',                             # Any rm -rf (even on folders)
+    r'rm\s+-r',                              # Recursive remove
+    r'>>\s*/dev/null',                       # Overwriting logs aggressively
+    r'chmod\s+-R',                           # Recursive chmod
+    r'find\s+.*-delete',                     # Find + delete
+    r'> /',                                  # Redirect to root
+]
+
+def is_dangerous_command(cmd: str) -> Tuple[bool, str, str]:
+    cmd_lower = cmd.strip().lower()
+
+    if not cmd_lower or len(cmd_lower) < 3:
+        return False, CommandRiskLevel.SAFE, ""
+
+    for pattern in DANGEROUS_PATTERNS:
+        if re.search(pattern, cmd_lower):
+            return True, CommandRiskLevel.DANGEROUS, f"Blocked dangerous command: {cmd}"
+
+    for pattern in WARNING_PATTERNS:
+        if re.search(pattern, cmd_lower):
+            return False, CommandRiskLevel.WARNING, f"High-risk command detected (confirmation recommended): {cmd}"
+
+    if "sudo" in cmd_lower and "rm" in cmd_lower:
+        return False, CommandRiskLevel.WARNING, "sudo + rm combination detected"
+
+    if cmd_lower.startswith(("reboot", "shutdown", "poweroff")):
+        return False, CommandRiskLevel.WARNING, "System shutdown/reboot command detected"
+
+    return False, CommandRiskLevel.SAFE, ""
+
+
+def get_risk_assessment(cmd: str) -> dict:
+    blocked, level, message = is_dangerous_command(cmd)
+    
+    return {
+        "command": cmd,
+        "risk_level": level,
+        "blocked": blocked,
+        "message": message or "Command appears safe",
+        "requires_confirmation": level == CommandRiskLevel.WARNING
+    }

termux_mcp-0.1.0/termux_mcp/server.py

@@ -0,0 +1,33 @@
+import logging
+import sys
+from http.server import HTTPServer
+
+from .config import HOST, PORT
+from .handler import MCPHandler
+from .network import kill_port
+from .shell import get_current_dir
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    datefmt="%H:%M:%S",
+)
+logger = logging.getLogger(__name__)
+
+
+def run() -> None:
+    logger.info("Freeing port %d if occupied…", PORT)
+    kill_port(PORT)
+
+    server = HTTPServer((HOST, PORT), MCPHandler)
+
+    logger.info("🚀 TermuxMCP running on http://localhost:%d", PORT)
+    logger.info("📂 Working dir: %s", get_current_dir())
+    logger.info("Press Ctrl+C to stop.\n")
+
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        logger.info("Shutting down…")
+        server.server_close()
+        sys.exit(0)

termux_mcp-0.1.0/termux_mcp/shell.py

@@ -0,0 +1,121 @@
+import os
+import subprocess
+import threading
+import time
+from typing import TYPE_CHECKING
+
+from .config import AUTO_INPUT_INTERVAL, AUTO_YES_COMMANDS, HOME
+
+if TYPE_CHECKING:
+    from http.server import BaseHTTPRequestHandler
+
+
+_current_dir: str = os.getcwd()
+
+
+def get_current_dir() -> str:
+    return _current_dir
+
+
+def set_current_dir(path: str) -> None:
+    global _current_dir
+    _current_dir = path
+
+def _inject_noninteractive(cmd: str) -> str:
+    return f"export DEBIAN_FRONTEND=noninteractive; {cmd}"
+
+
+def _inject_auto_yes(cmd: str) -> str:
+    for trigger in AUTO_YES_COMMANDS:
+        if trigger in cmd and "-y" not in cmd:
+            cmd = cmd.replace(trigger, f"{trigger} -y")
+    return cmd
+
+
+def preprocess(cmd: str) -> str:
+    cmd = _inject_auto_yes(cmd)
+    cmd = _inject_noninteractive(cmd)
+    return cmd
+
+
+def handle_cd(parts: list[str]) -> tuple[bool, str]:
+    if len(parts) == 1:
+        set_current_dir(HOME)
+        return True, f"📂 {_current_dir}"
+
+    raw_path = parts[1].strip().replace("~", HOME, 1)
+    new_path = os.path.abspath(
+        raw_path if os.path.isabs(raw_path) else os.path.join(_current_dir, raw_path)
+    )
+
+    if os.path.isdir(new_path):
+        set_current_dir(new_path)
+        return True, f"📂 {_current_dir}"
+
+    return False, f"❌ Directory not found: {new_path}"
+
+def _send_chunk(handler: "BaseHTTPRequestHandler", text: str) -> None:
+    data = text.encode()
+    size = hex(len(data))[2:].encode()
+    handler.wfile.write(size + b"\r\n" + data + b"\r\n")
+    handler.wfile.flush()
+
+
+def _finalize_chunks(handler: "BaseHTTPRequestHandler") -> None:
+    handler.wfile.write(b"0\r\n\r\n")
+
+def _spawn_auto_input(process: subprocess.Popen) -> None:
+    def _worker() -> None:
+        try:
+            while process.poll() is None:
+                time.sleep(AUTO_INPUT_INTERVAL)
+                process.stdin.write("y\n")
+                process.stdin.flush()
+        except Exception:
+            pass
+
+    threading.Thread(target=_worker, daemon=True).start()
+
+
+
+def execute_streaming(handler: "BaseHTTPRequestHandler", raw_cmd: str) -> None:
+    raw_cmd = raw_cmd.strip()
+
+    if raw_cmd.startswith("cd"):
+        ok, msg = handle_cd(raw_cmd.split(maxsplit=1))
+        handler.send_response(200)
+        handler.send_header("Content-Type", "text/plain")
+        handler.end_headers()
+        handler.wfile.write((msg + "\n").encode())
+        return
+
+    handler.send_response(200)
+    handler.send_header("Content-Type", "text/plain")
+    handler.send_header("Transfer-Encoding", "chunked")
+    handler.end_headers()
+
+    cmd = preprocess(raw_cmd)
+
+    process = subprocess.Popen(
+        f"export PAGER=cat; {cmd}",
+        shell=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        stdin=subprocess.PIPE,
+        text=True,
+        cwd=_current_dir,
+    )
+
+    _spawn_auto_input(process)
+
+    for line in process.stdout:
+        _send_chunk(handler, line)
+
+    process.wait()
+
+    if process.returncode != 0:
+        _send_chunk(handler, f"\n❌ Exit code: {process.returncode}\n")
+    else:
+        _send_chunk(handler, "\n✅ Done\n")
+
+    _finalize_chunks(handler)