hivemind-manager 0.1.0__tar.gz

hivemind_manager-0.1.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: hivemind-manager
+Version: 0.1.0
+Summary: A developer CLI tool for managing Hivemind services
+Author: dhruv13x
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Hivemind Manager (hm) CLI
+
+`hm` is a developer process manager and supervisor built around `hivemind` for development environments. It dynamically scans, starts, stops, and manages service configurations (`*.hm` files) with automatic dependency resolution.
+
+## Installation
+
+Install in editable mode in your virtual environment:
+
+```bash
+pip install -e ~/workspace/tools/hivemind_manager
+```
+
+## Dynamic Dependencies
+
+Declare dependencies inside your `*.hm` files using comments:
+
+```bash
+# depends_on: infra
+```

hivemind_manager-0.1.0/README.md

@@ -0,0 +1,19 @@
+# Hivemind Manager (hm) CLI
+
+`hm` is a developer process manager and supervisor built around `hivemind` for development environments. It dynamically scans, starts, stops, and manages service configurations (`*.hm` files) with automatic dependency resolution.
+
+## Installation
+
+Install in editable mode in your virtual environment:
+
+```bash
+pip install -e ~/workspace/tools/hivemind_manager
+```
+
+## Dynamic Dependencies
+
+Declare dependencies inside your `*.hm` files using comments:
+
+```bash
+# depends_on: infra
+```

hivemind_manager-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "hivemind-manager"
+version = "0.1.0"
+description = "A developer CLI tool for managing Hivemind services"
+readme = "README.md"
+authors = [{ name = "dhruv13x" }]
+requires-python = ">=3.8"
+dependencies = []
+
+[project.scripts]
+hm = "hm.cli:main"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.package-dir]
+"" = "src"
+
+[tool.setuptools.packages.find]
+where = ["src"]

hivemind_manager-0.1.0/setup.cfg

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

hivemind_manager-0.1.0/src/hivemind_manager.egg-info/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: hivemind-manager
+Version: 0.1.0
+Summary: A developer CLI tool for managing Hivemind services
+Author: dhruv13x
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Hivemind Manager (hm) CLI
+
+`hm` is a developer process manager and supervisor built around `hivemind` for development environments. It dynamically scans, starts, stops, and manages service configurations (`*.hm` files) with automatic dependency resolution.
+
+## Installation
+
+Install in editable mode in your virtual environment:
+
+```bash
+pip install -e ~/workspace/tools/hivemind_manager
+```
+
+## Dynamic Dependencies
+
+Declare dependencies inside your `*.hm` files using comments:
+
+```bash
+# depends_on: infra
+```

hivemind_manager-0.1.0/src/hivemind_manager.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/hivemind_manager.egg-info/PKG-INFO
+src/hivemind_manager.egg-info/SOURCES.txt
+src/hivemind_manager.egg-info/dependency_links.txt
+src/hivemind_manager.egg-info/entry_points.txt
+src/hivemind_manager.egg-info/top_level.txt
+src/hm/__init__.py
+src/hm/cli.py
+src/hm/config.py
+src/hm/discovery.py
+src/hm/process.py
+src/hm/tailer.py

hivemind_manager-0.1.0/src/hivemind_manager.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hivemind_manager-0.1.0/src/hivemind_manager.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+hm = hm.cli:main

hivemind_manager-0.1.0/src/hivemind_manager.egg-info/top_level.txt

@@ -0,0 +1 @@
+hm

hivemind_manager-0.1.0/src/hm/__init__.py

@@ -0,0 +1 @@
+from .cli import main

hivemind_manager-0.1.0/src/hm/cli.py

