@envsafes-org/cli 0.0.6

package/dist/commands/login.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.login = login;
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const index_js_1 = require("../index.js");
+const api_js_1 = require("../utils/api.js");
+const open_1 = __importDefault(require("open"));
+async function login(options) {
+    let token = options.token;
+    if (!token) {
+        const dashboardUrl = index_js_1.config.get("dashboardUrl");
+        const loginUrl = `${dashboardUrl}/dashboard?redirect=tokens`;
+        console.log(chalk_1.default.cyan(`\nOuverture du navigateur pour générer un token...\n`));
+        console.log(chalk_1.default.dim(`Si le navigateur ne s'ouvre pas, visitez : ${loginUrl}`));
+        try {
+            await (0, open_1.default)(loginUrl);
+        }
+        catch (err) {
+            // Ignore error if browser fails to open
+        }
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: "password",
+                name: "token",
+                message: "Collez votre token API EnvSafe ici:",
+                mask: "*",
+                validate: (input) => input.length > 0 || "Le token est requis",
+            },
+        ]);
+        token = answers.token;
+    }
+    console.log(chalk_1.default.dim("Vérification du token..."));
+    try {
+        // Test the token
+        const response = await (0, api_js_1.apiRequest)("/api/v1/projects", {
+            method: "GET",
+            token,
+        });
+        if (response.error) {
+            console.log(chalk_1.default.red(`✗ Erreur: ${response.error}`));
+            return;
+        }
+        // Save token
+        index_js_1.config.set("token", token);
+        console.log(chalk_1.default.green("✓ Connexion réussie!"));
+        console.log(chalk_1.default.dim(`  ${response.count} projet(s) accessible(s)`));
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`✗ Erreur de connexion: ${error.message}`));
+    }
+}

package/dist/commands/projects.d.ts

@@ -0,0 +1 @@
+export declare function projects(): Promise<void>;

package/dist/commands/projects.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projects = projects;
+const chalk_1 = __importDefault(require("chalk"));
+const index_js_1 = require("../index.js");
+const api_js_1 = require("../utils/api.js");
+async function projects() {
+    const token = index_js_1.config.get("token");
+    if (!token) {
+        console.log(chalk_1.default.red("✗ Non connecté. Utilisez 'envsafe login' d'abord."));
+        return;
+    }
+    try {
+        const response = await (0, api_js_1.apiRequest)("/api/v1/projects", {
+            method: "GET",
+            token,
+        });
+        if (response.error) {
+            console.log(chalk_1.default.red(`✗ ${response.error}`));
+            return;
+        }
+        console.log(chalk_1.default.cyan("\n📁 Projets accessibles\n"));
+        if (response.projects.length === 0) {
+            console.log(chalk_1.default.dim("  Aucun projet trouvé."));
+            return;
+        }
+        for (const project of response.projects) {
+            console.log(chalk_1.default.bold(`  ${project.name}`));
+            console.log(chalk_1.default.dim(`    slug: ${project.slug}`));
+            console.log(chalk_1.default.dim(`    envs: ${project.environments.join(", ")}`));
+            console.log("");
+        }
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`✗ Erreur: ${error.message}`));
+    }
+}

package/dist/commands/pull.d.ts

@@ -0,0 +1,4 @@
+export declare function pull(project: string, options: {
+    env: string;
+    output: string;
+}): Promise<void>;

package/dist/commands/pull.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pull = pull;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const fs_1 = __importDefault(require("fs"));
+const index_js_1 = require("../index.js");
+const api_js_1 = require("../utils/api.js");
+async function pull(project, options) {
+    const token = index_js_1.config.get("token");
+    if (!token) {
+        console.log(chalk_1.default.red("✗ Non connecté. Utilisez 'envsafe login' d'abord."));
+        return;
+    }
+    const spinner = (0, ora_1.default)(`Téléchargement des variables pour ${project} (${options.env})...`).start();
+    try {
+        const response = await (0, api_js_1.apiRequest)(`/api/v1/projects/${project}/${options.env}`, {
+            method: "GET",
+            token,
+        });
+        if (response.error) {
+            spinner.fail(chalk_1.default.red(response.error));
+            // Suggestion intelligente si l'utilisateur a confondu projet et environnement
+            const commonEnvs = ["development", "dev", "staging", "stg", "production", "prod", "test"];
+            if (commonEnvs.includes(project.toLowerCase()) || response.error.includes("trouvé")) {
+                console.log(chalk_1.default.yellow("\n💡 Astuce : La syntaxe est 'envsafe pull <MON_PROJET>'"));
+                console.log(chalk_1.default.yellow(`   Vous avez essayé de pull le projet "${project}".`));
+                console.log(chalk_1.default.yellow(`   Utilisez 'envsafe projects' pour voir la liste de vos projets/slugs.`));
+            }
+            return;
+        }
+        // Format as .env content
+        const envContent = Object.entries(response.variables)
+            .map(([key, value]) => `${key}="${value}"`)
+            .join("\n");
+        // Write to file
+        fs_1.default.writeFileSync(options.output, envContent + "\n");
+        spinner.succeed(chalk_1.default.green(`✓ ${response.count} variable(s) téléchargée(s) vers ${options.output}`));
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red(`Erreur: ${error.message}`));
+    }
+}

