@holon-run/agentinbox 0.1.0

package/dist/src/sources/github.js

@@ -0,0 +1,485 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GithubDeliveryAdapter = exports.GithubSourceRuntime = exports.GithubUxcClient = void 0;
+exports.normalizeGithubRepoEvent = normalizeGithubRepoEvent;
+const uxc_daemon_client_1 = require("@holon-run/uxc-daemon-client");
+const GITHUB_ENDPOINT = "https://api.github.com";
+const DEFAULT_EVENT_TYPES = [
+    "IssuesEvent",
+    "IssueCommentEvent",
+    "PullRequestEvent",
+    "PullRequestReviewCommentEvent",
+];
+const MAX_ERROR_BACKOFF_MULTIPLIER = 8;
+class GithubUxcClient {
+    client;
+    constructor(client = new uxc_daemon_client_1.UxcDaemonClient({ env: process.env })) {
+        this.client = client;
+    }
+    async ensureRepoEventsSubscription(config, checkpoint) {
+        if (checkpoint.uxcJobId) {
+            try {
+                const status = await this.client.subscribeStatus(checkpoint.uxcJobId);
+                if (status.status === "running" || status.status === "reconnecting") {
+                    return {
+                        job_id: checkpoint.uxcJobId,
+                        mode: "poll",
+                        protocol: "openapi",
+                        endpoint: GITHUB_ENDPOINT,
+                        sink: "memory:",
+                        status: status.status,
+                    };
+                }
+            }
+            catch {
+                // Recreate the job below.
+            }
+        }
+        const started = await this.client.subscribeStart({
+            endpoint: GITHUB_ENDPOINT,
+            operationId: "get:/repos/{owner}/{repo}/events",
+            args: { owner: config.owner, repo: config.repo, per_page: config.perPage ?? 10 },
+            mode: "poll",
+            pollConfig: {
+                interval_secs: config.pollIntervalSecs ?? 30,
+                extract_items_pointer: "",
+                checkpoint_strategy: {
+                    type: "item_key",
+                    item_key_pointer: "/id",
+                    seen_window: 1024,
+                },
+            },
+            options: { auth: config.uxcAuth },
+            sink: "memory:",
+            ephemeral: false,
+        });
+        return started;
+    }
+    async readSubscriptionEvents(jobId, afterSeq) {
+        const response = await this.client.subscriptionEvents({
+            jobId,
+            afterSeq,
+            limit: 100,
+            waitMs: 10,
+        });
+        return {
+            events: response.events,
+            nextAfterSeq: response.next_after_seq,
+            status: response.status,
+        };
+    }
+    async createIssueComment(input) {
+        await this.client.call({
+            endpoint: GITHUB_ENDPOINT,
+            operation: "post:/repos/{owner}/{repo}/issues/{issue_number}/comments",
+            payload: {
+                owner: input.owner,
+                repo: input.repo,
+                issue_number: input.issueNumber,
+                body: input.body,
+            },
+            options: { auth: input.auth },
+        });
+    }
+    async replyToReviewComment(input) {
+        await this.client.call({
+            endpoint: GITHUB_ENDPOINT,
+            operation: "post:/repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies",
+            payload: {
+                owner: input.owner,
+                repo: input.repo,
+                pull_number: input.pullNumber,
+                comment_id: input.commentId,
+                body: input.body,
+            },
+            options: { auth: input.auth },
+        });
+    }
+}
+exports.GithubUxcClient = GithubUxcClient;
+class GithubSourceRuntime {
+    store;
+    appendSourceEvent;
+    client;
+    interval = null;
+    inFlight = new Set();
+    errorCounts = new Map();
+    nextRetryAt = new Map();
+    constructor(store, appendSourceEvent, client) {
+        this.store = store;
+        this.appendSourceEvent = appendSourceEvent;
+        this.client = client ?? new GithubUxcClient();
+    }
+    async ensureSource(source) {
+        if (source.sourceType !== "github_repo") {
+            return;
+        }
+        const config = parseGithubSourceConfig(source);
+        const checkpoint = parseGithubCheckpoint(source.checkpoint);
+        const started = await this.client.ensureRepoEventsSubscription(config, checkpoint);
+        this.store.updateSourceRuntime(source.sourceId, {
+            status: "active",
+            checkpoint: JSON.stringify({
+                ...checkpoint,
+                uxcJobId: started.job_id,
+            }),
+        });
+    }
+    async start() {
+        if (this.interval) {
+            return;
+        }
+        this.interval = setInterval(() => {
+            void this.syncAll();
+        }, 2_000);
+        try {
+            await this.syncAll();
+        }
+        catch (error) {
+            console.warn("github_repo initial sync failed:", error);
+        }
+    }
+    async stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+    }
+    async pollSource(sourceId) {
+        return this.syncSource(sourceId);
+    }
+    status() {
+        return {
+            activeSourceIds: Array.from(this.inFlight.values()).sort(),
+            erroredSourceIds: Array.from(this.errorCounts.keys()).sort(),
+        };
+    }
+    async syncAll() {
+        const sources = this.store
+            .listSources()
+            .filter((source) => source.sourceType === "github_repo" && source.status !== "paused");
+        for (const source of sources) {
+            try {
+                await this.syncSource(source.sourceId);
+            }
+            catch (error) {
+                console.warn(`github_repo sync failed for ${source.sourceId}:`, error);
+            }
+        }
+    }
+    async syncSource(sourceId) {
+        if (this.inFlight.has(sourceId)) {
+            return {
+                sourceId,
+                sourceType: "github_repo",
+                appended: 0,
+                deduped: 0,
+                eventsRead: 0,
+                note: "source sync already in flight",
+            };
+        }
+        this.inFlight.add(sourceId);
+        try {
+            const source = this.store.getSource(sourceId);
+            if (!source) {
+                throw new Error(`unknown source: ${sourceId}`);
+            }
+            const config = parseGithubSourceConfig(source);
+            if (source.status === "error") {
+                const retryAt = this.nextRetryAt.get(sourceId) ?? 0;
+                if (Date.now() < retryAt) {
+                    return {
+                        sourceId,
+                        sourceType: "github_repo",
+                        appended: 0,
+                        deduped: 0,
+                        eventsRead: 0,
+                        note: "error backoff not elapsed",
+                    };
+                }
+            }
+            let checkpoint = parseGithubCheckpoint(source.checkpoint);
+            const subscription = await this.client.ensureRepoEventsSubscription(config, checkpoint);
+            if (subscription.job_id !== checkpoint.uxcJobId) {
+                checkpoint = { ...checkpoint, uxcJobId: subscription.job_id };
+            }
+            const batch = await this.client.readSubscriptionEvents(checkpoint.uxcJobId, checkpoint.afterSeq ?? 0);
+            let appended = 0;
+            let deduped = 0;
+            for (const event of batch.events) {
+                if (event.event_kind !== "data") {
+                    continue;
+                }
+                const normalized = normalizeGithubRepoEvent(source, config, event.data);
+                if (!normalized) {
+                    continue;
+                }
+                const result = await this.appendSourceEvent(normalized);
+                appended += result.appended;
+                deduped += result.deduped;
+            }
+            this.store.updateSourceRuntime(sourceId, {
+                status: "active",
+                checkpoint: JSON.stringify({
+                    ...checkpoint,
+                    uxcJobId: checkpoint.uxcJobId,
+                    afterSeq: batch.nextAfterSeq,
+                    lastEventAt: new Date().toISOString(),
+                    lastError: null,
+                }),
+            });
+            this.errorCounts.delete(sourceId);
+            this.nextRetryAt.delete(sourceId);
+            return {
+                sourceId,
+                sourceType: "github_repo",
+                appended,
+                deduped,
+                eventsRead: batch.events.length,
+                note: `subscription status=${batch.status}`,
+            };
+        }
+        catch (error) {
+            const source = this.store.getSource(sourceId);
+            if (source) {
+                const checkpoint = parseGithubCheckpoint(source.checkpoint);
+                const config = parseGithubSourceConfig(source);
+                const nextErrorCount = (this.errorCounts.get(sourceId) ?? 0) + 1;
+                this.errorCounts.set(sourceId, nextErrorCount);
+                this.nextRetryAt.set(sourceId, Date.now() + computeErrorBackoffMs(config.pollIntervalSecs ?? 30, nextErrorCount));
+                this.store.updateSourceRuntime(sourceId, {
+                    status: "error",
+                    checkpoint: JSON.stringify({
+                        ...checkpoint,
+                        lastError: error instanceof Error ? error.message : String(error),
+                    }),
+                });
+            }
+            throw error;
+        }
+        finally {
+            this.inFlight.delete(sourceId);
+        }
+    }
+}
+exports.GithubSourceRuntime = GithubSourceRuntime;
+function computeErrorBackoffMs(pollIntervalSecs, errorCount) {
+    const baseMs = Math.max(1, pollIntervalSecs) * 1000;
+    const multiplier = Math.min(2 ** Math.max(0, errorCount - 1), MAX_ERROR_BACKOFF_MULTIPLIER);
+    return baseMs * multiplier;
+}
+class GithubDeliveryAdapter {
+    client;
+    constructor(client) {
+        this.client = client ?? new GithubUxcClient();
+    }
+    async send(request, attempt) {
+        const payloadText = stringifyDeliveryPayload(request.payload);
+        const target = parseTargetRef(attempt.targetRef);
+        if (attempt.surface === "issue_comment" || attempt.surface === "pull_request_comment") {
+            await this.client.createIssueComment({
+                owner: target.owner,
+                repo: target.repo,
+                issueNumber: target.number,
+                body: payloadText,
+            });
+            return { status: "sent", note: "sent GitHub issue comment" };
+        }
+        if (attempt.surface === "review_comment") {
+            if (!attempt.threadRef || !attempt.threadRef.startsWith("review_comment:")) {
+                throw new Error("review_comment delivery requires threadRef=review_comment:<id>");
+            }
+            await this.client.replyToReviewComment({
+                owner: target.owner,
+                repo: target.repo,
+                pullNumber: target.number,
+                commentId: Number(attempt.threadRef.slice("review_comment:".length)),
+                body: payloadText,
+            });
+            return { status: "sent", note: "sent GitHub review comment reply" };
+        }
+        throw new Error(`unsupported GitHub surface: ${attempt.surface}`);
+    }
+}
+exports.GithubDeliveryAdapter = GithubDeliveryAdapter;
+function normalizeGithubRepoEvent(source, config, raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return null;
+    }
+    const event = raw;
+    const eventType = asString(event.type);
+    if (!eventType || !(config.eventTypes ?? DEFAULT_EVENT_TYPES).includes(eventType)) {
+        return null;
+    }
+    const eventId = asString(event.id);
+    if (!eventId) {
+        return null;
+    }
+    const actor = asRecord(event.actor);
+    const payload = asRecord(event.payload);
+    const repo = asRecord(event.repo);
+    const issue = asRecord(payload.issue);
+    const pullRequest = asRecord(payload.pull_request);
+    const comment = asRecord(payload.comment);
+    const action = asString(payload.action) ?? "observed";
+    const number = asNumber(issue.number) ?? asNumber(pullRequest.number);
+    const isPullRequest = eventType.startsWith("PullRequest");
+    const title = asString(issue.title) ?? asString(pullRequest.title) ?? null;
+    const body = asString(comment.body) ?? asString(issue.body) ?? asString(pullRequest.body) ?? null;
+    const labels = extractLabels(issue.labels);
+    const mentions = extractMentions(title, body);
+    const url = asString(comment.html_url) ??
+        asString(issue.html_url) ??
+        asString(pullRequest.html_url) ??
+        asString(event["url"]);
+    const deliveryHandle = buildGithubDeliveryHandle(config, eventType, number, comment);
+    return {
+        sourceId: source.sourceId,
+        sourceNativeId: `github_event:${eventId}`,
+        eventVariant: `${eventType}.${action}`,
+        occurredAt: asString(event.created_at) ?? new Date().toISOString(),
+        metadata: {
+            provider: "github",
+            owner: config.owner,
+            repo: config.repo,
+            repoFullName: asString(repo.name) ?? `${config.owner}/${config.repo}`,
+            eventType,
+            action,
+            number,
+            author: asString(actor.login) ?? null,
+            isPullRequest,
+            labels,
+            mentions,
+            title,
+            body,
+            url,
+        },
+        rawPayload: {
+            id: eventId,
+            type: eventType,
+            action,
+            actor: actor.login ?? null,
+            issue,
+            pull_request: pullRequest,
+            comment,
+        },
+        deliveryHandle,
+    };
+}
+function buildGithubDeliveryHandle(config, eventType, number, comment) {
+    if (!number) {
+        return null;
+    }
+    if (eventType === "PullRequestReviewCommentEvent") {
+        const commentId = asNumber(comment.id);
+        return {
+            provider: "github",
+            surface: "review_comment",
+            targetRef: `${config.owner}/${config.repo}#${number}`,
+            threadRef: commentId ? `review_comment:${commentId}` : null,
+            replyMode: "reply",
+        };
+    }
+    return {
+        provider: "github",
+        surface: eventType === "PullRequestEvent" ? "pull_request_comment" : "issue_comment",
+        targetRef: `${config.owner}/${config.repo}#${number}`,
+        threadRef: null,
+        replyMode: "comment",
+    };
+}
+function parseGithubSourceConfig(source) {
+    const config = source.config ?? {};
+    const owner = asString(config.owner);
+    const repo = asString(config.repo);
+    if (!owner || !repo) {
+        const [fallbackOwner, fallbackRepo] = source.sourceKey.split("/", 2);
+        if (!fallbackOwner || !fallbackRepo) {
+            throw new Error(`github_repo source requires config.owner and config.repo: ${source.sourceId}`);
+        }
+        return {
+            owner: fallbackOwner,
+            repo: fallbackRepo,
+            uxcAuth: asString(config.uxcAuth) ?? asString(config.credentialRef) ?? undefined,
+            pollIntervalSecs: asNumber(config.pollIntervalSecs) ?? 30,
+            perPage: asNumber(config.perPage) ?? 10,
+            eventTypes: asStringArray(config.eventTypes) ?? DEFAULT_EVENT_TYPES,
+        };
+    }
+    return {
+        owner,
+        repo,
+        uxcAuth: asString(config.uxcAuth) ?? asString(config.credentialRef) ?? undefined,
+        pollIntervalSecs: asNumber(config.pollIntervalSecs) ?? 30,
+        perPage: asNumber(config.perPage) ?? 10,
+        eventTypes: asStringArray(config.eventTypes) ?? DEFAULT_EVENT_TYPES,
+    };
+}
+function parseGithubCheckpoint(checkpoint) {
+    if (!checkpoint) {
+        return {};
+    }
+    try {
+        return JSON.parse(checkpoint);
+    }
+    catch {
+        return {};
+    }
+}
+function extractLabels(raw) {
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    return raw
+        .map((value) => asRecord(value))
+        .map((value) => asString(value.name))
+        .filter((value) => Boolean(value));
+}
+function extractMentions(...values) {
+    const seen = new Set();
+    for (const value of values) {
+        if (!value) {
+            continue;
+        }
+        const matches = value.match(/@([a-zA-Z0-9_-]+)/g) ?? [];
+        for (const match of matches) {
+            seen.add(match.slice(1));
+        }
+    }
+    return Array.from(seen.values()).sort();
+}
+function parseTargetRef(targetRef) {
+    const match = targetRef.match(/^([^/]+)\/([^#]+)#(\d+)$/);
+    if (!match) {
+        throw new Error(`invalid GitHub targetRef: ${targetRef}`);
+    }
+    return {
+        owner: match[1],
+        repo: match[2],
+        number: Number(match[3]),
+    };
+}
+function stringifyDeliveryPayload(payload) {
+    if (typeof payload.text === "string") {
+        return payload.text;
+    }
+    return JSON.stringify(payload, null, 2);
+}
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    return value;
+}
+function asString(value) {
+    return typeof value === "string" ? value : null;
+}
+function asNumber(value) {
+    return typeof value === "number" ? value : null;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    return value.filter((item) => typeof item === "string");
+}