@fazer-ai/agents 1.0.0

package/dist/agents/hermes.js

@@ -0,0 +1,474 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hermesAdapter = exports.FAZER_SOUL_MD = exports.FAZER_SKIN_YAML = exports.HERMES_PROFILE = void 0;
+exports.hermesProfileDir = hermesProfileDir;
+exports.hermesSkinsDir = hermesSkinsDir;
+exports.hermesMcpAddCommand = hermesMcpAddCommand;
+exports.hermesMcpAddArgs = hermesMcpAddArgs;
+exports.hermesLoggedIn = hermesLoggedIn;
+exports.hermesProfileExists = hermesProfileExists;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const exec_1 = require("../exec");
+const mcp_1 = require("../mcp");
+const ui_1 = require("../ui");
+const detect_1 = require("./detect");
+const handoff_1 = require("./handoff");
+const hermes_skills_1 = require("./hermes-skills");
+const shell_1 = require("./shell");
+// Total de macro-passos do setup do Hermes (barra de progresso).
+const HERMES_STEPS = 5;
+// Handoff sem prompts de aprovação por-ação: `--yolo` (bypass dos prompts de comando
+// "perigoso"). O onboarding é um fluxo DevOps guiado (ssh/docker/psql via a skill) em que
+// aprovar cada comando trava a jornada; abrimos direto no modo auto-approve. NÃO usamos
+// `--ignore-rules` (ele pularia a injeção do SOUL.md, que carrega o branding do Instalador).
+const HERMES_YOLO_FLAGS = ["--yolo"];
+// Profile dedicado do Hermes onde o onboarding roda, isolado do profile default do
+// usuário. Validado por checksum: criar/mutar `fazer-ai` NÃO toca config/tools/skills/
+// .env/auth do default. Tudo abaixo é escopado por `-p fazer-ai`; o `profile create`
+// ainda cria o alias `~/.local/bin/fazer-ai` (o usuário reabre com `fazer-ai chat`).
+exports.HERMES_PROFILE = "fazer-ai";
+// Branding exibido no banner do profile (`branding.agent_name`). "Instalador fazer.ai" é o
+// agente que CONDUZ o onboarding; a fazer.ai agents é o que ele constrói.
+const AGENT_NAME = "Instalador fazer.ai";
+// O branding "de verdade" do Hermes é uma SKIN (não só `config set branding.agent_name`).
+// O TUI (Ink) renderiza o logo via `parseRichMarkup` (ui-tui/src/banner.ts): cada linha tem que
+// ABRIR e FECHAR o markup `[#hex]...[/]` NA MESMA LINHA (ele dá split por \n antes), senão a tag
+// vaza como texto literal. Logo em ANSI Shadow (a fonte do próprio Hermes), com gradiente laranja
+// por linha. `banner_hero` é OMITIDO de propósito → cai no caduceu original do Hermes, colorido
+// pelo tema. `agent_name` vira `t.brand.name` (theme.ts:577) → o rodapé "Hermes Agent v…" vira
+// "Agente fazer.ai v…". O ícone ⚕ e a tagline "Nous Research · Messenger of the Digital Gods" são
+// HARDCODED no source do TUI (theme.ts:578, branding.tsx:47), não dá pra sobrescrever via skin.
+// Escrevemos o arquivo no skins dir do profile e ativamos via `config set display.skin`. Hermes 0.17.
+const SKIN_NAME = "fazer-ai";
+// Exportado só pra regressão de branding (nome do Instalador, sem em dash).
+exports.FAZER_SKIN_YAML = `name: fazer-ai
+description: "Tema fazer.ai · Instalador de onboarding"
+
+branding:
+  agent_name: "Instalador fazer.ai"
+  prompt_symbol: "❯"
+  welcome: "Instalador fazer.ai: pronto pro onboarding."
+  goodbye: "Até logo, fazer.ai"
+  help_header: "Comandos · fazer.ai"
+  response_label: " ✦ fazer.ai "
+
+banner_logo: |-
+  [#FFC078]███████╗ █████╗ ███████╗███████╗██████╗     █████╗ ██╗[/]
+  [#FFA94D]██╔════╝██╔══██╗╚══███╔╝██╔════╝██╔══██╗   ██╔══██╗██║[/]
+  [#FF922B]█████╗  ███████║  ███╔╝ █████╗  ██████╔╝   ███████║██║[/]
+  [#FD7E14]██╔══╝  ██╔══██║ ███╔╝  ██╔══╝  ██╔══██╗   ██╔══██║██║[/]
+  [#F76707]██║     ██║  ██║███████╗███████╗██║  ██║██╗██║  ██║██║[/]
+  [#E8590C]╚═╝     ╚═╝  ╚═╝╚══════╝╚══════╝╚═╝  ╚═╝╚═╝╚═╝  ╚═╝╚═╝[/]
+
+colors:
+  banner_border: "#FF6A00"
+  banner_title: "#FF9A3C"
+  banner_accent: "#FF6A00"
+  banner_dim: "#C2740F"
+  banner_text: "#F5F5F5"
+  ui_accent: "#FF6A00"
+  ui_label: "#FF9A3C"
+  ui_ok: "#5CB85C"
+  ui_warn: "#E0A030"
+  ui_error: "#E0533C"
+  prompt: "#FF6A00"
+  session_label: "#C2740F"
+  session_border: "#C2740F"
+`;
+// Raiz de um profile do Hermes. Resolve a raiz do Hermes via HERMES_HOME quando
+// definido (o instalador Windows o seta como %LOCALAPPDATA%\hermes), senão ~/.hermes
+// (default Linux/macOS). Espelha a resolução do próprio Hermes: sem isto os arquivos
+// iriam pra ~/.hermes no Windows e o agente (que lê de HERMES_HOME) não os acharia.
+// Pura (testável).
+function hermesProfileDir(profile, env = process.env, home = (0, node_os_1.homedir)()) {
+    const root = env.HERMES_HOME?.trim() || (0, node_path_1.join)(home, ".hermes");
+    return (0, node_path_1.join)(root, "profiles", profile);
+}
+// Diretório de skins do profile.
+function hermesSkinsDir(profile, env = process.env, home = (0, node_os_1.homedir)()) {
+    return (0, node_path_1.join)(hermesProfileDir(profile, env, home), "skins");
+}
+// Identidade do agente (SOUL.md). O Hermes injeta o `SOUL.md` da raiz do profile no
+// system prompt (get_hermes_home()/SOUL.md); o default nasce "You are Hermes Agent,
+// created by Nous Research", o que causava o flash HERMES→fazer.ai ao abrir. Escrevemos
+// a identidade do Instalador fazer.ai por cima pra ele nascer como o instalador, sem
+// menção a Hermes/Nous.
+exports.FAZER_SOUL_MD = `Você é o Instalador fazer.ai, o assistente que conduz o onboarding da fazer.ai agents (a plataforma de agentes de atendimento) no computador do usuário. Você provisiona infraestrutura, faz o deploy do Chatwoot, da fazer.ai agents e do Langfuse, e configura o agente de atendimento, seguindo a skill de onboarding. Seja claro, direto e prático; assuma incerteza quando for o caso e priorize ser genuinamente útil. Comunique cada passo em português do Brasil.`;
+// Escreve a skin no skins dir do profile (best-effort: falha não bloqueia o onboarding).
+function writeFazerSkin() {
+    const skinsDir = hermesSkinsDir(exports.HERMES_PROFILE);
+    (0, node_fs_1.mkdirSync)(skinsDir, { recursive: true });
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(skinsDir, `${SKIN_NAME}.yaml`), exports.FAZER_SKIN_YAML, "utf8");
+}
+// Escreve a identidade do Instalador fazer.ai no SOUL.md da raiz do profile
+// (best-effort). Mata o flash HERMES→fazer.ai: sem isto o agente abre se
+// apresentando como "Hermes Agent, by Nous Research".
+function writeFazerSoul() {
+    const dir = hermesProfileDir(exports.HERMES_PROFILE);
+    (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dir, "SOUL.md"), `${exports.FAZER_SOUL_MD}\n`, "utf8");
+}
+// Instala as skills OFFLINE a partir do bundle empacotado no CLI (caminho primário: sem
+// rede, sem rate-limit do GitHub anônimo). Escreve os arquivos no profile + a entrada no
+// lock.json com o content_hash correto. Devolve true se instalou pelo bundle; false se o
+// bundle não está disponível (o chamador cai no fallback de rede). Uma skill que falhe não
+// derruba as outras. `verbose` mostra o content_hash por skill.
+function installSkillsOffline(ctx, bundleRoot) {
+    const { config, log } = ctx;
+    let ok = 0;
+    for (const ref of config.hermesSkillRefs) {
+        const skill = (0, hermes_skills_1.skillNameFromRef)(ref);
+        try {
+            const result = (0, hermes_skills_1.installBundledSkill)({
+                profileDir: hermesProfileDir(exports.HERMES_PROFILE),
+                bundledSkillDir: (0, node_path_1.join)(bundleRoot, skill),
+                skill,
+                tapRepo: config.hermesTapRepo,
+            });
+            ok++;
+            if (ctx.verbose) {
+                log(`     ${ui_1.sym.bar} ${skill}: ${result.files} arquivo(s), ${result.contentHash}`);
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            log(`${ui_1.sym.warn} Não consegui instalar a skill "${skill}" do pacote (${msg}); ela pode faltar no agente.`);
+        }
+    }
+    return ok > 0;
+}
+// Fallback de rede: registra o tap (GitHub) e instala as skills rastreadas via o CLI do
+// Hermes. Só entra quando o bundle offline não está disponível. É este caminho que bate no
+// skills.sh/GitHub anônimo (rate-limit 60/h), por isso é secundário.
+async function installSkillsFromNetwork(ctx) {
+    const { config, log } = ctx;
+    try {
+        await (0, exec_1.run)("hermes", withProfile(["skills", "tap", "add", config.hermesTapRepo]), { quiet: !ctx.verbose });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        log(`${ui_1.sym.warn} Não consegui registrar o tap "${config.hermesTapRepo}" (${msg}); as skills podem não instalar.`);
+    }
+    for (const ref of config.hermesSkillRefs) {
+        try {
+            await (0, exec_1.run)("hermes", withProfile(["skills", "install", ref, "--yes", "--force"]), { quiet: !ctx.verbose });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            log(`${ui_1.sym.warn} Não consegui instalar a skill "${ref}" (${msg}); rode \`hermes -p ${exports.HERMES_PROFILE} skills install ${ref} --yes --force\` manualmente.`);
+        }
+    }
+}
+// O Hermes liga ~16 toolsets embutidos por padrão; o onboarding precisa só de
+// terminal/file/code_execution (SSH + docker + editar config) e skills (roda a própria
+// skill). Os MCP (Hostinger/hub) são gerenciados à parte e seguem ligados. Desligamos o
+// resto no profile pra cortar contexto/custo/superfície. `tools disable` é idempotente.
+// NOTE: `clarify` (pergunta estruturada multiple-choice, navegável por setas, equivalente ao
+// AskUserQuestion do Claude) fica LIGADO de propósito: o onboarding pergunta melhor por ele do
+// que listando em texto.
+const DISABLE_TOOLSETS = [
+    "web",
+    "browser",
+    "vision",
+    "video",
+    "image_gen",
+    "video_gen",
+    "tts",
+    "x_search",
+    "moa",
+    "context_engine",
+    "memory",
+    "session_search",
+    "delegation",
+    "cronjob",
+    "computer_use",
+    "homeassistant",
+    "spotify",
+    "yuanbao",
+    "todo",
+];
+// `-p <profile>` é flag GLOBAL e precisa vir ANTES do subcomando (vale pra qualquer um).
+function withProfile(args) {
+    return ["-p", exports.HERMES_PROFILE, ...args];
+}
+// Projeta um McpServerSpec no `hermes -p fazer-ai mcp add` (validado no Hermes 0.17).
+// stdio: `--command`/`--args` (--args é greedy → ÚLTIMA opção) + `--env KEY=VALUE`;
+// http: `--url --auth oauth` (depois `mcp login <name>`).
+function hermesMcpAddCommand(spec) {
+    if (spec.transport === "http") {
+        return `hermes -p ${exports.HERMES_PROFILE} mcp add ${spec.name} --url ${spec.url} --auth oauth`;
+    }
+    const envFlags = Object.entries(spec.env ?? {})
+        .map(([key, value]) => {
+        const shown = spec.secretEnvKeys?.includes(key) ? shell_1.REDACTED : value;
+        return `--env ${key}=${(0, shell_1.shellQuote)(shown)}`;
+    })
+        .join(" ");
+    const args = (spec.args ?? []).map(shell_1.shellQuote).join(" ");
+    const command = spec.command ?? "";
+    return `hermes -p ${exports.HERMES_PROFILE} mcp add ${spec.name}${envFlags ? ` ${envFlags}` : ""} --command ${command} --args ${args}`;
+}
+// Mesmo comando, como argv para spawn (sem shell).
+function hermesMcpAddArgs(spec) {
+    if (spec.transport === "http") {
+        return withProfile([
+            "mcp",
+            "add",
+            spec.name,
+            "--url",
+            spec.url ?? "",
+            "--auth",
+            "oauth",
+        ]);
+    }
+    const envFlags = Object.entries(spec.env ?? {}).flatMap(([key, value]) => [
+        "--env",
+        `${key}=${value}`,
+    ]);
+    // `--args` consome o resto, então fica por último.
+    return withProfile([
+        "mcp",
+        "add",
+        spec.name,
+        ...envFlags,
+        "--command",
+        spec.command ?? "",
+        "--args",
+        ...(spec.args ?? []),
+    ]);
+}
+// `hermes -p fazer-ai auth list` enumera as credenciais de provider pooladas (o profile
+// herda o login global por fallback read-only). Cada credencial é uma linha `#N`, então
+// ao menos uma ⇒ logado.
+function hermesLoggedIn(authListOutput) {
+    return /^\s*#\d+/m.test(authListOutput);
+}
+// O profile `fazer-ai` já existe? `profile list` imprime uma linha por profile com o
+// nome na 1ª coluna. `profile create` NÃO é idempotente (erra se já existe), então
+// guardamos a criação com isto.
+function hermesProfileExists(profileListOutput) {
+    return new RegExp(`(^|\\s)${exports.HERMES_PROFILE}(\\s|$)`, "m").test(profileListOutput);
+}
+// Cria o profile `fazer-ai` se faltar (idempotente sobre o `profile create`, que erra
+// se já existe). `--no-skills` cria vazio e já opta fora do sync de bundled skills do
+// `hermes update` (as nossas skills vêm pelo install nativo, à parte).
+async function ensureProfile() {
+    const { stdout } = await (0, exec_1.capture)("hermes", ["profile", "list"]);
+    if (hermesProfileExists(stdout))
+        return;
+    await (0, exec_1.run)("hermes", [
+        "profile",
+        "create",
+        exports.HERMES_PROFILE,
+        "--no-skills",
+        "--description",
+        "Onboarding do fazer.ai agents (Instalador fazer.ai)",
+    ], { quiet: true });
+}
+// O `hermes setup model` abre um picker do "free tool pool" da Nous (tools hospedados:
+// Firecrawl/FAL/TTS/Whisper/Browser) sempre que o provider é Nous + há entitlement e algum
+// tool coberto está "unconfigured"; NÃO há flag de "dismiss" (nous_subscription.py:920-975,
+// 1051-1073). A única supressão sem trocar de provider é marcar cada seção como use_gateway=true
+// (→ "already_managed" → o picker não aparece). Rodamos isso ANTES do setup model. Os tools com
+// toolset próprio (web/image_gen/browser/tts) seguem cortados pelo `tools disable` do execute
+// (model_tools.py:392-430: a subtração de toolset vence o use_gateway). O STT (transcribe_audio)
+// não tem toolset estático nem é core, então o disable não o alcança; confirmar com `tools list`.
+// Verificado no Hermes 0.17.
+const TOOL_GATEWAY_KEYS = [
+    "web",
+    "image_gen",
+    "video_gen",
+    "tts",
+    "stt",
+    "browser",
+];
+async function suppressToolPoolPrompt() {
+    for (const key of TOOL_GATEWAY_KEYS) {
+        try {
+            await (0, exec_1.run)("hermes", withProfile(["config", "set", `${key}.use_gateway`, "true"]), { quiet: true });
+        }
+        catch {
+            // best-effort: se falhar, o picker pode aparecer (o usuário desmarca); não trava o login.
+        }
+    }
+}
+// NOTE: Comandos validados contra o Hermes CLI real (0.17), incl. install E2E: `skills tap
+// add <owner/repo>` + `skills install <owner/repo/skill> --yes --force` (rastreado no lock →
+// `skills update`). O `--force` passa o verdict `caution` do scanner (conteúdo DevOps:
+// ssh/sudo/env); um verdict `dangerous` NÃO seria passável, por isso a skill evita findings
+// `critical` (ver gotchas/docs sem `$TOKEN`/`$KEY` em exemplos).
+exports.hermesAdapter = {
+    id: "hermes",
+    displayName: AGENT_NAME,
+    automated: true,
+    skillInvoker: "/",
+    detectCommand: "hermes --version",
+    installCommand: {
+        posix: "curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash",
+        win32: "iex (irm https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.ps1)",
+    },
+    marketplaceSource: (config) => config.marketplaceAddTarget,
+    detect() {
+        return (0, detect_1.detectVersion)("hermes", ["--version"]);
+    },
+    // Logado? O profile herda o login global (fallback read-only do auth.json). Sem saída
+    // e exit != 0 ⇒ indeterminado (o fluxo oferece o login em vez de afirmar que falta).
+    async configured() {
+        // Não toca num profile inexistente (evitando auto-criação sem `--no-skills`): se o
+        // profile ainda não existe, `false` → o login cria certo e abre só o `setup model`.
+        const list = await (0, exec_1.capture)("hermes", ["profile", "list"]);
+        if (!hermesProfileExists(list.stdout))
+            return false;
+        const { code, stdout } = await (0, exec_1.capture)("hermes", withProfile(["auth", "list"]));
+        if (code !== 0 && !stdout.trim())
+            return undefined;
+        return hermesLoggedIn(stdout);
+    },
+    // Garante o profile e abre só a seção de modelo do wizard (provider/modelo é a única
+    // escolha do usuário). NÃO roda `hermes setup` completo (que perguntaria gateways/tools).
+    async login() {
+        await ensureProfile();
+        await suppressToolPoolPrompt();
+        await (0, exec_1.runInteractive)("hermes", withProfile(["setup", "model"]));
+    },
+    plan(ctx) {
+        const { config } = ctx;
+        const specs = (0, mcp_1.bootstrapMcpSpecs)({
+            config,
+            provider: ctx.provider,
+            hostingerTokenProvided: ctx.hostingerTokenProvided,
+        });
+        const mcpCommands = specs.map(hermesMcpAddCommand);
+        const httpSpec = specs.find((s) => s.transport === "http");
+        if (httpSpec) {
+            mcpCommands.push(`hermes -p ${exports.HERMES_PROFILE} mcp login ${httpSpec.name}`);
+        }
+        return [
+            {
+                title: `Criar o profile isolado "${exports.HERMES_PROFILE}" (Instalador fazer.ai)`,
+            },
+            { title: "Escolher o provider/modelo do agente" },
+            {
+                title: ctx.provider === "hostinger"
+                    ? "Conectar as ferramentas (DNS, VPS, domínio)"
+                    : "Conectar as ferramentas de infraestrutura",
+                commands: mcpCommands,
+            },
+            {
+                title: "Enxugar as ferramentas e aplicar o branding (skin fazer.ai)",
+                commands: [
+                    `hermes -p ${exports.HERMES_PROFILE} tools disable ${DISABLE_TOOLSETS.join(" ")}`,
+                    `hermes -p ${exports.HERMES_PROFILE} config set lsp.enabled false`,
+                    `hermes -p ${exports.HERMES_PROFILE} config set branding.agent_name ${(0, shell_1.shellQuote)(AGENT_NAME)}`,
+                    `hermes -p ${exports.HERMES_PROFILE} config set display.skin ${SKIN_NAME}`,
+                ],
+            },
+            {
+                // As skills vêm empacotadas no CLI e são instaladas OFFLINE (arquivos + lock.json),
+                // sem bater no GitHub anônimo; o `tap add`/`skills install` fica só de fallback.
+                title: "Instalar as skills do fazer.ai agents (offline, do pacote; atualizáveis)",
+            },
+            { title: "Abrir o Instalador fazer.ai no onboarding" },
+        ];
+    },
+    async execute(ctx) {
+        const { config, log } = ctx;
+        const phase = (n, label) => log((0, ui_1.renderProgress)(n, HERMES_STEPS, label));
+        phase(1, "Preparando o profile do Instalador fazer.ai");
+        await ensureProfile();
+        const specs = (0, mcp_1.bootstrapMcpSpecs)({
+            config,
+            provider: ctx.provider,
+            hostingerTokenProvided: ctx.hostingerTokenProvided,
+            hostingerToken: ctx.hostingerToken,
+        });
+        phase(2, specs.length === 0
+            ? "Sem ferramentas extras a conectar (provider externo)"
+            : "Conectando as ferramentas (DNS, VPS, domínio)");
+        if ((0, mcp_1.hasHostingerSpecs)(specs))
+            await (0, mcp_1.installHostingerMcp)(log);
+        for (const spec of specs) {
+            // `mcp add` pode perguntar "Overwrite?" e "Enable all tools?"; respondemos "Y" às
+            // duas pelo stdin (sem isso vira "Cancelled" e o MCP não é salvo).
+            await (0, exec_1.runWithInput)("hermes", hermesMcpAddArgs(spec), "Y\nY\n", {
+                quiet: !ctx.verbose,
+            });
+            if (spec.transport === "http") {
+                await (0, exec_1.runInteractive)("hermes", withProfile(["mcp", "login", spec.name]));
+            }
+        }
+        phase(3, "Preparando o agente e aplicando o branding");
+        await (0, exec_1.run)("hermes", withProfile(["tools", "disable", ...DISABLE_TOOLSETS]), {
+            quiet: !ctx.verbose,
+        });
+        // NOTE: o onboarding roda comandos de instalação, não edita código, então o LSP/lint
+        // do Hermes é só ruído aqui (no Windows o spawn dos language-servers falha com
+        // WinError 193; o LSP acorda sozinho quando o cwd é um repo git). Desligamos o
+        // subsistema inteiro. Best-effort: a chave ausente numa versão antiga não bloqueia.
+        try {
+            await (0, exec_1.run)("hermes", withProfile(["config", "set", "lsp.enabled", "false"]), {
+                quiet: !ctx.verbose,
+            });
+        }
+        catch {
+            // best-effort: sem o disable o agente ainda abre (só com o ruído de LSP no Windows).
+        }
+        await (0, exec_1.run)("hermes", withProfile(["config", "set", "branding.agent_name", AGENT_NAME]), { quiet: !ctx.verbose });
+        // Branding completo: skin (logo ASCII fazer.ai + cores + labels) e a identidade
+        // (SOUL.md) do Instalador fazer.ai, que mata o flash HERMES→fazer.ai ao abrir.
+        try {
+            writeFazerSkin();
+            writeFazerSoul();
+            await (0, exec_1.run)("hermes", withProfile(["config", "set", "display.skin", SKIN_NAME]), { quiet: !ctx.verbose });
+        }
+        catch {
+            // best-effort: sem a skin/soul o agente ainda abre (só sem o branding completo).
+        }
+        // Pré-build do TUI em paralelo com a instalação da skill (sem contenção).
+        let tuiBuild = null;
+        if (ctx.handoff) {
+            tuiBuild = (0, exec_1.run)("hermes", withProfile(["chat", "--tui"]), {
+                quiet: true,
+            }).catch(() => { });
+        }
+        phase(4, "Instalando as skills do fazer.ai agents");
+        // Caminho PRIMÁRIO: instala as skills OFFLINE do bundle empacotado no CLI (sem rede,
+        // sem o rate-limit do GitHub anônimo que estourava aqui). Escreve os arquivos no profile
+        // + a entrada no lock.json (rastreável → `hermes skills update` depois). Só cai no
+        // fallback de rede (tap add + skills install) se o bundle não vier no pacote.
+        const bundleRoot = (0, hermes_skills_1.bundledSkillsRoot)();
+        const installedOffline = bundleRoot
+            ? installSkillsOffline(ctx, bundleRoot)
+            : false;
+        if (!installedOffline) {
+            log(bundleRoot
+                ? `${ui_1.sym.warn} Falha ao instalar as skills do pacote; tentando pela rede (pode esbarrar no rate-limit do GitHub).`
+                : `${ui_1.sym.warn} Sem skills empacotadas; instalando pela rede (pode esbarrar no rate-limit do GitHub).`);
+            await installSkillsFromNetwork(ctx);
+        }
+        if (ctx.handoff) {
+            const env = ctx.hostingerToken
+                ? { ...process.env, HOSTINGER_API_TOKEN: ctx.hostingerToken }
+                : process.env;
+            if (tuiBuild) {
+                await tuiBuild;
+            }
+            phase(5, "Abrindo o Instalador fazer.ai no onboarding");
+            const launched = await (0, exec_1.runHandoff)("hermes", withProfile([
+                "chat",
+                "--tui",
+                ...HERMES_YOLO_FLAGS,
+                "-q",
+                (0, handoff_1.handoffPrompt)("/", config.onboardingSkill, ctx.provider),
+            ]), { env });
+            if (!launched) {
+                log(`${ui_1.sym.ok} Tudo pronto. Abra o Instalador e invoque a skill: rode \`fazer-ai chat --tui\` e digite \`/${config.onboardingSkill}\`.`);
+            }
+        }
+        else {
+            phase(5, "Tudo pronto. Para abrir depois: fazer-ai chat --tui");
+        }
+    },
+};

package/dist/agents/index.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENTS = void 0;
+exports.getAgent = getAgent;
+exports.installCommandFor = installCommandFor;
+exports.detectAgents = detectAgents;
+const claude_1 = require("./claude");
+const codex_1 = require("./codex");
+const hermes_1 = require("./hermes");
+const other_1 = require("./other");
+__exportStar(require("./types"), exports);
+// NOTE: a ordem desta lista é a ordem do menu e o critério de desempate do default
+// (primeiro instalado). Codex e Claude Code (adapters de referência) vêm primeiro,
+// depois o Instalador fazer.ai (Hermes), todos automatizados (detectam, planejam e
+// executam o setup). O Instalador fazer.ai carrega o selo "recomendado" no picker
+// mesmo em 3º (ver selectAgent em index.ts). "other" é o genérico (sem automação, só
+// imprime o prompt pra mandar ao agente) e fica por último; também com --agent other.
+exports.AGENTS = [
+    codex_1.codexAdapter,
+    claude_1.claudeAdapter,
+    hermes_1.hermesAdapter,
+    other_1.otherAdapter,
+];
+function getAgent(id) {
+    return exports.AGENTS.find((agent) => agent.id === id);
+}
+// Resolve o `installCommand` de um adapter para a plataforma atual. String =
+// só POSIX (sem auto-install no Windows). Objeto = escolhe por SO; `win32`
+// ausente → undefined (sem instalador Windows conhecido). Função pura (testável).
+function installCommandFor(installCommand, platform = process.platform) {
+    if (installCommand === undefined)
+        return undefined;
+    if (typeof installCommand === "string") {
+        return platform === "win32" ? undefined : installCommand;
+    }
+    return platform === "win32" ? installCommand.win32 : installCommand.posix;
+}
+async function detectAgents() {
+    return Promise.all(exports.AGENTS.map(async (adapter) => ({
+        adapter,
+        result: await adapter.detect(),
+    })));
+}

package/dist/agents/manual.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manualExecute = manualExecute;
+// Adapter genérico ("outro"): não há automação específica de agente. Como o plano
+// não é impresso fora do dry-run, renderizamos aqui os passos acionáveis, e no
+// fim, o prompt pronto para copiar e colar no agente que o usuário for usar.
+async function manualExecute(adapter, ctx) {
+    const steps = adapter.plan({
+        config: ctx.config,
+        provider: ctx.provider,
+        hostingerTokenProvided: ctx.hostingerTokenProvided,
+    });
+    ctx.log("\nAgente genérico: sem automação. Faça estes passos no agente que você for usar:\n");
+    steps.forEach((step, i) => {
+        ctx.log(`  ${i + 1}. ${step.title}`);
+        if (step.detail)
+            ctx.log(`     ${step.detail}`);
+        for (const cmd of step.commands ?? []) {
+            ctx.log(`\n     → copie e cole no seu agente:\n\n     ${cmd}\n`);
+        }
+    });
+}

package/dist/agents/other.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.otherAdapter = void 0;
+const handoff_1 = require("./handoff");
+const manual_1 = require("./manual");
+// NOTE: Agente genérico. Sem setup agente-específico (não conhecemos o formato de
+// MCP/marketplace do agente). O CLI só imprime o que o usuário deve fazer e o
+// prompt para mandar ao agente que ele for usar.
+exports.otherAdapter = {
+    id: "other",
+    displayName: "Outro agente",
+    automated: false,
+    skillInvoker: "",
+    detectCommand: "",
+    detect() {
+        // Sem binário a detectar; é sempre uma opção válida (apenas instrui).
+        return Promise.resolve({ installed: true });
+    },
+    plan(ctx) {
+        const { config } = ctx;
+        return [
+            {
+                title: "Sem setup automático (agente genérico)",
+                detail: "Para um agente não suportado, o CLI não injeta MCP nem instala o bundle; configure-os conforme a doc do seu agente (a página de conexões do hub tem os snippets genéricos de MCP).",
+            },
+            {
+                title: "Obtenha o bundle de onboarding",
+                detail: `Instale/clone a skill ${config.onboardingSkill} do repo público ${config.marketplaceAddTarget} (GitHub) conforme o seu agente.`,
+            },
+            {
+                title: "Mande este prompt ao seu agente",
+                commands: [(0, handoff_1.handoffPrompt)("", config.onboardingSkill, ctx.provider)],
+            },
+        ];
+    },
+    execute(ctx) {
+        return (0, manual_1.manualExecute)(exports.otherAdapter, ctx);
+    },
+};

package/dist/agents/shell.js

@@ -0,0 +1,15 @@
+"use strict";
+// Utilitários de formatação de comando shell compartilhados pelos adapters.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REDACTED = void 0;
+exports.shellQuote = shellQuote;
+/** Marcador exibido no lugar de valores de env secretos no plano. */
+exports.REDACTED = "<redacted>";
+// Aspas simples POSIX só quando o valor tem caractere fora do conjunto seguro
+// (inclui `=` para `--package=...` não sair com aspas); escapa aspas simples
+// embutidas. Mantém os comandos exibidos legíveis.
+function shellQuote(value) {
+    if (/^[A-Za-z0-9_./:@=-]+$/.test(value))
+        return value;
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}

package/dist/agents/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/config.js

@@ -0,0 +1,48 @@
+"use strict";
+// Resolução de configuração de runtime a partir de variáveis de ambiente, com
+// defaults seguros. Espelha o override `FAZER_AI_HUB_URL` do `@fazer-ai/setup`
+// para que o mesmo fluxo aponte para um hub local/staging durante o desenvolvimento.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfig = resolveConfig;
+exports.asProvider = asProvider;
+const DEFAULT_HUB_BASE_URL = "https://app.fazer.ai";
+// As 3 skills do fazer.ai agents publicadas no repo dedicado (plugin `agents`). O Claude/Codex
+// instalam o plugin (traz as 3 de uma vez); o Hermes instala por skill, então precisa da lista.
+// Sem ela só a de onboarding entrava, divergindo dos outros agentes.
+const AGENTS_SKILLS = [
+    "agents-onboarding",
+    "agents-dev",
+    "agents-operation",
+];
+function stripTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+function resolveConfig(env = process.env) {
+    const hubBaseUrl = stripTrailingSlash(env.FAZER_AI_HUB_URL?.trim() || DEFAULT_HUB_BASE_URL);
+    const hermesTapRepo = env.AGENTS_HERMES_TAP_REPO?.trim() || "fazer-ai/agents-skills";
+    return {
+        hubBaseUrl,
+        // NOTE: Repo dedicado da skill (marketplace co-localizado, `source: "./"`). Claude/Codex
+        // dão `plugin marketplace add` nele e instalam direto do clone, sem npm. Sobrescrevível.
+        marketplaceAddTarget: env.AGENTS_MARKETPLACE_TARGET?.trim() || "fazer-ai/agents-skills",
+        // NOTE: Nome do marketplace no `marketplace.json` do repo. "agents", NÃO "fazer-ai":
+        // colidiria com o marketplace pago fazer-ai/skills (Claude/Codex chaveiam por nome).
+        marketplaceName: env.AGENTS_MARKETPLACE_NAME?.trim() || "agents",
+        onboardingPlugin: env.AGENTS_PLUGIN?.trim() || "agents",
+        onboardingSkill: env.AGENTS_SKILL?.trim() || "agents-onboarding",
+        // NOTE: Identifiers `owner/repo/skill` pro `hermes skills install` (o Hermes mira
+        // `skills/<skill>/` no repo, uma skill por install). As 3 = paridade com o plugin
+        // Claude/Codex. O tap registra o repo antes. Sobrescrevível (CSV em
+        // AGENTS_HERMES_SKILL_REFS).
+        hermesSkillRefs: (env.AGENTS_HERMES_SKILL_REFS?.trim()
+            ? env.AGENTS_HERMES_SKILL_REFS.split(",").map((s) => s.trim())
+            : AGENTS_SKILLS.map((name) => `${hermesTapRepo}/${name}`)).filter(Boolean),
+        // NOTE: Repo `owner/repo` pro `hermes skills tap add` (registra o repo público como fonte github).
+        hermesTapRepo,
+    };
+}
+function asProvider(value) {
+    if (value === "hostinger" || value === "other")
+        return value;
+    throw new Error(`provider inválido: ${value} (use "hostinger" ou "other")`);
+}