@minniexcode/codex-switch 0.0.4 → 0.0.5

package/dist/domain/config.js

@@ -33,74 +33,506 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_LINE_ENDING = void 0;
 exports.parseTopLevelProfile = parseTopLevelProfile;
 exports.parseProfileNames = parseProfileNames;
 exports.replaceTopLevelProfile = replaceTopLevelProfile;
+exports.parseStructuredConfig = parseStructuredConfig;
+exports.buildManagedProfileViews = buildManagedProfileViews;
+exports.collectConfigConsistencyIssues = collectConfigConsistencyIssues;
+exports.validateManagedProfileCreation = validateManagedProfileCreation;
+exports.planProfileLifecycleOutcome = planProfileLifecycleOutcome;
+exports.planConfigMutation = planConfigMutation;
+exports.applyPatchOperations = applyPatchOperations;
 const os = __importStar(require("node:os"));
+const errors_1 = require("./errors");
 /**
  * Reads the active top-level profile from config.toml content.
  */
 function parseTopLevelProfile(configContent) {
+    return parseStructuredConfig(configContent).activeProfile;
+}
+/**
+ * Collects all named profile sections declared in config.toml content.
+ */
+function parseProfileNames(configContent) {
+    return new Set(parseStructuredConfig(configContent).profiles.map((profile) => profile.name));
+}
+/**
+ * Replaces or inserts the top-level profile assignment while preserving the rest of the file.
+ */
+function replaceTopLevelProfile(configContent, profile) {
+    const plan = planConfigMutation(parseStructuredConfig(configContent), { setActiveProfile: profile });
+    return applyPatchOperations(configContent, plan.operations);
+}
+/**
+ * Parses the supported config.toml subset into a structured document with stable text ranges.
+ */
+function parseStructuredConfig(configContent) {
+    const lineEnding = configContent.includes("\r\n") ? "\r\n" : "\n";
+    const lines = splitWithOffsets(configContent);
+    let activeProfile = null;
+    let activeProfileRange = null;
+    const profiles = [];
+    let currentProfile = null;
     let inRoot = true;
-    for (const line of configContent.split(/\r?\n/)) {
-        const trimmed = line.trim();
-        if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    for (const line of lines) {
+        const trimmed = line.content.trim();
+        const headerMatch = trimmed.match(/^\[profiles\.([^\]]+)\]$/);
+        if (headerMatch) {
+            if (currentProfile) {
+                currentProfile.sectionEnd = line.start;
+            }
+            currentProfile = {
+                name: headerMatch[1],
+                headerStart: line.start,
+                sectionStart: line.start,
+                sectionEnd: configContent.length,
+                managedFieldInsertIndex: configContent.length,
+                modelValueRange: null,
+                baseUrlValueRange: null,
+                model: null,
+                baseUrl: null,
+            };
+            profiles.push(currentProfile);
             inRoot = false;
             continue;
         }
-        if (!inRoot || trimmed === "" || trimmed.startsWith("#")) {
+        if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+            if (currentProfile) {
+                currentProfile.sectionEnd = line.start;
+                currentProfile = null;
+            }
+            inRoot = false;
             continue;
         }
-        const match = trimmed.match(/^profile\s*=\s*["']([^"']+)["']/);
-        if (match) {
-            return match[1];
+        if (inRoot) {
+            const profileMatch = matchKeyValueLine(line.content, "profile");
+            if (profileMatch && !activeProfile) {
+                activeProfile = profileMatch.value;
+                activeProfileRange = {
+                    start: line.start + profileMatch.valueStart,
+                    end: line.start + profileMatch.valueEnd,
+                };
+            }
+        }
+        if (currentProfile) {
+            const modelMatch = matchKeyValueLine(line.content, "model");
+            if (modelMatch) {
+                currentProfile.model = modelMatch.value;
+                currentProfile.modelValueRange = {
+                    start: line.start + modelMatch.valueStart,
+                    end: line.start + modelMatch.valueEnd,
+                };
+            }
+            const baseUrlMatch = matchKeyValueLine(line.content, "base_url");
+            if (baseUrlMatch) {
+                currentProfile.baseUrl = baseUrlMatch.value;
+                currentProfile.baseUrlValueRange = {
+                    start: line.start + baseUrlMatch.valueStart,
+                    end: line.start + baseUrlMatch.valueEnd,
+                };
+            }
         }
     }
-    return null;
+    return {
+        rawText: configContent,
+        lineEnding,
+        activeProfile,
+        activeProfileRange,
+        profiles: profiles.map((profile) => ({
+            ...profile,
+            managedFieldInsertIndex: findManagedFieldInsertIndex(configContent, profile.sectionStart, profile.sectionEnd),
+        })),
+    };
 }
 /**
- * Collects all named profile sections declared in config.toml content.
+ * Builds the managed/unmanaged/orphaned profile views used by config commands and diagnostics.
  */
-function parseProfileNames(configContent) {
-    const result = new Set();
-    for (const line of configContent.split(/\r?\n/)) {
-        const trimmed = line.trim();
-        const match = trimmed.match(/^\[profiles\.([^\]]+)\]$/);
-        if (match) {
-            result.add(match[1]);
+function buildManagedProfileViews(document, providers) {
+    const linkMap = buildProfileLinkMap(providers);
+    const views = [];
+    const seen = new Set();
+    for (const section of document.profiles) {
+        const linkInfo = linkMap.get(section.name) ?? { linkedProviders: [], managed: false };
+        seen.add(section.name);
+        views.push({
+            name: section.name,
+            managed: linkInfo.managed,
+            isActive: document.activeProfile === section.name,
+            linkedProviders: [...linkInfo.linkedProviders].sort(),
+            model: section.model,
+            baseUrl: section.baseUrl,
+            managedFields: collectManagedFields(section.model, section.baseUrl),
+            source: linkInfo.managed ? "managed" : "unmanaged",
+        });
+    }
+    for (const [profile, linkInfo] of [...linkMap.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+        if (seen.has(profile)) {
+            continue;
         }
+        views.push({
+            name: profile,
+            managed: true,
+            isActive: document.activeProfile === profile,
+            linkedProviders: [...linkInfo.linkedProviders].sort(),
+            model: null,
+            baseUrl: null,
+            managedFields: [],
+            source: "orphaned-reference",
+        });
     }
-    return result;
+    return views.sort((left, right) => left.name.localeCompare(right.name));
 }
 /**
- * Replaces or inserts the top-level profile assignment while preserving the rest of the file.
+ * Collects structured config consistency issues for doctor and status.
  */
-function replaceTopLevelProfile(configContent, profile) {
-    const lines = configContent.split(/\r?\n/);
-    let inRoot = true;
-    let replaced = false;
-    const nextLines = lines.map((line) => {
-        const trimmed = line.trim();
-        if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
-            // Only the root section may contain the active `profile = ...` switch.
-            inRoot = false;
-            return line;
+function collectConfigConsistencyIssues(document, providers) {
+    const issues = [];
+    for (const view of buildManagedProfileViews(document, providers)) {
+        if (view.source === "orphaned-reference") {
+            issues.push({
+                code: "ORPHANED_PROFILE_REFERENCE",
+                profile: view.name,
+                providers: [...view.linkedProviders],
+            });
+        }
+        if (view.source === "unmanaged" && view.linkedProviders.length === 0) {
+            issues.push({
+                code: "ORPHANED_PROFILE_SECTION",
+                profile: view.name,
+            });
         }
-        if (!replaced && inRoot && /^profile\s*=/.test(trimmed)) {
-            replaced = true;
-            return `profile = "${profile}"`;
+        if (view.linkedProviders.length > 1) {
+            issues.push({
+                code: "SHARED_PROFILE_REFERENCE",
+                profile: view.name,
+                providers: [...view.linkedProviders],
+            });
+        }
+    }
+    if (document.activeProfile) {
+        const activeLinkInfo = buildProfileLinkMap(providers).get(document.activeProfile);
+        if (!activeLinkInfo) {
+            issues.push({
+                code: "UNMANAGED_ACTIVE_PROFILE",
+                profile: document.activeProfile,
+            });
         }
-        return line;
+    }
+    return issues.sort((left, right) => {
+        if (left.profile === right.profile) {
+            return left.code.localeCompare(right.code);
+        }
+        return left.profile.localeCompare(right.profile);
     });
-    if (!replaced) {
-        // When no root-level profile exists yet, insert it before the first section header.
-        const insertAt = nextLines.findIndex((line) => line.trim().startsWith("["));
-        if (insertAt === -1) {
-            nextLines.push(`profile = "${profile}"`);
+}
+/**
+ * Ensures the minimal managed profile fields are available before a new section is created.
+ */
+function validateManagedProfileCreation(profile, fields) {
+    const model = fields.model?.trim() ?? "";
+    const baseUrl = fields.baseUrl?.trim() ?? "";
+    if (!model || !baseUrl) {
+        throw (0, errors_1.cliError)("MANAGED_PROFILE_FIELDS_MISSING", `Managed profile "${profile}" requires both model and base_url.`, {
+            profile,
+            missingFields: [
+                !model ? "model" : null,
+                !baseUrl ? "base_url" : null,
+            ].filter((value) => Boolean(value)),
+        });
+    }
+    return {
+        model,
+        baseUrl,
+    };
+}
+/**
+ * Computes keep/delete/switch outcomes when a provider leaves or changes profiles.
+ */
+function planProfileLifecycleOutcome(args) {
+    if (!args.oldProfile || args.oldProfile === args.newProfile) {
+        return {
+            deletedProfileSections: [],
+            keptSharedProfiles: [],
+            switchedActiveProfile: false,
+            nextActiveProfile: args.activeProfile,
+        };
+    }
+    const remainingLinks = args.remainingLinksByProfile.get(args.oldProfile) ?? [];
+    if (remainingLinks.length > 0) {
+        return {
+            deletedProfileSections: [],
+            keptSharedProfiles: [args.oldProfile],
+            switchedActiveProfile: false,
+            nextActiveProfile: args.activeProfile,
+        };
+    }
+    if (args.activeProfile === args.oldProfile) {
+        if (!args.switchToProfile) {
+            throw (0, errors_1.cliError)("PROFILE_IN_USE", `Profile "${args.oldProfile}" is still the active profile. Switch first before removing the last linked provider.`, {
+                profile: args.oldProfile,
+                provider: args.providerName,
+                activeProfile: args.activeProfile,
+                linkedProviders: [],
+            });
+        }
+        return {
+            deletedProfileSections: [args.oldProfile],
+            keptSharedProfiles: [],
+            switchedActiveProfile: true,
+            nextActiveProfile: args.switchToProfile,
+        };
+    }
+    return {
+        deletedProfileSections: [args.oldProfile],
+        keptSharedProfiles: [],
+        switchedActiveProfile: false,
+        nextActiveProfile: args.activeProfile,
+    };
+}
+/**
+ * Builds a text patch plan for top-level profile changes and profile section lifecycle changes.
+ */
+function planConfigMutation(document, args) {
+    const operations = [];
+    const createdProfileSections = [];
+    const deletedProfileSections = [];
+    const updatedProfiles = [];
+    const sectionMap = new Map(document.profiles.map((profile) => [profile.name, profile]));
+    if (args.setActiveProfile && args.setActiveProfile !== document.activeProfile) {
+        const quoted = `"${args.setActiveProfile}"`;
+        if (document.activeProfileRange) {
+            operations.push({
+                kind: "replace-range",
+                start: document.activeProfileRange.start,
+                end: document.activeProfileRange.end,
+                text: quoted,
+            });
         }
         else {
-            nextLines.splice(insertAt, 0, `profile = "${profile}"`);
+            const insertAt = findTopLevelInsertIndex(document.rawText);
+            const text = `profile = ${quoted}${document.lineEnding}`;
+            operations.push({
+                kind: "insert-at",
+                index: insertAt,
+                text,
+            });
         }
     }
-    return nextLines.join(os.EOL);
+    for (const profileName of args.deleteProfiles ?? []) {
+        const section = sectionMap.get(profileName);
+        if (!section) {
+            continue;
+        }
+        operations.push({
+            kind: "delete-range",
+            start: section.sectionStart,
+            end: expandDeletionEnd(document.rawText, section.sectionStart, section.sectionEnd),
+        });
+        deletedProfileSections.push(profileName);
+    }
+    for (const [profileName, fields] of Object.entries(args.upsertProfiles ?? {}).sort(([left], [right]) => left.localeCompare(right))) {
+        const section = sectionMap.get(profileName);
+        if (!section) {
+            const requiredFields = validateManagedProfileCreation(profileName, fields);
+            const prefix = document.rawText.length > 0 && !document.rawText.endsWith(document.lineEnding)
+                ? document.lineEnding
+                : "";
+            operations.push({
+                kind: "insert-at",
+                index: document.rawText.length,
+                text: `${prefix}[profiles.${profileName}]${document.lineEnding}` +
+                    `model = ${JSON.stringify(requiredFields.model)}${document.lineEnding}` +
+                    `base_url = ${JSON.stringify(requiredFields.baseUrl)}${document.lineEnding}`,
+            });
+            createdProfileSections.push(profileName);
+            continue;
+        }
+        const sectionUpdated = planSectionFieldMutation(document, section, fields, operations);
+        if (sectionUpdated) {
+            updatedProfiles.push(profileName);
+        }
+    }
+    return {
+        operations,
+        createdProfileSections,
+        deletedProfileSections,
+        updatedProfiles,
+        switchedActiveProfile: Boolean(args.setActiveProfile && args.setActiveProfile !== document.activeProfile),
+    };
+}
+/**
+ * Applies a patch plan to raw config text. Callers should sort by reverse offsets only once here.
+ */
+function applyPatchOperations(rawText, operations) {
+    const sorted = [...operations].sort((left, right) => getOperationStart(right) - getOperationStart(left));
+    let nextText = rawText;
+    for (const operation of sorted) {
+        if (operation.kind === "replace-range") {
+            nextText = `${nextText.slice(0, operation.start)}${operation.text}${nextText.slice(operation.end)}`;
+            continue;
+        }
+        if (operation.kind === "delete-range") {
+            nextText = `${nextText.slice(0, operation.start)}${nextText.slice(operation.end)}`;
+            continue;
+        }
+        nextText = `${nextText.slice(0, operation.index)}${operation.text}${nextText.slice(operation.index)}`;
+    }
+    return nextText;
+}
+function planSectionFieldMutation(document, section, fields, operations) {
+    let updated = false;
+    const modelText = fields.model !== undefined ? JSON.stringify(fields.model) : null;
+    const baseUrlText = fields.baseUrl !== undefined ? JSON.stringify(fields.baseUrl) : null;
+    const inserts = [];
+    if (modelText !== null && section.modelValueRange) {
+        if (section.model !== fields.model) {
+            operations.push({
+                kind: "replace-range",
+                start: section.modelValueRange.start,
+                end: section.modelValueRange.end,
+                text: modelText,
+            });
+            updated = true;
+        }
+    }
+    else if (modelText !== null && !section.modelValueRange) {
+        inserts.push(`model = ${modelText}${document.lineEnding}`);
+        updated = true;
+    }
+    if (baseUrlText !== null && section.baseUrlValueRange) {
+        if (section.baseUrl !== fields.baseUrl) {
+            operations.push({
+                kind: "replace-range",
+                start: section.baseUrlValueRange.start,
+                end: section.baseUrlValueRange.end,
+                text: baseUrlText,
+            });
+            updated = true;
+        }
+    }
+    else if (baseUrlText !== null && !section.baseUrlValueRange) {
+        inserts.push(`base_url = ${baseUrlText}${document.lineEnding}`);
+        updated = true;
+    }
+    if (inserts.length > 0) {
+        operations.push({
+            kind: "insert-at",
+            index: section.managedFieldInsertIndex,
+            text: inserts.join(""),
+        });
+    }
+    return updated;
+}
+function splitWithOffsets(value) {
+    if (value.length === 0) {
+        return [];
+    }
+    const result = [];
+    let index = 0;
+    while (index < value.length) {
+        let nextBreak = value.indexOf("\n", index);
+        if (nextBreak === -1) {
+            nextBreak = value.length;
+        }
+        else {
+            nextBreak += 1;
+        }
+        result.push({
+            content: value.slice(index, nextBreak).replace(/\r?\n$/, ""),
+            start: index,
+            end: nextBreak,
+        });
+        index = nextBreak;
+    }
+    return result;
+}
+function matchKeyValueLine(line, key) {
+    const match = line.match(new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*(["'])(.*?)\\1\\s*(#.*)?$`));
+    if (!match || match.index === undefined) {
+        return null;
+    }
+    const value = match[2];
+    const openingQuoteIndex = line.indexOf(match[1], match.index);
+    if (openingQuoteIndex === -1) {
+        return null;
+    }
+    const valueStart = openingQuoteIndex;
+    const valueEnd = openingQuoteIndex + match[1].length + value.length + match[1].length;
+    return {
+        value,
+        valueStart,
+        valueEnd,
+    };
+}
+function findManagedFieldInsertIndex(rawText, sectionStart, sectionEnd) {
+    const sectionText = rawText.slice(sectionStart, sectionEnd);
+    const lines = splitWithOffsets(sectionText);
+    let lastMeaningfulIndex = lines.length - 1;
+    while (lastMeaningfulIndex >= 0) {
+        const trimmed = lines[lastMeaningfulIndex].content.trim();
+        if (trimmed === "" || trimmed.startsWith("#")) {
+            lastMeaningfulIndex -= 1;
+            continue;
+        }
+        break;
+    }
+    if (lastMeaningfulIndex < 0) {
+        return sectionEnd;
+    }
+    return sectionStart + lines[lastMeaningfulIndex].end;
+}
+function collectManagedFields(model, baseUrl) {
+    const fields = [];
+    if (model !== null) {
+        fields.push("model");
+    }
+    if (baseUrl !== null) {
+        fields.push("base_url");
+    }
+    return fields;
+}
+function buildProfileLinkMap(providers) {
+    const map = new Map();
+    for (const [providerName, provider] of Object.entries(providers?.providers ?? {})) {
+        const current = map.get(provider.profile) ?? { linkedProviders: [], managed: true };
+        current.linkedProviders.push(providerName);
+        current.managed = true;
+        map.set(provider.profile, current);
+    }
+    for (const value of map.values()) {
+        value.linkedProviders.sort();
+    }
+    return map;
+}
+function getOperationStart(operation) {
+    if (operation.kind === "insert-at") {
+        return operation.index;
+    }
+    return operation.start;
+}
+function findTopLevelInsertIndex(rawText) {
+    const sectionMatch = rawText.match(/^\s*\[/m);
+    return sectionMatch && sectionMatch.index !== undefined ? sectionMatch.index : rawText.length;
+}
+function expandDeletionEnd(rawText, sectionStart, sectionEnd) {
+    let end = sectionEnd;
+    while (end < rawText.length && (rawText[end] === "\r" || rawText[end] === "\n")) {
+        end += 1;
+    }
+    if (sectionStart > 0) {
+        let cursor = sectionStart - 1;
+        while (cursor >= 0 && (rawText[cursor] === "\r" || rawText[cursor] === "\n")) {
+            cursor -= 1;
+        }
+        if (cursor < sectionStart - 1) {
+            return end;
+        }
+    }
+    return end;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+exports.DEFAULT_LINE_ENDING = os.EOL === "\r\n" ? "\r\n" : "\n";

package/dist/infra/codex-cli.js

@@ -9,6 +9,18 @@ exports.checkCodexVersion = checkCodexVersion;
 const node_child_process_1 = require("node:child_process");
 const errors_1 = require("../domain/errors");
 let spawnImplementation = node_child_process_1.spawnSync;
+function getCodexInvocation(args) {
+    if (process.platform === "win32") {
+        return {
+            command: process.env.ComSpec || "cmd.exe",
+            args: ["/d", "/s", "/c", ["codex", ...args].join(" ")],
+        };
+    }
+    return {
+        command: "codex",
+        args,
+    };
+}
 /**
  * Overrides the spawn implementation for tests.
  */
@@ -25,7 +37,8 @@ function resetCodexSpawnImplementation() {
  * Runs `codex login --with-api-key` in the target Codex directory.
  */
 function runCodexLogin(apiKey, workingDir) {
-    const result = spawnImplementation("codex", ["login", "--with-api-key"], {
+    const invocation = getCodexInvocation(["login", "--with-api-key"]);
+    const result = spawnImplementation(invocation.command, invocation.args, {
         cwd: workingDir,
         input: `${apiKey}\n`,
         stdio: "pipe",
@@ -41,7 +54,8 @@ function runCodexLogin(apiKey, workingDir) {
  * Checks whether the Codex CLI is available on PATH.
  */
 function checkCodexAvailable() {
-    const result = spawnImplementation("codex", ["--version"], {
+    const invocation = getCodexInvocation(["--version"]);
+    const result = spawnImplementation(invocation.command, invocation.args, {
         stdio: "pipe",
         encoding: "utf8",
     });
@@ -57,7 +71,8 @@ function checkCodexAvailable() {
  * Reads the installed codex CLI version string.
  */
 function readCodexVersion() {
-    const result = spawnImplementation("codex", ["--version"], {
+    const invocation = getCodexInvocation(["--version"]);
+    const result = spawnImplementation(invocation.command, invocation.args, {
         stdio: "pipe",
         encoding: "utf8",
     });

package/dist/infra/codex-discovery.js

@@ -1,48 +1,10 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findCodexDirCandidates = findCodexDirCandidates;
-const fs = __importStar(require("node:fs"));
-const codex_paths_1 = require("./codex-paths");
+const config_repo_1 = require("./config-repo");
 /**
- * Finds candidate Codex home directories. v0.0.4 only supports explicit and default locations.
+ * Finds candidate Codex home directories using the shared config-aware discovery rules.
  */
 function findCodexDirCandidates(explicitCodexDir) {
-    if (explicitCodexDir) {
-        return [(0, codex_paths_1.resolveCodexDir)(explicitCodexDir)];
-    }
-    const defaultDir = (0, codex_paths_1.resolveCodexDir)();
-    return fs.existsSync(defaultDir) ? [defaultDir] : [];
+    return (0, config_repo_1.findCodexDirCandidates)(explicitCodexDir);
 }

package/dist/infra/codex-paths.js

@@ -39,7 +39,7 @@ exports.createCodexPaths = createCodexPaths;
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 exports.CODEX_DIR_ENV_NAME = "CODEXS_CODEX_DIR";
-const DEVELOPMENT_DEFAULT_CODEX_DIR = path.resolve(process.cwd(), "test-fixtures", "sample-codex");
+const DEVELOPMENT_DEFAULT_CODEX_DIR = path.resolve(process.cwd(), "dev-codex", "local-sandbox");
 /**
  * Resolves the working Codex directory, defaulting to `~/.codex`.
  */