agents-relay 1.0.175 → 1.0.177

package/dist/adapters.js

@@ -274,6 +274,7 @@ export class ChatGptAdapter {
                         submitted: true,
                         diagnosticThreadId: response.diagnostic_thread_id ?? null,
                         userMessageId: response.user_message_id ?? null,
+                        verifiedBy: response.verified_by ?? null,
                     },
                 };
             }

package/dist/dashboard-html.js

@@ -396,15 +396,36 @@ function shortReset(reset){if(!Number.isFinite(reset))return '';const at=new Dat
 function githubBucket(label,bucket){const row=element('div','usage-row');const heading=element('div','usage-label');heading.append(element('span','',text(label)),element('span','',text(bucket.remaining+' / '+bucket.limit)));const percent=bucket.limit>0?Math.max(0,Math.min(100,100*bucket.remaining/bucket.limit)):0;const track=element('div','usage-track');track.setAttribute('role','progressbar');track.setAttribute('aria-label',label+' remaining');track.setAttribute('aria-valuemin','0');track.setAttribute('aria-valuemax','100');track.setAttribute('aria-valuenow',String(Math.round(percent)));const fill=element('div','usage-fill');fill.style.width=percent+'%';track.append(fill);row.append(heading,track);const reset=shortReset(bucket.reset);if(reset){const hint=element('div','subtle',text(reset));hint.title=new Date(bucket.reset*1000).toLocaleString();row.append(hint);}return row;}
 function githubCounterLine(label,values){const entries=Object.entries(values||{}).sort((a,b)=>Number(b[1])-Number(a[1])).slice(0,8);return entries.length?element('div','subtle',text(label+' · '+entries.map(([key,count])=>key+' '+count).join(' · '))):null;}
 function githubDiagnostics(status){const body=element('div','usage-details-body');if(status?.calls)body.append(element('div','subtle',text('Calls · GraphQL '+(status.calls.graphql||0)+' · REST '+(status.calls.rest||0)+' · quota '+(status.calls.rateLimit||0))));const operations=githubCounterLine('GraphQL operations',status?.graphql?.operations);if(operations)body.append(operations);const contexts=githubCounterLine('GraphQL contexts',status?.graphql?.contexts);if(contexts)body.append(contexts);if(status?.readPaths){body.append(element('div','subtle',text('Reads · scans '+(status.readPaths.workspaceScans||0)+' · PR '+(status.readPaths.prRefreshes||0)+' · coalesced '+(status.readPaths.prRefreshCoalesced||0))));const triggers=githubCounterLine('Refresh triggers',status.readPaths.prRefreshesByTrigger);if(triggers)body.append(triggers);const coalesced=githubCounterLine('Coalesced',status.readPaths.prRefreshCoalescedByTrigger);if(coalesced)body.append(coalesced);}if(!body.children.length)return null;const details=element('details','usage-details');details.append(element('summary','',text('Diagnostics')),body);return details;}
+function githubObserved(label,observed){
+  if(!observed)return null;
+  const state=observed.throttled?'Throttled':observed.available===true?'Available':observed.available===false?'Unavailable':'Unknown';
+  const parts=[label+' observed',state];
+  if(observed.status!==null)parts.push('status '+observed.status);
+  if(observed.remaining!==null)parts.push('remaining '+observed.remaining);
+  if(observed.headersCaptured&&observed.reset!==null)parts.push(shortReset(observed.reset));
+  if(observed.retryAfterSeconds!==null)parts.push('retry '+observed.retryAfterSeconds+'s');
+  const row=element('div',observed.throttled?'usage-row error-state':'usage-row subtle');
+  row.textContent=parts.filter(Boolean).join(' · ');
+  if(observed.reason)row.title=observed.reason;
+  return row;
+}
 function githubUsageCard(snapshot,status){
   const card=element('section','usage-provider');
   card.append(element('h3','',text('GitHub API')));
   const resources=snapshot?.resources||{};
   const bars=element('div','usage-bars');
+  bars.append(element('div','usage-label',text('Primary quota (/rate_limit)')));
   if(resources.core)bars.append(githubBucket('REST',resources.core));
   if(resources.graphql)bars.append(githubBucket('GraphQL',resources.graphql));
   if(resources.search)bars.append(githubBucket('Search',resources.search));
   if(!bars.children.length)bars.append(element('p','empty',text('Quota unavailable')));
+  const observed=status?.runtimeRateUsage?.resources||{};
+  for(const row of [githubObserved('REST',observed.core),githubObserved('GraphQL',observed.graphql),githubObserved('Search',observed.search)])if(row)bars.append(row);
+  if(status?.runtimeRateUsage?.rejection){
+    const rejection=status.runtimeRateUsage.rejection;
+    const cooldown=rejection.cooldownUntil?' · cooldown '+new Date(rejection.cooldownUntil).toLocaleTimeString():'';
+    bars.append(element('div','error-state',text('Throttled · '+(rejection.kind==='unknown'?'rate limit':rejection.kind)+' limit'+cooldown)));
+  }
   if(status?.limited){
     const until=status.cooldownUntil?' until '+new Date(status.cooldownUntil).toLocaleTimeString():'';
     bars.append(element('div','error-state',text('Cooldown active'+until)));

package/dist/github-client.js

@@ -0,0 +1,276 @@
+import { spawn } from 'node:child_process';
+import { createSign } from 'node:crypto';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { emptyGitHubRuntimeRateUsage, observeRuntimeRateLimit, parseGitHubCliHeaders, runtimeRejection } from './github-runtime-usage.js';
+function base64Url(value) {
+    return Buffer.from(value).toString('base64url');
+}
+export function createGitHubAppJwt(options, now = Math.floor(Date.now() / 1000)) {
+    const header = base64Url(JSON.stringify({ alg: 'RS256', typ: 'JWT' }));
+    const payload = base64Url(JSON.stringify({ iat: now - 60, exp: now + 540, iss: options.appId }));
+    const unsigned = `${header}.${payload}`;
+    const signer = createSign('RSA-SHA256');
+    signer.update(unsigned);
+    signer.end();
+    return `${unsigned}.${signer.sign(options.privateKey).toString('base64url')}`;
+}
+export class GhApiClient {
+    appAuth;
+    cooldownUntil = 0;
+    rateLimitFailures = 0;
+    installationToken = null;
+    rateLimitCache = null;
+    rateLimitFlight = null;
+    rateLimitCacheTtlMs = 5 * 60_000;
+    apiDiagnostics = { rest: 0, graphql: 0, rateLimit: 0 };
+    graphqlDiagnostics = { operations: {}, contexts: {} };
+    runtimeRateUsage = emptyGitHubRuntimeRateUsage();
+    requestContext = new AsyncLocalStorage();
+    constructor(appAuth = null) {
+        this.appAuth = appAuth;
+    }
+    async withRequestContext(context, work) { return await this.requestContext.run(context, work); }
+    graphqlOperation(query) {
+        if (/mutation\s*\([^)]*\)\s*\{addComment\(/.test(query))
+            return 'comment.add';
+        if (/updateIssueComment\(/.test(query))
+            return 'comment.update';
+        if (/deleteIssueComment\(/.test(query))
+            return 'comment.delete';
+        if (/viewer\s*\{login/.test(query))
+            return 'viewer.login';
+        if (/comments\(first:100,after:\$cursor\)/.test(query))
+            return 'pr.comments';
+        if (/comments\(last:100\)/.test(query))
+            return 'pr.snapshot';
+        if (/headRefName/.test(query) && /headRefOid/.test(query))
+            return 'pr.node';
+        if (/repository\(owner:\$owner,name:\$name\)\{id\}/.test(query))
+            return 'repository.id';
+        if (/pullRequests\(/.test(query))
+            return 'repository.pull-requests';
+        return /^\s*mutation/.test(query) ? 'mutation.other' : 'query.other';
+    }
+    rateLimitStatus() {
+        const limited = Date.now() < this.cooldownUntil;
+        return { limited, cooldownUntil: limited ? new Date(this.cooldownUntil).toISOString() : null, calls: { ...this.apiDiagnostics }, graphql: { operations: { ...this.graphqlDiagnostics.operations }, contexts: { ...this.graphqlDiagnostics.contexts } }, runtimeRateUsage: { resources: { ...this.runtimeRateUsage.resources }, rejection: this.runtimeRateUsage.rejection } };
+    }
+    async rateLimitSnapshot(force = false) {
+        const now = Date.now();
+        if (!force && this.rateLimitCache && now - this.rateLimitCache.cachedAt < this.rateLimitCacheTtlMs)
+            return this.rateLimitCache.snapshot;
+        if (this.rateLimitFlight)
+            return this.rateLimitFlight;
+        if (this.rateLimitStatus().limited && this.rateLimitCache)
+            return this.rateLimitCache.snapshot;
+        const flight = (async () => {
+            this.apiDiagnostics.rateLimit += 1;
+            const stdout = await this.spawnGh(['api', 'rate_limit'], undefined, await this.commandEnv());
+            const parsed = JSON.parse(stdout);
+            const resources = parsed.resources;
+            const bucket = (value) => {
+                const item = value;
+                const limit = Number(item?.limit), used = Number(item?.used), remaining = Number(item?.remaining), reset = Number(item?.reset);
+                return [limit, used, remaining, reset].every(Number.isFinite) ? { limit, used, remaining, reset } : undefined;
+            };
+            const snapshot = { observedAt: new Date().toISOString(), resources: { core: bucket(resources?.core), graphql: bucket(resources?.graphql), search: bucket(resources?.search) } };
+            this.rateLimitCache = { cachedAt: Date.now(), snapshot };
+            return snapshot;
+        })();
+        this.rateLimitFlight = flight;
+        try {
+            return await flight;
+        }
+        finally {
+            if (this.rateLimitFlight === flight)
+                this.rateLimitFlight = null;
+        }
+    }
+    assertAvailable() {
+        if (Date.now() < this.cooldownUntil)
+            throw new Error(`GitHub API cooldown active until ${new Date(this.cooldownUntil).toISOString()}`);
+    }
+    noteFailure(message) {
+        if (!/rate limit|secondary rate|HTTP 429/i.test(message))
+            return;
+        this.rateLimitFailures += 1;
+        const delay = Math.min(15 * 60_000, 60_000 * (2 ** Math.min(this.rateLimitFailures - 1, 4)));
+        this.cooldownUntil = Date.now() + delay;
+    }
+    noteSuccess() { if (Date.now() >= this.cooldownUntil)
+        this.rateLimitFailures = 0; }
+    appJwt(now = Math.floor(Date.now() / 1000)) {
+        if (!this.appAuth)
+            throw new Error('GitHub App authentication is not configured');
+        return createGitHubAppJwt(this.appAuth, now);
+    }
+    async appRequest(path, method = 'GET') {
+        const response = await fetch(`https://api.github.com${path}`, {
+            method,
+            headers: {
+                accept: 'application/vnd.github+json',
+                authorization: `Bearer ${this.appJwt()}`,
+                'x-github-api-version': '2026-03-10',
+                'user-agent': 'agents-relay',
+            },
+        });
+        const text = await response.text();
+        if (!response.ok)
+            throw new Error(`GitHub App API ${response.status}: ${text}`);
+        return JSON.parse(text);
+    }
+    async installationAccessToken() {
+        if (!this.appAuth)
+            throw new Error('GitHub App authentication is not configured');
+        if (this.installationToken && this.installationToken.expiresAt - Date.now() > 5 * 60_000)
+            return this.installationToken.value;
+        const parsed = await this.appRequest(`/app/installations/${this.appAuth.installationId}/access_tokens`, 'POST');
+        const token = typeof parsed.token === 'string' ? parsed.token : '';
+        const expiresAt = typeof parsed.expires_at === 'string' ? Date.parse(parsed.expires_at) : 0;
+        if (!token || !Number.isFinite(expiresAt) || expiresAt <= Date.now())
+            throw new Error('GitHub App installation token response was invalid');
+        this.installationToken = { value: token, expiresAt };
+        return token;
+    }
+    async commandEnv() {
+        if (!this.appAuth)
+            return process.env;
+        const token = await this.installationAccessToken();
+        return { ...process.env, GH_TOKEN: token, GITHUB_TOKEN: token };
+    }
+    async runGh(args, input, env, rateLimited, includeHeaders) {
+        if (rateLimited)
+            this.assertAvailable();
+        const commandArgs = includeHeaders ? [args[0] ?? '', '--include', ...args.slice(1)] : args;
+        return await new Promise((resolve) => {
+            const child = spawn('gh', commandArgs, { env });
+            let stdout = '';
+            let stderr = '';
+            child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+            child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+            child.on('error', error => resolve({ status: null, headers: {}, body: '', stderr: error.message }));
+            if (input !== undefined)
+                child.stdin.write(input);
+            child.stdin.end();
+            child.on('close', code => {
+                const response = parseGitHubCliHeaders(stdout, includeHeaders);
+                const failed = code !== 0;
+                const message = failed ? stderr.trim() || response.body.trim() || `gh exited ${code}` : '';
+                if (failed && rateLimited)
+                    this.noteFailure(message);
+                if (!failed && rateLimited)
+                    this.noteSuccess();
+                resolve({ ...response, stderr: failed ? message : undefined });
+            });
+        });
+    }
+    async spawnGh(args, input, env = process.env, rateLimited = true) {
+        return (await this.runGh(args, input, env, rateLimited, false)).body;
+    }
+    noteRuntimeRateLimit(channel, response) {
+        const observation = observeRuntimeRateLimit(channel, response, new Date().toISOString());
+        this.runtimeRateUsage.resources[observation.resource] = observation;
+        this.runtimeRateUsage.rejection = runtimeRejection(observation);
+    }
+    async graphqlTransport(query, variables) {
+        const response = await this.runGh(['api', 'graphql', '--input', '-'], JSON.stringify({ query, variables }), await this.commandEnv(), true, true);
+        this.noteRuntimeRateLimit('graphql', response);
+        return response;
+    }
+    async requestTransport(path, init) {
+        const args = ['api', path];
+        const method = String(init.method ?? 'GET');
+        if (method !== 'GET')
+            args.push('--method', method);
+        if (init.body)
+            args.push('--input', '-');
+        const response = await this.runGh(args, init.body ? String(init.body) : undefined, await this.commandEnv(), true, true);
+        this.noteRuntimeRateLimit('rest', response);
+        return response;
+    }
+    async graphql(query, variables = {}) {
+        this.assertAvailable();
+        this.apiDiagnostics.graphql += 1;
+        const operation = this.graphqlOperation(query);
+        const context = this.requestContext.getStore() ?? 'unscoped';
+        this.graphqlDiagnostics.operations[operation] = (this.graphqlDiagnostics.operations[operation] ?? 0) + 1;
+        this.graphqlDiagnostics.contexts[context] = (this.graphqlDiagnostics.contexts[context] ?? 0) + 1;
+        const payload = JSON.stringify({ query, variables });
+        const response = await this.graphqlTransport(query, variables);
+        if (response.stderr)
+            throw new Error(response.stderr);
+        const parsed = JSON.parse(response.body);
+        if (Array.isArray(parsed.errors) && parsed.errors.length > 0) {
+            const message = JSON.stringify(parsed.errors);
+            this.noteFailure(message);
+            throw new Error(message);
+        }
+        return parsed.data ?? parsed;
+    }
+    async request(path, init = {}) {
+        this.assertAvailable();
+        this.apiDiagnostics.rest += 1;
+        const args = ['api', path];
+        const method = String(init.method ?? 'GET');
+        if (method !== 'GET')
+            args.push('--method', method);
+        if (init.body)
+            args.push('--input', '-');
+        const response = await this.requestTransport(path, init);
+        if (response.stderr)
+            throw new Error(response.stderr);
+        const stdout = response.body;
+        if (!stdout.trim())
+            return null;
+        try {
+            return JSON.parse(stdout);
+        }
+        catch {
+            return stdout;
+        }
+    }
+    async localLogin() {
+        return new Promise((resolve) => {
+            const child = spawn('gh', ['auth', 'status', '--active', '--json', 'hosts']);
+            let stdout = '';
+            child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+            child.on('error', () => resolve(null));
+            child.on('close', () => {
+                try {
+                    const value = JSON.parse(stdout);
+                    const hosts = value.hosts;
+                    const github = hosts?.['github.com'];
+                    const active = Array.isArray(github) ? github.find(item => item.active === true) : undefined;
+                    resolve(typeof active?.login === 'string' && active.login.length > 0 ? active.login : null);
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        });
+    }
+    async currentLogin() {
+        if (this.appAuth) {
+            const app = await this.appRequest('/app');
+            if (typeof app.slug === 'string' && app.slug.length > 0)
+                return `${app.slug}[bot]`;
+            throw new Error('GitHub App identity lookup returned no slug');
+        }
+        else {
+            const local = await this.localLogin();
+            if (local)
+                return local;
+            try {
+                const value = await this.graphql('query { viewer { login } }');
+                const viewer = value.viewer;
+                if (typeof viewer?.login === 'string' && viewer.login.length > 0)
+                    return viewer.login;
+            }
+            catch { /* handled below */ }
+        }
+        const local = await this.localLogin();
+        if (local)
+            return local;
+        throw new Error('gh authentication did not return a login');
+    }
+}

package/dist/github-runtime-usage.js

@@ -0,0 +1,81 @@
+export function emptyGitHubRuntimeRateUsage() {
+    return { resources: {}, rejection: null };
+}
+function headerNumber(value) {
+    if (!value)
+        return null;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function transportResource(requestChannel, headers) {
+    const resource = headers['x-ratelimit-resource'];
+    if (resource === 'core' || resource === 'graphql' || resource === 'search')
+        return resource;
+    return requestChannel === 'graphql' ? 'graphql' : 'core';
+}
+function rejectionKind(headers, reason) {
+    if (/secondary rate|graphql_rate_limit/i.test(reason))
+        return 'secondary';
+    if (/rate limit/i.test(reason) && headerNumber(headers['x-ratelimit-remaining']) !== 0)
+        return 'secondary';
+    if (/rate limit/i.test(reason))
+        return 'primary';
+    return 'unknown';
+}
+function isThrottled(status, reason) {
+    return status === 429 || /rate limit|secondary rate|graphql_rate_limit/i.test(reason);
+}
+export function observeRuntimeRateLimit(requestChannel, response, observedAt) {
+    const headers = response.headers;
+    const reason = [response.body, response.stderr].filter(value => typeof value === 'string' && value.length > 0).join('\n').slice(0, 2000);
+    const throttled = isThrottled(response.status, reason);
+    return {
+        resource: transportResource(requestChannel, headers),
+        observedAt,
+        status: response.status,
+        available: throttled ? false : response.status !== null ? response.status >= 200 && response.status < 300 : null,
+        throttled,
+        limit: headerNumber(headers['x-ratelimit-limit']),
+        used: headerNumber(headers['x-ratelimit-used']),
+        remaining: headerNumber(headers['x-ratelimit-remaining']),
+        reset: headerNumber(headers['x-ratelimit-reset']),
+        resetAt: headerNumber(headers['x-ratelimit-reset']) === null ? null : new Date(headerNumber(headers['x-ratelimit-reset']) * 1000).toISOString(),
+        retryAfterSeconds: headerNumber(headers['retry-after']),
+        reason: throttled ? reason : null,
+        headersCaptured: ['x-ratelimit-limit', 'x-ratelimit-remaining', 'x-ratelimit-reset', 'x-ratelimit-resource'].some(name => Object.hasOwn(headers, name)),
+    };
+}
+export function runtimeRejection(observation) {
+    if (!observation.throttled)
+        return null;
+    const headers = {};
+    if (observation.remaining !== null)
+        headers['x-ratelimit-remaining'] = String(observation.remaining);
+    const retryAfterSeconds = observation.retryAfterSeconds;
+    return {
+        resource: observation.resource,
+        kind: rejectionKind(headers, observation.reason ?? ''),
+        observedAt: observation.observedAt,
+        status: observation.status,
+        retryAfterSeconds,
+        cooldownUntil: retryAfterSeconds === null ? null : new Date(Date.parse(observation.observedAt) + retryAfterSeconds * 1000).toISOString(),
+        reason: observation.reason ?? 'GitHub rate-limit rejection',
+    };
+}
+export function parseGitHubCliHeaders(output, hadHeaders) {
+    if (!hadHeaders)
+        return { status: null, headers: {}, body: output };
+    const boundary = output.search(/\r?\n\r?\n/);
+    if (boundary < 0)
+        return { status: null, headers: {}, body: output };
+    const head = output.slice(0, boundary);
+    const statusMatch = /HTTP\/[\d.]+\s+(\d{3})/.exec(head);
+    const headers = {};
+    for (const line of head.split(/\r?\n/).slice(1)) {
+        const separator = line.indexOf(':');
+        if (separator <= 0)
+            continue;
+        headers[line.slice(0, separator).trim().toLowerCase()] = line.slice(separator + 1).trim();
+    }
+    return { status: statusMatch ? Number(statusMatch[1]) : null, headers, body: output.slice(boundary).replace(/^\r?\n\r?\n/, '') };
+}

package/dist/store.js

@@ -1,6 +1,3 @@
-import { spawn } from 'node:child_process';
-import { createSign } from 'node:crypto';
-import { AsyncLocalStorage } from 'node:async_hooks';
 import { parseAgent, parseJob, parsePlan, parseTask, renderAgentComment, renderJobComment, renderPlanComment, renderTaskComment, AGENT_MARKER, JOB_MARKER, PLAN_MARKER, TASK_MARKER } from './markers.js';
 import { isTaskForJob, sameTaskDefinition } from './store-task-definition.js';
 import { parsePackagePublicationMarker } from './github-webhook.js';
@@ -129,6 +126,7 @@ export class InMemoryStore {
     }
 }
 export async function withGitHubRequestContext(client, context, work) { return client.withRequestContext ? client.withRequestContext(context, work) : work(); }
+export { createGitHubAppJwt, GhApiClient } from './github-client.js';
 async function githubGraphql(client, query, variables) {
     if (!client.graphql)
         throw new Error('GitHub GraphQL client is required');
@@ -259,249 +257,6 @@ export async function resolvePullRequest(client, repository, options) {
         throw error;
     }
 }
-function base64Url(value) {
-    return Buffer.from(value).toString('base64url');
-}
-export function createGitHubAppJwt(options, now = Math.floor(Date.now() / 1000)) {
-    const header = base64Url(JSON.stringify({ alg: 'RS256', typ: 'JWT' }));
-    const payload = base64Url(JSON.stringify({ iat: now - 60, exp: now + 540, iss: options.appId }));
-    const unsigned = `${header}.${payload}`;
-    const signer = createSign('RSA-SHA256');
-    signer.update(unsigned);
-    signer.end();
-    return `${unsigned}.${signer.sign(options.privateKey).toString('base64url')}`;
-}
-export class GhApiClient {
-    appAuth;
-    cooldownUntil = 0;
-    rateLimitFailures = 0;
-    installationToken = null;
-    rateLimitCache = null;
-    rateLimitFlight = null;
-    rateLimitCacheTtlMs = 5 * 60_000;
-    apiDiagnostics = { rest: 0, graphql: 0, rateLimit: 0 };
-    graphqlDiagnostics = { operations: {}, contexts: {} };
-    requestContext = new AsyncLocalStorage();
-    constructor(appAuth = null) {
-        this.appAuth = appAuth;
-    }
-    async withRequestContext(context, work) { return await this.requestContext.run(context, work); }
-    graphqlOperation(query) {
-        if (/mutation\s*\([^)]*\)\s*\{addComment\(/.test(query))
-            return 'comment.add';
-        if (/updateIssueComment\(/.test(query))
-            return 'comment.update';
-        if (/deleteIssueComment\(/.test(query))
-            return 'comment.delete';
-        if (/viewer\s*\{login/.test(query))
-            return 'viewer.login';
-        if (/comments\(first:100,after:\$cursor\)/.test(query))
-            return 'pr.comments';
-        if (/comments\(last:100\)/.test(query))
-            return 'pr.snapshot';
-        if (/headRefName/.test(query) && /headRefOid/.test(query))
-            return 'pr.node';
-        if (/repository\(owner:\$owner,name:\$name\)\{id\}/.test(query))
-            return 'repository.id';
-        if (/pullRequests\(/.test(query))
-            return 'repository.pull-requests';
-        return /^\s*mutation/.test(query) ? 'mutation.other' : 'query.other';
-    }
-    rateLimitStatus() {
-        const limited = Date.now() < this.cooldownUntil;
-        return { limited, cooldownUntil: limited ? new Date(this.cooldownUntil).toISOString() : null, calls: { ...this.apiDiagnostics }, graphql: { operations: { ...this.graphqlDiagnostics.operations }, contexts: { ...this.graphqlDiagnostics.contexts } } };
-    }
-    async rateLimitSnapshot(force = false) {
-        const now = Date.now();
-        if (!force && this.rateLimitCache && now - this.rateLimitCache.cachedAt < this.rateLimitCacheTtlMs)
-            return this.rateLimitCache.snapshot;
-        if (this.rateLimitFlight)
-            return this.rateLimitFlight;
-        if (this.rateLimitStatus().limited && this.rateLimitCache)
-            return this.rateLimitCache.snapshot;
-        const flight = (async () => {
-            this.apiDiagnostics.rateLimit += 1;
-            const stdout = await this.spawnGh(['api', 'rate_limit'], undefined, await this.commandEnv());
-            const parsed = JSON.parse(stdout);
-            const resources = parsed.resources;
-            const bucket = (value) => {
-                const item = value;
-                const limit = Number(item?.limit), used = Number(item?.used), remaining = Number(item?.remaining), reset = Number(item?.reset);
-                return [limit, used, remaining, reset].every(Number.isFinite) ? { limit, used, remaining, reset } : undefined;
-            };
-            const snapshot = { observedAt: new Date().toISOString(), resources: { core: bucket(resources?.core), graphql: bucket(resources?.graphql), search: bucket(resources?.search) } };
-            this.rateLimitCache = { cachedAt: Date.now(), snapshot };
-            return snapshot;
-        })();
-        this.rateLimitFlight = flight;
-        try {
-            return await flight;
-        }
-        finally {
-            if (this.rateLimitFlight === flight)
-                this.rateLimitFlight = null;
-        }
-    }
-    assertAvailable() {
-        if (Date.now() < this.cooldownUntil)
-            throw new Error(`GitHub API cooldown active until ${new Date(this.cooldownUntil).toISOString()}`);
-    }
-    noteFailure(message) {
-        if (!/rate limit|secondary rate|HTTP 429/i.test(message))
-            return;
-        this.rateLimitFailures += 1;
-        const delay = Math.min(15 * 60_000, 60_000 * (2 ** Math.min(this.rateLimitFailures - 1, 4)));
-        this.cooldownUntil = Date.now() + delay;
-    }
-    noteSuccess() { if (Date.now() >= this.cooldownUntil)
-        this.rateLimitFailures = 0; }
-    appJwt(now = Math.floor(Date.now() / 1000)) {
-        if (!this.appAuth)
-            throw new Error('GitHub App authentication is not configured');
-        return createGitHubAppJwt(this.appAuth, now);
-    }
-    async appRequest(path, method = 'GET') {
-        const response = await fetch(`https://api.github.com${path}`, {
-            method,
-            headers: {
-                accept: 'application/vnd.github+json',
-                authorization: `Bearer ${this.appJwt()}`,
-                'x-github-api-version': '2026-03-10',
-                'user-agent': 'agents-relay',
-            },
-        });
-        const text = await response.text();
-        if (!response.ok)
-            throw new Error(`GitHub App API ${response.status}: ${text}`);
-        return JSON.parse(text);
-    }
-    async installationAccessToken() {
-        if (!this.appAuth)
-            throw new Error('GitHub App authentication is not configured');
-        if (this.installationToken && this.installationToken.expiresAt - Date.now() > 5 * 60_000)
-            return this.installationToken.value;
-        const parsed = await this.appRequest(`/app/installations/${this.appAuth.installationId}/access_tokens`, 'POST');
-        const token = typeof parsed.token === 'string' ? parsed.token : '';
-        const expiresAt = typeof parsed.expires_at === 'string' ? Date.parse(parsed.expires_at) : 0;
-        if (!token || !Number.isFinite(expiresAt) || expiresAt <= Date.now())
-            throw new Error('GitHub App installation token response was invalid');
-        this.installationToken = { value: token, expiresAt };
-        return token;
-    }
-    async commandEnv() {
-        if (!this.appAuth)
-            return process.env;
-        const token = await this.installationAccessToken();
-        return { ...process.env, GH_TOKEN: token, GITHUB_TOKEN: token };
-    }
-    async spawnGh(args, input, env = process.env, rateLimited = true) {
-        if (rateLimited)
-            this.assertAvailable();
-        return new Promise((resolve, reject) => {
-            const child = spawn('gh', args, { env });
-            let stdout = '';
-            let stderr = '';
-            child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
-            child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
-            child.on('error', reject);
-            if (input !== undefined)
-                child.stdin.write(input);
-            child.stdin.end();
-            child.on('close', code => {
-                if (code !== 0) {
-                    const message = stderr.trim() || `gh exited ${code}`;
-                    if (rateLimited)
-                        this.noteFailure(message);
-                    reject(new Error(message));
-                    return;
-                }
-                if (rateLimited)
-                    this.noteSuccess();
-                resolve(stdout);
-            });
-        });
-    }
-    async graphql(query, variables = {}) {
-        this.assertAvailable();
-        this.apiDiagnostics.graphql += 1;
-        const operation = this.graphqlOperation(query);
-        const context = this.requestContext.getStore() ?? 'unscoped';
-        this.graphqlDiagnostics.operations[operation] = (this.graphqlDiagnostics.operations[operation] ?? 0) + 1;
-        this.graphqlDiagnostics.contexts[context] = (this.graphqlDiagnostics.contexts[context] ?? 0) + 1;
-        const payload = JSON.stringify({ query, variables });
-        const stdout = await this.spawnGh(['api', 'graphql', '--input', '-'], payload, await this.commandEnv());
-        const parsed = JSON.parse(stdout);
-        if (Array.isArray(parsed.errors) && parsed.errors.length > 0) {
-            const message = JSON.stringify(parsed.errors);
-            this.noteFailure(message);
-            throw new Error(message);
-        }
-        return parsed.data ?? parsed;
-    }
-    async request(path, init = {}) {
-        this.assertAvailable();
-        this.apiDiagnostics.rest += 1;
-        const args = ['api', path];
-        const method = String(init.method ?? 'GET');
-        if (method !== 'GET')
-            args.push('--method', method);
-        if (init.body)
-            args.push('--input', '-');
-        const stdout = await this.spawnGh(args, init.body ? String(init.body) : undefined, await this.commandEnv());
-        if (!stdout.trim())
-            return null;
-        try {
-            return JSON.parse(stdout);
-        }
-        catch {
-            return stdout;
-        }
-    }
-    async localLogin() {
-        return new Promise((resolve) => {
-            const child = spawn('gh', ['auth', 'status', '--active', '--json', 'hosts']);
-            let stdout = '';
-            child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
-            child.on('error', () => resolve(null));
-            child.on('close', () => {
-                try {
-                    const value = JSON.parse(stdout);
-                    const hosts = value.hosts;
-                    const github = hosts?.['github.com'];
-                    const active = Array.isArray(github) ? github.find(item => item.active === true) : undefined;
-                    resolve(typeof active?.login === 'string' && active.login.length > 0 ? active.login : null);
-                }
-                catch {
-                    resolve(null);
-                }
-            });
-        });
-    }
-    async currentLogin() {
-        if (this.appAuth) {
-            const app = await this.appRequest('/app');
-            if (typeof app.slug === 'string' && app.slug.length > 0)
-                return `${app.slug}[bot]`;
-            throw new Error('GitHub App identity lookup returned no slug');
-        }
-        else {
-            const local = await this.localLogin();
-            if (local)
-                return local;
-            try {
-                const value = await this.graphql('query { viewer { login } }');
-                const viewer = value.viewer;
-                if (typeof viewer?.login === 'string' && viewer.login.length > 0)
-                    return viewer.login;
-            }
-            catch { /* handled below */ }
-        }
-        const local = await this.localLogin();
-        if (local)
-            return local;
-        throw new Error('gh authentication did not return a login');
-    }
-}
 export { GitHubStore } from './store-github.js';
 export async function listManagedGitHubJobs(client, repository, trustedAuthors) {
     if (!client.graphql)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "1.0.175",
+  "version": "1.0.177",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {