feat: show Codex and Claude usage limits

apps/server/src/provider/Drivers/ClaudeDriver.ts

@@ -17,6 +17,7 @@ import * as Cache from "effect/Cache";
 import * as Duration from "effect/Duration";
 import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
 import * as Schema from "effect/Schema";
@@ -33,6 +34,7 @@ import {
   checkClaudeProviderStatus,
   makePendingClaudeProvider,
   probeClaudeCapabilities,
+  probeClaudeUsageLimits,
 } from "../Layers/ClaudeProvider.ts";
 import { ProviderEventLoggers } from "../Layers/ProviderEventLoggers.ts";
 import { makeManagedServerProvider } from "../makeManagedServerProvider.ts";
@@ -162,12 +164,43 @@ export const ClaudeDriver: ProviderDriver<ClaudeSettings, ClaudeDriverEnv> = {
           ),
       });
       const capabilitiesCacheKey = yield* makeClaudeCapabilitiesCacheKey(effectiveConfig, cwd);
+      const usageProbeCache = yield* Cache.makeWith(
+        () =>
+          probeClaudeUsageLimits(effectiveConfig, processEnv, cwd).pipe(
+            Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
+            Effect.provideService(Path.Path, path),
+          ),
+        {
+          capacity: 2,
+          timeToLive: Exit.match({
+            onSuccess: (result) =>
+              result?.accountIdentity && result?.usageLimits
+                ? CAPABILITIES_PROBE_TTL
+                : Duration.zero,
+            onFailure: () => Duration.zero,
+          }),
+        },
+      );
 
       const checkProvider = checkClaudeProviderStatus(
         effectiveConfig,
         () => Cache.get(capabilitiesProbeCache, capabilitiesCacheKey),
         processEnv,
         cwd,
+        (accountIdentity) =>
+          Cache.get(
+            usageProbeCache,
+            `${capabilitiesCacheKey}:${accountIdentity ?? "unknown"}`,
+          ).pipe(
+            Effect.map((result) => {
+              if (!result) return undefined;
+              return result.accountIdentity &&
+                accountIdentity &&
+                result.accountIdentity !== accountIdentity
+                ? undefined
+                : result.usageLimits;
+            }),
+          ),
       ).pipe(
         Effect.map(stampIdentity),
         Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),

apps/server/src/provider/Layers/ClaudeProvider.ts

@@ -4,6 +4,7 @@ import {
   type ModelSelection,
   type ServerProviderModel,
   type ServerProviderSlashCommand,
+  type ServerProviderUsageLimits,
 } from "@t3tools/contracts";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
