@fazer-ai/agents 1.0.0

package/dist/exec.js

@@ -0,0 +1,279 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capture = capture;
+exports.run = run;
+exports.runWithInput = runWithInput;
+exports.windowsPowershell = windowsPowershell;
+exports.shellInvocation = shellInvocation;
+exports.runShell = runShell;
+exports.refreshWindowsPath = refreshWindowsPath;
+exports.withDirOnPath = withDirOnPath;
+exports.ensureUserLocalBinOnPath = ensureUserLocalBinOnPath;
+exports.persistUserLocalBinToWindowsPath = persistUserLocalBinToWindowsPath;
+exports.healPath = healPath;
+exports.runInteractive = runInteractive;
+exports.ptyArgv = ptyArgv;
+exports.handoffInvocation = handoffInvocation;
+exports.runHandoff = runHandoff;
+// cross-spawn (não node:child_process.spawn) resolve os shims do Windows: no
+// Windows os CLIs instalados via npm viram `.cmd`/`.ps1` (ex.: `npm.ps1`,
+// `claude.cmd`), e o spawn nativo sem shell falha com ENOENT (e o Node 20.12+
+// bloqueia `.cmd`/`.bat` sem shell por causa do CVE-2024-27980). cross-spawn faz
+// o lookup PATH×PATHEXT e o quoting de `cmd /c` mantendo o argv literal (sem
+// `shell: true`, que forçaria shell-quoting manual de tokens/prompts).
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const cross_spawn_1 = __importDefault(require("cross-spawn"));
+const shell_1 = require("./agents/shell");
+// Roda um comando e captura stdout (sem herdar o terminal). Não lança: devolve o
+// código de saída para o chamador decidir. ENOENT/timeout → código != 0.
+function capture(command, args, opts) {
+    return new Promise((resolve) => {
+        const child = (0, cross_spawn_1.default)(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ code, stdout, stderr });
+        };
+        const timer = setTimeout(() => {
+            child.kill();
+            finish(1);
+        }, opts?.timeout ?? 5000);
+        child.stdout?.on("data", (d) => {
+            stdout += d.toString();
+        });
+        child.stderr?.on("data", (d) => {
+            stderr += d.toString();
+        });
+        // Erro de spawn (binário ausente, ENOENT): não lança, devolve código != 0.
+        child.on("error", () => finish(1));
+        child.on("close", (code) => finish(typeof code === "number" ? code : 1));
+    });
+}
+// Roda um comando herdando stdout/stderr (sem shell: argv passa literal, sem
+// reparse). Rejeita em código de saída != 0. Com `quiet`, captura a saída em vez
+// de imprimir (silencioso no sucesso) e só a anexa ao erro se falhar.
+function run(command, args, opts) {
+    return new Promise((resolve, reject) => {
+        const std = opts?.quiet ? "pipe" : "inherit";
+        const child = (0, cross_spawn_1.default)(command, args, {
+            stdio: ["ignore", std, std],
+            env: opts?.env ?? process.env,
+        });
+        let buf = "";
+        if (opts?.quiet) {
+            child.stdout?.on("data", (d) => {
+                buf += d.toString();
+            });
+            child.stderr?.on("data", (d) => {
+                buf += d.toString();
+            });
+        }
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0)
+                resolve();
+            else {
+                const detail = buf.trim() ? `\n${buf.trim().slice(-1500)}` : "";
+                reject(new Error(`\`${command} ${args.join(" ")}\` saiu com código ${code ?? "?"}${detail}`));
+            }
+        });
+    });
+}
+// Roda um comando escrevendo `input` no stdin (e fechando-o); stdout/stderr
+// herdados. Pra auto-responder prompts não-evitáveis (ex.: o "Enable all tools?"
+// do `hermes mcp add`, que sem resposta vira "Cancelled"). Rejeita em código != 0.
+function runWithInput(command, args, input, opts) {
+    return new Promise((resolve, reject) => {
+        const std = opts?.quiet ? "pipe" : "inherit";
+        const child = (0, cross_spawn_1.default)(command, args, {
+            stdio: ["pipe", std, std],
+            env: opts?.env ?? process.env,
+        });
+        let buf = "";
+        if (opts?.quiet) {
+            child.stdout?.on("data", (d) => {
+                buf += d.toString();
+            });
+            child.stderr?.on("data", (d) => {
+                buf += d.toString();
+            });
+        }
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0)
+                resolve();
+            else {
+                const detail = buf.trim() ? `\n${buf.trim().slice(-1500)}` : "";
+                reject(new Error(`\`${command} ${args.join(" ")}\` saiu com código ${code ?? "?"}${detail}`));
+            }
+        });
+        child.stdin?.write(input);
+        child.stdin?.end();
+    });
+}
+// Windows: powershell.exe nem sempre está no PATH da sessão que roda o CLI (cmd/Git Bash com PATH
+// enxuto, Server Core, etc.), daí o "spawn powershell ENOENT". Resolve o caminho ABSOLUTO do Windows
+// PowerShell 5.1 (sempre em %SystemRoot%\System32\WindowsPowerShell\v1.0); cai no nome puro se o arquivo
+// não existir (ambiente sem PS 5.1). `root`/`exists` injetáveis pra testar. Pura.
+function windowsPowershell(root = process.env.SystemRoot || process.env.windir || "C:\\Windows", exists = node_fs_1.existsSync) {
+    const abs = `${root}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+    return exists(abs) ? abs : "powershell";
+}
+// Invocação de shell por plataforma para um instalador em pipe (`curl … | bash`,
+// `irm … | iex`). No Windows os instaladores oficiais dos agentes são PowerShell,
+// então rodamos via `powershell -Command` (o `cmd.exe`, que o `shell: true`
+// usaria, não entende `irm`/`iex`). Em POSIX, `sh -c`. Função pura (testável).
+function shellInvocation(command, platform = process.platform) {
+    if (platform === "win32") {
+        return {
+            cmd: windowsPowershell(),
+            args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", command],
+        };
+    }
+    return { cmd: "sh", args: ["-c", command] };
+}
+// Roda um instalador em pipe no shell certo da plataforma (ver shellInvocation),
+// herdando stdout/stderr. Rejeita em código de saída != 0.
+function runShell(command) {
+    return new Promise((resolve, reject) => {
+        const { cmd, args } = shellInvocation(command);
+        const child = (0, cross_spawn_1.default)(cmd, args, {
+            stdio: ["ignore", "inherit", "inherit"],
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`o instalador saiu com código ${code ?? "?"}`));
+        });
+    });
+}
+// Windows: relê o PATH persistente (Machine + User, do registro) e o mescla no
+// process.env.PATH desta sessão. Um instalador (ex.: o `.ps1` de um agente) grava
+// o diretório do binário no User PATH, mas o processo atual herdou o PATH antigo;
+// sem isto, o binário recém-instalado só apareceria num terminal NOVO. No-op fora
+// do Windows; best-effort (falha não interrompe o fluxo).
+async function refreshWindowsPath() {
+    if (process.platform !== "win32")
+        return;
+    const { code, stdout } = await capture(windowsPowershell(), [
+        "-NoProfile",
+        "-Command",
+        "[Environment]::GetEnvironmentVariable('Path','Machine') + ';' + [Environment]::GetEnvironmentVariable('Path','User')",
+    ]);
+    if (code !== 0)
+        return;
+    const fresh = stdout.trim();
+    // Prepend o PATH do registro (que já tem o novo diretório) preservando o atual.
+    if (fresh)
+        process.env.PATH = `${fresh};${process.env.PATH ?? ""}`;
+}
+// Prepend `dir` em `pathVar` (idempotente). Pura.
+function withDirOnPath(pathVar, dir, sep) {
+    if (!dir)
+        return pathVar;
+    if (pathVar.split(sep).includes(dir))
+        return pathVar;
+    return pathVar ? `${dir}${sep}${pathVar}` : dir;
+}
+// `~/.local/bin`: onde os instaladores nativos (Claude, Hermes) gravam o binário SEM
+// adicioná-lo ao PATH persistente, então o refreshWindowsPath (que só relê o registro) não o
+// pega. Prepend na sessão pra o detect do startup E o re-detect pós-install acharem o binário
+// sem depender de reabrir o terminal. Idempotente; no-op se já estiver no PATH.
+function ensureUserLocalBinOnPath() {
+    const sep = process.platform === "win32" ? ";" : ":";
+    process.env.PATH = withDirOnPath(process.env.PATH ?? "", (0, node_path_1.join)((0, node_os_1.homedir)(), ".local", "bin"), sep);
+}
+// Windows: PERSISTE `~/.local/bin` no User PATH do registro (idempotente). O ensureUserLocalBinOnPath
+// acima só conserta o PATH DESTA sessão do CLI; a etapa de OAuth do MCP no onboarding manda o usuário
+// REABRIR o agente num terminal NOVO, que só acha o binário se ~/.local/bin estiver no PATH persistente.
+// Os instaladores nativos gravam lá sem tocar no PATH, então persistimos por eles. No-op fora do Windows;
+// best-effort (capture não lança).
+async function persistUserLocalBinToWindowsPath() {
+    if (process.platform !== "win32")
+        return;
+    const dir = (0, node_path_1.join)((0, node_os_1.homedir)(), ".local", "bin");
+    // Lê o User PATH (coage null→''), anexa o dir só se ausente (case-insensitive) e regrava.
+    const script = `$d = '${dir}'; ` +
+        "$p = [string][Environment]::GetEnvironmentVariable('Path','User'); " +
+        "if (-not (($p -split ';') -contains $d)) { " +
+        "[Environment]::SetEnvironmentVariable('Path', (($p.TrimEnd(';') + ';' + $d).TrimStart(';')), 'User') }";
+    await capture(windowsPowershell(), ["-NoProfile", "-Command", script]);
+}
+// Auto-cura do PATH no startup, pra o CLI achar as ferramentas que spawna (npm/npx ao lado do node;
+// powershell e os agentes no PATH persistente) mesmo numa sessão com PATH mínimo/desatualizado; a raiz
+// dos "spawn npm/powershell ENOENT". (1) Prepend do dir do runtime atual (process.execPath: onde o
+// npm/npx vivem ao lado do node). (2) No Windows, relê o PATH persistente do registro (Machine+User).
+// Best-effort e idempotente.
+async function healPath() {
+    const sep = process.platform === "win32" ? ";" : ":";
+    process.env.PATH = withDirOnPath(process.env.PATH ?? "", (0, node_path_1.dirname)(process.execPath), sep);
+    await refreshWindowsPath();
+}
+// Roda um sub-comando interativo do agente (login/auth/setup) herdando o terminal. Esses rodam DURANTE a
+// fase interativa do CLI (que já tem o TTY) e não são a TUI longa do handoff. O código de saída não é erro
+// do CLI. Para a TUI FINAL do handoff use runHandoff (precisa de pty), não esta.
+function runInteractive(command, args, opts) {
+    return new Promise((resolve, reject) => {
+        const child = (0, cross_spawn_1.default)(command, args, {
+            stdio: "inherit",
+            env: opts?.env ?? process.env,
+        });
+        child.on("error", reject);
+        child.on("close", () => resolve());
+    });
+}
+// script(1) por plataforma para alocar um pty. BSD/macOS: `script -q /dev/null cmd args…` (argv direto,
+// sem re-quote). util-linux/Linux: `script -q -c "<cmd string>" /dev/null` (o comando é UMA string de
+// shell, daí o shellQuote). Fora de darwin/linux (ex.: Windows) não há script equivalente → undefined, e
+// o handoff cai no caminho manual (imprime o comando) em vez de arriscar um crash. Pura (testável).
+function ptyArgv(command, args, platform = process.platform) {
+    if (platform === "darwin") {
+        return { cmd: "script", argv: ["-q", "/dev/null", command, ...args] };
+    }
+    if (platform === "linux") {
+        const line = [command, ...args].map(shell_1.shellQuote).join(" ");
+        return { cmd: "script", argv: ["-q", "-c", line, "/dev/null"] };
+    }
+    return undefined;
+}
+// Decide COMO abrir a TUI do handoff por plataforma. Windows: spawn DIRETO (cmd/argv via cross-spawn),
+// porque o filho herda o console real do PowerShell e o crossterm do Codex inicia sem panic (validado num
+// box Windows); não há script(1) e nem é preciso. POSIX: pty via script(1) (ptyArgv), porque o instalador
+// roda via `curl | bash` e o pipe quebra o tty (o crossterm panica "reader source not set"). Devolve
+// undefined só em POSIX sem script equivalente (cai no caminho manual). Pura (testável).
+function handoffInvocation(command, args, platform = process.platform) {
+    if (platform === "win32")
+        return { cmd: command, argv: args };
+    return ptyArgv(command, args, platform);
+}
+// Handoff final: entrega o terminal à TUI do agente; devolve `true` se conseguiu ABRIR. A invocação por
+// plataforma vem de handoffInvocation (Windows: spawn direto, console herdado; POSIX: pty via script(1),
+// que o `curl | bash` exige, sem ele o crossterm do Codex panica "reader source not set"). Sem invocação
+// possível, ou se o spawn falhar ('error'), devolve `false` SEM crashar: o chamador imprime o comando pro
+// usuário abrir à mão. O código de saída do agente não é erro do CLI.
+function runHandoff(command, args, opts) {
+    const inv = handoffInvocation(command, args);
+    if (!inv)
+        return Promise.resolve(false);
+    return new Promise((resolve) => {
+        const child = (0, cross_spawn_1.default)(inv.cmd, inv.argv, {
+            stdio: "inherit",
+            env: opts?.env ?? process.env,
+        });
+        // 'error' = nem iniciou (binário ausente etc.) → false; o chamador imprime o caminho manual.
+        child.on("error", () => resolve(false));
+        child.on("close", () => resolve(true));
+    });
+}

package/dist/hostinger.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hostingerTokenPath = hostingerTokenPath;
+exports.loadHostingerToken = loadHostingerToken;
+exports.saveHostingerToken = saveHostingerToken;
+exports.classifyTokenStatus = classifyTokenStatus;
+exports.validateHostingerToken = validateHostingerToken;
+const node_fs_1 = require("node:fs");
+const node_https_1 = require("node:https");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+// Cache opt-in do token da API Hostinger (~/.fazer-ai/hostinger.json, 0600). É
+// uma chave poderosa (VPS/DNS/domínio), então só é gravada se o usuário aceitar.
+function hostingerTokenPath(home = (0, node_os_1.homedir)()) {
+    return (0, node_path_1.join)(home, ".fazer-ai", "hostinger.json");
+}
+function loadHostingerToken(path = hostingerTokenPath()) {
+    try {
+        const obj = JSON.parse((0, node_fs_1.readFileSync)(path, "utf8"));
+        return typeof obj.token === "string" && obj.token ? obj.token : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function saveHostingerToken(token, path = hostingerTokenPath()) {
+    try {
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true, mode: 0o700 });
+        (0, node_fs_1.writeFileSync)(path, `${JSON.stringify({ token }, null, 2)}\n`, {
+            mode: 0o600,
+        });
+        (0, node_fs_1.chmodSync)(path, 0o600);
+    }
+    catch {
+        // cache é best-effort; falhar aqui não quebra o fluxo.
+    }
+}
+// Classifica o status HTTP da validação do token: 2xx = válido; 401/403 =
+// inválido/expirado/sem permissão; o resto (5xx, rede, timeout) = "error"
+// (indeterminado, o chamador NÃO deve rejeitar o token por isto). Pura (testável).
+function classifyTokenStatus(code) {
+    if (code >= 200 && code < 300)
+        return true;
+    if (code === 401 || code === 403)
+        return false;
+    return "error";
+}
+// Valida o token contra a API Hostinger via um GET autenticado leve
+// (`/api/vps/v1/virtual-machines`): 401 confirma token inválido/expirado. true =
+// válido, false = inválido, "error" = não deu pra validar (rede/timeout/5xx),
+// caso em que o chamador aceita o token (best-effort), pra não travar por um
+// problema transitório.
+function validateHostingerToken(token, timeoutMs = 10000) {
+    return new Promise((resolve) => {
+        const req = (0, node_https_1.request)({
+            method: "GET",
+            hostname: "developers.hostinger.com",
+            path: "/api/vps/v1/virtual-machines",
+            headers: {
+                authorization: `Bearer ${token}`,
+                accept: "application/json",
+                "user-agent": "@fazer-ai/agents",
+            },
+        }, (res) => {
+            res.resume(); // descarta o corpo
+            resolve(classifyTokenStatus(res.statusCode ?? 0));
+        });
+        req.setTimeout(timeoutMs, () => {
+            req.destroy();
+            resolve("error");
+        });
+        req.on("error", () => resolve("error"));
+        req.end();
+    });
+}

package/dist/hub-command.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFlags = parseFlags;
+exports.resolveHubOp = resolveHubOp;
+exports.harborSecretPath = harborSecretPath;
+exports.runHubCommand = runHubCommand;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const oauth_1 = require("./oauth");
+// "--key value" / "--flag" → mapa. Pura.
+function parseFlags(argv) {
+    const out = {};
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === undefined || !a.startsWith("--"))
+            continue;
+        const key = a.slice(2);
+        const next = argv[i + 1];
+        if (next === undefined || next.startsWith("--")) {
+            out[key] = true;
+        }
+        else {
+            out[key] = next;
+            i++;
+        }
+    }
+    return out;
+}
+// Mapeia o subcomando + flags na tool do hub + argumentos. Pura + testável; lança com mensagem clara
+// quando falta uma flag obrigatória ou o op é desconhecido.
+function resolveHubOp(op, flags) {
+    const apply = flags.apply === true;
+    const need = (k) => {
+        const v = flags[k];
+        if (typeof v !== "string" || !v) {
+            throw new Error(`--${k} é obrigatório para 'hub ${op}'`);
+        }
+        return v;
+    };
+    switch (op) {
+        case "whoami":
+            return { tool: "whoami", args: {}, write: false, secret: false };
+        case "licenses":
+            return { tool: "list_licenses", args: {}, write: false, secret: false };
+        case "instances":
+            return { tool: "list_instances", args: {}, write: false, secret: false };
+        case "get-license":
+            return {
+                tool: "get_license",
+                args: { license_id: need("license") },
+                write: false,
+                secret: false,
+            };
+        case "get-instance":
+            return {
+                tool: "get_instance",
+                args: { instance_id: need("instance") },
+                write: false,
+                secret: false,
+            };
+        case "registry-credential": {
+            // Per-user por padrão (o hub aceita sem license_id e devolve o robot per-user); --license restringe.
+            const args = { dry_run: !apply };
+            if (typeof flags.license === "string" && flags.license) {
+                args.license_id = flags.license;
+            }
+            return { tool: "create_registry_credential", args, write: true, secret: true };
+        }
+        case "create-instance": {
+            const args = {
+                identifier: need("identifier"),
+                dry_run: !apply,
+            };
+            if (typeof flags.name === "string" && flags.name)
+                args.name = flags.name;
+            return { tool: "create_instance", args, write: true, secret: false };
+        }
+        case "attach-license":
+            return {
+                tool: "attach_license",
+                args: {
+                    license_id: need("license"),
+                    instance_id: need("instance"),
+                    dry_run: !apply,
+                },
+                write: true,
+                secret: false,
+            };
+        default:
+            throw new Error(`subcomando 'hub ${op}' desconhecido (use: whoami | licenses | instances | get-license | get-instance | registry-credential | create-instance | attach-license)`);
+    }
+}
+function harborSecretPath(home = (0, node_os_1.homedir)()) {
+    return (0, node_path_1.join)(home, ".fazer-ai", "harbor.secret");
+}
+const USAGE = `Uso: agents hub <op> [flags]
+
+Proxy do hub fazer.ai para o onboarding (usa a sessão OAuth do ~/.fazer-ai/oauth.json).
+Writes são DRY-RUN por padrão; aplique com --apply.
+
+  whoami                                           identidade + escopos do usuário (read)
+  licenses                                         lista as licenças (read)
+  instances                                        lista as instâncias (read)
+  get-license   --license <id>                     detalha uma licença (read)
+  get-instance  --instance <id>                    detalha uma instância (read)
+  registry-credential [--license <id>] [--apply]   credencial do Harbor; --apply grava o secret num
+                                                   arquivo 0600 (--out) e NÃO o imprime
+  create-instance --identifier <host> [--name <n>] [--apply]
+  attach-license  --license <id> --instance <id> [--apply]
+`;
+// Runner (IO). Chamado pelo index.ts quando argv[0] === "hub". Imprime JSON no stdout (o agente lê).
+async function runHubCommand(config, argv, log) {
+    const op = argv[0];
+    if (!op || op === "--help" || op === "-h" || op === "help") {
+        process.stdout.write(USAGE);
+        return;
+    }
+    const flags = parseFlags(argv.slice(1));
+    const spec = resolveHubOp(op, flags);
+    // refreshOnly: o agente roda headless; se a sessão do hub expirou, falha rápido (o operador re-roda o CLI).
+    const result = await (0, oauth_1.hubCall)(config, { log, refreshOnly: true }, spec.tool, spec.args);
+    if (spec.secret && spec.args.dry_run === false) {
+        const secretVal = typeof result.secret === "string" ? result.secret : undefined;
+        const username = typeof result.username === "string" ? result.username : undefined;
+        if (secretVal) {
+            const out = typeof flags.out === "string" && flags.out
+                ? flags.out
+                : harborSecretPath();
+            (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(out), { recursive: true, mode: 0o700 });
+            (0, node_fs_1.writeFileSync)(out, secretVal, { mode: 0o600 });
+            (0, node_fs_1.chmodSync)(out, 0o600);
+            process.stdout.write(`${JSON.stringify({
+                ok: true,
+                registry: "harbor.fazer.ai",
+                username,
+                secret_file: out,
+                note: "secret gravado em arquivo (0600), não impresso",
+            })}\n`);
+            return;
+        }
+    }
+    process.stdout.write(`${JSON.stringify({ ok: true, ...result })}\n`);
+}