runtime-sdk 0.4.49__py3-none-win_amd64.whl

runtime_sdk/config.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+import errno
+import json
+import os
+import sys
+import tempfile
+import time
+from contextlib import contextmanager
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Iterator, TextIO
+
+
+DEFAULT_BASE_URL = "https://api.runruntime.dev"
+
+
+class RuntimeConfigError(RuntimeError):
+    pass
+
+
+@dataclass(slots=True)
+class WorkOSSession:
+    access_token: str
+    refresh_token: str
+    organization_id: str
+    session_id: str
+
+    def __post_init__(self) -> None:
+        for field_name in (
+            "access_token",
+            "refresh_token",
+            "organization_id",
+            "session_id",
+        ):
+            value = getattr(self, field_name, None)
+            if not isinstance(value, str) or not value.strip():
+                raise ValueError(f"session {field_name} is required")
+
+
+@dataclass(slots=True)
+class RuntimeConfig:
+    base_url: str = DEFAULT_BASE_URL
+    configured_base_url: str | None = None
+    session: WorkOSSession | None = None
+    api_key: str | None = None
+    _tracks_saved_credentials: bool = field(
+        default=False, init=False, repr=False, compare=False
+    )
+
+    def __post_init__(self) -> None:
+        if self.session is not None and self.api_key is not None:
+            raise ValueError("config cannot contain both a WorkOS session and an API key")
+
+
+def config_path() -> Path:
+    root = os.environ.get("XDG_CONFIG_HOME")
+    if root:
+        return Path(root) / "runtime" / "config.json"
+    if sys.platform == "win32":
+        root = os.environ.get("APPDATA")
+        if root:
+            return Path(root) / "Runtime" / "config.json"
+    return Path.home() / ".config" / "runtime" / "config.json"
+
+
+def load_config() -> RuntimeConfig:
+    path = config_path()
+    if not path.exists():
+        config = RuntimeConfig()
+        config._tracks_saved_credentials = True
+        return config
+
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except OSError as exc:
+        raise RuntimeConfigError(f"failed to read config: {exc}") from exc
+    except ValueError as exc:
+        raise RuntimeConfigError("config file contains invalid JSON") from exc
+    if not isinstance(data, dict):
+        raise RuntimeConfigError("config file must contain a JSON object")
+
+    configured_base_url = data.get("base_url") or None
+    session = data.get("session")
+    try:
+        config = RuntimeConfig(
+            base_url=configured_base_url or DEFAULT_BASE_URL,
+            configured_base_url=configured_base_url,
+            session=WorkOSSession(**session) if session is not None else None,
+            api_key=_optional_string(data.get("api_key")),
+        )
+        config._tracks_saved_credentials = True
+        return config
+    except (TypeError, ValueError) as exc:
+        raise RuntimeConfigError(f"config file has an invalid shape: {exc}") from exc
+
+
+def save_config(config: RuntimeConfig) -> None:
+    with config_lock():
+        _save_config_unlocked(config)
+    config._tracks_saved_credentials = True
+
+
+@contextmanager
+def config_lock() -> Iterator[None]:
+    path = config_path()
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+        _set_private_permissions(path.parent, 0o700)
+        with path.with_suffix(".lock").open("a+", encoding="utf-8") as lock:
+            _set_private_permissions(Path(lock.name), 0o600)
+            with _exclusive_file_lock(lock):
+                yield
+    except OSError as exc:
+        raise RuntimeConfigError(f"failed to lock config: {exc}") from exc
+
+
+def _save_config_unlocked(config: RuntimeConfig) -> None:
+    path = config_path()
+    payload: dict[str, object] = {
+        "session": asdict(config.session) if config.session else None,
+        "api_key": config.api_key,
+    }
+    if config.configured_base_url is not None:
+        payload["base_url"] = config.configured_base_url
+
+    temporary_path: str | None = None
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+        _set_private_permissions(path.parent, 0o700)
+        fd, temporary_path = tempfile.mkstemp(prefix=".config-", dir=path.parent)
+        if sys.platform != "win32":
+            os.fchmod(fd, 0o600)
+        with os.fdopen(fd, "w", encoding="utf-8") as file:
+            json.dump(payload, file, indent=2)
+            file.write("\n")
+            file.flush()
+            os.fsync(file.fileno())
+        os.replace(temporary_path, path)
+        temporary_path = None
+        if sys.platform != "win32":
+            directory_fd = os.open(path.parent, os.O_RDONLY)
+            try:
+                os.fsync(directory_fd)
+            finally:
+                os.close(directory_fd)
+    except OSError as exc:
+        raise RuntimeConfigError(f"failed to write config: {exc}") from exc
+    finally:
+        if temporary_path is not None:
+            try:
+                os.unlink(temporary_path)
+            except FileNotFoundError:
+                pass
+
+
+@contextmanager
+def _exclusive_file_lock(lock: TextIO) -> Iterator[None]:
+    if sys.platform != "win32":
+        import fcntl
+
+        fcntl.flock(lock.fileno(), fcntl.LOCK_EX)
+        try:
+            yield
+        finally:
+            fcntl.flock(lock.fileno(), fcntl.LOCK_UN)
+        return
+
+    import msvcrt
+
+    lock.seek(0, os.SEEK_END)
+    if lock.tell() == 0:
+        lock.write("\0")
+        lock.flush()
+    lock.seek(0)
+    while True:
+        try:
+            msvcrt.locking(lock.fileno(), msvcrt.LK_NBLCK, 1)
+            break
+        except OSError as exc:
+            if exc.errno not in (errno.EACCES, errno.EAGAIN, errno.EDEADLK):
+                raise
+            time.sleep(0.05)
+    try:
+        yield
+    finally:
+        lock.seek(0)
+        msvcrt.locking(lock.fileno(), msvcrt.LK_UNLCK, 1)
+
+
+def _set_private_permissions(path: Path, mode: int) -> None:
+    if sys.platform != "win32":
+        os.chmod(path, mode)
+
+
+def _optional_string(value: object) -> str | None:
+    if value is None:
+        return None
+    if not isinstance(value, str) or not value.strip():
+        raise ValueError("api_key must be a non-empty string")
+    return value

