@swarmclawai/swarmclaw 0.9.0 → 0.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Self-hosted AI agent orchestration dashboard — manage LLM providers, orchestrate agent swarms, schedule tasks, and bridge agents to chat platforms.",
   "license": "MIT",
   "publishConfig": {

package/src/lib/server/chat-execution/chat-execution-utils.test.ts

@@ -82,11 +82,12 @@ describe('shouldPersistInboundUserMessage', () => {
     assert.equal(shouldPersistInboundUserMessage(false, 'connector'), true)
   })
 
-  it('returns true for internal eval messages', () => {
+  it('returns true for internal eval and subagent messages', () => {
     assert.equal(shouldPersistInboundUserMessage(true, 'eval'), true)
+    assert.equal(shouldPersistInboundUserMessage(true, 'subagent'), true)
   })
 
-  it('returns false for internal non-eval messages', () => {
+  it('returns false for other internal messages', () => {
     assert.equal(shouldPersistInboundUserMessage(true, 'heartbeat'), false)
     assert.equal(shouldPersistInboundUserMessage(true, 'chat'), false)
     assert.equal(shouldPersistInboundUserMessage(true, 'daemon'), false)

package/src/lib/server/chat-execution/chat-execution-utils.ts

@@ -40,7 +40,7 @@ export function shouldAutoRouteHeartbeatAlerts(config?: {
 
 export function shouldPersistInboundUserMessage(internal: boolean, source: string): boolean {
   if (!internal) return true
-  return source === 'eval'
+  return source === 'eval' || source === 'subagent'
 }
 
 function escapeRegExp(value: string): string {

package/src/lib/server/connectors/whatsapp.test.ts

@@ -8,6 +8,7 @@ import {
   normalizeWhatsAppAudioForSend,
   normalizeWhatsAppIdentifier,
   resolveWhatsAppAllowedIdentifiers,
+  sendWhatsAppTypingPresence,
 } from './whatsapp'
 import { normalizeE164, normalizeWhatsappTarget } from './response-media'
 
@@ -145,6 +146,29 @@ test('isWhatsAppSocketAlive keeps QR and active sessions marked live', () => {
   }), true)
 })
 
+test('sendWhatsAppTypingPresence sends composing updates for the target jid', async () => {
+  const calls: Array<{ state: string; jid: string }> = []
+  await sendWhatsAppTypingPresence({
+    socket: {
+      sendPresenceUpdate: async (state, jid) => {
+        calls.push({ state, jid })
+      },
+    },
+    channelId: '15550001111@s.whatsapp.net',
+  })
+
+  assert.deepEqual(calls, [
+    { state: 'composing', jid: '15550001111@s.whatsapp.net' },
+  ])
+})
+
+test('sendWhatsAppTypingPresence ignores empty targets and missing sockets', async () => {
+  await sendWhatsAppTypingPresence({
+    socket: null,
+    channelId: '   ',
+  })
+})
+
 test('normalizeWhatsAppAudioForSend transcodes mp3 voice notes to Android-safe opus/ogg', () => {
   let transcodeCalls = 0
   const converted = normalizeWhatsAppAudioForSend({

package/src/lib/server/connectors/whatsapp.ts

@@ -41,6 +41,10 @@ type WhatsAppSocketState = {
   } | null
 } | null
 
+type WhatsAppPresenceSocket = {
+  sendPresenceUpdate?: (state: 'composing' | 'paused', jid: string) => Promise<unknown>
+} | null
+
 export function buildWhatsAppTextPayloads(text: string): Array<{ text: string; linkPreview: null }> {
   const chunks = text.length <= WHATSAPP_SINGLE_MESSAGE_MAX
     ? [text]
@@ -68,6 +72,17 @@ export function isWhatsAppSocketAlive(params: {
   return params.connectionState == null
 }
 
+export async function sendWhatsAppTypingPresence(params: {
+  socket: WhatsAppPresenceSocket
+  channelId: string
+}): Promise<void> {
+  const channelId = String(params.channelId || '').trim()
+  if (!channelId) return
+  const sendPresenceUpdate = params.socket?.sendPresenceUpdate
+  if (typeof sendPresenceUpdate !== 'function') return
+  await sendPresenceUpdate('composing', channelId)
+}
+
 function normalizeMimeType(mimeType?: string): string {
   return String(mimeType || '').toLowerCase().split(';')[0].trim()
 }
@@ -438,6 +453,9 @@ const whatsapp: PlatformConnector = {
         }
         return { messageId: lastMessageId }
       },
+      async sendTyping(channelId) {
+        await sendWhatsAppTypingPresence({ socket: sock as WhatsAppPresenceSocket, channelId })
+      },
       async stop() {
         stopped = true
         connectionState = 'close'
@@ -652,9 +670,7 @@ const whatsapp: PlatformConnector = {
           console.log(`[whatsapp] Message from ${inbound.senderName} (${jid}): ${inbound.text.slice(0, 80)}`)
 
           try {
-            await sock!.sendPresenceUpdate('composing', jid)
             const reply = await resolveConnectorIngressReply(onMessage, inbound)
-            await sock!.sendPresenceUpdate('paused', jid)
             if (!reply) continue
 
             const sent = await instance.sendMessage?.(jid, reply.visibleText)

package/src/lib/server/runtime/heartbeat-wake.ts

@@ -17,6 +17,7 @@ import {
   enqueueSessionRun,
   getSessionExecutionState,
   hasActiveNonHeartbeatSessionLease,
+  repairSessionRunQueue,
 } from '@/lib/server/runtime/session-run-manager'
 import { log } from '@/lib/server/logger'
 import { isAgentDisabled } from '@/lib/server/agents/agent-availability'
@@ -301,8 +302,16 @@ function flushWakes(): void {
       const session = (sessions[sessionId] || loadSessions()[sessionId]) as Record<string, unknown> | undefined
       if (!session) continue
 
-      const execution = getSessionExecutionState(sessionId)
+      let execution = getSessionExecutionState(sessionId)
       const sharedNonHeartbeatBusy = hasActiveNonHeartbeatSessionLease(sessionId)
+      if (execution.hasQueued && !execution.hasRunning && !sharedNonHeartbeatBusy) {
+        const repair = repairSessionRunQueue(sessionId, {
+          reason: 'Recovered stale queued run before heartbeat wake',
+        })
+        if (repair.recoveredQueuedRuns > 0 || repair.kickedExecutionKeys > 0) {
+          execution = getSessionExecutionState(sessionId)
+        }
+      }
       if (execution.hasRunning || execution.hasQueued || sharedNonHeartbeatBusy) {
         queuePendingWakeRequest({
           ...wake,

package/src/lib/server/runtime/session-run-manager.test.ts

@@ -32,6 +32,29 @@ type RuntimeState = {
   activityLeaseRenewTimers?: Map<string, ReturnType<typeof setInterval>>
 }
 
+type ManualQueueEntry = {
+  executionKey: string
+  run: {
+    id: string
+    sessionId: string
+    source: string
+    internal: boolean
+    mode: 'followup' | 'steer' | 'collect'
+    status: 'queued' | 'running' | 'completed' | 'failed' | 'cancelled'
+    messagePreview: string
+    queuedAt: number
+    startedAt?: number
+    endedAt?: number
+    error?: string
+  }
+  message: string
+  onEvents: Array<(event: unknown) => void>
+  signalController: AbortController
+  resolve: (value: unknown) => void
+  reject: (error: Error) => void
+  promise: Promise<unknown>
+}
+
 /** Pending promises from fire-and-forget drain calls. We suppress their
  *  rejections and await them in afterEach so node:test doesn't see
  *  "asynchronous activity after the test ended" warnings. */
@@ -54,6 +77,54 @@ function resetState() {
   }
 }
 
+function getRuntimeState(): RuntimeState {
+  return (globalThis as Record<string, unknown>)[globalKey] as RuntimeState
+}
+
+function makeManualQueuedEntry(input: {
+  sessionId: string
+  runId: string
+  message: string
+  source?: string
+  internal?: boolean
+  queuedAt?: number
+}): { entry: ManualQueueEntry; promise: Promise<unknown> } {
+  let resolve!: (value: unknown) => void
+  let reject!: (error: Error) => void
+  const promise = new Promise<unknown>((res, rej) => {
+    resolve = res
+    reject = rej
+  })
+  const entry: ManualQueueEntry = {
+    executionKey: `session:${input.sessionId}`,
+    run: {
+      id: input.runId,
+      sessionId: input.sessionId,
+      source: input.source || 'chat',
+      internal: input.internal === true,
+      mode: input.internal ? 'collect' : 'followup',
+      status: 'queued',
+      messagePreview: input.message,
+      queuedAt: input.queuedAt ?? Date.now(),
+    },
+    message: input.message,
+    onEvents: [],
+    signalController: new AbortController(),
+    resolve,
+    reject,
+    promise,
+  }
+  return { entry, promise }
+}
+
+function insertManualQueuedEntry(entry: ManualQueueEntry, promise: Promise<unknown>) {
+  const state = getRuntimeState()
+  state.queueByExecution.set(entry.executionKey, [entry as unknown])
+  state.runs.set(entry.run.id, entry.run)
+  state.recentRunIds.push(entry.run.id)
+  state.promises.set(entry.run.id, promise)
+}
+
 /** Wrapper around enqueueSessionRun that captures the run promise to
  *  prevent async-after-test warnings from node:test. */
 function enqueue(input: Parameters<typeof mgr.enqueueSessionRun>[0]) {
@@ -663,6 +734,66 @@ describe('session-run-manager', () => {
       assert.ok(finished)
       assert.notEqual(finished.status, 'queued')
     })
+
+    it('re-kicks a recent queued entry when the execution lane is idle', async () => {
+      seedSession('sess-rekick')
+      const runId = 'manual-rekick'
+      const { entry, promise } = makeManualQueuedEntry({
+        sessionId: 'sess-rekick',
+        runId,
+        message: 'recover me',
+      })
+      insertManualQueuedEntry(entry, promise)
+
+      const repair = mgr.repairSessionRunQueue('sess-rekick')
+      assert.equal(repair.recoveredQueuedRuns, 0)
+      assert.equal(repair.kickedExecutionKeys, 1)
+
+      await promise.catch(() => {})
+
+      const run = mgr.getRunById(runId)
+      assert.ok(run)
+      assert.notEqual(run.status, 'queued')
+    })
+
+    it('recovers stale queued runs before a fresh enqueue can get wedged behind them', async () => {
+      seedSession('sess-stale-recover')
+      const staleRunId = 'manual-stale'
+      const { entry, promise } = makeManualQueuedEntry({
+        sessionId: 'sess-stale-recover',
+        runId: staleRunId,
+        message: 'ghost queued run',
+        queuedAt: Date.now() - 60_000,
+      })
+      insertManualQueuedEntry(entry, promise)
+
+      const fresh = enqueue({
+        sessionId: 'sess-stale-recover',
+        message: 'fresh message',
+      })
+
+      const staleResult = await promise
+      assert.deepEqual(staleResult, {
+        runId: staleRunId,
+        sessionId: 'sess-stale-recover',
+        text: '',
+        persisted: false,
+        toolEvents: [],
+        error: 'Recovered stale queued run before enqueue',
+      })
+
+      const staleRun = mgr.getRunById(staleRunId)
+      assert.ok(staleRun)
+      assert.equal(staleRun.status, 'failed')
+
+      const execution = mgr.getSessionExecutionState('sess-stale-recover')
+      assert.ok(execution.queueLength <= 1, `expected stale run to be cleared, got queueLength=${execution.queueLength}`)
+
+      await fresh.promise.catch(() => {})
+      const freshRun = mgr.getRunById(fresh.runId)
+      assert.ok(freshRun)
+      assert.notEqual(freshRun.status, 'queued')
+    })
   })
 
   describe('cancelAllHeartbeatRuns', () => {

package/src/lib/server/runtime/session-run-manager.ts

@@ -74,6 +74,7 @@ const COLLECT_COALESCE_WINDOW_MS = 1500
 const SHARED_ACTIVITY_LEASE_TTL_MS = 15_000
 const SHARED_ACTIVITY_LEASE_RENEW_MS = 5_000
 const HEARTBEAT_BUSY_RETRY_MS = 1_000
+const STALE_QUEUED_RUN_MS = 15_000
 const SHARED_ACTIVITY_LEASE_OWNER = `session-run:${process.pid}:${genId(6)}`
 const state: RuntimeState = hmrSingleton<RuntimeState>('__swarmclaw_session_run_manager__', () => ({
   runningByExecution: new Map<string, QueueEntry>(),
@@ -212,6 +213,13 @@ function clearDeferredDrain(executionKey: string): void {
   state.deferredDrainTimers.delete(executionKey)
 }
 
+function deleteQueueEntry(queue: QueueEntry[], target: QueueEntry): boolean {
+  const idx = queue.indexOf(target)
+  if (idx === -1) return false
+  queue.splice(idx, 1)
+  return true
+}
+
 function scheduleDeferredDrain(executionKey: string, delayMs = HEARTBEAT_BUSY_RETRY_MS): void {
   if (state.deferredDrainTimers.has(executionKey)) return
   const timer = setTimeout(() => {
@@ -249,6 +257,99 @@ function reconcileSessionActivityLease(sessionId: string): void {
   else stopSessionActivityLease(sessionId)
 }
 
+function resolveRecoveredQueuedEntry(entry: QueueEntry, reason: string): void {
+  if (entry.run.status === 'completed' || entry.run.status === 'failed' || entry.run.status === 'cancelled') {
+    entry.run.endedAt = entry.run.endedAt || now()
+  } else {
+    entry.run.status = 'failed'
+    entry.run.endedAt = now()
+  }
+  entry.run.error = reason
+  emitToSubscribers(entry, { t: 'err', text: reason })
+  emitRunMeta(entry, 'failed', {
+    error: reason,
+    recovered: true,
+  })
+  entry.resolve({
+    runId: entry.run.id,
+    sessionId: entry.run.sessionId,
+    text: '',
+    persisted: false,
+    toolEvents: [],
+    error: reason,
+  })
+}
+
+export function repairSessionRunQueue(
+  sessionId: string,
+  opts?: {
+    executionKey?: string
+    maxQueuedAgeMs?: number
+    reason?: string
+  },
+): {
+  kickedExecutionKeys: number
+  recoveredQueuedRuns: number
+} {
+  const maxQueuedAgeMs = Math.max(1_000, opts?.maxQueuedAgeMs ?? STALE_QUEUED_RUN_MS)
+  const reason = opts?.reason || 'Recovered stale queued run'
+  const targetExecutionKey = typeof opts?.executionKey === 'string' && opts.executionKey.trim()
+    ? opts.executionKey.trim()
+    : null
+  const queuedNow = now()
+  let kickedExecutionKeys = 0
+  let recoveredQueuedRuns = 0
+
+  for (const [executionKey, queue] of state.queueByExecution.entries()) {
+    if (targetExecutionKey && executionKey !== targetExecutionKey) continue
+    if (!queue.length) {
+      clearDeferredDrain(executionKey)
+      state.queueByExecution.delete(executionKey)
+      continue
+    }
+    if (state.runningByExecution.has(executionKey)) continue
+
+    const matching = queue.filter((entry) => entry.run.sessionId === sessionId)
+    if (!matching.length) continue
+
+    for (const entry of [...matching]) {
+      const missingPromise = !state.promises.has(entry.run.id)
+      const previousStatus = entry.run.status
+      const nonQueued = previousStatus !== 'queued'
+      const ageMs = Math.max(0, queuedNow - (entry.run.queuedAt || 0))
+      const stale = nonQueued || missingPromise || ageMs >= maxQueuedAgeMs
+      if (!stale) continue
+      if (!deleteQueueEntry(queue, entry)) continue
+      clearDeferredDrain(executionKey)
+      resolveRecoveredQueuedEntry(entry, reason)
+      recoveredQueuedRuns += 1
+      log.warn('session-run', `Recovered stale queued run ${entry.run.id}`, {
+        sessionId: entry.run.sessionId,
+        executionKey,
+        source: entry.run.source,
+        ageMs,
+        missingPromise,
+        previousStatus,
+      })
+    }
+
+    if (!queue.length) {
+      clearDeferredDrain(executionKey)
+      state.queueByExecution.delete(executionKey)
+      continue
+    }
+
+    if (queue.some((entry) => entry.run.sessionId === sessionId)) {
+      clearDeferredDrain(executionKey)
+      kickedExecutionKeys += 1
+      void drainExecution(executionKey)
+    }
+  }
+
+  if (recoveredQueuedRuns > 0) reconcileSessionActivityLease(sessionId)
+  return { kickedExecutionKeys, recoveredQueuedRuns }
+}
+
 function cancelPendingForSession(sessionId: string, reason: string): number {
   let cancelled = 0
   for (const [key, queue] of state.queueByExecution.entries()) {
@@ -510,6 +611,10 @@ export function enqueueSessionRun(input: EnqueueSessionRunInput): EnqueueSession
   const executionKey = typeof input.executionGroupKey === 'string' && input.executionGroupKey.trim()
     ? input.executionGroupKey.trim()
     : executionKeyForSession(input.sessionId)
+  repairSessionRunQueue(input.sessionId, {
+    executionKey,
+    reason: 'Recovered stale queued run before enqueue',
+  })
   const runtime = loadRuntimeSettings()
   const defaultMaxRuntimeMs = runtime.ongoingLoopMaxRuntimeMs ?? (10 * 60_000)
   const sessionData = loadSession(input.sessionId) as SessionToolConfig | null

package/src/lib/server/sandbox/session-runtime.test.ts

@@ -1,6 +1,7 @@
 import assert from 'node:assert/strict'
 import test from 'node:test'
 import { resolveSandboxRuntimeStatus, resolveSandboxWorkdir } from '@/lib/server/sandbox/session-runtime'
+import type { Session } from '@/types'
 
 test('resolveSandboxRuntimeStatus defaults enabled sandboxes to all sessions', () => {
   const status = resolveSandboxRuntimeStatus({
@@ -9,7 +10,7 @@ test('resolveSandboxRuntimeStatus defaults enabled sandboxes to all sessions', (
       id: 'session-1',
       agentId: 'agent-1',
       parentSessionId: 'parent-1',
-    } as any,
+    } as Session,
   })
 
   assert.equal(status.mode, 'all')
@@ -25,7 +26,7 @@ test('resolveSandboxRuntimeStatus skips the main session in non-main mode', () =
       id: 'main-session',
       agentId: 'agent-1',
       heartbeatEnabled: true,
-    } as any,
+    } as Session,
   })
 
   assert.equal(status.mode, 'non-main')
@@ -40,7 +41,7 @@ test('resolveSandboxRuntimeStatus sandboxes child sessions in non-main mode', ()
       id: 'child-session',
       agentId: 'agent-1',
       parentSessionId: 'main-session',
-    } as any,
+    } as Session,
   })
 
   assert.equal(status.sandboxed, true)

package/src/lib/server/storage.ts

@@ -244,17 +244,18 @@ function getCollectionRawCache(table: string): LRUMap<string, string> {
 }
 
 function loadCollectionWithNormalizationState(table: string): {
-  result: Record<string, any>
+  result: Record<string, StoredObject>
   normalizedCount: number
 } {
   const endPerf = perf.start('storage', 'loadCollection', { table })
   const raw = getCollectionRawCache(table)
-  const result: Record<string, any> = {}
+  const result: Record<string, StoredObject> = {}
   let normalizedCount = 0
   for (const [id, data] of raw.entries()) {
     try {
       const normalized = normalizeStoredRecord(table, JSON.parse(data))
-      result[id] = normalized
+      if (!normalized || typeof normalized !== 'object' || Array.isArray(normalized)) continue
+      result[id] = normalized as StoredObject
       if (JSON.stringify(normalized) !== data) normalizedCount += 1
     } catch {
       // Ignore malformed records instead of crashing list endpoints.
@@ -301,11 +302,11 @@ function normalizeStoredRecord(table: string, value: unknown): unknown {
   return session
 }
 
-function loadCollection(table: string): Record<string, any> {
+function loadCollection(table: string): Record<string, StoredObject> {
   return loadCollectionWithNormalizationState(table).result
 }
 
-function saveCollection(table: string, data: Record<string, any>) {
+function saveCollection(table: string, data: Record<string, unknown>) {
   const endPerf = perf.start('storage', 'saveCollection', { table })
   const current = getCollectionRawCache(table)
   const next = new Map<string, string>()