@orionpotter/menv 0.1.0

package/README.md

@@ -0,0 +1,267 @@
+# menv
+
+`mm` is a profile manager for AI CLI tools.
+
+It manages provider profiles such as `openai`, `openrouter`, or custom gateways, then applies the selected profile to a downstream CLI client. The current MVP supports `codex` by updating `~/.codex/config.toml`.
+
+## What problem it solves
+
+If you regularly switch between different model endpoints, API keys, or models, you usually end up editing one of these by hand:
+
+- shell environment variables
+- `.env` files
+- client config files such as `~/.codex/config.toml`
+- ad hoc scripts for each provider
+
+`mm` gives you a single place to define named profiles and switch clients between them safely.
+
+## Core concepts
+
+- `profile`: one saved configuration bundle, for example `openai-main` or `router-fast`
+- `client`: one downstream CLI whose config file can be managed by `mm`
+- `use`: apply one profile to one client
+- `doctor`: compare the selected profile with the actual client config and report drift
+- `sync`: re-apply the selected profile to the client config
+- `rollback`: restore the most recent backup created during `use` or `sync`
+
+## Current MVP scope
+
+Implemented now:
+
+- profile storage in `mm` config
+- alias support
+- client abstraction for future expansion
+- Codex client support
+- config drift detection
+- one-step sync back to Codex config
+- backup and rollback
+- npm package with `mm` executable
+
+Not implemented yet:
+
+- multiple backup history
+- encrypted secret storage
+- direct model invocation through `mm`
+- non-Codex client adapters
+
+## Install
+
+Local development:
+
+```bash
+npm install
+npm link
+mm.cmd --help
+```
+
+After publishing to npm:
+
+```bash
+npm install -g @orionpotter/menv
+mm --help
+```
+
+Notes:
+
+- On Windows PowerShell with restrictive execution policy, use `mm.cmd`.
+- The npm package name is `@orionpotter/menv` while the executable command remains `mm`.
+
+## Quick start
+
+### 1. Add profiles
+
+```bash
+mm add openai-main --provider openai --model gpt-5.4 --base-url https://api.openai.com/v1 --api-key-env OPENAI_API_KEY
+mm add router-fast --provider openrouter --model openai/gpt-4o-mini --base-url https://openrouter.ai/api/v1 --api-key-env OPENROUTER_API_KEY
+```
+
+### 2. Point Codex at one profile
+
+```bash
+mm use openai-main --client codex
+```
+
+This updates `~/.codex/config.toml` so Codex will use the selected profile values.
+
+### 3. Inspect current state
+
+```bash
+mm current --client codex
+mm which --client codex
+mm doctor --client codex
+```
+
+### 4. Re-sync after drift
+
+If you manually edited `~/.codex/config.toml` or another tool changed it:
+
+```bash
+mm sync --client codex
+```
+
+### 5. Roll back to the last backup
+
+```bash
+mm rollback --client codex
+```
+
+## Concrete Codex example
+
+Suppose your current `~/.codex/config.toml` points to one endpoint, but you want to temporarily switch Codex to OpenRouter.
+
+Create a profile:
+
+```bash
+mm add router-fast \
+  --provider openrouter \
+  --model openai/gpt-4o-mini \
+  --base-url https://openrouter.ai/api/v1 \
+  --api-key-env OPENROUTER_API_KEY
+```
+
+Apply it to Codex:
+
+```bash
+mm use router-fast --client codex
+```
+
+Now inspect the result:
+
+```bash
+mm which --client codex
+```
+
+You should see the selected profile values and the actual values found in `~/.codex/config.toml`.
+
+If they drift apart later:
+
+```bash
+mm doctor --client codex
+mm sync --client codex
+```
+
+If you want to go back to the previous Codex config snapshot:
+
+```bash
+mm rollback --client codex
+```
+
+## Alias example
+
+Aliases let you switch by intent instead of provider details.
+
+```bash
+mm alias set fast router-fast
+mm use fast --client codex
+```
+
+## Commands
+
+```bash
+mm list
+mm clients
+mm current [--client codex]
+mm which [--client codex]
+mm use <profile> [--client codex] [--project]
+mm sync [--client codex]
+mm doctor [--client codex]
+mm rollback [--client codex]
+mm add <profile> --provider NAME --model MODEL --base-url URL [--api-key KEY] [--api-key-env ENV]
+mm remove <profile>
+mm config set <key> <value>
+mm config get <key>
+mm config list
+mm alias list
+mm alias set <name> <profile>
+mm alias remove <name>
+```
+
+## How `mm use` works
+
+`mm use <profile> --client codex` does two things:
+
+1. It records the selected profile in `mm`'s own config.
+2. It applies that profile to Codex by updating `~/.codex/config.toml`.
+
+For Codex, the current implementation writes these top-level keys when present:
+
+- `provider`
+- `model`
+- `base_url`
+- `api_key`
+- `api_key_env`
+- `model_reasoning_effort`
+
+Existing unrelated TOML sections are preserved.
+
+## Backup and rollback semantics
+
+Before `mm use` or `mm sync` writes the client config, `mm` creates one backup file:
+
+- Codex backup path: `~/.codex/config.toml.bak`
+
+`mm rollback --client codex` restores that backup.
+
+Important limitation in the current MVP:
+
+- backup history is single-slot
+- the latest write replaces the previous backup
+- if you sync after a bad manual edit, rollback restores the state immediately before that sync, not an older historical version
+
+## Validation behavior
+
+For Codex, `mm doctor` currently checks:
+
+- whether the selected profile has a `model`
+- whether `baseURL` is missing
+- whether both `apiKey` and `apiKeyEnv` are missing
+- whether the current Codex config has drifted from the selected profile
+
+## Config files
+
+`mm` config:
+
+- Windows: `%APPDATA%/mm/config.json`
+- macOS/Linux: `~/.config/mm/config.json`
+
+Current supported client config:
+
+- Codex: `~/.codex/config.toml`
+
+Project override file:
+
+- `.mm.json`
+
+## Development
+
+```bash
+npm install
+npm run check
+npm run build
+npm link
+```
+
+## Publish to npm
+
+Manual publish:
+
+```bash
+npm login
+npm publish --provenance
+```
+
+GitHub Actions publish:
+
+- workflow file: `.github/workflows/publish.yml`
+- trigger: push tag matching `v*` or manual dispatch
+- required secret: `NPM_TOKEN`
+
+## Roadmap
+
+Planned next steps:
+
+- multiple backup history and named rollback targets
+- more client adapters beyond Codex
+- safer secret handling
+- richer profile schema per client
+

