bosun 0.35.2 → 0.35.3

package/ui-server.mjs

@@ -355,6 +355,15 @@ async function getWorkflowEngineModule() {
         };
         _wfEngine.getWorkflowEngine({ services });
         _wfServicesReady = true;
+
+        // Resume any runs that were interrupted by a previous shutdown.
+        // This must happen AFTER services are wired so node executors work.
+        const engine = _wfEngine.getWorkflowEngine();
+        if (typeof engine.resumeInterruptedRuns === "function") {
+          engine.resumeInterruptedRuns().catch((err) => {
+            console.warn("[workflows] Failed to resume interrupted runs:", err.message);
+          });
+        }
       } catch (err) {
         console.warn("[workflows] services setup failed (engine still usable):", err.message);
       }
@@ -1361,6 +1370,28 @@ let uiInstanceLockHeld = false;
 const logStreamers = new Map();
 let uiDeps = {};
 
+/**
+ * Resolve the execPrimaryPrompt function. Prefers the injected dependency,
+ * falls back to importing directly from primary-agent.mjs so the chat
+ * agent works even when the UI server starts standalone.
+ */
+let _fallbackExecPrimaryPrompt = null;
+async function resolveExecPrimaryPrompt() {
+  if (typeof uiDeps.execPrimaryPrompt === "function") return uiDeps.execPrimaryPrompt;
+  if (_fallbackExecPrimaryPrompt) return _fallbackExecPrimaryPrompt;
+  try {
+    const mod = await import("./primary-agent.mjs");
+    if (typeof mod.execPrimaryPrompt === "function") {
+      _fallbackExecPrimaryPrompt = mod.execPrimaryPrompt;
+      console.log("[ui-server] loaded execPrimaryPrompt fallback from primary-agent.mjs");
+      return _fallbackExecPrimaryPrompt;
+    }
+  } catch (err) {
+    console.warn("[ui-server] failed to load execPrimaryPrompt fallback:", err.message);
+  }
+  return null;
+}
+
 /**
  * Resolve the bosun config directory. Falls back through:
  *   1. uiDeps.configDir (injected at server start)
@@ -6302,11 +6333,68 @@ async function handleApi(req, res, url) {
       const wfMod = await getWorkflowEngine();
       if (!wfMod) { jsonResponse(res, 503, { ok: false, error: "Workflow engine not available" }); return; }
       const engine = wfMod.getWorkflowEngine();
-      const runId = decodeURIComponent(path.replace("/api/workflows/runs/", "")).trim();
+      const subPath = path.replace("/api/workflows/runs/", "");
+      const segments = subPath.split("/").map(decodeURIComponent);
+      const runId = (segments[0] || "").trim();
+      const action = (segments[1] || "").trim();
+
       if (!runId) {
         jsonResponse(res, 400, { ok: false, error: "runId is required" });
         return;
       }
+
+      // ── POST /api/workflows/runs/:id/retry ──────────────────────────
+      // Manual retry endpoint. Accepts { mode: "from_failed" | "from_scratch" }.
+      // If mode is omitted, returns available retry options so the UI can
+      // present a choice to the user.
+      if (action === "retry" && req.method === "POST") {
+        const run = engine.getRunDetail ? engine.getRunDetail(runId) : null;
+        if (!run) {
+          jsonResponse(res, 404, { ok: false, error: "Workflow run not found" });
+          return;
+        }
+        if (run.status !== "failed") {
+          jsonResponse(res, 400, { ok: false, error: `Run status is "${run.status}" — only failed runs can be retried` });
+          return;
+        }
+        const body = await readJsonBody(req);
+        const mode = body?.mode;
+        if (!mode) {
+          // No mode specified — return available retry options so the UI can
+          // present a picker (from scratch vs from failed step).
+          const failedNodes = [];
+          const nodeStatuses = run.detail?.nodeStatuses || {};
+          for (const [nodeId, status] of Object.entries(nodeStatuses)) {
+            if (status === "failed") failedNodes.push(nodeId);
+          }
+          jsonResponse(res, 200, {
+            ok: true,
+            runId,
+            status: run.status,
+            options: [
+              { mode: "from_failed", label: "Retry from last failed step", failedNodes },
+              { mode: "from_scratch", label: "Retry from scratch" },
+            ],
+          });
+          return;
+        }
+        if (mode !== "from_failed" && mode !== "from_scratch") {
+          jsonResponse(res, 400, { ok: false, error: `Invalid mode "${mode}". Use "from_failed" or "from_scratch".` });
+          return;
+        }
+        const result = await engine.retryRun(runId, { mode });
+        const retryStatus = result.ctx?.errors?.length > 0 ? "failed" : "completed";
+        jsonResponse(res, 200, {
+          ok: true,
+          retryRunId: result.retryRunId,
+          originalRunId: result.originalRunId,
+          mode: result.mode,
+          status: retryStatus,
+        });
+        return;
+      }
+
+      // ── GET /api/workflows/runs/:id ─────────────────────────────────
       const run = engine.getRunDetail ? engine.getRunDetail(runId) : null;
       if (!run) {
         jsonResponse(res, 404, { ok: false, error: "Workflow run not found" });
@@ -7217,7 +7305,26 @@ async function handleApi(req, res, url) {
           jsonResponse(res, 404, { ok: false, error: "Session not found" });
           return;
         }
-        jsonResponse(res, 200, { ok: true, session });
+        // Support ?limit=N&offset=N for message pagination
+        const reqUrl = new URL(req.url, `http://${req.headers.host || "localhost"}`);
+        const limitParam = reqUrl.searchParams.get("limit");
+        const offsetParam = reqUrl.searchParams.get("offset");
+        if (limitParam) {
+          const limit = Math.max(1, Math.min(Number(limitParam) || 20, 500));
+          const allMessages = session.messages || [];
+          const total = allMessages.length;
+          const offset = offsetParam != null
+            ? Math.max(0, Math.min(Number(offsetParam) || 0, total))
+            : Math.max(0, total - limit);
+          const sliced = allMessages.slice(offset, offset + limit);
+          jsonResponse(res, 200, {
+            ok: true,
+            session: { ...session, messages: sliced },
+            pagination: { total, offset, limit, hasMore: offset > 0 },
+          });
+        } else {
+          jsonResponse(res, 200, { ok: true, session });
+        }
       } catch (err) {
         jsonResponse(res, 500, { ok: false, error: err.message });
       }
@@ -7306,12 +7413,35 @@ async function handleApi(req, res, url) {
         const messageModel = body?.model || undefined;
 
         // Forward to primary agent if applicable (exec records user + assistant events)
-        const exec = session.type === "primary" ? uiDeps.execPrimaryPrompt : null;
+        let exec = session.type === "primary" ? uiDeps.execPrimaryPrompt : null;
+        // Fallback: resolve execPrimaryPrompt from primary-agent.mjs if not injected
+        if (!exec && session.type === "primary") {
+          exec = await resolveExecPrimaryPrompt();
+        }
         if (exec) {
           // Don't record user event here — execPrimaryPrompt records it
           // Respond immediately so the UI doesn't block on agent execution
           jsonResponse(res, 200, { ok: true, messageId });
           broadcastUiEvent(["sessions"], "invalidate", { reason: "session-message", sessionId });
+
+          // Build an onEvent callback so intermediate SDK events (thinking,
+          // tool calls, code edits, etc.) are streamed to the UI in real-time
+          // via the existing session-tracker → WebSocket listener pipeline.
+          // Without this, chat/telegram dispatches only show the final
+          // user+assistant pair instead of the full thought stream that Flows
+          // clients see.
+          const streamOnEvent = (err, event) => {
+            // The adapters call onEvent(err, event) or onEvent(event).
+            // Normalise both calling conventions.
+            const ev = event || err;
+            if (!ev) return;
+            try {
+              tracker.recordEvent(sessionId, ev);
+            } catch {
+              /* best-effort — never crash the agent loop */
+            }
+          };
+
           // Fire-and-forget: run agent asynchronously so the request handler
           // doesn't block and the agent doesn't appear "busy" to subsequent
           // messages from chat, telegram, portal, or any other source.
