@praeviso/code-env-switch 0.1.7 → 0.1.9

package/src/statusline/codex.ts

@@ -1,5 +1,5 @@
 /**
- * Codex CLI status line integration
+ * Codex CLI status line integration (official schema)
  */
 import * as fs from "fs";
 import * as os from "os";
@@ -9,37 +9,27 @@ import { expandEnv, resolvePath } from "../shell/utils";
 import { askConfirm, createReadline } from "../ui";
 
 const DEFAULT_CODEX_CONFIG_PATH = path.join(os.homedir(), ".codex", "config.toml");
-const DEFAULT_STATUSLINE_COMMAND = [
-    "codenv",
-    "statusline",
-    "--type",
-    "codex",
-    "--sync-usage",
-];
-const DEFAULT_SHOW_HINTS = false;
-const DEFAULT_UPDATE_INTERVAL_MS = 300;
-const DEFAULT_TIMEOUT_MS = 1000;
-
-interface ParsedStatusLineConfig {
-    command: string | string[] | null;
-    showHints: boolean | null;
-    updateIntervalMs: number | null;
-    timeoutMs: number | null;
+
+interface ParsedTuiConfig {
+    statusLineItems: string[] | null;
 }
 
 interface DesiredStatusLineConfig {
-    command: string | string[];
-    showHints: boolean;
-    updateIntervalMs: number;
-    timeoutMs: number;
+    statusLineItems: string[];
     configPath: string;
 }
 
-interface StatusLineSection {
+interface TuiSection {
+    start: number;
+    end: number;
+    sectionText: string;
+    config: ParsedTuiConfig;
+}
+
+interface TomlSectionRange {
     start: number;
     end: number;
     sectionText: string;
-    config: ParsedStatusLineConfig;
 }
 
 function parseBooleanEnv(value: string | undefined): boolean | null {
@@ -64,6 +54,25 @@ function resolveCodexConfigPath(config: Config): string {
     return DEFAULT_CODEX_CONFIG_PATH;
 }
 
+function resolveDesiredStatusLineItems(config: Config): string[] | null {
+    const raw = config.codexStatusline?.items;
+    if (!Array.isArray(raw)) return null;
+    return raw
+        .map((entry) => String(entry).trim())
+        .filter((entry) => entry);
+}
+
+function resolveDesiredStatusLineConfig(
+    config: Config
+): DesiredStatusLineConfig | null {
+    const statusLineItems = resolveDesiredStatusLineItems(config);
+    if (statusLineItems === null) return null;
+    return {
+        statusLineItems,
+        configPath: resolveCodexConfigPath(config),
+    };
+}
+
 function readConfig(filePath: string): string {
     if (!fs.existsSync(filePath)) return "";
     try {
@@ -93,90 +102,84 @@ function stripInlineComment(value: string): string {
     return value.trim();
 }
 
-function unquote(value: string): string {
-    const trimmed = value.trim();
-    if (
-        (trimmed.startsWith("\"") && trimmed.endsWith("\"")) ||
-        (trimmed.startsWith("'") && trimmed.endsWith("'"))
-    ) {
-        return trimmed.slice(1, -1);
-    }
-    return trimmed;
-}
-
-function parseCommandValue(raw: string): string | string[] | null {
-    const trimmed = raw.trim();
-    if (!trimmed) return null;
-    if (trimmed.startsWith("[")) {
-        const items: string[] = [];
-        const regex = /"((?:\\.|[^"\\])*)"/g;
-        let match: RegExpExecArray | null = null;
-        while ((match = regex.exec(trimmed))) {
-            const item = match[1].replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
-            items.push(item);
-        }
-        return items.length > 0 ? items : null;
-    }
-    return unquote(trimmed);
-}
-
-function tokenizeCommand(command: string): string[] {
-    const tokens: string[] = [];
-    let current = "";
+function hasUnquotedClosingBracket(value: string): boolean {
     let inSingle = false;
     let inDouble = false;
-    let escape = false;
-    for (let i = 0; i < command.length; i++) {
-        const ch = command[i];
-        if (escape) {
-            current += ch;
-            escape = false;
-            continue;
-        }
-        if (ch === "\\" && !inSingle) {
-            escape = true;
+    for (let i = 0; i < value.length; i++) {
+        const ch = value[i];
+        if (ch === "\"" && !inSingle && value[i - 1] !== "\\") {
+            inDouble = !inDouble;
             continue;
         }
-        if (ch === "'" && !inDouble) {
+        if (ch === "'" && !inDouble && value[i - 1] !== "\\") {
             inSingle = !inSingle;
             continue;
         }
-        if (ch === "\"" && !inSingle) {
-            inDouble = !inDouble;
-            continue;
+        if (!inSingle && !inDouble && ch === "]") {
+            return true;
         }
-        if (!inSingle && !inDouble && /\s/.test(ch)) {
-            if (current) {
-                tokens.push(current);
-                current = "";
-            }
+    }
+    return false;
+}
+
+function parseTomlStringArray(raw: string): string[] | null {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith("[") || !hasUnquotedClosingBracket(trimmed)) {
+        return null;
+    }
+    if (/^\[\s*\]$/.test(trimmed)) return [];
+
+    const items: string[] = [];
+    const regex = /"((?:\\.|[^"\\])*)"|'([^']*)'/g;
+    let match: RegExpExecArray | null = null;
+    while ((match = regex.exec(trimmed))) {
+        if (match[0].startsWith("\"")) {
+            items.push(match[1].replace(/\\"/g, "\"").replace(/\\\\/g, "\\"));
             continue;
         }
-        current += ch;
+        items.push(match[2] || "");
     }
-    if (current) tokens.push(current);
-    return tokens;
-}
 
-function parseBooleanValue(raw: string): boolean | null {
-    const normalized = raw.trim().toLowerCase();
-    if (normalized === "true") return true;
-    if (normalized === "false") return false;
-    return null;
+    if (items.length === 0) return null;
+    return items;
 }
 
-function parseNumberValue(raw: string): number | null {
-    const trimmed = raw.trim();
-    if (!trimmed) return null;
-    const parsed = Number(trimmed);
-    if (!Number.isFinite(parsed)) return null;
-    return Math.floor(parsed);
+function parseStatusLineItems(sectionText: string): string[] | null {
+    const lines = sectionText.split(/\r?\n/).slice(1);
+
+    for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith(";")) continue;
+
+        const matchLine = /^status_line\s*=\s*(.*)$/.exec(trimmed);
+        if (!matchLine) continue;
+
+        const value = stripInlineComment(matchLine[1]);
+        if (!value.startsWith("[")) return null;
+
+        const parts = [value];
+        if (!hasUnquotedClosingBracket(value)) {
+            for (let j = i + 1; j < lines.length; j++) {
+                const next = stripInlineComment(lines[j]);
+                if (!next) continue;
+                parts.push(next);
+                if (hasUnquotedClosingBracket(next)) break;
+            }
+        }
+
+        return parseTomlStringArray(parts.join(" "));
+    }
+
+    return null;
 }
 
-function parseStatusLineSection(text: string): StatusLineSection | null {
-    const headerRegex = /^\s*\[tui\.status_line\]\s*$/m;
+function parseSectionByHeader(
+    text: string,
+    headerRegex: RegExp
+): TomlSectionRange | null {
     const match = headerRegex.exec(text);
     if (!match || match.index === undefined) return null;
+
     const start = match.index;
     const afterHeader = start + match[0].length;
     const rest = text.slice(afterHeader);
@@ -184,140 +187,110 @@ function parseStatusLineSection(text: string): StatusLineSection | null {
     const end = nextHeaderMatch
         ? afterHeader + (nextHeaderMatch.index ?? rest.length)
         : text.length;
-    const sectionText = text.slice(start, end).trimEnd();
-    const lines = sectionText.split(/\r?\n/).slice(1);
-
-    const config: ParsedStatusLineConfig = {
-        command: null,
-        showHints: null,
-        updateIntervalMs: null,
-        timeoutMs: null,
+    return {
+        start,
+        end,
+        sectionText: text.slice(start, end).trimEnd(),
     };
+}
 
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed) continue;
-        if (trimmed.startsWith("#") || trimmed.startsWith(";")) continue;
-        const matchLine = /^([A-Za-z0-9_]+)\s*=\s*(.+)$/.exec(trimmed);
-        if (!matchLine) continue;
-        const key = matchLine[1];
-        const rawValue = stripInlineComment(matchLine[2]);
-        if (key === "command") {
-            config.command = parseCommandValue(rawValue);
-        } else if (key === "show_hints") {
-            config.showHints = parseBooleanValue(rawValue);
-        } else if (key === "update_interval_ms") {
-            config.updateIntervalMs = parseNumberValue(rawValue);
-        } else if (key === "timeout_ms") {
-            config.timeoutMs = parseNumberValue(rawValue);
-        }
-    }
+function parseTuiSection(text: string): TuiSection | null {
+    const section = parseSectionByHeader(text, /^\s*\[tui\]\s*$/m);
+    if (!section) return null;
 
     return {
-        start,
-        end,
-        sectionText,
-        config,
+        start: section.start,
+        end: section.end,
+        sectionText: section.sectionText,
+        config: {
+            statusLineItems: parseStatusLineItems(section.sectionText),
+        },
     };
 }
 
-function commandToArray(value: string | string[] | null): string[] | null {
-    if (!value) return null;
-    if (Array.isArray(value)) {
-        return value.map((entry) => String(entry));
-    }
-    const trimmed = value.trim();
-    if (!trimmed) return null;
-    return tokenizeCommand(trimmed);
+function parseLegacyStatusLineSection(text: string): TomlSectionRange | null {
+    return parseSectionByHeader(text, /^\s*\[tui\.status_line\]\s*$/m);
 }
 
-function commandMatches(
-    existing: string | string[] | null,
-    desired: string | string[]
+function statusLineItemsMatch(
+    existing: string[] | null,
+    desired: string[]
 ): boolean {
     if (!existing) return false;
-    const existingTokens = commandToArray(existing);
-    const desiredTokens = commandToArray(desired);
-    if (existingTokens && desiredTokens) {
-        if (existingTokens.length !== desiredTokens.length) return false;
-        for (let i = 0; i < desiredTokens.length; i++) {
-            if (existingTokens[i] !== desiredTokens[i]) return false;
-        }
-        return true;
-    }
-    if (typeof existing === "string" && typeof desired === "string") {
-        return existing.trim() === desired.trim();
+    if (existing.length !== desired.length) return false;
+    for (let i = 0; i < desired.length; i++) {
+        if (existing[i] !== desired[i]) return false;
     }
-    return false;
+    return true;
 }
 
 function configMatches(
-    config: ParsedStatusLineConfig,
+    config: ParsedTuiConfig,
     desired: DesiredStatusLineConfig
 ): boolean {
-    if (!commandMatches(config.command, desired.command)) return false;
-    if (config.showHints !== desired.showHints) return false;
-    if (config.updateIntervalMs !== desired.updateIntervalMs) return false;
-    if (config.timeoutMs !== desired.timeoutMs) return false;
-    return true;
+    return statusLineItemsMatch(config.statusLineItems, desired.statusLineItems);
 }
 
-function resolveDesiredCommand(
-    config: Config
-): string | string[] {
-    const raw = config.codexStatusline?.command;
-    if (typeof raw === "string") {
-        const trimmed = raw.trim();
-        if (trimmed) return trimmed;
-    } else if (Array.isArray(raw)) {
-        const cleaned = raw
-            .map((entry) => String(entry).trim())
-            .filter((entry) => entry);
-        if (cleaned.length > 0) return cleaned;
-    }
-    return DEFAULT_STATUSLINE_COMMAND;
+function formatStatusLineItems(items: string[]): string {
+    const parts = items.map((item) => JSON.stringify(item)).join(", ");
+    return `[${parts}]`;
 }
 
-function resolveDesiredStatusLineConfig(config: Config): DesiredStatusLineConfig {
-    const showHints =
-        config.codexStatusline?.showHints ?? DEFAULT_SHOW_HINTS;
-    const updateIntervalMs =
-        config.codexStatusline?.updateIntervalMs ?? DEFAULT_UPDATE_INTERVAL_MS;
-    const timeoutMs =
-        config.codexStatusline?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    const command = resolveDesiredCommand(config);
-    const configPath = resolveCodexConfigPath(config);
-    return {
-        command,
-        showHints,
-        updateIntervalMs,
-        timeoutMs,
-        configPath,
-    };
-}
+function removeStatusLineSettingLines(lines: string[]): string[] {
+    const kept: string[] = [];
+    let inMultilineArray = false;
+
+    for (const line of lines) {
+        const trimmed = line.trim();
+
+        if (inMultilineArray) {
+            const value = stripInlineComment(trimmed);
+            if (hasUnquotedClosingBracket(value)) {
+                inMultilineArray = false;
+            }
+            continue;
+        }
+
+        const matchLine = /^status_line\s*=\s*(.*)$/.exec(trimmed);
+        if (!matchLine) {
+            kept.push(line);
+            continue;
+        }
 
-function formatCommandValue(command: string | string[]): string {
-    if (Array.isArray(command)) {
-        const parts = command.map((part) => JSON.stringify(part)).join(", ");
-        return `[${parts}]`;
+        const value = stripInlineComment(matchLine[1]);
+        if (value.startsWith("[") && !hasUnquotedClosingBracket(value)) {
+            inMultilineArray = true;
+        }
     }
-    return JSON.stringify(command);
+
+    return kept;
 }
 
-function buildStatusLineSection(desired: DesiredStatusLineConfig): string {
-    const commandText = formatCommandValue(desired.command);
-    return (
-        `[tui.status_line]\n` +
-        `command = ${commandText}\n` +
-        `show_hints = ${desired.showHints ? "true" : "false"}\n` +
-        `update_interval_ms = ${desired.updateIntervalMs}\n` +
-        `timeout_ms = ${desired.timeoutMs}\n`
-    );
+function buildTuiSection(
+    section: TuiSection | null,
+    desired: DesiredStatusLineConfig
+): string {
+    const statusLine = `status_line = ${formatStatusLineItems(desired.statusLineItems)}`;
+
+    if (!section) {
+        return `[tui]\n${statusLine}\n`;
+    }
+
+    const lines = section.sectionText.split(/\r?\n/);
+    const header = lines[0].trim() === "[tui]" ? lines[0] : "[tui]";
+    const body = removeStatusLineSettingLines(lines.slice(1));
+
+    while (body.length > 0 && body[body.length - 1].trim() === "") {
+        body.pop();
+    }
+
+    body.push(statusLine);
+    return `${header}\n${body.join("\n")}\n`;
 }
 
 function upsertSection(
     text: string,
-    section: StatusLineSection | null,
+    section: TuiSection | null,
     newSection: string
 ): string {
     if (!section) {
@@ -326,6 +299,7 @@ function upsertSection(
         if (base && !base.endsWith("\n\n")) base += "\n";
         return `${base}${newSection}`;
     }
+
     let prefix = text.slice(0, section.start);
     let suffix = text.slice(section.end);
     if (prefix && !prefix.endsWith("\n")) prefix += "\n";
@@ -333,6 +307,17 @@ function upsertSection(
     return `${prefix}${newSection}${suffix}`;
 }
 
+function removeSection(
+    text: string,
+    section: TomlSectionRange
+): string {
+    let prefix = text.slice(0, section.start);
+    let suffix = text.slice(section.end);
+    if (prefix && !prefix.endsWith("\n")) prefix += "\n";
+    if (suffix && !suffix.startsWith("\n")) suffix = `\n${suffix}`;
+    return `${prefix}${suffix}`;
+}
+
 function writeConfig(filePath: string, text: string): boolean {
     try {
         fs.mkdirSync(path.dirname(filePath), { recursive: true });
@@ -352,21 +337,32 @@ export async function ensureCodexStatuslineConfig(
     if (!enabled || disabled) return false;
 
     const desired = resolveDesiredStatusLineConfig(config);
+    if (!desired) return false;
+
     const configPath = desired.configPath;
     const raw = readConfig(configPath);
-    const section = parseStatusLineSection(raw);
+    const legacySection = parseLegacyStatusLineSection(raw);
+    const base = legacySection ? removeSection(raw, legacySection) : raw;
+    const section = parseTuiSection(base);
 
     if (section && configMatches(section.config, desired)) return false;
 
     const force =
         parseBooleanEnv(process.env.CODE_ENV_CODEX_STATUSLINE_FORCE) === true;
+    const hasExistingStatusLine = Boolean(
+        (section && Array.isArray(section.config.statusLineItems)) || legacySection
+    );
 
-    if (section && !force) {
-        console.log(`codenv: existing Codex status_line config in ${configPath}:`);
-        console.log(section.sectionText);
+    if (hasExistingStatusLine && !force) {
+        console.log(`codenv: existing Codex tui.status_line config in ${configPath}:`);
+        if (section && Array.isArray(section.config.statusLineItems)) {
+            console.log(section.sectionText);
+        } else if (legacySection) {
+            console.log(legacySection.sectionText);
+        }
         if (!process.stdin.isTTY || !process.stdout.isTTY) {
             console.warn(
-                "codenv: no TTY available to confirm status_line overwrite."
+                "codenv: no TTY available to confirm tui.status_line overwrite."
             );
             return false;
         }
@@ -374,7 +370,7 @@ export async function ensureCodexStatuslineConfig(
         try {
             const confirm = await askConfirm(
                 rl,
-                "Overwrite Codex status_line config? (y/N): "
+                "Overwrite Codex tui.status_line config? (y/N): "
             );
             if (!confirm) return false;
         } finally {
@@ -382,10 +378,10 @@ export async function ensureCodexStatuslineConfig(
         }
     }
 
-    const updated = upsertSection(raw, section, buildStatusLineSection(desired));
+    const updated = upsertSection(base, section, buildTuiSection(section, desired));
     if (!writeConfig(configPath, updated)) {
         console.error(
-            "codenv: failed to write Codex config; status_line not updated."
+            "codenv: failed to write Codex config; tui.status_line not updated."
         );
         return false;
     }

package/src/statusline/index.ts

@@ -6,6 +6,7 @@ import { normalizeType, inferProfileType, getProfileDisplayName } from "../profi
 import {
     readUsageCostIndex,
     readUsageSessionCost,
+    resolveProfileFromLog,
     resolveUsageCostForProfile,
     syncUsageFromStatuslineInput,
 } from "../usage";
@@ -62,7 +63,7 @@ export function buildStatuslineResult(
     let type = normalizeTypeValue(typeCandidate);
     const envProfile = resolveEnvProfile(type);
 
-    const profileKey = firstNonEmpty(
+    let profileKey = firstNonEmpty(
         args.profileKey,
         envProfile.key,
         inputProfile ? inputProfile.key : null
@@ -73,6 +74,21 @@ export function buildStatuslineResult(
         inputProfile ? inputProfile.name : null
     );
 
+    const terminalTag = process.env.CODE_ENV_TERMINAL_TAG || null;
+    if (!profileKey && !profileName) {
+        const fallback = resolveProfileFromLog(
+            config,
+            configPath,
+            normalizeType(type || ""),
+            terminalTag
+        );
+        if (fallback) {
+            profileKey = fallback.profileKey;
+            profileName = fallback.profileName;
+        }
+    }
+
+    const sessionId = getSessionId(stdinInput);
     if (profileKey && !profileName && config.profiles && config.profiles[profileKey]) {
         const profile = config.profiles[profileKey];
         profileName = getProfileDisplayName(profileKey, profile, type || undefined);
@@ -96,9 +112,10 @@ export function buildStatuslineResult(
         process.cwd()
     )!;
 
-    const sessionId = getSessionId(stdinInput);
     const usageType = normalizeType(type || "");
     const stdinUsageTotals = getUsageTotalsFromInput(stdinInput, usageType);
+    const shouldSyncUsageFromSessions =
+        args.syncUsage && !stdinUsageTotals;
     const model = firstNonEmpty(
         args.model,
         process.env.CODE_ENV_MODEL,
@@ -184,7 +201,7 @@ export function buildStatuslineResult(
         type,
         profileKey,
         profileName,
-        args.syncUsage
+        shouldSyncUsageFromSessions
     );
 
     let finalUsage: StatuslineUsage | null = hasExplicitUsage ? usage : null;
@@ -236,14 +253,18 @@ export function buildStatuslineResult(
                   configPath,
                   type,
                   sessionId,
-                  args.syncUsage
+                  shouldSyncUsageFromSessions
               )
             : null;
         sessionCost =
             sessionCostFromRecords ??
             (sessionUsage ? calculateUsageCost(sessionUsage, pricing) : null);
     }
-    const costIndex = readUsageCostIndex(config, configPath, args.syncUsage);
+    const costIndex = readUsageCostIndex(
+        config,
+        configPath,
+        shouldSyncUsageFromSessions
+    );
     const costTotals = costIndex
         ? resolveUsageCostForProfile(costIndex, type, profileKey, profileName)
         : null;

package/src/types.ts

@@ -19,10 +19,7 @@ export interface Profile {
 }
 
 export interface CodexStatuslineConfig {
-    command?: string | string[];
-    showHints?: boolean;
-    updateIntervalMs?: number;
-    timeoutMs?: number;
+    items?: string[];
     configPath?: string;
 }