rustploy-gui 0.1.12

Rustploy — desktop client (glacier-ui) for the Rustploy PaaS daemon
--!strict
--!nolint FunctionUnused
-- handlers/connection.luau — ciclo de vida da sessão: init (semeia o contexto),
-- login/logout, configurações do daemon buscadas uma vez na conexão.

local State = require("../state")
local Helpers = require("../helpers")
local Api = require("../net/api")
local format = require("../format")
local Stream = require("stream")
local Settings = require("settings")
local AccessKey = require("../access_key")

-- ── login lembrado: lista de servidor/token (via o `storage` do glacier) ────
-- O login é UM campo: o token de conexão (endereço + token, ver
-- access_key.luau). Toda conexão bem-sucedida salva/atualiza o par sozinha
-- (ver `connect()`), e quem administra mais de um daemon tem a lista inteira
-- no `<select>` (login.gvb): cada item mostra o `host:porta`, e escolher um
-- preenche o campo com o token de conexão dele. O armazenamento continua `{url, token}` (o token é montado na hora
-- de mostrar), então servidores salvos antes do login por token não se
-- perdem. `storage` grava em `~/.local/share/rustploy/.glacier-storage/app.json`
-- (raiz definida por `app(id = rustploy)` de `views/app.gvb`).
local saved_servers: { { url: string, token: string } } = {}

-- Publica `{label, value}` para o `<select>` de servidores salvos: o rótulo é
-- o `host:porta` (para ver aonde vai conectar), o valor é o token de conexão,
-- que vai para o campo ao escolher. Select e campo são widgets separados de
-- propósito: num `<ComboEdit>` o campo mostra o RÓTULO da opção escolhida, e
-- não dá para ter o endereço na lista e o token no campo ao mesmo tempo.
local function publish_saved_servers(): ()
    local server_options = json.array{}
    for _, saved_server in ipairs(saved_servers) do
        local key = AccessKey.encode(saved_server.url, saved_server.token)
        table.insert(server_options, { label = AccessKey.address_of(saved_server.url), value = key })
    end
    ctx.saved_servers = json.encode(server_options)
end

-- A linha "conecta em host:porta" sob o campo, e o item do select que
-- corresponde ao token digitado/colado (vazio quando não é nenhum salvo).
local function publish_access_key_target(): ()
    local decoded_key = AccessKey.decode(ctx.access_key)
    ctx.access_key_target = if decoded_key then "conecta em " .. decoded_key.address else ""
    ctx.saved_server_choice = ""
    for _, saved_server in ipairs(saved_servers) do
        local key = AccessKey.encode(saved_server.url, saved_server.token)
        if key == ctx.access_key then
            ctx.saved_server_choice = key
            break
        end
    end
end

-- Salva/atualiza um par e o move pro topo da lista — o mais usado por último
-- fica em primeiro, e é também o que `init()` pré-preenche no próximo boot.
-- A igualdade é por `host:porta`, não pela URL: o token de conexão não tem
-- esquema, então `http://h:1` e `https://h:1` são o mesmo servidor (e dariam o
-- mesmo item na lista).
local function remember_server(url: string, token: string): ()
    local address = AccessKey.address_of(url)
    for index = #saved_servers, 1, -1 do
        if AccessKey.address_of(saved_servers[index].url) == address then
            table.remove(saved_servers, index)
        end
    end
    table.insert(saved_servers, 1, { url = url, token = token })
    storage.set("saved_servers", saved_servers)
    publish_saved_servers()
end

-- Campo do token de conexão: dispara a cada tecla/colagem.
function access_key_input(value: string): ()
    ctx.access_key = value
    ctx.error_access_key = ""
    publish_access_key_target()
end

-- `<select>` de servidores salvos: o valor escolhido é o token de conexão.
function choose_saved_server(value: string): ()
    ctx.access_key = value
    ctx.error_access_key = ""
    publish_access_key_target()
end