package/dist/cli.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCli = runCli;
+exports.handleCliError = handleCliError;
+const store_1 = require("./config/store");
+const resolver_1 = require("./core/resolver");
+const errors_1 = require("./errors");
+const clients_1 = require("./clients");
+const output_1 = require("./output");
+function parseArgs(argv) {
+    const positionals = [];
+    const flags = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (!token.startsWith("--")) {
+            positionals.push(token);
+            continue;
+        }
+        const key = token.slice(2);
+        const next = argv[index + 1];
+        if (!next || next.startsWith("--")) {
+            flags[key] = true;
+            continue;
+        }
+        flags[key] = next;
+        index += 1;
+    }
+    return { positionals, flags };
+}
+function asString(flag) {
+    return typeof flag === "string" ? flag : undefined;
+}
+function requirePositional(value, message) {
+    if (!value) {
+        throw new errors_1.ConfigError(message);
+    }
+    return value;
+}
+function printHelp() {
+    console.log(`mm - client config manager
+
+Commands:
+  mm list
+  mm clients
+  mm current [--client codex]
+  mm which [--client codex]
+  mm use <profile> [--client codex] [--project]
+  mm sync [--client codex]
+  mm doctor [--client codex]
+  mm rollback [--client codex]
+  mm add <profile> --provider NAME --model MODEL --base-url URL [--api-key KEY] [--api-key-env ENV]
+  mm remove <profile>
+  mm config set <key> <value>
+  mm config get <key>
+  mm config list
+  mm alias list
+  mm alias set <name> <profile>
+  mm alias remove <name>`);
+}
+function getClientName(flagValue, storeDefault) {
+    return flagValue ?? storeDefault;
+}
+async function runCli(argv) {
+    const store = new store_1.ConfigStore();
+    const resolver = new resolver_1.Resolver(store);
+    const [command, ...rest] = argv;
+    const parsed = parseArgs(rest);
+    const config = await store.readGlobalConfig();
+    const clientName = getClientName(asString(parsed.flags.client), config.defaultClient);
+    switch (command) {
+        case undefined:
+        case "help":
+        case "--help":
+            printHelp();
+            return;
+        case "clients": {
+            for (const client of (0, clients_1.listClientNames)()) {
+                console.log(client);
+            }
+            return;
+        }
+        case "list": {
+            (0, output_1.printList)(config);
+            return;
+        }
+        case "current": {
+            const resolved = await resolver.resolveProfile({ client: clientName });
+            const state = await (0, clients_1.getClientAdapter)(clientName).readState();
+            (0, output_1.printCurrent)(resolved, state);
+            return;
+        }
+        case "which": {
+            const resolved = await resolver.resolveProfile({ client: clientName });
+            const state = await (0, clients_1.getClientAdapter)(clientName).readState();
+            (0, output_1.printWhich)(resolved, state);
+            return;
+        }
+        case "use": {
+            const profileName = requirePositional(parsed.positionals[0], "Usage: mm use <profile>");
+            const scope = parsed.flags.project ? "project" : "global";
+            await store.setCurrentProfile(clientName, profileName, scope);
+            const client = (0, clients_1.getClientAdapter)(clientName);
+            const resolved = await resolver.resolveProfile({ client: clientName });
+            const validationIssues = client.validateProfile(resolved.profile).filter((issue) => issue.level === "error");
+            if (validationIssues.length > 0) {
+                (0, output_1.printIssues)(validationIssues);
+                throw new errors_1.ConfigError("Profile validation failed.");
+            }
+            const result = await client.applyProfile(resolved.profileName, resolved.profile);
+            console.log(`updated ${scope} profile for ${clientName} to ${profileName}`);
+            (0, output_1.printApplyResult)(result);
+            return;
+        }
+        case "sync": {
+            const client = (0, clients_1.getClientAdapter)(clientName);
+            const resolved = await resolver.resolveProfile({ client: clientName });
+            const validationIssues = client.validateProfile(resolved.profile).filter((issue) => issue.level === "error");
+            if (validationIssues.length > 0) {
+                (0, output_1.printIssues)(validationIssues);
+                throw new errors_1.ConfigError("Profile validation failed.");
+            }
+            const result = await client.applyProfile(resolved.profileName, resolved.profile);
+            (0, output_1.printApplyResult)(result);
+            return;
+        }
+        case "doctor": {
+            const client = (0, clients_1.getClientAdapter)(clientName);
+            const resolved = await resolver.resolveProfile({ client: clientName });
+            const state = await client.readState();
+            const issues = [
+                ...client.validateProfile(resolved.profile),
+                ...client.compareProfile(state, resolved.profile)
+            ];
+            (0, output_1.printIssues)(issues);
+            return;
+        }
+        case "rollback": {
+            const result = await (0, clients_1.getClientAdapter)(clientName).rollback();
+            (0, output_1.printRollbackResult)(result);
+            return;
+        }
+        case "add": {
+            const profileName = requirePositional(parsed.positionals[0], "Usage: mm add <profile> --provider NAME --model MODEL --base-url URL");
+            await store.upsertProfile(profileName, {
+                provider: asString(parsed.flags.provider),
+                model: asString(parsed.flags.model),
+                baseURL: asString(parsed.flags["base-url"]),
+                apiKey: asString(parsed.flags["api-key"]),
+                apiKeyEnv: asString(parsed.flags["api-key-env"]),
+                reasoningEffort: asString(parsed.flags["reasoning-effort"]),
+                organization: asString(parsed.flags.organization),
+                region: asString(parsed.flags.region),
+                deployment: asString(parsed.flags.deployment)
+            });
+            console.log(`profile ${profileName} updated`);
+            return;
+        }
+        case "remove": {
+            const profileName = requirePositional(parsed.positionals[0], "Usage: mm remove <profile>");
+            await store.removeProfile(profileName);
+            console.log(`profile ${profileName} removed`);
+            return;
+        }
+        case "config": {
+            const subcommand = parsed.positionals[0];
+            if (subcommand === "set") {
+                const key = requirePositional(parsed.positionals[1], "Usage: mm config set <key> <value>");
+                const value = requirePositional(parsed.positionals[2], "Usage: mm config set <key> <value>");
+                await store.setConfigValue(key, value);
+                console.log(`config updated: ${key}`);
+                return;
+            }
+            if (subcommand === "get") {
+                const key = requirePositional(parsed.positionals[1], "Usage: mm config get <key>");
+                const value = await store.getConfigValue(key);
+                console.log(value === undefined ? "(unset)" : JSON.stringify(value, null, 2));
+                return;
+            }
+            if (subcommand === "list") {
+                (0, output_1.printConfig)(config);
+                return;
+            }
+            throw new errors_1.ConfigError("Usage: mm config <set|get|list> ...");
+        }
+        case "alias": {
+            const subcommand = parsed.positionals[0];
+            if (subcommand === "list") {
+                for (const [name, target] of Object.entries(config.aliases)) {
+                    console.log(`${name}: ${target}`);
+                }
+                return;
+            }
+            if (subcommand === "set") {
+                const name = requirePositional(parsed.positionals[1], "Usage: mm alias set <name> <profile>");
+                const profileName = requirePositional(parsed.positionals[2], "Usage: mm alias set <name> <profile>");
+                await store.setAlias(name, profileName);
+                console.log(`alias ${name} -> ${profileName}`);
+                return;
+            }
+            if (subcommand === "remove") {
+                const name = requirePositional(parsed.positionals[1], "Usage: mm alias remove <name>");
+                await store.removeAlias(name);
+                console.log(`alias ${name} removed`);
+                return;
+            }
+            throw new errors_1.ConfigError("Usage: mm alias <list|set|remove> ...");
+        }
+        default:
+            throw new errors_1.ConfigError(`Unknown command: ${command}`);
+    }
+}
+function handleCliError(error) {
+    if (error instanceof errors_1.MmError) {
+        console.error(`error: ${error.message}`);
+        process.exit(1);
+    }
+    if (error instanceof Error) {
+        console.error(`error: ${error.message}`);
+        process.exit(1);
+    }
+    console.error("error: unexpected failure");
+    process.exit(1);
+}

