@swarmclawai/swarmclaw 0.7.7 → 0.8.0

package/src/lib/server/scheduler.ts

@@ -7,6 +7,7 @@ import { getScheduleSignatureKey } from '@/lib/schedule-dedupe'
 import { enqueueSystemEvent } from './system-events'
 import { requestHeartbeatNow } from './heartbeat-wake'
 import { processDueWatchJobs } from './watch-jobs'
+import { isAgentDisabled } from './agent-availability'
 
 const TICK_INTERVAL = 60_000 // 60 seconds
 let intervalId: ReturnType<typeof setInterval> | null = null
@@ -32,6 +33,11 @@ interface SchedulerScheduleLike {
   runNumber?: number
   createdInSessionId?: string | null
   createdByAgentId?: string | null
+  followupConnectorId?: string | null
+  followupChannelId?: string | null
+  followupThreadId?: string | null
+  followupSenderId?: string | null
+  followupSenderName?: string | null
 }
 
 export function startScheduler() {
@@ -123,6 +129,16 @@ async function tick() {
       })
       continue
     }
+    if (isAgentDisabled(agent)) {
+      console.warn(`[scheduler] Skipping schedule "${schedule.name}" (${schedule.id}) because agent ${schedule.agentId} is disabled`)
+      advanceSchedule(schedule)
+      saveSchedules(schedules)
+      pushMainLoopEventToMainSessions({
+        type: 'schedule_skipped',
+        text: `Schedule skipped: "${schedule.name}" (${schedule.id}) — agent ${schedule.agentId} is disabled.`,
+      })
+      continue
+    }
 
     console.log(`[scheduler] Firing schedule "${schedule.name}" (${schedule.id})`)
     schedule.lastRunAt = now
@@ -185,6 +201,11 @@ async function tick() {
         sourceScheduleKey: scheduleSignature || null,
         createdInSessionId: schedule.createdInSessionId || null,
         createdByAgentId: schedule.createdByAgentId || null,
+        followupConnectorId: schedule.followupConnectorId || null,
+        followupChannelId: schedule.followupChannelId || null,
+        followupThreadId: schedule.followupThreadId || null,
+        followupSenderId: schedule.followupSenderId || null,
+        followupSenderName: schedule.followupSenderName || null,
         runNumber: schedule.runNumber,
       }
       schedule.linkedTaskId = taskId
@@ -204,6 +225,13 @@ async function tick() {
     if (schedule.createdInSessionId) {
       enqueueSystemEvent(schedule.createdInSessionId, `Schedule triggered: ${schedule.name}`)
     }
-    requestHeartbeatNow({ agentId: schedule.agentId, reason: 'schedule' })
+    requestHeartbeatNow({
+      agentId: schedule.agentId,
+      eventId: `${schedule.id}:${schedule.runNumber}`,
+      reason: 'schedule',
+      source: `schedule:${schedule.id}`,
+      resumeMessage: `Schedule triggered: ${schedule.name}`,
+      detail: `Run #${schedule.runNumber} queued task ${taskId}.`,
+    })
   }
 }

package/src/lib/server/session-note.test.ts

@@ -0,0 +1,36 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { buildSessionNoteMessage } from './session-note'
+
+test('buildSessionNoteMessage defaults to assistant/system note metadata', () => {
+  const result = buildSessionNoteMessage({
+    text: 'Live test passed',
+  })
+
+  assert.ok(result)
+  assert.equal(result?.role, 'assistant')
+  assert.equal(result?.kind, 'system')
+  assert.equal(result?.text, 'Live test passed')
+  assert.equal(typeof result?.time, 'number')
+})
+
+test('buildSessionNoteMessage trims text and preserves explicit role/kind', () => {
+  const result = buildSessionNoteMessage({
+    text: '  Visible smoke report  ',
+    role: 'user',
+    kind: 'chat',
+    time: 123,
+  })
+
+  assert.deepEqual(result, {
+    role: 'user',
+    kind: 'chat',
+    text: 'Visible smoke report',
+    time: 123,
+  })
+})
+
+test('buildSessionNoteMessage returns null for empty text', () => {
+  assert.equal(buildSessionNoteMessage({ text: '   ' }), null)
+})

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

