@praeviso/code-env-switch 0.1.0

package/README.md

@@ -0,0 +1,90 @@
+# code-env-switch
+
+A tiny CLI to switch between Claude Code and Codex environment variables.
+
+## Setup
+
+1) Copy the example config and fill in your keys:
+
+```bash
+cp code-env.example.json code-env.json
+```
+
+2) Install from npm (after publish) or locally:
+
+```bash
+npm install -g code-env-switch
+# or local dev
+npm install -g .
+# or
+npm link
+```
+
+## Usage
+
+List profiles:
+
+```bash
+codenv list
+```
+
+Add or update a profile from the CLI:
+
+```bash
+codenv add codex-88 OPENAI_BASE_URL=https://api.openai.com/v1 OPENAI_API_KEY=sk-REPLACE_ME --note "OpenAI official"
+```
+
+Switch in the current shell (bash/zsh):
+
+```bash
+eval "$(codenv use codex-88)"
+```
+
+Unset all known keys:
+
+```bash
+eval "$(codenv unset)"
+```
+
+### Config lookup order
+
+`codenv` searches in this order:
+
+1) `--config <path>`
+2) `CODE_ENV_CONFIG`
+3) `./code-env.json`
+4) `./profiles.json`
+5) `./code-env.config.json`
+6) `~/.config/code-env/config.json`
+
+## Config format
+
+```json
+{
+  "unset": ["OPENAI_BASE_URL", "OPENAI_API_KEY"],
+  "profiles": {
+    "codex-88": {
+      "note": "OpenAI official",
+      "env": {
+        "OPENAI_BASE_URL": "https://api.openai.com/v1",
+        "OPENAI_API_KEY": "sk-REPLACE_ME",
+        "CODEX_PROVIDER": "OpenAI"
+      },
+      "removeFiles": ["$HOME/.config/openai/auth.json"],
+      "commands": ["echo \"Switched to codex-88\""]
+    }
+  }
+}
+```
+
+Notes:
+- `removeFiles` is optional; when present, `codenv use <profile>` emits `rm -f` lines for those paths.
+- `commands` is optional; any strings are emitted as-is.
+- `note` is shown in `codenv list` output.
+- `codenv add` creates the config file if it does not exist (default: `./code-env.json`).
+
+## Fish shell
+
+```fish
+codenv use codex-88 | source
+```

package/bin/codenv.js

