patchrelay 0.74.7 → 0.75.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.74.7",
-  "commit": "53cd46e337f8",
-  "builtAt": "2026-05-29T11:49:02.626Z"
+  "version": "0.75.0",
+  "commit": "ad9b09da1d53",
+  "builtAt": "2026-05-29T13:21:05.647Z"
 }

package/dist/cli/watch/use-detail-stream.js

@@ -1,4 +1,7 @@
 import { useEffect, useRef } from "react";
+const DETAIL_REHYDRATE_INTERVAL_MS = 3000;
+const FEED_REHYDRATE_LIMIT = 100;
+const MAX_CACHED_FEED_EVENTS = 300;
 export function useDetailStream(options) {
     const optionsRef = useRef(options);
     optionsRef.current = options;
@@ -14,10 +17,24 @@ export function useDetailStream(options) {
         if (bearerToken) {
             headers.authorization = `Bearer ${bearerToken}`;
         }
-        void rehydrate(baseUrl, issueKey, headers, abortController.signal, dispatch);
+        const feedState = {
+            lastFeedEventId: undefined,
+            feedEvents: [],
+        };
+        let inFlight = false;
+        const runRehydrate = () => {
+            if (inFlight)
+                return;
+            inFlight = true;
+            void rehydrate(baseUrl, issueKey, headers, abortController.signal, dispatch, feedState)
+                .finally(() => {
+                inFlight = false;
+            });
+        };
+        runRehydrate();
         const intervalId = setInterval(() => {
-            void rehydrate(baseUrl, issueKey, headers, abortController.signal, dispatch);
-        }, 3000);
+            runRehydrate();
+        }, DETAIL_REHYDRATE_INTERVAL_MS);
         return () => {
             clearInterval(intervalId);
             abortController.abort();
@@ -25,17 +42,22 @@ export function useDetailStream(options) {
     }, [options.issueKey, options.active]);
 }
 // ─── Rehydration ──────────────────────────────────────────────────