package/dist/clients/codex.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexClientAdapter = void 0;
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const promises_1 = require("node:fs/promises");
+const node_fs_1 = require("node:fs");
+const fs_1 = require("../utils/fs");
+const errors_1 = require("../errors");
+function parseTopLevelToml(content) {
+    const values = {};
+    const lines = content.split(/\r?\n/);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("[")) {
+            continue;
+        }
+        const match = /^([A-Za-z0-9_\-]+)\s*=\s*"(.*)"\s*$/.exec(trimmed);
+        if (match) {
+            values[match[1]] = match[2];
+        }
+    }
+    return values;
+}
+function upsertTopLevelToml(content, values) {
+    const lines = content === "" ? [] : content.split(/\r?\n/);
+    const updatedKeys = [];
+    const pending = new Map(Object.entries(values).filter((entry) => entry[1] !== undefined));
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const match = /^([A-Za-z0-9_\-]+)\s*=/.exec(line.trim());
+        if (!match) {
+            continue;
+        }
+        const key = match[1];
+        if (!pending.has(key)) {
+            continue;
+        }
+        lines[index] = `${key} = ${JSON.stringify(pending.get(key))}`;
+        updatedKeys.push(key);
+        pending.delete(key);
+    }
+    const insertionIndex = lines.findIndex((line) => line.trim().startsWith("["));
+    const appended = Array.from(pending.entries()).map(([key, value]) => `${key} = ${JSON.stringify(value)}`);
+    updatedKeys.push(...Array.from(pending.keys()));
+    if (appended.length > 0) {
+        if (insertionIndex === -1) {
+            if (lines.length > 0 && lines[lines.length - 1] !== "") {
+                lines.push("");
+            }
+            lines.push(...appended);
+        }
+        else {
+            const head = lines.slice(0, insertionIndex);
+            const tail = lines.slice(insertionIndex);
+            const merged = [...head];
+            if (merged.length > 0 && merged[merged.length - 1] !== "") {
+                merged.push("");
+            }
+            merged.push(...appended, "", ...tail);
+            return { content: `${merged.join("\n")}\n`, updatedKeys };
+        }
+    }
+    return { content: `${lines.join("\n")}\n`, updatedKeys };
+}
+class CodexClientAdapter {
+    name = "codex";
+    getConfigPath() {
+        return (0, node_path_1.join)((0, node_os_1.homedir)(), ".codex", "config.toml");
+    }
+    async readState() {
+        const configPath = this.getConfigPath();
+        const content = (0, node_fs_1.existsSync)(configPath) ? await (0, promises_1.readFile)(configPath, "utf8") : "";
+        return {
+            client: this.name,
+            configPath,
+            values: parseTopLevelToml(content)
+        };
+    }
+    validateProfile(profile) {
+        const issues = [];
+        if (!profile.model) {
+            issues.push({ level: "error", message: "profile.model is required for Codex." });
+        }
+        if (!profile.baseURL) {
+            issues.push({ level: "warn", message: "profile.baseURL is unset; Codex may continue using the previous endpoint." });
+        }
+        if (!profile.apiKey && !profile.apiKeyEnv) {
+            issues.push({ level: "warn", message: "Neither apiKey nor apiKeyEnv is set; authentication may fail." });
+        }
+        return issues;
+    }
+    compareProfile(state, profile) {
+        const issues = [];
+        const expected = {
+            provider: profile.provider,
+            model: profile.model,
+            base_url: profile.baseURL,
+            api_key: profile.apiKey,
+            api_key_env: profile.apiKeyEnv,
+            model_reasoning_effort: profile.reasoningEffort
+        };
+        for (const [key, value] of Object.entries(expected)) {
+            if (value === undefined) {
+                continue;
+            }
+            const actual = state.values[key];
+            if (actual !== value) {
+                issues.push({
+                    level: "warn",
+                    message: `${key} drifted: codex has ${actual ?? "(unset)"}, profile wants ${value}.`
+                });
+            }
+        }
+        if (issues.length === 0) {
+            issues.push({ level: "info", message: "Codex config matches the selected profile." });
+        }
+        return issues;
+    }
+    async applyProfile(profileName, profile) {
+        const configPath = this.getConfigPath();
+        await (0, fs_1.ensureDirForFile)(configPath);
+        const backupPath = await (0, fs_1.backupFile)(configPath);
+        const currentContent = (0, node_fs_1.existsSync)(configPath) ? await (0, promises_1.readFile)(configPath, "utf8") : "";
+        const { content, updatedKeys } = upsertTopLevelToml(currentContent, {
+            provider: profile.provider,
+            model: profile.model,
+            base_url: profile.baseURL,
+            api_key: profile.apiKey,
+            api_key_env: profile.apiKeyEnv,
+            model_reasoning_effort: profile.reasoningEffort
+        });
+        await (0, promises_1.writeFile)(configPath, content, "utf8");
+        return {
+            client: this.name,
+            configPath,
+            updatedKeys,
+            backupPath
+        };
+    }
+    async rollback() {
+        const configPath = this.getConfigPath();
+        const backupPath = await (0, fs_1.restoreBackupFile)(configPath);
+        if (!backupPath) {
+            throw new errors_1.ConfigError(`No backup found for ${configPath}.`);
+        }
+        return {
+            client: this.name,
+            configPath,
+            backupPath
+        };
+    }
+}
+exports.CodexClientAdapter = CodexClientAdapter;