package/dist/commands/push.d.ts

@@ -0,0 +1,4 @@
+export declare function push(project: string, options: {
+    env: string;
+    file: string;
+}): Promise<void>;

package/dist/commands/push.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.push = push;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const fs_1 = __importDefault(require("fs"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const index_js_1 = require("../index.js");
+const api_js_1 = require("../utils/api.js");
+async function push(project, options) {
+    const token = index_js_1.config.get("token");
+    if (!token) {
+        console.log(chalk_1.default.red("✗ Non connecté. Utilisez 'envsafe login' d'abord."));
+        return;
+    }
+    // Check if file exists
+    if (!fs_1.default.existsSync(options.file)) {
+        console.log(chalk_1.default.red(`✗ Fichier non trouvé: ${options.file}`));
+        return;
+    }
+    const spinner = (0, ora_1.default)(`Envoi des variables vers ${project} (${options.env})...`).start();
+    try {
+        // Parse .env file
+        const envContent = fs_1.default.readFileSync(options.file, "utf-8");
+        const parsed = dotenv_1.default.parse(envContent);
+        const response = await (0, api_js_1.apiRequest)(`/api/v1/projects/${project}/${options.env}`, {
+            method: "POST",
+            token,
+            body: { variables: parsed },
+        });
+        if (response.error) {
+            spinner.fail(chalk_1.default.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_1.default.yellow("\n💡 Astuce : La syntaxe est 'envsafe push <MON_PROJET>'"));
+                console.log(chalk_1.default.yellow(`   Vous avez essayé de push vers le projet "${project}".`));
+                console.log(chalk_1.default.yellow(`   Utilisez 'envsafe projects' pour voir la liste de vos projets/slugs.`));
+            }
+            return;
+        }
+        spinner.succeed(chalk_1.default.green(`✓ ${response.created} variable(s) créée(s)`));
+        if (response.errors?.length > 0) {
+            console.log(chalk_1.default.yellow("\nAvertissements:"));
+            response.errors.forEach((err) => {
+                console.log(chalk_1.default.dim(`  - ${err}`));
+            });
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red(`Erreur: ${error.message}`));
+    }
+}

package/dist/commands/run.d.ts

@@ -0,0 +1,3 @@
+export declare function run(project: string, command: string[], options: {
+    env: string;
+}): Promise<void>;

package/dist/commands/run.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const index_js_1 = require("../index.js");
+const api_js_1 = require("../utils/api.js");
+async function run(project, command, options) {
+    const token = index_js_1.config.get("token");
+    if (!token) {
+        console.log(chalk_1.default.red("✗ Non connecté. Utilisez 'envsafe login' d'abord."));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.dim(`Récupération des variables pour ${project} (${options.env})...`));
+    try {
+        const response = await (0, api_js_1.apiRequest)(`/api/v1/projects/${project}/${options.env}`, {
+            method: "GET",
+            token,
+        });
+        if (response.error) {
+            console.log(chalk_1.default.red(`✗ ${response.error}`));
+            process.exit(1);
+        }
+        const variables = response.variables;
+        console.log(chalk_1.default.green(`✓ ${Object.keys(variables).length} variable(s) chargée(s)`));
+        console.log(chalk_1.default.dim(`Exécution: ${command.join(" ")}\n`));
+        // Spawn the command with injected env vars
+        const [cmd, ...args] = command;
+        const child = (0, child_process_1.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_1.default.red(`Erreur d'exécution: ${err.message}`));
+            process.exit(1);
+        });
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`✗ Erreur: ${error.message}`));
+        process.exit(1);
+    }
+}

package/dist/commands/whoami.d.ts

@@ -0,0 +1 @@
+export declare function whoami(): Promise<void>;

