runspec-linux 0.1.3__tar.gz → 0.2.0__tar.gz

{runspec_linux-0.1.3 → runspec_linux-0.2.0}/.gitignore

@@ -56,3 +56,6 @@ chainlit-docs/
 
 # Claude Code local config (machine-specific)
 .claude/launch.json
+
+# Stray committed test venv (removed from tracking)
+.venv-test/

{runspec_linux-0.1.3 → runspec_linux-0.2.0}/CHANGELOG.md

@@ -1,5 +1,23 @@
 # runspec-linux Changelog
 
+## [0.2.0] — 2026-06-09
+
+Split the pure logic out into a new dependency-free package,
+**`runspec-linux-core`**, and make `runspec-linux` depend on it. Every runnable
+module is now a thin wrapper: it parses args via `runspec`, calls the matching
+`runspec_linux_core` function, and renders the JSON/exit behaviour. The helper
+functions are re-exported from `runspec_linux` for back-compat
+(`from runspec_linux import nc_send` and friends still work), and
+`runspec_linux.nc_command.nc_send` is preserved.
+
+Why: importing a helper (e.g. `nc_send`) previously required installing
+`runspec-linux`, which put all 21 console scripts on PATH and surfaced all 21
+runnables in `runspec local` / `runspec serve`. Code that only wants the
+importable helpers can now depend on `runspec-linux-core` instead — it has no
+`runspec` dependency, no `runspec.toml`, and no entry points, so it surfaces
+nothing. No behaviour change for the runnables themselves; JSON output and exit
+codes are unchanged.
+
 ## [0.1.3] — 2026-06-04
 
 Switch `[config.logging]` to `store = "per-run"` so every runnable writes one

{runspec_linux-0.1.3 → runspec_linux-0.2.0}/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: runspec-linux
-Version: 0.1.3
+Version: 0.2.0
 Summary: Linux system admin runnables for runspec
 Requires-Python: >=3.10
+Requires-Dist: runspec-linux-core>=0.1.0
 Requires-Dist: runspec>=0.27.0
 Provides-Extra: dev
 Requires-Dist: mypy; extra == 'dev'

{runspec_linux-0.1.3 → runspec_linux-0.2.0}/pyproject.toml

@@ -4,11 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "runspec-linux"
-version = "0.1.3"
+version = "0.2.0"
 requires-python = ">=3.10"
 description = "Linux system admin runnables for runspec"
 dependencies = [
     "runspec>=0.27.0",
+    "runspec-linux-core>=0.1.0",
 ]
 
 [project.scripts]

runspec_linux-0.2.0/runspec_linux/__init__.py

@@ -0,0 +1,56 @@
+"""runspec-linux — Linux system-admin runnables.
+
+The pure logic lives in the dependency-free ``runspec-linux-core`` package; the
+modules here wrap each helper in a runspec runnable. The helper functions are
+re-exported for convenience and back-compat (e.g. ``from runspec_linux import
+nc_send``). To import the helpers *without* surfacing any runnables in a venv,
+depend on ``runspec-linux-core`` directly instead.
+"""
+
+from runspec_linux_core import (
+    backup_files,
+    check_memory,
+    check_port,
+    check_service,
+    container_logs,
+    disk_usage,
+    find_large_files,
+    journalctl,
+    last_logins,
+    list_containers,
+    list_processes,
+    list_services,
+    nc_send,
+    ping_host,
+    restart_container,
+    restart_service,
+    search_log,
+    show_connections,
+    system_info,
+    tail_log,
+    who,
+)
+
+__all__ = [
+    "backup_files",
+    "check_memory",
+    "check_port",
+    "check_service",
+    "container_logs",
+    "disk_usage",
+    "find_large_files",
+    "journalctl",
+    "last_logins",
+    "list_containers",
+    "list_processes",
+    "list_services",
+    "nc_send",
+    "ping_host",
+    "restart_container",
+    "restart_service",
+    "search_log",
+    "show_connections",
+    "system_info",
+    "tail_log",
+    "who",
+]

runspec_linux-0.2.0/runspec_linux/containers.py

