runtime-sdk 0.4.20__tar.gz → 0.4.22__tar.gz

{runtime_sdk-0.4.20 → runtime_sdk-0.4.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runtime-sdk
-Version: 0.4.20
+Version: 0.4.22
 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
@@ -78,6 +78,8 @@ 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 list
 runtime info <id>
+runtime share public <id>
+runtime share private <id>
 runtime start <id>
 runtime run <id> "echo hello"      # one-shot foreground command only
 runtime run <id> "apt install -y nodejs" --uid 0

{runtime_sdk-0.4.20 → runtime_sdk-0.4.22}/README.md

@@ -56,6 +56,8 @@ 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 list
 runtime info <id>
+runtime share public <id>
+runtime share private <id>
 runtime start <id>
 runtime run <id> "echo hello"      # one-shot foreground command only
 runtime run <id> "apt install -y nodejs" --uid 0

{runtime_sdk-0.4.20 → runtime_sdk-0.4.22}/pyproject.toml

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

{runtime_sdk-0.4.20 → runtime_sdk-0.4.22}/scripts/runtime_sdk/cli.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import argparse
 import contextlib
+import difflib
 import importlib
 import json
 import os
@@ -132,7 +133,10 @@ class _UI:
 
 
 def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog="runtime")
+    parser = argparse.ArgumentParser(
+        prog="runtime",
+        description="Manage RuntimeVM computers — run code, publish apps, share URLs.",
+    )
     parser.add_argument("--base-url", help="Override the Runtime API base URL")
     parser.add_argument("--version", action="version", version=f"runtime-sdk {__version__}")
 
@@ -217,7 +221,17 @@ def build_parser() -> argparse.ArgumentParser:
     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")
-    subparsers.add_parser("list", aliases=["ls"], help="List computers")
+    list_cmd = subparsers.add_parser("list", aliases=["ls"], help="List computers")
+    list_cmd.add_argument(
+        "-w",
+        "--watch",
+        nargs="?",
+        const=2,
+        type=int,
+        default=None,
+        metavar="SECONDS",
+        help="Re-render the table every N seconds (default 2)",
+    )
 
     enter_cmd = subparsers.add_parser("enter", help="Enter a computer's console")
     enter_cmd.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
@@ -228,11 +242,24 @@ def build_parser() -> argparse.ArgumentParser:
     url_cmd = subparsers.add_parser("url", help="Show a computer's public URL and live published port")
     url_cmd.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
 
+    share_cmd = subparsers.add_parser("share", help="Set whether a computer is public or private")
+    share_subparsers = share_cmd.add_subparsers(dest="share_action", required=True)
+    share_public = share_subparsers.add_parser("public", help="Make a computer publicly accessible")
+    share_public.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
+    share_private = share_subparsers.add_parser("private", help="Require owner auth before browser access")
+    share_private.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)")
+    delete_cmd.add_argument(
+        "--force",
+        "-y",
+        action="store_true",
+        help="Skip the typed-name confirmation prompt",
+    )
 
     run_cmd = subparsers.add_parser("run", help="Run a one-shot command in a computer")
     run_cmd.add_argument("id", nargs="?", default=None, help="Computer ID (hostname)")
@@ -290,9 +317,129 @@ def build_parser() -> argparse.ArgumentParser:
     proxy_agent.add_argument("--local-port", type=int, required=True)
     proxy_agent.add_argument("--remote-port", type=int, required=True)
 
+    help_cmd = subparsers.add_parser("help", help="Show extended help for a topic")
+    help_cmd.add_argument("topic", nargs="?", default=None, help="Topic to show (computer, share, account, all)")
+
+    completion_cmd = subparsers.add_parser(
+        "completion", help="Print shell completion script (bash, zsh, fish)"
+    )
+    completion_cmd.add_argument("shell", choices=["bash", "zsh", "fish"], help="Target shell")
+
+    parser.format_help = lambda: _format_top_help()  # type: ignore[assignment]
     return parser
 
 
