patchrelay 0.12.9 → 0.13.0

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

@@ -0,0 +1,160 @@
+import { useEffect, useRef } from "react";
+export function useDetailStream(options) {
+    const optionsRef = useRef(options);
+    optionsRef.current = options;
+    useEffect(() => {
+        const { issueKey } = optionsRef.current;
+        if (!issueKey)
+            return;
+        const abortController = new AbortController();
+        const { baseUrl, bearerToken, dispatch } = optionsRef.current;
+        const headers = { accept: "application/json" };
+        if (bearerToken) {
+            headers.authorization = `Bearer ${bearerToken}`;
+        }
+        // Rehydrate from thread/read via /api/issues/:key/live
+        void rehydrate(baseUrl, issueKey, headers, abortController.signal, dispatch);
+        // Stream codex notifications via filtered SSE
+        void streamCodexEvents(baseUrl, issueKey, headers, abortController.signal, dispatch);
+        return () => {
+            abortController.abort();
+        };
+    }, [options.issueKey]);
+}
+async function rehydrate(baseUrl, issueKey, headers, signal, dispatch) {
+    try {
+        const url = new URL(`/api/issues/${encodeURIComponent(issueKey)}/live`, baseUrl);
+        const response = await fetch(url, { headers, signal });
+        if (!response.ok)
+            return;
+        const data = await response.json();
+        const threadData = data.thread;
+        if (!threadData)
+            return;
+        const thread = materializeThread(threadData);
+        dispatch({ type: "thread-snapshot", thread });
+    }
+    catch {
+        // Rehydration is best-effort — SSE stream will provide updates
+    }
+}
+async function streamCodexEvents(baseUrl, issueKey, baseHeaders, signal, dispatch) {
+    try {
+        const url = new URL("/api/watch", baseUrl);
+        url.searchParams.set("issue", issueKey);
+        const headers = { ...baseHeaders, accept: "text/event-stream" };
+        const response = await fetch(url, { headers, signal });
+        if (!response.ok || !response.body)
+            return;
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let eventType = "";
+        let dataLines = [];
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let newlineIndex = buffer.indexOf("\n");
+            while (newlineIndex !== -1) {
+                const rawLine = buffer.slice(0, newlineIndex);
+                buffer = buffer.slice(newlineIndex + 1);
+                const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+                if (!line) {
+                    if (dataLines.length > 0) {
+                        processDetailEvent(dispatch, eventType, dataLines.join("\n"));
+                        dataLines = [];
+                        eventType = "";
+                    }
+                    newlineIndex = buffer.indexOf("\n");
+                    continue;
+                }
+                if (line.startsWith(":")) {
+                    newlineIndex = buffer.indexOf("\n");
+                    continue;
+                }
+                if (line.startsWith("event:")) {
+                    eventType = line.slice(6).trim();
+                }
+                else if (line.startsWith("data:")) {
+                    dataLines.push(line.slice(5).trimStart());
+                }
+                newlineIndex = buffer.indexOf("\n");
+            }
+        }
+    }
+    catch {
+        // Stream ended or aborted
+    }
+}
+function processDetailEvent(dispatch, eventType, data) {
+    try {
+        if (eventType === "codex") {
+            const parsed = JSON.parse(data);
+            dispatch({ type: "codex-notification", method: parsed.method, params: parsed.params });
+        }
+        // Feed events are already handled by the main watch stream
+    }
+    catch {
+        // Ignore parse errors
+    }
+}
+// ─── Thread Materialization from thread/read ──────────────────────
+function materializeThread(summary) {
+    return {
+        threadId: summary.id,
+        status: summary.status,
+        turns: summary.turns.map(materializeTurn),
+    };
+}
+function materializeTurn(turn) {
+    return {
+        id: turn.id,
+        status: turn.status,
+        items: turn.items.map(materializeItem),
+    };
+}
+function materializeItem(item) {
+    // CodexThreadItem has an index-signature catch-all that defeats narrowing.
+    // Access fields via Record<string, unknown> and coerce explicitly.
+    const r = item;
+    const id = String(r.id ?? "unknown");
+    const type = String(r.type ?? "unknown");
+    const base = { id, type, status: "completed" };
+    switch (type) {
+        case "agentMessage":
+            return { ...base, text: String(r.text ?? "") };
+        case "commandExecution":
+            return {
+                ...base,
+                command: String(r.command ?? ""),
+                status: String(r.status ?? "completed"),
+                ...(typeof r.exitCode === "number" ? { exitCode: r.exitCode } : {}),
+                ...(typeof r.durationMs === "number" ? { durationMs: r.durationMs } : {}),
+                ...(typeof r.aggregatedOutput === "string" ? { output: r.aggregatedOutput } : {}),
+            };
+        case "fileChange":
+            return { ...base, status: String(r.status ?? "completed"), changes: Array.isArray(r.changes) ? r.changes : [] };
+        case "mcpToolCall":
+            return {
+                ...base,
+                status: String(r.status ?? "completed"),
+                toolName: `${String(r.server ?? "")}/${String(r.tool ?? "")}`,
+                ...(typeof r.durationMs === "number" ? { durationMs: r.durationMs } : {}),
+            };
+        case "dynamicToolCall":
+            return {
+                ...base,
+                status: String(r.status ?? "completed"),
+                toolName: String(r.tool ?? ""),
+                ...(typeof r.durationMs === "number" ? { durationMs: r.durationMs } : {}),
+            };
+        case "plan":
+            return { ...base, text: String(r.text ?? "") };
+        case "reasoning":
+            return { ...base, text: Array.isArray(r.summary) ? r.summary.join("\n") : "" };
+        default:
+            return base;
+    }
+}

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

