tokenmaxxing 1.34.0 → 1.35.0

package/src/lib/codexdecide.ts

@@ -1,157 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { z } from "zod";
-import { withLock } from "./lock.ts";
-import { writeFileAtomic } from "./atomic.ts";
-import { codexPaths } from "./paths.ts";
-import { loadConfig } from "./state.ts";
-import { loadCodexAccounts, loadCodexLastSwapAt, saveCodexAccounts } from "./codexstate.ts";
-import { isCodexExhausted, pickBestCodex } from "./codexpick.ts";
-import { performCodexSwap } from "./codexswap.ts";
-import { CodexInvalidGrantError, refreshCodexAuth } from "./codexoauth.ts";
-import { fetchCodexUsage } from "./codexusage.ts";
-import { codexIdentityOf, isCodexAccessExpiring, readLiveCodexAuth, writeLiveCodexAuth, writeParkedCodexAuth } from "./codexauth.ts";
-import { liveCodexAccountId } from "./codexsample.ts";
-import { livingCodexPresences, presentCodexAccountIds, targetableCodexAccounts } from "./codexpresence.ts";
-import { thresholdBars } from "./picker.ts";
-import { log } from "./log.ts";
-import { CodexAccountSchema, CodexReconcileMarkerSchema, type CodexAccount } from "./types.ts";
-
-const CodexSwapDecisionSchema = z.object({
-  swapped: z.boolean(),
-  account: CodexAccountSchema.nullable(),
-  reason: z.string(),
-});
-export type CodexSwapDecision = z.infer<typeof CodexSwapDecisionSchema>;
-
-const POST_SWAP_COOLDOWN_MS = 45_000;
-
-async function sampleLiveOntoOwner(input: { now: number }): Promise<string | null> {
-  const { now } = input;
-  let live = readLiveCodexAuth();
-  if (!live) return null;
-  const index = loadCodexAccounts();
-  const identity = codexIdentityOf({ auth: live });
-  const owner = index.accounts.find((account) => account.accountId === identity.accountId);
-  if (!owner) return null;
-
-  if (isCodexAccessExpiring({ auth: live, now }) && !presentCodexAccountIds().has(identity.accountId)) {
-    try {
-      live = await refreshCodexAuth({ auth: live, now });
-    } catch (e) {
-      if (e instanceof CodexInvalidGrantError) {
-        owner.needsReauth = true;
-        saveCodexAccounts({ index });
-        log("codexdecide.live_invalid_grant", { account: owner.accountId.slice(0, 8) });
-        return owner.accountId;
-      }
-      throw e;
-    }
-    writeLiveCodexAuth({ auth: live });
-    writeParkedCodexAuth({ credFile: owner.credFile, auth: live });
-  }
-  const usage = await fetchCodexUsage({ auth: live });
-  owner.lastUsage = { aggregate: usage.aggregate, perLimit: usage.perLimit };
-  owner.lastUsageAt = now;
-  if (usage.email != null) owner.email = usage.email;
-  if (usage.planType != null) owner.planType = usage.planType;
-  saveCodexAccounts({ index });
-  return owner.accountId;
-}
-
-function reconcileNonLiveSiblings(input: {
-  index: { accounts: CodexAccount[] };
-  liveAccountId: string;
-  bars: { session: number; weekly: number };
-  now: number;
-}): void {
-  const { index, liveAccountId, bars, now } = input;
-  const unusable = (account: CodexAccount): boolean =>
-    account.needsReauth === true || isCodexExhausted({ account, thresholds: bars, now });
-  const liveAccount = index.accounts.find((account) => account.accountId === liveAccountId);
-  if (!liveAccount || unusable(liveAccount)) return;
-  const living = livingCodexPresences();
-  if (existsSync(codexPaths.reconcileDir)) {
-    const alive = new Set(living.map((presence) => presence.supervisorId));
-    for (const name of readdirSync(codexPaths.reconcileDir)) {
-      if (!alive.has(name)) rmSync(join(codexPaths.reconcileDir, name), { force: true });
-    }
-  }
-  for (const presence of living) {
-    if (presence.accountId === liveAccountId) continue;
-    const seated = index.accounts.find((account) => account.accountId === presence.accountId);
-    if (!seated) continue;
-    const markerPath = join(codexPaths.reconcileDir, presence.supervisorId);
-    if (existsSync(markerPath)) continue;
-    mkdirSync(codexPaths.reconcileDir, { recursive: true });
-    writeFileAtomic(markerPath, JSON.stringify(CodexReconcileMarkerSchema.parse({ accountId: presence.accountId, ts: now })));
-    log("codexdecide.reconcile_signal", { supervisorId: presence.supervisorId.slice(0, 8), account: presence.accountId.slice(0, 8) });
-  }
-}
-
-function postSwapResweep(input: { liveAccountId: string; bars: { session: number; weekly: number }; now: number }): void {
-  try {
-    reconcileNonLiveSiblings({ index: loadCodexAccounts(), liveAccountId: input.liveAccountId, bars: input.bars, now: input.now });
-  } catch (e) {
-    log("codexdecide.resweep_failed", { err: e instanceof Error ? e.message : String(e) });
-  }
-}
-
-export async function evaluateAndMaybeSwapCodex(input: { now?: number }): Promise<CodexSwapDecision> {
-  const now = input.now ?? Date.now();
-  const cfg = loadConfig();
-  const bars = thresholdBars(cfg);
-
-  return withLock(codexPaths.lockFile, async () => {
-    let index = loadCodexAccounts();
-    if (index.accounts.length === 0) return { swapped: false, account: null, reason: "no-pool" };
-
-    const activeId = liveCodexAccountId();
-    if (activeId == null || !index.accounts.some((account) => account.accountId === activeId)) {
-      return { swapped: false, account: null, reason: "live-credential-not-in-pool" };
-    }
-
-    reconcileNonLiveSiblings({ index, liveAccountId: activeId, bars, now });
-
-    const lastSwapAt = loadCodexLastSwapAt();
-    if (lastSwapAt != null && now - lastSwapAt < POST_SWAP_COOLDOWN_MS) {
-      return { swapped: false, account: null, reason: "post-swap-cooldown" };
-    }
-
-    const activeEntry = index.accounts.find((account) => account.accountId === activeId);
-    const stale = activeEntry?.lastUsageAt == null || now - activeEntry.lastUsageAt > cfg.policy.usagePollTtlMs;
-    if (stale) {
-      const sampledId = await sampleLiveOntoOwner({ now });
-      if (sampledId == null) {
-        return { swapped: false, account: null, reason: "live-credential-not-in-pool" };
-      }
-      index = loadCodexAccounts();
-    }
-
-    const active = index.accounts.find((account) => account.accountId === activeId) ?? null;
-    if (!active) return { swapped: false, account: null, reason: "no-active-account" };
-
-    const engaged = active.needsReauth === true || isCodexExhausted({ account: active, thresholds: bars, now });
-    if (!engaged) return { swapped: false, account: null, reason: "under-threshold-or-stale" };
-
-    const tried = new Set<string>();
-    while (true) {
-      const current = loadCodexAccounts();
-      const candidates = targetableCodexAccounts({ accounts: current.accounts, activeAccountId: activeId }).filter(
-        (account) => !tried.has(account.accountId),
-      );
-      const best = pickBestCodex({ accounts: candidates, thresholds: bars, now, currentAccountId: activeId });
-      if (!best) return { swapped: false, account: null, reason: "all-depleted" };
-      tried.add(best.accountId);
-      try {
-        await performCodexSwap({ target: best });
-      } catch (e) {
-        if (e instanceof CodexInvalidGrantError) continue;
-        throw e;
-      }
-      log("codexdecide.swap", { account: best.accountId.slice(0, 8) });
-      postSwapResweep({ liveAccountId: best.accountId, bars, now });
-      return { swapped: true, account: best, reason: "swapped" };
-    }
-  });
-}

