@atolis-hq/wake 0.3.74 → 0.3.76

package/dist/src/bootstrap/surface-api-applications.js

@@ -203,12 +203,21 @@ function createSystemApplications(root, now) {
                         detail: `rolled back from ${selfUpdateFailure.tag} at ${selfUpdateFailure.occurredAt}: ${selfUpdateFailure.message}`,
                     },
             ];
+            const adapters = root.providers.flatMap((instance) => (instance.health?.() ?? []).map((check) => ({
+                adapter: instance.adapter,
+                provider: instance.provider,
+                ...check,
+            })));
             return {
                 data: {
-                    status: checks.some((check) => check.status === 'degraded') ? 'degraded' : 'ok',
+                    status: checks.some((check) => check.status === 'degraded') ||
+                        adapters.some((check) => check.status === 'degraded')
+                        ? 'degraded'
+                        : 'ok',
                     version: wakeVersion,
                     checkedAt,
                     checks,
+                    adapters,
                 },
                 meta: sampledMeta(checkedAt),
             };

package/dist/src/bootstrap/version.js

@@ -108,4 +108,4 @@ export function resolveWakeVersion(options = {}) {
         return `g${headHash.slice(0, 7)}`;
     return '0.1.0-dev';
 }
-export const wakeVersion = "gb6b6a2c";
+export const wakeVersion = "gad83503";

package/dist/src/integrations/application/adapter-health-tracker.js

@@ -0,0 +1,43 @@
+const DEFINITIVE_STATUSES = new Set([401, 403, 429]);
+export function createAdapterHealthTracker(options = {}) {
+    const now = options.now ?? Date.now;
+    const threshold = options.degradeAfterConsecutiveFailures ?? 3;
+    let successCount = 0;
+    let failureCount = 0;
+    let consecutiveFailures = 0;
+    let degradedDetail;
+    return {
+        recordSuccess() {
+            successCount += 1;
+            consecutiveFailures = 0;
+            degradedDetail = undefined;
+        },
+        recordFailure(error) {
+            failureCount += 1;
+            consecutiveFailures += 1;
+            const status = statusOf(error);
+            const occurredAt = new Date(now()).toISOString();
+            const message = error instanceof Error ? error.message : String(error);
+            if (status !== undefined && DEFINITIVE_STATUSES.has(status)) {
+                degradedDetail = `${status} at ${occurredAt}: ${message}`;
+                return;
+            }
+            if (consecutiveFailures >= threshold) {
+                degradedDetail = `${consecutiveFailures} consecutive failures, last: ${status ?? 'error'} at ${occurredAt}: ${message}`;
+            }
+        },
+        snapshot() {
+            return {
+                status: degradedDetail === undefined ? 'ok' : 'degraded',
+                ...(degradedDetail === undefined ? {} : { detail: degradedDetail }),
+                successCount,
+                failureCount,
+            };
+        },
+    };
+}
+function statusOf(error) {
+    if (typeof error !== 'object' || error === null || !('status' in error))
+        return undefined;
+    return typeof error.status === 'number' ? error.status : undefined;
+}

package/dist/src/integrations/contracts/provider.js