@@ -0,0 +1,42 @@
+import json
+import sys
+
+import runspec as rs
+from runspec_linux_core import container_logs, list_containers, restart_container
+from runspec_linux_core.errors import CommandError
+
+
+def main_list_containers() -> None:
+    spec = rs.parse("list-containers")
+    include_all = bool(spec.all)
+    try:
+        print(json.dumps(list_containers(include_all)))
+    except Exception as e:
+        # Includes ToolNotFoundError (docker absent) and CommandError (docker ps failed).
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)
+
+
+def main_container_logs() -> None:
+    spec = rs.parse("container-logs")
+    container = str(spec.container)
+    lines = int(spec.lines)
+    try:
+        print(json.dumps(container_logs(container, lines)))
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)
+
+
+def main_restart_container() -> None:
+    spec = rs.parse("restart-container")
+    container = str(spec.container)
+    try:
+        print(json.dumps(restart_container(container)))
+    except CommandError as e:
+        print(json.dumps({"container": container, "restarted": False, "error": str(e)}))
+        sys.exit(1)
+    except Exception as e:
+        # Includes ToolNotFoundError (docker absent).
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)

runspec_linux-0.2.0/runspec_linux/files.py

@@ -0,0 +1,28 @@
+import json
+import sys
+
+import runspec as rs
+from runspec_linux_core import backup_files, find_large_files
+
+
+def main_find_large_files() -> None:
+    spec = rs.parse("find-large-files")
+    search_path = str(spec.path)
+    min_mb = float(spec.min_mb)
+    limit = int(spec.limit)
+    try:
+        print(json.dumps(find_large_files(search_path, min_mb, limit)))
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)
+
+
+def main_backup_files() -> None:
+    spec = rs.parse("backup-files")
+    source = str(spec.source)
+    destination = str(spec.destination)
+    try:
+        print(json.dumps(backup_files(source, destination)))
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)

runspec_linux-0.2.0/runspec_linux/logs.py

@@ -0,0 +1,52 @@
+import json
+import re
+import subprocess
+import sys
+
+import runspec as rs
+from runspec_linux_core import journalctl, search_log, tail_log
+from runspec_linux_core.errors import ToolNotFoundError
+
+
+def main_tail_log() -> None:
+    spec = rs.parse("tail-log")
+    file_path = str(spec.file)
+    lines = int(spec.lines)
+    try:
+        print(json.dumps(tail_log(file_path, lines)))
+    except OSError as e:
+        print(json.dumps({"error": str(e), "file": file_path}))
+        sys.exit(1)
+
+
+def main_search_log() -> None:
+    spec = rs.parse("search-log")
+    file_path = str(spec.file)
+    pattern = str(spec.pattern)
+    limit = int(spec.limit)
+    try:
+        print(json.dumps(search_log(file_path, pattern, limit)))
+    except OSError as e:
+        print(json.dumps({"error": str(e), "file": file_path}))
+        sys.exit(1)
+    except re.error as e:
+        print(json.dumps({"error": f"Invalid regex: {e}", "pattern": pattern}))
+        sys.exit(1)
+
+
+def main_journalctl() -> None:
+    spec = rs.parse("journalctl")
+    unit = str(spec.unit)
+    lines = int(spec.lines)
+    since = str(spec.since) if spec.since is not None else None
+    try:
+        print(json.dumps(journalctl(unit, lines, since)))
+    except ToolNotFoundError as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)
+    except subprocess.CalledProcessError as e:
+        print(json.dumps({"error": e.stderr.strip(), "unit": unit}))
+        sys.exit(1)
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)

runspec_linux-0.2.0/runspec_linux/nc_command.py

@@ -0,0 +1,38 @@
+import json
+import sys
+
+import runspec as rs
+
+# Re-exported for back-compat: callers historically did
+# `from runspec_linux.nc_command import nc_send`. The implementation now lives
+# in the dependency-free runspec-linux-core package.
+from runspec_linux_core import nc_send
+
+__all__ = ["main", "nc_send"]
+
+
+def main() -> None:
+    spec = rs.parse("nc-command")
+    host = str(spec.host)
+    port = int(spec.port)
+    command = str(spec.command)
+    wait = float(spec.wait)
+    read_timeout = float(spec.read_timeout)
+
+    try:
+        response = nc_send(host, port, command, wait=wait, read_timeout=read_timeout)
+        lines = response.splitlines()
+        print(
+            json.dumps(
+                {
+                    "host": host,
+                    "port": port,
+                    "command": command,
+                    "stdout": response,
+                    "lines": lines,
+                }
+            )
+        )
+    except OSError as e:
+        print(json.dumps({"error": str(e), "host": host, "port": port}))
+        sys.exit(1)

runspec_linux-0.2.0/runspec_linux/network.py