runtime_sdk/console.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import contextlib
+import os
+import sys
+import time
+from collections.abc import Callable, Iterator
+
+from runtime_sdk.client import RuntimeAPIError
+
+
+@contextlib.contextmanager
+def raw_terminal_input(fd: int) -> Iterator[Callable[[float], bytes | None]]:
+    if sys.platform == "win32":
+        with _windows_raw_terminal_input(fd) as read:
+            yield read
+        return
+    with _posix_raw_terminal_input(fd) as read:
+        yield read
+
+
+@contextlib.contextmanager
+def _posix_raw_terminal_input(
+    fd: int,
+) -> Iterator[Callable[[float], bytes | None]]:
+    try:
+        import select
+        import termios
+        import tty
+    except ModuleNotFoundError as exc:
+        raise RuntimeAPIError(
+            "interactive console is not supported on this platform"
+        ) from exc
+
+    old_settings = termios.tcgetattr(fd)
+    tty.setraw(fd)
+    try:
+        def read(timeout: float) -> bytes | None:
+            readable, _, _ = select.select([fd], [], [], timeout)
+            return os.read(fd, 1024) if fd in readable else None
+
+        yield read
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+
+
+@contextlib.contextmanager
+def _windows_raw_terminal_input(
+    fd: int,
+) -> Iterator[Callable[[float], bytes | None]]:
+    import ctypes
+    import msvcrt
+    from ctypes import wintypes
+
+    kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+    kernel32.GetConsoleMode.argtypes = [wintypes.HANDLE, ctypes.POINTER(wintypes.DWORD)]
+    kernel32.GetConsoleMode.restype = wintypes.BOOL
+    kernel32.SetConsoleMode.argtypes = [wintypes.HANDLE, wintypes.DWORD]
+    kernel32.SetConsoleMode.restype = wintypes.BOOL
+    input_handle = msvcrt.get_osfhandle(fd)
+    output_handle = msvcrt.get_osfhandle(sys.stdout.fileno())
+    input_mode = wintypes.DWORD()
+    output_mode = wintypes.DWORD()
+    if not kernel32.GetConsoleMode(input_handle, ctypes.byref(input_mode)):
+        raise RuntimeAPIError("failed to read Windows console mode")
+    if not kernel32.GetConsoleMode(output_handle, ctypes.byref(output_mode)):
+        raise RuntimeAPIError("failed to read Windows console output mode")
+
+    enable_virtual_terminal_input = 0x0200
+    enable_virtual_terminal_processing = 0x0004
+    cooked_input_flags = 0x0001 | 0x0002 | 0x0004
+    raw_input_mode = (input_mode.value & ~cooked_input_flags) | enable_virtual_terminal_input
+    raw_output_mode = output_mode.value | enable_virtual_terminal_processing
+    if not kernel32.SetConsoleMode(input_handle, raw_input_mode):
+        raise RuntimeAPIError("failed to enable Windows console input")
+    if not kernel32.SetConsoleMode(output_handle, raw_output_mode):
+        kernel32.SetConsoleMode(input_handle, input_mode.value)
+        raise RuntimeAPIError("failed to enable Windows terminal output")
+
+    try:
+        yield lambda timeout: _read_windows_input(msvcrt, timeout)
+    finally:
+        kernel32.SetConsoleMode(input_handle, input_mode.value)
+        kernel32.SetConsoleMode(output_handle, output_mode.value)
+
+
+_WINDOWS_SPECIAL_KEYS = {
+    "H": b"\x1b[A",
+    "P": b"\x1b[B",
+    "M": b"\x1b[C",
+    "K": b"\x1b[D",
+    "G": b"\x1b[H",
+    "O": b"\x1b[F",
+    "R": b"\x1b[2~",
+    "S": b"\x1b[3~",
+    "I": b"\x1b[5~",
+    "Q": b"\x1b[6~",
+}
+
+
+def _read_windows_input(msvcrt: object, timeout: float) -> bytes | None:
+    deadline = time.monotonic() + timeout
+    while not msvcrt.kbhit():
+        if time.monotonic() >= deadline:
+            return None
+        time.sleep(min(0.01, max(0.0, deadline - time.monotonic())))
+
+    data = bytearray()
+    while msvcrt.kbhit():
+        char = msvcrt.getwch()
+        if char in ("\0", "\xe0"):
+            data.extend(_WINDOWS_SPECIAL_KEYS.get(msvcrt.getwch(), b""))
+            continue
+        if "\ud800" <= char <= "\udbff" and msvcrt.kbhit():
+            char += msvcrt.getwch()
+            char = char.encode("utf-16", errors="surrogatepass").decode("utf-16")
+        data.extend(char.encode("utf-8", errors="replace"))
+    return bytes(data)

