tokenmaxxing 1.20.0 → 1.23.0

package/src/entries/mcp.ts

@@ -1,277 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { cmdLs } from "../cli/ls.ts";
-import { cmdStatus } from "../cli/status.ts";
-import { cmdDoctor } from "../cli/doctor.ts";
-import { cmdConfig } from "../cli/config.ts";
-import { cmdSwitch } from "../cli/switch.ts";
-import { cmdCodexSwitch } from "../cli/codexswitch.ts";
-import { cmdCheck } from "../cli/check.ts";
-
-const MUTATIONS_ENV = "TOKENMAXXING_AGENT_MUTATIONS";
-const PACKAGE_ROOT = join(import.meta.dir, "../..");
-
-function packageVersion(): string {
-  try {
-    const raw = JSON.parse(readFileSync(join(PACKAGE_ROOT, "package.json"), "utf8")) as { version?: string };
-    return raw.version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-
-export function refuseAmbientStoreEnv(): string | null {
-  const nonEmpty = (v: string | undefined) => (v != null && v !== "" ? v : null);
-  return nonEmpty(process.env.CLAUDE_SECURESTORAGE_CONFIG_DIR) ?? nonEmpty(process.env.CLAUDE_CONFIG_DIR);
-}
-
-export function scrubSecrets(text: string): string {
-  return text
-    .replace(/\b(Bearer\s+)[A-Za-z0-9._\-+/=]+/gi, "$1[redacted]")
-    .replace(/\b(sk-ant-[A-Za-z0-9_-]+)\b/g, "[redacted]")
-    .replace(/\b(accessToken|refreshToken|claudeAiOauth)\b\s*[:=]\s*["']?[^"'}\s,]+/gi, "$1=[redacted]");
-}
-
-type CaptureResult = { code: number; stdout: string; stderr: string };
-
-let captureChain: Promise<unknown> = Promise.resolve();
-
-export async function captureCli(run: () => number | Promise<number>): Promise<CaptureResult> {
-  const job = async (): Promise<CaptureResult> => {
-    const out: string[] = [];
-    const err: string[] = [];
-    const joinArgs = (args: unknown[]) => args.map((a) => (typeof a === "string" ? a : String(a))).join(" ");
-    const log = console.log;
-    const error = console.error;
-    console.log = (...args: unknown[]) => { out.push(joinArgs(args)); };
-    console.error = (...args: unknown[]) => { err.push(joinArgs(args)); };
-    try {
-      const code = await run();
-      return { code, stdout: out.join("\n"), stderr: err.join("\n") };
-    } finally {
-      console.log = log;
-      console.error = error;
-    }
-  };
-  const next = captureChain.then(job, job);
-  captureChain = next.then(
-    () => undefined,
-    () => undefined,
-  );
-  return next;
-}
-
-function textResult(input: { text: string; isError?: boolean }) {
-  return {
-    content: [{ type: "text" as const, text: scrubSecrets(input.text) }],
-    ...(input.isError ? { isError: true } : {}),
-  };
-}
-
-function formatCapture(cap: CaptureResult): string {
-  const parts: string[] = [];
-  if (cap.stdout) parts.push(cap.stdout);
-  if (cap.stderr) parts.push(cap.stderr);
-  parts.push(`exit ${cap.code}`);
-  return parts.join("\n").trimEnd();
-}
-
-export function mutationsEnabled(): boolean {
-  return process.env[MUTATIONS_ENV] === "1";
-}
-
-function mutationDenied(confirm: boolean): string | null {
-  if (!confirm) {
-    return `Mutating tools require confirm=true. Also set ${MUTATIONS_ENV}=1 in the MCP server environment after the user approves.`;
-  }
-  if (!mutationsEnabled()) {
-    return `Mutations are disabled. Set ${MUTATIONS_ENV}=1 in the MCP server environment only after the user explicitly approves a pool mutation.`;
-  }
-  return null;
-}
-
-const HELP_TEXT = `tokenmaxxing agent MCP
-
-Read tools (always available):
-  pool_ls       list pooled Claude and Codex accounts (labels/status only)
-  pool_status   sample usage bars (free /usage path; never --ping)
-  doctor        verify install health (labels/status only)
-  config_get    read effective config, or one key when provided
-  help          this catalog
-
-Mutating tools (confirm=true AND ${MUTATIONS_ENV}=1):
-  pool_switch   Claude greedy/forced switch, or Codex when codex=true
-  pool_check    one evaluate-and-maybe-swap pass
-  config_set    write a config.json override
-  config_unset  remove a config.json override
-
-Hard deny (no tools):
-  status --ping / metered pings
-  init / add / auth / rm / uninstall
-  credential blobs or token values
-  killing sessions or supervisors
-
-Prefer these tools over raw shell for pool ops. Honor TOKENMAXXING_HOME for hermetic use.
-`;
-
-export function createTokenmaxxingMcpServer(): McpServer {
-  const server = new McpServer({
-    name: "tokenmaxxing",
-    version: packageVersion(),
-  });
-
-  server.registerTool(
-    "help",
-    {
-      description: "Catalog of tokenmaxxing MCP tools and hard safety rules. Use when deciding which pool tool to call.",
-      inputSchema: {},
-    },
-    async () => textResult({ text: HELP_TEXT }),
-  );
-
-  server.registerTool(
-    "pool_ls",
-    {
-      description: "List pooled Claude and Codex accounts with active and needs-reauth flags. Labels and status only; never credential material.",
-      inputSchema: {},
-    },
-    async () => {
-      const cap = await captureCli(() => cmdLs());
-      return textResult({ text: formatCapture(cap), isError: cap.code !== 0 });
-    },
-  );
-
-  server.registerTool(
-    "pool_status",
-    {
-      description: "Show pool usage bars via the free /usage path. Never opens 5h windows. Do not request --ping; that tool does not exist.",
-      inputSchema: {},
-    },
-    async () => {
-      const cap = await captureCli(() => cmdStatus());
-      return textResult({ text: formatCapture(cap), isError: cap.code !== 0 });
-    },
-  );
-
-  server.registerTool(
-    "doctor",
-    {
-      description: "Verify supervisor, hooks, timer, and credential identity health. Reports labels and pass/fail only; never returns credential blobs.",
-      inputSchema: {},
-    },
-    async () => {
-      const cap = await captureCli(() => cmdDoctor());
-      return textResult({ text: formatCapture(cap), isError: cap.code !== 0 });
-    },
-  );
-
-  server.registerTool(
-    "config_get",
-    {
-      description: "Read effective config with sources, or one dotted key when key is set (e.g. thresholds.session).",
-      inputSchema: {
-        key: z.string().optional().describe("Optional dotted config key; omit for the full effective table"),
-      },
-    },
-    async ({ key }) => {
-      const args = key ? ["get", key] : [];
-      const cap = await captureCli(() => cmdConfig(args));
-      return textResult({ text: formatCapture(cap), isError: cap.code !== 0 });
-    },
-  );
-
-  server.registerTool(
-    "pool_switch",
-    {
-      description: "Switch the Claude pool (or Codex when codex=true). Requires confirm=true and TOKENMAXXING_AGENT_MUTATIONS=1. Hot-swaps live Claude; Codex takes effect on next start.",
-      inputSchema: {
-        confirm: z.boolean().describe("Must be true after the user approves the mutation"),
-        selector: z.string().optional().describe("Optional account selector; omit for greedy best"),
-        codex: z.boolean().optional().describe("When true, run the Codex pool switch instead"),
-      },
-    },
-    async ({ confirm, selector, codex }) => {
-      const denied = mutationDenied(confirm);
-      if (denied) return textResult({ text: denied, isError: true });
-      const cap = await captureCli(() => (codex ? cmdCodexSwitch(selector) : cmdSwitch(selector)));
-      return textResult({ text: formatCapture(cap), isError: cap.code !== 0 });
-    },
-  );
-
-  server.registerTool(
-    "pool_check",
-    {
-      description: "Run one evaluate-and-maybe-swap pass (the periodic timer path). Requires confirm=true and TOKENMAXXING_AGENT_MUTATIONS=1.",
-      inputSchema: {
-        confirm: z.boolean().describe("Must be true after the user approves the mutation"),
-      },
-    },
-    async ({ confirm }) => {
-      const denied = mutationDenied(confirm);
-      if (denied) return textResult({ text: denied, isError: true });
-      const cap = await captureCli(() => cmdCheck());
-      return textResult({ text: formatCapture(cap), isError: cap.code !== 0 });
-    },
-  );
-
-  server.registerTool(
-    "config_set",
-    {
-      description: "Write a config.json override. Requires confirm=true and TOKENMAXXING_AGENT_MUTATIONS=1.",
-      inputSchema: {
-        confirm: z.boolean().describe("Must be true after the user approves the mutation"),
-        key: z.string().describe("Dotted config key"),
-        value: z.string().describe("JSON or literal string value"),
-      },
-    },
-    async ({ confirm, key, value }) => {
-      const denied = mutationDenied(confirm);
-      if (denied) return textResult({ text: denied, isError: true });
-      const cap = await captureCli(() => cmdConfig(["set", key, value]));
-      return textResult({ text: formatCapture(cap), isError: cap.code !== 0 });
-    },
-  );
-
-  server.registerTool(
-    "config_unset",
-    {
-      description: "Remove a config.json override. Requires confirm=true and TOKENMAXXING_AGENT_MUTATIONS=1.",
-      inputSchema: {
-        confirm: z.boolean().describe("Must be true after the user approves the mutation"),
-        key: z.string().describe("Dotted config key"),
-      },
-    },
-    async ({ confirm, key }) => {
-      const denied = mutationDenied(confirm);
-      if (denied) return textResult({ text: denied, isError: true });
-      const cap = await captureCli(() => cmdConfig(["unset", key]));
-      return textResult({ text: formatCapture(cap), isError: cap.code !== 0 });
-    },
-  );
-
-  return server;
-}
-
-export async function main(): Promise<void> {
-  const ambient = refuseAmbientStoreEnv();
-  if (ambient != null) {
-    console.error(
-      `CLAUDE_CONFIG_DIR / CLAUDE_SECURESTORAGE_CONFIG_DIR is set (${ambient}): the pooled MCP surface requires the default Claude Code credential store. Unset it and retry.`,
-    );
-    process.exit(1);
-  }
-  const server = createTokenmaxxingMcpServer();
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error("tokenmaxxing MCP server running on stdio");
-}
-
-if (import.meta.main) {
-  main().catch((e) => {
-    console.error(e instanceof Error ? e.message : String(e));
-    process.exit(1);
-  });
-}

package/src/lib/bankedreset.ts

@@ -1,234 +0,0 @@
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { z } from "zod";
-import { MAX_WRAP_DEPTH, WRAP_DEPTH_ENV, resolveRealClaude } from "./claudebin.ts";
-import { withClaudeRefreshLock } from "./claudelock.ts";
-import { liveTarget, mergeIntoLive, readItem, writeItem } from "./credstore.ts";
-import { http, safeErrorDetail } from "./http.ts";
-import { log } from "./log.ts";
-import { InvalidGrantError, fetchTokenIdentity, isAccessTokenExpiring, isDeadCredential, refreshCredential } from "./oauth.ts";
-import { clearDepletedWait, clearNextCheck, loadAccounts, loadUsage, saveAccounts, saveLastResetAt, writeUsage } from "./state.ts";
-import { keepRotatedPair } from "./swap.ts";
-import { normalizeResetsAt } from "./usage.ts";
-import { CredentialBlobSchema, type Account, type BankedResetOutcome, type BankedResetRecord, type OAuthCreds } from "./types.ts";
-
-const EnvOverrideSchema = z.string().min(1).optional().catch(undefined);
-const API_BASE_URL = EnvOverrideSchema.parse(process.env.TOKENMAXXING_OAUTH_API_BASE_URL) ?? "https://api.anthropic.com";
-const OAUTH_BETA = "oauth-2025-04-20";
-const RESET_PROGRAM = "juniper_tide";
-const CLAIM_TIMEOUT_MS = 25_000;
-const VERSION_PROBE_TIMEOUT_MS = 5_000;
-const REFRESH_SKEW_MS = 300_000;
-const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
-const INELIGIBLE_TTL_MS = 24 * 60 * 60 * 1000;
-
-const ClaimResponseSchema = z.looseObject({
-  result: z.enum(["reset", "already_used", "not_limited", "ineligible", "unavailable"]).catch("unavailable"),
-  next_available_at: z.union([z.string(), z.number()]).nullable().optional().catch(null),
-});
-
-const ClaimSchema = z.object({ outcome: z.enum(["reset", "pass"]) });
-export type Claim = z.infer<typeof ClaimSchema>["outcome"];
-
-export function bankedResetBelievedAvailable(account: Account, now: number): boolean {
-  const rec = account.bankedReset;
-  if (!rec) return true;
-  if (rec.nextAvailableAt != null) return rec.nextAvailableAt <= now;
-  if (rec.outcome === "reset" || rec.outcome === "already_used") return now - rec.at >= WEEK_MS;
-  if (rec.outcome === "ineligible") return now - rec.at >= INELIGIBLE_TTL_MS;
-  return true;
-}
-
-const VersionSchema = z.string().regex(/^\d+\.\d+\.\d+\S*$/);
-const PackageJsonSchema = z.looseObject({ version: VersionSchema });
-
-function claudeVersion(): string | undefined {
-  const bin = resolveRealClaude();
-  const fromPath = VersionSchema.safeParse(bin.match(/\/versions\/(\d+\.\d+\.\d+[^/]*)$/)?.[1]);
-  if (fromPath.success) return fromPath.data;
-  try {
-    const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync(join(dirname(bin), "package.json"), "utf8")));
-    if (pkg.success) return pkg.data.version;
-  } catch {
-  }
-  try {
-    const r = Bun.spawnSync([bin, "--version"], {
-      env: { ...process.env, TOKENMAXXING_PROBE: "1", [WRAP_DEPTH_ENV]: String(MAX_WRAP_DEPTH) },
-      stdout: "pipe",
-      stderr: "pipe",
-      timeout: VERSION_PROBE_TIMEOUT_MS,
-    });
-    const spawned = VersionSchema.safeParse(r.stdout.toString("utf8").trim().match(/^(\d+\.\d+\.\d+\S*)/)?.[1]);
-    if (spawned.success) return spawned.data;
-  } catch {
-  }
-  return undefined;
-}
-
-function claudeUserAgent(): string {
-  const version = claudeVersion();
-  return version ? `claude-cli/${version} (external, cli)` : "claude-cli (external, cli)";
-}
-
-const LiveTokenSchema = z.discriminatedUnion("ok", [
-  z.object({ ok: z.literal(true), accessToken: z.string(), organizationUuid: z.string() }),
-  z.object({ ok: z.literal(false), outcome: z.enum(["auth_error", "error"]), detail: z.string() }),
-]);
-type LiveToken = z.infer<typeof LiveTokenSchema>;
-
-function liveAccessToken(raw: string | null): string | null {
-  if (raw == null) return null;
-  const parsed = CredentialBlobSchema.safeParse((() => {
-    try { return JSON.parse(raw); } catch { return null; }
-  })());
-  return parsed.success ? parsed.data.claudeAiOauth.accessToken : null;
-}
-
-async function liveTokenLocked(account: Account, lock: { compromised: () => boolean }): Promise<LiveToken> {
-  const raw = await readItem(liveTarget());
-  if (!raw) return { ok: false, outcome: "auth_error", detail: "no live credential" };
-  let creds: OAuthCreds;
-  try {
-    creds = CredentialBlobSchema.parse(JSON.parse(raw)).claudeAiOauth;
-  } catch (e) {
-    return { ok: false, outcome: "error", detail: `live credential blob unreadable (${(e instanceof Error ? e.message : String(e)).slice(0, 80)})` };
-  }
-  if (isDeadCredential(creds)) return { ok: false, outcome: "auth_error", detail: "live credential was cleared after a failed refresh" };
-  if (isAccessTokenExpiring(creds, REFRESH_SKEW_MS)) {
-    let next: OAuthCreds;
-    try {
-      next = await refreshCredential(creds);
-    } catch (e) {
-      const detail = e instanceof Error ? e.message : String(e);
-      return { ok: false, outcome: e instanceof InvalidGrantError ? "auth_error" : "error", detail };
-    }
-    if (lock.compromised()) {
-      let owner: Account | null = null;
-      try {
-        const id = await fetchTokenIdentity(next.accessToken);
-        owner = loadAccounts().accounts.find((a) => a.accountUuid === id.accountUuid) ?? null;
-      } catch {
-      }
-      const kept = await keepRotatedPair({ fresh: next, owner, fallback: account, liveOwnerUuid: account.accountUuid, expectedLiveToken: creds.accessToken, lock });
-      return { ok: false, outcome: "error", detail: `refresh lock compromised mid-refresh - the rotated token ${kept}` };
-    }
-    await writeItem(liveTarget(), mergeIntoLive(raw, next));
-    creds = next;
-  }
-  let identity;
-  try {
-    identity = await fetchTokenIdentity(creds.accessToken);
-  } catch (e) {
-    return { ok: false, outcome: "error", detail: e instanceof Error ? e.message : String(e) };
-  }
-  if (identity.accountUuid !== account.accountUuid) {
-    return { ok: false, outcome: "error", detail: `live credential belongs to account ${identity.accountUuid.slice(0, 8)}, not the seat` };
-  }
-  return { ok: true, accessToken: creds.accessToken, organizationUuid: identity.organizationUuid };
-}
-
-const PostResultSchema = z.object({
-  outcome: z.enum(["reset", "already_used", "not_limited", "ineligible", "unavailable", "rate_limited", "auth_error", "error"]),
-  nextAvailableAt: z.number().nullable(),
-  detail: z.string(),
-  ambiguous: z.boolean().optional(),
-});
-type PostResult = z.infer<typeof PostResultSchema>;
-
-async function postClaim(input: { accessToken: string; organizationUuid: string; userAgent: string }): Promise<PostResult> {
-  const url = `${API_BASE_URL}/api/organizations/${input.organizationUuid}/reset_rate_limits`;
-  let res: Response;
-  try {
-    res = await http.post(url, {
-      headers: {
-        Authorization: `Bearer ${input.accessToken}`,
-        "anthropic-beta": OAUTH_BETA,
-        "Content-Type": "application/json",
-        "User-Agent": input.userAgent,
-      },
-      body: JSON.stringify({ program: RESET_PROGRAM }),
-      timeout: CLAIM_TIMEOUT_MS,
-    });
-  } catch (e) {
-    return { outcome: "error", nextAvailableAt: null, detail: `reset endpoint unreachable: ${e instanceof Error ? e.message : String(e)}` };
-  }
-  let text: string;
-  try {
-    text = await res.text();
-  } catch (e) {
-    return { outcome: "error", nextAvailableAt: null, detail: `reset endpoint answered HTTP ${res.status} but the body could not be read: ${e instanceof Error ? e.message : String(e)}`, ambiguous: true };
-  }
-  if (!res.ok) {
-    const detail = `HTTP ${res.status}: ${safeErrorDetail({ text })}`;
-    if (res.status === 429) return { outcome: "rate_limited", nextAvailableAt: null, detail };
-    if (res.status === 401 || res.status === 403) return { outcome: "auth_error", nextAvailableAt: null, detail };
-    return { outcome: "error", nextAvailableAt: null, detail };
-  }
-  const parsed = ClaimResponseSchema.safeParse((() => {
-    try { return JSON.parse(text); } catch { return null; }
-  })());
-  if (!parsed.success) {
-    return { outcome: "error", nextAvailableAt: null, detail: `reset endpoint answered HTTP ${res.status} with an unrecognized body (${text.length} bytes, withheld)`, ambiguous: true };
-  }
-  return { outcome: parsed.data.result, nextAvailableAt: normalizeResetsAt(parsed.data.next_available_at), detail: parsed.data.result };
-}
-
-function record(accountUuid: string, rec: BankedResetRecord, reset: boolean, now: number): void {
-  const idx = loadAccounts();
-  const account = idx.accounts.find((a) => a.accountUuid === accountUuid);
-  if (!account) return;
-  account.bankedReset = rec;
-  if (reset) {
-    delete account.enforcedUntil;
-    if (account.lastUsage) {
-      account.lastUsage = { ...account.lastUsage, fiveHour: { usedPercentage: 0, resetsAt: null } };
-    }
-  }
-  saveAccounts(idx);
-  if (!reset) return;
-  const u = loadUsage();
-  if (u && u.account === accountUuid) {
-    writeUsage({ ...u, fiveHour: { usedPercentage: 0, resetsAt: null }, ts: now }, { stamp: true });
-  }
-  saveLastResetAt(now);
-  clearDepletedWait();
-  clearNextCheck();
-}
-
-export async function claimBankedReset(input: { account: Account }): Promise<Claim> {
-  const { account } = input;
-  const short = account.accountUuid.slice(0, 8);
-  let result: PostResult;
-  let moved = false;
-  try {
-    const userAgent = claudeUserAgent();
-    ({ result, moved } = await withClaudeRefreshLock(async (lock) => {
-      const token = await liveTokenLocked(account, lock);
-      if (!token.ok) return { result: { outcome: token.outcome, nextAvailableAt: null, detail: token.detail }, moved: false };
-      let posted = await postClaim({ accessToken: token.accessToken, organizationUuid: token.organizationUuid, userAgent });
-      if (posted.ambiguous) {
-        const again = await postClaim({ accessToken: token.accessToken, organizationUuid: token.organizationUuid, userAgent });
-        posted =
-          again.outcome === "already_used"
-            ? { outcome: "reset", nextAvailableAt: again.nextAvailableAt, detail: "already_used on the confirming claim, so the ambiguous claim was the reset", ambiguous: true }
-            : again;
-      }
-      return { result: posted, moved: liveAccessToken(await readItem(liveTarget())) !== token.accessToken };
-    }));
-  } catch (e) {
-    result = { outcome: "error", nextAvailableAt: null, detail: `claim aborted: ${e instanceof Error ? e.message : String(e)}` };
-  }
-  const outcome: BankedResetOutcome = result.outcome;
-  const reset = outcome === "reset";
-  const completedAt = Date.now();
-  record(account.accountUuid, { outcome, at: completedAt, nextAvailableAt: result.nextAvailableAt }, reset, completedAt);
-  log(reset ? "bankedreset.claimed" : "bankedreset.refused", {
-    account: short,
-    outcome,
-    nextAvailableAt: result.nextAvailableAt,
-    moved,
-    ambiguous: result.ambiguous === true ? true : undefined,
-    detail: reset && result.ambiguous !== true ? undefined : result.detail.slice(0, 200),
-  });
-  return reset && !moved ? "reset" : "pass";
-}

package/src/lib/codexreset.ts

@@ -1,122 +0,0 @@
-import { z } from "zod";
-import { codexIdentityOf, readLiveCodexAuth } from "./codexauth.ts";
-import { allWindows, barFor, liveUsed } from "./codexpick.ts";
-import { loadCodexAccounts, saveCodexAccounts } from "./codexstate.ts";
-import { http, safeErrorDetail } from "./http.ts";
-import { log } from "./log.ts";
-import type { CodexAccount, CodexAuthJson, CodexBankedResetOutcome, Thresholds } from "./types.ts";
-
-const EnvOverrideSchema = z.string().min(1).optional().catch(undefined);
-const CONSUME_URL =
-  EnvOverrideSchema.parse(process.env.TOKENMAXXING_CODEX_RESET_URL) ?? "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits/consume";
-const CONSUME_TIMEOUT_MS = 30_000;
-const RETRY_KEY_TTL_MS = 10 * 60_000;
-const WALL_PERCENT = 100;
-const LIMIT_REACHED = "rate_limit_reached";
-
-const VerdictSchema = z.enum(["hold", "claim", "pass"]);
-export type CodexBankedVerdict = z.infer<typeof VerdictSchema>;
-const ClaimSchema = z.enum(["reset", "pass"]);
-export type CodexBankedClaim = z.infer<typeof ClaimSchema>;
-
-export function codexBankedResetVerdict(input: { account: CodexAccount; thresholds: Thresholds; now: number; pollTtlMs: number }): CodexBankedVerdict {
-  const { account, thresholds, now, pollTtlMs } = input;
-  const usage = account.lastUsage;
-  if (!usage) return "pass";
-  const credits = usage.resetCredits ?? null;
-  if (credits == null || credits <= 0) return "pass";
-  const rec = account.bankedReset;
-  if (rec != null && rec.outcome !== "reset" && now - rec.at < pollTtlMs) return "pass";
-  const sampledAt = account.lastUsageAt ?? null;
-  const windows = allWindows(account);
-  const over = windows.some((window) => liveUsed({ window, now, sampledAt }) >= barFor({ window, thresholds }));
-  if (!over) return "pass";
-  const atWall = usage.reachedType === LIMIT_REACHED || windows.some((window) => liveUsed({ window, now, sampledAt }) >= WALL_PERCENT);
-  return atWall ? "claim" : "hold";
-}
-
-const ConsumeResponseSchema = z.looseObject({
-  code: z.enum(["reset", "nothing_to_reset", "no_credit", "already_redeemed"]),
-  windows_reset: z.number().int().nullish(),
-});
-
-const ConsumeResultSchema = z.object({ outcome: z.enum(["reset", "nothing_to_reset", "no_credit", "already_redeemed", "auth_error", "error"]), detail: z.string() });
-type ConsumeResult = z.infer<typeof ConsumeResultSchema>;
-
-export async function consumeCodexBankedReset(input: { auth: CodexAuthJson; idempotencyKey: string }): Promise<ConsumeResult> {
-  const { auth, idempotencyKey } = input;
-  const identity = codexIdentityOf({ auth });
-  let res: Response;
-  let text: string;
-  try {
-    res = await http.post(CONSUME_URL, {
-      headers: {
-        Authorization: `Bearer ${auth.tokens.access_token}`,
-        "ChatGPT-Account-Id": identity.accountId,
-        "User-Agent": "codex-cli",
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({ redeem_request_id: idempotencyKey }),
-      timeout: CONSUME_TIMEOUT_MS,
-    });
-    text = await res.text();
-  } catch (e) {
-    return { outcome: "error", detail: `reset endpoint unreachable: ${e instanceof Error ? e.message : String(e)}` };
-  }
-  if (!res.ok) {
-    const detail = `HTTP ${res.status}: ${safeErrorDetail({ text })}`;
-    if (res.status === 401 || res.status === 403) return { outcome: "auth_error", detail };
-    return { outcome: "error", detail };
-  }
-  const parsed = ConsumeResponseSchema.safeParse((() => {
-    try {
-      return JSON.parse(text);
-    } catch {
-      return null;
-    }
-  })());
-  if (!parsed.success) return { outcome: "error", detail: `reset endpoint returned an unrecognized body (${text.length} bytes, withheld)` };
-  return { outcome: parsed.data.code, detail: `${parsed.data.code} (windows reset: ${parsed.data.windows_reset ?? "unknown"})` };
-}
-
-function rememberPendingKey(accountId: string, key: string, now: number): void {
-  const index = loadCodexAccounts();
-  const entry = index.accounts.find((a) => a.accountId === accountId);
-  if (!entry) return;
-  entry.bankedReset = { outcome: "error", at: now, key };
-  saveCodexAccounts({ index });
-}
-
-export async function consumeLiveCodexBankedReset(input: { account: CodexAccount; now: number }): Promise<CodexBankedClaim> {
-  const { account, now } = input;
-  const short = account.accountId.slice(0, 8);
-  const live = readLiveCodexAuth();
-  let result: ConsumeResult;
-  let idempotencyKey: string | null = null;
-  if (!live) {
-    result = { outcome: "auth_error", detail: "live auth.json vanished" };
-  } else if (codexIdentityOf({ auth: live }).accountId !== account.accountId) {
-    result = { outcome: "error", detail: "live codex credential belongs to another account" };
-  } else {
-    const prior = account.bankedReset;
-    const retrying = prior != null && prior.outcome === "error" && prior.key != null && now - prior.at < RETRY_KEY_TTL_MS;
-    idempotencyKey = retrying ? prior.key! : crypto.randomUUID();
-    if (!retrying) rememberPendingKey(account.accountId, idempotencyKey, now);
-    result = await consumeCodexBankedReset({ auth: live, idempotencyKey });
-    if (result.outcome === "already_redeemed" && retrying) result = { outcome: "reset", detail: `${result.detail}; the retried key had already completed` };
-  }
-  const outcome: CodexBankedResetOutcome = result.outcome;
-  const reset = outcome === "reset";
-  const index = loadCodexAccounts();
-  const entry = index.accounts.find((a) => a.accountId === account.accountId);
-  if (entry) {
-    entry.bankedReset = { outcome, at: now, ...(outcome === "error" && idempotencyKey != null ? { key: idempotencyKey } : {}) };
-    if (reset) {
-      delete entry.lastUsage;
-      delete entry.lastUsageAt;
-    }
-    saveCodexAccounts({ index });
-  }
-  log(reset ? "codexreset.consumed" : "codexreset.refused", { account: short, outcome, detail: result.detail.slice(0, 200) });
-  return reset ? "reset" : "pass";
-}

package/src/sdk.ts

@@ -1,55 +0,0 @@
-import { z } from "zod";
-import { UNMANAGED_ENV, resolveRealClaude } from "./lib/claudebin.ts";
-import { evaluateAndMaybeSwap, type SwapDecision } from "./lib/decide.ts";
-import { CRED_ENV_OVERRIDES } from "./lib/usage.ts";
-import { log } from "./lib/log.ts";
-
-export { evaluateAndMaybeSwap };
-export type { SwapDecision };
-
-export async function ensureBestAccount(now = Date.now()): Promise<SwapDecision> {
-  return evaluateAndMaybeSwap(now, false);
-}
-
-export function claudeExecutablePath(): string {
-  return resolveRealClaude();
-}
-
-const AMBIENT_STORE_VARS = ["CLAUDE_SECURESTORAGE_CONFIG_DIR", "CLAUDE_CONFIG_DIR"] as const;
-
-export function pooledSpawnEnv(): Record<string, string> {
-  for (const k of AMBIENT_STORE_VARS) {
-    if (process.env[k]) {
-      throw new Error(
-        `${k} is set: the pooled SDK surface requires the default Claude Code credential store (a swap writes the live credential where ${k} points, while the spawned subprocess reads the default store). Unset it in the process running tokenmaxxing.`,
-      );
-    }
-  }
-  const env: Record<string, string> = { ...process.env, [UNMANAGED_ENV]: "1" };
-  for (const k of CRED_ENV_OVERRIDES) delete env[k];
-  return env;
-}
-
-const PooledOptionsSchema = z.object({
-  pathToClaudeCodeExecutable: z.string(),
-  env: z.record(z.string(), z.string()),
-});
-export type PooledOptions = z.infer<typeof PooledOptionsSchema>;
-
-export function pooledOptions(): PooledOptions {
-  return PooledOptionsSchema.parse({
-    pathToClaudeCodeExecutable: claudeExecutablePath(),
-    env: pooledSpawnEnv(),
-  });
-}
-
-export async function stopHookCheck(): Promise<Record<string, never>> {
-  try {
-    await evaluateAndMaybeSwap(Date.now(), false);
-  } catch (e) {
-    const err = e instanceof Error ? e.message : String(e);
-    console.error(`tokenmaxxing: switch check failed at turn boundary: ${err}`);
-    log("sdk.stop_error", { err });
-  }
-  return {};
-}