@@ -0,0 +1,34 @@
+import json
+import sys
+
+import runspec as rs
+from runspec_linux_core import check_port, ping_host, show_connections
+
+
+def main_ping_host() -> None:
+    spec = rs.parse("ping-host")
+    host = str(spec.host)
+    count = int(spec.count)
+    try:
+        print(json.dumps(ping_host(host, count)))
+    except Exception as e:
+        print(json.dumps({"error": str(e), "host": host}))
+        sys.exit(1)
+
+
+def main_check_port() -> None:
+    spec = rs.parse("check-port")
+    host = str(spec.host)
+    port = int(spec.port)
+    timeout = float(spec.timeout)
+    print(json.dumps(check_port(host, port, timeout)))
+
+
+def main_show_connections() -> None:
+    spec = rs.parse("show-connections")
+    state_filter = str(spec.state)
+    try:
+        print(json.dumps(show_connections(state_filter)))
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)

runspec_linux-0.2.0/runspec_linux/security.py

@@ -0,0 +1,24 @@
+import json
+import sys
+
+import runspec as rs
+from runspec_linux_core import last_logins, who
+
+
+def main_last_logins() -> None:
+    spec = rs.parse("last-logins")
+    limit = int(spec.limit)
+    try:
+        print(json.dumps(last_logins(limit)))
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)
+
+
+def main_who() -> None:
+    rs.parse("who")
+    try:
+        print(json.dumps(who()))
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)

runspec_linux-0.2.0/runspec_linux/services.py

@@ -0,0 +1,40 @@
+import json
+import sys
+
+import runspec as rs
+from runspec_linux_core import check_service, list_services, restart_service
+from runspec_linux_core.errors import CommandError
+
+
+def main_check_service() -> None:
+    spec = rs.parse("check-service")
+    service = str(spec.service)
+    try:
+        print(json.dumps(check_service(service)))
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)
+
+
+def main_list_services() -> None:
+    spec = rs.parse("list-services")
+    state_filter = str(spec.state)
+    try:
+        print(json.dumps(list_services(state_filter)))
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)
+
+
+def main_restart_service() -> None:
+    spec = rs.parse("restart-service")
+    service = str(spec.service)
+    try:
+        print(json.dumps(restart_service(service)))
+    except CommandError as e:
+        print(json.dumps({"service": service, "restarted": False, "error": str(e)}))
+        sys.exit(1)
+    except Exception as e:
+        # Includes ToolNotFoundError (systemctl absent).
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)

runspec_linux-0.2.0/runspec_linux/system_info.py

@@ -0,0 +1,43 @@
+import json
+import sys
+
+import runspec as rs
+from runspec_linux_core import check_memory, disk_usage, list_processes, system_info
+
+
+def main_system_info() -> None:
+    rs.parse("system-info")
+    try:
+        print(json.dumps(system_info()))
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)
+
+
+def main_disk_usage() -> None:
+    rs.parse("disk-usage")
+    try:
+        print(json.dumps(disk_usage()))
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)
+
+
+def main_check_memory() -> None:
+    rs.parse("check-memory")
+    try:
+        print(json.dumps(check_memory()))
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)
+
+
+def main_list_processes() -> None:
+    spec = rs.parse("list-processes")
+    name_filter = str(spec.filter) if spec.filter is not None else None
+    limit = int(spec.limit)
+    try:
+        print(json.dumps(list_processes(name_filter, limit)))
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)

runspec_linux-0.1.3/runspec_linux/__init__.py

@@ -1,3 +0,0 @@
-from runspec_linux.nc_command import nc_send
-
-__all__ = ["nc_send"]

runspec_linux-0.1.3/runspec_linux/containers.py

