@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/integrations/github/infrastructure/etag-cache.js

@@ -0,0 +1,56 @@
+export const createEtagCache = () => new Map();
+export async function fetchWithEtag(input) {
+    const cached = input.cache.get(input.key);
+    try {
+        const response = await input.request(cached === undefined ? undefined : { 'if-none-match': cached.etag });
+        if (response.etag !== undefined)
+            input.cache.set(input.key, { etag: response.etag, data: response.data });
+        return response.data;
+    }
+    catch (error) {
+        if (status(error) === 304 && cached !== undefined)
+            return cached.data;
+        throw error;
+    }
+}
+export async function fetchPaginatedWithEtag(input) {
+    const cached = input.cache.get(input.key);
+    const values = [];
+    let pages = 0;
+    let etag;
+    try {
+        for await (const page of input.pages(cached === undefined ? undefined : { 'if-none-match': cached.etag })) {
+            pages += 1;
+            etag = page.headers?.etag;
+            values.push(...page.data);
+            if (reachedLimit(values.length, input.maxResults))
+                break;
+        }
+    }
+    catch (error) {
+        const notModified = cached !== undefined && status(error) === 304;
+        if (!notModified)
+            throw error;
+        return truncate(cached.data, input.maxResults);
+    }
+    const data = truncate(values, input.maxResults);
+    if (pages <= 1 && etag !== undefined)
+        input.cache.set(input.key, { etag, data });
+    else
+        input.cache.delete(input.key);
+    return data;
+}
+function reachedLimit(count, maxResults) {
+    return maxResults !== undefined && count >= maxResults;
+}
+function truncate(values, maxResults) {
+    return maxResults === undefined ? values : values.slice(0, maxResults);
+}
+function status(error) {
+    return typeof error === 'object' &&
+        error !== null &&
+        'status' in error &&
+        typeof error.status === 'number'
+        ? error.status
+        : undefined;
+}

package/dist/src/integrations/github/infrastructure/gh-auth.js

@@ -0,0 +1,19 @@
+import { execFileSync } from 'node:child_process';
+/** Resolves the credential held by the GitHub CLI inside the Wake sandbox. */
+export function resolveGitHubCliToken(run = runGhAuthToken) {
+    try {
+        const token = run('gh', ['auth', 'token']).trim();
+        if (token.length > 0)
+            return token;
+    }
+    catch {
+        // The common cause is an unauthenticated or unavailable GitHub CLI.
+    }
+    throw new Error('GitHub authentication is unavailable. Run `wake sandbox setup` and complete `gh auth login`.');
+}
+function runGhAuthToken(command, arguments_) {
+    return execFileSync(command, arguments_, {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+    });
+}

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

