@atolis-hq/wake 0.2.96 → 0.3.0

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

@@ -0,0 +1,127 @@
+import { z } from 'zod';
+import { ProviderPermission, PullRequestCheckState, PullRequestState, ReviewActorKind, ReviewerAuthorizationSource, } from '../../../activities/index.js';
+import { eventEnvelopeSchema, } from '../../../kernel/index.js';
+import { adapterId } from '../../contracts/identifiers.js';
+import { ExternalWorkOutcome } from '../../contracts/outcome-vocabulary.js';
+import { IntegrationStreamKind } from '../../contracts/streams.js';
+export const GitHubEventType = {
+    WorkObserved: 'integration.github.work-observed',
+    CommentObserved: 'integration.github.comment-observed',
+    DeliveryObserved: 'integration.github.delivery-observed',
+};
+const streamSchema = z
+    .object({
+    kind: z.literal(IntegrationStreamKind.Integration),
+    id: z.string().transform(adapterId),
+})
+    .strict();
+const rawSchema = z.record(z.string(), z.unknown());
+const actorSchema = z
+    .object({ id: z.string(), kind: z.enum([ReviewActorKind.Human, ReviewActorKind.Bot]) })
+    .strict();
+const authorizationSchema = z.discriminatedUnion('source', [
+    z
+        .object({
+        source: z.literal(ReviewerAuthorizationSource.ConfiguredReviewer),
+        reviewerId: z.string(),
+    })
+        .strict(),
+    z
+        .object({
+        source: z.literal(ReviewerAuthorizationSource.ProviderPermission),
+        permission: z.enum([
+            ProviderPermission.None,
+            ProviderPermission.Read,
+            ProviderPermission.Triage,
+            ProviderPermission.Write,
+            ProviderPermission.Maintain,
+            ProviderPermission.Admin,
+        ]),
+    })
+        .strict(),
+    z.object({ source: z.literal(ReviewerAuthorizationSource.None) }).strict(),
+]);
+const eventSchema = z.discriminatedUnion('eventType', [
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(GitHubEventType.WorkObserved),
+        stream: streamSchema,
+        payload: z
+            .object({
+            externalKey: z.string(),
+            kind: z.enum(['issue', 'pull-request']),
+            title: z.string(),
+            body: z.string(),
+            state: z.enum([PullRequestState.Open, PullRequestState.Closed, PullRequestState.Merged]),
+            outcome: z.enum([ExternalWorkOutcome.Completed, ExternalWorkOutcome.Cancelled]).optional(),
+            revision: z.string(),
+            headRevision: z.string().optional(),
+            baseRevision: z.string().optional(),
+            checks: z
+                .enum([
+                PullRequestCheckState.Unknown,
+                PullRequestCheckState.Pending,
+                PullRequestCheckState.Passing,
+                PullRequestCheckState.Failing,
+            ])
+                .optional(),
+            actor: actorSchema,
+            labels: z.array(z.string()).readonly().optional(),
+            assignees: z.array(z.string()).readonly().optional(),
+            raw: rawSchema,
+        })
+            .strict(),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(GitHubEventType.CommentObserved),
+        stream: streamSchema,
+        payload: z.discriminatedUnion('reviewKind', [
+            z
+                .object({
+                externalKey: z.string(),
+                reviewKind: z.literal('formal'),
+                body: z.string(),
+                revision: z.string(),
+                actor: actorSchema,
+                resourceAuthorId: z.string().optional(),
+                authorization: authorizationSchema.optional(),
+                raw: rawSchema,
+            })
+                .strict(),
+            z
+                .object({
+                externalKey: z.string(),
+                reviewKind: z.literal('issue'),
+                body: z.string(),
+                revision: z.string(),
+                location: z
+                    .object({
+                    path: z.string(),
+                    line: z.number().int(),
+                    side: z.enum(['LEFT', 'RIGHT']),
+                })
+                    .strict()
+                    .optional(),
+                actor: actorSchema,
+                raw: rawSchema,
+            })
+                .strict(),
+        ]),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(GitHubEventType.DeliveryObserved),
+        stream: streamSchema,
+        payload: z.object({ deliveryId: z.string(), raw: rawSchema }).strict(),
+    }),
+]);
+export function decodeGitHubAdapterEvent(event) {
+    const result = eventSchema.safeParse(event);
+    if (!result.success)
+        throw invalidGitHubEvent(event, result.error);
+    return result.data;
+}
+export function selectGitHubAdapterEvent(event) {
+    return event.eventType.startsWith('integration.github.') ? decodeGitHubAdapterEvent(event) : null;
+}
+function invalidGitHubEvent(event, cause) {
+    return new Error(`Invalid GitHub adapter event ${event.eventId} at global position ${event.globalPosition} (${event.eventType}): ${cause.message}`, { cause });
+}

