@praeviso/code-env-switch 0.1.0 → 0.1.2

package/bin/profile/resolve.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateProfileKey = generateProfileKey;
+exports.resolveProfileName = resolveProfileName;
+exports.resolveProfileByType = resolveProfileByType;
+const type_1 = require("./type");
+const match_1 = require("./match");
+function generateProfileKey(config) {
+    const profiles = config && config.profiles ? config.profiles : {};
+    for (let i = 0; i < 10; i++) {
+        const key = `p_${Date.now().toString(36)}_${Math.random()
+            .toString(36)
+            .slice(2, 8)}`;
+        if (!profiles[key])
+            return key;
+    }
+    let idx = 0;
+    while (true) {
+        const key = `p_${Date.now().toString(36)}_${idx}`;
+        if (!profiles[key])
+            return key;
+        idx++;
+    }
+}
+function resolveProfileName(config, params) {
+    if (!params || params.length === 0) {
+        throw new Error("Missing profile name.");
+    }
+    if (params.length >= 2) {
+        const maybeType = (0, type_1.normalizeType)(params[0]);
+        if (maybeType) {
+            const name = params[1];
+            return resolveProfileByType(config, maybeType, name, params[0]);
+        }
+    }
+    const name = params[0];
+    const profiles = config && config.profiles ? config.profiles : {};
+    if (profiles[name])
+        return name;
+    const matches = (0, match_1.findProfileKeysByName)(config, name, null);
+    if (matches.length === 1)
+        return matches[0];
+    if (matches.length > 1) {
+        throw new Error(`Multiple profiles named "${name}". ` +
+            `Use: codenv <type> ${name} (or profile key: ${matches.join(", ")})`);
+    }
+    return name;
+}
+function resolveProfileByType(config, type, name, rawType) {
+    if (!name)
+        throw new Error("Missing profile name.");
+    const profiles = config && config.profiles ? config.profiles : {};
+    if (profiles[name] && (0, match_1.profileMatchesType)(profiles[name], type)) {
+        return name;
+    }
+    const matches = (0, match_1.findProfileKeysByName)(config, name, type);
+    if (matches.length === 1)
+        return matches[0];
+    if (matches.length > 1) {
+        throw new Error(`Multiple profiles named "${name}" for type "${type}". ` +
+            `Use profile key: ${matches.join(", ")}`);
+    }
+    if (rawType) {
+        const prefixes = [];
+        const raw = String(rawType).trim();
+        if (raw && raw.toLowerCase() !== type)
+            prefixes.push(raw);
+        prefixes.push(type);
+        for (const prefix of prefixes) {
+            for (const sep of ["-", "_", "."]) {
+                const candidate = `${prefix}${sep}${name}`;
+                if (profiles[candidate] && (0, match_1.profileMatchesType)(profiles[candidate], type)) {
+                    return candidate;
+                }
+            }
+        }
+    }
+    throw new Error(`Unknown profile for type "${type}": ${name}`);
+}

