@ben-studios/envedit 0.0.0-stage → 1.0.1

package/cli/cmd/variableCmd/edit.ts

@@ -0,0 +1,150 @@
+import { confirm, input, password, select, checkbox } from "@inquirer/prompts";
+
+import { Configuration, EnvironmentFile, VariableType } from "#lib/config";
+import { NotFoundError } from "#lib/error";
+import { Logger } from "#lib/logger";
+
+export default {
+    command: 'edit',
+    describe: 'Edit an environment variable',
+    builder: (yargs) => yargs,
+    handler: async (argv) => {
+        const config = new Configuration();
+        const logger = new Logger(argv.level);
+
+        const name = await select({
+            message: "Select the variable to edit:",
+            choices: Array.from(config.vars.keys()),
+        });
+
+        const variableConfiguration = config.vars.get(name);
+
+        if (!variableConfiguration) {
+            throw new NotFoundError(`Variable not found: ${name}`);
+        }
+
+        const isEditingConfig = await select({
+            message: "Are you editing the variable configuration (name/type) or the variable value?",
+            choices: [
+                { name: "Configuration", value: true },
+                { name: "Value", value: false },
+            ],
+        });
+
+        if (isEditingConfig) {
+            logger.debug(`Editing variable configuration for: ${name}`);
+
+            const itemsToEdit = await checkbox({
+                message: "Select the items to edit:",
+                choices: [
+                    { name: "Name", value: "name" },
+                    { name: "Type", value: "type" },
+                ],
+            });
+
+            const updatedVariable = { ...variableConfiguration };
+
+            if (itemsToEdit.includes("name")) {
+                updatedVariable.name = await input({
+                    message: "Enter the new variable name:",
+                    default: variableConfiguration.name,
+                });
+
+                for (const [_, env] of config.envs) {
+                    const envFile = new EnvironmentFile(env.file);
+
+                    logger.debug(`Editing variable "${name}" in environment file: ${env.file}`);
+
+                    if (envFile.vars.has(name)) {
+                        const value = envFile.vars.get(name) || '';
+
+                        envFile.vars.delete(name);
+                        envFile.vars.set(updatedVariable.name, value);
+                    };
+
+                    envFile.save();
+                }
+
+                config.vars.delete(name);
+            }
+
+            if (itemsToEdit.includes("type")) {
+                updatedVariable.type = await select({
+                    message: "Select the new variable type:",
+                    choices: [
+                        { name: "Public", value: VariableType.Public },
+                        { name: "Private", value: VariableType.Private },
+                    ],
+                    default: variableConfiguration.type,
+                });
+
+                logger.debug(`Editing variable type for "${name}" to "${updatedVariable.type}"`);
+            }
+
+            config.vars.set(updatedVariable.name, updatedVariable);
+            config.save();
+        } else {
+            logger.debug(`Adding edited variable value for: ${name}`);
+
+            let valuesToSet = Array.from(config.envs.values()).map(env => ({
+                envName: env.name,
+                value: '',
+            }));
+
+            const shouldGloballySet = await confirm({
+                message: "Do you want to set this variable for all environments?",
+            });
+
+            if (shouldGloballySet) {
+                const request = {
+                    message: `Enter the global value for ${variableConfiguration.name}:`,
+                    mask: variableConfiguration.type === VariableType.Private ? "*" : undefined,
+                };
+
+                const globalValue = variableConfiguration.type === VariableType.Private
+                    ? await password(request)
+                    : await input(request);
+
+                logger.debug(`Setting variable "${variableConfiguration.name}" with global value "${globalValue}" for all environments`);
+
+                for (const [_, env] of config.envs) {
+                    const envFile = new EnvironmentFile(env.file);
+
+                    logger.debug(`Setting variable "${variableConfiguration.name}" with value "${globalValue}" in environment file: ${env.file}`);
+                    
+                    envFile.vars.set(variableConfiguration.name, globalValue);
+                    envFile.save();
+                }
+            } else {
+                const envsToEdit = await checkbox({
+                    message: "Select the environments to edit the variable value for:",
+                    choices: Array.from(config.envs.keys()),
+                });
+
+                logger.debug(`Selected environments for editing: ${envsToEdit.join(", ")}`);
+
+                for (const selectedEnv of envsToEdit) {
+                    const env = config.envs.get(selectedEnv);
+
+                    if (!env) {
+                        throw new NotFoundError(`Environment not found: ${selectedEnv}`);
+                    }
+
+                    const envFile = new EnvironmentFile(env.file);
+
+                    const request = {
+                        message: `Enter the value for ${variableConfiguration.name} in environment ${selectedEnv}:`,
+                        mask: variableConfiguration.type === VariableType.Private ? "*" : undefined,
+                    };
+
+                    const newValue = variableConfiguration.type === VariableType.Private
+                        ? await password(request)
+                        : await input(request);
+
+                    envFile.vars.set(variableConfiguration.name, newValue);
+                    envFile.save();
+                }
+            }
+        }
+    }
+} satisfies CommandModule;

