@swarmclawai/swarmclaw 0.8.4 → 0.8.7

package/src/lib/server/task-followups.ts

@@ -0,0 +1,391 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import type { BoardTask, Connector } from '@/types'
+import { normalizeWhatsappTarget } from './connectors/response-media'
+import { WORKSPACE_DIR } from './data-dir'
+import { loadConnectors, loadSessions, UPLOAD_DIR } from './storage'
+import { errorMessage } from '@/lib/shared-utils'
+
+export { normalizeWhatsappTarget }
+
+export interface SessionMessageLike {
+  role?: string
+  text?: string
+  time?: number
+  kind?: string
+  historyExcluded?: boolean
+  source?: {
+    connectorId?: string
+    channelId?: string
+    threadId?: string
+  }
+  toolEvents?: Array<{ name?: string; output?: string }>
+  streaming?: boolean
+  imageUrl?: string
+}
+
+export interface SessionLike {
+  id?: string
+  name?: string
+  user?: string
+  cwd?: string
+  agentId?: string | null
+  messages?: SessionMessageLike[]
+  connectorContext?: {
+    connectorId?: string | null
+    channelId?: string | null
+    threadId?: string | null
+    senderId?: string | null
+    senderName?: string | null
+  }
+  lastActiveAt?: number
+  heartbeatEnabled?: boolean | null
+  active?: boolean
+  currentRunId?: string | null
+}
+
+export interface ScheduleTaskMeta extends BoardTask {
+  user?: string | null
+  createdInSessionId?: string | null
+}
+
+export interface RunningConnectorLike {
+  id: string
+  platform: string
+  agentId: string | null
+  supportsSend: boolean
+  configuredTargets: string[]
+  recentChannelId: string | null
+}
+
+export interface ConnectorTaskFollowupTarget {
+  connectorId: string
+  channelId: string
+  threadId?: string | null
+}
+
+function isEnabledFlag(value: unknown): boolean {
+  if (typeof value === 'boolean') return value
+  if (typeof value !== 'string') return false
+  const normalized = value.trim().toLowerCase()
+  return normalized === '1'
+    || normalized === 'true'
+    || normalized === 'yes'
+    || normalized === 'on'
+    || normalized === 'enabled'
+}
+
+export function fillTaskFollowupTemplate(template: string, data: {
+  status: string
+  title: string
+  summary: string
+  taskId: string
+}): string {
+  return template
+    .replaceAll('{status}', data.status)
+    .replaceAll('{title}', data.title)
+    .replaceAll('{summary}', data.summary)
+    .replaceAll('{taskId}', data.taskId)
+}
+
+export function maybeResolveUploadMediaPathFromUrl(url: string | undefined): string | undefined {
+  if (!url || !url.startsWith('/api/uploads/')) return undefined
+  const rawName = url.slice('/api/uploads/'.length).split(/[?#]/)[0] || ''
+  let decoded: string
+  try { decoded = decodeURIComponent(rawName) } catch { decoded = rawName }
+  const safeName = decoded.replace(/[^a-zA-Z0-9._-]/g, '')
+  if (!safeName) return undefined
+  const fullPath = path.join(UPLOAD_DIR, safeName)
+  return fs.existsSync(fullPath) ? fullPath : undefined
+}
+
+const OUTPUT_FILE_BACKTICK_RE = /`([^`\n]+\.(?:txt|md|json|csv|pdf|png|jpe?g|webp|gif|svg|mp4|webm|mov|zip|tar|gz|log|yml|yaml|xml|html|css|js|ts|tsx|jsx|py|go|rs|java|swift|kt|sql))`/gi
+const OUTPUT_FILE_PATH_RE = /\b((?:\.{1,2}\/|~\/|\/)?[\w./-]+\.(?:txt|md|json|csv|pdf|png|jpe?g|webp|gif|svg|mp4|webm|mov|zip|tar|gz|log|yml|yaml|xml|html|css|js|ts|tsx|jsx|py|go|rs|java|swift|kt|sql))\b/gi
+const MAX_CONNECTOR_ATTACHMENT_BYTES = 25 * 1024 * 1024
+
+export function extractLikelyOutputFiles(text: string): string[] {
+  const out: string[] = []
+  const seen = new Set<string>()
+  const push = (raw: string) => {
+    const value = raw.trim().replace(/^['"]|['"]$/g, '')
+    if (!value || /^https?:\/\//i.test(value)) return
+    if (value.startsWith('/api/uploads/')) return
+    const key = value.toLowerCase()
+    if (seen.has(key)) return
+    seen.add(key)
+    out.push(value)
+  }
+
+  for (const match of text.matchAll(OUTPUT_FILE_BACKTICK_RE)) {
+    push(match[1] || '')
+    if (out.length >= 8) return out
+  }
+  for (const match of text.matchAll(OUTPUT_FILE_PATH_RE)) {
+    push(match[1] || '')
+    if (out.length >= 8) return out
+  }
+
+  return out
+}
+
+export function resolveExistingOutputFilePath(fileRef: string, cwd: string): string | null {
+  const ref = (fileRef || '').trim()
+  if (!ref) return null
+  if (ref.startsWith('/api/uploads/')) {
+    return maybeResolveUploadMediaPathFromUrl(ref) || null
+  }
+  const withoutFileScheme = ref.replace(/^file:\/\//i, '')
+  const candidates = path.isAbsolute(withoutFileScheme)
+    ? [withoutFileScheme]
+    : [
+        cwd ? path.resolve(cwd, withoutFileScheme) : '',
+        path.resolve(WORKSPACE_DIR, withoutFileScheme),
+      ].filter(Boolean)
+
+  for (const candidate of candidates) {
+    try {
+      const stat = fs.statSync(candidate)
+      if (stat.isFile()) return candidate
+    } catch {
+      // ignore missing candidate
+    }
+  }
+  return null
+}
+
+export function isSendableAttachment(filePath: string): boolean {
+  try {
+    const stat = fs.statSync(filePath)
+    return stat.isFile() && stat.size <= MAX_CONNECTOR_ATTACHMENT_BYTES
+  } catch {
+    return false
+  }
+}
+
+export function resolveTaskOriginConnectorFollowupTarget(params: {
+  task: BoardTask
+  sessions: Record<string, SessionLike>
+  connectors: Record<string, Connector>
+  running: RunningConnectorLike[]
+}): ConnectorTaskFollowupTarget | null {
+  const { task, sessions, connectors, running } = params
+  const metaTask = task as ScheduleTaskMeta
+  const delegatedByAgentId = typeof metaTask.delegatedByAgentId === 'string'
+    ? metaTask.delegatedByAgentId.trim()
+    : ''
+  const allowedOwners = new Set([task.agentId, delegatedByAgentId].filter(Boolean))
+  const sourceSessionId = typeof metaTask.createdInSessionId === 'string'
+    ? metaTask.createdInSessionId.trim()
+    : ''
+
+  const runningById = new Map<string, RunningConnectorLike>()
+  for (const entry of running) {
+    if (!entry?.id) continue
+    runningById.set(entry.id, entry)
+  }
+
+  const normalizeTarget = (raw: {
+    connectorId?: string | null
+    channelId?: string | null
+    threadId?: string | null
+  }): ConnectorTaskFollowupTarget | null => {
+    const connectorId = typeof raw.connectorId === 'string' ? raw.connectorId.trim() : ''
+    if (!connectorId) return null
+    const connector = connectors[connectorId]
+    if (!connector) return null
+    const ownerId = typeof connector.agentId === 'string' ? connector.agentId.trim() : ''
+    if (ownerId && !allowedOwners.has(ownerId)) return null
+
+    const runtime = runningById.get(connectorId)
+    if (runtime && !runtime.supportsSend) return null
+
+    const channelId = typeof raw.channelId === 'string' ? raw.channelId.trim() : ''
+    if (!channelId) return null
+    const normalizedChannelId = connector.platform === 'whatsapp'
+      ? normalizeWhatsappTarget(channelId)
+      : channelId
+    const threadId = typeof raw.threadId === 'string' ? raw.threadId.trim() : ''
+    return {
+      connectorId,
+      channelId: normalizedChannelId,
+      ...(threadId ? { threadId } : {}),
+    }
+  }
+
+  const explicitTarget = normalizeTarget({
+    connectorId: typeof metaTask.followupConnectorId === 'string' ? metaTask.followupConnectorId : null,
+    channelId: typeof metaTask.followupChannelId === 'string' ? metaTask.followupChannelId : null,
+    threadId: typeof metaTask.followupThreadId === 'string' ? metaTask.followupThreadId : null,
+  })
+  if (explicitTarget) return explicitTarget
+
+  if (!sourceSessionId) return null
+  const sourceSession = sessions[sourceSessionId]
+  if (!sourceSession) return null
+
+  const sessionContextTarget = normalizeTarget({
+    connectorId: typeof sourceSession.connectorContext?.connectorId === 'string'
+      ? sourceSession.connectorContext.connectorId
+      : null,
+    channelId: typeof sourceSession.connectorContext?.channelId === 'string'
+      ? sourceSession.connectorContext.channelId
+      : null,
+    threadId: typeof sourceSession.connectorContext?.threadId === 'string'
+      ? sourceSession.connectorContext.threadId
+      : null,
+  })
+  if (sessionContextTarget) return sessionContextTarget
+
+  if (!Array.isArray(sourceSession.messages)) return null
+
+  for (let index = sourceSession.messages.length - 1; index >= 0; index -= 1) {
+    const message = sourceSession.messages[index]
+    if (!message || message.role !== 'user') continue
+    if (message.historyExcluded === true) continue
+
+    const connectorId = typeof message.source?.connectorId === 'string'
+      ? message.source.connectorId.trim()
+      : ''
+    if (!connectorId) continue
+
+    const connector = connectors[connectorId]
+    if (!connector) continue
+    const runtime = runningById.get(connectorId)
+    const sourceChannel = typeof message.source?.channelId === 'string'
+      ? message.source.channelId.trim()
+      : ''
+    const fallbackChannel = runtime?.recentChannelId
+      || runtime?.configuredTargets?.[0]
+      || connector.config?.outboundJid
+      || connector.config?.outboundTarget
+      || ''
+    const target = normalizeTarget({
+      connectorId,
+      channelId: sourceChannel || fallbackChannel,
+      threadId: typeof message.source?.threadId === 'string' ? message.source.threadId : null,
+    })
+    if (target) return target
+  }
+
+  return null
+}
+
+export function collectTaskConnectorFollowupTargets(params: {
+  task: BoardTask
+  sessions: Record<string, SessionLike>
+  connectors: Record<string, Connector>
+  running: RunningConnectorLike[]
+}): ConnectorTaskFollowupTarget[] {
+  const { task, sessions, connectors, running } = params
+  const originTarget = resolveTaskOriginConnectorFollowupTarget({ task, sessions, connectors, running })
+  if (originTarget) return [originTarget]
+
+  const targets: ConnectorTaskFollowupTarget[] = []
+  const seen = new Set<string>()
+  const pushTarget = (target: ConnectorTaskFollowupTarget | null | undefined) => {
+    if (!target?.connectorId || !target?.channelId) return
+    const key = `${target.connectorId}|${target.channelId}|${target.threadId || ''}`
+    if (seen.has(key)) return
+    seen.add(key)
+    targets.push(target)
+  }
+
+  for (const entry of running) {
+    if (!entry.supportsSend || !entry.id) continue
+    const connector = connectors[entry.id]
+    if (!connector) continue
+    if (connector.agentId !== task.agentId) continue
+    if (!isEnabledFlag(connector.config?.taskFollowups)) continue
+    const channelTargetRaw = entry.configuredTargets[0]
+      || connector.config?.outboundJid
+      || connector.config?.outboundTarget
+      || ''
+    if (!channelTargetRaw) continue
+    pushTarget({
+      connectorId: entry.id,
+      channelId: connector.platform === 'whatsapp'
+        ? normalizeWhatsappTarget(channelTargetRaw)
+        : channelTargetRaw,
+    })
+  }
+
+  return targets
+}
+
+export async function notifyConnectorTaskFollowups(params: {
+  task: BoardTask
+  statusLabel: string
+  summaryText: string
+  imageUrl?: string
+  mediaPath?: string
+  mediaFileName?: string
+}) {
+  const { task, statusLabel, summaryText, imageUrl, mediaPath, mediaFileName } = params
+
+  const connectors = loadConnectors()
+  const running = (await import('./connectors/manager')).listRunningConnectors()
+  const manager = await import('./connectors/manager')
+  const sessions = loadSessions()
+  const targets = collectTaskConnectorFollowupTargets({
+    task,
+    sessions: sessions as Record<string, SessionLike>,
+    connectors: connectors as any,
+    running: running as RunningConnectorLike[],
+  })
+  if (!targets.length) return
+  const originTarget = resolveTaskOriginConnectorFollowupTarget({
+    task,
+    sessions: sessions as Record<string, SessionLike>,
+    connectors: connectors as any,
+    running: running as RunningConnectorLike[],
+  })
+  const preferredTargetKey = originTarget
+    ? `${originTarget.connectorId}|${originTarget.channelId}|${originTarget.threadId || ''}`
+    : ''
+
+  const summary = summaryText.trim().slice(0, 1400)
+  for (const target of targets) {
+    const connector = connectors[target.connectorId]
+    if (!connector) continue
+
+    const template = typeof (connector as any).config?.taskFollowupTemplate === 'string'
+      ? (connector as any).config.taskFollowupTemplate.trim()
+      : ''
+    const message = template
+      ? fillTaskFollowupTemplate(template, {
+          status: statusLabel,
+          title: task.title || task.id,
+          summary,
+          taskId: task.id,
+        })
+      : [
+          `Task ${statusLabel}: ${task.title}`,
+          summary || 'No summary provided.',
+        ].join('\n\n')
+    const targetKey = `${target.connectorId}|${target.channelId}|${target.threadId || ''}`
+    const preferredChannelNote = !template && preferredTargetKey && targetKey === preferredTargetKey
+      ? '\n\n(Update sent in the same channel that requested this task.)'
+      : ''
+    const outboundMessage = `${message}${preferredChannelNote}`
+
+    const resolvedMediaPath = mediaPath || maybeResolveUploadMediaPathFromUrl(imageUrl)
+    try {
+      await manager.sendConnectorMessage({
+        connectorId: target.connectorId,
+        channelId: target.channelId,
+        threadId: target.threadId || undefined,
+        text: outboundMessage,
+        ...(resolvedMediaPath
+          ? {
+              mediaPath: resolvedMediaPath,
+              fileName: mediaFileName || path.basename(resolvedMediaPath),
+              caption: outboundMessage,
+            }
+          : {}),
+      })
+    } catch (err: unknown) {
+      const errMsg = errorMessage(err)
+      console.warn(`[queue] Failed task follow-up send on connector ${target.connectorId}: ${errMsg}`)
+    }
+  }
+}

package/src/lib/server/task-lifecycle.test.ts

@@ -0,0 +1,205 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import type { BoardTask, Schedule } from '@/types'
+
+import {
+  buildBoardTask,
+  didTaskValidationChange,
+  markInvalidCompletedTaskFailed,
+  markValidatedTaskCompleted,
+  prepareScheduledTaskRun,
+  resetTaskForRerun,
+} from './task-lifecycle'
+
+function makeTask(overrides: Partial<BoardTask> = {}): BoardTask {
+  return {
+    id: 'task-1',
+    title: 'Example Task',
+    description: 'Do the work',
+    status: 'backlog',
+    agentId: 'agent-1',
+    sessionId: null,
+    result: null,
+    error: null,
+    createdAt: 1,
+    updatedAt: 1,
+    queuedAt: null,
+    startedAt: null,
+    completedAt: null,
+    ...overrides,
+  }
+}
+
+function makeSchedule(overrides: Partial<Schedule> = {}): Schedule {
+  return {
+    id: 'schedule-1',
+    name: 'Nightly backup',
+    agentId: 'agent-1',
+    taskPrompt: 'Run nightly backup',
+    scheduleType: 'cron',
+    cron: '0 0 * * *',
+    status: 'active',
+    runNumber: 2,
+    createdAt: 1,
+    updatedAt: 1,
+    ...overrides,
+  }
+}
+
+describe('task lifecycle helpers', () => {
+  it('buildBoardTask applies shared defaults and preserves seed metadata', () => {
+    const task = buildBoardTask({
+      id: 'task-build',
+      title: 'Build',
+      description: 'Compile project',
+      agentId: 'agent-1',
+      now: 123,
+      seed: {
+        comments: [],
+        sourceType: 'manual',
+      },
+    })
+
+    assert.equal(task.id, 'task-build')
+    assert.equal(task.status, 'backlog')
+    assert.equal(task.sessionId, null)
+    assert.equal(task.result, null)
+    assert.equal(task.createdAt, 123)
+    assert.equal(task.sourceType, 'manual')
+  })
+
+  it('resetTaskForRerun clears terminal fields and rolls stats forward', () => {
+    const task = makeTask({
+      status: 'completed',
+      result: 'done',
+      error: 'old error',
+      sessionId: 'session-1',
+      completionReportPath: 'report.md',
+      outputFiles: ['a.txt'],
+      artifacts: [{ url: '/x', type: 'file', filename: 'x.txt' }],
+      attempts: 3,
+      retryScheduledAt: 10,
+      deadLetteredAt: 20,
+      validation: { ok: true, reasons: [], checkedAt: 5 },
+      runNumber: 1,
+      totalRuns: 4,
+      totalCompleted: 2,
+    })
+
+    resetTaskForRerun(task, {
+      title: '[Sched] Nightly backup (run #2)',
+      now: 99,
+      runNumber: 2,
+    })
+
+    assert.equal(task.status, 'backlog')
+    assert.equal(task.title, '[Sched] Nightly backup (run #2)')
+    assert.equal(task.result, null)
+    assert.equal(task.error, null)
+    assert.equal(task.sessionId, null)
+    assert.equal(task.completionReportPath, null)
+    assert.equal(task.completedAt, null)
+    assert.equal(task.attempts, 0)
+    assert.equal(task.retryScheduledAt, null)
+    assert.equal(task.deadLetteredAt, null)
+    assert.equal(task.validation, null)
+    assert.equal(task.totalRuns, 5)
+    assert.equal(task.totalCompleted, 3)
+    assert.equal(task.runNumber, 2)
+  })
+
+  it('prepareScheduledTaskRun creates a schedule-backed task when no reusable task exists', () => {
+    const schedule = makeSchedule({
+      createdInSessionId: 'session-1',
+      createdByAgentId: 'agent-owner',
+      followupConnectorId: 'connector-1',
+    })
+    const tasks: Record<string, BoardTask> = {}
+
+    const { taskId, task } = prepareScheduledTaskRun({
+      schedule,
+      tasks,
+      now: 200,
+      scheduleSignature: 'sig-1',
+    })
+
+    assert.equal(taskId, task.id)
+    assert.equal(task.sourceType, 'schedule')
+    assert.equal(task.sourceScheduleId, schedule.id)
+    assert.equal(task.sourceScheduleKey, 'sig-1')
+    assert.equal(task.createdInSessionId, 'session-1')
+    assert.equal(task.followupConnectorId, 'connector-1')
+    assert.equal(schedule.linkedTaskId, taskId)
+    assert.equal(tasks[taskId], task)
+  })
+
+  it('prepareScheduledTaskRun reuses and resets a terminal linked task', () => {
+    const existing = makeTask({
+      id: 'linked-task',
+      status: 'failed',
+      result: 'failed before',
+      runNumber: 1,
+    })
+    const tasks: Record<string, BoardTask> = { 'linked-task': existing }
+    const schedule = makeSchedule({
+      linkedTaskId: 'linked-task',
+      runNumber: 7,
+    })
+
+    const { taskId, task } = prepareScheduledTaskRun({
+      schedule,
+      tasks,
+      now: 300,
+      scheduleSignature: 'sig-2',
+    })
+
+    assert.equal(taskId, 'linked-task')
+    assert.equal(task, existing)
+    assert.equal(task.status, 'backlog')
+    assert.equal(task.runNumber, 7)
+    assert.equal(task.result, null)
+  })
+
+  it('markValidatedTaskCompleted preserves or sets completedAt as requested', () => {
+    const task = makeTask({ status: 'completed', completedAt: 10, error: 'nope' })
+    markValidatedTaskCompleted(task, { now: 50, preserveCompletedAt: true })
+    assert.equal(task.completedAt, 10)
+    assert.equal(task.error, null)
+
+    markValidatedTaskCompleted(task, { now: 75 })
+    assert.equal(task.completedAt, 75)
+  })
+
+  it('markInvalidCompletedTaskFailed records failure state and comment', () => {
+    const task = makeTask({ status: 'completed' })
+    markInvalidCompletedTaskFailed(task, {
+      ok: false,
+      reasons: ['Missing evidence'],
+      checkedAt: 20,
+    }, {
+      now: 30,
+      comment: {
+        author: 'System',
+        text: 'Validation failed.',
+      },
+    })
+
+    assert.equal(task.status, 'failed')
+    assert.equal(task.completedAt, null)
+    assert.match(task.error || '', /Completion validation failed/)
+    assert.equal(task.comments?.[0]?.author, 'System')
+  })
+
+  it('didTaskValidationChange compares both status and reasons', () => {
+    assert.equal(didTaskValidationChange(null, { ok: true, reasons: [], checkedAt: 1 }), true)
+    assert.equal(didTaskValidationChange(
+      { ok: true, reasons: [], checkedAt: 1 },
+      { ok: true, reasons: [], checkedAt: 2 },
+    ), false)
+    assert.equal(didTaskValidationChange(
+      { ok: true, reasons: [], checkedAt: 1 },
+      { ok: false, reasons: ['x'], checkedAt: 2 },
+    ), true)
+  })
+})