runspec-linux-core 0.1.0__py3-none-any.whl

runspec_linux_core/__init__.py

@@ -0,0 +1,60 @@
+"""runspec-linux-core — pure-Python Linux system-admin helpers.
+
+This package has **no dependency on runspec** and ships **no runspec.toml and no
+entry points**, so installing it exposes the helper functions for import without
+surfacing any runnables (it is invisible to ``runspec local`` / ``runspec serve``
+discovery). ``runspec-linux`` depends on it and wraps each helper in a runnable.
+
+Each function does the work and returns plain data; failures raise (see
+``runspec_linux_core.errors``).
+"""
+
+from runspec_linux_core.containers import (
+    container_logs,
+    list_containers,
+    restart_container,
+)
+from runspec_linux_core.errors import CommandError, LinuxCoreError, ToolNotFoundError
+from runspec_linux_core.files import backup_files, find_large_files
+from runspec_linux_core.logs import journalctl, search_log, tail_log
+from runspec_linux_core.nc import nc_send
+from runspec_linux_core.network import check_port, ping_host, show_connections
+from runspec_linux_core.security import last_logins, who
+from runspec_linux_core.services import check_service, list_services, restart_service
+from runspec_linux_core.system import check_memory, disk_usage, list_processes, system_info
+
+__all__ = [
+    # errors
+    "LinuxCoreError",
+    "ToolNotFoundError",
+    "CommandError",
+    # system
+    "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
+    "nc_send",
+]

runspec_linux_core/containers.py

@@ -0,0 +1,88 @@
+"""Docker container helpers: list, logs, restart."""
+
+import shutil
+import subprocess
+
+from runspec_linux_core.errors import CommandError, ToolNotFoundError
+
+
+def _docker_available() -> bool:
+    return shutil.which("docker") is not None
+
+
+def list_containers(include_all: bool = False) -> list[dict]:
+    """Return Docker containers (running, or all if ``include_all``).
+
+    Raises ToolNotFoundError if docker is not installed, or CommandError if the
+    ``docker ps`` command returns a non-zero exit.
+    """
+    if not _docker_available():
+        raise ToolNotFoundError("docker not installed or not in PATH")
+
+    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:
+        raise CommandError(result.stderr.strip())
+
+    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],
+            }
+        )
+    return rows
+
+
+def container_logs(container: str, lines: int = 50) -> dict:
+    """Return the last ``lines`` log lines for a container.
+
+    Raises ToolNotFoundError if docker is not installed.
+    """
+    if not _docker_available():
+        raise ToolNotFoundError("docker not installed or not in PATH")
+
+    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()
+    return {"container": container, "lines": output_lines, "count": len(output_lines)}
+
+
+def restart_container(container: str) -> dict:
+    """Restart a container. Returns ``{container, restarted: True}`` on success.
+
+    Raises ToolNotFoundError if docker is not installed, or CommandError if the
+    restart returns a non-zero exit (message is the captured stderr).
+    """
+    if not _docker_available():
+        raise ToolNotFoundError("docker not installed or not in PATH")
+
+    result = subprocess.run(
+        ["docker", "restart", container],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise CommandError(result.stderr.strip())
+    return {"container": container, "restarted": True}

runspec_linux_core/errors.py

@@ -0,0 +1,20 @@
+"""Exception types raised by the pure helper functions.
+
+The functions in this package do the work and *raise* on failure; the thin
+runnable wrappers in ``runspec-linux`` catch these and turn them into the JSON
+error payloads + non-zero exits that the CLI/agent surface expects. Keeping the
+error types here (rather than re-deriving them from messages) lets each wrapper
+format its own shape — e.g. a missing tool vs. a command that ran but failed.
+"""
+
+
+class LinuxCoreError(Exception):
+    """Base class for all runspec-linux-core failures."""
+
+
+class ToolNotFoundError(LinuxCoreError):
+    """A required system tool (systemctl, docker, ss, last, ...) is not on PATH."""
+
+
+class CommandError(LinuxCoreError):
+    """A subprocess ran to completion but reported failure (non-zero exit)."""

runspec_linux_core/files.py

@@ -0,0 +1,54 @@
+"""File helpers: find large files, create a timestamped tar.gz backup."""
+
+import os
+import tarfile
+from datetime import datetime
+from pathlib import Path
+
+
+def find_large_files(search_path: str, min_mb: float = 100.0, limit: int = 50) -> list[dict]:
+    """Return files under ``search_path`` at least ``min_mb`` MB, biggest first."""
+    min_bytes = int(min_mb * 1_048_576)
+
+    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)
+    return results[:limit]
+
+
+def backup_files(source: str, destination: str) -> dict:
+    """Create a timestamped ``.tar.gz`` of ``source`` inside ``destination``.
+
+    Returns the archive path and its size.
+    """
+    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)
+
+    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)
+    return {
+        "source": source,
+        "destination": archive_path,
+        "size_bytes": size_bytes,
+        "size_mb": round(size_bytes / 1_048_576, 2),
+    }

