@fazer-ai/agents 1.0.0

package/dist/licenses.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUsable = isUsable;
+exports.isAvailable = isAvailable;
+exports.kanbanLicenses = kanbanLicenses;
+exports.hasCommunityAccess = hasCommunityAccess;
+exports.licenseLabel = licenseLabel;
+exports.instanceLabel = instanceLabel;
+exports.parseLicenseChoice = parseLicenseChoice;
+exports.buildLicenseMenu = buildLicenseMenu;
+// Status que tornam a licença utilizável pra ligar o Pro (os demais: past_due,
+// canceled, unpaid, paused, incomplete, não habilitam).
+const USABLE_STATUS = new Set(["ACTIVE", "TRIALING"]);
+function isUsable(l) {
+    return USABLE_STATUS.has(l.status.toUpperCase());
+}
+// Disponível = utilizável E ainda não atachada a uma instância.
+function isAvailable(l) {
+    return isUsable(l) && l.instance === null;
+}
+// Filtra as licenças Kanban/Chatwoot do conjunto cru do `list_licenses`.
+function kanbanLicenses(all) {
+    return all.filter((l) => l.feature?.toUpperCase() === "KANBAN" &&
+        l.instanceType?.toUpperCase() === "CHATWOOT");
+}
+// Acesso à edição Pro da fazer.ai agents = membership da comunidade (`isCommunityGrant`)
+// com status utilizável. Difere do Kanban avulso: o projeto `agents` no Harbor é
+// liberado só pra membros da comunidade (robot per-user, gating no hub). Uma licença
+// Chatwoot Pro avulsa (isCommunityGrant=false) NÃO desbloqueia o fazer.ai agents Pro.
+function hasCommunityAccess(all) {
+    return all.some((l) => l.isCommunityGrant && isUsable(l));
+}
+// Rótulo curto e estável de uma licença pro seletor.
+function licenseLabel(l) {
+    const grant = l.isCommunityGrant ? " · comunidade" : "";
+    return `Licença #${l.number}${grant}`;
+}
+// Rótulo legível da instância atachada: nome amigável → host → UUID de instalação.
+// O `identifier` cru é um UUID, ilegível como "em uso por"; é o último recurso.
+function instanceLabel(instance) {
+    if (!instance)
+        return "outra instância";
+    return instance.name?.trim() || instance.host?.trim() || instance.identifier;
+}
+// Decodifica o value escolhido no seletor (`lic:<id>` / `attached:<id>` / ação).
+function parseLicenseChoice(value) {
+    if (value.startsWith("lic:"))
+        return { kind: "available", id: value.slice(4) };
+    if (value.startsWith("attached:")) {
+        return { kind: "attached", id: value.slice("attached:".length) };
+    }
+    return { kind: "action", action: value };
+}
+// Monta o menu de licença, ciente do estado:
+//  - **empty** (0 licenças): "Atualizar lista" + "Ainda não tenho licença" (única
+//    porta pro fluxo da comunidade, só faz sentido quando não há NENHUMA).
+//  - **none-available** (só consumidas) / **has-available**: as licenças primeiro
+//    (disponíveis selecionáveis = `lic:`, consumidas selecionáveis = `attached:`
+//    pra desvincular), depois "Adquirir nova licença" + "Seguir sem o Chatwoot
+//    Pro". `defaultIndex` cai na última usada se ainda disponível, senão na 1ª opção.
+function buildLicenseMenu(kanban, lastUsedId) {
+    const available = kanban.filter(isAvailable);
+    const consumed = kanban.filter((l) => isUsable(l) && l.instance !== null);
+    const options = [];
+    for (const l of available) {
+        options.push({ value: `lic:${l.id}`, label: licenseLabel(l) });
+    }
+    for (const l of consumed) {
+        options.push({
+            value: `attached:${l.id}`,
+            label: licenseLabel(l),
+            hint: `em uso por ${instanceLabel(l.instance)}`,
+        });
+    }
+    let state;
+    if (available.length + consumed.length === 0) {
+        state = "empty";
+        options.push({ value: "refresh", label: "Atualizar lista" });
+        options.push({ value: "community", label: "Ainda não tenho licença" });
+    }
+    else {
+        state = available.length > 0 ? "has-available" : "none-available";
+        options.push({ value: "acquire", label: "Adquirir nova licença" });
+        options.push({
+            value: "skip",
+            label: "Seguir sem o Chatwoot Pro (OSS, sem Kanban)",
+        });
+    }
+    const lastIdx = lastUsedId
+        ? available.findIndex((l) => l.id === lastUsedId)
+        : -1;
+    return { options, defaultIndex: lastIdx >= 0 ? lastIdx : 0, state };
+}

