@envsafes-org/cli 0.0.6

package/README.md

@@ -0,0 +1,343 @@
+# 🔐 EnvSafe CLI
+
+**Gestionnaire sécurisé de variables d'environnement pour vos équipes**
+
+[![npm version](https://img.shields.io/npm/v/@envsafes-org/cli.svg)](https://www.npmjs.com/package/@envsafes-org/cli)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+EnvSafe CLI vous permet de gérer vos variables d'environnement de manière sécurisée avec chiffrement de bout en bout. Idéal pour les équipes qui veulent centraliser leurs secrets sans compromettre la sécurité.
+
+## 🛑 Prérequis
+
+Avant d'utiliser la CLI, vous devez créer un compte et un projet sur **[https://envsafe.vercel.app](https://envsafe.vercel.app)**.
+
+## 📦 Installation
+
+```bash
+# Installation globale (recommandé)
+npm install -g @envsafes-org/cli
+
+# Avec yarn
+yarn global add @envsafes-org/cli
+
+# Avec pnpm
+pnpm add -g @envsafes-org/cli
+
+# Utilisation ponctuelle sans installation
+npx @envsafes-org/cli
+```
+
+## 🚀 Démarrage rapide
+
+```bash
+# 1. Connectez-vous avec votre token API
+envsafe login
+
+# 2. Listez vos projets
+envsafe projects
+
+# 3. Récupérez vos variables
+envsafe pull mon-projet
+
+# 4. Ou exécutez directement avec injection
+envsafe run mon-projet -- npm start
+```
+
+## 📖 Commandes
+
+### `envsafe login`
+
+Authentifiez-vous avec un token d'accès personnel (PAT).
+
+```bash
+# Mode interactif
+envsafe login
+
+# Avec token direct (CI/CD)
+envsafe login --token es_live_xxxxxxxxxxxxx
+```
+
+**💡 Générer un token :** Rendez-vous dans votre Dashboard → Settings → API Tokens
+
+---
+
+### `envsafe projects` (alias: `ls`)
+
+Listez tous les projets accessibles.
+
+```bash
+envsafe projects
+# ou
+envsafe ls
+```
+
+---
+
+### `envsafe pull <project>`
+
+Téléchargez les variables d'environnement dans un fichier local.
+
+```bash
+# Environnement de développement (par défaut)
+envsafe pull mon-projet
+
+# Environnement spécifique
+envsafe pull mon-projet --env staging
+envsafe pull mon-projet --env production
+
+# Fichier de sortie personnalisé
+envsafe pull mon-projet --output .env.local
+envsafe pull mon-projet --env production --output .env.prod
+```
+
+**Options:**
+- `-e, --env <environment>` : Environnement (development, staging, production) - Défaut: `development`
+- `-o, --output <file>` : Fichier de sortie - Défaut: `.env`
+
+---
+
+### `envsafe push <project>`
+
+Envoyez vos variables locales vers EnvSafe (chiffrées automatiquement).
+
+```bash
+# Envoyer .env vers development
+envsafe push mon-projet
+
+# Environnement et fichier spécifiques
+envsafe push mon-projet --env production --file .env.prod
+```
+
+**Options:**
+- `-e, --env <environment>` : Environnement cible - Défaut: `development`
+- `-f, --file <file>` : Fichier source - Défaut: `.env`
+
+---
+
+### `envsafe run <project> -- <command>`
+
+**⭐️ Commande recommandée** : Exécutez une commande avec les variables injectées directement, sans créer de fichier `.env` sur le disque.
+
+```bash
+# Développement
+envsafe run mon-projet -- npm start
+envsafe run mon-projet -- npm run dev
+
+# Production
+envsafe run mon-projet --env production -- node server.js
+
+# Autres exemples
+envsafe run mon-projet -- pnpm build
+envsafe run mon-projet -- python main.py
+envsafe run mon-projet -- docker-compose up
+```
+
+**Avantages:**
+- ✅ Plus sécurisé (pas de fichier .env sur le disque)
+- ✅ Idéal pour CI/CD
+- ✅ Pas de risque de commit accidentel de secrets
+
+---
+
+### `envsafe whoami`
+
+Affichez les informations du compte connecté.
+
+```bash
+envsafe whoami
+```
+
+---
+
+### `envsafe logout`
+
+Déconnectez-vous (supprime le token local).
+
+```bash
+envsafe logout
+```
+
+---
+
+### `envsafe config`
+
+Gérez la configuration de la CLI.
+
+```bash
+# Afficher la configuration actuelle
+envsafe config --show
+
+# Changer l'URL de l'API (pour instances self-hosted)
+envsafe config --api-url https://votre-instance.com
+```
+
+---
+
+## 🔧 Utilisation en CI/CD
+
+### Méthode recommandée : Variable d'environnement
+
+Définissez `ENVSAFE_TOKEN` comme secret dans votre CI/CD, puis utilisez directement les commandes sans `login`.
+
+#### GitHub Actions
+
+```yaml
+name: Deploy
+on: [push]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Install EnvSafe CLI
+        run: npm install -g @envsafes-org/cli
+      
+      - name: Run tests with EnvSafe
+        env:
+          ENVSAFE_TOKEN: ${{ secrets.ENVSAFE_TOKEN }}
+        run: |
+          envsafe run mon-projet --env staging -- npm test
+      
+      - name: Deploy to production
+        env:
+          ENVSAFE_TOKEN: ${{ secrets.ENVSAFE_TOKEN }}
+        run: |
+          envsafe run mon-projet --env production -- npm run build
+          envsafe run mon-projet --env production -- npm run deploy
+```
+
+#### GitLab CI
+
+```yaml
+deploy:
+  stage: deploy
+  script:
+    - npm install -g @envsafes-org/cli
+    - envsafe run mon-projet --env production -- npm run deploy
+  variables:
+    ENVSAFE_TOKEN: $ENVSAFE_TOKEN_SECRET
+```
+
+#### Docker
+
+```dockerfile
+FROM node:20-alpine
+
+# Installer la CLI
+RUN npm install -g @envsafes-org/cli
+
+WORKDIR /app
+COPY . .
+
+# Injecter les variables au démarrage
+CMD ["envsafe", "run", "mon-projet", "--env", "production", "--", "npm", "start"]
+```
+
+---
+
+## 💡 Exemples d'utilisation
+
+### Développement local
+
+```bash
+# Option 1 : Fichier .env (traditionnel)
+envsafe pull mon-projet
+npm run dev
+
+# Option 2 : Injection directe (recommandé)
+envsafe run mon-projet -- npm run dev
+```
+
+### Script de déploiement
+
+```bash
+#!/bin/bash
+# deploy.sh
+
+# Charger les variables de production et déployer
+envsafe run mon-projet --env production -- npm run build
+envsafe run mon-projet --env production -- npm run deploy
+```
+
+### Tests automatisés
+
+```bash
+# Exécuter les tests avec les variables de staging
+envsafe run mon-projet --env staging -- npm test
+```
+
+### Multi-environnements
+
+```bash
+# Développement
+envsafe run mon-projet --env development -- npm run dev
+
+# Staging
+envsafe run mon-projet --env staging -- npm run build
+
+# Production
+envsafe run mon-projet --env production -- npm start
+```
+
+---
+
+## 🔐 Sécurité
+
+EnvSafe utilise une architecture de chiffrement de bout en bout :
+
+- **Chiffrement des variables** : AES-256-GCM
+- **Gestion des clés** : RSA-2048 avec chiffrement asymétrique
+- **Transport** : TLS 1.3
+- **Zero Knowledge** : Vos clés privées ne quittent jamais votre machine
+
+### Bonnes pratiques
+
+✅ **À faire :**
+- Utilisez `ENVSAFE_TOKEN` en CI/CD
+- Configurez des dates d'expiration pour vos tokens
+- Privilégiez `envsafe run` pour éviter les fichiers .env
+- Révoquez immédiatement les tokens compromis
+
+❌ **À éviter :**
+- Ne commitez jamais vos tokens dans Git
+- N'utilisez pas `--token` en ligne de commande (visible dans l'historique)
+- Ne partagez pas vos tokens par email/Slack
+
+---
+
+## 🌍 Variables d'environnement
+
+| Variable | Description | Exemple |
+|----------|-------------|---------|
+| `ENVSAFE_TOKEN` | Token d'authentification (recommandé en CI/CD) | `es_live_xxx...` |
+| `ENVSAFE_API_URL` | URL de l'API (pour instances self-hosted) | `https://api.example.com` |
+
+---
+
+## 📚 Documentation complète
+
+Pour plus d'informations, consultez la [documentation officielle](https://envsafe.vercel.app/docs).
+
+---
+
+## 🐛 Signaler un bug
+
+Si vous rencontrez un problème, [ouvrez une issue](https://github.com/Ifiboys/envsafe-cli/issues).
+
+---
+
+## 📄 Licence
+
+MIT © EnvSafe Team
+
+---
+
+## 🤝 Contribuer
+
+Les contributions sont les bienvenues ! Consultez notre [guide de contribution](CONTRIBUTING.md).
+
+---
+
+Made with ❤️ by the EnvSafe Team

package/STORAGE_AGENT_README.md

@@ -0,0 +1,328 @@
+# EnvSafe Storage Agent (BYOS)
+
+Agent simple pour héberger vos secrets chiffrés EnvSafe sur votre propre infrastructure.
+
+## Qu'est-ce que c'est ?
+
+Cet agent vous permet de stocker vos secrets chiffrés sur **votre propre serveur** au lieu du cloud EnvSafe, tout en continuant à utiliser l'interface EnvSafe et la CLI.
+
+## ⚠  Rappel Important de Sécurité
+
+**Même avec cet agent sur votre serveur, vos données sont DÉJÀ chiffrées (AES-256-GCM).** 
+
+- **Cet agent ne peut PAS lire vos secrets**
+- Il stocke uniquement du texte illisible
+- **Seule votre clé privée locale peut déchiffrer les données**
+- EnvSafe (SaaS) ne peut pas non plus lire vos secrets
+
+## Installation
+
+### Prérequis
+
+- Docker et Docker Compose
+- Node.js 18+ (si vous lancez sans Docker)
+
+### Avec Docker (Recommandé)
+
+```bash
+# Cloner ce dépôt
+git clone https://github.com/Ifiboys/envsafe-storage-agent
+cd envsafe-storage-agent
+
+# Configurer les variables d'environnement
+cp .env.example .env
+# Éditez .env et définissez AUTH_SECRET avec une valeur très sécurisée
+
+# Lancer l'agent
+docker-compose up -d
+```
+
+### Sans Docker
+
+```bash
+npm install
+npm run build
+npm start
+```
+
+## Configuration
+
+### Variables d'environnement
+
+```bash
+# SECRET PARTAGÉ - Utilisez un générateur de mots de passe sécurisé
+AUTH_SECRET=your-very-long-and-secure-secret-here
+
+# Port d'écoute
+PORT=3001
+
+# Base de données (SQLite par défaut, PostgreSQL recommandé en production)
+DATABASE_URL=file:./envsafe-storage.db
+# Exemple PostgreSQL:
+# DATABASE_URL=postgresql://user:password@localhost:5432/envsafe_storage
+```
+
+### Génération du secret
+
+```bash
+# Utilisez cette commande pour générer un secret sécurisé:
+openssl rand -hex 32
+```
+
+## Configuration dans EnvSafe
+
+1. Allez dans votre projet EnvSafe
+2. Paramètres → Stockage
+3. Activez **"Stockage Externe (BYOS)"**
+4. Renseignez:
+   - **URL**: `https://votre-serveur.com` (l'URL où votre agent est accessible)
+   - **Secret**: Le même `AUTH_SECRET` que vous avez défini dans `.env`
+5. Cliquez sur **"Tester la connexion"**
+6. Si le test est réussi, sauvegardez
+
+## API Endpoints
+
+L'agent expose ces routes (toutes protégées par authentification):
+
+- `GET /health` - Vérification de la santé de l'agent
+- `POST /store-secret` - Stocke un secret chiffré
+- `GET /get-secret` - Récupère un secret chiffré
+- `GET /get-all-secrets` - Récupère tous les secrets d'un environnement
+- `DELETE /delete-secret` - Supprime un secret
+
+## Exemple de Code de l'Agent
+
+Voici un exemple complet d'agent de stockage (Node.js + Express):
+
+```typescript
+import express, { Request, Response } from "express";
+import crypto from "crypto";
+import { PrismaClient } from "@prisma/client";
+
+const app = express();
+const prisma = new PrismaClient();
+
+app.use(express.json());
+
+// ⚠️ IMPORTANT: Cet agent stocke UNIQUEMENT des données CHIFFRÉES
+// Il ne peut PAS lire vos secrets
+
+// Middleware d'authentification
+const authenticate = (req: Request, res: Response, next: Function) => {
+    const authHeader = req.headers.authorization;
+    const timestamp = req.headers["x-envsafe-timestamp"] as string;
+    const signature = req.headers["x-envsafe-signature"] as string;
+
+    if (!authHeader || !timestamp || !signature) {
+        return res.status(401).json({ error: "Missing authentication headers" });
+    }
+
+    const token = authHeader.replace("Bearer ", "");
+    const expectedSecret = process.env.AUTH_SECRET;
+
+    if (!expectedSecret) {
+        console.error("AUTH_SECRET not configured");
+        return res.status(500).json({ error: "Server misconfiguration" });
+    }
+
+    // Vérifier le token
+    if (token !== expectedSecret) {
+        console.warn(`Failed authentication attempt from ${req.ip}`);
+        return res.status(401).json({ error: "Invalid token" });
+    }
+
+    // Vérifier la signature HMAC
+    const expectedSignature = crypto
+        .createHmac("sha256", expectedSecret)
+        .update(timestamp)
+        .digest("hex");
+
+    if (signature !== expectedSignature) {
+        console.warn(`Invalid HMAC signature from ${req.ip}`);
+        return res.status(401).json({ error: "Invalid signature" });
+    }
+
+    // Vérifier que le timestamp n'est pas trop ancien (5 minutes max)
+    const now = Date.now();
+    const requestTime = parseInt(timestamp);
+    if (Math.abs(now - requestTime) > 5 * 60 * 1000) {
+        return res.status(401).json({ error: "Request expired" });
+    }
+
+    next();
+};
+
+// Health check
+app.get("/health", authenticate, (req: Request, res: Response) => {
+    res.json({ 
+        status: "healthy",
+        timestamp: new Date().toISOString(),
+        version: "1.0.0"
+    });
+});
+
+// Stocker un secret chiffré
+app.post("/store-secret", authenticate, async (req: Request, res: Response) => {
+    const { key, encryptedValue, environmentId } = req.body;
+
+    if (!key || !encryptedValue || !environmentId) {
+        return res.status(400).json({ error: "Missing required fields" });
+    }
+
+    try {
+        // Note: encryptedValue est déjà chiffré par le client
+        // L'agent ne fait que le stocker, il ne peut pas le lire
+        await prisma.encryptedVariable.upsert({
+            where: {
+                environmentId_key: { environmentId, key }
+            },
+            create: { key, encryptedValue, environmentId },
+            update: { encryptedValue }
+        });
+
+        console.log(`✅ Stored encrypted variable: ${key} for env: ${environmentId}`);
+        res.json({ success: true });
+    } catch (error) {
+        console.error("Error storing variable:", error);
+        res.status(500).json({ error: "Failed to store variable" });
+    }
+});
+
+// Récupérer un secret chiffré
+app.get("/get-secret", authenticate, async (req: Request, res: Response) => {
+    const { key, environmentId } = req.query;
+
+    if (!key || !environmentId) {
+        return res.status(400).json({ error: "Missing required parameters" });
+    }
+
+    try {
+        const variable = await prisma.encryptedVariable.findUnique({
+            where: {
+                environmentId_key: {
+                    environmentId: environmentId as string,
+                    key: key as string
+                }
+            }
+        });
+
+        if (!variable) {
+            return res.status(404).json({ error: "Variable not found" });
+        }
+
+        // Retourne la valeur chiffrée (toujours illisible)
+        res.json({ encryptedValue: variable.encryptedValue });
+    } catch (error) {
+        console.error("Error getting variable:", error);
+        res.status(500).json({ error: "Failed to get variable" });
+    }
+});
+
+const PORT = process.env.PORT || 3001;
+
+app.listen(PORT, () => {
+    console.log(`🔐 EnvSafe Storage Agent running on port ${PORT}`);
+    console.log(`⚠️  Reminder: This agent stores ENCRYPTED data only`);
+    console.log(`⚠️  Even with database access, secrets remain unreadable`);
+});
+```
+
+### Schéma Prisma pour l'agent
+
+```prisma
+// prisma/schema.prisma (pour l'agent de stockage)
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+model EncryptedVariable {
+  id             String   @id @default(cuid())
+  key            String
+  encryptedValue String   @map("encrypted_value") // Toujours chiffré (AES-256-GCM)
+  environmentId  String   @map("environment_id")
+  
+  createdAt      DateTime @default(now()) @map("created_at")
+  updatedAt      DateTime @updatedAt @map("updated_at")
+
+  @@unique([environmentId, key])
+  @@map("encrypted_variables")
+}
+```
+
+## Sécurité
+
+### Authentification
+
+Toutes les requêtes doivent inclure:
+- `Authorization: Bearer <AUTH_SECRET>`
+- `X-EnvSafe-Timestamp: <timestamp>`
+- `X-EnvSafe-Signature: <HMAC-SHA256>`
+
+### Ce que l'agent NE FAIT PAS
+
+- ❌ Il ne stocke PAS de secrets en clair
+- ❌ Il ne peut PAS déchiffrer vos données
+- ❌ Il n'a PAS accès à vos clés de déchiffrement
+
+### Ce qu'il FAIT
+
+- ✅ Il stocke des blobs chiffrés (texte illisible)
+- ✅ Il vérifie l'authentification HMAC des requêtes
+- ✅ Il refuse les requêtes non autorisées
+
+## Production
+
+### Recommandations
+
+1. **HTTPS Obligatoire** : Utilisez un reverse proxy (Nginx, Caddy) avec certificat SSL
+2. **Base de données externe** : Utilisez PostgreSQL au lieu de SQLite
+3. **Firewall** : Limitez l'accès à l'IP du serveur EnvSafe
+4. **Backups** : Configurez des sauvegardes régulières de votre base de données
+5. **Monitoring** : Surveillez les logs et les tentatives d'accès
+
+### Exemple Nginx
+
+```nginx
+server {
+    listen 443 ssl http2;
+    server_name envsafe-storage.votre-domaine.com;
+
+    ssl_certificate /etc/letsencrypt/live/votre-domaine.com/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/votre-domaine.com/privkey.pem;
+
+    location / {
+        proxy_pass http://localhost:3001;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+    }
+}
+```
+
+## Logs
+
+Les logs de l'agent incluent:
+- Tentatives d'authentification (succès/échecs)
+- Opérations de stockage/récupération
+- Erreurs système
+
+```bash
+# Voir les logs en temps réel
+docker-compose logs -f
+```
+
+## Support
+
+Pour toute question ou problème:
+- Documentation: https://envsafe.vercel.app/docs
+- Issues: https://github.com/Ifiboys/envsafe-storage-agent/issues
+- Email: oladokunefi123@gmail.com
+
+## Licence
+
+MIT - Voir LICENSE

package/dist/commands/login.d.ts

@@ -0,0 +1,3 @@
+export declare function login(options: {
+    token?: string;
+}): Promise<void>;