@hadcloud/deploy-cli 0.1.0

package/dist/credentials.js

@@ -0,0 +1,98 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+const service = "com.hadcloud.deploy-cli";
+const account = "default";
+function configDirectory() {
+    if (process.env.HAD_DEPLOY_CONFIG_DIR)
+        return process.env.HAD_DEPLOY_CONFIG_DIR;
+    if (platform() === "win32")
+        return join(process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local"), "HAD Deploy");
+    return join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "had-deploy");
+}
+const configPath = () => join(configDirectory(), "config.json");
+const tokenPath = () => join(configDirectory(), "token.dpapi");
+async function writeConfig(apiUrl) {
+    await mkdir(configDirectory(), { recursive: true, mode: 0o700 });
+    await writeFile(configPath(), `${JSON.stringify({ apiUrl, version: 1 }, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+}
+async function readConfig() {
+    try {
+        const value = JSON.parse(await readFile(configPath(), "utf8"));
+        return typeof value.apiUrl === "string" ? { apiUrl: value.apiUrl } : null;
+    }
+    catch {
+        return null;
+    }
+}
+function powershell(script, input) {
+    const result = spawnSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], { encoding: "utf8", input, windowsHide: true });
+    if (result.status !== 0)
+        throw new Error("Não foi possível acessar o armazenamento protegido do Windows.");
+    return result.stdout.trim();
+}
+async function saveWindowsToken(token) {
+    const encrypted = powershell("$plain=[Console]::In.ReadToEnd(); $secure=ConvertTo-SecureString -String $plain -AsPlainText -Force; ConvertFrom-SecureString -SecureString $secure", token);
+    await writeFile(tokenPath(), `${encrypted}\n`, { encoding: "utf8", mode: 0o600 });
+}
+async function readWindowsToken() {
+    try {
+        const encrypted = await readFile(tokenPath(), "utf8");
+        return powershell("$cipher=[Console]::In.ReadToEnd().Trim(); $secure=ConvertTo-SecureString -String $cipher; $bstr=[Runtime.InteropServices.Marshal]::SecureStringToBSTR($secure); try {[Runtime.InteropServices.Marshal]::PtrToStringBSTR($bstr)} finally {[Runtime.InteropServices.Marshal]::ZeroFreeBSTR($bstr)}", encrypted) || null;
+    }
+    catch {
+        return null;
+    }
+}
+function secretTool(args, input) {
+    const result = spawnSync("secret-tool", args, { encoding: "utf8", input, windowsHide: true });
+    return result.status === 0 ? result.stdout.trim() || null : null;
+}
+async function saveToken(token) {
+    if (platform() === "win32")
+        return saveWindowsToken(token);
+    if (platform() === "linux") {
+        if (secretTool(["store", "--label=HAD Deploy CLI", "service", service, "account", account], token) === null)
+            throw new Error("Secret Service indisponível. Instale secret-tool/libsecret ou use HAD_DEPLOY_TOKEN na sessão.");
+        return;
+    }
+    throw new Error("Armazenamento de credenciais ainda não está disponível neste sistema. Use HAD_DEPLOY_TOKEN na sessão.");
+}
+async function readStoredToken() {
+    if (platform() === "win32")
+        return readWindowsToken();
+    if (platform() === "linux")
+        return secretTool(["lookup", "service", service, "account", account]);
+    return null;
+}
+export async function saveCredentials(credentials) {
+    await writeConfig(credentials.apiUrl);
+    try {
+        await saveToken(credentials.token);
+    }
+    catch (error) {
+        await rm(configPath(), { force: true });
+        throw error;
+    }
+}
+export async function loadCredentials() {
+    const apiUrl = process.env.HAD_DEPLOY_API_URL?.replace(/\/$/, "") ?? (await readConfig())?.apiUrl;
+    const token = process.env.HAD_DEPLOY_TOKEN ?? await readStoredToken();
+    if (!apiUrl || !token)
+        throw new Error("Execute 'had login' ou defina HAD_DEPLOY_TOKEN e HAD_DEPLOY_API_URL para esta sessão.");
+    return { apiUrl, token };
+}
+export async function removeCredentials() {
+    await rm(configPath(), { force: true });
+    if (platform() === "win32")
+        await rm(tokenPath(), { force: true });
+    if (platform() === "linux")
+        secretTool(["clear", "service", service, "account", account]);
+}
+export async function credentialStatus() {
+    const config = await readConfig();
+    return { apiUrl: process.env.HAD_DEPLOY_API_URL ?? config?.apiUrl ?? null, storage: platform() === "win32" ? "Windows DPAPI" : platform() === "linux" ? "Linux Secret Service" : "Variável de ambiente" };
+}
+export function isToken(value) { return /^hd_cli_[A-Za-z0-9_-]{24,}$/.test(value); }
+export function normalizeApiUrl(value) { return new URL(value).origin; }

package/dist/index.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { credentialStatus, isToken, loadCredentials, normalizeApiUrl, removeCredentials, saveCredentials, } from "./credentials.js";
+function usage() {
+    console.error(`HAD Deploy CLI
+
+Uso:
+  had login [--api-url https://api.exemplo.com] [--token-stdin]
+  had logout
+  had config
+  had projects list
+  had apps list <project-id>
+  had deploy <project-id> <app-id>
+  had status <deployment-id>
+  had logs <deployment-id> [tail]
+
+Variáveis opcionais (inclusive para CI):
+  HAD_DEPLOY_TOKEN
+  HAD_DEPLOY_API_URL`);
+    process.exit(1);
+}
+async function request(path, init) {
+    const credentials = await loadCredentials();
+    const response = await fetch(`${credentials.apiUrl}${path}`, {
+        ...init,
+        headers: { authorization: `Bearer ${credentials.token}`, accept: "application/json", ...init?.headers },
+    });
+    if (!response.ok) {
+        const payload = (await response.json().catch(() => ({})));
+        throw new Error(payload.error?.message ?? `A API retornou HTTP ${response.status}.`);
+    }
+    return response.json();
+}
+async function prompt(question) {
+    const readline = createInterface({ input, output });
+    try {
+        return (await readline.question(question)).trim();
+    }
+    finally {
+        readline.close();
+    }
+}
+async function readStdin() {
+    let value = "";
+    for await (const chunk of input)
+        value += chunk.toString();
+    return value.trim();
+}
+async function promptSecret(question) {
+    if (!input.isTTY)
+        return prompt(question);
+    output.write(question);
+    input.setRawMode(true);
+    input.resume();
+    return new Promise((resolve, reject) => {
+        let value = "";
+        const onData = (chunk) => {
+            const character = chunk.toString("utf8");
+            if (character === "\r" || character === "\n") {
+                cleanup();
+                output.write("\n");
+                resolve(value.trim());
+            }
+            else if (character === "\u0003") {
+                cleanup();
+                reject(new Error("Login cancelado."));
+            }
+            else if (character === "\u007f" || character === "\b") {
+                value = value.slice(0, -1);
+            }
+            else {
+                value += character;
+            }
+        };
+        const cleanup = () => {
+            input.off("data", onData);
+            input.setRawMode(false);
+            input.pause();
+        };
+        input.on("data", onData);
+    });
+}
+async function login(args) {
+    const apiUrlIndex = args.indexOf("--api-url");
+    const apiInput = apiUrlIndex >= 0 ? args[apiUrlIndex + 1] : await prompt("URL da API HAD Deploy: ");
+    if (!apiInput)
+        throw new Error("A URL da API é obrigatória.");
+    const fromStdin = args.includes("--token-stdin");
+    const token = fromStdin
+        ? await readStdin()
+        : await promptSecret("Token CLI: ");
+    if (!isToken(token))
+        throw new Error("Token CLI inválido. Crie um token do tipo CLI no painel HAD Deploy.");
+    await saveCredentials({ apiUrl: normalizeApiUrl(apiInput), token });
+    console.log("Login concluído. O token foi armazenado no armazenamento protegido deste usuário.");
+}
+function printRows(rows) {
+    if (!rows.length) {
+        console.log("Nenhum recurso encontrado.");
+        return;
+    }
+    const columns = Object.keys(rows[0] ?? {});
+    const widths = columns.map((column) => Math.max(column.length, ...rows.map((row) => (row[column] ?? "").length)));
+    console.log(columns.map((column, index) => column.toUpperCase().padEnd(widths[index] ?? column.length)).join("  "));
+    console.log(widths.map((width) => "-".repeat(width)).join("  "));
+    for (const row of rows)
+        console.log(columns.map((column, index) => (row[column] ?? "").padEnd(widths[index] ?? 0)).join("  "));
+}
+export async function main(args) {
+    const [group, action, resourceId, extra] = args;
+    if (group === "login")
+        return login(args.slice(1));
+    if (group === "logout" && !action) {
+        await removeCredentials();
+        console.log("Credenciais locais removidas.");
+        return;
+    }
+    if (group === "config" && !action) {
+        const status = await credentialStatus();
+        console.log(`API: ${status.apiUrl ?? "não configurada"}\nArmazenamento: ${status.storage}`);
+        return;
+    }
+    if (group === "projects" && action === "list" && !resourceId) {
+        const { projects } = await request("/api/v1/automation/projects");
+        printRows(projects.map((project) => ({ id: project.id, name: project.name, status: project.status })));
+        return;
+    }
+    if (group === "apps" && action === "list" && resourceId) {
+        const { applications } = await request(`/api/v1/automation/projects/${encodeURIComponent(resourceId)}/apps`);
+        printRows(applications.map((application) => ({ id: application.id, name: application.name, framework: application.framework, status: application.status })));
+        return;
+    }
+    if (group === "deploy" && action && resourceId && !extra) {
+        const response = await request(`/api/v1/automation/projects/${encodeURIComponent(action)}/apps/${encodeURIComponent(resourceId)}/deployments`, { method: "POST", headers: { "idempotency-key": crypto.randomUUID() } });
+        console.log(`Deploy ${response.deployment.id} solicitado: ${response.deployment.status}`);
+        return;
+    }
+    if (group === "status" && action && !resourceId) {
+        const { deployment } = await request(`/api/v1/automation/deployments/${encodeURIComponent(action)}`);
+        printRows([{ id: deployment.id, status: deployment.status, trigger: deployment.trigger, queued: deployment.queuedAt, started: deployment.startedAt ?? "-", finished: deployment.finishedAt ?? "-", error: deployment.errorCode ?? "-" }]);
+        return;
+    }
+    if (group === "logs" && action && (!resourceId || /^\d+$/.test(resourceId))) {
+        const tail = resourceId ?? "200";
+        const { logs } = await request(`/api/v1/automation/deployments/${encodeURIComponent(action)}/logs?tail=${encodeURIComponent(tail)}`);
+        for (const log of logs)
+            console.log(`[${log.stream}] ${log.message}`);
+        return;
+    }
+    usage();
+}
+main(process.argv.slice(2)).catch((error) => {
+    console.error(error instanceof Error ? error.message : "Não foi possível concluir o comando.");
+    process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@hadcloud/deploy-cli",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "bin": {
+    "had": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node -e \"process.exit(0)\"",
+    "pack:dry-run": "npm pack --dry-run"
+  }
+}