bosun 0.35.0 → 0.35.2

package/ui-server.mjs

@@ -1796,6 +1796,7 @@ const SETTINGS_SENSITIVE_KEYS = new Set([
 
 const SETTINGS_KNOWN_SET = new Set(SETTINGS_KNOWN_KEYS);
 let _settingsLastUpdateTime = 0;
+const ASYNC_UI_COMMAND_BASES = new Set(["/plan"]);
 
 function hasSettingValue(value) {
   return value !== undefined && value !== null && value !== "";
@@ -2827,6 +2828,82 @@ function textResponse(res, statusCode, body, contentType = "text/plain") {
   res.end(body);
 }
 
+function normalizeTaskStatusKey(status) {
+  return String(status || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[\s_-]+/g, "");
+}
+
+function shouldRestartTaskAfterStatusUpdate(previousStatus, nextStatus) {
+  const prev = normalizeTaskStatusKey(previousStatus);
+  const next = normalizeTaskStatusKey(nextStatus);
+  return prev === "inreview" && next === "inprogress";
+}
+
+async function maybeRestartTaskOnReopen({
+  taskId,
+  previousStatus,
+  nextStatus,
+  updatedTask,
+  adapter,
+  executor,
+}) {
+  if (!taskId) {
+    return { attempted: false, started: false, reason: "missing_task_id" };
+  }
+  if (!shouldRestartTaskAfterStatusUpdate(previousStatus, nextStatus)) {
+    return { attempted: false, started: false, reason: "transition_not_eligible" };
+  }
+  if (!executor) {
+    return { attempted: true, started: false, reason: "executor_unavailable" };
+  }
+
+  const status = executor.getStatus?.() || {};
+  const activeSlots = Array.isArray(status?.slots) ? status.slots : [];
+  const alreadyRunning = activeSlots.some(
+    (slot) => String(slot?.taskId || "").trim() === String(taskId).trim(),
+  );
+  if (alreadyRunning) {
+    return { attempted: true, started: false, reason: "already_running" };
+  }
+
+  const maxParallel = Number(status?.maxParallel || 0);
+  const activeCount = Number(status?.activeSlots || activeSlots.length || 0);
+  const hasFreeSlot = maxParallel <= 0 || activeCount < maxParallel;
+  if (!hasFreeSlot) {
+    return { attempted: true, started: false, reason: "no_free_slots" };
+  }
+
+  let taskToRun = updatedTask && typeof updatedTask === "object" ? updatedTask : null;
+  if (!taskToRun?.id && typeof adapter?.getTask === "function") {
+    try {
+      taskToRun = await adapter.getTask(taskId);
+    } catch (err) {
+      return {
+        attempted: true,
+        started: false,
+        reason: "task_lookup_failed",
+        error: err?.message || String(err),
+      };
+    }
+  }
+  if (!taskToRun) {
+    return { attempted: true, started: false, reason: "task_not_found" };
+  }
+
+  executor.executeTask(taskToRun, {
+    force: true,
+    recoveredFromInProgress: true,
+  }).catch((error) => {
+    console.warn(
+      `[telegram-ui] failed to restart reopened task ${taskId}: ${error.message}`,
+    );
+  });
+
+  return { attempted: true, started: true, reason: "restarted" };
+}
+
 function parseInitData(initData) {
   const params = new URLSearchParams(initData);
   const data = {};
@@ -4609,6 +4686,9 @@ async function handleApi(req, res, url) {
         return;
       }
       const adapter = getKanbanAdapter();
+      const previousTask = typeof adapter.getTask === "function"
+        ? await adapter.getTask(taskId).catch(() => null)
+        : null;
       const tagsProvided = body && Object.prototype.hasOwnProperty.call(body, "tags");
       const tags = tagsProvided ? normalizeTagsInput(body?.tags) : undefined;
       const draftProvided = body && Object.prototype.hasOwnProperty.call(body, "draft");
@@ -4651,12 +4731,27 @@ async function handleApi(req, res, url) {
         typeof adapter.updateTask === "function"
           ? await adapter.updateTask(taskId, patch)
           : await adapter.updateTaskStatus(taskId, patch.status);
-      jsonResponse(res, 200, { ok: true, data: updated });
+      const executor = uiDeps.getInternalExecutor?.() || null;
+      const restart = await maybeRestartTaskOnReopen({
+        taskId,
+        previousStatus: previousTask?.status || null,
+        nextStatus: updated?.status || patch.status || null,
+        updatedTask: updated,
+        adapter,
+        executor,
+      });
+      jsonResponse(res, 200, { ok: true, data: updated, restart });
       broadcastUiEvent(["tasks", "overview"], "invalidate", {
         reason: "task-updated",
         taskId,
         status: updated?.status || patch.status || null,
       });
+      if (restart?.started) {
+        broadcastUiEvent(["tasks", "overview", "executor", "agents"], "invalidate", {
+          reason: "task-restarted",
+          taskId,
+        });
+      }
     } catch (err) {
       jsonResponse(res, 500, { ok: false, error: err.message });
     }
@@ -4672,6 +4767,9 @@ async function handleApi(req, res, url) {
         return;
       }
       const adapter = getKanbanAdapter();
+      const previousTask = typeof adapter.getTask === "function"
+        ? await adapter.getTask(taskId).catch(() => null)
+        : null;
       const tagsProvided = body && Object.prototype.hasOwnProperty.call(body, "tags");
       const tags = tagsProvided ? normalizeTagsInput(body?.tags) : undefined;
       const draftProvided = body && Object.prototype.hasOwnProperty.call(body, "draft");
@@ -4714,12 +4812,27 @@ async function handleApi(req, res, url) {
         typeof adapter.updateTask === "function"
           ? await adapter.updateTask(taskId, patch)
           : await adapter.updateTaskStatus(taskId, patch.status);
-      jsonResponse(res, 200, { ok: true, data: updated });
+      const executor = uiDeps.getInternalExecutor?.() || null;
+      const restart = await maybeRestartTaskOnReopen({
+        taskId,
+        previousStatus: previousTask?.status || null,
+        nextStatus: updated?.status || patch.status || null,
+        updatedTask: updated,
+        adapter,
+        executor,
+      });
+      jsonResponse(res, 200, { ok: true, data: updated, restart });
       broadcastUiEvent(["tasks", "overview"], "invalidate", {
         reason: "task-edited",
         taskId,
         status: updated?.status || patch.status || null,
       });
+      if (restart?.started) {
+        broadcastUiEvent(["tasks", "overview", "executor", "agents"], "invalidate", {
+          reason: "task-restarted",
+          taskId,
+        });
+      }
     } catch (err) {
       jsonResponse(res, 500, { ok: false, error: err.message });
     }
@@ -6620,8 +6733,44 @@ async function handleApi(req, res, url) {
       }
       const handler = uiDeps.handleUiCommand;
       if (typeof handler === "function") {
-        const result = await handler(command);
-        jsonResponse(res, 200, { ok: true, data: result || null, command });
+        if (ASYNC_UI_COMMAND_BASES.has(cmdBase)) {
+          setImmediate(() => {
+            let pending;
+            try {
+              pending = Promise.resolve(handler(command));
+            } catch (err) {
+              console.warn(`[ui] async command failed (${command}): ${err?.message || err}`);
+              broadcastUiEvent(["overview", "executor", "tasks"], "invalidate", {
+                reason: "command-failed",
+                command,
+              });
+              return;
+            }
+            pending
+              .then(() => {
+                broadcastUiEvent(["overview", "executor", "tasks"], "invalidate", {
+                  reason: "command-executed",
+                  command,
+                });
+              })
+              .catch((err) => {
+                console.warn(`[ui] async command failed (${command}): ${err?.message || err}`);
+                broadcastUiEvent(["overview", "executor", "tasks"], "invalidate", {
+                  reason: "command-failed",
+                  command,
+                });
+              });
+          });
+          jsonResponse(res, 202, {
+            ok: true,
+            queued: true,
+            command,
+            message: "Command accepted and running in background.",
+          });
+        } else {
+          const result = await handler(command);
+          jsonResponse(res, 200, { ok: true, data: result || null, command });
+        }
       } else {
         // No command handler wired — acknowledge and broadcast refresh
         jsonResponse(res, 200, {
@@ -6632,7 +6781,7 @@ async function handleApi(req, res, url) {
         });
       }
       broadcastUiEvent(["overview", "executor", "tasks"], "invalidate", {
-        reason: "command-executed",
+        reason: ASYNC_UI_COMMAND_BASES.has(cmdBase) ? "command-queued" : "command-executed",
         command,
       });
     } catch (err) {
@@ -7326,7 +7475,8 @@ async function handleStatic(req, res, url) {
     return;
   }
 
-  const pathname = url.pathname === "/" ? "/index.html" : url.pathname;
+  const rawPathname = String(url.pathname || "/").trim() || "/";
+  const pathname = rawPathname === "/" ? "/index.html" : rawPathname;
   const filePath = resolve(uiRoot, `.${pathname}`);
 
   if (!filePath.startsWith(uiRoot)) {
@@ -7335,6 +7485,28 @@ async function handleStatic(req, res, url) {
   }
 
   if (!existsSync(filePath)) {
+    // SPA fallback: deep links like /tasks/123 must load index.html so the
+    // client router can resolve the route after refresh.
+    const looksLikeFile = /\.[a-z0-9]+$/i.test(pathname);
+    const hasTemplateBraces = pathname.includes("{{") || pathname.includes("}}");
+    if (!looksLikeFile || hasTemplateBraces) {
+      const indexPath = resolve(uiRoot, "index.html");
+      if (existsSync(indexPath)) {
+        try {
+          const data = await readFile(indexPath);
+          res.writeHead(200, {
+            "Content-Type": "text/html; charset=utf-8",
+            "Access-Control-Allow-Origin": "*",
+            "Cache-Control": "no-store",
+          });
+          res.end(data);
+          return;
+        } catch (err) {
+          textResponse(res, 500, `Failed to load /index.html: ${err.message}`);
+          return;
+        }
+      }
+    }
     textResponse(res, 404, "Not Found");
     return;
   }