runtime-sdk 0.4.24__tar.gz → 0.4.26__tar.gz

{runtime_sdk-0.4.24 → runtime_sdk-0.4.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runtime-sdk
-Version: 0.4.24
+Version: 0.4.26
 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
@@ -66,8 +66,9 @@ runtime login --api-key rt_live_...
 runtime api-keys list
 runtime api-keys create "my laptop"
 runtime api-keys revoke 123
-runtime integrations list
-runtime integrations connect github
+runtime integrate github
+runtime github list
+runtime github disconnect acme
 
 # Computers
 runtime switch --repo owner/repo feature/login      # open or create the branch workspace computer
@@ -170,13 +171,15 @@ that ad-hoc process is not.
 between parallel tasks without local worktrees.
 
 ```bash
-runtime integrations connect github
+runtime integrate github
+runtime github list
 runtime switch --repo owner/repo feature/login
 runtime switch -c feature/search --repo owner/repo --from main
 ```
 
 Rules:
-- GitHub must already be connected with `runtime integrations connect github`.
+- GitHub must already be connected with `runtime integrate github`.
+- Run `runtime integrate github` again when you want to add another personal account or org.
 - `runtime switch` opens an existing branch workspace, or creates the computer if
   the branch exists but the workspace does not yet.
 - `runtime switch -c` creates a new branch first, then opens that branch's

{runtime_sdk-0.4.24 → runtime_sdk-0.4.26}/README.md

@@ -44,8 +44,9 @@ runtime login --api-key rt_live_...
 runtime api-keys list
 runtime api-keys create "my laptop"
 runtime api-keys revoke 123
-runtime integrations list
-runtime integrations connect github
+runtime integrate github
+runtime github list
+runtime github disconnect acme
 
 # Computers
 runtime switch --repo owner/repo feature/login      # open or create the branch workspace computer
@@ -148,13 +149,15 @@ that ad-hoc process is not.
 between parallel tasks without local worktrees.
 
 ```bash
-runtime integrations connect github
+runtime integrate github
+runtime github list
 runtime switch --repo owner/repo feature/login
 runtime switch -c feature/search --repo owner/repo --from main
 ```
 
 Rules:
-- GitHub must already be connected with `runtime integrations connect github`.
+- GitHub must already be connected with `runtime integrate github`.
+- Run `runtime integrate github` again when you want to add another personal account or org.
 - `runtime switch` opens an existing branch workspace, or creates the computer if
   the branch exists but the workspace does not yet.
 - `runtime switch -c` creates a new branch first, then opens that branch's

{runtime_sdk-0.4.24 → runtime_sdk-0.4.26}/pyproject.toml

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

{runtime_sdk-0.4.24 → runtime_sdk-0.4.26}/scripts/runtime_sdk/cli.py

@@ -192,14 +192,16 @@ def build_parser() -> argparse.ArgumentParser:
     secrets_delete = secrets_subparsers.add_parser("delete", aliases=["rm"], help="Delete a secret set")
     secrets_delete.add_argument("slug", nargs="?", default=None, help="Secret set slug")
 
-    integrations_cmd = subparsers.add_parser("integrations", help="Connect account-level integrations")
-    integrations_subparsers = integrations_cmd.add_subparsers(dest="integrations_action", required=True)
-    integrations_subparsers.add_parser("list", aliases=["ls"], help="List integrations")
-    integrations_connect = integrations_subparsers.add_parser("connect", help="Connect an integration")
-    integrations_connect.add_argument("provider", choices=["github"])
-    integrations_connect.add_argument("--slug", default="github", help="Integration slug to create (default: github)")
-    integrations_connect.add_argument("--owner", default=None, help="GitHub username or org where the app is installed")
-    integrations_connect.add_argument("--no-open", action="store_true", help="Print the install URL instead of opening a browser")
+    github_cmd = subparsers.add_parser("github", help="Manage connected GitHub App installations")
+    github_subparsers = github_cmd.add_subparsers(dest="github_action", required=True)
+    github_subparsers.add_parser("list", aliases=["ls"], help="List connected GitHub installations")
+    github_disconnect = github_subparsers.add_parser("disconnect", aliases=["rm"], help="Disconnect a GitHub installation from Runtime")
+    github_disconnect.add_argument("ref", nargs="?", default=None, help="GitHub owner or installation id")
+
+    integrate_cmd = subparsers.add_parser("integrate", help="Connect the RuntimeVM GitHub App")
+    integrate_cmd.add_argument("provider", choices=["github"])
+    integrate_cmd.add_argument("--no-open", action="store_true", help="Print the install URL instead of opening a browser")
+    integrate_cmd.add_argument("--timeout", type=int, default=180, help="Seconds to wait for the browser install to finish (default: 180)")
 
     switch_cmd = subparsers.add_parser(
         "switch",
@@ -376,8 +378,9 @@ _HELP_SECTIONS: tuple[tuple[str, tuple[tuple[str, str], ...]], ...] = (
         "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"),
+            ("integrate github", "Install the RuntimeVM GitHub App and wait for completion"),
+            ("github list", "List connected GitHub installations"),
+            ("github disconnect, rm [owner|id]", "Disconnect one GitHub installation"),
         ),
     ),
     (
@@ -407,6 +410,8 @@ _HELP_EXAMPLES: tuple[str, ...] = (
     "runtime ls -w                   # live-updating list",
     "runtime create mybox --command 'npm start' --cwd /app --port 3000",
     "runtime share private mybox     # require owner auth",
+    "runtime integrate github         # open GitHub and wait for the install to finish",
+    "runtime github list              # show connected GitHub orgs/accounts",
     "runtime proxy start mybox 5432  # forward localhost:5432 → mybox:5432",
     "runtime completion zsh > ~/.zsh/completions/_runtime",
 )
@@ -506,12 +511,14 @@ def main(argv: list[str] | None = None) -> int:
             if args.secrets_action in ("delete", "rm"):
                 return handle_secrets_delete(config, args.slug)
             return report_error("unknown secrets command")
-        if args.command == "integrations":
-            if args.integrations_action in ("list", "ls"):
-                return handle_integrations_list(config)
-            if args.integrations_action == "connect":
-                return handle_integrations_connect(config, args.provider, args.slug, args.owner, no_open=args.no_open)
-            return report_error("unknown integrations command")
+        if args.command == "github":
+            if args.github_action in ("list", "ls"):
+                return handle_github_list(config)
+            if args.github_action in ("disconnect", "rm"):
+                return handle_github_disconnect(config, args.ref)
+            return report_error("unknown github command")
+        if args.command == "integrate":
+            return handle_integrate_github(config, args.provider, no_open=args.no_open, timeout_seconds=args.timeout)
         if args.command in ("switch", "checkout"):
             return handle_switch(
                 config,
@@ -889,22 +896,6 @@ def _prompt_typed_confirm(message: str, expected: str) -> bool:
     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))