@@ -1,117 +0,0 @@
-import json
-import shutil
-import subprocess
-import sys
-
-import runspec as rs
-
-
-def _docker_available() -> bool:
-    return shutil.which("docker") is not None
-
-
-def main_list_containers() -> None:
-    spec = rs.parse("list-containers")
-    include_all = bool(spec.all)
-
-    if not _docker_available():
-        print(json.dumps({"error": "docker not installed or not in PATH"}))
-        sys.exit(1)
-
-    try:
-        cmd = [
-            "docker",
-            "ps",
-            "--format",
-            "{{.ID}}\t{{.Image}}\t{{.Command}}\t{{.CreatedAt}}\t{{.Status}}\t{{.Names}}",
-        ]
-        if include_all:
-            cmd.append("--all")
-
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        if result.returncode != 0:
-            print(json.dumps({"error": result.stderr.strip()}))
-            sys.exit(1)
-
-        rows = []
-        for line in result.stdout.strip().splitlines():
-            parts = line.split("\t")
-            if len(parts) < 6:
-                continue
-            rows.append(
-                {
-                    "id": parts[0],
-                    "image": parts[1],
-                    "command": parts[2].strip('"'),
-                    "created": parts[3],
-                    "status": parts[4],
-                    "name": parts[5],
-                }
-            )
-        print(json.dumps(rows))
-    except Exception as e:
-        print(json.dumps({"error": str(e)}))
-        sys.exit(1)
-
-
-def main_container_logs() -> None:
-    spec = rs.parse("container-logs")
-    container = str(spec.container)
-    lines = int(spec.lines)
-
-    if not _docker_available():
-        print(json.dumps({"error": "docker not installed or not in PATH"}))
-        sys.exit(1)
-
-    try:
-        result = subprocess.run(
-            ["docker", "logs", "--tail", str(lines), container],
-            capture_output=True,
-            text=True,
-        )
-        # docker logs writes to stderr by default
-        output = result.stderr if result.stderr else result.stdout
-        output_lines = output.strip().splitlines()
-        print(
-            json.dumps(
-                {
-                    "container": container,
-                    "lines": output_lines,
-                    "count": len(output_lines),
-                }
-            )
-        )
-    except Exception as e:
-        print(json.dumps({"error": str(e)}))
-        sys.exit(1)
-
-
-def main_restart_container() -> None:
-    spec = rs.parse("restart-container")
-    container = str(spec.container)
-
-    if not _docker_available():
-        print(json.dumps({"error": "docker not installed or not in PATH"}))
-        sys.exit(1)
-
-    try:
-        result = subprocess.run(
-            ["docker", "restart", container],
-            capture_output=True,
-            text=True,
-        )
-        if result.returncode != 0:
-            print(
-                json.dumps(
-                    {
-                        "container": container,
-                        "restarted": False,
-                        "error": result.stderr.strip(),
-                    }
-                )
-            )
-            sys.exit(1)
-        print(json.dumps({"container": container, "restarted": True}))
-    except Exception as e:
-        print(json.dumps({"error": str(e)}))
-        sys.exit(1)

runspec_linux-0.1.3/runspec_linux/files.py

@@ -1,72 +0,0 @@
-import json
-import os
-import sys
-import tarfile
-from datetime import datetime
-from pathlib import Path
-
-import runspec as rs
-
-
-def main_find_large_files() -> None:
-    spec = rs.parse("find-large-files")
-    search_path = str(spec.path)
-    min_mb = float(spec.min_mb)
-    limit = int(spec.limit)
-
-    min_bytes = int(min_mb * 1_048_576)
-
-    try:
-        results: list[dict] = []
-        for dirpath, _dirs, filenames in os.walk(search_path):
-            for name in filenames:
-                fpath = os.path.join(dirpath, name)
-                try:
-                    stat = os.stat(fpath, follow_symlinks=False)
-                    if stat.st_size >= min_bytes:
-                        results.append(
-                            {
-                                "path": fpath,
-                                "size_mb": round(stat.st_size / 1_048_576, 2),
-                                "modified": datetime.fromtimestamp(stat.st_mtime).strftime("%Y-%m-%d %H:%M:%S"),
-                            }
-                        )
-                except OSError:
-                    continue
-
-        results.sort(key=lambda r: r["size_mb"], reverse=True)
-        print(json.dumps(results[:limit]))
-    except Exception as e:
-        print(json.dumps({"error": str(e)}))
-        sys.exit(1)
-
-
-def main_backup_files() -> None:
-    spec = rs.parse("backup-files")
-    source = str(spec.source)
-    destination = str(spec.destination)
-
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    source_name = Path(source).name or "backup"
-    archive_name = f"{source_name}_{timestamp}.tar.gz"
-    archive_path = os.path.join(destination, archive_name)
-
-    try:
-        os.makedirs(destination, exist_ok=True)
-        with tarfile.open(archive_path, "w:gz") as tar:
-            tar.add(source, arcname=source_name)
-
-        size_bytes = os.path.getsize(archive_path)
-        print(
-            json.dumps(
-                {
-                    "source": source,
-                    "destination": archive_path,
-                    "size_bytes": size_bytes,
-                    "size_mb": round(size_bytes / 1_048_576, 2),
-                }
-            )
-        )
-    except Exception as e:
-        print(json.dumps({"error": str(e)}))
-        sys.exit(1)

runspec_linux-0.1.3/runspec_linux/logs.py

