directops-operator 0.1.9__py3-none-any.whl

agent/discovery.py

@@ -0,0 +1,229 @@
+"""Machine capability discovery — runs at install time and on demand.
+
+Probes the local system for installed tools, configured accounts, and
+available credentials. Results are written to ~/.config/directops/capabilities.json
+and sent to the Director in RegisterMessage.system_context on every connect.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+CAPABILITIES_PATH = Path.home() / ".config" / "directops" / "capabilities.json"
+
+# Curated categories for semantic context. The Director uses these to understand
+# what *role* a tool plays (e.g. msmtp = email). The full available_tools list
+# comes from a live PATH scan and includes everything on the machine.
+_TOOLS: dict[str, list[str]] = {
+    "email":            ["msmtp", "sendmail", "mutt", "mailx", "s-nail", "swaks"],
+    "vcs":              ["git", "gh", "svn", "hg"],
+    "containers":       ["docker", "podman", "kubectl", "helm", "compose", "docker-compose"],
+    "languages":        ["python3", "python", "node", "go", "ruby", "java", "rustc", "php",
+                         "perl", "lua", "elixir", "erlang", "scala", "kotlinc"],
+    "package_managers": ["apt", "apt-get", "brew", "dnf", "yum", "pacman", "zypper",
+                         "pip3", "pip", "npm", "yarn", "pnpm", "cargo", "gem", "composer"],
+    "shell_tools":      ["curl", "wget", "jq", "make", "cmake", "ssh", "rsync",
+                         "tmux", "screen", "socat", "envsubst", "parallel"],
+    "editors":          ["vim", "nvim", "nano", "emacs", "code", "helix", "micro"],
+    "network":          ["nmap", "masscan", "arp-scan", "nc", "ncat", "netcat",
+                         "ss", "ip", "ifconfig", "netstat", "tcpdump", "tshark",
+                         "dig", "nslookup", "host", "ping", "ping6", "traceroute",
+                         "tracepath", "mtr", "whois", "ngrep", "iftop", "nethogs",
+                         "bmon", "iperf", "iperf3", "speedtest-cli", "bandwhich"],
+    "security":         ["openssl", "gpg", "gpg2", "age", "sshpass", "ssh-keygen",
+                         "fail2ban-client", "iptables", "ip6tables", "ufw", "nft",
+                         "firewall-cmd", "apparmor_status", "semanage"],
+    "browsers":         ["firefox", "firefox-esr", "chromium", "chromium-browser",
+                         "google-chrome", "google-chrome-stable", "brave-browser",
+                         "brave", "opera", "vivaldi", "lynx", "w3m", "links",
+                         "elinks", "epiphany", "midori"],
+    "system":           ["systemctl", "service", "journalctl", "crontab", "at",
+                         "ps", "top", "htop", "btop", "lsof", "strace", "ltrace",
+                         "perf", "dmesg", "lshw", "lscpu", "lsblk", "lspci", "lsusb",
+                         "df", "du", "free", "vmstat", "iostat", "sar", "uptime",
+                         "dmidecode", "hwinfo", "inxi"],
+    "database":         ["mysql", "mysqldump", "psql", "pg_dump", "sqlite3",
+                         "redis-cli", "mongosh", "mongo", "mongodump", "mongorestore",
+                         "influx", "clickhouse-client"],
+    "automation":       ["ansible", "ansible-playbook", "terraform", "puppet",
+                         "chef", "salt", "fabric", "capistrano"],
+    "media":            ["ffmpeg", "ffprobe", "convert", "magick", "identify",
+                         "vlc", "mpv", "yt-dlp", "youtube-dl", "sox", "mediainfo"],
+    "archive":          ["tar", "zip", "unzip", "7z", "gzip", "bzip2", "xz",
+                         "zstd", "rar", "unrar", "lz4", "lzma"],
+    "text":             ["grep", "sed", "awk", "sort", "uniq", "cut", "tr",
+                         "xargs", "find", "fd", "rg", "ripgrep", "bat", "fzf",
+                         "less", "head", "tail", "wc", "column", "jq", "yq",
+                         "xmllint", "pandoc", "miller", "csvkit"],
+    "monitoring":       ["prometheus", "grafana-server", "datadog-agent",
+                         "telegraf", "collectd", "munin-run", "zabbix_agentd"],
+    "cloud":            ["aws", "az", "gcloud", "doctl", "linode-cli", "vultr-cli",
+                         "terraform", "vault", "consul", "nomad", "packer"],
+}
+
+
+def _probe_all_executables() -> list[str]:
+    """Walk every directory in $PATH and return all executable file names.
+
+    This is the primary source of available_tools — it finds everything on
+    the machine regardless of whether it's in the curated _TOOLS list above.
+    nmap, browsers, custom scripts — anything in PATH shows up here.
+    """
+    found: set[str] = set()
+    for dir_str in os.environ.get("PATH", "").split(os.pathsep):
+        d = Path(dir_str)
+        if not d.is_dir():
+            continue
+        try:
+            for entry in d.iterdir():
+                if (
+                    entry.is_file()
+                    and os.access(entry, os.X_OK)
+                    and len(entry.name) >= 2
+                    and not entry.name.startswith(".")
+                ):
+                    found.add(entry.name)
+        except PermissionError:
+            pass
+    return sorted(found)
+
+
+def _probe_tools() -> dict[str, dict[str, Any]]:
+    """Check which curated tools are installed. Returns {tool: {available, path}}."""
+    found: dict[str, dict[str, Any]] = {}
+    for _category, tools in _TOOLS.items():
+        for tool in tools:
+            path = shutil.which(tool)
+            found[tool] = {"available": path is not None, "path": path or ""}
+    return found
+
+
+def _probe_email_accounts() -> dict[str, str]:
+    """Parse ~/.msmtprc and return {account_name: from_address} mappings.
+
+    msmtp accounts are referenced by their NAME (e.g. 'gmail'), NOT by
+    email address. Always pass the account name to --account / -a.
+    """
+    accounts: dict[str, str] = {}
+    msmtprc = Path.home() / ".msmtprc"
+    if not msmtprc.exists():
+        return accounts
+    try:
+        current: str | None = None
+        for raw in msmtprc.read_text().splitlines():
+            line = raw.strip()
+            if not line or line.startswith("#"):
+                continue
+            parts = line.split(None, 1)
+            key = parts[0].lower()
+            val = parts[1].strip() if len(parts) > 1 else ""
+            if key == "account" and ":" not in val:
+                current = val
+            elif key == "from" and "@" in val and current:
+                accounts[current] = val
+    except Exception:
+        pass
+    return accounts
+
+
+def _probe_git_identity() -> str:
+    """Return git user.email if configured."""
+    try:
+        result = subprocess.run(
+            ["git", "config", "--global", "user.email"],
+            capture_output=True, text=True, timeout=5,
+        )
+        return result.stdout.strip()
+    except Exception:
+        return ""
+
+
+def _probe_python_packages() -> list[str]:
+    """Return list of notable installed Python packages."""
+    notable = ["requests", "httpx", "boto3", "paramiko", "fabric", "ansible"]
+    try:
+        out = subprocess.run(
+            ["pip3", "show"] + notable,
+            capture_output=True, text=True, timeout=10,
+        ).stdout
+    except Exception:
+        return []
+    found = []
+    for line in out.splitlines():
+        if line.startswith("Name:"):
+            found.append(line.split(":", 1)[1].strip())
+    return found
+
+
+def run_discovery() -> dict[str, Any]:
+    """Probe the machine and return a capabilities dict."""
+    import platform
+    import socket
+
+    logger.info("Running capability discovery…")
+
+    # Full PATH scan — the authoritative list of what's installed
+    all_executables = _probe_all_executables()
+
+    # Curated probe — adds semantic category context for the Director
+    categorized = _probe_tools()
+
+    msmtp_accounts = _probe_email_accounts()
+    git_email = _probe_git_identity()
+
+    context: dict[str, Any] = {
+        "hostname": socket.gethostname(),
+        "os": f"{platform.system()} {platform.release()}",
+        "user": os.getenv("USER", os.getenv("LOGNAME", "unknown")),
+        "tools": categorized,
+        "accounts": {
+            "msmtp": msmtp_accounts,          # {name: email} — use name with -a flag
+            "email": list(msmtp_accounts.values()),
+            "git": git_email,
+        },
+        "python_packages": _probe_python_packages(),
+        # Full PATH scan: every executable on the machine. This is what Devstral
+        # and Claude check when planning — nothing gets missed.
+        "available_tools": all_executables,
+    }
+
+    logger.info(
+        "Discovery complete: %d executables in PATH, email accounts: %s",
+        len(all_executables),
+        list(msmtp_accounts.keys()) or "none",
+    )
+    return context
+
+
+def load_or_run() -> dict[str, Any]:
+    """Load cached capabilities, or run discovery if cache is missing."""
+    if CAPABILITIES_PATH.exists():
+        try:
+            data = json.loads(CAPABILITIES_PATH.read_text())
+            logger.debug("Loaded capabilities from %s", CAPABILITIES_PATH)
+            return data
+        except Exception:
+            pass
+    return run_discovery()
+
+
+def save(context: dict[str, Any]) -> None:
+    """Write capabilities to ~/.config/directops/capabilities.json."""
+    CAPABILITIES_PATH.parent.mkdir(parents=True, exist_ok=True)
+    CAPABILITIES_PATH.write_text(json.dumps(context, indent=2))
+    logger.info("Capabilities saved to %s", CAPABILITIES_PATH)
+
+
+def run_and_save() -> dict[str, Any]:
+    """Run discovery, save result, and return it."""
+    context = run_discovery()
+    save(context)
+    return context

agent/dops.py

@@ -0,0 +1,408 @@
+"""dops — DirectOps Operator control CLI.
+
+Commands:
+    dops start              Start the operator service
+    dops stop               Stop the operator service
+    dops restart            Restart the operator service
+    dops status             Show current status
+    dops enable             Install + enable as systemd service (start on boot)
+    dops disable            Disable + remove systemd service
+    dops update             Check for and install updates
+    dops update --check     Check only, do not install
+    dops config auto-update on|off   Toggle automatic updates
+    dops config show        Show current configuration
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+SERVICE_NAME = "directops-operator"
+CONFIG_DIR = Path.home() / ".config" / "directops"
+ENV_FILE = CONFIG_DIR / "operator.env"
+PID_FILE = CONFIG_DIR / "operator.pid"
+SERVICE_FILE = Path(f"/etc/systemd/system/{SERVICE_NAME}.service")
+
+# ── helpers ────────────────────────────────────────────────────────────────────
+
+def _has_systemd() -> bool:
+    return shutil.which("systemctl") is not None and SERVICE_FILE.exists()
+
+
+def _systemctl(*args: str) -> subprocess.CompletedProcess:
+    cmd = ["sudo", "systemctl", *args, SERVICE_NAME]
+    return subprocess.run(cmd, capture_output=True, text=True)
+
+
+def _read_pid() -> int | None:
+    try:
+        return int(PID_FILE.read_text().strip())
+    except Exception:
+        return None
+
+
+def _proc_running(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+        return True
+    except (ProcessLookupError, PermissionError):
+        return False
+
+
+# ── commands ───────────────────────────────────────────────────────────────────
+
+def cmd_start(args) -> None:
+    if _has_systemd():
+        r = _systemctl("start")
+        if r.returncode == 0:
+            print("Operator started (systemd).")
+        else:
+            print(f"Failed to start: {r.stderr.strip()}", file=sys.stderr)
+            sys.exit(1)
+    else:
+        pid = _read_pid()
+        if pid and _proc_running(pid):
+            print(f"Operator already running (PID {pid}).")
+            return
+
+        operator_bin = shutil.which("directops-operator")
+        if not operator_bin:
+            print("directops-operator not found in PATH.", file=sys.stderr)
+            sys.exit(1)
+
+        env_vars = _load_env()
+        cmd = [operator_bin]
+        if env_vars.get("DIRECTOR_URL"):
+            cmd += ["--url", env_vars["DIRECTOR_URL"]]
+        if env_vars.get("OPERATOR_TOKEN"):
+            cmd += ["--token", env_vars["OPERATOR_TOKEN"]]
+        if env_vars.get("MACHINE_NAME"):
+            cmd += ["--name", env_vars["MACHINE_NAME"]]
+
+        proc = subprocess.Popen(cmd, start_new_session=True)
+        PID_FILE.write_text(str(proc.pid))
+        print(f"Operator started (PID {proc.pid}).")
+
+
+def cmd_stop(args) -> None:
+    if _has_systemd():
+        r = _systemctl("stop")
+        if r.returncode == 0:
+            print("Operator stopped.")
+        else:
+            print(f"Failed to stop: {r.stderr.strip()}", file=sys.stderr)
+            sys.exit(1)
+    else:
+        pid = _read_pid()
+        if not pid or not _proc_running(pid):
+            print("Operator is not running.")
+            return
+        import signal
+        os.kill(pid, signal.SIGTERM)
+        PID_FILE.unlink(missing_ok=True)
+        print(f"Operator stopped (PID {pid}).")
+
+
+def cmd_restart(args) -> None:
+    if _has_systemd():
+        r = _systemctl("restart")
+        if r.returncode != 0:
+            print(f"Failed to restart: {r.stderr.strip()}", file=sys.stderr)
+            sys.exit(1)
+        # Give it a moment, then confirm it didn't immediately crash-loop.
+        time.sleep(2)
+        active = _systemctl("is-active").stdout.strip()
+        if active == "active":
+            print("Operator restarted.")
+        else:
+            print(f"Operator restarted but is now '{active}' — check logs (dops logs).", file=sys.stderr)
+            sys.exit(1)
+    else:
+        cmd_stop(args)
+        cmd_start(args)
+
+
+def cmd_status(args) -> None:
+    from .updater import get_installed_version
+    version = get_installed_version()
+
+    if _has_systemd():
+        r = _systemctl("is-active")
+        active = r.stdout.strip()
+        r2 = subprocess.run(
+            ["sudo", "systemctl", "status", SERVICE_NAME, "--no-pager", "-l"],
+            capture_output=True, text=True,
+        )
+        state = "running" if active == "active" else active
+        print(f"Operator v{version} — {state} (systemd)")
+        print(r2.stdout)
+    else:
+        pid = _read_pid()
+        if pid and _proc_running(pid):
+            print(f"Operator v{version} — running (PID {pid})")
+        else:
+            print(f"Operator v{version} — stopped")
+
+    env_vars = _load_env()
+    auto = env_vars.get("AUTO_UPDATE", "false")
+    url = env_vars.get("DIRECTOR_URL", "(not set)")
+    print(f"  Director URL : {url}")
+    print(f"  Auto-update  : {auto}")
+
+
+def cmd_enable(args) -> None:
+    """Install and enable systemd service."""
+    operator_bin = shutil.which("directops-operator")
+    if not operator_bin:
+        print("directops-operator not found in PATH.", file=sys.stderr)
+        sys.exit(1)
+
+    env_vars = _load_env()
+    user = os.environ.get("USER", os.environ.get("LOGNAME", ""))
+    service_content = f"""[Unit]
+Description=DirectOps Operator
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User={user}
+EnvironmentFile={ENV_FILE}
+ExecStart={operator_bin} --url ${{DIRECTOR_URL}} --token ${{OPERATOR_TOKEN}} --name "${{MACHINE_NAME}}"
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+"""
+    tmp = Path("/tmp/directops-operator.service")
+    tmp.write_text(service_content)
+
+    print("Admin password required to install the DirectOps systemd service.")
+    subprocess.check_call(["sudo", "-v"])
+    subprocess.check_call(["sudo", "cp", str(tmp), str(SERVICE_FILE)])
+    tmp.unlink()
+    subprocess.check_call(["sudo", "systemctl", "daemon-reload"])
+    subprocess.check_call(["sudo", "systemctl", "enable", "--now", SERVICE_NAME])
+    print(f"Service installed and enabled. Operator will start on boot.")
+
+
+def cmd_disable(args) -> None:
+    """Disable and remove systemd service."""
+    print("Admin password required to remove the DirectOps systemd service.")
+    subprocess.check_call(["sudo", "-v"])
+    subprocess.check_call(["sudo", "systemctl", "disable", "--now", SERVICE_NAME])
+    subprocess.check_call(["sudo", "rm", "-f", str(SERVICE_FILE)])
+    subprocess.check_call(["sudo", "systemctl", "daemon-reload"])
+    print("Service disabled and removed.")
+
+
+def cmd_update(args) -> None:
+    from .updater import (
+        fetch_latest, get_installed_version, is_newer, install_update
+    )
+
+    check_only = getattr(args, "check", False)
+    installed = get_installed_version()
+    print(f"Installed: v{installed}")
+    print("Checking for updates…")
+
+    manifest = fetch_latest()
+    if not manifest:
+        print("Could not reach update server.", file=sys.stderr)
+        sys.exit(1)
+
+    latest = manifest.get("version", "")
+    if not is_newer(latest, installed):
+        print(f"Already up to date (v{installed}).")
+        return
+
+    changelog = manifest.get("changelog", "")
+    print(f"Update available: v{latest}")
+    if changelog:
+        print(f"  {changelog}")
+
+    if check_only:
+        print("Run `dops update` to install.")
+        return
+
+    wheel_url = manifest.get("wheel_url", "")
+    sha256 = manifest.get("sha256", "")
+    if not wheel_url:
+        print("No download URL in manifest.", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"Installing v{latest}…")
+    if install_update(wheel_url, sha256):
+        print(f"Updated to v{latest}. Restart the operator to apply: dops restart")
+    else:
+        print("Update failed.", file=sys.stderr)
+        sys.exit(1)
+
+
+def cmd_logs(args) -> None:
+    """Stream operator logs. Falls back to log file if systemd is unavailable."""
+    n = getattr(args, "lines", 50)
+    follow = getattr(args, "follow", False)
+
+    if _has_systemd():
+        cmd = ["journalctl", "-u", SERVICE_NAME, "--no-pager", "-n", str(n)]
+        if follow:
+            cmd.append("-f")
+        try:
+            subprocess.run(cmd)
+        except KeyboardInterrupt:
+            pass
+        return
+
+    # Fallback: look for a log file written by the operator
+    log_candidates = [
+        CONFIG_DIR / "operator.log",
+        Path("/tmp/directops-operator.log"),
+    ]
+    for log_file in log_candidates:
+        if log_file.exists():
+            lines = log_file.read_text().splitlines()
+            print("\n".join(lines[-n:]))
+            return
+
+    print("No systemd service and no log file found. Run the operator via systemd for logs.", file=sys.stderr)
+    sys.exit(1)
+
+
+def cmd_set_token(args) -> None:
+    """Write a new token to operator.env and restart the service."""
+    token = args.token.strip()
+    if not token:
+        print("Error: token must not be empty.", file=sys.stderr)
+        sys.exit(1)
+
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    env_vars = _load_env()
+    env_vars["OPERATOR_TOKEN"] = token
+
+    lines = "\n".join(f"{k}={v}" for k, v in env_vars.items()) + "\n"
+    ENV_FILE.write_text(lines)
+    ENV_FILE.chmod(0o600)
+    print("Token updated.")
+
+    if _has_systemd():
+        r = _systemctl("restart")
+        if r.returncode == 0:
+            print("Operator restarted.")
+        else:
+            print(f"Restart failed: {r.stderr.strip()}", file=sys.stderr)
+            sys.exit(1)
+
+
+def cmd_config(args) -> None:
+    from .updater import set_auto_update_setting
+
+    sub = getattr(args, "setting", None)
+
+    if sub == "show" or sub is None:
+        env_vars = _load_env()
+        print("Current configuration:")
+        for k, v in env_vars.items():
+            display = v if k != "OPERATOR_TOKEN" else v[:8] + "…" if len(v) > 8 else v
+            print(f"  {k}={display}")
+        return
+
+    if sub == "auto-update":
+        value = getattr(args, "value", "").lower()
+        if value in ("on", "true", "1", "yes"):
+            set_auto_update_setting(True)
+            print("Auto-update enabled. Operator will update automatically on startup.")
+        elif value in ("off", "false", "0", "no"):
+            set_auto_update_setting(False)
+            print("Auto-update disabled. Run `dops update` to update manually.")
+        else:
+            print("Usage: dops config auto-update on|off", file=sys.stderr)
+            sys.exit(1)
+
+
+# ── env file ───────────────────────────────────────────────────────────────────
+
+def _load_env() -> dict[str, str]:
+    result: dict[str, str] = {}
+    if not ENV_FILE.exists():
+        return result
+    for line in ENV_FILE.read_text().splitlines():
+        line = line.strip()
+        if line and not line.startswith("#") and "=" in line:
+            k, _, v = line.partition("=")
+            result[k.strip()] = v.strip()
+    return result
+
+
+# ── CLI wiring ─────────────────────────────────────────────────────────────────
+
+def main() -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        prog="dops",
+        description="DirectOps Operator control CLI",
+    )
+    sub = parser.add_subparsers(dest="command", metavar="COMMAND")
+
+    sub.add_parser("start",   help="Start the operator service")
+    sub.add_parser("stop",    help="Stop the operator service")
+    sub.add_parser("restart", help="Restart the operator service")
+    sub.add_parser("status",  help="Show operator status")
+    sub.add_parser("enable",  help="Install + enable systemd service (start on boot)")
+    sub.add_parser("disable", help="Disable + remove systemd service")
+
+    p_update = sub.add_parser("update", help="Check for and install updates")
+    p_update.add_argument(
+        "--check", action="store_true",
+        help="Check only — do not install",
+    )
+
+    p_logs = sub.add_parser("logs", help="Show operator logs (live with -f)")
+    p_logs.add_argument("-n", "--lines", type=int, default=50, help="Number of lines to show (default: 50)")
+    p_logs.add_argument("-f", "--follow", action="store_true", help="Follow log output in real time")
+
+    p_set_token = sub.add_parser("set-token", help="Update the auth token and restart the operator")
+    p_set_token.add_argument("token", help="New token from the DirectOps dashboard")
+
+    p_config = sub.add_parser("config", help="View or change configuration")
+    p_config.add_argument(
+        "setting", nargs="?", default="show",
+        choices=["show", "auto-update"],
+        help="Setting to view or change",
+    )
+    p_config.add_argument(
+        "value", nargs="?", default="",
+        help="Value for the setting (e.g. on|off for auto-update)",
+    )
+
+    args = parser.parse_args()
+
+    dispatch = {
+        "start":     cmd_start,
+        "stop":      cmd_stop,
+        "restart":   cmd_restart,
+        "status":    cmd_status,
+        "logs":      cmd_logs,
+        "enable":    cmd_enable,
+        "disable":   cmd_disable,
+        "update":    cmd_update,
+        "set-token": cmd_set_token,
+        "config":    cmd_config,
+    }
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(0)
+
+    dispatch[args.command](args)
+
+
+if __name__ == "__main__":
+    main()