package/src/lib/codexpick.ts

@@ -1,80 +0,0 @@
-import { sortBy } from "es-toolkit";
-import { nextWeeklyReset } from "./picker.ts";
-import { isSessionWindow, weeklyWindowOf } from "./codexusage.ts";
-import type { CodexAccount, CodexWindow, Thresholds } from "./types.ts";
-
-function liveUsed(input: { window: CodexWindow; now: number; sampledAt: number | null }): number {
-  const { window, now, sampledAt } = input;
-  if (window.resetsAt != null) return window.resetsAt <= now ? 0 : window.usedPercentage;
-  if (sampledAt != null && window.windowSeconds != null && now >= sampledAt + window.windowSeconds * 1000) return 0;
-  return window.usedPercentage;
-}
-
-function allWindows(account: CodexAccount): CodexWindow[] {
-  const usage = account.lastUsage;
-  if (!usage) return [];
-  return [...usage.aggregate, ...Object.values(usage.perLimit).flat()];
-}
-
-function barFor(input: { window: CodexWindow; thresholds: Thresholds }): number {
-  return isSessionWindow({ window: input.window }) ? input.thresholds.session : input.thresholds.weekly;
-}
-
-export function isCodexExhausted(input: { account: CodexAccount; thresholds: Thresholds; now: number }): boolean {
-  const { account, thresholds, now } = input;
-  const sampledAt = account.lastUsageAt ?? null;
-  return allWindows(account).some(
-    (window) => liveUsed({ window, now, sampledAt }) >= barFor({ window, thresholds }),
-  );
-}
-
-export function codexPacePressure(input: { account: CodexAccount; now: number }): number {
-  const { account, now } = input;
-  const weekly = account.lastUsage ? weeklyWindowOf({ aggregate: account.lastUsage.aggregate }) : null;
-  if (!weekly) return 0;
-  const reset = nextWeeklyReset(weekly.resetsAt, now);
-  if (reset == null) return 0;
-  return Math.max(0, 100 - liveUsed({ window: weekly, now, sampledAt: account.lastUsageAt ?? null })) / Math.max(1, reset - now);
-}
-
-function weeklyExpiryOf(input: { account: CodexAccount; now: number }): number {
-  const { account, now } = input;
-  const weekly = account.lastUsage ? weeklyWindowOf({ aggregate: account.lastUsage.aggregate }) : null;
-  return nextWeeklyReset(weekly?.resetsAt ?? null, now) ?? Number.POSITIVE_INFINITY;
-}
-
-const codexSwapPreference = (now: number) => [
-  (account: CodexAccount) => -codexPacePressure({ account, now }),
-  (account: CodexAccount) => weeklyExpiryOf({ account, now }),
-];
-
-export function pickBestCodex(input: {
-  accounts: CodexAccount[];
-  thresholds: Thresholds;
-  now: number;
-  currentAccountId: string | null;
-}): CodexAccount | null {
-  const { accounts, thresholds, now, currentAccountId } = input;
-  const usable = accounts.filter(
-    (account) =>
-      account.accountId !== currentAccountId &&
-      account.needsReauth !== true &&
-      !isCodexExhausted({ account, thresholds, now }),
-  );
-  return sortBy(usable, codexSwapPreference(now))[0] ?? null;
-}
-
-export const CODEX_SWAP_IMPROVEMENT = 1.2;
-
-export function codexCurrentWins(input: {
-  active: CodexAccount | null;
-  accounts: CodexAccount[];
-  thresholds: Thresholds;
-  now: number;
-}): boolean {
-  const { active, accounts, thresholds, now } = input;
-  if (!active || active.needsReauth === true || isCodexExhausted({ account: active, thresholds, now })) return false;
-  const best = pickBestCodex({ accounts, thresholds, now, currentAccountId: null });
-  if (best == null || best.accountId === active.accountId) return true;
-  return codexPacePressure({ account: best, now }) <= codexPacePressure({ account: active, now }) * CODEX_SWAP_IMPROVEMENT;
-}