package/dist/clients/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClientAdapter = getClientAdapter;
+exports.listClientNames = listClientNames;
+const errors_1 = require("../errors");
+const codex_1 = require("./codex");
+const REGISTRY = {
+    codex: new codex_1.CodexClientAdapter()
+};
+function getClientAdapter(name) {
+    const adapter = REGISTRY[name];
+    if (!adapter) {
+        throw new errors_1.ClientNotFoundError(`Client adapter not found for ${name}.`);
+    }
+    return adapter;
+}
+function listClientNames() {
+    return Object.keys(REGISTRY);
+}

package/dist/config/store.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigStore = void 0;
+const node_process_1 = require("node:process");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const fs_1 = require("../utils/fs");
+const DEFAULT_GLOBAL_CONFIG = {
+    defaultClient: "codex",
+    currentProfiles: {},
+    profiles: {},
+    aliases: {}
+};
+class ConfigStore {
+    getGlobalConfigPath() {
+        if (process.platform === "win32" && process.env.APPDATA) {
+            return (0, node_path_1.join)(process.env.APPDATA, "mm", "config.json");
+        }
+        return (0, node_path_1.join)((0, node_os_1.homedir)(), ".config", "mm", "config.json");
+    }
+    getProjectConfigPath(startDir = (0, node_process_1.cwd)()) {
+        const found = (0, fs_1.findUp)(".mm.json", startDir);
+        return found ?? (0, node_path_1.join)(startDir, ".mm.json");
+    }
+    async readGlobalConfig() {
+        const config = await (0, fs_1.readJsonFile)(this.getGlobalConfigPath());
+        return this.mergeGlobalConfig(config);
+    }
+    async writeGlobalConfig(config) {
+        await (0, fs_1.writeJsonFile)(this.getGlobalConfigPath(), config);
+    }
+    async readProjectConfig(startDir = (0, node_process_1.cwd)()) {
+        return (0, fs_1.readJsonFile)(this.getProjectConfigPath(startDir));
+    }
+    async writeProjectConfig(config, startDir = (0, node_process_1.cwd)()) {
+        await (0, fs_1.writeJsonFile)(this.getProjectConfigPath(startDir), config);
+    }
+    async setCurrentProfile(client, profileName, scope) {
+        if (scope === "project") {
+            const projectConfig = (await this.readProjectConfig()) ?? {};
+            projectConfig.profile = profileName;
+            await this.writeProjectConfig(projectConfig);
+            return;
+        }
+        const globalConfig = await this.readGlobalConfig();
+        globalConfig.currentProfiles[client] = profileName;
+        await this.writeGlobalConfig(globalConfig);
+    }
+    async upsertProfile(name, profile) {
+        const globalConfig = await this.readGlobalConfig();
+        globalConfig.profiles[name] = {
+            ...globalConfig.profiles[name],
+            ...profile
+        };
+        await this.writeGlobalConfig(globalConfig);
+    }
+    async removeProfile(name) {
+        const globalConfig = await this.readGlobalConfig();
+        delete globalConfig.profiles[name];
+        for (const client of Object.keys(globalConfig.currentProfiles)) {
+            if (globalConfig.currentProfiles[client] === name) {
+                delete globalConfig.currentProfiles[client];
+            }
+        }
+        delete globalConfig.aliases[name];
+        await this.writeGlobalConfig(globalConfig);
+    }
+    async setAlias(name, profileName) {
+        const globalConfig = await this.readGlobalConfig();
+        globalConfig.aliases[name] = profileName;
+        await this.writeGlobalConfig(globalConfig);
+    }
+    async removeAlias(name) {
+        const globalConfig = await this.readGlobalConfig();
+        delete globalConfig.aliases[name];
+        await this.writeGlobalConfig(globalConfig);
+    }
+    async setConfigValue(key, value) {
+        const globalConfig = await this.readGlobalConfig();
+        const path = key.split(".");
+        let cursor = globalConfig;
+        for (const segment of path.slice(0, -1)) {
+            const next = cursor[segment];
+            if (!next || typeof next !== "object" || Array.isArray(next)) {
+                cursor[segment] = {};
+            }
+            cursor = cursor[segment];
+        }
+        cursor[path[path.length - 1]] = value;
+        await this.writeGlobalConfig(globalConfig);
+    }
+    async getConfigValue(key) {
+        const globalConfig = await this.readGlobalConfig();
+        return key.split(".").reduce((acc, segment) => {
+            if (!acc || typeof acc !== "object") {
+                return undefined;
+            }
+            return acc[segment];
+        }, globalConfig);
+    }
+    mergeGlobalConfig(config) {
+        return {
+            defaultClient: config?.defaultClient ?? DEFAULT_GLOBAL_CONFIG.defaultClient,
+            currentProfiles: {
+                ...DEFAULT_GLOBAL_CONFIG.currentProfiles,
+                ...(config?.currentProfiles ?? {})
+            },
+            profiles: {
+                ...DEFAULT_GLOBAL_CONFIG.profiles,
+                ...(config?.profiles ?? {})
+            },
+            aliases: {
+                ...DEFAULT_GLOBAL_CONFIG.aliases,
+                ...(config?.aliases ?? {})
+            }
+        };
+    }
+}
+exports.ConfigStore = ConfigStore;