-- Botão "Esquecer": remove da lista o servidor do token atual e limpa o
-- campo. Casa pelo token de conexão inteiro e, se ele decodificar, também
-- pelo `host:porta` — um par salvo sem token (daemon sem `[api].token`) gera
-- `host:porta::`, que antes não decodificava e por isso nunca era esquecido.
function forget_server(): ()
    local decoded_key = AccessKey.decode(ctx.access_key)
    local address = if decoded_key then decoded_key.address else nil
    for index = #saved_servers, 1, -1 do
        local saved_server = saved_servers[index]
        if AccessKey.encode(saved_server.url, saved_server.token) == ctx.access_key
            or AccessKey.address_of(saved_server.url) == address
        then
            table.remove(saved_servers, index)
        end
    end
    storage.set("saved_servers", saved_servers)
    publish_saved_servers()
    ctx.access_key = ""
    ctx.error_access_key = ""
    publish_access_key_target()
end

-- ── init: semeia o contexto para a UI pintar antes de qualquer dado ─────────
function init(): ()
    if not ctx.screen or ctx.screen == "" then
        ctx.screen = "login"
    end
    if not ctx.view or ctx.view == "" then
        ctx.view = "deployments"
    end
    ctx.connected = ctx.connected or "false"
    ctx.status_line = ctx.status_line or "pronto para conectar"
    ctx.error = ctx.error or ""
    ctx.search = ctx.search or ""
    -- Sidebar-gaveta (<drawer> em shell.gvb): começa aberta; o ☰ da topbar
    -- alterna via `drawer::toggle:menu`.
    ctx.menu = ctx.menu or "true"
    -- Checkboxes do Infra as Code (Settings → aba IaC): semeados aqui pra o
    -- estado ser determinístico e o `do_import` nunca ler `nil`.
    ctx.manifest_prune = ctx.manifest_prune or "false"
    ctx.manifest_deploy = ctx.manifest_deploy or "false"
    ctx.data_loading = "true"
    -- Coleção fixa do <radiogroup> de dia da semana (aba Manutenção). Semeada
    -- aqui, e não no docker_cleanup_apply_config, porque não depende da config carregada:
    -- se o load falhasse, a lista sumiria e o grupo ficaria vazio.
    ctx.weekdays = format.WEEKDAYS_JSON
    -- Itens das <tabbar> de rótulo fixo ({id,label}); a barra grava o id na
    -- chave `:value` sozinha, sem handler.
    ctx.settings_tabs = [=[[{"id":"web","label":"Web Server"},{"id":"git","label":"Git"},{"id":"iac","label":"Infra as Code"},{"id":"maintenance","label":"Manutenção"}]]=]
    ctx.docker_cleanup_kinds = [=[[{"id":"interval","label":"A cada N horas"},{"id":"daily","label":"Todo dia"},{"id":"weekly","label":"Toda semana"}]]=]
    ctx.git_provider_modes = [=[[{"id":"oauth","label":"OAuth2"},{"id":"pat","label":"Token (PAT)"}]]=]
    ctx.healthcheck_kinds = [=[[{"id":"none","label":"None"},{"id":"tcp","label":"Tcp"},{"id":"http","label":"Http"},{"id":"docker","label":"Docker"}]]=]
    -- Listas vazias como "[]" (não nil) para os ForEach não verem literal.
    for _, key in ipairs{
        "deployments",
        "projects",
        "project_rows",
        "services",
        "service_rows",
        "docker_rows",
        "docker_images",
        "docker_volumes",
        "docker_networks",
        "ingress",
        "host_ports",
        "jobs_summary",
        "project_jobs",
        "monitoring",
        "running",
        "deploy_engine_active",
        "deploy_engine_recent",
        "project_services",
    } do
        if not ctx[key] or ctx[key] == "" then
            ctx[key] = "[]"
        end
    end
    -- Contadores nascem "…", não "0": antes do primeiro snapshot não sabemos
    -- quantos são, e "0" AFIRMA vazio — a UI piscava "Projects (0)" → "Projects
    -- (2)", e mensagens como "Nenhum job cadastrado ainda" apareciam durante o
    -- carregamento. O snapshot troca todos por número (apply_snapshot em
    -- handlers/stream.luau, junto de `data_loading = "false"`). Os `equals="0"`
    -- dos templates continuam valendo: com "…" não casam, então o estado vazio
    -- só pinta quando o dado realmente chegou e é zero.
    for _, key in ipairs{
        "deployments_count",
        "projects_count",
        "services_count",
        "ingress_count",
        "host_ports_count",
        "jobs_count",
        "project_env_count",
        "project_jobs_count",
        "project_secrets_count",
        "docker_images_count",
        "docker_volumes_count",
        "docker_networks_count",
        "deploy_engine_active_count",
        "deploy_engine_recent_count",
        "deploy_engine_success_24h",
        "deploy_engine_failed_24h",
        "deploy_engine_total_24h",
        "services_running",
        "services_total",
    } do
        if not ctx[key] or ctx[key] == "" then
            ctx[key] = "…"
        end
    end
    -- Semeia o formulário de login com a lista de servidores salvos, e
    -- pré-preenche o token de conexão do mais usado por último (topo da lista) — para
    -- nascer pronto pra conectar de novo sem escolher nada.
    local stored = storage.get("saved_servers")
    if type(stored) == "table" then
        saved_servers = stored
    end
    publish_saved_servers()
    if #saved_servers > 0 and (not ctx.access_key or ctx.access_key == "") then
        ctx.access_key = AccessKey.encode(saved_servers[1].url, saved_servers[1].token)
    end
    publish_access_key_target()