package/bin/profile/type.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeType = normalizeType;
+exports.hasTypePrefix = hasTypePrefix;
+exports.hasEnvKeyPrefix = hasEnvKeyPrefix;
+exports.inferProfileType = inferProfileType;
+exports.stripTypePrefixFromName = stripTypePrefixFromName;
+exports.getProfileDisplayName = getProfileDisplayName;
+function normalizeType(value) {
+    if (!value)
+        return null;
+    const raw = String(value).trim().toLowerCase();
+    if (!raw)
+        return null;
+    const compact = raw.replace(/[\s_-]+/g, "");
+    if (compact === "codex")
+        return "codex";
+    if (compact === "claude" || compact === "claudecode" || compact === "cc") {
+        return "claude";
+    }
+    return null;
+}
+function hasTypePrefix(name, type) {
+    if (!name)
+        return false;
+    const lowered = String(name).toLowerCase();
+    const prefixes = type === "claude" ? [type, "cc"] : [type];
+    for (const prefix of prefixes) {
+        for (const sep of ["-", "_", "."]) {
+            if (lowered.startsWith(`${prefix}${sep}`))
+                return true;
+        }
+    }
+    return false;
+}
+function hasEnvKeyPrefix(profile, prefix) {
+    if (!profile || !profile.env)
+        return false;
+    const normalized = prefix.toUpperCase();
+    for (const key of Object.keys(profile.env)) {
+        if (key.toUpperCase().startsWith(normalized))
+            return true;
+    }
+    return false;
+}
+function inferProfileType(profileName, profile, requestedType) {
+    if (requestedType)
+        return requestedType;
+    const fromProfile = profile ? normalizeType(profile.type) : null;
+    if (fromProfile)
+        return fromProfile;
+    if (hasEnvKeyPrefix(profile, "OPENAI_"))
+        return "codex";
+    if (hasEnvKeyPrefix(profile, "ANTHROPIC_"))
+        return "claude";
+    if (hasTypePrefix(profileName, "codex"))
+        return "codex";
+    if (hasTypePrefix(profileName, "claude"))
+        return "claude";
+    return null;
+}
+function stripTypePrefixFromName(name, type) {
+    if (!name)
+        return name;
+    const normalizedType = normalizeType(type);
+    if (!normalizedType)
+        return name;
+    const lowered = String(name).toLowerCase();
+    const prefixes = normalizedType === "claude" ? [normalizedType, "cc"] : [normalizedType];
+    for (const prefix of prefixes) {
+        for (const sep of ["-", "_", "."]) {
+            const candidate = `${prefix}${sep}`;
+            if (lowered.startsWith(candidate)) {
+                const stripped = String(name).slice(candidate.length);
+                return stripped || name;
+            }
+        }
+    }
+    return name;
+}
+function getProfileDisplayName(profileKey, profile, requestedType) {
+    if (profile.name)
+        return String(profile.name);
+    const rawType = profile.type ? String(profile.type) : "";
+    if (rawType)
+        return stripTypePrefixFromName(profileKey, rawType);
+    if (requestedType)
+        return stripTypePrefixFromName(profileKey, requestedType);
+    return profileKey;
+}

package/bin/shell/detect.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeShell = normalizeShell;
+exports.detectShell = detectShell;
+exports.getShellRcPath = getShellRcPath;
+/**
+ * Shell detection utilities
+ */
+const path = require("path");
+const os = require("os");
+function normalizeShell(value) {
+    if (!value)
+        return null;
+    const raw = String(value).trim().toLowerCase();
+    if (!raw)
+        return null;
+    if (raw === "bash")
+        return "bash";
+    if (raw === "zsh")
+        return "zsh";
+    if (raw === "fish")
+        return "fish";
+    return null;
+}
+function detectShell(explicitShell) {
+    if (explicitShell)
+        return normalizeShell(explicitShell);
+    const envShell = process.env.SHELL ? path.basename(process.env.SHELL) : "";
+    return normalizeShell(envShell);
+}
+function getShellRcPath(shellName) {
+    if (shellName === "bash")
+        return path.join(os.homedir(), ".bashrc");
+    if (shellName === "zsh")
+        return path.join(os.homedir(), ".zshrc");
+    if (shellName === "fish") {
+        return path.join(os.homedir(), ".config", "fish", "config.fish");
+    }
+    return null;
+}