package/dist/core/resolver.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Resolver = void 0;
+const errors_1 = require("../errors");
+class Resolver {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    async resolveProfile(options) {
+        const globalConfig = await this.store.readGlobalConfig();
+        const projectConfig = await this.store.readProjectConfig();
+        const profileField = this.pickFirst([
+            { value: options.profileOverride, source: "command line" },
+            { value: projectConfig?.profile, source: "project config" },
+            { value: process.env.MM_PROFILE, source: "environment" },
+            { value: globalConfig.currentProfiles[options.client], source: "global config" }
+        ]);
+        if (!profileField.value) {
+            throw new errors_1.ConfigError(`No active profile for client ${options.client}. Use \`mm use <profile>\` first.`);
+        }
+        const expandedProfileName = globalConfig.aliases[profileField.value] ?? profileField.value;
+        const profile = globalConfig.profiles[expandedProfileName];
+        if (!profile) {
+            throw new errors_1.ProfileNotFoundError(`Unknown profile: ${expandedProfileName}`);
+        }
+        const profileSource = globalConfig.aliases[profileField.value] && expandedProfileName !== profileField.value
+            ? `${profileField.source} via alias`
+            : profileField.source;
+        return {
+            client: options.client,
+            profileName: expandedProfileName,
+            profile,
+            resolvedFrom: {
+                profileName: profileSource
+            }
+        };
+    }
+    pickFirst(values) {
+        for (const item of values) {
+            if (item.value !== undefined && item.value !== "") {
+                return item;
+            }
+        }
+        return { value: undefined, source: "unset" };
+    }
+}
+exports.Resolver = Resolver;

