@motive_sx/envm 1.0.0

package/README.md

@@ -0,0 +1,151 @@
+# envm
+
+Secure environment variable manager - store and sync .env files across machines.
+
+## Features
+
+- **Encrypted storage**: All env files are encrypted with AES-256-GCM
+- **Multi-environment support**: Manage dev, staging, prod, and custom environments
+- **Remote sync**: Pull and push env files between server and local machine
+- **Simple CLI**: Easy-to-use commands for managing environment variables
+
+## Installation
+
+```bash
+npm install -g envm
+```
+
+Or run directly with npx:
+
+```bash
+npx envm <command>
+```
+
+## Quick Start
+
+### On your server
+
+1. Start the envm server:
+
+```bash
+envm server start --port 3737
+```
+
+2. Create a project and add variables:
+
+```bash
+envm init myapp
+envm set myapp dev DB_HOST=localhost DB_PORT=5432
+envm set myapp prod DB_HOST=prod.example.com DB_PORT=5432
+```
+
+### On your local machine
+
+1. Open an SSH tunnel to your server:
+
+```bash
+ssh -L 3737:localhost:3737 your-server
+```
+
+2. Configure the CLI:
+
+```bash
+envm config set server http://localhost:3737
+```
+
+3. Pull env files:
+
+```bash
+cd your-project
+envm pull myapp dev           # Saves to .env
+envm pull myapp prod -o .env.production
+```
+
+4. Push local changes:
+
+```bash
+envm push myapp dev           # Pushes .env
+envm push myapp staging -f .env.staging
+```
+
+## Commands
+
+### Server Commands
+
+| Command | Description |
+|---------|-------------|
+| `envm server start [--port 3737]` | Start the envm server |
+| `envm init <project>` | Create a new project |
+| `envm set <project> [env] KEY=value...` | Set environment variables |
+| `envm get <project> [env] [key]` | Get environment variables |
+| `envm edit <project> [env]` | Edit env in your default editor |
+| `envm list` | List all projects |
+| `envm envs <project>` | List environments for a project |
+
+### Client Commands
+
+| Command | Description |
+|---------|-------------|
+| `envm config set server <url>` | Configure remote server URL |
+| `envm config get [key]` | View configuration |
+| `envm pull <project> [env]` | Pull env from remote to local .env |
+| `envm push <project> [env]` | Push local .env to remote |
+| `envm list -r` | List projects from remote |
+| `envm envs <project> -r` | List environments from remote |
+
+### Options
+
+- `[env]` defaults to `dev` if not specified
+- `--output, -o <file>` - Specify output file for pull (default: `.env`)
+- `--file, -f <file>` - Specify input file for push (default: `.env`)
+- `--force` - Overwrite existing files without prompting
+- `--create` - Create project on push if it doesn't exist
+- `--remote, -r` - Force remote server operation
+
+## Data Storage
+
+### Server
+
+All data is stored in `~/.envm/`:
+
+```
+~/.envm/
+├── master.key          # Auto-generated encryption key
+├── projects.json       # Project metadata
+└── projects/
+    └── myapp/
+        ├── dev.enc     # Encrypted env files
+        ├── staging.enc
+        └── prod.enc
+```
+
+### Client
+
+Client configuration is stored in `~/.envm/config.json`.
+
+## Security
+
+- **Encryption**: All env files are encrypted with AES-256-GCM
+- **Master key**: Auto-generated on first run, stored in `~/.envm/master.key`
+- **Localhost only**: Server binds to 127.0.0.1 by default (use SSH tunnel for remote access)
+- **No auth required**: Security is provided by SSH tunnel
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run in development
+npm run dev -- <command>
+
+# Build
+npm run build
+
+# Run built version
+npm start -- <command>
+```
+
+## License
+
+MIT

package/dist/commands/config.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const configCommand: Command;

package/dist/commands/config.js

@@ -0,0 +1,61 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { loadConfig, setServerUrl } from "../lib/config.js";
+export const configCommand = new Command("config")
+    .description("Manage CLI configuration");
+configCommand
+    .command("set")
+    .description("Set a configuration value")
+    .argument("<key>", "Configuration key (server)")
+    .argument("<value>", "Configuration value")
+    .action((key, value) => {
+    try {
+        if (key === "server") {
+            // Validate URL
+            try {
+                new URL(value);
+            }
+            catch {
+                console.error(chalk.red("Invalid URL format"));
+                process.exit(1);
+            }
+            setServerUrl(value);
+            console.log(chalk.green(`✓ Server URL set to ${value}`));
+        }
+        else {
+            console.error(chalk.red(`Unknown config key: ${key}`));
+            console.log(chalk.dim("Available keys: server"));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+});
+configCommand
+    .command("get")
+    .description("Get a configuration value")
+    .argument("[key]", "Configuration key (optional, shows all if omitted)")
+    .action((key) => {
+    try {
+        const config = loadConfig();
+        if (key) {
+            if (key === "server") {
+                console.log(config.server || chalk.dim("(not set)"));
+            }
+            else {
+                console.error(chalk.red(`Unknown config key: ${key}`));
+                process.exit(1);
+            }
+        }
+        else {
+            console.log(chalk.bold("Configuration:"));
+            console.log(`  server: ${config.server || chalk.dim("(not set)")}`);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+});

package/dist/commands/edit.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const editCommand: Command;

package/dist/commands/edit.js

@@ -0,0 +1,57 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { spawn } from "node:child_process";
+import * as storage from "../lib/storage.js";
+export const editCommand = new Command("edit")
+    .description("Edit environment in your default editor")
+    .argument("<project>", "Project name")
+    .argument("[env]", "Environment name", "dev")
+    .action(async (project, env) => {
+    try {
+        // Get existing content or start fresh
+        let content = "";
+        try {
+            content = storage.getEnvContent(project, env);
+        }
+        catch {
+            // Environment doesn't exist yet, start with empty
+            console.log(chalk.dim(`Creating new environment: ${project}/${env}`));
+        }
+        // Create temp file
+        const tmpDir = os.tmpdir();
+        const tmpFile = path.join(tmpDir, `envm-${project}-${env}-${Date.now()}.env`);
+        fs.writeFileSync(tmpFile, content);
+        // Get editor
+        const editor = process.env.EDITOR || process.env.VISUAL || (process.platform === "win32" ? "notepad" : "vi");
+        // Open editor
+        const child = spawn(editor, [tmpFile], {
+            stdio: "inherit",
+            shell: true,
+        });
+        child.on("exit", (code) => {
+            if (code === 0) {
+                // Read modified content
+                const newContent = fs.readFileSync(tmpFile, "utf-8");
+                storage.setEnvContent(project, env, newContent);
+                console.log(chalk.green(`✓ Updated ${project}/${env}`));
+            }
+            else {
+                console.log(chalk.yellow("Editor exited with non-zero code, changes not saved"));
+            }
+            // Clean up temp file
+            try {
+                fs.unlinkSync(tmpFile);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        });
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+});

package/dist/commands/envs.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const envsCommand: Command;

package/dist/commands/envs.js

@@ -0,0 +1,46 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import * as storage from "../lib/storage.js";
+import * as client from "../lib/client.js";
+import { getServerUrl } from "../lib/config.js";
+export const envsCommand = new Command("envs")
+    .description("List environments for a project")
+    .argument("<project>", "Project name")
+    .option("-r, --remote", "List environments from remote server")
+    .action(async (project, options) => {
+    try {
+        if (options.remote || getServerUrl()) {
+            try {
+                const environments = await client.fetchEnvironments(project);
+                if (environments.length === 0) {
+                    console.log(chalk.dim(`No environments found for project "${project}"`));
+                    return;
+                }
+                console.log(chalk.bold(`Environments for ${chalk.cyan(project)} (remote):`));
+                for (const env of environments) {
+                    console.log(`  ${chalk.green(env)}`);
+                }
+                return;
+            }
+            catch (error) {
+                if (options.remote) {
+                    throw error;
+                }
+            }
+        }
+        const environments = storage.listEnvironments(project);
+        if (environments.length === 0) {
+            console.log(chalk.dim(`No environments found for project "${project}"`));
+            console.log(chalk.dim(`Add one with: envm set ${project} dev KEY=value`));
+            return;
+        }
+        console.log(chalk.bold(`Environments for ${chalk.cyan(project)}:`));
+        for (const env of environments) {
+            console.log(`  ${chalk.green(env)}`);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+});

package/dist/commands/get.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const getCommand: Command;

package/dist/commands/get.js

@@ -0,0 +1,45 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import * as storage from "../lib/storage.js";
+import { parseEnv } from "../lib/env-parser.js";
+export const getCommand = new Command("get")
+    .description("Get environment variable value")
+    .argument("<project>", "Project name")
+    .argument("[env]", "Environment name", "dev")
+    .argument("[key]", "Variable key (optional, shows all if omitted)")
+    .action((project, env, key) => {
+    try {
+        // Check if env is actually a key (no env specified)
+        if (env && !["dev", "staging", "prod", "production", "test", "local"].includes(env) && !key) {
+            key = env;
+            env = "dev";
+        }
+        const content = storage.getEnvContent(project, env);
+        const data = parseEnv(content);
+        if (key) {
+            if (key in data) {
+                console.log(data[key]);
+            }
+            else {
+                console.error(chalk.red(`Variable "${key}" not found in ${project}/${env}`));
+                process.exit(1);
+            }
+        }
+        else {
+            // Show all variables
+            const keys = Object.keys(data);
+            if (keys.length === 0) {
+                console.log(chalk.dim("No variables set"));
+                return;
+            }
+            console.log(chalk.bold(`Variables in ${chalk.cyan(project)}/${chalk.green(env)}:`));
+            for (const [k, v] of Object.entries(data)) {
+                console.log(`  ${chalk.yellow(k)}=${v}`);
+            }
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+});

package/dist/commands/init.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const initCommand: Command;

package/dist/commands/init.js

@@ -0,0 +1,17 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import * as storage from "../lib/storage.js";
+export const initCommand = new Command("init")
+    .description("Initialize a new project")
+    .argument("<project>", "Project name")
+    .action((project) => {
+    try {
+        storage.createProject(project);
+        console.log(chalk.green(`✓ Project "${project}" created successfully`));
+        console.log(chalk.dim(`  Add environment variables with: envm set ${project} KEY=value`));
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+});

package/dist/commands/list.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const listCommand: Command;

package/dist/commands/list.js

@@ -0,0 +1,50 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import * as storage from "../lib/storage.js";
+import * as client from "../lib/client.js";
+import { getServerUrl } from "../lib/config.js";
+export const listCommand = new Command("list")
+    .description("List all projects")
+    .option("-r, --remote", "List projects from remote server")
+    .action(async (options) => {
+    try {
+        if (options.remote || getServerUrl()) {
+            // Try remote first if configured
+            try {
+                const projects = await client.fetchProjects();
+                if (projects.length === 0) {
+                    console.log(chalk.dim("No projects found on remote server"));
+                    return;
+                }
+                console.log(chalk.bold("Projects (remote):"));
+                for (const project of projects) {
+                    const envCount = project.environments.length;
+                    console.log(`  ${chalk.cyan(project.name)} ${chalk.dim(`(${envCount} env${envCount !== 1 ? "s" : ""})`)}`);
+                }
+                return;
+            }
+            catch (error) {
+                if (options.remote) {
+                    throw error;
+                }
+                // Fall through to local if remote fails and not explicitly requested
+            }
+        }
+        // Local projects
+        const projects = storage.listProjects();
+        if (projects.length === 0) {
+            console.log(chalk.dim("No projects found"));
+            console.log(chalk.dim("Create one with: envm init <project-name>"));
+            return;
+        }
+        console.log(chalk.bold("Projects:"));
+        for (const project of projects) {
+            const envCount = project.environments.length;
+            console.log(`  ${chalk.cyan(project.name)} ${chalk.dim(`(${envCount} env${envCount !== 1 ? "s" : ""})`)}`);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+});

package/dist/commands/pull.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const pullCommand: Command;

package/dist/commands/pull.js

@@ -0,0 +1,37 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import fs from "node:fs";
+import path from "node:path";
+import * as client from "../lib/client.js";
+export const pullCommand = new Command("pull")
+    .description("Pull environment file from remote server")
+    .argument("<project>", "Project name")
+    .argument("[env]", "Environment name", "dev")
+    .option("-o, --output <file>", "Output file path", ".env")
+    .option("-f, --force", "Overwrite existing file without prompting")
+    .action(async (project, env, options) => {
+    try {
+        const outputPath = path.resolve(options.output);
+        // Check if file exists
+        if (fs.existsSync(outputPath) && !options.force) {
+            console.log(chalk.yellow(`File ${options.output} already exists.`));
+            console.log(chalk.dim("Use --force to overwrite"));
+            process.exit(1);
+        }
+        console.log(chalk.dim(`Pulling ${project}/${env} from remote...`));
+        const content = await client.fetchEnvContent(project, env);
+        // Ensure directory exists
+        const dir = path.dirname(outputPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(outputPath, content);
+        const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#")).length;
+        console.log(chalk.green(`✓ Pulled ${project}/${env} to ${options.output}`));
+        console.log(chalk.dim(`  ${lines} variable${lines !== 1 ? "s" : ""}`));
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+});

package/dist/commands/push.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const pushCommand: Command;

package/dist/commands/push.js

@@ -0,0 +1,44 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import fs from "node:fs";
+import path from "node:path";
+import * as client from "../lib/client.js";
+export const pushCommand = new Command("push")
+    .description("Push environment file to remote server")
+    .argument("<project>", "Project name")
+    .argument("[env]", "Environment name", "dev")
+    .option("-f, --file <file>", "Input file path", ".env")
+    .option("--create", "Create project if it doesn't exist")
+    .action(async (project, env, options) => {
+    try {
+        const inputPath = path.resolve(options.file);
+        // Check if file exists
+        if (!fs.existsSync(inputPath)) {
+            console.error(chalk.red(`File not found: ${options.file}`));
+            process.exit(1);
+        }
+        const content = fs.readFileSync(inputPath, "utf-8");
+        const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#")).length;
+        console.log(chalk.dim(`Pushing ${options.file} to ${project}/${env}...`));
+        try {
+            await client.pushEnvContent(project, env, content);
+        }
+        catch (error) {
+            const message = error.message;
+            if (message.includes("not found") && options.create) {
+                console.log(chalk.dim(`Creating project "${project}"...`));
+                await client.createRemoteProject(project);
+                await client.pushEnvContent(project, env, content);
+            }
+            else {
+                throw error;
+            }
+        }
+        console.log(chalk.green(`✓ Pushed ${options.file} to ${project}/${env}`));
+        console.log(chalk.dim(`  ${lines} variable${lines !== 1 ? "s" : ""}`));
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+});

package/dist/commands/server.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const serverCommand: Command;

package/dist/commands/server.js

@@ -0,0 +1,20 @@
+import { Command } from "commander";
+import { startServer } from "../lib/server.js";
+export const serverCommand = new Command("server")
+    .description("Server management commands");
+serverCommand
+    .command("start")
+    .description("Start the envm server")
+    .option("-p, --port <port>", "Port to listen on", "3737")
+    .option("-d, --data-dir <dir>", "Data directory for storing encrypted envs")
+    .action((options) => {
+    if (options.dataDir) {
+        process.env.ENVM_DATA_DIR = options.dataDir;
+    }
+    const port = parseInt(options.port, 10);
+    if (isNaN(port) || port < 1 || port > 65535) {
+        console.error("Invalid port number");
+        process.exit(1);
+    }
+    startServer(port);
+});

package/dist/commands/set.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const setCommand: Command;

package/dist/commands/set.js

@@ -0,0 +1,49 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import * as storage from "../lib/storage.js";
+import { parseEnv, serializeEnv, mergeEnv, parseKeyValue } from "../lib/env-parser.js";
+export const setCommand = new Command("set")
+    .description("Set environment variable(s)")
+    .argument("<project>", "Project name")
+    .argument("[env]", "Environment name", "dev")
+    .argument("<keyvalues...>", "KEY=value pairs to set")
+    .action((project, env, keyvalues) => {
+    try {
+        // Check if env is actually a KEY=value (no env specified)
+        if (env.includes("=")) {
+            keyvalues = [env, ...keyvalues];
+            env = "dev";
+        }
+        // Parse all KEY=value pairs
+        const updates = {};
+        for (const kv of keyvalues) {
+            const parsed = parseKeyValue(kv);
+            if (!parsed) {
+                console.error(chalk.red(`Invalid format: "${kv}". Use KEY=value`));
+                process.exit(1);
+            }
+            updates[parsed.key] = parsed.value;
+        }
+        // Get existing content or start fresh
+        let existingContent = "";
+        try {
+            existingContent = storage.getEnvContent(project, env);
+        }
+        catch {
+            // Environment doesn't exist yet
+        }
+        const existingData = parseEnv(existingContent);
+        const mergedData = mergeEnv(existingData, updates);
+        const newContent = serializeEnv(mergedData);
+        storage.setEnvContent(project, env, newContent);
+        const keys = Object.keys(updates);
+        console.log(chalk.green(`✓ Set ${keys.length} variable${keys.length !== 1 ? "s" : ""} in ${project}/${env}`));
+        for (const key of keys) {
+            console.log(chalk.dim(`  ${key}=***`));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { serverCommand } from "./commands/server.js";
+import { initCommand } from "./commands/init.js";
+import { listCommand } from "./commands/list.js";
+import { envsCommand } from "./commands/envs.js";
+import { setCommand } from "./commands/set.js";
+import { getCommand } from "./commands/get.js";
+import { editCommand } from "./commands/edit.js";
+import { configCommand } from "./commands/config.js";
+import { pullCommand } from "./commands/pull.js";
+import { pushCommand } from "./commands/push.js";
+const program = new Command();
+program
+    .name("envm")
+    .description("Secure environment variable manager - store and sync .env files across machines")
+    .version("1.0.0");
+// Server commands
+program.addCommand(serverCommand);
+// Local/Server commands
+program.addCommand(initCommand);
+program.addCommand(listCommand);
+program.addCommand(envsCommand);
+program.addCommand(setCommand);
+program.addCommand(getCommand);
+program.addCommand(editCommand);
+// Client commands
+program.addCommand(configCommand);
+program.addCommand(pullCommand);
+program.addCommand(pushCommand);
+program.parse();

package/dist/lib/client.d.ts

@@ -0,0 +1,6 @@
+import type { Project } from "../types/index.js";
+export declare function fetchProjects(): Promise<Project[]>;
+export declare function fetchEnvironments(projectName: string): Promise<string[]>;
+export declare function fetchEnvContent(projectName: string, envName: string): Promise<string>;
+export declare function pushEnvContent(projectName: string, envName: string, content: string): Promise<void>;
+export declare function createRemoteProject(projectName: string): Promise<Project>;

package/dist/lib/client.js

@@ -0,0 +1,57 @@
+import { getServerUrl } from "./config.js";
+class ApiError extends Error {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = "ApiError";
+    }
+}
+async function request(method, endpoint, body) {
+    const serverUrl = getServerUrl();
+    if (!serverUrl) {
+        throw new ApiError("Server not configured. Run: envm config set server <url>");
+    }
+    const url = `${serverUrl}${endpoint}`;
+    const options = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+        },
+    };
+    if (body) {
+        options.body = JSON.stringify(body);
+    }
+    try {
+        const response = await fetch(url, options);
+        const data = (await response.json());
+        if (!response.ok || !data.success) {
+            throw new ApiError(data.error || `Request failed with status ${response.status}`, response.status);
+        }
+        return data.data;
+    }
+    catch (error) {
+        if (error instanceof ApiError) {
+            throw error;
+        }
+        throw new ApiError(`Failed to connect to server: ${error.message}`);
+    }
+}
+export async function fetchProjects() {
+    const data = await request("GET", "/projects");
+    return data.projects;
+}
+export async function fetchEnvironments(projectName) {
+    const data = await request("GET", `/projects/${encodeURIComponent(projectName)}/envs`);
+    return data.environments;
+}
+export async function fetchEnvContent(projectName, envName) {
+    const data = await request("GET", `/projects/${encodeURIComponent(projectName)}/envs/${encodeURIComponent(envName)}`);
+    return data.content;
+}
+export async function pushEnvContent(projectName, envName, content) {
+    await request("PUT", `/projects/${encodeURIComponent(projectName)}/envs/${encodeURIComponent(envName)}`, { content });
+}
+export async function createRemoteProject(projectName) {
+    return await request("POST", `/projects/${encodeURIComponent(projectName)}`);
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,5 @@
+import type { ClientConfig } from "../types/index.js";
+export declare function loadConfig(): ClientConfig;
+export declare function saveConfig(config: ClientConfig): void;
+export declare function getServerUrl(): string | undefined;
+export declare function setServerUrl(url: string): void;

package/dist/lib/config.js

@@ -0,0 +1,32 @@
+import fs from "node:fs";
+import path from "node:path";
+function getConfigDir() {
+    return path.join(process.env.HOME || process.env.USERPROFILE || "~", ".envm");
+}
+function getConfigPath() {
+    return path.join(getConfigDir(), "config.json");
+}
+export function loadConfig() {
+    const configPath = getConfigPath();
+    if (!fs.existsSync(configPath)) {
+        return {};
+    }
+    const content = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+}
+export function saveConfig(config) {
+    const configDir = getConfigDir();
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    const configPath = getConfigPath();
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+export function getServerUrl() {
+    return loadConfig().server;
+}
+export function setServerUrl(url) {
+    const config = loadConfig();
+    config.server = url;
+    saveConfig(config);
+}

package/dist/lib/crypto.d.ts

@@ -0,0 +1,8 @@
+export declare function getDataDir(): string;
+export declare function getMasterKeyPath(): string;
+export declare function ensureDataDir(): void;
+export declare function generateMasterKey(): Buffer;
+export declare function saveMasterKey(key: Buffer): void;
+export declare function loadMasterKey(): Buffer;
+export declare function encrypt(plaintext: string, key: Buffer): string;
+export declare function decrypt(encryptedData: string, key: Buffer): string;

package/dist/lib/crypto.js

@@ -0,0 +1,61 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+const ALGORITHM = "aes-256-gcm";
+const KEY_LENGTH = 32; // 256 bits
+const IV_LENGTH = 16;
+const AUTH_TAG_LENGTH = 16;
+export function getDataDir() {
+    return process.env.ENVM_DATA_DIR || path.join(process.env.HOME || process.env.USERPROFILE || "~", ".envm");
+}
+export function getMasterKeyPath() {
+    return path.join(getDataDir(), "master.key");
+}
+export function ensureDataDir() {
+    const dataDir = getDataDir();
+    if (!fs.existsSync(dataDir)) {
+        fs.mkdirSync(dataDir, { recursive: true });
+    }
+}
+export function generateMasterKey() {
+    return crypto.randomBytes(KEY_LENGTH);
+}
+export function saveMasterKey(key) {
+    ensureDataDir();
+    const keyPath = getMasterKeyPath();
+    fs.writeFileSync(keyPath, key.toString("hex"), { mode: 0o600 });
+}
+export function loadMasterKey() {
+    const keyPath = getMasterKeyPath();
+    if (!fs.existsSync(keyPath)) {
+        // Auto-generate master key on first use
+        const key = generateMasterKey();
+        saveMasterKey(key);
+        return key;
+    }
+    const hexKey = fs.readFileSync(keyPath, "utf-8").trim();
+    return Buffer.from(hexKey, "hex");
+}
+export function encrypt(plaintext, key) {
+    const iv = crypto.randomBytes(IV_LENGTH);
+    const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+    let encrypted = cipher.update(plaintext, "utf8", "hex");
+    encrypted += cipher.final("hex");
+    const authTag = cipher.getAuthTag();
+    // Format: iv:authTag:encryptedData (all hex)
+    return `${iv.toString("hex")}:${authTag.toString("hex")}:${encrypted}`;
+}
+export function decrypt(encryptedData, key) {
+    const parts = encryptedData.split(":");
+    if (parts.length !== 3) {
+        throw new Error("Invalid encrypted data format");
+    }
+    const [ivHex, authTagHex, encrypted] = parts;
+    const iv = Buffer.from(ivHex, "hex");
+    const authTag = Buffer.from(authTagHex, "hex");
+    const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+    decipher.setAuthTag(authTag);
+    let decrypted = decipher.update(encrypted, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+}

package/dist/lib/env-parser.d.ts

@@ -0,0 +1,20 @@
+import type { EnvData } from "../types/index.js";
+/**
+ * Parse .env file content into key-value object
+ */
+export declare function parseEnv(content: string): EnvData;
+/**
+ * Serialize key-value object to .env file content
+ */
+export declare function serializeEnv(data: EnvData): string;
+/**
+ * Merge new values into existing env data
+ */
+export declare function mergeEnv(existing: EnvData, updates: EnvData): EnvData;
+/**
+ * Parse KEY=value string
+ */
+export declare function parseKeyValue(input: string): {
+    key: string;
+    value: string;
+} | null;

package/dist/lib/env-parser.js

@@ -0,0 +1,63 @@
+/**
+ * Parse .env file content into key-value object
+ */
+export function parseEnv(content) {
+    const result = {};
+    const lines = content.split("\n");
+    for (const line of lines) {
+        // Skip empty lines and comments
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) {
+            continue;
+        }
+        // Find first = sign
+        const eqIndex = trimmed.indexOf("=");
+        if (eqIndex === -1) {
+            continue;
+        }
+        const key = trimmed.substring(0, eqIndex).trim();
+        let value = trimmed.substring(eqIndex + 1).trim();
+        // Remove quotes if present
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        if (key) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Serialize key-value object to .env file content
+ */
+export function serializeEnv(data) {
+    const lines = [];
+    for (const [key, value] of Object.entries(data)) {
+        // Quote values that contain spaces, newlines, or special characters
+        const needsQuotes = /[\s#"'\\]/.test(value) || value.includes("=");
+        const formattedValue = needsQuotes ? `"${value.replace(/"/g, '\\"')}"` : value;
+        lines.push(`${key}=${formattedValue}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Merge new values into existing env data
+ */
+export function mergeEnv(existing, updates) {
+    return { ...existing, ...updates };
+}
+/**
+ * Parse KEY=value string
+ */
+export function parseKeyValue(input) {
+    const eqIndex = input.indexOf("=");
+    if (eqIndex === -1) {
+        return null;
+    }
+    const key = input.substring(0, eqIndex).trim();
+    const value = input.substring(eqIndex + 1);
+    if (!key) {
+        return null;
+    }
+    return { key, value };
+}

package/dist/lib/server.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from "hono";
+export declare function createServer(): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export declare function startServer(port?: number): void;

package/dist/lib/server.js

@@ -0,0 +1,146 @@
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import * as storage from "./storage.js";
+import { parseEnv, serializeEnv, mergeEnv } from "./env-parser.js";
+import { loadMasterKey } from "./crypto.js";
+export function createServer() {
+    const app = new Hono();
+    // Helper to send success response
+    const success = (data) => ({ success: true, data });
+    // Helper to send error response
+    const error = (message) => ({ success: false, error: message });
+    // List all projects
+    app.get("/projects", (c) => {
+        try {
+            const projects = storage.listProjects();
+            return c.json(success({ projects }));
+        }
+        catch (err) {
+            return c.json(error(err.message), 500);
+        }
+    });
+    // Create project
+    app.post("/projects/:name", (c) => {
+        try {
+            const { name } = c.req.param();
+            const project = storage.createProject(name);
+            return c.json(success(project), 201);
+        }
+        catch (err) {
+            const message = err.message;
+            const status = message.includes("already exists") ? 409 : 500;
+            return c.json(error(message), status);
+        }
+    });
+    // Delete project
+    app.delete("/projects/:name", (c) => {
+        try {
+            const { name } = c.req.param();
+            storage.deleteProject(name);
+            return c.json(success({ deleted: true }));
+        }
+        catch (err) {
+            const message = err.message;
+            const status = message.includes("not found") ? 404 : 500;
+            return c.json(error(message), status);
+        }
+    });
+    // List environments for a project
+    app.get("/projects/:name/envs", (c) => {
+        try {
+            const { name } = c.req.param();
+            const environments = storage.listEnvironments(name);
+            return c.json(success({ environments }));
+        }
+        catch (err) {
+            const message = err.message;
+            const status = message.includes("not found") ? 404 : 500;
+            return c.json(error(message), status);
+        }
+    });
+    // Get env content
+    app.get("/projects/:name/envs/:env", (c) => {
+        try {
+            const { name, env } = c.req.param();
+            const content = storage.getEnvContent(name, env);
+            return c.json(success({
+                content,
+                env,
+                project: name,
+            }));
+        }
+        catch (err) {
+            const message = err.message;
+            const status = message.includes("not found") ? 404 : 500;
+            return c.json(error(message), status);
+        }
+    });
+    // Set entire env content (PUT)
+    app.put("/projects/:name/envs/:env", async (c) => {
+        try {
+            const { name, env } = c.req.param();
+            const body = await c.req.json();
+            storage.setEnvContent(name, env, body.content);
+            return c.json(success({ updated: true }));
+        }
+        catch (err) {
+            const message = err.message;
+            const status = message.includes("not found") ? 404 : 500;
+            return c.json(error(message), status);
+        }
+    });
+    // Update single key (PATCH)
+    app.patch("/projects/:name/envs/:env", async (c) => {
+        try {
+            const { name, env } = c.req.param();
+            const body = await c.req.json();
+            let existingContent = "";
+            try {
+                existingContent = storage.getEnvContent(name, env);
+            }
+            catch {
+                // Env doesn't exist yet, start fresh
+            }
+            const existingData = parseEnv(existingContent);
+            const updatedData = mergeEnv(existingData, { [body.key]: body.value });
+            const newContent = serializeEnv(updatedData);
+            storage.setEnvContent(name, env, newContent);
+            return c.json(success({ updated: true }));
+        }
+        catch (err) {
+            const message = err.message;
+            const status = message.includes("not found") ? 404 : 500;
+            return c.json(error(message), status);
+        }
+    });
+    // Delete env
+    app.delete("/projects/:name/envs/:env", (c) => {
+        try {
+            const { name, env } = c.req.param();
+            storage.deleteEnv(name, env);
+            return c.json(success({ deleted: true }));
+        }
+        catch (err) {
+            const message = err.message;
+            const status = message.includes("not found") ? 404 : 500;
+            return c.json(error(message), status);
+        }
+    });
+    // Health check
+    app.get("/health", (c) => {
+        return c.json(success({ status: "ok" }));
+    });
+    return app;
+}
+export function startServer(port = 3737) {
+    // Ensure master key exists
+    loadMasterKey();
+    const app = createServer();
+    console.log(`Starting envm server on http://localhost:${port}`);
+    console.log(`Data directory: ${process.env.ENVM_DATA_DIR || "~/.envm"}`);
+    serve({
+        fetch: app.fetch,
+        port,
+        hostname: "127.0.0.1", // Bind to localhost only for security
+    });
+}

