runtime-sdk 0.4.28__tar.gz → 0.4.30__tar.gz

{runtime_sdk-0.4.28 → runtime_sdk-0.4.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runtime-sdk
-Version: 0.4.28
+Version: 0.4.30
 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

{runtime_sdk-0.4.28 → runtime_sdk-0.4.30}/pyproject.toml

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

{runtime_sdk-0.4.28 → runtime_sdk-0.4.30}/scripts/runtime_sdk/cli.py

@@ -12,6 +12,7 @@ import shlex
 import shutil
 import signal
 import socket
+import struct
 import subprocess
 import sys
 import threading
@@ -220,9 +221,9 @@ def build_parser() -> argparse.ArgumentParser:
         default=None,
         help="Subdomain name (e.g. redsox → redsox.runruntime.dev). Random if skipped.",
     )
-    create_cmd.add_argument("--command", dest="startup_command", help="Durable startup command to save on create")
-    create_cmd.add_argument("--cwd", help="Working directory for the durable startup command")
-    create_cmd.add_argument("--port", type=int, help="App port to publish for durable startup")
+    create_cmd.add_argument("--command", dest="startup_command", help="Initial service command to save on create")
+    create_cmd.add_argument("--cwd", help="Working directory for the initial service command")
+    create_cmd.add_argument("--port", type=int, help="App port to publish for the initial service")
     list_cmd = subparsers.add_parser("list", aliases=["ls"], help="List computers")
     list_cmd.add_argument(
         "-w",
@@ -282,8 +283,9 @@ def build_parser() -> argparse.ArgumentParser:
     )
     publish_cmd.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
     publish_cmd.add_argument("port", nargs="?", type=int, default=None, help="Local app port")
+    publish_cmd.add_argument("publish_command", nargs="*", help="Command after --")
 
-    startup_cmd = subparsers.add_parser("startup", help="Manage durable startup config")
+    startup_cmd = subparsers.add_parser("startup", help=argparse.SUPPRESS)
     startup_subparsers = startup_cmd.add_subparsers(dest="startup_action", required=True)
     startup_show = startup_subparsers.add_parser("show", help="Show durable startup config")
     startup_show.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
@@ -297,8 +299,22 @@ def build_parser() -> argparse.ArgumentParser:
 
     service_cmd = subparsers.add_parser("service", help="Manage the durable published app service")
     service_subparsers = service_cmd.add_subparsers(dest="service_action", required=True)
+    service_run = service_subparsers.add_parser("run", help="Start and publish a durable service command")
+    service_run.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
+    service_run.add_argument("--port", required=True, type=int, help="Service port")
+    service_run.add_argument("--cwd", help="Working directory for the service command")
+    service_run.add_argument("service_command", nargs="*", help="Command after --")
     service_show = service_subparsers.add_parser("show", help="Show the durable published app service")
     service_show.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
+    service_status = service_subparsers.add_parser("status", help="Show durable service status")
+    service_status.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
+    service_logs = service_subparsers.add_parser("logs", help="Stream durable service logs")
+    service_logs.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
+    service_logs.add_argument("--follow", action="store_true", help="Follow live logs")
+    service_restart = service_subparsers.add_parser("restart", help="Restart the durable service")
+    service_restart.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
+    service_stop = service_subparsers.add_parser("stop", help="Stop the durable service but keep its config")
+    service_stop.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
     service_clear = service_subparsers.add_parser("clear", help="Clear the durable published app service")
     service_clear.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
 
@@ -345,7 +361,7 @@ _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"),
-            ("publish [id] [port]", "Promote a running app on a port to the durable public URL"),
+            ("publish [id] <port> -- <cmd>", "Run and publish a durable service command"),
             ("delete, rm [id]", "Delete a computer (typed-name confirm; --force / -y to skip)"),
         ),
     ),
@@ -359,10 +375,11 @@ _HELP_SECTIONS: tuple[tuple[str, tuple[tuple[str, str], ...]], ...] = (
     (
         "Startup & service",
         (
-            ("startup show [id]", "Show durable startup config"),
-            ("startup set [id] --command … --port …", "Save durable startup command"),
-            ("startup clear [id]", "Clear durable startup config"),
-            ("service show [id]", "Show the durable published app service"),
+            ("service run [id] --port N -- <cmd>", "Run and publish a durable service command"),
+            ("service status [id]", "Show durable service status"),
+            ("service logs [id] --follow", "Stream service logs"),
+            ("service restart [id]", "Restart the durable service"),
+            ("service stop [id]", "Stop service but keep config"),
             ("service clear [id]", "Clear the durable published app service"),
         ),
     ),
@@ -554,7 +571,7 @@ def main(argv: list[str] | None = None) -> int:
                 config, args.id, args.run_command, args.uid, args.gid, args.cwd, args.shell
             )
         if args.command == "publish":
