tokenmaxxing 1.34.0 → 1.38.0

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 });
-}
-