@swarmclawai/swarmclaw 0.2.0

package/src/lib/server/runtime-settings.ts

@@ -0,0 +1,119 @@
+import type { LoopMode } from '@/types'
+import {
+  DEFAULT_AGENT_LOOP_RECURSION_LIMIT,
+  DEFAULT_CLAUDE_CODE_TIMEOUT_SEC,
+  DEFAULT_CLI_PROCESS_TIMEOUT_SEC,
+  DEFAULT_LEGACY_ORCHESTRATOR_MAX_TURNS,
+  DEFAULT_LOOP_MODE,
+  DEFAULT_ONGOING_LOOP_MAX_ITERATIONS,
+  DEFAULT_ONGOING_LOOP_MAX_RUNTIME_MINUTES,
+  DEFAULT_ORCHESTRATOR_LOOP_RECURSION_LIMIT,
+  DEFAULT_SHELL_COMMAND_TIMEOUT_SEC,
+} from '@/lib/runtime-loop'
+import { loadSettings } from './storage'
+
+export interface RuntimeSettings {
+  loopMode: LoopMode
+  agentLoopRecursionLimit: number
+  orchestratorLoopRecursionLimit: number
+  legacyOrchestratorMaxTurns: number
+  ongoingLoopMaxIterations: number
+  ongoingLoopMaxRuntimeMs: number | null
+  shellCommandTimeoutMs: number
+  claudeCodeTimeoutMs: number
+  cliProcessTimeoutMs: number
+}
+
+function parseIntSetting(value: unknown, fallback: number, min: number, max: number): number {
+  const parsed = typeof value === 'number'
+    ? value
+    : typeof value === 'string'
+      ? Number.parseInt(value, 10)
+      : Number.NaN
+  if (!Number.isFinite(parsed)) return fallback
+  const int = Math.trunc(parsed)
+  return Math.max(min, Math.min(max, int))
+}
+
+function parseLoopMode(value: unknown): LoopMode {
+  return value === 'ongoing' ? 'ongoing' : DEFAULT_LOOP_MODE
+}
+
+export function loadRuntimeSettings(): RuntimeSettings {
+  const settings = loadSettings()
+  const loopMode = parseLoopMode(settings.loopMode)
+
+  const agentLoopRecursionLimit = parseIntSetting(
+    settings.agentLoopRecursionLimit,
+    DEFAULT_AGENT_LOOP_RECURSION_LIMIT,
+    1,
+    200,
+  )
+  const orchestratorLoopRecursionLimit = parseIntSetting(
+    settings.orchestratorLoopRecursionLimit,
+    DEFAULT_ORCHESTRATOR_LOOP_RECURSION_LIMIT,
+    1,
+    300,
+  )
+  const legacyOrchestratorMaxTurns = parseIntSetting(
+    settings.legacyOrchestratorMaxTurns,
+    DEFAULT_LEGACY_ORCHESTRATOR_MAX_TURNS,
+    1,
+    300,
+  )
+  const ongoingLoopMaxIterations = parseIntSetting(
+    settings.ongoingLoopMaxIterations,
+    DEFAULT_ONGOING_LOOP_MAX_ITERATIONS,
+    10,
+    5000,
+  )
+  const ongoingLoopMaxRuntimeMinutes = parseIntSetting(
+    settings.ongoingLoopMaxRuntimeMinutes,
+    DEFAULT_ONGOING_LOOP_MAX_RUNTIME_MINUTES,
+    0,
+    1440,
+  )
+
+  const shellCommandTimeoutSec = parseIntSetting(
+    settings.shellCommandTimeoutSec,
+    DEFAULT_SHELL_COMMAND_TIMEOUT_SEC,
+    1,
+    600,
+  )
+  const claudeCodeTimeoutSec = parseIntSetting(
+    settings.claudeCodeTimeoutSec,
+    DEFAULT_CLAUDE_CODE_TIMEOUT_SEC,
+    5,
+    7200,
+  )
+  const cliProcessTimeoutSec = parseIntSetting(
+    settings.cliProcessTimeoutSec,
+    DEFAULT_CLI_PROCESS_TIMEOUT_SEC,
+    10,
+    7200,
+  )
+
+  return {
+    loopMode,
+    agentLoopRecursionLimit,
+    orchestratorLoopRecursionLimit,
+    legacyOrchestratorMaxTurns,
+    ongoingLoopMaxIterations,
+    ongoingLoopMaxRuntimeMs: ongoingLoopMaxRuntimeMinutes > 0 ? ongoingLoopMaxRuntimeMinutes * 60_000 : null,
+    shellCommandTimeoutMs: shellCommandTimeoutSec * 1000,
+    claudeCodeTimeoutMs: claudeCodeTimeoutSec * 1000,
+    cliProcessTimeoutMs: cliProcessTimeoutSec * 1000,
+  }
+}
+
+export function getAgentLoopRecursionLimit(runtime: RuntimeSettings): number {
+  return runtime.loopMode === 'ongoing' ? runtime.ongoingLoopMaxIterations : runtime.agentLoopRecursionLimit
+}
+
+export function getOrchestratorLoopRecursionLimit(runtime: RuntimeSettings): number {
+  return runtime.loopMode === 'ongoing' ? runtime.ongoingLoopMaxIterations : runtime.orchestratorLoopRecursionLimit
+}
+
+export function getLegacyOrchestratorMaxTurns(runtime: RuntimeSettings): number {
+  return runtime.loopMode === 'ongoing' ? runtime.ongoingLoopMaxIterations : runtime.legacyOrchestratorMaxTurns
+}