package/dist/commands/whoami.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whoami = whoami;
+const chalk_1 = __importDefault(require("chalk"));
+const index_js_1 = require("../index.js");
+const api_js_1 = require("../utils/api.js");
+async function whoami() {
+    const token = index_js_1.config.get("token");
+    const apiUrl = index_js_1.config.get("apiUrl");
+    if (!token) {
+        console.log(chalk_1.default.red("✗ Non connecté. Utilisez 'envsafe login' d'abord."));
+        return;
+    }
+    try {
+        const user = await (0, api_js_1.apiRequest)("/api/v1/user/me", {
+            method: "GET",
+            token
+        });
+        console.log(chalk_1.default.cyan("\n🔐 EnvSafe CLI\n"));
+        console.log(`  Utilisateur: ${chalk_1.default.white(user.name)} (${chalk_1.default.dim(user.email)})`);
+        if (user.lastLoginAt) {
+            const date = new Date(user.lastLoginAt).toLocaleString();
+            console.log(`  Dernière connexion: ${chalk_1.default.dim(date)}`);
+        }
+        console.log(`  API:   ${chalk_1.default.dim(apiUrl)}`);
+        console.log(`  Token: ${chalk_1.default.dim(token.substring(0, 12) + "...")}\n`);
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`✗ Impossible de récupérer les infos utilisateur: ${error.message}`));
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import Conf from "conf";
+export declare const config: Conf<{
+    token: unknown;
+    apiUrl: unknown;
+    dashboardUrl: unknown;
+}>;

package/dist/index.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const conf_1 = __importDefault(require("conf"));
+const login_js_1 = require("./commands/login.js");
+const pull_js_1 = require("./commands/pull.js");
+const push_js_1 = require("./commands/push.js");
+const run_js_1 = require("./commands/run.js");
+const projects_js_1 = require("./commands/projects.js");
+const whoami_js_1 = require("./commands/whoami.js");
+const package_json_1 = __importDefault(require("../package.json"));
+// Config store for token
+exports.config = new conf_1.default({
+    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 commander_1.Command();
+program
+    .name("envsafe")
+    .description(chalk_1.default.cyan("🔐 EnvSafe CLI - Gestionnaire sécurisé de variables d'environnement"))
+    .version(package_json_1.default.version);
+// Login command
+program
+    .command("login")
+    .description("Se connecter avec un token API")
+    .option("-t, --token <token>", "Token API")
+    .action(login_js_1.login);
+// Whoami command
+program
+    .command("whoami")
+    .description("Afficher l'utilisateur connecté")
+    .action(whoami_js_1.whoami);
+// Projects command
+program
+    .command("projects")
+    .alias("ls")
+    .description("Lister les projets accessibles")
+    .action(projects_js_1.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_js_1.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_js_1.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_js_1.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) {
+        exports.config.set("apiUrl", options.apiUrl);
+        console.log(chalk_1.default.green(`✓ URL de l'API définie: ${options.apiUrl}`));
+    }
+    if (options.show) {
+        console.log(chalk_1.default.cyan("Configuration actuelle:"));
+        console.log(`  API URL: ${exports.config.get("apiUrl")}`);
+        console.log(`  Token: ${exports.config.get("token") ? "••••••••" : "(non défini)"}`);
+    }
+});
+// Logout command
+program
+    .command("logout")
+    .description("Se déconnecter")
+    .action(() => {
+    exports.config.set("token", "");
+    console.log(chalk_1.default.green("✓ Déconnexion réussie"));
+});
+program.parse();

package/dist/utils/api.d.ts

@@ -0,0 +1,7 @@
+interface ApiRequestOptions {
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    token?: string;
+    body?: any;
+}
+export declare function apiRequest(endpoint: string, options: ApiRequestOptions): Promise<any>;
+export {};