+_HELP_SECTIONS: tuple[tuple[str, tuple[tuple[str, str], ...]], ...] = (
+    (
+        "Computers",
+        (
+            ("create [name]", "Create a new computer (starter app published by default)"),
+            ("list, ls", "List computers (-w watches, refreshes every 2s)"),
+            ("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)"),
+            ("run [id] <cmd>", "Run a one-shot command"),
+            ("publish [id] [port]", "Promote a running app on a port to the durable public URL"),
+            ("delete, rm [id]", "Delete a computer (typed-name confirm; --force / -y to skip)"),
+        ),
+    ),
+    (
+        "Sharing",
+        (
+            ("share public [id]", "Make a computer publicly accessible"),
+            ("share private [id]", "Require owner auth before browser access"),
+        ),
+    ),
+    (
+        "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 clear [id]", "Clear the durable published app service"),
+        ),
+    ),
+    (
+        "Proxy",
+        (
+            ("proxy start <id> <ports…>", "Forward local → remote ports (e.g. 5432 or 15432:5432)"),
+            ("proxy ls", "List running proxies"),
+            ("proxy stop [ports…] [--all]", "Stop proxies (by local port or all)"),
+        ),
+    ),
+    (
+        "GitHub",
+        (
+            ("switch, checkout [branch]", "Open a GitHub branch workspace in its own computer"),
+            ("integrations list", "List account-level integrations"),
+            ("integrations connect github", "Install the RuntimeVM GitHub App"),
+        ),
+    ),
+    (
+        "Account",
+        (
+            ("signup [email]", "Send an email verification code"),
+            ("verify [code]", "Verify an emailed code and save a fresh API key"),
+            ("login [email|api-key]", "Email login or import an API key"),
+            ("whoami", "Show current account"),
+            ("logout", "Revoke API key and remove local config"),
+            ("api-keys list/create/revoke", "Manage Runtime API keys"),
+            ("secrets list/show/set/import/rm", "Manage account-level secret sets"),
+        ),
+    ),
+    (
+        "Shell",
+        (
+            ("help [topic]", "Show extended help — topics: computer, share, account, all"),
+            ("completion <bash|zsh|fish>", "Print shell completion script"),
+        ),
+    ),
+)
+
+
+_HELP_EXAMPLES: tuple[str, ...] = (
+    "runtime                         # interactive menu (create if piped)",
+    "runtime ls -w                   # live-updating list",
+    "runtime create mybox --command 'npm start' --cwd /app --port 3000",
+    "runtime share private mybox     # require owner auth",
+    "runtime proxy start mybox 5432  # forward localhost:5432 → mybox:5432",
+    "runtime completion zsh > ~/.zsh/completions/_runtime",
+)
+
+
+def _format_top_help() -> str:
+    lines: list[str] = []
+    lines.append("runtime — manage RuntimeVM computers")
+    lines.append("")
+    lines.append("usage: runtime [--base-url URL] [--version] [-h] <command> [args…]")
+    lines.append("")
+    lines.append("Global options:")
+    lines.append("  --base-url URL       Override the Runtime API base URL")
+    lines.append("  --version            Show the CLI version")
+    lines.append("  -h, --help           Show this help")
+    lines.append("")
+    left_width = 0
+    for _, rows in _HELP_SECTIONS:
+        for name, _ in rows:
+            left_width = max(left_width, len(name))
+    left_width = min(left_width, 38)
+    for title, rows in _HELP_SECTIONS:
+        lines.append(f"{title}:")
+        for name, desc in rows:
+            padded = name if len(name) >= left_width else name + " " * (left_width - len(name))
+            lines.append(f"  {padded}  {desc}")
+        lines.append("")
+    lines.append("Examples:")
+    for example in _HELP_EXAMPLES:
+        lines.append(f"  {example}")
+    lines.append("")
+    lines.append("Run `runtime <command> --help` for flags and examples on one command.")
+    lines.append("Run `runtime help <topic>` for long-form docs.")
+    return "\n".join(lines) + "\n"
+
+
 def _windows_unsupported() -> bool:
     return sys.platform == "win32"
 
@@ -314,10 +461,15 @@ def main(argv: list[str] | None = None) -> int:
         else:
             config.base_url = config.configured_base_url or DEFAULT_BASE_URL
 
-        # Bare `runtime` → first-run onboarding for interactive users, create otherwise.
+        # Bare `runtime` →
+        #   TTY + no api key      → onboarding
+        #   TTY + api key         → interactive menu (list + actions)
+        #   non-TTY               → create (preserves script-friendly default)
         if args.command is None:
