agent-relay-orchestrator 0.78.1 → 0.78.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.78.1",
+  "version": "0.78.3",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.54"
+    "agent-relay-sdk": "0.2.55"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/quota-poller.ts

@@ -1,5 +1,5 @@
 import { homedir } from "node:os";
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { createServer } from "node:net";
 import { join } from "node:path";
 import {
@@ -9,8 +9,10 @@ import {
   QuotaCollectionError,
   collectClaudeQuotaSample,
   collectCodexQuotaSample,
+  credentialAccountKey,
   providerQuotaErrorFromCollectorError,
   quotaRetryAfterMs,
+  readClaudeOAuthAccessToken,
   resolveStableClaudeQuotaIdentity,
   resolveStableCodexQuotaIdentityFromHome,
   type ProviderQuotaIdentity,
@@ -25,6 +27,14 @@ const QUOTA_LEASE_RENEW_MS = 30_000;
 const CODEX_APP_SERVER_CONNECT_ATTEMPTS = 40;
 const CODEX_APP_SERVER_CONNECT_RETRY_MS = 250;
 
+// A provider that is configured but has no usable quota credential on this host
+// is uncollectable by design. Rather than silently omitting it (so the row
+// vanishes from the dashboard), we report a marker record carrying the reason,
+// so the widget can show a muted "unavailable" row.
+// A stable synthetic account key keeps it out of the host:/home: unstable-key prune.
+const PROVIDER_QUOTA_UNAVAILABLE_ACCOUNT_KEY = "unavailable";
+const PROVIDER_QUOTA_UNAVAILABLE_ERROR_TYPE = "unavailable";
+
 type QuotaRelay = {
   acquireProviderQuotaLease(orchestratorId: string, input: ProviderQuotaLeaseAcquireInput): Promise<{
     acquired: boolean;
@@ -37,10 +47,14 @@ type QuotaRelay = {
 };
 
 type QuotaCandidate = ProviderQuotaIdentity & {
+  accessToken?: string;
   appServerUrl?: string;
   codexHome?: string;
 };
 
+type ProviderSkip = { provider: string; reason: string };
+type QuotaDiscovery = { candidates: QuotaCandidate[]; skips: ProviderSkip[] };
+
 type QuotaPollState = {
   leaseToken?: string;
   leaseExpiresAt?: number;
@@ -91,11 +105,14 @@ export class OrchestratorQuotaPoller {
     if (this.inFlight || !this.active || !this.relay.connected) return;
     this.inFlight = true;
     try {
-      const candidates = await this.discoverCandidates();
+      const { candidates, skips } = await this.discoverCandidates();
       await this.releaseRemovedCandidates(candidates);
       for (const candidate of candidates) {
         await this.processCandidate(candidate);
       }
+      for (const skip of skips) {
+        await this.reportSkip(skip);
+      }
     } finally {
       this.inFlight = false;
       this.schedule(this.options.intervalMs ?? QUOTA_LEASE_RENEW_MS);
@@ -112,38 +129,54 @@ export class OrchestratorQuotaPoller {
     }, Math.max(1_000, delayMs));
   }
 
-  private async discoverCandidates(): Promise<QuotaCandidate[]> {
+  private async discoverCandidates(): Promise<QuotaDiscovery> {
     const candidates: QuotaCandidate[] = [];
+    const skips: ProviderSkip[] = [];
     if (this.config.providers.includes("claude")) {
-      candidates.push(...await this.discoverClaudeCandidates());
+      const found = await this.discoverClaudeCandidates();
+      candidates.push(...found.candidates);
+      if (found.skipReason) skips.push({ provider: "claude", reason: found.skipReason });
     }
     if (this.config.providers.includes("codex")) {
-      candidates.push(...await this.discoverCodexCandidates());
+      const found = await this.discoverCodexCandidates();
+      candidates.push(...found.candidates);
+      if (found.skipReason) skips.push({ provider: "codex", reason: found.skipReason });
     }
     const deduped = new Map<string, QuotaCandidate>();
     for (const candidate of candidates) {
       deduped.set(candidateStateKey(candidate), candidate);
     }
-    return [...deduped.values()];
+    return { candidates: [...deduped.values()], skips };
   }
 
-  private async discoverClaudeCandidates(): Promise<QuotaCandidate[]> {
-    const paths = [
+  private async discoverClaudeCandidates(): Promise<{ candidates: QuotaCandidate[]; skipReason?: string }> {
+    const credentialsPaths = [
       join(this.config.env.CLAUDE_CONFIG_DIR || process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude"), ".credentials.json"),
       ...providerHomeCredentialPaths("claude", ".credentials.json"),
     ];
     const candidates: QuotaCandidate[] = [];
-    for (const credentialsPath of paths) {
+    for (const accessToken of [
+      this.config.env.CLAUDE_CODE_OAUTH_TOKEN,
+      process.env.CLAUDE_CODE_OAUTH_TOKEN,
+      ...claudeSetupTokenEnvPaths(this.config).map((path) => readEnvFileValue(path, "CLAUDE_CODE_OAUTH_TOKEN")),
+    ]) {
+      if (accessToken) candidates.push(claudeBearerCandidate(accessToken));
+    }
+    for (const credentialsPath of credentialsPaths) {
+      const accessToken = await readClaudeOAuthAccessToken(credentialsPath);
+      if (!accessToken) continue;
       const identity = await resolveStableClaudeQuotaIdentity({ credentialsPath });
-      if (identity) candidates.push(identity);
+      candidates.push({ ...(identity ?? claudeBearerCandidate(accessToken)), credentialsPath, accessToken });
     }
     if (candidates.length === 0) {
-      this.logOnce("claude:no-stable-credentials", "quota refresh skipped for claude: no materialized Claude OAuth credentials found");
+      const reason = "no usable Claude bearer token on this host";
+      this.logOnce("claude:no-usable-bearer", `quota refresh skipped for claude: ${reason}`);
+      return { candidates, skipReason: reason };
     }
-    return candidates;
+    return { candidates };
   }
 
-  private async discoverCodexCandidates(): Promise<QuotaCandidate[]> {
+  private async discoverCodexCandidates(): Promise<{ candidates: QuotaCandidate[]; skipReason?: string }> {
     const homes = [
       this.config.env.CODEX_HOME || process.env.CODEX_HOME || join(homedir(), ".codex"),
       ...providerHomeConfigDirs("codex", "auth.json"),
@@ -155,9 +188,25 @@ export class OrchestratorQuotaPoller {
       if (identity) candidates.push({ ...identity, codexHome, ...(appServerUrl ? { appServerUrl } : {}) });
     }
     if (candidates.length === 0) {
-      this.logOnce("codex:no-stable-auth", "quota refresh skipped for codex: no account id found in Codex auth.json");
+      const reason = "no Codex account id found in auth.json";
+      this.logOnce("codex:no-stable-auth", `quota refresh skipped for codex: ${reason}`);
+      return { candidates, skipReason: reason };
     }
-    return candidates;
+    return { candidates };
+  }
+
+  // Publish a marker record for a provider that is configured but uncollectable on
+  // this host, so the dashboard shows a muted "unavailable" row with the reason
+  // instead of dropping the provider entirely. Re-sent each tick to keep the row
+  // fresh (the day-old prune is keyed on updated_at).
+  private async reportSkip(skip: ProviderSkip): Promise<void> {
+    await this.relay.reportProviderQuota({
+      provider: skip.provider,
+      accountKey: PROVIDER_QUOTA_UNAVAILABLE_ACCOUNT_KEY,
+      lastAttemptAt: this.now(),
+      lastError: { type: PROVIDER_QUOTA_UNAVAILABLE_ERROR_TYPE, message: skip.reason },
+      sourceAgentId: this.sourceAgentId(),
+    }).catch((publishError) => this.log(`quota skip publish failed for ${skip.provider}: ${errMessage(publishError)}`));
   }
 
   private async releaseRemovedCandidates(candidates: QuotaCandidate[]): Promise<void> {
@@ -232,6 +281,7 @@ export class OrchestratorQuotaPoller {
     if (candidate.provider === "claude") {
       return collectClaudeQuotaSample({
         agentId: this.sourceAgentId(),
+        accessToken: candidate.accessToken,
         credentialsPath: candidate.credentialsPath,
         fetchImpl: this.options.fetchImpl,
       });
@@ -294,9 +344,10 @@ async function codexRateLimitsRead(appServerUrl: string, attempts = 1): Promise<
   try {
     await connectWithRetry(client, attempts);
     await client.request("initialize", {
-      clientInfo: { name: "agent-relay-orchestrator", title: "Agent Relay Orchestrator" },
+      clientInfo: { name: "agent-relay-orchestrator", title: "Agent Relay Orchestrator", version: "0.1.0" },
       capabilities: { experimentalApi: true },
-    }).catch(() => undefined);
+    });
+    client.notify("initialized");
     return await client.request("account/rateLimits/read");
   } finally {
     client.close();
@@ -373,6 +424,45 @@ function providerHomeCredentialPaths(provider: "claude", markerFile: string): st
   return providerHomeConfigDirs(provider, markerFile).map((dir) => join(dir, markerFile));
 }
 
+function claudeSetupTokenEnvPaths(config: OrchestratorConfig): string[] {
+  const configDir = config.env.CLAUDE_CONFIG_DIR || process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+  return [
+    join(configDir, "setup-token.env"),
+    ...providerHomeConfigDirs("claude", "setup-token.env").map((dir) => join(dir, "setup-token.env")),
+  ];
+}
+
+function claudeBearerCandidate(accessToken: string): QuotaCandidate {
+  return {
+    provider: "claude",
+    accountKey: credentialAccountKey(accessToken),
+    accessToken,
+  };
+}
+
+function readEnvFileValue(path: string, key: string): string | undefined {
+  try {
+    for (const line of readFileSync(path, "utf8").split(/\r?\n/)) {
+      const match = new RegExp(`^\\s*(?:export\\s+)?${key}\\s*=\\s*(.*)\\s*$`).exec(line);
+      if (!match) continue;
+      return cleanEnvValue(match[1] ?? "");
+    }
+  } catch {
+    return undefined;
+  }
+  return undefined;
+}
+
+function cleanEnvValue(value: string): string | undefined {
+  let cleaned = value.trim();
+  if (!cleaned) return undefined;
+  const quote = cleaned[0];
+  if ((quote === "'" || quote === "\"") && cleaned.endsWith(quote)) {
+    cleaned = cleaned.slice(1, -1);
+  }
+  return cleaned.trim() || undefined;
+}
+
 function safeReadDir(path: string): string[] {
   try {
     return readdirSync(path, { withFileTypes: true })
@@ -414,6 +504,10 @@ class JsonRpcWebSocket {
     return promise;
   }
 
+  notify(method: string, params?: unknown): void {
+    this.ws.send(JSON.stringify(params === undefined ? { method } : { method, params }));
+  }
+
   close(): void {
     this.ws?.close();
   }