@@ -1,81 +0,0 @@
-import json
-import re
-import shutil
-import subprocess
-import sys
-
-import runspec as rs
-
-
-def main_tail_log() -> None:
-    spec = rs.parse("tail-log")
-    file_path = str(spec.file)
-    lines = int(spec.lines)
-
-    try:
-        with open(file_path, errors="replace") as f:
-            all_lines = f.readlines()
-        tail = [line.rstrip("\n") for line in all_lines[-lines:]]
-        print(json.dumps({"file": file_path, "lines": tail, "count": len(tail)}))
-    except OSError as e:
-        print(json.dumps({"error": str(e), "file": file_path}))
-        sys.exit(1)
-
-
-def main_search_log() -> None:
-    spec = rs.parse("search-log")
-    file_path = str(spec.file)
-    pattern = str(spec.pattern)
-    limit = int(spec.limit)
-
-    try:
-        regex = re.compile(pattern, re.IGNORECASE)
-        matches: list[str] = []
-        with open(file_path, errors="replace") as f:
-            for line in f:
-                if regex.search(line):
-                    matches.append(line.rstrip("\n"))
-        trimmed = matches[-limit:] if len(matches) > limit else matches
-        print(
-            json.dumps(
-                {
-                    "file": file_path,
-                    "pattern": pattern,
-                    "matches": trimmed,
-                    "count": len(trimmed),
-                    "total_matches": len(matches),
-                }
-            )
-        )
-    except OSError as e:
-        print(json.dumps({"error": str(e), "file": file_path}))
-        sys.exit(1)
-    except re.error as e:
-        print(json.dumps({"error": f"Invalid regex: {e}", "pattern": pattern}))
-        sys.exit(1)
-
-
-def main_journalctl() -> None:
-    spec = rs.parse("journalctl")
-    unit = str(spec.unit)
-    lines = int(spec.lines)
-    since = str(spec.since) if spec.since is not None else None
-
-    if not shutil.which("journalctl"):
-        print(json.dumps({"error": "journalctl not available — not a systemd system"}))
-        sys.exit(1)
-
-    try:
-        cmd = ["journalctl", f"-u{unit}", f"-n{lines}", "--no-pager", "--output=short"]
-        if since:
-            cmd += [f"--since={since}"]
-
-        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
-        output_lines = result.stdout.strip().splitlines()
-        print(json.dumps({"unit": unit, "lines": output_lines, "count": len(output_lines)}))
-    except subprocess.CalledProcessError as e:
-        print(json.dumps({"error": e.stderr.strip(), "unit": unit}))
-        sys.exit(1)
-    except Exception as e:
-        print(json.dumps({"error": str(e)}))
-        sys.exit(1)

runspec_linux-0.1.3/runspec_linux/nc_command.py

@@ -1,65 +0,0 @@
-import json
-import socket
-import sys
-import time
-
-import runspec as rs
-
-
-def nc_send(
-    host: str,
-    port: int,
-    command: str,
-    wait: float = 0.3,
-    read_timeout: float = 0.1,
-) -> str:
-    """Send a command over a plain TCP socket and return the response.
-
-    Appends a newline to command if not present, waits `wait` seconds for the
-    server to respond, then reads in chunks until the socket goes quiet.
-    """
-    with socket.create_connection((host, port), timeout=10) as sock:
-        payload = command if command.endswith("\n") else command + "\n"
-        sock.sendall(payload.encode())
-
-        time.sleep(wait)
-
-        sock.settimeout(read_timeout)
-        chunks: list[bytes] = []
-        while True:
-            try:
-                chunk = sock.recv(4096)
-                if not chunk:
-                    break
-                chunks.append(chunk)
-            except TimeoutError:
-                break
-
-    return b"".join(chunks).decode(errors="replace")
-
-
-def main() -> None:
-    spec = rs.parse("nc-command")
-    host = str(spec.host)
-    port = int(spec.port)
-    command = str(spec.command)
-    wait = float(spec.wait)
-    read_timeout = float(spec.read_timeout)
-
-    try:
-        response = nc_send(host, port, command, wait=wait, read_timeout=read_timeout)
-        lines = response.splitlines()
-        print(
-            json.dumps(
-                {
-                    "host": host,
-                    "port": port,
-                    "command": command,
-                    "stdout": response,
-                    "lines": lines,
-                }
-            )
-        )
-    except OSError as e:
-        print(json.dumps({"error": str(e), "host": host, "port": port}))
-        sys.exit(1)

runspec_linux-0.1.3/runspec_linux/network.py