runspec_linux_core/logs.py

@@ -0,0 +1,57 @@
+"""Log helpers: tail a file, search a file, read journald units."""
+
+import re
+import shutil
+import subprocess
+
+from runspec_linux_core.errors import ToolNotFoundError
+
+
+def tail_log(file_path: str, lines: int = 50) -> dict:
+    """Return the last ``lines`` lines of a text file.
+
+    Propagates OSError if the file can't be read.
+    """
+    with open(file_path, errors="replace") as f:
+        all_lines = f.readlines()
+    tail = [line.rstrip("\n") for line in all_lines[-lines:]]
+    return {"file": file_path, "lines": tail, "count": len(tail)}
+
+
+def search_log(file_path: str, pattern: str, limit: int = 100) -> dict:
+    """Return up to ``limit`` (most recent) lines of a file matching ``pattern``.
+
+    Propagates OSError if the file can't be read, or re.error on a bad pattern.
+    """
+    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
+    return {
+        "file": file_path,
+        "pattern": pattern,
+        "matches": trimmed,
+        "count": len(trimmed),
+        "total_matches": len(matches),
+    }
+
+
+def journalctl(unit: str, lines: int = 50, since: str | None = None) -> dict:
+    """Return recent journald log lines for a systemd unit.
+
+    Raises ToolNotFoundError if journalctl is not present; propagates
+    subprocess.CalledProcessError if journalctl exits non-zero.
+    """
+    if not shutil.which("journalctl"):
+        raise ToolNotFoundError("journalctl not available — not a systemd system")
+
+    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()
+    return {"unit": unit, "lines": output_lines, "count": len(output_lines)}

runspec_linux_core/nc.py

@@ -0,0 +1,36 @@
+"""Plain-TCP send/receive helper (the ``nc-command`` core)."""
+
+import socket
+import time
+
+
+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")

runspec_linux_core/network.py

@@ -0,0 +1,130 @@
+"""Network helpers: ping, TCP port check, socket connection listing."""
+
+import re
+import shutil
+import socket
+import subprocess
+import time
+
+from runspec_linux_core.errors import ToolNotFoundError
+
+
+def ping_host(host: str, count: int = 4) -> dict:
+    """Ping a host ``count`` times and return reachability + packet stats."""
+    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))
+
+    return {
+        "host": host,
+        "reachable": received > 0,
+        "packets_sent": sent,
+        "packets_received": received,
+        "loss_pct": loss_pct,
+    }
+
+
+def check_port(host: str, port: int, timeout: float = 3.0) -> dict:
+    """Check whether a TCP port accepts a connection.
+
+    A refused/timed-out connection is a valid result (``open: False``), not an
+    error — this function does not raise on connection failure.
+    """
+    start = time.monotonic()
+    try:
+        with socket.create_connection((host, port), timeout=timeout):
+            elapsed_ms = round((time.monotonic() - start) * 1000, 1)
+            return {"host": host, "port": port, "open": True, "response_ms": elapsed_ms}
+    except (OSError, TimeoutError):
+        elapsed_ms = round((time.monotonic() - start) * 1000, 1)
+        return {"host": host, "port": port, "open": False, "response_ms": elapsed_ms}
+
+
+def show_connections(state_filter: str = "all") -> list[dict]:
+    """Return active socket connections via ``ss`` (preferred) or ``netstat``.
+
+    Raises ToolNotFoundError if neither tool is on PATH.
+    """
+    if shutil.which("ss"):
+        result = subprocess.run(["ss", "-tupn"], capture_output=True, text=True, check=True)
+        return _parse_ss(result.stdout, state_filter)
+    if shutil.which("netstat"):
+        result = subprocess.run(["netstat", "-tupn"], capture_output=True, text=True)
+        return _parse_netstat(result.stdout, state_filter)
+    raise ToolNotFoundError("Neither ss nor netstat found in PATH")
+
+
+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_core/security.py

@@ -0,0 +1,63 @@
+"""Security helpers: recent logins, currently logged-in users."""
+
+import shutil
+import subprocess
+
+from runspec_linux_core.errors import ToolNotFoundError
+
+
+def last_logins(limit: int = 20) -> list[dict]:
+    """Return the most recent logins via ``last``.
+
+    Raises ToolNotFoundError if ``last`` is not on PATH.
+    """
+    if not shutil.which("last"):
+        raise ToolNotFoundError("last command not found")
+
+    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 "",
+            }
+        )
+    return rows[:limit]
+
+
+def who() -> list[dict]:
+    """Return currently logged-in users via ``who``.
+
+    Raises ToolNotFoundError if ``who`` is not on PATH.
+    """
+    if not shutil.which("who"):
+        raise ToolNotFoundError("who command not found")
+
+    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 "",
+            }
+        )
+    return rows

runspec_linux_core/services.py

