@fazer-ai/agents 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 FAZER.AI LTDA
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+# @fazer-ai/agents
+
+CLI de bootstrap do onboarding da **fazer.ai agents**. Roda no PC do usuário,
+agnóstico de SO (via `bunx`/`npx`), e prepara o seu agente de IA para conduzir a
+jornada de onboarding ponta a ponta.
+
+## O que faz
+
+`bunx @fazer-ai/agents@latest` (ou `npx @fazer-ai/agents@latest`):
+
+1. **Escolhe o agente**: Hermes, Claude Code, Codex ou "outro" (genérico). Sem
+   `--agent`, o CLI pergunta; a última escolha vira o default ("último usado").
+2. **Autentica na fazer.ai**: login OAuth no browser por padrão, com a sessão
+   reaproveitada nas próximas vezes (`~/.fazer-ai/oauth.json`); `--login` força um
+   login novo.
+3. **Instala o agente** se faltar (instalador oficial de cada um) e confere o login.
+4. **Define a edição do Chatwoot (licença do Kanban)**: lista as suas licenças do
+   hub: uma livre → **Pro** (com Kanban); uma já atribuída → alerta pra desvincular;
+   nenhuma disponível → adquirir (`app.fazer.ai?cart=1`) ou seguir em **OSS**; lista
+   vazia → a comunidade do Lucas Moreira (licença grátis) ou OSS. A escolha vira o
+   marcador `~/.fazer-ai/onboarding.json` que a skill lê no deploy.
+5. **Conecta as ferramentas (MCP)**: os conectores da Hostinger (DNS, VPS,
+   domínio) quando o provider é Hostinger. O MCP da fazer.ai agents é conectado
+   depois, pelo próprio agente, após o deploy.
+6. **Instala o guia de onboarding**: a skill `agents-onboarding` a partir do
+   marketplace fazer.ai.
+7. **Faz o handoff**: abre o agente já na jornada, com o prompt inicial semeado.
+
+Os agentes automatizados (Hermes/Claude/Codex) executam tudo de ponta a ponta.
+O "outro" não automatiza: imprime os passos e o prompt para você levar ao agente
+que for usar.
+
+## Uso
+
+```sh
+bunx @fazer-ai/agents@latest [opções]
+npx  @fazer-ai/agents@latest [opções]
+```
+
+| Opção             | Para quê                                                           |
+| ----------------- | ------------------------------------------------------------------ |
+| `--agent <id>`    | `hermes`, `claude`, `codex` ou `other`. Sem isto, o CLI pergunta.  |
+| `--provider <id>` | Infra de VPS/DNS: `hostinger` (default) ou `other`.                |
+| `--login`         | Força um login novo no browser (ignora a sessão salva).            |
+| `--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`   | Versão do CLI.                                                     |
+| `-h, --help`      | Ajuda.                                                             |
+
+O **provider** `hostinger` injeta os MCPs de provisionamento; `other` não injeta
+(o agente instrui DNS/VPS com base no provider que você indicar).
+
+Defina `FAZER_AI_CLI_THEME=light` para o tema claro (terminais de fundo branco); o
+padrão é o tema escuro. `NO_COLOR` desliga a cor por completo.
+
+## Plataformas
+
+Roda em **Linux, macOS, Windows nativo (PowerShell/cmd) e WSL**. Pré-requisito:
+Node ≥ 18 (ou Bun, via `bunx`).
+
+No **Windows nativo** (sem WSL) o CLI resolve os shims dos CLIs instalados via npm
+(`npm.ps1`, `claude.cmd`, …) e usa o instalador **PowerShell oficial** de cada
+agente (`install.ps1`). Use um terminal moderno (Windows Terminal recomendado)
+para a UI interativa de setas/Enter.
+
+## Estado em disco (`~/.fazer-ai/`, 0600)
+
+O CLI guarda localmente, para reaproveitar entre execuções:
+
+| Arquivo            | Conteúdo                                                       |
+| ------------------ | ------------------------------------------------------------- |
+| `oauth.json`       | Sessão OAuth da fazer.ai.                                      |
+| `hostinger.json`   | Token da API Hostinger (opt-in; reaproveitado nas próximas).  |
+| `onboarding.json`  | Marcador da jornada que a skill lê: `chatwootTier` (`pro`/`community`) + `chatwootLicenseId`. |
+| `preferences.json` | Últimas escolhas (agente, provider, licença) pra virar default. |
+| `mcp/`             | Conector da Hostinger instalado localmente (`hostinger-api-mcp`). |
+
+O token da Hostinger é **gravado no config de MCP do agente** (a partir do
+`hostinger.json`), para o conector funcionar mesmo quando você reabrir o agente
+fora do handoff. Consequência: **não versione nem compartilhe o config de MCP do
+agente** (`~/.codex/…`, `~/.claude.json`, config do Hermes), pois ele passa a
+conter o token. No preview (`--dry-run`) o token é sempre redigido.
+
+## Desenvolvimento
+
+```sh
+npm install
+npm run build      # tsc -> dist/
+node dist/index.js --help
+npm test           # vitest
+```
+
+Uma única dependência de runtime (`cross-spawn`, para resolver os shims
+`.cmd`/`.ps1` no Windows nativo); o resto é `node:*`. Excluído do Biome/tsconfig
+do app principal; tem o próprio `tsconfig.json` e suíte `vitest`.
+
+## Configuração (env)
+
+| Variável                        | Default                  | Para quê                                             |
+| ------------------------------- | ------------------------ | --------------------------------------------------- |
+| `FAZER_AI_HUB_URL`              | `https://app.fazer.ai`   | Base do hub (MCP, OAuth/licenças).                  |
+| `HOSTINGER_API_TOKEN`           | (nenhum)                        | Token da API Hostinger (senão o CLI pede/usa cache).|
+| `AGENTS_PROVIDER`           | `hostinger`              | Provider de infra (equivale a `--provider`).        |
+| `AGENTS_MARKETPLACE_TARGET` | `fazer-ai/agents-skills` | Repo do `plugin marketplace add` (Claude/Codex). |
+| `AGENTS_MARKETPLACE_NAME`   | `agents`                 | Nome sob o qual o marketplace é registrado.         |
+| `AGENTS_HERMES_TAP_REPO`    | `fazer-ai/agents-skills` | Repo do `hermes skills tap add`.            |
+| `AGENTS_HERMES_SKILL_REF`   | `fazer-ai/agents-skills/agents-onboarding` | Ref do `hermes skills install`. |
+| `AGENTS_PLUGIN`             | `agents`                 | Plugin/skill a instalar + handoff.                  |
+| `AGENTS_OAUTH_CLIENT_ID`    | (nenhum)                        | `client_id` OAuth pré-registrado (se o hub não usar DCR).|
+</content>

