bosun 0.41.1 → 0.41.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.41.1",
+  "version": "0.41.2",
   "description": "Bosun Autonomous Engineering — manages AI agent executors with failover, extremely powerful workflow builder, and a massive amount of included default workflow templates for autonomous engineering, creates PRs via Vibe-Kanban API, and sends Telegram notifications. Supports N executors with weighted distribution, multi-repo projects, and auto-setup.",
   "type": "module",
   "license": "Apache-2.0",

package/workflow/workflow-nodes/custom-loader.mjs

@@ -248,4 +248,3 @@ export function scaffoldCustomNodeFile(name, options = {}) {
   return { filePath, type, customDir, repoRoot };
 }
 
-

package/workflow/workflow-nodes.mjs

@@ -67,6 +67,131 @@ const WORKFLOW_AGENT_EVENT_PREVIEW_LIMIT = (() => {
 })();
 const BOSUN_ATTACHED_PR_LABEL = "bosun-attached";
 
+const HTML_TEXT_BREAK_TAGS = new Set([
+  "address",
+  "article",
+  "aside",
+  "blockquote",
+  "br",
+  "dd",
+  "div",
+  "dl",
+  "dt",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hr",
+  "li",
+  "main",
+  "nav",
+  "ol",
+  "p",
+  "pre",
+  "section",
+  "table",
+  "tbody",
+  "td",
+  "tfoot",
+  "th",
+  "thead",
+  "tr",
+  "ul",
+]);
+
+function decodeHtmlEntities(value = "") {
+  return String(value).replace(/&(?:nbsp|amp|lt|gt|quot|apos|#39|#\d+|#x[0-9a-f]+);/gi, (entity) => {
+    const normalized = entity.toLowerCase();
+    switch (normalized) {
+      case " ":
+        return " ";
+      case "&":
+        return "&";
+      case "<":
+        return "<";
+      case "&gt;":
+        return ">";
+      case "&quot;":
+        return '"';
+      case "&apos;":
+      case "&#39;":
+        return "'";
+      default:
+        if (normalized.startsWith("&#x")) {
+          return String.fromCodePoint(Number.parseInt(normalized.slice(3, -1), 16));
+        }
+        if (normalized.startsWith("&#")) {
+          return String.fromCodePoint(Number.parseInt(normalized.slice(2, -1), 10));
+        }
+        return entity;
+    }
+  });
+}
+
+function stripHtmlToText(html = "") {
+  const input = String(html ?? "");
+  let plain = "";
+  let index = 0;
+  let skippedTagName = null;
+
+  while (index < input.length) {
+    const tagStart = input.indexOf("<", index);
+    if (tagStart === -1) {
+      if (!skippedTagName) plain += input.slice(index);
+      break;
+    }
+
+    if (!skippedTagName && tagStart > index) {
+      plain += input.slice(index, tagStart);
+    }
+
+    const tagEnd = input.indexOf(">", tagStart + 1);
+    if (tagEnd === -1) {
+      if (!skippedTagName) plain += input.slice(tagStart).replace(/</g, " ");
+      break;
+    }
+
+    const rawTag = input.slice(tagStart + 1, tagEnd).trim();
+    const loweredTag = rawTag.toLowerCase();
+    const isClosingTag = loweredTag.startsWith("/");
+    const normalizedTag = isClosingTag ? loweredTag.slice(1).trimStart() : loweredTag;
+    const tagName = normalizedTag.match(/^[a-z0-9]+/i)?.[0] ?? "";
+
+    if (skippedTagName) {
+      if (isClosingTag && tagName === skippedTagName) {
+        skippedTagName = null;
+        plain += " ";
+      }
+      index = tagEnd + 1;
+      continue;
+    }
+
+    if (tagName === "script" || tagName === "style") {
+      if (!isClosingTag && !normalizedTag.endsWith("/")) {
+        skippedTagName = tagName;
+      }
+      index = tagEnd + 1;
+      continue;
+    }
+
+    if (HTML_TEXT_BREAK_TAGS.has(tagName)) {
+      plain += " ";
+    }
+
+    index = tagEnd + 1;
+  }
+
+  return decodeHtmlEntities(plain);
+}
+
+
 const PORT_TYPE_DESCRIPTIONS = Object.freeze({
   Any: "Wildcard payload",
   TaskDef: "Task definition/context payload",
@@ -9517,8 +9642,57 @@ function isValidGitWorktreePath(worktreePath) {
   }
 }
 
+function resolveGitDirForWorktree(worktreePath) {
+  if (!worktreePath || !existsSync(worktreePath)) return "";
+  try {
+    const topLevel = execGitArgsSync(["rev-parse", "--show-toplevel"], {
+      cwd: worktreePath,
+      encoding: "utf8",
+      timeout: 5000,
+      stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+    const normalize = (value) =>
+      resolve(String(value || ""))
+        .replace(/\\/g, "/")
+        .replace(/\/+$/, "")
+        .toLowerCase();
+    if (normalize(topLevel) !== normalize(worktreePath)) return "";
+    const gitDir = execGitArgsSync(["rev-parse", "--git-dir"], {
+      cwd: worktreePath,
+      encoding: "utf8",
+      timeout: 5000,
+      stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+    if (!gitDir) return "";
+    return resolve(worktreePath, gitDir);
+  } catch {
+    return "";
+  }
+}
+
+function hasUnresolvedGitOperation(worktreePath) {
+  if (!worktreePath || !existsSync(worktreePath)) return false;
+  try {
+    const gitDir = resolveGitDirForWorktree(worktreePath);
+    if (!gitDir || !existsSync(gitDir)) return true;
+    for (const marker of ["rebase-merge", "rebase-apply", "MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD"]) {
+      if (existsSync(resolve(gitDir, marker))) return true;
+    }
+    const unmerged = execGitArgsSync(["diff", "--name-only", "--diff-filter=U"], {
+      cwd: worktreePath,
+      encoding: "utf8",
+      timeout: 5000,
+      stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+    return Boolean(unmerged);
+  } catch {
+    return true;
+  }
+}
+
 function cleanupBrokenManagedWorktree(repoRoot, worktreePath) {
   if (!worktreePath) return;
+  const linkedGitDir = resolveGitDirForWorktree(worktreePath);
   try {
     execGitArgsSync(["worktree", "remove", String(worktreePath), "--force"], {
       cwd: repoRoot,
@@ -9534,6 +9708,13 @@ function cleanupBrokenManagedWorktree(repoRoot, worktreePath) {
   } catch {
     /* best-effort */
   }
+  try {
+    if (linkedGitDir && existsSync(linkedGitDir)) {
+      rmSync(linkedGitDir, { recursive: true, force: true });
+    }
+  } catch {
+    /* best-effort */
+  }
   try {
     execGitArgsSync(["worktree", "prune"], {
       cwd: repoRoot,
@@ -10551,6 +10732,9 @@ registerBuiltinNodeType("action.acquire_worktree", {
         if (!isValidGitWorktreePath(worktreePath)) {
           ctx.log(node.id, `Managed worktree is invalid, recreating: ${worktreePath}`);
           cleanupBrokenManagedWorktree(repoRoot, worktreePath);
+        } else if (hasUnresolvedGitOperation(worktreePath)) {
+          ctx.log(node.id, `Managed worktree has unresolved git state, recreating: ${worktreePath}`);
+          cleanupBrokenManagedWorktree(repoRoot, worktreePath);
         }
       }
 
@@ -10566,14 +10750,20 @@ registerBuiltinNodeType("action.acquire_worktree", {
           } catch {
             /* rebase failures are non-fatal for reuse */
           }
+          if (existsSync(worktreePath) && hasUnresolvedGitOperation(worktreePath)) {
+            ctx.log(node.id, `Managed worktree refresh left unresolved git state, recreating: ${worktreePath}`);
+            cleanupBrokenManagedWorktree(repoRoot, worktreePath);
+          }
+        }
+        if (existsSync(worktreePath)) {
+          ctx.data.worktreePath = worktreePath;
+          ctx.data._worktreeCreated = false;
+          ctx.data._worktreeManaged = true;
+          ctx.log(node.id, `Reusing worktree: ${worktreePath}`);
+          const cleared1 = clearBlockedWorktreeIdentity(worktreePath);
+          if (cleared1) ctx.log(node.id, `Cleared blocked test git identity from worktree: ${worktreePath}`);
+          return { success: true, worktreePath, created: false, reused: true, branch, baseBranch };
         }
-        ctx.data.worktreePath = worktreePath;
-        ctx.data._worktreeCreated = false;
-        ctx.data._worktreeManaged = true;
-        ctx.log(node.id, `Reusing worktree: ${worktreePath}`);
-        const cleared1 = clearBlockedWorktreeIdentity(worktreePath);
-        if (cleared1) ctx.log(node.id, `Cleared blocked test git identity from worktree: ${worktreePath}`);
-        return { success: true, worktreePath, created: false, reused: true, branch, baseBranch };
       }
 
       // Create fresh worktree