handmux 0.23.0 → 0.25.0

package/dist/src/agents/codexSessionControl.js

@@ -0,0 +1,118 @@
+const record = (value) => (value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null);
+const text = (value) => (typeof value === 'string' && value.trim() ? value.trim() : undefined);
+function effortOptions(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((candidate) => {
+        const item = record(candidate);
+        const id = text(item?.reasoningEffort);
+        if (!id)
+            return [];
+        const description = text(item?.description);
+        return [{ id, label: id, ...(description === undefined ? {} : { description }) }];
+    });
+}
+function tierOptions(model) {
+    const explicit = Array.isArray(model.serviceTiers)
+        ? model.serviceTiers.flatMap((candidate) => {
+            const item = record(candidate);
+            const id = text(item?.id);
+            if (!id)
+                return [];
+            const label = text(item?.name);
+            const description = text(item?.description);
+            return [{
+                    id,
+                    ...(label === undefined ? {} : { label }),
+                    ...(description === undefined ? {} : { description }),
+                }];
+        }) : [];
+    const fallback = explicit.length ? explicit : Array.isArray(model.additionalSpeedTiers)
+        ? model.additionalSpeedTiers.flatMap((candidate) => {
+            const id = text(candidate);
+            return id ? [{ id, label: id }] : [];
+        }) : [];
+    return fallback.length ? fallback : undefined;
+}
+function modelOptions(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((candidate) => {
+        const item = record(candidate);
+        if (!item)
+            return [];
+        const id = text(item.model) ?? text(item.id);
+        if (!id)
+            return [];
+        const label = text(item.displayName) ?? id;
+        const description = text(item.description);
+        const efforts = effortOptions(item.supportedReasoningEfforts);
+        const defaultEffort = text(item.defaultReasoningEffort);
+        const serviceTiers = tierOptions(item);
+        return [{
+                id,
+                label,
+                ...(description === undefined ? {} : { description }),
+                efforts,
+                ...(defaultEffort === undefined || !efforts.some((effort) => effort.id === defaultEffort)
+                    ? {} : { defaultEffort }),
+                ...(serviceTiers === undefined ? {} : { serviceTiers }),
+            }];
+    });
+}
+function settingsFrom(value) {
+    const root = record(value);
+    return record(root?.settings) ?? root ?? {};
+}
+function snapshot(modelsValue, settingsValue) {
+    const models = modelOptions(modelsValue);
+    const settings = settingsFrom(settingsValue);
+    const selectedModelId = text(settings.model) ?? null;
+    const selectedModel = models.find((model) => model.id === selectedModelId);
+    const effort = text(settings.effort);
+    const serviceTier = settings.serviceTier === null ? null : text(settings.serviceTier) ?? null;
+    return {
+        models,
+        selected: {
+            model: selectedModel?.id ?? null,
+            effort: effort && selectedModel?.efforts.some((candidate) => candidate.id === effort)
+                ? effort : null,
+            serviceTier: serviceTier && selectedModel?.serviceTiers?.some((tier) => tier.id === serviceTier)
+                ? serviceTier : null,
+        },
+    };
+}
+export function createCodexSessionControlAdapter(app) {
+    if (!app || typeof app.models !== 'function' || typeof app.status !== 'function'
+        || typeof app.updateSettings !== 'function') {
+        throw new TypeError('Codex Session Control adapter requires App Server model/settings APIs');
+    }
+    const read = async (pane, threadId) => {
+        const [models, status] = await Promise.all([
+            app.models(pane, threadId),
+            app.status(pane, threadId),
+        ]);
+        return snapshot(models, status);
+    };
+    return {
+        apiVersion: 1,
+        async readModelControl(run, options) {
+            const threadId = run.ref.sessionId;
+            if (!threadId || run.signal.aborted)
+                return null;
+            // Codex App Server's model/list is already a live native read and exposes no stronger refresh
+            // operation. `refresh` therefore has the same semantics instead of being backed by a Web cache.
+            void options?.refresh;
+            return read(run.ref.paneId, threadId);
+        },
+        async updateModelControl(run, patch) {
+            const threadId = run.ref.sessionId;
+            if (!threadId || run.signal.aborted)
+                throw new Error('Codex run is unavailable');
+            await app.updateSettings(run.ref.paneId, threadId, { ...patch });
+            if (run.signal.aborted)
+                throw new Error('Codex run is unavailable');
+            return read(run.ref.paneId, threadId);
+        },
+    };
+}

package/dist/src/agents/codexSubscriptionUsage.js