@@ -0,0 +1,252 @@
+import sys
+import time
+import subprocess
+from pathlib import Path
+from .config import PROJECT_ROOT, HIVEMIND_BIN
+from .discovery import discover_services
+from .process import (
+    read_pid,
+    is_running,
+    log_file,
+    stop_service,
+    run_supervised,
+    remove_pid
+)
+from .tailer import multi_tail
+
+def start(service, follow=True, extra_args=None, started_set=None):
+    """
+    Starts a service supervisor. Checks and starts dependencies first if they are not running.
+    """
+    if extra_args is None:
+        extra_args = []
+    if started_set is None:
+        started_set = set()
+
+    services_meta = discover_services()
+    if service not in services_meta:
+        print(f"Unknown service: {service}")
+        sys.exit(1)
+
+    if service in started_set:
+        return
+    started_set.add(service)
+
+    # 1. Resolve and start dependencies
+    deps = services_meta[service]["dependencies"]
+    for dep in deps:
+        if dep not in services_meta:
+            print(f"Warning: [{service}] depends on unknown service '{dep}'")
+            continue
+
+        dep_pid = read_pid(dep)
+        if dep_pid and is_running(dep_pid):
+            # Dependency already running, no action needed
+            continue
+
+        print(f"[{service}] Dependency '{dep}' is not running. Starting '{dep}' first...")
+        start(dep, follow=False, started_set=started_set)
+        # Brief pause to allow the dependency supervisor & worker to start
+        time.sleep(1.5)
+
+    # 2. Stop existing service instance to prevent collision
+    stop_service(service)
+
+    logfile = log_file(service)
+    # Truncate logs
+    open(logfile, "w").close()
+
+    print(f"[{service}] supervisor starting...")
+
+    # Spawn supervisor pointing back to the entrypoint CLI wrapper
+    entrypoint_script = str(Path(sys.argv[0]).resolve())
+    proc = subprocess.Popen(
+        [sys.executable, entrypoint_script, "_run", service] + extra_args,
+        preexec_fn=os_setsid_safely(),
+        cwd=str(PROJECT_ROOT),
+    )
+
+    from .process import write_pid
+    write_pid(service, proc.pid)
+
+    print(f"[{service}] supervisor started (PID {proc.pid})")
+
+    if follow:
+        multi_tail([service])
+
+
+def os_setsid_safely():
+    """
+    Safely returns os.setsid reference if available (Unix systems).
+    """
+    import os
+    return getattr(os, "setsid", None)
+
+
+def ps():
+    """
+    Lists running services and unmanaged hivemind processes.
+    """
+    services_meta = discover_services()
+    print(f"{'SERVICE':<15} {'STATUS':<10} {'PID':<8}")
+    print("-" * 40)
+
+    supervisor_pids = set()
+
+    for svc in services_meta:
+        pid = read_pid(svc)
+        if pid and is_running(pid):
+            print(f"{svc:<15} {'running':<10} {pid:<8}")
+            supervisor_pids.add(str(pid))
+        else:
+            print(f"{svc:<15} {'stopped':<10} -")
+            remove_pid(svc)
+
+    try:
+        out = subprocess.check_output(["pgrep", "-af", HIVEMIND_BIN], text=True)
+        lines = out.strip().split("\n")
+
+        extra = []
+
+        for line in lines:
+            if not line.strip():
+                continue
+            parts = line.split()
+            pid = parts[0]
+
+            try:
+                ppid = subprocess.check_output(
+                    ["ps", "-o", "ppid=", "-p", pid],
+                    text=True
+                ).strip()
+            except subprocess.CalledProcessError:
+                continue
+
+            if ppid in supervisor_pids or pid in supervisor_pids:
+                continue
+
+            extra.append(line)
+
+        if extra:
+            print("\n[unmanaged hivemind processes]")
+            for l in extra:
+                print(" ", l)
+
+    except subprocess.CalledProcessError:
+        pass
+
+
+def status(service=None):
+    """
+    Shows status of all or a specific service.
+    """
+    if service is None:
+        ps()
+        return
+
+    pid = read_pid(service)
+    if pid and is_running(pid):
+        print(f"[{service}] running (PID {pid})")
+    else:
+        print(f"[{service}] stopped")
+        remove_pid(service)
+
+
+def up():
+    """
+    Starts all discovered services in dynamic order.
+    """
+    services_meta = discover_services()
+    started_set = set()
+    for svc in services_meta:
+        start(svc, follow=False, started_set=started_set)
+    print("\nAll services started.\n")
+
+
+def down():
+    """
+    Stops all discovered services.
+    """
+    services_meta = discover_services()
+    for svc in services_meta:
+        stop_service(svc)
+    print("\nAll services stopped.\n")
+
+
+def usage():
+    cmd = Path(sys.argv[0]).name
+    print(f"""
+Usage:
+  {cmd} start <service> [--no-follow]
+  {cmd} stop <service>
+  {cmd} restart <service>
+  {cmd} status [service]
+  {cmd} logs <service> [service2...]
+  {cmd} ps
+  {cmd} up
+  {cmd} down
+""")
+
+
+def main():
+    if len(sys.argv) < 2:
+        usage()
+        sys.exit(1)
+
+    cmd = sys.argv[1]
+
+    if cmd == "_run":
+        if len(sys.argv) < 3:
+            print("Error: service name required for _run")
+            sys.exit(1)
+        service = sys.argv[2]
+        extra_args = sys.argv[3:]
+        run_supervised(service, extra_args)
+        return
+
+    if cmd in ("up", "down"):
+        if cmd == "up":
+            up()
+        else:
+            down()
+        return
+
+    if cmd == "ps":
+        ps()
+        return
+
+    if cmd == "status":
+        if len(sys.argv) == 2:
+            status(None)
+        else:
+            status(sys.argv[2])
+        return
+
+    if cmd == "logs":
+        if len(sys.argv) < 3:
+            usage()
+            return
+        multi_tail(sys.argv[2:])
+        return
+
+    if len(sys.argv) < 3:
+        usage()
+        sys.exit(1)
+
+    service = sys.argv[2]
+    extra_args = sys.argv[3:]
+
+    follow = True
+    if "--no-follow" in extra_args:
+        follow = False
+        extra_args.remove("--no-follow")
+
+    if cmd == "start":
+        start(service, follow, extra_args)
+    elif cmd == "stop":
+        stop_service(service)
+    elif cmd == "restart":
+        stop_service(service)
+        start(service, follow, extra_args)
+    else:
+        usage()