package/dist/agents/claude.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeAdapter = void 0;
+exports.claudeMcpAddCommand = claudeMcpAddCommand;
+exports.claudeMcpAddArgs = claudeMcpAddArgs;
+exports.claudeMcpAdd = claudeMcpAdd;
+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 shell_1 = require("./shell");
+// Total de macro-passos do setup do Claude (barra de progresso).
+const CLAUDE_STEPS = 3;
+function claudeMcpAddCommand(spec) {
+    if (spec.transport === "http") {
+        return `claude mcp add --transport http ${spec.name} ${spec.url}`;
+    }
+    const envFlags = Object.entries(spec.env ?? {})
+        .map(([key, value]) => {
+        const shown = spec.secretEnvKeys?.includes(key) ? shell_1.REDACTED : value;
+        return `-e ${key}=${(0, shell_1.shellQuote)(shown)}`;
+    })
+        .join(" ");
+    const cmd = [spec.command, ...(spec.args ?? [])]
+        .filter((part) => Boolean(part))
+        .map(shell_1.shellQuote)
+        .join(" ");
+    return `claude mcp add ${spec.name}${envFlags ? ` ${envFlags}` : ""} -- ${cmd}`;
+}
+// Argv para execução (spawn sem shell). O valor de env vai LITERAL: para o token
+// é a referência ${HOSTINGER_API_TOKEN}, que o Claude expande no launch do MCP.
+function claudeMcpAddArgs(spec) {
+    if (spec.transport === "http") {
+        return ["mcp", "add", "--transport", "http", spec.name, spec.url ?? ""];
+    }
+    const envFlags = Object.entries(spec.env ?? {}).flatMap(([key, value]) => [
+        "-e",
+        `${key}=${value}`,
+    ]);
+    const cmd = [spec.command, ...(spec.args ?? [])].filter((part) => Boolean(part));
+    return ["mcp", "add", spec.name, ...envFlags, "--", ...cmd];
+}
+// `claude mcp add` sai != 0 quando o servidor já existe ("... already exists in ... config"), o que
+// derruba um re-run (run() rejeita e o passo de conectar as ferramentas aborta). A config que remontamos é idêntica entre runs (o
+// token é a referência ${HOSTINGER_API_TOKEN}, o path é estável), então "already exists" é sucesso: o MCP
+// já está do jeito que queremos. Qualquer outra falha propaga. Idempotência alinhada à resumabilidade do fluxo.
+async function claudeMcpAdd(spec) {
+    try {
+        await (0, exec_1.run)("claude", claudeMcpAddArgs(spec), { quiet: true });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (/already exists/i.test(msg))
+            return;
+        throw err;
+    }
+}
+exports.claudeAdapter = {
+    id: "claude",
+    displayName: "Claude Code",
+    automated: true,
+    skillInvoker: "/",
+    detectCommand: "claude --version",
+    installCommand: {
+        posix: "curl -fsSL https://claude.ai/install.sh | bash",
+        win32: "irm https://claude.ai/install.ps1 | iex",
+    },
+    marketplaceSource: (config) => config.marketplaceAddTarget,
+    detect() {
+        return (0, detect_1.detectVersion)("claude", ["--version"]);
+    },
+    // Sem login/configured no CLI: o Claude Code autentica no próprio TUI ao abrir o
+    // handoff. Um pre-login aqui (claude auth login) duplicava o sign-in (o CLI logava e
+    // o TUI pedia de novo), então deixamos o Claude cuidar do próprio login.
+    plan(ctx) {
+        const { config } = ctx;
+        const specs = (0, mcp_1.bootstrapMcpSpecs)({
+            config,
+            provider: ctx.provider,
+            hostingerTokenProvided: ctx.hostingerTokenProvided,
+        });
+        return [
+            {
+                title: ctx.provider === "hostinger"
+                    ? "Conectar as ferramentas (DNS, VPS, domínio)"
+                    : "Conectar as ferramentas de infraestrutura",
+                commands: specs.map(claudeMcpAddCommand),
+            },
+            {
+                title: "Instalar/atualizar o guia de onboarding",
+                commands: [
+                    `claude plugin marketplace add ${config.marketplaceAddTarget}`,
+                    `claude plugin marketplace update ${config.marketplaceName}`,
+                    `claude plugin install ${config.onboardingPlugin}@${config.marketplaceName}`,
+                    `claude plugin update ${config.onboardingPlugin}@${config.marketplaceName}`,
+                ],
+            },
+            { title: "Abrir o Claude no onboarding" },
+        ];
+    },
+    async execute(ctx) {
+        const { config, log } = ctx;
+        const phase = (n, label) => log((0, ui_1.renderProgress)(n, CLAUDE_STEPS, label));
+        const specs = (0, mcp_1.bootstrapMcpSpecs)({
+            config,
+            provider: ctx.provider,
+            hostingerTokenProvided: ctx.hostingerTokenProvided,
+            hostingerToken: ctx.hostingerToken,
+        });
+        phase(1, 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) {
+            await claudeMcpAdd(spec);
+        }
+        phase(2, "Instalando/atualizando o guia de onboarding");
+        await (0, exec_1.run)("claude", ["plugin", "marketplace", "add", config.marketplaceAddTarget]);
+        // marketplace update refresca o snapshot do repo (vê a nova versão publicada);
+        // plugin update força a atualização quando o plugin já estava instalado (re-run).
+        // Sem isso, `install` é no-op num re-run e o agente fica preso na versão antiga.
+        await (0, exec_1.run)("claude", ["plugin", "marketplace", "update", config.marketplaceName]);
+        await (0, exec_1.run)("claude", [
+            "plugin",
+            "install",
+            `${config.onboardingPlugin}@${config.marketplaceName}`,
+        ]);
+        // update usa o id COMPLETO plugin@marketplace (o Claude chaveia o plugin instalado
+        // assim; `update agents` puro dá "not found"). No-op quando já está na latest.
+        await (0, exec_1.run)("claude", [
+            "plugin",
+            "update",
+            `${config.onboardingPlugin}@${config.marketplaceName}`,
+        ]);
+        if (ctx.handoff) {
+            phase(3, "Abrindo o Claude no onboarding");
+            const env = ctx.hostingerToken
+                ? { ...process.env, HOSTINGER_API_TOKEN: ctx.hostingerToken }
+                : process.env;
+            const launched = await (0, exec_1.runHandoff)("claude", [(0, handoff_1.handoffPrompt)("/", config.onboardingSkill, ctx.provider)], { env });
+            if (!launched) {
+                phase(3, "Tudo pronto.");
+                log(`${ui_1.sym.ok} Abra o Claude e invoque a skill: rode \`claude\` e digite \`/${config.onboardingSkill}\`.`);
+            }
+        }
+        else {
+            phase(3, "Tudo pronto. Para abrir depois: claude");
+        }
+    },
+};