@@ -0,0 +1,313 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { homedir } from 'node:os';
+import { spawn } from 'node:child_process';
+import { readLatestUsage, readSnapshot, writeSnapshot } from '../codexUsageSnapshot.js';
+import { codexSessionsDir, codexUsagePath } from '../usagePaths.js';
+const isRecord = (value) => (typeof value === 'object' && value !== null && !Array.isArray(value));
+const finite = (value) => typeof value === 'number' && Number.isFinite(value);
+const optionalString = (value) => (typeof value === 'string' && value.trim() ? value.trim() : null);
+function rolloutFilesByMtime(dir) {
+    const files = [];
+    const visit = (current) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.'))
+                continue;
+            const file = path.join(current, entry.name);
+            if (entry.isDirectory())
+                visit(file);
+            else if (entry.name.startsWith('rollout-') && entry.name.endsWith('.jsonl')) {
+                try {
+                    files.push({ file, mtimeMs: fs.statSync(file).mtimeMs });
+                }
+                catch { /* raced away */ }
+            }
+        }
+    };
+    visit(dir);
+    return files.sort((first, second) => second.mtimeMs - first.mtimeMs);
+}
+function scanCodexUsage(home) {
+    let latest = null;
+    for (const { file, mtimeMs } of rolloutFilesByMtime(codexSessionsDir(home))) {
+        if (latest?.updatedAt && mtimeMs < latest.updatedAt)
+            break;
+        const usage = readLatestUsage(file);
+        if (usage && (!latest || usage.updatedAt > latest.updatedAt))
+            latest = usage;
+    }
+    return latest;
+}
+export function readCodexSubscriptionUsage(home = homedir(), { now = Date.now(), calibrationMs = 60_000 } = {}) {
+    const file = codexUsagePath(home);
+    const snapshot = readSnapshot(file);
+    if (snapshot && now - snapshot.checkedAt < calibrationMs)
+        return snapshot.usage;
+    writeSnapshot(file, scanCodexUsage(home), { checkedAt: now });
+    return readSnapshot(file)?.usage ?? null;
+}
+function normalizeWindow(value) {
+    if (!isRecord(value) || !finite(value.usedPercent))
+        return null;
+    return {
+        usedPercent: value.usedPercent,
+        windowMinutes: finite(value.windowDurationMins) ? value.windowDurationMins : null,
+        resetsAt: finite(value.resetsAt) ? value.resetsAt : null,
+    };
+}
+function normalizeAccount(value) {
+    if (!isRecord(value))
+        return null;
+    const type = optionalString(value.type);
+    return type ? { type, email: optionalString(value.email), planType: optionalString(value.planType) } : null;
+}
+function normalizeModels(value, mainLimitId) {
+    if (!isRecord(value))
+        return [];
+    const models = [];
+    const seen = new Set();
+    for (const [key, raw] of Object.entries(value)) {
+        if (!isRecord(raw))
+            continue;
+        const limitId = optionalString(raw.limitId) ?? key;
+        if (limitId === (mainLimitId ?? 'codex') || seen.has(limitId))
+            continue;
+        const primary = normalizeWindow(raw.primary);
+        const secondary = normalizeWindow(raw.secondary);
+        if (!primary && !secondary)
+            continue;
+        models.push({ limitId, limitName: optionalString(raw.limitName), primary, secondary });
+        seen.add(limitId);
+    }
+    return models;
+}
+function normalizeCredits(value) {
+    if (!isRecord(value) || !Number.isSafeInteger(value.availableCount))
+        return null;
+    const availableCount = value.availableCount;
+    if (availableCount < 0)
+        return null;
+    const expiryTimes = (Array.isArray(value.credits) ? value.credits : []).flatMap((credit) => {
+        if (!isRecord(credit) || credit.status !== 'available' || !finite(credit.expiresAt)
+            || credit.expiresAt <= 0 || !Number.isFinite(new Date(credit.expiresAt * 1000).getTime()))
+            return [];
+        return [credit.expiresAt];
+    }).sort((first, second) => first - second).slice(0, availableCount);
+    return { availableCount, expiryTimes };
+}
+export function fetchCodexSubscriptionUsage({ home = homedir(), command = 'codex', args = ['app-server', '--stdio'], timeoutMs = 15_000, } = {}) {
+    return new Promise((resolve) => {
+        let child;
+        let settled = false;
+        let stdout = '';
+        let account = null;
+        let accountRead = false;
+        let limits = null;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            try {
+                child?.kill();
+            }
+            catch { /* best effort */ }
+            resolve(value);
+        };
+        const finishWhenReady = () => { if (accountRead && limits)
+            finish({ account, ...limits }); };
+        const timer = setTimeout(() => finish(null), timeoutMs);
+        try {
+            child = spawn(command, args, {
+                env: { ...process.env, CODEX_HOME: path.join(home, '.codex') },
+                stdio: ['pipe', 'pipe', 'ignore'],
+            });
+        }
+        catch {
+            finish(null);
+            return;
+        }
+        child.on('error', () => finish(null));
+        child.on('exit', () => finish(null));
+        child.stdout?.on('data', (chunk) => {
+            stdout += chunk;
+            if (stdout.length > 1024 * 1024) {
+                finish(null);
+                return;
+            }
+            let newline;
+            while ((newline = stdout.indexOf('\n')) >= 0) {
+                const line = stdout.slice(0, newline);
+                stdout = stdout.slice(newline + 1);
+                if (!line)
+                    continue;
+                let message;
+                try {
+                    message = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (!isRecord(message))
+                    continue;
+                if (message.id === 1 && message.result) {
+                    child?.stdin?.write(`${JSON.stringify({ method: 'initialized', params: {} })}\n`);
+                    child?.stdin?.write(`${JSON.stringify({ method: 'account/read', id: 2, params: { refreshToken: false } })}\n`);
+                    child?.stdin?.write(`${JSON.stringify({ method: 'account/rateLimits/read', id: 3 })}\n`);
+                }
+                else if (message.id === 2) {
+                    const result = isRecord(message.result) ? message.result : null;
+                    account = normalizeAccount(result?.account);
+                    accountRead = true;
+                    finishWhenReady();
+                }
+                else if (message.id === 3) {
+                    const result = isRecord(message.result) ? message.result : null;
+                    const source = result && isRecord(result.rateLimits) ? result.rateLimits : null;
+                    if (!source) {
+                        finish(null);
+                        return;
+                    }
+                    limits = {
+                        rateLimits: {
+                            primary: normalizeWindow(source.primary), secondary: normalizeWindow(source.secondary),
+                        },
+                        modelRateLimits: normalizeModels(result?.rateLimitsByLimitId, optionalString(source.limitId)),
+                        resetCredits: normalizeCredits(result?.rateLimitResetCredits),
+                    };
+                    finishWhenReady();
+                }
+            }
+        });
+        child.stdin?.on('error', () => finish(null));
+        child.stdin?.write(`${JSON.stringify({
+            method: 'initialize', id: 1,
+            params: { clientInfo: { name: 'handmux', title: 'handmux', version: '0.0.0' } },
+        })}\n`);
+    });
+}
+function adapterWindow(id, value) {
+    if (!value)
+        return null;
+    return {
+        id, usedPercent: value.usedPercent,
+        ...(value.windowMinutes === null ? {} : { windowMinutes: value.windowMinutes }),
+        ...(value.resetsAt === null ? {} : { resetsAt: value.resetsAt }),
+    };
+}
+function group(kind, id, label, limits) {
+    const windows = [adapterWindow('primary', limits.primary), adapterWindow('secondary', limits.secondary)]
+        .filter((window) => window !== null);
+    return windows.length ? { kind, id, ...(label ? { label } : {}), windows } : null;
+}
+function titleCase(value) {
+    return value.replace(/[_-]+/g, ' ').replace(/\b\w/g, (letter) => letter.toUpperCase());
+}
+function accountLabel(account) {
+    if (account.email)
+        return account.email;
+    if (account.type === 'apiKey')
+        return 'API Key';
+    if (account.type === 'chatgpt')
+        return 'ChatGPT';
+    return titleCase(account.type);
+}
+export function createCodexSubscriptionUsageAdapter(options = {}) {
+    const home = options.home ?? homedir();
+    const now = options.now ?? Date.now;
+    let lastAccount = null;
+    let accountCheckedAt = Number.NEGATIVE_INFINITY;
+    let accountPromise = null;
+    let accountPromiseForced = false;
+    let legacy = null;
+    const refreshAccount = async (force) => {
+        const current = now();
+        if (!force && current - accountCheckedAt < (options.accountTtlMs ?? 60_000))
+            return lastAccount;
+        if (accountPromise) {
+            if (!force || accountPromiseForced)
+                return accountPromise;
+            try {
+                await accountPromise;
+            }
+            catch { /* the explicit refresh below gets its own authoritative result */ }
+            return refreshAccount(true);
+        }
+        let pending;
+        pending = (options.fetchAccount
+            ? options.fetchAccount()
+            : fetchCodexSubscriptionUsage({ ...options, home })).then((fetched) => {
+            if (!fetched && force)
+                throw new Error('Codex subscription usage refresh failed');
+            if (fetched) {
+                accountCheckedAt = now();
+                lastAccount = { ...fetched, updatedAt: accountCheckedAt };
+            }
+            return lastAccount;
+        }).finally(() => {
+            if (accountPromise === pending) {
+                accountPromise = null;
+                accountPromiseForced = false;
+            }
+        });
+        accountPromise = pending;
+        accountPromiseForced = force;
+        return pending;
+    };
+    return {
+        apiVersion: 1,
+        async snapshot({ refresh = false } = {}) {
+            const rollout = readCodexSubscriptionUsage(home, {
+                now: now(), calibrationMs: refresh ? 0 : options.calibrationMs ?? 60_000,
+            });
+            const account = await refreshAccount(refresh);
+            const effectiveLimits = account?.rateLimits ?? rollout?.rateLimits ?? { primary: null, secondary: null };
+            const coreResetCredits = account?.resetCredits ? {
+                availableCount: account.resetCredits.availableCount,
+                expiryTimes: account.resetCredits.expiryTimes.slice(0, 256),
+            } : null;
+            const groups = [];
+            const accountGroup = group('account', 'account', null, effectiveLimits);
+            if (accountGroup)
+                groups.push(accountGroup);
+            for (const model of (account?.modelRateLimits ?? []).slice(0, 63)) {
+                const modelGroup = group('model', model.limitId, model.limitName, model);
+                if (modelGroup)
+                    groups.push(modelGroup);
+            }
+            legacy = !account && !rollout ? null : {
+                updatedAt: account?.updatedAt ?? rollout?.updatedAt ?? null,
+                account: account?.account ? structuredClone(account.account) : null,
+                rateLimits: structuredClone(effectiveLimits),
+                modelRateLimits: structuredClone(account?.modelRateLimits ?? []),
+                rateLimitResetCredits: account?.resetCredits
+                    ? structuredClone(account.resetCredits) : null,
+                tokens: structuredClone(rollout?.tokens ?? {
+                    total: null, input: null, cachedInput: null, output: null, reasoning: null,
+                }),
+                contextWindow: rollout?.contextWindow ?? null,
+            };
+            return {
+                ...(account?.account ? {
+                    account: {
+                        label: accountLabel(account.account),
+                        ...(account.account.planType ? { plan: titleCase(account.account.planType) } : {}),
+                    },
+                } : {}),
+                groups,
+                ...(coreResetCredits ? { resetCredits: coreResetCredits } : {}),
+                updatedAt: account?.updatedAt ?? rollout?.updatedAt ?? null,
+                status: !account && !rollout ? 'unavailable'
+                    : groups.length || account?.account || account?.resetCredits ? 'ready' : 'pending',
+            };
+        },
+        legacySnapshot: () => legacy ? structuredClone(legacy) : null,
+    };
+}

