runtime-sdk 0.4.14__tar.gz → 0.4.16__tar.gz

{runtime_sdk-0.4.14 → runtime_sdk-0.4.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runtime-sdk
-Version: 0.4.14
+Version: 0.4.16
 Summary: Runtime Python SDK and CLI
 Project-URL: Repository, https://github.com/The-Money-Company-Limited/runtimevm
 Project-URL: Issues, https://github.com/The-Money-Company-Limited/runtimevm/issues

{runtime_sdk-0.4.14 → runtime_sdk-0.4.16}/pyproject.toml

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

{runtime_sdk-0.4.14 → runtime_sdk-0.4.16}/scripts/runtime_sdk/cli.py

@@ -15,6 +15,7 @@ import termios
 import threading
 import time
 import tty
+import webbrowser
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Callable
@@ -173,6 +174,28 @@ def build_parser() -> argparse.ArgumentParser:
     api_keys_revoke = api_keys_subparsers.add_parser("revoke", help="Revoke an API key")
     api_keys_revoke.add_argument("id", nargs="?", default=None, help="API key id")
 
+    secrets_cmd = subparsers.add_parser("secrets", help="Manage account-level secret sets")
+    secrets_subparsers = secrets_cmd.add_subparsers(dest="secrets_action", required=True)
+    secrets_subparsers.add_parser("list", aliases=["ls"], help="List secret sets")
+    secrets_show = secrets_subparsers.add_parser("show", help="Show one secret set")
+    secrets_show.add_argument("slug", nargs="?", default=None, help="Secret set slug")
+    secrets_set = secrets_subparsers.add_parser("set", help="Create or replace a secret set from KEY=VALUE pairs")
+    secrets_set.add_argument("slug", nargs="?", default=None, help="Secret set slug")
+    secrets_set.add_argument("pairs", nargs="*", help="KEY=VALUE pairs")
+    secrets_import = secrets_subparsers.add_parser("import", help="Create or replace a secret set from a .env file")
+    secrets_import.add_argument("slug", nargs="?", default=None, help="Secret set slug")
+    secrets_import.add_argument("--env-file", required=True, help="Path to .env file")
+    secrets_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_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")
+
     create_cmd = subparsers.add_parser("create", help="Create a new computer with the starter app published by default")
     create_cmd.add_argument(
         "name",
@@ -297,6 +320,22 @@ def main(argv: list[str] | None = None) -> int:
             if args.api_keys_action == "revoke":
                 return handle_api_keys_revoke(config, args.id)
             return report_error("unknown api-keys command")
+        if args.command == "secrets":
+            if args.secrets_action in ("list", "ls"):
+                return handle_secrets_list(config)
+            if args.secrets_action == "show":
+                return handle_secrets_show(config, args.slug)
+            if args.secrets_action == "set":
+                return handle_secrets_set(config, args.slug, args.pairs)
+            if args.secrets_action == "import":
+                return handle_secrets_import(config, args.slug, args.env_file)
+            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 == "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 == "create":
             return handle_create(
                 config,
@@ -1172,6 +1211,45 @@ def _render_api_key_created(payload: dict[str, Any]) -> None:
     _UI.console().print(Panel(body, title="api key created", border_style="cyan", expand=False))
 
 
+
+def _render_secret_sets_table(payload: dict[str, Any]) -> None:
+    mods = _UI.rich()
+    Table = mods["Table"]
+    secret_sets = payload.get("secret_sets") or []
+    if not isinstance(secret_sets, list) or not secret_sets:
+        _UI.console().print("[yellow]no secret sets found[/yellow]")
+        return
+
+    table = Table(title="Secret sets", expand=True, box=mods["box"].SIMPLE_HEAVY)
+    table.add_column("Slug", style="bold white")
+    table.add_column("Keys", style="white")
+    table.add_column("Updated", style="dim", no_wrap=True, justify="right")
+
+    for entry in secret_sets:
+        if not isinstance(entry, dict):
+            continue
+        keys = entry.get("keys") or []
+        table.add_row(
+            str(entry.get("slug") or "—"),
+            ", ".join(str(key) for key in keys) or "—",
+            _relative_time_label(entry.get("updated_at")) or "—",
+        )
+
+    _UI.console().print(table)
+
+
+
+def _render_secret_set_panel(payload: dict[str, Any]) -> None:
+    mods = _UI.rich()
+    Panel, Text = mods["Panel"], mods["Text"]
+    body = Text()
+    body.append(f"{'slug':<12}", style="dim")
+    body.append(f"{payload.get('slug') or '—'}\n")
+    body.append(f"{'keys':<12}", style="dim")
+    body.append(", ".join(str(key) for key in (payload.get("keys") or [])) or "—")
+    _UI.console().print(Panel(body, title="secret set", border_style="cyan", expand=False))
+
+
 # --------------------------------------------------------------------------- #
 # Command handlers                                                            #
 # --------------------------------------------------------------------------- #
@@ -1407,6 +1485,200 @@ def handle_api_keys_revoke(config: RuntimeConfig, key_id: str | None) -> int:
 
 
 
+def _coerce_secret_set_slug(slug: str | None) -> str | None:
+    value = str(slug or "").strip()
+    return value or None
+
+
+
+def _parse_secret_pairs(pairs: list[str] | None) -> dict[str, str]:
+    values: dict[str, str] = {}
+    for pair in pairs or []:
+        if "=" not in pair:
+            raise RuntimeConfigError(f"invalid secret pair: {pair}")
+        key, value = pair.split("=", 1)
+        key = key.strip()
+        if not key:
+            raise RuntimeConfigError(f"invalid secret pair: {pair}")
+        values[key] = value
+    return values
+
+
+
+def _parse_env_file(path: str) -> dict[str, str]:
+    try:
+        lines = Path(path).read_text(encoding="utf-8").splitlines()
+    except OSError as exc:
+        raise RuntimeConfigError(f"failed to read env file: {exc}") from exc
+    values: dict[str, str] = {}
+    for raw_line in lines:
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if line.startswith("export "):
+            line = line[len("export "):].strip()
+        if "=" not in line:
+            raise RuntimeConfigError(f"invalid env line: {raw_line}")
+        key, value = line.split("=", 1)
+        key = key.strip()
+        if not key:
+            raise RuntimeConfigError(f"invalid env line: {raw_line}")
+        value = value.strip()
+        if value and value[0] == value[-1] and value[0] in {'\"', "'"}:
+            value = value[1:-1]
+        values[key] = value
+    return values
+
+
+
+def handle_secrets_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_secret_sets(), _render_secret_sets_table)
+
+
+
+def handle_secrets_show(config: RuntimeConfig, slug: str | None) -> int:
+    if (err := _require_api_key(config)) is not None:
+        return err
+    resolved_slug = _coerce_secret_set_slug(slug)
+    if resolved_slug is None:
+        if not _interactive():
+            return report_error("secret set slug is required")
+        resolved_slug = _prompt_text("Secret set slug")
+        if not resolved_slug:
+            return report_error("secret set slug is required")
+    client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
+    return report_success(client.get_secret_set(resolved_slug), _render_secret_set_panel)
+
+
+
+def handle_secrets_set(config: RuntimeConfig, slug: str | None, pairs: list[str] | None) -> int:
+    if (err := _require_api_key(config)) is not None:
+        return err
+    resolved_slug = _coerce_secret_set_slug(slug)
+    if resolved_slug is None:
+        if not _interactive():
+            return report_error("secret set slug is required")
+        resolved_slug = _prompt_text("Secret set slug")
+        if not resolved_slug:
+            return report_error("secret set slug is required")
+    values = _parse_secret_pairs(pairs)
+    if not values:
+        return report_error("at least one KEY=VALUE pair is required")
+    client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
+    secret_set = client.put_secret_set(resolved_slug, values)
+    return report_success(
+        {"secret_set": secret_set},
+        lambda payload: _UI.console().print(f"[green]✓[/green] saved [bold]{payload['secret_set'].get('slug', resolved_slug)}[/bold]"),
+    )
+
+
+
+def handle_secrets_import(config: RuntimeConfig, slug: str | None, env_file: str) -> int:
+    if (err := _require_api_key(config)) is not None:
+        return err
+    resolved_slug = _coerce_secret_set_slug(slug)
+    if resolved_slug is None:
+        if not _interactive():
+            return report_error("secret set slug is required")
+        resolved_slug = _prompt_text("Secret set slug")
+        if not resolved_slug:
+            return report_error("secret set slug is required")
+    values = _parse_env_file(env_file)
+    if not values:
+        return report_error("env file did not contain any secrets")
+    client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
+    secret_set = client.put_secret_set(resolved_slug, values)
+    return report_success(
+        {"secret_set": secret_set},
+        lambda payload: _UI.console().print(f"[green]✓[/green] saved [bold]{payload['secret_set'].get('slug', resolved_slug)}[/bold] from [bold]{env_file}[/bold]"),
+    )
+
+
+
+def handle_secrets_delete(config: RuntimeConfig, slug: str | None) -> int:
+    if (err := _require_api_key(config)) is not None:
+        return err
+    resolved_slug = _coerce_secret_set_slug(slug)
+    if resolved_slug is None:
+        if not _interactive():
+            return report_error("secret set slug is required")
+        resolved_slug = _prompt_text("Secret set slug")
+        if not resolved_slug:
+            return report_error("secret set slug is required")
+    client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
+    client.delete_secret_set(resolved_slug)
+    return report_success(
+        {"slug": resolved_slug, "deleted": True},
+        lambda payload: _UI.console().print(f"[green]✓[/green] deleted [bold]{payload['slug']}[/bold]"),
+    )
+
+
+
+def handle_integrations_connect(
+    config: RuntimeConfig,
+    provider: str,
+    slug: str | None,
+    owner: str | None,
+    *,
+    no_open: bool = False,
+) -> int:
+    if (err := _require_api_key(config)) is not None:
+        return err
+    if provider != "github":
+        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))
+    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")
+
+    opened = False
+    if not no_open:
+        with contextlib.suppress(Exception):
+            opened = bool(webbrowser.open(install_url))
+
+    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={},
+        ),
+    )
+
+    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]"
+        )
+
+    return report_success({"integration": integration, "install_url": install_url}, render)
+
+
+
 def handle_onboarding(config: RuntimeConfig) -> int:
     code = handle_login(config, None, None, None)
     if code != 0:

{runtime_sdk-0.4.14 → runtime_sdk-0.4.16}/scripts/runtime_sdk/client.py

@@ -52,6 +52,48 @@ 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 ---
+
+    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 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_secret_sets(self) -> dict[str, Any]:
+        return self._request("GET", "/api/secrets", auth_required=True)
+
+    def get_secret_set(self, slug: str) -> dict[str, Any]:
+        return self._request("GET", f"/api/secrets/{slug}", auth_required=True)
+
+    def put_secret_set(self, slug: str, values: dict[str, str]) -> dict[str, Any]:
+        return self._request("PUT", f"/api/secrets/{slug}", json={"values": values}, auth_required=True)
+
+    def delete_secret_set(self, slug: str) -> dict[str, Any]:
+        return self._request("DELETE", f"/api/secrets/{slug}", auth_required=True)
+
     # --- Computers ---
 
     def create_computer(

{runtime_sdk-0.4.14 → runtime_sdk-0.4.16}/scripts/runtime_sdk.egg-info/PKG-INFO

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