runtime-sdk 0.4.33__tar.gz → 0.4.35__tar.gz

{runtime_sdk-0.4.33 → runtime_sdk-0.4.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runtime-sdk
-Version: 0.4.33
+Version: 0.4.35
 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
@@ -84,6 +84,15 @@ 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
+runtime files ls <id> /home/ubuntu
+runtime files read <id> /home/ubuntu/app.py --output app.py
+runtime files write <id> /home/ubuntu/app.py --input app.py --mode 0644
+runtime files mkdir <id> /home/ubuntu/data --parents
+runtime files upload <id> ./local-app /home/ubuntu/app
+runtime files download <id> /home/ubuntu/app ./downloaded-app
+runtime files rm <id> /home/ubuntu/data --recursive
 runtime startup show <id>
 runtime startup set <id> --command "python3 app.py" --cwd /home/ubuntu --port 3000
 runtime startup clear <id>          # low-level durable service config
@@ -123,6 +132,10 @@ app = client.create_computer(
 result = client.run_command(computer["id"], "echo hello")
 print(result["stdout"])
 
+client.write_file(computer["id"], "/home/ubuntu/hello.txt", b"hello\n")
+print(client.read_file(computer["id"], "/home/ubuntu/hello.txt"))
+print(client.list_files(computer["id"], "/home/ubuntu"))
+
 # Wake a cold computer explicitly
 client.start_computer(app["id"])
 

{runtime_sdk-0.4.33 → runtime_sdk-0.4.35}/README.md

@@ -62,6 +62,15 @@ 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
+runtime files ls <id> /home/ubuntu
+runtime files read <id> /home/ubuntu/app.py --output app.py
+runtime files write <id> /home/ubuntu/app.py --input app.py --mode 0644
+runtime files mkdir <id> /home/ubuntu/data --parents
+runtime files upload <id> ./local-app /home/ubuntu/app
+runtime files download <id> /home/ubuntu/app ./downloaded-app
+runtime files rm <id> /home/ubuntu/data --recursive
 runtime startup show <id>
 runtime startup set <id> --command "python3 app.py" --cwd /home/ubuntu --port 3000
 runtime startup clear <id>          # low-level durable service config
@@ -101,6 +110,10 @@ app = client.create_computer(
 result = client.run_command(computer["id"], "echo hello")
 print(result["stdout"])
 
+client.write_file(computer["id"], "/home/ubuntu/hello.txt", b"hello\n")
+print(client.read_file(computer["id"], "/home/ubuntu/hello.txt"))
+print(client.list_files(computer["id"], "/home/ubuntu"))
+
 # Wake a cold computer explicitly
 client.start_computer(app["id"])
 

{runtime_sdk-0.4.33 → runtime_sdk-0.4.35}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "runtime-sdk"
-version = "0.4.33"
+version = "0.4.35"
 description = "Runtime Python SDK and CLI"
 readme = "README.md"
 requires-python = ">=3.11"

{runtime_sdk-0.4.33 → runtime_sdk-0.4.35}/scripts/runtime_sdk/cli.py

@@ -15,6 +15,8 @@ import socket
 import struct
 import subprocess
 import sys
+import tarfile
+import tempfile
 import threading
 import time
 import webbrowser
@@ -278,6 +280,53 @@ def build_parser() -> argparse.ArgumentParser:
     run_cmd.add_argument("--cwd", help="Working directory")
     run_cmd.add_argument("--shell", help="Shell to use")
 
+    exec_cmd = subparsers.add_parser("exec", help="Stream a command in a computer")
+    exec_cmd.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
+    exec_cmd.add_argument("exec_command", nargs="*", help="Command after --")
+    exec_cmd.add_argument("--stdin", action="store_true", help="Pipe local stdin to the command")
+    exec_cmd.add_argument("--uid", type=int, help="User ID")
+    exec_cmd.add_argument("--gid", type=int, help="Group ID")
+    exec_cmd.add_argument("--cwd", help="Working directory")
+    exec_cmd.add_argument("--shell", help="Shell to use")
+
+    files_cmd = subparsers.add_parser("files", aliases=["fs", "file"], help="Read, write, list, and delete files")
+    files_subparsers = files_cmd.add_subparsers(dest="files_action", required=True)
+    files_read = files_subparsers.add_parser("read", help="Read a file to stdout or --output")
+    files_read.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
+    files_read.add_argument("path", nargs="?", default=None, help="Path inside the computer")
+    files_read.add_argument("--output", "-o", help="Local output file")
+    files_write = files_subparsers.add_parser("write", help="Write stdin, --content, or --input into a file")
+    files_write.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
+    files_write.add_argument("path", nargs="?", default=None, help="Path inside the computer")
+    files_write.add_argument("--input", "-i", help="Local input file (defaults to stdin)")
+    files_write.add_argument("--content", help="Literal text to write")
+    files_write.add_argument("--mode", help="File mode, e.g. 0644")
+    files_write.add_argument("--uid", type=int, help="User ID")
+    files_write.add_argument("--gid", type=int, help="Group ID")
+    files_list = files_subparsers.add_parser("list", aliases=["ls"], help="List a directory")
+    files_list.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
+    files_list.add_argument("path", nargs="?", default=None, help="Directory path")
+    files_stat = files_subparsers.add_parser("stat", help="Show file metadata")
+    files_stat.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
+    files_stat.add_argument("path", nargs="?", default=None, help="Path inside the computer")
+    files_mkdir = files_subparsers.add_parser("mkdir", help="Create a directory")
+    files_mkdir.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
+    files_mkdir.add_argument("path", nargs="?", default=None, help="Directory path")
+    files_mkdir.add_argument("--parents", "-p", action="store_true", help="Create parent directories")
+    files_mkdir.add_argument("--mode", help="Directory mode, e.g. 0755")
+    files_rm = files_subparsers.add_parser("rm", aliases=["delete"], help="Delete a file or directory")
+    files_rm.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
+    files_rm.add_argument("path", nargs="?", default=None, help="Path inside the computer")
+    files_rm.add_argument("--recursive", "-r", action="store_true", help="Delete directories recursively")
+    files_upload = files_subparsers.add_parser("upload", help="Upload a local file or directory")
+    files_upload.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
+    files_upload.add_argument("local", nargs="?", default=None, help="Local file or directory")
+    files_upload.add_argument("remote", nargs="?", default=None, help="Remote destination directory")
+    files_download = files_subparsers.add_parser("download", help="Download a remote file or directory")
+    files_download.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
+    files_download.add_argument("remote", nargs="?", default=None, help="Remote file or directory")
+    files_download.add_argument("local", nargs="?", default=None, help="Local destination directory")
+
     publish_cmd = subparsers.add_parser(
         "publish", help="Promote the running app on a local port into the durable public app"
     )
@@ -361,10 +410,19 @@ _HELP_SECTIONS: tuple[tuple[str, tuple[tuple[str, str], ...]], ...] = (
             ("start [id]", "Wake a cold computer"),
             ("enter [id]", "Enter a computer's console (TTY)"),
             ("run [id] <cmd>", "Run a one-shot command"),
+            ("exec [id] -- <cmd>", "Stream stdout/stderr and optionally pipe stdin"),
             ("publish [id] <port> -- <cmd>", "Run and publish a durable service command"),
             ("delete, rm [id]", "Delete a computer (typed-name confirm; --force / -y to skip)"),
         ),
     ),
+    (
+        "Files",
+        (
+            ("files read [id] <path>", "Read a file to stdout or --output"),
+            ("files write [id] <path>", "Write stdin, --input, or --content to a file"),
+            ("files ls/stat/mkdir/rm", "List, inspect, create, and delete paths"),
+        ),
+    ),
     (
         "Sharing",
         (
@@ -570,6 +628,10 @@ def main(argv: list[str] | None = None) -> int:
             return handle_run(
                 config, args.id, args.run_command, args.uid, args.gid, args.cwd, args.shell
             )
+        if args.command == "exec":
+            return handle_exec_stream(config, args.id, args.exec_command, args.stdin, args.uid, args.gid, args.cwd, args.shell)
+        if args.command in ("files", "fs", "file"):
+            return handle_files(config, args)
         if args.command == "publish":
             return handle_publish(config, args.id, args.port, args.publish_command)
         if args.command == "startup":
@@ -1068,6 +1130,36 @@ def _computer_url_label(c: dict[str, Any]) -> str:
 
 
 
+def _computer_email_address(c: dict[str, Any]) -> str:
+    explicit = str(c.get("email_address") or "").strip()
+    if explicit:
+        return explicit
+    slug = str(c.get("slug") or "").strip()
+    public_url = str(c.get("public_url") or "").strip()
+    if not slug or not public_url:
+        return ""
+    host = urlparse(public_url).netloc
+    if not host:
+        return ""
+    suffix = host.removeprefix(slug + ".")
+    if suffix == host or not suffix:
+        return ""
+    return f"{slug}@mail.{suffix}"
+
+
+
+def _with_computer_email(payload: dict[str, Any]) -> dict[str, Any]:
+    if payload.get("email_address"):
+        return payload
+    email_address = _computer_email_address(payload)
+    if not email_address:
+        return payload
+    enriched = dict(payload)
+    enriched["email_address"] = email_address
+    return enriched
+
+
+
 def _relative_time_label(value: Any) -> str:
     raw = str(value or "").strip()
     if not raw:
@@ -1282,6 +1374,7 @@ def _render_computer_panel(c: dict[str, Any], *, title: str = "computer") -> Non
         ("state", f"{_computer_status_dot(status)} {status}", status_style),
         ("share", str(c.get("visibility") or "public"), "bold white"),
         ("url", _computer_url_label(c) or "—", "white"),
+        ("email", _computer_email_address(c) or "—", "white"),
         ("age", _computer_created_label(c) or "—", "dim"),
         ("id", str(c.get("id") or "—"), "dim"),
     ]
@@ -2118,10 +2211,14 @@ def handle_create(
 
     def render(payload: dict[str, Any]) -> None:
         _render_computer_panel(payload, title="created")
+        email_address = payload.get("email_address") or _computer_email_address(payload)
+        if email_address:
+            _UI.console().print(f"[bold green]@[/bold green] [cyan]{email_address}[/cyan]")
         url = payload.get("public_url")
         if url:
             _UI.console().print(f"[bold green]→[/bold green] [cyan]{url}[/cyan]")
 
+    result = _with_computer_email(result)
     code = report_success(result, render)
     if code != 0 or not _interactive():
         return code
@@ -2590,6 +2687,241 @@ def handle_run(
     return report_success(result, _render_run_result)
 
 
+def handle_exec_stream(
+    config: RuntimeConfig,
+    computer_id: str | None,
+    command_parts: list[str] | None,
+    pipe_stdin: bool,
+    uid: int | None,
+    gid: int | None,
+    cwd: str | None,
+    shell: str | None,
+) -> int:
+    if (err := _require_api_key(config)) is not None:
+        return err
+    if not computer_id:
+        return report_error("computer id is required")
+    command = _command_from_remainder(command_parts)
+    if not command:
+        return report_error("exec requires -- <command...>")
+    stdin_data = None
+    if pipe_stdin:
+        stdin_buffer = getattr(sys.stdin, "buffer", None)
+        stdin_data = stdin_buffer.read() if stdin_buffer is not None else sys.stdin.read().encode()
+    client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
+    computer_id = _resolve_computer_ref(client, computer_id)
+    exit_code = 0
+    for frame in client.stream_command(computer_id, command, stdin=stdin_data, uid=uid, gid=gid, cwd=cwd, shell=shell):
+        stdout = frame.get("stdout") or frame.get("data") or ""
+        stderr = frame.get("stderr") or ""
+        error = frame.get("error") or ""
+        if stdout:
+            print(stdout, end="")
+        if stderr:
+            print(stderr, end="", file=sys.stderr)
+        if error:
+            print(error, file=sys.stderr)
+            exit_code = 1
+        if frame.get("type") == "exit" or frame.get("exit_code") is not None:
+            try:
+                exit_code = int(frame.get("exit_code") or 0)
+            except (TypeError, ValueError):
+                exit_code = 1
+    return exit_code
+
+
+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 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 := _require_api_key(config)) is not None:
+        return err
+    if not computer_id:
+        return report_error("computer id is required")
+    if not path:
+        return report_error("path is required")
+    client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
+    resolved_id = _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 report_error(f"failed to write output file: {exc}")
+        return report_success({"path": resolved_path, "output": output, "size": len(data)}, lambda p: _UI.console().print(f"[green]✓[/green] wrote [bold]{p['size']}[/bold] bytes to [bold]{p['output']}[/bold]"))
+    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 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 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 report_success(result, lambda p: _UI.console().print(f"[green]✓[/green] wrote [bold]{p.get('size', len(data))}[/bold] bytes to [bold]{p.get('path', resolved_path)}[/bold]"))
+
+
+def _render_file_list(payload: dict[str, Any]) -> None:
+    mods = _UI.rich()
+    Table = mods["Table"]
+    table = Table(title=str(payload.get("path") or "files"))
+    table.add_column("Name", style="bold white")
+    table.add_column("Type")
+    table.add_column("Size", justify="right")
+    table.add_column("Mode", style="dim")
+    for entry in payload.get("entries") or []:
+        if not isinstance(entry, dict):
+            continue
+        table.add_row(str(entry.get("name") or ""), str(entry.get("type") or ""), str(entry.get("size") or 0), str(entry.get("mode") or ""))
+    _UI.console().print(table)
+
+
+def handle_files_list(config: RuntimeConfig, computer_id: str | None, path: str | None) -> int:
+    resolved = _resolve_file_target(config, computer_id, path or "/home/ubuntu")
+    if isinstance(resolved, int):
+        return resolved
+    client, resolved_id, resolved_path = resolved
+    return report_success(client.list_files(resolved_id, resolved_path), _render_file_list)
+
+
+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 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 report_success(result, lambda p: _UI.console().print(f"[green]✓[/green] created [bold]{p.get('name', resolved_path)}[/bold]"))
+
+
+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 report_success(result, lambda p: _UI.console().print(f"[green]✓[/green] deleted [bold]{p.get('path', resolved_path)}[/bold]"))
+
+
+def handle_files_upload(config: RuntimeConfig, computer_id: str | None, local: str | None, remote: str | None) -> int:
+    if not local:
+        return report_error("local path is required")
+    local_path = Path(local)
+    if not local_path.exists():
+        return 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 report_error(f"failed to read local path: {exc}")
+        archive.seek(0)
+        result = client.upload_files(resolved_id, remote_path, archive)
+    return report_success(result, lambda p: _UI.console().print(f"[green]✓[/green] uploaded [bold]{p.get('files', 0)}[/bold] files to [bold]{p.get('path', remote_path)}[/bold]"))
+
+
+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 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 report_error(f"missing archive data: {member.name}")
+                    target.write_bytes(source.read())
+    except (OSError, tarfile.TarError) as exc:
+        return report_error(f"failed to write downloaded files: {exc}")
+    return report_success({"path": remote_path, "output": str(local_dir), "entries": len(members)}, lambda p: _UI.console().print(f"[green]✓[/green] downloaded [bold]{p['entries']}[/bold] entries to [bold]{p['output']}[/bold]"))
+
+
+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
+
+
 def handle_publish(config: RuntimeConfig, computer_id: str | None, port: int | None, command_parts: list[str] | None = None) -> int:
     if (err := _require_api_key(config)) is not None:
         return err

{runtime_sdk-0.4.33 → runtime_sdk-0.4.35}/scripts/runtime_sdk/client.py

@@ -1,7 +1,10 @@
 from __future__ import annotations
 
+import base64
+import json
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, BinaryIO
+from urllib.parse import urlencode
 
 import httpx
 
@@ -284,6 +287,138 @@ class RuntimeClient:
             body["shell"] = shell
         return self._request("POST", f"/api/computers/{computer_id}/exec", json=body, auth_required=True)
 
+    def stream_command(
+        self,
+        computer_id: str,
+        command: str,
+        *,
+        stdin: bytes | None = None,
+        uid: int | None = None,
+        gid: int | None = None,
+        cwd: str | None = None,
+        shell: str | None = None,
+    ):
+        body: dict[str, Any] = {"command": command}
+        if stdin:
+            body["stdin_base64"] = base64.b64encode(stdin).decode()
+        if uid is not None:
+            body["uid"] = uid
+        if gid is not None:
+            body["gid"] = gid
+        if cwd is not None:
+            body["cwd"] = cwd
+        if shell is not None:
+            body["shell"] = shell
+        headers = self._headers(True)
+        client = httpx.Client(base_url=self.base_url, timeout=None, transport=self.transport)
+        try:
+            with client.stream("POST", f"/api/computers/{computer_id}/exec/stream", json=body, headers=headers) as response:
+                if not response.is_success:
+                    body_bytes = response.read()
+                    payload: dict[str, Any] = {}
+                    if body_bytes:
+                        try:
+                            decoded = json.loads(body_bytes.decode())
+                            if isinstance(decoded, dict):
+                                payload = decoded
+                        except ValueError:
+                            pass
+                    message = payload.get("error") or payload.get("message") or f"http {response.status_code}"
+                    raise RuntimeAPIError(str(message), status_code=response.status_code)
+                for line in response.iter_lines():
+                    if not line:
+                        continue
+                    try:
+                        frame = json.loads(line)
+                    except ValueError as exc:
+                        raise RuntimeAPIError("server returned invalid NDJSON", status_code=response.status_code) from exc
+                    if not isinstance(frame, dict):
+                        raise RuntimeAPIError("server returned non-object NDJSON", status_code=response.status_code)
+                    yield frame
+        except httpx.HTTPError as exc:
+            raise RuntimeAPIError(f"request failed: {exc}") from exc
+        finally:
+            client.close()
+
+    def read_file(self, computer_id: str, path: str) -> bytes:
+        return self._request_bytes(
+            "GET",
+            f"/api/computers/{computer_id}/files/read",
+            params={"path": path},
+            auth_required=True,
+        )
+
+    def write_file(
+        self,
+        computer_id: str,
+        path: str,
+        data: bytes,
+        *,
+        uid: int | None = None,
+        gid: int | None = None,
+        mode: str | None = None,
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {"path": path}
+        if uid is not None:
+            params["uid"] = uid
+        if gid is not None:
+            params["gid"] = gid
+        if mode is not None:
+            params["mode"] = mode
+        return self._request(
+            "PUT",
+            f"/api/computers/{computer_id}/files/write",
+            params=params,
+            data=data,
+            auth_required=True,
+        )
+
+    def list_files(self, computer_id: str, path: str) -> dict[str, Any]:
+        return self._request("GET", f"/api/computers/{computer_id}/files/list", params={"path": path}, auth_required=True)
+
+    def stat_file(self, computer_id: str, path: str) -> dict[str, Any]:
+        return self._request("GET", f"/api/computers/{computer_id}/files/stat", params={"path": path}, auth_required=True)
+
+    def mkdir(self, computer_id: str, path: str, *, recursive: bool = False, mode: str | None = None) -> dict[str, Any]:
+        body: dict[str, Any] = {"path": path, "recursive": recursive}
+        if mode is not None:
+            body["mode"] = mode
+        return self._request("POST", f"/api/computers/{computer_id}/files/mkdir", json=body, auth_required=True)
+
+    def delete_file(self, computer_id: str, path: str, *, recursive: bool = False) -> dict[str, Any]:
+        return self._request(
+            "DELETE",
+            f"/api/computers/{computer_id}/files/delete",
+            params={"path": path, "recursive": str(recursive).lower()},
+            auth_required=True,
+        )
+
+    def upload_files(self, computer_id: str, path: str, archive: Any) -> dict[str, Any]:
+        return self._request(
+            "PUT",
+            f"/api/computers/{computer_id}/files/upload",
+            params={"path": path},
+            data=archive,
+            auth_required=True,
+        )
+
+    def download_files(self, computer_id: str, path: str) -> bytes:
+        return self._request_bytes(
+            "GET",
+            f"/api/computers/{computer_id}/files/download",
+            params={"path": path},
+            auth_required=True,
+        )
+
+    def download_files_to(self, computer_id: str, path: str, writer: BinaryIO) -> None:
+        self._request_bytes_to(
+            "GET",
+            f"/api/computers/{computer_id}/files/download",
+            writer,
+            params={"path": path},
+            auth_required=True,
+        )
+
     def publish_port(self, computer_id: str, port: int, *, command: str | None = None, cwd: str | None = None) -> dict[str, Any]:
         if port <= 0 or port > 65535:
             raise RuntimeAPIError("port must be between 1 and 65535")
@@ -297,14 +432,12 @@ class RuntimeClient:
         path: str,
         *,
         json: dict[str, Any] | None = None,
+        data: Any = None,
+        params: dict[str, Any] | None = None,
         auth_required: bool = False,
         timeout: float | None = None,
     ) -> dict[str, Any]:
-        headers: dict[str, str] = {}
-        if auth_required:
-            if not self.api_key:
-                raise RuntimeAPIError("missing api key")
-            headers["Authorization"] = f"Bearer {self.api_key}"
+        headers = self._headers(auth_required)
 
         try:
             with httpx.Client(
@@ -312,7 +445,7 @@ class RuntimeClient:
                 timeout=self.timeout if timeout is None else timeout,
                 transport=self.transport,
             ) as client:
-                response = client.request(method, path, json=json, headers=headers)
+                response = client.request(method, self._path(path, params), json=json, content=data, headers=headers)
         except httpx.HTTPError as exc:
             raise RuntimeAPIError(f"request failed: {exc}") from exc
 
@@ -323,6 +456,80 @@ class RuntimeClient:
         message = payload.get("error") or payload.get("message") or f"http {response.status_code}"
         raise RuntimeAPIError(str(message), status_code=response.status_code)
 
+    def _request_bytes(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        auth_required: bool = False,
+        timeout: float | None = None,
+    ) -> bytes:
+        headers = self._headers(auth_required)
+        try:
+            with httpx.Client(
+                base_url=self.base_url,
+                timeout=self.timeout if timeout is None else timeout,
+                transport=self.transport,
+            ) as client:
+                response = client.request(method, self._path(path, params), headers=headers)
+        except httpx.HTTPError as exc:
+            raise RuntimeAPIError(f"request failed: {exc}") from exc
+
+        if response.is_success:
+            return response.content
+
+        payload = self._decode_response(response)
+        message = payload.get("error") or payload.get("message") or f"http {response.status_code}"
+        raise RuntimeAPIError(str(message), status_code=response.status_code)
+
+    def _request_bytes_to(
+        self,
+        method: str,
+        path: str,
+        writer: BinaryIO,
+        *,
+        params: dict[str, Any] | None = None,
+        auth_required: bool = False,
+        timeout: float | None = None,
+    ) -> None:
+        headers = self._headers(auth_required)
+        try:
+            with httpx.Client(
+                base_url=self.base_url,
+                timeout=self.timeout if timeout is None else timeout,
+                transport=self.transport,
+            ) as client:
+                with client.stream(method, self._path(path, params), headers=headers) as response:
+                    if response.is_success:
+                        for chunk in response.iter_bytes():
+                            writer.write(chunk)
+                        return
+                    response.read()
+                    payload = self._decode_response(response)
+        except httpx.HTTPError as exc:
+            raise RuntimeAPIError(f"request failed: {exc}") from exc
+
+        message = payload.get("error") or payload.get("message") or f"http {response.status_code}"
+        raise RuntimeAPIError(str(message), status_code=response.status_code)
+
+    def _headers(self, auth_required: bool) -> dict[str, str]:
+        if not auth_required:
+            return {}
+        if not self.api_key:
+            raise RuntimeAPIError("missing api key")
+        return {"Authorization": f"Bearer {self.api_key}"}
+
+    @staticmethod
+    def _path(path: str, params: dict[str, Any] | None = None) -> str:
+        if not params:
+            return path
+        query = urlencode({key: value for key, value in params.items() if value is not None})
+        if not query:
+            return path
+        separator = "&" if "?" in path else "?"
+        return f"{path}{separator}{query}"
+
     @staticmethod
     def _decode_response(response: httpx.Response) -> dict[str, Any]:
         if not response.content:

{runtime_sdk-0.4.33 → runtime_sdk-0.4.35}/scripts/runtime_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runtime-sdk
-Version: 0.4.33
+Version: 0.4.35
 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
@@ -84,6 +84,15 @@ 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
+runtime files ls <id> /home/ubuntu
+runtime files read <id> /home/ubuntu/app.py --output app.py
+runtime files write <id> /home/ubuntu/app.py --input app.py --mode 0644
+runtime files mkdir <id> /home/ubuntu/data --parents
+runtime files upload <id> ./local-app /home/ubuntu/app
+runtime files download <id> /home/ubuntu/app ./downloaded-app
+runtime files rm <id> /home/ubuntu/data --recursive
 runtime startup show <id>
 runtime startup set <id> --command "python3 app.py" --cwd /home/ubuntu --port 3000
 runtime startup clear <id>          # low-level durable service config
@@ -123,6 +132,10 @@ app = client.create_computer(
 result = client.run_command(computer["id"], "echo hello")
 print(result["stdout"])
 
+client.write_file(computer["id"], "/home/ubuntu/hello.txt", b"hello\n")
+print(client.read_file(computer["id"], "/home/ubuntu/hello.txt"))
+print(client.list_files(computer["id"], "/home/ubuntu"))
+
 # Wake a cold computer explicitly
 client.start_computer(app["id"])