-
-
-def _fit_cell(value: Any, width: int) -> str:
-    text = str(value or "")
-    if width <= 0:
-        return ""
-    if len(text) > width:
-        if width == 1:
-            return "…"
-        text = text[: width - 1] + "…"
-    return text.ljust(width)
-
-
 def _computer_power_state(c: dict[str, Any]) -> str:
     power = c.get("power_state")
     if power is not None:
@@ -1123,157 +1114,97 @@ def _computer_sort_key(c: dict[str, Any]) -> tuple[int, str, str]:
 
 
 
-def _computer_table_layout(computers: list[dict[str, Any]]) -> dict[str, int]:
-    term_width = shutil.get_terminal_size((100, 20)).columns
-    slug_width = max(_display_width(_computer_name(c), len("name"), 24) for c in computers)
-    status_width = max(
-        _display_width(_computer_status_label(c), len("state"), 20)
-        for c in computers
-    )
-    created_width = max(
-        _display_width(_computer_created_label(c), len("age"), 8)
-        for c in computers
-    )
-    reserved = slug_width + status_width + created_width + len("  ") * 3
-    url_budget = max(16, term_width - reserved)
-    url_width = max(
-        len("url"),
-        min(max(len(_computer_url_label(c)) for c in computers), url_budget),
-    )
-    return {
-        "slug": slug_width,
-        "status": status_width,
-        "public_url": url_width,
-        "created_at": created_width,
-    }
-
-
-def _format_computer_row(c: dict[str, Any], widths: dict[str, int]) -> str:
-    return " │ ".join(
-        [
-            _fit_cell(_computer_name(c), widths["slug"]),
-            _fit_cell(_computer_status_label(c), widths["status"]),
-            _fit_cell(_computer_url_label(c), widths["public_url"]),
-            _fit_cell(_computer_created_label(c), widths["created_at"]),
-        ]
-    )
-
-
-def _computer_table_prompt(prompt: str, computers: list[dict[str, Any]]) -> tuple[str, dict[str, int]]:
-    widths = _computer_table_layout(computers)
-    header = " │ ".join(
-        [
-            _fit_cell("name", widths["slug"]),
-            _fit_cell("state", widths["status"]),
-            _fit_cell("url", widths["public_url"]),
-            _fit_cell("age", widths["created_at"]),
-        ]
-    )
-    divider = "─" * len(header)
-    return f"{prompt}\n{header}\n{divider}", widths
+def _picker_status_color(status: str) -> str:
+    if "cold" in status:
+        return "fg:#60a5fa"  # cyan-blue
+    if "warm" in status or "running" in status:
+        return "fg:#22c55e"  # green
+    if "archiving" in status or "restoring" in status:
+        return "fg:#eab308"  # yellow
+    if "creating" in status:
+        return "fg:#a855f7"  # magenta
+    if "orphaned" in status:
+        return "fg:#ef4444"  # red
+    return "fg:#e5e7eb"
 
 
+def _picker_widths(computers: list[dict[str, Any]]) -> dict[str, int]:
+    """Compute aligned column widths for the interactive picker rows.
 
-def _computer_choice_title(c: dict[str, Any], widths: dict[str, int]) -> str:
-    del widths
+    We budget total width to leave room for questionary's pointer + indicator.
+    """
+    term_width = shutil.get_terminal_size((100, 20)).columns
+    name_w = max(len("name"), max((len(_computer_name(c)) for c in computers), default=0))
+    name_w = min(name_w, 24)
+    status_w = max(len("state"), max((len(_computer_status_label(c)) for c in computers), default=0))
+    status_w = min(status_w, 14)
+    age_w = max(len("age"), max((len(_computer_created_label(c)) for c in computers), default=0))
+    age_w = min(age_w, 6)
+    # pointer + indicator + 2 gaps * 3 + status dot (2 chars) + padding
+    reserved = 6 + name_w + status_w + age_w + 2 * 3 + 2
+    url_w = max(len("url"), min(max((len(_computer_url_label(c)) for c in computers), default=16), term_width - reserved))
+    url_w = max(10, url_w)
+    return {"name": name_w, "status": status_w, "url": url_w, "age": age_w}
+
+
+def _computer_choice_title(c: dict[str, Any], widths: dict[str, int]) -> list[tuple[str, str]]:
+    """Return a styled list-of-tuples title so the picker rows look tabular.
+
+    Columns: name · state (colored dot + label) · url · age.
+    """
+    name = _computer_name(c)
     status = _computer_status_label(c)