@@ -0,0 +1,95 @@
+"""systemd service helpers: check status, list units, restart."""
+
+import shutil
+import subprocess
+
+from runspec_linux_core.errors import CommandError, ToolNotFoundError
+
+
+def _systemctl_available() -> bool:
+    return shutil.which("systemctl") is not None
+
+
+def check_service(service: str) -> dict:
+    """Return the status of a systemd service.
+
+    Raises ToolNotFoundError if systemctl is not present.
+    """
+    if not _systemctl_available():
+        raise ToolNotFoundError("systemctl not available — not a systemd system")
+
+    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")
+    return {
+        "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", ""),
+    }
+
+
+def list_services(state_filter: str = "all") -> list[dict]:
+    """Return systemd service units, optionally filtered by state.
+
+    Raises ToolNotFoundError if systemctl is not present.
+    """
+    if not _systemctl_available():
+        raise ToolNotFoundError("systemctl not available — not a systemd system")
+
+    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 "",
+            }
+        )
+    return rows
+
+
+def restart_service(service: str) -> dict:
+    """Restart a systemd service. Returns ``{service, restarted: True}`` on success.
+
+    Raises ToolNotFoundError if systemctl is not present, or CommandError if the
+    restart command returns a non-zero exit (message is the captured stderr).
+    """
+    if not _systemctl_available():
+        raise ToolNotFoundError("systemctl not available — not a systemd system")
+
+    result = subprocess.run(
+        ["systemctl", "restart", service],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise CommandError(result.stderr.strip())
+    return {"service": service, "restarted": True}

runspec_linux_core/system.py

@@ -0,0 +1,110 @@
+"""System monitoring helpers: host info, disk, memory, processes."""
+
+import os
+import platform
+import subprocess
+from typing import cast
+
+
+def system_info() -> dict:
+    """Return hostname, OS/kernel, uptime, load averages, and CPU count."""
+    load1, load5, load15 = os.getloadavg()
+    with open("/proc/uptime") as f:
+        uptime_seconds = float(f.read().split()[0])
+
+    return {
+        "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(),
+    }
+
+
+def disk_usage() -> list[dict]:
+    """Return per-filesystem usage (sizes in MB) parsed from ``df``."""
+    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],
+            }
+        )
+    return rows
+
+
+def check_memory() -> dict:
+    """Return memory and swap usage (in MB) parsed from ``/proc/meminfo``."""
+    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
+
+    return {
+        "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),
+    }
+
+
+def list_processes(name_filter: str | None = None, limit: int = 20) -> list[dict]:
+    """Return running processes (from ``ps aux``) sorted by CPU, capped at ``limit``.
+
+    If ``name_filter`` is given, only processes whose command contains it
+    (case-insensitive) are included.
+    """
+    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: cast(float, r["cpu_pct"]), reverse=True)
+    return rows[:limit]

runspec_linux_core-0.1.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: runspec-linux-core
+Version: 0.1.0
+Summary: Pure-Python Linux system-admin helpers — the importable core behind runspec-linux (no runspec dependency, no runnables)
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'

runspec_linux_core-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+runspec_linux_core/__init__.py,sha256=K_zW7iQDoVYcXE-AlAuA9eXzNAdJUK5zj6kFNwAmcJ8,1807
+runspec_linux_core/containers.py,sha256=VlIa1Z9eCx-FFz0I9XMtqyDP92ew6ARXjf-yiJmWeGE,2746
+runspec_linux_core/errors.py,sha256=v5XNWR5AAs-K5gmL0FOf-jnXp1XxTmIXbK0OrBlxde4,792
+runspec_linux_core/files.py,sha256=TxY6czJwzcoiJXWnP03jW6T40AwhYr6hGAtjCH7U83A,1911
+runspec_linux_core/logs.py,sha256=MTEBLo9BYNL7OosR6uF-yh3NqKnQlndUDH2-LlD2jqA,2018
+runspec_linux_core/nc.py,sha256=8jgfXeXqL00QrCfPhOSMJYpN8YDaXRst6AUlP5FFh2k,1005
+runspec_linux_core/network.py,sha256=VmcrIEPHiT4OPAUaJtCYXEqZlGp7L_Djg35TLpskaBk,4283
+runspec_linux_core/security.py,sha256=ywFGjeLasVrF2UA_XvM3wjotNTXx00tYDmEzLiAltjc,1907
+runspec_linux_core/services.py,sha256=IJZkWaIdoqer97BnQZ2x1FbrTanD6D884htGGESui-c,3009
+runspec_linux_core/system.py,sha256=m8lcZFyr40hsUivjDxjySY-TedsNgcOT-h1tjt6Jya0,3642
+runspec_linux_core-0.1.0.dist-info/METADATA,sha256=6wQs-dXtZSRnyzDV_wVPQbwxurdYG0St6wEuSLfbU2A,352
+runspec_linux_core-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+runspec_linux_core-0.1.0.dist-info/RECORD,,

runspec_linux_core-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any