machinaos 0.0.87 → 0.0.89

package/cli/commands/deploy/providers/aws.py

@@ -0,0 +1,45 @@
+"""aws-cli adapter -- placeholder (the AWS Terraform module is a follow-on).
+
+Implements the ``ProviderCli`` shape so the resolver/wiring is uniform, but
+aborts with a clear message until the ``cli/terraform/aws/`` module lands. The
+real adapter will mirror gcp.py: ``aws sts get-caller-identity`` for auth, the
+default credential chain for Terraform, region from ``aws configure get region``
+/ ``$AWS_REGION``, and a security-group + EC2 instance module.
+"""
+
+from __future__ import annotations
+
+import typer
+
+from cli._common import error_block
+
+
+class AwsCli:
+    name = "aws"
+
+    def _not_yet(self) -> None:
+        error_block(
+            "The aws provider is not implemented yet.",
+            ["Use --provider gcp for now; the AWS module is a planned follow-on."],
+        )
+        raise typer.Exit(code=1)
+
+    def check(self) -> None:
+        self._not_yet()
+
+    def authed_account(self) -> str | None:
+        return None
+
+    def resolve_context(self, *, region, zone, project) -> dict:
+        self._not_yet()
+        return {}
+
+    def ensure_terraform_auth(self) -> None:
+        self._not_yet()
+
+    def enable_apis(self, ctx: dict) -> None:
+        self._not_yet()
+
+    def tfvars_extra(self, ctx: dict) -> dict:
+        self._not_yet()
+        return {}

package/cli/commands/deploy/providers/gcp.py

@@ -0,0 +1,89 @@
+"""gcloud adapter -- Stage 1 of ``machina deploy --provider gcp``.
+
+Uses the operator's installed + authenticated ``gcloud`` CLI for auth/context/
+API-enablement; Terraform's ``google`` provider then reuses the same
+Application Default Credentials to create the resources.
+"""
+
+from __future__ import annotations
+
+import typer
+
+from cli._common import error_block
+from cli.colors import console
+from cli.run import capture, run
+
+_REQUIRED_APIS = [
+    "compute.googleapis.com",
+    "storage.googleapis.com",
+    "iam.googleapis.com",
+]
+
+
+def _clean(value: str | None) -> str | None:
+    """Normalise gcloud config reads (``(unset)`` / empty -> None)."""
+    if not value:
+        return None
+    v = value.strip()
+    return None if v in ("", "(unset)") else v
+
+
+class GcpCli:
+    name = "gcp"
+
+    def check(self) -> None:
+        if capture(["gcloud", "version"]) is None:
+            error_block(
+                "The gcloud CLI was not found on PATH.",
+                ["Install the Google Cloud SDK: https://cloud.google.com/sdk/docs/install"],
+            )
+            raise typer.Exit(code=1)
+
+    def authed_account(self) -> str | None:
+        return _clean(
+            capture(
+                ["gcloud", "auth", "list", "--filter=status:ACTIVE", "--format=value(account)"]
+            )
+        )
+
+    def resolve_context(self, *, region, zone, project) -> dict:
+        account = self.authed_account()
+        if not account:
+            error_block(
+                "gcloud is not logged in.",
+                ["Run: gcloud auth login"],
+            )
+            raise typer.Exit(code=1)
+
+        proj = project or _clean(capture(["gcloud", "config", "get-value", "project"]))
+        if not proj:
+            error_block(
+                "No GCP project is set.",
+                ["Pass --project <id>, or run: gcloud config set project <id>"],
+            )
+            raise typer.Exit(code=1)
+
+        reg = region or _clean(capture(["gcloud", "config", "get-value", "compute/region"])) or "us-central1"
+        zn = zone or _clean(capture(["gcloud", "config", "get-value", "compute/zone"])) or "us-central1-a"
+
+        console.print(f"  gcloud account: {account}")
+        console.print(f"  project={proj}  region={reg}  zone={zn}")
+        return {"project": proj, "region": reg, "zone": zn}
+
+    def ensure_terraform_auth(self) -> None:
+        # Terraform's google provider authenticates via Application Default
+        # Credentials. print-access-token exits non-zero (capture -> None) when
+        # ADC is not configured.
+        if capture(["gcloud", "auth", "application-default", "print-access-token"]) is None:
+            error_block(
+                "Terraform needs Application Default Credentials.",
+                ["Run: gcloud auth application-default login"],
+            )
+            raise typer.Exit(code=1)
+
+    def enable_apis(self, ctx: dict) -> None:
+        console.log("Enabling required GCP APIs (compute, storage, iam)...")
+        run(["gcloud", "services", "enable", *_REQUIRED_APIS, "--project", ctx["project"]])
+
+    def tfvars_extra(self, ctx: dict) -> dict:
+        return {"project": ctx["project"], "region": ctx["region"], "zone": ctx["zone"]}

