tokenmaxxing 1.134.0 → 1.136.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.134.0",
+  "version": "1.136.0",
   "description": "Automatic Claude Code account switching: pool multiple accounts, start each session on its own account, and resume a session on a fresher account when quota fills.",
   "type": "module",
   "license": "MIT",

package/src/entries/supervisor.ts

@@ -5,7 +5,7 @@ import { maxBy, omit } from "es-toolkit";
 import { z } from "zod";
 import { claudePool, paths, storeDirFor } from "../lib/paths.ts";
 import { CLAUDE_BIN, UNMANAGED_ENV, WRAP_DEPTH_ENV, resolveRealBin, wrapDepth } from "../lib/claudebin.ts";
-import { apiKeyEnv, clearSessionCost, foldSessionCost, loadApiKeys, readApiKey, sendApiKey, usableApiKey, writeSessionCost } from "../lib/apikeys.ts";
+import { apiKeyEnv, clearSessionCost, foldCompactionCost, foldSessionCost, loadApiKeys, readApiKey, sendApiKey, usableApiKey, writeSessionCost } from "../lib/apikeys.ts";
 import { claude, pickLaunch, type LaunchTarget } from "../lib/claude.ts";
 import { compactClaudeSession } from "../lib/compact.ts";
 import { evaluateAndMaybeSwap, moveTarget } from "../lib/decide.ts";
@@ -19,7 +19,7 @@ import { saveTermios } from "../lib/tty.ts";
 import { liveSessionId, loadSessionFlags, pruneStaleSessions, saveSessionFlags, writeRespawnMarker } from "../lib/sessions.ts";
 import { loadAccounts, loadConfig, readJsonFile, releaseWaitClaim, writeUsage } from "../lib/state.ts";
 import { gatedFamilies, modelFromFlag, parseStreamLine, scrubCredEnv } from "../lib/usage.ts";