-            if _interactive() and not config.api_key:
-                return handle_onboarding(config)
+            if _interactive():
+                if not config.api_key:
+                    return handle_onboarding(config)
+                return handle_list(config)
             args.command = "create"
             args.name = None
 
@@ -374,17 +526,19 @@ def main(argv: list[str] | None = None) -> int:
                 getattr(args, "port", None),
             )
         if args.command in ("list", "ls"):
-            return handle_list(config)
+            return handle_list(config, watch=getattr(args, "watch", None))
         if args.command == "info":
             return handle_info(config, args.id)
         if args.command == "url":
             return handle_url(config, args.id)
+        if args.command == "share":
+            return handle_share(config, args.share_action, args.id)
         if args.command == "start":
             return handle_start(config, args.id)
         if args.command == "enter":
             return handle_enter(config, args.id)
         if args.command in ("delete", "rm"):
-            return handle_delete(config, args.id)
+            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
@@ -413,6 +567,10 @@ def main(argv: list[str] | None = None) -> int:
             if args.proxy_command == "stop":
                 return handle_proxy_stop(config, args.local_ports, stop_all=args.all)
             return report_error("unknown proxy command")
+        if args.command == "help":
+            return handle_help(args.topic)
+        if args.command == "completion":
+            return handle_completion(args.shell)
         if args.command == "_proxy_agent":
             return run_proxy_agent(
                 args.base_url,
@@ -687,6 +845,45 @@ def _prompt_confirm(message: str, *, default: bool = False) -> bool:
     return bool(_UI.q().confirm(message, default=default).unsafe_ask())
 
 
+def _copy_to_clipboard(text: str) -> bool:
+    """Copy text to the OS clipboard. Returns True on success."""
+    text = str(text or "")
+    if not text:
+        return False
+    candidates = [
+        ["pbcopy"],
+        ["wl-copy"],
+        ["xclip", "-selection", "clipboard"],
+        ["xsel", "--clipboard", "--input"],
+    ]
+    if sys.platform == "win32":
+        candidates.insert(0, ["clip"])
+    for cmd in candidates:
+        if not shutil.which(cmd[0]):
+            continue
+        try:
+            subprocess.run(cmd, input=text.encode(), check=True)
+            return True
+        except (OSError, subprocess.SubprocessError):
+            continue
+    return False
+
+
+def _close_matches(ref: str, candidates: list[str], limit: int = 3) -> list[str]:
+    """Return up to `limit` candidates that look similar to ref."""
+    ref = (ref or "").strip()
+    if not ref:
+        return []
+    pool = [c for c in candidates if c]
+    return difflib.get_close_matches(ref, pool, n=limit, cutoff=0.4)
+
+
+def _prompt_typed_confirm(message: str, expected: str) -> bool:
+    """Ask the user to retype the expected token (case-insensitive). Empty = cancel."""
+    typed = _prompt_text(f"{message} (type {expected!r} to confirm)") or ""
+    return typed.strip().lower() == expected.strip().lower()
+
+
 def _display_width(value: Any, minimum: int, maximum: int) -> int:
     text = str(value or "")
     return max(minimum, min(len(text), maximum))
@@ -782,6 +979,12 @@ def _resolve_computer_ref(client: RuntimeClient, ref: str) -> str:
         return resolved or ref
     if len(matches) > 1:
         raise RuntimeAPIError(f"multiple computers matched {ref!r}; use the exact computer id")
+
+    slugs = [str(c.get("slug") or "").strip() for c in computers if isinstance(c, dict)]
+    suggestions = _close_matches(ref, [s for s in slugs if s])
+    if suggestions:
+        hint = ", ".join(repr(s) for s in suggestions)
+        raise RuntimeAPIError(f"computer {ref!r} not found. Did you mean {hint}?")
     raise RuntimeAPIError(f"computer {ref!r} not found")
 
 
@@ -1052,14 +1255,16 @@ def _render_computer_table(computers: list[dict[str, Any]], *, title: str | None
     _UI.console().print(table)
 
 
-def _select_prompt(message: str, choices: list[Any]) -> Any:
+def _select_prompt(message: str, choices: list[Any], *, instruction: str | None = None) -> Any:
     return _UI.q().select(
         message,
         choices=choices,
         qmark="●",
         pointer="❯",
-        instruction="↑/↓ or j/k • Enter",
+        instruction=instruction or "↑↓ navigate · / search · enter select · esc cancel",
         use_indicator=True,
+        use_jk_keys=True,
+        use_search_filter=True,
         style=_UI.style(),
     )
 
@@ -1111,6 +1316,7 @@ def _render_computer_panel(c: dict[str, Any], *, title: str = "computer") -> Non
     rows: list[tuple[str, str, str | None]] = [
         ("name", _computer_name(c), "bold white"),
         ("state", f"{_computer_status_dot(status)} {status}", status_style),
+        ("share", str(c.get("visibility") or "public"), "bold white"),
         ("url", _computer_url_label(c) or "—", "white"),
         ("age", _computer_created_label(c) or "—", "dim"),
         ("id", str(c.get("id") or "—"), "dim"),
@@ -1147,6 +1353,7 @@ def _render_network_panel(payload: dict[str, Any], *, title: str = "url") -> Non
     rows: list[tuple[str, str, str | None]] = [
         ("url", str(payload.get("public_url") or "—"), "cyan"),
         ("state", f"{_computer_status_dot(status)} {status}", _computer_status_style(status)),
+        ("share", str(payload.get("visibility") or "public"), "bold white"),
     ]
     if published_port:
         rows.append(("port", str(published_port), "bold white"))
@@ -1906,10 +2113,16 @@ def handle_create(
     return _enter_computer(config, str(computer_id))
 
 
-def handle_list(config: RuntimeConfig) -> int:
+def handle_list(config: RuntimeConfig, *, watch: int | None = None) -> int:
     if (err := _require_api_key(config)) is not None:
         return err
 
+    if watch is not None:
+        if not _interactive():
+            return report_error("--watch requires an interactive terminal")
+        interval = max(1, int(watch))
+        return _watch_list(config, interval)
+
     if _interactive():
         return _interactive_list(config)
 
@@ -1917,6 +2130,59 @@ def handle_list(config: RuntimeConfig) -> int:
     return report_success(client.list_computers())
 
 
+def _watch_list(config: RuntimeConfig, interval: int) -> int:
+    from rich.live import Live
+
+    client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
+    console = _UI.console()
+    console.print(f"[dim]watching every {interval}s · press Ctrl+C to exit[/dim]")
+
+    def render_table() -> Any:
+        mods = _UI.rich()
+        Table, box = mods["Table"], mods["box"]
+        table = Table(
+            title=f"computers · refresh {interval}s · {datetime.now().strftime('%H:%M:%S')}",
+            box=box.MINIMAL_DOUBLE_HEAD,
+            expand=True,
+            header_style="bold #7dd3fc",
+            title_style="bold white",
+            row_styles=["", "dim"],
+        )
+        table.add_column("Name", style="bold white", no_wrap=True, ratio=2)
+        table.add_column("State", no_wrap=True, ratio=2)
+        table.add_column("URL", overflow="fold", ratio=4)
+        table.add_column("Age", style="dim", justify="right", ratio=1)
+        try:
+            payload = client.list_computers()
+        except RuntimeAPIError as exc:
+            table.add_row(f"[red]error: {exc}[/red]", "", "", "")
+            return table
+        computers = payload.get("computers") or []
+        if not isinstance(computers, list):
+            computers = []
+        for computer in sorted(computers, key=_computer_sort_key):
+            status = _computer_status_label(computer)
+            style = _computer_status_style(status)
+            table.add_row(
+                _computer_name(computer),
+                f"[{style}]{_computer_status_dot(status)} {status}[/{style}]",
+                _computer_url_label(computer),
+                _computer_created_label(computer),
+            )
+        if not computers:
+            table.add_row("[dim]no computers yet[/dim]", "", "", "")
+        return table
+
+    try:
+        with Live(render_table(), console=console, refresh_per_second=4, screen=False) as live:
+            while True:
+                time.sleep(interval)
+                live.update(render_table())
+    except KeyboardInterrupt:
+        console.print("[dim]watch stopped[/dim]")
+        return 0
+
+
 def handle_info(config: RuntimeConfig, computer_id: str | None) -> int:
     if (err := _require_api_key(config)) is not None:
         return err
@@ -1957,6 +2223,36 @@ def handle_url(config: RuntimeConfig, computer_id: str | None) -> int:
     return report_success(result, lambda p: _render_network_panel(p, title="url"))
 
 
+def handle_share(config: RuntimeConfig, visibility: str | None, computer_id: str | None) -> int:
+    if (err := _require_api_key(config)) is not None:
+        return err
+    if visibility not in ("public", "private"):
+        return report_error("share target must be public or private")
+
+    if computer_id is None:
+        if not _interactive():
+            return report_error("computer id is required")
+        picked = _pick_computer(config, "Pick a computer")
+        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)
+    computer_id = _resolve_computer_ref(client, computer_id)
+    result = _with_spinner(
+        f"setting {computer_id} to {visibility}…",
+        lambda: client.set_visibility(computer_id, visibility),
+    )
+
+    def render(payload: dict[str, Any]) -> None:
+        _render_computer_panel(payload, title="share")
+        _UI.console().print(f"[green]✓[/green] [bold]{computer_id}[/bold] is now [bold]{visibility}[/bold]")
+
+    return report_success(result, render)
+
+
 def handle_startup_show(config: RuntimeConfig, computer_id: str | None) -> int:
     if (err := _require_api_key(config)) is not None:
         return err
@@ -2116,11 +2412,10 @@ def handle_enter(config: RuntimeConfig, computer_id: str | None) -> int:
     return _enter_computer(config, str(computer_id))
 
 
-def handle_delete(config: RuntimeConfig, computer_id: str | None) -> int:
+def handle_delete(config: RuntimeConfig, computer_id: str | None, *, force: bool = False) -> int:
     if (err := _require_api_key(config)) is not None:
         return err
 
-    interactive_pick = False
     if computer_id is None:
         if not _interactive():
             return report_error("computer id is required")
@@ -2130,11 +2425,13 @@ def handle_delete(config: RuntimeConfig, computer_id: str | None) -> int:
         computer_id = picked.get("id") or picked.get("slug")
         if not computer_id:
             return report_error("computer is missing an id")
-        interactive_pick = True
 
-    if interactive_pick:
-        if not _prompt_confirm(
-            f"Delete {computer_id}? This cannot be undone.", default=False
+    # In TTY mode, require the user to retype the slug as confirmation
+    # unless --force was passed. Non-TTY callers stay script-friendly.
+    if _interactive() and not force:
+        if not _prompt_typed_confirm(
+            f"Delete {computer_id}? This permanently destroys filesystem, service, and public URL.",
+            str(computer_id),
         ):
             _UI.console().print("[dim]cancelled[/dim]")
             return 0
@@ -2684,18 +2981,19 @@ def _interactive_list(config: RuntimeConfig) -> int:
             computers = []
 
         if not computers:
-            _UI.console().print("[dim]no computers yet. create one with `runtime create`.[/dim]")
-            return 0
+            _UI.console().print("[dim]no computers yet. creating your first one…[/dim]")
+            return handle_create(config, None, None, None, None)
 
         computers = sorted(computers, key=_computer_sort_key)
         _render_computer_summary(computers)
         widths = _computer_table_layout(computers)
         _render_computer_table(computers, title="computers")
-        choices = [
+        choices: list[Any] = [
             questionary.Choice(title=_computer_choice_title(c, widths), value=c)
             for c in computers
         ]
         choices.append(questionary.Separator())
+        choices.append(questionary.Choice(title="+ new computer", value="__new__"))
         choices.append(questionary.Choice(title="↻ refresh", value="__refresh__"))
         choices.append(questionary.Choice(title="✕ quit", value="__quit__"))
 
@@ -2705,6 +3003,9 @@ def _interactive_list(config: RuntimeConfig) -> int:
             return 0
         if picked == "__refresh__":
             continue
+        if picked == "__new__":
+            handle_create(config, None, None, None, None)
+            continue
         if not isinstance(picked, dict):
             continue
 
@@ -2725,7 +3026,10 @@ def _vm_detail_menu(client: RuntimeClient, vm: dict[str, Any]) -> str:
 
         power_state = _computer_power_state(vm)
         internal_status = _computer_internal_status(vm)
-        choices = []
+        visibility = str(vm.get("visibility") or "public")
+        flip_visibility = "private" if visibility == "public" else "public"
+
+        choices: list[Any] = []
         if internal_status in ("running", "cold"):
             choices.append(questionary.Choice(title="⌨ enter console", value="enter"))
         if internal_status == "running":
@@ -2735,10 +3039,13 @@ def _vm_detail_menu(client: RuntimeClient, vm: dict[str, Any]) -> str:
             choices.append(questionary.Choice(title="☀ start / wake", value="start"))
         choices.extend(
             [
+                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="ℹ refresh info", value="info"),
-                questionary.Choice(title="⧉ copy public url", value="url"),
-                questionary.Choice(title="✕ delete", value="delete"),
                 questionary.Separator(),
+                questionary.Choice(title="✕ delete", value="delete"),
                 questionary.Choice(title="← back", value="__back__"),
                 questionary.Choice(title="✕ quit", value="__quit__"),
             ]
@@ -2798,17 +3105,47 @@ def _vm_detail_menu(client: RuntimeClient, vm: dict[str, Any]) -> str:
             vm = _with_spinner("fetching…", lambda: client.get_computer(vm_id))
             continue
 
-        if action == "url":
-            url = vm.get("public_url") or ""
+        if action == "copy-url":
+            url = str(vm.get("public_url") or "").strip()
             if not url:
                 _UI.console().print("[yellow]no public url on this computer[/yellow]")
                 continue
-            _UI.console().print(f"[cyan]{url}[/cyan]")
+            if _copy_to_clipboard(url):
+                _UI.console().print(f"[green]✓[/green] copied [cyan]{url}[/cyan]")
+            else:
+                _UI.console().print(f"[yellow]no clipboard tool found[/yellow] [cyan]{url}[/cyan]")
+            continue
+
+        if action == "open-url":
+            url = str(vm.get("public_url") or "").strip()
+            if not url:
+                _UI.console().print("[yellow]no public url on this computer[/yellow]")
+                continue
+            with contextlib.suppress(Exception):
+                webbrowser.open(url)
+            _UI.console().print(f"[green]→[/green] opened [cyan]{url}[/cyan]")
+            continue
+
+        if action.startswith("share:"):
+            target = action.split(":", 1)[1]
+            vm = _with_spinner(
+                f"setting {slug} to {target}…",
+                lambda: client.set_visibility(str(vm_id), target),
+            )
+            _UI.console().print(
+                f"[green]✓[/green] [bold]{slug}[/bold] is now [bold]{target}[/bold]"
+            )
+            continue
+
+        if action == "startup":
+            _vm_startup_submenu(client, vm_id, slug)
+            vm = _with_spinner("fetching…", lambda: client.get_computer(vm_id))
             continue
 
         if action == "delete":
-            if not _prompt_confirm(
-                f"Delete {slug}? This cannot be undone.", default=False
+            if not _prompt_typed_confirm(
+                f"Delete {slug}? This permanently destroys filesystem, service, and public URL.",
+                str(slug),
             ):
                 _UI.console().print("[dim]cancelled[/dim]")
                 continue
@@ -2817,5 +3154,236 @@ def _vm_detail_menu(client: RuntimeClient, vm: dict[str, Any]) -> str:
             return "__back__"
 
 
+def _vm_startup_submenu(client: RuntimeClient, vm_id: str, slug: str) -> None:
+    """Inner submenu for durable startup config."""
+    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}")
+        configured = bool(current.get("configured"))
+        choices: list[Any] = [
+            questionary.Choice(title="✎ set / replace", value="set"),
+        ]
+        if configured:
+            choices.append(questionary.Choice(title="✕ clear", value="clear"))
+        choices.extend(
+            [
+                questionary.Separator(),
+                questionary.Choice(title="← back", value="__back__"),
+            ]
+        )
+        action = _select_prompt("startup config", choices).unsafe_ask()
+        if action in (None, "__back__"):
+            return
+        if action == "set":
+            command = _prompt_text("Startup command", default=str(current.get("command") or ""))
+            if not command:
+                _UI.console().print("[dim]cancelled[/dim]")
+                continue
+            port_text = _prompt_text("App port", default=str(current.get("port") or "3000"))
+            if not port_text:
+                _UI.console().print("[dim]cancelled[/dim]")
+                continue
+            try:
+                port = int(port_text)
+            except ValueError:
+                _UI.err().print("[red]port must be a number[/red]")
+                continue
+            if port <= 0 or port > 65535:
+                _UI.err().print("[red]port must be between 1 and 65535[/red]")
+                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),
+            )
+            _UI.console().print(f"[green]✓[/green] startup saved for [bold]{slug}[/bold]")
+            continue
+        if action == "clear":
+            if not _prompt_confirm(f"Clear startup config for {slug}?", default=False):
+                _UI.console().print("[dim]cancelled[/dim]")
+                continue
+            _with_spinner(
+                "clearing startup config…",
+                lambda: client.clear_startup_config(vm_id),
+            )
+            _UI.console().print(f"[green]✓[/green] cleared startup config for [bold]{slug}[/bold]")
+            continue
+
+
+# --------------------------------------------------------------------------- #
+# Help browser + shell completion                                              #
+# --------------------------------------------------------------------------- #
+
+
+_HELP_TOPICS: dict[str, tuple[str, ...]] = {
+    "computer": ("Computers",),
+    "computers": ("Computers",),
+    "share": ("Sharing",),
+    "sharing": ("Sharing",),
+    "startup": ("Startup & service",),
+    "service": ("Startup & service",),
+    "proxy": ("Proxy",),
+    "github": ("GitHub",),
+    "account": ("Account",),
+    "shell": ("Shell",),
+    "all": tuple(title for title, _ in _HELP_SECTIONS),
+}
+
+
+def handle_help(topic: str | None) -> int:
+    if topic is None:
+        sys.stdout.write(_format_top_help())
+        return 0
+    key = topic.strip().lower()
+    if key not in _HELP_TOPICS:
+        matches = _close_matches(key, list(_HELP_TOPICS))
+        if matches:
+            return report_error(f"unknown help topic {topic!r}. Did you mean {', '.join(repr(m) for m in matches)}?")
+        return report_error(f"unknown help topic {topic!r}. Try: {', '.join(sorted(_HELP_TOPICS))}")
+
+    wanted = set(_HELP_TOPICS[key])
+    lines: list[str] = []
+    for title, rows in _HELP_SECTIONS:
+        if title not in wanted:
+            continue
+        lines.append(f"{title}:")
+        left = max((len(name) for name, _ in rows), default=0)
+        for name, desc in rows:
+            padded = name + " " * max(0, left - len(name))
+            lines.append(f"  {padded}  {desc}")
+        lines.append("")
+    sys.stdout.write("\n".join(lines) + "\n")
+    return 0
+
+
+_COMPLETION_BASH = r"""# bash completion for runtime
+_runtime_complete() {
+  local cur sub
+  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 integrations secrets api-keys signup verify login whoami logout completion help" -- "$cur") )
+    return
+  fi
+  sub="${COMP_WORDS[1]}"
+  case "$sub" in
+    info|url|start|enter|run|publish|delete|rm|share|startup|service)
+      local ids
+      ids=$(runtime ls 2>/dev/null | python3 -c 'import sys,json;print("\n".join(c["slug"] for c in json.load(sys.stdin).get("computers",[]) if c.get("slug")))' 2>/dev/null)
+      COMPREPLY=( $(compgen -W "$ids" -- "$cur") )
+      ;;
+    completion)
+      COMPREPLY=( $(compgen -W "bash zsh fish" -- "$cur") )
+      ;;
+    share)
+      if [[ ${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "public private" -- "$cur") )
+      fi
+      ;;
+  esac
+}
+complete -F _runtime_complete runtime
+"""
+
+
+_COMPLETION_ZSH = r"""#compdef runtime
+_runtime() {
+  local -a _runtime_commands
+  _runtime_commands=(
+    'create:Create a new computer'
+    'list:List computers'
+    'ls:List computers'
+    'info:Show details'
+    'url:Show public URL'
+    'start:Wake a cold computer'
+    'enter:Enter console'
+    'run:Run a command'
+    'publish:Publish a port'
+    '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'
+    'checkout:Open a GitHub branch workspace'
+    'integrations:Integrations'
+    'secrets:Secret sets'
+    'api-keys:API keys'
+    'signup:Send verification code'
+    'verify:Verify code'
+    'login:Login'
+    'whoami:Show account'
+    'logout:Log out'
+    'completion:Shell completion'
+    'help:Extended help'
+  )
+  local state
+  _arguments -C '1: :->cmd' '*:: :->args'
+  case $state in
+    cmd)
+      _describe -t commands 'runtime command' _runtime_commands
+      ;;
+    args)
+      case ${words[1]} in
+        info|url|start|enter|run|publish|delete|rm|startup|service)
+          local -a ids
+          ids=(${(f)"$(runtime ls 2>/dev/null | python3 -c 'import sys,json;print(\"\\n\".join(c[\"slug\"] for c in json.load(sys.stdin).get(\"computers\",[]) if c.get(\"slug\")))' 2>/dev/null)"})
+          _describe -t slugs 'computer' ids
+          ;;
+        share)
+          _values 'visibility' public private
+          ;;
+        completion)
+          _values 'shell' bash zsh fish
+          ;;
+      esac
+      ;;
+  esac
+}
+_runtime "$@"
+"""
+
+
+_COMPLETION_FISH = r"""# fish completion for runtime
+function __runtime_slugs
+  runtime ls 2>/dev/null | python3 -c 'import sys,json;print("\n".join(c["slug"] for c in json.load(sys.stdin).get("computers",[]) if c.get("slug")))' 2>/dev/null
+end
+
+complete -c runtime -f
+complete -c runtime -n '__fish_use_subcommand' -a create -d 'Create'
+complete -c runtime -n '__fish_use_subcommand' -a list -d 'List'
+complete -c runtime -n '__fish_use_subcommand' -a ls -d 'List'
+complete -c runtime -n '__fish_use_subcommand' -a info -d 'Show details'
+complete -c runtime -n '__fish_use_subcommand' -a url -d 'Show URL'
+complete -c runtime -n '__fish_use_subcommand' -a start -d 'Wake'
+complete -c runtime -n '__fish_use_subcommand' -a enter -d 'Console'
+complete -c runtime -n '__fish_use_subcommand' -a run -d 'Run command'
+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 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 completion' -a 'bash zsh fish'
+complete -c runtime -n '__fish_seen_subcommand_from share' -a 'public private'
+"""
+
+
+def handle_completion(shell: str) -> int:
+    scripts = {"bash": _COMPLETION_BASH, "zsh": _COMPLETION_ZSH, "fish": _COMPLETION_FISH}
+    script = scripts.get(shell)
+    if script is None:
+        return report_error(f"unsupported shell: {shell}")
+    sys.stdout.write(script)
+    return 0
+
+
 if __name__ == "__main__":
     raise SystemExit(main())

{runtime_sdk-0.4.20 → runtime_sdk-0.4.22}/scripts/runtime_sdk/client.py

@@ -155,6 +155,14 @@ class RuntimeClient:
     def get_computer_network(self, computer_id: str) -> dict[str, Any]:
         return self._request("GET", f"/api/computers/{computer_id}/network", auth_required=True)
 
+    def set_visibility(self, computer_id: str, visibility: str) -> dict[str, Any]:
+        return self._request(
+            "PUT",
+            f"/api/computers/{computer_id}/visibility",
+            json={"visibility": visibility},
+            auth_required=True,
+        )
+
     def get_startup_config(self, computer_id: str) -> dict[str, Any]:
         return self._request("GET", f"/api/computers/{computer_id}/startup", auth_required=True)
 

{runtime_sdk-0.4.20 → runtime_sdk-0.4.22}/scripts/runtime_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runtime-sdk
-Version: 0.4.20
+Version: 0.4.22
 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
@@ -78,6 +78,8 @@ 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 list
 runtime info <id>
+runtime share public <id>
+runtime share private <id>
 runtime start <id>
 runtime run <id> "echo hello"      # one-shot foreground command only
 runtime run <id> "apt install -y nodejs" --uid 0