@@ -0,0 +1,109 @@
+import { PullRequestState, ReviewActorKind } from '../../../activities/index.js';
+import { createEventDraft, EventActorKind, EventSourceKind } from '../../../kernel/index.js';
+import { ExternalWorkOutcome } from '../../contracts/outcome-vocabulary.js';
+import { integrationStream } from '../../contracts/streams.js';
+import { GitHubEventType } from '../contracts/events.js';
+import { formatGitHubResourceKey } from '../contracts/external-key.js';
+import { gitHubAssigneeLogins, gitHubLabelNames, } from '../contracts/payloads.js';
+import { GitHubAdapter, UnknownGitHubIdentity } from '../contracts/vocabulary.js';
+import { gitHubContentFingerprint, withoutWakeMarkers } from './content-fingerprint.js';
+export function issueObservation(input) {
+    const key = formatGitHubResourceKey({
+        ...parseRepository(input.repository),
+        number: input.issue.number,
+    });
+    const actor = {
+        id: input.issue.user?.login ?? UnknownGitHubIdentity,
+        kind: input.issue.user?.type === 'Bot' ? ReviewActorKind.Bot : ReviewActorKind.Human,
+    };
+    const labels = gitHubLabelNames(input.issue);
+    const assignees = gitHubAssigneeLogins(input.issue);
+    const outcome = issueOutcome(input.issue);
+    // Wake's own status/stage/workflow labels are excluded here so republishing them
+    // never looks like an external change and re-triggers discovery.
+    const fingerprint = gitHubContentFingerprint({
+        title: input.issue.title,
+        body: input.issue.body ?? '',
+        state: input.issue.state,
+        outcome,
+        actor,
+        labels: withoutWakeMarkers(labels),
+        assignees: [...assignees].sort(),
+    });
+    return createEventDraft({
+        eventId: `github:issue:${key}:${fingerprint}`,
+        eventType: GitHubEventType.WorkObserved,
+        occurredAt: input.issue.updated_at,
+        correlationId: `github:${key}`,
+        causationId: `github:${key}:${fingerprint}`,
+        actor: { kind: EventActorKind.Integration, id: 'github' },
+        source: { kind: EventSourceKind.Adapter, id: input.adapter ?? GitHubAdapter },
+        stream: integrationStream(input.adapter ?? GitHubAdapter),
+        payload: {
+            externalKey: key,
+            kind: 'issue',
+            title: input.issue.title,
+            body: input.issue.body ?? '',
+            state: input.issue.state,
+            outcome,
+            revision: fingerprint,
+            actor,
+            labels,
+            assignees,
+            raw: { number: input.issue.number },
+        },
+    });
+}
+function issueOutcome(issue) {
+    if (issue.state !== PullRequestState.Closed)
+        return undefined;
+    return issue.state_reason === 'not_planned'
+        ? ExternalWorkOutcome.Cancelled
+        : ExternalWorkOutcome.Completed;
+}
+function parseRepository(repository) {
+    const [owner, repo, ...extra] = repository.split('/');
+    if (owner === undefined || repo === undefined || extra.length > 0)
+        throw new Error(`Invalid GitHub repository: ${repository}`);
+    return { owner, repo };
+}
+export function issueCommentObservation(input) {
+    const body = input.comment.body?.trim();
+    if (body === undefined || body.length === 0)
+        return null;
+    const key = formatGitHubResourceKey({
+        ...parseRepository(input.repository),
+        number: input.issue.number,
+    });
+    const location = commentLocation(input.comment);
+    return createEventDraft({
+        eventId: `github:issue-comment:${key}:${input.comment.id}:${input.comment.updated_at}`,
+        eventType: GitHubEventType.CommentObserved,
+        occurredAt: input.comment.updated_at,
+        correlationId: `github:${key}`,
+        causationId: `github:issue-comment:${input.comment.id}`,
+        actor: { kind: EventActorKind.Integration, id: 'github' },
+        source: { kind: EventSourceKind.Adapter, id: input.adapter ?? GitHubAdapter },
+        stream: integrationStream(input.adapter ?? GitHubAdapter),
+        payload: {
+            reviewKind: 'issue',
+            externalKey: key,
+            body,
+            revision: input.comment.updated_at,
+            ...(location === undefined ? {} : { location }),
+            actor: {
+                id: input.comment.user?.login ?? UnknownGitHubIdentity,
+                kind: input.comment.user?.type === 'Bot' ? ReviewActorKind.Bot : ReviewActorKind.Human,
+            },
+            raw: { id: input.comment.id },
+        },
+    });
+}
+function commentLocation(comment) {
+    if (comment.path === undefined ||
+        comment.line === undefined ||
+        comment.line === null ||
+        comment.side === undefined)
+        return undefined;
+    return { path: comment.path, line: comment.line, side: comment.side };
+}

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

