envmgr-cli 1.0.0

package/README.md

@@ -0,0 +1,89 @@
+# 🚀 EnvMgr CLI Documentation
+
+EnvMgr is a CLI tool designed to manage your environment variables across different projects and environments with ease. It provides both a beautiful interactive dashboard and powerful standalone commands.
+
+---
+
+## 🏗️ Getting Started
+
+### 1. Configuration
+Set your API server URL (default: `https://envmgr.vercel.app`).
+```bash
+envmgr configure
+```
+
+### 2. Login
+Authenticate your CLI session.
+```bash
+envmgr login
+```
+
+### 3. Link Project
+Connect your current directory to a remote EnvMgr project. This creates a `.envmgr/config.json` file to track your linkage.
+```bash
+envmgr link
+```
+
+---
+
+## ⚡ Core Workflow Commands
+
+### 🔄 Syncing Variables (Remote → Local)
+Pull the latest variables from the remote server into your local environment file (e.g., `.env.local`).
+```bash
+envmgr sync
+```
+*Use `--dry-run` to see what would change without modifying files:* `envmgr sync --dry-run`
+
+### 📤 Pushing Variables (Local → Remote)
+Push your local variables back to the remote server. The CLI will ask for confirmation before updating.
+```bash
+envmgr push
+```
+
+### 🔀 Switch Environment
+Quickly switch between different environments (e.g., staging, production) within your linked project.
+```bash
+envmgr switch [alias|name]
+```
+
+---
+
+## 🛠️ Management Commands
+
+### 📁 Add Variables (External Editor)
+Bulk add variables by opening your default system editor (Vim, Notepad, etc.). 
+```bash
+envmgr var add
+```
+
+### ➕ Create Environment
+Interactively create a new environment for a project.
+```bash
+envmgr env create
+```
+
+### 📋 System Status
+View your current login status, API URL, and project linkage details.
+```bash
+envmgr status
+```
+
+### 🩺 Doctor
+Run a self-diagnostic check to troubleshoot connectivity or configuration issues.
+```bash
+envmgr doctor
+```
+
+---
+
+## 💡 Pro Tips
+
+- **Interactive Mode**: Simply run `envmgr` without any arguments to open the management dashboard.
+- **JSON Output**: Use `--json` with the `status` command for machine-readable output.
+- **Escape Key**: Use the `Esc` key on any interactive screen to cancel and go back.
+- **Security**: The `.envmgr/` folder and `.env*` files are automatically ignored in your provided `.gitignore` to keep secrets safe.
+
+---
+
+*Need more help? Run `envmgr --help` any time.*

package/dist/api/client.js

@@ -0,0 +1,27 @@
+import { getApiUrl, getToken } from "../config/config.js";
+const DEFAULT_BASE_URL = "http://localhost:3000";
+function resolveBaseUrl() {
+    return (getApiUrl() ||
+        process.env.ENVMGR_API_URL ||
+        DEFAULT_BASE_URL);
+}
+export async function apiFetch(path, options = {}) {
+    const token = getToken();
+    const baseUrl = resolveBaseUrl();
+    const headers = {
+        "Content-Type": "application/json",
+        ...options.headers,
+    };
+    if (token) {
+        headers.Authorization = `Bearer ${token}`;
+    }
+    const res = await fetch(`${baseUrl}${path}`, {
+        ...options,
+        headers,
+    });
+    const data = await res.json();
+    if (!res.ok) {
+        throw new Error(data.message || "Request failed");
+    }
+    return data;
+}

package/dist/api/service.js