@@ -0,0 +1,42 @@
+import type { Message, MessageToolEvent } from '@/types'
+import { loadSessions, saveSessions } from './storage'
+import { notify } from './ws-hub'
+
+export interface SessionNoteInput {
+  sessionId: string
+  text: string
+  role?: Message['role']
+  kind?: Message['kind']
+  toolEvents?: MessageToolEvent[]
+  time?: number
+}
+
+export function buildSessionNoteMessage(input: Omit<SessionNoteInput, 'sessionId'>): Message | null {
+  const trimmed = String(input.text || '').trim()
+  if (!trimmed) return null
+  return {
+    role: input.role || 'assistant',
+    kind: input.kind || 'system',
+    text: trimmed,
+    time: typeof input.time === 'number' && Number.isFinite(input.time) ? input.time : Date.now(),
+    ...(Array.isArray(input.toolEvents) && input.toolEvents.length ? { toolEvents: input.toolEvents } : {}),
+  }
+}
+
+export function appendSessionNote(input: SessionNoteInput): Message | null {
+  const sessions = loadSessions()
+  const session = sessions[input.sessionId]
+  if (!session) return null
+  if (!Array.isArray(session.messages)) session.messages = []
+
+  const next = buildSessionNoteMessage(input)
+  if (!next) return null
+
+  session.messages.push(next)
+  session.lastActiveAt = next.time
+  sessions[input.sessionId] = session
+  saveSessions(sessions)
+  notify('sessions')
+  notify(`messages:${input.sessionId}`)
+  return next
+}

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

@@ -7,6 +7,7 @@ import { log } from './logger'
 import { isInternalHeartbeatRun } from './heartbeat-source'
 import { cleanupSessionBrowser } from './session-tools/web'
 import { cancelDelegationJobsForParentSession } from './delegation-jobs'
+import { handleMainLoopRunResult } from './main-agent-loop'
 
 export type SessionRunStatus = 'queued' | 'running' | 'completed' | 'failed' | 'cancelled'
 export type SessionQueueMode = 'followup' | 'steer' | 'collect'
@@ -218,7 +219,10 @@ export function cancelAllHeartbeatRuns(reason = 'Heartbeat disabled globally'):
 async function drainExecution(executionKey: string): Promise<void> {
   if (state.runningByExecution.has(executionKey)) return
   const q = queueForExecution(executionKey)
-  const next = q.shift()
+  // Priority: user (non-heartbeat) runs go first. If a heartbeat is queued
+  // behind a user run, the user run takes priority.
+  const userIdx = q.findIndex(e => !isInternalHeartbeatRun(e.run.internal, e.run.source))
+  const next = userIdx >= 0 ? q.splice(userIdx, 1)[0] : q.shift()
   if (!next) return
 
   state.runningByExecution.set(executionKey, next)
@@ -276,6 +280,36 @@ async function drainExecution(executionKey: string): Promise<void> {
       error: next.run.error || null,
       durationMs: (next.run.endedAt || now()) - (next.run.startedAt || now()),
     })
+    const followup = handleMainLoopRunResult({
+      sessionId: next.run.sessionId,
+      message: next.message,
+      internal: next.run.internal,
+      source: next.run.source,
+      resultText: result.text,
+      error: next.run.error,
+      toolEvents: result.toolEvents,
+      inputTokens: result.inputTokens,
+      outputTokens: result.outputTokens,
+      estimatedCost: result.estimatedCost,
+    })
+    if (followup) {
+      setTimeout(() => {
+        try {
+          enqueueSessionRun({
+            sessionId: next.run.sessionId,
+            message: followup.message,
+            internal: true,
+            source: 'main-loop-followup',
+            mode: 'followup',
+            dedupeKey: followup.dedupeKey,
+          })
+        } catch (err: unknown) {
+          log.warn('session-run', `Main loop follow-up enqueue failed for ${next.run.sessionId}`, {
+            error: err instanceof Error ? err.message : String(err),
+          })
+        }
+      }, Math.max(0, followup.delayMs || 0))
+    }
     next.resolve(result)
   } catch (err: any) {
     const aborted = next.signalController.signal.aborted
@@ -385,6 +419,18 @@ export function enqueueSessionRun(input: EnqueueSessionRunInput): EnqueueSession
     cancelPendingForSession(input.sessionId, 'Cancelled by steer mode')
   }
 
