patchrelay 0.8.8 → 0.9.0

package/dist/service-runtime.js

@@ -1,46 +1,15 @@
 import { SerialWorkQueue } from "./service-queue.js";
 const ISSUE_KEY_DELIMITER = "::";
 const DEFAULT_RECONCILE_INTERVAL_MS = 5_000;
-function toReconciler(value) {
-    if (typeof value === "function") {
-        return {
-            reconcileActiveStageRuns: value,
-        };
-    }
-    return value;
-}
-function toReadyIssueSource(value) {
-    if (typeof value === "function") {
-        return {
-            listIssuesReadyForExecution: value,
-        };
-    }
-    return value;
-}
-function toWebhookProcessor(value) {
-    if (typeof value === "function") {
-        return {
-            processWebhookEvent: value,
-        };
-    }
-    return value;
-}
-function toIssueProcessor(value) {
-    if (typeof value === "function") {
-        return {
-            processIssue: value,
-        };
-    }
-    return value;
-}
+const DEFAULT_RECONCILE_TIMEOUT_MS = 60_000;
 function makeIssueQueueKey(item) {
     return `${item.projectId}${ISSUE_KEY_DELIMITER}${item.issueId}`;
 }
-// ServiceRuntime is the coordination seam for the harness. It is responsible for
-// startup reconciliation, queue ownership, and handing eligible work to the stage runner.
 export class ServiceRuntime {
     codex;
     logger;
+    runReconciler;
+    readyIssueSource;
     options;
     webhookQueue;
     issueQueue;
@@ -48,27 +17,19 @@ export class ServiceRuntime {
     startupError;
     reconcileTimer;
     reconcileInProgress = false;
-    constructor(codex, logger, stageRunReconciler, readyIssueSource, webhookProcessor, issueProcessor, options = {}) {
+    constructor(codex, logger, runReconciler, readyIssueSource, webhookProcessor, issueProcessor, options = {}) {
         this.codex = codex;
         this.logger = logger;
+        this.runReconciler = runReconciler;
+        this.readyIssueSource = readyIssueSource;
         this.options = options;
-        this.stageRunReconciler = toReconciler(stageRunReconciler);
-        this.readyIssueSource = toReadyIssueSource(readyIssueSource);
-        this.webhookProcessor = toWebhookProcessor(webhookProcessor);
-        this.issueProcessor = toIssueProcessor(issueProcessor);
-        this.webhookQueue = new SerialWorkQueue((eventId) => this.webhookProcessor.processWebhookEvent(eventId), logger, (eventId) => String(eventId));
-        this.issueQueue = new SerialWorkQueue((item) => this.issueProcessor.processIssue(item), logger, makeIssueQueueKey);
+        this.webhookQueue = new SerialWorkQueue((eventId) => webhookProcessor.processWebhookEvent(eventId), logger, (eventId) => String(eventId));
+        this.issueQueue = new SerialWorkQueue((item) => issueProcessor.processIssue(item), logger, makeIssueQueueKey);
     }
-    stageRunReconciler;
-    readyIssueSource;
-    webhookProcessor;
-    issueProcessor;
     async start() {
         try {
             await this.codex.start();
-            // Reconciliation happens before new work is enqueued so restart recovery can
-            // resolve or release any previously claimed work deterministically.
-            await this.stageRunReconciler.reconcileActiveStageRuns();
+            await this.runReconciler.reconcileActiveRuns();
             for (const issue of this.readyIssueSource.listIssuesReadyForExecution()) {
                 this.enqueueIssue(issue.projectId, issue.linearIssueId);
             }
@@ -115,21 +76,18 @@ export class ServiceRuntime {
         }
     }
     async runBackgroundReconcile() {
-        if (!this.ready || !this.codex.isStarted()) {
+        if (!this.ready || !this.codex.isStarted())
             return;
-        }
         if (this.reconcileInProgress) {
             this.scheduleBackgroundReconcile();
             return;
         }
         this.reconcileInProgress = true;
         try {
-            await this.stageRunReconciler.reconcileActiveStageRuns();
+            await promiseWithTimeout(this.runReconciler.reconcileActiveRuns(), this.options.reconcileTimeoutMs ?? DEFAULT_RECONCILE_TIMEOUT_MS, "Background active-run reconciliation");
         }
         catch (error) {
-            this.logger.warn({
-                error: error instanceof Error ? error.message : String(error),
-            }, "Background active-stage reconciliation failed");
+            this.logger.warn({ error: error instanceof Error ? error.message : String(error) }, "Background active-run reconciliation failed");
         }
         finally {
             this.reconcileInProgress = false;
@@ -139,3 +97,12 @@ export class ServiceRuntime {
         }
     }
 }
+function promiseWithTimeout(promise, timeoutMs, label) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            reject(new Error(`${label} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        timeout.unref?.();
+        promise.then((value) => { clearTimeout(timeout); resolve(value); }, (error) => { clearTimeout(timeout); reject(error); });
+    });
+}

package/dist/service-webhooks.js

@@ -1,5 +1,5 @@
 import { normalizeWebhook } from "./webhooks.js";
-import { redactSensitiveHeaders, timestampMsWithinSkew, verifyHmacSha256Hex } from "./utils.js";
+import { timestampMsWithinSkew, verifyHmacSha256Hex } from "./utils.js";
 export async function acceptIncomingWebhook(params) {
     const receivedAt = new Date().toISOString();
     const signature = typeof params.headers["linear-signature"] === "string" ? params.headers["linear-signature"] : "";
@@ -21,47 +21,24 @@ export async function acceptIncomingWebhook(params) {
     }
     let normalized;
     try {
-        normalized = normalizeWebhook({
-            webhookId: params.webhookId,
-            payload,
-        });
+        normalized = normalizeWebhook({ webhookId: params.webhookId, payload });
     }
     catch (error) {
         params.logger.warn({ webhookId: params.webhookId, error }, "Rejecting unsupported webhook payload");
         return { status: 400, body: { ok: false, reason: "unsupported_payload" } };
     }
-    const sanitizedHeaders = redactSensitiveHeaders(params.headers);
-    const headersJson = JSON.stringify(sanitizedHeaders);
     const payloadJson = JSON.stringify(payload);
     logWebhookSummary(params.logger, normalized);
     const stored = params.stores.webhookEvents.insertWebhookEvent({
         webhookId: params.webhookId,
         receivedAt,
-        eventType: normalized.eventType,
-        ...(normalized.issue ? { issueId: normalized.issue.id } : {}),
-        headersJson,
         payloadJson,
-        signatureValid: true,
-        dedupeStatus: "accepted",
     });
-    if (!stored.inserted) {
-        recordEventReceipt(params.stores, {
-            webhookId: params.webhookId,
-            receivedAt,
-            normalized,
-            headersJson,
-            payloadJson,
-        });
+    const isDuplicate = stored.dedupeStatus === "duplicate";
+    if (isDuplicate) {
         params.logger.info({ webhookId: params.webhookId, webhookEventId: stored.id }, "Ignoring duplicate webhook delivery");
         return { status: 200, body: { ok: true, duplicate: true } };
     }
-    recordEventReceipt(params.stores, {
-        webhookId: params.webhookId,
-        receivedAt,
-        normalized,
-        headersJson,
-        payloadJson,
-    });
     params.logger.info({
         webhookId: params.webhookId,
         webhookEventId: stored.id,
@@ -70,27 +47,11 @@ export async function acceptIncomingWebhook(params) {
         issueId: normalized.issue?.id,
     }, "Accepted Linear webhook for asynchronous processing");
     return {
-        accepted: {
-            id: stored.id,
-            normalized,
-            payload,
-        },
+        accepted: { id: stored.id, normalized, payload },
         status: 200,
         body: { ok: true, accepted: true, webhookEventId: stored.id },
     };
 }
-function recordEventReceipt(stores, params) {
-    stores.eventReceipts.insertEventReceipt({
-        source: "linear-webhook",
-        externalId: params.webhookId,
-        eventType: params.normalized.eventType,
-        receivedAt: params.receivedAt,
-        acceptanceStatus: "accepted",
-        ...(params.normalized.issue ? { linearIssueId: params.normalized.issue.id } : {}),
-        headersJson: params.headersJson,
-        payloadJson: params.payloadJson,
-    });
-}
 function logWebhookSummary(logger, normalized) {
     const issueRef = normalized.issue?.identifier ?? normalized.issue?.id ?? normalized.installation?.appUserId ?? normalized.entityType;
     const stateName = normalized.issue?.stateName;
@@ -100,9 +61,7 @@ function logWebhookSummary(logger, normalized) {
         normalized.triggerEvent,
         stateName ? `to ${stateName}` : undefined,
         title ? `(${title})` : undefined,
-    ]
-        .filter(Boolean)
-        .join(" ");
+    ].filter(Boolean).join(" ");
     logger.info({
         issueKey: normalized.issue?.identifier,
         triggerEvent: normalized.triggerEvent,
@@ -111,9 +70,5 @@ function logWebhookSummary(logger, normalized) {
         appUserId: normalized.installation?.appUserId,
         notificationType: normalized.installation?.notificationType,
     }, summary);
-    logger.debug({
-        webhookId: normalized.webhookId,
-        eventType: normalized.eventType,
-        issueId: normalized.issue?.id,
-    }, "Webhook metadata");
+    logger.debug({ webhookId: normalized.webhookId, eventType: normalized.eventType, issueId: normalized.issue?.id }, "Webhook metadata");
 }

package/dist/service.js

@@ -1,49 +1,21 @@
+import { GitHubWebhookHandler } from "./github-webhook-handler.js";
 import { IssueQueryService } from "./issue-query-service.js";
 import { LinearOAuthService } from "./linear-oauth-service.js";
+import { RunOrchestrator } from "./run-orchestrator.js";
 import { OperatorEventFeed } from "./operator-feed.js";
 import { buildSessionStatusUrl, createSessionStatusToken, deriveSessionStatusSigningSecret, verifySessionStatusToken, } from "./public-agent-session-status.js";
 import { ServiceRuntime } from "./service-runtime.js";
-import { ServiceStageFinalizer } from "./service-stage-finalizer.js";
-import { ServiceStageRunner } from "./service-stage-runner.js";
-import { ServiceWebhookProcessor } from "./service-webhook-processor.js";
+import { WebhookHandler } from "./webhook-handler.js";
 import { acceptIncomingWebhook } from "./service-webhooks.js";
-function createServiceStores(db) {
-    return {
-        webhookEvents: db.webhookEvents,
-        eventReceipts: db.eventReceipts,
-        issueControl: db.issueControl,
-        issueSessions: db.issueSessions,
-        workspaceOwnership: db.workspaceOwnership,
-        runLeases: db.runLeases,
-        obligations: db.obligations,
-        workflowCoordinator: db.workflowCoordinator,
-        issueWorkflows: db.issueWorkflows,
-        stageEvents: db.stageEvents,
-        linearInstallations: db.linearInstallations,
-    };
-}
-function createReadyIssueSource(stores) {
-    return {
-        listIssuesReadyForExecution: () => stores.issueControl.listIssueControlsReadyForLaunch().map((issue) => ({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-        })),
-    };
-}
-// PatchRelayService wires together the harness layers:
-// - integration: webhook intake, OAuth, Linear client access
-// - coordination: runtime queueing, stage launch, completion, reconciliation
-// - execution: Codex app-server and worktree-backed stage runs
-// - observability: issue/report query surfaces
 export class PatchRelayService {
     config;
     db;
     codex;
     logger;
     linearProvider;
-    stageRunner;
-    stageFinalizer;
-    webhookProcessor;
+    orchestrator;
+    webhookHandler;
+    githubWebhookHandler;
     oauthService;
     queryService;
     runtime;
@@ -55,22 +27,19 @@ export class PatchRelayService {
         this.logger = logger;
         this.linearProvider = toLinearClientProvider(linearProvider);
         this.feed = new OperatorEventFeed(db.operatorFeed);
-        const stores = createServiceStores(db);
-        this.stageRunner = new ServiceStageRunner(config, stores, codex, this.linearProvider, logger, (fn) => db.connection.transaction(fn)(), this.feed);
         let enqueueIssue = () => {
             throw new Error("Service runtime enqueueIssue is not initialized");
         };
-        this.stageFinalizer = new ServiceStageFinalizer(config, stores, codex, this.linearProvider, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed, (fn) => db.connection.transaction(fn)());
-        this.webhookProcessor = new ServiceWebhookProcessor(config, stores, this.linearProvider, codex, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed);
-        const runtime = new ServiceRuntime(codex, logger, this.stageFinalizer, createReadyIssueSource(stores), this.webhookProcessor, {
-            processIssue: (item) => this.stageRunner.run(item),
-        });
+        this.orchestrator = new RunOrchestrator(config, db, codex, this.linearProvider, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed);
+        this.webhookHandler = new WebhookHandler(config, db, this.linearProvider, codex, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed);
+        this.githubWebhookHandler = new GitHubWebhookHandler(config, db, this.linearProvider, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed);
+        const runtime = new ServiceRuntime(codex, logger, this.orchestrator, { listIssuesReadyForExecution: () => db.listIssuesReadyForExecution() }, this.webhookHandler, { processIssue: (item) => this.orchestrator.run(item) });
         enqueueIssue = (projectId, issueId) => runtime.enqueueIssue(projectId, issueId);
-        this.oauthService = new LinearOAuthService(config, stores, logger);
-        this.queryService = new IssueQueryService(stores, codex, this.stageFinalizer);
+        this.oauthService = new LinearOAuthService(config, { linearInstallations: db.linearInstallations }, logger);
+        this.queryService = new IssueQueryService(db, codex, this.orchestrator);
         this.runtime = runtime;
         this.codex.on("notification", (notification) => {
-            void this.stageFinalizer.handleCodexNotification(notification);
+            void this.orchestrator.handleCodexNotification(notification);
         });
     }
     async start() {
@@ -104,8 +73,12 @@ export class PatchRelayService {
         const result = await acceptIncomingWebhook({
             config: this.config,
             stores: {
-                webhookEvents: this.db.webhookEvents,
-                eventReceipts: this.db.eventReceipts,
+                webhookEvents: {
+                    insertWebhookEvent: (p) => {
+                        const r = this.db.insertFullWebhookEvent(p);
+                        return { id: r.id, dedupeStatus: r.dedupeStatus };
+                    },
+                },
             },
             logger: this.logger,
             webhookId: params.webhookId,
@@ -122,11 +95,22 @@ export class PatchRelayService {
             body: result.body,
         };
     }
+    async acceptGitHubWebhook(params) {
+        const result = await this.githubWebhookHandler.acceptGitHubWebhook(params);
+        if (result.body.accepted && result.body.webhookEventId) {
+            // Process inline since GitHub events are lightweight (just PR state updates)
+            await this.githubWebhookHandler.processGitHubWebhookEvent({
+                eventType: params.eventType,
+                rawBody: params.rawBody.toString("utf8"),
+            });
+        }
+        return result;
+    }
     async processWebhookEvent(webhookEventId) {
-        await this.webhookProcessor.processWebhookEvent(webhookEventId);
+        await this.webhookHandler.processWebhookEvent(webhookEventId);
     }
     async processIssue(item) {
-        await this.stageRunner.run(item);
+        await this.orchestrator.run(item);
     }
     async getIssueOverview(issueKey) {
         return await this.queryService.getIssueOverview(issueKey);
@@ -134,16 +118,15 @@ export class PatchRelayService {
     async getIssueReport(issueKey) {
         return await this.queryService.getIssueReport(issueKey);
     }
-    async getStageEvents(issueKey, stageRunId) {
-        return await this.queryService.getStageEvents(issueKey, stageRunId);
+    async getRunEvents(issueKey, runId) {
+        return await this.queryService.getRunEvents(issueKey, runId);
     }
-    async getActiveStageStatus(issueKey) {
-        return await this.queryService.getActiveStageStatus(issueKey);
+    async getActiveRunStatus(issueKey) {
+        return await this.orchestrator.getActiveRunStatus(issueKey);
     }
     createPublicAgentSessionStatusLink(issueKey, options) {
-        if (!this.config.server.publicBaseUrl) {
+        if (!this.config.server.publicBaseUrl)
             return undefined;
-        }
         const signingSecret = deriveSessionStatusSigningSecret(this.config.linear.tokenEncryptionKey);
         const token = createSessionStatusToken({
             issueKey,
@@ -152,11 +135,7 @@ export class PatchRelayService {
             ...(options?.ttlSeconds !== undefined ? { ttlSeconds: options.ttlSeconds } : {}),
         });
         return {
-            url: buildSessionStatusUrl({
-                publicBaseUrl: this.config.server.publicBaseUrl,
-                issueKey,
-                token: token.token,
-            }),
+            url: buildSessionStatusUrl({ publicBaseUrl: this.config.server.publicBaseUrl, issueKey, token: token.token }),
             issueKey: token.issueKey,
             expiresAt: token.expiresAt,
         };
@@ -168,9 +147,8 @@ export class PatchRelayService {
             return { status: "invalid_token" };
         }
         const sessionStatus = await this.queryService.getPublicAgentSessionStatus(params.issueKey);
-        if (!sessionStatus) {
+        if (!sessionStatus)
             return { status: "issue_not_found" };
-        }
         return {
             status: "ok",
             issueKey: params.issueKey,