@@ -1,159 +0,0 @@
-import json
-import re
-import shutil
-import socket
-import subprocess
-import sys
-import time
-
-import runspec as rs
-
-
-def main_ping_host() -> None:
-    spec = rs.parse("ping-host")
-    host = str(spec.host)
-    count = int(spec.count)
-
-    try:
-        result = subprocess.run(
-            ["ping", "-c", str(count), host],
-            capture_output=True,
-            text=True,
-        )
-        output = result.stdout + result.stderr
-
-        sent = received = 0
-        m = re.search(r"(\d+) packets transmitted,\s*(\d+) received", output)
-        if m:
-            sent = int(m.group(1))
-            received = int(m.group(2))
-
-        loss_pct = 0.0
-        m2 = re.search(r"([\d.]+)% packet loss", output)
-        if m2:
-            loss_pct = float(m2.group(1))
-
-        print(
-            json.dumps(
-                {
-                    "host": host,
-                    "reachable": received > 0,
-                    "packets_sent": sent,
-                    "packets_received": received,
-                    "loss_pct": loss_pct,
-                }
-            )
-        )
-    except Exception as e:
-        print(json.dumps({"error": str(e), "host": host}))
-        sys.exit(1)
-
-
-def main_check_port() -> None:
-    spec = rs.parse("check-port")
-    host = str(spec.host)
-    port = int(spec.port)
-    timeout = float(spec.timeout)
-
-    start = time.monotonic()
-    try:
-        with socket.create_connection((host, port), timeout=timeout):
-            elapsed_ms = round((time.monotonic() - start) * 1000, 1)
-            print(
-                json.dumps(
-                    {
-                        "host": host,
-                        "port": port,
-                        "open": True,
-                        "response_ms": elapsed_ms,
-                    }
-                )
-            )
-    except (OSError, TimeoutError):
-        elapsed_ms = round((time.monotonic() - start) * 1000, 1)
-        print(json.dumps({"host": host, "port": port, "open": False, "response_ms": elapsed_ms}))
-
-
-def main_show_connections() -> None:
-    spec = rs.parse("show-connections")
-    state_filter = str(spec.state)
-
-    try:
-        if shutil.which("ss"):
-            cmd = ["ss", "-tupn"]
-            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
-            rows = _parse_ss(result.stdout, state_filter)
-        elif shutil.which("netstat"):
-            cmd = ["netstat", "-tupn"]
-            result = subprocess.run(cmd, capture_output=True, text=True)
-            rows = _parse_netstat(result.stdout, state_filter)
-        else:
-            print(json.dumps({"error": "Neither ss nor netstat found in PATH"}))
-            sys.exit(1)
-
-        print(json.dumps(rows))
-    except Exception as e:
-        print(json.dumps({"error": str(e)}))
-        sys.exit(1)
-
-
-def _parse_ss(output: str, state_filter: str) -> list[dict]:
-    rows = []
-    for line in output.strip().splitlines()[1:]:
-        parts = line.split()
-        if len(parts) < 5:
-            continue
-        proto, local, peer = parts[0], parts[3], parts[4]
-        state = parts[5] if len(parts) > 5 and not parts[5].startswith("users:") else ""
-        process = ""
-        for p in parts:
-            if p.startswith("users:"):
-                m = re.search(r'"([^"]+)"', p)
-                if m:
-                    process = m.group(1)
-
-        row_state = state.lower() if state else ("listen" if peer == "*:*" else "established")
-        if state_filter == "established" and "estab" not in row_state:
-            continue
-        if state_filter == "listening" and "listen" not in row_state:
-            continue
-
-        rows.append(
-            {
-                "proto": proto,
-                "local": local,
-                "peer": peer,
-                "state": state,
-                "process": process,
-            }
-        )
-    return rows
-
-
-def _parse_netstat(output: str, state_filter: str) -> list[dict]:
-    rows = []
-    for line in output.strip().splitlines():
-        parts = line.split()
-        if not parts or parts[0] not in ("tcp", "tcp6", "udp", "udp6"):
-            continue
-        if len(parts) < 6:
-            continue
-        proto, local, foreign = parts[0], parts[3], parts[4]
-        state = parts[5] if len(parts) > 5 else ""
-        process = parts[-1] if len(parts) > 6 else ""
-
-        if state_filter == "established" and state.upper() != "ESTABLISHED":
-            continue
-        if state_filter == "listening" and state.upper() != "LISTEN":
-            continue
-
-        rows.append(
-            {
-                "proto": proto,
-                "local": local,
-                "peer": foreign,
-                "state": state,
-                "process": process,
-            }
-        )
-    return rows

runspec_linux-0.1.3/runspec_linux/security.py