package/src/lib/codexsample.ts

@@ -1,48 +0,0 @@
-import { codexIdentityOf, isCodexAccessExpiring, readLiveCodexAuth, readParkedCodexAuth, writeLiveCodexAuth, writeParkedCodexAuth } from "./codexauth.ts";
-import { CodexInvalidGrantError, CodexRefreshFailedError, refreshCodexAuth } from "./codexoauth.ts";
-import { CodexUsageReadError, fetchCodexUsage } from "./codexusage.ts";
-import { presentCodexAccountIds } from "./codexpresence.ts";
-import type { CodexAccount, CodexUsage } from "./types.ts";
-import { z } from "zod";
-
-const CodexSampleOutcomeSchema = z.union([
-  z.object({ ok: z.literal(true), usage: z.custom<CodexUsage>() }),
-  z.object({ ok: z.literal(false), reason: z.string(), deadGrant: z.boolean() }),
-]);
-export type CodexSampleOutcome = z.infer<typeof CodexSampleOutcomeSchema>;
-
-export function liveCodexAccountId(): string | null {
-  const live = readLiveCodexAuth();
-  if (!live) return null;
-  return codexIdentityOf({ auth: live }).accountId;
-}
-
-export async function sampleCodexAccount(input: { account: CodexAccount; liveAccountId: string | null; now?: number }): Promise<CodexSampleOutcome> {
-  const { account, liveAccountId, now = Date.now() } = input;
-  const isLive = liveAccountId != null && account.accountId === liveAccountId;
-  try {
-    let auth = isLive ? readLiveCodexAuth() : readParkedCodexAuth({ credFile: account.credFile });
-    if (!auth) return { ok: false, reason: isLive ? "live auth.json vanished" : "no parked credential", deadGrant: false };
-    if (isCodexAccessExpiring({ auth, now })) {
-      const running = presentCodexAccountIds().has(account.accountId);
-      if (running && !isLive) {
-        return { ok: false, reason: "running in a live codex session (parked token refresh unsafe)", deadGrant: false };
-      }
-      if (!running) {
-        auth = await refreshCodexAuth({ auth, now });
-        if (isLive) writeLiveCodexAuth({ auth });
-        writeParkedCodexAuth({ credFile: account.credFile, auth });
-      }
-    }
-    const usage = await fetchCodexUsage({ auth });
-    return { ok: true, usage };
-  } catch (e) {
-    if (e instanceof CodexInvalidGrantError) {
-      return { ok: false, reason: e.message, deadGrant: true };
-    }
-    if (e instanceof CodexRefreshFailedError || e instanceof CodexUsageReadError) {
-      return { ok: false, reason: e.message, deadGrant: false };
-    }
-    throw e;
-  }
-}