end

-- Configurações do daemon + provedores Git, buscados uma vez na conexão (não
-- entram no snapshot para não sobrescrever campos que o usuário edita).
local function load_settings(): ()
    local api = State.api
    if not api then return end
    local get_daemon_settings_ok, get_daemon_settings_response = api:rpc("GetDaemonSettings")
    if get_daemon_settings_ok and get_daemon_settings_response.DaemonSettings then
        -- Base pública derivada pelo daemon a partir de [api] domain/port — é
        -- só-leitura (não há setter no protocolo), serve para exibir a base do
        -- webhook e montar a redirect URI do OAuth.
        local base = get_daemon_settings_response.DaemonSettings.public_base_url or ""
        ctx.server_settings_public_base = base
        ctx.server_settings_email = get_daemon_settings_response.DaemonSettings.acme_email or ""
        ctx.server_settings_registry_domain = get_daemon_settings_response.DaemonSettings.registry_domain or ""
        ctx.git_provider_redirect = Helpers.oauth_redirect_uri(base)
    end
    -- O token de conexão deste servidor, para Settings → Web Server → copiar. Montado
    -- aqui (já temos url + token da sessão) em vez de pedida ao daemon: assim
    -- ele é o que FUNCIONOU desta máquina, não o do `public_base_url`.
    ctx.server_access_key = if api.token then AccessKey.encode(api.base_url, api.token) else ""
    -- O comando que liga o Claude Code ao MCP deste servidor, pronto para colar
    -- num terminal: o token já resolvido, sem `curl /api/login` no meio.
    ctx.server_mcp_command = "claude mcp add --transport http --scope user rustploy "
        .. api.base_url .. "/mcp"
        .. (if api.token then ' --header "Authorization: Bearer ' .. api.token .. '"' else "")
    ctx.server_access_key_short = if api.token
        then string.sub(ctx.server_access_key, 1, 12) .. "…" .. string.sub(ctx.server_access_key, -6)
        else "— (daemon sem token)"
    local git_provider_list_ok, git_provider_list_response = api:rpc("GitProviderList")
    if git_provider_list_ok and git_provider_list_response.GitProviders then
        ctx.gitea_count = tostring(#git_provider_list_response.GitProviders)
    end
    Settings.docker_cleanup_load()
end

-- O esquema de um `host:porta`: o token de conexão não o carrega. Sonda
-- `GET /api/version` (pública, sem token) primeiro com o esquema de um servidor
-- já salvo com esse endereço, depois https, depois http — qualquer resposta
-- HTTP, até um 404, prova que o esquema é aquele; erro de transporte (TLS
-- recusado, conexão fechada) passa para o próximo.
local function resolve_base(address: string): (string?, string?)
    local schemes: { string } = {}
    for _, saved_server in ipairs(saved_servers) do
        if AccessKey.address_of(saved_server.url) == address then
            table.insert(schemes, string.lower(string.match(saved_server.url, "^(%a[%w+.-]*)://") or "https"))
            break
        end
    end
    for _, scheme in ipairs({ "https", "http" }) do
        if not table.find(schemes, scheme) then
            table.insert(schemes, scheme)
        end
    end
    local last_error = ""
    for _, scheme in ipairs(schemes) do
        local base = scheme .. "://" .. address
        local http_response = fetch(base .. "/api/version", { method = "GET", timeout = 8000 })
        if http_response.status ~= nil and http_response.status > 0 then
            return base, nil
        end
        last_error = if http_response.error ~= nil and http_response.error ~= "" then http_response.error else "sem resposta"
    end
    return nil, "não deu para falar com " .. address .. " nem por https nem por http (" .. last_error .. ")"
end

-- on_submit/on_click do formulário de login: decodifica o token de conexão
-- (base64 de `host:porta::token`), descobre o esquema e usa o token da API
-- direto como Bearer — sem `/api/login`, o daemon não precisa de nada novo.
-- Valida a sessão com um DaemonStatus antes de abrir o stream. `fetch`
-- suspende a corrotina.
function connect(): ()
    local decoded_key, key_error = AccessKey.decode(ctx.access_key)
    if not decoded_key then
        ctx.error_access_key = key_error or "token de conexão inválido"
        return
    end
    ctx.error_access_key = ""
    ctx.status_line = "conectando…"
    ctx.error = ""

    local resolved_base, resolve_error = resolve_base(decoded_key.address)
    local base = if resolved_base then Helpers.normalize_url(resolved_base) else nil
    if not base then
        ctx.error = resolve_error or ("endereço inválido no token de conexão: " .. decoded_key.address)
        ctx.status_line = "falha na conexão"
        ctx.connected = "false"
        return
    end
    local token = decoded_key.token

    ctx.api_url = base
    ctx.api_token = token
    -- Topbar: a qual servidor esta janela está ligada (host:porta, sem esquema).
    ctx.connected_server = string.match(base, "^%a[%w+.-]*://(.+)$") or base
    local client = Api.new(base, token)
    State.api = client
    local daemon_status_ok, daemon_status_response = client:rpc("DaemonStatus")
    if not daemon_status_ok then
        State.api = nil
        ctx.error = daemon_status_response
        ctx.status_line = "falha na conexão"
        ctx.connected = "false"
        return
    end

    -- Só salva na lista quando a conexão realmente deu certo — uma tentativa
    -- com URL/token errados não deve virar entrada salva.
    remember_server(base, token)
    publish_access_key_target()

    ctx.connected = "true"
    ctx.status_line = "conectado"
    ctx.screen = "shell"
    if not ctx.view or ctx.view == "" then
        ctx.view = "deployments"
    end

    load_settings()
    Stream.open_stream()
end

-- Logout: nada da sessão anterior pode sobreviver em RAM — nem no `ctx` (o
-- espelho do contexto do motor, de onde a UI pinta tudo: nomes de projeto,
-- linhas de log, api_token…) nem no `State` (cache do snapshot/métricas).
--
-- Em vez de enumerar as chaves a limpar — a lista cresce a cada tela nova e
-- sempre esquece alguma — apagamos o `ctx` INTEIRO e deixamos `init()` semear
-- os defaults como no boot. O login lembrado volta do `storage` (disco), não da
-- memória, então conectar de novo continua nascendo preenchido.
--
-- `ctx[k] = nil` é remoção de verdade, não só sumiço do lado Luau: o glacier
-- espelha o contexto na tabela no início da execução e, no fim, remove do motor
-- toda chave ausente nela (sync_to_luau/sync_from_luau).
function disconnect(): ()
    if State.state_conn then
        pcall(function()
            State.state_conn:close()
        end)
        State.state_conn = nil
    end
    State.api = nil
    State.snap = nil
    State.last_pairs = {}
    State.metrics_by_id = {}
    State.jobs_by_id = {}
    State.new_service_templates_all = {}
    State.search_term = ""
    State.deploy_track =
        { service_id = "", deployment_id = "", running = false, name = "" }

    -- Coleta as chaves antes de apagar: mutar a tabela durante o próprio
    -- `pairs` sobre ela é comportamento indefinido.
    local data = ctx :: { [string]: any }
    local keys: { string } = {}
    for key in pairs(data) do
        table.insert(keys, key)
    end
    for _, key in ipairs(keys) do
        data[key] = nil
    end

    init()
    ctx.connected = "false"
    ctx.screen = "login"
    ctx.status_line = "desconectado"
end