package/cli/commands/deploy/status.py

@@ -0,0 +1,48 @@
+"""``machina deploy status`` -- show the deployment's URL + health."""
+
+from __future__ import annotations
+
+import urllib.error
+import urllib.request
+
+import typer
+
+from cli._common import preflight
+from cli.colors import console
+
+from . import _state, _terraform
+
+
+def status_command() -> None:
+    # Establish the same DATA_DIR context as `deploy up` (load_config sets it)
+    # so workdir() resolves to the directory `up` created.
+    preflight()
+    meta = _state.read_meta()
+    if meta is None:
+        console.print("[yellow]No 'machinaos' deployment found.[/]")
+        raise typer.Exit(code=1)
+
+    wd = _state.workdir()
+    ip = _terraform.tf_output(wd, "external_ip")
+    url = _terraform.tf_output(wd, "url") or (
+        f"http://{ip}:{meta.get('port', 8080)}" if ip else None
+    )
+
+    console.print("  Deployment:  machinaos")
+    console.print(f"  Provider:    {meta.get('provider', '?')}")
+    console.print(f"  External IP: {ip or '(unknown / destroyed)'}")
+    console.print(f"  URL:         {url or '(unknown)'}")
+    console.print(f"  Login email: {meta.get('owner_email', '?')}")
+
+    if not url:
+        raise typer.Exit(code=1)
+
+    healthy = False
+    try:
+        with urllib.request.urlopen(url.rstrip("/") + "/health", timeout=5) as resp:  # noqa: S310
+            healthy = resp.status == 200
+    except (urllib.error.URLError, OSError):
+        healthy = False
+    console.print(f"  Health:      {'[green]OK[/]' if healthy else '[yellow]not ready[/]'}")
+    if not healthy:
+        raise typer.Exit(code=1)

package/cli/commands/deploy/up.py