package/src/lib/server/scheduler.ts

@@ -0,0 +1,196 @@
+import crypto from 'crypto'
+import { loadSchedules, saveSchedules, loadAgents, loadTasks, saveTasks } from './storage'
+import { enqueueTask } from './queue'
+import { CronExpressionParser } from 'cron-parser'
+import { pushMainLoopEventToMainSessions } from './main-agent-loop'
+import { getScheduleSignatureKey } from '@/lib/schedule-dedupe'
+
+const TICK_INTERVAL = 60_000 // 60 seconds
+let intervalId: ReturnType<typeof setInterval> | null = null
+
+interface ScheduleTaskLike {
+  status?: string
+  sourceScheduleKey?: string | null
+}
+
+interface SchedulerScheduleLike {
+  id: string
+  name: string
+  agentId: string
+  taskPrompt: string
+  scheduleType: 'cron' | 'interval' | 'once'
+  cron?: string
+  intervalMs?: number
+  runAt?: number
+  lastRunAt?: number
+  nextRunAt?: number
+  status: 'active' | 'paused' | 'completed' | 'failed'
+  linkedTaskId?: string | null
+  runNumber?: number
+  createdInSessionId?: string | null
+  createdByAgentId?: string | null
+}
+
+export function startScheduler() {
+  if (intervalId) return
+  console.log('[scheduler] Starting scheduler engine (60s tick)')
+
+  // Compute initial nextRunAt for cron schedules missing it
+  computeNextRuns()
+
+  intervalId = setInterval(tick, TICK_INTERVAL)
+}
+
+export function stopScheduler() {
+  if (intervalId) {
+    clearInterval(intervalId)
+    intervalId = null
+    console.log('[scheduler] Stopped scheduler engine')
+  }
+}
+
+function computeNextRuns() {
+  const schedules = loadSchedules()
+  let changed = false
+  for (const schedule of Object.values(schedules) as SchedulerScheduleLike[]) {
+    if (schedule.status !== 'active') continue
+    if (schedule.scheduleType === 'cron' && schedule.cron && !schedule.nextRunAt) {
+      try {
+        const interval = CronExpressionParser.parse(schedule.cron)
+        schedule.nextRunAt = interval.next().getTime()
+        changed = true
+      } catch (err) {
+        console.error(`[scheduler] Invalid cron for ${schedule.id}:`, err)
+        schedule.status = 'failed'
+        changed = true
+      }
+    }
+  }
+  if (changed) saveSchedules(schedules)
+}
+
+async function tick() {
+  const now = Date.now()
+  const schedules = loadSchedules()
+  const agents = loadAgents()
+  const tasks = loadTasks()
+  const inFlightScheduleKeys = new Set<string>(
+    Object.values(tasks as Record<string, ScheduleTaskLike>)
+      .filter((task) => task && (task.status === 'queued' || task.status === 'running'))
+      .map((task) => (typeof task.sourceScheduleKey === 'string' ? task.sourceScheduleKey : ''))
+      .filter((value: string) => value.length > 0),
+  )
+
+  const advanceSchedule = (schedule: SchedulerScheduleLike): void => {
+    if (schedule.scheduleType === 'cron' && schedule.cron) {
+      try {
+        const interval = CronExpressionParser.parse(schedule.cron)
+        schedule.nextRunAt = interval.next().getTime()
+      } catch {
+        schedule.status = 'failed'
+      }
+    } else if (schedule.scheduleType === 'interval' && schedule.intervalMs) {
+      schedule.nextRunAt = now + schedule.intervalMs
+    } else if (schedule.scheduleType === 'once') {
+      schedule.status = 'completed'
+      schedule.nextRunAt = undefined
+    }
+  }
+
+  for (const schedule of Object.values(schedules) as SchedulerScheduleLike[]) {
+    if (schedule.status !== 'active') continue
+    if (!schedule.nextRunAt || schedule.nextRunAt > now) continue
+
+    const scheduleSignature = getScheduleSignatureKey(schedule)
+    if (scheduleSignature && inFlightScheduleKeys.has(scheduleSignature)) {
+      advanceSchedule(schedule)
+      saveSchedules(schedules)
+      continue
+    }
+
+    const agent = agents[schedule.agentId]
+    if (!agent) {
+      console.error(`[scheduler] Agent ${schedule.agentId} not found for schedule ${schedule.id}`)
+      schedule.status = 'failed'
+      saveSchedules(schedules)
+      pushMainLoopEventToMainSessions({
+        type: 'schedule_failed',
+        text: `Schedule failed: "${schedule.name}" (${schedule.id}) — agent ${schedule.agentId} not found.`,
+      })
+      continue
+    }
+
+    console.log(`[scheduler] Firing schedule "${schedule.name}" (${schedule.id})`)
+    schedule.lastRunAt = now
+    schedule.runNumber = (schedule.runNumber || 0) + 1
+
+    // Compute next run
+    advanceSchedule(schedule)
+
+    // Reuse linked task if it exists and is not currently in-flight
+    let taskId = ''
+    const existingTaskId = typeof schedule.linkedTaskId === 'string' ? schedule.linkedTaskId : ''
+    const existingTask = existingTaskId ? tasks[existingTaskId] : null
+    if (existingTask && existingTask.status !== 'queued' && existingTask.status !== 'running') {
+      // Accumulate stats from the previous run before resetting
+      taskId = existingTaskId
+      const prev = existingTask as any
+      prev.totalRuns = (prev.totalRuns || 0) + 1
+      if (existingTask.status === 'completed') prev.totalCompleted = (prev.totalCompleted || 0) + 1
+      if (existingTask.status === 'failed') prev.totalFailed = (prev.totalFailed || 0) + 1
+
+      // Reset for the new run
+      existingTask.status = 'backlog'
+      existingTask.title = `[Sched] ${schedule.name} (run #${schedule.runNumber})`
+      existingTask.result = null
+      existingTask.error = null
+      existingTask.sessionId = null
+      existingTask.updatedAt = now
+      existingTask.queuedAt = null
+      existingTask.startedAt = null
+      existingTask.completedAt = null
+      existingTask.archivedAt = null
+      existingTask.attempts = 0
+      existingTask.retryScheduledAt = null
+      existingTask.deadLetteredAt = null
+      existingTask.validation = null
+      prev.runNumber = schedule.runNumber
+    } else {
+      // Create a new linked task (first run or previous task still in-flight)
+      taskId = crypto.randomBytes(4).toString('hex')
+      tasks[taskId] = {
+        id: taskId,
+        title: `[Sched] ${schedule.name} (run #${schedule.runNumber})`,
+        description: schedule.taskPrompt,
+        status: 'backlog',
+        agentId: schedule.agentId,
+        sessionId: null,
+        result: null,
+        error: null,
+        createdAt: now,
+        updatedAt: now,
+        queuedAt: null,
+        startedAt: null,
+        completedAt: null,
+        sourceType: 'schedule',
+        sourceScheduleId: schedule.id,
+        sourceScheduleName: schedule.name,
+        sourceScheduleKey: scheduleSignature || null,
+        createdInSessionId: schedule.createdInSessionId || null,
+        createdByAgentId: schedule.createdByAgentId || null,
+        runNumber: schedule.runNumber,
+      }
+      schedule.linkedTaskId = taskId
+    }
+
+    saveTasks(tasks)
+    saveSchedules(schedules)
+
+    enqueueTask(taskId)
+    if (scheduleSignature) inFlightScheduleKeys.add(scheduleSignature)
+    pushMainLoopEventToMainSessions({
+      type: 'schedule_fired',
+      text: `Schedule fired: "${schedule.name}" (${schedule.id}) run #${schedule.runNumber} — task ${taskId}`,
+    })
+  }
+}

