agent-relay-runner 0.77.0 → 0.77.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.77.0",
+  "version": "0.77.1",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {

package/plugins/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-relay-runner",
   "description": "Thin Agent Relay runner bridge for Claude Code",
-  "version": "0.77.0",
+  "version": "0.77.1",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/quota.ts

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir, hostname } from "node:os";
 import { dirname, join } from "node:path";
 import type { ContextProbeMetrics, ProviderQuotaError, ProviderQuotaUpdateInput, QuotaState, QuotaWindowName } from "agent-relay-sdk";
@@ -46,6 +46,7 @@ export class RunnerQuotaPoller {
   private timer?: Timer;
   private inFlight = false;
   private active = false;
+  private activeLockDir?: string;
   private lastLog?: { key: string; at: number };
 
   constructor(private readonly options: {
@@ -74,6 +75,9 @@ export class RunnerQuotaPoller {
     this.active = false;
     if (this.timer) clearTimeout(this.timer);
     this.timer = undefined;
+    const lockDir = this.activeLockDir;
+    this.activeLockDir = undefined;
+    if (lockDir) releaseQuotaLock(lockDir);
   }
 
   clear(): void {
@@ -112,6 +116,7 @@ export class RunnerQuotaPoller {
         return;
       }
       lockDir = attempt.lockDir;
+      this.activeLockDir = lockDir;
       const sample = await collectRunnerQuotaSample({
         provider: this.options.provider,
         agentId: this.options.agentId,
@@ -147,7 +152,7 @@ export class RunnerQuotaPoller {
       const lastError = providerQuotaErrorFromCollectorError(error, retryAfterMs);
       const lastAttemptAt = Date.now();
       const retryDelayMs = retryAfterMs ?? (identity && !readSharedQuotaEntry(identity, this.options.quotaStateDir)?.lastAttemptAt ? QUOTA_FAST_RETRY_MS : QUOTA_POLL_INTERVAL_MS);
-      if (identity) {
+      if (identity && this.active) {
         await this.reportProviderQuota({
           provider: identity.provider,
           accountKey: identity.accountKey,
@@ -168,7 +173,10 @@ export class RunnerQuotaPoller {
       if (this.active) this.logFailure(error, retryAfterMs);
       this.schedule(retryDelayMs);
     } finally {
-      if (lockDir) releaseQuotaLock(lockDir);
+      if (lockDir && this.activeLockDir === lockDir) {
+        releaseQuotaLock(lockDir);
+        this.activeLockDir = undefined;
+      }
       this.inFlight = false;
     }
   }
@@ -223,16 +231,15 @@ export async function resolveRunnerQuotaIdentity(input: {
   const provider = input.provider.trim().toLowerCase();
   if (provider === "claude") {
     const credentialsPath = claudeCredentialsPathFromProcess(input.process);
-    const token = await readClaudeOAuthAccessToken(credentialsPath);
     return {
       provider,
-      accountKey: token ? `credential:${shortHash(token)}` : hostProviderAccountKey(provider),
+      accountKey: hostProviderAccountKey(),
       credentialsPath,
     };
   }
   return {
     provider,
-    accountKey: codexAccountKeyFromProcess(input.process) ?? hostProviderAccountKey(provider),
+    accountKey: codexAccountKeyFromProcess(input.process) ?? hostProviderAccountKey(),
   };
 }
 
@@ -383,8 +390,8 @@ function processEnvFromMeta(proc: ManagedProcess | undefined): Record<string, un
   return isRecord(config?.env) ? config.env : undefined;
 }
 
-function hostProviderAccountKey(provider: string): string {
-  return `host:${hostname()}:${provider}`;
+function hostProviderAccountKey(): string {
+  return `host:${hostname()}`;
 }
 
 export function beginSharedQuotaAttempt(identity: QuotaIdentity, stateDir?: string, now = Date.now()): {
@@ -449,16 +456,17 @@ function sharedQuotaKey(identity: QuotaIdentity): string {
 }
 
 function acquireQuotaLock(lockDir: string, now = Date.now()): boolean {
+  mkdirSync(dirname(lockDir), { recursive: true });
   try {
     mkdirSync(lockDir, { recursive: false });
     writeFileSync(join(lockDir, "owner"), String(now));
     return true;
   } catch {
     const ownerPath = join(lockDir, "owner");
+    const lockedAt = quotaLockTimestamp(lockDir, ownerPath);
+    if (lockedAt !== undefined && now - lockedAt <= QUOTA_LOCK_STALE_MS) return false;
+    rmSync(lockDir, { recursive: true, force: true });
     try {
-      const lockedAt = Number(readFileSync(ownerPath, "utf8"));
-      if (Number.isFinite(lockedAt) && now - lockedAt <= QUOTA_LOCK_STALE_MS) return false;
-      rmSync(lockDir, { recursive: true, force: true });
       mkdirSync(lockDir, { recursive: false });
       writeFileSync(ownerPath, String(now));
       return true;
@@ -472,6 +480,18 @@ function releaseQuotaLock(lockDir: string): void {
   rmSync(lockDir, { recursive: true, force: true });
 }
 
+function quotaLockTimestamp(lockDir: string, ownerPath: string): number | undefined {
+  try {
+    const lockedAt = Number(readFileSync(ownerPath, "utf8"));
+    if (Number.isFinite(lockedAt)) return lockedAt;
+  } catch {}
+  try {
+    return statSync(lockDir).mtimeMs;
+  } catch {
+    return undefined;
+  }
+}
+
 function isQuotaState(value: unknown): value is QuotaState {
   return isRecord(value) && Array.isArray(value.windows) && typeof value.updatedAt === "number";
 }