-            return handle_publish(config, args.id, args.port)
+            return handle_publish(config, args.id, args.port, args.publish_command)
         if args.command == "startup":
             if args.startup_action == "show":
                 return handle_startup_show(config, args.id)
@@ -564,8 +581,16 @@ def main(argv: list[str] | None = None) -> int:
                 return handle_startup_clear(config, args.id)
             return report_error("unknown startup command")
         if args.command == "service":
-            if args.service_action == "show":
+            if args.service_action == "run":
+                return handle_service_run(config, args.id, args.port, args.cwd, args.service_command)
+            if args.service_action in ("show", "status"):
                 return handle_service_show(config, args.id)
+            if args.service_action == "logs":
+                return handle_service_logs(config, args.id, args.follow)
+            if args.service_action == "restart":
+                return handle_service_restart(config, args.id)
+            if args.service_action == "stop":
+                return handle_service_stop(config, args.id)
             if args.service_action == "clear":
                 return handle_service_clear(config, args.id)
             return report_error("unknown service command")
@@ -1314,6 +1339,10 @@ def _render_startup_panel(payload: dict[str, Any], *, title: str = "startup") ->
     body = Text()
     configured = bool(payload.get("configured"))
     rows: list[tuple[str, str, str | None]] = [("configured", "yes" if configured else "no", "bold white" if configured else "dim")]
+    if payload.get("status"):
+        rows.append(("status", str(payload.get("status")), "bold white"))
+    if payload.get("public_url"):
+        rows.append(("url", str(payload.get("public_url")), "cyan"))
     if configured:
         rows.extend(
             [
@@ -1322,6 +1351,12 @@ def _render_startup_panel(payload: dict[str, Any], *, title: str = "startup") ->
                 ("port", str(payload.get("port") or "—"), "bold white"),
             ]
         )
+        if payload.get("exec_id"):
+            rows.append(("exec", str(payload.get("exec_id")), "dim"))
+        if payload.get("started_at"):
+            rows.append(("started", str(payload.get("started_at")), "dim"))
+        if payload.get("exit_code") is not None:
+            rows.append(("exit", str(payload.get("exit_code")), "red"))
     for label, value, style in rows:
         body.append(f"{label:<10}", style="dim")
         body.append(value, style=style or "white")