@@ -0,0 +1,102 @@
+import { useEffect, useRef } from "react";
+export function useWatchStream(options) {
+    const optionsRef = useRef(options);
+    optionsRef.current = options;
+    useEffect(() => {
+        let abortController = new AbortController();
+        let reconnectTimeout;
+        let attempt = 0;
+        const connect = () => {
+            abortController = new AbortController();
+            const { baseUrl, bearerToken, issueFilter, dispatch } = optionsRef.current;
+            const url = new URL("/api/watch", baseUrl);
+            if (issueFilter) {
+                url.searchParams.set("issue", issueFilter);
+            }
+            const headers = { accept: "text/event-stream" };
+            if (bearerToken) {
+                headers.authorization = `Bearer ${bearerToken}`;
+            }
+            void fetch(url, { headers, signal: abortController.signal })
+                .then(async (response) => {
+                if (!response.ok || !response.body) {
+                    throw new Error(`Watch stream failed: ${response.status}`);
+                }
+                dispatch({ type: "connected" });
+                attempt = 0;
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = "";
+                let eventType = "";
+                let dataLines = [];
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    let newlineIndex = buffer.indexOf("\n");
+                    while (newlineIndex !== -1) {
+                        const rawLine = buffer.slice(0, newlineIndex);
+                        buffer = buffer.slice(newlineIndex + 1);
+                        const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+                        if (!line) {
+                            if (dataLines.length > 0) {
+                                processEvent(dispatch, eventType, dataLines.join("\n"));
+                                dataLines = [];
+                                eventType = "";
+                            }
+                            newlineIndex = buffer.indexOf("\n");
+                            continue;
+                        }
+                        if (line.startsWith(":")) {
+                            newlineIndex = buffer.indexOf("\n");
+                            continue;
+                        }
+                        if (line.startsWith("event:")) {
+                            eventType = line.slice(6).trim();
+                        }
+                        else if (line.startsWith("data:")) {
+                            dataLines.push(line.slice(5).trimStart());
+                        }
+                        newlineIndex = buffer.indexOf("\n");
+                    }
+                }
+            })
+                .catch((error) => {
+                if (abortController.signal.aborted)
+                    return;
+                const _msg = error instanceof Error ? error.message : String(error);
+            })
+                .finally(() => {
+                if (abortController.signal.aborted)
+                    return;
+                dispatch({ type: "disconnected" });
+                attempt = Math.min(attempt + 1, 5);
+                const delay = Math.min(2000 * Math.pow(2, attempt), 30000);
+                reconnectTimeout = setTimeout(connect, delay);
+            });
+        };
+        connect();
+        return () => {
+            abortController.abort();
+            if (reconnectTimeout !== undefined) {
+                clearTimeout(reconnectTimeout);
+            }
+        };
+    }, []);
+}
+function processEvent(dispatch, eventType, data) {
+    try {
+        if (eventType === "issues") {
+            const issues = JSON.parse(data);
+            dispatch({ type: "issues-snapshot", issues });
+        }
+        else if (eventType === "feed") {
+            const event = JSON.parse(data);
+            dispatch({ type: "feed-event", event });
+        }
+    }
+    catch {
+        // Ignore parse errors from malformed events
+    }
+}