package/dist/lib/storage.d.ts

@@ -0,0 +1,11 @@
+import type { Project, ProjectsData } from "../types/index.js";
+export declare function loadProjectsData(): ProjectsData;
+export declare function saveProjectsData(data: ProjectsData): void;
+export declare function listProjects(): Project[];
+export declare function getProject(name: string): Project | undefined;
+export declare function createProject(name: string): Project;
+export declare function deleteProject(name: string): void;
+export declare function listEnvironments(projectName: string): string[];
+export declare function getEnvContent(projectName: string, envName: string): string;
+export declare function setEnvContent(projectName: string, envName: string, content: string): void;
+export declare function deleteEnv(projectName: string, envName: string): void;

package/dist/lib/storage.js

@@ -0,0 +1,119 @@
+import fs from "node:fs";
+import path from "node:path";
+import { encrypt, decrypt, loadMasterKey, getDataDir, ensureDataDir } from "./crypto.js";
+function getProjectsFilePath() {
+    return path.join(getDataDir(), "projects.json");
+}
+function getProjectsDir() {
+    return path.join(getDataDir(), "projects");
+}
+function getProjectDir(projectName) {
+    return path.join(getProjectsDir(), projectName);
+}
+function getEnvFilePath(projectName, envName) {
+    return path.join(getProjectDir(projectName), `${envName}.enc`);
+}
+export function loadProjectsData() {
+    const filePath = getProjectsFilePath();
+    if (!fs.existsSync(filePath)) {
+        return { projects: [] };
+    }
+    const content = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+}
+export function saveProjectsData(data) {
+    ensureDataDir();
+    const filePath = getProjectsFilePath();
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+}
+export function listProjects() {
+    return loadProjectsData().projects;
+}
+export function getProject(name) {
+    return loadProjectsData().projects.find((p) => p.name === name);
+}
+export function createProject(name) {
+    const data = loadProjectsData();
+    if (data.projects.some((p) => p.name === name)) {
+        throw new Error(`Project "${name}" already exists`);
+    }
+    const project = {
+        name,
+        createdAt: new Date().toISOString(),
+        environments: [],
+    };
+    data.projects.push(project);
+    saveProjectsData(data);
+    // Create project directory
+    const projectDir = getProjectDir(name);
+    fs.mkdirSync(projectDir, { recursive: true });
+    return project;
+}
+export function deleteProject(name) {
+    const data = loadProjectsData();
+    const index = data.projects.findIndex((p) => p.name === name);
+    if (index === -1) {
+        throw new Error(`Project "${name}" not found`);
+    }
+    data.projects.splice(index, 1);
+    saveProjectsData(data);
+    // Delete project directory
+    const projectDir = getProjectDir(name);
+    if (fs.existsSync(projectDir)) {
+        fs.rmSync(projectDir, { recursive: true });
+    }
+}
+export function listEnvironments(projectName) {
+    const project = getProject(projectName);
+    if (!project) {
+        throw new Error(`Project "${projectName}" not found`);
+    }
+    return project.environments;
+}
+export function getEnvContent(projectName, envName) {
+    const project = getProject(projectName);
+    if (!project) {
+        throw new Error(`Project "${projectName}" not found`);
+    }
+    const envPath = getEnvFilePath(projectName, envName);
+    if (!fs.existsSync(envPath)) {
+        throw new Error(`Environment "${envName}" not found in project "${projectName}"`);
+    }
+    const encrypted = fs.readFileSync(envPath, "utf-8");
+    const key = loadMasterKey();
+    return decrypt(encrypted, key);
+}
+export function setEnvContent(projectName, envName, content) {
+    const data = loadProjectsData();
+    const project = data.projects.find((p) => p.name === projectName);
+    if (!project) {
+        throw new Error(`Project "${projectName}" not found`);
+    }
+    const key = loadMasterKey();
+    const encrypted = encrypt(content, key);
+    const envPath = getEnvFilePath(projectName, envName);
+    fs.mkdirSync(path.dirname(envPath), { recursive: true });
+    fs.writeFileSync(envPath, encrypted);
+    // Update environments list
+    if (!project.environments.includes(envName)) {
+        project.environments.push(envName);
+        saveProjectsData(data);
+    }
+}
+export function deleteEnv(projectName, envName) {
+    const data = loadProjectsData();
+    const project = data.projects.find((p) => p.name === projectName);
+    if (!project) {
+        throw new Error(`Project "${projectName}" not found`);
+    }
+    const envPath = getEnvFilePath(projectName, envName);
+    if (fs.existsSync(envPath)) {
+        fs.unlinkSync(envPath);
+    }
+    // Update environments list
+    const envIndex = project.environments.indexOf(envName);
+    if (envIndex !== -1) {
+        project.environments.splice(envIndex, 1);
+        saveProjectsData(data);
+    }
+}

package/dist/types/index.d.ts

@@ -0,0 +1,30 @@
+export interface Project {
+    name: string;
+    createdAt: string;
+    environments: string[];
+}
+export interface ProjectsData {
+    projects: Project[];
+}
+export interface EnvData {
+    [key: string]: string;
+}
+export interface ClientConfig {
+    server?: string;
+}
+export interface ApiResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+export interface ProjectListResponse {
+    projects: Project[];
+}
+export interface EnvListResponse {
+    environments: string[];
+}
+export interface EnvContentResponse {
+    content: string;
+    env: string;
+    project: string;
+}

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@motive_sx/envm",
+  "version": "1.0.0",
+  "description": "Secure environment variable manager - store and sync .env files across machines",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "envm": "./dist/index.js"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "env",
+    "environment",
+    "dotenv",
+    "secrets",
+    "cli"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anthropics/envm.git"
+  },
+  "bugs": {
+    "url": "https://github.com/anthropics/envm/issues"
+  },
+  "homepage": "https://github.com/anthropics/envm#readme",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@hono/node-server": "^1.13.8",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "dotenv": "^16.4.7",
+    "hono": "^4.7.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.4",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3"
+  }
+}