runtime-sdk 0.4.34__tar.gz → 0.4.36__tar.gz

{runtime_sdk-0.4.34 → runtime_sdk-0.4.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runtime-sdk
-Version: 0.4.34
+Version: 0.4.36
 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
@@ -76,7 +76,9 @@ runtime switch -c feature/login --repo owner/repo   # create a new branch worksp
 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/ubuntu --port 3000
-runtime enter <name-or-id>         # accepts slug/name like test, or the computer id
+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 list
 runtime info <id>
 runtime share public <id>
@@ -84,6 +86,16 @@ 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/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 +135,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.34 → runtime_sdk-0.4.36}/README.md

@@ -54,7 +54,9 @@ runtime switch -c feature/login --repo owner/repo   # create a new branch worksp
 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/ubuntu --port 3000
-runtime enter <name-or-id>         # accepts slug/name like test, or the computer id
+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 list
 runtime info <id>
 runtime share public <id>
@@ -62,6 +64,16 @@ 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/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 +113,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.34 → runtime_sdk-0.4.36}/pyproject.toml

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

{runtime_sdk-0.4.34 → runtime_sdk-0.4.36}/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
@@ -187,9 +189,11 @@ def build_parser() -> argparse.ArgumentParser:
     secrets_set = secrets_subparsers.add_parser("set", help="Create or replace a secret set from KEY=VALUE pairs")
     secrets_set.add_argument("slug", nargs="?", default=None, help="Secret set slug")
     secrets_set.add_argument("pairs", nargs="*", help="KEY=VALUE pairs")
+    secrets_set.add_argument("--proxy", action="append", default=[], metavar="KEY=HOST", help="Deliver KEY through the egress proxy and inject it only for HOST")
     secrets_import = secrets_subparsers.add_parser("import", help="Create or replace a secret set from a .env file")
     secrets_import.add_argument("slug", nargs="?", default=None, help="Secret set slug")
     secrets_import.add_argument("--env-file", required=True, help="Path to .env file")
+    secrets_import.add_argument("--proxy", action="append", default=[], metavar="KEY=HOST", help="Deliver KEY through the egress proxy and inject it only for HOST")
     secrets_delete = secrets_subparsers.add_parser("delete", aliases=["rm"], help="Delete a secret set")
     secrets_delete.add_argument("slug", nargs="?", default=None, help="Secret set slug")
 
@@ -236,8 +240,13 @@ def build_parser() -> argparse.ArgumentParser:
         help="Re-render the table every N seconds (default 2)",
     )
 
-    enter_cmd = subparsers.add_parser("enter", help="Enter a computer's console")
+    enter_cmd = subparsers.add_parser(
+        "enter",
+        help="Enter a computer's console",
+        epilog="Use `runtime exec` for exact exit codes; use `runtime enter <id> -- <cmd>` for interactive TTY commands.",
+    )
     enter_cmd.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
+    enter_cmd.add_argument("enter_command", nargs="*", help="Command to run in the interactive terminal")
 
     info_cmd = subparsers.add_parser("info", help="Get computer details")
     info_cmd.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
@@ -278,6 +287,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"
     )