package/dist/agents/codex.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexAdapter = void 0;
+exports.codexLoggedIn = codexLoggedIn;
+exports.codexMcpAddCommand = codexMcpAddCommand;
+exports.codexMcpAddArgs = codexMcpAddArgs;
+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 shell_1 = require("./shell");
+// Total de macro-passos do setup do Codex (barra de progresso).
+const CODEX_STEPS = 3;
+// Lê o estado do `codex login status`. "Not logged in" ⇒ false; "Logged in …" ⇒
+// true; nenhum dos dois ⇒ undefined (indeterminado). A ordem importa: "not logged
+// in" contém "logged in", então testa o negativo primeiro.
+function codexLoggedIn(output) {
+    if (/not logged in/i.test(output))
+        return false;
+    if (/logged in/i.test(output))
+        return true;
+    return undefined;
+}
+// Projeta um McpServerSpec no `codex mcp add` (validado no Codex 0.142). stdio:
+// `--env KEY=VALUE` antes do `--`, depois o comando. http: bridge stdio via
+// `mcp-remote` (formato que o hub documenta para o Codex).
+function codexMcpAddCommand(spec) {
+    if (spec.transport === "http") {
+        return `codex mcp add ${spec.name} -- npx -y mcp-remote ${spec.url}`;
+    }
+    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 cmd = [spec.command, ...(spec.args ?? [])]
+        .filter((part) => Boolean(part))
+        .map(shell_1.shellQuote)
+        .join(" ");
+    return `codex mcp add ${spec.name}${envFlags ? ` ${envFlags}` : ""} -- ${cmd}`;
+}
+// Mesmo comando, como argv para spawn (sem shell). O valor de env vai LITERAL: a
+// referência ${HOSTINGER_API_TOKEN} é expandida pelo Codex no launch do MCP.
+function codexMcpAddArgs(spec) {
+    if (spec.transport === "http") {
+        return ["mcp", "add", spec.name, "--", "npx", "-y", "mcp-remote", spec.url ?? ""];
+    }
+    const envFlags = Object.entries(spec.env ?? {}).flatMap(([key, value]) => [
+        "--env",
+        `${key}=${value}`,
+    ]);
+    const cmd = [spec.command, ...(spec.args ?? [])].filter((part) => Boolean(part));
+    return ["mcp", "add", spec.name, ...envFlags, "--", ...cmd];
+}
+// NOTE: Comandos validados contra o Codex CLI real (0.142): `codex mcp add`,
+// `codex plugin marketplace add owner/repo` (clona repo público direto, sem proxy nem
+// credencial, `<SOURCE>` aceita owner/repo[@ref]/HTTPS), `codex plugin marketplace upgrade`
+// (refresca o snapshot Git), `codex plugin remove`, `codex plugin add <plugin>@<mkt>`.
+// Fonte: o repo dedicado da skill (config.marketplaceAddTarget), validado no plugin list.
+exports.codexAdapter = {
+    id: "codex",
+    displayName: "Codex",
+    automated: true,
+    skillInvoker: "$",
+    detectCommand: "codex --version",
+    installCommand: {
+        posix: "curl -fsSL https://chatgpt.com/codex/install.sh | sh",
+        win32: "irm https://chatgpt.com/codex/install.ps1 | iex",
+    },
+    marketplaceSource: (config) => config.marketplaceAddTarget,
+    detect() {
+        return (0, detect_1.detectVersion)("codex", ["--version"]);
+    },
+    // `codex login status` imprime o estado no STDERR (não no stdout), então lê os
+    // dois fluxos. "Logged in using ChatGPT" ⇒ logado; "Not logged in" ⇒ não.
+    async configured() {
+        const { stdout, stderr } = await (0, exec_1.capture)("codex", ["login", "status"]);
+        return codexLoggedIn(`${stdout}\n${stderr}`);
+    },
+    // `codex login` abre o OAuth do ChatGPT no browser; creds em ~/.codex/config.toml.
+    login() {
+        return (0, exec_1.runInteractive)("codex", ["login"]);
+    },
+    plan(ctx) {
+        const { config } = ctx;
+        const specs = (0, mcp_1.bootstrapMcpSpecs)({
+            config,
+            provider: ctx.provider,
+            hostingerTokenProvided: ctx.hostingerTokenProvided,
+        });
+        return [
+            {
+                title: ctx.provider === "hostinger"
+                    ? "Conectar as ferramentas (DNS, VPS, domínio)"
+                    : "Conectar as ferramentas de infraestrutura",
+                commands: specs.map(codexMcpAddCommand),
+            },
+            {
+                title: "Instalar/atualizar o guia de onboarding",
+                commands: [
+                    `codex plugin marketplace add ${config.marketplaceAddTarget}`,
+                    `codex plugin marketplace upgrade ${config.marketplaceName}`,
+                    `codex plugin add ${config.onboardingPlugin}@${config.marketplaceName}`,
+                ],
+            },
+            { title: "Abrir o Codex no onboarding" },
+        ];
+    },
+    async execute(ctx) {
+        const { config, log } = ctx;
+        const phase = (n, label) => log((0, ui_1.renderProgress)(n, CODEX_STEPS, label));
+        const specs = (0, mcp_1.bootstrapMcpSpecs)({
+            config,
+            provider: ctx.provider,
+            hostingerTokenProvided: ctx.hostingerTokenProvided,
+            hostingerToken: ctx.hostingerToken,
+        });
+        phase(1, 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) {
+            await (0, exec_1.run)("codex", codexMcpAddArgs(spec), { quiet: true });
+        }
+        phase(2, "Instalando/atualizando o guia de onboarding");
+        await (0, exec_1.run)("codex", ["plugin", "marketplace", "add", config.marketplaceAddTarget]);
+        // O Codex não tem `plugin update`: pra um re-run pegar a versão nova, refrescamos o
+        // snapshot do marketplace (upgrade) e reinstalamos. O remove é tolerante (capture, não
+        // run) porque na 1ª run o plugin ainda não existe; sem ele, `add` seria no-op no re-run.
+        await (0, exec_1.run)("codex", ["plugin", "marketplace", "upgrade", config.marketplaceName]);
+        await (0, exec_1.capture)("codex", ["plugin", "remove", config.onboardingPlugin]);
+        await (0, exec_1.run)("codex", [
+            "plugin",
+            "add",
+            `${config.onboardingPlugin}@${config.marketplaceName}`,
+        ]);
+        if (ctx.handoff) {
+            phase(3, "Abrindo o Codex no onboarding");
+            const env = ctx.hostingerToken
+                ? { ...process.env, HOSTINGER_API_TOKEN: ctx.hostingerToken }
+                : process.env;
+            const launched = await (0, exec_1.runHandoff)("codex", [(0, handoff_1.handoffPrompt)("$", config.onboardingSkill, ctx.provider)], { env });
+            if (!launched) {
+                phase(3, "Tudo pronto.");
+                log(`${ui_1.sym.ok} Abra o Codex e invoque a skill: rode \`codex\` e digite \`$${config.onboardingSkill}\`.`);
+            }
+        }
+        else {
+            phase(3, "Tudo pronto. Para abrir depois: codex");
+        }
+    },
+};

