remote-codex 0.11.32 → 0.11.33

package/apps/supervisor-web/dist/index.html

@@ -10,7 +10,7 @@
     <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png" />
     <link rel="manifest" href="/site.webmanifest" />
     <title>Remote Codex</title>
-    <script type="module" crossorigin src="/assets/index-CGHHTNkM.js"></script>
+    <script type="module" crossorigin src="/assets/index-DIi8wTEY.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/react-vendor-Dfg_6BLf.js">
     <link rel="modulepreload" crossorigin href="/assets/ui-vendor-CuR8GHb0.js">
     <link rel="modulepreload" crossorigin href="/assets/graph-vendor-DVQUpZ8C.js">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remote-codex",
-  "version": "0.11.32",
+  "version": "0.11.33",
   "description": "Local web supervisor for Codex workspaces and threads.",
   "license": "MIT",
   "type": "module",

package/packages/claude/src/runtimeAdapter.test.ts

@@ -15,6 +15,7 @@ interface Query extends AsyncIterable<SDKMessage> {
   interrupt(): Promise<void>;
   supportedModels(): Promise<any[]>;
   mcpServerStatus(): Promise<any[]>;
+  usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET(): Promise<any>;
 }
 
 function wait(ms = 0) {
@@ -29,7 +30,7 @@ class FakeQuery implements Query {
 
   constructor(
     private readonly messages: SDKMessage[],
-    private readonly options: { holdOpen?: boolean } = {},
+    private readonly options: { holdOpen?: boolean; usage?: Record<string, any> } = {},
   ) {}
 
   [Symbol.asyncIterator]() {
@@ -104,6 +105,12 @@ class FakeQuery implements Query {
   async getContextUsage(): Promise<any> {
     return {};
   }
+  async usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET(): Promise<any> {
+    if (!this.options.usage) {
+      throw new Error('Structured usage unavailable in this fixture.');
+    }
+    return this.options.usage;
+  }
   async readFile(): Promise<any> {
     return {};
   }
@@ -208,6 +215,55 @@ function makeAdapter(
 }
 
 describe('ClaudeRuntimeAdapter', () => {
+  it('actively reads Claude subscription windows from the structured usage API', async () => {
+    const adapter = makeAdapter(() => new FakeQuery(
+      [systemInit(), result()],
+      {
+        usage: {
+          subscription_type: 'max',
+          rate_limits_available: true,
+          rate_limits: {
+            five_hour: {
+              utilization: 23,
+              resets_at: '2027-01-15T08:00:00.000Z',
+            },
+            seven_day: {
+              utilization: 84,
+              resets_at: '2027-01-20T08:00:00.000Z',
+            },
+          },
+        },
+      },
+    ));
+
+    await adapter.start();
+    await adapter.startSession({
+      cwd: '/tmp/workspace',
+      model: 'sonnet',
+      approvalMode: 'guarded',
+      sandboxMode: 'workspace-write',
+    });
+
+    await expect(adapter.getSubscriptionUsage()).resolves.toMatchObject({
+      provider: 'claude',
+      authKind: 'subscription',
+      windows: [
+        {
+          id: 'five_hour',
+          label: '5h',
+          usedPercent: 23,
+          resetsAt: '2027-01-15T08:00:00.000Z',
+        },
+        {
+          id: 'seven_day',
+          label: '7d',
+          usedPercent: 84,
+          resetsAt: '2027-01-20T08:00:00.000Z',
+        },
+      ],
+    });
+  });
+
   it('captures Claude subscription rate-limit windows from SDK events', async () => {
     const adapter = makeAdapter(() => [
       systemInit(),

package/packages/claude/src/runtimeAdapter.ts

@@ -99,6 +99,19 @@ interface Query extends AsyncIterable<SDKMessage> {
   interrupt(): Promise<void>;
   supportedModels(): Promise<ModelInfo[]>;
   mcpServerStatus(): Promise<McpServerStatus[]>;
+  usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET?(): Promise<SDKUsageResponse>;
+}
+interface SDKUsageWindow {
+  utilization: number | null;
+  resets_at: string | null;
+}
+interface SDKUsageResponse {
+  subscription_type: string | null;
+  rate_limits_available: boolean;
+  rate_limits: {
+    five_hour?: SDKUsageWindow | null;
+    seven_day?: SDKUsageWindow | null;
+  } | null;
 }
 interface SDKMessage {
   type: string;
@@ -1239,6 +1252,7 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
     'five_hour' | 'seven_day',
     { usedPercent: number; resetsAt: string | null }
   >();
+  private subscriptionAuthKind: 'subscription' | 'apiKey' | 'unknown' = 'unknown';
   private subscriptionUsageObservedAt: string | null = null;
   private readonly clientApp: string;
   private sdkLoadError: string | null = null;
@@ -1271,7 +1285,7 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
     }));
     return {
       provider: 'claude' as const,
-      authKind: windows.length > 0 ? 'subscription' as const : 'unknown' as const,
+      authKind: this.subscriptionAuthKind,
       observedAt,
       stale: false,
       windows,
@@ -1297,9 +1311,56 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
         ? new Date(info.resetsAt * 1000).toISOString()
         : null,
     });
+    this.subscriptionAuthKind = 'subscription';
     this.subscriptionUsageObservedAt = new Date().toISOString();
   }
 
+  private async captureStructuredSubscriptionUsage(query: Query) {
+    const getUsage = query.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET;
+    if (!getUsage) {
+      return;
+    }
+
+    try {
+      const usage = await getUsage.call(query);
+      const nextWindows = new Map<
+        'five_hour' | 'seven_day',
+        { usedPercent: number; resetsAt: string | null }
+      >();
+      const addWindow = (
+        id: 'five_hour' | 'seven_day',
+        window: SDKUsageWindow | null | undefined,
+      ) => {
+        if (
+          typeof window?.utilization !== 'number'
+          || !Number.isFinite(window.utilization)
+        ) {
+          return;
+        }
+        nextWindows.set(id, {
+          usedPercent: Math.max(0, Math.min(100, window.utilization)),
+          resetsAt: typeof window.resets_at === 'string' ? window.resets_at : null,
+        });
+      };
+      addWindow('five_hour', usage.rate_limits?.five_hour);
+      addWindow('seven_day', usage.rate_limits?.seven_day);
+
+      this.subscriptionUsageWindows.clear();
+      for (const [id, window] of nextWindows) {
+        this.subscriptionUsageWindows.set(id, window);
+      }
+      this.subscriptionAuthKind = usage.subscription_type
+        ? 'subscription'
+        : usage.rate_limits_available
+          ? 'subscription'
+          : 'apiKey';
+      this.subscriptionUsageObservedAt = new Date().toISOString();
+    } catch {
+      // This SDK method is experimental. Rate-limit events remain the
+      // compatibility fallback for Claude versions that do not expose it.
+    }
+  }
+
   private updateToolboxItemsFromSystemInit(message: SDKMessage) {
     this.managementSchema.toolboxItems = buildClaudeToolboxItems(
       normalizeClaudeSlashCommands(message.slash_commands),
@@ -1463,9 +1524,14 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
     let providerSessionId: string | null = null;
     let model: string | null = input.model;
     const rawMessages: SDKMessage[] = [];
+    let capturedStructuredUsage = false;
     try {
       for await (const message of query) {
         rawMessages.push(message);
+        if (!capturedStructuredUsage) {
+          capturedStructuredUsage = true;
+          await this.captureStructuredSubscriptionUsage(query);
+        }
         this.captureRateLimit(message);
         if (message.type === 'system' && message.subtype === 'init') {
           this.updateToolboxItemsFromSystemInit(message);
@@ -1755,9 +1821,14 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
     const rawMessages: SDKMessage[] = [];
     let terminalStatus: AgentTurn['status'] | null = null;
     let terminalError: string | null = null;
+    let capturedStructuredUsage = false;
     try {
       for await (const message of state.query) {
         rawMessages.push(message);
+        if (!capturedStructuredUsage) {
+          capturedStructuredUsage = true;
+          await this.captureStructuredSubscriptionUsage(state.query);
+        }
         this.captureRateLimit(message);
         this.consumeMessage(state, message);
         const status = queryResultStatus(message);