@holon-run/agentinbox 0.1.0

package/dist/src/sources/github_ci.js

@@ -0,0 +1,372 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GithubCiSourceRuntime = exports.GithubActionsUxcClient = void 0;
+exports.normalizeGithubWorkflowRunEvent = normalizeGithubWorkflowRunEvent;
+const uxc_daemon_client_1 = require("@holon-run/uxc-daemon-client");
+const GITHUB_ENDPOINT = "https://api.github.com";
+const DEFAULT_POLL_INTERVAL_SECS = 30;
+const DEFAULT_PER_PAGE = 20;
+const MAX_SEEN_KEYS = 512;
+const MAX_ERROR_BACKOFF_MULTIPLIER = 8;
+class GithubActionsUxcClient {
+    client;
+    constructor(client = new uxc_daemon_client_1.UxcDaemonClient({ env: process.env })) {
+        this.client = client;
+    }
+    async listWorkflowRuns(config) {
+        const payload = {
+            owner: config.owner,
+            repo: config.repo,
+            per_page: config.perPage ?? DEFAULT_PER_PAGE,
+        };
+        if (config.eventFilter) {
+            payload.event = config.eventFilter;
+        }
+        if (config.branch) {
+            payload.branch = config.branch;
+        }
+        if (config.statusFilter) {
+            payload.status = config.statusFilter;
+        }
+        const response = await this.client.call({
+            endpoint: GITHUB_ENDPOINT,
+            operation: "get:/repos/{owner}/{repo}/actions/runs",
+            payload,
+            options: { auth: config.uxcAuth },
+        });
+        const data = asRecord(response.data);
+        return Array.isArray(data.workflow_runs)
+            ? data.workflow_runs.map((value) => asRecord(value)).filter((value) => Object.keys(value).length > 0)
+            : [];
+    }
+}
+exports.GithubActionsUxcClient = GithubActionsUxcClient;
+class GithubCiSourceRuntime {
+    store;
+    appendSourceEvent;
+    client;
+    interval = null;
+    inFlight = new Set();
+    lastPollAt = new Map();
+    errorCounts = new Map();
+    nextRetryAt = new Map();
+    constructor(store, appendSourceEvent, client) {
+        this.store = store;
+        this.appendSourceEvent = appendSourceEvent;
+        this.client = client ?? new GithubActionsUxcClient();
+    }
+    async ensureSource(source) {
+        if (source.sourceType !== "github_repo_ci") {
+            return;
+        }
+        const checkpoint = parseGithubCiCheckpoint(source.checkpoint);
+        this.store.updateSourceRuntime(source.sourceId, {
+            status: "active",
+            checkpoint: JSON.stringify(checkpoint),
+        });
+    }
+    async start() {
+        if (this.interval) {
+            return;
+        }
+        this.interval = setInterval(() => {
+            void this.syncAll();
+        }, 2_000);
+        try {
+            await this.syncAll();
+        }
+        catch (error) {
+            console.warn("github_repo_ci initial sync failed:", error);
+        }
+    }
+    async stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+    }
+    async pollSource(sourceId) {
+        return this.syncSource(sourceId, true);
+    }
+    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_ci" && source.status !== "paused");
+        for (const source of sources) {
+            try {
+                await this.syncSource(source.sourceId, false);
+            }
+            catch (error) {
+                console.warn(`github_repo_ci sync failed for ${source.sourceId}:`, error);
+            }
+        }
+    }
+    async syncSource(sourceId, force) {
+        if (this.inFlight.has(sourceId)) {
+            return {
+                sourceId,
+                sourceType: "github_repo_ci",
+                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 = parseGithubCiSourceConfig(source);
+            if (!force) {
+                const retryAt = this.nextRetryAt.get(sourceId) ?? 0;
+                if (Date.now() < retryAt) {
+                    return {
+                        sourceId,
+                        sourceType: "github_repo_ci",
+                        appended: 0,
+                        deduped: 0,
+                        eventsRead: 0,
+                        note: "error backoff not elapsed",
+                    };
+                }
+                const lastPollAt = this.lastPollAt.get(sourceId) ?? 0;
+                const pollIntervalMs = (config.pollIntervalSecs ?? DEFAULT_POLL_INTERVAL_SECS) * 1000;
+                if (Date.now() - lastPollAt < pollIntervalMs) {
+                    return {
+                        sourceId,
+                        sourceType: "github_repo_ci",
+                        appended: 0,
+                        deduped: 0,
+                        eventsRead: 0,
+                        note: "poll interval not elapsed",
+                    };
+                }
+            }
+            this.lastPollAt.set(sourceId, Date.now());
+            const checkpoint = parseGithubCiCheckpoint(source.checkpoint);
+            const runs = await this.client.listWorkflowRuns(config);
+            let appended = 0;
+            let deduped = 0;
+            let lastSeenUpdatedAt = checkpoint.lastSeenUpdatedAt ?? undefined;
+            const seenKeys = new Set(checkpoint.seenRunKeys ?? []);
+            for (const run of runs.slice().reverse()) {
+                const normalized = normalizeGithubWorkflowRunEvent(source, config, run);
+                if (!normalized) {
+                    continue;
+                }
+                const eventUpdatedAt = normalized.metadata?.updatedAt;
+                const runKey = `${normalized.sourceNativeId}:${normalized.eventVariant}`;
+                const shouldProcess = !lastSeenUpdatedAt ||
+                    (typeof eventUpdatedAt === "string" && eventUpdatedAt > lastSeenUpdatedAt) ||
+                    !seenKeys.has(runKey);
+                if (!shouldProcess) {
+                    continue;
+                }
+                const result = await this.appendSourceEvent(normalized);
+                appended += result.appended;
+                deduped += result.deduped;
+                seenKeys.add(runKey);
+                if (typeof eventUpdatedAt === "string" && (!lastSeenUpdatedAt || eventUpdatedAt >= lastSeenUpdatedAt)) {
+                    lastSeenUpdatedAt = eventUpdatedAt;
+                }
+            }
+            this.store.updateSourceRuntime(sourceId, {
+                status: "active",
+                checkpoint: JSON.stringify({
+                    lastSeenUpdatedAt,
+                    seenRunKeys: Array.from(seenKeys).slice(-MAX_SEEN_KEYS),
+                    lastEventAt: new Date().toISOString(),
+                    lastError: undefined,
+                }),
+            });
+            this.errorCounts.delete(sourceId);
+            this.nextRetryAt.delete(sourceId);
+            return {
+                sourceId,
+                sourceType: "github_repo_ci",
+                appended,
+                deduped,
+                eventsRead: runs.length,
+                note: `workflow runs fetched=${runs.length}`,
+            };
+        }
+        catch (error) {
+            const source = this.store.getSource(sourceId);
+            if (source) {
+                const checkpoint = parseGithubCiCheckpoint(source.checkpoint);
+                const config = parseGithubCiSourceConfig(source);
+                const nextErrorCount = (this.errorCounts.get(sourceId) ?? 0) + 1;
+                this.errorCounts.set(sourceId, nextErrorCount);
+                this.nextRetryAt.set(sourceId, Date.now() + computeErrorBackoffMs(config.pollIntervalSecs ?? DEFAULT_POLL_INTERVAL_SECS, 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.GithubCiSourceRuntime = GithubCiSourceRuntime;
+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;
+}
+function normalizeGithubWorkflowRunEvent(source, config, raw) {
+    const run = asRecord(raw);
+    const runId = asNumber(run.id);
+    if (!runId) {
+        return null;
+    }
+    const workflowName = asString(run.name) ?? asString(run.display_title);
+    const conclusion = asString(run.conclusion);
+    const status = inferWorkflowRunStatus(run, conclusion);
+    const variant = buildWorkflowRunVariant(workflowName, status, conclusion);
+    const actor = asRecord(run.actor);
+    const headCommit = asRecord(run.head_commit);
+    return {
+        sourceId: source.sourceId,
+        sourceNativeId: `workflow_run:${runId}`,
+        eventVariant: variant,
+        occurredAt: asString(run.updated_at) ?? asString(run.created_at) ?? new Date().toISOString(),
+        metadata: {
+            provider: "github",
+            owner: config.owner,
+            repo: config.repo,
+            repoFullName: `${config.owner}/${config.repo}`,
+            workflowRunId: runId,
+            workflowId: asNumber(run.workflow_id),
+            name: workflowName,
+            displayTitle: asString(run.display_title),
+            status,
+            conclusion,
+            event: asString(run.event),
+            headSha: asString(run.head_sha),
+            headBranch: asString(run.head_branch),
+            runNumber: asNumber(run.run_number),
+            runAttempt: asNumber(run.run_attempt),
+            actor: asString(actor.login),
+            htmlUrl: asString(run.html_url),
+            createdAt: asString(run.created_at),
+            updatedAt: asString(run.updated_at),
+            commitMessage: asString(headCommit.message),
+        },
+        rawPayload: {
+            id: runId,
+            workflow_id: asNumber(run.workflow_id),
+            name: workflowName,
+            display_title: asString(run.display_title),
+            status,
+            conclusion,
+            event: asString(run.event),
+            head_sha: asString(run.head_sha),
+            head_branch: asString(run.head_branch),
+            run_number: asNumber(run.run_number),
+            run_attempt: asNumber(run.run_attempt),
+            html_url: asString(run.html_url),
+            actor: asString(actor.login),
+            head_commit: {
+                id: asString(headCommit.id),
+                message: asString(headCommit.message),
+            },
+        },
+        deliveryHandle: null,
+    };
+}
+function parseGithubCiSourceConfig(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_ci 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) ?? DEFAULT_POLL_INTERVAL_SECS,
+            perPage: asNumber(config.perPage) ?? DEFAULT_PER_PAGE,
+            eventFilter: asString(config.eventFilter) ?? undefined,
+            branch: asString(config.branch) ?? undefined,
+            statusFilter: asString(config.statusFilter) ?? undefined,
+        };
+    }
+    return {
+        owner,
+        repo,
+        uxcAuth: asString(config.uxcAuth) ?? asString(config.credentialRef) ?? undefined,
+        pollIntervalSecs: asNumber(config.pollIntervalSecs) ?? DEFAULT_POLL_INTERVAL_SECS,
+        perPage: asNumber(config.perPage) ?? DEFAULT_PER_PAGE,
+        eventFilter: asString(config.eventFilter) ?? undefined,
+        branch: asString(config.branch) ?? undefined,
+        statusFilter: asString(config.statusFilter) ?? undefined,
+    };
+}
+function parseGithubCiCheckpoint(checkpoint) {
+    if (!checkpoint) {
+        return {};
+    }
+    try {
+        return JSON.parse(checkpoint);
+    }
+    catch {
+        return {};
+    }
+}
+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" && Number.isFinite(value) ? value : null;
+}
+function inferWorkflowRunStatus(run, conclusion) {
+    return asString(run.status)
+        ?? (conclusion ? "completed" : null)
+        ?? "observed";
+}
+function buildWorkflowRunVariant(workflowName, status, conclusion) {
+    const parts = ["workflow_run"];
+    const workflowSlug = slugifyWorkflowName(workflowName);
+    if (workflowSlug) {
+        parts.push(workflowSlug);
+    }
+    parts.push(status);
+    if (conclusion) {
+        parts.push(conclusion);
+    }
+    return parts.join(".");
+}
+function slugifyWorkflowName(value) {
+    if (!value) {
+        return null;
+    }
+    const slug = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+    return slug.length > 0 ? slug : null;
+}