@fazer-ai/agents 1.0.0

package/dist/index.js

@@ -0,0 +1,726 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const agents_1 = require("./agents");
+const hermes_skills_1 = require("./agents/hermes-skills");
+const config_1 = require("./config");
+const exec_1 = require("./exec");
+const hostinger_1 = require("./hostinger");
+const hub_command_1 = require("./hub-command");
+const licenses_1 = require("./licenses");
+const onboarding_marker_1 = require("./onboarding-marker");
+const oauth_1 = require("./oauth");
+const preferences_1 = require("./preferences");
+const ui_1 = require("./ui");
+const ui_select_1 = require("./ui-select");
+// NOTE: versão = a do package.json (fonte única). __dirname é dist/ (build) ou src/ (dev); em ambos
+// ../package.json é a raiz do pacote, inclusive instalado via npm (package.json sempre no tarball).
+const { version: CLI_VERSION } = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, "../package.json"), "utf8"));
+function parseArgs(argv) {
+    const out = {
+        help: false,
+        version: false,
+        dryRun: false,
+        yes: false,
+        noHandoff: false,
+        login: false,
+        verbose: false,
+    };
+    const positional = [];
+    let parsingOptions = true;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (parsingOptions && arg === "--") {
+            parsingOptions = false;
+        }
+        else if (parsingOptions && (arg === "--help" || arg === "-h")) {
+            out.help = true;
+        }
+        else if (parsingOptions && (arg === "--version" || arg === "-V")) {
+            out.version = true;
+        }
+        else if (parsingOptions && (arg === "--dry-run" || arg === "--dryrun")) {
+            out.dryRun = true;
+        }
+        else if (parsingOptions && (arg === "--yes" || arg === "-y")) {
+            out.yes = true;
+        }
+        else if (parsingOptions && arg === "--no-handoff") {
+            out.noHandoff = true;
+        }
+        else if (parsingOptions && arg === "--login") {
+            out.login = true;
+        }
+        else if (parsingOptions && (arg === "--verbose" || arg === "-v")) {
+            out.verbose = true;
+        }
+        else if (parsingOptions && arg === "--pro") {
+            out.pro = true;
+        }
+        else if (parsingOptions && arg === "--free") {
+            out.pro = false;
+        }
+        else if (parsingOptions && arg.startsWith("--agent=")) {
+            out.agent = arg.slice("--agent=".length);
+        }
+        else if (parsingOptions && arg === "--agent") {
+            const next = argv[i + 1];
+            if (next === undefined)
+                throw new Error("--agent requer um valor");
+            out.agent = next;
+            i++;
+        }
+        else if (parsingOptions && arg.startsWith("--provider=")) {
+            out.provider = arg.slice("--provider=".length);
+        }
+        else if (parsingOptions && arg === "--provider") {
+            const next = argv[i + 1];
+            if (next === undefined)
+                throw new Error("--provider requer um valor");
+            out.provider = next;
+            i++;
+        }
+        else if (parsingOptions && arg.startsWith("-") && arg !== "-") {
+            throw new Error(`opção desconhecida: ${arg}`);
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    if (positional.length > 0) {
+        throw new Error("argumentos extras inesperados");
+    }
+    return out;
+}
+function printHelp() {
+    process.stderr.write((0, ui_1.banner)());
+    process.stderr.write(`Uso: bunx @fazer-ai/agents@latest [opções]
+       npx  @fazer-ai/agents@latest [opções]
+
+Prepara o seu agente de IA para o onboarding da fazer.ai agents: instala o agente
+se faltar, faz login na fazer.ai, conecta as ferramentas,
+instala o guia de onboarding e abre o agente.
+
+Opções:
+  --agent <id>      Agente: claude, codex, hermes ou other. Sem isto, o CLI pergunta.
+  --provider <id>   Provider de VPS/DNS: hostinger (default) ou other.
+  --login           Força um novo login no browser (ignora a sessão salva).
+  --pro             Edição Pro da fazer.ai agents (requer membership da comunidade).
+  --free            Edição Free da fazer.ai agents (pula a pergunta de edição).
+  --dry-run         Só mostra o que faria, sem executar.
+  -y, --yes         Executa sem confirmação interativa.
+  --no-handoff      Prepara tudo, mas não abre o agente ao final.
+  -v, --verbose     Mostra a saída dos comandos (normalmente silenciada) + diagnósticos.
+  -V, --version     Mostra a versão do CLI.
+  -h, --help        Mostra esta ajuda.
+
+Ambiente:
+  FAZER_AI_HUB_URL             Sobrescreve a base do hub (default: https://app.fazer.ai).
+  FAZER_AI_CLI_THEME           Tema do CLI: light para fundo claro (default: escuro).
+  HOSTINGER_API_TOKEN          Token da API Hostinger (para conectar as ferramentas).
+  AGENTS_OAUTH_CLIENT_ID   client_id OAuth pré-registrado (se o hub não usar DCR).
+
+Por padrão o CLI faz login OAuth no browser e reaproveita a sessão nas próximas
+vezes (cache em ~/.fazer-ai/oauth.json). Use --login pra forçar um login novo.
+
+A última escolha de agente e provider fica salva (~/.fazer-ai/preferences.json) e
+vira o default ("último usado") no próximo run; os flags --agent/--provider têm
+prioridade.
+`);
+}
+// Prévia curta (só dry-run): o que cada etapa faz, em palavras simples. Sem
+// comandos nem detalhes técnicos.
+function renderPreview(adapter, steps) {
+    process.stderr.write(`\n${(0, ui_1.headline)(`O que vou fazer · ${adapter.displayName}`)}\n`);
+    steps.forEach((s, idx) => {
+        process.stderr.write(`  ${ui_1.c.cyan(`${idx + 1}.`)} ${s.title}\n`);
+    });
+}
+async function main() {
+    const rawArgs = process.argv.slice(2);
+    // Proxy do hub (`agents hub <op>`): o agente de onboarding chama as ops do hub por aqui, não pelo
+    // hub MCP. Curto-circuita antes do banner/fluxo de onboarding; usa a sessão OAuth já no oauth.json.
+    if (rawArgs[0] === "hub") {
+        await (0, hub_command_1.runHubCommand)((0, config_1.resolveConfig)(), rawArgs.slice(1), (m) => process.stderr.write(`${m}\n`));
+        return;
+    }
+    const args = parseArgs(rawArgs);
+    if (args.help) {
+        printHelp();
+        return;
+    }
+    if (args.version) {
+        process.stdout.write(`${CLI_VERSION}\n`);
+        return;
+    }
+    // Instaladores nativos (Claude/Hermes) gravam em ~/.local/bin sem pô-lo no PATH
+    // persistente; garante-o na sessão pra detectar o agente (recém-instalado ou de um run
+    // anterior) sem depender de reabrir o terminal.
+    (0, exec_1.ensureUserLocalBinOnPath)();
+    // E persiste ~/.local/bin no User PATH do Windows: a etapa de OAuth do MCP pede pra REABRIR o
+    // agente num terminal NOVO, que só acha o binário se o dir estiver no PATH persistente.
+    await (0, exec_1.persistUserLocalBinToWindowsPath)();
+    // Começa numa tela limpa (só em TTY, respeitando NO_COLOR): tira o ruído do bunx/npx
+    // acima do banner e dá uma primeira impressão limpa.
+    (0, ui_1.clearScreen)();
+    process.stderr.write((0, ui_1.banner)());
+    const config = (0, config_1.resolveConfig)();
+    // Surface os overrides de env load-bearing pra nada apontar pra outro lugar
+    // (hub/marketplace/plugin/client) em silêncio.
+    const overrides = [];
+    if (process.env.FAZER_AI_HUB_URL?.trim())
+        overrides.push(`hub=${config.hubBaseUrl}`);
+    if (process.env.AGENTS_MARKETPLACE_TARGET?.trim())
+        overrides.push(`marketplace=${config.marketplaceAddTarget}`);
+    if (process.env.AGENTS_MARKETPLACE_NAME?.trim())
+        overrides.push(`marketplaceName=${config.marketplaceName}`);
+    if (process.env.AGENTS_PLUGIN?.trim())
+        overrides.push(`plugin=${config.onboardingPlugin}`);
+    if (process.env.AGENTS_OAUTH_CLIENT_ID?.trim())
+        overrides.push("oauthClientId=set");
+    if (overrides.length) {
+        process.stderr.write(`${ui_1.sym.warn} Overrides: ${overrides.join(", ")}.\n`);
+    }
+    // Verbose: diagnósticos de ambiente (versão do CLI, runtime, plataforma, se as skills
+    // vêm empacotadas). O resto do verbose (saída dos comandos silenciados) é passado
+    // adiante em ExecContext.verbose.
+    if (args.verbose) {
+        const runtime = process.versions.bun
+            ? `bun ${process.versions.bun}`
+            : `node ${process.versions.node}`;
+        const bundle = (0, hermes_skills_1.bundledSkillsRoot)() ? "empacotadas" : "não empacotadas (rede)";
+        process.stderr.write(`${(0, ui_1.detail)(`CLI ${CLI_VERSION} · ${runtime} · ${process.platform}/${process.arch} · skills ${bundle}`)}\n`);
+    }
+    let selected = args.agent ? (0, agents_1.getAgent)(args.agent) : undefined;
+    if (args.agent && !selected) {
+        throw new Error(`agente não suportado: ${args.agent} (suportados: ${agents_1.AGENTS.map((a) => a.id).join(", ")})`);
+    }
+    const prefs = (0, preferences_1.loadPreferences)();
+    const detected = await (0, agents_1.detectAgents)();
+    process.stderr.write(`${(0, ui_1.phaseHeader)(1, 4, "Agente")}\n`);
+    if (!selected) {
+        // Sem --agent: menu interativo (TTY) ou auto-pick (sem TTY, ex.: CI/pipe).
+        // O default vem da última seleção salva (se ainda válida).
+        const preferred = prefs.agent
+            ? detected.find((d) => d.adapter.id === prefs.agent)?.adapter
+            : undefined;
+        selected = process.stdin.isTTY
+            ? await selectAgent(detected, prefs.agent)
+            : (preferred ??
+                detected.find((d) => d.result.installed)?.adapter ??
+                detected[0]?.adapter ??
+                agents_1.AGENTS[0]);
+    }
+    if (!selected)
+        throw new Error("nenhum adapter de agente registrado");
+    const adapter = selected;
+    let detection = detected.find((d) => d.adapter.id === adapter.id)?.result ??
+        (await adapter.detect());
+    const installCmd = (0, agents_1.installCommandFor)(adapter.installCommand);
+    // O agente não está instalado, mas o próximo passo o instala (automatizado +
+    // há instalador pra esta plataforma): tom neutro, não um alerta de erro.
+    const willInstall = adapter.automated && !detection.installed && Boolean(installCmd);
+    process.stderr.write(`${(0, ui_1.targetLine)(adapter.displayName, {
+        installed: detection.installed,
+        version: detection.version,
+        hasDetect: adapter.detectCommand !== "",
+        willInstall,
+    })}\n`);
+    // O aviso "fora do PATH" só faz sentido quando NÃO há instalação a seguir
+    // (com willInstall, o passo seguinte resolve, o alerta seria ruído).
+    if (adapter.detectCommand !== "" && !detection.installed && !willInstall) {
+        process.stderr.write(`${(0, ui_1.detail)(`\`${adapter.detectCommand}\` falhou; pode não estar no PATH.`)}\n`);
+    }
+    process.stderr.write(`${(0, ui_1.phaseHeader)(2, 4, "Provedor de infraestrutura")}\n`);
+    const provider = await resolveProvider(args, prefs.provider);
+    process.stderr.write(`${ui_1.sym.ok} Infra: ${provider === "hostinger" ? "Hostinger" : "Outro provider"}.\n`);
+    const ctx = {
+        config,
+        provider,
+        hostingerTokenProvided: Boolean(process.env.HOSTINGER_API_TOKEN),
+    };
+    if (args.dryRun) {
+        if (willInstall && installCmd) {
+            process.stderr.write(`\n${ui_1.sym.info} ${adapter.displayName} não está instalado; será instalado antes:\n`);
+            process.stderr.write(`${(0, ui_1.detail)(installCmd)}\n`);
+        }
+        renderPreview(adapter, adapter.plan(ctx));
+        process.stderr.write(`\n${ui_1.sym.info} ${ui_1.c.dim("nada foi executado (dry-run).")}\n`);
+        if (!ctx.hostingerTokenProvided && provider === "hostinger") {
+            process.stderr.write(`${(0, ui_1.detail)("o CLI vai pedir o token da Hostinger na execução (ou defina HOSTINGER_API_TOKEN antes).")}\n`);
+        }
+        return;
+    }
+    // Run real (passou do dry-run): lembra a escolha de agente + provider para
+    // virar o default no próximo run (qualquer origem: flag, picker, auto-pick).
+    (0, preferences_1.savePreferences)({ agent: adapter.id, provider });
+    // Agente automatizado ausente: instala (com confirmação) e re-detecta.
+    if (adapter.automated && !detection.installed) {
+        detection = await ensureInstalled(adapter, detection, args.yes);
+    }
+    // Auth / momentary-login: agentes com fluxo de login no CLI (Codex/Hermes). O Claude
+    // não entra aqui (sem adapter.login): autentica no próprio TUI ao abrir o handoff, e
+    // um pre-login duplicaria o sign-in.
+    if (detection.installed && adapter.login) {
+        await ensureLoggedIn(adapter);
+    }
+    // Adapter manual (só "other"): execute() apenas imprime o plano + o prompt, não
+    // muta a máquina. Hermes/Claude/Codex são automatizados (seguem abaixo).
+    if (!adapter.automated) {
+        await adapter.execute({
+            config,
+            provider,
+            hostingerToken: process.env.HOSTINGER_API_TOKEN,
+            hostingerTokenProvided: Boolean(process.env.HOSTINGER_API_TOKEN),
+            handoff: !args.noHandoff,
+            verbose: args.verbose,
+            log: (message) => process.stderr.write(`${message}\n`),
+        });
+        return;
+    }
+    // O onboarding lista as licenças reais do hub (login OAuth no browser) e abre o
+    // agente; precisa de um terminal interativo.
+    if (!process.stdin.isTTY) {
+        throw new Error("o onboarding precisa de um terminal interativo para o login na fazer.ai.");
+    }
+    process.stderr.write(`${(0, ui_1.phaseHeader)(3, 4, "Chatwoot")}\n`);
+    // Chatwoot: subir um novo ou plugar num já existente. O login OAuth (list_licenses do
+    // hub) acontece aqui de todo jeito: mesmo no "existing", as licenças alimentam o gate da
+    // edição do fazer.ai agents (community access); o --login força uma sessão nova.
+    const chatwootSource = await selectChatwootSource(prefs);
+    let choice;
+    let licenses;
+    if (chatwootSource === "new") {
+        ({ choice, licenses } = await selectChatwootTier(config, prefs, args.login));
+    }
+    else {
+        // Chatwoot existente: sem seleção de licença; só lista as licenças pro gate da edição.
+        const log = (message) => process.stderr.write(`${message}\n`);
+        try {
+            licenses = await (0, oauth_1.listHubLicenses)(config, { log, forceLogin: args.login });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            log(`${ui_1.sym.warn} Não consegui listar as licenças do hub (${msg}).`);
+            licenses = [];
+        }
+        choice = { chatwootSource: "existing" };
+    }
+    const edition = await selectEdition(licenses, args);
+    const marker = { ...choice, edition };
+    (0, onboarding_marker_1.saveOnboardingMarker)(marker);
+    (0, preferences_1.savePreferences)({ chatwootSource });
+    if (choice.chatwootTier === "pro" && choice.chatwootLicenseId) {
+        (0, preferences_1.savePreferences)({ chatwootLicenseId: choice.chatwootLicenseId });
+    }
+    process.stderr.write(`${ui_1.sym.ok} Chatwoot: ${choice.chatwootSource === "existing"
+        ? "existente (conecta ao seu)"
+        : choice.chatwootTier === "pro"
+            ? `Pro (Kanban), licença ${choice.chatwootLicenseId}`
+            : "OSS (sem Kanban)"}.\n`);
+    process.stderr.write(`${ui_1.sym.ok} fazer.ai agents: ${edition === "pro" ? "Pro (multi-tenant)" : "Free (1 tenant)"}.\n`);
+    // Hostinger precisa do token pra conectar os MCPs; captura se faltar.
+    if (provider === "hostinger")
+        await resolveHostingerToken();
+    process.stderr.write(`${(0, ui_1.phaseHeader)(4, 4, "Configurar o agente")}\n`);
+    await adapter.execute({
+        config,
+        provider,
+        hostingerToken: process.env.HOSTINGER_API_TOKEN,
+        hostingerTokenProvided: Boolean(process.env.HOSTINGER_API_TOKEN),
+        handoff: !args.noHandoff,
+        verbose: args.verbose,
+        log: (message) => process.stderr.write(`${message}\n`),
+    });
+    process.stderr.write(`\n${ui_1.sym.ok} ${ui_1.c.bold("Pronto.")}\n`);
+}
+// Lê um segredo do TTY sem ecoar (mostra `*`). Raw mode, sem dependências.
+function askSecret(question) {
+    if (!process.stdin.isTTY)
+        return Promise.resolve("");
+    process.stderr.write(question);
+    const stdin = process.stdin;
+    return new Promise((resolve) => {
+        let buf = "";
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.setEncoding("utf8");
+        const onData = (chunk) => {
+            for (const ch of chunk) {
+                if (ch === "\r" || ch === "\n" || ch === "\u0004") {
+                    stdin.setRawMode(false);
+                    stdin.pause();
+                    stdin.removeListener("data", onData);
+                    process.stderr.write("\n");
+                    resolve(buf);
+                    return;
+                }
+                if (ch === "\u0003") {
+                    stdin.setRawMode(false);
+                    process.stderr.write("\n");
+                    process.exit(130);
+                }
+                if (ch === "\u007f" || ch === "\b") {
+                    if (buf.length > 0) {
+                        buf = buf.slice(0, -1);
+                        process.stderr.write("\b \b");
+                    }
+                    continue;
+                }
+                buf += ch;
+                process.stderr.write("*");
+            }
+        };
+        stdin.on("data", onData);
+    });
+}
+// Garante o token da Hostinger no ambiente (env → cache → prompt mascarado).
+// Setá-lo em process.env faz o env-ref ${HOSTINGER_API_TOKEN} resolver no
+// handoff sem virar literal em argv. Sem token, os MCPs da Hostinger são pulados.
+async function resolveHostingerToken() {
+    // Env explícito: usa; valida só pra avisar (a escolha do usuário tem precedência).
+    const envToken = process.env.HOSTINGER_API_TOKEN?.trim();
+    if (envToken) {
+        if ((await (0, hostinger_1.validateHostingerToken)(envToken)) === false) {
+            process.stderr.write(`${ui_1.sym.warn} O HOSTINGER_API_TOKEN definido foi recusado pela Hostinger (401). Vou usá-lo mesmo assim; se as ferramentas falharem, gere um novo.\n`);
+        }
+        return;
+    }
+    // Cache: reusa só se ainda válido (pode ter expirado/sido revogado entre sessões).
+    const cached = (0, hostinger_1.loadHostingerToken)();
+    if (cached) {
+        const ok = await (0, hostinger_1.validateHostingerToken)(cached);
+        if (ok === true) {
+            process.env.HOSTINGER_API_TOKEN = cached;
+            process.stderr.write(`${ui_1.sym.ok} Token da Hostinger reaproveitado (~/.fazer-ai/hostinger.json).\n`);
+            return;
+        }
+        if (ok === "error") {
+            // Não deu pra validar (sem conexão): usa o cache mesmo (best-effort).
+            process.env.HOSTINGER_API_TOKEN = cached;
+            process.stderr.write(`${ui_1.sym.ok} Token da Hostinger reaproveitado (não validado: sem conexão com a API).\n`);
+            return;
+        }
+        // ok === false: o token salvo morreu; cai no prompt por um novo.
+        process.stderr.write(`${ui_1.sym.warn} O token salvo expirou ou foi revogado; vou pedir um novo.\n`);
+    }
+    if (!process.stdin.isTTY)
+        return;
+    process.stderr.write(`\n${(0, ui_1.headline)("Token da API Hostinger")}\n`);
+    const hpanelApiUrl = "https://hpanel.hostinger.com/api";
+    process.stderr.write(`${(0, ui_1.detail)(`Abrindo o hPanel em ${hpanelApiUrl} pra gerar a chave (ou acesse o link manualmente). Enter em branco pula as ferramentas de infra.`)}\n`);
+    (0, oauth_1.openBrowser)(hpanelApiUrl);
+    // Loop: pede, valida e repete enquanto a Hostinger recusar (401).
+    for (;;) {
+        const token = (await askSecret(`${ui_1.sym.info} Cole o token: `)).trim();
+        if (!token) {
+            process.stderr.write(`${ui_1.sym.warn} Sem token; vou pular as ferramentas da Hostinger. Defina HOSTINGER_API_TOKEN e rode de novo pra conectá-las.\n`);
+            return;
+        }
+        const ok = await (0, hostinger_1.validateHostingerToken)(token);
+        if (ok === false) {
+            process.stderr.write(`${ui_1.sym.err} Token recusado pela Hostinger (401). Confira ou gere outro em ${hpanelApiUrl} e cole de novo.\n`);
+            continue;
+        }
+        process.env.HOSTINGER_API_TOKEN = token;
+        (0, hostinger_1.saveHostingerToken)(token);
+        process.stderr.write(ok === true
+            ? `${ui_1.sym.ok} Token validado e salvo em ~/.fazer-ai/hostinger.json (0600).\n`
+            : `${ui_1.sym.ok} Token salvo em ~/.fazer-ai/hostinger.json (0600). Não consegui validar agora (sem conexão); se as ferramentas falharem, gere um novo.\n`);
+        return;
+    }
+}
+// Agente recomendado no picker (o Instalador fazer.ai / Hermes): é o mais integrado
+// à jornada e o que abre já no onboarding. Carrega o selo "recomendado" e é o default
+// quando não há uma última escolha salva.
+const RECOMMENDED_AGENT_ID = "hermes";
+// Sem --agent (e com TTY): menu para o usuário escolher o agente, com status de detecção
+// e um selo "recomendado" no Instalador fazer.ai. Enter usa o padrão: a última escolha
+// salva (se ainda válida), senão o recomendado.
+async function selectAgent(detected, prefAgentId) {
+    const fallback = detected[0]?.adapter ?? agents_1.AGENTS[0];
+    if (!fallback)
+        throw new Error("nenhum adapter de agente registrado");
+    // Default: última seleção salva (se ainda válida) → senão o recomendado → senão o
+    // primeiro instalado → senão o primeiro da lista.
+    const preferred = prefAgentId
+        ? detected.find((d) => d.adapter.id === prefAgentId)?.adapter
+        : undefined;
+    const recommended = detected.find((d) => d.adapter.id === RECOMMENDED_AGENT_ID)?.adapter;
+    const def = preferred ??
+        recommended ??
+        detected.find((d) => d.result.installed)?.adapter ??
+        fallback;
+    const defIdx = Math.max(0, detected.findIndex((d) => d.adapter === def));
+    const options = detected.map((d, i) => {
+        let status = "";
+        if (d.adapter.detectCommand !== "") {
+            status = d.result.installed
+                ? ui_1.c.green(d.result.version ?? "instalado")
+                : ui_1.c.gray("não instalado");
+        }
+        const badge = d.adapter.id === RECOMMENDED_AGENT_ID ? ui_1.c.cyan("recomendado") : "";
+        const tag = i === defIdx ? ui_1.c.gray(preferred ? "(último usado)" : "(padrão)") : "";
+        const hint = [badge, status, tag].filter(Boolean).join(" ");
+        return { value: d.adapter, label: d.adapter.displayName, hint };
+    });
+    return (0, ui_select_1.select)({
+        title: "Qual agente você prefere usar? Recomendamos o Instalador fazer.ai.",
+        options,
+        defaultIndex: defIdx,
+    });
+}
+// Provider de infra: do flag/env, senão um picker (TTY), senão o default.
+// O default vem da última seleção salva (se válida), senão hostinger.
+async function resolveProvider(args, prefProvider) {
+    const explicit = args.provider ?? process.env.AGENTS_PROVIDER;
+    if (explicit)
+        return (0, config_1.asProvider)(explicit);
+    const fromPref = prefProvider === "hostinger" || prefProvider === "other";
+    const def = prefProvider === "other" ? "other" : "hostinger";
+    if (!process.stdin.isTTY)
+        return def;
+    return selectProvider(def, fromPref);
+}
+// Sem --provider (e com TTY): pergunta onde está a infra. Enter = default.
+async function selectProvider(def = "hostinger", fromPref = false) {
+    const choices = [
+        {
+            id: "hostinger",
+            label: "Hostinger: DNS, VPS e domínio automatizados",
+            extra: ui_1.c.cyan("recomendado"),
+        },
+        { id: "other", label: "Outro provider" },
+    ];
+    const defIdx = Math.max(0, choices.findIndex((o) => o.id === def));
+    const options = choices.map((o, i) => {
+        const tag = i === defIdx ? ui_1.c.gray(fromPref ? "(último usado)" : "(padrão)") : "";
+        return {
+            value: o.id,
+            label: o.label,
+            hint: [o.extra ?? "", tag].filter(Boolean).join(" "),
+        };
+    });
+    // Dica pra quem ainda não tem infra: a Hostinger é a rota automatizada.
+    process.stderr.write(`${(0, ui_1.detail)("Não tem VPS ainda? Recomendamos a Hostinger: o CLI provisiona DNS/VPS/domínio por você.")}\n`);
+    return (0, ui_select_1.select)({
+        title: "Onde está a sua infraestrutura (VPS/DNS)?",
+        options,
+        defaultIndex: defIdx,
+    });
+}
+// Chatwoot: subir um novo (cai na seleção de licença/tier) ou usar um já existente
+// (BYO: o fazer.ai agents só pluga, sem provisionar Chatwoot nem escolher licença). Enter usa o
+// default: a última escolha salva (se houver), senão "new". Só com TTY (o fluxo já garante).
+async function selectChatwootSource(prefs) {
+    const fromPref = prefs.chatwootSource === "new" || prefs.chatwootSource === "existing";
+    const def = prefs.chatwootSource === "existing" ? "existing" : "new";
+    const choices = [
+        {
+            id: "new",
+            label: "Subir um Chatwoot novo",
+            hint: "escolhe a edição/licença a seguir",
+        },
+        {
+            id: "existing",
+            label: "Usar um Chatwoot que já existe",
+            hint: "conecta o fazer.ai agents ao seu Chatwoot já existente",
+        },
+    ];
+    const defIdx = Math.max(0, choices.findIndex((o) => o.id === def));
+    const options = choices.map((o, i) => {
+        const tag = i === defIdx ? ui_1.c.gray(fromPref ? "(último usado)" : "(padrão)") : "";
+        return { value: o.id, label: o.label, hint: [o.hint, tag].filter(Boolean).join(" ") };
+    });
+    return (0, ui_select_1.select)({
+        title: "Chatwoot: subir um novo ou usar um já existente?",
+        options,
+        defaultIndex: defIdx,
+    });
+}
+// Seleção da edição do Chatwoot via licença do Kanban (Chatwoot Pro). Lista as
+// licenças reais do hub (list_licenses), com copy ciente do estado: licença livre
+// → Pro; licença atribuída → alerta pra desvincular no hub + recarrega; sem
+// nenhuma disponível → "Adquirir" (carrinho) ou "Seguir sem"; lista vazia →
+// "Atualizar" ou "Ainda não tenho licença" (porta da comunidade do Lucas
+// Moreira). Roda só com TTY + sessão do hub. Devolve a escolha + as licenças do
+// último snapshot (reusadas pra decidir a edição do fazer.ai agents, sem re-listar).
+async function selectChatwootTier(config, prefs, forceLogin) {
+    const log = (message) => process.stderr.write(`${message}\n`);
+    const app = config.hubBaseUrl;
+    // O --login força um login novo só na 1ª listagem; os refreshes reusam a sessão.
+    let force = forceLogin;
+    for (;;) {
+        let licenses = [];
+        try {
+            licenses = await (0, oauth_1.listHubLicenses)(config, { log, forceLogin: force });
+            force = false;
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            log(`${ui_1.sym.warn} Não consegui listar as licenças do hub (${msg}).`);
+        }
+        const kanban = (0, licenses_1.kanbanLicenses)(licenses);
+        const { options, defaultIndex, state } = (0, licenses_1.buildLicenseMenu)(kanban, prefs.chatwootLicenseId);
+        const title = state === "empty"
+            ? "Licença do Kanban: nenhuma licença encontrada"
+            : "Licença do Kanban (Chatwoot Pro)";
+        const choice = (0, licenses_1.parseLicenseChoice)(await (0, ui_select_1.select)({ title, options, defaultIndex }));
+        if (choice.kind === "available") {
+            return {
+                choice: {
+                    chatwootSource: "new",
+                    chatwootTier: "pro",
+                    chatwootLicenseId: choice.id,
+                },
+                licenses,
+            };
+        }
+        // Licença já atribuída: alerta pra desvincular no hub; o "OK" recarrega.
+        if (choice.kind === "attached") {
+            process.stderr.write(`\n${ui_1.sym.warn} Essa licença já está atribuída a uma instância. Desvincule-a em ${app} (a instância → desvincular licença).\n`);
+            (0, oauth_1.openBrowser)(app);
+            await (0, ui_select_1.acknowledge)("Pressione Enter para atualizar a lista.");
+            continue;
+        }
+        if (choice.action === "refresh")
+            continue;
+        // Adquirir: abre o carrinho do hub; o "OK" recarrega (a nova licença aparece).
+        if (choice.action === "acquire") {
+            const cart = `${app}?cart=1`;
+            process.stderr.write(`\n${(0, ui_1.detail)(`Abrindo o carrinho em ${cart} (ou acesse o link manualmente).`)}\n`);
+            (0, oauth_1.openBrowser)(cart);
+            await (0, ui_select_1.acknowledge)("Pressione Enter para atualizar a lista.");
+            continue;
+        }
+        // "Ainda não tenho licença" (só no estado vazio): oferta da comunidade.
+        if (choice.action === "community") {
+            process.stderr.write(`\n${(0, ui_1.headline)("Licença grátis do Kanban pela comunidade")}\n`);
+            process.stderr.write(`${(0, ui_1.detail)("Vire membro Pro da comunidade do Lucas Moreira (lucasmoreira.ai): licença grátis do Kanban (1 conta no plano mensal, ou 2 ilimitadas no anual).")}\n`);
+            process.stderr.write(`${(0, ui_1.detail)("Abrindo lucasmoreira.ai no navegador (ou acesse o link manualmente).")}\n`);
+            (0, oauth_1.openBrowser)("https://lucasmoreira.ai");
+            const next = await (0, ui_select_1.select)({
+                title: "E agora?",
+                options: [
+                    { value: "member", label: "Já me tornei membro (recarregar licenças)" },
+                    { value: "skip", label: "Seguir sem o Chatwoot Pro (OSS, sem Kanban)" },
+                ],
+            });
+            if (next === "member")
+                continue;
+            return {
+                choice: { chatwootSource: "new", chatwootTier: "community" },
+                licenses,
+            };
+        }
+        // "Seguir sem o Chatwoot Pro" (action === "skip").
+        return {
+            choice: { chatwootSource: "new", chatwootTier: "community" },
+            licenses,
+        };
+    }
+}
+// Seleção da edição da fazer.ai agents (app), reusando as licenças já listadas no
+// passo do Chatwoot (sem re-listar). `--pro` força Pro (erra se a conta não tem
+// acesso e não há como perguntar); `--free` força Free; sem flag, pergunta sempre
+// (upsell). Acesso Pro = membership da comunidade (hasCommunityAccess); sem ela, o
+// projeto `agents` no Harbor não abre, então segue Free com instrução.
+async function selectEdition(licenses, args) {
+    const access = (0, licenses_1.hasCommunityAccess)(licenses);
+    // --pro explícito.
+    if (args.pro === true) {
+        if (access)
+            return "pro";
+        if (args.yes || !process.stdin.isTTY) {
+            throw new Error("você pediu --pro, mas a sua conta não tem acesso à fazer.ai agents Pro (requer membership da comunidade do Lucas Moreira, lucasmoreira.ai). Rode sem --pro para a edição Free.");
+        }
+        process.stderr.write(`\n${ui_1.sym.warn} A sua conta não tem acesso à fazer.ai agents Pro (requer membership da comunidade do Lucas Moreira).\n`);
+        if (!(await (0, ui_select_1.confirm)("Seguir com a edição Free?", true))) {
+            throw new Error("onboarding cancelado. Torne-se membro em lucasmoreira.ai e rode de novo com --pro.");
+        }
+        return "free";
+    }
+    // --free explícito, ou não-interativo (-y/sem TTY): Free direto, sem upsell.
+    if (args.pro === false || args.yes || !process.stdin.isTTY)
+        return "free";
+    // Sem flag, interativo: pergunta sempre (upsell).
+    process.stderr.write(`\n${(0, ui_1.detail)("Edição da fazer.ai agents: Free (1 tenant, imagem pública) ou Pro (multi-tenant, imagem privada; requer membership da comunidade do Lucas Moreira).")}\n`);
+    if (!(await (0, ui_select_1.confirm)("Instalar a edição Pro da fazer.ai agents?", false))) {
+        return "free";
+    }
+    if (access)
+        return "pro";
+    // Quer Pro, mas sem acesso: instrui a comunidade e segue Free.
+    process.stderr.write(`\n${(0, ui_1.headline)("fazer.ai agents Pro pela comunidade")}\n`);
+    process.stderr.write(`${(0, ui_1.detail)("A edição Pro requer membership da comunidade do Lucas Moreira (lucasmoreira.ai). Abrindo o site (ou acesse o link manualmente). Sigo com a Free por ora; rode de novo com --pro depois de virar membro.")}\n`);
+    (0, oauth_1.openBrowser)("https://lucasmoreira.ai");
+    return "free";
+}
+// Agente automatizado ausente: roda o instalador oficial e re-detecta. Não pergunta
+// "posso instalar?" (o usuário já escolheu este agente); só anuncia o que vai rodar.
+// Sem installCommand, ou ainda fora do PATH → erro claro. Sem TTY ainda exige --yes:
+// baixar+executar um script remoto sem interação numa automação seria surpreendente.
+async function ensureInstalled(adapter, detection, assumeYes) {
+    if (detection.installed)
+        return detection;
+    const installCmd = (0, agents_1.installCommandFor)(adapter.installCommand);
+    if (!installCmd) {
+        throw new Error(`${adapter.displayName} não está instalado e não há instalador conhecido para esta plataforma. Instale-o e rode de novo.`);
+    }
+    if (!assumeYes && !process.stdin.isTTY) {
+        throw new Error(`${adapter.displayName} não está instalado. Use um terminal interativo, passe --yes, ou instale você: ${installCmd}.`);
+    }
+    process.stderr.write(`\n${ui_1.sym.info} Instalando o ${adapter.displayName} (não está instalado):\n`);
+    process.stderr.write(`${(0, ui_1.detail)(installCmd)}\n`);
+    await (0, exec_1.runShell)(installCmd);
+    // Windows: o instalador grava o binário no User PATH persistente, mas esta
+    // sessão herdou o PATH antigo. Relê o PATH do registro pra detectar e usar o
+    // binário recém-instalado sem precisar reabrir o terminal.
+    await (0, exec_1.refreshWindowsPath)();
+    const recheck = await adapter.detect();
+    if (!recheck.installed) {
+        throw new Error(`instalei o ${adapter.displayName}, mas ele não aparece no PATH desta sessão. Adicione a pasta do binário ao seu PATH de usuário e rode o comando de novo.`);
+    }
+    process.stderr.write(`${ui_1.sym.ok} ${adapter.displayName} instalado${recheck.version ? ` (${recheck.version})` : ""}.\n`);
+    return recheck;
+}
+// Garante (best-effort) que o agente está logado. Claude detecta via auth status
+// e abre o login se faltar; Codex/Hermes não têm status confiável, então o fluxo
+// OFERECE o login. Sem TTY, só avisa (o agente pede login no uso).
+async function ensureLoggedIn(adapter) {
+    if (!adapter.login)
+        return;
+    const configured = adapter.configured ? await adapter.configured() : undefined;
+    if (configured === true)
+        return;
+    if (!process.stdin.isTTY) {
+        process.stderr.write(`${ui_1.sym.warn} sem terminal interativo para o login do ${adapter.displayName}; ele vai pedir no uso.\n`);
+        return;
+    }
+    if (configured === false) {
+        process.stderr.write(`\n${ui_1.sym.info} ${adapter.displayName} sem login. Abrindo o login (conclua e volte)...\n`);
+        await adapter.login();
+        const recheck = adapter.configured ? await adapter.configured() : undefined;
+        if (recheck === false) {
+            process.stderr.write(`${ui_1.sym.warn} ${adapter.displayName} segue sem login; ele vai pedir no uso.\n`);
+        }
+    }
+    else {
+        // configured indeterminado (Codex/Hermes): oferece o login.
+        const yes = await (0, ui_select_1.confirm)(`Não consegui verificar o login do ${adapter.displayName}. Fazer login agora?`);
+        if (yes)
+            await adapter.login();
+    }
+}
+// NOTE: Só executa quando rodado como binário (não no import dos testes, que
+// usam parseArgs/renderPlan diretamente).
+if (require.main === module) {
+    main().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${ui_1.sym.err} ${message}\n`);
+        process.exit(1);
+    });
+}