@@ -0,0 +1,64 @@
+import { getToken, getApiUrl } from '../config/config.js';
+import chalk from 'chalk';
+import { performance } from 'perf_hooks';
+export async function fetchWithAuth(url, options = {}) {
+    const token = getToken();
+    const isDebug = process.env.ENVMGR_DEBUG === '1';
+    const method = options.method || 'GET';
+    const headers = {
+        'Content-Type': 'application/json',
+        ...options.headers,
+        ...(token ? { 'Authorization': `Bearer ${token}` } : {}),
+    };
+    if (isDebug) {
+        console.log(`${chalk.blue('→')} ${chalk.bold(method)} ${chalk.dim(url)}`);
+    }
+    const start = performance.now();
+    const response = await fetch(url, { ...options, headers });
+    const duration = Math.round(performance.now() - start);
+    if (isDebug) {
+        const statusColor = response.ok ? chalk.green : chalk.red;
+        console.log(`${chalk.blue('←')} ${statusColor(response.status)} ${response.statusText} ${chalk.dim(`(${duration}ms)`)}`);
+    }
+    if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(errorData.message || `API error: ${response.status}`);
+    }
+    return response.json();
+}
+export async function fetchProjects(search = '', page = 1, limit = 10) {
+    const apiUrl = getApiUrl();
+    const query = new URLSearchParams({ search, page: page.toString(), limit: limit.toString() });
+    return fetchWithAuth(`${apiUrl}/api/projects?${query.toString()}`);
+}
+export async function fetchEnvironments(projectId, search = '') {
+    const apiUrl = getApiUrl();
+    const query = new URLSearchParams({ projectId, search });
+    return fetchWithAuth(`${apiUrl}/api/environments?${query.toString()}`);
+}
+export async function fetchVariables(environmentId) {
+    const apiUrl = getApiUrl();
+    const query = new URLSearchParams({ environmentId });
+    return fetchWithAuth(`${apiUrl}/api/variables?${query.toString()}`);
+}
+export async function createEnvironment(name, projectId) {
+    const apiUrl = getApiUrl();
+    return fetchWithAuth(`${apiUrl}/api/environments`, {
+        method: 'POST',
+        body: JSON.stringify({ name, projectId })
+    });
+}
+export async function createVariable(key, value, isSecret, environmentId) {
+    const apiUrl = getApiUrl();
+    return fetchWithAuth(`${apiUrl}/api/variables`, {
+        method: 'POST',
+        body: JSON.stringify({ key, value, isSecret, environmentId })
+    });
+}
+export async function bulkCreateVariables(environmentId, variables) {
+    const apiUrl = getApiUrl();
+    return fetchWithAuth(`${apiUrl}/api/variables/bulk`, {
+        method: 'POST',
+        body: JSON.stringify({ environmentId, variables })
+    });
+}

package/dist/commands/config.js

@@ -0,0 +1,17 @@
+import chalk from "chalk";
+import { setApiUrl } from "../config/config.js";
+export function configSet(key, value) {
+    if (key !== "api-url") {
+        console.log(chalk.red("❌ Unknown config key"));
+        process.exit(1);
+    }
+    try {
+        new URL(value);
+    }
+    catch {
+        console.log(chalk.red("❌ Invalid URL"));
+        process.exit(1);
+    }
+    setApiUrl(value);
+    console.log(chalk.green(`✅ API URL set to ${value}`));
+}

package/dist/commands/configure.js

@@ -0,0 +1,30 @@
+import { confirm, input } from "@inquirer/prompts";
+import { ui } from "../ui/index.js";
+import { setApiUrl } from "../config/config.js";
+import { DEFAULT_API_URL } from "../constants.js";
+export async function configure() {
+    ui.box("EnvMgr CLI Setup", "Let’s get you connected 🚀");
+    const isSelfHosted = await confirm({
+        message: "Is this a self-hosted EnvMgr instance?",
+        default: false,
+    });
+    if (!isSelfHosted) {
+        setApiUrl(DEFAULT_API_URL);
+        ui.success("Using default EnvMgr API");
+        return;
+    }
+    const apiUrl = await input({
+        message: "Enter API URL:",
+        validate(value) {
+            try {
+                new URL(value);
+                return true;
+            }
+            catch {
+                return "Please enter a valid URL";
+            }
+        },
+    });
+    setApiUrl(apiUrl);
+    ui.success("Configuration saved");
+}

package/dist/commands/doctor.js