@@ -0,0 +1,186 @@
+import { createHash } from 'node:crypto';
+import { PullRequestCheckState, PullRequestState, ReviewActorKind, } from '../../../activities/index.js';
+import { createEventDraft, EventActorKind, EventSourceKind } from '../../../kernel/index.js';
+import { integrationStream } from '../../contracts/streams.js';
+import { GitHubEventType } from '../contracts/events.js';
+import { formatGitHubResourceKey } from '../contracts/external-key.js';
+import { gitHubAssigneeLogins, gitHubLabelNames, } from '../contracts/payloads.js';
+import { GitHubAdapter, GitHubCheckRunStatus, UnknownGitHubIdentity, UnknownGitHubRevision, } from '../contracts/vocabulary.js';
+import { withoutWakeMarkers } from './content-fingerprint.js';
+export function createGitHubPullRequestSource(input) {
+    const { owner, repo } = parseRepository(input.repository);
+    return {
+        async poll(signal) {
+            signal.throwIfAborted();
+            const pullRequests = await input.client.listPullRequests(owner, repo, input.maxResults);
+            return mapConcurrent(pullRequests, input.maxConcurrency ?? 4, async (pullRequest) => {
+                signal.throwIfAborted();
+                const headRevision = fallback(pullRequest.head?.sha, pullRequest.updated_at);
+                const evidence = await readCheckEvidence(input.client, owner, repo, headRevision);
+                return pullRequestObservation({
+                    repository: input.repository,
+                    pullRequest,
+                    evidence,
+                    ...(input.adapter === undefined ? {} : { adapter: input.adapter }),
+                });
+            });
+        },
+    };
+}
+function pullRequestObservation(input) {
+    const pullRequest = input.pullRequest;
+    const key = formatGitHubResourceKey({
+        ...parseRepository(input.repository),
+        number: pullRequest.number,
+    });
+    const revision = fallback(pullRequest.head?.sha, pullRequest.updated_at);
+    const checks = input.evidence.available
+        ? normalizeCheckEvidence(input.evidence.checkRuns, input.evidence.statuses)
+        : PullRequestCheckState.Unknown;
+    const payload = {
+        externalKey: key,
+        kind: 'pull-request',
+        title: pullRequest.title,
+        body: fallback(pullRequest.body, ''),
+        state: pullRequestState(pullRequest),
+        revision,
+        headRevision: revision,
+        baseRevision: fallback(pullRequest.base?.sha, UnknownGitHubRevision),
+        checks,
+        actor: {
+            id: fallback(pullRequest.user?.login, UnknownGitHubIdentity),
+            kind: actorKind(pullRequest.user?.type),
+        },
+        labels: gitHubLabelNames(pullRequest),
+        assignees: gitHubAssigneeLogins(pullRequest),
+        raw: { number: pullRequest.number },
+    };
+    const fingerprint = evidenceFingerprint(payload, input.evidence);
+    return createEventDraft({
+        eventId: `github:pr:${key}:${fingerprint}`,
+        eventType: GitHubEventType.WorkObserved,
+        occurredAt: pullRequest.updated_at,
+        correlationId: `github:${key}`,
+        causationId: `github:${key}:${fingerprint}`,
+        actor: { kind: EventActorKind.Integration, id: 'github' },
+        source: { kind: EventSourceKind.Adapter, id: input.adapter ?? GitHubAdapter },
+        stream: integrationStream(input.adapter ?? GitHubAdapter),
+        payload,
+    });
+}
+function normalizeCheckEvidence(checkRuns, statuses) {
+    const states = [
+        ...checkRuns.map(checkRunState),
+        ...statuses.map((status) => commitStatusState(status.state)),
+    ];
+    if (states.includes(PullRequestCheckState.Failing))
+        return PullRequestCheckState.Failing;
+    if (states.includes(PullRequestCheckState.Pending))
+        return PullRequestCheckState.Pending;
+    if (states.includes(PullRequestCheckState.Passing))
+        return PullRequestCheckState.Passing;
+    return PullRequestCheckState.Unknown;
+}
+async function readCheckEvidence(client, owner, repo, headRevision) {
+    try {
+        const [checkRuns, statuses] = await Promise.all([
+            client.listCheckRunsForRef(owner, repo, headRevision),
+            client.getCombinedStatusForRef(owner, repo, headRevision),
+        ]);
+        return { available: true, checkRuns, statuses };
+    }
+    catch {
+        return { available: false, checkRuns: [], statuses: [] };
+    }
+}
+async function mapConcurrent(values, concurrency, transform) {
+    const output = new Array(values.length);
+    let nextIndex = 0;
+    async function worker() {
+        while (nextIndex < values.length) {
+            const index = nextIndex;
+            nextIndex += 1;
+            output[index] = await transform(values[index]);
+        }
+    }
+    const workerCount = Math.min(Math.max(1, concurrency), values.length);
+    await Promise.all(Array.from({ length: workerCount }, worker));
+    return output;
+}
+function evidenceFingerprint(payload, evidence) {
+    const providerEvidence = {
+        available: evidence.available,
+        checkRuns: evidence.checkRuns.map(checkRunIdentity).sort(compareJson),
+        statuses: evidence.statuses.map(statusIdentity).sort(compareJson),
+    };
+    // Wake's own status/stage/workflow labels are excluded so republishing them
+    // never looks like an external change and re-triggers a WorkObserved event.
+    const fingerprintPayload = { ...payload, labels: withoutWakeMarkers(payload.labels) };
+    return createHash('sha256')
+        .update(JSON.stringify({ payload: fingerprintPayload, providerEvidence }))
+        .digest('hex');
+}
+function checkRunIdentity(checkRun) {
+    return {
+        id: checkRun.id ?? null,
+        name: checkRun.name ?? null,
+        status: checkRun.status ?? null,
+        conclusion: checkRun.conclusion ?? null,
+        startedAt: checkRun.started_at ?? null,
+        completedAt: checkRun.completed_at ?? null,
+    };
+}
+function statusIdentity(status) {
+    return {
+        id: status.id ?? null,
+        context: status.context ?? null,
+        state: status.state ?? null,
+        createdAt: status.created_at ?? null,
+        updatedAt: status.updated_at ?? null,
+    };
+}
+function compareJson(left, right) {
+    return JSON.stringify(left).localeCompare(JSON.stringify(right));
+}
+function checkRunState(checkRun) {
+    if (checkRun.status !== GitHubCheckRunStatus.Completed)
+        return PullRequestCheckState.Pending;
+    if (checkRun.conclusion === null || checkRun.conclusion === undefined)
+        return PullRequestCheckState.Pending;
+    return passingConclusions.has(checkRun.conclusion)
+        ? PullRequestCheckState.Passing
+        : PullRequestCheckState.Failing;
+}
+function commitStatusState(state) {
+    if (state === GitHubCommitStatusState.Failure || state === GitHubCommitStatusState.Error)
+        return PullRequestCheckState.Failing;
+    if (state === GitHubCommitStatusState.Pending)
+        return PullRequestCheckState.Pending;
+    return state === GitHubCommitStatusState.Success
+        ? PullRequestCheckState.Passing
+        : PullRequestCheckState.Unknown;
+}
+function pullRequestState(pullRequest) {
+    if (pullRequest.merged_at !== null && pullRequest.merged_at !== undefined)
+        return PullRequestState.Merged;
+    return pullRequest.state;
+}
+function parseRepository(repository) {
+    const [owner, repo, ...extra] = repository.split('/');
+    if (owner === undefined || repo === undefined || extra.length > 0)
+        throw new Error(`Invalid GitHub repository: ${repository}`);
+    return { owner, repo };
+}
+function fallback(value, defaultValue) {
+    return value === null || value === undefined ? defaultValue : value;
+}
+function actorKind(type) {
+    return type === 'Bot' ? ReviewActorKind.Bot : ReviewActorKind.Human;
+}
+const passingConclusions = new Set(['success', 'neutral', 'skipped']);
+const GitHubCommitStatusState = {
+    Error: 'error',
+    Failure: 'failure',
+    Pending: PullRequestCheckState.Pending,
+    Success: 'success',
+};

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