@@ -0,0 +1,146 @@
+"""``machina deploy up`` -- provision + run MachinaOs on a fresh cloud VM.
+
+Two stages:
+  STAGE 1 (cloud CLI): the provider adapter verifies the CLI is installed +
+    authenticated, resolves project/region/zone, ensures Terraform auth, and
+    enables the required cloud APIs.
+  STAGE 2 (Terraform): generate secrets + owner creds -> (local source) npm
+    pack -> write tfvars -> ``terraform init`` + ``apply`` -> read outputs ->
+    poll ``/health`` -> print URL + credentials.
+
+The VM instance is always named ``machinaos`` (one deployment per project).
+"""
+
+from __future__ import annotations
+
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+import typer
+
+from cli._common import error_block, preflight
+from cli.colors import console
+from cli.run import capture
+
+from . import _secrets, _state, _terraform
+from .providers import get_provider
+
+
+def _npm_pack(root: Path) -> str:
+    """Run ``npm pack`` in the repo root; return the abs path to the tarball."""
+    console.log("Packaging local build (npm pack)...")
+    out = capture(["npm", "pack"], cwd=root)
+    if not out:
+        error_block(
+            "`npm pack` produced no output.",
+            ["Ensure Node/npm are installed and you are in a MachinaOs checkout."],
+        )
+        raise typer.Exit(code=1)
+    tarball = out.strip().splitlines()[-1].strip()
+    path = (root / tarball).resolve()
+    if not path.is_file():
+        error_block(f"npm pack reported {tarball!r} but it is not on disk.", [str(path)])
+        raise typer.Exit(code=1)
+    return str(path)
+
+
+def _poll_health(url: str, *, attempts: int = 40, delay: float = 15.0) -> bool:
+    """Poll ``<url>/health`` until 200 or attempts exhausted (~10 min)."""
+    health = url.rstrip("/") + "/health"
+    for i in range(1, attempts + 1):
+        try:
+            with urllib.request.urlopen(health, timeout=5) as resp:  # noqa: S310
+                if resp.status == 200:
+                    return True
+        except (urllib.error.URLError, OSError):
+            pass
+        console.log(f"waiting for the VM to finish provisioning... ({i}/{attempts})")
+        time.sleep(delay)
+    return False
+
+
+def up_command(
+    *,
+    provider: str,
+    region: str | None,
+    zone: str | None,
+    machine_type: str,
+    port: int,
+    owner_email: str,
+    owner_password: str | None,
+    source: str,
+    version: str,
+    allow_cidr: str,
+    project: str | None,
+) -> None:
+    _, root = preflight()
+
+    # --- STAGE 1: cloud CLI (auth + context + APIs) ------------------------
+    cli = get_provider(provider)
+    cli.check()
+    _terraform.ensure_terraform()
+    ctx = cli.resolve_context(region=region, zone=zone, project=project)
+    cli.ensure_terraform_auth()
+    cli.enable_apis(ctx)
+
+    if _state.exists() and (_state.workdir() / "terraform.tfstate").exists():
+        console.print(
+            "[yellow]A 'machinaos' deployment already exists. Re-running will "
+            "re-apply Terraform (safe), or run `machina deploy destroy` first.[/]"
+        )
+
+    # --- STAGE 2: secrets + source + Terraform -----------------------------
+    pw = owner_password or _secrets.new_password()
+    pw_generated = owner_password is None
+    app_env = _secrets.build_app_env(owner_email=owner_email, owner_password=pw, port=port)
+
+    pack_tarball = _npm_pack(root) if source == "local" else ""
+
+    tfvars: dict = {
+        "machine_type": machine_type,
+        "port": port,
+        "allow_cidr": allow_cidr,
+        "app_env": app_env,
+        "source_mode": source,
+        "machinaos_version": version,
+        "pack_tarball": pack_tarball,
+    }
+    tfvars.update(cli.tfvars_extra(ctx))
+
+    wd = _state.workdir()
+    _terraform.prepare_workdir(wd, provider)
+    _terraform.write_tfvars(wd, tfvars)
+    _state.write_meta({"provider": provider, "port": port, "owner_email": owner_email})
+
+    console.log("terraform init...")
+    _terraform.tf(wd, "init", "-input=false")
+    console.log("terraform apply (creating cloud resources)...")
+    _terraform.tf(wd, "apply", "-auto-approve", "-input=false")
+
+    ip = _terraform.tf_output(wd, "external_ip")
+    url = _terraform.tf_output(wd, "url") or (f"http://{ip}:{port}" if ip else None)
+
+    console.print()
+    console.print("  [bold green]VM 'machinaos' provisioned.[/]")
+    if ip:
+        console.print(f"  External IP: {ip}")
+    if url:
+        console.print(f"  URL:         {url}")
+    console.print(f"  Login email: {owner_email}")
+    if pw_generated:
+        console.print(f"  Login password (save this now): [bold]{pw}[/]")
+    else:
+        console.print("  Login password: (the one you provided)")
+    console.print()
+
+    if url:
+        console.log("The VM is installing MachinaOs (Node + npm + build); this takes a few minutes.")
+        if _poll_health(url):
+            console.print(f"  [bold green]Ready.[/] Open {url} and log in.")
+        else:
+            console.print(
+                "  [yellow]Still provisioning.[/] Check again with "
+                "`machina deploy status` in a few minutes."
+            )

