enver-cli 1.0.0 → 1.0.2

package/README.md

@@ -13,7 +13,7 @@
   - **Smart Selection**: Choose between specific versions or instantly grab the latest backup.
 - **📁 Automated Organization**:
   - Automatically organizes backups by `project-name` and `version` (from `package.json`).
-  - **Auto-Prunning**: Keeps only the last 5 backups per version to optimize storage.
+  - **Auto-Prunning**: Keeps only the last 5 backups per project version to optimize storage.
 - **⚙️ Configurable Security**: Enable/disable encryption or set a global default password for seamless automation.
 
 ---
@@ -22,13 +22,10 @@
 
 ### 1. Installation
 
-Clone the repository and install dependencies:
+Install **Enver** globally via NPM:
 
 ```bash
-git clone <your-repo-url>
-cd Enver
-npm install
-npm run build
+npm install -g enver-cli
 ```
 
 ### 2. Authentication
@@ -53,6 +50,14 @@ enver config password
 
 ## 🚀 Usage
 
+### Help & Commands
+
+Get a full list of commands and options:
+
+```bash
+enver --help
+```
+
 ### Backup your Environment
 
 Create an encrypted backup of your current `.env` file:
@@ -105,10 +110,17 @@ Google Drive
 
 ---
 
+## 🔗 Official Repositories
+
+- **CLI Tool**: [Enver-CLI](https://github.com/NipunHemal/Enver-CLI)
+- **Background Server**: [Enver-Server](https://github.com/NipunHemal/Enver-Server)
+
+---
+
 ## 🤝 Contributing
 
 Contributions are welcome! Please feel free to submit a Pull Request.
 
 ## 📄 License
 
-MIT © 2026
+MIT © 2026 Nipuna Theekshana Hemal

package/dist/auth.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logout = logout;
+exports.getAuthenticatedClient = getAuthenticatedClient;
+const googleapis_1 = require("googleapis");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const http_1 = __importDefault(require("http"));
+const url_1 = __importDefault(require("url"));
+const open_1 = __importDefault(require("open"));
+// Placeholder for your backend URL
+const BACKEND_AUTH_URL = 'https://enver.elight.lk/auth/login';
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.env-manager');
+const TOKEN_PATH = path_1.default.join(process.cwd(), 'token.json');
+const CREDENTIALS_PATH = path_1.default.join(process.cwd(), 'credentials.json');
+/**
+ * Deletes the token.json file to log the user out.
+ */
+async function logout() {
+    if (await fs_extra_1.default.pathExists(TOKEN_PATH)) {
+        await fs_extra_1.default.remove(TOKEN_PATH);
+    }
+}
+/**
+ * Ensures the global config directory exists.
+ */
+async function ensureConfigDir() {
+    if (!(await fs_extra_1.default.pathExists(CONFIG_DIR))) {
+        await fs_extra_1.default.ensureDir(CONFIG_DIR);
+    }
+}
+/**
+ * Returns an authenticated OAuth2Client.
+ * Orchestrates local server for token capture if no token is found.
+ */
+async function getAuthenticatedClient() {
+    await ensureConfigDir();
+    // 1. Check if token exists globally
+    if (await fs_extra_1.default.pathExists(TOKEN_PATH)) {
+        const tokenData = await fs_extra_1.default.readFile(TOKEN_PATH, 'utf8');
+        const tokens = JSON.parse(tokenData);
+        // We don't have client_id/secret anymore, but the drive-env-manager 
+        // needs an OAuth2Client. Your backend should ideally provide these 
+        // or the CLI should use a shared Client ID.
+        // Assuming the backend returns tokens for a predefined client.
+        const oAuth2Client = new googleapis_1.google.auth.OAuth2();
+        oAuth2Client.setCredentials(tokens);
+        return oAuth2Client;
+    }
+    // 2. Start local server to wait for callback
+    return new Promise((resolve, reject) => {
+        const server = http_1.default.createServer(async (req, res) => {
+            const parsedUrl = url_1.default.parse(req.url || '', true);
+            if (parsedUrl.pathname === '/callback') {
+                const { access_token, refresh_token, expiry_date } = parsedUrl.query;
+                if (access_token) {
+                    const tokens = {
+                        access_token: access_token,
+                        refresh_token: refresh_token,
+                        expiry_date: expiry_date ? parseInt(expiry_date) : undefined,
+                    };
+                    await fs_extra_1.default.writeFile(TOKEN_PATH, JSON.stringify(tokens));
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end('<h1>Login Successful!</h1><p>You can close this tab and return to the CLI.</p>');
+                    server.close();
+                    const oAuth2Client = new googleapis_1.google.auth.OAuth2();
+                    oAuth2Client.setCredentials(tokens);
+                    resolve(oAuth2Client);
+                }
+                else {
+                    res.writeHead(400);
+                    res.end('Authentication failed: No access token received.');
+                    server.close();
+                    reject(new Error('Authentication failed: No access token received.'));
+                }
+            }
+        });
+        // Listen on a random free port
+        server.listen(0, 'localhost', async () => {
+            const address = server.address();
+            const port = address.port;
+            const authUrlWithPort = `${BACKEND_AUTH_URL}?port=${port}`;
+            console.log('Opening browser for authentication...');
+            console.log(`If the browser does not open, visit: ${authUrlWithPort}`);
+            await (0, open_1.default)(authUrlWithPort);
+            // 5-minute timeout
+            setTimeout(() => {
+                server.close();
+                reject(new Error('Authentication timed out after 5 minutes.'));
+            }, 5 * 60 * 1000);
+        });
+    });
+}

package/dist/config.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = getConfig;
+exports.updateConfig = updateConfig;
+exports.setPassword = setPassword;
+exports.setEncryption = setEncryption;
+exports.resetConfig = resetConfig;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.enver');
+const CONFIG_FILE = path_1.default.join(CONFIG_DIR, 'config.json');
+/**
+ * Ensures the config directory exists.
+ */
+async function ensureConfigDir() {
+    await fs_extra_1.default.ensureDir(CONFIG_DIR);
+}
+/**
+ * Gets the current global configuration.
+ */
+async function getConfig() {
+    await ensureConfigDir();
+    if (!(await fs_extra_1.default.pathExists(CONFIG_FILE))) {
+        return { encryptionEnabled: false };
+    }
+    try {
+        const config = await fs_extra_1.default.readJson(CONFIG_FILE);
+        return { encryptionEnabled: false, ...config };
+    }
+    catch (err) {
+        return { encryptionEnabled: false };
+    }
+}
+/**
+ * Updates the global configuration.
+ */
+async function updateConfig(update) {
+    await ensureConfigDir();
+    const current = await getConfig();
+    const next = { ...current, ...update };
+    await fs_extra_1.default.writeJson(CONFIG_FILE, next, { spaces: 2 });
+}
+/**
+ * Sets the default encryption password.
+ */
+async function setPassword(password) {
+    await updateConfig({ defaultPassword: password });
+}
+/**
+ * Toggles encryption globally.
+ */
+async function setEncryption(enabled) {
+    await updateConfig({ encryptionEnabled: enabled });
+}
+/**
+ * Resets all configurations to defaults.
+ */
+async function resetConfig() {
+    await fs_extra_1.default.remove(CONFIG_FILE);
+}

package/dist/crypto.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encrypt = encrypt;
+exports.decrypt = decrypt;
+const crypto_1 = __importDefault(require("crypto"));
+const ALGORITHM = 'aes-256-cbc';
+const IV_LENGTH = 16;
+const SALT_LENGTH = 64;
+const KEY_LENGTH = 32;
+const ITERATIONS = 100000;
+/**
+ * Encrypts a string using a password.
+ */
+function encrypt(text, password) {
+    const iv = crypto_1.default.randomBytes(IV_LENGTH);
+    const salt = crypto_1.default.randomBytes(SALT_LENGTH);
+    const key = crypto_1.default.pbkdf2Sync(password, salt, ITERATIONS, KEY_LENGTH, 'sha512');
+    const cipher = crypto_1.default.createCipheriv(ALGORITHM, key, iv);
+    let encrypted = cipher.update(text, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    // Return format: salt:iv:encrypted
+    return `${salt.toString('hex')}:${iv.toString('hex')}:${encrypted}`;
+}
+/**
+ * Decrypts a string using a password.
+ */
+function decrypt(encryptedData, password) {
+    const parts = encryptedData.split(':');
+    if (parts.length !== 3) {
+        throw new Error('Invalid encrypted data format.');
+    }
+    const salt = Buffer.from(parts[0], 'hex');
+    const iv = Buffer.from(parts[1], 'hex');
+    const encryptedText = parts[2];
+    const key = crypto_1.default.pbkdf2Sync(password, salt, ITERATIONS, KEY_LENGTH, 'sha512');
+    const decipher = crypto_1.default.createDecipheriv(ALGORITHM, key, iv);
+    try {
+        let decrypted = decipher.update(encryptedText, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+        return decrypted;
+    }
+    catch (err) {
+        throw new Error('Decryption failed. Incorrect password?');
+    }
+}

package/dist/drive.js

@@ -0,0 +1,280 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadEnv = uploadEnv;
+exports.downloadEnv = downloadEnv;
+const googleapis_1 = require("googleapis");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const ora_1 = __importDefault(require("ora"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const diff = __importStar(require("diff"));
+const auth_1 = require("./auth");
+const crypto_1 = require("./crypto");
+const config_1 = require("./config");
+/**
+ * Retrieves and sanitizes project metadata.
+ */
+async function getProjectDetails() {
+    let name = '';
+    let version = 'v0.0.0';
+    const packageJsonPath = path_1.default.join(process.cwd(), 'package.json');
+    if (await fs_extra_1.default.pathExists(packageJsonPath)) {
+        try {
+            const pkg = await fs_extra_1.default.readJson(packageJsonPath);
+            if (pkg.name)
+                name = pkg.name;
+            if (pkg.version)
+                version = `v${pkg.version}`;
+        }
+        catch (err) { }
+    }
+    if (!name)
+        name = path_1.default.basename(process.cwd());
+    const sanitizedName = name
+        .toLowerCase()
+        .replace(/\s+/g, '-')
+        .replace(/[^a-z0-9-]/g, '');
+    return { name: sanitizedName, version };
+}
+function getTimestamp() {
+    const now = new Date();
+    const pad = (n) => n.toString().padStart(2, '0');
+    const date = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+    const time = `${pad(now.getHours())}-${pad(now.getMinutes())}-${pad(now.getSeconds())}`;
+    return `${date}_${time}`;
+}
+async function getOrCreateFolder(drive, folderName, parentId) {
+    let query = `name = '${folderName}' and mimeType = 'application/vnd.google-apps.folder' and trashed = false`;
+    if (parentId)
+        query += ` and '${parentId}' in parents`;
+    const response = await drive.files.list({
+        q: query,
+        fields: 'files(id, name)',
+        supportsAllDrives: true,
+        includeItemsFromAllDrives: true
+    });
+    if (response.data.files && response.data.files.length > 0)
+        return response.data.files[0].id;
+    const folder = await drive.files.create({
+        requestBody: { name: folderName, mimeType: 'application/vnd.google-apps.folder', parents: parentId ? [parentId] : [] },
+        fields: 'id',
+    });
+    return folder.data.id;
+}
+async function getEncryptionPassword(spinner) {
+    const config = await (0, config_1.getConfig)();
+    if (config.defaultPassword)
+        return config.defaultPassword;
+    const wasSpinning = spinner?.isSpinning;
+    if (spinner)
+        spinner.stop();
+    const { password } = await inquirer_1.default.prompt([{
+            type: 'password',
+            name: 'password',
+            message: 'Enter encryption password:',
+            mask: '*',
+        }]);
+    if (wasSpinning && spinner)
+        spinner.start();
+    return password;
+}
+/**
+ * Prunes backups in a folder, keeping only the latest 5.
+ */
+async function pruneBackups(drive, folderId) {
+    const response = await drive.files.list({
+        q: `'${folderId}' in parents and trashed = false`,
+        fields: 'files(id, name, createdTime)',
+        orderBy: 'createdTime desc',
+        supportsAllDrives: true,
+        includeItemsFromAllDrives: true
+    });
+    const files = response.data.files || [];
+    if (files.length > 5) {
+        const toDelete = files.slice(5);
+        for (const file of toDelete) {
+            await drive.files.delete({ fileId: file.id });
+        }
+        console.log(chalk_1.default.yellow(`\nAuto-pruned ${toDelete.length} old backups.`));
+    }
+}
+async function uploadEnv(options = {}) {
+    const fileName = options.file || '.env';
+    const filePath = path_1.default.join(process.cwd(), fileName);
+    if (!(await fs_extra_1.default.pathExists(filePath))) {
+        console.error(chalk_1.default.red(`Error: ${fileName} not found.`));
+        return;
+    }
+    const spinner = (0, ora_1.default)('Authenticating...').start();
+    try {
+        const auth = await (0, auth_1.getAuthenticatedClient)();
+        const drive = googleapis_1.google.drive({ version: 'v3', auth });
+        const config = await (0, config_1.getConfig)();
+        const isEncryptionEnabled = config.encryptionEnabled !== false;
+        let contentToUpload = await fs_extra_1.default.readFile(filePath, 'utf8');
+        let extension = '';
+        if (isEncryptionEnabled) {
+            spinner.text = 'Encrypting content...';
+            const password = await getEncryptionPassword(spinner);
+            contentToUpload = (0, crypto_1.encrypt)(contentToUpload, password);
+            extension = '.enc';
+        }
+        const { name, version } = await getProjectDetails();
+        const folderName = `${name}-${version}`;
+        spinner.text = `Ensuring folder: Enver > ${folderName}...`;
+        const rootId = await getOrCreateFolder(drive, 'Enver');
+        const folderId = await getOrCreateFolder(drive, folderName, rootId);
+        const backupName = `${name}_${fileName}_${getTimestamp()}${extension}`;
+        spinner.text = `Uploading ${backupName}...`;
+        await drive.files.create({
+            requestBody: { name: backupName, mimeType: 'text/plain', parents: [folderId] },
+            media: { mimeType: 'text/plain', body: contentToUpload },
+            supportsAllDrives: true
+        });
+        spinner.succeed(chalk_1.default.green(`Successfully uploaded: ${backupName}`));
+        await pruneBackups(drive, folderId);
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red(`Upload failed: ${error.message}`));
+    }
+}
+async function downloadEnv(options = {}) {
+    const targetFileName = options.file || '.env';
+    const spinner = (0, ora_1.default)('Authenticating...').start();
+    try {
+        const auth = await (0, auth_1.getAuthenticatedClient)();
+        const drive = googleapis_1.google.drive({ version: 'v3', auth });
+        const { name, version } = await getProjectDetails();
+        const folderName = options.name || `${name}-${version}`;
+        spinner.text = `Looking for folder: ${folderName}...`;
+        const rootId = await getOrCreateFolder(drive, 'Enver');
+        // Find projector folder inside EnvManager
+        const res = await drive.files.list({
+            q: `'${rootId}' in parents and name = '${folderName}' and mimeType = 'application/vnd.google-apps.folder' and trashed = false`,
+            fields: 'files(id, name)',
+            supportsAllDrives: true,
+            includeItemsFromAllDrives: true
+        });
+        const folderId = res.data.files?.[0]?.id;
+        if (!folderId) {
+            spinner.fail(chalk_1.default.red(`\nNo backups found for project folder: ${folderName}.`));
+            console.log(chalk_1.default.gray(`\nPlease ensure you have pushed a backup for this project version first.`));
+            return;
+        }
+        spinner.text = 'Fetching backups...';
+        if (!spinner.isSpinning)
+            spinner.start();
+        const backupRes = await drive.files.list({
+            q: `'${folderId}' in parents and trashed = false`,
+            fields: 'files(id, name, createdTime)',
+            orderBy: 'createdTime desc',
+            supportsAllDrives: true,
+            includeItemsFromAllDrives: true
+        });
+        const backups = backupRes.data.files || [];
+        if (backups.length === 0) {
+            spinner.info(chalk_1.default.yellow('No backup files found.'));
+            return;
+        }
+        let selectedFileId = '';
+        if (options.latest) {
+            selectedFileId = backups[0].id;
+        }
+        else {
+            spinner.stop();
+            const { fileId } = await inquirer_1.default.prompt([{
+                    type: 'list',
+                    name: 'fileId',
+                    message: 'Select a backup to restore:',
+                    choices: backups.map(f => ({ name: `${f.name} (${f.createdTime})`, value: f.id })),
+                }]);
+            selectedFileId = fileId;
+        }
+        const selectedFile = backups.find(f => f.id === selectedFileId);
+        const isEncrypted = selectedFile?.name?.endsWith('.enc');
+        spinner.text = `Downloading ${selectedFile?.name}...`;
+        if (!spinner.isSpinning)
+            spinner.start();
+        const response = await drive.files.get({
+            fileId: selectedFileId,
+            alt: 'media',
+            supportsAllDrives: true
+        });
+        let downloadedContent = response.data;
+        if (isEncrypted) {
+            spinner.text = 'Decrypting backup...';
+            const password = await getEncryptionPassword(spinner);
+            downloadedContent = (0, crypto_1.decrypt)(downloadedContent, password);
+        }
+        spinner.stop();
+        const localPath = path_1.default.join(process.cwd(), targetFileName);
+        if (await fs_extra_1.default.pathExists(localPath)) {
+            const localContent = await fs_extra_1.default.readFile(localPath, 'utf8');
+            const changes = diff.diffLines(localContent, downloadedContent);
+            const added = changes.filter(c => c.added).length;
+            const removed = changes.filter(c => c.removed).length;
+            console.log(chalk_1.default.blue(`\nSummary: ${chalk_1.default.green(`+${added}`)} ${chalk_1.default.red(`-${removed}`)} lines changed.`));
+            const { action } = await inquirer_1.default.prompt([{
+                    type: 'list',
+                    name: 'action',
+                    message: 'How would you like to proceed?',
+                    choices: ['Show Diff', 'Overwrite/Restore', 'Cancel'],
+                }]);
+            if (action === 'Show Diff') {
+                changes.forEach((part) => {
+                    const color = part.added ? chalk_1.default.green : part.removed ? chalk_1.default.red : chalk_1.default.gray;
+                    process.stdout.write(color(part.value));
+                });
+                console.log('\n');
+                const { confirm } = await inquirer_1.default.prompt([{ type: 'confirm', name: 'confirm', message: 'Proceed with restore?', default: false }]);
+                if (!confirm)
+                    return;
+            }
+            else if (action === 'Cancel') {
+                return;
+            }
+        }
+        await fs_extra_1.default.writeFile(localPath, downloadedContent);
+        console.log(chalk_1.default.green(`\nSuccessfully restored to ${targetFileName}`));
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red(`Download failed: ${error.message}`));
+    }
+}

package/dist/{bin/index.js → index.js}

@@ -8,9 +8,9 @@ const commander_1 = require("commander");
 const dotenv_1 = __importDefault(require("dotenv"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const chalk_1 = __importDefault(require("chalk"));
-const auth_1 = require("../src/auth");
-const drive_1 = require("../src/drive");
-const config_1 = require("../src/config");
+const auth_1 = require("./auth");
+const drive_1 = require("./drive");
+const config_1 = require("./config");
 dotenv_1.default.config();
 const program = new commander_1.Command();
 program

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "enver-cli",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "A CLI tool to backup and restore .env files using Google Drive",
-  "main": "dist/bin/index.js",
+  "main": "dist/index.js",
   "bin": {
-    "enver": "./dist/bin/index.js"
+    "enver": "./dist/index.js"
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsc",
-    "start": "node dist/bin/index.js",
-    "dev": "ts-node bin/index.ts"
+    "prepublishOnly": "npm run build",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts"
   },
   "keywords": [
     "cli",

package/bin/index.ts

@@ -1,155 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import dotenv from 'dotenv';
-import inquirer from 'inquirer';
-import chalk from 'chalk';
-import { getAuthenticatedClient, logout } from '../src/auth';
-import { uploadEnv, downloadEnv } from '../src/drive';
-import { setPassword, setEncryption, resetConfig } from '../src/config';
-
-dotenv.config();
-
-const program = new Command();
-
-program
-    .name('enver')
-    .description('Backup and restore your local .env files with encryption and versioning')
-    .version('2.2.0', '-v, -V, --version');
-
-async function runSetup() {
-    console.log(chalk.blue('\n--- Initial Setup ---'));
-
-    const { encryption } = await inquirer.prompt([{
-        type: 'confirm',
-        name: 'encryption',
-        message: 'Enable encryption globally by default?',
-        default: false,
-    }]);
-
-    await setEncryption(encryption);
-
-    const { setPass } = await inquirer.prompt([{
-        type: 'confirm',
-        name: 'setPass',
-        message: 'Set a default encryption password now? (saves you from manual prompts)',
-        default: false,
-    }]);
-
-    if (setPass) {
-        const { password } = await inquirer.prompt([{
-            type: 'password',
-            name: 'password',
-            message: 'Enter your default password:',
-            mask: '*',
-        }]);
-        await setPassword(password);
-    }
-
-    console.log(chalk.green('\nSetup complete! You can change these anytime using "enver config".\n'));
-}
-
-program
-    .command('login')
-    .description('Authenticate with your Google account and run setup')
-    .action(async () => {
-        try {
-            await getAuthenticatedClient();
-            console.log(chalk.green('Successfully authenticated!'));
-            await runSetup();
-        } catch (error: any) {
-            console.error(chalk.red('Authentication failed:'), error.message);
-        }
-    });
-
-program
-    .command('logout')
-    .description('Sign out and remove authentication tokens')
-    .action(async () => {
-        await logout();
-        console.log(chalk.yellow('Successfully logged out. Credentials removed locally.'));
-    });
-
-program
-    .command('push')
-    .description('Upload local .env (encrypted) to Google Drive')
-    .option('-f, --file <filename>', 'Local filename to backup (default: .env)')
-    .action(async (options) => {
-        await uploadEnv({ file: options.file });
-    });
-
-program
-    .command('pull')
-    .description('Restore .env from Google Drive with diff preview')
-    .option('-f, --file <filename>', 'Local filename to restore to (default: .env)')
-    .option('-n, --name <project>', 'Specific project folder name')
-    .option('-l, --latest', 'Automatically pick the latest backup')
-    .action(async (options) => {
-        await downloadEnv({
-            file: options.file,
-            name: options.name,
-            latest: options.latest
-        });
-    });
-
-const config = program.command('config').description('Manage CLI configuration');
-
-config
-    .command('password')
-    .description('Set, update, or remove the default encryption password')
-    .action(async () => {
-        const { action } = await inquirer.prompt([{
-            type: 'list',
-            name: 'action',
-            message: 'What would you like to do?',
-            choices: ['Set/Update Password', 'Remove Password', 'Cancel'],
-        }]);
-
-        if (action === 'Set/Update Password') {
-            const { password } = await inquirer.prompt([{
-                type: 'password',
-                name: 'password',
-                message: 'Enter new default password:',
-                mask: '*',
-            }]);
-            await setPassword(password);
-            console.log(chalk.green('Default password updated!'));
-        } else if (action === 'Remove Password') {
-            await setPassword(undefined);
-            console.log(chalk.yellow('Default password removed. You will be prompted manually for future operations.'));
-        }
-    });
-
-config
-    .command('encryption <state>')
-    .description('Enable or disable encryption globally (on|off)')
-    .action(async (state) => {
-        if (state === 'on') {
-            await setEncryption(true);
-            console.log(chalk.green('Encryption enabled! Local files will be encrypted before upload.'));
-        } else if (state === 'off') {
-            await setEncryption(false);
-            console.log(chalk.yellow('Encryption disabled! Backups will be stored as plain text.'));
-        } else {
-            console.error(chalk.red('Invalid state. Use "on" or "off".'));
-        }
-    });
-
-config
-    .command('reset')
-    .description('Reset all global configurations to factory defaults')
-    .action(async () => {
-        const { confirm } = await inquirer.prompt([{
-            type: 'confirm',
-            name: 'confirm',
-            message: chalk.red('Are you sure you want to reset all configurations? This cannot be undone.'),
-            default: false,
-        }]);
-
-        if (confirm) {
-            await resetConfig();
-            console.log(chalk.green('Configuration reset successfully! Settings are back to factory defaults.'));
-        }
-    });
-
-program.parse(process.argv);