package/cli/cmd/variableCmd/index.ts

@@ -0,0 +1,6 @@
+import Add from "./add";
+import Edit from "./edit";
+import List from "./list";
+import Remove from "./remove";
+
+export default [Add, Edit, List, Remove]

package/cli/cmd/variableCmd/list.ts

@@ -0,0 +1,35 @@
+import { Configuration, EnvironmentFile, VariableType } from "#lib/config";
+import { NotFoundError } from "#lib/error";
+import { Logger } from "#lib/logger";
+
+export default {
+    command: 'list',
+    describe: 'List all environment variables',
+    builder: (yargs) => yargs,
+    handler: async (argv) => {
+        const config = new Configuration();
+        const logger = new Logger(argv.level);
+
+        const activeEnv = config.active ? config.envs.get(config.active)! : undefined;
+
+        if (!activeEnv) {
+            throw new NotFoundError(`No active environment found. Please set an active environment using the "use" command.`);
+        }
+
+        const envFile = new EnvironmentFile(activeEnv.file);
+
+        for (const [key, value] of envFile.vars) {
+            const variableConfiguration = config.vars.get(key);
+            if (variableConfiguration) {
+                const type = Configuration.getTypeDetails(variableConfiguration.type);
+
+                const maskedValue = type.value === VariableType.Private ? value.replaceAll(/./gm, '*') : value;
+
+                logger
+                    .info(`Name: ${key}`)
+                    .info(`Value: ${maskedValue}`)
+                    .info(`Type: ${type.name} (${type.value})`);
+            }
+        }
+    }
+} satisfies CommandModule;

package/cli/cmd/variableCmd/remove.ts

@@ -0,0 +1,39 @@
+import { select } from "@inquirer/prompts";
+
+import { Configuration, EnvironmentFile } from "#lib/config";
+import { NotFoundError } from "#lib/error";
+import { Logger } from "#lib/logger";
+
+export default {
+    command: 'remove',
+    describe: 'Remove an environment variable',
+    builder: (yargs) => yargs,
+    handler: async (argv) => {
+        const config = new Configuration();
+        const logger = new Logger(argv.level);
+
+        const name = await select({
+            message: "Select the variable to remove:",
+            choices: Array.from(config.vars.keys()),
+        });
+
+        if (!config.vars.has(name)) {
+            throw new NotFoundError(`Variable not found: ${name}`);
+        }
+
+        logger.debug(`Removing variable "${name}" from configuration and all environment files`);
+
+        config.vars.delete(name);
+        config.save();
+
+        for (const [_, env] of config.envs) {
+            const envFile = new EnvironmentFile(env.file);
+
+            if (envFile.vars.has(name)) {
+                logger.debug(`Removing variable "${name}" from environment file: ${env.file}`);
+                envFile.vars.delete(name);
+                envFile.save();
+            }
+        }
+    }
+} satisfies CommandModule;

package/cli/index.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env bun
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+if (!process.isBun) {
+    const [red, reset] = process.stdout.isTTY && process.env.TERM !== "dumb" ? ["\x1b[31m", "\x1b[0m"] : ["", ""];
+    console.error(`${red}This script is intended to be run with Bun.${reset}`);
+    process.exit(1);
+}
+
+await yargs(hideBin(process.argv))
+    .option("level", {
+        alias: "l",
+        type: "string",
+        description: "Set the log level",
+        default: process.env.LOG_LEVEL || "info",
+    })
+    .env('ENVEDIT')
+    .scriptName("envedit")
+    .usage("Usage: $0 <command>")
+    .command(await import("./cmd/index.ts").then((mod) => mod.default))
+    .showHelpOnFail(false)
+    .demandCommand()
+    .version()
+    .alias("h", "help")
+    .alias("v", "version")
+    .strict()
+    .parseAsync();

package/lib/config.ts