hivemind_manager-0.1.0/src/hm/config.py

@@ -0,0 +1,33 @@
+import os
+import sys
+from pathlib import Path
+
+def find_project_root():
+    """
+    Traverses upwards from the current working directory to find a directory
+    containing *.hm files. Falls back to the current directory if none are found.
+    """
+    current_dir = Path(os.getcwd()).resolve()
+    for parent in [current_dir] + list(current_dir.parents):
+        if list(parent.glob("*.hm")):
+            return parent
+    return current_dir
+
+PROJECT_ROOT = find_project_root()
+BASE_DIR = PROJECT_ROOT / "hm"
+BASE_DIR.mkdir(exist_ok=True)
+
+HIVEMIND_BIN = "hivemind"
+
+RESTART_DELAY = 1.0
+MAX_RESTART_DELAY = 10.0
+
+COLORS = [
+    "\033[36m",  # cyan
+    "\033[33m",  # yellow
+    "\033[35m",  # magenta
+    "\033[32m",  # green
+    "\033[34m",  # blue
+    "\033[31m",  # red
+]
+RESET = "\033[0m"

hivemind_manager-0.1.0/src/hm/discovery.py

@@ -0,0 +1,32 @@
+import re
+from .config import PROJECT_ROOT
+
+def discover_services():
+    """
+    Scans the project root for *.hm files and dynamically builds the services registry,
+    including dependencies parsed from comments inside each file (e.g., # depends_on: infra).
+    """
+    services = {}
+    for path in sorted(PROJECT_ROOT.glob("*.hm")):
+        service_name = path.stem
+        dependencies = []
+
+        try:
+            with open(path, "r") as f:
+                for line in f:
+                    # Parse line like "# depends_on: infra, database"
+                    match = re.match(r"^\s*#\s*depends_on\s*:\s*(.*)$", line, re.IGNORECASE)
+                    if match:
+                        deps = match.group(1).split(",")
+                        for dep in deps:
+                            dep = dep.strip()
+                            if dep:
+                                dependencies.append(dep)
+        except Exception:
+            pass
+
+        services[service_name] = {
+            "path": path,
+            "dependencies": dependencies
+        }
+    return services

hivemind_manager-0.1.0/src/hm/process.py

