@envsafes-org/cli 0.0.6

package/src/commands/push.ts

@@ -0,0 +1,64 @@
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs";
+import dotenv from "dotenv";
+import { config } from "../index.js";
+import { apiRequest } from "../utils/api.js";
+
+export async function push(
+    project: string,
+    options: { env: string; file: string }
+) {
+    const token = config.get("token") as string;
+
+    if (!token) {
+        console.log(chalk.red("✗ Non connecté. Utilisez 'envsafe login' d'abord."));
+        return;
+    }
+
+    // Check if file exists
+    if (!fs.existsSync(options.file)) {
+        console.log(chalk.red(`✗ Fichier non trouvé: ${options.file}`));
+        return;
+    }
+
+    const spinner = ora(`Envoi des variables vers ${project} (${options.env})...`).start();
+
+    try {
+        // Parse .env file
+        const envContent = fs.readFileSync(options.file, "utf-8");
+        const parsed = dotenv.parse(envContent);
+
+        const response = await apiRequest(`/api/v1/projects/${project}/${options.env}`, {
+            method: "POST",
+            token,
+            body: { variables: parsed },
+        });
+
+        if (response.error) {
+            spinner.fail(chalk.red(response.error));
+
+            // Suggestion intelligente
+            const commonEnvs = ["development", "dev", "staging", "stg", "production", "prod", "test"];
+            if (commonEnvs.includes(project.toLowerCase()) || response.error.includes("trouvé")) {
+                console.log(chalk.yellow("\n💡 Astuce : La syntaxe est 'envsafe push <MON_PROJET>'"));
+                console.log(chalk.yellow(`   Vous avez essayé de push vers le projet "${project}".`));
+                console.log(chalk.yellow(`   Utilisez 'envsafe projects' pour voir la liste de vos projets/slugs.`));
+            }
+            return;
+        }
+
+        spinner.succeed(
+            chalk.green(`✓ ${response.created} variable(s) créée(s)`)
+        );
+
+        if (response.errors?.length > 0) {
+            console.log(chalk.yellow("\nAvertissements:"));
+            response.errors.forEach((err: string) => {
+                console.log(chalk.dim(`  - ${err}`));
+            });
+        }
+    } catch (error: any) {
+        spinner.fail(chalk.red(`Erreur: ${error.message}`));
+    }
+}

package/src/commands/run.ts

@@ -0,0 +1,55 @@
+import chalk from "chalk";
+import { spawn } from "child_process";
+import { config } from "../index.js";
+import { apiRequest } from "../utils/api.js";
+
+export async function run(
+    project: string,
+    command: string[],
+    options: { env: string }
+) {
+    const token = config.get("token") as string;
+
+    if (!token) {
+        console.log(chalk.red("✗ Non connecté. Utilisez 'envsafe login' d'abord."));
+        process.exit(1);
+    }
+
+    console.log(chalk.dim(`Récupération des variables pour ${project} (${options.env})...`));
+
+    try {
+        const response = await apiRequest(`/api/v1/projects/${project}/${options.env}`, {
+            method: "GET",
+            token,
+        });
+
+        if (response.error) {
+            console.log(chalk.red(`✗ ${response.error}`));
+            process.exit(1);
+        }
+
+        const variables = response.variables as Record<string, string>;
+        console.log(chalk.green(`✓ ${Object.keys(variables).length} variable(s) chargée(s)`));
+        console.log(chalk.dim(`Exécution: ${command.join(" ")}\n`));
+
+        // Spawn the command with injected env vars
+        const [cmd, ...args] = command;
+        const child = spawn(cmd, args, {
+            env: { ...process.env, ...variables },
+            stdio: "inherit",
+            shell: true,
+        });
+
+        child.on("close", (code) => {
+            process.exit(code ?? 0);
+        });
+
+        child.on("error", (err) => {
+            console.error(chalk.red(`Erreur d'exécution: ${err.message}`));
+            process.exit(1);
+        });
+    } catch (error: any) {
+        console.log(chalk.red(`✗ Erreur: ${error.message}`));
+        process.exit(1);
+    }
+}

package/src/commands/whoami.ts

@@ -0,0 +1,33 @@
+import chalk from "chalk";
+import { config } from "../index.js";
+import { apiRequest } from "../utils/api.js";
+
+export async function whoami() {
+    const token = config.get("token") as string;
+    const apiUrl = config.get("apiUrl") as string;
+
+    if (!token) {
+        console.log(chalk.red("✗ Non connecté. Utilisez 'envsafe login' d'abord."));
+        return;
+    }
+
+    try {
+        const user = await apiRequest("/api/v1/user/me", {
+            method: "GET",
+            token
+        });
+
+        console.log(chalk.cyan("\n🔐 EnvSafe CLI\n"));
+        console.log(`  Utilisateur: ${chalk.white(user.name)} (${chalk.dim(user.email)})`);
+
+        if (user.lastLoginAt) {
+            const date = new Date(user.lastLoginAt).toLocaleString();
+            console.log(`  Dernière connexion: ${chalk.dim(date)}`);
+        }
+
+        console.log(`  API:   ${chalk.dim(apiUrl)}`);
+        console.log(`  Token: ${chalk.dim(token.substring(0, 12) + "...")}\n`);
+    } catch (error: any) {
+        console.log(chalk.red(`✗ Impossible de récupérer les infos utilisateur: ${error.message}`));
+    }
+}