-import { CostLineSchema, JsonTextSchema, RespawnMarkerSchema, type Account, type ApiKey, type Config, type ModelInfo, type UsageWindows } from "../lib/types.ts";
+import { CostLineSchema, JsonTextSchema, RespawnMarkerSchema, type Account, type ApiKey, type Config, type ModelInfo, type SessionCost, type UsageWindows } from "../lib/types.ts";
 import { errorMessage, log } from "../lib/log.ts";
 
 const SUBCOMMANDS = new Set([
@@ -297,9 +297,10 @@ function resolveLaunch(wanted: { accountId: string | null; apiKeyId: string | nu
   return pickLaunch(now, model);
 }
 
-async function foldCost(sid: string, keyId: string | null, resumed: Set<string>): Promise<void> {
+async function foldCost(sid: string, keyId: string | null, resumed: Set<string>, compaction: SessionCost | null = null): Promise<void> {
   try {
-    await foldSessionCost(sid, keyId, resumed);
+    if (compaction) await foldCompactionCost(sid, compaction, keyId, resumed);
+    else await foldSessionCost(sid, keyId, resumed);
   } catch (e) {
     log("supervisor.cost_fold_failed", { err: errorMessage(e) });
   }
@@ -683,6 +684,7 @@ export async function runSupervisor(argv: string[]): Promise<number> {
           },
         });
         child = null;
+        await foldCost(sid, compactKey?.id ?? null, resumed, outcome.cost);
         if (terminating) {
           await releaseClaim();
           return 143;

package/src/lib/apikeys.ts

@@ -121,6 +121,12 @@ export function clearSessionCost(sid: string): void {
   rmSync(costFileFor(sid), { force: true });
 }
 
+export async function foldCompactionCost(sid: string, cost: SessionCost, keyId: string | null, resumed: Set<string>): Promise<void> {
+  if (!existsSync(claudePool.apiKeysJson)) return;
+  writeSessionCost(sid, cost);
+  await foldSessionCost(sid, keyId, new Set([...resumed, cost.sessionId]));
+}
+
 const BASELINE_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
 
 export async function foldSessionCost(sid: string, keyId: string | null, resumed: Set<string>): Promise<void> {

package/src/lib/compact.ts

@@ -4,7 +4,7 @@ import { z } from "zod";
 import pkg from "../../package.json" with { type: "json" };
 import { errorMessage, log } from "./log.ts";
 import { readLines } from "./proc.ts";
-import { JsonTextSchema } from "./types.ts";
+import { CostStateRowSchema, JsonTextSchema, type SessionCost } from "./types.ts";
 
 export type CompactOutcome = { ok: true } | { ok: false; reason: string };
 
@@ -13,7 +13,9 @@ const PIPE_GRACE_MS = 2_000;
 
 const CompactBoundarySchema = z.looseObject({ type: z.literal("system"), subtype: z.literal("compact_boundary") });
 
-export async function compactClaudeSession(input: { real: string; sid: string; transcript: string; env: Record<string, string | undefined>; keyPipe: boolean; onSpawn: (child: Subprocess) => void }): Promise<CompactOutcome> {
+export type ClaudeCompactResult = CompactOutcome & { cost: SessionCost | null };
+
+export async function compactClaudeSession(input: { real: string; sid: string; transcript: string; env: Record<string, string | undefined>; keyPipe: boolean; onSpawn: (child: Subprocess) => void }): Promise<ClaudeCompactResult> {
   const offset = statSync(input.transcript).size;
   const extra: "pipe"[] = input.keyPipe ? ["pipe"] : [];
   const p = Bun.spawn([input.real, "-p", "--resume", input.sid, "/compact"], {
@@ -26,13 +28,15 @@ export async function compactClaudeSession(input: { real: string; sid: string; t
   const reads = Promise.all([p.stdout.text(), p.stderr.text()]);
   const settled = await Promise.race([reads, p.exited.then(() => Bun.sleep(PIPE_GRACE_MS)).then(() => null)]);
   await p.exited;
-  const appended = await Bun.file(input.transcript).slice(offset).text();
-  if (appended.split("\n").some((line) => CompactBoundarySchema.safeParse(JsonTextSchema.safeParse(line).data).success)) return { ok: true };
-  if (settled === null) return { ok: false, reason: "output pipes still open after child exit (leaked descendant)" };
+  const rows = (await Bun.file(input.transcript).slice(offset).text()).split("\n").map((line) => JsonTextSchema.safeParse(line).data);
+  const cost = rows.map((row) => CostStateRowSchema.safeParse(row).data).findLast((c) => c?.sessionId === input.sid) ?? null;
+  const done = (outcome: CompactOutcome): ClaudeCompactResult => ({ ...outcome, cost });
+  if (rows.some((row) => CompactBoundarySchema.safeParse(row).success)) return done({ ok: true });
+  if (settled === null) return done({ ok: false, reason: "output pipes still open after child exit (leaked descendant)" });
   const [stdout, stderr] = settled;
-  if (p.exitCode === null) return { ok: false, reason: `killed after ${CLAUDE_COMPACT_KILL_MS / 1000}s` };
+  if (p.exitCode === null) return done({ ok: false, reason: `killed after ${CLAUDE_COMPACT_KILL_MS / 1000}s` });
   const output = (stderr.trim() || stdout.trim()).slice(0, 200);
-  return { ok: false, reason: output ? `no compact boundary (exit ${p.exitCode}): ${output}` : `no compact boundary (exit ${p.exitCode})` };
+  return done({ ok: false, reason: output ? `no compact boundary (exit ${p.exitCode}): ${output}` : `no compact boundary (exit ${p.exitCode})` });
 }
 
 export const CODEX_COMPACT_KILL_MS = 180_000;

package/src/lib/types.ts

@@ -195,12 +195,16 @@ export const SessionCostSchema = z.object({ sessionId: z.string(), usd: z.number
 export type SessionCost = z.infer<typeof SessionCostSchema>;
 
 export const CostLineSchema = z
-  .looseObject({ session_id: z.string(), total_cost_usd: z.number().optional(), cost: z.looseObject({ total_cost_usd: z.number() }).nullable().optional() })
+  .looseObject({ session_id: z.string(), num_turns: z.number().optional(), total_cost_usd: z.number().optional(), cost: z.looseObject({ total_cost_usd: z.number() }).nullable().optional() })
   .transform((line): SessionCost | null => {
     const usd = line.total_cost_usd ?? line.cost?.total_cost_usd;
-    return usd == null ? null : { sessionId: line.session_id, usd };
+    return usd == null || (usd === 0 && line.num_turns === 0) ? null : { sessionId: line.session_id, usd };
   });
 
+export const CostStateRowSchema = z
+  .looseObject({ type: z.literal("cost-state"), sessionId: z.string(), totalCostUSD: z.number() })
+  .transform((row): SessionCost => ({ sessionId: row.sessionId, usd: row.totalCostUSD }));
+
 export const EpochSecondsSchema = z.number().transform((seconds) => seconds * 1000);
 
 export const InstantSchema = z.iso.datetime({ offset: true }).transform((iso) => Date.parse(iso));