package/dist/agents/detect.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectVersion = detectVersion;
+const exec_1 = require("../exec");
+// Detecta um agente pelo seu comando de versão. Reusa `capture` (sobre
+// cross-spawn) para resolver shims `.cmd`/`.ps1` no Windows. Código != 0
+// (binário ausente, timeout, saída não-zero) vira { installed: false }, nunca lança.
+async function detectVersion(command, args) {
+    const { code, stdout } = await (0, exec_1.capture)(command, args);
+    if (code !== 0)
+        return { installed: false };
+    // Só a 1ª linha: alguns agentes (Hermes) imprimem versão multi-linha.
+    const version = stdout.trim().split(/\r?\n/)[0]?.trim();
+    return { installed: true, version: version || undefined };
+}

package/dist/agents/handoff.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handoffPrompt = handoffPrompt;
+// Prompt do handoff: instrui o agente a usar a skill E entrega o contexto que o CLI já preparou
+// (provider, MCPs conectados, marcador), pra ele NÃO re-perguntar o que já foi decidido. O
+// invocador é específico do agente (Claude "/", Codex "$"; vazio no genérico).
+function handoffPrompt(skillInvoker, plugin, provider) {
+    const base = `Use a skill ${skillInvoker}${plugin} para conduzir o onboarding da fazer.ai agents.`;
+    let msg = base;
+    if (provider === "hostinger") {
+        msg = `${base} Contexto já preparado pelo CLI: provider de infra = Hostinger (os MCPs hostinger-dns/vps/domains já estão conectados, use-os; não pergunte "se for Hostinger") e o marcador da jornada está em ~/.fazer-ai/onboarding.json (tier do Chatwoot + licença, edição da fazer.ai agents free/pro). LEIA o marcador e os MCPs conectados antes de perguntar; não re-pergunte provider/tier/licença/edição já definidos.`;
+    }
+    else if (provider === "other") {
+        msg = `${base} Contexto já preparado pelo CLI: provider de infra = outro (sem MCPs da Hostinger) e o marcador da jornada está em ~/.fazer-ai/onboarding.json (tier do Chatwoot + licença, edição da fazer.ai agents free/pro). LEIA o marcador antes de perguntar; só pergunte o provider de VPS/DNS se a skill precisar.`;
+    }
+    // No Windows o agente tende a tratar o PowerShell como bash (escape/BOM) e a contornar o MCP por REST.
+    // Semeia as duas regras antes do 1º comando: enterradas na skill, não pegam o começo da run.
+    if (process.platform === "win32") {
+        msg += ` IMPORTANTE (Windows/PowerShell): o shell só ORQUESTRA, NUNCA carrega código. Não rode script/SQL/JSON inline (sem here-string @'…'@ | …, sem ssh host '…código…' com aspas/{{…}}/(, sem \\ de continuação de linha, sem pipe de payload): escreva o payload num ARQUIVO (ferramenta de edição) e rode via "scripts/remote.py --script-file" (bash/psql/rails-runner remoto) ou "python x.py" (local). A config do fazer.ai agents é só por MCP: se as tools MCP não estiverem expostas na sessão, PARE e peça pra reiniciar o harness, NUNCA contorne por REST/console/leitura do código.`;
+    }
+    return msg;
+}