@@ -0,0 +1,105 @@
+import chalk from 'chalk';
+import figures from 'figures';
+import fs from 'fs';
+import path from 'path';
+import { getApiUrl, getToken } from '../config/config.js';
+export async function doctor() {
+    console.log(chalk.bold('\nEnvMgr Diagnostics\n'));
+    // 1. Check API URL
+    const apiUrl = getApiUrl();
+    if (!apiUrl) {
+        console.log(`${chalk.red(figures.cross)} API URL not configured. Use ${chalk.cyan('envmgr configure')} to set it.`);
+    }
+    else {
+        try {
+            const res = await fetch(`${apiUrl}/api/health`, { method: 'HEAD' }).catch(() => null);
+            if (res && res.ok) {
+                console.log(`${chalk.green(figures.tick)} API reachable: ${chalk.dim(apiUrl)}`);
+            }
+            else {
+                console.log(`${chalk.red(figures.cross)} API not reachable at ${chalk.dim(apiUrl)}`);
+            }
+        }
+        catch (err) {
+            console.log(`${chalk.red(figures.cross)} API not reachable at ${chalk.dim(apiUrl)}`);
+        }
+    }
+    // 2. Check Token / Auth
+    const token = getToken();
+    if (!token) {
+        console.log(`${chalk.red(figures.cross)} Not authenticated. Use ${chalk.cyan('envmgr login')} to sign in.`);
+    }
+    else {
+        try {
+            const res = await fetch(`${apiUrl}/api/auth/me`, {
+                headers: { 'Authorization': `Bearer ${token}` }
+            });
+            if (res.ok) {
+                const data = await res.json();
+                console.log(`${chalk.green(figures.tick)} Authenticated as ${chalk.cyan(data.data?.email || 'unknown user')}`);
+            }
+            else {
+                console.log(`${chalk.red(figures.cross)} Token invalid or expired. Please login again.`);
+            }
+        }
+        catch (err) {
+            console.log(`${chalk.red(figures.cross)} Failed to verify authentication.`);
+        }
+    }
+    // 3. Check Project Link
+    const configPath = path.join(process.cwd(), '.envmgr', 'config.json');
+    let localConfig = null;
+    if (!fs.existsSync(configPath)) {
+        console.log(`${chalk.yellow(figures.warning)} No project linked in this directory.`);
+    }
+    else {
+        try {
+            localConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            console.log(`${chalk.green(figures.tick)} Project linked: ${chalk.cyan(localConfig.projectName)}`);
+            // 4. Verify Environment
+            if (apiUrl && token) {
+                try {
+                    const res = await fetch(`${apiUrl}/api/environments?projectId=${localConfig.projectId}`, {
+                        headers: { 'Authorization': `Bearer ${token}` }
+                    });
+                    if (res.ok) {
+                        const envs = await res.json();
+                        const exists = envs.data.some((e) => e.id === localConfig.environmentId);
+                        if (exists) {
+                            console.log(`${chalk.green(figures.tick)} Environment exists: ${chalk.cyan(localConfig.environmentName)}`);
+                        }
+                        else {
+                            console.log(`${chalk.red(figures.cross)} Environment ${chalk.dim(localConfig.environmentName)} no longer exists or you lack access.`);
+                        }
+                    }
+                    else {
+                        console.log(`${chalk.red(figures.cross)} Failed to verify environment.`);
+                    }
+                }
+                catch (err) {
+                    console.log(`${chalk.red(figures.cross)} Failed to connect to API for environment verification.`);
+                }
+            }
+            // 5. Check Env File Writable
+            const envFilePath = path.join(process.cwd(), localConfig.envFilePath || '.env.local');
+            try {
+                if (fs.existsSync(envFilePath)) {
+                    fs.accessSync(envFilePath, fs.constants.W_OK);
+                    console.log(`${chalk.green(figures.tick)} Target file writable: ${chalk.dim(localConfig.envFilePath || '.env.local')}`);
+                }
+                else {
+                    // Check if directory is writable to create it
+                    fs.accessSync(path.dirname(envFilePath), fs.constants.W_OK);
+                    console.log(`${chalk.green(figures.tick)} Target location writable (file will be created): ${chalk.dim(localConfig.envFilePath || '.env.local')}`);
+                }
+            }
+            catch (err) {
+                console.log(`${chalk.red(figures.cross)} Target file not writable: ${chalk.dim(localConfig.envFilePath || '.env.local')}`);
+            }
+        }
+        catch (err) {
+            console.log(`${chalk.red(figures.cross)} Failed to read local config at .envmgr/config.json`);
+        }
+    }
+    console.log('');
+}

package/dist/commands/help.js

@@ -0,0 +1,42 @@
+import chalk from 'chalk';
+import boxen from 'boxen';
+export function help() {
+    const usage = `
+${chalk.bold('Usage:')}
+  ${chalk.cyan('envmgr')} [command] [options]
+
+${chalk.bold('Commands:')}
+  ${chalk.green('link')}       Link current directory to an EnvMgr project (Interactive)
+  ${chalk.green('switch')}     Switch environment using name or alias (e.g., envmgr switch prod)
+  ${chalk.green('sync')}       Pull latest variables from remote to local file
+  ${chalk.green('push')}       Push local variables from .env file to remote environment
+  ${chalk.green('env create')} Add a new environment to a project
+  ${chalk.green('var add')}    Add variables (single or bulk paste) to an environment
+  ${chalk.green('status')}     Show current configuration and link status
+  ${chalk.green('doctor')}     Run self-diagnostics to troubleshoot issues
+  ${chalk.green('configure')}  Set API URL and global settings
+  ${chalk.green('login')}      Authenticate with your EnvMgr account
+  ${chalk.green('logout')}     Sign out and clear local credentials
+
+${chalk.bold('Options:')}
+  ${chalk.yellow('--json')}     Output status in machine-readable JSON format
+  ${chalk.yellow('--dry-run')}  Preview sync changes without modifying files
+  ${chalk.yellow('--debug')}    Show verbose API request/response logs
+  ${chalk.yellow('--help')}     Show this help message
+
+${chalk.bold('Examples:')}
+  ${chalk.dim('$')} envmgr link
+  ${chalk.dim('$')} envmgr switch prod
+  ${chalk.dim('$')} envmgr sync --dry-run
+  ${chalk.dim('$')} envmgr push
+  ${chalk.dim('$')} envmgr status --json
+	`;
+    console.log(boxen(usage, {
+        padding: 1,
+        margin: 1,
+        borderStyle: 'round',
+        borderColor: 'cyan',
+        title: 'EnvMgr CLI Help',
+        titleAlignment: 'center'
+    }));
+}

