claude-use 5.4.1 → 5.5.0

package/README.md

@@ -106,8 +106,8 @@ claude-use doctor [--json]
 claude-use headroom status [--json]
 claude-use codex status [--json]
 claude-use frontdoor status [--json]
-claude-use usage [--identity <name>] [--provider <name>] [--since <duration>] [--json]
-claude-use account show [<identity>] [--json]
+claude-use usage [--identity <name>] [--provider <name>] [--since <duration>] [--refresh] [--json]
+claude-use account show [<identity>] [--refresh] [--json]
 claude-use completion <bash|zsh|fish>
 claude-use shim enable [--dir <path>] [--force]
 claude-use shim disable [--dir <path>] [--force]

package/dist/cli.cjs

@@ -273458,7 +273458,7 @@ function resolveLaunchIdentity(paths, cwd) {
 // package.json
 var package_default = {
   name: "claude-use",
-  version: "5.4.1",
+  version: "5.5.0",
   description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   license: "Apache-2.0",
   author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -277476,6 +277476,29 @@ var LimitEventSchema = LimitClassificationSchema.extend({
   observedAt: InstantSchema,
   status: external_exports.number().int()
 });
+var ProviderQuotaWindowSchema = external_exports.strictObject({
+  /** What the window measures, in the provider's terms (`tokens`, `tool-calls`). */
+  measures: external_exports.string(),
+  /** The window's length in milliseconds, when the provider's unit is one this project knows; absent for an unrecognised unit, with `period` carrying the raw code. */
+  periodMs: external_exports.number().int().positive().optional(),
+  /** The provider's own description of the period when `periodMs` could not be derived, such as `unit 4 x 1`. */
+  period: external_exports.string().optional(),
+  /** The fraction of the window used (0 to 1). */
+  utilization: external_exports.number().nonnegative(),
+  resetsAt: InstantSchema.optional(),
+  /** Absolute counts, when the provider reports them for this window. */
+  limit: external_exports.number().nonnegative().optional(),
+  used: external_exports.number().nonnegative().optional(),
+  remaining: external_exports.number().nonnegative().optional()
+});
+var ProviderQuotaSchema = external_exports.strictObject({
+  observedAt: InstantSchema,
+  /** Which usage endpoint produced it (`z.ai`). */
+  source: external_exports.string(),
+  /** The subscription level the endpoint reports, when it does. */
+  level: external_exports.string().optional(),
+  windows: external_exports.array(ProviderQuotaWindowSchema)
+});
 var ProviderUsageStateSchema = external_exports.strictObject({
   lastRequestAt: InstantSchema,
   lastStatus: external_exports.number().int(),
@@ -277483,7 +277506,9 @@ var ProviderUsageStateSchema = external_exports.strictObject({
   /** The latest rate-limit state, from the last response that carried any rate-limit header. */
   rateLimit: RateLimitStateSchema.optional(),
   /** The latest classified refusal. It stays after later successes, so a reader compares its `resetAt` (or `observedAt` plus `retryAfterSeconds`) with the current time. */
-  lastLimit: LimitEventSchema.optional()
+  lastLimit: LimitEventSchema.optional(),
+  /** The latest quota the provider's usage endpoint reported, for providers whose quota is not visible in response headers. */
+  quota: ProviderQuotaSchema.optional()
 });
 var AccountMetadataSchema = external_exports.strictObject({
   accountUuid: external_exports.string().optional(),
@@ -278095,8 +278120,264 @@ function createUsageMiddleware(deps) {
   };
 }
 
-// src/usage/store.ts
-var import_node_path27 = __toESM(require("node:path"), 1);
+// src/usage/providerQuota.ts
+var ProviderQuotaError = class extends Error {
+  constructor(source, detail) {
+    super(`${source} usage endpoint: ${detail}`);
+    this.name = "ProviderQuotaError";
+  }
+};
+var MS_PER_SECOND4 = 1e3;
+var SECONDS_PER_HOUR = 3600;
+var HOURS_PER_DAY = 24;
+var DAYS_PER_MONTH = 30;
+var PERCENT = 100;
+var HTTP_OK = 200;
+var ZAI_SOURCE = "z.ai";
+var ZAI_HOST = "api.z.ai";
+var ZAI_QUOTA_URL = `https://${ZAI_HOST}/api/monitor/usage/quota/limit`;
+var ZAI_UNIT_HOURS = 3;
+var ZAI_UNIT_MONTHS = 5;
+var ZAI_UNIT_MS = /* @__PURE__ */ new Map([
+  [ZAI_UNIT_HOURS, SECONDS_PER_HOUR * MS_PER_SECOND4],
+  [ZAI_UNIT_MONTHS, DAYS_PER_MONTH * HOURS_PER_DAY * SECONDS_PER_HOUR * MS_PER_SECOND4]
+]);
+var ZAI_MEASURES = { TOKENS_LIMIT: "tokens", TIME_LIMIT: "tool-calls" };
+var ZaiLimitSchema = external_exports.object({
+  type: external_exports.string(),
+  unit: external_exports.number().int(),
+  number: external_exports.number().int().positive(),
+  percentage: external_exports.number().nonnegative(),
+  nextResetTime: external_exports.number().positive().optional(),
+  usage: external_exports.number().nonnegative().optional(),
+  currentValue: external_exports.number().nonnegative().optional(),
+  remaining: external_exports.number().nonnegative().optional()
+});
+var ZaiResponseSchema = external_exports.object({
+  success: external_exports.boolean(),
+  msg: external_exports.string().optional(),
+  data: external_exports.object({ level: external_exports.string().optional(), limits: external_exports.array(ZaiLimitSchema) })
+});
+function zaiWindow(limit) {
+  const unitMs = ZAI_UNIT_MS.get(limit.unit);
+  return {
+    measures: ZAI_MEASURES[limit.type] ?? limit.type.toLowerCase(),
+    ...unitMs === void 0 ? { period: `unit ${String(limit.unit)} x ${String(limit.number)}` } : { periodMs: unitMs * limit.number },
+    utilization: limit.percentage / PERCENT,
+    ...limit.nextResetTime === void 0 ? {} : { resetsAt: new Date(limit.nextResetTime).toISOString() },
+    ...limit.usage === void 0 ? {} : { limit: limit.usage },
+    ...limit.currentValue === void 0 ? {} : { used: limit.currentValue },
+    ...limit.remaining === void 0 ? {} : { remaining: limit.remaining }
+  };
+}
+var zaiQuotaAdapter = {
+  source: ZAI_SOURCE,
+  matches: (baseUrl) => URL.canParse(baseUrl) && new URL(baseUrl).hostname === ZAI_HOST,
+  fetch: async (apiKey, http5, signal, nowMs) => {
+    const response = await http5(ZAI_QUOTA_URL, { authorization: apiKey, accept: "application/json" }, signal);
+    if (response.status !== HTTP_OK) {
+      throw new ProviderQuotaError(ZAI_SOURCE, `answered HTTP ${String(response.status)}`);
+    }
+    let body;
+    try {
+      body = JSON.parse(response.text);
+    } catch {
+      throw new ProviderQuotaError(ZAI_SOURCE, "answered something that is not JSON");
+    }
+    const parsed = ZaiResponseSchema.safeParse(body);
+    if (!parsed.success) {
+      throw new ProviderQuotaError(ZAI_SOURCE, `answered an unexpected shape: ${parsed.error.issues.map((issue2) => `${issue2.path.join(".")}: ${issue2.message}`).join("; ")}`);
+    }
+    if (!parsed.data.success) {
+      throw new ProviderQuotaError(ZAI_SOURCE, `reported failure${parsed.data.msg === void 0 ? "" : `: ${parsed.data.msg}`}`);
+    }
+    return ProviderQuotaSchema.parse({
+      observedAt: new Date(nowMs).toISOString(),
+      source: ZAI_SOURCE,
+      ...parsed.data.data.level === void 0 ? {} : { level: parsed.data.data.level },
+      windows: parsed.data.data.limits.map(zaiWindow)
+    });
+  }
+};
+var OPENROUTER_SOURCE = "OpenRouter";
+var OPENROUTER_HOST = "openrouter.ai";
+var OPENROUTER_KEY_URL = `https://${OPENROUTER_HOST}/api/v1/key`;
+var OPENROUTER_CREDITS_URL = `https://${OPENROUTER_HOST}/api/v1/credits`;
+var HTTP_FORBIDDEN = 403;
+var MS_PER_DAY2 = HOURS_PER_DAY * SECONDS_PER_HOUR * MS_PER_SECOND4;
+var OpenRouterKeySchema = external_exports.object({
+  data: external_exports.object({
+    limit: external_exports.number().nonnegative().nullable(),
+    limit_remaining: external_exports.number().nullable(),
+    limit_reset: external_exports.string().nullable(),
+    is_free_tier: external_exports.boolean().optional(),
+    free_model_daily_requests: external_exports.object({ used: external_exports.number().nonnegative(), limit: external_exports.number().nonnegative(), remaining: external_exports.number() }).optional()
+  })
+});
+var OpenRouterCreditsSchema = external_exports.object({ data: external_exports.object({ total_credits: external_exports.number().nonnegative(), total_usage: external_exports.number().nonnegative() }) });
+async function openRouterGet(url2, schema, apiKey, http5, signal) {
+  const response = await http5(url2, { authorization: `Bearer ${apiKey}`, accept: "application/json" }, signal);
+  if (response.status === HTTP_FORBIDDEN) {
+    return "forbidden";
+  }
+  if (response.status !== HTTP_OK) {
+    throw new ProviderQuotaError(OPENROUTER_SOURCE, `${new URL(url2).pathname} answered HTTP ${String(response.status)}`);
+  }
+  let body;
+  try {
+    body = JSON.parse(response.text);
+  } catch {
+    throw new ProviderQuotaError(OPENROUTER_SOURCE, `${new URL(url2).pathname} answered something that is not JSON`);
+  }
+  const parsed = schema.safeParse(body);
+  if (!parsed.success) {
+    throw new ProviderQuotaError(OPENROUTER_SOURCE, `${new URL(url2).pathname} answered an unexpected shape: ${parsed.error.issues.map((issue2) => `${issue2.path.join(".")}: ${issue2.message}`).join("; ")}`);
+  }
+  return parsed.data;
+}
+function nextUtcMidnight(nowMs) {
+  return new Date((Math.floor(nowMs / MS_PER_DAY2) + 1) * MS_PER_DAY2).toISOString();
+}
+var openRouterQuotaAdapter = {
+  source: OPENROUTER_SOURCE,
+  matches: (baseUrl) => URL.canParse(baseUrl) && new URL(baseUrl).hostname === OPENROUTER_HOST,
+  fetch: async (apiKey, http5, signal, nowMs) => {
+    const key = await openRouterGet(OPENROUTER_KEY_URL, OpenRouterKeySchema, apiKey, http5, signal);
+    if (key === "forbidden") {
+      throw new ProviderQuotaError(OPENROUTER_SOURCE, "/api/v1/key refused the key (HTTP 403)");
+    }
+    const credits = await openRouterGet(OPENROUTER_CREDITS_URL, OpenRouterCreditsSchema, apiKey, http5, signal);
+    const { limit, limit_remaining: limitRemaining, limit_reset: limitReset, free_model_daily_requests: free, is_free_tier: isFreeTier } = key.data;
+    const windows = [];
+    if (limit !== null && limit > 0) {
+      const remaining = Math.max(limitRemaining ?? limit, 0);
+      windows.push({ measures: "key-credits", period: limitReset ?? "no reset", utilization: (limit - remaining) / limit, limit, used: limit - remaining, remaining });
+    }
+    if (credits !== "forbidden" && credits.data.total_credits > 0) {
+      const { total_credits: total, total_usage: used } = credits.data;
+      windows.push({ measures: "account-credits", period: "prepaid", utilization: used / total, limit: total, used, remaining: Math.max(total - used, 0) });
+    }
+    if (free !== void 0 && free.limit > 0) {
+      windows.push({ measures: "free-model-requests", periodMs: MS_PER_DAY2, utilization: free.used / free.limit, resetsAt: nextUtcMidnight(nowMs), limit: free.limit, used: free.used, remaining: Math.max(free.remaining, 0) });
+    }
+    return ProviderQuotaSchema.parse({
+      observedAt: new Date(nowMs).toISOString(),
+      source: OPENROUTER_SOURCE,
+      ...isFreeTier === true ? { level: "free" } : {},
+      windows
+    });
+  }
+};
+var PROVIDER_QUOTA_ADAPTERS = [zaiQuotaAdapter, openRouterQuotaAdapter];
+function adapterFor(baseUrl) {
+  return PROVIDER_QUOTA_ADAPTERS.find((adapter) => adapter.matches(baseUrl));
+}
+function quotaFreshnessMs(quota) {
+  const lengths = quota.windows.flatMap((window) => window.periodMs === void 0 ? [] : [window.periodMs]);
+  return lengths.length === 0 ? Number.POSITIVE_INFINITY : Math.min(...lengths) / PERCENT;
+}
+
+// src/usage/quotaRefresh.ts
+var QUOTA_REQUEST_TIMEOUT_MS = 1e4;
+function describeError2(error62) {
+  return error62 instanceof Error ? error62.message : String(error62);
+}
+function createQuotaRefresher(deps) {
+  const inFlight = /* @__PURE__ */ new Map();
+  const failedAt = /* @__PURE__ */ new Map();
+  const fetchNow = async (identity, provider, lookup, adapter) => {
+    const key = `${identity}\0${provider}`;
+    try {
+      const apiKey = lookup.apiKey();
+      const quota = await adapter.fetch(apiKey, deps.http, AbortSignal.timeout(QUOTA_REQUEST_TIMEOUT_MS), deps.now());
+      if (!deps.record(identity, provider, quota)) {
+        return { status: "no-usage" };
+      }
+      failedAt.delete(key);
+      return { status: "refreshed", quota };
+    } catch (error62) {
+      failedAt.set(key, deps.now());
+      const message = describeError2(error62);
+      deps.log(`usage: quota refresh for ${identity} via ${provider} failed: ${message}`);
+      return { status: "failed", message };
+    }
+  };
+  return {
+    refresh: async (identity, provider, options = {}) => {
+      let lookup;
+      try {
+        lookup = deps.lookup(provider);
+      } catch (error62) {
+        const message = describeError2(error62);
+        deps.log(`usage: quota refresh for ${identity} via ${provider} failed: ${message}`);
+        return { status: "failed", message };
+      }
+      const adapter = lookup === void 0 ? void 0 : adapterFor(lookup.baseUrl);
+      if (lookup === void 0 || adapter === void 0) {
+        return { status: "unsupported" };
+      }
+      const key = `${identity}\0${provider}`;
+      const running = inFlight.get(key);
+      if (running !== void 0) {
+        return await running;
+      }
+      if (options.force !== true) {
+        const failed = failedAt.get(key);
+        if (failed !== void 0 && deps.now() - failed < QUOTA_REQUEST_TIMEOUT_MS) {
+          return { status: "fresh" };
+        }
+        let stored;
+        try {
+          stored = deps.readQuota(identity, provider);
+        } catch (error62) {
+          const message = describeError2(error62);
+          deps.log(`usage: quota refresh for ${identity} via ${provider} failed: ${message}`);
+          return { status: "failed", message };
+        }
+        if (stored !== void 0 && deps.now() - Date.parse(stored.observedAt) < quotaFreshnessMs(stored)) {
+          return { status: "fresh" };
+        }
+      }
+      const started = fetchNow(identity, provider, lookup, adapter).finally(() => {
+        inFlight.delete(key);
+      });
+      inFlight.set(key, started);
+      return await started;
+    }
+  };
+}
+function createProviderLookup(ports) {
+  return (name) => {
+    const definition = loadProvider(ports.providersDir, name, ports.fs);
+    if (definition === void 0 || isCodexProvider(definition)) {
+      return void 0;
+    }
+    return {
+      baseUrl: definition.baseUrl,
+      apiKey: () => {
+        const resolution = resolveCredential({ credential: definition.credential, env: ports.env, port: ports.credentials, subject: `provider ${name}` });
+        if (!resolution.ok) {
+          throw new Error(resolution.message);
+        }
+        return resolution.credential.token;
+      }
+    };
+  };
+}
+function withQuotaRefresh(record2, refresher) {
+  return (usageRecord) => {
+    record2(usageRecord);
+    if (usageRecord.identity !== void 0 && usageRecord.provider !== ANTHROPIC_PROVIDER) {
+      void refresher.refresh(usageRecord.identity, usageRecord.provider);
+    }
+  };
+}
+
+// src/usage/quotaHttp.ts
+var realQuotaHttpGet = async (url2, headers, signal) => {
+  const response = await fetch(url2, { method: "GET", headers: { ...headers }, signal });
+  return { status: response.status, text: await response.text() };
+};
 
 // src/usage/read.ts
 var import_node_path26 = __toESM(require("node:path"), 1);
@@ -278251,7 +278532,30 @@ function summariseUsage(records) {
   return summaries.sort((left, right) => (left.identity ?? "").localeCompare(right.identity ?? "") || left.provider.localeCompare(right.provider));
 }
 
+// src/usage/realQuotaRefresher.ts
+function createRealQuotaRefresher(params) {
+  const { paths, store, log } = params;
+  return createQuotaRefresher({
+    lookup: createProviderLookup({ fs: realFsPort, providersDir: paths.providersDir, env: process.env, credentials: realCredentialPort }),
+    http: realQuotaHttpGet,
+    readQuota: (identity, provider) => {
+      try {
+        return readUsageSnapshot(realFarmFs, paths.usageSnapshotsDir, identity)?.providers[provider]?.quota;
+      } catch (error62) {
+        if (error62 instanceof UsageSnapshotError) {
+          return void 0;
+        }
+        throw error62;
+      }
+    },
+    record: store.recordQuota,
+    now: () => Date.now(),
+    log
+  });
+}
+
 // src/usage/store.ts
+var import_node_path27 = __toESM(require("node:path"), 1);
 var DAY_MS2 = 864e5;
 var DAYS_IN_WEEK = 7;
 var USAGE_RETENTION_MS = DAYS_IN_WEEK * DAY_MS2;
@@ -278283,16 +278587,17 @@ function foldProviderState(current, record2) {
     lastStatus: newest ? record2.status : current.lastStatus,
     ...lastModel === void 0 ? {} : { lastModel },
     ...rateLimit === void 0 ? {} : { rateLimit },
-    ...lastLimit === void 0 ? {} : { lastLimit }
+    ...lastLimit === void 0 ? {} : { lastLimit },
+    ...current?.quota === void 0 ? {} : { quota: current.quota }
   };
 }
 function createUsageStore(deps) {
   const { fs: fs16, paths } = deps;
   let prunedDay;
-  const updateSnapshot = (record2, identity) => {
+  const rewriteSnapshot = (identity, fold) => {
     if (!isIdentityName(identity)) {
       deps.log(`usage: no snapshot for identity "${identity}", which is not a valid identity name`);
-      return;
+      return false;
     }
     let current;
     try {
@@ -278303,6 +278608,10 @@ function createUsageStore(deps) {
       }
       deps.log(`usage: replacing an unreadable snapshot: ${error62.message}`);
     }
+    const providers = fold(current);
+    if (providers === void 0) {
+      return false;
+    }
     let account;
     try {
       account = deps.readAccount(identity);
@@ -278317,11 +278626,12 @@ function createUsageStore(deps) {
       identity,
       updatedAt: new Date(deps.now()).toISOString(),
       ...account === void 0 ? {} : { account },
-      providers: { ...current?.providers, [record2.provider]: foldProviderState(current?.providers[record2.provider], record2) }
+      providers
     });
     fs16.mkdirPrivate(paths.usageSnapshotsDir);
     fs16.writeFilePrivate(snapshotPath(paths.usageSnapshotsDir, identity), `${JSON.stringify(snapshot, null, 2)}
 `);
+    return true;
   };
   return {
     record: (input2) => {
@@ -278337,9 +278647,17 @@ function createUsageStore(deps) {
       fs16.appendFilePrivate(import_node_path27.default.join(paths.usageLogDir, segmentName(day, deps.pid)), `${JSON.stringify(record2)}
 `);
       if (record2.identity !== void 0) {
-        updateSnapshot(record2, record2.identity);
+        rewriteSnapshot(record2.identity, (current) => ({ ...current?.providers, [record2.provider]: foldProviderState(current?.providers[record2.provider], record2) }));
       }
-    }
+    },
+    recordQuota: (identity, provider, quota) => rewriteSnapshot(identity, (current) => {
+      const state = current?.providers[provider];
+      if (current === void 0 || state === void 0) {
+        return void 0;
+      }
+      const keep = state.quota !== void 0 && state.quota.observedAt.localeCompare(quota.observedAt) > 0;
+      return { ...current.providers, [provider]: { ...state, quota: keep ? state.quota : quota } };
+    })
   };
 }
 
@@ -278368,8 +278686,9 @@ function realFrontDoorSupervisorPorts(paths) {
     readAccount: createAccountReader(realFarmFs, paths.identitiesDir),
     log
   });
+  const quotaRefresher = createRealQuotaRefresher({ paths, store: usageStore, log });
   const usageMiddleware = createUsageMiddleware({
-    record: usageStore.record,
+    record: withQuotaRefresh(usageStore.record, quotaRefresher),
     defer: (task) => {
       setImmediate(task);
     },
@@ -280113,12 +280432,12 @@ function collectUsageReport(fs16, paths, filters) {
     invalidLines: log.invalidLines
   };
 }
-var PERCENT = 100;
+var PERCENT2 = 100;
 function formatWindow(label, window) {
   if (window === void 0) {
     return void 0;
   }
-  const used = window.utilization === void 0 ? "usage unknown" : `${String(Math.round(window.utilization * PERCENT))}% used`;
+  const used = window.utilization === void 0 ? "usage unknown" : `${String(Math.round(window.utilization * PERCENT2))}% used`;
   return `${label} ${used}${window.resetsAt === void 0 ? "" : `, resets ${window.resetsAt}`}${window.status === void 0 ? "" : ` (${window.status})`}`;
 }
 function formatRateLimit(state) {
@@ -280136,12 +280455,37 @@ function formatLimit(limit) {
   ];
   return `last limit: ${limit.kind} (${String(limit.status)}) at ${limit.observedAt}${limit.window === void 0 ? "" : ` on the ${limit.window} window`}${wait.length === 0 ? "" : `, ${wait.join(", ")}`}`;
 }
+var MONEY_DECIMALS = 2;
+var MS_PER_HOUR = 36e5;
+var HOURS_PER_DAY2 = 24;
+function formatPeriod(window) {
+  if (window.periodMs === void 0) {
+    return window.period ?? "unknown period";
+  }
+  const hours = window.periodMs / MS_PER_HOUR;
+  return hours >= HOURS_PER_DAY2 && Number.isInteger(hours / HOURS_PER_DAY2) ? `${String(hours / HOURS_PER_DAY2)}d` : `${String(hours)}h`;
+}
+function formatCount(value) {
+  return String(Number(value.toFixed(MONEY_DECIMALS)));
+}
+function formatQuota(quota) {
+  return quota.windows.map((window, index) => {
+    const counts = window.used !== void 0 && window.limit !== void 0 ? `, ${formatCount(window.used)} of ${formatCount(window.limit)}` : "";
+    const resets = window.resetsAt === void 0 ? "" : `, resets ${window.resetsAt}`;
+    const head = index === 0 ? `quota via ${quota.source}${quota.level === void 0 ? "" : ` (${quota.level})`}, observed ${quota.observedAt}: ` : "                                           ";
+    return `  ${head}${window.measures} ${formatPeriod(window)} ${String(Math.round(window.utilization * PERCENT2))}% used${counts}${resets}`;
+  });
+}
 function snapshotLines(snapshot, provider) {
   const state = snapshot?.providers[provider];
   if (state === void 0) {
     return [];
   }
-  return [...state.rateLimit === void 0 ? [] : [`  ${formatRateLimit(state.rateLimit)}`], ...state.lastLimit === void 0 ? [] : [`  ${formatLimit(state.lastLimit)}`]];
+  return [
+    ...state.rateLimit === void 0 ? [] : [`  ${formatRateLimit(state.rateLimit)}`],
+    ...state.quota === void 0 ? [] : formatQuota(state.quota),
+    ...state.lastLimit === void 0 ? [] : [`  ${formatLimit(state.lastLimit)}`]
+  ];
 }
 function formatUsageReport(report) {
   const lines = [`usage ${report.since === void 0 ? "over the retained log" : `since ${report.since}`} (${report.logDir})`];
@@ -280214,12 +280558,42 @@ function formatAccounts(views) {
     return lines;
   });
 }
+async function refreshQuotas(paths, filters) {
+  if (filters.identity !== void 0) {
+    requireIdentity(paths, filters.identity);
+  }
+  const store = createUsageStore({
+    fs: realFarmFs,
+    paths,
+    pid: process.pid,
+    now: () => Date.now(),
+    readAccount: createAccountReader(realFarmFs, paths.identitiesDir),
+    log: (line) => {
+      console.error(line);
+    }
+  });
+  const refresher = createRealQuotaRefresher({ paths, store, log: () => void 0 });
+  const pairs = listUsageSnapshots(realFarmFs, paths.usageSnapshotsDir).filter((snapshot) => filters.identity === void 0 || snapshot.identity === filters.identity).flatMap((snapshot) => Object.keys(snapshot.providers).filter((provider) => provider !== ANTHROPIC_PROVIDER && (filters.provider === void 0 || provider === filters.provider)).map((provider) => ({ identity: snapshot.identity, provider })));
+  const warnings = [];
+  for (const { identity, provider } of pairs) {
+    const outcome = await refresher.refresh(identity, provider, { force: true });
+    if (outcome.status === "failed") {
+      warnings.push(`warning: could not refresh ${identity} via ${provider}: ${outcome.message}`);
+    }
+  }
+  return warnings;
+}
 function registerUsageCommands(program2, deps) {
   const { paths } = deps;
   withExamples(
     program2.command("usage").description(
       `Report recorded requests, token usage and the latest quota state per identity and provider, from the usage log the front door writes (the last ${String(USAGE_RETENTION_MS / DAY_MS3)} days). Read-only.`
-    ).option("--identity <name>", "Only this identity's requests and snapshot.").option("--provider <name>", "Only this provider's requests (anthropic for OAuth sessions).").option("--since <duration>", "Only requests from this long ago on: a count followed by m, h, d or w, such as 5h or 7d.", parseDurationOption).option("--json", "Print the report as JSON.").action((options) => {
+    ).option("--identity <name>", "Only this identity's requests and snapshot.").option("--provider <name>", "Only this provider's requests (anthropic for OAuth sessions).").option("--since <duration>", "Only requests from this long ago on: a count followed by m, h, d or w, such as 5h or 7d.", parseDurationOption).option("--refresh", "First fetch the quota of providers that report it through their own usage endpoint (z.ai), regardless of how fresh the stored one is.").option("--json", "Print the report as JSON.").action(async (options) => {
+      if (options.refresh === true) {
+        for (const warning of await refreshQuotas(paths, { ...options.identity === void 0 ? {} : { identity: options.identity }, ...options.provider === void 0 ? {} : { provider: options.provider } })) {
+          console.error(warning);
+        }
+      }
       const report = collectUsageReport(realFarmFs, paths, {
         ...options.identity === void 0 ? {} : { identity: options.identity },
         ...options.provider === void 0 ? {} : { provider: options.provider },
@@ -280233,13 +280607,18 @@ function registerUsageCommands(program2, deps) {
         console.log(line);
       }
     }),
-    ["claude-use usage", "claude-use usage --identity work --since 5h", "claude-use usage --provider z --json"]
+    ["claude-use usage", "claude-use usage --identity work --since 5h", "claude-use usage --provider z --refresh --json"]
   );
   const account = withExamples(program2.command("account").description("Inspect the Claude account behind each identity: plan, tier and latest quota."), [
     "claude-use account show work"
   ]);
   withExamples(
-    account.command("show [identity]").description("Show an identity's account metadata (read live from its stored login) and its latest recorded quota; every identity when none is named. Read-only.").option("--json", "Print the accounts as JSON.").action((identity, options) => {
+    account.command("show [identity]").description("Show an identity's account metadata (read live from its stored login) and its latest recorded quota; every identity when none is named. Read-only.").option("--refresh", "First fetch the quota of providers that report it through their own usage endpoint (z.ai), regardless of how fresh the stored one is.").option("--json", "Print the accounts as JSON.").action(async (identity, options) => {
+      if (options.refresh === true) {
+        for (const warning of await refreshQuotas(paths, identity === void 0 ? {} : { identity })) {
+          console.error(warning);
+        }
+      }
       const views = collectAccounts(realFarmFs, paths, identity);
       if (options.json === true) {
         printJson(identity === void 0 ? views : views[0]);
@@ -280550,18 +280929,18 @@ function spawnClaude(params) {
 }
 
 // src/usage/preflight.ts
-var MS_PER_SECOND4 = 1e3;
+var MS_PER_SECOND5 = 1e3;
 var SECONDS_PER_MINUTE = 60;
 var MINUTES_PER_HOUR = 60;
-var HOURS_PER_DAY = 24;
+var HOURS_PER_DAY3 = 24;
 var WARNING_STATUSES = /* @__PURE__ */ new Set(["allowed_warning", "rejected"]);
 function formatAge(ms) {
-  const minutes = Math.floor(ms / (MS_PER_SECOND4 * SECONDS_PER_MINUTE));
+  const minutes = Math.floor(ms / (MS_PER_SECOND5 * SECONDS_PER_MINUTE));
   if (minutes < MINUTES_PER_HOUR) {
     return `${String(Math.max(minutes, 0))}m`;
   }
   const hours = Math.floor(minutes / MINUTES_PER_HOUR);
-  return hours < HOURS_PER_DAY ? `${String(hours)}h` : `${String(Math.floor(hours / HOURS_PER_DAY))}d`;
+  return hours < HOURS_PER_DAY3 ? `${String(hours)}h` : `${String(Math.floor(hours / HOURS_PER_DAY3))}d`;
 }
 function quotaWarnings(snapshot, provider, nowMs) {
   const rateLimit = snapshot?.providers[provider]?.rateLimit;

package/dist/index.cjs

@@ -3046,6 +3046,29 @@ var LimitEventSchema = LimitClassificationSchema.extend({
   observedAt: InstantSchema,
   status: import_zod5.z.number().int()
 });
+var ProviderQuotaWindowSchema = import_zod5.z.strictObject({
+  /** What the window measures, in the provider's terms (`tokens`, `tool-calls`). */
+  measures: import_zod5.z.string(),
+  /** The window's length in milliseconds, when the provider's unit is one this project knows; absent for an unrecognised unit, with `period` carrying the raw code. */
+  periodMs: import_zod5.z.number().int().positive().optional(),
+  /** The provider's own description of the period when `periodMs` could not be derived, such as `unit 4 x 1`. */
+  period: import_zod5.z.string().optional(),
+  /** The fraction of the window used (0 to 1). */
+  utilization: import_zod5.z.number().nonnegative(),
+  resetsAt: InstantSchema.optional(),
+  /** Absolute counts, when the provider reports them for this window. */
+  limit: import_zod5.z.number().nonnegative().optional(),
+  used: import_zod5.z.number().nonnegative().optional(),
+  remaining: import_zod5.z.number().nonnegative().optional()
+});
+var ProviderQuotaSchema = import_zod5.z.strictObject({
+  observedAt: InstantSchema,
+  /** Which usage endpoint produced it (`z.ai`). */
+  source: import_zod5.z.string(),
+  /** The subscription level the endpoint reports, when it does. */
+  level: import_zod5.z.string().optional(),
+  windows: import_zod5.z.array(ProviderQuotaWindowSchema)
+});
 var ProviderUsageStateSchema = import_zod5.z.strictObject({
   lastRequestAt: InstantSchema,
   lastStatus: import_zod5.z.number().int(),
@@ -3053,7 +3076,9 @@ var ProviderUsageStateSchema = import_zod5.z.strictObject({
   /** The latest rate-limit state, from the last response that carried any rate-limit header. */
   rateLimit: RateLimitStateSchema.optional(),
   /** The latest classified refusal. It stays after later successes, so a reader compares its `resetAt` (or `observedAt` plus `retryAfterSeconds`) with the current time. */
-  lastLimit: LimitEventSchema.optional()
+  lastLimit: LimitEventSchema.optional(),
+  /** The latest quota the provider's usage endpoint reported, for providers whose quota is not visible in response headers. */
+  quota: ProviderQuotaSchema.optional()
 });
 var AccountMetadataSchema = import_zod5.z.strictObject({
   accountUuid: import_zod5.z.string().optional(),

package/dist/index.mjs

@@ -2972,6 +2972,29 @@ var LimitEventSchema = LimitClassificationSchema.extend({
   observedAt: InstantSchema,
   status: z5.number().int()
 });
+var ProviderQuotaWindowSchema = z5.strictObject({
+  /** What the window measures, in the provider's terms (`tokens`, `tool-calls`). */
+  measures: z5.string(),
+  /** The window's length in milliseconds, when the provider's unit is one this project knows; absent for an unrecognised unit, with `period` carrying the raw code. */
+  periodMs: z5.number().int().positive().optional(),
+  /** The provider's own description of the period when `periodMs` could not be derived, such as `unit 4 x 1`. */
+  period: z5.string().optional(),
+  /** The fraction of the window used (0 to 1). */
+  utilization: z5.number().nonnegative(),
+  resetsAt: InstantSchema.optional(),
+  /** Absolute counts, when the provider reports them for this window. */
+  limit: z5.number().nonnegative().optional(),
+  used: z5.number().nonnegative().optional(),
+  remaining: z5.number().nonnegative().optional()
+});
+var ProviderQuotaSchema = z5.strictObject({
+  observedAt: InstantSchema,
+  /** Which usage endpoint produced it (`z.ai`). */
+  source: z5.string(),
+  /** The subscription level the endpoint reports, when it does. */
+  level: z5.string().optional(),
+  windows: z5.array(ProviderQuotaWindowSchema)
+});
 var ProviderUsageStateSchema = z5.strictObject({
   lastRequestAt: InstantSchema,
   lastStatus: z5.number().int(),
@@ -2979,7 +3002,9 @@ var ProviderUsageStateSchema = z5.strictObject({
   /** The latest rate-limit state, from the last response that carried any rate-limit header. */
   rateLimit: RateLimitStateSchema.optional(),
   /** The latest classified refusal. It stays after later successes, so a reader compares its `resetAt` (or `observedAt` plus `retryAfterSeconds`) with the current time. */
-  lastLimit: LimitEventSchema.optional()
+  lastLimit: LimitEventSchema.optional(),
+  /** The latest quota the provider's usage endpoint reported, for providers whose quota is not visible in response headers. */
+  quota: ProviderQuotaSchema.optional()
 });
 var AccountMetadataSchema = z5.strictObject({
   accountUuid: z5.string().optional(),

package/dist/types/usage/schema.d.ts

@@ -129,6 +129,35 @@ declare const LimitEventSchema: z.ZodObject<{
     status: z.ZodNumber;
 }, z.core.$strict>;
 export type LimitEvent = z.infer<typeof LimitEventSchema>;
+/** One quota window a provider reports through its own usage endpoint (as opposed to headers on a response): how much of it is used and when it resets. */
+declare const ProviderQuotaWindowSchema: z.ZodObject<{
+    measures: z.ZodString;
+    periodMs: z.ZodOptional<z.ZodNumber>;
+    period: z.ZodOptional<z.ZodString>;
+    utilization: z.ZodNumber;
+    resetsAt: z.ZodOptional<z.ZodISODateTime>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    used: z.ZodOptional<z.ZodNumber>;
+    remaining: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type ProviderQuotaWindow = z.infer<typeof ProviderQuotaWindowSchema>;
+/** A provider's quota as its usage endpoint last reported it. Pulled, not observed on a request, so it carries its own observation time. */
+export declare const ProviderQuotaSchema: z.ZodObject<{
+    observedAt: z.ZodISODateTime;
+    source: z.ZodString;
+    level: z.ZodOptional<z.ZodString>;
+    windows: z.ZodArray<z.ZodObject<{
+        measures: z.ZodString;
+        periodMs: z.ZodOptional<z.ZodNumber>;
+        period: z.ZodOptional<z.ZodString>;
+        utilization: z.ZodNumber;
+        resetsAt: z.ZodOptional<z.ZodISODateTime>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        used: z.ZodOptional<z.ZodNumber>;
+        remaining: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ProviderQuota = z.infer<typeof ProviderQuotaSchema>;
 /** One provider's latest state under one identity. */
 declare const ProviderUsageStateSchema: z.ZodObject<{
     lastRequestAt: z.ZodISODateTime;
@@ -166,6 +195,21 @@ declare const ProviderUsageStateSchema: z.ZodObject<{
         observedAt: z.ZodISODateTime;
         status: z.ZodNumber;
     }, z.core.$strict>>;
+    quota: z.ZodOptional<z.ZodObject<{
+        observedAt: z.ZodISODateTime;
+        source: z.ZodString;
+        level: z.ZodOptional<z.ZodString>;
+        windows: z.ZodArray<z.ZodObject<{
+            measures: z.ZodString;
+            periodMs: z.ZodOptional<z.ZodNumber>;
+            period: z.ZodOptional<z.ZodString>;
+            utilization: z.ZodNumber;
+            resetsAt: z.ZodOptional<z.ZodISODateTime>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            used: z.ZodOptional<z.ZodNumber>;
+            remaining: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type ProviderUsageState = z.infer<typeof ProviderUsageStateSchema>;
 /**
@@ -249,6 +293,21 @@ export declare const UsageSnapshotSchema: z.ZodObject<{
             observedAt: z.ZodISODateTime;
             status: z.ZodNumber;
         }, z.core.$strict>>;
+        quota: z.ZodOptional<z.ZodObject<{
+            observedAt: z.ZodISODateTime;
+            source: z.ZodString;
+            level: z.ZodOptional<z.ZodString>;
+            windows: z.ZodArray<z.ZodObject<{
+                measures: z.ZodString;
+                periodMs: z.ZodOptional<z.ZodNumber>;
+                period: z.ZodOptional<z.ZodString>;
+                utilization: z.ZodNumber;
+                resetsAt: z.ZodOptional<z.ZodISODateTime>;
+                limit: z.ZodOptional<z.ZodNumber>;
+                used: z.ZodOptional<z.ZodNumber>;
+                remaining: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type UsageSnapshot = z.infer<typeof UsageSnapshotSchema>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-use",
-  "version": "5.4.1",
+  "version": "5.5.0",
   "description": "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   "license": "Apache-2.0",
   "author": "Joseph Mearman <joseph@mearman.co.uk>",