-    url = _computer_url_label(c)
-    created = _computer_created_label(c)
-    parts = [f"{_computer_name(c)}", status]
-    if url:
-        parts.append(url)
-    if created:
-        parts.append(created)
-    return "  ·  ".join(parts)
-
-
-
-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 = _computer_status_label(computer)
-        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
-        status_style = "bold white"
-        for token, style in status_styles.items():
-            if token in status:
-                status_style = style
-                break
-        body.append(status, style=status_style)
-        body.append(f" {counts[status]}", style="white")
-
-    _UI.console().print(
-        Panel(body, title="runtime", border_style="blue", expand=False, padding=(0, 1))
-    )
-
+    url = _computer_url_label(c) or "—"
+    age = _computer_created_label(c) or ""
+    color = _picker_status_color(status)
+    dot = _computer_status_dot(status)
+    # Keep each column within its budget; truncate with ellipsis on overflow.
+    def fit(text: str, width: int, align: str = "<") -> str:
+        text = str(text or "")
+        if len(text) > width:
+            return text[: max(1, width - 1)] + "…"
+        return format(text, f"{align}{width}")
+    return [
+        ("", fit(name, widths["name"]) + "  "),
+        (color, f"{dot} "),
+        (color, fit(status, widths["status"])),
+        ("", "  "),
+        ("fg:#cbd5e1", fit(url, widths["url"])),
+        ("", "  "),
+        ("fg:#6b7280", fit(age, widths["age"], ">")),
+    ]
 
 
-def _render_computer_table(computers: list[dict[str, Any]], *, title: str | None = None) -> None:
-    mods = _UI.rich()
-    Table, box = mods["Table"], mods["box"]
-    table = Table(
-        title=title,
-        box=box.MINIMAL_DOUBLE_HEAD,
-        expand=True,
-        show_lines=False,
-        header_style="bold #7dd3fc",
-        title_style="bold white",
-        pad_edge=False,
-        collapse_padding=True,
-        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", style="white", overflow="fold", ratio=4)
-    table.add_column("Age", style="dim", no_wrap=True, justify="right", ratio=1)
-
-    for computer in sorted(computers, key=_computer_sort_key):
-        status = _computer_status_label(computer)
-        status_style = _computer_status_style(status)
-        table.add_row(
-            _computer_name(computer),
-            f"[{status_style}]{_computer_status_dot(status)} {status}[/{status_style}]",
-            _computer_url_label(computer),
-            _computer_created_label(computer),
-        )
 
-    _UI.console().print(table)
 
 
 def _select_prompt(message: str, choices: list[Any], *, instruction: str | None = None) -> Any:
     # questionary rejects use_jk_keys together with use_search_filter because
     # j/k would be swallowed by the search prefix. We pick search over vim keys.
-    return _UI.q().select(
+    question = _UI.q().select(
         message,
         choices=choices,
         qmark="●",
         pointer="❯",
-        instruction=instruction or "↑↓ navigate · type to search · enter · esc cancel",
+        instruction=instruction or "↑↓ · type to search · enter select · esc back",
         use_indicator=True,
         use_jk_keys=False,
         use_search_filter=True,
         style=_UI.style(),
     )
+    # Bind ESC explicitly — questionary's select prompt does not bind it by
+    # default. With eager=True the binding fires before prompt_toolkit's
+    # meta-key timeout. .unsafe_ask() returns the `result` we pass to exit().
+    with contextlib.suppress(Exception):
+        from prompt_toolkit.keys import Keys
+
+        bindings = question.application.key_bindings
+
+        @bindings.add(Keys.Escape, eager=True)
+        def _escape(event: Any) -> None:
+            event.app.exit(result=None)
+
+    return question
 
 
 def _pick_computer(
@@ -1283,8 +1214,8 @@ def _pick_computer(
 ) -> dict[str, Any] | None:
     """Fetch computers and let the user arrow-key through them.
 
-    Returns the picked computer dict, or None if the list is empty or the user
-    explicitly chose "← cancel". Ctrl-C propagates as KeyboardInterrupt.
+    Returns the picked computer dict, or None on ESC / "← cancel".
+    Ctrl-C propagates as KeyboardInterrupt.
     """
     client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
     payload = client.list_computers()
@@ -1299,8 +1230,7 @@ def _pick_computer(
         return None
 
     questionary = _UI.q()
-    widths = _computer_table_layout(computers)
-    _render_computer_table(computers)
+    widths = _picker_widths(computers)
     choices = [
         questionary.Choice(title=_computer_choice_title(c, widths), value=c) for c in computers
     ]
@@ -1770,30 +1700,31 @@ def handle_api_keys_revoke(config: RuntimeConfig, key_id: str | None) -> int:
 
 
 
-def _render_integrations_table(payload: dict[str, Any]) -> None:
+def _render_github_installations_table(payload: dict[str, Any]) -> None:
     mods = _UI.rich()
     Table = mods["Table"]
-    integrations = payload.get("integrations") or []
-    if not isinstance(integrations, list) or not integrations:
-        _UI.console().print("[yellow]no integrations found[/yellow]")
+    installations = payload.get("installations") or []
+    if not isinstance(installations, list) or not installations:
+        _UI.console().print("[yellow]no GitHub installations found[/yellow]")
         return
 
-    table = Table(title="Integrations", expand=True, box=mods["box"].SIMPLE_HEAVY)
-    table.add_column("Slug", style="bold white")
-    table.add_column("Provider", style="white")
+    table = Table(title="GitHub", expand=True, box=mods["box"].SIMPLE_HEAVY)
+    table.add_column("ID", style="bold white")
     table.add_column("Owner", style="white")
-    table.add_column("Transport", style="white")
-    table.add_column("Backend", style="white")
+    table.add_column("Type", style="white")
+    table.add_column("Repos", style="white")
+    table.add_column("Status", style="white")
 
-    for entry in integrations:
+    for entry in installations:
         if not isinstance(entry, dict):
             continue
+        status = "suspended" if entry.get("suspended") else "connected"
         table.add_row(
-            str(entry.get("slug") or "—"),
-            str(entry.get("provider") or "—"),
-            str(entry.get("credential_ref") or "—"),
-            str(entry.get("transport") or "—"),
-            str(entry.get("backend") or "—"),
+            str(entry.get("id") or "—"),
+            str(entry.get("github_account_login") or "—"),
+            str(entry.get("github_account_type") or "—"),
+            str(entry.get("repository_selection") or "—"),
+            status,
         )
     _UI.console().print(table)
 
@@ -1931,21 +1862,68 @@ def handle_secrets_delete(config: RuntimeConfig, slug: str | None) -> int:
 
 
 
-def handle_integrations_list(config: RuntimeConfig) -> int:
+def handle_github_list(config: RuntimeConfig) -> int:
     if (err := _require_api_key(config)) is not None:
         return err
     client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
-    return report_success(client.list_integrations(), _render_integrations_table)
+    return report_success(client.list_github_installations(), _render_github_installations_table)
+
 
 
+def handle_github_disconnect(config: RuntimeConfig, ref: str | None) -> int:
+    if (err := _require_api_key(config)) is not None:
+        return err
+    resolved_ref = str(ref or "").strip()
+    if not resolved_ref:
+        if not _interactive():
+            return report_error("github owner or installation id is required")
+        resolved_ref = _prompt_text("GitHub owner or installation id")
+        if not resolved_ref:
+            return report_error("github owner or installation id is required")
+
+    client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
+    installation_id: int | None = None
+    owner = resolved_ref
 
-def handle_integrations_connect(
+    try:
+        installation_id = int(resolved_ref)
+    except ValueError:
+        payload = client.list_github_installations()
+        installations = payload.get("installations") or []
+        target_owner = resolved_ref.casefold()
+        match = next(
+            (
+                entry
+                for entry in installations
+                if isinstance(entry, dict) and str(entry.get("github_account_login") or "").strip().casefold() == target_owner
+            ),
+            None,
+        )
+        if match is None:
+            return report_error(f"github installation not found: {resolved_ref}")
+        try:
+            installation_id = int(match.get("id"))
+        except (TypeError, ValueError):
+            return report_error(f"github installation is missing an id: {resolved_ref}")
+        owner = str(match.get("github_account_login") or resolved_ref)
+
+    if installation_id is None or installation_id <= 0:
+        return report_error("installation id must be a positive number")
+
+    client.disconnect_github_installation(installation_id)
+    return report_success(
+        {"id": installation_id, "owner": owner, "deleted": True},
+        lambda payload: _UI.console().print(f"[green]✓[/green] disconnected [bold]{payload['owner']}[/bold]"),
+    )
+
+
+
+def handle_integrate_github(
     config: RuntimeConfig,
     provider: str,
-    slug: str | None,
-    owner: str | None,
     *,
     no_open: bool = False,
+    timeout_seconds: int = 180,
 ) -> int:
     if (err := _require_api_key(config)) is not None:
         return err
@@ -1953,11 +1931,11 @@ def handle_integrations_connect(
         return report_error(f"unsupported integration provider: {provider}")
 
     client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
-    payload = _with_spinner("getting GitHub install link…", lambda: client.start_github_connect(slug=slug))
+    payload = _with_spinner("getting GitHub install link…", client.start_github_connect)
     install_url = str(payload.get("install_url") or "").strip()
-    resolved_slug = str(payload.get("slug") or slug or "github").strip() or "github"
-    if not install_url:
-        return report_error("server did not return a GitHub install URL")
+    session_id = int(payload.get("session_id") or 0)
+    if not install_url or session_id <= 0:
+        return report_error("server did not return a GitHub install session")
 
     opened = False
     if not no_open:
@@ -1967,37 +1945,26 @@ def handle_integrations_connect(
     if _interactive():
         action = "opened in your browser" if opened else "copy this URL into your browser"
         _UI.console().print(f"[cyan]→[/cyan] {action}: [link={install_url}]{install_url}[/link]")
-        _UI.console().print("[dim]Install the RuntimeVM GitHub App, then come back here.[/dim]")
-        input("Press Enter after the GitHub App is installed... ")
-        if not owner:
-            owner = _prompt_text("GitHub owner (username or org)")
-    elif not owner:
-        return report_error("--owner is required without a TTY")
-
-    resolved_owner = str(owner or "").strip()
-    if not resolved_owner:
-        return report_error("GitHub owner is required")
-
-    integration = _with_spinner(
-        "connecting GitHub…",
-        lambda: client.create_integration(
-            slug=resolved_slug,
-            provider="github",
-            transport="scoped_credential",
-            backend="native",
-            credential_source="external_account",
-            credential_ref=resolved_owner,
-            config={},
-        ),
-    )
+        _UI.console().print("[dim]Choose the GitHub account/org and repo access in GitHub. Waiting for completion…[/dim]")
 
-    def render(result: dict[str, Any]) -> None:
-        connected = result.get("integration") or {}
-        _UI.console().print(
-            f"[green]✓[/green] connected [bold]{connected.get('slug', resolved_slug)}[/bold] → [bold]{connected.get('credential_ref', resolved_owner)}[/bold]"
-        )
+    deadline = time.time() + max(1, int(timeout_seconds))
+    last_status = "pending"
+    while time.time() < deadline:
+        session = client.get_github_connect_session(session_id)
+        status = str(session.get("status") or "pending")
+        last_status = status
+        if status == "completed":
+            installation = session.get("installation") or {}
+            owner = str(installation.get("github_account_login") or "github")
+            return report_success(
+                {"installation": installation, "install_url": install_url, "session_id": session_id},
+                lambda result: _UI.console().print(f"[green]✓[/green] connected [bold]{(result.get('installation') or {}).get('github_account_login', owner)}[/bold]"),
+            )
+        if status in {"failed", "expired"}:
+            return report_error(str(session.get("error") or f"github connect {status}"))
+        time.sleep(2)
 
-    return report_success({"integration": integration, "install_url": install_url}, render)
+    return report_error(f"timed out waiting for GitHub install to finish (last status: {last_status})")
 
 
 
@@ -2977,7 +2944,11 @@ def _send_terminal_resize(ws: Any) -> None:
 
 
 def _interactive_list(config: RuntimeConfig) -> int:
-    """Nested menu: table → pick VM → action → back."""
+    """Interactive top-level menu: picker is the display, no separate table.
+
+    ESC / Ctrl+C / "✕ quit" exit. "+ new computer" creates one. "↻ refresh"
+    re-fetches. Picking a VM drops into its action submenu.
+    """
     client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
     questionary = _UI.q()
 
@@ -2992,9 +2963,19 @@ def _interactive_list(config: RuntimeConfig) -> int:
             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")
+        widths = _picker_widths(computers)
+
+        # Title summarises counts so the picker alone carries enough context.
+        total = len(computers)
+        warm = sum(1 for c in computers if "warm" in _computer_status_label(c) or "running" in _computer_status_label(c))
+        cold = sum(1 for c in computers if "cold" in _computer_status_label(c))
+        bits = [f"{total} total"]
+        if warm:
+            bits.append(f"{warm} warm")
+        if cold:
+            bits.append(f"{cold} cold")
+        summary = " · ".join(bits)
+
         choices: list[Any] = [
             questionary.Choice(title=_computer_choice_title(c, widths), value=c)
             for c in computers
@@ -3004,9 +2985,9 @@ def _interactive_list(config: RuntimeConfig) -> int:
         choices.append(questionary.Choice(title="↻ refresh", value="__refresh__"))
         choices.append(questionary.Choice(title="✕ quit", value="__quit__"))
 
-        picked = _select_prompt("Pick a computer", choices).unsafe_ask()
+        picked = _select_prompt(f"Pick a computer ({summary})", choices).unsafe_ask()
 
-        if picked == "__quit__":
+        if picked is None or picked == "__quit__":
             return 0
         if picked == "__refresh__":
             continue
@@ -3270,7 +3251,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 integrations 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 startup service proxy switch checkout github integrate secrets api-keys signup verify login whoami logout completion help" -- "$cur") )
     return
   fi
   sub="${COMP_WORDS[1]}"
@@ -3319,7 +3300,8 @@ _runtime() {
     'proxy:Port proxies'
     'switch:Open a GitHub branch workspace'
     'checkout:Open a GitHub branch workspace'
-    'integrations:Integrations'
+    'github:GitHub connections'
+    'integrate:Connect GitHub'
     'secrets:Secret sets'
     'api-keys:API keys'
     'signup:Send verification code'
@@ -3384,6 +3366,8 @@ 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'
+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'
 

{runtime_sdk-0.4.24 → runtime_sdk-0.4.26}/scripts/runtime_sdk/client.py

@@ -52,38 +52,19 @@ class RuntimeClient:
     def revoke_api_key(self, key_id: int) -> dict[str, Any]:
         return self._request("POST", f"/api/api-keys/{key_id}/revoke", auth_required=True)
 
-    # --- Integrations ---
+    # --- GitHub App ---
 
-    def list_integrations(self) -> dict[str, Any]:
-        return self._request("GET", "/api/integrations", auth_required=True)
+    def start_github_connect(self) -> dict[str, Any]:
+        return self._request("POST", "/api/github/connect", auth_required=True)
 
-    def start_github_connect(self, *, slug: str | None = None) -> dict[str, Any]:
-        body: dict[str, Any] = {}
-        if slug:
-            body["slug"] = slug
-        return self._request("POST", "/api/integrations/github/connect", json=body, auth_required=True)
+    def get_github_connect_session(self, session_id: int) -> dict[str, Any]:
+        return self._request("GET", f"/api/github/connect/{session_id}", auth_required=True)
 
-    def create_integration(
-        self,
-        *,
-        slug: str,
-        provider: str,
-        transport: str,
-        backend: str,
-        credential_source: str,
-        credential_ref: str,
-        config: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        body: dict[str, Any] = {
-            "slug": slug,
-            "provider": provider,
-            "transport": transport,
-            "backend": backend,
-            "credential_source": credential_source,
-            "credential_ref": credential_ref,
-            "config": config or {},
-        }
-        return self._request("POST", "/api/integrations", json=body, auth_required=True)
+    def list_github_installations(self) -> dict[str, Any]:
+        return self._request("GET", "/api/github/installations", auth_required=True)
+
+    def disconnect_github_installation(self, installation_id: int) -> dict[str, Any]:
+        return self._request("DELETE", f"/api/github/installations/{installation_id}", auth_required=True)
 
     def list_secret_sets(self) -> dict[str, Any]:
         return self._request("GET", "/api/secrets", auth_required=True)

{runtime_sdk-0.4.24 → runtime_sdk-0.4.26}/scripts/runtime_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runtime-sdk
-Version: 0.4.24
+Version: 0.4.26
 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
@@ -66,8 +66,9 @@ runtime login --api-key rt_live_...
 runtime api-keys list
 runtime api-keys create "my laptop"
 runtime api-keys revoke 123
-runtime integrations list
-runtime integrations connect github
+runtime integrate github
+runtime github list
+runtime github disconnect acme
 
 # Computers
 runtime switch --repo owner/repo feature/login      # open or create the branch workspace computer
@@ -170,13 +171,15 @@ that ad-hoc process is not.
 between parallel tasks without local worktrees.
 
 ```bash
-runtime integrations connect github
+runtime integrate github
+runtime github list
 runtime switch --repo owner/repo feature/login
 runtime switch -c feature/search --repo owner/repo --from main
 ```
 
 Rules:
-- GitHub must already be connected with `runtime integrations connect github`.
+- GitHub must already be connected with `runtime integrate github`.
+- Run `runtime integrate github` again when you want to add another personal account or org.
 - `runtime switch` opens an existing branch workspace, or creates the computer if
   the branch exists but the workspace does not yet.
 - `runtime switch -c` creates a new branch first, then opens that branch's