@swarmclawai/swarmclaw 0.6.0 → 0.6.3

package/src/lib/server/openclaw-gateway.ts

@@ -160,8 +160,8 @@ export class OpenClawGateway {
       this.doConnect().catch(() => {})
     }, this.reconnectDelay)
     this.reconnectDelay = Math.min(this.reconnectDelay * 2, maxDelay)
-    if (this.consecutiveFailures % 5 === 0) {
-      console.log(`[openclaw-gateway] ${this.consecutiveFailures} consecutive failures, next retry in ${Math.round(this.reconnectDelay / 1000)}s`)
+    if (this.consecutiveFailures === 1 || this.consecutiveFailures % 5 === 0) {
+      console.log(`[openclaw-gateway] ${this.consecutiveFailures} consecutive failure${this.consecutiveFailures > 1 ? 's' : ''}, next retry in ${Math.round(this.reconnectDelay / 1000)}s`)
     }
   }
 

package/src/lib/server/orchestrator-lg.ts

@@ -11,6 +11,7 @@ import { buildChatModel } from './build-llm'
 import { getCheckpointSaver } from './langgraph-checkpoint'
 import { notify } from './ws-hub'
 import { pushMainLoopEventToMainSessions } from './main-agent-loop'
+import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
 import { genId } from '@/lib/id'
 import { NON_LANGGRAPH_PROVIDER_IDS } from '@/lib/provider-sets'
 import type { Agent, TaskComment, MessageToolEvent } from '@/types'