@@ -0,0 +1,173 @@
+import os
+import sys
+import time
+import signal
+import subprocess
+from .config import BASE_DIR, PROJECT_ROOT, HIVEMIND_BIN, RESTART_DELAY, MAX_RESTART_DELAY
+
+def pid_file(service):
+    return BASE_DIR / f"{service}.pid"
+
+
+def log_file(service):
+    return BASE_DIR / f"{service}.log"
+
+
+def is_running(pid):
+    try:
+        os.kill(pid, 0)
+        return True
+    except OSError:
+        return False
+
+
+def read_pid(service):
+    f = pid_file(service)
+    if not f.exists():
+        return None
+    try:
+        return int(f.read_text().strip())
+    except:
+        return None
+
+
+def write_pid(service, pid):
+    pid_file(service).write_text(str(pid))
+
+
+def remove_pid(service):
+    pid_file(service).unlink(missing_ok=True)
+
+
+def stop_service(service):
+    """
+    Terminates the specified service.
+    First tries to gracefully stop using the stored PID.
+    Then scans the system for orphaned or unmanaged processes of that service and stops them as well.
+    """
+    pid = read_pid(service)
+    stopped_any = False
+
+    if pid:
+        if is_running(pid):
+            print(f"[{service}] stopping (PID {pid})")
+            try:
+                os.killpg(pid, signal.SIGTERM)
+                stopped_any = True
+            except ProcessLookupError:
+                pass
+
+            for _ in range(20):
+                if not is_running(pid):
+                    break
+                time.sleep(0.2)
+
+            if is_running(pid):
+                print(f"[{service}] force killing")
+                try:
+                    os.killpg(pid, signal.SIGKILL)
+                except ProcessLookupError:
+                    pass
+        remove_pid(service)
+
+    # Terminate any leftover orphaned/unmanaged processes running the .hm file for this service
+    try:
+        out = subprocess.check_output(["pgrep", "-af", HIVEMIND_BIN], text=True)
+        for line in out.strip().split("\n"):
+            if not line.strip():
+                continue
+            parts = line.split()
+            p_pid = int(parts[0])
+            cmdline = " ".join(parts[1:])
+
+            if f"{service}.hm" in cmdline:
+                print(f"[{service}] found orphaned/unmanaged process (PID {p_pid}): {cmdline}")
+                print(f"[{service}] terminating process group for PID {p_pid}...")
+                try:
+                    pgid = os.getpgid(p_pid)
+                    os.killpg(pgid, signal.SIGTERM)
+                    # Wait up to 1 second for the process to exit
+                    for _ in range(10):
+                        try:
+                            os.kill(p_pid, 0)
+                        except OSError:
+                            break
+                        time.sleep(0.1)
+                    # Force kill if still running
+                    try:
+                        os.killpg(pgid, signal.SIGKILL)
+                    except OSError:
+                        pass
+                    stopped_any = True
+                except OSError:
+                    try:
+                        os.kill(p_pid, 0) # check existence
+                        os.kill(p_pid, signal.SIGTERM)
+                        for _ in range(10):
+                            try:
+                                os.kill(p_pid, 0)
+                            except OSError:
+                                break
+                            time.sleep(0.1)
+                        os.kill(p_pid, signal.SIGKILL)
+                        stopped_any = True
+                    except OSError:
+                        pass
+    except subprocess.CalledProcessError:
+        pass
+
+    if not pid and not stopped_any:
+        print(f"[{service}] not running")
+
+
+def run_supervised(service, extra_args):
+    """
+    Supervisor process loop. Monitors a single hivemind worker and restarts it if it crashes.
+    """
+    logfile = log_file(service)
+
+    stop_flag = False
+    child_proc = None
+
+    def handle_exit(signum, frame):
+        nonlocal stop_flag, child_proc
+        stop_flag = True
+        if child_proc and child_proc.poll() is None:
+            try:
+                os.killpg(child_proc.pid, signal.SIGTERM)
+            except ProcessLookupError:
+                pass
+
+    signal.signal(signal.SIGTERM, handle_exit)
+    signal.signal(signal.SIGINT, handle_exit)
+
+    delay = RESTART_DELAY
+
+    while not stop_flag:
+        with open(logfile, "ab") as f:
+            child_proc = subprocess.Popen(
+                [HIVEMIND_BIN, f"{service}.hm"] + extra_args,
+                stdout=f,
+                stderr=subprocess.STDOUT,
+                preexec_fn=os.setsid,
+                cwd=str(PROJECT_ROOT),
+            )
+
+        print(f"[{service}] worker started (PID {child_proc.pid})")
+
+        exit_code = child_proc.wait()
+
+        if stop_flag:
+            break
+
+        print(f"[{service}] worker exited (code {exit_code})")
+
+        if exit_code == 0:
+            break
+
+        print(f"[{service}] restarting in {delay:.1f}s...")
+        time.sleep(delay)
+
+        delay = min(delay * 2, MAX_RESTART_DELAY)
+
+    print(f"[{service}] supervisor exiting")

hivemind_manager-0.1.0/src/hm/tailer.py

@@ -0,0 +1,51 @@
+import os
+import time
+import threading
+from .config import COLORS, RESET
+from .process import log_file, read_pid, is_running
+
+def tail_worker(service, color):
+    """
+    Tails the log file for a specific service and color-prefixes output.
+    Terminates when the service stops running.
+    """
+    logfile = log_file(service)
+
+    while not logfile.exists():
+        time.sleep(0.1)
+
+    with open(logfile, "r") as f:
+        f.seek(0, os.SEEK_END)
+
+        while True:
+            line = f.readline()
+            if line:
+                print(line, end="")
+            else:
+                # auto-stop if service dead
+                pid = read_pid(service)
+                if not pid or not is_running(pid):
+                    print(f"{color}[{service}] stopped{RESET}")
+                    break
+                time.sleep(0.2)
+
+
+def multi_tail(services):
+    """
+    Spawns log tailing threads for multiple services.
+    """
+    print(f"Tailing logs: {', '.join(services)}\n")
+
+    threads = []
+
+    for i, svc in enumerate(services):
+        color = COLORS[i % len(COLORS)]
+        t = threading.Thread(target=tail_worker, args=(svc, color), daemon=True)
+        t.start()
+        threads.append(t)
+
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print("\nStopped log tail")