@@ -359,12 +415,21 @@ _HELP_SECTIONS: tuple[tuple[str, tuple[tuple[str, str], ...]], ...] = (
             ("info [id]", "Show computer details"),
             ("url [id]", "Show a computer's public URL and live published port"),
             ("start [id]", "Wake a cold computer"),
-            ("enter [id]", "Enter a computer's console (TTY)"),
+            ("enter [id] [-- <cmd>]", "Enter a computer's console or interactive TTY command"),
             ("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",
         (
@@ -522,9 +587,9 @@ def main(argv: list[str] | None = None) -> int:
             if args.secrets_action == "show":
                 return handle_secrets_show(config, args.slug)
             if args.secrets_action == "set":
-                return handle_secrets_set(config, args.slug, args.pairs)
+                return handle_secrets_set(config, args.slug, args.pairs, args.proxy)
             if args.secrets_action == "import":
-                return handle_secrets_import(config, args.slug, args.env_file)
+                return handle_secrets_import(config, args.slug, args.env_file, args.proxy)
             if args.secrets_action in ("delete", "rm"):
                 return handle_secrets_delete(config, args.slug)
             return report_error("unknown secrets command")
@@ -563,13 +628,17 @@ def main(argv: list[str] | None = None) -> int:
         if args.command == "start":
             return handle_start(config, args.id)
         if args.command == "enter":
-            return handle_enter(config, args.id)
+            return handle_enter(config, args.id, args.enter_command)
         if args.command in ("delete", "rm"):
             return handle_delete(config, args.id, force=getattr(args, "force", False))
         if args.command == "run":
             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":
@@ -1529,7 +1598,15 @@ def _render_secret_set_panel(payload: dict[str, Any]) -> None:
     body.append(f"{'slug':<12}", style="dim")
     body.append(f"{payload.get('slug') or '—'}\n")
     body.append(f"{'keys':<12}", style="dim")
-    body.append(", ".join(str(key) for key in (payload.get("keys") or [])) or "—")
+    deliveries = payload.get("deliveries") or {}
+    lines = []
+    for key in payload.get("keys") or []:
+        meta = deliveries.get(str(key)) if isinstance(deliveries, dict) else None
+        if isinstance(meta, dict) and meta.get("delivery") == "proxy":
+            lines.append(f"{key} proxy {meta.get('target_host') or '—'}")
+        else:
+            lines.append(f"{key} env")
+    body.append("\n".join(lines) or "—")
     _UI.console().print(Panel(body, title="secret set", border_style="cyan", expand=False))
 
 
@@ -1818,6 +1895,26 @@ def _parse_secret_pairs(pairs: list[str] | None) -> dict[str, str]:
 
 
 
+def _parse_secret_delivery(proxy_specs: list[str] | None, values: dict[str, str]) -> dict[str, dict[str, str]]:
+    delivery: dict[str, dict[str, str]] = {}
+    for spec in proxy_specs or []:
+        if "=" not in spec:
+            raise RuntimeConfigError(f"invalid proxy delivery: {spec}")
+        key, host = spec.split("=", 1)
+        key = key.strip()
+        host = host.strip()
+        if not key or not host or key not in values:
+            raise RuntimeConfigError(f"invalid proxy delivery: {spec}")
+        delivery[key] = {
+            "delivery": "proxy",
+            "target_host": host,
+            "header": "Authorization",
+            "scheme": "Bearer",
+        }
+    return delivery
+
+
+
 def _parse_env_file(path: str) -> dict[str, str]:
     try:
         lines = Path(path).read_text(encoding="utf-8").splitlines()
@@ -1867,7 +1964,7 @@ def handle_secrets_show(config: RuntimeConfig, slug: str | None) -> int:
 
 
 
-def handle_secrets_set(config: RuntimeConfig, slug: str | None, pairs: list[str] | None) -> int:
+def handle_secrets_set(config: RuntimeConfig, slug: str | None, pairs: list[str] | None, proxy_specs: list[str] | None) -> int:
     if (err := _require_api_key(config)) is not None:
         return err
     resolved_slug = _coerce_secret_set_slug(slug)
@@ -1880,8 +1977,9 @@ def handle_secrets_set(config: RuntimeConfig, slug: str | None, pairs: list[str]
     values = _parse_secret_pairs(pairs)
     if not values:
         return report_error("at least one KEY=VALUE pair is required")
+    delivery = _parse_secret_delivery(proxy_specs, values)
     client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
-    secret_set = client.put_secret_set(resolved_slug, values)
+    secret_set = client.put_secret_set(resolved_slug, values, delivery)
     return report_success(
         {"secret_set": secret_set},
         lambda payload: _UI.console().print(f"[green]✓[/green] saved [bold]{payload['secret_set'].get('slug', resolved_slug)}[/bold]"),
@@ -1889,7 +1987,7 @@ def handle_secrets_set(config: RuntimeConfig, slug: str | None, pairs: list[str]
 
 
 
-def handle_secrets_import(config: RuntimeConfig, slug: str | None, env_file: str) -> int:
+def handle_secrets_import(config: RuntimeConfig, slug: str | None, env_file: str, proxy_specs: list[str] | None) -> int:
     if (err := _require_api_key(config)) is not None:
         return err
     resolved_slug = _coerce_secret_set_slug(slug)
@@ -1902,8 +2000,9 @@ def handle_secrets_import(config: RuntimeConfig, slug: str | None, env_file: str
     values = _parse_env_file(env_file)
     if not values:
         return report_error("env file did not contain any secrets")
+    delivery = _parse_secret_delivery(proxy_specs, values)
     client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
-    secret_set = client.put_secret_set(resolved_slug, values)
+    secret_set = client.put_secret_set(resolved_slug, values, delivery)
     return report_success(
         {"secret_set": secret_set},
         lambda payload: _UI.console().print(f"[green]✓[/green] saved [bold]{payload['secret_set'].get('slug', resolved_slug)}[/bold] from [bold]{env_file}[/bold]"),
@@ -2523,12 +2622,14 @@ def handle_start(config: RuntimeConfig, computer_id: str | None) -> int:
     return report_success(result, render)
 
 
-def handle_enter(config: RuntimeConfig, computer_id: str | None) -> int:
+def handle_enter(config: RuntimeConfig, computer_id: str | None, command_parts: list[str] | None = None) -> int:
     if (err := _require_api_key(config)) is not None:
         return err
     if not _interactive():
         return report_error("enter requires an interactive terminal")
 
+    command = _command_from_remainder(command_parts)
+
     if computer_id is None:
         picked = _pick_computer(
             config,
@@ -2543,6 +2644,8 @@ def handle_enter(config: RuntimeConfig, computer_id: str | None) -> int:
 
     client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
     computer_id = _resolve_computer_ref(client, str(computer_id))
+    if command:
+        return _enter_computer(config, str(computer_id), command=command)
     return _enter_computer(config, str(computer_id))
 
 
@@ -2625,6 +2728,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
@@ -2893,7 +3231,7 @@ def _handle_proxy_client(base_url: str, api_key: str, computer_id: str, remote_p
             conn.close()
 
 
-def _enter_computer(config: RuntimeConfig, computer_id: str) -> int:
+def _enter_computer(config: RuntimeConfig, computer_id: str, *, command: str | None = None) -> int:
     client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
     ticket_payload = _with_spinner(
         f"preparing console for {computer_id}…",
@@ -2906,7 +3244,7 @@ def _enter_computer(config: RuntimeConfig, computer_id: str) -> int:
     _UI.console().print("[cyan]●[/cyan] Connecting to console...")
 
     try:
-        return _run_terminal_session(ws_url)
+        return _run_terminal_session(ws_url, bootstrap_command=command)
     except RuntimeAPIError as exc:
         return report_error(str(exc), status_code=exc.status_code)
     except (InvalidHandshake, TimeoutError, OSError) as exc:
@@ -2945,7 +3283,7 @@ def _parse_terminal_frame(raw: bytes) -> tuple[int, bytes]:
     return raw[0], raw[TERMINAL_FRAME_HEADER_SIZE:]
 
 
-def _run_terminal_session(ws_url: str) -> int:
+def _run_terminal_session(ws_url: str, *, bootstrap_command: str | None = None) -> int:
     if not sys.stdin.isatty() or not sys.stdout.isatty():
         return report_error("enter requires an interactive terminal")
 
@@ -2954,10 +3292,12 @@ def _run_terminal_session(ws_url: str) -> int:
     old_settings = termios_mod.tcgetattr(fd)
     stop = threading.Event()
     result: dict[str, Any] = {"code": 0, "error": None}
-    output_state: dict[str, Any] = {"buffer": "", "suppressing_preamble": True}
+    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:
@@ -3035,7 +3375,7 @@ 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)
+        return _strip_terminal_noise(chunk, str(state.get("bootstrap_echo") or ""))
 
     buffer = str(state.get("buffer") or "") + chunk
     marker = "\x1b[1;34mruntime@"
@@ -3043,9 +3383,9 @@ def _filter_terminal_output(chunk: str, state: dict[str, Any]) -> str:
     if idx != -1:
         state["suppressing_preamble"] = False
         state["buffer"] = ""
-        return _strip_terminal_noise(buffer[idx:])
+        return _strip_terminal_noise(buffer[idx:], str(state.get("bootstrap_echo") or ""))
 
-    cleaned = _strip_terminal_noise(buffer)
+    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"] = ""
@@ -3054,7 +3394,7 @@ def _filter_terminal_output(chunk: str, state: dict[str, Any]) -> str:
     if len(buffer) > 8192:
         state["suppressing_preamble"] = False
         state["buffer"] = ""
-        return _strip_terminal_noise(buffer)
+        return _strip_terminal_noise(buffer, str(state.get("bootstrap_echo") or ""))
 
     state["buffer"] = buffer
     return ""
@@ -3077,10 +3417,13 @@ def _should_release_terminal_output(text: str) -> bool:
 def _flush_terminal_output(state: dict[str, Any]) -> str:
     buffer = str(state.get("buffer") or "")
     state["buffer"] = ""
-    return _strip_terminal_noise(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) -> str:
+
+def _strip_terminal_noise(text: str, bootstrap_echo: str = "") -> str:
     if not text:
         return ""
 
@@ -3098,10 +3441,27 @@ def _strip_terminal_noise(text: str) -> str:
             continue
         if stripped == "* Docs: https://docs.slicervm.com":
             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)))

{runtime_sdk-0.4.34 → runtime_sdk-0.4.36}/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
 
@@ -72,8 +75,11 @@ class RuntimeClient:
     def get_secret_set(self, slug: str) -> dict[str, Any]:
         return self._request("GET", f"/api/secrets/{slug}", auth_required=True)
 
-    def put_secret_set(self, slug: str, values: dict[str, str]) -> dict[str, Any]:
-        return self._request("PUT", f"/api/secrets/{slug}", json={"values": values}, auth_required=True)
+    def put_secret_set(self, slug: str, values: dict[str, str], delivery: dict[str, Any] | None = None) -> dict[str, Any]:
+        payload: dict[str, Any] = {"values": values}
+        if delivery:
+            payload["deliveries"] = delivery
+        return self._request("PUT", f"/api/secrets/{slug}", json=payload, auth_required=True)
 
     def delete_secret_set(self, slug: str) -> dict[str, Any]:
         return self._request("DELETE", f"/api/secrets/{slug}", auth_required=True)
@@ -284,6 +290,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 +435,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 +448,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 +459,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.34 → runtime_sdk-0.4.36}/scripts/runtime_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runtime-sdk
-Version: 0.4.34
+Version: 0.4.36
 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
@@ -76,7 +76,9 @@ runtime switch -c feature/login --repo owner/repo   # create a new branch worksp
 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/ubuntu --port 3000
-runtime enter <name-or-id>         # accepts slug/name like test, or the computer id
+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 list
 runtime info <id>
 runtime share public <id>
@@ -84,6 +86,16 @@ 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/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 +135,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"])