package/cli/commands/serve.py

@@ -0,0 +1,98 @@
+"""``machina serve`` -- single-port production runtime.
+
+Runs the app on ONE public port: uvicorn serves the REST API + WebSocket +
+the built React SPA (via the ``SERVE_STATIC_CLIENT`` block in
+``server/main.py``), plus the Node.js code-exec sidecar on its own internal
+port. Used locally for a production-shaped run AND as the systemd
+``ExecStart`` on a VM provisioned by ``machina deploy``.
+
+Unlike ``machina start`` (which runs a separate static-client server + the
+backend + temporal on multiple ports), ``serve`` is single-port and serves
+the client from the backend itself. The Node sidecar is NOT launched by
+``start``/``dev`` today, so ``serve`` adds it (the JS/TS executor nodes need
+it).
+
+The long-running uvicorn is invoked via the server venv's interpreter
+directly (not ``uv run``) so the systemd service has no runtime dependency
+on ``uv`` being on PATH.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from pathlib import Path
+
+import typer
+
+from cli._common import preflight
+from cli.buildenv import validate_build
+from cli.colors import console
+from cli.platform_ import IS_WINDOWS, server_dir, server_venv
+
+
+def _venv_python(root: Path | None = None) -> str:
+    """Absolute path to the server venv's Python interpreter."""
+    venv = server_venv(root)
+    rel = "Scripts/python.exe" if IS_WINDOWS else "bin/python"
+    return str(venv / rel)
+
+
+def serve_command(port: int | None = None) -> None:
+    from cli.supervisor import Manager, ServiceSpec
+
+    cfg, root = preflight()
+    os.environ.setdefault("PYTHONUTF8", "1")
+    validate_build(root, require_client_dist=True)
+
+    # Public port: --port flag > $PORT (Cloud Run / systemd convention) >
+    # PYTHON_BACKEND_PORT from the env files.
+    bind_port = port or int(os.environ.get("PORT") or cfg.backend_port)
+
+    # Free the ports we will bind (clears stale orphans; idempotent).
+    from cli.ports import kill_port
+
+    for p in {bind_port, cfg.nodejs_port}:
+        kill_port(p)
+
+    console.print()
+    console.print("  [bold]MachinaOS[/] serve (single-port)")
+    console.print(f"  App:     http://0.0.0.0:{bind_port}  (API + WebSocket + SPA)")
+    console.print(f"  Sidecar: 127.0.0.1:{cfg.nodejs_port}  (JS/TS executor)")
+    console.print()
+
+    sidecar = server_dir(root) / "nodejs" / "dist" / "index.js"
+
+    specs = [
+        ServiceSpec(
+            name="server",
+            argv=[
+                _venv_python(root),
+                "-m",
+                "uvicorn",
+                "main:app",
+                "--host",
+                "0.0.0.0",
+                "--port",
+                str(bind_port),
+                "--log-level",
+                "warning",
+            ],
+            cwd=server_dir(root),
+            env={"SERVE_STATIC_CLIENT": "1", "PORT": str(bind_port)},
+            ready_port=bind_port,
+        ),
+        ServiceSpec(
+            name="nodejs",
+            argv=["node", str(sidecar)],
+            cwd=server_dir(root) / "nodejs",
+            env={"NODEJS_EXECUTOR_PORT": str(cfg.nodejs_port)},
+            ready_port=cfg.nodejs_port,
+        ),
+    ]
+
+    manager = Manager()
+    manager.add_all(specs)
+    rc = asyncio.run(manager.run())
+    if rc != 0:
+        raise typer.Exit(code=rc)