package/src/lib/codexstate.ts

@@ -1,22 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { writeFileAtomic } from "./atomic.ts";
-import { codexPaths } from "./paths.ts";
-import { CodexAccountsIndexSchema, LastSwapSchema, type CodexAccountsIndex } from "./types.ts";
-
-export function loadCodexAccounts(): CodexAccountsIndex {
-  if (!existsSync(codexPaths.accountsJson)) return { version: 1, activeAccountId: null, accounts: [] };
-  return CodexAccountsIndexSchema.parse(JSON.parse(readFileSync(codexPaths.accountsJson, "utf8")));
-}
-
-export function saveCodexAccounts(input: { index: CodexAccountsIndex }): void {
-  writeFileAtomic(codexPaths.accountsJson, JSON.stringify(CodexAccountsIndexSchema.parse(input.index), null, 2) + "\n");
-}
-
-export function loadCodexLastSwapAt(): number | null {
-  if (!existsSync(codexPaths.lastSwapJson)) return null;
-  return LastSwapSchema.parse(JSON.parse(readFileSync(codexPaths.lastSwapJson, "utf8"))).ts;
-}
-
-export function saveCodexLastSwapAt(input: { ts: number }): void {
-  writeFileAtomic(codexPaths.lastSwapJson, JSON.stringify(LastSwapSchema.parse({ ts: input.ts })));
-}

