patchrelay 0.20.0 → 0.20.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.20.0",
-  "commit": "e3ce50c81db1",
-  "builtAt": "2026-03-25T20:18:22.070Z"
+  "version": "0.20.1",
+  "commit": "d3e7ac8f36d2",
+  "builtAt": "2026-03-25T21:27:48.361Z"
 }

package/dist/cli/watch/App.js

@@ -12,12 +12,18 @@ async function postPrompt(baseUrl, issueKey, text, bearerToken) {
     const headers = { "content-type": "application/json" };
     if (bearerToken)
         headers.authorization = `Bearer ${bearerToken}`;
-    await fetch(new URL(`/api/issues/${encodeURIComponent(issueKey)}/prompt`, baseUrl), {
-        method: "POST",
-        headers,
-        body: JSON.stringify({ text }),
-        signal: AbortSignal.timeout(5000),
-    }).catch(() => { });
+    try {
+        const response = await fetch(new URL(`/api/issues/${encodeURIComponent(issueKey)}/prompt`, baseUrl), {
+            method: "POST",
+            headers,
+            body: JSON.stringify({ text }),
+            signal: AbortSignal.timeout(5000),
+        });
+        return await response.json();
+    }
+    catch {
+        return { reason: "Request failed" };
+    }
 }
 async function postRetry(baseUrl, issueKey, bearerToken) {
     const headers = { "content-type": "application/json" };
@@ -46,12 +52,35 @@ export function App({ baseUrl, bearerToken, initialIssueKey }) {
             void postRetry(baseUrl, state.activeDetailKey, bearerToken);
         }
     }, [baseUrl, bearerToken, state.activeDetailKey]);
+    const [promptStatus, setPromptStatus] = useState(null);
     const handlePromptSubmit = useCallback(() => {
-        if (state.activeDetailKey && promptBuffer.trim()) {
-            void postPrompt(baseUrl, state.activeDetailKey, promptBuffer.trim(), bearerToken);
+        const text = promptBuffer.trim();
+        if (!state.activeDetailKey || !text) {
+            setPromptMode(false);
+            setPromptBuffer("");
+            return;
         }
+        // Add synthetic userMessage to timeline immediately
+        dispatch({
+            type: "codex-notification",
+            method: "item/started",
+            params: { item: { id: `prompt-${Date.now()}`, type: "userMessage", status: "completed", text } },
+        });
         setPromptMode(false);
         setPromptBuffer("");
+        setPromptStatus("sending...");
+        void postPrompt(baseUrl, state.activeDetailKey, text, bearerToken).then((result) => {
+            if (result.delivered) {
+                setPromptStatus("delivered");
+            }
+            else if (result.queued) {
+                setPromptStatus("queued for next run");
+            }
+            else if (result.reason) {
+                setPromptStatus(`failed: ${result.reason}`);
+            }
+            setTimeout(() => setPromptStatus(null), 3000);
+        });
     }, [baseUrl, bearerToken, state.activeDetailKey, promptBuffer]);
     useInput((input, key) => {
         if (promptMode) {
@@ -120,5 +149,5 @@ export function App({ baseUrl, bearerToken, initialIssueKey }) {
             }
         }
     });
-    return (_jsx(Box, { flexDirection: "column", children: state.view === "list" ? (_jsx(IssueListView, { issues: filtered, allIssues: state.issues, selectedIndex: state.selectedIndex, connected: state.connected, filter: state.filter, totalCount: state.issues.length })) : state.view === "detail" ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(IssueDetailView, { issue: state.issues.find((i) => i.issueKey === state.activeDetailKey), timeline: state.timeline, follow: state.follow, activeRunStartedAt: state.activeRunStartedAt, tokenUsage: state.tokenUsage, diffSummary: state.diffSummary, plan: state.plan, issueContext: state.issueContext, allIssues: filtered, activeDetailKey: state.activeDetailKey }), promptMode && (_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: "prompt> " }), _jsx(Text, { children: promptBuffer }), _jsx(Text, { dimColor: true, children: "_" })] }))] })) : (_jsx(FeedView, { events: state.feedEvents, connected: state.connected })) }));
+    return (_jsx(Box, { flexDirection: "column", children: state.view === "list" ? (_jsx(IssueListView, { issues: filtered, allIssues: state.issues, selectedIndex: state.selectedIndex, connected: state.connected, filter: state.filter, totalCount: state.issues.length })) : state.view === "detail" ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(IssueDetailView, { issue: state.issues.find((i) => i.issueKey === state.activeDetailKey), timeline: state.timeline, follow: state.follow, activeRunStartedAt: state.activeRunStartedAt, tokenUsage: state.tokenUsage, diffSummary: state.diffSummary, plan: state.plan, issueContext: state.issueContext, allIssues: filtered, activeDetailKey: state.activeDetailKey }), promptMode && (_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: "prompt> " }), _jsx(Text, { children: promptBuffer }), _jsx(Text, { dimColor: true, children: "_" })] })), promptStatus && !promptMode && (_jsx(Text, { dimColor: true, children: promptStatus }))] })) : (_jsx(FeedView, { events: state.feedEvents, connected: state.connected })) }));
 }