package/src/lib/server/session-mailbox.ts

@@ -0,0 +1,129 @@
+import crypto from 'crypto'
+import { loadSessions, saveSessions } from './storage'
+
+export type MailboxStatus = 'new' | 'ack'
+
+export interface MailboxEnvelope {
+  id: string
+  type: string
+  payload: string
+  fromSessionId?: string | null
+  fromAgentId?: string | null
+  toSessionId: string
+  toAgentId?: string | null
+  correlationId?: string | null
+  status: MailboxStatus
+  createdAt: number
+  expiresAt?: number | null
+  ackAt?: number | null
+}
+
+interface MailboxOptions {
+  limit?: number
+  includeAcked?: boolean
+}
+
+function normalizeMailboxList(raw: unknown): MailboxEnvelope[] {
+  if (!Array.isArray(raw)) return []
+  const out: MailboxEnvelope[] = []
+  for (const item of raw) {
+    if (!item || typeof item !== 'object') continue
+    const v = item as MailboxEnvelope
+    if (!v.id || !v.toSessionId) continue
+    out.push(v)
+  }
+  return out
+}
+
+function pruneExpired(envelopes: MailboxEnvelope[], now = Date.now()): MailboxEnvelope[] {
+  return envelopes.filter((env) => !env.expiresAt || env.expiresAt > now)
+}
+
+export function sendMailboxEnvelope(input: {
+  toSessionId: string
+  type: string
+  payload: string
+  fromSessionId?: string | null
+  fromAgentId?: string | null
+  toAgentId?: string | null
+  correlationId?: string | null
+  ttlSec?: number | null
+}): MailboxEnvelope {
+  const sessions = loadSessions()
+  const target = sessions[input.toSessionId]
+  if (!target) throw new Error(`Target session not found: ${input.toSessionId}`)
+
+  const now = Date.now()
+  const ttl = typeof input.ttlSec === 'number' && Number.isFinite(input.ttlSec)
+    ? Math.max(0, Math.min(7 * 24 * 3600, Math.trunc(input.ttlSec)))
+    : null
+  const envelope: MailboxEnvelope = {
+    id: crypto.randomBytes(6).toString('hex'),
+    type: (input.type || 'message').trim() || 'message',
+    payload: String(input.payload || ''),
+    fromSessionId: input.fromSessionId || null,
+    fromAgentId: input.fromAgentId || null,
+    toSessionId: input.toSessionId,
+    toAgentId: input.toAgentId || null,
+    correlationId: input.correlationId || null,
+    status: 'new',
+    createdAt: now,
+    expiresAt: ttl ? now + ttl * 1000 : null,
+    ackAt: null,
+  }
+
+  const existing = pruneExpired(normalizeMailboxList(target.mailbox || []), now)
+  existing.push(envelope)
+  target.mailbox = existing
+  target.lastActiveAt = now
+  sessions[input.toSessionId] = target
+  saveSessions(sessions)
+  return envelope
+}
+
+export function listMailbox(sessionId: string, opts: MailboxOptions = {}): MailboxEnvelope[] {
+  const sessions = loadSessions()
+  const target = sessions[sessionId]
+  if (!target) throw new Error(`Session not found: ${sessionId}`)
+  const list = pruneExpired(normalizeMailboxList(target.mailbox || []))
+  const includeAcked = opts.includeAcked === true
+  const filtered = includeAcked ? list : list.filter((env) => env.status !== 'ack')
+  const limit = Math.max(1, Math.min(500, Math.trunc(opts.limit || 50)))
+  return filtered
+    .sort((a, b) => b.createdAt - a.createdAt)
+    .slice(0, limit)
+}
+
+export function ackMailboxEnvelope(sessionId: string, envelopeId: string): MailboxEnvelope | null {
+  const sessions = loadSessions()
+  const target = sessions[sessionId]
+  if (!target) throw new Error(`Session not found: ${sessionId}`)
+  const list = pruneExpired(normalizeMailboxList(target.mailbox || []))
+  const idx = list.findIndex((env) => env.id === envelopeId)
+  if (idx === -1) return null
+  list[idx] = {
+    ...list[idx],
+    status: 'ack',
+    ackAt: Date.now(),
+  }
+  target.mailbox = list
+  target.lastActiveAt = Date.now()
+  sessions[sessionId] = target
+  saveSessions(sessions)
+  return list[idx]
+}
+
+export function clearMailbox(sessionId: string, includeAcked = true): { before: number; after: number } {
+  const sessions = loadSessions()
+  const target = sessions[sessionId]
+  if (!target) throw new Error(`Session not found: ${sessionId}`)
+  const list = pruneExpired(normalizeMailboxList(target.mailbox || []))
+  const before = list.length
+  const afterList = includeAcked ? [] : list.filter((env) => env.status !== 'ack')
+  target.mailbox = afterList
+  target.lastActiveAt = Date.now()
+  sessions[sessionId] = target
+  saveSessions(sessions)
+  return { before, after: afterList.length }
+}
+