runtime-sdk 0.4.49__py3-none-win_amd64.whl

runtime_sdk/terminal.py

@@ -0,0 +1,330 @@
+from __future__ import annotations
+
+import contextlib
+import re
+import shutil
+import struct
+import sys
+import threading
+import time
+from typing import Any
+from urllib.parse import urljoin, urlparse
+
+from websockets.exceptions import ConnectionClosed, InvalidHandshake
+from websockets.sync.client import connect as websocket_connect
+
+from runtime_sdk import console, output as cli_output
+from runtime_sdk.auth import authenticated_client
+from runtime_sdk.client import DEFAULT_WARMUP_TIMEOUT, RuntimeAPIError
+from runtime_sdk.config import RuntimeConfig
+
+
+def resolve_ws_url(base_url: str, ws_url: Any) -> str:
+    text = str(ws_url or "").strip()
+    if not text:
+        return ""
+    if text.startswith("ws://") or text.startswith("wss://"):
+        return text
+
+    parsed = urlparse(base_url)
+    scheme = "wss" if parsed.scheme == "https" else "ws"
+    root = f"{scheme}://{parsed.netloc}"
+    if text.startswith("/"):
+        return root + text
+    return urljoin(root + "/", text)
+
+
+def strip_controls(text: str) -> str:
+    text = re.sub(r"\x1b\].*?(?:\x07|\x1b\\)", "", text, flags=re.S)
+    text = re.sub(r"\x1bP.*?\x1b\\", "", text, flags=re.S)
+    text = re.sub(r"\x1b\[[0-?]*[ -/]*[@-~]", "", text)
+    text = re.sub(r"\x1b[@-Z\\-_]", "", text)
+    text = "".join(ch for ch in text if ch in "\n\r\t" or ord(ch) >= 32)
+    return text.replace("\r\n", "\n").replace("\r", "\n")
+
+
+def enter_computer(
+    config: RuntimeConfig, computer_id: str, *, command: str | None = None
+) -> int:
+    client = authenticated_client(config)
+    ticket_payload = client.create_terminal_ticket(computer_id)
+    ws_url = resolve_ws_url(config.base_url, ticket_payload.get("ws_url"))
+    if not ws_url:
+        return cli_output.report_error(
+            "terminal endpoint did not return a websocket url"
+        )
+
+    print("Connecting to console...")
+
+    try:
+        return _run_terminal_session(ws_url, bootstrap_command=command)
+    except RuntimeAPIError as exc:
+        return cli_output.report_error(str(exc), status_code=exc.status_code)
+    except (InvalidHandshake, TimeoutError, OSError) as exc:
+        return cli_output.report_error(f"terminal failed: {exc}")
+
+
+TERMINAL_FRAME_DATA = 0x01
+
+
+TERMINAL_FRAME_WINDOW_SIZE = 0x02
+
+
+TERMINAL_FRAME_SHUTDOWN = 0x03
+
+
+TERMINAL_FRAME_HEARTBEAT = 0x04
+
+
+TERMINAL_FRAME_SESSION_CLOSE = 0x05
+
+
+TERMINAL_FRAME_HEADER_SIZE = 5
+
+
+TERMINAL_HEARTBEAT_INTERVAL = 15.0
+
+
+def _encode_terminal_frame(frame_type: int, payload: bytes = b"") -> bytes:
+    return bytes([frame_type]) + struct.pack(">I", len(payload)) + payload
+
+
+def _parse_terminal_frame(raw: bytes) -> tuple[int, bytes]:
+    if len(raw) < TERMINAL_FRAME_HEADER_SIZE:
+        raise RuntimeAPIError("terminal received a truncated frame")
+    payload_len = struct.unpack(">I", raw[1:TERMINAL_FRAME_HEADER_SIZE])[0]
+    if len(raw) != TERMINAL_FRAME_HEADER_SIZE + payload_len:
+        raise RuntimeAPIError("terminal received a malformed frame")
+    return raw[0], raw[TERMINAL_FRAME_HEADER_SIZE:]
+
+
+def _run_terminal_session(ws_url: str, *, bootstrap_command: str | None = None) -> int:
+    if not sys.stdin.isatty() or not sys.stdout.isatty():
+        return cli_output.report_error("enter requires an interactive terminal")
+
+    fd = sys.stdin.fileno()
+    stop = threading.Event()
+    result: dict[str, Any] = {"code": 0, "error": None}
+    bootstrap_echo = (
+        f"exec {bootstrap_command.strip()}"
+        if bootstrap_command and bootstrap_command.strip()
+        else ""
+    )
+    output_state: dict[str, Any] = {
+        "buffer": "",
+        "suppressing_preamble": True,
+        "bootstrap_echo": bootstrap_echo,
+    }
+
+    with websocket_connect(
+        ws_url, open_timeout=DEFAULT_WARMUP_TIMEOUT, close_timeout=1
+    ) as ws:
+        _send_terminal_resize(ws)
+        _send_terminal_bootstrap(ws, bootstrap_command)
+
+        def recv_loop() -> None:
+            try:
+                while not stop.is_set():
+                    raw = ws.recv()
+                    if raw is None:
+                        result["code"] = 0
+                        stop.set()
+                        return
+                    if not isinstance(raw, bytes):
+                        raise RuntimeAPIError("terminal received a non-binary frame")
+                    frame_type, payload = _parse_terminal_frame(raw)
+                    if frame_type == TERMINAL_FRAME_HEARTBEAT:
+                        continue
+                    if frame_type == TERMINAL_FRAME_DATA:
+                        data = _filter_terminal_output(
+                            payload.decode("utf-8", errors="ignore"), output_state
+                        )
+                        if data:
+                            sys.stdout.write(data)
+                            sys.stdout.flush()
+                        continue
+                    if frame_type in (
+                        TERMINAL_FRAME_SHUTDOWN,
+                        TERMINAL_FRAME_SESSION_CLOSE,
+                    ):
+                        stop.set()
+                        return
+            except ConnectionClosed:
+                if (
+                    not stop.is_set()
+                    and not result.get("error")
+                    and int(result.get("code") or 0) == 0
+                ):
+                    result["code"] = 1
+                    result["error"] = "terminal connection closed unexpectedly"
+                stop.set()
+            except (
+                Exception
+            ) as exc:  # pragma: no cover - defensive for real TTY sessions
+                result["code"] = 1
+                result["error"] = str(exc)
+                stop.set()
+
+        recv_thread = threading.Thread(target=recv_loop, daemon=True)
+        recv_thread.start()
+
+        last_size = shutil.get_terminal_size((100, 24))
+        last_heartbeat = time.monotonic()
+
+        def mark_connection_closed() -> None:
+            if (
+                not stop.is_set()
+                and not result.get("error")
+                and int(result.get("code") or 0) == 0
+            ):
+                result["code"] = 1
+                result["error"] = "terminal connection closed unexpectedly"
+            stop.set()
+
+        try:
+            with console.raw_terminal_input(fd) as read_input:
+                while not stop.is_set():
+                    current_size = shutil.get_terminal_size((100, 24))
+                    if current_size != last_size:
+                        _send_terminal_resize(ws)
+                        last_size = current_size
+
+                    now = time.monotonic()
+                    if now - last_heartbeat >= TERMINAL_HEARTBEAT_INTERVAL:
+                        try:
+                            _send_terminal_heartbeat(ws)
+                        except ConnectionClosed:
+                            mark_connection_closed()
+                            break
+                        last_heartbeat = now
+
+                    data = read_input(0.1)
+                    if data is None:
+                        continue
+                    if not data:
+                        stop.set()
+                        break
+                    try:
+                        ws.send(_encode_terminal_frame(TERMINAL_FRAME_DATA, data))
+                    except ConnectionClosed:
+                        mark_connection_closed()
+                        break
+        finally:
+            stop.set()
+            with contextlib.suppress(Exception):
+                ws.send(_encode_terminal_frame(TERMINAL_FRAME_SHUTDOWN))
+            with contextlib.suppress(Exception):
+                ws.close()
+            recv_thread.join(timeout=1)
+
+    sys.stdout.write("\n")
+    sys.stdout.flush()
+    tail = _flush_terminal_output(output_state)
+    if tail:
+        sys.stdout.write(tail)
+        sys.stdout.flush()
+    if result.get("error"):
+        print(str(result["error"]), file=sys.stderr)
+    return int(result.get("code") or 0)
+
+
+def _filter_terminal_output(chunk: str, state: dict[str, Any]) -> str:
+    if not chunk:
+        return ""
+    if not state.get("suppressing_preamble", False):
+        return _strip_terminal_noise(chunk, str(state.get("bootstrap_echo") or ""))
+
+    buffer = str(state.get("buffer") or "") + chunk
+    marker = "\x1b[1;34mruntime@"
+    idx = buffer.find(marker)
+    if idx != -1:
+        state["suppressing_preamble"] = False
+        state["buffer"] = ""
+        return _strip_terminal_noise(
+            buffer[idx:], str(state.get("bootstrap_echo") or "")
+        )
+
+    cleaned = _strip_terminal_noise(buffer, str(state.get("bootstrap_echo") or ""))
+    if cleaned and _should_release_terminal_output(cleaned):
+        state["suppressing_preamble"] = False
+        state["buffer"] = ""
+        return cleaned
+
+    if len(buffer) > 8192:
+        state["suppressing_preamble"] = False
+        state["buffer"] = ""
+        return _strip_terminal_noise(buffer, str(state.get("bootstrap_echo") or ""))
+
+    state["buffer"] = buffer
+    return ""
+
+
+def _should_release_terminal_output(text: str) -> bool:
+    if not text:
+        return False
+    if "\n" in text or "\r" in text:
+        return True
+    if len(text) >= 256:
+        return True
+
+    stripped = text.rstrip()
+    return text.endswith(("$ ", "# ", "% ", "> ")) or stripped.endswith(
+        ("$", "#", "%", ">")
+    )
+
+
+def _flush_terminal_output(state: dict[str, Any]) -> str:
+    buffer = str(state.get("buffer") or "")
+    state["buffer"] = ""
+    return _strip_terminal_noise(buffer, str(state.get("bootstrap_echo") or ""))
+
+
+ANSI_ESCAPE_RE = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
+
+
+def _strip_terminal_noise(text: str, bootstrap_echo: str = "") -> str:
+    if not text:
+        return ""
+
+    lines = text.splitlines(keepends=True)
+    filtered: list[str] = []
+    for line in lines:
+        stripped = line.rstrip("\r\n")
+        if stripped.startswith(
+            "Running bootstrap command: export PS1='\\[\\033[1;34m\\]runtime@"
+        ):
+            continue
+        if stripped == "Connected! Press Ctrl+] to exit.":
+            continue
+        if _is_terminal_bootstrap_echo(stripped, bootstrap_echo):
+            continue
+        filtered.append(line)
+    return "".join(filtered)
+
+
+def _is_terminal_bootstrap_echo(line: str, bootstrap_echo: str) -> bool:
+    bootstrap_echo = bootstrap_echo.strip()
+    if not bootstrap_echo:
+        return False
+    clean = ANSI_ESCAPE_RE.sub("", line).strip()
+    return clean == bootstrap_echo or clean.endswith(bootstrap_echo)
+
+
+def _send_terminal_bootstrap(ws: Any, command: str | None) -> None:
+    command = (command or "").strip()
+    if not command:
+        return
+    ws.send(_encode_terminal_frame(TERMINAL_FRAME_DATA, f"exec {command}\n".encode()))
+
+
+def _send_terminal_resize(ws: Any) -> None:
+    size = shutil.get_terminal_size((100, 24))
+    ws.send(
+        _encode_terminal_frame(
+            TERMINAL_FRAME_WINDOW_SIZE, struct.pack(">II", size.columns, size.lines)
+        )
+    )
+
+
+def _send_terminal_heartbeat(ws: Any) -> None:
+    ws.send(_encode_terminal_frame(TERMINAL_FRAME_HEARTBEAT))