package/bin/shell/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePath = exports.expandEnv = exports.shellEscape = exports.upsertShellSnippet = exports.escapeRegExp = exports.getShellSnippet = exports.getShellRcPath = exports.detectShell = exports.normalizeShell = void 0;
+/**
+ * Shell module exports
+ */
+var detect_1 = require("./detect");
+Object.defineProperty(exports, "normalizeShell", { enumerable: true, get: function () { return detect_1.normalizeShell; } });
+Object.defineProperty(exports, "detectShell", { enumerable: true, get: function () { return detect_1.detectShell; } });
+Object.defineProperty(exports, "getShellRcPath", { enumerable: true, get: function () { return detect_1.getShellRcPath; } });
+var snippet_1 = require("./snippet");
+Object.defineProperty(exports, "getShellSnippet", { enumerable: true, get: function () { return snippet_1.getShellSnippet; } });
+Object.defineProperty(exports, "escapeRegExp", { enumerable: true, get: function () { return snippet_1.escapeRegExp; } });
+Object.defineProperty(exports, "upsertShellSnippet", { enumerable: true, get: function () { return snippet_1.upsertShellSnippet; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "shellEscape", { enumerable: true, get: function () { return utils_1.shellEscape; } });
+Object.defineProperty(exports, "expandEnv", { enumerable: true, get: function () { return utils_1.expandEnv; } });
+Object.defineProperty(exports, "resolvePath", { enumerable: true, get: function () { return utils_1.resolvePath; } });

package/bin/shell/snippet.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getShellSnippet = getShellSnippet;
+exports.escapeRegExp = escapeRegExp;
+exports.upsertShellSnippet = upsertShellSnippet;
+/**
+ * Shell snippet generation
+ */
+const fs = require("fs");
+const path = require("path");
+function getShellSnippet(shellName) {
+    if (shellName === "fish") {
+        return [
+            "if not set -q CODE_ENV_TERMINAL_TAG",
+            "  if type -q uuidgen",
+            "    set -gx CODE_ENV_TERMINAL_TAG (uuidgen)",
+            "  else",
+            "    set -gx CODE_ENV_TERMINAL_TAG (date +%s)-$fish_pid-(random)",
+            "  end",
+            "end",
+            "function codenv",
+            "  if test (count $argv) -ge 1",
+            "    switch $argv[1]",
+            "      case use unset auto",
+            "        command codenv $argv | source",
+            "      case '*'",
+            "        command codenv $argv",
+            "    end",
+            "  else",
+            "    command codenv",
+            "  end",
+            "end",
+            "function codex",
+            "  command codenv launch codex -- $argv",
+            "end",
+            "function claude",
+            "  command codenv launch claude -- $argv",
+            "end",
+            "codenv auto",
+        ].join("\n");
+    }
+    return [
+        'if [ -z "$CODE_ENV_TERMINAL_TAG" ]; then',
+        '  if command -v uuidgen >/dev/null 2>&1; then',
+        '    CODE_ENV_TERMINAL_TAG="$(uuidgen)"',
+        "  else",
+        '    CODE_ENV_TERMINAL_TAG="$(date +%s)-$$-$RANDOM"',
+        "  fi",
+        "  export CODE_ENV_TERMINAL_TAG",
+        "fi",
+        "codenv() {",
+        '  if [ "$1" = "use" ] || [ "$1" = "unset" ] || [ "$1" = "auto" ]; then',
+        '    source <(command codenv "$@")',
+        "  else",
+        '    command codenv "$@"',
+        "  fi",
+        "}",
+        "codex() {",
+        '  command codenv launch codex -- "$@"',
+        "}",
+        "claude() {",
+        '  command codenv launch claude -- "$@"',
+        "}",
+        "codenv auto",
+    ].join("\n");
+}
+function escapeRegExp(value) {
+    return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function upsertShellSnippet(rcPath, snippet) {
+    const markerStart = "# >>> codenv >>>";
+    const markerEnd = "# <<< codenv <<<";
+    const block = `${markerStart}\n${snippet}\n${markerEnd}`;
+    const existing = fs.existsSync(rcPath) ? fs.readFileSync(rcPath, "utf8") : "";
+    let updated = "";
+    if (existing.includes(markerStart) && existing.includes(markerEnd)) {
+        const re = new RegExp(`${escapeRegExp(markerStart)}[\\s\\S]*?${escapeRegExp(markerEnd)}`);
+        updated = existing.replace(re, block);
+    }
+    else if (existing.trim().length === 0) {
+        updated = `${block}\n`;
+    }
+    else {
+        const sep = existing.endsWith("\n") ? "\n" : "\n\n";
+        updated = `${existing}${sep}${block}\n`;
+    }
+    const dir = path.dirname(rcPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(rcPath, updated, "utf8");
+}

package/bin/shell/utils.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shellEscape = shellEscape;
+exports.expandEnv = expandEnv;
+exports.resolvePath = resolvePath;
+/**
+ * Shell utility functions
+ */
+const path = require("path");
+const os = require("os");
+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 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);
+}

package/bin/statusline/claude.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureClaudeStatusline = ensureClaudeStatusline;
+/**
+ * Claude Code statusline integration
+ */
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const utils_1 = require("../shell/utils");
+const ui_1 = require("../ui");
+const DEFAULT_CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
+const DEFAULT_STATUSLINE_COMMAND = "codenv statusline --type claude --sync-usage";
+const DEFAULT_STATUSLINE_TYPE = "command";
+const DEFAULT_STATUSLINE_PADDING = 0;
+function parseBooleanEnv(value) {
+    if (value === undefined)
+        return null;
+    const normalized = String(value).trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized))
+        return true;
+    if (["0", "false", "no", "off"].includes(normalized))
+        return false;
+    return null;
+}
+function resolveClaudeSettingsPath(config) {
+    var _a;
+    const override = process.env.CODE_ENV_CLAUDE_SETTINGS_PATH;
+    if (override && String(override).trim()) {
+        const expanded = (0, utils_1.expandEnv)(String(override).trim());
+        return (0, utils_1.resolvePath)(expanded) || DEFAULT_CLAUDE_SETTINGS_PATH;
+    }
+    const configOverride = (_a = config.claudeStatusline) === null || _a === void 0 ? void 0 : _a.settingsPath;
+    if (configOverride && String(configOverride).trim()) {
+        const expanded = (0, utils_1.expandEnv)(String(configOverride).trim());
+        return (0, utils_1.resolvePath)(expanded) || DEFAULT_CLAUDE_SETTINGS_PATH;
+    }
+    return DEFAULT_CLAUDE_SETTINGS_PATH;
+}
+function readSettings(filePath) {
+    if (!fs.existsSync(filePath))
+        return {};
+    try {
+        const raw = fs.readFileSync(filePath, "utf8");
+        const trimmed = raw.trim();
+        if (!trimmed)
+            return {};
+        const parsed = JSON.parse(trimmed);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isCommandStatusLine(value) {
+    if (!isPlainObject(value))
+        return false;
+    const type = value.type;
+    const command = value.command;
+    return typeof type === "string" && typeof command === "string";
+}
+function resolveCommand(command) {
+    if (typeof command === "string") {
+        const trimmed = command.trim();
+        if (trimmed)
+            return trimmed;
+    }
+    if (Array.isArray(command)) {
+        const cleaned = command
+            .map((entry) => String(entry).trim())
+            .filter((entry) => entry);
+        if (cleaned.length > 0)
+            return cleaned.join(" ");
+    }
+    return DEFAULT_STATUSLINE_COMMAND;
+}
+function resolveDesiredStatusLineConfig(config) {
+    var _a, _b, _c;
+    const type = ((_a = config.claudeStatusline) === null || _a === void 0 ? void 0 : _a.type) || DEFAULT_STATUSLINE_TYPE;
+    const command = resolveCommand((_b = config.claudeStatusline) === null || _b === void 0 ? void 0 : _b.command);
+    const paddingRaw = (_c = config.claudeStatusline) === null || _c === void 0 ? void 0 : _c.padding;
+    const padding = typeof paddingRaw === "number" && Number.isFinite(paddingRaw)
+        ? Math.floor(paddingRaw)
+        : DEFAULT_STATUSLINE_PADDING;
+    const settingsPath = resolveClaudeSettingsPath(config);
+    return { type, command, padding, settingsPath };
+}
+function statusLineMatches(existing, desired) {
+    if (!isCommandStatusLine(existing))
+        return false;
+    if (existing.type !== desired.type)
+        return false;
+    if (existing.command !== desired.command)
+        return false;
+    const existingPadding = typeof existing.padding === "number" ? existing.padding : undefined;
+    if (existingPadding !== desired.padding)
+        return false;
+    return true;
+}
+async function ensureClaudeStatusline(config, enabled) {
+    const disabled = parseBooleanEnv(process.env.CODE_ENV_CLAUDE_STATUSLINE_DISABLE) === true;
+    if (!enabled || disabled)
+        return false;
+    const desired = resolveDesiredStatusLineConfig(config);
+    const settingsPath = desired.settingsPath;
+    const force = parseBooleanEnv(process.env.CODE_ENV_CLAUDE_STATUSLINE_FORCE) === true;
+    const settings = readSettings(settingsPath);
+    if (!settings) {
+        console.error("codenv: unable to read Claude settings; skipping statusLine update.");
+        return false;
+    }
+    const existing = settings.statusLine;
+    if (existing && statusLineMatches(existing, desired)) {
+        return false;
+    }
+    if (typeof existing !== "undefined" && !force) {
+        console.log(`codenv: existing Claude statusLine config in ${settingsPath}:`);
+        console.log(JSON.stringify(existing, null, 2));
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            console.warn("codenv: no TTY available to confirm statusLine overwrite.");
+            return false;
+        }
+        const rl = (0, ui_1.createReadline)();
+        try {
+            const confirm = await (0, ui_1.askConfirm)(rl, "Overwrite Claude statusLine config? (y/N): ");
+            if (!confirm)
+                return false;
+        }
+        finally {
+            rl.close();
+        }
+    }
+    settings.statusLine = {
+        type: desired.type,
+        command: desired.command,
+        padding: desired.padding,
+    };
+    try {
+        fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+        fs.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+        return true;
+    }
+    catch {
+        console.error("codenv: failed to write Claude settings; statusLine not updated.");
+        return false;
+    }
+}