@@ -0,0 +1,133 @@
+import {
+    existsSync as exists,
+    readFileSync as read,
+    writeFileSync as write,
+    appendFileSync as append,
+} from 'fs';
+
+import { parse } from 'dotenv';
+
+import { NotFoundError } from '#lib/error';
+
+export enum VariableType {
+    Public,
+    Private,
+}
+
+export interface VariableConfiguration {
+    name: string;
+    type: VariableType;
+}
+
+export interface EnvironmentConfiguration {
+    name: string;
+    prefix: string;
+    file: string;
+    isActive: boolean;
+}
+
+export interface GeneralConfiguration {
+    version: number;
+    environments: EnvironmentConfiguration[];
+    variables: VariableConfiguration[];
+}
+
+export class Configuration {
+    public readonly vars: Map<string, VariableConfiguration> = new Map();
+    public readonly envs: Map<string, EnvironmentConfiguration> = new Map();
+    public readonly version: number = 1;
+    private readonly configFilePath: string = 'env.config.yaml';
+
+    constructor() {
+        if (!exists(this.configFilePath)) {
+            this
+                .importFromEnv(exists('.env') ? read('.env', "utf-8") : '')
+                .save();
+        }
+
+        const configContent = Bun.YAML.parse(read(this.configFilePath, "utf-8")) as GeneralConfiguration;
+
+        const setWrapper = <
+            K extends EnvironmentConfiguration | VariableConfiguration
+        >(map: Map<string, K>): ((item: K) => void) => (item: K) => void map.set(item.name, item);
+
+        configContent.environments.forEach(setWrapper(this.envs))
+        configContent.variables.forEach(setWrapper(this.vars))
+    }
+
+    public save() {
+        write(
+            this.configFilePath,
+            Bun.YAML.stringify({
+                "$schema": "https://benshawmean.com/api/schema/envedit",
+                version: this.version,
+                environments: Array.from(this.envs.values()),
+                variables: Array.from(this.vars.values()),
+            }, null, 2),
+            { mode: 0o600 },
+        );
+
+        return this;
+    }
+
+    public get active() {
+        const activeEnv = Array.from(this.envs.values()).find(env => env.isActive);
+
+        return activeEnv ? activeEnv.name : undefined;
+    }
+
+    public set active(env: string | undefined) {
+        if (env && !this.envs.has(env)) {
+            throw new NotFoundError(`Environment not found: ${env}`)
+        }
+
+        for (const [name, environment] of this.envs.entries()) {
+            this.envs.set(name, { ...environment, isActive: name === env });
+        }
+
+        this.save();
+    }
+
+    public importFromEnv(content: string): Configuration {
+        for (const [key, _] of Object.entries(parse(content))) {
+            this.vars.set(key, { name: key, type: VariableType.Private });
+        }
+
+        return this;
+    }
+
+    public static getTypeDetails(type: VariableType) {
+        const VariableTypeMap = new Map<number, keyof typeof VariableType>();
+
+        for (const [key, value] of Object.entries(VariableType)) {
+            if (typeof value !== "number") continue;
+            VariableTypeMap.set(value, key as keyof typeof VariableType);
+        }
+
+        return {
+            name: VariableTypeMap.get(type)!,
+            value: type
+        };
+    }
+}
+
+export class EnvironmentFile {
+    public readonly vars: Map<string, string> = new Map();
+    constructor(public readonly path: string) {
+        if (exists(path)) {
+            const content = read(path, "utf-8");
+            const parsed = parse(content);
+
+            for (const [key, value] of Object.entries(parsed)) {
+                this.vars.set(key, value);
+            }
+        }
+    }
+
+    public save() {
+        write(this.path, '')
+        for (const [key, value] of this.vars.entries()) {
+            append(this.path, `${key}='${value}'\n`);
+        }
+    }
+}

package/lib/error.ts

@@ -0,0 +1,6 @@
+export class NotFoundError extends Error {
+    constructor(message?: string) {
+        super(message);
+        this.name = 'NotFoundError';
+    }
+};

package/lib/logger.ts

@@ -0,0 +1,40 @@
+import pino from 'pino';
+import type { LevelWithSilentOrString, Logger as PinoLogger } from 'pino';
+
+export class Logger {
+    private readonly logger: PinoLogger<never, boolean> = pino({
+        transport: {
+            target: 'pino-pretty',
+            options: {
+                colorize: true,
+                translateTime: 'SYS:standard',
+                ignore: 'pid,hostname',
+            },
+        },
+    });
+
+    constructor(public readonly level: LevelWithSilentOrString, private testMode: boolean = false) {
+        this.logger.level = level;
+    }
+
+    public readonly debug = (msg: string) => {
+        this.testMode ? '' : this.logger.debug(msg);
+        return this;
+    }
+    public readonly info = (msg: string) => {
+        this.testMode ? '' : this.logger.info(msg);
+        return this;
+    }
+    public readonly warn = (msg: string) => {
+        this.testMode ? '' : this.logger.warn(msg);
+        return this;
+    }
+    public readonly error = (msg: string) => {
+        this.testMode ? '' : this.logger.error(msg);
+        return this;
+    }
+    public readonly fatal = (msg: string) => {
+        this.testMode ? '' : this.logger.fatal(msg);
+        return this;
+    }
+}

package/package.json

@@ -1,6 +1,30 @@
 {
   "name": "@ben-studios/envedit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "type": "module",
+  "version": "1.0.1",
+  "license": "GPL-3.0-only",
+  "bin": {
+    "envedit": "cli/index.ts"
+  },
+  "repository": {
+    "url": "https://gitlab.com/ben-studios/envedit.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "@types/yargs": "^17.0.35"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.5.2",
+    "dotenv": "^17.4.2",
+    "pino": "^10.3.1",
+    "pino-pretty": "^13.1.3",
+    "yargs": "^18.1.0"
+  }
 }

package/tsconfig.json

@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "types": ["bun", "./@types/custom.d.ts"],
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false,
+
+    "paths": {
+      "@/*": ["./*"],
+      "#lib/*": ["./lib/*"]
+    }
+  }
+}