package/dist/src/integrations/github/contracts/external-key.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+const keyPattern = /^([^/\s#]+)\/([^/\s#]+)#(\d+)$/;
+export function formatGitHubResourceKey(locator) {
+    return `${locator.owner}/${locator.repo}#${locator.number}`;
+}
+export function parseGitHubResourceKey(key) {
+    const matched = keyPattern.exec(key);
+    if (matched === null)
+        throw new Error(`Invalid GitHub resource key: ${key}`);
+    const parsed = z.coerce
+        .number()
+        .int()
+        .positive()
+        .max(Number.MAX_SAFE_INTEGER, 'Expected safe integer')
+        .safeParse(matched[3]);
+    if (!parsed.success)
+        throw new Error(`Invalid GitHub resource key: ${key}: ${parsed.error.issues.map((issue) => issue.message).join('; ')}`, { cause: parsed.error });
+    return { owner: matched[1], repo: matched[2], number: parsed.data };
+}

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

@@ -0,0 +1,9 @@
+export function gitHubLabelNames(payload) {
+    return (payload.labels ?? []).flatMap((label) => {
+        const name = typeof label === 'string' ? label : label.name;
+        return name === undefined ? [] : [name];
+    });
+}
+export function gitHubAssigneeLogins(payload) {
+    return (payload.assignees ?? []).flatMap((assignee) => assignee?.login === undefined ? [] : [assignee.login]);
+}

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

@@ -0,0 +1,55 @@
+import { MergeMethod } from '../../../activities/index.js';
+import { defineClosedVocabulary } from '../../../kernel/index.js';
+import { adapterId } from '../../contracts/identifiers.js';
+export const GitHubAdapter = adapterId('github');
+export const BuiltInAdapterId = { GitHub: GitHubAdapter };
+export const GitHubCheckRunStatus = defineClosedVocabulary({
+    Queued: 'queued',
+    InProgress: 'in_progress',
+    Completed: 'completed',
+});
+// GitHub's own issue/PR listing filter. Distinct from Wake's MatchMode, which
+// happens to share the token "all" but means something unrelated.
+export const GitHubListState = defineClosedVocabulary({
+    All: 'all',
+    Open: 'open',
+    Closed: 'closed',
+});
+export const GitHubReviewState = defineClosedVocabulary({
+    Approved: 'APPROVED',
+    ChangesRequested: 'CHANGES_REQUESTED',
+});
+// Label families Wake owns and republishes. Nothing may tag intake from them: the
+// adapter would observe Wake's own marker, re-route, and publish again.
+export const GitHubWakeStatusLabel = defineClosedVocabulary({
+    Working: 'working',
+    AwaitingApproval: 'awaiting-approval',
+    Blocked: 'blocked',
+    Completed: 'completed',
+    Failed: 'failed',
+});
+export const GitHubWakeMarkerPrefix = defineClosedVocabulary({
+    Status: 'wake:status.',
+    Stage: 'wake:stage.',
+    Workflow: 'wake:workflow.',
+});
+const GitHubWakeMarkerNamespace = 'wake:';
+export function isGitHubWakeMarker(label) {
+    return label.startsWith(GitHubWakeMarkerNamespace);
+}
+// Facets a GitHub intake rule may constrain, and the observation fields they read.
+export const GitHubIntakeFacet = {
+    Kind: 'kind',
+    Label: 'label',
+    Assignee: 'assignee',
+    Author: 'author',
+};
+export const UnknownGitHubIdentity = 'unknown-github-identity';
+export const UnknownGitHubRevision = 'unknown-github-revision';
+export const GitHubOutboundAction = {
+    Approve: 'approve',
+    EnableAutoMerge: 'enable-auto-merge',
+    Merge: MergeMethod.Merge,
+    Status: 'status',
+    Reply: 'reply',
+};

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

@@ -0,0 +1,31 @@
+export * from '../../kernel/index.js';
+export * from '../contracts/identifiers.js';
+export * from '../contracts/streams.js';
+export * from '../delivery/application/delivery-outcome-reactor.js';
+export * from '../delivery/application/delivery-projector.js';
+export * from '../delivery/application/delivery-service.js';
+export * from '../delivery/contracts/commands.js';
+export * from '../delivery/contracts/config.js';
+export * from '../delivery/contracts/event-factory.js';
+export * from '../delivery/contracts/events.js';
+export * from '../delivery/contracts/intents.js';
+export * from '../delivery/contracts/views.js';
+export * from '../delivery/contracts/vocabulary.js';
+export * from './application/inbound-translator.js';
+export * from './application/agent-context-reader.js';
+export * from './application/poll-service.js';
+export * from './application/resource-links.js';
+export * from './application/review-command-translator.js';
+export * from './application/wake-labels.js';
+export * from './contracts/config.js';
+export * from './contracts/events.js';
+export * from './contracts/payloads.js';
+export * from './contracts/vocabulary.js';
+export * from './infrastructure/client.js';
+export * from './infrastructure/etag-cache.js';
+export * from './infrastructure/gh-auth.js';
+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 './provider.js';

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

@@ -0,0 +1,214 @@
+/* eslint-disable max-lines */
+import { PullRequestState } from '../../../activities/index.js';
+import { GitHubListState } from '../contracts/vocabulary.js';
+import { fetchPaginatedWithEtag, fetchWithEtag } from './etag-cache.js';
+export function listIssues(octokit, cache, owner, repo, maxResults) {
+    return fetchPaginatedWithEtag({
+        cache,
+        key: `issues:${owner}/${repo}`,
+        maxResults,
+        pages: (headers) => octokit.paginate.iterator(octokit.rest.issues.listForRepo, {
+            owner,
+            repo,
+            state: GitHubListState.All,
+            per_page: Math.min(maxResults, 100),
+            ...(headers === undefined ? {} : { headers }),
+        }),
+    }).then((items) => items.map(normalizeIssue));
+}
+function normalizeIssue(issue) {
+    return {
+        number: issue.number,
+        title: issue.title,
+        body: issue.body ?? null,
+        state: issue.state === PullRequestState.Closed ? PullRequestState.Closed : PullRequestState.Open,
+        ...(issue.state_reason === undefined ? {} : { state_reason: issue.state_reason }),
+        updated_at: issue.updated_at,
+        ...(issue.user === undefined ? {} : { user: issue.user }),
+        ...(issue.labels === undefined ? {} : { labels: issue.labels }),
+        ...(issue.assignees === undefined ? {} : { assignees: issue.assignees }),
+        ...(issue.pull_request === undefined ? {} : { pull_request: issue.pull_request }),
+    };
+}
+export async function listPullRequests(octokit, cache, owner, repo, maxResults) {
+    const pullRequests = await fetchPaginatedWithEtag({
+        cache,
+        key: `pulls:${owner}/${repo}`,
+        maxResults,
+        pages: (headers) => octokit.paginate.iterator(octokit.rest.pulls.list, {
+            owner,
+            repo,
+            state: GitHubListState.All,
+            per_page: Math.min(maxResults, 100),
+            ...(headers === undefined ? {} : { headers }),
+        }),
+    });
+    return pullRequests.map(normalizePullRequestState);
+}
+export async function listReviews(octokit, cache, owner, repo, pullNumber, pageSize) {
+    const reviews = await fetchPaginatedWithEtag({
+        cache,
+        key: `reviews:${owner}/${repo}#${pullNumber}`,
+        pages: (headers) => octokit.paginate.iterator(octokit.rest.pulls.listReviews, {
+            owner,
+            repo,
+            pull_number: pullNumber,
+            per_page: pageSize,
+            ...(headers === undefined ? {} : { headers }),
+        }),
+    });
+    return reviews.map((review) => ({
+        id: review.id,
+        state: review.state,
+        body: review.body,
+        commit_id: review.commit_id ?? '',
+        submitted_at: review.submitted_at ?? '',
+        ...(review.user === undefined ? {} : { user: review.user }),
+    }));
+}
+export async function listReviewComments(octokit, cache, owner, repo, pullNumber, pageSize) {
+    const comments = await fetchPaginatedWithEtag({
+        cache,
+        key: `review-comments:${owner}/${repo}#${pullNumber}`,
+        pages: (headers) => octokit.paginate.iterator(octokit.rest.pulls.listReviewComments, {
+            owner,
+            repo,
+            pull_number: pullNumber,
+            per_page: Math.min(pageSize, 100),
+            ...(headers === undefined ? {} : { headers }),
+        }),
+    });
+    return comments.map((comment) => ({
+        id: comment.id,
+        body: comment.body ?? null,
+        created_at: comment.created_at,
+        updated_at: comment.updated_at,
+        ...(comment.user === undefined ? {} : { user: comment.user }),
+        ...(comment.path === undefined ? {} : { path: comment.path }),
+        ...(comment.line === undefined || comment.line === null ? {} : { line: comment.line }),
+        ...(comment.side === undefined ? {} : { side: comment.side }),
+    }));
+}
+export function listCheckRunsForRef(octokit, cache, owner, repo, ref) {
+    return fetchPaginatedWithEtag({
+        cache,
+        key: `check-runs:${owner}/${repo}@${ref}`,
+        pages: (headers) => octokit.paginate.iterator(octokit.rest.checks.listForRef, {
+            owner,
+            repo,
+            ref,
+            per_page: 100,
+            ...(headers === undefined ? {} : { headers }),
+        }),
+    });
+}
+export function getCombinedStatusForRef(octokit, cache, owner, repo, ref) {
+    return fetchPaginatedWithEtag({
+        cache,
+        key: `combined-status:${owner}/${repo}@${ref}`,
+        pages: (headers) => ({
+            async *[Symbol.asyncIterator]() {
+                let page = 1;
+                let count = 0;
+                while (true) {
+                    const response = await octokit.rest.repos.getCombinedStatusForRef({
+                        owner,
+                        repo,
+                        ref,
+                        per_page: 100,
+                        page,
+                        ...(headers === undefined ? {} : { headers }),
+                    });
+                    const statuses = response.data.statuses;
+                    count += statuses.length;
+                    yield { data: statuses, headers: response.headers };
+                    if (statuses.length < 100 || count >= response.data.total_count)
+                        return;
+                    page += 1;
+                }
+            },
+        }),
+    });
+}
+export function branch(octokit, cache, owner, repo, name) {
+    return fetchWithEtag({
+        cache,
+        key: `branch:${owner}/${repo}/${name}`,
+        request: async (headers) => {
+            const response = await octokit.rest.repos.getBranch({
+                owner,
+                repo,
+                branch: name,
+                ...(headers === undefined ? {} : { headers }),
+            });
+            return {
+                data: response.data,
+                ...(response.headers.etag === undefined ? {} : { etag: response.headers.etag }),
+            };
+        },
+    });
+}
+export function getIssueLabels(octokit, cache, owner, repo, issueNumber) {
+    return fetchWithEtag({
+        cache,
+        key: `issue:${owner}/${repo}#${issueNumber}`,
+        request: async (headers) => {
+            const response = await octokit.rest.issues.get({
+                owner,
+                repo,
+                issue_number: issueNumber,
+                ...(headers === undefined ? {} : { headers }),
+            });
+            return {
+                data: response.data.labels.flatMap((label) => typeof label === 'string' ? [label] : label.name === undefined ? [] : [label.name]),
+                ...(response.headers.etag === undefined ? {} : { etag: response.headers.etag }),
+            };
+        },
+    });
+}
+export function getPullRequest(octokit, cache, owner, repo, pullNumber) {
+    return fetchWithEtag({
+        cache,
+        key: `pull:${owner}/${repo}#${pullNumber}`,
+        request: async (headers) => {
+            const response = await octokit.rest.pulls.get({
+                owner,
+                repo,
+                pull_number: pullNumber,
+                ...(headers === undefined ? {} : { headers }),
+            });
+            return {
+                data: response.data,
+                ...(response.headers.etag === undefined ? {} : { etag: response.headers.etag }),
+            };
+        },
+    });
+}
+function normalizePullRequestState(pullRequest) {
+    return {
+        ...pullRequest,
+        state: pullRequest.state === PullRequestState.Closed
+            ? PullRequestState.Closed
+            : PullRequestState.Open,
+    };
+}
+export async function listIssueComments(octokit, cache, owner, repo, issueNumber, pageSize) {
+    const comments = await fetchPaginatedWithEtag({
+        cache,
+        key: `issue-comments:${owner}/${repo}#${issueNumber}`,
+        pages: (headers) => octokit.paginate.iterator(octokit.rest.issues.listComments, {
+            owner,
+            repo,
+            issue_number: issueNumber,
+            per_page: Math.min(pageSize, 100),
+            ...(headers === undefined ? {} : { headers }),
+        }),
+    });
+    return comments.map((comment) => ({
+        id: comment.id,
+        body: comment.body ?? null,
+        created_at: comment.created_at,
+        updated_at: comment.updated_at,
+        ...(comment.user === undefined ? {} : { user: comment.user }),
+    }));
+}

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

@@ -0,0 +1,132 @@
+import { Octokit } from '@octokit/rest';
+import { MergeMethod } from '../../../activities/index.js';
+import { GitHubOutboundAction } from '../contracts/vocabulary.js';
+import { branch, getCombinedStatusForRef, getIssueLabels, getPullRequest, listCheckRunsForRef, listIssueComments, listIssues, listPullRequests, listReviewComments, listReviews, } from './client-reads.js';
+import { createEtagCache } from './etag-cache.js';
+// Octokit's request-log plugin reports every non-2xx response through this
+// callback, including the expected 304 responses produced by conditional ETag
+// reads. Keep those cache hits quiet, but retain a small, safe operator signal
+// for actual GitHub failures. Octokit may pass error context after the message;
+// deliberately ignore it because it can contain request authentication data.
+function requestLogStatus(message) {
+    const match = / - (\d{3}) with id /.exec(message);
+    return match === null ? undefined : Number(match[1]);
+}
+export function redactGitHubRequestMessage(message) {
+    if (typeof message !== 'string')
+        return 'GitHub request failed';
+    return message
+        .replace(/\b(?:gh[pousr]_[A-Za-z0-9_]+|github_pat_[A-Za-z0-9_]+)\b/g, '<redacted>')
+        .replace(/\b(?:bearer|token|basic)\s+\S+/gi, '<redacted>')
+        .replace(/([?&](?:access_token|token|authorization)=)[^&\s]+/gi, '$1<redacted>');
+}
+function logGitHubRequestFailure(message) {
+    const text = redactGitHubRequestMessage(message);
+    if (requestLogStatus(text) === 304)
+        return;
+    process.stderr.write(`GitHub request failed: ${text}\n`);
+}
+export function createGitHubClient(token) {
+    const octokit = new Octokit({
+        auth: token,
+        log: { debug() { }, info() { }, warn() { }, error: logGitHubRequestFailure },
+    });
+    const cache = createEtagCache();
+    return {
+        authenticatedLogin: async () => (await octokit.rest.users.getAuthenticated()).data.login,
+        listIssues: (owner, repo, maxResults) => listIssues(octokit, cache, owner, repo, maxResults),
+        listPullRequests: (owner, repo, maxResults) => listPullRequests(octokit, cache, owner, repo, maxResults),
+        listIssueComments: (owner, repo, issueNumber, pageSize) => listIssueComments(octokit, cache, owner, repo, issueNumber, pageSize),
+        listReviewComments: (owner, repo, pullNumber, pageSize) => listReviewComments(octokit, cache, owner, repo, pullNumber, pageSize),
+        getIssueLabels: (owner, repo, issueNumber) => getIssueLabels(octokit, cache, owner, repo, issueNumber),
+        setIssueLabels: async (owner, repo, issueNumber, labels) => {
+            await octokit.rest.issues.setLabels({
+                owner,
+                repo,
+                issue_number: issueNumber,
+                labels: [...labels],
+            });
+        },
+        getPullRequest: (owner, repo, pullNumber) => getPullRequest(octokit, cache, owner, repo, pullNumber),
+        listReviews: (owner, repo, pullNumber, pageSize) => listReviews(octokit, cache, owner, repo, pullNumber, pageSize),
+        listCheckRunsForRef: (owner, repo, ref) => listCheckRunsForRef(octokit, cache, owner, repo, ref),
+        getCombinedStatusForRef: (owner, repo, ref) => getCombinedStatusForRef(octokit, cache, owner, repo, ref),
+        branch: (owner, repo, name) => branch(octokit, cache, owner, repo, name),
+        deliver: (command) => deliver(octokit, command),
+    };
+}
+async function deliver(octokit, command) {
+    const marker = `<!-- wake:delivery:${command.idempotencyKey} -->`;
+    if (command.action === 'approve') {
+        if (command.pull_number === undefined)
+            throw new Error('GitHub approval requires a pull request');
+        const response = await octokit.rest.pulls.createReview({
+            owner: command.owner,
+            repo: command.repo,
+            pull_number: command.pull_number,
+            event: 'APPROVE',
+            body: marker,
+        });
+        return String(response.data.id);
+    }
+    if (command.action === MergeMethod.Merge) {
+        if (command.pull_number === undefined)
+            throw new Error('GitHub merge requires a pull request');
+        return directMerge(octokit, command);
+    }
+    if (command.action === GitHubOutboundAction.EnableAutoMerge) {
+        return enableAutoMerge(octokit, command);
+    }
+    const issueNumber = command.issue_number ?? command.pull_number;
+    if (issueNumber === undefined)
+        throw new Error('GitHub comment requires an issue or pull request');
+    const response = await octokit.rest.issues.createComment({
+        owner: command.owner,
+        repo: command.repo,
+        issue_number: issueNumber,
+        body: `${command.body ?? ''}\n${marker}`,
+    });
+    return String(response.data.id);
+}
+async function enableAutoMerge(octokit, command) {
+    if (command.pull_number === undefined)
+        throw new Error('GitHub auto-merge requires a pull request');
+    if (command.merge_method === undefined)
+        throw new Error('GitHub auto-merge requires an explicit merge method');
+    const pullRequest = await octokit.rest.pulls.get({
+        owner: command.owner,
+        repo: command.repo,
+        pull_number: command.pull_number,
+    });
+    try {
+        const result = await octokit.graphql(`mutation EnableWakeAutoMerge($pullRequestId: ID!, $mergeMethod: PullRequestMergeMethod!) {
+        enablePullRequestAutoMerge(input: { pullRequestId: $pullRequestId, mergeMethod: $mergeMethod }) {
+          pullRequest { id }
+        }
+      }`, {
+            pullRequestId: pullRequest.data.node_id,
+            mergeMethod: graphQlMergeMethod(command.merge_method),
+        });
+        return result.enablePullRequestAutoMerge.pullRequest.id;
+    }
+    catch (error) {
+        if (!isAlreadyCleanError(error))
+            throw error;
+        return directMerge(octokit, command);
+    }
+}
+async function directMerge(octokit, command) {
+    const response = await octokit.rest.pulls.merge({
+        owner: command.owner,
+        repo: command.repo,
+        pull_number: command.pull_number,
+        ...(command.merge_method === undefined ? {} : { merge_method: command.merge_method }),
+    });
+    return response.data.sha;
+}
+function graphQlMergeMethod(method) {
+    return method.toUpperCase();
+}
+function isAlreadyCleanError(error) {
+    return error instanceof Error && /is in clean status/i.test(error.message);
+}

package/dist/src/integrations/github/infrastructure/content-fingerprint.js

@@ -0,0 +1,10 @@
+import { createHash } from 'node:crypto';
+import { isGitHubWakeMarker } from '../contracts/vocabulary.js';
+// Wake's own status/stage/workflow labels are excluded so republishing them never
+// looks like an external change — see reconcileGitHubWakeLabels.
+export function gitHubContentFingerprint(input) {
+    return createHash('sha256').update(JSON.stringify(input)).digest('hex');
+}
+export function withoutWakeMarkers(labels) {
+    return [...labels].filter((label) => !isGitHubWakeMarker(label)).sort();
+}

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

@@ -0,0 +1,31 @@
+import { DeliveryResultKind } from '../../delivery/contracts/vocabulary.js';
+const GitHubDeliveryFailureCode = 'github-error';
+export function createGitHubDelivery(deliver) {
+    return {
+        async deliver(intent) {
+            try {
+                return {
+                    kind: DeliveryResultKind.Confirmed,
+                    externalId: await deliver(intent, intent.intentEventId),
+                };
+            }
+            catch (error) {
+                return {
+                    kind: DeliveryResultKind.Failed,
+                    code: GitHubDeliveryFailureCode,
+                    message: githubErrorMessage(error),
+                };
+            }
+        },
+        async reconcile() {
+            return { kind: DeliveryResultKind.Unknown };
+        },
+    };
+}
+function githubErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'string')
+        return error;
+    return 'GitHub delivery failed with a non-Error rejection';
+}