envelope-env 1.0.0

package/LICENSE.md

@@ -0,0 +1,13 @@
+DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+Version 2, December 2004
+
+Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+Everyone is permitted to copy and distribute verbatim or modified
+copies of this license document, and changing it is allowed as long
+as the name is changed.
+
+DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+0. You just DO WHAT THE FUCK YOU WANT TO.

package/README.md

@@ -0,0 +1,191 @@
+# Envelope 📨
+
+Envelope is a CLI tool that compiles a `.env` from a set of
+
+## Installation
+
+### Global Installation
+
+```bash
+npm install -g envelope
+```
+
+### Local Development
+
+```bash
+git clone <repository-url>
+cd envelope-node
+npm install
+npm run build
+```
+
+## Project Structure
+
+Envelope expects your project to have the following structure:
+
+```
+your-project/
+├── env/                    # Environment configuration directory
+│   ├── .env                # Common environment variables (shared across all envs)
+│   ├── development/
+│   │   └── .env            # Development-specific variables
+│   ├── staging/
+│   │   └── .env            # Staging-specific variables
+│   ├── production/
+│   │   └── .env            # Production-specific variables
+│   └── some-custom-env/
+│       └── .env            # Production-specific variables
+├── .env                    # Compiled by running `envelope use <environment name>`
+└── ...
+```
+
+Alternatively you can use the `.env.<name>` syntax:
+
+```
+your-project/
+├── env/                     # Environment configuration directory
+│   ├── .env                 # Common environment variables (shared across all envs)
+│   ├── .env.development     # Development-specific variables
+│   ├── .env.staging         # Staging environment
+│   ├── .env.production      # Production environment
+│   └── .env.some-custom-env # Production environment
+├── .env                     # Compiled by running `envelope use <environment name>`
+└── ...
+```
+
+## Usage
+
+### Commands
+
+#### `envelope list`
+
+List all available environments in your project.
+
+```bash
+envelope list
+```
+
+**Output:**
+
+```
+Available environments: development, staging, production
+```
+
+#### `envelope get <environment>`
+
+Display the compiled environment variables for a specific environment without writing to file.
+
+```bash
+envelope get development
+envelope get production --silent
+```
+
+**Options:**
+
+- `--silent, -s` - Suppress status messages
+
+#### `envelope use <environment>`
+
+Compile and write environment variables for a specific environment to your project's `.env` file.
+
+```bash
+envelope use development
+envelope use production --silent
+```
+
+**Options:**
+
+- `--silent, -s` - Suppress status messages
+
+### Examples
+
+#### Setting up a new environment
+
+1. Create your environment directory:
+
+```bash
+mkdir -p env/staging
+```
+
+2. Create environment-specific variables:
+
+```bash
+# env/staging/.env
+DATABASE_URL=postgresql://staging:pass@localhost:5432/staging_db
+API_URL=https://staging-api.example.com
+LOG_LEVEL=debug
+```
+
+3. Use the environment:
+
+```bash
+envelope use staging
+```
+
+#### Viewing environment variables
+
+```bash
+# View development environment variables
+envelope get development
+
+# View production environment variables silently
+envelope get production --silent
+```
+
+## Environment File Format
+
+Environment files follow standard `.env` format:
+
+```bash
+# Comments start with #
+DATABASE_URL=postgresql://localhost:5432/mydb
+API_KEY=your-secret-key
+DEBUG=true
+
+# Empty lines are allowed
+
+# Variables can contain spaces and special characters
+COMPLEX_VALUE="This is a complex value with spaces"
+```
+
+## Environment Variable Precedence
+
+When compiling environment variables, Envelope follows this order:
+
+1. **Base variables** - `ENVELOPE_ENV` and `ENVELOPE_DIR` are always set
+2. **Common variables** - From `env/.env` (if it exists)
+3. **Environment-specific variables** - From `env/<environment>/.env`
+
+Environment-specific variables will override common variables with the same name.
+
+## Development
+
+### Building
+
+```bash
+npm run build
+```
+
+### Development Mode
+
+```bash
+npm run dev
+```
+
+### Testing
+
+```bash
+npm test
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests if applicable
+5. Submit a pull request
+
+## License
+
+WTFPL

package/dist/index.cjs

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/main.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_dotenv = __toESM(require("dotenv"), 1);
+var import_citty = require("citty");
+
+// package.json
+var version = "1.0.0";
+
+// src/main.ts
+var import_consola = require("consola");
+var log = (0, import_consola.createConsola)({
+  level: 3,
+  fancy: true
+});
+function getConfDir() {
+  let currentDir = process.cwd();
+  while (true) {
+    const configDir = import_path.default.join(currentDir, "config");
+    if (import_fs.default.existsSync(configDir) && import_fs.default.statSync(configDir).isDirectory()) {
+      return configDir;
+    }
+    const parentDir = import_path.default.dirname(currentDir);
+    if (parentDir === currentDir) {
+      throw new Error("Could not find config directory");
+    }
+    currentDir = parentDir;
+  }
+}
+function getEnvDir(env) {
+  const confDir = getConfDir();
+  const envDir = import_path.default.join(confDir, env);
+  if (import_fs.default.existsSync(envDir) && import_fs.default.statSync(envDir).isDirectory()) {
+    return envDir;
+  }
+  throw new Error(`Could not find directory ${envDir}`);
+}
+function validateEnvString(envVars) {
+  const lines = envVars.split("\n");
+  const validLineRegex = /^(\s*#.*|\s*$|[A-Za-z_][A-Za-z0-9_]*\s*=\s*.*)$/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!validLineRegex.test(line)) {
+      throw new Error(`invalid .env format at line ${i + 1}: ${line}`);
+    }
+  }
+  return true;
+}
+function getCompiledEnv(env) {
+  const envDir = getEnvDir(env);
+  const confDir = getConfDir();
+  const commonEnvPath = import_path.default.join(confDir, ".env");
+  const envEnvPath = import_path.default.join(envDir, ".env");
+  let envVars = "";
+  if (import_fs.default.existsSync(commonEnvPath)) {
+    envVars += import_fs.default.readFileSync(commonEnvPath, "utf-8");
+  }
+  if (import_fs.default.existsSync(envEnvPath)) {
+    envVars += "\n" + import_fs.default.readFileSync(envEnvPath, "utf-8");
+  }
+  validateEnvString(envVars);
+  return import_dotenv.default.parse(envVars);
+}
+function getEnvDetails(env) {
+  const compiledEnv = getCompiledEnv(env);
+  return Object.entries(compiledEnv).map(([key, value]) => `${key}=${value}`).join("\n");
+}
+function applyEnv(env) {
+  const compiledEnv = getCompiledEnv(env);
+  const envDir = getEnvDir(env);
+  process.env.ENV_DIR = envDir;
+  Object.entries(compiledEnv).forEach(([key, value]) => {
+    process.env[key] = value;
+  });
+}
+var main = (0, import_citty.defineCommand)({
+  meta: {
+    name: "envelope",
+    version,
+    description: "\u{1F4E8}"
+  },
+  subCommands: {
+    use: (0, import_citty.defineCommand)({
+      meta: {
+        name: "use",
+        description: "use an environment"
+      },
+      args: {
+        environment: {
+          type: "positional",
+          description: "the environment name"
+        }
+      },
+      async run({ args }) {
+        try {
+          applyEnv(args.environment);
+          log.success(`Using environment: ${args.environment}`);
+        } catch (error) {
+          log.error(error);
+        }
+      }
+    }),
+    get: (0, import_citty.defineCommand)({
+      meta: {
+        name: "get",
+        description: "prints environment details"
+      },
+      args: {
+        environment: {
+          type: "positional",
+          description: "the environment name",
+          required: false
+        }
+      },
+      async run({ args }) {
+        if (args.environment === void 0) {
+          const usage = await (0, import_citty.renderUsage)(this);
+          return log.info(usage);
+        }
+        try {
+          const details = getEnvDetails(args.environment);
+          log.info(details);
+        } catch (error) {
+          log.error(error);
+        }
+      }
+    }),
+    list: (0, import_citty.defineCommand)({
+      meta: {
+        name: "list",
+        description: "List all dev environment variables"
+      },
+      run() {
+        console.log("Listing all dev environment variables");
+      }
+    })
+  },
+  async run(opts) {
+    if (opts.args.help || opts.cmd === void 0) {
+      const usage = await (0, import_citty.renderUsage)(this);
+      log.info(usage);
+      return;
+    }
+  }
+});
+
+// src/index.ts
+var import_citty2 = require("citty");
+(0, import_citty2.runMain)(main);

package/dist/index.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import fs from "node:fs";
+import path from "node:path";
+import dotenv from "dotenv";
+import { defineCommand, renderUsage } from "citty";
+
+// package.json
+var version = "1.0.0";
+
+// src/main.ts
+import { createConsola } from "consola";
+var log = createConsola({
+  level: 3,
+  fancy: true
+});
+function getRootDir() {
+  let currentDir = process.cwd();
+  while (true) {
+    const configDir = path.join(currentDir, "env");
+    if (fs.existsSync(configDir) && fs.statSync(configDir).isDirectory()) {
+      return currentDir;
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      throw new Error("Could not find env directory");
+    }
+    currentDir = parentDir;
+  }
+}
+function getRootEnvDir() {
+  const rootDir = getRootDir();
+  return path.join(rootDir, "env");
+}
+function validateEnvString(envVars) {
+  const lines = envVars.split("\n");
+  const validLineRegex = /^(\s*#.*|\s*$|[A-Za-z_][A-Za-z0-9_]*\s*=\s*.*)$/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!validLineRegex.test(line)) {
+      throw new Error(`invalid .env format at line ${i + 1}: ${line}`);
+    }
+  }
+  return true;
+}
+function assertSingleEnvMode(rootEnvDir) {
+  const entries = fs.readdirSync(rootEnvDir, { withFileTypes: true });
+  const hasSubdirs = entries.some(
+    (e) => e.isDirectory() && e.name !== "node_modules"
+  );
+  const hasFlatFiles = entries.some(
+    (e) => e.isFile() && /^\.env\../.test(e.name)
+  );
+  if (hasSubdirs && hasFlatFiles) {
+    throw new Error(
+      `Incompatible environment modes detected in '${rootEnvDir}': found both subdirectories (directory mode) and .env.* files (flat mode). Use one layout or the other, not both.`
+    );
+  }
+}
+async function getCompiledEnv(env, opts) {
+  const rootEnvDir = getRootEnvDir();
+  assertSingleEnvMode(rootEnvDir);
+  const envSubDir = path.join(rootEnvDir, env);
+  const flatEnvFile = path.join(rootEnvDir, `.env.${env}`);
+  const isDirectoryMode = fs.existsSync(envSubDir) && fs.statSync(envSubDir).isDirectory();
+  const isFlatMode = !isDirectoryMode && fs.existsSync(flatEnvFile);
+  if (!isDirectoryMode && !isFlatMode) {
+    throw new Error(
+      `Could not find environment '${env}': no directory '${envSubDir}' or file '${flatEnvFile}'`
+    );
+  }
+  const envDir = isDirectoryMode ? envSubDir : rootEnvDir;
+  let envVars = "";
+  envVars += `ENVELOPE_ENV=${env}
+`;
+  envVars += `ENVELOPE_DIR=${envDir}
+`;
+  const envFiles = [
+    { path: path.join(rootEnvDir, ".env"), name: "common" },
+    {
+      path: isDirectoryMode ? path.join(envSubDir, ".env") : flatEnvFile,
+      name: env
+    }
+  ];
+  for (const file of envFiles) {
+    if (fs.existsSync(file.path)) {
+      if (opts?.silent !== true)
+        log.info(`Reading ${file.name} environment variables from ${file.path}`);
+      envVars += "\n" + fs.readFileSync(file.path, "utf-8");
+    }
+  }
+  validateEnvString(envVars);
+  return dotenv.parse(envVars);
+}
+async function compileDotEnv(env, silent) {
+  const compiledEnv = await getCompiledEnv(env, {
+    silent
+  });
+  return Object.entries(compiledEnv).map(([key, value]) => `${key}=${value}`).join("\n");
+}
+var main = defineCommand({
+  meta: {
+    name: "envelope",
+    version,
+    description: "\u{1F4E8}"
+  },
+  subCommands: {
+    get: defineCommand({
+      meta: {
+        name: "get",
+        description: "Print environment variables to console"
+      },
+      args: {
+        silent: {
+          type: "boolean",
+          description: "Do not log status messages",
+          alias: ["s"]
+        },
+        environment: {
+          type: "positional",
+          description: "The environment name",
+          required: true
+        }
+      },
+      async run({ args }) {
+        try {
+          const silent = !!args.silent;
+          const env = await compileDotEnv(args.environment, silent);
+          log.box(env);
+        } catch (error) {
+          log.error(`Error in 'get' command: ${error.message}`);
+        }
+      }
+    }),
+    use: defineCommand({
+      meta: {
+        name: "use",
+        description: "Compile a .env file for the given environment"
+      },
+      args: {
+        silent: {
+          type: "boolean",
+          description: "Do not log status messages",
+          alias: ["s"]
+        },
+        environment: {
+          type: "positional",
+          description: "The environment name",
+          required: true
+        }
+      },
+      async run({ args }) {
+        const silent = !!args.silent;
+        try {
+          if (!silent) {
+            log.info(`Compiling environment variables for ${args.environment}`);
+          }
+          const env = await compileDotEnv(args.environment, silent);
+          const rootDir = getRootDir();
+          if (!silent) {
+            log.success(
+              `Compiled environment variables for ${args.environment}: to ${rootDir}/.env`
+              // TODO: this is not correct
+            );
+          }
+          fs.writeFileSync(path.join(rootDir, ".env"), env, "utf-8");
+        } catch (error) {
+          if (!silent) log.error(error);
+          process.exit(1);
+        }
+      }
+    }),
+    list: defineCommand({
+      meta: {
+        name: "list",
+        description: "List all available environments"
+      },
+      run() {
+        try {
+          const rootEnvDir = getRootEnvDir();
+          assertSingleEnvMode(rootEnvDir);
+          const entries = fs.readdirSync(rootEnvDir, { withFileTypes: true });
+          const environments = [
+            ...entries.filter((e) => e.isDirectory() && e.name !== "node_modules").map((e) => e.name),
+            ...entries.filter((e) => e.isFile() && /^\.env\../.test(e.name)).map((e) => e.name.slice(5))
+          ];
+          log.info("Available environments: " + environments.join(", "));
+        } catch (error) {
+          log.error(`Error listing environments: ${error.message}`);
+          process.exit(1);
+        }
+      }
+    }),
+    current: defineCommand({
+      meta: {
+        name: "current",
+        description: "Print current environment"
+      },
+      run() {
+        try {
+          const rootDir = getRootDir();
+          const envFilePath = path.join(rootDir, ".env");
+          if (!fs.existsSync(envFilePath)) {
+            throw new Error("Oopsie");
+          }
+          const envString = fs.readFileSync(envFilePath, "utf-8");
+          validateEnvString(envString);
+          const parsed = dotenv.parse(envString);
+          if (!parsed.ENVELOPE_ENV) {
+            throw new Error("Could not parse ENVELOPE_ENV");
+          }
+          log.info(`The current environment is: ${parsed.ENVELOPE_ENV}`);
+        } catch (error) {
+          log.error(`Error getting current environment: ${error.message}`);
+          process.exit(1);
+        }
+      }
+    })
+  },
+  args: {
+    help: {
+      type: "boolean",
+      description: "show help"
+    }
+  },
+  async run(opts) {
+    if (opts.args.help || opts.rawArgs.length === 0) {
+      const usage = await renderUsage(this);
+      log.info(usage);
+      return;
+    }
+  }
+});
+
+// src/index.ts
+import { runMain } from "citty";
+await runMain(main);

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "envelope-env",
+  "version": "1.0.0",
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --target es2022",
+    "start": "node dist/index.js",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --onSuccess \"node dist/index.js\"",
+    "test": "vitest"
+  },
+  "keywords": ["env", "environment variables", "dx"],
+  "author": "Maximillian George",
+  "license": "ISC",
+  "description": "Organise multiple environments in /env and compile into root .env by name",
+  "dependencies": {
+    "c12": "^1.11.2",
+    "citty": "^0.1.6",
+    "consola": "^3.2.3",
+    "defu": "^6.1.4",
+    "dotenv": "^16.4.5",
+    "glob": "^11.0.0"
+  },
+  "devDependencies": {
+    "@types/dotenv": "^6.1.1",
+    "@types/node": "^22.5.5",
+    "memfs": "^4.12.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.2",
+    "vite": "^5.4.7",
+    "vitest": "^2.1.1"
+  },
+  "bin": {
+    "envelope": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module"
+}