sideby 0.0.0-stage → 0.1.0

package/dist/src/families/claude/index.js

@@ -0,0 +1,124 @@
+// Built-in Family Plugin for Claude Code (spec §3.4, checked against Claude Code 2.1.289).
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { identityFromJsonFile, identityOf } from '../../core/identity.js';
+import { readSecretFile } from '../../core/secret-file.js';
+import { claudeStatusline } from '../../quota/claude-statusline.js';
+import { BUILTIN_LOGOS } from '../logos.js';
+import { CLAUDE_LAYOUT } from './layout.js';
+import { readClaudeQuota } from './quota.js';
+import { readClaudeUsage } from './usage.js';
+const LINKED = [
+    'settings.json',
+    'settings.local.json',
+    'skills',
+    'commands',
+    'plugins',
+    'hooks',
+    'themes',
+    'CLAUDE.md',
+];
+/** The Main Account keeps `.claude.json` in HOME; other Accounts keep it inside their directory. */
+export function claudeJsonOf(account) {
+    return account.isMain ? join(dirname(account.dir), '.claude.json') : join(account.dir, '.claude.json');
+}
+/** Only checks whether `oauthAccount` is present; the parsed content is dropped immediately. */
+async function loginState(account) {
+    let parsed;
+    try {
+        parsed = JSON.parse(await readFile(claudeJsonOf(account), 'utf8'));
+    }
+    catch {
+        return 'unknown';
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        return 'unknown';
+    return parsed.oauthAccount != null ? 'logged-in' : 'logged-out';
+}
+/**
+ * `oauthAccount.emailAddress` and `organizationName` from `.claude.json`; nothing else is kept. The organization a
+ * personal sign-in gets by default ("<name>'s Organization") says nothing new, so it is left out.
+ */
+export function claudeIdentity(account) {
+    return identityFromJsonFile(claudeJsonOf(account), (data) => {
+        const o = data
+            ?.oauthAccount;
+        if (typeof o !== 'object' || o === null)
+            return undefined;
+        const org = typeof o.organizationName === 'string' && !/'s Organization$/.test(o.organizationName)
+            ? o.organizationName
+            : undefined;
+        return identityOf(o.emailAddress, org);
+    });
+}
+async function model(account) {
+    if (account.kind === 'api') {
+        if (!account.secretFile)
+            return undefined;
+        try {
+            return (await readSecretFile(account.secretFile)).ANTHROPIC_MODEL || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    try {
+        const s = JSON.parse(await readFile(join(account.dir, 'settings.json'), 'utf8'));
+        return typeof s?.model === 'string' && s.model ? s.model : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export const claudeFamily = {
+    id: 'claude',
+    title: 'Claude Code',
+    logo: BUILTIN_LOGOS.claude,
+    bin: 'claude',
+    installUrl: 'https://code.claude.com/docs/en/setup',
+    selectVar: 'CLAUDE_CONFIG_DIR',
+    layout: CLAUDE_LAYOUT,
+    // `plugins` alone is too generic: claude-code-router keeps `~/.claude-code-router/plugins`.
+    markers: [
+        '.claude.json',
+        'settings.json',
+        'settings.local.json',
+        'skills',
+        'commands',
+        'hooks',
+        'themes',
+        'CLAUDE.md',
+        'projects',
+    ],
+    hijackVars: [
+        'ANTHROPIC_API_KEY',
+        'ANTHROPIC_AUTH_TOKEN',
+        'ANTHROPIC_BASE_URL',
+        'ANTHROPIC_MODEL',
+        'ANTHROPIC_SMALL_FAST_MODEL',
+        'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+        'ANTHROPIC_DEFAULT_SONNET_MODEL',
+        'ANTHROPIC_DEFAULT_OPUS_MODEL',
+    ],
+    apiVars: ['ANTHROPIC_BASE_URL', 'ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_MODEL'],
+    sharedItems: [
+        ...LINKED.map((path) => ({ path, mode: 'link' })),
+        { path: '.claude.json', mode: 'json-key', key: 'mcpServers', mainPath: '.claude.json', credential: true },
+    ],
+    login: {
+        args: ['auth', 'login'],
+        hint: 'Opens the browser to sign this account in to Claude (`claude auth login`).',
+    },
+    loginState,
+    model,
+    identity: claudeIdentity,
+    readQuota: readClaudeQuota,
+    readUsage: readClaudeUsage,
+    quotaSetup: claudeStatusline,
+};
+export const claudePlugin = {
+    name: 'claude',
+    register(api) {
+        api.family(claudeFamily);
+    },
+};

package/dist/src/families/claude/layout.d.ts

@@ -0,0 +1,6 @@
+export declare const CLAUDE_MAIN_DIR = ".claude";
+export declare const CLAUDE_ACCOUNT_PREFIX = ".claude-";
+export declare const CLAUDE_LAYOUT: {
+    main: string;
+    account: string;
+};

package/dist/src/families/claude/layout.js

@@ -0,0 +1,5 @@
+// Where Claude Code keeps an Account. A leaf module (no imports) shared by the Family, the quota setup and
+// the status line tap, which must not import the Family's index on every refresh.
+export const CLAUDE_MAIN_DIR = '.claude';
+export const CLAUDE_ACCOUNT_PREFIX = '.claude-';
+export const CLAUDE_LAYOUT = { main: CLAUDE_MAIN_DIR, account: `${CLAUDE_ACCOUNT_PREFIX}<name>` };

package/dist/src/families/claude/quota-cache.d.ts

@@ -0,0 +1,31 @@
+import type { Env, QuotaWindow } from '../../types.ts';
+export interface ClaudeQuotaCache {
+    version: 1;
+    /** When the status line last reported these windows. */
+    observedAt: string;
+    windows: QuotaWindow[];
+}
+export declare function claudeQuotaCacheFile(stateDir: string, name: string): string;
+/** sideby's state directory for this environment (same rule as the Runtime). */
+export declare function cacheStateDir(env: Env): string;
+/** Account name from CLAUDE_CONFIG_DIR: unset or `~/.claude` is `main`, `.claude-<name>` is `<name>`, else null. */
+export declare function accountNameFromEnv(env: Env): string | null;
+/** Extracts the 5h and 7d windows from status line JSON; null when there is nothing usable. */
+export declare function parseRateLimits(input: string, observedAt: Date): ClaudeQuotaCache | null;
+/** Writes the cache atomically; creates the private parent directory first (writeFileAtomic does not). */
+export declare function writeQuotaCache(stateDir: string, name: string, cache: ClaudeQuotaCache): Promise<void>;
+export type CacheRead = {
+    status: 'ok';
+    observedAt: string;
+    windows: QuotaWindow[];
+} | {
+    status: 'missing';
+} | {
+    status: 'unrecognized';
+    detail: string;
+};
+/**
+ * Reads the cache. Accepts any file with a parseable `observedAt` and at least one valid window; `version`
+ * is not enforced so caches written by earlier releases keep working.
+ */
+export declare function readQuotaCache(stateDir: string, name: string): Promise<CacheRead>;

package/dist/src/families/claude/quota-cache.js

@@ -0,0 +1,111 @@
+// The Claude Quota cache: one module owns where it lives, how the Account is named, and how it is written,
+// read and validated. The status line tap writes it on every refresh, so this module imports only leaf
+// modules and Node built-ins (never the Family index, the Runtime or core/accounts.ts).
+import { mkdir, readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+import { ACCOUNT_NAME } from '../../core/account-name.js';
+import { writeFileAtomic } from '../../core/fs-safe.js';
+import { resolvePaths } from '../../core/paths.js';
+import { CLAUDE_ACCOUNT_PREFIX, CLAUDE_MAIN_DIR } from './layout.js';
+const WINDOWS = [
+    { key: 'five_hour', label: '5h', minutes: 300 },
+    { key: 'seven_day', label: '7d', minutes: 10_080 },
+];
+export function claudeQuotaCacheFile(stateDir, name) {
+    return join(stateDir, 'quota', 'claude', `${name}.json`);
+}
+/** sideby's state directory for this environment (same rule as the Runtime). */
+export function cacheStateDir(env) {
+    return resolvePaths(env).stateDir;
+}
+/** Account name from CLAUDE_CONFIG_DIR: unset or `~/.claude` is `main`, `.claude-<name>` is `<name>`, else null. */
+export function accountNameFromEnv(env) {
+    const dir = env.CLAUDE_CONFIG_DIR;
+    if (!dir)
+        return 'main';
+    if (resolve(dir) === join(env.HOME || homedir(), CLAUDE_MAIN_DIR))
+        return 'main';
+    const base = basename(dir);
+    if (!base.startsWith(CLAUDE_ACCOUNT_PREFIX))
+        return null;
+    const name = base.slice(CLAUDE_ACCOUNT_PREFIX.length);
+    return name !== 'main' && ACCOUNT_NAME.test(name) ? name : null;
+}
+/** Extracts the 5h and 7d windows from status line JSON; null when there is nothing usable. */
+export function parseRateLimits(input, observedAt) {
+    let data;
+    try {
+        data = JSON.parse(input);
+    }
+    catch {
+        return null;
+    }
+    const rl = data?.rate_limits;
+    if (typeof rl !== 'object' || rl === null)
+        return null;
+    const windows = [];
+    for (const w of WINDOWS) {
+        const v = rl[w.key];
+        if (typeof v !== 'object' || v === null)
+            continue;
+        const used = v.used_percentage;
+        const resets = v.resets_at;
+        if (typeof used !== 'number' || !Number.isFinite(used))
+            continue;
+        if (typeof resets !== 'number' || !Number.isFinite(resets) || resets <= 0)
+            continue;
+        windows.push({
+            label: w.label,
+            windowMinutes: w.minutes,
+            usedPercent: used,
+            resetsAt: new Date(resets * 1000).toISOString(),
+        });
+    }
+    return windows.length ? { version: 1, observedAt: observedAt.toISOString(), windows } : null;
+}
+/** Writes the cache atomically; creates the private parent directory first (writeFileAtomic does not). */
+export async function writeQuotaCache(stateDir, name, cache) {
+    const file = claudeQuotaCacheFile(stateDir, name);
+    await mkdir(dirname(file), { recursive: true, mode: 0o700 });
+    await writeFileAtomic(file, `${JSON.stringify(cache)}\n`, 0o600);
+}
+function validWindow(w) {
+    if (typeof w !== 'object' || w === null)
+        return false;
+    const v = w;
+    return (typeof v.label === 'string' &&
+        typeof v.windowMinutes === 'number' &&
+        typeof v.usedPercent === 'number' &&
+        typeof v.resetsAt === 'string' &&
+        Number.isFinite(Date.parse(v.resetsAt)));
+}
+/**
+ * Reads the cache. Accepts any file with a parseable `observedAt` and at least one valid window; `version`
+ * is not enforced so caches written by earlier releases keep working.
+ */
+export async function readQuotaCache(stateDir, name) {
+    const file = claudeQuotaCacheFile(stateDir, name);
+    let raw;
+    try {
+        raw = await readFile(file, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return { status: 'missing' };
+        throw err;
+    }
+    let cache;
+    try {
+        cache = JSON.parse(raw);
+    }
+    catch {
+        return { status: 'unrecognized', detail: `${file} is not valid JSON` };
+    }
+    const windows = Array.isArray(cache?.windows) ? cache.windows.filter(validWindow) : [];
+    if (typeof cache?.observedAt !== 'string' ||
+        !Number.isFinite(Date.parse(cache.observedAt)) ||
+        !windows.length)
+        return { status: 'unrecognized', detail: `${file} has no usable quota windows` };
+    return { status: 'ok', observedAt: cache.observedAt, windows };
+}

package/dist/src/families/claude/quota.d.ts

@@ -0,0 +1,3 @@
+import type { Account, QuotaResult, ReadContext } from '../../types.ts';
+export declare const QUOTA_SOURCE = "claude statusline";
+export declare function readClaudeQuota(account: Account, ctx: ReadContext): Promise<QuotaResult>;

package/dist/src/families/claude/quota.js

@@ -0,0 +1,53 @@
+// Quota for a Claude subscription Account: the windows `sideby statusline-tap` last cached for it.
+// Windows past `resetsAt` are returned unchanged; callers compare with the current time and show "reset".
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { realpathOrNull } from '../../core/fs-safe.js';
+import { claudeStatusline, isWrapped, mainSettingsFile } from '../../quota/claude-statusline.js';
+import { readQuotaCache } from './quota-cache.js';
+export const QUOTA_SOURCE = 'claude statusline';
+/** How the Account reaches the wrapper: the shared main settings.json, its own wrapped file, or neither. */
+async function accountWrapped(account, ctx) {
+    if (account.isMain)
+        return 'shared';
+    const own = join(account.dir, 'settings.json');
+    const [a, b] = await Promise.all([realpathOrNull(own), realpathOrNull(mainSettingsFile(ctx.home))]);
+    if (a !== null && a === b)
+        return 'shared';
+    try {
+        const s = JSON.parse(await readFile(own, 'utf8'));
+        return isWrapped(s?.statusLine?.command) ? 'own' : 'own-unwrapped';
+    }
+    catch {
+        return 'own-unwrapped';
+    }
+}
+async function withoutCache(account, ctx) {
+    const wiring = await accountWrapped(account, ctx);
+    if (wiring === 'own-unwrapped')
+        return {
+            status: 'unavailable',
+            reason: 'not-enabled',
+            detail: "this account's settings.json is not shared with the main account, so its quota needs its own status line setup",
+        };
+    const planStatus = await claudeStatusline.plan(ctx).then((p) => p.status, () => 'blocked');
+    if (wiring === 'shared' && planStatus !== 'enabled')
+        return {
+            status: 'unavailable',
+            reason: 'not-enabled',
+            detail: 'run `sideby quota setup claude` to record Claude quota from the status line',
+        };
+    return {
+        status: 'unavailable',
+        reason: 'no-session',
+        detail: 'start a Claude Code session with this account; quota is recorded after its first reply',
+    };
+}
+export async function readClaudeQuota(account, ctx) {
+    const read = await readQuotaCache(ctx.stateDir, account.name);
+    if (read.status === 'missing')
+        return withoutCache(account, ctx);
+    if (read.status === 'unrecognized')
+        return { status: 'unavailable', reason: 'unrecognized', detail: read.detail };
+    return { status: 'ok', windows: read.windows, observedAt: read.observedAt, source: QUOTA_SOURCE };
+}

package/dist/src/families/claude/usage.d.ts

@@ -0,0 +1,22 @@
+import { FileMemo } from '../../core/file-memo.ts';
+import type { Account, ReadContext, UsageResult } from '../../types.ts';
+interface Entry {
+    timestamp: number;
+    session: string;
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+}
+/** What one session log holds: its usage rows in file order, keyed for the "last line wins" dedupe. */
+interface Parsed {
+    lines: number;
+    parsed: number;
+    rows: [string, Entry][];
+    /** The read stopped early; the rows so far still count, but the result is not remembered. */
+    failed: boolean;
+}
+/** Parsed session logs per Account directory; a file is parsed again only after it changed. */
+export declare const claudeUsageMemo: FileMemo<Parsed>;
+export declare function readClaudeUsage(account: Account, ctx: ReadContext): Promise<UsageResult>;
+export {};

package/dist/src/families/claude/usage.js

@@ -0,0 +1,146 @@
+// Usage for a Claude Code Account, counted from its own session logs (`<dir>/projects/**/*.jsonl`).
+// One assistant message can be logged on several lines; the last line per `message.id` wins. Each file's parse is
+// remembered until the file changes (core/file-memo.ts), so a refresh reads only the logs that grew.
+import { createReadStream } from 'node:fs';
+import { readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { FileMemo } from '../../core/file-memo.js';
+import { USAGE_DAYS } from '../../core/quota-levels.js';
+import { dailyBuckets } from '../../core/usage-days.js';
+const DAY_MS = 86_400_000;
+async function listJsonl(dir, out = []) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        const p = join(dir, e.name);
+        // Dirent types do not follow symlinks, so a linked directory can never loop the walk.
+        if (e.isDirectory())
+            await listJsonl(p, out);
+        else if (e.isFile() && e.name.endsWith('.jsonl'))
+            out.push(p);
+    }
+    return out;
+}
+const count = (v) => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : 0);
+async function parseFile(file) {
+    const out = { lines: 0, parsed: 0, rows: [], failed: false };
+    try {
+        const rl = createInterface({ input: createReadStream(file), crlfDelay: Number.POSITIVE_INFINITY });
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            out.lines++;
+            let row;
+            try {
+                row = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            out.parsed++;
+            if (row?.type !== 'assistant')
+                continue;
+            const usage = row.message?.usage;
+            if (typeof usage !== 'object' || usage === null)
+                continue;
+            const id = row.message?.id;
+            const key = typeof id === 'string'
+                ? id
+                : typeof row.requestId === 'string'
+                    ? `request:${row.requestId}`
+                    : `${file}:${out.lines}`;
+            out.rows.push([
+                key,
+                {
+                    timestamp: typeof row.timestamp === 'string' ? Date.parse(row.timestamp) : Number.NaN,
+                    session: typeof row.sessionId === 'string' ? row.sessionId : file,
+                    input: count(usage.input_tokens),
+                    output: count(usage.output_tokens),
+                    cacheRead: count(usage.cache_read_input_tokens),
+                    cacheWrite: count(usage.cache_creation_input_tokens),
+                },
+            ]);
+        }
+    }
+    catch {
+        // An unreadable file is skipped; the others still count.
+        out.failed = true;
+    }
+    return out;
+}
+/** Parsed session logs per Account directory; a file is parsed again only after it changed. */
+export const claudeUsageMemo = new FileMemo();
+export async function readClaudeUsage(account, ctx) {
+    const files = await listJsonl(join(account.dir, 'projects'));
+    if (!files.length)
+        return {
+            status: 'unavailable',
+            reason: 'no-session',
+            detail: 'no Claude Code sessions recorded for this account yet',
+        };
+    const now = ctx.now.getTime();
+    const since = now - USAGE_DAYS * DAY_MS;
+    const entries = new Map();
+    let lines = 0;
+    let parsed = 0;
+    const memo = claudeUsageMemo.pass(account.dir);
+    for (const file of files) {
+        const st = await stat(file).catch(() => null);
+        if (!st || st.mtimeMs < since)
+            continue;
+        const p = await memo.get(file, st, () => parseFile(file), (v) => !v.failed);
+        lines += p.lines;
+        parsed += p.parsed;
+        for (const [key, entry] of p.rows) {
+            // Re-insert so the last occurrence wins.
+            entries.delete(key);
+            entries.set(key, entry);
+        }
+    }
+    memo.done();
+    if (lines > 0 && parsed === 0)
+        return {
+            status: 'unavailable',
+            reason: 'unrecognized',
+            detail: `session logs in the last ${USAGE_DAYS} days could not be parsed as JSON lines`,
+        };
+    const sessions = new Set();
+    const days = dailyBuckets(ctx.now);
+    let last = Number.NEGATIVE_INFINITY;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadTokens = 0;
+    let cacheWriteTokens = 0;
+    for (const e of entries.values()) {
+        if (!Number.isFinite(e.timestamp) || e.timestamp > now)
+            continue;
+        if (e.timestamp > last)
+            last = e.timestamp;
+        if (e.timestamp < since)
+            continue;
+        sessions.add(e.session);
+        inputTokens += e.input;
+        outputTokens += e.output;
+        cacheReadTokens += e.cacheRead;
+        cacheWriteTokens += e.cacheWrite;
+        days.add(e.timestamp, e.input + e.output + e.cacheRead + e.cacheWrite);
+    }
+    return {
+        status: 'ok',
+        days: USAGE_DAYS,
+        sessions: sessions.size,
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheWriteTokens,
+        totalTokens: inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens,
+        daily: days.daily,
+        ...(Number.isFinite(last) ? { lastActivityAt: new Date(last).toISOString() } : {}),
+    };
+}

package/dist/src/families/codex/index.d.ts

@@ -0,0 +1,5 @@
+import type { Account, FamilyDef, Plugin } from '../../types.ts';
+/** The email claim of `tokens.id_token` in auth.json; the token and every other claim are dropped. */
+export declare function codexIdentity(account: Account): Promise<import("../../types.ts").AccountIdentity | undefined>;
+export declare const codexFamily: FamilyDef;
+export declare const codexPlugin: Plugin;

package/dist/src/families/codex/index.js

@@ -0,0 +1,67 @@
+import { readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { identityFromJsonFile, identityOf, jwtEmail } from '../../core/identity.js';
+import { BUILTIN_LOGOS } from '../logos.js';
+import { topLevelTomlString } from '../shared/toml.js';
+import { readCodexQuota, readCodexUsage } from './rollout.js';
+const FILE_STORE_KEY = 'cli_auth_credentials_store';
+async function readModel(account) {
+    try {
+        return topLevelTomlString(await readFile(join(account.dir, 'config.toml'), 'utf8'), 'model');
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The email claim of `tokens.id_token` in auth.json; the token and every other claim are dropped. */
+export function codexIdentity(account) {
+    return identityFromJsonFile(join(account.dir, 'auth.json'), (data) => identityOf(jwtEmail(data?.tokens?.id_token)));
+}
+export const codexFamily = {
+    id: 'codex',
+    title: 'Codex',
+    logo: BUILTIN_LOGOS.codex,
+    bin: 'codex',
+    installUrl: 'https://github.com/openai/codex',
+    selectVar: 'CODEX_HOME',
+    layout: { main: '.codex', account: '.codex-<name>' },
+    hijackVars: ['OPENAI_API_KEY', 'OPENAI_BASE_URL', 'CODEX_API_BASE_URL'],
+    apiVars: ['OPENAI_BASE_URL', 'OPENAI_API_KEY'],
+    sharedItems: [
+        { path: 'AGENTS.md', mode: 'link' },
+        { path: 'hooks.json', mode: 'link' },
+        { path: 'plugins', mode: 'link' },
+        { path: 'rules', mode: 'link' },
+        { path: 'skills', mode: 'link' },
+        { path: 'config.toml', mode: 'local-if-api' },
+        { path: 'auth.json', mode: 'info', credential: true },
+    ],
+    login: {
+        args: ['login'],
+        hint: "Sign in with ChatGPT in the browser; the login is saved to this account's auth.json",
+    },
+    // A non-main Account keeps its login in its own auth.json instead of the shared OS keyring.
+    defaultArgs(account, userArgs) {
+        if (account.isMain || userArgs.some((a) => a.includes(FILE_STORE_KEY)))
+            return [];
+        return ['-c', `${FILE_STORE_KEY}="file"`];
+    },
+    async loginState(account) {
+        try {
+            return (await stat(join(account.dir, 'auth.json'))).isFile() ? 'logged-in' : 'unknown';
+        }
+        catch (err) {
+            return err.code === 'ENOENT' ? 'logged-out' : 'unknown';
+        }
+    },
+    model: readModel,
+    identity: codexIdentity,
+    readQuota: (account) => readCodexQuota(account.dir),
+    readUsage: (account, ctx) => readCodexUsage(account.dir, ctx.now),
+};
+export const codexPlugin = {
+    name: 'codex',
+    register(api) {
+        api.family(codexFamily);
+    },
+};

package/dist/src/families/codex/rollout.d.ts

@@ -0,0 +1,67 @@
+import { FileMemo, type FileStats } from '../../core/file-memo.ts';
+import type { QuotaResult, QuotaWindow, UsageResult } from '../../types.ts';
+export declare const MAX_QUOTA_FILES = 20;
+export interface RolloutFile {
+    path: string;
+    mtimeMs: number;
+    stats: FileStats;
+}
+/** Every rollout file under `<dir>/sessions`, newest mtime first. */
+export declare function listRollouts(dir: string): Promise<RolloutFile[]>;
+export declare function windowLabel(minutes: number): string;
+interface FileLimits {
+    /** The file's newest well-formed `rate_limits` (the later line on a tie), or null. */
+    best: {
+        at: number;
+        windows: QuotaWindow[];
+        plan?: string;
+    } | null;
+    failed: boolean;
+}
+/** Parsed `rate_limits` per Account directory; a rollout is read again only after it changed. */
+export declare const codexQuotaMemo: FileMemo<FileLimits>;
+/** Newest well-formed `rate_limits` across the newest rollout files, by event timestamp. */
+export declare function readCodexQuota(dir: string): Promise<QuotaResult>;
+interface Totals {
+    input: number;
+    cached: number;
+    output: number;
+    cacheWrite: number;
+}
+/**
+ * What each event adds, by index. `total_token_usage` is cumulative per segment: every field, cached input
+ * included, only grows until the Host starts a new segment, where they all start again from zero. A subagent's
+ * file starts from its parent's running total. So the first event adds its total minus the starting baseline
+ * (that total minus the first turn's own usage, zero for an ordinary session), an event where any field went
+ * down starts a new segment and adds its whole total, and any other event adds its growth. Every field of every
+ * increment is therefore zero or more, and any run of events sums to exactly what it added.
+ */
+export declare function fileDeltas(events: {
+    total: Totals;
+    turn: Totals | null;
+}[]): Totals[];
+/** Tokens one whole rollout file adds: the sum of its fileDeltas. */
+export declare function fileTokens(events: {
+    total: Totals;
+    turn: Totals | null;
+}[]): Totals | null;
+interface FileUsage {
+    /** Time of every `token_count` event, with or without totals. */
+    times: number[];
+    events: {
+        at: number;
+        total: Totals;
+        turn: Totals | null;
+    }[];
+    deltas: Totals[];
+    failed: boolean;
+}
+/** Parsed token totals per Account directory; a rollout is read again only after it changed. */
+export declare const codexUsageMemo: FileMemo<FileUsage>;
+/**
+ * Token totals for events in the last `days` x 24 h, from rollout files modified in that window (mtime only
+ * picks which files to read). Each event counts its fileDeltas increment, so a long session resumed today
+ * adds only its recent turns. `daily` spreads the same increments over local days.
+ */
+export declare function readCodexUsage(dir: string, now: Date, days?: number): Promise<UsageResult>;
+export {};