@praeviso/code-env-switch 0.1.0 → 0.1.2

package/src/commands/launch.ts

@@ -0,0 +1,395 @@
+/**
+ * Launch codex/claude with session binding
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { spawn } from "child_process";
+import type { Config, ProfileType } from "../types";
+import { CODEX_AUTH_PATH } from "../constants";
+import { normalizeType } from "../profile/type";
+import {
+    getCodexSessionsPath,
+    getClaudeSessionsPath,
+    logProfileUse,
+    logSessionBinding,
+    readSessionBindingIndex,
+} from "../usage";
+import { ensureClaudeStatusline } from "../statusline/claude";
+import { ensureCodexStatuslineConfig } from "../statusline/codex";
+
+const SESSION_BINDING_POLL_MS = 1000;
+const SESSION_BINDING_START_GRACE_MS = 5000;
+
+interface SessionMeta {
+    filePath: string;
+    sessionId: string | null;
+    timestamp: string | null;
+    fileTimestampMs: number | null;
+    cwd: string | null;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function collectSessionFiles(root: string | null): string[] {
+    if (!root || !fs.existsSync(root)) return [];
+    const files: string[] = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current) continue;
+        let entries: fs.Dirent[] = [];
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        } catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith(".")) continue;
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(full);
+            } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+                files.push(full);
+            }
+        }
+    }
+    return files;
+}
+
+function readFirstJsonLine(filePath: string): unknown | null {
+    let fd: number | null = null;
+    try {
+        fd = fs.openSync(filePath, "r");
+        const buffer = Buffer.alloc(64 * 1024);
+        const bytes = fs.readSync(fd, buffer, 0, buffer.length, 0);
+        if (bytes <= 0) return null;
+        const text = buffer.slice(0, bytes).toString("utf8");
+        const line = text.split(/\r?\n/)[0];
+        if (!line) return null;
+        return JSON.parse(line);
+    } catch {
+        return null;
+    } finally {
+        if (fd !== null) {
+            try {
+                fs.closeSync(fd);
+            } catch {
+                // ignore
+            }
+        }
+    }
+}
+
+function parseCodexFilenameInfo(filePath: string): {
+    timestamp: string | null;
+    timestampMs: number | null;
+    sessionId: string | null;
+} {
+    const base = path.basename(filePath);
+    const match = base.match(
+        /(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})-([0-9a-fA-F-]+)\.jsonl$/
+    );
+    if (!match) {
+        return { timestamp: null, timestampMs: null, sessionId: null };
+    }
+    const [, date, hour, minute, second, sessionId] = match;
+    const timestamp = `${date}T${hour}:${minute}:${second}`;
+    const parsedMs = new Date(timestamp).getTime();
+    return {
+        timestamp,
+        timestampMs: Number.isNaN(parsedMs) ? null : parsedMs,
+        sessionId: sessionId ? String(sessionId) : null,
+    };
+}
+
+function readSessionMeta(filePath: string, type: ProfileType): SessionMeta | null {
+    const first = readFirstJsonLine(filePath);
+    if (!isRecord(first)) return null;
+    if (type === "codex") {
+        const fromName = parseCodexFilenameInfo(filePath);
+        const payload = isRecord(first.payload) ? first.payload : null;
+        const ts = payload && payload.timestamp ? payload.timestamp : first.timestamp;
+        const timestamp = ts ? String(ts) : fromName.timestamp;
+        return {
+            filePath,
+            sessionId:
+                payload && payload.id
+                    ? String(payload.id)
+                    : fromName.sessionId
+                    ? String(fromName.sessionId)
+                    : null,
+            timestamp,
+            fileTimestampMs: fromName.timestampMs,
+            cwd: payload && payload.cwd ? String(payload.cwd) : null,
+        };
+    }
+    return {
+        filePath,
+        sessionId: first.sessionId ? String(first.sessionId) : null,
+        timestamp: first.timestamp ? String(first.timestamp) : null,
+        fileTimestampMs: null,
+        cwd: first.cwd ? String(first.cwd) : null,
+    };
+}
+
+function getSessionCandidateTimestamp(meta: SessionMeta, stat: fs.Stats): number | null {
+    const times: number[] = [];
+    if (Number.isFinite(stat.mtimeMs)) times.push(stat.mtimeMs);
+    if (meta.timestamp) {
+        const tsMs = new Date(meta.timestamp).getTime();
+        if (Number.isFinite(tsMs)) times.push(tsMs);
+    }
+    if (Number.isFinite(meta.fileTimestampMs)) times.push(meta.fileTimestampMs);
+    if (times.length === 0) return null;
+    return Math.max(...times);
+}
+
+function findLatestUnboundSessionMeta(
+    root: string | null,
+    type: ProfileType,
+    bound: { byFile: Set<string>; byId: Set<string> },
+    minTimestampMs: number | null,
+    cwd: string | null,
+    skipFiles: Set<string> | null
+): SessionMeta | null {
+    const files = collectSessionFiles(root);
+    let bestMeta: SessionMeta | null = null;
+    let bestTs = Number.NEGATIVE_INFINITY;
+    let bestCwdMatch = false;
+
+    for (const filePath of files) {
+        if (bound.byFile.has(filePath)) continue;
+        if (skipFiles && skipFiles.has(filePath)) continue;
+        let stat: fs.Stats | null = null;
+        try {
+            stat = fs.statSync(filePath);
+        } catch {
+            continue;
+        }
+        if (!stat || !stat.isFile()) continue;
+        const meta =
+            readSessionMeta(filePath, type) || {
+                filePath,
+                sessionId: null,
+                timestamp: null,
+                fileTimestampMs: null,
+                cwd: null,
+            };
+        if (meta.sessionId && bound.byId.has(meta.sessionId)) continue;
+        const tsMs = getSessionCandidateTimestamp(meta, stat);
+        if (tsMs === null || Number.isNaN(tsMs)) continue;
+        if (minTimestampMs !== null && tsMs < minTimestampMs) continue;
+        const cwdMatch = Boolean(cwd && meta.cwd && meta.cwd === cwd);
+        if (
+            !bestMeta ||
+            (cwdMatch && !bestCwdMatch) ||
+            (cwdMatch === bestCwdMatch && tsMs > bestTs)
+        ) {
+            bestMeta = meta;
+            bestTs = tsMs;
+            bestCwdMatch = cwdMatch;
+        }
+    }
+
+    return bestMeta;
+}
+
+function getProfileEnv(type: ProfileType): { key: string | null; name: string | null } {
+    const suffix = type.toUpperCase();
+    const key = process.env[`CODE_ENV_PROFILE_KEY_${suffix}`] || null;
+    const name = process.env[`CODE_ENV_PROFILE_NAME_${suffix}`] || key;
+    return { key, name };
+}
+
+function writeCodexAuthFromEnv(): void {
+    const apiKey = process.env.OPENAI_API_KEY;
+    try {
+        fs.mkdirSync(path.dirname(CODEX_AUTH_PATH), { recursive: true });
+    } catch {
+        // ignore
+    }
+    const authJson =
+        apiKey === null || apiKey === undefined || apiKey === ""
+            ? "null"
+            : JSON.stringify({ OPENAI_API_KEY: String(apiKey) });
+    try {
+        fs.writeFileSync(CODEX_AUTH_PATH, `${authJson}\n`, "utf8");
+    } catch {
+        // ignore
+    }
+}
+
+function parseBooleanEnv(value: string | undefined): boolean | null {
+    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 isStatuslineEnabled(type: ProfileType): boolean {
+    if (!process.stdout.isTTY || process.env.TERM === "dumb") return false;
+    const disable = parseBooleanEnv(process.env.CODE_ENV_STATUSLINE_DISABLE);
+    if (disable === true) return false;
+    const typeFlag = parseBooleanEnv(
+        process.env[`CODE_ENV_STATUSLINE_${type.toUpperCase()}`]
+    );
+    if (typeFlag !== null) return typeFlag;
+    const genericFlag = parseBooleanEnv(process.env.CODE_ENV_STATUSLINE);
+    if (genericFlag !== null) return genericFlag;
+    return true;
+}
+
+async function ensureClaudeStatuslineConfig(
+    config: Config,
+    enabled: boolean
+): Promise<void> {
+    await ensureClaudeStatusline(config, enabled);
+}
+
+export async function runLaunch(
+    config: Config,
+    configPath: string | null,
+    target: string,
+    args: string[]
+): Promise<number> {
+    const type = normalizeType(target);
+    if (!type) {
+        throw new Error(`Unknown launch target: ${target}`);
+    }
+    if (type === "codex") {
+        writeCodexAuthFromEnv();
+    }
+
+    const { key: profileKey, name: profileName } = getProfileEnv(type);
+    const terminalTag = process.env.CODE_ENV_TERMINAL_TAG || null;
+    const cwd = process.cwd();
+    const startMs = Date.now();
+    const minBindingTimestampMs = startMs - SESSION_BINDING_START_GRACE_MS;
+    const sessionRoot =
+        type === "codex" ? getCodexSessionsPath(config) : getClaudeSessionsPath(config);
+    const initialBindingIndex = readSessionBindingIndex(config, configPath);
+    const initialUnboundFiles = new Set<string>();
+    for (const filePath of collectSessionFiles(sessionRoot)) {
+        if (!initialBindingIndex.byFile.has(filePath)) {
+            initialUnboundFiles.add(filePath);
+        }
+    }
+
+    const statuslineEnabled = isStatuslineEnabled(type);
+    if (type === "claude") {
+        await ensureClaudeStatuslineConfig(config, statuslineEnabled);
+    } else if (type === "codex") {
+        await ensureCodexStatuslineConfig(config, statuslineEnabled);
+    }
+    if (profileKey) {
+        logProfileUse(config, configPath, profileKey, type, terminalTag, cwd);
+    }
+    const child = spawn(target, args, { stdio: "inherit", env: process.env });
+    const canBindSession = Boolean(profileKey || profileName);
+    let boundSession: SessionMeta | null = null;
+    let bindingTimer: NodeJS.Timeout | null = null;
+
+    const tryBindSession = () => {
+        if (!canBindSession || boundSession) return;
+        const bindingIndex = readSessionBindingIndex(config, configPath);
+        const candidate = findLatestUnboundSessionMeta(
+            sessionRoot,
+            type,
+            bindingIndex,
+            minBindingTimestampMs,
+            cwd,
+            initialUnboundFiles
+        );
+        if (!candidate) return;
+        boundSession = candidate;
+        logSessionBinding(
+            config,
+            configPath,
+            type,
+            profileKey,
+            profileName,
+            terminalTag,
+            cwd,
+            boundSession.filePath,
+            boundSession.sessionId,
+            boundSession.timestamp
+        );
+        if (bindingTimer) {
+            clearInterval(bindingTimer);
+            bindingTimer = null;
+        }
+    };
+
+    if (canBindSession) {
+        tryBindSession();
+        bindingTimer = setInterval(tryBindSession, SESSION_BINDING_POLL_MS);
+    }
+
+    const forwardSignal = (signal: NodeJS.Signals) => {
+        try {
+            child.kill(signal);
+        } catch {
+            // ignore
+        }
+    };
+    process.on("SIGINT", forwardSignal);
+    process.on("SIGTERM", forwardSignal);
+
+    const exitCode = await new Promise<number>((resolve) => {
+        child.on("error", (err) => {
+            process.off("SIGINT", forwardSignal);
+            process.off("SIGTERM", forwardSignal);
+            if (bindingTimer) {
+                clearInterval(bindingTimer);
+                bindingTimer = null;
+            }
+            console.error(`codenv: failed to launch ${target}: ${err.message}`);
+            resolve(1);
+        });
+        child.on("exit", (code, signal) => {
+            process.off("SIGINT", forwardSignal);
+            process.off("SIGTERM", forwardSignal);
+            if (bindingTimer) {
+                clearInterval(bindingTimer);
+                bindingTimer = null;
+            }
+            const bindingIndex = readSessionBindingIndex(config, configPath);
+            const sessionMeta = findLatestUnboundSessionMeta(
+                sessionRoot,
+                type,
+                bindingIndex,
+                minBindingTimestampMs,
+                cwd,
+                initialUnboundFiles
+            );
+            if (!boundSession && sessionMeta && (profileKey || profileName)) {
+                logSessionBinding(
+                    config,
+                    configPath,
+                    type,
+                    profileKey,
+                    profileName,
+                    terminalTag,
+                    cwd,
+                    sessionMeta.filePath,
+                    sessionMeta.sessionId,
+                    sessionMeta.timestamp
+                );
+            }
+            if (typeof code === "number") {
+                resolve(code);
+                return;
+            }
+            if (signal) {
+                resolve(1);
+                return;
+            }
+            resolve(0);
+        });
+    });
+
+    return exitCode;
+}

package/src/commands/list.ts

@@ -0,0 +1,91 @@
+/**
+ * List command - show all profiles
+ */
+import type { Config } from "../types";
+import { buildListRows } from "../profile/display";
+import { getResolvedDefaultProfileKeys } from "../config/defaults";
+import {
+    formatTokenCount,
+    readUsageTotalsIndex,
+    resolveUsageTotalsForProfile,
+} from "../usage";
+
+export function printList(config: Config, configPath: string | null): void {
+    const rows = buildListRows(config, getResolvedDefaultProfileKeys);
+    if (rows.length === 0) {
+        console.log("(no profiles found)");
+        return;
+    }
+    try {
+        const usageTotals = readUsageTotalsIndex(config, configPath, true);
+        if (usageTotals) {
+            for (const row of rows) {
+                if (!row.usageType) continue;
+                const usage = resolveUsageTotalsForProfile(
+                    usageTotals,
+                    row.usageType,
+                    row.key,
+                    row.name
+                );
+                if (!usage) continue;
+                row.todayTokens = usage.today;
+                row.totalTokens = usage.total;
+            }
+        }
+    } catch {
+        // ignore usage sync errors
+    }
+    const headerName = "PROFILE";
+    const headerType = "TYPE";
+    const headerToday = "TODAY";
+    const headerTotal = "TOTAL";
+    const headerNote = "NOTE";
+    const todayTexts = rows.map((row) => formatTokenCount(row.todayTokens));
+    const totalTexts = rows.map((row) => formatTokenCount(row.totalTokens));
+    const nameWidth = Math.max(
+        headerName.length,
+        ...rows.map((row) => row.name.length)
+    );
+    const typeWidth = Math.max(
+        headerType.length,
+        ...rows.map((row) => row.type.length)
+    );
+    const todayWidth = Math.max(headerToday.length, ...todayTexts.map((v) => v.length));
+    const totalWidth = Math.max(headerTotal.length, ...totalTexts.map((v) => v.length));
+    const noteWidth = Math.max(
+        headerNote.length,
+        ...rows.map((row) => row.note.length)
+    );
+    const formatRow = (
+        name: string,
+        type: string,
+        today: string,
+        total: string,
+        note: string
+    ) =>
+        `${name.padEnd(nameWidth)}  ${type.padEnd(typeWidth)}  ${today.padStart(
+            todayWidth
+        )}  ${total.padStart(totalWidth)}  ${note.padEnd(noteWidth)}`;
+
+    console.log(formatRow(headerName, headerType, headerToday, headerTotal, headerNote));
+    console.log(
+        formatRow(
+            "-".repeat(nameWidth),
+            "-".repeat(typeWidth),
+            "-".repeat(todayWidth),
+            "-".repeat(totalWidth),
+            "-".repeat(noteWidth)
+        )
+    );
+    for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        const todayText = todayTexts[i] || "-";
+        const totalText = totalTexts[i] || "-";
+        const line = formatRow(row.name, row.type, todayText, totalText, row.note);
+        if (row.active) {
+            console.log(`\x1b[32m${line}\x1b[0m`);
+        } else {
+            console.log(line);
+        }
+    }
+}