@@ -7322,6 +7452,7 @@ async function handleApi(req, res, url) {
             model: messageModel,
             attachments,
             attachmentsAppended,
+            onEvent: streamOnEvent,
           }).then(() => {
             broadcastUiEvent(["sessions"], "invalidate", { reason: "agent-response", sessionId });
           }).catch((execErr) => {
@@ -7335,14 +7466,20 @@ async function handleApi(req, res, url) {
             broadcastUiEvent(["sessions"], "invalidate", { reason: "agent-error", sessionId });
           });
         } else {
-          // No agent — record user event and acknowledge
+          // No agent available — record user event and notify user
           tracker.recordEvent(sessionId, {
             role: "user",
             content: messageContent,
             attachments,
             timestamp: new Date().toISOString(),
           });
-          jsonResponse(res, 200, { ok: true, messageId });
+          tracker.recordEvent(sessionId, {
+            role: "system",
+            type: "error",
+            content: "⚠️ No agent is available to process this message. The primary agent may not be initialized — try restarting bosun or check the Logs tab for details.",
+            timestamp: new Date().toISOString(),
+          });
+          jsonResponse(res, 200, { ok: true, messageId, warning: "no_agent_available" });
           broadcastUiEvent(["sessions"], "invalidate", { reason: "session-message", sessionId });
         }
       } catch (err) {