@atolis-hq/wake 0.4.35 → 0.4.37

package/dist/src/bootstrap/composition-root.d.ts

@@ -71,6 +71,7 @@ export interface CompositionRoot {
     readonly delivery: DeliveryService;
     readonly intakePipeline: IntakePipeline;
     readonly runnerPipeline: RunnerPipeline;
+    readonly requestImmediatePoll: (adapter: string) => void;
     readonly resolveResourceLink: ResourceLinkResolver;
 }
 export declare function createCompositionRoot(wakeRoot: string, options?: CompositionRootOptions): Promise<CompositionRoot>;

package/dist/src/bootstrap/composition-root.js

@@ -103,7 +103,7 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
         },
     }, activities, config.execution, orchestration);
     const controlPlane = createControlPlaneService({ journal, clock, ids });
-    const isRuntimePaused = async () => (await controlPlane.isPaused()) || (await maintenance.read()) !== null;
+    const isRuntimePaused = async () => (await controlPlane.isDispatchPaused()) || (await maintenance.read()) !== null;
     const runnerControls = createRunnerControlService({
         journal,
         clock,

package/dist/src/bootstrap/integration-runtime.d.ts

@@ -19,6 +19,7 @@ export interface IntegrationRuntime {
     readonly delivery: DeliveryService;
     readonly intakePipeline: IntakePipeline;
     readonly runnerPipeline: RunnerPipeline;
+    readonly requestImmediatePoll: (adapter: string) => void;
 }
 export interface IntegrationRuntimeInput {
     readonly config: ResolvedWakeModulesConfig;
@@ -46,3 +47,5 @@ export interface IntegrationRuntimeInput {
     readonly providerDefinitions: readonly ProviderDefinition[];
 }
 export declare function composeIntegrationRuntime(input: IntegrationRuntimeInput): Promise<IntegrationRuntime>;
+/** Coalesces provider webhook requests while retaining the source's durable poll semantics. */
+export declare function createImmediatePollRequester(providers: readonly ProviderInstance[], journal: EventJournal, wakeRoot: string): (adapter: string) => void;

package/dist/src/bootstrap/integration-runtime.js

@@ -23,6 +23,7 @@ export async function composeIntegrationRuntime(input) {
         registry.register(definition);
     const { instances, failures: providerFailures } = registry.compose(await hydrateFakeProviderEvidence(input.wakeRoot, input.config.integrations), {
         publicUiUrl: input.config.surfaces.web.publicUrl,
+        providerStateRoot: join(input.wakeRoot, '.wake'),
         work: input.work,
         conversations: input.conversations,
         resources: input.resources,
@@ -155,6 +156,7 @@ export async function composeIntegrationRuntime(input) {
             await delivery.deliverNext(signal);
         }),
     });
+    const requestImmediatePoll = createImmediatePollRequester(providers, input.journal, input.wakeRoot);
     return {
         projectionSubscriptions,
         processors: [
@@ -172,6 +174,26 @@ export async function composeIntegrationRuntime(input) {
         delivery,
         intakePipeline,
         runnerPipeline,
+        requestImmediatePoll,
+    };
+}
+/** Coalesces provider webhook requests while retaining the source's durable poll semantics. */
+export function createImmediatePollRequester(providers, journal, wakeRoot) {
+    const immediatePolls = new Map();
+    return (adapter) => {
+        if (immediatePolls.has(adapter))
+            return;
+        const provider = providers.find((candidate) => candidate.adapter === adapter);
+        if (provider === undefined)
+            return;
+        const run = withFileLock(join(wakeRoot, '.wake', 'locks', `poll-${provider.adapter}.lock`), async () => {
+            await new PollService(journal, provider).pollOnce(new AbortController().signal, {
+                bypassInterval: true,
+            });
+        })
+            .catch((error) => console.error(`Webhook polling ${adapter} failed`, error))
+            .finally(() => immediatePolls.delete(adapter));
+        immediatePolls.set(adapter, run);
     };
 }
 async function observeMemory(profile, phase, operation) {

package/dist/src/bootstrap/surface-api-applications.d.ts

@@ -11,9 +11,9 @@ export declare function readControlPlaneStatus(root: CompositionRoot, now: () =>
             startedAt: string;
         };
         updatedAt: string;
-        reason?: string;
-        pausedUntil?: string;
-        paused: boolean;
+        dispatchPauseReason?: string;
+        dispatchPausedUntil?: string;
+        dispatchPaused: boolean;
     };
     meta: import("../surfaces/index.js").ResponseMeta;
 }>;

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

@@ -359,12 +359,12 @@ function toHealthErrorText(value) {
 function createControlPlaneApplications(root, now) {
     return {
         status: () => readControlPlaneStatus(root, now),
-        async pause(command) {
-            await root.controlPlane.pause(command.idempotencyKey);
+        async pauseDispatch(command) {
+            await root.controlPlane.pauseDispatch(command.idempotencyKey);
             return commandAccepted(command, now());
         },
-        async resume(command) {
-            await root.controlPlane.resume(command.idempotencyKey);
+        async resumeDispatch(command) {
+            await root.controlPlane.resumeDispatch(command.idempotencyKey);
             return commandAccepted(command, now());
         },
         async clearMaintenance(command) {
@@ -402,9 +402,14 @@ export async function readControlPlaneStatus(root, now) {
     const lease = await root.maintenance.read();
     return {
         data: {
-            paused: stored?.value.pausedUntil !== null && stored?.value.pausedUntil !== undefined,
-            ...(stored?.value.pausedUntil == null ? {} : { pausedUntil: stored.value.pausedUntil }),
-            ...(stored?.value.reason === undefined ? {} : { reason: stored.value.reason }),
+            dispatchPaused: stored?.value.dispatchPausedUntil !== null &&
+                stored?.value.dispatchPausedUntil !== undefined,
+            ...(stored?.value.dispatchPausedUntil == null
+                ? {}
+                : { dispatchPausedUntil: stored.value.dispatchPausedUntil }),
+            ...(stored?.value.dispatchPauseReason === undefined
+                ? {}
+                : { dispatchPauseReason: stored.value.dispatchPauseReason }),
             updatedAt: meta.asOf,
             ...(lease === null
                 ? {}

package/dist/src/bootstrap/surface-cli-applications.d.ts

@@ -28,6 +28,7 @@ interface ExecutionShutdown {
     shutdown(): Promise<void>;
 }
 export declare function closeResidentRuntime(execution: ExecutionShutdown, closeResources: () => Promise<void>): Promise<void>;
+export declare function createProviderWebhookReceiver(providers: readonly CompositionRoot['providers'][number][], requestImmediatePoll: (adapter: string) => void): (body: Buffer, headers: Readonly<Record<string, string | string[] | undefined>>) => Promise<401 | 404 | 400 | 202>;
 /** The production maintenance boundary shared by the CLI update application. */
 export declare function createSelfUpdateQuiescePort(root: CompositionRoot): SelfUpdateQuiescePort;
 export {};

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

@@ -55,10 +55,13 @@ export function createSurfaceCliApplications(root, api, now) {
         },
         start: {
             async run(signal, budget) {
+                const listening = root.config.surfaces.web.enabled || root.config.surfaces.api.enabled;
                 if (root.config.surfaces.web.enabled)
                     await startHttp({}, true);
                 else if (root.config.surfaces.api.enabled)
                     await startHttp({}, false);
+                if (listening)
+                    await Promise.all(root.providers.flatMap((provider) => provider.webhook === undefined ? [] : [provider.webhook.provision()]));
                 return runResidentLifecycle({
                     signal,
                     budget,
@@ -289,6 +292,7 @@ function createHttpStarter(root, api, servers) {
                 disabled: root.config.surfaces.web.auth.disabled,
                 redeemGrant: (grant) => redeemPairingGrant(root.paths.wakeRoot, grant, undefined, serialiseCredentialMutation),
             },
+            webhookReceiver: createProviderWebhookReceiver(root.providers, root.requestImmediatePoll),
             ...(assets === undefined ? {} : { assets }),
         });
         servers.add(server);
@@ -304,6 +308,20 @@ function createHttpStarter(root, api, servers) {
         }
     };
 }
+export function createProviderWebhookReceiver(providers, requestImmediatePoll) {
+    return async (body, headers) => {
+        const statuses = await Promise.all(providers.flatMap((provider) => provider.webhook === undefined
+            ? []
+            : [provider.webhook.receive(body, headers, () => requestImmediatePoll(provider.adapter))]));
+        if (statuses.includes(202))
+            return 202;
+        if (statuses.includes(401))
+            return 401;
+        if (statuses.includes(400))
+            return 400;
+        return 404;
+    };
+}
 function serialiseCredentialMutation(lockPath, operation) {
     return withFileLock(lockPath, operation, { waitMs: 5_000, retryIntervalMs: 10 });
 }

package/dist/src/bootstrap/version.js

@@ -124,6 +124,6 @@ export function resolveWakeVersion(options = {}) {
         return `g${headHash.slice(0, 7)}`;
     return '0.1.0-dev';
 }
-export const wakeVersion = "v0.4.35";
+export const wakeVersion = "v0.4.37";
 /** The registry-installable version used by packaged sandbox images. */
 export const wakePackageVersion = packageVersion(defaultRepoRoot) ?? wakeVersion;

package/dist/src/control-plane/application/control-plane-projection.d.ts

@@ -1,8 +1,8 @@
 import type { EventJournal, ProjectionDefinition } from '@atolis-hq/eventing';
 import { ControlEventType, type ControlEvent } from '../contracts/events.js';
 export interface ControlPlaneView {
-    readonly pausedUntil: string | null;
-    readonly reason?: string;
+    readonly dispatchPausedUntil: string | null;
+    readonly dispatchPauseReason?: string;
     readonly runnerPauses: Readonly<Record<string, {
         readonly cause: Extract<ControlEvent['event'], {
             readonly eventType: typeof ControlEventType.RunnerPaused;

package/dist/src/control-plane/application/control-plane-projection.js

@@ -26,7 +26,7 @@ export const controlPlaneProjection = {
     select(event) {
         return selectControlEvent(event) === null ? null : { key: 'global' };
     },
-    initial: () => ({ pausedUntil: null, runnerPauses: {} }),
+    initial: () => ({ dispatchPausedUntil: null, runnerPauses: {} }),
     project(previous, envelope) {
         const event = selectControlEvent(envelope);
         if (event === null)
@@ -35,8 +35,8 @@ export const controlPlaneProjection = {
             case ControlEventType.DispatchPaused:
                 return {
                     ...previous,
-                    pausedUntil: event.event.payload.resumeAt,
-                    reason: event.event.payload.reason,
+                    dispatchPausedUntil: event.event.payload.resumeAt,
+                    dispatchPauseReason: event.event.payload.reason,
                 };
             case ControlEventType.DispatchResumed:
                 return withoutDispatchPause(previous);
@@ -56,8 +56,8 @@ export const controlPlaneProjection = {
     },
 };
 function withoutDispatchPause(previous) {
-    const { reason: _, ...rest } = previous;
-    return { ...rest, pausedUntil: null };
+    const { dispatchPauseReason: _, ...rest } = previous;
+    return { ...rest, dispatchPausedUntil: null };
 }
 export const controlPlaneProjectionDefinitions = [
     controlPlaneProjection,

package/dist/src/control-plane/application/control-plane-service.d.ts

@@ -1,9 +1,9 @@
 import { type EventJournal } from '@atolis-hq/eventing';
 import { type Clock, type IdGenerator } from '../../kernel/index.js';
 export interface ControlPlaneService {
-    pause(idempotencyKey: string): Promise<void>;
-    resume(idempotencyKey: string): Promise<void>;
-    isPaused(): Promise<boolean>;
+    pauseDispatch(idempotencyKey: string): Promise<void>;
+    resumeDispatch(idempotencyKey: string): Promise<void>;
+    isDispatchPaused(): Promise<boolean>;
 }
 export declare function createControlPlaneService(input: {
     readonly journal: EventJournal;

package/dist/src/control-plane/application/control-plane-service.js

@@ -3,13 +3,13 @@ import { createControlPlaneEventData } from '../contracts/event-factory.js';
 import { ControlEventType, selectControlEvent } from '../contracts/events.js';
 import { ControlStreamKind, controlPlaneStream } from '../contracts/streams.js';
 export function createControlPlaneService(input) {
-    // isPaused() is checked many times per pipeline run, so memoize by
+    // isDispatchPaused() is checked many times per pipeline run, so memoize by
     // journal position to skip the read entirely when nothing has moved.
     let cached;
     return {
-        pause: (key) => change(input, key, 'pause'),
-        resume: (key) => change(input, key, 'resume'),
-        async isPaused() {
+        pauseDispatch: (key) => change(input, key, 'pause-dispatch'),
+        resumeDispatch: (key) => change(input, key, 'resume-dispatch'),
+        async isDispatchPaused() {
             const position = await input.journal.latestGlobalPosition();
             if (cached !== undefined && cached.position === position)
                 return cached.paused;
@@ -36,12 +36,15 @@ function isPausedIn(events) {
 async function change(input, idempotencyKey, operation) {
     const stream = controlPlaneStream();
     const events = await input.journal.readStream(stream);
-    const eventType = operation === 'pause' ? ControlEventType.DispatchPaused : ControlEventType.DispatchResumed;
+    const eventType = operation === 'pause-dispatch'
+        ? ControlEventType.DispatchPaused
+        : ControlEventType.DispatchResumed;
     const correlation = correlationId(`control:${operation}:${idempotencyKey}`);
     if (events.some((event) => event.event.eventType === eventType && event.event.correlationId === correlation))
         return;
     const currentlyPaused = isPausedIn(events);
-    if ((operation === 'pause' && currentlyPaused) || (operation === 'resume' && !currentlyPaused))
+    if ((operation === 'pause-dispatch' && currentlyPaused) ||
+        (operation === 'resume-dispatch' && !currentlyPaused))
         return;
     const occurredAt = input.clock.now().toISOString();
     const context = {
@@ -50,7 +53,7 @@ async function change(input, idempotencyKey, operation) {
         occurredAt,
         actor: { kind: EventActorKind.Operator, id: 'web' },
     };
-    const event = operation === 'pause'
+    const event = operation === 'pause-dispatch'
         ? createControlPlaneEventData({
             eventId: `${context.commandId}:${ControlEventType.DispatchPaused}`,
             eventType: ControlEventType.DispatchPaused,

package/dist/src/integrations/application/poll-service.d.ts

@@ -9,5 +9,7 @@ export declare class PollService {
     private readonly instance;
     constructor(journal: EventJournal, instance: ProviderInstance);
     /** Persists every independently durable draft and reports partial progress. */
-    pollOnce(signal: AbortSignal): Promise<PollResult>;
+    pollOnce(signal: AbortSignal, options?: {
+        readonly bypassInterval?: boolean;
+    }): Promise<PollResult>;
 }

package/dist/src/integrations/application/poll-service.js

@@ -7,9 +7,9 @@ export class PollService {
         this.instance = instance;
     }
     /** Persists every independently durable draft and reports partial progress. */
-    async pollOnce(signal) {
+    async pollOnce(signal, options) {
         const adapter = this.instance.adapter;
-        const drafts = await this.instance.source.poll(signal);
+        const drafts = await this.instance.source.poll(signal, options);
         let appended = 0;
         let failed = 0;
         for (const draft of drafts) {

package/dist/src/integrations/contracts/intake.d.ts

@@ -1,7 +1,9 @@
 import type { EventData, EventProcessor } from '@atolis-hq/eventing';
 export type ProviderEventData = EventData<string, unknown>;
 export interface ExternalEventSource {
-    poll(signal: AbortSignal): Promise<readonly ProviderEventData[]>;
+    poll(signal: AbortSignal, options?: {
+        readonly bypassInterval?: boolean;
+    }): Promise<readonly ProviderEventData[]>;
     /** Commits provider cursor state after every draft from the poll is durable. */
     markPollPersisted?(): Promise<void>;
 }

package/dist/src/integrations/contracts/provider.d.ts

@@ -22,6 +22,8 @@ export interface WorkConclusion {
 export interface ProviderServices {
     /** Stable operator-configured UI address included in provider notifications when present. */
     readonly publicUiUrl?: string | undefined;
+    /** Durable provider-owned operational state, rooted at .wake/. */
+    readonly providerStateRoot: string;
     readonly work: WorkService;
     readonly conversations: ConversationService;
     readonly resources: ResourceService;
@@ -73,6 +75,11 @@ export interface ProviderInstance {
     readonly health?: () => readonly AdapterHealthCheck[];
     readonly commands?: () => readonly AdapterCommand[];
     readonly replyPublication?: ReplyPublicationConfig | undefined;
+    readonly webhook?: ProviderWebhook | undefined;
+}
+export interface ProviderWebhook {
+    provision(): Promise<void>;
+    receive(body: Buffer, headers: Readonly<Record<string, string | string[] | undefined>>, trigger: () => void): Promise<404 | 400 | 401 | 202>;
 }
 export type ComposedProviderInstance = Omit<ProviderInstance, 'provider'>;
 export interface ProviderDefinition<Config = unknown> {

package/dist/src/integrations/github/contracts/config.d.ts

@@ -13,6 +13,9 @@ export declare const gitHubConfigSchema: z.ZodObject<{
         lookbackMs: z.ZodDefault<z.ZodNumber>;
         intervalMs: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>;
+    webhooks: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
     intake: z.ZodDefault<z.ZodArray<z.ZodObject<{
         where: z.ZodObject<{
             kind: z.ZodOptional<z.ZodEnum<{

package/dist/src/integrations/github/contracts/config.js

@@ -88,6 +88,10 @@ export const gitHubConfigSchema = z
         lookbackMs: 60_000,
         intervalMs: 30_000,
     }),
+    webhooks: z
+        .object({ enabled: z.boolean().default(false) })
+        .strict()
+        .default({ enabled: false }),
     intake: z.array(intakeRuleSchema).default([]),
     publication: z
         .object({

package/dist/src/integrations/github/index.d.ts

@@ -31,4 +31,6 @@ export * from './infrastructure/issue-source.js';
 export * from './infrastructure/pr-source.js';
 export * from './infrastructure/review-source.js';
 export * from './infrastructure/source.js';
+export * from './infrastructure/webhook.js';
+export * from './infrastructure/webhook-state.js';
 export * from './provider.js';

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

@@ -31,4 +31,6 @@ export * from './infrastructure/issue-source.js';
 export * from './infrastructure/pr-source.js';
 export * from './infrastructure/review-source.js';
 export * from './infrastructure/source.js';
+export * from './infrastructure/webhook.js';
+export * from './infrastructure/webhook-state.js';
 export * from './provider.js';

package/dist/src/integrations/github/infrastructure/adapter-health-registry.d.ts

@@ -1,5 +1,5 @@
 import type { AdapterHealthCheck } from '../../contracts/provider.js';
-export type GitHubHealthChannel = 'poll' | 'deliver';
+export type GitHubHealthChannel = 'poll' | 'deliver' | 'webhook';
 export interface GitHubAdapterHealthRegistry {
     recordSuccess(repository: string, channel: GitHubHealthChannel): void;
     recordFailure(repository: string, channel: GitHubHealthChannel, error: unknown): void;

package/dist/src/integrations/github/infrastructure/client.d.ts

@@ -3,6 +3,22 @@ import type { GitHubIssueQueryFilters } from '../contracts/issue-query.js';
 import { GitHubOutboundAction } from '../contracts/vocabulary.js';
 export declare function redactGitHubRequestMessage(message: unknown): string;
 export declare function createGitHubClient(token: string): {
+    getHook: (owner: string, repo: string, hookId: number) => Promise<void>;
+    createHook: (input: {
+        owner: string;
+        repo: string;
+        url: string;
+        secret: string;
+        events: readonly string[];
+    }) => Promise<number>;
+    updateHook: (input: {
+        owner: string;
+        repo: string;
+        hookId: number;
+        url: string;
+        secret: string;
+        events: readonly string[];
+    }) => Promise<void>;
     authenticatedLogin: () => Promise<string>;
     collaboratorPermission: (owner: string, repo: string, login: string) => Promise<ProviderPermission>;
     getIssueLabelsFresh: (owner: string, repo: string, issueNumber: number) => Promise<string[]>;

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

@@ -62,6 +62,35 @@ export function createGitHubClient(token) {
             });
         },
         deliver: (command) => deliver(octokit, command),
+        ...createGitHubWebhookClient(octokit),
+    };
+}
+function createGitHubWebhookClient(octokit) {
+    return {
+        getHook: async (owner, repo, hookId) => {
+            await octokit.rest.repos.getWebhook({ owner, repo, hook_id: hookId });
+        },
+        createHook: async (input) => {
+            const response = await octokit.rest.repos.createWebhook({
+                owner: input.owner,
+                repo: input.repo,
+                name: 'web',
+                active: true,
+                events: [...input.events],
+                config: { url: input.url, content_type: 'json', secret: input.secret },
+            });
+            return response.data.id;
+        },
+        updateHook: async (input) => {
+            await octokit.rest.repos.updateWebhook({
+                owner: input.owner,
+                repo: input.repo,
+                hook_id: input.hookId,
+                active: true,
+                events: [...input.events],
+                config: { url: input.url, content_type: 'json', secret: input.secret },
+            });
+        },
     };
 }
 function createGitHubReadClient(octokit, cache) {

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

@@ -20,9 +20,11 @@ export function createGitHubSource(config, client, adapter, requests = createGit
     // the same tradeoff already made for lastEventIds above.
     let lastPolledAt;
     return {
-        async poll(signal) {
+        async poll(signal, options) {
             const currentTime = now();
-            if (lastPolledAt !== undefined && currentTime - lastPolledAt < config.polling.intervalMs) {
+            if (options?.bypassInterval !== true &&
+                lastPolledAt !== undefined &&
+                currentTime - lastPolledAt < config.polling.intervalMs) {
                 return [];
             }
             lastPolledAt = currentTime;

package/dist/src/integrations/github/infrastructure/webhook-state.d.ts

@@ -0,0 +1,16 @@
+import type { AdapterId } from '../../contracts/identifiers.js';
+export interface GitHubWebhookState {
+    readonly secret: string;
+    readonly hookId?: number;
+}
+/** Provider operational state: intentionally outside configuration and projections. */
+export declare class GitHubWebhookStateStore {
+    private readonly root;
+    private readonly adapter;
+    constructor(root: string, adapter: AdapterId);
+    load(owner: string, repo: string): Promise<GitHubWebhookState>;
+    save(owner: string, repo: string, state: GitHubWebhookState): Promise<void>;
+    serialise<Value>(owner: string, repo: string, operation: () => Promise<Value>): Promise<Value>;
+    private path;
+    private lockPath;
+}

package/dist/src/integrations/github/infrastructure/webhook-state.js

@@ -0,0 +1,70 @@
+import { randomBytes } from 'node:crypto';
+import { mkdir, open, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+/** Provider operational state: intentionally outside configuration and projections. */
+export class GitHubWebhookStateStore {
+    root;
+    adapter;
+    constructor(root, adapter) {
+        this.root = root;
+        this.adapter = adapter;
+    }
+    async load(owner, repo) {
+        const path = this.path(owner, repo);
+        try {
+            const parsed = JSON.parse(await readFile(path, 'utf8'));
+            if (typeof parsed === 'object' &&
+                parsed !== null &&
+                'secret' in parsed &&
+                typeof parsed.secret === 'string' &&
+                ('hookId' in parsed ? typeof parsed.hookId === 'number' : true))
+                return parsed;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        const state = { secret: randomBytes(32).toString('hex') };
+        await this.save(owner, repo, state);
+        return state;
+    }
+    async save(owner, repo, state) {
+        const path = this.path(owner, repo);
+        await mkdir(join(this.root, 'github-webhooks', this.adapter), { recursive: true });
+        const temporary = `${path}.${process.pid}.tmp`;
+        await writeFile(temporary, JSON.stringify(state), { encoding: 'utf8', mode: 0o600 });
+        await rename(temporary, path);
+    }
+    async serialise(owner, repo, operation) {
+        await mkdir(join(this.root, 'locks'), { recursive: true });
+        const lock = this.lockPath(owner, repo);
+        await acquireLock(lock);
+        try {
+            return await operation();
+        }
+        finally {
+            await unlink(lock);
+        }
+    }
+    path(owner, repo) {
+        return join(this.root, 'github-webhooks', this.adapter, `${encodeURIComponent(owner)}--${encodeURIComponent(repo)}.json`);
+    }
+    lockPath(owner, repo) {
+        return join(this.root, 'locks', `github-webhook-${this.adapter}-${encodeURIComponent(owner)}--${encodeURIComponent(repo)}.lock`);
+    }
+}
+async function acquireLock(path) {
+    const deadline = Date.now() + 5_000;
+    while (true) {
+        try {
+            const handle = await open(path, 'wx', 0o600);
+            await handle.close();
+            return;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST' || Date.now() >= deadline)
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    }
+}

package/dist/src/integrations/github/infrastructure/webhook.d.ts

@@ -0,0 +1,24 @@
+import type { AdapterId } from '../../contracts/identifiers.js';
+import type { ProviderWebhook } from '../../contracts/provider.js';
+import type { GitHubConfig } from '../contracts/config.js';
+import type { GitHubAdapterHealthRegistry } from './adapter-health-registry.js';
+interface HookClient {
+    getHook(owner: string, repo: string, hookId: number): Promise<void>;
+    createHook(input: {
+        owner: string;
+        repo: string;
+        url: string;
+        secret: string;
+        events: readonly string[];
+    }): Promise<number>;
+    updateHook(input: {
+        owner: string;
+        repo: string;
+        hookId: number;
+        url: string;
+        secret: string;
+        events: readonly string[];
+    }): Promise<void>;
+}
+export declare function createGitHubWebhook(adapter: AdapterId, config: GitHubConfig, publicUrl: string | undefined, root: string, client: HookClient, health: GitHubAdapterHealthRegistry): ProviderWebhook;
+export {};