package/dist/commands/import.js

@@ -0,0 +1,64 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { spawnSync } from 'child_process';
+import chalk from 'chalk';
+import figures from 'figures';
+import { bulkCreateVariables } from '../api/service.js';
+export async function importVariables() {
+    const configPath = path.join(process.cwd(), '.envmgr', 'config.json');
+    if (!fs.existsSync(configPath)) {
+        console.log(`${chalk.red(figures.cross)} No project linked. Run ${chalk.cyan('envmgr link')} first.`);
+        process.exit(1);
+    }
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    console.log(chalk.bold(`\nImport Variables to ${chalk.cyan(config.environmentName)}`));
+    console.log(chalk.dim('Opening editor... Paste your variables in KEY=VALUE format, save and close.\n'));
+    const tmpFile = path.join(os.tmpdir(), `.envmgr-import-${Date.now()}.env`);
+    const initialContent = `# Paste your variables below (KEY=VALUE format)
+# Lines starting with # are ignored
+# Example:
+# API_URL=https://api.example.com
+# SECRET_KEY=12345
+`;
+    fs.writeFileSync(tmpFile, initialContent);
+    const editor = process.env.EDITOR || (process.platform === 'win32' ? 'notepad' : 'vi');
+    spawnSync(editor, [tmpFile], { stdio: 'inherit' });
+    const content = fs.readFileSync(tmpFile, 'utf-8');
+    fs.unlinkSync(tmpFile);
+    const lines = content.split('\n');
+    const variables = [];
+    lines.forEach(line => {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            return;
+        let key = '', value = '';
+        if (trimmed.includes('=')) {
+            const [k, ...v] = trimmed.split('=');
+            key = k.trim();
+            value = v.join('=').trim();
+        }
+        else if (trimmed.includes(':')) {
+            const [k, ...v] = trimmed.split(':');
+            key = k.trim();
+            value = v.join(':').trim();
+        }
+        if (key) {
+            const isSecret = /SECRET|PASSWORD|TOKEN|KEY|AUTH|CREDENTIAL|PRIVATE/i.test(key);
+            variables.push({ key, value, isSecret });
+        }
+    });
+    if (variables.length === 0) {
+        console.log(`${chalk.yellow(figures.warning)} No variables found. Canceled.`);
+        return;
+    }
+    console.log(`${chalk.blue(figures.play)} Adding ${variables.length} variables...`);
+    try {
+        await bulkCreateVariables(config.environmentId, variables);
+        console.log(`${chalk.green(figures.tick)} Successfully added ${chalk.bold(variables.length)} variables!`);
+        console.log(`Run ${chalk.cyan('envmgr sync')} to update your local file.`);
+    }
+    catch (err) {
+        console.log(`${chalk.red(figures.cross)} Failed to add variables: ${err.message}`);
+    }
+}

package/dist/commands/login.js

@@ -0,0 +1,38 @@
+import { input, password } from "@inquirer/prompts";
+import { ui } from "../ui/index.js";
+import { saveToken } from "../config/config.js";
+import { requireApiConfig } from "../config/guard.js";
+export async function login() {
+    const apiUrl = requireApiConfig();
+    const email = await input({
+        message: "Email:",
+    });
+    const pass = await password({
+        message: "Password:",
+        mask: "•",
+    });
+    const spinner = ui.spinner("Logging in…").start();
+    try {
+        const res = await fetch(`${apiUrl}/api/auth/login`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                email,
+                password: pass,
+                client: "cli",
+            }),
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            spinner.fail("Login failed");
+            ui.error(data.message);
+            process.exit(1);
+        }
+        saveToken(data.data.token);
+        spinner.succeed("Logged in successfully");
+    }
+    catch {
+        spinner.fail("Unable to reach server");
+        process.exit(1);
+    }
+}

