@swarmclawai/swarmclaw 0.5.3 → 0.6.2

package/src/app/api/tasks/metrics/route.ts

@@ -0,0 +1,101 @@
+import { NextResponse } from 'next/server'
+import { loadTasks, loadAgents } from '@/lib/server/storage'
+
+type Range = '24h' | '7d' | '30d'
+
+const RANGE_MS: Record<Range, number> = {
+  '24h': 24 * 3600_000,
+  '7d': 7 * 86400_000,
+  '30d': 30 * 86400_000,
+}
+
+function bucketKey(ts: number, range: Range): string {
+  const d = new Date(ts)
+  if (range === '24h') return d.toISOString().slice(0, 13) // "2026-03-01T14"
+  return d.toISOString().slice(0, 10) // "2026-03-01"
+}
+
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url)
+  const range = (searchParams.get('range') as Range) || '7d'
+  const cutoff = Date.now() - (RANGE_MS[range] || RANGE_MS['7d'])
+
+  const tasks = loadTasks()
+  const agents = loadAgents()
+  const all = Object.values(tasks)
+
+  // --- by-status counts ---
+  const byStatus: Record<string, number> = {}
+  for (const t of all) {
+    byStatus[t.status] = (byStatus[t.status] || 0) + 1
+  }
+
+  // WIP = queued + running
+  const wip = (byStatus['queued'] || 0) + (byStatus['running'] || 0)
+
+  // --- completions in range ---
+  const completedInRange = all.filter(
+    (t) => t.status === 'completed' && t.completedAt && t.completedAt >= cutoff,
+  )
+
+  // --- cycle times (queuedAt → completedAt) ---
+  const cycleTimes: number[] = []
+  for (const t of completedInRange) {
+    const start = t.queuedAt || t.createdAt
+    const end = t.completedAt!
+    if (end > start) cycleTimes.push(end - start)
+  }
+  cycleTimes.sort((a, b) => a - b)
+
+  const avgCycleMs = cycleTimes.length
+    ? Math.round(cycleTimes.reduce((s, v) => s + v, 0) / cycleTimes.length)
+    : 0
+  const p50CycleMs = cycleTimes.length ? cycleTimes[Math.floor(cycleTimes.length * 0.5)] : 0
+  const p90CycleMs = cycleTimes.length ? cycleTimes[Math.floor(cycleTimes.length * 0.9)] : 0
+
+  // --- velocity (completions per bucket) ---
+  const velocityMap: Record<string, number> = {}
+  for (const t of completedInRange) {
+    const key = bucketKey(t.completedAt!, range)
+    velocityMap[key] = (velocityMap[key] || 0) + 1
+  }
+  const velocity = Object.entries(velocityMap)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([bucket, count]) => ({ bucket, count }))
+
+  // --- by-agent completions ---
+  const byAgent: Record<string, { agentName: string; completed: number; failed: number }> = {}
+  const recentTasks = all.filter(
+    (t) => (t.completedAt && t.completedAt >= cutoff) || (t.status === 'failed' && t.updatedAt >= cutoff),
+  )
+  for (const t of recentTasks) {
+    if (!t.agentId) continue
+    if (!byAgent[t.agentId]) {
+      const agent = agents[t.agentId]
+      byAgent[t.agentId] = { agentName: agent?.name || t.agentId, completed: 0, failed: 0 }
+    }
+    if (t.status === 'completed') byAgent[t.agentId].completed++
+    else if (t.status === 'failed') byAgent[t.agentId].failed++
+  }
+  const byAgentList = Object.values(byAgent).sort((a, b) => b.completed - a.completed)
+
+  // --- by-priority counts ---
+  const byPriority: Record<string, number> = {}
+  for (const t of all) {
+    const p = t.priority || 'none'
+    byPriority[p] = (byPriority[p] || 0) + 1
+  }
+
+  return NextResponse.json({
+    range,
+    byStatus,
+    wip,
+    completedCount: completedInRange.length,
+    avgCycleMs,
+    p50CycleMs,
+    p90CycleMs,
+    velocity,
+    byAgent: byAgentList,
+    byPriority,
+  })
+}

package/src/app/api/tasks/route.ts

@@ -1,11 +1,13 @@
 import { NextResponse } from 'next/server'
 import { genId } from '@/lib/id'
-import { loadTasks, saveTasks, loadSettings, logActivity } from '@/lib/server/storage'
+import { loadTasks, saveTasks, loadSettings, loadAgents, logActivity } from '@/lib/server/storage'
 import { enqueueTask, validateCompletedTasksQueue } from '@/lib/server/queue'
 import { ensureTaskCompletionReport } from '@/lib/server/task-reports'
 import { formatValidationFailure, validateTaskCompletion } from '@/lib/server/task-validation'
 import { pushMainLoopEventToMainSessions } from '@/lib/server/main-agent-loop'
 import { notify } from '@/lib/server/ws-hub'
+import { computeTaskFingerprint, findDuplicateTask } from '@/lib/task-dedupe'
+import { resolveTaskAgentFromDescription } from '@/lib/server/task-mention'
 
 export async function GET(req: Request) {
   // Keep completed queue integrity even if daemon is not running.
@@ -64,12 +66,18 @@ export async function POST(req: Request) {
   const retryBackoffSec = Number.isFinite(Number(body.retryBackoffSec))
     ? Math.max(1, Math.min(3600, Math.trunc(Number(body.retryBackoffSec))))
     : Math.max(1, Math.min(3600, Math.trunc(Number(settings.taskRetryBackoffSec ?? 30))))
+  // Resolve @mentions in description to auto-assign agent
+  const resolvedAgentId = body.description
+    ? resolveTaskAgentFromDescription(body.description, body.agentId || '', loadAgents())
+    : (body.agentId || '')
+
   tasks[id] = {
     id,
     title: body.title || 'Untitled Task',
     description: body.description || '',
     status: body.status || 'backlog',
-    agentId: body.agentId || '',
+    agentId: resolvedAgentId,
+    projectId: typeof body.projectId === 'string' && body.projectId ? body.projectId : null,
     goalContract: body.goalContract || null,
     cwd: typeof body.cwd === 'string' ? body.cwd : null,
     file: typeof body.file === 'string' ? body.file : null,
@@ -93,6 +101,14 @@ export async function POST(req: Request) {
     tags: Array.isArray(body.tags) ? body.tags.filter((s: unknown) => typeof s === 'string') : [],
     dueAt: typeof body.dueAt === 'number' ? body.dueAt : null,
     customFields: body.customFields && typeof body.customFields === 'object' ? body.customFields : undefined,
+    priority: ['low', 'medium', 'high', 'critical'].includes(body.priority) ? body.priority : undefined,
+    fingerprint: computeTaskFingerprint(body.title || 'Untitled Task', body.agentId || ''),
+  }
+
+  // Dedup: if a non-terminal task with same fingerprint exists, return it
+  const dupe = findDuplicateTask(tasks, { fingerprint: tasks[id].fingerprint! })
+  if (dupe && dupe.id !== id) {
+    return NextResponse.json({ ...dupe, deduplicated: true })
   }
 
   if (tasks[id].status === 'completed') {

package/src/app/api/tts/route.ts

@@ -10,8 +10,9 @@ export async function POST(req: Request) {
     return new NextResponse('No ElevenLabs API key. Set one in Settings > Voice.', { status: 500 })
   }
 
-  const { text } = await req.json()
-  const apiRes = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${ELEVENLABS_VOICE}`, {
+  const { text, voiceId } = await req.json()
+  const voice = voiceId || ELEVENLABS_VOICE
+  const apiRes = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${voice}`, {
     method: 'POST',
     headers: {
       'xi-api-key': ELEVENLABS_KEY,

package/src/app/api/tts/stream/route.ts

@@ -9,13 +9,14 @@ export async function POST(req: Request) {
     return new Response('No ElevenLabs API key. Set one in Settings > Voice.', { status: 500 })
   }
 
-  const { text } = await req.json()
+  const { text, voiceId } = await req.json()
   if (!text?.trim()) {
     return new Response('No text provided', { status: 400 })
   }
 
+  const voice = voiceId || ELEVENLABS_VOICE
   const apiRes = await fetch(
-    `https://api.elevenlabs.io/v1/text-to-speech/${ELEVENLABS_VOICE}/stream`,
+    `https://api.elevenlabs.io/v1/text-to-speech/${voice}/stream`,
     {
       method: 'POST',
       headers: {

package/src/app/api/uploads/[filename]/route.ts

@@ -3,40 +3,7 @@ import { notFound } from '@/lib/server/collection-helpers'
 import fs from 'fs'
 import path from 'path'
 import { UPLOAD_DIR } from '@/lib/server/storage'
-
-const MIME_TYPES: Record<string, string> = {
-  '.png': 'image/png',
-  '.jpg': 'image/jpeg',
-  '.jpeg': 'image/jpeg',
-  '.gif': 'image/gif',
-  '.webp': 'image/webp',
-  '.svg': 'image/svg+xml',
-  '.bmp': 'image/bmp',
-  '.ico': 'image/x-icon',
-  '.mp4': 'video/mp4',
-  '.webm': 'video/webm',
-  '.mov': 'video/quicktime',
-  '.avi': 'video/x-msvideo',
-  '.mkv': 'video/x-matroska',
-  '.pdf': 'application/pdf',
-  '.json': 'application/json',
-  '.csv': 'text/csv',
-  '.txt': 'text/plain',
-  '.html': 'text/html',
-  '.xml': 'application/xml',
-  '.zip': 'application/zip',
-  '.tar': 'application/x-tar',
-  '.gz': 'application/gzip',
-  '.doc': 'application/msword',
-  '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-  '.xls': 'application/vnd.ms-excel',
-  '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-  '.ppt': 'application/vnd.ms-powerpoint',
-  '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-  '.mp3': 'audio/mpeg',
-  '.wav': 'audio/wav',
-  '.ogg': 'audio/ogg',
-}
+import { MIME_TYPES } from '@/lib/server/mime'
 
 export async function GET(_req: Request, { params }: { params: Promise<{ filename: string }> }) {
   const { filename } = await params
@@ -60,3 +27,21 @@ export async function GET(_req: Request, { params }: { params: Promise<{ filenam
     },
   })
 }
+
+export async function DELETE(_req: Request, { params }: { params: Promise<{ filename: string }> }) {
+  const { filename } = await params
+  const safeName = filename.replace(/[^a-zA-Z0-9._-]/g, '')
+
+  if (safeName.includes('..') || safeName.includes('/')) {
+    return NextResponse.json({ error: 'Invalid filename' }, { status: 400 })
+  }
+
+  const filePath = path.join(UPLOAD_DIR, safeName)
+
+  if (!fs.existsSync(filePath)) {
+    return notFound()
+  }
+
+  fs.unlinkSync(filePath)
+  return NextResponse.json({ ok: true })
+}

package/src/app/api/uploads/route.ts

@@ -0,0 +1,94 @@
+import { NextResponse } from 'next/server'
+import fs from 'fs'
+import path from 'path'
+import { UPLOAD_DIR } from '@/lib/server/storage'
+import { getFileCategory } from '@/lib/server/mime'
+
+interface UploadFile {
+  name: string
+  size: number
+  modified: number
+  category: string
+  url: string
+}
+
+function listUploadFiles(): UploadFile[] {
+  if (!fs.existsSync(UPLOAD_DIR)) return []
+  const entries = fs.readdirSync(UPLOAD_DIR)
+  const files: UploadFile[] = []
+  for (const name of entries) {
+    const filePath = path.join(UPLOAD_DIR, name)
+    try {
+      const stat = fs.statSync(filePath)
+      if (!stat.isFile()) continue
+      const ext = path.extname(name).toLowerCase()
+      files.push({
+        name,
+        size: stat.size,
+        modified: stat.mtimeMs,
+        category: getFileCategory(ext),
+        url: `/api/uploads/${encodeURIComponent(name)}`,
+      })
+    } catch {
+      // skip files we can't stat
+    }
+  }
+  return files
+}
+
+export async function GET() {
+  const files = listUploadFiles()
+  const totalSize = files.reduce((sum, f) => sum + f.size, 0)
+  return NextResponse.json({ files, totalSize, count: files.length })
+}
+
+interface DeleteBody {
+  filenames?: string[]
+  olderThanDays?: number
+  category?: string
+  all?: boolean
+}
+
+function isUnsafeName(name: string): boolean {
+  return name.includes('/') || name.includes('\\') || name.includes('..')
+}
+
+export async function DELETE(req: Request) {
+  const body = (await req.json()) as DeleteBody
+  const files = listUploadFiles()
+  let toDelete: string[] = []
+
+  if (body.all) {
+    toDelete = files.map((f) => f.name)
+  } else if (body.filenames && Array.isArray(body.filenames)) {
+    for (const name of body.filenames) {
+      if (typeof name !== 'string' || isUnsafeName(name)) {
+        return NextResponse.json({ error: `Invalid filename: ${name}` }, { status: 400 })
+      }
+    }
+    toDelete = body.filenames
+  } else if (typeof body.olderThanDays === 'number') {
+    const cutoff = Date.now() - body.olderThanDays * 86_400_000
+    toDelete = files.filter((f) => f.modified < cutoff).map((f) => f.name)
+  } else if (typeof body.category === 'string') {
+    toDelete = files.filter((f) => f.category === body.category).map((f) => f.name)
+  } else {
+    return NextResponse.json({ error: 'Provide filenames, olderThanDays, category, or all' }, { status: 400 })
+  }
+
+  let deleted = 0
+  let freedBytes = 0
+  for (const name of toDelete) {
+    const filePath = path.join(UPLOAD_DIR, name)
+    try {
+      const stat = fs.statSync(filePath)
+      fs.unlinkSync(filePath)
+      freedBytes += stat.size
+      deleted++
+    } catch {
+      // file already gone or inaccessible
+    }
+  }
+
+  return NextResponse.json({ deleted, freedBytes })
+}

package/src/app/api/webhooks/[id]/route.ts

@@ -1,8 +1,11 @@
 import { genId } from '@/lib/id'
+import { timingSafeEqual } from 'node:crypto'
 import { NextResponse } from 'next/server'
 import { loadAgents, loadSessions, loadWebhooks, saveSessions, saveWebhooks, appendWebhookLog, upsertWebhookRetry } from '@/lib/server/storage'
 import { WORKSPACE_DIR } from '@/lib/server/data-dir'
 import { enqueueSessionRun } from '@/lib/server/session-run-manager'
+import { enqueueSystemEvent } from '@/lib/server/system-events'
+import { requestHeartbeatNow } from '@/lib/server/heartbeat-wake'
 import { mutateItem, deleteItem, notFound, type CollectionOps } from '@/lib/server/collection-helpers'
 import type { WebhookRetryEntry } from '@/types'
 
@@ -71,7 +74,12 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   if (secret) {
     const url = new URL(req.url)
     const provided = req.headers.get('x-webhook-secret') || url.searchParams.get('secret') || ''
-    if (provided !== secret) {
+    const secretBuf = Buffer.from(secret)
+    const providedBuf = Buffer.from(provided)
+    // timingSafeEqual requires equal lengths; compare against secretBuf if lengths differ
+    const compareBuf = providedBuf.length === secretBuf.length ? providedBuf : secretBuf
+    const isInvalid = providedBuf.length !== secretBuf.length || !timingSafeEqual(secretBuf, compareBuf)
+    if (isInvalid) {
       appendWebhookLog(genId(8), {
         id: genId(8), webhookId: id, event: 'unknown',
         payload: '', status: 'error', error: 'Invalid webhook secret', timestamp: Date.now(),
@@ -193,6 +201,12 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
       mode: 'followup',
     })
 
+    // Enqueue system event + heartbeat wake
+    enqueueSystemEvent(sid, `Webhook received: ${webhook.name || id} (${incomingEvent})`)
+    if (webhook.agentId) {
+      requestHeartbeatNow({ agentId: webhook.agentId, reason: 'webhook' })
+    }
+
     appendWebhookLog(genId(8), {
       id: genId(8), webhookId: id, event: incomingEvent,
       payload: (rawBody || '').slice(0, 2000), status: 'success',

package/src/app/globals.css

@@ -49,16 +49,17 @@
   --radius-4xl: calc(var(--radius) + 16px);
 
   /* ===== Midnight Glass Palette ===== */
-  --color-bg: #08080d;
-  --color-raised: #0d0d14;
-  --color-surface: #13131e;
-  --color-surface-2: #1e1e30;
-  --color-surface-3: #23233a;
+  /* Surfaces derived from --neutral-tint for single-knob theming */
+  --color-bg: color-mix(in srgb, var(--neutral-tint, #1e1e30) 40%, #000);
+  --color-raised: color-mix(in srgb, var(--neutral-tint, #1e1e30) 50%, #000);
+  --color-surface: color-mix(in srgb, var(--neutral-tint, #1e1e30) 65%, #000);
+  --color-surface-2: var(--neutral-tint, #1e1e30);
+  --color-surface-3: color-mix(in srgb, var(--neutral-tint, #1e1e30) 80%, #333);
   --color-border-hi: rgba(255,255,255,0.07);
   --color-border-focus: rgba(99,102,241,0.5);
   --color-text: #e2e2ec;
-  --color-text-2: #8e8ea8;
-  --color-text-3: #5c5c78;
+  --color-text-2: #a0a0ba;
+  --color-text-3: #8282a0;
   --color-accent-soft: rgba(99,102,241,0.08);
   --color-accent-glow: rgba(99,102,241,0.18);
   --color-accent-bright: #818CF8;
@@ -83,25 +84,29 @@
   --font-sora: 'Segoe UI';
   --font-jetbrains-mono: 'SF Mono';
   --radius: 0.625rem;
-  --background: #08080d;
+
+  /* ===== Single-Tint Theming ===== */
+  /* Change this one value to shift the entire palette hue */
+  --neutral-tint: #1e1e30;
+  --background: color-mix(in srgb, var(--neutral-tint) 40%, #000);
   --foreground: #e2e2ec;
-  --card: #0d0d14;
+  --card: color-mix(in srgb, var(--neutral-tint) 50%, #000);
   --card-foreground: #e2e2ec;
-  --popover: #0d0d14;
+  --popover: color-mix(in srgb, var(--neutral-tint) 50%, #000);
   --popover-foreground: #e2e2ec;
   --primary: #6366F1;
   --primary-foreground: #ffffff;
-  --secondary: #13131e;
+  --secondary: color-mix(in srgb, var(--neutral-tint) 65%, #000);
   --secondary-foreground: #e2e2ec;
-  --muted: #13131e;
-  --muted-foreground: #8e8ea8;
+  --muted: color-mix(in srgb, var(--neutral-tint) 65%, #000);
+  --muted-foreground: #a0a0ba;
   --accent: #6366F1;
   --accent-foreground: #ffffff;
   --destructive: #F43F5E;
   --border: rgba(255,255,255,0.04);
   --input: rgba(255,255,255,0.04);
   --ring: rgba(99,102,241,0.4);
-  --sidebar: #0d0d14;
+  --sidebar: color-mix(in srgb, var(--neutral-tint) 50%, #000);
   --sidebar-foreground: #e2e2ec;
   --sidebar-primary: #6366F1;
   --sidebar-primary-foreground: #ffffff;
@@ -113,7 +118,7 @@
   /* ===== Status Badge System ===== */
   --status-idle-bg: rgba(255,255,255,0.04);
   --status-idle-border: rgba(255,255,255,0.06);
-  --status-idle-fg: #8e8ea8;
+  --status-idle-fg: #a0a0ba;
   --status-running-bg: rgba(52,211,153,0.08);
   --status-running-border: rgba(52,211,153,0.15);
   --status-running-fg: #34D399;
@@ -205,6 +210,10 @@ textarea:hover::-webkit-scrollbar { width: 6px; }
   from { opacity: 0; transform: scale(0.97) translateY(6px); }
   to { opacity: 1; transform: scale(1) translateY(0); }
 }
+@keyframes msg-in {
+  from { opacity: 0; transform: translateY(6px); }
+  to { opacity: 1; transform: translateY(0); }
+}
 @keyframes spin { to { transform: rotate(360deg); } }
 @keyframes slide-in-left {
   from { transform: translateX(-100%); }
@@ -243,6 +252,35 @@ textarea:hover::-webkit-scrollbar { width: 6px; }
   to { opacity: 1; transform: translateY(0); }
 }
 
+/* Heartbeat float animation */
+@keyframes heartbeat-float {
+  0% { opacity: 1; transform: translateY(0) scale(1); }
+  50% { opacity: 0.7; transform: translateY(-14px) scale(1.15); }
+  100% { opacity: 0; transform: translateY(-26px) scale(0.85); }
+}
+
+/* Activity moment animations */
+@keyframes activity-moment-in {
+  from { opacity: 0; transform: translateY(6px) scale(0.92); }
+  to { opacity: 1; transform: translateY(0) scale(1); }
+}
+@keyframes activity-moment-out {
+  from { opacity: 1; transform: translateY(0) scale(1); }
+  to { opacity: 0; transform: translateY(-8px) scale(0.95); }
+}
+
+@keyframes delegation-handoff-in {
+  0% { opacity: 0; transform: translateX(16px) scale(0.95); }
+  100% { opacity: 1; transform: translateX(0) scale(1); }
+}
+
+@keyframes avatar-moment-pulse {
+  0% { transform: scale(1); }
+  30% { transform: scale(1.15); }
+  60% { transform: scale(0.95); }
+  100% { transform: scale(1); }
+}
+
 /* AI avatar mood animations */
 @keyframes ai-pulse { 0%,100% { transform: scale(1); } 50% { transform: scale(1.15); } }
 @keyframes ai-glow { 0%,100% { box-shadow: 0 0 0 0 rgba(99,102,241,0); } 50% { box-shadow: 0 0 12px 4px rgba(99,102,241,0.35); } }
@@ -414,6 +452,16 @@ textarea:hover::-webkit-scrollbar { width: 6px; }
   font-family: var(--font-sora), 'Sora', system-ui, sans-serif;
 }
 
+/* Monospace micro-label utility */
+.label-mono {
+  font-family: var(--font-mono);
+  font-size: 10px;
+  font-weight: 600;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--color-text-3);
+}
+
 /* ===== Status Badge Classes ===== */
 .status-badge-idle, .status-badge-running, .status-badge-error,
 .status-badge-connecting, .status-badge-connected, .status-badge-disconnected,