@@ -42,6 +43,7 @@ import {
 import { resolveClaudeSdkExecutablePath } from "../Drivers/ClaudeExecutable.ts";
 import { makeClaudeEnvironment } from "../Drivers/ClaudeHome.ts";
 import { discoverClaudeSkills } from "../Drivers/ClaudeSkills.ts";
+import { parseClaudeUsageLimitsJson } from "../providerUsageLimits.ts";
 
 const DEFAULT_CLAUDE_MODEL_CAPABILITIES: ModelCapabilities = createModelCapabilities({
   optionDescriptors: [],
@@ -571,6 +573,7 @@ function apiProviderAuthMetadata(
 // account info. The previous 8s budget expired mid-init, so the probe returned
 // `undefined` and left the provider unverified and unselectable in the picker.
 const CAPABILITIES_PROBE_TIMEOUT_MS = 25_000;
+const USAGE_PROBE_TIMEOUT_MS = 4_000;
 
 /**
  * Keep workspace-scoped command discovery intact while isolating the periodic
@@ -776,6 +779,7 @@ const runClaudeCommand = Effect.fn("runClaudeCommand")(function* (
   claudeSettings: ClaudeSettings,
   args: ReadonlyArray<string>,
   environment?: NodeJS.ProcessEnv,
+  options?: { readonly closeStdin?: boolean; readonly cwd?: string },
 ) {
   const claudeEnvironment = yield* makeClaudeEnvironment(claudeSettings, environment);
   const spawnCommand = yield* resolveSpawnCommand(claudeSettings.binaryPath, args, {
@@ -784,17 +788,94 @@ const runClaudeCommand = Effect.fn("runClaudeCommand")(function* (
   const command = ChildProcess.make(spawnCommand.command, spawnCommand.args, {
     env: claudeEnvironment,
     shell: spawnCommand.shell,
+    ...(options?.cwd ? { cwd: options.cwd } : {}),
+    ...(options?.closeStdin ? { stdin: "ignore" as const } : {}),
   });
   return yield* spawnAndCollect(claudeSettings.binaryPath, command);
 });
 
+export const probeClaudeUsageLimits = Effect.fn("probeClaudeUsageLimits")(function* (
+  claudeSettings: ClaudeSettings,
+  environment?: NodeJS.ProcessEnv,
+  cwd?: string,
+): Effect.fn.Return<
+  | {
+      readonly accountIdentity: string | undefined;
+      readonly usageLimits: ServerProviderUsageLimits | undefined;
+    }
+  | undefined,
+  never,
+  ChildProcessSpawner.ChildProcessSpawner | Path.Path
+> {
+  const checkedAt = DateTime.formatIso(yield* DateTime.now);
+  return yield* Effect.all(
+    [
+      runClaudeCommand(
+        claudeSettings,
+        [
+          "--print",
+          "/usage",
+          "--output-format",
+          "json",
+          "--permission-mode",
+          "plan",
+          "--strict-mcp-config",
+          "--mcp-config",
+          '{"mcpServers":{}}',
+        ],
+        {
+          ...(environment ?? process.env),
+          ENABLE_CLAUDEAI_MCP_SERVERS: "false",
+        },
+        { closeStdin: true, ...(cwd ? { cwd } : {}) },
+      ),
+      runClaudeCommand(claudeSettings, ["auth", "status", "--json"], environment, {
+        closeStdin: true,
+        ...(cwd ? { cwd } : {}),
+      }),
+    ],
+    { concurrency: "unbounded" },
+  ).pipe(
+    Effect.timeoutOption(USAGE_PROBE_TIMEOUT_MS),
+    Effect.map(
+      Option.map(([usageResult, authResult]) => {
+        let accountIdentity: string | undefined;
+        if (authResult.code === 0) {
+          try {
+            const decoded: unknown = JSON.parse(authResult.stdout);
+            const email =
+              typeof decoded === "object" && decoded !== null
+                ? (decoded as { email?: unknown }).email
+                : undefined;
+            accountIdentity = typeof email === "string" ? email.trim() || undefined : undefined;
+          } catch {
+            accountIdentity = undefined;
+          }
+        }
+        return {
+          accountIdentity,
+          usageLimits:
+            usageResult.code === 0
+              ? parseClaudeUsageLimitsJson(usageResult.stdout, checkedAt)
+              : undefined,
+        };
+      }),
+    ),
+    Effect.catchCause(() => Effect.succeed(Option.none())),
+    Effect.map(Option.getOrUndefined),
+  );
+});
+
 export const checkClaudeProviderStatus = Effect.fn("checkClaudeProviderStatus")(function* (
   claudeSettings: ClaudeSettings,
   resolveCapabilities?: (
     claudeSettings: ClaudeSettings,
   ) => Effect.Effect<ClaudeCapabilitiesProbe | undefined>,
   environment?: NodeJS.ProcessEnv,
   cwd?: string,
+  resolveUsage?: (
+    accountIdentity: string | undefined,
+  ) => Effect.Effect<ServerProviderUsageLimits | undefined>,
 ): Effect.fn.Return<
   ServerProviderDraft,
   never,
@@ -937,6 +1018,24 @@ export const checkClaudeProviderStatus = Effect.fn("checkClaudeProviderStatus")(
       subscriptionType: capabilities.subscriptionType,
       authMethod: capabilities.tokenSource,
     }) ?? apiProviderAuthMetadata(capabilities.apiProvider);
+  const usageLimits =
+    authMetadata?.type === "apiKey" || authMetadata?.type === "bedrock"
+      ? undefined
+      : yield* resolveUsage
+          ? resolveUsage(capabilities.email?.trim() || undefined).pipe(
+              Effect.catchCause(() => Effect.void),
+            )
+          : probeClaudeUsageLimits(claudeSettings, resolvedEnvironment, cwd).pipe(
+              Effect.map((result) => {
+                if (!result) return undefined;
+                const expectedIdentity = capabilities.email?.trim();
+                return result.accountIdentity &&
+                  expectedIdentity &&
+                  result.accountIdentity !== expectedIdentity
+                  ? undefined
+                  : result.usageLimits;
+              }),
+            );
   return buildServerProvider({
     presentation: CLAUDE_PRESENTATION,
     enabled: claudeSettings.enabled,
@@ -953,6 +1052,7 @@ export const checkClaudeProviderStatus = Effect.fn("checkClaudeProviderStatus")(
         ...(capabilities.email ? { email: capabilities.email } : {}),
         ...(authMetadata ? authMetadata : {}),
       },
+      ...(usageLimits ? { usageLimits } : {}),
       ...(versionUpgradeMessage ? { message: versionUpgradeMessage } : {}),
     },
   });

apps/server/src/provider/Layers/CodexProvider.ts

@@ -33,10 +33,12 @@ import {
   type ServerProviderDraft,
 } from "../providerSnapshot.ts";
 import { expandHomePath } from "../../pathExpansion.ts";
+import { usageLimitsFromCodexRateLimits } from "../providerUsageLimits.ts";
 import packageJson from "../../../package.json" with { type: "json" };
 const isCodexAppServerSpawnError = Schema.is(CodexErrors.CodexAppServerSpawnError);
 
 const CODEX_APP_SERVER_PROBE_FORCE_KILL_AFTER = "2 seconds" as const;
+const CODEX_RATE_LIMITS_PROBE_TIMEOUT = "2 seconds" as const;
 
 const CODEX_PRESENTATION = {
   displayName: "Codex",
@@ -45,6 +47,7 @@ const CODEX_PRESENTATION = {
 
 export interface CodexAppServerProviderSnapshot {
   readonly account: CodexSchema.V2GetAccountResponse;
+  readonly rateLimits?: CodexSchema.V2GetAccountRateLimitsResponse;
   readonly version: string | undefined;
   readonly models: ReadonlyArray<ServerProviderModel>;
   readonly skills: ReadonlyArray<ServerProviderSkill>;
@@ -395,18 +398,31 @@ const probeCodexAppServerProvider = Effect.fn("probeCodexAppServerProvider")(fun
     } satisfies CodexAppServerProviderSnapshot;
   }
 
-  const [skillsResponse, models] = yield* Effect.all(
+  const [skillsResponse, models, rateLimits] = yield* Effect.all(
     [
       client.request("skills/list", {
         cwds: [input.cwd],
       }),
       requestAllCodexModels(client),
+      accountResponse.account?.type === "chatgpt"
+        ? client
+            .request("account/rateLimits/read", undefined)
+            .pipe(
+              Effect.option,
+              Effect.timeoutOption(CODEX_RATE_LIMITS_PROBE_TIMEOUT),
+              Effect.map(Option.flatten),
+              Effect.map(Option.getOrUndefined),
+            )
+        : Effect.void.pipe(
+            Effect.as(undefined as CodexSchema.V2GetAccountRateLimitsResponse | undefined),
+          ),
     ],
     { concurrency: "unbounded" },
   );
 
   return {
     account: accountResponse,
+    ...(rateLimits ? { rateLimits } : {}),
     version,
     models: applyPreferredCodexDefaultModel(
       appendCustomCodexModels(models, input.customModels ?? []),
@@ -594,6 +610,9 @@ export const checkCodexProviderStatus = Effect.fn("checkCodexProviderStatus")(fu
 
   const snapshot = probeResult.success.value;
   const accountStatus = accountProbeStatus(snapshot.account);
+  const usageLimits = snapshot.rateLimits
+    ? usageLimitsFromCodexRateLimits(snapshot.rateLimits, checkedAt)
+    : undefined;
 
   return buildServerProvider({
     presentation: CODEX_PRESENTATION,
@@ -606,6 +625,7 @@ export const checkCodexProviderStatus = Effect.fn("checkCodexProviderStatus")(fu
       version: snapshot.version ?? null,
       status: accountStatus.status,
       auth: accountStatus.auth,
+      ...(usageLimits ? { usageLimits } : {}),
       ...(accountStatus.message ? { message: accountStatus.message } : {}),
     },
   });