package/dist/agents/hermes-skills.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hermesSkillsDir = hermesSkillsDir;
+exports.hermesLockPath = hermesLockPath;
+exports.comparePosixPaths = comparePosixPaths;
+exports.listSkillFiles = listSkillFiles;
+exports.skillContentHash = skillContentHash;
+exports.buildLockEntry = buildLockEntry;
+exports.installBundledSkill = installBundledSkill;
+exports.bundledSkillsRoot = bundledSkillsRoot;
+exports.skillNameFromRef = skillNameFromRef;
+// Instalação OFFLINE das skills do fazer.ai agents no profile do Hermes.
+//
+// Por que existe: instalar via `hermes skills tap add` + `skills install` bate no
+// skills.sh / GitHub anônimo, cujo rate-limit (60/h) estourava no meio do onboarding
+// ("skill not found", lock.json vazio). Em vez de puxar da rede no caminho quente,
+// EMPACOTAMOS as skills já buildadas (`tooling/skills/dist`) dentro do CLI e as
+// escrevemos direto no profile, reproduzindo o que o instalador nativo do Hermes faria:
+// os arquivos em `profiles/<p>/skills/<skill>/` + a entrada em
+// `profiles/<p>/skills/.hub/lock.json` com o `content_hash` correto.
+//
+// O `content_hash` tem que casar bit a bit com o do Hermes (skills_guard.content_hash
+// == skills_hub.bundle_content_hash): sha256 sobre, para cada arquivo em `sorted(files)`
+// (ordem de codepoint, NÃO case-insensitive), `relPosix + "\x00" + bytes`, e então
+// `sha256:` + os 16 primeiros hex. Assim um `hermes skills update` futuro compara certo.
+//
+// NOTE: o proxy autenticado do app.fazer.ai (fallback quando não há bundle, p.ex. skill
+// nova publicada só no hub) vive em OUTRO repo (o hub) e não é construído aqui. Este
+// caminho empacotado é o primário; o `tap add`/`skills install` na rede fica como
+// fallback no adapter, atrás de uma flag.
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+// Caminhos-espelho da resolução do Hermes (skills_hub.py): SKILLS_DIR = <profile>/skills,
+// HUB_DIR = SKILLS_DIR/.hub, LOCK = HUB_DIR/lock.json. Puros.
+function hermesSkillsDir(profileDir) {
+    return (0, node_path_1.join)(profileDir, "skills");
+}
+function hermesLockPath(profileDir) {
+    return (0, node_path_1.join)(hermesSkillsDir(profileDir), ".hub", "lock.json");
+}
+// Ordena caminhos POSIX igual ao `sorted()` de PurePosixPath do Python (por COMPONENTES,
+// não pela string juntada): ("a","b") < ("a.txt",) porque compara "a" < "a.txt", enquanto
+// a string "a/b" > "a.txt" (porque "/" 0x2F > "." 0x2E). O content_hash do Hermes ordena
+// os Path component-wise, então temos que casar isso pra o hash bater em árvores aninhadas.
+function comparePosixPaths(a, b) {
+    const pa = a.split("/");
+    const pb = b.split("/");
+    const n = Math.min(pa.length, pb.length);
+    for (let i = 0; i < n; i++) {
+        if (pa[i] < pb[i])
+            return -1;
+        if (pa[i] > pb[i])
+            return 1;
+    }
+    return pa.length - pb.length;
+}
+// Lista os arquivos de um diretório de skill em POSIX relativo, ORDENADOS component-wise
+// (o mesmo `sorted(rglob("*"))` do Hermes sobre PurePosixPath). Pula diretórios. Puro
+// sobre o FS.
+function listSkillFiles(skillDir) {
+    const out = [];
+    const walk = (dir) => {
+        for (const name of (0, node_fs_1.readdirSync)(dir)) {
+            const full = (0, node_path_1.join)(dir, name);
+            if ((0, node_fs_1.statSync)(full).isDirectory())
+                walk(full);
+            else
+                out.push((0, node_path_1.relative)(skillDir, full).split("\\").join("/"));
+        }
+    };
+    walk(skillDir);
+    return out.sort(comparePosixPaths);
+}
+// Reproduz skills_hub.bundle_content_hash / skills_guard.content_hash: para cada arquivo
+// em ordem, `path + NUL + conteúdo`, sha256, prefixo `sha256:` + 16 hex. `read` injetável
+// pra teste. `files` DEVE vir ordenado (listSkillFiles já ordena).
+function skillContentHash(skillDir, files, read = (rel) => (0, node_fs_1.readFileSync)((0, node_path_1.join)(skillDir, rel))) {
+    const h = (0, node_crypto_1.createHash)("sha256");
+    for (const rel of files) {
+        h.update(Buffer.from(rel, "utf8"));
+        h.update(Buffer.from([0]));
+        h.update(read(rel));
+    }
+    return `sha256:${h.digest("hex").slice(0, 16)}`;
+}
+// Monta a entrada do lock idêntica ao HubLockFile.record_install do Hermes. `identifier`
+// no formato skills.sh (`skills-sh/<owner>/<repo>/<skill>`) pra um `skills update` futuro
+// resolver a mesma origem. `now` injetável pra teste. Puro.
+function buildLockEntry(opts) {
+    const iso = opts.now ?? new Date().toISOString();
+    return {
+        source: "skills.sh",
+        identifier: `skills-sh/${opts.tapRepo}/${opts.skill}`,
+        trust_level: "community",
+        scan_verdict: "caution",
+        content_hash: opts.contentHash,
+        install_path: opts.skill,
+        files: opts.files,
+        metadata: {
+            detail_url: `https://skills.sh/${opts.tapRepo}/${opts.skill}`,
+            repo_url: `https://github.com/${opts.tapRepo}`,
+        },
+        installed_at: iso,
+        updated_at: iso,
+    };
+}
+function loadLock(lockPath) {
+    if ((0, node_fs_1.existsSync)(lockPath)) {
+        try {
+            const data = JSON.parse((0, node_fs_1.readFileSync)(lockPath, "utf8"));
+            if (data && typeof data === "object" && data.installed) {
+                return { version: data.version ?? 1, installed: data.installed };
+            }
+        }
+        catch {
+            // lock corrompido: recomeça limpo (o Hermes reconcilia no próximo update).
+        }
+    }
+    return { version: 1, installed: {} };
+}
+// Copia os arquivos da skill buildada pro profile (substitui a árvore inteira, como o
+// install_from_quarantine do Hermes) e devolve o dir instalado.
+function copySkillTree(srcSkillDir, destSkillDir) {
+    (0, node_fs_1.rmSync)(destSkillDir, { recursive: true, force: true });
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(destSkillDir), { recursive: true });
+    (0, node_fs_1.cpSync)(srcSkillDir, destSkillDir, { recursive: true });
+}
+// Instala UMA skill buildada offline no profile: copia os arquivos, calcula o
+// content_hash a partir do que foi escrito no disco (fonte da verdade, igual ao Hermes) e
+// grava a entrada no lock.json. Idempotente (re-run substitui a árvore e reescreve a
+// entrada). Lança em erro de FS; quem chama trata por-skill pra uma não derrubar as outras.
+function installBundledSkill(opts) {
+    const skillsDir = hermesSkillsDir(opts.profileDir);
+    const destSkillDir = (0, node_path_1.join)(skillsDir, opts.skill);
+    copySkillTree(opts.bundledSkillDir, destSkillDir);
+    const files = listSkillFiles(destSkillDir);
+    const contentHash = skillContentHash(destSkillDir, files);
+    const lockPath = hermesLockPath(opts.profileDir);
+    const lock = loadLock(lockPath);
+    lock.installed[opts.skill] = buildLockEntry({
+        skill: opts.skill,
+        tapRepo: opts.tapRepo,
+        contentHash,
+        files,
+        now: opts.now,
+    });
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(lockPath), { recursive: true });
+    (0, node_fs_1.writeFileSync)(lockPath, `${JSON.stringify(lock, null, 2)}\n`, "utf8");
+    return { skill: opts.skill, files: files.length, contentHash };
+}
+// Resolve a raiz das skills empacotadas no pacote do CLI. Em runtime buildado, `__dirname`
+// é `dist/agents/` → as skills ficam em `dist/skills/` (copiadas no build por
+// `scripts/bundle-skills.mjs`). Em dev/teste (`src/agents/`), cai no `tooling/skills/dist`
+// do monorepo. Devolve undefined se nenhum existir (o adapter cai no fallback de rede).
+function bundledSkillsRoot(fromDir = __dirname) {
+    const candidates = [
+        (0, node_path_1.join)(fromDir, "..", "skills"), // dist/agents → dist/skills (pacote publicado)
+        (0, node_path_1.join)(fromDir, "..", "..", "..", "skills", "dist"), // src/agents → tooling/skills/dist (dev)
+    ];
+    return candidates.find((p) => (0, node_fs_1.existsSync)((0, node_path_1.join)(p)) && hasAnySkill(p));
+}
+// Um diretório de skills válido tem ao menos um <skill>/SKILL.md.
+function hasAnySkill(root) {
+    try {
+        return (0, node_fs_1.readdirSync)(root, { withFileTypes: true }).some((d) => d.isDirectory() && (0, node_fs_1.existsSync)((0, node_path_1.join)(root, d.name, "SKILL.md")));
+    }
+    catch {
+        return false;
+    }
+}
+// Nome da skill a partir do ref `owner/repo/skill` do config (hermesSkillRefs). O offline
+// instala por nome de pasta (o último segmento). Puro.
+function skillNameFromRef(ref) {
+    const parts = ref.split("/").filter(Boolean);
+    return parts[parts.length - 1] ?? ref;
+}