envd-cli 0.1.0

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "envd-cli",
+  "version": "0.1.0",
+  "description": "Environment variables management CLI",
+  "type": "module",
+  "bin": {
+    "envd": "./src/index.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "bun build src/index.ts --compile --outfile dist/envd",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "env",
+    "environment",
+    "dotenv",
+    "cli",
+    "sync"
+  ],
+  "author": "sunneydev",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sunneydev/envd.git"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,426 @@
+#!/usr/bin/env bun
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, basename } from "path";
+import { homedir } from "os";
+
+// Config management
+const CONFIG_DIR = join(homedir(), ".envd");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+interface Config {
+  apiUrl: string;
+  apiKey: string;
+}
+
+function loadConfig(): Config | null {
+  if (!existsSync(CONFIG_FILE)) return null;
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function saveConfig(config: Config): void {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+function requireConfig(): Config {
+  const config = loadConfig();
+  if (!config) {
+    console.error("Not configured. Run: envd config");
+    process.exit(1);
+  }
+  return config;
+}
+
+// API client
+async function api<T>(
+  config: Config,
+  method: string,
+  path: string,
+  body?: unknown
+): Promise<T> {
+  const url = `${config.apiUrl}${path}`;
+  const res = await fetch(url, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      "X-API-Key": config.apiKey,
+    },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`API error ${res.status}: ${text}`);
+  }
+
+  return res.json();
+}
+
+// .env file parsing
+function parseEnvFile(content: string): Record<string, string> {
+  const vars: Record<string, string> = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    const key = trimmed.slice(0, eq).trim();
+    let value = trimmed.slice(eq + 1).trim();
+    // Remove surrounding quotes
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    vars[key] = value;
+  }
+  return vars;
+}
+
+function formatEnvFile(vars: Record<string, string>): string {
+  return Object.entries(vars)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([k, v]) => {
+      // Quote if contains spaces or special chars
+      if (v.includes(" ") || v.includes("=") || v.includes("#")) {
+        return `${k}="${v}"`;
+      }
+      return `${k}=${v}`;
+    })
+    .join("\n") + "\n";
+}
+
+// Get current project name from directory
+function getProjectName(): string {
+  return basename(process.cwd());
+}
+
+// Commands
+async function cmdConfig(): Promise<void> {
+  const readline = await import("readline");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const question = (q: string): Promise<string> =>
+    new Promise((resolve) => rl.question(q, resolve));
+
+  const existing = loadConfig();
+  
+  console.log("envd configuration\n");
+  
+  const apiUrl = await question(
+    `API URL [${existing?.apiUrl || "https://envd.example.com"}]: `
+  );
+  const apiKey = await question("API Key: ");
+  
+  rl.close();
+
+  const config: Config = {
+    apiUrl: apiUrl || existing?.apiUrl || "https://envd.example.com",
+    apiKey: apiKey || existing?.apiKey || "",
+  };
+
+  saveConfig(config);
+  console.log(`\nConfig saved to ${CONFIG_FILE}`);
+}
+
+async function cmdInit(): Promise<void> {
+  const config = requireConfig();
+  const projectName = getProjectName();
+
+  console.log(`Initializing project: ${projectName}`);
+
+  try {
+    // Create project
+    await api(config, "POST", "/api/projects", { name: projectName });
+    console.log("Created project");
+  } catch (e: any) {
+    if (e.message.includes("409") || e.message.includes("already exists")) {
+      console.log("Project already exists");
+    } else {
+      throw e;
+    }
+  }
+
+  // Create default environment
+  try {
+    const project = await api<{ id: string }>(
+      config,
+      "GET",
+      `/api/projects/${encodeURIComponent(projectName)}`
+    );
+    await api(config, "POST", `/api/projects/${project.id}/environments`, {
+      name: "default",
+    });
+    console.log("Created default environment");
+  } catch (e: any) {
+    if (e.message.includes("409") || e.message.includes("already exists")) {
+      console.log("Default environment already exists");
+    } else {
+      throw e;
+    }
+  }
+
+  console.log("\nProject initialized. Use 'envd push' to upload variables.");
+}
+
+async function cmdPush(envName: string = "default"): Promise<void> {
+  const config = requireConfig();
+  const projectName = getProjectName();
+
+  // Read local .env
+  const envPath = join(process.cwd(), ".env");
+  if (!existsSync(envPath)) {
+    console.error("No .env file found in current directory");
+    process.exit(1);
+  }
+
+  const content = readFileSync(envPath, "utf-8");
+  const vars = parseEnvFile(content);
+  const count = Object.keys(vars).length;
+
+  if (count === 0) {
+    console.log("No variables found in .env");
+    return;
+  }
+
+  console.log(`Pushing ${count} variables to ${projectName}/${envName}...`);
+
+  // Get project and environment
+  const project = await api<{ id: string }>(
+    config,
+    "GET",
+    `/api/projects/${encodeURIComponent(projectName)}`
+  );
+
+  const envs = await api<{ id: string; name: string }[]>(
+    config,
+    "GET",
+    `/api/projects/${project.id}/environments`
+  );
+
+  const env = envs.find((e) => e.name === envName);
+  if (!env) {
+    console.error(`Environment '${envName}' not found. Create it with: envd env create ${envName}`);
+    process.exit(1);
+  }
+
+  // Push variables
+  await api(config, "PUT", `/api/environments/${env.id}/variables`, { variables: vars });
+
+  console.log("Done");
+}
+
+async function cmdPull(envName: string = "default"): Promise<void> {
+  const config = requireConfig();
+  const projectName = getProjectName();
+
+  console.log(`Pulling ${projectName}/${envName}...`);
+
+  // Get project and environment
+  const project = await api<{ id: string }>(
+    config,
+    "GET",
+    `/api/projects/${encodeURIComponent(projectName)}`
+  );
+
+  const envs = await api<{ id: string; name: string }[]>(
+    config,
+    "GET",
+    `/api/projects/${project.id}/environments`
+  );
+
+  const env = envs.find((e) => e.name === envName);
+  if (!env) {
+    console.error(`Environment '${envName}' not found`);
+    process.exit(1);
+  }
+
+  // Get variables
+  const variables = await api<{ key: string; value: string }[]>(
+    config,
+    "GET",
+    `/api/environments/${env.id}/variables`
+  );
+
+  if (variables.length === 0) {
+    console.log("No variables found");
+    return;
+  }
+
+  // Convert to record and write
+  const vars: Record<string, string> = {};
+  for (const v of variables) {
+    vars[v.key] = v.value;
+  }
+
+  const content = formatEnvFile(vars);
+  const envPath = join(process.cwd(), ".env");
+  writeFileSync(envPath, content);
+
+  console.log(`Wrote ${variables.length} variables to .env`);
+}
+
+async function cmdEnvList(): Promise<void> {
+  const config = requireConfig();
+  const projectName = getProjectName();
+
+  const project = await api<{ id: string }>(
+    config,
+    "GET",
+    `/api/projects/${encodeURIComponent(projectName)}`
+  );
+
+  const envs = await api<{ id: string; name: string; created_at: number }[]>(
+    config,
+    "GET",
+    `/api/projects/${project.id}/environments`
+  );
+
+  if (envs.length === 0) {
+    console.log("No environments found");
+    return;
+  }
+
+  console.log("Environments:\n");
+  for (const env of envs) {
+    console.log(`  ${env.name}`);
+  }
+}
+
+async function cmdEnvCreate(name: string): Promise<void> {
+  const config = requireConfig();
+  const projectName = getProjectName();
+
+  const project = await api<{ id: string }>(
+    config,
+    "GET",
+    `/api/projects/${encodeURIComponent(projectName)}`
+  );
+
+  await api(config, "POST", `/api/projects/${project.id}/environments`, { name });
+
+  console.log(`Created environment: ${name}`);
+}
+
+async function cmdEnvDelete(name: string): Promise<void> {
+  const config = requireConfig();
+  const projectName = getProjectName();
+
+  const project = await api<{ id: string }>(
+    config,
+    "GET",
+    `/api/projects/${encodeURIComponent(projectName)}`
+  );
+
+  const envs = await api<{ id: string; name: string }[]>(
+    config,
+    "GET",
+    `/api/projects/${project.id}/environments`
+  );
+
+  const env = envs.find((e) => e.name === name);
+  if (!env) {
+    console.error(`Environment '${name}' not found`);
+    process.exit(1);
+  }
+
+  await api(config, "DELETE", `/api/environments/${env.id}`, {});
+
+  console.log(`Deleted environment: ${name}`);
+}
+
+function printHelp(): void {
+  console.log(`envd - environment variables management
+
+USAGE:
+  envd <command> [args]
+
+COMMANDS:
+  config              Configure API endpoint and key
+  init                Initialize project (creates default environment)
+  push [env]          Push .env to remote (default: default)
+  pull [env]          Pull remote env to local .env (default: default)
+  env list            List environments for current project
+  env create <name>   Create new environment
+  env delete <name>   Delete environment
+  help                Show this help
+
+EXAMPLES:
+  envd config                    # Set up API connection
+  envd init                      # Initialize current directory as project
+  envd push                      # Push .env to default environment
+  envd push production           # Push to production environment
+  envd pull staging              # Pull staging environment to .env
+  envd env create staging        # Create staging environment
+`);
+}
+
+// Main
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  const cmd = args[0];
+
+  try {
+    switch (cmd) {
+      case "config":
+        await cmdConfig();
+        break;
+      case "init":
+        await cmdInit();
+        break;
+      case "push":
+        await cmdPush(args[1]);
+        break;
+      case "pull":
+        await cmdPull(args[1]);
+        break;
+      case "env":
+        switch (args[1]) {
+          case "list":
+            await cmdEnvList();
+            break;
+          case "create":
+            if (!args[2]) {
+              console.error("Usage: envd env create <name>");
+              process.exit(1);
+            }
+            await cmdEnvCreate(args[2]);
+            break;
+          case "delete":
+            if (!args[2]) {
+              console.error("Usage: envd env delete <name>");
+              process.exit(1);
+            }
+            await cmdEnvDelete(args[2]);
+            break;
+          default:
+            console.error("Unknown env command. Use: list, create, delete");
+            process.exit(1);
+        }
+        break;
+      case "help":
+      case "--help":
+      case "-h":
+      case undefined:
+        printHelp();
+        break;
+      default:
+        console.error(`Unknown command: ${cmd}`);
+        printHelp();
+        process.exit(1);
+    }
+  } catch (e: any) {
+    console.error("Error:", e.message);
+    process.exit(1);
+  }
+}
+
+main();