package/dist/cli/watch/ItemLine.js

@@ -64,6 +64,9 @@ export function ItemLine({ item, isLast }) {
         case "plan":
             content = renderPlan(item);
             break;
+        case "userMessage":
+            content = (_jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "you: " }), _jsx(Text, { children: truncate(item.text ?? "", 120) })] }));
+            break;
         default:
             content = renderDefault(item);
             break;

package/dist/cli/watch/format-utils.js

@@ -0,0 +1,43 @@
+/** Format ISO timestamp as HH:MM:SS (24h, en-GB). */
+export function formatTime(iso) {
+    return new Date(iso).toLocaleTimeString("en-GB", { hour12: false });
+}
+/** Format ISO timestamp as compact relative time: "3s", "12m", "2h", "5d". */
+export function relativeTime(iso) {
+    const ms = Date.now() - new Date(iso).getTime();
+    if (ms < 0)
+        return "now";
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    const days = Math.floor(hours / 24);
+    return `${days}d`;
+}
+/** Format millisecond duration as "2m 30s" or "45s". */
+export function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    return `${minutes}m ${remainingSeconds}s`;
+}
+/** Format token count with k/M suffix. */
+export function formatTokens(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(1)}k`;
+    return String(n);
+}
+/** Truncate text to max length with ellipsis. Collapses newlines. */
+export function truncate(text, max) {
+    const line = text.replace(/\n/g, " ").trim();
+    return line.length > max ? `${line.slice(0, max - 1)}\u2026` : line;
+}

package/dist/cli/watch/sse-parser.js

@@ -0,0 +1,43 @@
+/**
+ * Shared SSE (Server-Sent Events) stream parser.
+ * Extracts event type + data from a ReadableStream, calls onEvent for each complete event.
+ */
+export async function readSSEStream(body, onEvent) {
+    const reader = 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) {
+                    onEvent(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");
+        }
+    }
+}

package/dist/cli/watch/theme.js

@@ -0,0 +1,55 @@
+// ─── Factory State Colors ─────────────────────────────────────────
+export const FACTORY_STATE_COLORS = {
+    delegated: "blue",
+    preparing: "blue",
+    implementing: "yellow",
+    awaiting_input: "yellow",
+    pr_open: "cyan",
+    changes_requested: "magenta",
+    repairing_ci: "magenta",
+    repairing_queue: "magenta",
+    awaiting_queue: "green",
+    done: "green",
+    failed: "red",
+    escalated: "red",
+};
+// ─── Item Status Symbols & Colors ─────────────────────────────────
+export const ITEM_STATUS_SYMBOLS = {
+    completed: "\u2713",
+    failed: "\u2717",
+    declined: "\u2717",
+    inProgress: "\u25cf",
+};
+export const ITEM_STATUS_COLORS = {
+    completed: "green",
+    failed: "red",
+    declined: "red",
+    inProgress: "yellow",
+};
+// ─── CI Check Symbols & Colors ────────────────────────────────────
+export const CHECK_SYMBOLS = {
+    passed: "\u2713",
+    failed: "\u2717",
+    pending: "\u25cf",
+};
+export const CHECK_COLORS = {
+    passed: "green",
+    failed: "red",
+    pending: "yellow",
+};
+// ─── Feed Event Colors ────────────────────────────────────────────
+export const FEED_LEVEL_COLORS = {
+    info: "white",
+    warn: "yellow",
+    error: "red",
+};
+export const FEED_KIND_COLORS = {
+    stage: "cyan",
+    turn: "yellow",
+    github: "green",
+    webhook: "blue",
+    agent: "magenta",
+    service: "white",
+    workflow: "cyan",
+    linear: "blue",
+};

package/dist/cli/watch/timeline-builder.js

@@ -303,7 +303,7 @@ export function appendCodexItemToTimeline(timeline, params, activeRunId) {
     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")
+    if ((type === "agentMessage" || type === "userMessage") && typeof itemObj.text === "string")
         item.text = itemObj.text;
     if (type === "commandExecution") {
         const cmd = itemObj.command;

package/dist/http.js

@@ -323,7 +323,7 @@ export async function buildHttpServer(config, service, logger) {
             if ("error" in result) {
                 return reply.code(409).send({ ok: false, reason: result.error });
             }
-            return reply.send({ ok: true, delivered: true });
+            return reply.send({ ok: true, ...result });
         });
         app.get("/api/feed", async (request, reply) => {
             const feedQuery = {

package/dist/service.js

@@ -218,22 +218,58 @@ export class PatchRelayService {
         this.codex.on("notification", handler);
         return () => { this.codex.off("notification", handler); };
     }
-    async promptIssue(issueKey, text) {
+    async promptIssue(issueKey, text, source = "watch") {
         const issue = this.db.getIssueByKey(issueKey);
         if (!issue)
             return undefined;
-        if (!issue.activeRunId)
-            return { error: "No active run" };
+        // Publish to operator feed so all clients see the prompt
+        this.feed.publish({
+            level: "info",
+            kind: "comment",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: issue.factoryState,
+            status: "operator_prompt",
+            summary: `Operator prompt (${source})`,
+            detail: text.slice(0, 200),
+        });
+        // If no active run, queue as pending context for the next run
+        if (!issue.activeRunId) {
+            const existing = issue.pendingRunContextJson
+                ? JSON.parse(issue.pendingRunContextJson)
+                : {};
+            this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                pendingRunContextJson: JSON.stringify({ ...existing, operatorPrompt: text }),
+            });
+            return { delivered: false, queued: true };
+        }
         const run = this.db.getRun(issue.activeRunId);
-        if (!run?.threadId || !run.turnId)
-            return { error: "No active thread or turn" };
+        if (!run?.threadId || !run.turnId) {
+            return { error: "Active run has no thread or turn yet" };
+        }
         try {
-            await this.codex.steerTurn({ threadId: run.threadId, turnId: run.turnId, input: `Operator prompt from watch TUI:\n\n${text}` });
+            await this.codex.steerTurn({
+                threadId: run.threadId,
+                turnId: run.turnId,
+                input: `Operator prompt (${source}):\n\n${text}`,
+            });
             return { delivered: true };
         }
         catch (error) {
+            // Turn may have completed between check and steer — queue for next run
             const msg = error instanceof Error ? error.message : String(error);
-            return { error: `Failed to deliver prompt: ${msg}` };
+            this.logger.warn({ issueKey, error: msg }, "steerTurn failed, queuing prompt for next run");
+            const existing = issue.pendingRunContextJson
+                ? JSON.parse(issue.pendingRunContextJson)
+                : {};
+            this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                pendingRunContextJson: JSON.stringify({ ...existing, operatorPrompt: text }),
+            });
+            return { delivered: false, queued: true };
         }
     }
     retryIssue(issueKey) {

package/package.json

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