@@ -0,0 +1,70 @@
+import { ReviewActorKind, ReviewerAuthorizationSource } from '../../../activities/index.js';
+import { createEventDraft, EventActorKind, EventSourceKind } from '../../../kernel/index.js';
+import { integrationStream } from '../../contracts/streams.js';
+import { GitHubEventType } from '../contracts/events.js';
+import { formatGitHubResourceKey } from '../contracts/external-key.js';
+import { GitHubAdapter, GitHubReviewState, UnknownGitHubIdentity, } from '../contracts/vocabulary.js';
+export function githubReviewObservation(input) {
+    const body = input.review.body?.trim();
+    const command = reviewCommand(input.review.state);
+    const actorId = input.review.user?.login ?? UnknownGitHubIdentity;
+    const key = formatGitHubResourceKey({
+        ...parseRepository(input.repository),
+        number: input.pullRequest.number,
+    });
+    const draft = (eventId, content) => createEventDraft({
+        eventId,
+        eventType: GitHubEventType.CommentObserved,
+        occurredAt: input.review.submitted_at,
+        correlationId: `github:${key}`,
+        causationId: `github:review:${input.review.id}`,
+        actor: { kind: EventActorKind.Integration, id: 'github' },
+        source: { kind: EventSourceKind.Adapter, id: 'github' },
+        stream: integrationStream(GitHubAdapter),
+        payload: {
+            externalKey: key,
+            reviewKind: 'formal',
+            body: content,
+            revision: input.review.commit_id,
+            actor: {
+                id: actorId,
+                kind: input.review.user?.type === 'Bot' ? ReviewActorKind.Bot : ReviewActorKind.Human,
+            },
+            resourceAuthorId: input.pullRequest.user?.login ?? UnknownGitHubIdentity,
+            authorization: configuredAuthorization(actorId, input.authorizedReviewers),
+            raw: { reviewId: input.review.id, state: input.review.state },
+        },
+    });
+    return [
+        ...(body === undefined || body.length === 0
+            ? []
+            : [
+                draft(`github:review-feedback:${key}:${input.review.id}:${input.review.commit_id}`, body),
+            ]),
+        ...(command === null
+            ? []
+            : [
+                draft(`github:review:${key}:${input.review.id}:${input.review.state}:${input.review.commit_id}`, command),
+            ]),
+    ];
+}
+function parseRepository(repository) {
+    const [owner, repo, ...extra] = repository.split('/');
+    if (owner === undefined || repo === undefined || extra.length > 0)
+        throw new Error(`Invalid GitHub repository: ${repository}`);
+    return { owner, repo };
+}
+function configuredAuthorization(actorId, reviewers) {
+    const reviewerId = reviewers.find((reviewer) => sameIdentity(reviewer, actorId));
+    return reviewerId === undefined
+        ? { source: ReviewerAuthorizationSource.None }
+        : { source: ReviewerAuthorizationSource.ConfiguredReviewer, reviewerId };
+}
+function reviewCommand(state) {
+    if (state === GitHubReviewState.Approved)
+        return '/accepted';
+    return state === GitHubReviewState.ChangesRequested ? '/changes' : null;
+}
+function sameIdentity(left, right) {
+    return left.toLowerCase() === right.toLowerCase();
+}

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