package/cli/terraform/gcp/main.tf

@@ -0,0 +1,116 @@
+terraform {
+  required_version = ">= 1.3"
+  required_providers {
+    google = {
+      source  = "hashicorp/google"
+      version = "~> 5.0"
+    }
+  }
+}
+
+provider "google" {
+  project = var.project
+  region  = var.region
+}
+
+locals {
+  # The instance is always named "machinaos" (one deployment per project).
+  use_local   = var.source_mode == "local"
+  res_name    = "machinaos"
+  bucket_name = "${var.project}-machinaos"
+  object_name = "machinaos.tgz"
+}
+
+# --- Artifact bucket + object (local source only) --------------------------
+
+resource "google_storage_bucket" "artifact" {
+  count                       = local.use_local ? 1 : 0
+  name                        = local.bucket_name
+  location                    = var.region
+  force_destroy               = true
+  uniform_bucket_level_access = true
+}
+
+resource "google_storage_bucket_object" "pkg" {
+  count  = local.use_local ? 1 : 0
+  name   = local.object_name
+  bucket = google_storage_bucket.artifact[0].name
+  source = var.pack_tarball
+}
+
+# --- VM service account (reads the artifact bucket) ------------------------
+
+resource "google_service_account" "vm" {
+  account_id   = local.res_name
+  display_name = "MachinaOs VM"
+}
+
+resource "google_storage_bucket_iam_member" "vm_read" {
+  count  = local.use_local ? 1 : 0
+  bucket = google_storage_bucket.artifact[0].name
+  role   = "roles/storage.objectViewer"
+  member = "serviceAccount:${google_service_account.vm.email}"
+}
+
+# --- Firewall: app port + SSH ----------------------------------------------
+
+resource "google_compute_firewall" "app" {
+  name    = "${local.res_name}-app"
+  network = "default"
+
+  allow {
+    # CF-proxied front door (80 http-redirected, 443 TLS via nginx) + SSH +
+    # the app port for direct-IP access.
+    protocol = "tcp"
+    ports    = ["80", "443", tostring(var.port), "22"]
+  }
+
+  source_ranges = [var.allow_cidr]
+  target_tags   = [local.res_name]
+}
+
+# --- Instance --------------------------------------------------------------
+
+resource "google_compute_instance" "vm" {
+  name         = local.res_name
+  machine_type = var.machine_type
+  zone         = var.zone
+  tags         = [local.res_name]
+
+  boot_disk {
+    initialize_params {
+      # Ubuntu 24.04 ships Python 3.12 natively — required by the package's
+      # install (server needs >=3.11,<3.13; the CLI needs >=3.12). 22.04
+      # ships 3.10 and the npm postinstall hard-fails on it.
+      image = "ubuntu-os-cloud/ubuntu-2404-lts-amd64"
+      size  = 40
+      type  = "pd-balanced"
+    }
+  }
+
+  network_interface {
+    network = "default"
+    access_config {} # ephemeral external IP
+  }
+
+  service_account {
+    email  = google_service_account.vm.email
+    scopes = ["cloud-platform"]
+  }
+
+  metadata = {
+    startup-script = templatefile("${path.module}/startup.sh.tftpl", {
+      app_env     = var.app_env
+      source_mode = var.source_mode
+      version     = var.machinaos_version
+      bucket      = local.use_local ? google_storage_bucket.artifact[0].name : ""
+      object      = local.object_name
+    })
+  }
+
+  # The startup script reads the bucket object; ensure it exists + is readable first.
+  depends_on = [
+    google_storage_bucket_object.pkg,
+    google_storage_bucket_iam_member.vm_read,
+  ]
+}

package/cli/terraform/gcp/outputs.tf

