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

{runspec_linux-0.1.2 → 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.2.0/CHANGELOG.md

@@ -0,0 +1,69 @@
+# 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
+log file per invocation (`{runnable}.{utc-ts}.{run_id}.log`) instead of a single
+shared rotating `{runnable}.log`. These runnables are meant to be installed into
+shared venvs and run by multiple users (and in parallel); per-invocation files
+are multi-writer safe — no in-process rotation and no contention over one file.
+Use `runspec logs` to view, compact, and prune. The `rotate`/`keep` keys (inert
+under per-run) are dropped. Bumps the `runspec` dependency floor to `>=0.27.0`,
+where `store = "per-run"` was introduced.
+
+## [0.1.2] — 2026-06-02
+
+Lower the Python floor to 3.10 to match the core `runspec` library (no
+3.11-only features are used). Bump the `runspec` dependency floor to
+`>=0.23.0`.
+
+## [0.1.1] — 2026-05-28
+
+Enable `[config.logging]` for all 21 runnables. Each invocation now writes a
+JSON audit record to `{venv}/logs/{runnable}.log` (rotates at 10 MB, keeps 14
+backups) and emits a one-line run summary to stderr. The auto-added `--debug`
+and `--no-summary` flags are available on every runnable. No code changes —
+existing `print(json.dumps(...))` payloads are captured into the audit log via
+the print-capture mechanism; stdout stays clean for pipe consumers.
+
+## [0.1.0] — 2026-05-27
+
+Initial release.
+
+21 runnables covering Linux system administration:
+
+**System monitoring** — `system-info`, `disk-usage`, `check-memory`, `list-processes`
+
+**Services** — `check-service`, `list-services`, `restart-service`
+
+**Logs** — `tail-log`, `search-log`, `journalctl`
+
+**Network** — `ping-host`, `check-port`, `show-connections`
+
+**Files** — `find-large-files`, `backup-files`
+
+**Security** — `last-logins`, `who`
+
+**Containers** — `list-containers`, `container-logs`, `restart-container`
+
+**TCP interfaces** — `nc-command` (also exports `nc_send()` as a public Python API for wrapper runnables)
+
+All read-only runnables are `autonomy = "autonomous"`. State-changing runnables (`restart-service`, `backup-files`, `restart-container`) are `autonomy = "confirm"`. Missing tools (`docker`, `systemctl`, `journalctl`) return a structured JSON error rather than a stack trace.

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

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

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

@@ -4,11 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "runspec-linux"
-version = "0.1.2"
+version = "0.2.0"
 requires-python = ">=3.10"
 description = "Linux system admin runnables for runspec"
 dependencies = [
-    "runspec>=0.23.0",
+    "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.1.2 → runspec_linux-0.2.0}/runspec_linux/runspec.toml

@@ -2,8 +2,10 @@
 autonomy-default = "autonomous"
 
 [config.logging]
-rotate = "10 MB"
-keep   = 14
+# Per-invocation log files: one {runnable}.{utc-ts}.{run_id}.log per run.
+# Multi-writer safe for shared venvs — no in-process rotation (use
+# `runspec logs` to view/compact/prune). rotate/keep are inert under per-run.
+store = "per-run"
 
 # ── System monitoring ─────────────────────────────────────────────────────────
 

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.2/CHANGELOG.md

@@ -1,40 +0,0 @@
-# runspec-linux Changelog
-
-## [0.1.2] — 2026-06-02
-
-Lower the Python floor to 3.10 to match the core `runspec` library (no
-3.11-only features are used). Bump the `runspec` dependency floor to
-`>=0.23.0`.
-
-## [0.1.1] — 2026-05-28
-
-Enable `[config.logging]` for all 21 runnables. Each invocation now writes a
-JSON audit record to `{venv}/logs/{runnable}.log` (rotates at 10 MB, keeps 14
-backups) and emits a one-line run summary to stderr. The auto-added `--debug`
-and `--no-summary` flags are available on every runnable. No code changes —
-existing `print(json.dumps(...))` payloads are captured into the audit log via
-the print-capture mechanism; stdout stays clean for pipe consumers.
-
-## [0.1.0] — 2026-05-27
-
-Initial release.
-
-21 runnables covering Linux system administration:
-
-**System monitoring** — `system-info`, `disk-usage`, `check-memory`, `list-processes`
-
-**Services** — `check-service`, `list-services`, `restart-service`
-
-**Logs** — `tail-log`, `search-log`, `journalctl`
-
-**Network** — `ping-host`, `check-port`, `show-connections`
-
-**Files** — `find-large-files`, `backup-files`
-
-**Security** — `last-logins`, `who`
-
-**Containers** — `list-containers`, `container-logs`, `restart-container`
-
-**TCP interfaces** — `nc-command` (also exports `nc_send()` as a public Python API for wrapper runnables)
-
-All read-only runnables are `autonomy = "autonomous"`. State-changing runnables (`restart-service`, `backup-files`, `restart-container`) are `autonomy = "confirm"`. Missing tools (`docker`, `systemctl`, `journalctl`) return a structured JSON error rather than a stack trace.

runspec_linux-0.1.2/runspec_linux/__init__.py

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

runspec_linux-0.1.2/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)