runtime-sdk 0.2.0__tar.gz → 0.3.0__tar.gz

{runtime_sdk-0.2.0 → runtime_sdk-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runtime-sdk
-Version: 0.2.0
+Version: 0.3.0
 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
@@ -46,16 +46,18 @@ Or pass `--base-url` per command.
 
 ```bash
 # Auth
-runtime signup you@example.com --name "Your Name"
+runtime login you@example.com
 runtime verify 123456
 runtime whoami
 runtime logout
-runtime login <api_key>
+runtime login --api-key rt_live_...
 
 # Computers
 runtime create
+runtime create myapp --command "python3 app.py" --cwd /home/ubuntu --port 3000
 runtime list
 runtime info <id>
+runtime start <id>
 runtime run <id> "echo hello"
 runtime run <id> "apt install -y nodejs" --uid 0
 runtime publish <id> 3000
@@ -73,10 +75,22 @@ client = RuntimeClient(base_url="https://api.runruntime.dev", api_key="rt_live_.
 computer = client.create_computer()
 print(computer["public_url"])  # https://goldbird.runruntime.dev
 
+# Or create one with a durable startup command.
+# That startup config is replayed after cold restore / auto-wake.
+app = client.create_computer(
+    slug="myapp",
+    command="python3 app.py",
+    cwd="/home/ubuntu",
+    port=3000,
+)
+
 # Run a command
 result = client.run_command(computer["id"], "echo hello")
 print(result["stdout"])
 
+# Wake a cold computer explicitly
+client.start_computer(app["id"])
+
 # Pin the public URL to a local app port
 client.publish_port(computer["id"], 3000)
 
@@ -104,6 +118,11 @@ make smoke
 Use `make deploy` instead of `make sync` when migrations, env
 files, Caddy, or systemd units changed.
 
+Cold restore and public auto-wake replay the saved startup command only for
+computers created with `--command` + `--port` (or the SDK `command`/`port`
+arguments). If you start an app later via a one-off `runtime run`, the
+filesystem is restored after going cold, but that ad-hoc process is not.
+
 Run the SDK unit tests through the backend project environment:
 
 ```bash

{runtime_sdk-0.2.0 → runtime_sdk-0.3.0}/README.md

@@ -28,16 +28,18 @@ Or pass `--base-url` per command.
 
 ```bash
 # Auth
-runtime signup you@example.com --name "Your Name"
+runtime login you@example.com
 runtime verify 123456
 runtime whoami
 runtime logout
-runtime login <api_key>
+runtime login --api-key rt_live_...
 
 # Computers
 runtime create
+runtime create myapp --command "python3 app.py" --cwd /home/ubuntu --port 3000
 runtime list
 runtime info <id>
+runtime start <id>
 runtime run <id> "echo hello"
 runtime run <id> "apt install -y nodejs" --uid 0
 runtime publish <id> 3000
@@ -55,10 +57,22 @@ client = RuntimeClient(base_url="https://api.runruntime.dev", api_key="rt_live_.
 computer = client.create_computer()
 print(computer["public_url"])  # https://goldbird.runruntime.dev
 
+# Or create one with a durable startup command.
+# That startup config is replayed after cold restore / auto-wake.
+app = client.create_computer(
+    slug="myapp",
+    command="python3 app.py",
+    cwd="/home/ubuntu",
+    port=3000,
+)
+
 # Run a command
 result = client.run_command(computer["id"], "echo hello")
 print(result["stdout"])
 
+# Wake a cold computer explicitly
+client.start_computer(app["id"])
+
 # Pin the public URL to a local app port
 client.publish_port(computer["id"], 3000)
 
@@ -86,6 +100,11 @@ make smoke
 Use `make deploy` instead of `make sync` when migrations, env
 files, Caddy, or systemd units changed.
 
+Cold restore and public auto-wake replay the saved startup command only for
+computers created with `--command` + `--port` (or the SDK `command`/`port`
+arguments). If you start an app later via a one-off `runtime run`, the
+filesystem is restored after going cold, but that ad-hoc process is not.
+
 Run the SDK unit tests through the backend project environment:
 
 ```bash

{runtime_sdk-0.2.0 → runtime_sdk-0.3.0}/pyproject.toml

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

{runtime_sdk-0.2.0 → runtime_sdk-0.3.0}/scripts/runtime_sdk/cli.py

@@ -50,6 +50,7 @@ class _UI:
     _console: Any = None
     _err_console: Any = None
     _questionary: Any = None
+    _questionary_style: Any = None
     _rich_mods: dict[str, Any] | None = None
 
     @classmethod
@@ -76,6 +77,25 @@ class _UI:
             cls._questionary = questionary
         return cls._questionary
 
+    @classmethod
+    def style(cls) -> Any:
+        if cls._questionary_style is None:
+            cls._questionary_style = cls.q().Style(
+                [
+                    ("qmark", "fg:#22c55e bold"),
+                    ("question", "bold fg:#e5e7eb"),
+                    ("answer", "fg:#22c55e bold"),
+                    ("pointer", "fg:#60a5fa bold"),
+                    ("highlighted", "fg:#ffffff bg:#1f2937 bold"),
+                    ("selected", "fg:#22c55e bold"),
+                    ("separator", "fg:#4b5563"),
+                    ("instruction", "fg:#94a3b8 italic"),
+                    ("text", "fg:#d1d5db"),
+                    ("disabled", "fg:#6b7280 italic"),
+                ]
+            )
+        return cls._questionary_style
+
     @classmethod
     def rich(cls) -> dict[str, Any]:
         if cls._rich_mods is None:
@@ -98,16 +118,29 @@ def build_parser() -> argparse.ArgumentParser:
     # Subcommand is optional: bare `runtime` defaults to `create`.
     subparsers = parser.add_subparsers(dest="command", required=False)
 
-    signup = subparsers.add_parser("signup")
+    signup = subparsers.add_parser("signup", help="Send an email verification code")
     signup.add_argument("email", nargs="?", default=None)
     signup.add_argument("--name", default=None)
 
-    verify = subparsers.add_parser("verify")
+    verify = subparsers.add_parser("verify", help="Verify an emailed code and save a fresh API key")
     verify.add_argument("code", nargs="?", default=None)
     verify.add_argument("--flow-id", type=int)
 
-    login = subparsers.add_parser("login")
-    login.add_argument("api_key", nargs="?", default=None)
+    login = subparsers.add_parser("login", help="Start email login or import an API key")
+    login.add_argument(
+        "identifier",
+        nargs="?",
+        default=None,
+        help="Email address to send a code to, or an API key for backwards compatibility",
+    )
+    login.add_argument("--name", default=None, help="Optional display name for first-time email signup")
+    login.add_argument(
+        "--api-key",
+        nargs="?",
+        const="",
+        default=None,
+        help="Import an API key explicitly (prompts if omitted in interactive mode)",
+    )
 
     subparsers.add_parser("whoami")
     subparsers.add_parser("logout")
@@ -119,11 +152,17 @@ 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="App startup command to run after create")
+    create_cmd.add_argument("--cwd", help="Working directory for the startup command")
+    create_cmd.add_argument("--port", type=int, help="App port to publish after startup")
     subparsers.add_parser("list", aliases=["ls"], help="List computers")
 
     info_cmd = subparsers.add_parser("info", help="Get computer details")
     info_cmd.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
 
