tokenmaxxing 1.168.0 → 1.170.0

package/README.md

@@ -25,33 +25,6 @@ bun add -g tokenmaxxing
 tokenmaxxing init
 ```
 
-Or with Nix (same source-run-by-Bun package; `init` still owns the stores, the `claude` shim, and settings merges). Install onto PATH first, then init: `nix run ... -- init` alone leaves supervisor shims without a stable `tokenmaxxing` on PATH after the ephemeral run exits.
-
-```sh
-nix profile install github:anaclumos/tokenmaxxing
-tokenmaxxing init
-```
-
-nix-darwin:
-
-```nix
-inputs.tokenmaxxing.url = "github:anaclumos/tokenmaxxing";
-modules = [
-  inputs.tokenmaxxing.darwinModules.withOverlay
-  { programs.tokenmaxxing.enable = true; }
-];
-```
-
-Home Manager:
-
-```nix
-imports = [ inputs.tokenmaxxing.homeManagerModules.default ];
-programs.tokenmaxxing.enable = true;
-programs.tokenmaxxing.package = inputs.tokenmaxxing.packages.${pkgs.system}.default;
-```
-
-With either module, run `tokenmaxxing init` afterwards.
-
 `init` verifies and pins the real `claude` binary, opens an isolated `claude` session for your first pooled account (run `/login` there, even if you are already signed in; the login you already have stays for sessions started outside the supervisor), installs the `claude` supervisor and the `xx` entry point, five `settings.json` entries (the tokenmaxxing statusLine, a subagentStatusLine, a Stop hook, a StopFailure hook, a SessionStart hook), the periodic check timer, and the usage hub service, and adds the supervisor's bin dir to PATH in your shell rc (idempotent; it must sit ahead of the real `claude` to intercept it). Restart your shell, then add more accounts and go:
 
 ```sh
@@ -67,7 +40,7 @@ claude                  # use claude as always; each session gets its own accoun
 | `tokenmaxxing init --codex` | same for codex: log in the first account (isolated), install codex supervisor + Stop hook |
 | `tokenmaxxing init --pi` | verify and pin the real `pi` and install the `pi` supervisor, which runs pi sessions on pooled Claude and ChatGPT accounts that have a pi login |
 | `tokenmaxxing init --grok` | pool the first grok login, status-only: no supervisor, no switching |
-| `tokenmaxxing init --muse` | pool the first Muse Code login, status-only: no supervisor, no switching, no usage read |
+| `tokenmaxxing init --muse` | pool the first Muse Code login, status-only: no supervisor, no switching |
 | `tokenmaxxing add [--codex \| --grok \| --muse]` | register an additional account in that pool (isolated login, harvested once into its own store) |
 | `tokenmaxxing auth [--codex \| --grok \| --muse] [sel \| --all]` | reauthenticate a pooled account in place: bare lists the pool (emails shown) and asks which; a selector targets one account and tells you the email to sign in with; `--all` walks every account that is flagged or has no usable credential in its store, one by one |
 | `tokenmaxxing auth --pi [--codex] [sel \| --all]` | log a pooled Claude account (or a codex account with `--codex`) into pi, isolated, and keep that login as the account's pi credential after an identity check; `--all` walks every account without a pi login |
@@ -153,7 +126,7 @@ pi keeps its own credential and refreshes it itself, so each pooled account gets
 - **Keychain (macOS).** The first keychain access for a new store happens inside the interactive `init`, `add`, or `auth` run, where a prompt can be answered, not inside a headless hook.
 - **Plaintext credentials (Linux).** Claude Code itself stores Linux credentials as a 0600 plaintext file; a store follows the same model.
 - **The status-only grok pool does not switch.** grok `status` shows the weekly subscription credit window, and no grok session moves.