package/src/commands/show.ts

@@ -0,0 +1,12 @@
+/**
+ * Show command - display profile details
+ */
+import type { Config } from "../types";
+
+export function printShow(config: Config, profileName: string): void {
+    const profile = config.profiles && config.profiles[profileName];
+    if (!profile) {
+        throw new Error(`Unknown profile: ${profileName}`);
+    }
+    console.log(JSON.stringify(profile, null, 2));
+}

package/src/commands/statusline.ts

@@ -0,0 +1,18 @@
+/**
+ * Statusline command - output statusline text or JSON
+ */
+import type { Config, StatuslineArgs } from "../types";
+import { buildStatuslineResult } from "../statusline";
+
+export function printStatusline(
+    config: Config,
+    configPath: string | null,
+    args: StatuslineArgs
+): void {
+    const result = buildStatuslineResult(args, config, configPath);
+    if (args.format === "json") {
+        console.log(JSON.stringify(result.json));
+        return;
+    }
+    console.log(result.text);
+}

package/src/commands/unset.ts

@@ -0,0 +1,19 @@
+/**
+ * Unset command - print unset statements
+ */
+import type { Config } from "../types";
+import { DEFAULT_PROFILE_TYPES } from "../constants";
+import { getTypeDefaultUnsetKeys } from "../config/defaults";
+
+export function printUnset(config: Config): void {
+    const keySet = new Set<string>();
+    if (Array.isArray(config.unset)) {
+        for (const key of config.unset) keySet.add(key);
+    }
+    for (const type of DEFAULT_PROFILE_TYPES) {
+        for (const key of getTypeDefaultUnsetKeys(type)) keySet.add(key);
+    }
+    if (keySet.size === 0) return;
+    const lines = Array.from(keySet, (key) => `unset ${key}`);
+    console.log(lines.join("\n"));
+}