+  // Heartbeat preemption: if a user chat arrives while a heartbeat is running,
+  // abort the heartbeat so the user doesn't wait. The heartbeat will retry
+  // on the next tick.
+  if (!internal && source === 'chat') {
+    const running = state.runningByExecution.get(executionKey)
+    if (running && isInternalHeartbeatRun(running.run.internal, running.run.source)) {
+      log.info('session-run', `Preempting heartbeat ${running.run.id} for user chat on ${input.sessionId}`)
+      abortSessionRuntime(running, 'Preempted by user chat')
+      state.runningByExecution.delete(executionKey)
+    }
+  }
+
   const running = state.runningByExecution.get(executionKey)
   const q = queueForExecution(executionKey)
   if (mode === 'collect' && !input.imagePath && !input.imageUrl && !input.attachedFiles?.length) {
@@ -475,15 +521,48 @@ export function enqueueSessionRun(input: EnqueueSessionRunInput): EnqueueSession
 export function getSessionRunState(sessionId: string): {
   runningRunId?: string
   queueLength: number
+} {
+  const summary = getSessionExecutionState(sessionId)
+  return {
+    runningRunId: summary.runningRunId,
+    queueLength: summary.queueLength,
+  }
+}
+
+export function getSessionExecutionState(sessionId: string): {
+  runningRunId?: string
+  queueLength: number
+  hasRunning: boolean
+  hasQueued: boolean
+  hasRunningHeartbeat: boolean
+  hasQueuedHeartbeat: boolean
+  hasRunningNonHeartbeat: boolean
+  hasQueuedNonHeartbeat: boolean
 } {
   const executionKey = executionKeyForSession(sessionId)
   const running = state.runningByExecution.get(executionKey)
-  const queued = queueForExecution(executionKey).filter((entry) => entry.run.sessionId === sessionId).length
+  const runningMatchesSession = running?.run.sessionId === sessionId
+  const runningHeartbeat = Boolean(
+    runningMatchesSession
+    && isInternalHeartbeatRun(running.run.internal, running.run.source),
+  )
+  const runningNonHeartbeat = Boolean(runningMatchesSession && !runningHeartbeat)
+  const queuedEntries = queueForExecution(executionKey).filter((entry) => entry.run.sessionId === sessionId)
+  const queuedHeartbeat = queuedEntries.filter((entry) =>
+    isInternalHeartbeatRun(entry.run.internal, entry.run.source),
+  ).length
+  const queuedNonHeartbeat = queuedEntries.length - queuedHeartbeat
   return {
-    runningRunId: (running?.run.sessionId === sessionId && running.run.status === 'running')
+    runningRunId: (runningMatchesSession && running?.run.status === 'running')
       ? running.run.id
       : undefined,
-    queueLength: queued,
+    queueLength: queuedEntries.length,
+    hasRunning: Boolean(runningMatchesSession),
+    hasQueued: queuedEntries.length > 0,
+    hasRunningHeartbeat: runningHeartbeat,
+    hasQueuedHeartbeat: queuedHeartbeat > 0,
+    hasRunningNonHeartbeat: runningNonHeartbeat,
+    hasQueuedNonHeartbeat: queuedNonHeartbeat > 0,
   }
 }
 

package/src/lib/server/session-tools/canvas.ts

@@ -6,6 +6,7 @@ import type { ToolBuildContext } from './context'
 import type { Plugin, PluginHooks } from '@/types'
 import { getPluginManager } from '../plugins'
 import { normalizeToolInputArgs } from './normalize-tool-args'
+import { normalizeCanvasContent, summarizeCanvasContent } from '@/lib/canvas-content'
 
 /**
  * Core Canvas Execution Logic
@@ -14,6 +15,7 @@ async function executeCanvasAction(args: Record<string, unknown>, context: { ses
   const normalized = normalizeToolInputArgs(args)
   const action = normalized.action as string
   const content = normalized.content as string | undefined
+  const document = normalized.document
   try {
     const sessionId = context.sessionId
     if (!sessionId) return 'Error: no active session for canvas.'
@@ -23,13 +25,18 @@ async function executeCanvasAction(args: Record<string, unknown>, context: { ses
     if (!session) return 'Error: session not found.'
 
     if (action === 'present') {
-      if (!content) return 'Error: content is required for present action.'
-      ;(session as Record<string, unknown>).canvasContent = content
+      const nextContent = normalizeCanvasContent(document ?? content)
+      if (!nextContent) return 'Error: content or document is required for present action.'
+      ;(session as Record<string, unknown>).canvasContent = nextContent
       session.lastActiveAt = Date.now()
       sessions[sessionId] = session
       saveSessions(sessions)
       notify(`canvas:${sessionId}`)
-      return JSON.stringify({ ok: true, action: 'present', contentLength: content.length })
+      return JSON.stringify({
+        ok: true,
+        action: 'present',
+        ...summarizeCanvasContent(nextContent),
+      })
     }
 
     if (action === 'hide') {
@@ -42,14 +49,8 @@ async function executeCanvasAction(args: Record<string, unknown>, context: { ses
     }
 
     if (action === 'snapshot') {
-      const current = (session as Record<string, unknown>).canvasContent
-      return JSON.stringify({
-        ok: true,
-        action: 'snapshot',
-        hasContent: !!current,
-        contentLength: typeof current === 'string' ? current.length : 0,
-        preview: typeof current === 'string' ? current.slice(0, 500) : null,
-      })
+      const current = normalizeCanvasContent((session as Record<string, unknown>).canvasContent)
+      return JSON.stringify({ ok: true, action: 'snapshot', ...summarizeCanvasContent(current) })
     }
 
     return `Unknown canvas action "${action}".`
@@ -73,7 +74,8 @@ const CanvasPlugin: Plugin = {
         type: 'object',
         properties: {
           action: { type: 'string', enum: ['present', 'hide', 'snapshot'] },
-          content: { type: 'string' }
+          content: { type: 'string' },
+          document: { type: 'object', additionalProperties: true },
         },
         required: ['action']
       },

package/src/lib/server/session-tools/connector-inputs.test.ts

@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import { describe, it } from 'node:test'
+import { UPLOAD_DIR } from '../storage'
+import { resolveConnectorMediaInput } from './connector'
+
+describe('resolveConnectorMediaInput', () => {
+  it('resolves /api/uploads urls passed via mediaPath back to disk', () => {
+    const filename = `screenshot-test-${Date.now()}.png`
+    const uploadPath = path.join(UPLOAD_DIR, filename)
+    fs.mkdirSync(UPLOAD_DIR, { recursive: true })
+    fs.writeFileSync(uploadPath, 'png')
+
+    try {
+      const resolved = resolveConnectorMediaInput({
+        cwd: process.cwd(),
+        mediaPath: `/api/uploads/${filename}`,
+      })
+      assert.equal(resolved.error, undefined)
+      assert.equal(resolved.mediaPath, uploadPath)
+    } finally {
+      fs.rmSync(uploadPath, { force: true })
+    }
+  })
+
+  it('treats remote urls passed via mediaPath as sendable urls instead of local files', () => {
+    const resolved = resolveConnectorMediaInput({
+      cwd: process.cwd(),
+      mediaPath: 'https://example.com/report.pdf',
+    })
+
+    assert.equal(resolved.error, undefined)
+    assert.equal(resolved.mediaPath, undefined)
+    assert.equal(resolved.fileUrl, 'https://example.com/report.pdf')
+  })
+})

package/src/lib/server/session-tools/connector.test.ts

@@ -0,0 +1,138 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import {
+  CONNECTOR_MESSAGE_TOOL_ACTIONS,
+  CONNECTOR_MESSAGE_TOOL_PARAMETERS,
+  inferConnectorActionName,
+  normalizeConnectorActionInputAliases,
+  normalizeConnectorActionName,
+} from './connector'
+import { getPluginManager } from '../plugins'
+import { buildSessionTools } from './index'
+
+describe('connector_message_tool contract', () => {
+  it('exposes the connector actions and voice-note fields through the plugin schema', () => {
+    const entry = getPluginManager()
+      .getTools(['manage_connectors'])
+      .find((tool) => tool.tool.name === 'connector_message_tool')
+
+    assert.ok(entry, 'connector_message_tool should be registered for manage_connectors')
+
+    const props = (entry!.tool.parameters?.properties ?? {}) as Record<string, { type?: string; enum?: string[] }>
+    assert.deepEqual(props.action?.enum, [...CONNECTOR_MESSAGE_TOOL_ACTIONS])
+    assert.equal(props.approved?.type, 'boolean')
+    assert.equal(props.ptt?.type, 'boolean')
+    assert.equal(props.voiceText?.type, 'string')
+    assert.equal(props.recipientId?.type, 'string')
+    assert.equal(props.channel?.type, 'string')
+    assert.equal(Array.isArray(entry!.tool.parameters?.required), false)
+    assert.equal(Array.isArray((CONNECTOR_MESSAGE_TOOL_PARAMETERS as { required?: unknown }).required), false)
+  })
+
+  it('normalizes legacy rich-message aliases to the current connector actions', () => {
+    assert.equal(normalizeConnectorActionName('message_react'), 'react')
+    assert.equal(normalizeConnectorActionName('message_edit'), 'edit')
+    assert.equal(normalizeConnectorActionName('message_delete'), 'delete')
+    assert.equal(normalizeConnectorActionName('message_pin'), 'pin')
+    assert.equal(normalizeConnectorActionName('send_voice_note'), 'send_voice_note')
+  })
+
+  it('infers send-style actions from partial connector payloads', () => {
+    assert.equal(inferConnectorActionName({ voiceText: 'hello there' }), 'send_voice_note')
+    assert.equal(inferConnectorActionName({ followUpMessage: 'check back later', delaySec: 60 }), 'schedule_followup')
+    assert.equal(inferConnectorActionName({ message: 'plain text message' }), 'send')
+    assert.equal(inferConnectorActionName({}), null)
+  })
+
+  it('normalizes connector and target aliases from model-generated delivery calls', () => {
+    const running = [{ id: 'd81cd63b', name: 'Main Whatsapp connection' }]
+
+    assert.deepEqual(
+      normalizeConnectorActionInputAliases({
+        action: 'send_voice_note',
+        channel: 'Main Whatsapp connection',
+        recipientId: '07958148127',
+      }, running),
+      {
+        action: 'send_voice_note',
+        channel: 'Main Whatsapp connection',
+        recipientId: '07958148127',
+        connectorId: 'd81cd63b',
+        to: '07958148127',
+      },
+    )
+
+    assert.deepEqual(
+      normalizeConnectorActionInputAliases({
+        action: 'send_voice_note',
+        id: 'd81cd63b',
+        target: '199900000001@lid',
+      }, running),
+      {
+        action: 'send_voice_note',
+        id: 'd81cd63b',
+        target: '199900000001@lid',
+        connectorId: 'd81cd63b',
+        to: '199900000001@lid',
+      },
+    )
+  })
+
+  it('treats raw id as messageId for message actions instead of as a target alias', () => {
+    assert.deepEqual(
+      normalizeConnectorActionInputAliases({
+        action: 'react',
+        id: 'msg-123',
+        emoji: '👍',
+      }, [{ id: 'conn-1', name: 'Primary connector' }]),
+      {
+        action: 'react',
+        id: 'msg-123',
+        emoji: '👍',
+        messageId: 'msg-123',
+      },
+    )
+  })
+
+  it('buildSessionTools exposes the native connector schema instead of the legacy passthrough bridge', async () => {
+    const built = await buildSessionTools(process.cwd(), ['manage_connectors'], {
+      sessionId: 'connector-native-schema-test',
+      agentId: 'default',
+      platformAssignScope: 'self',
+    })
+
+    try {
+      const connectorTool = built.tools.find((tool) => tool.name === 'connector_message_tool')
+      assert.ok(connectorTool, 'connector_message_tool should be available when manage_connectors is enabled')
+
+      const schema = (connectorTool as { schema?: { safeParse: (value: unknown) => { success: boolean } } }).schema
+      assert.ok(schema, 'connector_message_tool should expose a validation schema')
+      assert.equal(schema.safeParse({ action: 'send_voice_note', approved: true, ptt: true }).success, true)
+      assert.equal(schema.safeParse({ voiceText: 'hello', recipientId: '07958148127', channel: 'Main Whatsapp connection' }).success, true)
+      assert.equal(schema.safeParse({ action: 'message_react' }).success, true)
+      assert.equal(schema.safeParse({}).success, true)
+      assert.equal(schema.safeParse({ action: 'bogus_action' }).success, false)
+    } finally {
+      await built.cleanup()
+    }
+  })
+
+  it('loads connector_message_tool when a session only has the tool-level grant alias', async () => {
+    const built = await buildSessionTools(process.cwd(), ['connector_message_tool'], {
+      sessionId: 'connector-tool-alias-test',
+      agentId: 'default',
+      platformAssignScope: 'self',
+    })
+
+    try {
+      assert.equal(
+        built.tools.some((tool) => tool.name === 'connector_message_tool'),
+        true,
+        'connector_message_tool should load from its persisted approval alias',
+      )
+    } finally {
+      await built.cleanup()
+    }
+  })
+})