bosun 0.42.2 → 0.42.4

package/task/task-store.mjs

@@ -328,6 +328,140 @@ export function normalizeWorkspaceStorageKey(rawKey) {
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function isLikelyUrl(value) {
+  return /^[a-z][a-z0-9+.-]*:\/\//i.test(String(value || "").trim());
+}
+
+const PORTABLE_TASK_PATH_KEYS = Object.freeze([
+  "archivePath",
+  "archiveDir",
+  "artifactPath",
+  "artifactsDir",
+  "attachmentPath",
+  "attachmentsDir",
+  "exportPath",
+  "exportDir",
+  "importPath",
+  "importDir",
+]);
+
+export function normalizePortableTaskPath(rawPath) {
+  if (rawPath == null) return "";
+  const value = String(rawPath).trim();
+  if (!value || isLikelyUrl(value)) return value;
+  return normalizeWorkspaceStorageKey(value).toLowerCase();
+}
+
+function normalizePortablePathValue(rawPath) {
+  return normalizePortableTaskPath(rawPath);
+}
+
+function normalizePortablePathList(rawPaths) {
+  const values = Array.isArray(rawPaths) ? rawPaths : [rawPaths];
+  const normalized = [];
+  const seen = new Set();
+  for (const entry of values) {
+    const canonical = normalizePortablePathValue(entry);
+    if (!canonical || seen.has(canonical)) continue;
+    seen.add(canonical);
+    normalized.push(canonical);
+  }
+  return normalized;
+}
+
+export function getTaskAttachmentCanonicalKey(attachment = {}) {
+  if (!attachment || typeof attachment !== "object") return "";
+  const url = String(attachment.url || attachment.uri || "").trim();
+  if (url) return `url:${url}`;
+  const location = normalizePortablePathValue(
+    attachment.filePath || attachment.path || attachment.localPath || "",
+  );
+  if (location) return `path:${location}`;
+  if (attachment.id) return `id:${attachment.id}`;
+  return `raw:${JSON.stringify(attachment)}`;
+}
+
+export function normalizeTaskAttachmentRecord(rawAttachment) {
+  if (!rawAttachment || typeof rawAttachment !== "object") return null;
+  const normalized = { ...rawAttachment };
+  const canonicalLocation = normalizePortablePathValue(
+    normalized.filePath || normalized.path || normalized.localPath || "",
+  );
+  if (canonicalLocation) {
+    normalized.filePath = canonicalLocation;
+    if (Object.prototype.hasOwnProperty.call(normalized, "path")) {
+      normalized.path = canonicalLocation;
+    }
+    if (Object.prototype.hasOwnProperty.call(normalized, "localPath")) {
+      normalized.localPath = canonicalLocation;
+    }
+  }
+  return normalized;
+}
+
+export function normalizeTaskAttachments(rawAttachments, options = {}) {
+  const values = Array.isArray(rawAttachments) ? rawAttachments : [];
+  const normalized = [];
+  const seen = new Set();
+  for (const value of values) {
+    const attachment = normalizeTaskAttachmentRecord(value);
+    if (!attachment) continue;
+    const key = getTaskAttachmentCanonicalKey(attachment);
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    normalized.push(attachment);
+  }
+  if (options.limit && normalized.length > options.limit) {
+    return normalized.slice(0, options.limit);
+  }
+  return normalized;
+}
+
+function normalizeTaskPathPayload(rawPayload = {}, taskId = "", options = {}) {
+  if (!isPlainObject(rawPayload)) return {};
+  const normalized = { ...rawPayload };
+  for (const key of PORTABLE_TASK_PATH_KEYS) {
+    if (typeof normalized[key] === "string") {
+      normalized[key] = normalizePortablePathValue(normalized[key]);
+    }
+  }
+  if (options.includeWorkspace === true && typeof normalized.workspace === "string") {
+    normalized.workspace = normalizeWorkspaceStorageKey(normalized.workspace) || null;
+  }
+  if (options.includeRepository === true && typeof normalized.repository === "string") {
+    normalized.repository = normalizeWorkspaceStorageKey(normalized.repository) || null;
+  }
+  if (options.includeRepositories === true && normalized.repositories != null) {
+    normalized.repositories = normalizeWorkspaceStorageKeys(normalized.repositories, {
+      kind: `task:${taskId || "<unknown-task>"}:repositories`,
+    });
+  }
+  if (normalized.attachments != null) {
+    normalized.attachments = normalizeTaskAttachments(normalized.attachments, {
+      kind: `task:${taskId || "<unknown-task>"}:${options.attachmentKind || "attachments"}`,
+    });
+  }
+  if (normalized.filePaths != null) {
+    normalized.filePaths = normalizePortablePathList(normalized.filePaths);
+  }
+  if (normalized.paths != null) {
+    normalized.paths = normalizePortablePathList(normalized.paths);
+  }
+  return normalized;
+}
+
+function normalizeTaskMeta(rawMeta = {}, taskId = "") {
+  return normalizeTaskPathPayload(rawMeta, taskId, {
+    includeWorkspace: true,
+    includeRepository: true,
+    attachmentKind: "meta.attachments",
+  });
+}
+
 export function normalizeWorkspaceStorageKeys(rawKeys, options = {}) {
   const kind = String(options.kind || "workspace-rooted storage").trim();
   const values = Array.isArray(rawKeys) ? rawKeys : [rawKeys];
@@ -588,68 +722,79 @@ function validateTaskTransition(currentStatus, nextStatus, options = {}) {
 function normalizeTaskStructure(rawTask = {}) {
   const base = defaultTask(rawTask);
   const taskId = String(base?.id || rawTask?.id || "").trim() || "<unknown-task>";
-  const workspaceKey = normalizeWorkspaceStorageKey(base.workspace);
-  const repositoryKey = normalizeWorkspaceStorageKey(base.repository);
-  const repositoryKeys = normalizeWorkspaceStorageKeys(base.repositories || [], {
+  const normalizedBase = normalizeTaskPathPayload(base, taskId, {
+    attachmentKind: "attachments",
+  });
+  const workspaceKey = normalizeWorkspaceStorageKey(normalizedBase.workspace);
+  const repositoryKey = normalizeWorkspaceStorageKey(normalizedBase.repository);
+  const repositoryKeys = normalizeWorkspaceStorageKeys(normalizedBase.repositories || [], {
     kind: `task:${taskId}:repositories`,
   });
   const scopedRepositoryKeys = normalizeWorkspaceStorageKeys(
     [repositoryKey, ...repositoryKeys],
     { kind: `task:${taskId}:workspace-rooted` },
   );
+  const attachments = normalizeTaskAttachments(normalizedBase.attachments, {
+    kind: `task:${taskId}:attachments`,
+  });
+  const normalizedMeta = normalizeTaskMeta(normalizedBase.meta, taskId);
   const normalized = {
-    ...base,
-    status: normalizeTaskStatus(base.status),
-    type: normalizeTaskType(base.type),
-    epicId: base.epicId ? String(base.epicId) : null,
-    parentTaskId: base.parentTaskId ? String(base.parentTaskId) : null,
-    childTaskIds: uniqueStringList(base.childTaskIds || []),
-    dependencyTaskIds: uniqueStringList(base.dependencyTaskIds || []),
-    blockedByTaskIds: uniqueStringList(base.blockedByTaskIds || []),
-    dependsOn: uniqueStringList(base.dependsOn || base.dependencyTaskIds || []),
-    assignees: uniqueStringList(base.assignees || []),
-    watchers: uniqueStringList(base.watchers || []),
+    ...normalizedBase,
+    status: normalizeTaskStatus(normalizedBase.status),
+    type: normalizeTaskType(normalizedBase.type),
+    epicId: normalizedBase.epicId ? String(normalizedBase.epicId) : null,
+    parentTaskId: normalizedBase.parentTaskId ? String(normalizedBase.parentTaskId) : null,
+    childTaskIds: uniqueStringList(normalizedBase.childTaskIds || []),
+    dependencyTaskIds: uniqueStringList(normalizedBase.dependencyTaskIds || []),
+    blockedByTaskIds: uniqueStringList(normalizedBase.blockedByTaskIds || []),
+    dependsOn: uniqueStringList(
+      normalizedBase.dependsOn || normalizedBase.dependencyTaskIds || [],
+    ),
+    assignees: uniqueStringList(normalizedBase.assignees || []),
+    watchers: uniqueStringList(normalizedBase.watchers || []),
     links: {
-      branches: uniqueStringList(base.links?.branches || []),
-      prs: uniqueStringList(base.links?.prs || []),
-      workflows: uniqueStringList(base.links?.workflows || []),
+      branches: uniqueStringList(normalizedBase.links?.branches || []),
+      prs: uniqueStringList(normalizedBase.links?.prs || []),
+      workflows: uniqueStringList(normalizedBase.links?.workflows || []),
     },
     comments: normalizeTaskComments(
-      Array.isArray(base.comments) && base.comments.length
-        ? base.comments
-        : Array.isArray(base.meta?.comments)
-          ? base.meta.comments
+      Array.isArray(normalizedBase.comments) && normalizedBase.comments.length
+        ? normalizedBase.comments
+        : Array.isArray(normalizedBase.meta?.comments)
+          ? normalizedBase.meta.comments
           : [],
     ),
     timeline: normalizeTimelineEvents(
-      Array.isArray(base.timeline)
-        ? base.timeline
-        : Array.isArray(base.meta?.timeline)
-          ? base.meta.timeline
+      Array.isArray(normalizedBase.timeline)
+        ? normalizedBase.timeline
+        : Array.isArray(normalizedBase.meta?.timeline)
+          ? normalizedBase.meta.timeline
           : [],
     ),
     workflowRuns: normalizeWorkflowRunLinks(
-      Array.isArray(base.workflowRuns)
-        ? base.workflowRuns
-        : Array.isArray(base.meta?.workflowRuns)
-          ? base.meta.workflowRuns
+      Array.isArray(normalizedBase.workflowRuns)
+        ? normalizedBase.workflowRuns
+        : Array.isArray(normalizedBase.meta?.workflowRuns)
+          ? normalizedBase.meta.workflowRuns
           : [],
     ),
     runs: normalizeTaskRuns(
-      Array.isArray(base.runs)
-        ? base.runs
-        : Array.isArray(base.meta?.runs)
-          ? base.meta.runs
+      Array.isArray(normalizedBase.runs)
+        ? normalizedBase.runs
+        : Array.isArray(normalizedBase.meta?.runs)
+          ? normalizedBase.meta.runs
           : [],
     ),
-    stateVersion: Number.isFinite(Number(base.stateVersion))
-      ? Number(base.stateVersion)
+    stateVersion: Number.isFinite(Number(normalizedBase.stateVersion))
+      ? Number(normalizedBase.stateVersion)
       : 2,
-    sprintId: normalizeSprintId(base.sprintId),
-    sprintOrder: normalizeSprintOrder(base.sprintOrder),
+    sprintId: normalizeSprintId(normalizedBase.sprintId),
+    sprintOrder: normalizeSprintOrder(normalizedBase.sprintOrder),
     workspace: workspaceKey || null,
     repository: repositoryKey || null,
     repositories: scopedRepositoryKeys,
+    attachments,
+    meta: normalizedMeta,
   };
   if (normalized.status === "draft") {
     normalized.draft = true;
@@ -657,6 +802,10 @@ function normalizeTaskStructure(rawTask = {}) {
   return normalized;
 }
 
+export function normalizeTaskStorageRecord(rawTask = {}) {
+  return normalizeTaskStructure(rawTask);
+}
+
 function pushTaskTimeline(task, event = {}) {
   task.timeline = normalizeTimelineEvents([...(Array.isArray(task.timeline) ? task.timeline : []), event]);
 }
@@ -1367,6 +1516,7 @@ export function updateTask(taskId, updates) {
     repositories: (next) => { task.repositories = next; },
     baseBranch: (next) => { task.baseBranch = next; },
     branchName: (next) => { task.branchName = next; },
+    prLinkage: (next) => { task.prLinkage = next; },
     prNumber: (next) => { task.prNumber = next; },
     prUrl: (next) => { task.prUrl = next; },
     epicId: (next) => { task.epicId = next; },
@@ -1404,6 +1554,12 @@ export function updateTask(taskId, updates) {
       task.tags = normalizeTags(value);
       continue;
     }
+    if (key === "attachments") {
+      task.attachments = normalizeTaskAttachments(value, {
+        kind: `task:${taskId}:attachments`,
+      });
+      continue;
+    }
     if (key === "status") {
       task.status = normalizeTaskStatus(value);
       continue;
@@ -3034,3 +3190,4 @@ export function getStaleInReviewTasks(maxAgeMs) {
     (t) => t.status === "inreview" && t.lastActivityAt < cutoff,
   );
 }
+

package/telegram/telegram-bot.mjs

@@ -1264,6 +1264,7 @@ let _getErrorDetector = null;
 let _getPrCleanupDaemon = null;
 let _getWorkspaceMonitor = null;
 let _getMonitorMonitorStatus = null;
+let _getTuiMonitorStats = null;
 let _getTaskStoreStats = null;
 let _getTasksPendingReview = null;
 let _triggerTaskPlanner = null;
@@ -1300,6 +1301,7 @@ export function injectMonitorFunctions({
   getPrCleanupDaemon,
   getWorkspaceMonitor,
   getMonitorMonitorStatus,
+  getTuiMonitorStats,
   getTaskStoreStats,
   getTasksPendingReview,
   triggerTaskPlanner,
@@ -1332,6 +1334,7 @@ export function injectMonitorFunctions({
   _getPrCleanupDaemon = getPrCleanupDaemon || null;
   _getWorkspaceMonitor = getWorkspaceMonitor || null;
   _getMonitorMonitorStatus = getMonitorMonitorStatus || null;
+  _getTuiMonitorStats = getTuiMonitorStats || null;
   _getTaskStoreStats = getTaskStoreStats || null;
   _getTasksPendingReview = getTasksPendingReview || null;
   _triggerTaskPlanner = triggerTaskPlanner || null;
@@ -11633,6 +11636,7 @@ export async function startTelegramBot(options = {}) {
         dependencies: {
           execPrimaryPrompt,
           getInternalExecutor: _getInternalExecutor,
+          getTuiMonitorStats: _getTuiMonitorStats,
           getExecutorMode: _getExecutorMode,
           getAgentEventBus: _getAgentEventBus,
           handleUiCommand: handleUiCommand,
@@ -12080,4 +12084,3 @@ export function stopStatusFileWriter() {
     _statusWriterTimer = null;
   }
 }
-