@@ -0,0 +1,9 @@
+output "external_ip" {
+  value       = google_compute_instance.vm.network_interface[0].access_config[0].nat_ip
+  description = "The VM's public IP."
+}
+
+output "url" {
+  value       = "http://${google_compute_instance.vm.network_interface[0].access_config[0].nat_ip}:${var.port}"
+  description = "The app URL (login gate)."
+}

package/cli/terraform/gcp/startup.sh.tftpl

@@ -0,0 +1,65 @@
+#!/bin/bash
+# MachinaOs VM startup script (rendered by Terraform `templatefile`).
+# Installs the toolchain, installs MachinaOs (npm), writes the login-gate env
+# file, and runs it under systemd via `machina serve`.
+#
+# NOTE on syntax: Terraform renders this file with templatefile(), so any
+# dollar-brace sequence is a Terraform interpolation. Bash variables are
+# therefore written UNBRACED ($TOKEN, $MACHINA_BIN) so Terraform leaves them
+# alone. `set -x` is intentionally NOT used so secrets in the env file are
+# never echoed to the serial console.
+set -euo pipefail
+export DEBIAN_FRONTEND=noninteractive
+
+echo "[machinaos] installing toolchain..."
+apt-get update
+apt-get install -y curl ca-certificates git build-essential pkg-config libffi-dev libssl-dev
+curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
+apt-get install -y nodejs
+corepack enable || true
+# uv on a stable system path (machina build uses it to sync the Python venv).
+curl -LsSf https://astral.sh/uv/install.sh | env UV_INSTALL_DIR=/usr/local/bin sh
+
+echo "[machinaos] installing MachinaOs package..."
+%{ if source_mode == "local" ~}
+TOKEN=$(curl -s -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token" | python3 -c 'import sys, json; print(json.load(sys.stdin)["access_token"])')
+curl -fsS -H "Authorization: Bearer $TOKEN" -o /tmp/machinaos.tgz "https://storage.googleapis.com/storage/v1/b/${bucket}/o/${object}?alt=media"
+npm install -g /tmp/machinaos.tgz
+%{ else ~}
+npm install -g machinaos@${version}
+%{ endif ~}
+
+echo "[machinaos] writing login-gate env..."
+mkdir -p /etc/machinaos
+cat > /etc/machinaos/machina.env <<'MACHINA_ENV_EOF'
+%{ for k, v in app_env ~}
+${k}=${v}
+%{ endfor ~}
+MACHINA_ENV_EOF
+chmod 600 /etc/machinaos/machina.env
+
+mkdir -p /var/lib/machinaos
+
+echo "[machinaos] installing systemd service..."
+MACHINA_BIN=$(command -v machina)
+cat > /etc/systemd/system/machinaos.service <<SERVICE_EOF
+[Unit]
+Description=MachinaOs (single login-gated instance)
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+EnvironmentFile=/etc/machinaos/machina.env
+ExecStart=$MACHINA_BIN serve
+Restart=on-failure
+RestartSec=5
+TimeoutStopSec=20
+
+[Install]
+WantedBy=multi-user.target
+SERVICE_EOF
+
+systemctl daemon-reload
+systemctl enable --now machinaos
+echo "[machinaos] done."

package/cli/terraform/gcp/variables.tf

@@ -0,0 +1,54 @@
+# Shared deployment variable interface (every provider module declares the
+# same set, so `machina deploy` writes one tfvars shape regardless of provider).
+
+variable "project" {
+  type        = string
+  description = "GCP project id."
+}
+
+variable "region" {
+  type        = string
+  description = "GCP region."
+}
+
+variable "zone" {
+  type        = string
+  description = "GCP zone for the instance."
+}
+
+variable "machine_type" {
+  type        = string
+  description = "Compute Engine machine type."
+}
+
+variable "port" {
+  type        = number
+  description = "Public port the app binds and the firewall opens."
+}
+
+variable "allow_cidr" {
+  type        = string
+  description = "Firewall source range (e.g. 0.0.0.0/0 or <your-ip>/32)."
+}
+
+variable "source_mode" {
+  type        = string
+  description = "Install source: 'local' (npm pack tarball via bucket) or 'release' (npm registry)."
+}
+
+variable "machinaos_version" {
+  type        = string
+  description = "machinaos version to install when source_mode = 'release'."
+}
+
+variable "pack_tarball" {
+  type        = string
+  default     = ""
+  description = "Absolute path to the npm pack tarball (source_mode = 'local')."
+}
+
+variable "app_env" {
+  type        = map(string)
+  sensitive   = true
+  description = "KEY=VALUE map rendered into the VM's /etc/machinaos/machina.env."
+}

package/client/dist/assets/{ActionBar-Bg1hW3t6.js → ActionBar-DqL2u6-G.js}

@@ -1 +1 @@
-import{f as u,n as d,o as p,p as m,q as f,r as g,k as x}from"./index-D-LxTbwD.js";import{j as l}from"./vendor-query-SzWcOU0G.js";import{q as b}from"./vendor-icons-CVrPjN2Q.js";function h(r){const t=u.c(7),a=d(),n=p(),s=m(),i=f(),o=g();if(!r)return null;let e;return t[0]!==n||t[1]!==i||t[2]!==r||t[3]!==s||t[4]!==o||t[5]!==a?(e={whatsapp:a,android:n,twitter:s,google:i,telegram:o}[r]??null,t[0]=n,t[1]=i,t[2]=r,t[3]=s,t[4]=o,t[5]=a,t[6]=e):e=t[6],e}const y=r=>{const t=u.c(7),{actions:a,loading:n}=r;let s;if(t[0]!==a||t[1]!==n){let o;t[3]!==n?(o=e=>{const c=n===e.key;return l.jsxs(x,{intent:e.intent,onClick:e.onClick,disabled:e.disabled||c,children:[c?l.jsx(b,{className:"h-4 w-4 animate-spin"}):e.icon,e.label]},e.key)},t[3]=n,t[4]=o):o=t[4],s=a.filter(j).map(o),t[0]=a,t[1]=n,t[2]=s}else s=t[2];let i;return t[5]!==s?(i=l.jsx("div",{className:"flex justify-center gap-2 border-t border-border pt-3",children:s}),t[5]=s,t[6]=i):i=t[6],i};function j(r){return!r.hidden}export{y as A,h as u};
+import{f as u,n as d,o as p,p as m,q as f,r as g,k as x}from"./index-CW3r0-Ob.js";import{j as l}from"./vendor-query-SzWcOU0G.js";import{q as b}from"./vendor-icons-CVrPjN2Q.js";function h(r){const t=u.c(7),a=d(),n=p(),s=m(),i=f(),o=g();if(!r)return null;let e;return t[0]!==n||t[1]!==i||t[2]!==r||t[3]!==s||t[4]!==o||t[5]!==a?(e={whatsapp:a,android:n,twitter:s,google:i,telegram:o}[r]??null,t[0]=n,t[1]=i,t[2]=r,t[3]=s,t[4]=o,t[5]=a,t[6]=e):e=t[6],e}const y=r=>{const t=u.c(7),{actions:a,loading:n}=r;let s;if(t[0]!==a||t[1]!==n){let o;t[3]!==n?(o=e=>{const c=n===e.key;return l.jsxs(x,{intent:e.intent,onClick:e.onClick,disabled:e.disabled||c,children:[c?l.jsx(b,{className:"h-4 w-4 animate-spin"}):e.icon,e.label]},e.key)},t[3]=n,t[4]=o):o=t[4],s=a.filter(j).map(o),t[0]=a,t[1]=n,t[2]=s}else s=t[2];let i;return t[5]!==s?(i=l.jsx("div",{className:"flex justify-center gap-2 border-t border-border pt-3",children:s}),t[5]=s,t[6]=i):i=t[6],i};function j(r){return!r.hidden}export{y as A,h as u};