package/dist/src/agents/codexTerminalControl.js

@@ -0,0 +1,23 @@
+const INPUT_SETTLE_MS = 100;
+const CLEAR_SWITCH_ATTEMPTS = 60;
+const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+// Codex's /clear replaces the active TUI chat widget as well as the App Server thread. Driving that
+// native action keeps terminal and Conversation on one session; a direct thread/start would split them.
+export async function clearCodexConversationThroughTui(codexApp, commands, pane, previousThreadId, wait = pause) {
+    await commands.exitCopyModeIfActive(pane);
+    await commands.sendKey(pane, 'C-u');
+    await wait(INPUT_SETTLE_MS);
+    await commands.sendText(pane, '/clear');
+    await wait(INPUT_SETTLE_MS);
+    await commands.sendEnter(pane);
+    for (let attempt = 0; attempt < CLEAR_SWITCH_ATTEMPTS; attempt += 1) {
+        const discovered = await codexApp.discover(pane);
+        if (!discovered?.managed)
+            throw new Error('Codex session is no longer managed by Handmux');
+        if (discovered.threadId && discovered.threadId !== previousThreadId) {
+            return { threadId: discovered.threadId };
+        }
+        await wait(INPUT_SETTLE_MS);
+    }
+    throw new Error('Codex terminal did not accept /clear; switch to the terminal, close any open panel, and try again');
+}