patchrelay 0.12.6 → 0.12.8

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.12.6",
-  "commit": "62c29649ea46",
-  "builtAt": "2026-03-24T21:48:34.334Z"
+  "version": "0.12.8",
+  "commit": "711863ef2d94",
+  "builtAt": "2026-03-24T22:49:07.152Z"
 }

package/dist/codex-app-server.js

@@ -48,6 +48,15 @@ export class CodexAppServerClient extends EventEmitter {
         this.child = this.spawnProcess(launch.command, launch.args, {
             stdio: ["pipe", "pipe", "pipe"],
         });
+        this.child.stdin.on("error", (error) => {
+            this.logger.error({ error: sanitizeDiagnosticText(error.message) }, "Codex app-server stdin error");
+        });
+        this.child.stdout.on("error", (error) => {
+            this.logger.error({ error: sanitizeDiagnosticText(error.message) }, "Codex app-server stdout error");
+        });
+        this.child.stderr.on("error", (error) => {
+            this.logger.error({ error: sanitizeDiagnosticText(error.message) }, "Codex app-server stderr error");
+        });
         this.child.stderr.on("data", (chunk) => {
             const line = chunk.toString().trim();
             if (line) {
@@ -75,6 +84,13 @@ export class CodexAppServerClient extends EventEmitter {
         });
         this.child.stdout.on("data", (chunk) => {
             this.stdoutBuffer += chunk.toString("utf8");
+            if (this.stdoutBuffer.length > 50 * 1024 * 1024) {
+                this.logger.error({ bufferSize: this.stdoutBuffer.length }, "Codex app-server stdout buffer exceeded 50 MB — killing process");
+                this.stdoutBuffer = "";
+                this.rejectAllPending(new Error("Codex app-server stdout buffer overflow"));
+                this.child?.kill("SIGTERM");
+                return;
+            }
             this.drainMessages();
         });
         const initializeResponse = await this.sendRequest("initialize", {
@@ -96,14 +112,24 @@ export class CodexAppServerClient extends EventEmitter {
         this.started = true;
     }
     async stop() {
-        if (!this.child) {
+        const child = this.child;
+        if (!child) {
             return;
         }
         this.logger.info("Stopping Codex app-server");
         this.stopping = true;
-        this.child.kill("SIGTERM");
-        this.child = undefined;
         this.started = false;
+        const exited = new Promise((resolve) => {
+            child.on("close", () => resolve());
+        });
+        child.kill("SIGTERM");
+        this.child = undefined;
+        // Wait for the child to exit, but don't block shutdown forever.
+        const timeout = new Promise((resolve) => {
+            const timer = setTimeout(resolve, 10_000);
+            timer.unref?.();
+        });
+        await Promise.race([exited, timeout]);
     }
     async startThread(options) {
         const params = {

package/dist/db.js

@@ -217,6 +217,16 @@ export class PatchRelayDatabase {
             linearIssueId: String(row.linear_issue_id),
         }));
     }
+    /**
+     * Issues idle in pr_open with no active run — candidates for state
+     * advancement based on stored PR metadata (missed GitHub webhooks).
+     */
+    listIdlePrOpenIssues() {
+        const rows = this.connection
+            .prepare("SELECT * FROM issues WHERE factory_state = 'pr_open' AND active_run_id IS NULL AND pending_run_type IS NULL AND pr_number IS NOT NULL")
+            .all();
+        return rows.map(mapIssueRow);
+    }
     listIssuesByState(projectId, state) {
         const rows = this.connection
             .prepare("SELECT * FROM issues WHERE project_id = ? AND factory_state = ? ORDER BY pr_number ASC")

package/dist/http.js

@@ -312,6 +312,12 @@ export async function buildHttpServer(config, service, logger) {
             for (const event of service.listOperatorFeed(feedQuery)) {
                 writeEvent(event);
             }
+            const cleanup = () => {
+                clearInterval(keepAlive);
+                unsubscribe();
+                if (!reply.raw.destroyed)
+                    reply.raw.end();
+            };
             const unsubscribe = service.subscribeOperatorFeed((event) => {
                 if (!matchesOperatorFeedEvent(event, feedQuery)) {
                     return;
@@ -321,11 +327,8 @@ export async function buildHttpServer(config, service, logger) {
             const keepAlive = setInterval(() => {
                 reply.raw.write(": keepalive\n\n");
             }, 15000);
-            request.raw.on("close", () => {
-                clearInterval(keepAlive);
-                unsubscribe();
-                reply.raw.end();
-            });
+            reply.raw.on("error", cleanup);
+            request.raw.on("close", cleanup);
         });
         app.get("/api/installations", async (_request, reply) => {
             return reply.send({ ok: true, installations: service.listLinearInstallations() });

package/dist/index.js

@@ -62,15 +62,16 @@ async function main() {
         secrets: config.secretSources,
     }, "PatchRelay started");
     const shutdown = async () => {
-        service.stop();
+        await service.stop();
         await app.close();
     };
-    process.once("SIGINT", () => {
-        void shutdown();
-    });
-    process.once("SIGTERM", () => {
-        void shutdown();
-    });
+    const onSignal = (signal) => {
+        shutdown().catch((error) => {
+            logger.error({ signal, error: error instanceof Error ? error.message : String(error) }, "Shutdown error");
+        }).finally(() => { process.exitCode ??= 0; });
+    };
+    process.once("SIGINT", () => onSignal("SIGINT"));
+    process.once("SIGTERM", () => onSignal("SIGTERM"));
 }
 main().catch((error) => {
     process.stderr.write(`${error instanceof Error ? error.stack : String(error)}\n`);

package/dist/run-orchestrator.js

@@ -349,6 +349,57 @@ export class RunOrchestrator {
         for (const run of this.db.listRunningRuns()) {
             await this.reconcileRun(run);
         }
+        // Advance issues stuck in pr_open whose stored PR metadata already
+        // shows they should transition (e.g. approved PR, missed webhook).
+        await this.reconcileIdlePrOpenIssues();
+    }
+    async reconcileIdlePrOpenIssues() {
+        for (const issue of this.db.listIdlePrOpenIssues()) {
+            if (issue.prState === "merged") {
+                this.advanceIdleIssue(issue, "done");
+                continue;
+            }
+            if (issue.prReviewState === "approved") {
+                this.advanceIdleIssue(issue, "awaiting_queue");
+                continue;
+            }
+            // Stored metadata may be stale (missed webhooks during downtime).
+            // Query GitHub for the actual PR review state.
+            const project = this.config.projects.find((p) => p.id === issue.projectId);
+            if (!project?.github?.repoFullName || !issue.prNumber)
+                continue;
+            try {
+                const { stdout } = await execCommand("gh", [
+                    "pr", "view", String(issue.prNumber),
+                    "--repo", project.github.repoFullName,
+                    "--json", "state,reviewDecision",
+                ], { timeoutMs: 10_000 });
+                const pr = JSON.parse(stdout);
+                if (pr.state === "MERGED") {
+                    this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
+                    this.advanceIdleIssue(issue, "done");
+                }
+                else if (pr.reviewDecision === "APPROVED") {
+                    this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prReviewState: "approved" });
+                    this.advanceIdleIssue(issue, "awaiting_queue");
+                }
+            }
+            catch (error) {
+                this.logger.debug({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to query GitHub PR state during reconciliation");
+            }
+        }
+    }
+    advanceIdleIssue(issue, newState) {
+        this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState }, "Reconciliation: advancing idle issue from stored PR metadata");
+        this.db.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            factoryState: newState,
+            ...(newState === "awaiting_queue" ? { pendingMergePrep: true } : {}),
+        });
+        if (newState === "awaiting_queue") {
+            this.enqueueIssue(issue.projectId, issue.linearIssueId);
+        }
     }
     async reconcileRun(run) {
         const issue = this.db.getIssue(run.projectId, run.linearIssueId);

package/dist/service-runtime.js

@@ -44,10 +44,10 @@ export class ServiceRuntime {
             throw error;
         }
     }
-    stop() {
+    async stop() {
         this.ready = false;
         this.clearBackgroundReconcile();
-        void this.codex.stop();
+        await this.codex.stop();
     }
     enqueueWebhookEvent(eventId, options) {
         this.webhookQueue.enqueue(eventId, options);
@@ -90,6 +90,11 @@ export class ServiceRuntime {
         this.reconcileInProgress = true;
         try {
             await promiseWithTimeout(this.runReconciler.reconcileActiveRuns(), this.options.reconcileTimeoutMs ?? DEFAULT_RECONCILE_TIMEOUT_MS, "Background active-run reconciliation");
+            // Pick up issues that became ready outside the webhook path
+            // (e.g. CLI retry, manual DB edits) without requiring a restart.
+            for (const issue of this.readyIssueSource.listIssuesReadyForExecution()) {
+                this.enqueueIssue(issue.projectId, issue.linearIssueId);
+            }
         }
         catch (error) {
             this.logger.warn({ error: error instanceof Error ? error.message : String(error) }, "Background active-run reconciliation failed");

package/dist/service.js

@@ -115,9 +115,9 @@ export class PatchRelayService {
         await this.runtime.start();
         this.mergeQueue.seedOnStartup();
     }
-    stop() {
+    async stop() {
         this.githubAppTokenManager?.stop();
-        this.runtime.stop();
+        await this.runtime.stop();
     }
     async createLinearOAuthStart(params) {
         return await this.oauthService.createStart(params);

package/dist/webhook-handler.js

@@ -230,7 +230,8 @@ export class WebhookHandler {
                     summary: `Delivered follow-up prompt to active ${activeRun.runType} workflow`,
                 });
             }
-            catch {
+            catch (error) {
+                this.logger.warn({ issueKey: trackedIssue?.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to deliver follow-up prompt");
                 this.feed?.publish({
                     level: "warn",
                     kind: "agent",
@@ -288,7 +289,8 @@ export class WebhookHandler {
                 summary: `Delivered follow-up comment to active ${run.runType} workflow`,
             });
         }
-        catch {
+        catch (error) {
+            this.logger.warn({ issueKey: trackedIssue?.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to deliver follow-up comment");
             this.feed?.publish({
                 level: "warn",
                 kind: "comment",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.12.6",
+  "version": "0.12.8",
   "license": "MIT",
   "type": "module",
   "repository": {