package/dist/cli/watch/watch-state.js

@@ -0,0 +1,261 @@
+export const initialWatchState = {
+    connected: false,
+    issues: [],
+    selectedIndex: 0,
+    view: "list",
+    activeDetailKey: null,
+    thread: null,
+};
+export function watchReducer(state, action) {
+    switch (action.type) {
+        case "connected":
+            return { ...state, connected: true };
+        case "disconnected":
+            return { ...state, connected: false };
+        case "issues-snapshot":
+            return {
+                ...state,
+                issues: action.issues,
+                selectedIndex: Math.min(state.selectedIndex, Math.max(0, action.issues.length - 1)),
+            };
+        case "feed-event":
+            return applyFeedEvent(state, action.event);
+        case "select":
+            return {
+                ...state,
+                selectedIndex: Math.max(0, Math.min(action.index, state.issues.length - 1)),
+            };
+        case "enter-detail":
+            return { ...state, view: "detail", activeDetailKey: action.issueKey, thread: null };
+        case "exit-detail":
+            return { ...state, view: "list", activeDetailKey: null, thread: null };
+        case "thread-snapshot":
+            return { ...state, thread: action.thread };
+        case "codex-notification":
+            return applyCodexNotification(state, action.method, action.params);
+    }
+}
+// ─── Feed Event Application ───────────────────────────────────────
+function applyFeedEvent(state, event) {
+    if (!event.issueKey) {
+        return state;
+    }
+    const index = state.issues.findIndex((issue) => issue.issueKey === event.issueKey);
+    if (index === -1) {
+        return state;
+    }
+    const updated = [...state.issues];
+    const issue = { ...updated[index] };
+    if (event.kind === "stage" && event.stage) {
+        issue.factoryState = event.stage;
+    }
+    if (event.kind === "stage" && event.status === "starting" && event.stage) {
+        issue.activeRunType = event.stage;
+    }
+    if (event.kind === "turn") {
+        if (event.status === "completed" || event.status === "failed") {
+            issue.activeRunType = undefined;
+            issue.latestRunStatus = event.status;
+        }
+    }
+    if (event.kind === "github" && event.status) {
+        if (event.status === "check_passed" || event.status === "check_failed") {
+            issue.prCheckStatus = event.status === "check_passed" ? "passed" : "failed";
+        }
+    }
+    issue.updatedAt = event.at;
+    updated[index] = issue;
+    return { ...state, issues: updated };
+}
+// ─── Codex Notification Application ───────────────────────────────
+function applyCodexNotification(state, method, params) {
+    if (!state.thread) {
+        // No thread loaded yet — only turn/started can bootstrap one
+        if (method === "turn/started") {
+            return bootstrapThreadFromTurnStarted(state, params);
+        }
+        return state;
+    }
+    switch (method) {
+        case "turn/started":
+            return withThread(state, addTurn(state.thread, params));
+        case "turn/completed":
+            return withThread(state, completeTurn(state.thread, params));
+        case "turn/plan/updated":
+            return withThread(state, updatePlan(state.thread, params));
+        case "turn/diff/updated":
+            return withThread(state, updateDiff(state.thread, params));
+        case "item/started":
+            return withThread(state, addItem(state.thread, params));
+        case "item/completed":
+            return withThread(state, completeItem(state.thread, params));
+        case "item/agentMessage/delta":
+            return withThread(state, appendItemText(state.thread, params));
+        case "item/commandExecution/outputDelta":
+            return withThread(state, appendItemOutput(state.thread, params));
+        case "item/plan/delta":
+            return withThread(state, appendItemText(state.thread, params));
+        case "item/reasoning/summaryTextDelta":
+            return withThread(state, appendItemText(state.thread, params));
+        case "thread/status/changed":
+            return withThread(state, updateThreadStatus(state.thread, params));
+        default:
+            return state;
+    }
+}
+function withThread(state, thread) {
+    return { ...state, thread };
+}
+function bootstrapThreadFromTurnStarted(state, params) {
+    const turnObj = params.turn;
+    const threadId = typeof params.threadId === "string" ? params.threadId : "unknown";
+    const turnId = typeof turnObj?.id === "string" ? turnObj.id : "unknown";
+    return {
+        ...state,
+        thread: {
+            threadId,
+            status: "active",
+            turns: [{ id: turnId, status: "inProgress", items: [] }],
+        },
+    };
+}
+// ─── Turn Handlers ────────────────────────────────────────────────
+function addTurn(thread, params) {
+    const turnObj = params.turn;
+    const turnId = typeof turnObj?.id === "string" ? turnObj.id : "unknown";
+    const existing = thread.turns.find((t) => t.id === turnId);
+    if (existing) {
+        return thread;
+    }
+    return {
+        ...thread,
+        status: "active",
+        turns: [...thread.turns, { id: turnId, status: "inProgress", items: [] }],
+    };
+}
+function completeTurn(thread, params) {
+    const turnObj = params.turn;
+    const turnId = typeof turnObj?.id === "string" ? turnObj.id : undefined;
+    const status = typeof turnObj?.status === "string" ? turnObj.status : "completed";
+    if (!turnId)
+        return thread;
+    return {
+        ...thread,
+        turns: thread.turns.map((t) => t.id === turnId ? { ...t, status } : t),
+    };
+}
+function updatePlan(thread, params) {
+    const plan = params.plan;
+    if (!Array.isArray(plan))
+        return thread;
+    return {
+        ...thread,
+        plan: plan.map((entry) => {
+            const e = entry;
+            return {
+                step: typeof e.step === "string" ? e.step : String(e.step ?? ""),
+                status: typeof e.status === "string" ? e.status : "pending",
+            };
+        }),
+    };
+}
+function updateDiff(thread, params) {
+    const diff = typeof params.diff === "string" ? params.diff : undefined;
+    return { ...thread, diff };
+}
+function updateThreadStatus(thread, params) {
+    const statusObj = params.status;
+    const statusType = typeof statusObj?.type === "string" ? statusObj.type : undefined;
+    if (!statusType)
+        return thread;
+    return { ...thread, status: statusType };
+}
+// ─── Item Handlers ────────────────────────────────────────────────
+function getLatestTurn(thread) {
+    return thread.turns[thread.turns.length - 1];
+}
+function updateLatestTurn(thread, updater) {
+    const last = getLatestTurn(thread);
+    if (!last)
+        return thread;
+    return {
+        ...thread,
+        turns: [...thread.turns.slice(0, -1), updater(last)],
+    };
+}
+function addItem(thread, params) {
+    const itemObj = params.item;
+    if (!itemObj)
+        return thread;
+    const id = typeof itemObj.id === "string" ? itemObj.id : "unknown";
+    const type = typeof itemObj.type === "string" ? itemObj.type : "unknown";
+    const status = typeof itemObj.status === "string" ? itemObj.status : "inProgress";
+    const item = { id, type, status };
+    if (type === "agentMessage" && typeof itemObj.text === "string") {
+        item.text = itemObj.text;
+    }
+    if (type === "commandExecution") {
+        const cmd = itemObj.command;
+        item.command = Array.isArray(cmd) ? cmd.join(" ") : typeof cmd === "string" ? cmd : undefined;
+    }
+    if (type === "mcpToolCall") {
+        const server = typeof itemObj.server === "string" ? itemObj.server : "";
+        const tool = typeof itemObj.tool === "string" ? itemObj.tool : "";
+        item.toolName = `${server}/${tool}`;
+    }
+    if (type === "dynamicToolCall") {
+        item.toolName = typeof itemObj.tool === "string" ? itemObj.tool : undefined;
+    }
+    return updateLatestTurn(thread, (turn) => ({
+        ...turn,
+        items: [...turn.items, item],
+    }));
+}
+function completeItem(thread, params) {
+    const itemObj = params.item;
+    if (!itemObj)
+        return thread;
+    const id = typeof itemObj.id === "string" ? itemObj.id : undefined;
+    if (!id)
+        return thread;
+    const status = typeof itemObj.status === "string" ? itemObj.status : "completed";
+    const exitCode = typeof itemObj.exitCode === "number" ? itemObj.exitCode : undefined;
+    const durationMs = typeof itemObj.durationMs === "number" ? itemObj.durationMs : undefined;
+    const text = typeof itemObj.text === "string" ? itemObj.text : undefined;
+    const changes = Array.isArray(itemObj.changes) ? itemObj.changes : undefined;
+    return updateLatestTurn(thread, (turn) => ({
+        ...turn,
+        items: turn.items.map((item) => {
+            if (item.id !== id)
+                return item;
+            return {
+                ...item,
+                status,
+                ...(exitCode !== undefined ? { exitCode } : {}),
+                ...(durationMs !== undefined ? { durationMs } : {}),
+                ...(text !== undefined ? { text } : {}),
+                ...(changes !== undefined ? { changes } : {}),
+            };
+        }),
+    }));
+}
+function appendItemText(thread, params) {
+    const itemId = typeof params.itemId === "string" ? params.itemId : undefined;
+    const delta = typeof params.delta === "string" ? params.delta : undefined;
+    if (!itemId || !delta)
+        return thread;
+    return updateLatestTurn(thread, (turn) => ({
+        ...turn,
+        items: turn.items.map((item) => item.id === itemId ? { ...item, text: (item.text ?? "") + delta } : item),
+    }));
+}
+function appendItemOutput(thread, params) {
+    const itemId = typeof params.itemId === "string" ? params.itemId : undefined;
+    const delta = typeof params.delta === "string" ? params.delta : undefined;
+    if (!itemId || !delta)
+        return thread;
+    return updateLatestTurn(thread, (turn) => ({
+        ...turn,
+        items: turn.items.map((item) => item.id === itemId ? { ...item, output: (item.output ?? "") + delta } : item),
+    }));
+}