@@ -351,6 +352,7 @@ export async function executeLangGraphOrchestrator(
   const settings = loadSettings()
   const promptParts: string[] = []
   if (settings.userPrompt) promptParts.push(settings.userPrompt)
+  promptParts.push(buildCurrentDateTimePromptContext())
   if (orchestrator.soul) promptParts.push(orchestrator.soul)
   if (orchestrator.systemPrompt) promptParts.push(orchestrator.systemPrompt)
   // Inject dynamic skills

package/src/lib/server/orchestrator.ts

@@ -6,6 +6,7 @@ import {
 import { WORKSPACE_DIR } from './data-dir'
 import { loadRuntimeSettings, getLegacyOrchestratorMaxTurns } from './runtime-settings'
 import { getMemoryDb } from './memory-db'
+import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
 import { getProvider } from '../providers'
 import type { Agent } from '@/types'
 
@@ -109,6 +110,7 @@ async function executeOrchestratorLegacy(
   const settings = loadSettings()
   const promptParts: string[] = []
   if (settings.userPrompt) promptParts.push(settings.userPrompt)
+  promptParts.push(buildCurrentDateTimePromptContext())
   if (orchestrator.soul) promptParts.push(orchestrator.soul)
   if (orchestrator.systemPrompt) promptParts.push(orchestrator.systemPrompt)
   if (orchestrator.skillIds?.length) {
@@ -308,8 +310,8 @@ async function executeSubTask(
 
 export async function callProvider(
   agent: Agent,
-  systemPrompt: string,
-  history: { role: string; text: string }[],
+  systemPrompt?: string,
+  history: { role: string; text: string }[] = [],
 ): Promise<string> {
   const provider = getProvider(agent.provider)
   if (!provider) throw new Error(`Unknown provider: ${agent.provider}`)
@@ -346,6 +348,7 @@ export async function callProvider(
     session: mockSession,
     message: history[history.length - 1].text,
     apiKey,
+    systemPrompt,
     write: (data: string) => {
       // Parse SSE data to extract text
       if (data.startsWith('data: ')) {

package/src/lib/server/playwright-proxy.mjs

@@ -7,9 +7,8 @@
 import { spawn } from 'child_process'
 import fs from 'fs'
 import path from 'path'
-import os from 'os'
 
-const UPLOAD_DIR = process.env.SWARMCLAW_UPLOAD_DIR || path.join(os.tmpdir(), 'swarmclaw-uploads')
+const UPLOAD_DIR = process.env.SWARMCLAW_UPLOAD_DIR || path.join(process.env.DATA_DIR || path.join(process.cwd(), 'data'), 'uploads')
 if (!fs.existsSync(UPLOAD_DIR)) fs.mkdirSync(UPLOAD_DIR, { recursive: true })
 
 const child = spawn('npx', ['@playwright/mcp@latest'], {
@@ -47,7 +46,7 @@ child.stdout.on('data', (chunk) => {
             fs.writeFileSync(path.join(UPLOAD_DIR, filename), Buffer.from(block.data, 'base64'))
             newContent.push({
               type: 'text',
-              text: `Screenshot saved. Show it to the user with this markdown: ![Screenshot](/api/uploads/${filename})`,
+              text: `Screenshot saved to /api/uploads/${filename} — it is already displayed inline above (do not repeat it with markdown).`,
             })
             newContent.push(block) // keep image so Claude can see it
           } else {

package/src/lib/server/prompt-runtime-context.ts

@@ -0,0 +1,53 @@
+function resolveLocalTimezone(): string {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC'
+  } catch {
+    return 'UTC'
+  }
+}
+
+function formatDateTimeInTimezone(date: Date, timezone: string): string | null {
+  try {
+    return new Intl.DateTimeFormat('en-US', {
+      weekday: 'long',
+      year: 'numeric',
+      month: 'long',
+      day: 'numeric',
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit',
+      hour12: false,
+      timeZone: timezone,
+      timeZoneName: 'short',
+    }).format(date)
+  } catch {
+    return null
+  }
+}
+
+export function buildCurrentDateTimePromptContext(preferredTimezone?: string | null): string {
+  const now = new Date()
+  const utcIso = now.toISOString()
+  const utcFormatted = formatDateTimeInTimezone(now, 'UTC') || utcIso
+  const localTimezone = resolveLocalTimezone()
+  const requestedTimezone = (preferredTimezone || '').trim()
+  const chosenTimezone = requestedTimezone || localTimezone
+  const chosenFormatted = formatDateTimeInTimezone(now, chosenTimezone)
+
+  const lines = [
+    '## Runtime Date/Time Context',
+    `- Current timestamp (UTC): ${utcIso}`,
+    `- Current date/time (UTC): ${utcFormatted}`,
+  ]
+
+  if (chosenFormatted) {
+    lines.push(`- Current date/time (${chosenTimezone}): ${chosenFormatted}`)
+  } else if (requestedTimezone) {
+    lines.push(`- Requested timezone "${requestedTimezone}" could not be resolved. Use UTC time above.`)
+  }
+
+  lines.push('- Treat these as authoritative for terms like "today", "yesterday", "tomorrow", and "recent".')
+  lines.push('- For time-sensitive answers, use explicit dates (for example, "March 2, 2026").')
+
+  return lines.join('\n')
+}

package/src/lib/server/queue.ts

@@ -1,5 +1,7 @@
 import { genId } from '@/lib/id'
-import { loadTasks, saveTasks, loadQueue, saveQueue, loadAgents, loadSchedules, saveSchedules, loadSessions, saveSessions, loadSettings } from './storage'
+import fs from 'node:fs'
+import path from 'node:path'
+import { loadTasks, saveTasks, loadQueue, saveQueue, loadAgents, loadSchedules, saveSchedules, loadSessions, saveSessions, loadSettings, loadConnectors, UPLOAD_DIR } from './storage'
 import { notify } from './ws-hub'
 import { WORKSPACE_DIR } from './data-dir'
 import { createOrchestratorSession, executeOrchestrator } from './orchestrator'
@@ -13,13 +15,13 @@ import { isProtectedMainSession } from './main-session'
 import type { Agent, BoardTask, Message } from '@/types'
 
 // HMR-safe: pin processing flag to globalThis so hot reloads don't reset it
-const _queueState = ((globalThis as Record<string, unknown>).__swarmclaw_queue__ ??= { processing: false }) as { processing: boolean }
+const _queueState = ((globalThis as Record<string, unknown>).__swarmclaw_queue__ ??= { processing: false, pendingKick: false }) as { processing: boolean; pendingKick: boolean }
 
 interface SessionMessageLike {
   role?: string
   text?: string
   time?: number
-  kind?: 'chat' | 'heartbeat' | 'system'
+  kind?: 'chat' | 'heartbeat' | 'system' | 'context-clear'
   toolEvents?: Array<{ name?: string; output?: string }>
 }
 
@@ -114,6 +116,54 @@ function latestAssistantText(session: SessionLike | null | undefined): string {
   return ''
 }
 
+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'
+}
+
+function normalizeWhatsappTarget(raw: string): string {
+  const trimmed = raw.trim()
+  if (!trimmed) return trimmed
+  if (trimmed.includes('@')) return trimmed
+  let cleaned = trimmed.replace(/[^\d+]/g, '')
+  if (cleaned.startsWith('+')) cleaned = cleaned.slice(1)
+  if (cleaned.startsWith('0') && cleaned.length >= 10) {
+    cleaned = `44${cleaned.slice(1)}`
+  }
+  cleaned = cleaned.replace(/[^\d]/g, '')
+  return cleaned ? `${cleaned}@s.whatsapp.net` : trimmed
+}
+
+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)
+}
+
+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
+}
+
 // Task result extraction now uses Zod-validated structured data
 // from ./task-result.ts (extractTaskResult, formatResultBody)
 
@@ -215,6 +265,78 @@ function notifyMainChatScheduleResult(task: BoardTask): void {
   if (changed) saveSessions(sessions)
 }
 
+async function notifyConnectorTaskFollowups(params: {
+  task: BoardTask
+  statusLabel: string
+  summaryText: string
+  imageUrl?: string
+}) {
+  const { task, statusLabel, summaryText, imageUrl } = params
+
+  const connectors = loadConnectors()
+  const running = (await import('./connectors/manager')).listRunningConnectors()
+  const manager = await import('./connectors/manager')
+
+  const candidates = running.filter((entry) => {
+    if (!entry.supportsSend || !entry.id) return false
+    const connector = connectors[entry.id]
+    if (!connector) return false
+    if (connector.agentId !== task.agentId) return false
+    return isEnabledFlag(connector.config?.taskFollowups)
+  })
+  if (!candidates.length) return
+
+  const summary = summaryText.trim().slice(0, 1400)
+  for (const candidate of candidates) {
+    const connector = connectors[candidate.id]
+    if (!connector) continue
+
+    const channelTargetRaw = candidate.recentChannelId
+      || candidate.configuredTargets[0]
+      || connector.config?.outboundJid
+      || connector.config?.outboundTarget
+      || ''
+    if (!channelTargetRaw) continue
+
+    const channelId = connector.platform === 'whatsapp'
+      ? normalizeWhatsappTarget(channelTargetRaw)
+      : channelTargetRaw
+
+    const template = typeof connector.config?.taskFollowupTemplate === 'string'
+      ? connector.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 resolvedMediaPath = maybeResolveUploadMediaPathFromUrl(imageUrl)
+    try {
+      await manager.sendConnectorMessage({
+        connectorId: candidate.id,
+        channelId,
+        text: message,
+        ...(resolvedMediaPath
+          ? {
+              mediaPath: resolvedMediaPath,
+              caption: message,
+            }
+          : {}),
+      })
+    } catch (err: unknown) {
+      const errMsg = err instanceof Error ? err.message : String(err)
+      console.warn(`[queue] Failed task follow-up send on connector ${candidate.id}: ${errMsg}`)
+    }
+  }
+}
+
 /**
  * Notify agent thread sessions when a task completes or fails.
  * - Always pushes to the executing agent's thread
@@ -280,22 +402,54 @@ function notifyAgentThreadTaskResult(task: BoardTask): void {
     changed = true
   }
 
-  // 2. If delegated, push to delegating agent's thread
+  // 2. If delegated, push to delegating agent's thread AND active chat sessions
   const delegatedBy = (task as unknown as Record<string, unknown>).delegatedByAgentId
   if (typeof delegatedBy === 'string' && delegatedBy !== task.agentId) {
     const delegator = agents[delegatedBy]
+    const agentName = agent?.name || task.agentId
+    const delegationBody = buildResultBlock(`Delegated task ${statusLabel}: **${taskLink}** (by ${agentName})`)
+
+    // Push to delegating agent's thread
     if (delegator?.threadSessionId && sessions[delegator.threadSessionId]) {
       const thread = sessions[delegator.threadSessionId]
       if (!Array.isArray(thread.messages)) thread.messages = []
-      const agentName = agent?.name || task.agentId
-      const body = buildResultBlock(`Delegated task ${statusLabel}: **${taskLink}** (by ${agentName})`)
-      thread.messages.push(buildMsg(body))
+      thread.messages.push(buildMsg(delegationBody))
       thread.lastActiveAt = now
       changed = true
     }
+
+    // Push to delegating agent's active user-facing chat sessions
+    // so the result is visible in the chat the user is looking at
+    if (delegator) {
+      for (const session of Object.values(sessions)) {
+        if (!session || session.agentId !== delegatedBy) continue
+        // Skip thread sessions and orchestrated/subagent sessions
+        if (session.id === delegator.threadSessionId) continue
+        if (session.sessionType === 'orchestrated') continue
+        // Only push to recently-active sessions (within last 30 minutes)
+        const lastActive = typeof session.lastActiveAt === 'number' ? session.lastActiveAt : 0
+        if (now - lastActive > 30 * 60_000) continue
+        if (!Array.isArray(session.messages)) session.messages = []
+        // Avoid duplicate push
+        const lastMsg = session.messages.at(-1)
+        if (lastMsg?.text === delegationBody && typeof lastMsg?.time === 'number' && now - lastMsg.time < 30_000) continue
+        session.messages.push(buildMsg(delegationBody))
+        session.lastActiveAt = now
+        changed = true
+        // Notify the specific session's message topic for real-time UI update
+        notify(`messages:${session.id}`)
+      }
+    }
   }
 
   if (changed) saveSessions(sessions)
+
+  void notifyConnectorTaskFollowups({
+    task,
+    statusLabel,
+    summaryText: resultBody || '',
+    imageUrl: firstImage?.url,
+  })
 }
 
 /** Disable heartbeat on a task's session when the task finishes. */
@@ -331,6 +485,10 @@ export function enqueueTask(taskId: string) {
     text: `Task queued: "${task.title}" (${task.id})`,
   })
 
+  // If processNext is already running, mark a pending kick so it re-enters after finishing
+  if (_queueState.processing) {
+    _queueState.pendingKick = true
+  }
   // Delay before kicking worker so UI shows the queued state
   setTimeout(() => processNext(), 2000)
 }
@@ -619,10 +777,21 @@ export async function processNext() {
       // Save initial assistant message so user sees context when opening the session
       const sessions = loadSessions()
       if (sessions[sessionId]) {
+        const isDelegation = (task as unknown as Record<string, unknown>).sourceType === 'delegation'
+        let initialText: string
+        if (isDelegation) {
+          const delegatorId = (task as unknown as Record<string, unknown>).delegatedByAgentId as string | undefined
+          const delegator = delegatorId ? agents[delegatorId] : null
+          const prefix = `[delegation-source:${delegatorId || ''}:${delegator?.name || 'Agent'}:${delegator?.avatarSeed || ''}]`
+          initialText = `${prefix}\nDelegated by **${delegator?.name || 'another agent'}** | [${task.title}](#task:${task.id})\n\n${task.description || ''}\n\nWorking directory: \`${taskCwd}\`\n\nI'll begin working on this now.`
+        } else {
+          initialText = `Starting task: **${task.title}**\n\n${task.description || ''}\n\nWorking directory: \`${taskCwd}\`\n\nI'll begin working on this now.`
+        }
         sessions[sessionId].messages.push({
           role: 'assistant',
-          text: `Starting task: **${task.title}**\n\n${task.description || ''}\n\nWorking directory: \`${taskCwd}\`\n\nI'll begin working on this now.`,
+          text: initialText,
           time: Date.now(),
+          ...(isDelegation ? { kind: 'system' as const } : {}),
         })
         saveSessions(sessions)
       }
@@ -807,6 +976,11 @@ export async function processNext() {
     }
   } finally {
     _queueState.processing = false
+    // If tasks were enqueued while we were processing, kick another round
+    if (_queueState.pendingKick) {
+      _queueState.pendingKick = false
+      setTimeout(() => processNext(), 500)
+    }
   }
 }
 

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

@@ -0,0 +1,67 @@
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import { loadSessions, saveSessions } from '../storage'
+import { notify } from '../ws-hub'
+import type { ToolBuildContext } from './context'
+
+export function buildCanvasTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  const { ctx, hasTool } = bctx
+  if (!hasTool('canvas')) return []
+
+  return [
+    tool(
+      async ({ action, content }) => {
+        try {
+          const sessionId = ctx?.sessionId
+          if (!sessionId) return 'Error: no active session for canvas.'
+
+          const sessions = loadSessions()
+          const session = sessions[sessionId]
+          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
+            session.lastActiveAt = Date.now()
+            sessions[sessionId] = session
+            saveSessions(sessions)
+            notify(`canvas:${sessionId}`)
+            return JSON.stringify({ ok: true, action: 'present', contentLength: content.length })
+          }
+
+          if (action === 'hide') {
+            ;(session as Record<string, unknown>).canvasContent = null
+            session.lastActiveAt = Date.now()
+            sessions[sessionId] = session
+            saveSessions(sessions)
+            notify(`canvas:${sessionId}`)
+            return JSON.stringify({ ok: true, action: 'hide' })
+          }
+
+          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,
+            })
+          }
+
+          return `Unknown canvas action "${action}". Valid: present, hide, snapshot`
+        } catch (err: unknown) {
+          return `Error: ${err instanceof Error ? err.message : String(err)}`
+        }
+      },
+      {
+        name: 'canvas',
+        description: 'Present live HTML/CSS/JS content to the user in an interactive canvas panel. Use "present" to show content, "hide" to dismiss, "snapshot" to check current state. The canvas renders in a sandboxed iframe alongside the chat.',
+        schema: z.object({
+          action: z.enum(['present', 'hide', 'snapshot']).describe('Canvas action to perform'),
+          content: z.string().optional().describe('HTML content to render (required for "present"). Can include inline CSS and JS.'),
+        }),
+      },
+    ),
+  ]
+}