runtime_sdk-0.4.49.dist-info/METADATA

@@ -0,0 +1,273 @@
+Metadata-Version: 2.4
+Name: runtime-sdk
+Version: 0.4.49
+Summary: Runtime Python SDK and CLI
+Project-URL: Repository, https://github.com/The-Money-Company-Limited/runtimevm
+Project-URL: Issues, https://github.com/The-Money-Company-Limited/runtimevm/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Environment :: Console
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: websockets>=15.0
+
+# runtime-sdk
+
+Python SDK and CLI for Runtime.
+
+## Install
+
+Supported host OS for scriptable CLI commands: **Windows, macOS, and Linux**.
+
+The interactive dashboard ships in native wheels for Windows ARM64/x64,
+macOS 13+ ARM64/x64, and 64-bit Linux with glibc 2.17+. Other supported
+environments receive the universal wheel with the complete scriptable CLI but
+without the OpenTUI dashboard.
+
+```bash
+uv tool install runtime-sdk
+```
+
+To upgrade an existing install:
+
+```bash
+uv tool upgrade runtime-sdk
+```
+
+## Configure
+
+The CLI talks to `https://api.runruntime.dev` by default.
+
+For local or self-hosted Runtime, override it with:
+
+```bash
+export RUNTIME_BASE_URL=http://127.0.0.1:8080
+```
+
+Or pass `--base-url` per command.
+
+## Usage
+
+```bash
+# Auth
+runtime                          # open the interactive dashboard; sign in first if needed
+runtime login                    # WorkOS device login; opens the verification page
+runtime login --no-open          # print the URL and code for a browserless host
+runtime whoami
+runtime logout
+runtime login --api-key sk_...   # explicit headless credential mode
+# Or set RUNTIME_API_KEY for one process without saving it.
+runtime api-keys list
+runtime api-keys create "my laptop"
+runtime api-keys revoke key_01...
+runtime integrate github
+runtime github list
+runtime github disconnect acme
+
+# Computers
+runtime switch --repo owner/repo feature/login      # open or create the branch workspace computer
+runtime switch -c feature/login --repo owner/repo   # create a new branch workspace from the repo default branch
+runtime checkout --repo owner/repo feature/login    # alias for switch
+runtime create                       # creates a computer with the starter app already published
+runtime create myapp --command "python3 app.py" --cwd /home/runtime --port 3000
+runtime create locked --network allowlist --allow-host api.example.com
+runtime enter <name-or-id>         # open an interactive shell; accepts slug/name or computer id
+runtime enter <name-or-id> -- claude   # open a real TTY and run an interactive command
+runtime enter <name-or-id> -- python   # use enter for REPLs, agents, prompts, and full-screen apps
+runtime ssh <name-or-id>           # open SSH through Runtime's authenticated tunnel
+runtime ssh <name-or-id> -- uptime # run a command with the local ssh client
+runtime list                    # open the computer dashboard in a terminal
+runtime list --json             # one JSON response for scripts and agents
+runtime list --json --watch 2   # newline-delimited JSON updates
+runtime info <id>
+runtime share public <id>
+runtime share private <id>
+runtime start <id>
+runtime run <id> "echo hello"      # one-shot foreground command only
+runtime run <id> "apt install -y nodejs" --uid 0
+runtime exec <id> -- bash -lc 'for i in 1 2 3; do echo $i; sleep 1; done'
+printf 'hello' | runtime exec <id> --stdin -- cat
+# Use runtime exec for automation and exact exit codes; use runtime enter -- <cmd> for interactive TTY commands.
+runtime files ls <id> /home/runtime
+runtime files read <id> /home/runtime/app.py --output app.py
+runtime files write <id> /home/runtime/app.py --input app.py --mode 0644
+runtime files mkdir <id> /home/runtime/data --parents
+runtime files upload <id> ./local-app /home/runtime/app
+runtime files download <id> /home/runtime/app ./downloaded-app
+runtime files rm <id> /home/runtime/data --recursive
+runtime startup show <id>
+runtime startup set <id> --command "python3 app.py" --cwd /home/runtime --port 3000
+runtime startup clear <id>          # low-level durable service config
+runtime service show <id>           # user-facing alias for the durable published app
+runtime service clear <id>
+runtime publish <id> 3000 -- python3 app.py
+runtime delete <id>
+
+# Network policy
+runtime network default show
+runtime network default allowlist api.example.com '*.github.com'
+runtime network show <id>
+runtime network denials <id>
+runtime network set <id> none
+runtime network set <id> open
+
+# Inside a running computer, the helper installed by Runtime can manage the
+# durable app without leaving the sandbox:
+#   runtime-env publish 3000 -- python3 app.py
+#   runtime-env service show
+#   runtime-env service clear
+```
+
+Private public URLs authenticate the browser before forwarding traffic. Apps
+behind a private URL receive trusted `X-Runtime-Account-ID`,
+`X-Runtime-User-ID`, and `X-Runtime-User-Email` headers. Runtime strips
+client-supplied versions of those headers from both public and private traffic;
+public URLs receive no Runtime identity headers.
+
+## Python
+
+```python
+from runtime_sdk import RuntimeClient
+
+client = RuntimeClient(base_url="https://api.runruntime.dev", credential="sk_...")
+
+# Create a computer. New computers start with the starter app already published.
+computer = client.create_computer()
+print(computer["public_url"])  # https://goldbird.runruntime.dev
+
+# Or create one with an explicit durable app command.
+# That saved service is replayed after cold restore / start.
+app = client.create_computer(
+    slug="myapp",
+    command="python3 app.py",
+    cwd="/home/runtime",
+    port=3000,
+)
+
+# Account defaults are copied only to computers created later.
+client.set_default_network("allowlist", ["api.example.com"])
+restricted = client.create_computer()
+client.set_computer_network(restricted["id"], "none")
+
+# Run a command
+result = client.run_command(computer["id"], "echo hello")
+print(result["stdout"])
+
+client.write_file(computer["id"], "/home/runtime/hello.txt", b"hello\n")
+print(client.read_file(computer["id"], "/home/runtime/hello.txt"))
+print(client.list_files(computer["id"], "/home/runtime"))
+
+# Wake a cold computer explicitly
+client.start_computer(app["id"])
+
+# Promote the running app on a local port to the durable public app.
+# Runtime inspects the listening process and saves its command + cwd when possible.
+client.publish_port(computer["id"], 3000)
+
+# List, info, delete
+computers = client.list_computers()
+info = client.get_computer(computer["id"])
+client.delete_computer(computer["id"])
+```
+
+## Development
+
+For fast local backend iteration:
+
+```bash
+make local-backend
+```
+
+For deploying and testing against the Hetzner production server:
+
+```bash
+make sync SERVER_IP=x.x.x.x SSH_USER=root
+make smoke
+```
+
+Use `make deploy` instead of `make sync` when migrations, env
+files, Caddy, or systemd units changed.
+
+Cold restore and explicit `runtime start` replay the saved published app command.
+New computers seed that durable app from the starter workspace. Later,
+`runtime publish <id> <port> -- <command...>` replaces the durable app command
+and starts it. Inside a running computer,
+`runtime-env publish <port> -- <command...>` does the same thing using a
+computer-scoped token installed by Runtime. `runtime service show|clear` and
+`runtime-env service show|clear`
+expose that same durable app state directly. The low-level `runtime startup ...`
+commands still map to the same durable state. A one-off `runtime run` stays
+one-shot: the filesystem is restored after going cold, but that ad-hoc process
+is not.
+
+## GitHub branch workspaces
+
+`runtime switch` gives a repo branch its own Runtime computer so you can jump
+between parallel tasks without local worktrees.
+
+```bash
+runtime integrate github
+runtime github list
+runtime switch --repo owner/repo feature/login
+runtime switch -c feature/search --repo owner/repo --from main
+```
+
+Rules:
+- GitHub must already be connected with `runtime integrate github`.
+- Run `runtime integrate github` again when you want to add another personal account or org.
+- New GitHub connects require user authorization during installation and
+  `GITHUB_APP_CLIENT_ID` / `GITHUB_APP_CLIENT_SECRET` on the Runtime API.
+  In GitHub App settings, enable user authorization during installation and set
+  the callback URL to `https://api.runruntime.dev/github/callback`.
+- `runtime switch` opens an existing branch workspace, or creates the computer if
+  the branch exists but the workspace does not yet.
+- `runtime switch -c` creates a new branch first, then opens that branch's
+  workspace.
+- Each `repo + branch` maps to one dedicated computer.
+- The repo is cloned into `/home/runtime/<repo>` and new shells in that computer
+  start there automatically.
+- `runtime checkout ...` is an alias for `runtime switch ...`.
+
+Run the SDK unit tests through the backend project environment:
+
+```bash
+uv run python -m unittest discover -s scripts/tests -p 'test_*.py'
+```
+
+## Release
+
+Set and commit the release version first:
+
+```bash
+cd backend
+uv version <next-version>
+```
+
+Merge the release version to `main`, then run the Runtime SDK workflow with the
+exact committed version. The workflow tests the Python CLI and OpenTUI, builds
+all platform wheels, runs the installed Windows wheel against production, and
+only then publishes those same artifacts to PyPI.
+
+```bash
+VERSION="$(uv version --short)"
+gh workflow run runtime-sdk.yml --ref main -f version="${VERSION}" -f publish=true
+```
+
+Preview the runner commands without building:
+
+```bash
+./scripts/release_runtime_sdk.sh --dry-run
+```
+
+`RUNTIME_WINDOWS_SMOKE_API_KEY` is the production smoke credential;
+`UV_PUBLISH_TOKEN` is used only by the publish job after every wheel and the
+Windows production smoke pass. The build script never publishes, changes the
+source version, or loads a local `.env` file.