package/src/lib/codexswap.ts

@@ -1,70 +0,0 @@
-import { codexIdentityOf, readLiveCodexAuth, readParkedCodexAuth, writeLiveCodexAuth, writeParkedCodexAuth } from "./codexauth.ts";
-import { CodexInvalidGrantError, refreshCodexAuth } from "./codexoauth.ts";
-import { loadCodexAccounts, saveCodexAccounts, saveCodexLastSwapAt } from "./codexstate.ts";
-import { log } from "./log.ts";
-import type { CodexAccount } from "./types.ts";
-
-export async function performCodexSwap(input: { target: CodexAccount }): Promise<void> {
-  const { target } = input;
-  const index = loadCodexAccounts();
-
-  const parked = readParkedCodexAuth({ credFile: target.credFile });
-  if (!parked) throw new Error(`no parked codex credential for ${target.label}`);
-
-  const live = readLiveCodexAuth();
-  let liveOwner = null;
-  if (live) {
-    const liveIdentity = codexIdentityOf({ auth: live });
-    if (liveIdentity.accountId === target.accountId) {
-      throw new Error(
-        `${target.label} is already the live codex credential - refusing to swap an account onto itself`,
-      );
-    }
-    liveOwner = index.accounts.find((account) => account.accountId === liveIdentity.accountId) ?? null;
-    if (!liveOwner) {
-      throw new Error(
-        `live codex credential belongs to ${liveIdentity.email ?? liveIdentity.accountId.slice(0, 8)}, which is not in the pool - refusing to swap over it; import it first with \`tokenmaxxing add --codex\``,
-      );
-    }
-    if (liveOwner.accountId !== index.activeAccountId) {
-      log("codexswap.harvest_drift", {
-        labeled: index.activeAccountId?.slice(0, 8) ?? null,
-        actual: liveOwner.accountId.slice(0, 8),
-      });
-    }
-  }
-
-  let fresh;
-  try {
-    fresh = await refreshCodexAuth({ auth: parked });
-  } catch (e) {
-    if (e instanceof CodexInvalidGrantError) {
-      const entry = index.accounts.find((account) => account.accountId === target.accountId);
-      if (entry) {
-        entry.needsReauth = true;
-        saveCodexAccounts({ index });
-      }
-      log("codexswap.invalid_grant", { account: target.accountId.slice(0, 8) });
-    }
-    throw e;
-  }
-  writeParkedCodexAuth({ credFile: target.credFile, auth: fresh });
-
-  if (live && liveOwner) {
-    const liveNow = readLiveCodexAuth();
-    if (!liveNow || codexIdentityOf({ auth: liveNow }).accountId !== liveOwner.accountId) {
-      throw new Error("live codex credential changed mid-swap - refusing to harvest under a stale identity; retry");
-    }
-    writeParkedCodexAuth({ credFile: liveOwner.credFile, auth: liveNow });
-    log("codexswap.harvest", { account: liveOwner.accountId.slice(0, 8) });
-  }
-
-  writeLiveCodexAuth({ auth: fresh });
-  index.activeAccountId = target.accountId;
-  const entry = index.accounts.find((account) => account.accountId === target.accountId);
-  if (entry) entry.needsReauth = false;
-  saveCodexAccounts({ index });
-  saveCodexLastSwapAt({ ts: Date.now() });
-  log("codexswap.done", { account: target.accountId.slice(0, 8), label: target.label });
-}
-