@@ -0,0 +1,108 @@
+import { GitHubEventType } from '../contracts/events.js';
+import { issueCommentObservation, issueObservation } from './issue-source.js';
+import { createGitHubPullRequestSource } from './pr-source.js';
+import { githubReviewObservation } from './review-source.js';
+export function createGitHubSource(config, client, adapter) {
+    let nextPollAt = 0;
+    // 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
+    // a single process lifetime — it's a perf optimization, not a correctness dependency,
+    // so it's safe for it to reset on restart.
+    const lastEventIds = new Map();
+    return {
+        async poll(signal) {
+            if (Date.now() < nextPollAt)
+                return [];
+            nextPollAt = Date.now() + config.polling.lookbackMs;
+            const perRepository = await Promise.all(config.repositories.map(({ owner, repo }) => pollRepository({ client, config, adapter, signal, owner, repo })));
+            return perRepository.flat().filter((draft) => {
+                if (draft.eventType !== GitHubEventType.WorkObserved)
+                    return true;
+                const prior = lastEventIds.get(draft.payload.externalKey);
+                lastEventIds.set(draft.payload.externalKey, draft.eventId);
+                return prior !== draft.eventId;
+            });
+        },
+    };
+}
+async function pollRepository(input) {
+    const { client, config, adapter, signal, owner, repo } = input;
+    const context = {
+        client,
+        config,
+        adapter,
+        owner,
+        repo,
+        repository: `${owner}/${repo}`,
+    };
+    try {
+        const pullRequestPayloads = await client.listPullRequests(owner, repo, config.polling.maxPerRepo);
+        const [issues, pullRequests, reviews, reviewComments] = await Promise.all([
+            client.listIssues(owner, repo, config.polling.maxPerRepo),
+            createGitHubPullRequestSource({
+                client: { ...client, listPullRequests: async () => pullRequestPayloads },
+                repository: context.repository,
+                maxResults: config.polling.maxPerRepo,
+                ...(adapter === undefined ? {} : { adapter }),
+            }).poll(signal),
+            reviewEventsFor(context, pullRequestPayloads),
+            reviewCommentEventsFor(context, pullRequestPayloads),
+        ]);
+        const issueComments = await issueCommentEventsFor(context, issues);
+        return [
+            ...issues
+                .filter((issue) => issue.pull_request === undefined)
+                .map((issue) => issueObservation({
+                repository: context.repository,
+                issue,
+                ...(adapter === undefined ? {} : { adapter }),
+            })),
+            ...pullRequests,
+            ...reviews,
+            ...reviewComments,
+            ...issueComments,
+        ];
+    }
+    catch {
+        return [];
+    }
+}
+async function reviewCommentEventsFor(context, pullRequests) {
+    if (context.client.listReviewComments === undefined)
+        return [];
+    const items = await Promise.all(pullRequests.map(async (pullRequest) => (await context.client.listReviewComments(context.owner, context.repo, pullRequest.number, context.config.polling.commentPageSize)).flatMap((comment) => {
+        const event = issueCommentObservation({
+            repository: context.repository,
+            issue: pullRequest,
+            comment,
+            ...(context.adapter === undefined ? {} : { adapter: context.adapter }),
+        });
+        return event === null ? [] : [event];
+    })));
+    return items.flat();
+}
+async function reviewEventsFor(context, pullRequestPayloads) {
+    const items = await Promise.all(pullRequestPayloads.map(async (pullRequest) => {
+        const reviewEvents = await context.client.listReviews(context.owner, context.repo, pullRequest.number, context.config.polling.commentPageSize);
+        return reviewEvents.flatMap((review) => githubReviewObservation({
+            repository: context.repository,
+            pullRequest,
+            review,
+            authorizedReviewers: [],
+        }));
+    }));
+    return items.flat();
+}
+async function issueCommentEventsFor(context, issues) {
+    const items = await Promise.all(issues.map(async (issue) => (await context.client.listIssueComments(context.owner, context.repo, issue.number, context.config.polling.commentPageSize)).flatMap((comment) => {
+        const event = issueCommentObservation({
+            repository: context.repository,
+            issue,
+            comment,
+            ...(context.adapter === undefined ? {} : { adapter: context.adapter }),
+        });
+        return event === null ? [] : [event];
+    })));
+    return items.flat();
+}

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