package/dist/commands/status.js

@@ -0,0 +1,43 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { getApiUrl, getToken } from '../config/config.js';
+export async function status(options = {}) {
+    const apiUrl = getApiUrl();
+    const token = getToken();
+    let localConfig = null;
+    try {
+        const localConfigPath = path.join(process.cwd(), '.envmgr', 'config.json');
+        if (fs.existsSync(localConfigPath)) {
+            localConfig = JSON.parse(fs.readFileSync(localConfigPath, 'utf-8'));
+        }
+    }
+    catch (err) {
+        // Ignore
+    }
+    if (options.json) {
+        const output = {
+            authenticated: !!token,
+            apiUrl: apiUrl || null,
+            project: localConfig?.projectName || null,
+            environment: localConfig?.environmentName || null,
+            envFile: localConfig?.envFilePath || null
+        };
+        console.log(JSON.stringify(output, null, 2));
+        return;
+    }
+    // Text-based status (for non-interactive shell usage)
+    console.log(chalk.bold('\nEnvMgr Status\n'));
+    console.log(`${chalk.bold('API URL:')} ${apiUrl ? chalk.green(apiUrl) : chalk.red('Not configured')}`);
+    console.log(`${chalk.bold('Auth Status:')} ${token ? chalk.green('Authenticated') : chalk.red('Not logged in')}`);
+    if (localConfig) {
+        console.log(`\n${chalk.bold('Local Project Linkage')}`);
+        console.log(`${chalk.bold('  Project:')} ${chalk.green(localConfig.projectName)}`);
+        console.log(`${chalk.bold('  Environment:')} ${chalk.yellow(localConfig.environmentName)}`);
+        console.log(`${chalk.bold('  Linked File:')} ${chalk.dim(localConfig.envFilePath)}`);
+    }
+    else {
+        console.log(`\n${chalk.dim('No project linked in this directory')}`);
+    }
+    console.log('');
+}

package/dist/commands/switch.js

@@ -0,0 +1,59 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import figures from 'figures';
+import { getApiUrl, getToken } from '../config/config.js';
+import { fetchEnvironments } from '../api/service.js';
+export async function handleSwitch(args) {
+    const target = args[0];
+    if (!target) {
+        console.log(`${chalk.red(figures.cross)} Please specify an environment name or alias.`);
+        console.log(`Usage: ${chalk.cyan('envmgr switch <environment|alias>')}`);
+        process.exit(1);
+    }
+    const configPath = path.join(process.cwd(), '.envmgr', 'config.json');
+    if (!fs.existsSync(configPath)) {
+        console.log(`${chalk.red(figures.cross)} No project linked in this directory. Use ${chalk.cyan('envmgr link')} first.`);
+        process.exit(1);
+    }
+    let config;
+    try {
+        config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    }
+    catch (err) {
+        console.log(`${chalk.red(figures.cross)} Failed to read .envmgr/config.json`);
+        process.exit(1);
+    }
+    // Resolve alias
+    let envName = target;
+    if (config.envAliases && config.envAliases[target]) {
+        envName = config.envAliases[target];
+        console.log(`${chalk.dim(`Resolved alias ${chalk.cyan(target)} to ${chalk.cyan(envName)}`)}`);
+    }
+    const apiUrl = getApiUrl();
+    const token = getToken();
+    if (!apiUrl || !token) {
+        console.log(`${chalk.red(figures.cross)} You must be logged in and configured to switch environments.`);
+        process.exit(1);
+    }
+    try {
+        console.log(`${chalk.blue(figures.play)} Searching for environment "${envName}"...`);
+        const { data: envs } = await fetchEnvironments(config.projectId, envName);
+        const matchedEnv = envs.find((e) => e.name.toLowerCase() === envName.toLowerCase());
+        if (!matchedEnv) {
+            console.log(`${chalk.red(figures.cross)} Environment "${envName}" not found in project "${config.projectName}".`);
+            process.exit(1);
+        }
+        // Update config
+        config.environmentId = matchedEnv.id;
+        config.environmentName = matchedEnv.name;
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        console.log(`${chalk.green(figures.tick)} Switched to environment: ${chalk.bold(matchedEnv.name)}`);
+        console.log(`${chalk.dim(`Project: ${config.projectName}`)}`);
+        console.log(`\nRun ${chalk.cyan('envmgr sync')} to update your local file.`);
+    }
+    catch (err) {
+        console.log(`${chalk.red(figures.cross)} Failed to switch environment: ${err.message}`);
+        process.exit(1);
+    }
+}