package/src/commands/use.ts

@@ -0,0 +1,121 @@
+/**
+ * Use command - apply profile environment
+ */
+import * as path from "path";
+import type { Config, ProfileType } from "../types";
+import { CODEX_AUTH_PATH } from "../constants";
+import { shellEscape, expandEnv } from "../shell/utils";
+import { inferProfileType, getProfileDisplayName } from "../profile/type";
+import { shouldRemoveCodexAuth } from "../profile/match";
+import { buildEffectiveEnv } from "../profile/display";
+import { getFilteredUnsetKeys, getTypeDefaultUnsetKeys } from "../config/defaults";
+
+export function buildUseLines(
+    config: Config,
+    profileName: string,
+    requestedType: ProfileType | null,
+    includeGlobalUnset: boolean,
+    configPath: string | null = null
+): string[] {
+    const profile = config.profiles && config.profiles[profileName];
+    if (!profile) {
+        throw new Error(`Unknown profile: ${profileName}`);
+    }
+
+    const unsetLines: string[] = [];
+    const exportLines: string[] = [];
+    const postLines: string[] = [];
+    const unsetKeys = new Set<string>();
+    const activeType = inferProfileType(profileName, profile, requestedType);
+    const effectiveEnv = buildEffectiveEnv(profile, activeType);
+
+    const addUnset = (key: string) => {
+        if (unsetKeys.has(key)) return;
+        if (Object.prototype.hasOwnProperty.call(effectiveEnv, key)) return;
+        unsetKeys.add(key);
+        unsetLines.push(`unset ${key}`);
+    };
+
+    if (includeGlobalUnset) {
+        for (const key of getFilteredUnsetKeys(config, activeType)) {
+            addUnset(key);
+        }
+    }
+
+    if (activeType) {
+        for (const key of getTypeDefaultUnsetKeys(activeType)) {
+            addUnset(key);
+        }
+    }
+
+    for (const key of Object.keys(effectiveEnv)) {
+        const value = effectiveEnv[key];
+        if (value === null || value === undefined || value === "") {
+            if (!unsetKeys.has(key)) {
+                unsetKeys.add(key);
+                unsetLines.push(`unset ${key}`);
+            }
+        } else {
+            exportLines.push(`export ${key}=${shellEscape(value)}`);
+        }
+    }
+
+    if (activeType) {
+        const typeSuffix = activeType.toUpperCase();
+        const displayName = getProfileDisplayName(profileName, profile, activeType);
+        exportLines.push(
+            `export CODE_ENV_PROFILE_KEY_${typeSuffix}=${shellEscape(profileName)}`
+        );
+        exportLines.push(
+            `export CODE_ENV_PROFILE_NAME_${typeSuffix}=${shellEscape(displayName)}`
+        );
+    }
+    if (configPath) {
+        exportLines.push(`export CODE_ENV_CONFIG_PATH=${shellEscape(configPath)}`);
+    }
+
+    if (shouldRemoveCodexAuth(profileName, profile, requestedType)) {
+        const codexApiKey = effectiveEnv.OPENAI_API_KEY;
+        const authDir = path.dirname(CODEX_AUTH_PATH);
+        const authJson =
+            codexApiKey === null || codexApiKey === undefined || codexApiKey === ""
+                ? "null"
+                : JSON.stringify({ OPENAI_API_KEY: String(codexApiKey) });
+        postLines.push(`mkdir -p ${shellEscape(authDir)}`);
+        postLines.push(
+            `printf '%s\\n' ${shellEscape(authJson)} > ${shellEscape(CODEX_AUTH_PATH)}`
+        );
+    }
+
+    if (Array.isArray(profile.removeFiles)) {
+        for (const p of profile.removeFiles) {
+            const expanded = expandEnv(p);
+            if (expanded) postLines.push(`rm -f ${shellEscape(expanded)}`);
+        }
+    }
+
+    if (Array.isArray(profile.commands)) {
+        for (const cmd of profile.commands) {
+            if (cmd && String(cmd).trim()) postLines.push(String(cmd));
+        }
+    }
+
+    return [...unsetLines, ...exportLines, ...postLines];
+}
+
+export function printUse(
+    config: Config,
+    profileName: string,
+    requestedType: ProfileType | null = null,
+    includeGlobalUnset = true,
+    configPath: string | null = null
+): void {
+    const lines = buildUseLines(
+        config,
+        profileName,
+        requestedType,
+        includeGlobalUnset,
+        configPath
+    );
+    console.log(lines.join("\n"));
+}