package/dist/errors.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientNotFoundError = exports.ProfileNotFoundError = exports.ConfigError = exports.MmError = void 0;
+class MmError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = new.target.name;
+    }
+}
+exports.MmError = MmError;
+class ConfigError extends MmError {
+}
+exports.ConfigError = ConfigError;
+class ProfileNotFoundError extends MmError {
+}
+exports.ProfileNotFoundError = ProfileNotFoundError;
+class ClientNotFoundError extends MmError {
+}
+exports.ClientNotFoundError = ClientNotFoundError;

package/dist/index.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_1 = require("./cli");
+void (0, cli_1.runCli)(process.argv.slice(2)).catch(cli_1.handleCliError);

package/dist/output.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printConfig = printConfig;
+exports.printList = printList;
+exports.printCurrent = printCurrent;
+exports.printWhich = printWhich;
+exports.printApplyResult = printApplyResult;
+exports.printRollbackResult = printRollbackResult;
+exports.printIssues = printIssues;
+function printConfig(config) {
+    console.log(JSON.stringify(config, null, 2));
+}
+function printList(config) {
+    console.log("clients:");
+    for (const [client, profile] of Object.entries(config.currentProfiles)) {
+        console.log(`  ${client}: ${profile}`);
+    }
+    console.log("profiles:");
+    for (const [name, profile] of Object.entries(config.profiles)) {
+        const summary = [profile.provider, profile.model].filter(Boolean).join(" / ");
+        console.log(`  ${name}${summary ? ` -> ${summary}` : ""}`);
+    }
+    console.log("aliases:");
+    for (const [name, target] of Object.entries(config.aliases)) {
+        console.log(`  ${name} -> ${target}`);
+    }
+}
+function printCurrent(resolved, state) {
+    console.log(`client: ${resolved.client}`);
+    console.log(`profile: ${resolved.profileName}`);
+    console.log(`provider: ${resolved.profile.provider ?? "(unset)"}`);
+    console.log(`model: ${resolved.profile.model ?? "(unset)"}`);
+    console.log(`baseURL: ${resolved.profile.baseURL ?? "(unset)"}`);
+    console.log(`configPath: ${state.configPath}`);
+    console.log(`source: ${resolved.resolvedFrom.profileName}`);
+}
+function printWhich(resolved, state) {
+    console.log(`client: ${resolved.client}`);
+    console.log(`profile: ${resolved.profileName}`);
+    console.log(`configPath: ${state.configPath}`);
+    console.log(`resolvedFrom.profile: ${resolved.resolvedFrom.profileName}`);
+    console.log(`profile.provider: ${resolved.profile.provider ?? "(unset)"}`);
+    console.log(`profile.model: ${resolved.profile.model ?? "(unset)"}`);
+    console.log(`profile.baseURL: ${resolved.profile.baseURL ?? "(unset)"}`);
+    console.log(`profile.apiKey: ${resolved.profile.apiKey ? "(set)" : "(unset)"}`);
+    console.log(`profile.apiKeyEnv: ${resolved.profile.apiKeyEnv ?? "(unset)"}`);
+    console.log(`codex.provider: ${state.values.provider ?? "(unset)"}`);
+    console.log(`codex.model: ${state.values.model ?? "(unset)"}`);
+    console.log(`codex.base_url: ${state.values.base_url ?? "(unset)"}`);
+    console.log(`codex.api_key: ${state.values.api_key ? "(set)" : "(unset)"}`);
+    console.log(`codex.api_key_env: ${state.values.api_key_env ?? "(unset)"}`);
+}
+function printApplyResult(result) {
+    console.log(`client: ${result.client}`);
+    console.log(`configPath: ${result.configPath}`);
+    console.log(`updatedKeys: ${result.updatedKeys.join(", ") || "(none)"}`);
+    if (result.backupPath) {
+        console.log(`backup: ${result.backupPath}`);
+    }
+}
+function printRollbackResult(result) {
+    console.log(`client: ${result.client}`);
+    console.log(`configPath: ${result.configPath}`);
+    console.log(`restoredFrom: ${result.backupPath}`);
+}
+function printIssues(issues) {
+    if (issues.length === 0) {
+        console.log("ok: no issues found");
+        return;
+    }
+    for (const issue of issues) {
+        console.log(`${issue.level}: ${issue.message}`);
+    }
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/fs.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readJsonFile = readJsonFile;
+exports.writeJsonFile = writeJsonFile;
+exports.ensureDirForFile = ensureDirForFile;
+exports.backupFile = backupFile;
+exports.restoreBackupFile = restoreBackupFile;
+exports.findUp = findUp;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+async function readJsonFile(filePath) {
+    if (!(0, node_fs_1.existsSync)(filePath)) {
+        return undefined;
+    }
+    const content = await (0, promises_1.readFile)(filePath, "utf8");
+    return JSON.parse(content);
+}
+async function writeJsonFile(filePath, value) {
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(filePath), { recursive: true });
+    await (0, promises_1.writeFile)(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+async function ensureDirForFile(filePath) {
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(filePath), { recursive: true });
+}
+async function backupFile(filePath) {
+    if (!(0, node_fs_1.existsSync)(filePath)) {
+        return undefined;
+    }
+    const backupPath = `${filePath}.bak`;
+    await (0, promises_1.copyFile)(filePath, backupPath);
+    return backupPath;
+}
+async function restoreBackupFile(filePath) {
+    const backupPath = `${filePath}.bak`;
+    if (!(0, node_fs_1.existsSync)(backupPath)) {
+        return undefined;
+    }
+    await (0, promises_1.rename)(backupPath, filePath);
+    return backupPath;
+}
+function findUp(fileName, startDir) {
+    let current = startDir;
+    while (true) {
+        const candidate = (0, node_path_1.join)(current, fileName);
+        if ((0, node_fs_1.existsSync)(candidate)) {
+            return candidate;
+        }
+        const parent = (0, node_path_1.dirname)(current);
+        if (parent === current || current === (0, node_path_1.parse)(current).root) {
+            return undefined;
+        }
+        current = parent;
+    }
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@orionpotter/menv",
+  "version": "0.1.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/OrionPotter/menv"
+  },
+  "description": "CLI profile manager for Codex and other AI CLIs",
+  "type": "commonjs",
+  "bin": {
+    "mm": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run check && npm run build",
+    "start": "node dist/index.js"
+  },
+  "keywords": [
+    "cli",
+    "codex",
+    "config",
+    "provider-manager",
+    "npm"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.0",
+    "typescript": "^5.9.3"
+  }
+}
+