@@ -2066,10 +2101,18 @@ def handle_create(
     label = "creating computer…"
     if startup_command is not None:
         label = f"creating computer and starting app on port {port}…"
-    result = _with_spinner(
-        label,
-        lambda: client.create_computer(slug=name, command=startup_command, cwd=cwd, port=port),
-    )
+    try:
+        result = _with_spinner(
+            label,
+            lambda: client.create_computer(slug=name, command=startup_command, cwd=cwd, port=port),
+        )
+    except RuntimeAPIError as exc:
+        if exc.status_code == 409 and "slug already in use" in str(exc) and name:
+            return report_error(
+                f"computer name {name!r} is already in use. Names become public URL slugs and must be unique across active and cold computers. Pick it from `runtime list`, delete it, or choose a different name.",
+                status_code=exc.status_code,
+            )
+        raise
 
     def render(payload: dict[str, Any]) -> None:
         _render_computer_panel(payload, title="created")
@@ -2293,6 +2336,36 @@ def handle_startup_clear(config: RuntimeConfig, computer_id: str | None) -> int:
     return report_success(result or {"configured": False}, render)
 
 
+def _command_from_remainder(parts: list[str] | None) -> str | None:
+    if not parts:
+        return None
+    if parts and parts[0] == "--":
+        parts = parts[1:]
+    if not parts:
+        return None
+    return shlex.join(parts)
+
+
+def handle_service_run(config: RuntimeConfig, computer_id: str | None, port: int | None, cwd: str | None, command_parts: list[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")
+    if port is None or port <= 0 or port > 65535:
+        return report_error("port must be between 1 and 65535")
+    command = _command_from_remainder(command_parts)
+    if not command:
+        return report_error("service run requires -- <command...>")
+
+    client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
+    computer_id = _resolve_computer_ref(client, computer_id)
+    result = _with_spinner(
+        f"starting service on {computer_id}…",
+        lambda: client.run_service(computer_id, command=command, cwd=cwd, port=port),
+    )
+    return report_success(result, lambda p: _render_startup_panel(p, title="service"))
+
+
 def handle_service_show(config: RuntimeConfig, computer_id: str | None) -> int:
     if (err := _require_api_key(config)) is not None:
         return err
@@ -2313,6 +2386,56 @@ def handle_service_show(config: RuntimeConfig, computer_id: str | None) -> int:
     return report_success(result, lambda p: _render_startup_panel(p, title="service"))
 
 
+def handle_service_logs(config: RuntimeConfig, computer_id: str | None, follow: bool) -> int:
+    if (err := _require_api_key(config)) is not None:
+        return err
+    if not computer_id:
+        return report_error("computer id is required")
+    client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
+    computer_id = _resolve_computer_ref(client, computer_id)
+    for line in client.stream_service_logs(computer_id, follow=follow):
+        try:
+            frame = json.loads(line)
+        except ValueError:
+            print(line)
+            continue
+        stdout = frame.get("stdout") or ""
+        stderr = frame.get("stderr") or ""
+        data = frame.get("data") or ""
+        error = frame.get("error") or ""
+        if stdout:
+            print(stdout, end="")
+        if stderr:
+            print(stderr, end="", file=sys.stderr)
+        if data:
+            print(data, end="")
+        if error:
+            print(error, file=sys.stderr)
+    return 0
+
+
+def handle_service_restart(config: RuntimeConfig, computer_id: 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")
+    client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
+    computer_id = _resolve_computer_ref(client, computer_id)
+    result = _with_spinner(f"restarting service for {computer_id}…", lambda: client.restart_service(computer_id))
+    return report_success(result, lambda p: _render_startup_panel(p, title="service restarted"))
+
+
+def handle_service_stop(config: RuntimeConfig, computer_id: 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")
+    client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
+    computer_id = _resolve_computer_ref(client, computer_id)
+    result = _with_spinner(f"stopping service for {computer_id}…", lambda: client.stop_service(computer_id))
+    return report_success(result, lambda p: _render_startup_panel(p, title="service stopped"))
+
+
 def handle_service_clear(config: RuntimeConfig, computer_id: str | None) -> int:
     if (err := _require_api_key(config)) is not None:
         return err
@@ -2465,7 +2588,7 @@ def handle_run(
     return report_success(result, _render_run_result)
 
 
-def handle_publish(config: RuntimeConfig, computer_id: str | None, port: int | None) -> int:
+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
 
@@ -2497,22 +2620,17 @@ def handle_publish(config: RuntimeConfig, computer_id: str | None, port: int | N
     if port <= 0 or port > 65535:
         return report_error("port must be between 1 and 65535")
 
+    command = _command_from_remainder(command_parts)
+    if not command:
+        return report_error(f"publish requires -- <command...>, for example: runtime publish {computer_id} {port} -- npm run dev -- --host 0.0.0.0")
+
     client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
     computer_id = _resolve_computer_ref(client, computer_id)
     result = _with_spinner(
-        f"publishing port {port} on {computer_id}…",
-        lambda: client.publish_port(computer_id, port),
+        f"publishing service on {computer_id}…",
+        lambda: client.publish_port(computer_id, port, command=command),
     )
-
-    def render(payload: dict[str, Any]) -> None:
-        _UI.console().print(
-            f"[green]✓[/green] public url for [bold]{computer_id}[/bold] now points at durable app port [bold]{payload.get('published_port') or port}[/bold]"
-        )
-        url = payload.get("public_url")
-        if url:
-            _UI.console().print(f"[bold green]→[/bold green] [cyan]{url}[/cyan]")
-
-    return report_success(result, render)
+    return report_success(result, lambda p: _render_startup_panel(p, title="service"))
 
 
 def handle_proxy_start(config: RuntimeConfig, computer_id: str | None, specs: list[str] | None) -> int:
@@ -2769,6 +2887,26 @@ def _load_posix_tty_modules() -> tuple[Any, Any]:
     return termios_mod, tty_mod
 
 
+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
+
+
+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) -> int:
     if not sys.stdin.isatty() or not sys.stdout.isatty():
@@ -2792,26 +2930,18 @@ def _run_terminal_session(ws_url: str) -> int:
                         result["code"] = 0
                         stop.set()
                         return
-                    event = json.loads(raw)
-                    event_type = str(event.get("type") or "")
-                    if event_type == "ready":
+                    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 event_type == "output":
-                        data = _filter_terminal_output(str(event.get("data") or ""), output_state)
+                    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 event_type == "exit":
-                        result["code"] = int(event.get("code") or 0)
-                        message = str(event.get("message") or "").strip()
-                        if message:
-                            result["error"] = message
-                        stop.set()
-                        return
-                    if event_type == "error":
-                        result["code"] = 1
-                        result["error"] = str(event.get("message") or "terminal error")
+                    if frame_type in (TERMINAL_FRAME_SHUTDOWN, TERMINAL_FRAME_SESSION_CLOSE):
                         stop.set()
                         return
             except ConnectionClosed:
@@ -2843,9 +2973,11 @@ def _run_terminal_session(ws_url: str) -> int:
                 if not data:
                     stop.set()
                     break
-                ws.send(json.dumps({"type": "input", "data": data.decode("utf-8", errors="ignore")}))
+                ws.send(_encode_terminal_frame(TERMINAL_FRAME_DATA, data))
         finally:
             stop.set()
+            with contextlib.suppress(Exception):
+                ws.send(_encode_terminal_frame(TERMINAL_FRAME_SHUTDOWN))
             with contextlib.suppress(Exception):
                 ws.close()
             termios_mod.tcsetattr(fd, termios_mod.TCSADRAIN, old_settings)
@@ -2935,7 +3067,7 @@ def _strip_terminal_noise(text: str) -> str:
 
 def _send_terminal_resize(ws: Any) -> None:
     size = shutil.get_terminal_size((100, 24))
-    ws.send(json.dumps({"type": "resize", "cols": size.columns, "rows": size.lines}))
+    ws.send(_encode_terminal_frame(TERMINAL_FRAME_WINDOW_SIZE, struct.pack(">II", size.columns, size.lines)))
 
 
 # --------------------------------------------------------------------------- #
@@ -3022,7 +3154,7 @@ def _vm_detail_menu(client: RuntimeClient, vm: dict[str, Any]) -> str:
             choices.append(questionary.Choice(title="⌨ enter console", value="enter"))
         if internal_status == "running":
             choices.append(questionary.Choice(title="▶ run a command", value="run"))
-            choices.append(questionary.Choice(title="⤴ publish a port", value="publish"))
+            choices.append(questionary.Choice(title="⤴ publish service", value="publish"))
         if power_state == "cold":
             choices.append(questionary.Choice(title="☀ start / wake", value="start"))
         choices.extend(
@@ -3030,7 +3162,7 @@ def _vm_detail_menu(client: RuntimeClient, vm: dict[str, Any]) -> str:
                 questionary.Choice(title="⧉ copy public url", value="copy-url"),
                 questionary.Choice(title="↗ open in browser", value="open-url"),
                 questionary.Choice(title=f"⚑ make {flip_visibility}", value=f"share:{flip_visibility}"),
-                questionary.Choice(title="⚙ startup config…", value="startup"),
+                questionary.Choice(title="⚙ service…", value="startup"),
                 questionary.Choice(title="ℹ refresh info", value="info"),
                 questionary.Separator(),
                 questionary.Choice(title="✕ delete", value="delete"),
@@ -3080,13 +3212,14 @@ def _vm_detail_menu(client: RuntimeClient, vm: dict[str, Any]) -> str:
             if port <= 0 or port > 65535:
                 _UI.err().print("[red]port must be between 1 and 65535[/red]")
                 continue
-            _with_spinner(
-                f"publishing port {port} on {slug}…",
-                lambda: client.publish_port(vm_id, port),
-            )
-            _UI.console().print(
-                f"[green]✓[/green] public url for [bold]{slug}[/bold] pinned to [bold]{port}[/bold]"
+            command = _prompt_text("Command to run as the service")
+            if not command:
+                continue
+            result = _with_spinner(
+                f"publishing service on {slug}…",
+                lambda: client.publish_port(vm_id, port, command=command),
             )
+            _render_startup_panel(result, title=f"service: {slug}")
             continue
 
         if action == "info":
@@ -3143,11 +3276,11 @@ def _vm_detail_menu(client: RuntimeClient, vm: dict[str, Any]) -> str:
 
 
 def _vm_startup_submenu(client: RuntimeClient, vm_id: str, slug: str) -> None:
-    """Inner submenu for durable startup config."""
+    """Inner submenu for the durable service."""
     questionary = _UI.q()
     while True:
-        current = _with_spinner("fetching startup…", lambda: client.get_startup_config(vm_id))
-        _render_startup_panel(current, title=f"startup: {slug}")
+        current = _with_spinner("fetching service…", lambda: client.get_service(vm_id))
+        _render_startup_panel(current, title=f"service: {slug}")
         configured = bool(current.get("configured"))
         choices: list[Any] = [
             questionary.Choice(title="✎ set / replace", value="set"),
@@ -3160,11 +3293,11 @@ def _vm_startup_submenu(client: RuntimeClient, vm_id: str, slug: str) -> None:
                 questionary.Choice(title="← back", value="__back__"),
             ]
         )
-        action = _select_prompt("startup config", choices).unsafe_ask()
+        action = _select_prompt("service", choices).unsafe_ask()
         if action in (None, "__back__"):
             return
         if action == "set":
-            command = _prompt_text("Startup command", default=str(current.get("command") or ""))
+            command = _prompt_text("Service command", default=str(current.get("command") or ""))
             if not command:
                 _UI.console().print("[dim]cancelled[/dim]")
                 continue
@@ -3182,20 +3315,20 @@ def _vm_startup_submenu(client: RuntimeClient, vm_id: str, slug: str) -> None:
                 continue
             cwd = _prompt_text("Working directory (optional)", default=str(current.get("cwd") or ""))
             _with_spinner(
-                "saving startup config…",
-                lambda: client.set_startup_config(vm_id, command=command, cwd=cwd or None, port=port),
+                "starting service…",
+                lambda: client.run_service(vm_id, command=command, cwd=cwd or None, port=port),
             )
-            _UI.console().print(f"[green]✓[/green] startup saved for [bold]{slug}[/bold]")
+            _UI.console().print(f"[green]✓[/green] service started for [bold]{slug}[/bold]")
             continue
         if action == "clear":
-            if not _prompt_confirm(f"Clear startup config for {slug}?", default=False):
+            if not _prompt_confirm(f"Clear service for {slug}?", default=False):
                 _UI.console().print("[dim]cancelled[/dim]")
                 continue
             _with_spinner(
-                "clearing startup config…",
-                lambda: client.clear_startup_config(vm_id),
+                "clearing service…",
+                lambda: client.clear_service(vm_id),
             )
-            _UI.console().print(f"[green]✓[/green] cleared startup config for [bold]{slug}[/bold]")
+            _UI.console().print(f"[green]✓[/green] cleared service for [bold]{slug}[/bold]")
             continue
 
 
@@ -3209,7 +3342,6 @@ _HELP_TOPICS: dict[str, tuple[str, ...]] = {
     "computers": ("Computers",),
     "share": ("Sharing",),
     "sharing": ("Sharing",),
-    "startup": ("Startup & service",),
     "service": ("Startup & service",),
     "proxy": ("Proxy",),
     "github": ("GitHub",),
@@ -3251,7 +3383,7 @@ _runtime_complete() {
   COMPREPLY=()
   cur="${COMP_WORDS[COMP_CWORD]}"
   if [[ ${COMP_CWORD} -eq 1 ]]; then
-    COMPREPLY=( $(compgen -W "create list ls info url start enter run publish delete rm share startup service proxy switch checkout github integrate secrets api-keys signup verify login whoami logout completion help" -- "$cur") )
+    COMPREPLY=( $(compgen -W "create list ls info url start enter run publish delete rm share service proxy switch checkout github integrate secrets api-keys signup verify login whoami logout completion help" -- "$cur") )
     return
   fi
   sub="${COMP_WORDS[1]}"
@@ -3295,7 +3427,6 @@ _runtime() {
     'delete:Delete a computer'
     'rm:Delete a computer'
     'share:Set visibility'
-    'startup:Startup config'
     'service:Service config'
     'proxy:Port proxies'
     'switch:Open a GitHub branch workspace'
@@ -3363,7 +3494,6 @@ complete -c runtime -n '__fish_use_subcommand' -a publish -d 'Publish port'
 complete -c runtime -n '__fish_use_subcommand' -a delete -d 'Delete'
 complete -c runtime -n '__fish_use_subcommand' -a rm -d 'Delete'
 complete -c runtime -n '__fish_use_subcommand' -a share -d 'Set visibility'
-complete -c runtime -n '__fish_use_subcommand' -a startup -d 'Startup config'
 complete -c runtime -n '__fish_use_subcommand' -a service -d 'Service config'
 complete -c runtime -n '__fish_use_subcommand' -a proxy -d 'Port proxies'
 complete -c runtime -n '__fish_use_subcommand' -a github -d 'GitHub connections'
@@ -3371,7 +3501,7 @@ complete -c runtime -n '__fish_use_subcommand' -a integrate -d 'Connect GitHub'
 complete -c runtime -n '__fish_use_subcommand' -a help -d 'Extended help'
 complete -c runtime -n '__fish_use_subcommand' -a completion -d 'Completion'
 
-complete -c runtime -n '__fish_seen_subcommand_from info url start enter run publish delete rm startup service' -a '(__runtime_slugs)'
+complete -c runtime -n '__fish_seen_subcommand_from info url start enter run publish delete rm service' -a '(__runtime_slugs)'
 complete -c runtime -n '__fish_seen_subcommand_from completion' -a 'bash zsh fish'
 complete -c runtime -n '__fish_seen_subcommand_from share' -a 'public private'
 """

{runtime_sdk-0.4.28 → runtime_sdk-0.4.30}/scripts/runtime_sdk/client.py

@@ -148,7 +148,71 @@ class RuntimeClient:
         return self._request("GET", f"/api/computers/{computer_id}/startup", auth_required=True)
 
     def get_service_config(self, computer_id: str) -> dict[str, Any]:
-        return self.get_startup_config(computer_id)
+        return self.get_service(computer_id)
+
+    def get_service(self, computer_id: str) -> dict[str, Any]:
+        return self._request("GET", f"/api/computers/{computer_id}/service", auth_required=True)
+
+    def run_service(
+        self,
+        computer_id: str,
+        *,
+        command: str,
+        cwd: str | None = None,
+        port: int,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {"command": command, "port": port}
+        if cwd is not None:
+            body["cwd"] = cwd
+        return self._request(
+            "POST",
+            f"/api/computers/{computer_id}/service/run",
+            json=body,
+            auth_required=True,
+            timeout=max(self.timeout, DEFAULT_WARMUP_TIMEOUT),
+        )
+
+    def restart_service(self, computer_id: str) -> dict[str, Any]:
+        return self._request(
+            "POST",
+            f"/api/computers/{computer_id}/service/restart",
+            auth_required=True,
+            timeout=max(self.timeout, DEFAULT_WARMUP_TIMEOUT),
+        )
+
+    def stop_service(self, computer_id: str) -> dict[str, Any]:
+        return self._request("POST", f"/api/computers/{computer_id}/service/stop", auth_required=True)
+
+    def clear_service(self, computer_id: str) -> dict[str, Any]:
+        return self._request("DELETE", f"/api/computers/{computer_id}/service", auth_required=True)
+
+    def stream_service_logs(self, computer_id: str, *, follow: bool = False):
+        if not self.api_key:
+            raise RuntimeAPIError("missing api key")
+        path = f"/api/computers/{computer_id}/service/logs"
+        if follow:
+            path += "?follow=true"
+        client = httpx.Client(base_url=self.base_url, timeout=None, transport=self.transport)
+        try:
+            with client.stream("GET", path, headers={"Authorization": f"Bearer {self.api_key}"}) as response:
+                if not response.is_success:
+                    body = response.read()
+                    payload: dict[str, Any] = {}
+                    if body:
+                        try:
+                            decoded = response.json()
+                            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
+                    yield line
+        finally:
+            client.close()
 
     def set_startup_config(
         self,
@@ -167,7 +231,7 @@ class RuntimeClient:
         return self._request("DELETE", f"/api/computers/{computer_id}/startup", auth_required=True)
 
     def clear_service_config(self, computer_id: str) -> dict[str, Any]:
-        return self.clear_startup_config(computer_id)
+        return self.clear_service(computer_id)
 
     def start_computer(self, computer_id: str) -> dict[str, Any]:
         return self._request(
@@ -220,15 +284,12 @@ class RuntimeClient:
             body["shell"] = shell
         return self._request("POST", f"/api/computers/{computer_id}/exec", json=body, auth_required=True)
 
-    def publish_port(self, computer_id: str, port: int) -> dict[str, Any]:
+    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")
-        return self._request(
-            "POST",
-            f"/api/computers/{computer_id}/publish",
-            json={"port": port},
-            auth_required=True,
-        )
+        if not command:
+            raise RuntimeAPIError("publish requires -- <command...>")
+        return self.run_service(computer_id, command=command, cwd=cwd, port=port)
 
     def _request(
         self,

{runtime_sdk-0.4.28 → runtime_sdk-0.4.30}/scripts/runtime_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runtime-sdk
-Version: 0.4.28
+Version: 0.4.30
 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