package/dist/mcp.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hostingerEntryPath = hostingerEntryPath;
+exports.installHostingerMcp = installHostingerMcp;
+exports.hasHostingerSpecs = hasHostingerSpecs;
+exports.bootstrapMcpSpecs = bootstrapMcpSpecs;
+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");
+// NOTE: Pacote único oficial (hostinger-api-mcp) que expõe 3 servidores por módulo
+// (DNS, VPS, domains). Instalamos LOCAL (~/.fazer-ai/mcp) e apontamos o MCP pro
+// entry .js via o runtime atual (`process.execPath`), em vez de `npx … @latest`: o npx tem startup
+// variável (resolução + checagem de registro do @latest) que estoura os timeouts
+// de conexão do agente (Hermes ~10s) → "Connection closed". O entry via runtime sobe
+// em <1s, conecta de forma confiável nos 3 agentes e é cross-platform (o shim do
+// `.bin/` viraria `.cmd`/`.ps1` no Windows). Token: no execute gravamos o LITERAL (vindo do
+// ~/.fazer-ai/hostinger.json que já mantemos) no config de MCP do agente, pra o
+// conector funcionar também ao REABRIR o agente fora do handoff, sem depender do
+// env vivo nem da expansão de ${VAR} (que só confirmamos no Hermes). No preview do
+// plan usamos a REFERÊNCIA ${HOSTINGER_API_TOKEN} e a marca como segredo, então o
+// literal nunca aparece em saída/preview.
+const HOSTINGER_PACKAGE = "hostinger-api-mcp@latest";
+const HOSTINGER_MODULES = ["dns", "vps", "domains"];
+const HOSTINGER_MCP_DIR = (0, node_path_1.join)((0, node_os_1.homedir)(), ".fazer-ai", "mcp");
+// Caminho do ENTRY .js do servidor MCP de um módulo (o `bin` do pacote aponta
+// pra src/servers/<mod>.js). Lançamos via o runtime atual (`process.execPath`) em vez do shim do
+// `.bin/`: no Windows o shim vira `.cmd`/`.ps1` (que o agente não consegue lançar
+// como stdio sem shell), enquanto o runtime é um caminho absoluto sempre resolvível. É o que o
+// shim faz por baixo, só que cross-platform.
+function hostingerEntryPath(mod) {
+    return (0, node_path_1.join)(HOSTINGER_MCP_DIR, "node_modules", "hostinger-api-mcp", "src", "servers", `${mod}.js`);
+}
+// Instala o pacote localmente (idempotente: pula se o binário já existe). Robusto a PATH mínimo, na
+// ordem: bun → npm → heal+retry. O instalador instala o bun pra rodar o CLI, então o bun é garantido;
+// sob `bunx` o próprio process.execPath JÁ é o bun (caminho absoluto, sem depender do PATH), o que cobre
+// até o caso bun-only (sem node/npm). O heal do PATH (registro) só entra como último recurso, antes de
+// retentar o npm.
+async function installHostingerMcp(log) {
+    if ((0, node_fs_1.existsSync)(hostingerEntryPath("dns")))
+        return;
+    log?.("Instalando o conector da Hostinger...");
+    (0, node_fs_1.mkdirSync)(HOSTINGER_MCP_DIR, { recursive: true });
+    const bun = process.versions.bun
+        ? process.execPath
+        : (await (0, exec_1.capture)("bun", ["--version"])).code === 0
+            ? "bun"
+            : undefined;
+    if (bun) {
+        await (0, exec_1.run)(bun, ["add", `--cwd=${HOSTINGER_MCP_DIR}`, HOSTINGER_PACKAGE], {
+            quiet: true,
+        });
+        return;
+    }
+    const npmArgs = [
+        "install",
+        "--no-fund",
+        "--no-audit",
+        "--prefix",
+        HOSTINGER_MCP_DIR,
+        HOSTINGER_PACKAGE,
+    ];
+    try {
+        await (0, exec_1.run)("npm", npmArgs, { quiet: true });
+    }
+    catch {
+        await (0, exec_1.healPath)();
+        await (0, exec_1.run)("npm", npmArgs, { quiet: true });
+    }
+}
+// Algum spec é dos MCPs da Hostinger? (gateia o install no execute do agente.)
+function hasHostingerSpecs(specs) {
+    return specs.some((s) => s.name.startsWith("hostinger-"));
+}
+function bootstrapMcpSpecs(opts) {
+    // Provider "other": sem MCP de provisionamento. O agente instrui DNS/VPS com
+    // base no conhecimento do provider que o usuário indicar (ver o skill).
+    // Hostinger só entra com token (index.ts captura/seta antes); sem token,
+    // conectar falharia, então pula em vez de injetar MCPs quebrados.
+    const literalToken = typeof opts.hostingerToken === "string" && opts.hostingerToken.length > 0
+        ? opts.hostingerToken
+        : undefined;
+    const specs = opts.provider === "hostinger" && opts.hostingerTokenProvided
+        ? HOSTINGER_MODULES.map((mod) => ({
+            name: `hostinger-${mod}`,
+            transport: "stdio",
+            command: process.execPath,
+            args: [hostingerEntryPath(mod)],
+            env: { HOSTINGER_API_TOKEN: literalToken ?? "${HOSTINGER_API_TOKEN}" },
+            // Só marca como segredo quando é o token literal (execute): o preview
+            // redige. A referência de env (plan) não é segredo e pode aparecer.
+            ...(literalToken ? { secretEnvKeys: ["HOSTINGER_API_TOKEN"] } : {}),
+            note: `Hostinger ${mod}.`,
+        }))
+        : [];
+    // NOTE: o hub NÃO é injetado como MCP no agente. As ops do hub que o onboarding precisa saem pelo
+    // proxy `agents hub <op>` (hub-command.ts): menos privilégio (sem token mcp:admin na sessão do
+    // agente) e resolve o timing (o agente chama attach-license quando já sabe o host da instância).
+    return specs;
+}