patchrelay 0.12.9 → 0.14.0

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

@@ -0,0 +1,193 @@
+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) {
+            dispatch({ type: "thread-snapshot", thread: materializeThread(threadData) });
+            return;
+        }
+        // No active thread — fall back to latest run report
+        await rehydrateFromReport(baseUrl, issueKey, headers, signal, dispatch);
+    }
+    catch {
+        // Rehydration is best-effort — SSE stream will provide updates
+    }
+}
+async function rehydrateFromReport(baseUrl, issueKey, headers, signal, dispatch) {
+    try {
+        const url = new URL(`/api/issues/${encodeURIComponent(issueKey)}/report`, baseUrl);
+        const response = await fetch(url, { headers, signal });
+        if (!response.ok)
+            return;
+        const data = await response.json();
+        const latest = data.runs?.[0];
+        if (!latest)
+            return;
+        const report = {
+            runType: latest.run.runType,
+            status: latest.run.status,
+            summary: typeof latest.summary?.latestAssistantMessage === "string"
+                ? latest.summary.latestAssistantMessage
+                : latest.report?.assistantMessages.at(-1),
+            commands: latest.report?.commands.map((c) => ({
+                command: c.command,
+                ...(typeof c.exitCode === "number" ? { exitCode: c.exitCode } : {}),
+                ...(typeof c.durationMs === "number" ? { durationMs: c.durationMs } : {}),
+            })) ?? [],
+            fileChanges: latest.report?.fileChanges.length ?? 0,
+            toolCalls: latest.report?.toolCalls.length ?? 0,
+            assistantMessages: latest.report?.assistantMessages ?? [],
+        };
+        dispatch({ type: "report-snapshot", report });
+    }
+    catch {
+        // Report fetch is best-effort
+    }
+}
+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,285 @@
+export const initialWatchState = {
+    connected: false,
+    issues: [],
+    selectedIndex: 0,
+    view: "list",
+    activeDetailKey: null,
+    thread: null,
+    report: null,
+    filter: "non-done",
+};
+const TERMINAL_FACTORY_STATES = new Set(["done", "failed"]);
+export function filterIssues(issues, filter) {
+    switch (filter) {
+        case "all":
+            return issues;
+        case "active":
+            return issues.filter((i) => i.activeRunType !== undefined);
+        case "non-done":
+            return issues.filter((i) => !TERMINAL_FACTORY_STATES.has(i.factoryState));
+    }
+}
+function nextFilter(filter) {
+    switch (filter) {
+        case "non-done": return "active";
+        case "active": return "all";
+        case "all": return "non-done";
+    }
+}
+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, report: null };
+        case "exit-detail":
+            return { ...state, view: "list", activeDetailKey: null, thread: null, report: null };
+        case "thread-snapshot":
+            return { ...state, thread: action.thread };
+        case "report-snapshot":
+            return { ...state, report: action.report };
+        case "codex-notification":
+            return applyCodexNotification(state, action.method, action.params);
+        case "cycle-filter":
+            return { ...state, filter: nextFilter(state.filter), selectedIndex: 0 };
+    }
+}
+// ─── 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) => {