runtime_sdk-0.4.49.dist-info/RECORD

@@ -0,0 +1,26 @@
+runtime_sdk/__init__.py,sha256=_fcdLGAGl00mqptSUWHoPwjgEL8kASrWVMy_tZqUUf0,501
+runtime_sdk/account.py,sha256=2GEG5pZiF1Dh3ZhkpxaAKE0B03RGubVMnIzLwVgbel4,8468
+runtime_sdk/arguments.py,sha256=-zfsxKFoCr-2epM8cSk9g8NltBaRZ-ih3vDNeChWPk0,264
+runtime_sdk/auth.py,sha256=GXuTMaT3an7dv2Fgl8arIi1zSgZ2CDLAskML3X8GxSI,5914
+runtime_sdk/cli.py,sha256=xUKaQBwIizcXt_0l6XiSaDW__aPhT2MwE2x48mTNJ8o,50587
+runtime_sdk/client.py,sha256=Kthr1FjPFMMh2oO_ZzlxAC7OrUmwm8wI2mgo09v1YVY,23250
+runtime_sdk/completion.py,sha256=yaGk0YVYK8i4RLdrqWuJUVndONbp5G173gyPGhEyAlo,13617
+runtime_sdk/computers.py,sha256=ZKRb8jAtsP3mYpeiCWAddLworKqFrS32SykizSdCR7s,20084
+runtime_sdk/config.py,sha256=CdjCDs-5qa12DWrHgqSf0YQOZ5_o3cjYvEzosaEXT-4,6158
+runtime_sdk/console.py,sha256=KvvgmNJzEixNa9SHp9JF2WGRQdrO9bqrtLeU1zoCGus,4035
+runtime_sdk/files.py,sha256=LyZohpK6fjXhSv5X4M2kuGG0y75791ZvPAD_QEjJsRw,8936
+runtime_sdk/github.py,sha256=cPxLNJScawmptCeraMeDbZviDJ1gXo9M9tGSdnIMXYM,8189
+runtime_sdk/goals.py,sha256=FWM9OhIFiFTEujUUSDzkgymgEcAV1LkaM9QNpEO5p4Y,11491
+runtime_sdk/output.py,sha256=NNzG_xpwe91j2bNnIKDj-Z9Xk5Tg8DFHaZD-VXnhVes,2046
+runtime_sdk/providers.py,sha256=TQan5VB63pIxEuhpMxS8d5VoxG_dqlO93aVxu61_LXE,14478
+runtime_sdk/proxy.py,sha256=KJVmoVGJ7btZYmsjnT0JUAd9cjNK98ASvMQED7VG5xU,19744
+runtime_sdk/runtime-tui.exe,sha256=o-3ZwrRicYA8WHSWO2N-7dgY1BwJgRkGXcSNssty_6Y,107655168
+runtime_sdk/secrets.py,sha256=aAXC-4ywbv8kbn9Zl55CicpTRD0wcnFc4lyk8JGAB8s,5900
+runtime_sdk/services.py,sha256=gmGNLa_u9WAoMmAjQWrPaeVvN-zVqT-oxNDp2ftjptQ,6411
+runtime_sdk/ssh.py,sha256=e9fRSkqeVE6DYux_W1yks3YVGX_7Ba7S3rJcfYs4JZ0,6492
+runtime_sdk/terminal.py,sha256=PzPXfTPA5TZb4VFpNxWlt-2Y56XT38wOzFwBEIvGuk8,11030
+runtime_sdk-0.4.49.dist-info/METADATA,sha256=sPhn3uDPsdpA9Xsz58RwRs6P5FXwxzxGkxHpYpx-KZM,10182
+runtime_sdk-0.4.49.dist-info/WHEEL,sha256=hVx9elvUDfBjRmbl8JwIcXXikst35RZTZK9nspfI_28,98
+runtime_sdk-0.4.49.dist-info/entry_points.txt,sha256=Hk_zo0mQTeqWOYb1oTxGnGN-b61_6uKYAt3THED8xeE,49
+runtime_sdk-0.4.49.dist-info/top_level.txt,sha256=RmTYN3o3Mn1j6OozW1LbYaYvy3FjQU3E118nfNv7Ye0,12
+runtime_sdk-0.4.49.dist-info/RECORD,,

runtime_sdk-0.4.49.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64
+

runtime_sdk-0.4.49.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+runtime = runtime_sdk.cli:main

runtime_sdk-0.4.49.dist-info/top_level.txt

@@ -0,0 +1 @@
+runtime_sdk