@@ -1,70 +0,0 @@
-import json
-import shutil
-import subprocess
-import sys
-
-import runspec as rs
-
-
-def main_last_logins() -> None:
-    spec = rs.parse("last-logins")
-    limit = int(spec.limit)
-
-    if not shutil.which("last"):
-        print(json.dumps({"error": "last command not found"}))
-        sys.exit(1)
-
-    try:
-        result = subprocess.run(
-            ["last", "-n", str(limit), "--time-format", "iso"],
-            capture_output=True,
-            text=True,
-        )
-        rows = []
-        for line in result.stdout.strip().splitlines():
-            if not line or line.startswith("wtmp") or line.startswith("btmp"):
-                continue
-            parts = line.split()
-            if len(parts) < 3:
-                continue
-            rows.append(
-                {
-                    "user": parts[0],
-                    "terminal": parts[1],
-                    "from": parts[2] if len(parts) > 2 else "",
-                    "login_time": parts[3] if len(parts) > 3 else "",
-                    "logout_time": parts[5] if len(parts) > 5 else "",
-                }
-            )
-        print(json.dumps(rows[:limit]))
-    except Exception as e:
-        print(json.dumps({"error": str(e)}))
-        sys.exit(1)
-
-
-def main_who() -> None:
-    rs.parse("who")
-
-    if not shutil.which("who"):
-        print(json.dumps({"error": "who command not found"}))
-        sys.exit(1)
-
-    try:
-        result = subprocess.run(["who"], capture_output=True, text=True, check=True)
-        rows = []
-        for line in result.stdout.strip().splitlines():
-            parts = line.split()
-            if len(parts) < 3:
-                continue
-            rows.append(
-                {
-                    "user": parts[0],
-                    "terminal": parts[1],
-                    "login_time": " ".join(parts[2:4]) if len(parts) > 3 else parts[2],
-                    "from": parts[4].strip("()") if len(parts) > 4 else "",
-                }
-            )
-        print(json.dumps(rows))
-    except Exception as e:
-        print(json.dumps({"error": str(e)}))
-        sys.exit(1)

runspec_linux-0.1.3/runspec_linux/services.py

@@ -1,119 +0,0 @@
-import json
-import shutil
-import subprocess
-import sys
-
-import runspec as rs
-
-
-def _systemctl_available() -> bool:
-    return shutil.which("systemctl") is not None
-
-
-def main_check_service() -> None:
-    spec = rs.parse("check-service")
-    service = str(spec.service)
-
-    if not _systemctl_available():
-        print(json.dumps({"error": "systemctl not available — not a systemd system"}))
-        sys.exit(1)
-
-    try:
-        result = subprocess.run(
-            [
-                "systemctl",
-                "show",
-                service,
-                "--property=ActiveState,SubState,LoadState,Description,ActiveEnterTimestamp",
-            ],
-            capture_output=True,
-            text=True,
-        )
-        props: dict[str, str] = {}
-        for line in result.stdout.strip().splitlines():
-            if "=" in line:
-                k, v = line.split("=", 1)
-                props[k] = v
-
-        active = props.get("ActiveState", "unknown")
-        print(
-            json.dumps(
-                {
-                    "service": service,
-                    "active": active == "active",
-                    "active_state": active,
-                    "sub_state": props.get("SubState", "unknown"),
-                    "load_state": props.get("LoadState", "unknown"),
-                    "description": props.get("Description", ""),
-                    "since": props.get("ActiveEnterTimestamp", ""),
-                }
-            )
-        )
-    except Exception as e:
-        print(json.dumps({"error": str(e)}))
-        sys.exit(1)
-
-
-def main_list_services() -> None:
-    spec = rs.parse("list-services")
-    state_filter = str(spec.state)
-
-    if not _systemctl_available():
-        print(json.dumps({"error": "systemctl not available — not a systemd system"}))
-        sys.exit(1)
-
-    try:
-        cmd = ["systemctl", "list-units", "--type=service", "--no-pager", "--no-legend"]
-        if state_filter != "all":
-            cmd += [f"--state={state_filter}"]
-
-        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
-        rows = []
-        for line in result.stdout.strip().splitlines():
-            parts = line.split(None, 4)
-            if len(parts) < 4:
-                continue
-            rows.append(
-                {
-                    "unit": parts[0],
-                    "load": parts[1],
-                    "active": parts[2],
-                    "sub": parts[3],
-                    "description": parts[4] if len(parts) > 4 else "",
-                }
-            )
-        print(json.dumps(rows))
-    except Exception as e:
-        print(json.dumps({"error": str(e)}))
-        sys.exit(1)
-
-
-def main_restart_service() -> None:
-    spec = rs.parse("restart-service")
-    service = str(spec.service)
-
-    if not _systemctl_available():
-        print(json.dumps({"error": "systemctl not available — not a systemd system"}))
-        sys.exit(1)
-
-    try:
-        result = subprocess.run(
-            ["systemctl", "restart", service],
-            capture_output=True,
-            text=True,
-        )
-        if result.returncode != 0:
-            print(
-                json.dumps(
-                    {
-                        "service": service,
-                        "restarted": False,
-                        "error": result.stderr.strip(),
-                    }
-                )
-            )
-            sys.exit(1)
-        print(json.dumps({"service": service, "restarted": True}))
-    except Exception as e:
-        print(json.dumps({"error": str(e)}))
-        sys.exit(1)