-- **The status-only Muse Code pool does not switch and shows no usage.** Muse Code exposes no read-only quota endpoint, so every Muse Code account stays unmeasured.
+- **The status-only Muse Code pool does not switch, and shows no usage before the first model request of a window.** Its usage read is the key mint, which reports no usage until a model request opens the 5-hour window.
 
 ## How it's built
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.168.0",
+  "version": "1.170.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",
@@ -26,8 +26,7 @@
   ],
   "scripts": {
     "dev": "bun run src/main.ts",
-    "typecheck": "tsc --noEmit",
-    "nix:bun": "bunx bun2nix@2.1.2 -o bun.nix"
+    "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
     "@types/bun": "1.3.14",

package/src/lib/install.ts

@@ -28,15 +28,6 @@ export function isBinDirAhead(bin: { name: string; key: BinKey } = CLAUDE_BIN):
 
 const envFlag = (name: string): boolean => z.stringbool().optional().parse(optionalEnv(name)) === true;
 
-export function isNixPackaged(): boolean {
-  if (envFlag("TOKENMAXXING_NIX")) return true;
-  try {
-    return realpathSync(Bun.main).startsWith("/nix/store/");
-  } catch {
-    return false;
-  }
-}
-
 function skipImperativeTimer(): boolean {
   return envFlag("TOKENMAXXING_SKIP_TIMER");
 }
@@ -45,13 +36,8 @@ function skipImperativeHub(): boolean {
   return envFlag("TOKENMAXXING_SKIP_HUB");
 }
 
-function isNixStorePath(path: string): boolean {
-  return path === "/nix/store" || path.startsWith("/nix/store/");
-}
-
 function cannotWriteRcTarget(target: string): boolean {
   if (envFlag("TOKENMAXXING_SKIP_SHELL_RC")) return true;
-  if (isNixStorePath(target)) return true;
   if (!existsSync(target)) return false;
   try {
     accessSync(target, constants.W_OK);
@@ -63,40 +49,16 @@ function cannotWriteRcTarget(target: string): boolean {
 
 export function managedShellRcSkipLines(): { headline: string; detail: string; exportLine: string } {
   return {
-    headline: "shell rc is managed (Home Manager / nix-store) - PATH was not auto-edited",
-    detail: `put ${paths.binDir} on PATH via home.sessionPath (programs.tokenmaxxing Home Manager module sets this), e.g.`,
-    exportLine: `home.sessionPath = [ "${paths.binDir}" ];`,
+    headline: "shell rc is not writable - PATH was not auto-edited",
+    detail: `put ${paths.binDir} on PATH ahead of the real claude, e.g.`,
+    exportLine: `export PATH="${paths.binDir}:$PATH"`,
   };
 }
 
-function nixSupervisorShim(bun: string, entry: string): string {
-  return `#!/bin/sh
-dir=$(CDPATH= cd -- "$(dirname "$0")" && pwd)
-old_ifs=$IFS
-IFS=:
-new_path=
-for p in $PATH; do
-  [ "$p" = "$dir" ] && continue
-  if [ -n "$new_path" ]; then new_path="$new_path:$p"; else new_path="$p"; fi
-done
-IFS=$old_ifs
-PATH=$new_path
-export PATH
-if command -v tokenmaxxing >/dev/null 2>&1; then
-  exec tokenmaxxing "$@"
-fi
-exec ${shellQuote(bun)} --no-env-file run ${shellQuote(entry)} "$@"
-`;
-}
-
 function installEntryPoints(): string {
   const target = installedBin();
   const entry = realpathSync(Bun.main);
-  if (isNixPackaged()) {
-    writeFileAtomic(target, nixSupervisorShim(process.execPath, entry), 0o755);
-  } else {
-    writeFileAtomic(target, `#!/bin/sh\nexec ${shellQuote(process.execPath)} --no-env-file run ${shellQuote(entry)} "$@"\n`, 0o755);
-  }
+  writeFileAtomic(target, `#!/bin/sh\nexec ${shellQuote(process.execPath)} --no-env-file run ${shellQuote(entry)} "$@"\n`, 0o755);
   writeFileAtomic(join(paths.binDir, "xx"), `#!/bin/sh\nexec ${shellQuote(target)} "$@"\n`, 0o755);
   return target;
 }

package/src/lib/muse.ts

@@ -1,15 +1,16 @@
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
-import { museAuthJsonFor, musePaths, musePool, museStoreDirFor } from "./paths.ts";
+import { http, safeErrorDetail } from "./http.ts";
+import { errorMessage } from "./log.ts";
+import { env, museAuthJsonFor, musePaths, musePool, museStoreDirFor } from "./paths.ts";
 import type { SampleReport } from "./provider.ts";
 import { readJsonFile, type Harvest } from "./state.ts";
 import { statusOnlyProvider, type AuthEntry } from "./statusonly.ts";
-import { ErrnoSchema, type Account } from "./types.ts";
+import { EpochSecondsSchema, ErrnoSchema, JsonTextSchema, type Account } from "./types.ts";
 import { c } from "../cli/render.ts";
 
 const MuseProviderSchema = z.looseObject({
   access_token: z.string().optional(),
-  api_key: z.string().optional(),
   user_email: z.string().nullish(),
 });
 
@@ -48,13 +49,75 @@ function readAuth(path: string): AuthEntry[] {
               writeFileAtomic(museAuthJsonFor(id), JSON.stringify({ ...file, providers: { [key]: value } }, null, 2), 0o600);
             },
           };
-    out.push({ id, usable: (parsed.data.access_token ?? "") !== "" || (parsed.data.api_key ?? "") !== "", harvest });
+    out.push({ id, usable: (parsed.data.access_token ?? "") !== "", harvest });
   }
   return out;
 }
 
-async function samplePool(accounts: Account[]): Promise<Map<string, SampleReport>> {
-  return new Map(accounts.map((a) => [a.id, { ok: false, reason: "Muse Code exposes no read-only quota endpoint" }]));
+const SubscriptionWindowSchema = z.looseObject({ used_percent: z.number(), resets_at: EpochSecondsSchema });
+
+const MintSchema = z.looseObject({
+  subs_usage: z
+    .looseObject({
+      window: SubscriptionWindowSchema.extend({ window_duration_mins: z.number() }),
+      weekly: SubscriptionWindowSchema,
+    })
+    .nullable(),
+});
+
+const WEEK_S = 7 * 86400;
+
+function usageUrl(): string {
+  return env("TOKENMAXXING_MUSE_USAGE_URL", "https://api.meta.ai/muse-code/key");
+}
+
+function storedAccessToken(id: string): string | null {
+  const file = readFile(museAuthJsonFor(id));
+  if (file == null) return null;
+  for (const value of Object.values(file.providers)) {
+    const token = MuseProviderSchema.safeParse(value).data?.access_token ?? "";
+    if (token !== "") return token;
+  }
+  return null;
+}
+
+async function readMuseUsage(account: Account, now: number): Promise<SampleReport> {
+  let token: string | null;
+  try {
+    token = storedAccessToken(account.id);
+  } catch (e) {
+    return { ok: false, reason: `this account's store is unreadable (${errorMessage(e)}) - run \`tokenmaxxing auth --muse\`` };
+  }
+  if (token == null) return { ok: false, reason: "no access_token in this account's store - run `tokenmaxxing auth --muse`" };
+  let res: Response;
+  let text: string;
+  try {
+    res = await http.post(usageUrl(), { headers: { Authorization: `Bearer ${token}` }, json: {} });
+    text = await res.text();
+  } catch (e) {
+    return { ok: false, reason: `Muse Code usage read failed: endpoint unreachable: ${errorMessage(e)}` };
+  }
+  if (res.status === 401 || res.status === 403) {
+    account.needsReauth = true;
+    return { ok: false, reason: `Muse Code rejected the stored login (HTTP ${res.status}) - run \`tokenmaxxing auth --muse\`` };
+  }
+  if (!res.ok) return { ok: false, reason: `Muse Code usage read failed: HTTP ${res.status}: ${safeErrorDetail({ text })}` };
+  const parsed = MintSchema.safeParse(JsonTextSchema.safeParse(text).data);
+  if (!parsed.success) return { ok: false, reason: "Muse Code usage read failed: endpoint returned an unexpected body shape (withheld)" };
+  if (parsed.data.subs_usage == null) return { ok: false, reason: "Muse Code reports no usage until a model request opens the 5-hour window" };
+  const { window, weekly } = parsed.data.subs_usage;
+  account.windows = [
+    { name: null, usedPercentage: window.used_percent, resetsAt: window.resets_at, windowSeconds: window.window_duration_mins * 60, sampledAt: now },
+    { name: null, usedPercentage: weekly.used_percent, resetsAt: weekly.resets_at, windowSeconds: WEEK_S, sampledAt: now },
+  ];
+  account.lastUsageAt = now;
+  return { ok: true, source: "probe" };
+}
+
+async function samplePool(accounts: Account[], now: number): Promise<Map<string, SampleReport>> {
+  const reports = new Map<string, SampleReport>();
+  await Promise.all(accounts.map(async (account) => reports.set(account.id, await readMuseUsage(account, now))));
+  return reports;
 }
 
 export const muse = statusOnlyProvider({

package/src/lib/update.ts

@@ -4,7 +4,6 @@ import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
 import { realpathOrNull } from "./claudebin.ts";
 import { http } from "./http.ts";
-import { isNixPackaged } from "./install.ts";
 import { withLock } from "./lock.ts";
 import { errorMessage, log } from "./log.ts";
 import { env, HOME, optionalEnv, paths } from "./paths.ts";
@@ -56,7 +55,6 @@ function registryPackageDir(root: string): string | null {
 }
 
 function detectGlobalRoot(): string | null {
-  if (isNixPackaged()) return null;
   const entry = realpathOrNull(Bun.main);
   if (entry == null) return null;
   return (