@@ -0,0 +1,377 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+function printHelp() {
+  const msg = `codenv - switch Claude/Codex env vars\n\nUsage:\n  codenv list\n  codenv use <profile>\n  codenv show <profile>\n  codenv unset\n  codenv add <profile> KEY=VALUE [KEY=VALUE ...]\n\nOptions:\n  -c, --config <path>   Path to config JSON\n  -h, --help            Show help\n\nAdd options:\n  -n, --note <text>            Set profile note\n  -r, --remove-file <path>     Add a removeFiles entry (repeat)\n  -x, --command <cmd>          Add a commands entry (repeat)\n  -u, --unset <KEY>            Add a global unset key (repeat)\n\nExamples:\n  eval "$(codenv use codex)"\n  codenv list\n  CODE_ENV_CONFIG=./code-env.json codenv use claude\n  codenv add codex-88 OPENAI_BASE_URL=https://api.openai.com/v1 OPENAI_API_KEY=sk-REPLACE_ME\n`;
+  console.log(msg);
+}
+
+function parseArgs(argv) {
+  let configPath = null;
+  const args = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "-h" || arg === "--help") return { help: true };
+    if (arg === "-c" || arg === "--config") {
+      configPath = argv[i + 1];
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--config=")) {
+      configPath = arg.slice("--config=".length);
+      continue;
+    }
+    args.push(arg);
+  }
+  return { args, configPath, help: false };
+}
+
+function resolvePath(p) {
+  if (!p) return null;
+  if (p.startsWith("~")) {
+    return path.join(os.homedir(), p.slice(1));
+  }
+  if (path.isAbsolute(p)) return p;
+  return path.resolve(process.cwd(), p);
+}
+
+function findConfigPath(explicitPath) {
+  if (explicitPath) {
+    const resolved = resolvePath(explicitPath);
+    if (fs.existsSync(resolved)) return resolved;
+    return resolved; // let readConfig raise a helpful error
+  }
+
+  if (process.env.CODE_ENV_CONFIG) {
+    const fromEnv = resolvePath(process.env.CODE_ENV_CONFIG);
+    if (fs.existsSync(fromEnv)) return fromEnv;
+    return fromEnv;
+  }
+
+  const candidates = [
+    path.resolve(process.cwd(), "code-env.json"),
+    path.resolve(process.cwd(), "profiles.json"),
+    path.resolve(process.cwd(), "code-env.config.json"),
+    path.join(os.homedir(), ".config", "code-env", "config.json"),
+  ];
+
+  for (const p of candidates) {
+    if (fs.existsSync(p)) return p;
+  }
+
+  return null;
+}
+
+function findConfigPathForWrite(explicitPath) {
+  if (explicitPath) return resolvePath(explicitPath);
+  if (process.env.CODE_ENV_CONFIG) return resolvePath(process.env.CODE_ENV_CONFIG);
+  const existing = findConfigPath(null);
+  if (existing) return existing;
+  return path.resolve(process.cwd(), "code-env.json");
+}
+
+function readConfig(configPath) {
+  if (!configPath) {
+    throw new Error(
+      "No config file found. Use --config or set CODE_ENV_CONFIG."
+    );
+  }
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`Config file not found: ${configPath}`);
+  }
+  const raw = fs.readFileSync(configPath, "utf8");
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Invalid JSON in config: ${configPath}`);
+  }
+}
+
+function readConfigIfExists(configPath) {
+  if (!configPath || !fs.existsSync(configPath)) {
+    return { unset: [], profiles: {} };
+  }
+  return readConfig(configPath);
+}
+
+function writeConfig(configPath, config) {
+  if (!configPath) {
+    throw new Error("Missing config path for write.");
+  }
+  const dir = path.dirname(configPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const data = JSON.stringify(config, null, 2);
+  fs.writeFileSync(configPath, `${data}\n`, "utf8");
+}
+
+function shellEscape(value) {
+  const str = String(value);
+  return `'${str.replace(/'/g, `'\\''`)}'`;
+}
+
+function expandEnv(input) {
+  if (!input) return input;
+  let out = String(input);
+  if (out.startsWith("~")) {
+    out = path.join(os.homedir(), out.slice(1));
+  }
+  out = out.replace(/\$\{([^}]+)\}/g, (_, key) => process.env[key] || "");
+  out = out.replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, key) => process.env[key] || "");
+  return out;
+}
+
+function parseAddArgs(args) {
+  const result = {
+    profile: null,
+    pairs: [],
+    note: null,
+    removeFiles: [],
+    commands: [],
+    unset: [],
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!result.profile && !arg.startsWith("-")) {
+      result.profile = arg;
+      continue;
+    }
+    if (arg === "-n" || arg === "--note") {
+      const val = args[i + 1];
+      if (!val) throw new Error("Missing value for --note.");
+      result.note = val;
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--note=")) {
+      result.note = arg.slice("--note=".length);
+      continue;
+    }
+    if (arg === "-r" || arg === "--remove-file") {
+      const val = args[i + 1];
+      if (!val) throw new Error("Missing value for --remove-file.");
+      result.removeFiles.push(val);
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--remove-file=")) {
+      result.removeFiles.push(arg.slice("--remove-file=".length));
+      continue;
+    }
+    if (arg === "-x" || arg === "--command") {
+      const val = args[i + 1];
+      if (!val) throw new Error("Missing value for --command.");
+      result.commands.push(val);
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--command=")) {
+      result.commands.push(arg.slice("--command=".length));
+      continue;
+    }
+    if (arg === "-u" || arg === "--unset") {
+      const val = args[i + 1];
+      if (!val) throw new Error("Missing value for --unset.");
+      result.unset.push(val);
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--unset=")) {
+      result.unset.push(arg.slice("--unset=".length));
+      continue;
+    }
+    if (arg.includes("=")) {
+      result.pairs.push(arg);
+      continue;
+    }
+    throw new Error(`Unknown add argument: ${arg}`);
+  }
+
+  if (!result.profile) {
+    throw new Error("Missing profile name.");
+  }
+
+  return result;
+}
+
+function addConfig(config, addArgs) {
+  if (!config.profiles || typeof config.profiles !== "object") {
+    config.profiles = {};
+  }
+  if (!config.profiles[addArgs.profile]) {
+    config.profiles[addArgs.profile] = {};
+  }
+  const profile = config.profiles[addArgs.profile];
+  if (!profile.env || typeof profile.env !== "object") {
+    profile.env = {};
+  }
+
+  for (const pair of addArgs.pairs) {
+    const idx = pair.indexOf("=");
+    if (idx <= 0) throw new Error(`Invalid KEY=VALUE: ${pair}`);
+    const key = pair.slice(0, idx);
+    const value = pair.slice(idx + 1);
+    profile.env[key] = value;
+  }
+
+  if (addArgs.note !== null && addArgs.note !== undefined) {
+    profile.note = addArgs.note;
+  }
+
+  if (addArgs.removeFiles.length > 0) {
+    if (!Array.isArray(profile.removeFiles)) profile.removeFiles = [];
+    for (const p of addArgs.removeFiles) {
+      if (!profile.removeFiles.includes(p)) profile.removeFiles.push(p);
+    }
+  }
+
+  if (addArgs.commands.length > 0) {
+    if (!Array.isArray(profile.commands)) profile.commands = [];
+    for (const cmd of addArgs.commands) {
+      if (!profile.commands.includes(cmd)) profile.commands.push(cmd);
+    }
+  }
+
+  if (addArgs.unset.length > 0) {
+    if (!Array.isArray(config.unset)) config.unset = [];
+    for (const key of addArgs.unset) {
+      if (!config.unset.includes(key)) config.unset.push(key);
+    }
+  }
+
+  return config;
+}
+
+function printList(config) {
+  const profiles = config && config.profiles ? config.profiles : {};
+  const names = Object.keys(profiles).sort();
+  if (names.length === 0) {
+    console.log("(no profiles found)");
+    return;
+  }
+  for (const name of names) {
+    const note = profiles[name] && profiles[name].note ? `\t${profiles[name].note}` : "";
+    console.log(`${name}${note}`);
+  }
+}
+
+function printShow(config, profileName) {
+  const profile = config.profiles && config.profiles[profileName];
+  if (!profile) {
+    throw new Error(`Unknown profile: ${profileName}`);
+  }
+  console.log(JSON.stringify(profile, null, 2));
+}
+
+function printUnset(config) {
+  const keys = Array.isArray(config.unset) ? config.unset : [];
+  if (keys.length === 0) return;
+  const lines = keys.map((k) => `unset ${k}`);
+  console.log(lines.join("\n"));
+}
+
+function printUse(config, profileName) {
+  const profile = config.profiles && config.profiles[profileName];
+  if (!profile) {
+    throw new Error(`Unknown profile: ${profileName}`);
+  }
+
+  const env = profile.env || {};
+  const lines = [];
+
+  if (Array.isArray(config.unset)) {
+    for (const key of config.unset) {
+      if (!Object.prototype.hasOwnProperty.call(env, key)) {
+        lines.push(`unset ${key}`);
+      }
+    }
+  }
+
+  for (const key of Object.keys(env)) {
+    const value = env[key];
+    if (value === null || value === undefined || value === "") {
+      lines.push(`unset ${key}`);
+    } else {
+      lines.push(`export ${key}=${shellEscape(value)}`);
+    }
+  }
+
+  if (Array.isArray(profile.removeFiles)) {
+    for (const p of profile.removeFiles) {
+      const expanded = expandEnv(p);
+      if (expanded) lines.push(`rm -f ${shellEscape(expanded)}`);
+    }
+  }
+
+  if (Array.isArray(profile.commands)) {
+    for (const cmd of profile.commands) {
+      if (cmd && String(cmd).trim()) lines.push(String(cmd));
+    }
+  }
+
+  console.log(lines.join("\n"));
+}
+
+function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  if (parsed.help) {
+    printHelp();
+    return;
+  }
+
+  const args = parsed.args || [];
+
+  if (args.length === 0) {
+    printHelp();
+    return;
+  }
+
+  const cmd = args[0];
+  try {
+    if (cmd === "add") {
+      const addArgs = parseAddArgs(args.slice(1));
+      const writePath = findConfigPathForWrite(parsed.configPath);
+      const config = readConfigIfExists(writePath);
+      const updated = addConfig(config, addArgs);
+      writeConfig(writePath, updated);
+      console.log(`Updated config: ${writePath}`);
+      return;
+    }
+
+    const configPath = findConfigPath(parsed.configPath);
+    const config = readConfig(configPath);
+    if (cmd === "list") {
+      printList(config);
+      return;
+    }
+    if (cmd === "use") {
+      const profileName = args[1];
+      if (!profileName) throw new Error("Missing profile name.");
+      printUse(config, profileName);
+      return;
+    }
+    if (cmd === "show") {
+      const profileName = args[1];
+      if (!profileName) throw new Error("Missing profile name.");
+      printShow(config, profileName);
+      return;
+    }
+    if (cmd === "unset") {
+      printUnset(config);
+      return;
+    }
+
+    throw new Error(`Unknown command: ${cmd}`);
+  } catch (err) {
+    console.error(`codenv: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/code-env.example.json

@@ -0,0 +1,40 @@
+{
+  "unset": [
+    "OPENAI_BASE_URL",
+    "OPENAI_API_KEY",
+    "CODEX_PROVIDER",
+    "ANTHROPIC_API_KEY",
+    "CLAUDE_CODE_BASE_URL"
+  ],
+  "profiles": {
+    "codex-88": {
+      "note": "OpenAI official",
+      "env": {
+        "OPENAI_BASE_URL": "https://api.openai.com/v1",
+        "OPENAI_API_KEY": "sk-REPLACE_ME",
+        "CODEX_PROVIDER": "OpenAI"
+      },
+      "removeFiles": [
+        "$HOME/.config/openai/auth.json"
+      ]
+    },
+    "codex-mirror": {
+      "note": "AICodeMirror",
+      "env": {
+        "OPENAI_BASE_URL": "https://api.aicodemirror.com/api/codex/backend-api/codex",
+        "OPENAI_API_KEY": "sk-REPLACE_ME",
+        "CODEX_PROVIDER": "AICodeMirror"
+      },
+      "removeFiles": [
+        "$HOME/.config/openai/auth.json"
+      ]
+    },
+    "claude": {
+      "note": "Claude Code",
+      "env": {
+        "ANTHROPIC_API_KEY": "sk-REPLACE_ME",
+        "CLAUDE_CODE_BASE_URL": "https://api.anthropic.com"
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@praeviso/code-env-switch",
+  "version": "0.1.0",
+  "description": "Switch between Claude Code and Codex environment variables from a single CLI",
+  "bin": {
+    "codenv": "bin/codenv.js"
+  },
+  "type": "commonjs",
+  "license": "MIT",
+  "engines": {
+    "node": ">=16"
+  }
+}