package/dist/codex-app-server.js

@@ -141,11 +141,8 @@ export class CodexAppServerClient extends EventEmitter {
             modelProvider: this.config.modelProvider ?? null,
             baseInstructions: this.config.baseInstructions ?? null,
             developerInstructions: this.config.developerInstructions ?? null,
-            experimentalRawEvents: false,
+            experimentalRawEvents: this.config.experimentalRawEvents ?? false,
         };
-        if (this.config.persistExtendedHistory) {
-            this.logger.warn("persistExtendedHistory is requested but not enabled in the active app-server capability handshake; ignoring");
-        }
         const response = (await this.sendRequest("thread/start", params));
         return this.mapThread(response.thread);
     }

package/dist/config.js

@@ -95,6 +95,7 @@ const configSchema = z.object({
             approval_policy: z.enum(["never", "on-request", "on-failure", "untrusted"]).default("never"),
             sandbox_mode: z.enum(["danger-full-access", "workspace-write", "read-only"]).default("danger-full-access"),
             persist_extended_history: z.boolean().default(false),
+            experimental_raw_events: z.boolean().default(false),
         }),
     }),
     projects: z.array(projectSchema).default([]),
@@ -369,6 +370,7 @@ export function loadConfig(configPath = process.env.PATCHRELAY_CONFIG ?? getDefa
                 approvalPolicy: parsed.runner.codex.approval_policy,
                 sandboxMode: parsed.runner.codex.sandbox_mode,
                 persistExtendedHistory: parsed.runner.codex.persist_extended_history,
+                experimentalRawEvents: parsed.runner.codex.experimental_raw_events,
             },
         },
         projects: parsed.projects.map((project) => {

package/dist/github-webhook-handler.js

@@ -1,5 +1,8 @@
 import { resolveFactoryStateFromGitHub } from "./factory-state.js";
 import { normalizeGitHubWebhook, verifyGitHubWebhookSignature } from "./github-webhooks.js";
+import { buildAgentSessionPlanForIssue } from "./agent-session-plan.js";
+import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
+import { buildGitHubStateActivity } from "./linear-session-reporting.js";
 import { resolveSecret } from "./resolve-secret.js";
 import { safeJsonParse } from "./utils.js";
 /**
@@ -137,8 +140,9 @@ export class GitHubWebhookHandler {
                     factoryState: newState,
                 });
                 this.logger.info({ issueKey: issue.issueKey, from: afterMetadata.factoryState, to: newState, trigger: event.triggerEvent }, "Factory state transition from GitHub event");
-                // Emit Linear activity for significant state changes
-                void this.emitLinearActivity(issue, newState, event);
+                const transitionedIssue = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+                void this.emitLinearActivity(transitionedIssue, newState, event);
+                void this.syncLinearSession(transitionedIssue);
                 // Schedule merge prep when entering awaiting_queue
                 if (newState === "awaiting_queue") {
                     this.db.upsertIssue({
@@ -230,24 +234,14 @@ export class GitHubWebhookHandler {
             const linear = await this.linearProvider.forProject(issue.projectId);
             if (!linear?.createAgentActivity)
                 return;
-            const messages = {
-                pr_open: `PR #${event.prNumber ?? ""} opened.${event.prUrl ? ` ${event.prUrl}` : ""}`,
-                awaiting_queue: "PR approved. Preparing merge.",
-                changes_requested: `Review requested changes.${event.reviewerName ? ` Reviewer: ${event.reviewerName}` : ""}`,
-                repairing_ci: `CI check failed${event.checkName ? `: ${event.checkName}` : ""}. Starting repair.`,
-                repairing_queue: "Merge conflict with base branch. Starting repair.",
-                done: `PR merged and deployed.${event.prNumber ? ` PR #${event.prNumber}` : ""}`,
-                failed: "PR was closed without merging.",
-            };
-            const body = messages[newState];
-            if (!body)
+            const content = buildGitHubStateActivity(issue.factoryState, event);
+            if (!content)
                 return;
-            const type = newState === "failed" || newState === "repairing_ci" || newState === "repairing_queue"
-                ? "error"
-                : "response";
+            const allowEphemeral = content.type === "thought" || content.type === "action";
             await linear.createAgentActivity({
                 agentSessionId: issue.agentSessionId,
-                content: { type, body },
+                content,
+                ...(allowEphemeral ? { ephemeral: false } : {}),
             });
         }
         catch (error) {
@@ -263,4 +257,26 @@ export class GitHubWebhookHandler {
             });
         }
     }
+    async syncLinearSession(issue) {
+        if (!issue.agentSessionId)
+            return;
+        try {
+            const linear = await this.linearProvider.forProject(issue.projectId);
+            if (!linear?.updateAgentSession)
+                return;
+            const externalUrls = buildAgentSessionExternalUrls(this.config, {
+                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                ...(issue.prUrl ? { prUrl: issue.prUrl } : {}),
+            });
+            await linear.updateAgentSession({
+                agentSessionId: issue.agentSessionId,
+                plan: buildAgentSessionPlanForIssue(issue),
+                ...(externalUrls ? { externalUrls } : {}),
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to sync Linear session from GitHub webhook");
+        }
+    }
 }