@@ -0,0 +1,96 @@
+import { BuiltInResourceCapability, resourceId, resourceKind } from '../../resources/index.js';
+import { ArtifactVerificationResult } from '../contracts/artifact-vocabulary.js';
+import { InboundTranslator } from './application/inbound-translator.js';
+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 { createGitHubClient } from './infrastructure/client.js';
+import { createGitHubDelivery } from './infrastructure/delivery.js';
+import { resolveGitHubCliToken } from './infrastructure/gh-auth.js';
+import { createGitHubSource } from './infrastructure/source.js';
+export const gitHubProviderDefinition = {
+    provider: 'github',
+    eventTypes: Object.values(GitHubEventType),
+    parseConfig(value) {
+        return gitHubConfigSchema.parse(value);
+    },
+    create({ adapter, config, services }) {
+        if (services === undefined)
+            throw new Error('GitHub provider requires composed services');
+        const client = createGitHubClient(config.token ?? resolveGitHubCliToken());
+        return {
+            adapter,
+            eventTypes: Object.values(GitHubEventType),
+            source: createGitHubSource(config, client, adapter),
+            maintenance: createGitHubWakeLabelReconciler({
+                orchestration: services.orchestration,
+                resources: services.resources,
+                work: services.work,
+                getLabels: client.getIssueLabels,
+                setLabels: client.setIssueLabels,
+            }),
+            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), idempotencyKey });
+            }),
+            verifyArtifact: async (kind, externalKey, context) => {
+                if (kind !== resourceKind('pull-request'))
+                    return ArtifactVerificationResult.NotFound;
+                const parsed = parsePullRequestKey(externalKey.key);
+                if (parsed === null)
+                    return ArtifactVerificationResult.NotFound;
+                try {
+                    const pullRequest = await client.getPullRequest(parsed.owner, parsed.repo, parsed.number);
+                    if (pullRequest.head.ref !== context.workspaceBranch)
+                        return ArtifactVerificationResult.NotFound;
+                    return {
+                        kind,
+                        externalKey,
+                        capabilities: [
+                            BuiltInResourceCapability.Reviewable,
+                            BuiltInResourceCapability.Approvable,
+                            BuiltInResourceCapability.Mergeable,
+                            BuiltInResourceCapability.Revisioned,
+                        ],
+                        ...(pullRequest.head.sha === undefined ? {} : { revision: pullRequest.head.sha }),
+                    };
+                }
+                catch (error) {
+                    if (typeof error === 'object' &&
+                        error !== null &&
+                        'status' in error &&
+                        error.status === 404)
+                        return ArtifactVerificationResult.NotFound;
+                    return ArtifactVerificationResult.Ambiguous;
+                }
+            },
+            inbound: new InboundTranslator(services.journal, services.checkpoints, services.work, services.resources, {
+                pullRequests: services.pullRequests,
+                ids: services.ids,
+                lookup: services.resourceLookup,
+                adapter,
+                orchestration: services.orchestration,
+                runs: services.runs,
+                routing: services.routing,
+                intake: config.intake,
+                conclusion: services.conclusion,
+            }),
+            checkConnectivity: async () => {
+                await client.authenticatedLogin();
+            },
+        };
+    },
+};
+function parsePullRequestKey(key) {
+    const match = /^(?<owner>[^/]+)\/(?<repo>[^#]+)#(?<number>[1-9]\d*)$/.exec(key);
+    if (match?.groups === undefined)
+        return null;
+    return {
+        owner: match.groups.owner,
+        repo: match.groups.repo,
+        number: Number(match.groups.number),
+    };
+}

package/dist/src/integrations/index.js

@@ -0,0 +1,30 @@
+export * from '../kernel/index.js';
+export * from './application/poll-service.js';
+export * from './application/work-admission.js';
+export * from './application/work-conclusion.js';
+export * from './application/artifact-registration-reactor.js';
+export * from './application/agent-run-publication-reactor.js';
+export * from './application/terminal-agent-run-report.js';
+export * from './contracts/config.js';
+export * from './contracts/artifact-events.js';
+export * from './contracts/artifact-vocabulary.js';
+export * from './contracts/outcome-vocabulary.js';
+export * from './contracts/identifiers.js';
+export * from './contracts/intake-rules.js';
+export * from './contracts/intake.js';
+export * from './contracts/provider.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 './fake/durable-delivery-provider.js';
+export * from './fake/external-sink.js';
+export * from './fake/external-source.js';
+export * from './fake/provider.js';