@@ -18,11 +18,14 @@ export class ProviderRegistry {
                 throw new Error(`Provider ${provider} is not registered`);
             const adapter = adapterId(name);
             try {
-                instances.push(definition.create({
-                    adapter,
-                    config: definition.parseConfig(entry),
-                    ...(services === undefined ? {} : { services }),
-                }));
+                instances.push({
+                    ...definition.create({
+                        adapter,
+                        config: definition.parseConfig(entry),
+                        ...(services === undefined ? {} : { services }),
+                    }),
+                    provider,
+                });
             }
             catch (error) {
                 failures.push({

package/dist/src/integrations/github/infrastructure/bounded-fetch.js

@@ -1,4 +1,5 @@
 const defaultMaximumGitHubResponseBytes = 8 * 1024 * 1024;
+const defaultGitHubRequestTimeoutMs = 30_000;
 export class GitHubResponseTooLargeError extends Error {
     maximumBytes;
     observedBytes;
@@ -9,9 +10,39 @@ export class GitHubResponseTooLargeError extends Error {
         this.name = 'GitHubResponseTooLargeError';
     }
 }
-export function createBoundedGitHubFetch(baseFetch = globalThis.fetch, maximumResponseBytes = defaultMaximumGitHubResponseBytes) {
+// Neither Octokit nor the underlying fetch implementation bounds how long a
+// single request may hang: a connection that never responds (rather than
+// returning a clean error status) blocks forever. Every caller of the GitHub
+// client boundary — reads and mutations alike — currently awaits that call
+// inline within the runner's single serialized tick, so one hung request
+// stalls Advancement for every other, unrelated work item too.
+export class GitHubRequestTimeoutError extends Error {
+    timeoutMs;
+    constructor(timeoutMs) {
+        super(`GitHub request did not complete within ${timeoutMs}ms`);
+        this.timeoutMs = timeoutMs;
+        this.name = 'GitHubRequestTimeoutError';
+    }
+}
+export function createBoundedGitHubFetch(baseFetch = globalThis.fetch, maximumResponseBytes = defaultMaximumGitHubResponseBytes, timeoutMs = defaultGitHubRequestTimeoutMs) {
     return async (input, init) => {
-        const response = await baseFetch(input, init);
+        const timeoutController = new AbortController();
+        const timer = setTimeout(() => timeoutController.abort(), timeoutMs);
+        const signal = init?.signal
+            ? AbortSignal.any([init.signal, timeoutController.signal])
+            : timeoutController.signal;
+        let response;
+        try {
+            response = await baseFetch(input, { ...init, signal });
+        }
+        catch (error) {
+            if (timeoutController.signal.aborted)
+                throw new GitHubRequestTimeoutError(timeoutMs);
+            throw error;
+        }
+        finally {
+            clearTimeout(timer);
+        }
         const declaredBytes = contentLength(response);
         if (declaredBytes !== undefined && declaredBytes > maximumResponseBytes) {
             await response.body?.cancel();

package/dist/src/integrations/github/infrastructure/source.js

@@ -1,4 +1,5 @@
 import { GitHubEventType } from '../contracts/events.js';
+import { createGitHubAdapterHealthRegistry, } from './adapter-health-registry.js';
 import { issueCommentEventsFor, reviewCommentEventsFor, reviewEventsFor, } from './comment-source.js';
 import { issueObservation } from './issue-source.js';
 import { loadWatermark, overlapSince, reportPartialPollFailure, watermarkCheckpoint, } from './poll-watermark.js';
@@ -7,6 +8,7 @@ import { createGitHubRequestCoordinator, } from './request-coordinator.js';
 export function createGitHubSource(config, client, adapter, requests = createGitHubRequestCoordinator({
     maxConcurrent: config.polling.maxConcurrent,
 }), state) {
+    const health = state?.health ?? createGitHubAdapterHealthRegistry(config.repositories);
     // Draft eventIds are already content fingerprints (see issue-source.ts/pr-source.ts),
     // so the journal itself is idempotent per item. This cache only avoids re-appending
     // (and re-triggering downstream translation) an unchanged item on every poll within
@@ -25,6 +27,7 @@ export function createGitHubSource(config, client, adapter, requests = createGit
                 repo,
                 watermark: await loadWatermark(state?.checkpoints, adapter, owner, repo),
                 now: state?.now ?? Date.now,
+                health,
             })));
             for (const result of perRepository)
                 if (result.succeeded)
@@ -40,10 +43,11 @@ export function createGitHubSource(config, client, adapter, requests = createGit
             });
         },
         async markPollPersisted() {
-            if (state === undefined)
+            if (state?.checkpoints === undefined)
                 return;
+            const checkpoints = state.checkpoints;
             for (const [repository, watermark] of pendingWatermarks) {
-                await state.checkpoints.save(watermarkCheckpoint(adapter, repository), watermark);
+                await checkpoints.save(watermarkCheckpoint(adapter, repository), watermark);
                 pendingWatermarks.delete(repository);
             }
         },
@@ -72,7 +76,7 @@ function limitGitHubSourceClient(client, requests) {
     };
 }
 async function pollRepository(input) {
-    const { client, config, adapter, signal, owner, repo } = input;
+    const { client, config, adapter, signal, owner, repo, health } = input;
     const queriedAt = input.now();
     const context = {
         client,
@@ -87,10 +91,18 @@ async function pollRepository(input) {
         client.listIssues(owner, repo, config.polling.maxPerRepo, since),
         client.listPullRequests(owner, repo, config.polling.maxPerRepo),
     ]);
-    if (!isFulfilled(issuesResult))
+    if (isFulfilled(issuesResult))
+        health.recordSuccess(context.repository, 'poll');
+    else {
         reportPartialPollFailure(context.repository, 'issues');
-    if (!isFulfilled(pullRequestsResult))
+        health.recordFailure(context.repository, 'poll', issuesResult.reason);
+    }
+    if (isFulfilled(pullRequestsResult))
+        health.recordSuccess(context.repository, 'poll');
+    else {
         reportPartialPollFailure(context.repository, 'pull requests');
+        health.recordFailure(context.repository, 'poll', pullRequestsResult.reason);
+    }
     const issues = isFulfilled(issuesResult) ? issuesResult.value : [];
     const pullRequestPayloads = isFulfilled(pullRequestsResult)
         ? pullRequestsResult.value.filter((pullRequest) => since === undefined || pullRequest.updated_at >= since)

package/dist/src/integrations/github/provider.js

@@ -6,6 +6,7 @@ import { translateGitHubOutbound } from './application/outbound-translator.js';
 import { createGitHubWakeLabelReconciler } from './application/wake-labels.js';
 import { gitHubConfigSchema } from './contracts/config.js';
 import { GitHubEventType } from './contracts/events.js';
+import { createGitHubAdapterHealthRegistry } from './infrastructure/adapter-health-registry.js';
 import { createGitHubClient } from './infrastructure/client.js';
 import { createGitHubDelivery } from './infrastructure/delivery.js';
 import { resolveGitHubCliToken } from './infrastructure/gh-auth.js';
@@ -24,12 +25,14 @@ export const gitHubProviderDefinition = {
         const requests = createGitHubRequestCoordinator({
             maxConcurrent: config.polling.maxConcurrent,
         });
+        const health = createGitHubAdapterHealthRegistry(config.repositories);
         return {
             adapter,
             eventTypes: Object.values(GitHubEventType),
             source: createGitHubSource(config, client, adapter, requests, {
                 checkpoints: services.checkpoints,
                 now: () => services.clock.now().getTime(),
+                health,
             }),
             maintenance: createGitHubWakeLabelReconciler({
                 orchestration: services.orchestration,
@@ -39,16 +42,29 @@ export const gitHubProviderDefinition = {
                 setLabels: client.setIssueLabels,
                 requests,
             }),
+            health: () => health.snapshotAll(),
             delivery: createGitHubDelivery(async (intent, idempotencyKey) => {
                 const resource = await services.resources.get(resourceId(intent.resourceId));
                 if (resource === null)
                     throw new Error(`GitHub resource ${intent.resourceId} is unavailable`);
-                return client.deliver({
-                    ...translateGitHubOutbound(resource, intent, {
-                        publicUiUrl: services.publicUiUrl,
-                    }),
-                    idempotencyKey,
-                });
+                const parsedKey = parsePullRequestKey(resource.externalKey.key);
+                const repository = parsedKey === null ? null : `${parsedKey.owner}/${parsedKey.repo}`;
+                try {
+                    const externalId = await client.deliver({
+                        ...translateGitHubOutbound(resource, intent, {
+                            publicUiUrl: services.publicUiUrl,
+                        }),
+                        idempotencyKey,
+                    });
+                    if (repository !== null)
+                        health.recordSuccess(repository, 'deliver');
+                    return externalId;
+                }
+                catch (error) {
+                    if (repository !== null)
+                        health.recordFailure(repository, 'deliver', error);
+                    throw error;
+                }
             }, async (intent) => {
                 if (intent.kind !== BuiltInActivityName.IssueComplete)
                     return null;