enver-cli 1.0.1 → 1.0.2

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.1",
+  "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",