package/src/index.ts

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import chalk from "chalk";
+import Conf from "conf";
+import { login } from "./commands/login.js";
+import { pull } from "./commands/pull.js";
+import { push } from "./commands/push.js";
+import { run } from "./commands/run.js";
+import { projects } from "./commands/projects.js";
+import { whoami } from "./commands/whoami.js";
+import pkg from "../package.json";
+
+// Config store for token
+export const config = new Conf({
+    projectName: "envsafe-cli",
+    schema: {
+        token: { type: "string", default: "" },
+        apiUrl: { type: "string", default: "https://envsafe.vercel.app" },
+        dashboardUrl: { type: "string", default: "https://envsafe.vercel.app" },
+    },
+});
+
+const program = new Command();
+
+program
+    .name("envsafe")
+    .description(chalk.cyan("🔐 EnvSafe CLI - Gestionnaire sécurisé de variables d'environnement"))
+    .version(pkg.version);
+
+// Login command
+program
+    .command("login")
+    .description("Se connecter avec un token API")
+    .option("-t, --token <token>", "Token API")
+    .action(login);
+
+// Whoami command
+program
+    .command("whoami")
+    .description("Afficher l'utilisateur connecté")
+    .action(whoami);
+
+// Projects command
+program
+    .command("projects")
+    .alias("ls")
+    .description("Lister les projets accessibles")
+    .action(projects);
+
+// Pull command
+program
+    .command("pull")
+    .description("Télécharger les variables d'environnement")
+    .argument("<project>", "Slug du projet")
+    .option("-e, --env <environment>", "Environnement (development, staging, production)", "development")
+    .option("-o, --output <file>", "Fichier de sortie", ".env")
+    .action(pull);
+
+// Push command
+program
+    .command("push")
+    .description("Envoyer les variables d'environnement")
+    .argument("<project>", "Slug du projet")
+    .option("-e, --env <environment>", "Environnement", "development")
+    .option("-f, --file <file>", "Fichier source", ".env")
+    .action(push);
+
+// Run command
+program
+    .command("run")
+    .description("Exécuter une commande avec les variables d'environnement injectées")
+    .argument("<project>", "Slug du projet")
+    .option("-e, --env <environment>", "Environnement", "development")
+    .argument("<command...>", "Commande à exécuter")
+    .action(run);
+
+// Config command
+program
+    .command("config")
+    .description("Gérer la configuration")
+    .option("--api-url <url>", "Définir l'URL de l'API EnvSafe")
+    .option("--show", "Afficher la configuration actuelle")
+    .action((options) => {
+        if (options.apiUrl) {
+            config.set("apiUrl", options.apiUrl);
+            console.log(chalk.green(`✓ URL de l'API définie: ${options.apiUrl}`));
+        }
+        if (options.show) {
+            console.log(chalk.cyan("Configuration actuelle:"));
+            console.log(`  API URL: ${config.get("apiUrl")}`);
+            console.log(`  Token: ${config.get("token") ? "••••••••" : "(non défini)"}`);
+        }
+    });
+
+// Logout command
+program
+    .command("logout")
+    .description("Se déconnecter")
+    .action(() => {
+        config.set("token", "");
+        console.log(chalk.green("✓ Déconnexion réussie"));
+    });
+
+program.parse();

package/src/utils/api.ts

@@ -0,0 +1,36 @@
+import { config } from "../index.js";
+
+interface ApiRequestOptions {
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    token?: string;
+    body?: any;
+}
+
+export async function apiRequest(endpoint: string, options: ApiRequestOptions) {
+    const apiUrl = config.get("apiUrl") as string;
+    const token = options.token || (config.get("token") as string);
+
+    const url = `${apiUrl}${endpoint}`;
+
+    const headers: Record<string, string> = {
+        "Content-Type": "application/json",
+    };
+
+    if (token) {
+        headers["Authorization"] = `Bearer ${token}`;
+    }
+
+    const response = await fetch(url, {
+        method: options.method,
+        headers,
+        body: options.body ? JSON.stringify(options.body) : undefined,
+    });
+
+    const data = await response.json();
+
+    if (!response.ok && !data.error) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    return data;
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "declaration": true,
+        "resolveJsonModule": true
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
+}