runspec_linux-0.1.3/runspec_linux/system_info.py

@@ -1,140 +0,0 @@
-import json
-import os
-import platform
-import sys
-
-import runspec as rs
-
-
-def main_system_info() -> None:
-    rs.parse("system-info")
-
-    try:
-        load1, load5, load15 = os.getloadavg()
-        with open("/proc/uptime") as f:
-            uptime_seconds = float(f.read().split()[0])
-
-        print(
-            json.dumps(
-                {
-                    "hostname": platform.node(),
-                    "os": f"{platform.system()} {platform.release()}",
-                    "kernel": platform.version(),
-                    "machine": platform.machine(),
-                    "uptime_seconds": round(uptime_seconds),
-                    "load_1": round(load1, 2),
-                    "load_5": round(load5, 2),
-                    "load_15": round(load15, 2),
-                    "cpu_count": os.cpu_count(),
-                }
-            )
-        )
-    except Exception as e:
-        print(json.dumps({"error": str(e)}))
-        sys.exit(1)
-
-
-def main_disk_usage() -> None:
-    rs.parse("disk-usage")
-
-    try:
-        import subprocess
-
-        result = subprocess.run(
-            ["df", "-P", "-B1"],
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-        rows = []
-        for line in result.stdout.strip().splitlines()[1:]:
-            parts = line.split()
-            if len(parts) < 6:
-                continue
-            size_bytes = int(parts[1])
-            used_bytes = int(parts[2])
-            avail_bytes = int(parts[3])
-            rows.append(
-                {
-                    "filesystem": parts[0],
-                    "size_mb": round(size_bytes / 1_048_576, 1),
-                    "used_mb": round(used_bytes / 1_048_576, 1),
-                    "available_mb": round(avail_bytes / 1_048_576, 1),
-                    "use_pct": parts[4],
-                    "mounted_on": parts[5],
-                }
-            )
-        print(json.dumps(rows))
-    except Exception as e:
-        print(json.dumps({"error": str(e)}))
-        sys.exit(1)
-
-
-def main_check_memory() -> None:
-    rs.parse("check-memory")
-
-    try:
-        mem: dict[str, int] = {}
-        with open("/proc/meminfo") as f:
-            for line in f:
-                key, val_kb = line.split(":")
-                kb = int(val_kb.strip().split()[0])
-                mem[key.strip()] = kb
-
-        print(
-            json.dumps(
-                {
-                    "total_mb": round(mem.get("MemTotal", 0) / 1024, 1),
-                    "used_mb": round((mem.get("MemTotal", 0) - mem.get("MemAvailable", 0)) / 1024, 1),
-                    "free_mb": round(mem.get("MemFree", 0) / 1024, 1),
-                    "available_mb": round(mem.get("MemAvailable", 0) / 1024, 1),
-                    "cached_mb": round(mem.get("Cached", 0) / 1024, 1),
-                    "swap_total_mb": round(mem.get("SwapTotal", 0) / 1024, 1),
-                    "swap_used_mb": round((mem.get("SwapTotal", 0) - mem.get("SwapFree", 0)) / 1024, 1),
-                }
-            )
-        )
-    except Exception as e:
-        print(json.dumps({"error": str(e)}))
-        sys.exit(1)
-
-
-def main_list_processes() -> None:
-    spec = rs.parse("list-processes")
-    name_filter = str(spec.filter) if spec.filter is not None else None
-    limit = int(spec.limit)
-
-    try:
-        import subprocess
-
-        result = subprocess.run(
-            ["ps", "aux", "--no-headers"],
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-        rows = []
-        for line in result.stdout.strip().splitlines():
-            parts = line.split(None, 10)
-            if len(parts) < 11:
-                continue
-            command = parts[10]
-            if name_filter and name_filter.lower() not in command.lower():
-                continue
-            rows.append(
-                {
-                    "user": parts[0],
-                    "pid": int(parts[1]),
-                    "cpu_pct": float(parts[2]),
-                    "mem_pct": float(parts[3]),
-                    "vsz_kb": int(parts[4]),
-                    "rss_kb": int(parts[5]),
-                    "stat": parts[7],
-                    "command": command,
-                }
-            )
-        rows.sort(key=lambda r: r["cpu_pct"], reverse=True)
-        print(json.dumps(rows[:limit]))
-    except Exception as e:
-        print(json.dumps({"error": str(e)}))
-        sys.exit(1)