-async function rehydrate(baseUrl, issueKey, headers, signal, dispatch) {
+async function rehydrate(baseUrl, issueKey, headers, signal, dispatch, feedState) {
     try {
         const url = new URL(`/api/issues/${encodeURIComponent(issueKey)}`, baseUrl);
-        const response = await fetch(url, { headers: { ...headers, accept: "application/json" }, signal });
+        const feedUrl = buildFeedUrl(baseUrl, issueKey, feedState.lastFeedEventId);
+        const [response, newFeedEvents] = await Promise.all([
+            fetch(url, { headers: { ...headers, accept: "application/json" }, signal }),
+            fetchFeedEvents(feedUrl, headers, signal),
+        ]);
         if (!response.ok)
             return;
+        updateFeedState(feedState, newFeedEvents);
         const data = await response.json();
         dispatch({
             type: "timeline-rehydrate",
             runs: Array.isArray(data.runs) ? data.runs : [],
-            feedEvents: [],
+            feedEvents: feedState.feedEvents,
             liveThread: data.liveThread ?? null,
             activeRunId: data.activeRun?.id ?? null,
             activeRunStartedAt: data.activeRun?.startedAt ?? null,
@@ -46,3 +68,39 @@ async function rehydrate(baseUrl, issueKey, headers, signal, dispatch) {
         // Rehydration is best-effort
     }
 }
+function buildFeedUrl(baseUrl, issueKey, afterId) {
+    const feedUrl = new URL(`/api/issues/${encodeURIComponent(issueKey)}/feed`, baseUrl);
+    feedUrl.searchParams.set("limit", String(FEED_REHYDRATE_LIMIT));
+    if (afterId !== undefined) {
+        feedUrl.searchParams.set("afterId", String(afterId));
+    }
+    return feedUrl;
+}
+async function fetchFeedEvents(url, headers, signal) {
+    try {
+        const response = await fetch(url, { headers: { ...headers, accept: "application/json" }, signal });
+        if (!response.ok)
+            return [];
+        const data = await response.json();
+        return Array.isArray(data.events) ? data.events : [];
+    }
+    catch {
+        return [];
+    }
+}
+function updateFeedState(feedState, newEvents) {
+    if (newEvents.length === 0)
+        return;
+    const byId = new Map();
+    for (const event of feedState.feedEvents) {
+        byId.set(event.id, event);
+    }
+    for (const event of newEvents) {
+        byId.set(event.id, event);
+    }
+    const feedEvents = [...byId.values()]
+        .sort((left, right) => left.id - right.id)
+        .slice(-MAX_CACHED_FEED_EVENTS);
+    feedState.feedEvents = feedEvents;
+    feedState.lastFeedEventId = feedEvents.at(-1)?.id;
+}

package/dist/codex-status.js

@@ -1,7 +1,8 @@
 import { spawnSync } from "node:child_process";
 const CODEX_STATUS_TIMEOUT_MS = 15_000;
 function stripAnsiCodes(value) {
-    return value.replace(/\u001b\[[0-9;]*m/g, "");
+    const escape = String.fromCharCode(27);
+    return value.replace(new RegExp(`${escape}\\[[0-9;]*m`, "g"), "");
 }
 function parseAccountLine(output) {
     const lines = output.split(/\r?\n/);

package/dist/http.js

@@ -264,6 +264,19 @@ export async function buildHttpServer(config, service, logger) {
             }
             return reply.send({ ok: true, ...result });
         });
+        app.get("/api/issues/:issueKey/feed", async (request, reply) => {
+            const issueKey = request.params.issueKey;
+            const afterId = getPositiveIntegerQueryParam(request, "afterId");
+            const requestedLimit = getPositiveIntegerQueryParam(request, "limit");
+            const result = service.listIssueFeedEvents(issueKey, {
+                ...(afterId !== undefined ? { afterId } : {}),
+                limit: requestedLimit ? Math.min(requestedLimit, 100) : 100,
+            });
+            if (!result) {
+                return reply.code(404).send({ ok: false, reason: "issue_not_found" });
+            }
+            return reply.send({ ok: true, events: result.events });
+        });
         app.get("/api/issues/:issueKey/live", async (request, reply) => {
             const issueKey = request.params.issueKey;
             const result = await service.getActiveRunStatus(issueKey);

package/dist/index.js

@@ -1,7 +1,19 @@
 #!/usr/bin/env node
 import { dirname } from "node:path";
 import { runCli } from "./cli/index.js";
+function suppressNodeSqliteExperimentalWarning() {
+    const originalEmitWarning = process.emitWarning;
+    process.emitWarning = function emitWarningWithoutNodeSqliteNoise(warning, optionsOrType, codeOrCtor, ctor) {
+        const message = warning instanceof Error ? warning.message : warning;
+        const type = typeof optionsOrType === "string" ? optionsOrType : optionsOrType?.type;
+        if (type === "ExperimentalWarning" && message.includes("SQLite is an experimental feature")) {
+            return;
+        }
+        return originalEmitWarning.call(process, warning, optionsOrType, codeOrCtor, ctor);
+    };
+}
 async function main() {
+    suppressNodeSqliteExperimentalWarning();
     const cliExitCode = await runCli(process.argv.slice(2));
     if (cliExitCode !== -1) {
         process.exitCode = cliExitCode;

package/dist/preflight.js

@@ -117,6 +117,9 @@ async function checkLinearApi(graphqlUrl) {
         if (response.ok) {
             return pass("linear_api", `Linear GraphQL API is reachable at ${graphqlUrl}`);
         }
+        if (response.status === 401 || response.status === 403) {
+            return pass("linear_api", `Linear GraphQL API is reachable at ${graphqlUrl} (authentication required)`);
+        }
         return warn("linear_api", `Linear GraphQL API returned ${response.status} — may be unreachable or rate-limited`);
     }
     catch (error) {

package/dist/service.js

@@ -338,6 +338,22 @@ export class PatchRelayService {
     async getIssueOverview(issueKey) {
         return await this.queryService.getIssueOverview(issueKey);
     }
+    listIssueFeedEvents(issueKey, options) {
+        const session = this.db.issueSessions.getIssueSessionByKey(issueKey);
+        const issue = this.db.issues.getIssueByKey(issueKey);
+        const projectId = session?.projectId ?? issue?.projectId;
+        const resolvedIssueKey = session?.issueKey ?? issue?.issueKey ?? issueKey;
+        if (!projectId)
+            return undefined;
+        return {
+            events: this.db.operatorFeed.list({
+                issueKey: resolvedIssueKey,
+                projectId,
+                ...(options?.afterId !== undefined ? { afterId: options.afterId } : {}),
+                limit: Math.min(options?.limit ?? 100, 100),
+            }),
+        };
+    }
     async getActiveRunStatus(issueKey) {
         return await this.orchestrator.getActiveRunStatus(issueKey);
     }

package/dist/telemetry.js

@@ -78,8 +78,24 @@ export class OperatorFeedTelemetrySink {
                     };
                 }
                 return undefined;
+            case "health.invariant":
+                return {
+                    level: event.status === "observed" ? "warn" : "info",
+                    kind: "workflow",
+                    ...(event.issueKey ? { issueKey: event.issueKey } : {}),
+                    ...(event.projectId ? { projectId: event.projectId } : {}),
+                    ...(event.runType ? { stage: event.runType } : {}),
+                    status: `health_${event.status}`,
+                    summary: event.status === "observed"
+                        ? `Health warning: ${formatInvariant(event.invariant)}`
+                        : `Health repaired: ${formatInvariant(event.invariant)}`,
+                    ...(event.detail ? { detail: event.detail } : {}),
+                };
             default:
                 return undefined;
         }
     }
 }
+function formatInvariant(invariant) {
+    return invariant.replaceAll("_", " ");
+}

package/package.json

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