+    start_cmd = subparsers.add_parser("start", help="Wake a cold computer")
+    start_cmd.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
+
     delete_cmd = subparsers.add_parser("delete", aliases=["rm"], help="Delete a computer")
     delete_cmd.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
 
@@ -174,17 +213,25 @@ def main(argv: list[str] | None = None) -> int:
         if args.command == "verify":
             return handle_verify(config, args.code, args.flow_id)
         if args.command == "login":
-            return handle_login(config, args.api_key)
+            return handle_login(config, args.identifier, args.name, args.api_key)
         if args.command == "whoami":
             return handle_whoami(config)
         if args.command == "logout":
             return handle_logout(config)
         if args.command == "create":
-            return handle_create(config, args.name)
+            return handle_create(
+                config,
+                args.name,
+                getattr(args, "startup_command", None),
+                getattr(args, "cwd", None),
+                getattr(args, "port", None),
+            )
         if args.command in ("list", "ls"):
             return handle_list(config)
         if args.command == "info":
             return handle_info(config, args.id)
+        if args.command == "start":
+            return handle_start(config, args.id)
         if args.command in ("delete", "rm"):
             return handle_delete(config, args.id)
         if args.command == "run":
@@ -242,7 +289,7 @@ def report_success(payload: dict[str, Any], renderer: Callable[[dict[str, Any]],
 def _require_api_key(config: RuntimeConfig) -> int | None:
     if config.api_key:
         return None
-    return report_error("missing api key; run verify or login first")
+    return report_error("missing api key; run login or verify first")
 
 
 def _prompt_text(message: str, *, default: str | None = None) -> str | None:
@@ -308,7 +355,7 @@ def _computer_table_layout(computers: list[dict[str, Any]]) -> dict[str, int]:
 
 
 def _format_computer_row(c: dict[str, Any], widths: dict[str, int]) -> str:
-    return "  ".join(
+    return " │ ".join(
         [
             _fit_cell(c.get("slug") or c.get("id") or "?", widths["slug"]),
             _fit_cell(c.get("status") or "?", widths["status"]),
@@ -320,7 +367,7 @@ def _format_computer_row(c: dict[str, Any], widths: dict[str, int]) -> str:
 
 def _computer_table_prompt(prompt: str, computers: list[dict[str, Any]]) -> tuple[str, dict[str, int]]:
     widths = _computer_table_layout(computers)
-    header = "  ".join(
+    header = " │ ".join(
         [
             _fit_cell("slug", widths["slug"]),
             _fit_cell("status", widths["status"]),
@@ -328,7 +375,54 @@ def _computer_table_prompt(prompt: str, computers: list[dict[str, Any]]) -> tupl
             _fit_cell("created", widths["created_at"]),
         ]
     )
-    return f"{prompt}\n{header}", widths
+    divider = "─" * len(header)
+    return f"{prompt}\n{header}\n{divider}", widths
+
+
+def _render_computer_summary(computers: list[dict[str, Any]]) -> None:
+    mods = _UI.rich()
+    Panel, Text = mods["Panel"], mods["Text"]
+    counts: dict[str, int] = {}
+    for computer in computers:
+        status = str(computer.get("status") or "unknown")
+        counts[status] = counts.get(status, 0) + 1
+
+    body = Text()
+    body.append(f"total {len(computers)}", style="bold white")
+    if counts:
+        body.append("   ")
+    first = True
+    status_styles = {
+        "warm": "bold green",
+        "cold": "bold cyan",
+        "running": "bold green",
+        "archiving": "bold yellow",
+        "restoring": "bold yellow",
+        "creating": "bold magenta",
+        "orphaned": "bold red",
+    }
+    for status in sorted(counts):
+        if not first:
+            body.append("  •  ", style="dim")
+        first = False
+        body.append(status, style=status_styles.get(status, "bold white"))
+        body.append(f" {counts[status]}", style="white")
+
+    _UI.console().print(
+        Panel(body, title="runtime", border_style="blue", expand=False, padding=(0, 1))
+    )
+
+
+def _select_prompt(message: str, choices: list[Any]) -> Any:
+    return _UI.q().select(
+        message,
+        choices=choices,
+        qmark="●",
+        pointer="❯",
+        instruction="↑/↓ move • Enter select • j/k also work",
+        use_indicator=True,
+        style=_UI.style(),
+    )
 
 
 def _pick_computer(config: RuntimeConfig, prompt: str) -> dict[str, Any] | None:
@@ -350,11 +444,7 @@ def _pick_computer(config: RuntimeConfig, prompt: str) -> dict[str, Any] | None:
         questionary.Choice(title=_format_computer_row(c, widths), value=c) for c in computers
     ]
     choices.append(questionary.Choice(title="← cancel", value=None))
-    picked = questionary.select(
-        message,
-        choices=choices,
-        instruction="↑/↓ to move, Enter to select",
-    ).unsafe_ask()
+    picked = _select_prompt(message, choices).unsafe_ask()
     return picked if isinstance(picked, dict) else None
 
 
@@ -367,7 +457,7 @@ def _render_computer_panel(c: dict[str, Any], *, title: str = "computer") -> Non
     mods = _UI.rich()
     Panel, Text = mods["Panel"], mods["Text"]
     body = Text()
-    for key in ("id", "slug", "status", "public_url", "created_at"):
+    for key in ("id", "slug", "status", "internal_status", "public_url", "created_at"):
         if key in c and c[key] is not None:
             body.append(f"{key:<12}", style="dim")
             body.append(f"{c[key]}\n")
@@ -413,22 +503,21 @@ def _render_whoami_panel(payload: dict[str, Any]) -> None:
 # --------------------------------------------------------------------------- #
 
 
-def handle_signup(config: RuntimeConfig, email: str | None, name: str | None) -> int:
+def _looks_like_api_key(value: str | None) -> bool:
+    candidate = (value or "").strip()
+    return candidate.startswith("rt_live_")
+
+
+def _start_verification_flow(config: RuntimeConfig, email: str | None, name: str | None) -> int:
     if email is None:
         if not _interactive():
             return report_error("email is required")
         email = _prompt_text("Email")
         if not email:
             return report_error("email is required")
-    if name is None:
-        if not _interactive():
-            return report_error("--name is required")
-        name = _prompt_text("Your name")
-        if not name:
-            return report_error("name is required")
 
     client = RuntimeClient(base_url=config.base_url)
-    result = client.signup(email, name)
+    result = client.start_verification(email, name)
     config.pending_signup = PendingSignup(
         flow_id=int(result["flow_id"]),
         email=email,
@@ -447,11 +536,40 @@ def handle_signup(config: RuntimeConfig, email: str | None, name: str | None) ->
     return report_success(result, render)
 
 
+def _login_with_api_key(config: RuntimeConfig, api_key: str | None) -> int:
+    if api_key is None or api_key == "":
+        if not _interactive():
+            return report_error("api key is required")
+        api_key = _prompt_password("API key")
+        if not api_key:
+            return report_error("api key is required")
+
+    client = RuntimeClient(base_url=config.base_url, api_key=api_key)
+    whoami = client.whoami()
+    config.api_key = api_key
+    config.pending_signup = None
+    save_config(config)
+
+    def render(_: dict[str, Any]) -> None:
+        owner = whoami.get("owner") or {}
+        email = owner.get("email")
+        if email:
+            _UI.console().print(f"[green]✓[/green] logged in as [bold]{email}[/bold]")
+            return
+        _UI.console().print("[green]✓[/green] api key saved")
+
+    return report_success({"message": "logged in", **whoami}, render)
+
+
+def handle_signup(config: RuntimeConfig, email: str | None, name: str | None) -> int:
+    return _start_verification_flow(config, email, name)
+
+
 def handle_verify(config: RuntimeConfig, code: str | None, flow_id: int | None) -> int:
     pending = config.pending_signup
     resolved_flow_id = flow_id or (pending.flow_id if pending else None)
     if not resolved_flow_id:
-        return report_error("missing flow id; run signup first or pass --flow-id")
+        return report_error("missing flow id; run login first or pass --flow-id")
 
     if code is None:
         if not _interactive():
@@ -468,27 +586,32 @@ def handle_verify(config: RuntimeConfig, code: str | None, flow_id: int | None)
     config.pending_signup = None
     save_config(config)
 
-    def render(_: dict[str, Any]) -> None:
+    def render(payload: dict[str, Any]) -> None:
+        owner = payload.get("owner") or {}
+        email = owner.get("email")
+        if email:
+            _UI.console().print(f"[green]✓[/green] verified, logged in as [bold]{email}[/bold]")
+            return
         _UI.console().print("[green]✓[/green] verified, api key saved")
 
     return report_success(result, render)
 
 
-def handle_login(config: RuntimeConfig, api_key: str | None) -> int:
-    if api_key is None:
-        if not _interactive():
-            return report_error("api_key is required")
-        api_key = _prompt_password("API key")
-        if not api_key:
-            return report_error("api key is required")
-
-    config.api_key = api_key
-    save_config(config)
+def handle_login(
+    config: RuntimeConfig,
+    identifier: str | None,
+    name: str | None,
+    api_key: str | None,
+) -> int:
+    if api_key is not None:
+        if identifier is not None:
+            return report_error("pass either an email/api key argument or --api-key, not both")
+        return _login_with_api_key(config, api_key)
 
-    def render(_: dict[str, Any]) -> None:
-        _UI.console().print("[green]✓[/green] api key saved")
+    if _looks_like_api_key(identifier):
+        return _login_with_api_key(config, identifier)
 
-    return report_success({"message": "api key saved"}, render)
+    return _start_verification_flow(config, identifier, name)
 
 
 def handle_whoami(config: RuntimeConfig) -> int:
@@ -500,26 +623,54 @@ def handle_whoami(config: RuntimeConfig) -> int:
 
 
 def handle_logout(config: RuntimeConfig) -> int:
+    had_api_key = config.api_key is not None
+    revoked = False
+    if config.api_key:
+        try:
+            RuntimeClient(base_url=config.base_url, api_key=config.api_key).logout()
+            revoked = True
+        except RuntimeAPIError:
+            revoked = False
+
     config.api_key = None
     config.pending_signup = None
     save_config(config)
 
+    message = "logged out"
+    if had_api_key and not revoked:
+        message = "logged out locally"
+
     def render(_: dict[str, Any]) -> None:
-        _UI.console().print("[green]✓[/green] logged out")
+        _UI.console().print(f"[green]✓[/green] {message}")
 
-    return report_success({"message": "logged out"}, render)
+    return report_success({"message": message}, render)
 
 
-def handle_create(config: RuntimeConfig, name: str | None) -> int:
+def handle_create(
+    config: RuntimeConfig,
+    name: str | None,
+    startup_command: str | None,
+    cwd: str | None,
+    port: int | None,
+) -> int:
     if (err := _require_api_key(config)) is not None:
         return err
 
     if name is None and _interactive():
         name = _prompt_text("Name your computer")
 
+    if startup_command is None and port is not None:
+        return report_error("startup command is required when port is provided")
+    if startup_command is not None and port is None:
+        return report_error("port is required when startup command is provided")
+
     client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
+    label = "creating computer…"
+    if startup_command is not None:
+        label = f"creating computer and starting app on port {port}…"
     result = _with_spinner(
-        "creating computer…", lambda: client.create_computer(slug=name)
+        label,
+        lambda: client.create_computer(slug=name, command=startup_command, cwd=cwd, port=port),
     )
 
     def render(payload: dict[str, Any]) -> None:
@@ -561,6 +712,33 @@ def handle_info(config: RuntimeConfig, computer_id: str | None) -> int:
     return report_success(result, lambda p: _render_computer_panel(p, title="computer"))
 
 
+def handle_start(config: RuntimeConfig, computer_id: str | None) -> int:
+    if (err := _require_api_key(config)) is not None:
+        return err
+
+    if computer_id is None:
+        if not _interactive():
+            return report_error("computer id is required")
+        picked = _pick_computer(config, "Pick a cold computer to wake")
+        if picked is None:
+            return 0
+        computer_id = picked.get("id") or picked.get("slug")
+        if not computer_id:
+            return report_error("computer is missing an id")
+
+    client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
+    result = _with_spinner(f"warming {computer_id}…", lambda: client.start_computer(computer_id))
+
+    def render(payload: dict[str, Any]) -> None:
+        _render_computer_panel(payload, title="warmed")
+        url = payload.get("public_url")
+        if url:
+            _UI.console().print(f"[bold green]→[/bold green] [cyan]{url}[/cyan]")
+
+    return report_success(result, render)
+
+
+
 def handle_delete(config: RuntimeConfig, computer_id: str | None) -> int:
     if (err := _require_api_key(config)) is not None:
         return err
@@ -701,6 +879,7 @@ def _interactive_list(config: RuntimeConfig) -> int:
             _UI.console().print("[dim]no computers yet. create one with `runtime create`.[/dim]")
             return 0
 
+        _render_computer_summary(computers)
         message, widths = _computer_table_prompt("Pick a computer", computers)
         choices = [
             questionary.Choice(title=_format_computer_row(c, widths), value=c)
@@ -710,11 +889,7 @@ def _interactive_list(config: RuntimeConfig) -> int:
         choices.append(questionary.Choice(title="↻ refresh", value="__refresh__"))
         choices.append(questionary.Choice(title="✕ quit", value="__quit__"))
 
-        picked = questionary.select(
-            message,
-            choices=choices,
-            instruction="↑/↓ to move, Enter to select",
-        ).unsafe_ask()
+        picked = _select_prompt(message, choices).unsafe_ask()
 
         if picked == "__quit__":
             return 0
@@ -738,10 +913,11 @@ def _vm_detail_menu(client: RuntimeClient, vm: dict[str, Any]) -> str:
     while True:
         _render_computer_panel(vm, title=f"computer: {slug}")
 
-        action = questionary.select(
-            f"What would you like to do with {slug}?",
-            choices=[
-                questionary.Choice(title="▶ run a command", value="run"),
+        choices = [questionary.Choice(title="▶ run a command", value="run")]
+        if vm.get("status") == "cold":
+            choices.append(questionary.Choice(title="☀ start / wake", value="start"))
+        choices.extend(
+            [
                 questionary.Choice(title="⤴ publish a port", value="publish"),
                 questionary.Choice(title="ℹ refresh info", value="info"),
                 questionary.Choice(title="⧉ copy public url", value="url"),
@@ -749,7 +925,12 @@ def _vm_detail_menu(client: RuntimeClient, vm: dict[str, Any]) -> str:
                 questionary.Separator(),
                 questionary.Choice(title="← back", value="__back__"),
                 questionary.Choice(title="✕ quit", value="__quit__"),
-            ],
+            ]
+        )
+
+        action = _select_prompt(
+            f"What would you like to do with {slug}?",
+            choices,
         ).unsafe_ask()
 
         if action == "__back__":
@@ -767,6 +948,10 @@ def _vm_detail_menu(client: RuntimeClient, vm: dict[str, Any]) -> str:
             _render_run_result(result)
             continue
 
+        if action == "start":
+            vm = _with_spinner(f"warming {slug}…", lambda: client.start_computer(vm_id))
+            continue
+
         if action == "publish":
             port_text = _prompt_text("Port to publish", default="3000")
             if not port_text:

{runtime_sdk-0.2.0 → runtime_sdk-0.3.0}/scripts/runtime_sdk/client.py

@@ -22,8 +22,14 @@ class RuntimeClient:
     def __post_init__(self) -> None:
         self.base_url = self.base_url.rstrip("/")
 
-    def signup(self, email: str, name: str) -> dict[str, Any]:
-        return self._request("POST", "/api/auth/start", json={"email": email, "name": name})
+    def start_verification(self, email: str, name: str | None = None) -> dict[str, Any]:
+        body: dict[str, Any] = {"email": email}
+        if name is not None:
+            body["name"] = name
+        return self._request("POST", "/api/auth/start", json=body)
+
+    def signup(self, email: str, name: str | None = None) -> dict[str, Any]:
+        return self.start_verification(email, name)
 
     def verify(self, flow_id: int, code: str) -> dict[str, Any]:
         return self._request("POST", "/api/auth/verify", json={"flow_id": flow_id, "code": code})
@@ -31,12 +37,31 @@ class RuntimeClient:
     def whoami(self) -> dict[str, Any]:
         return self._request("GET", "/api/auth/whoami", auth_required=True)
 
+    def logout(self) -> dict[str, Any]:
+        return self._request("POST", "/api/auth/logout", auth_required=True)
+
     # --- Computers ---
 
-    def create_computer(self, *, slug: str | None = None) -> dict[str, Any]:
+    def create_computer(
+        self,
+        *,
+        slug: str | None = None,
+        command: str | None = None,
+        cwd: str | None = None,
+        port: int | None = None,
+    ) -> dict[str, Any]:
         body: dict[str, Any] = {}
         if slug:
             body["slug"] = slug
+        if command is not None or cwd is not None or port is not None:
+            start: dict[str, Any] = {}
+            if command is not None:
+                start["command"] = command
+            if cwd is not None:
+                start["cwd"] = cwd
+            if port is not None:
+                start["port"] = port
+            body["start"] = start
         return self._request("POST", "/api/computers", json=body or None, auth_required=True)
 
     def list_computers(self) -> dict[str, Any]:
@@ -45,6 +70,9 @@ class RuntimeClient:
     def get_computer(self, computer_id: str) -> dict[str, Any]:
         return self._request("GET", f"/api/computers/{computer_id}", auth_required=True)
 
+    def start_computer(self, computer_id: str) -> dict[str, Any]:
+        return self._request("POST", f"/api/computers/{computer_id}/start", auth_required=True)
+
     def delete_computer(self, computer_id: str) -> dict[str, Any]:
         return self._request("DELETE", f"/api/computers/{computer_id}", auth_required=True)
 

{runtime_sdk-0.2.0 → runtime_sdk-0.3.0}/scripts/runtime_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runtime-sdk
-Version: 0.2.0
+Version: 0.3.0
 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
@@ -46,16 +46,18 @@ Or pass `--base-url` per command.
 
 ```bash
 # Auth
-runtime signup you@example.com --name "Your Name"
+runtime login you@example.com
 runtime verify 123456
 runtime whoami
 runtime logout
-runtime login <api_key>
+runtime login --api-key rt_live_...
 
 # Computers
 runtime create
+runtime create myapp --command "python3 app.py" --cwd /home/ubuntu --port 3000
 runtime list
 runtime info <id>
+runtime start <id>
 runtime run <id> "echo hello"
 runtime run <id> "apt install -y nodejs" --uid 0
 runtime publish <id> 3000
@@ -73,10 +75,22 @@ client = RuntimeClient(base_url="https://api.runruntime.dev", api_key="rt_live_.
 computer = client.create_computer()
 print(computer["public_url"])  # https://goldbird.runruntime.dev
 
+# Or create one with a durable startup command.
+# That startup config is replayed after cold restore / auto-wake.
+app = client.create_computer(
+    slug="myapp",
+    command="python3 app.py",
+    cwd="/home/ubuntu",
+    port=3000,
+)
+
 # Run a command
 result = client.run_command(computer["id"], "echo hello")
 print(result["stdout"])
 
+# Wake a cold computer explicitly
+client.start_computer(app["id"])
+
 # Pin the public URL to a local app port
 client.publish_port(computer["id"], 3000)
 
@@ -104,6 +118,11 @@ make smoke
 Use `make deploy` instead of `make sync` when migrations, env
 files, Caddy, or systemd units changed.
 
+Cold restore and public auto-wake replay the saved startup command only for
+computers created with `--command` + `--port` (or the SDK `command`/`port`
+arguments). If you start an app later via a one-off `runtime run`, the
+filesystem is restored after going cold, but that ad-hoc process is not.
+
 Run the SDK unit tests through the backend project environment:
 
 ```bash