runtime_sdk/files.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+import sys
+import tarfile
+import tempfile
+from pathlib import Path
+from typing import Any
+
+from runtime_sdk import computers, output as cli_output
+from runtime_sdk.auth import authenticated_client
+from runtime_sdk.client import RuntimeAPIError, RuntimeClient
+from runtime_sdk.config import RuntimeConfig
+
+
+def handle_files(config: RuntimeConfig, args: Any) -> int:
+    action = str(getattr(args, "files_action", "") or "")
+    if action == "read":
+        return handle_files_read(config, args.id, args.path, args.output)
+    if action == "write":
+        return handle_files_write(config, args)
+    if action in ("list", "ls"):
+        return handle_files_list(config, args.id, args.path)
+    if action == "stat":
+        return handle_files_stat(config, args.id, args.path)
+    if action == "mkdir":
+        return handle_files_mkdir(config, args.id, args.path, args.parents, args.mode)
+    if action in ("rm", "delete"):
+        return handle_files_rm(config, args.id, args.path, args.recursive)
+    if action == "upload":
+        return handle_files_upload(config, args.id, args.local, args.remote)
+    if action == "download":
+        return handle_files_download(config, args.id, args.remote, args.local)
+    return cli_output.report_error("unknown files command")
+
+
+def _resolve_file_target(
+    config: RuntimeConfig, computer_id: str | None, path: str | None
+) -> tuple[RuntimeClient, str, str] | int:
+    if (err := cli_output.require_auth(config)) is not None:
+        return err
+    if not computer_id:
+        return cli_output.report_error("computer id is required")
+    if not path:
+        return cli_output.report_error("path is required")
+    client = authenticated_client(config)
+    resolved_id = computers.resolve_computer_ref(client, computer_id)
+    return client, resolved_id, path
+
+
+def handle_files_read(
+    config: RuntimeConfig, computer_id: str | None, path: str | None, output: str | None
+) -> int:
+    resolved = _resolve_file_target(config, computer_id, path)
+    if isinstance(resolved, int):
+        return resolved
+    client, resolved_id, resolved_path = resolved
+    data = client.read_file(resolved_id, resolved_path)
+    if output:
+        try:
+            Path(output).write_bytes(data)
+        except OSError as exc:
+            return cli_output.report_error(f"failed to write output file: {exc}")
+        return cli_output.report_success(
+            {"path": resolved_path, "output": output, "size": len(data)}
+        )
+    stdout_buffer = getattr(sys.stdout, "buffer", None)
+    if stdout_buffer is None:
+        sys.stdout.write(data.decode(errors="replace"))
+        sys.stdout.flush()
+        return 0
+    stdout_buffer.write(data)
+    stdout_buffer.flush()
+    return 0
+
+
+def handle_files_write(config: RuntimeConfig, args: Any) -> int:
+    input_path = getattr(args, "input", None)
+    content = getattr(args, "content", None)
+    if input_path and content is not None:
+        return cli_output.report_error("pass either --input or --content, not both")
+    resolved = _resolve_file_target(config, args.id, args.path)
+    if isinstance(resolved, int):
+        return resolved
+    client, resolved_id, resolved_path = resolved
+    if input_path:
+        try:
+            data = Path(input_path).read_bytes()
+        except OSError as exc:
+            return cli_output.report_error(f"failed to read input file: {exc}")
+    elif content is not None:
+        data = content.encode()
+    else:
+        stdin_buffer = getattr(sys.stdin, "buffer", None)
+        data = (
+            stdin_buffer.read()
+            if stdin_buffer is not None
+            else sys.stdin.read().encode()
+        )
+    result = client.write_file(
+        resolved_id, resolved_path, data, uid=args.uid, gid=args.gid, mode=args.mode
+    )
+    return cli_output.report_success(result)
+
+
+def handle_files_list(
+    config: RuntimeConfig, computer_id: str | None, path: str | None
+) -> int:
+    resolved = _resolve_file_target(config, computer_id, path or "/home/runtime")
+    if isinstance(resolved, int):
+        return resolved
+    client, resolved_id, resolved_path = resolved
+    return cli_output.report_success(client.list_files(resolved_id, resolved_path))
+
+
+def handle_files_stat(
+    config: RuntimeConfig, computer_id: str | None, path: str | None
+) -> int:
+    resolved = _resolve_file_target(config, computer_id, path)
+    if isinstance(resolved, int):
+        return resolved
+    client, resolved_id, resolved_path = resolved
+    return cli_output.report_success(client.stat_file(resolved_id, resolved_path))
+
+
+def handle_files_mkdir(
+    config: RuntimeConfig,
+    computer_id: str | None,
+    path: str | None,
+    parents: bool,
+    mode: str | None,
+) -> int:
+    resolved = _resolve_file_target(config, computer_id, path)
+    if isinstance(resolved, int):
+        return resolved
+    client, resolved_id, resolved_path = resolved
+    result = client.mkdir(resolved_id, resolved_path, recursive=parents, mode=mode)
+    return cli_output.report_success(result)
+
+
+def handle_files_rm(
+    config: RuntimeConfig, computer_id: str | None, path: str | None, recursive: bool
+) -> int:
+    resolved = _resolve_file_target(config, computer_id, path)
+    if isinstance(resolved, int):
+        return resolved
+    client, resolved_id, resolved_path = resolved
+    result = client.delete_file(resolved_id, resolved_path, recursive=recursive)
+    return cli_output.report_success(result)
+
+
+def handle_files_upload(
+    config: RuntimeConfig,
+    computer_id: str | None,
+    local: str | None,
+    remote: str | None,
+) -> int:
+    if not local:
+        return cli_output.report_error("local path is required")
+    local_path = Path(local)
+    if not local_path.exists():
+        return cli_output.report_error(f"local path does not exist: {local}")
+    resolved = _resolve_file_target(config, computer_id, remote)
+    if isinstance(resolved, int):
+        return resolved
+    client, resolved_id, remote_path = resolved
+    with tempfile.TemporaryFile() as archive:
+        try:
+            with tarfile.open(fileobj=archive, mode="w") as tar:
+                if local_path.is_dir():
+                    for child in sorted(local_path.rglob("*")):
+                        tar.add(
+                            child,
+                            arcname=str(child.relative_to(local_path)),
+                            recursive=False,
+                        )
+                else:
+                    tar.add(local_path, arcname=local_path.name, recursive=False)
+        except (OSError, tarfile.TarError) as exc:
+            return cli_output.report_error(f"failed to read local path: {exc}")
+        archive.seek(0)
+        result = client.upload_files(resolved_id, remote_path, archive)
+    return cli_output.report_success(result)
+
+
+def handle_files_download(
+    config: RuntimeConfig,
+    computer_id: str | None,
+    remote: str | None,
+    local: str | None,
+) -> int:
+    local_dir = Path(local or ".")
+    resolved = _resolve_file_target(config, computer_id, remote)
+    if isinstance(resolved, int):
+        return resolved
+    client, resolved_id, remote_path = resolved
+    try:
+        local_dir.mkdir(parents=True, exist_ok=True)
+        with tempfile.TemporaryFile() as archive:
+            client.download_files_to(resolved_id, remote_path, archive)
+            archive.seek(0)
+            with tarfile.open(fileobj=archive, mode="r") as tar:
+                members = tar.getmembers()
+                for member in members:
+                    target = safe_local_extract_path(local_dir, member.name)
+                    if member.isdir():
+                        target.mkdir(parents=True, exist_ok=True)
+                        continue
+                    if not member.isfile():
+                        return cli_output.report_error(
+                            f"unsupported archive entry: {member.name}"
+                        )
+                    target.parent.mkdir(parents=True, exist_ok=True)
+                    source = tar.extractfile(member)
+                    if source is None:
+                        return cli_output.report_error(
+                            f"missing archive data: {member.name}"
+                        )
+                    target.write_bytes(source.read())
+    except (OSError, tarfile.TarError) as exc:
+        return cli_output.report_error(f"failed to write downloaded files: {exc}")
+    return cli_output.report_success(
+        {"path": remote_path, "output": str(local_dir), "entries": len(members)}
+    )
+
+
+def safe_local_extract_path(root: Path, name: str) -> Path:
+    if not name or Path(name).is_absolute():
+        raise RuntimeAPIError(f"unsafe archive entry: {name}")
+    target = (root / name).resolve()
+    root_resolved = root.resolve()
+    if target != root_resolved and root_resolved not in target.parents:
+        raise RuntimeAPIError(f"unsafe archive entry: {name}")
+    return target