package/dist/utils/api.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiRequest = apiRequest;
+const index_js_1 = require("../index.js");
+async function apiRequest(endpoint, options) {
+    const apiUrl = index_js_1.config.get("apiUrl");
+    const token = options.token || index_js_1.config.get("token");
+    const url = `${apiUrl}${endpoint}`;
+    const headers = {
+        "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/package.json

@@ -0,0 +1,42 @@
+{
+    "name": "@envsafes-org/cli",
+    "version": "0.0.6",
+    "description": "CLI pour EnvSafe - Gestionnaire sécurisé de variables d'environnement",
+    "main": "dist/index.js",
+    "bin": {
+        "envsafe": "./dist/index.js"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Ifiboys/envsafe-cli.git"
+    },
+    "scripts": {
+        "build": "tsc",
+        "dev": "tsx src/index.ts",
+        "start": "node dist/index.js"
+    },
+    "keywords": [
+        "env",
+        "environment",
+        "variables",
+        "cli",
+        "secrets"
+    ],
+    "author": "EnvSafe Team",
+    "license": "MIT",
+    "dependencies": {
+        "chalk": "^5.3.0",
+        "commander": "^12.0.0",
+        "conf": "^12.0.0",
+        "dotenv": "^16.3.1",
+        "inquirer": "^9.2.12",
+        "open": "^11.0.0",
+        "ora": "^8.0.1"
+    },
+    "devDependencies": {
+        "@types/inquirer": "^9.0.7",
+        "@types/node": "^20.0.0",
+        "tsx": "^4.0.0",
+        "typescript": "^5.0.0"
+    }
+}

package/src/commands/login.ts

@@ -0,0 +1,58 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { config } from "../index.js";
+import { apiRequest } from "../utils/api.js";
+
+import open from "open";
+
+export async function login(options: { token?: string }) {
+    let token = options.token;
+
+    if (!token) {
+        const dashboardUrl = config.get("dashboardUrl") as string;
+        const loginUrl = `${dashboardUrl}/dashboard?redirect=tokens`;
+
+        console.log(chalk.cyan(`\nOuverture du navigateur pour générer un token...\n`));
+        console.log(chalk.dim(`Si le navigateur ne s'ouvre pas, visitez : ${loginUrl}`));
+
+        try {
+            await open(loginUrl);
+        } catch (err) {
+            // Ignore error if browser fails to open
+        }
+
+        const answers = await inquirer.prompt([
+            {
+                type: "password",
+                name: "token",
+                message: "Collez votre token API EnvSafe ici:",
+                mask: "*",
+                validate: (input) => input.length > 0 || "Le token est requis",
+            },
+        ]);
+        token = answers.token;
+    }
+
+    console.log(chalk.dim("Vérification du token..."));
+
+    try {
+        // Test the token
+        const response = await apiRequest("/api/v1/projects", {
+            method: "GET",
+            token,
+        });
+
+        if (response.error) {
+            console.log(chalk.red(`✗ Erreur: ${response.error}`));
+            return;
+        }
+
+        // Save token
+        config.set("token", token);
+
+        console.log(chalk.green("✓ Connexion réussie!"));
+        console.log(chalk.dim(`  ${response.count} projet(s) accessible(s)`));
+    } catch (error: any) {
+        console.log(chalk.red(`✗ Erreur de connexion: ${error.message}`));
+    }
+}

package/src/commands/projects.ts

@@ -0,0 +1,40 @@
+import chalk from "chalk";
+import { config } from "../index.js";
+import { apiRequest } from "../utils/api.js";
+
+export async function projects() {
+    const token = config.get("token") as string;
+
+    if (!token) {
+        console.log(chalk.red("✗ Non connecté. Utilisez 'envsafe login' d'abord."));
+        return;
+    }
+
+    try {
+        const response = await apiRequest("/api/v1/projects", {
+            method: "GET",
+            token,
+        });
+
+        if (response.error) {
+            console.log(chalk.red(`✗ ${response.error}`));
+            return;
+        }
+
+        console.log(chalk.cyan("\n📁 Projets accessibles\n"));
+
+        if (response.projects.length === 0) {
+            console.log(chalk.dim("  Aucun projet trouvé."));
+            return;
+        }
+
+        for (const project of response.projects) {
+            console.log(chalk.bold(`  ${project.name}`));
+            console.log(chalk.dim(`    slug: ${project.slug}`));
+            console.log(chalk.dim(`    envs: ${project.environments.join(", ")}`));
+            console.log("");
+        }
+    } catch (error: any) {
+        console.log(chalk.red(`✗ Erreur: ${error.message}`));
+    }
+}

package/src/commands/pull.ts

@@ -0,0 +1,53 @@
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs";
+import { config } from "../index.js";
+import { apiRequest } from "../utils/api.js";
+
+export async function pull(
+    project: string,
+    options: { env: string; output: string }
+) {
+    const token = config.get("token") as string;
+
+    if (!token) {
+        console.log(chalk.red("✗ Non connecté. Utilisez 'envsafe login' d'abord."));
+        return;
+    }
+
+    const spinner = ora(`Téléchargement des variables pour ${project} (${options.env})...`).start();
+
+    try {
+        const response = await apiRequest(`/api/v1/projects/${project}/${options.env}`, {
+            method: "GET",
+            token,
+        });
+
+        if (response.error) {
+            spinner.fail(chalk.red(response.error));
+
+            // Suggestion intelligente si l'utilisateur a confondu projet et environnement
+            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 pull <MON_PROJET>'"));
+                console.log(chalk.yellow(`   Vous avez essayé de pull le projet "${project}".`));
+                console.log(chalk.yellow(`   Utilisez 'envsafe projects' pour voir la liste de vos projets/slugs.`));
+            }
+            return;
+        }
+
+        // Format as .env content
+        const envContent = Object.entries(response.variables as Record<string, string>)
+            .map(([key, value]) => `${key}="${value}"`)
+            .join("\n");
+
+        // Write to file
+        fs.writeFileSync(options.output, envContent + "\n");
+
+        spinner.succeed(
+            chalk.green(`✓ ${response.count} variable(s) téléchargée(s) vers ${options.output}`)
+        );
+    } catch (error: any) {
+        spinner.fail(chalk.red(`Erreur: ${error.message}`));
+    }
+}