@swarmclawai/swarmclaw 0.7.1 → 0.7.3

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

@@ -0,0 +1,276 @@
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import type { Plugin, PluginHooks } from '@/types'
+import { getPluginManager } from '../plugins'
+import type { ToolBuildContext } from './context'
+import { normalizeToolInputArgs } from './normalize-tool-args'
+import {
+  downloadMailboxAttachment,
+  fetchMailboxMessageByUid,
+  fetchMailboxMessages,
+  getMailboxConfig,
+  replyMailboxMessage,
+} from '../mailbox-utils'
+import { createWatchJob } from '../watch-jobs'
+
+function parseMessageUid(value: unknown): number {
+  const parsed = typeof value === 'number' ? value : typeof value === 'string' ? Number.parseInt(value, 10) : Number.NaN
+  return Number.isFinite(parsed) ? Math.max(0, Math.trunc(parsed)) : 0
+}
+
+async function executeMailboxAction(args: Record<string, unknown>, bctx: { cwd: string; sessionId?: string | null; agentId?: string | null }) {
+  const normalized = normalizeToolInputArgs(args)
+  const action = String(normalized.action || 'status').trim().toLowerCase()
+  const folder = typeof normalized.folder === 'string' ? normalized.folder.trim() : undefined
+
+  try {
+    if (action === 'status') {
+      const config = getMailboxConfig()
+      return JSON.stringify({
+        configured: !!(config.imapHost && config.user && config.password),
+        imapHost: config.imapHost || null,
+        smtpHost: config.smtpHost || null,
+        folder: config.folder || 'INBOX',
+        fromAddress: config.fromAddress || null,
+        subjectPrefix: config.subjectPrefix || null,
+      })
+    }
+
+    if (action === 'list_messages' || action === 'search_messages') {
+      const messages = await fetchMailboxMessages({
+        folder,
+        query: typeof normalized.query === 'string' ? normalized.query : undefined,
+        from: typeof normalized.from === 'string' ? normalized.from : undefined,
+        subjectContains: typeof normalized.subjectContains === 'string' ? normalized.subjectContains : undefined,
+        bodyContains: typeof normalized.containsText === 'string' ? normalized.containsText : undefined,
+        unreadOnly: normalized.unreadOnly === true,
+        hasAttachments: normalized.hasAttachments === true,
+        limit: typeof normalized.limit === 'number' ? normalized.limit : undefined,
+      })
+      return JSON.stringify(messages.map((message) => ({
+        uid: message.uid,
+        messageId: message.messageId,
+        subject: message.subject,
+        from: message.from,
+        fromName: message.fromName,
+        date: message.date,
+        snippet: message.snippet,
+        hasAttachments: message.hasAttachments,
+        attachmentCount: message.attachments.length,
+        threadKey: message.threadKey,
+      })))
+    }
+
+    if (action === 'list_threads') {
+      const messages = await fetchMailboxMessages({
+        folder,
+        limit: typeof normalized.limit === 'number' ? Math.max(10, normalized.limit * 4) : 80,
+      })
+      const threads = new Map<string, {
+        threadKey: string
+        subject: string
+        participants: Set<string>
+        latestUid: number
+        latestDate: string | null
+        messageCount: number
+        unreadCount: number
+        snippet: string
+      }>()
+      for (const message of messages) {
+        const current = threads.get(message.threadKey) || {
+          threadKey: message.threadKey,
+          subject: message.subject,
+          participants: new Set<string>(),
+          latestUid: message.uid,
+          latestDate: message.date,
+          messageCount: 0,
+          unreadCount: 0,
+          snippet: message.snippet,
+        }
+        current.messageCount += 1
+        current.participants.add(message.from)
+        if (!message.flags.includes('\\Seen')) current.unreadCount += 1
+        if (message.uid >= current.latestUid) {
+          current.latestUid = message.uid
+          current.latestDate = message.date
+          current.subject = message.subject
+          current.snippet = message.snippet
+        }
+        threads.set(message.threadKey, current)
+      }
+      return JSON.stringify(Array.from(threads.values())
+        .map((thread) => ({
+          threadKey: thread.threadKey,
+          subject: thread.subject,
+          participants: Array.from(thread.participants),
+          latestUid: thread.latestUid,
+          latestDate: thread.latestDate,
+          messageCount: thread.messageCount,
+          unreadCount: thread.unreadCount,
+          snippet: thread.snippet,
+        }))
+        .sort((a, b) => b.latestUid - a.latestUid)
+        .slice(0, Math.max(1, Math.min(typeof normalized.limit === 'number' ? normalized.limit : 20, 100))))
+    }
+
+    if (action === 'read_message') {
+      const uid = parseMessageUid(normalized.uid ?? normalized.id)
+      if (!uid) return 'Error: uid is required.'
+      const message = await fetchMailboxMessageByUid(uid, folder)
+      if (!message) return `Error: mailbox message "${uid}" not found.`
+      return JSON.stringify(message)
+    }
+
+    if (action === 'download_attachment') {
+      const uid = parseMessageUid(normalized.uid ?? normalized.id)
+      if (!uid) return 'Error: uid is required.'
+      const result = await downloadMailboxAttachment({
+        uid,
+        folder,
+        attachmentId: typeof normalized.attachmentId === 'string' ? normalized.attachmentId : undefined,
+        attachmentName: typeof normalized.attachmentName === 'string' ? normalized.attachmentName : undefined,
+        saveTo: typeof normalized.saveTo === 'string' ? normalized.saveTo : undefined,
+        cwd: bctx.cwd,
+      })
+      return JSON.stringify(result)
+    }
+
+    if (action === 'reply') {
+      const uid = parseMessageUid(normalized.uid ?? normalized.id)
+      if (!uid) return 'Error: uid is required.'
+      const text = typeof normalized.text === 'string'
+        ? normalized.text
+        : typeof normalized.body === 'string'
+          ? normalized.body
+          : ''
+      if (!text.trim()) return 'Error: text is required.'
+      const result = await replyMailboxMessage({
+        uid,
+        folder,
+        text,
+        html: typeof normalized.html === 'string' ? normalized.html : undefined,
+        subject: typeof normalized.subject === 'string' ? normalized.subject : undefined,
+      })
+      return JSON.stringify({ ok: true, ...result, uid })
+    }
+
+    if (action === 'wait_for_email') {
+      if (!bctx.sessionId && !bctx.agentId) return 'Error: email waits require a session or agent context.'
+      const resumeMessage = typeof normalized.resumeMessage === 'string' && normalized.resumeMessage.trim()
+        ? normalized.resumeMessage.trim()
+        : 'A matching email arrived. Read it, decide what to do next, and continue the task.'
+      const intervalMs = typeof normalized.intervalSec === 'number'
+        ? Math.max(30, normalized.intervalSec) * 1000
+        : 60_000
+      const timeoutAt = typeof normalized.timeoutMinutes === 'number'
+        ? Date.now() + Math.max(1, normalized.timeoutMinutes) * 60_000
+        : undefined
+      const job = await createWatchJob({
+        type: 'email',
+        sessionId: bctx.sessionId || null,
+        agentId: bctx.agentId || null,
+        createdByAgentId: bctx.agentId || null,
+        resumeMessage,
+        description: typeof normalized.description === 'string' ? normalized.description : 'Wait for email',
+        intervalMs,
+        timeoutAt,
+        target: {
+          folder: folder || getMailboxConfig().folder || 'INBOX',
+        },
+        condition: {
+          from: typeof normalized.from === 'string' ? normalized.from : undefined,
+          subjectContains: typeof normalized.subjectContains === 'string' ? normalized.subjectContains : undefined,
+          containsText: typeof normalized.containsText === 'string' ? normalized.containsText : undefined,
+          query: typeof normalized.query === 'string' ? normalized.query : undefined,
+          unreadOnly: normalized.unreadOnly === true,
+          hasAttachments: normalized.hasAttachments === true,
+        },
+      })
+      return JSON.stringify(job)
+    }
+
+    return `Error: Unknown action "${action}".`
+  } catch (err: unknown) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
+const MailboxPlugin: Plugin = {
+  name: 'Mailbox',
+  enabledByDefault: false,
+  description: 'Read/search/reply to inbox messages over IMAP/SMTP, download attachments, and wait for matching inbound email.',
+  hooks: {
+    getCapabilityDescription: () =>
+      'I can inspect inboxes with `mailbox`, read and search messages, download attachments, reply to emails, and wait for specific inbound messages.',
+  } as PluginHooks,
+  tools: [
+    {
+      name: 'mailbox',
+      description: 'Work with email inboxes. Actions: status, list_messages, list_threads, search_messages, read_message, download_attachment, reply, wait_for_email.',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', enum: ['status', 'list_messages', 'list_threads', 'search_messages', 'read_message', 'download_attachment', 'reply', 'wait_for_email'] },
+          uid: { type: 'number' },
+          query: { type: 'string' },
+          from: { type: 'string' },
+          subjectContains: { type: 'string' },
+          containsText: { type: 'string' },
+          attachmentId: { type: 'string' },
+          attachmentName: { type: 'string' },
+          text: { type: 'string' },
+          body: { type: 'string' },
+          html: { type: 'string' },
+          subject: { type: 'string' },
+          folder: { type: 'string' },
+          unreadOnly: { type: 'boolean' },
+          hasAttachments: { type: 'boolean' },
+          limit: { type: 'number' },
+          saveTo: { type: 'string' },
+          resumeMessage: { type: 'string' },
+          intervalSec: { type: 'number' },
+          timeoutMinutes: { type: 'number' },
+        },
+        required: ['action'],
+      },
+      execute: async (args, context) => executeMailboxAction(args, {
+        cwd: context.session.cwd || process.cwd(),
+        sessionId: context.session.id,
+        agentId: context.session.agentId || null,
+      }),
+    },
+  ],
+  ui: {
+    settingsFields: [
+      { key: 'imapHost', label: 'IMAP Host', type: 'text', placeholder: 'imap.gmail.com', help: 'Inbound mailbox host.' },
+      { key: 'imapPort', label: 'IMAP Port', type: 'number', defaultValue: 993, help: '993 for TLS IMAP.' },
+      { key: 'smtpHost', label: 'SMTP Host', type: 'text', placeholder: 'smtp.gmail.com', help: 'Outbound mail host for replies.' },
+      { key: 'smtpPort', label: 'SMTP Port', type: 'number', defaultValue: 587, help: '587 for STARTTLS, 465 for SSL.' },
+      { key: 'user', label: 'Mailbox Username', type: 'text', placeholder: 'agent@example.com' },
+      { key: 'password', label: 'Mailbox Password', type: 'secret', help: 'IMAP password or app password.' },
+      { key: 'folder', label: 'Folder', type: 'text', defaultValue: 'INBOX', placeholder: 'INBOX' },
+      { key: 'fromAddress', label: 'Reply From Address', type: 'text', placeholder: 'agent@example.com' },
+      { key: 'fromName', label: 'Reply From Name', type: 'text', defaultValue: 'SwarmClaw Agent' },
+    ],
+  },
+}
+
+getPluginManager().registerBuiltin('mailbox', MailboxPlugin)
+
+export function buildMailboxTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasPlugin('mailbox')) return []
+  return [
+    tool(
+      async (args) => executeMailboxAction(args, {
+        cwd: bctx.cwd,
+        sessionId: bctx.ctx?.sessionId || null,
+        agentId: bctx.ctx?.agentId || null,
+      }),
+      {
+        name: 'mailbox',
+        description: MailboxPlugin.tools![0].description,
+        schema: z.object({}).passthrough(),
+      },
+    ),
+  ]
+}

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

@@ -15,6 +15,8 @@ import type { MemoryEntry, Plugin, PluginHooks } from '@/types'
 import type { ToolBuildContext } from './context'
 import { getPluginManager } from '../plugins'
 import { normalizeToolInputArgs } from './normalize-tool-args'
+import { partitionMemoriesByTier } from '../memory-tiers'
+import { syncSessionArchiveMemory } from '../session-archive-memory'
 
 /**
  * Advanced Database-Backed Memory logic.
@@ -34,6 +36,12 @@ async function executeMemoryAction(input: any, ctx: any) {
   
   const memDb = getMemoryDb()
   const currentAgentId = ctx?.agentId || null
+  const currentSessionId = typeof ctx?.sessionId === 'string'
+    ? ctx.sessionId
+    : typeof ctx?.id === 'string'
+      ? ctx.id
+      : null
+  const currentSession = ctx && typeof ctx === 'object' && Array.isArray(ctx.messages) ? ctx : null
   const rawScope = typeof scope === 'string' ? scope : 'auto'
   const scopeMode = normalizeMemoryScopeMode(rawScope === 'shared' ? 'global' : rawScope)
   const rerankMode = rerank === 'semantic' || rerank === 'lexical' ? rerank : 'balanced'
@@ -41,7 +49,7 @@ async function executeMemoryAction(input: any, ctx: any) {
   const scopeFilter = {
     mode: scopeMode,
     agentId: currentAgentId,
-    sessionId: (typeof scopeSessionId === 'string' && scopeSessionId.trim()) ? scopeSessionId.trim() : (ctx?.sessionId || null),
+    sessionId: (typeof scopeSessionId === 'string' && scopeSessionId.trim()) ? scopeSessionId.trim() : currentSessionId,
     projectRoot: (typeof projectRoot === 'string' && projectRoot.trim()) ? projectRoot.trim() : ((project && typeof project === 'object' && 'rootPath' in project && typeof (project as Record<string, unknown>).rootPath === 'string') ? (project as Record<string, unknown>).rootPath as string : null),
   }
   
@@ -52,6 +60,10 @@ async function executeMemoryAction(input: any, ctx: any) {
   const limits = getMemoryLookupLimits(loadSettings())
   const maxPerLookup = limits.maxPerLookup
 
+  if ((action === 'search' || action === 'list') && currentSession) {
+    try { syncSessionArchiveMemory(currentSession) } catch { /* archive sync is best-effort */ }
+  }
+
   const formatEntry = (m: any) => {
     let line = `[${m.id}] (${m.agentId ? `agent:${m.agentId}` : 'shared'}) ${m.category}/${m.title}: ${m.content}`
     if (m.reinforcementCount) line += ` (reinforced ×${m.reinforcementCount})`
@@ -127,7 +139,164 @@ async function executeMemoryAction(input: any, ctx: any) {
 const MemoryPlugin: Plugin = {
   name: 'Core Memory',
   description: 'Advanced database-backed long-term memory with semantic search and graph linking.',
-  hooks: {} as PluginHooks,
+  hooks: {
+    getAgentContext: async (ctx) => {
+      const agentId = ctx.session.agentId
+      if (!agentId) return null
+
+      try { syncSessionArchiveMemory(ctx.session) } catch { /* archive sync is best-effort */ }
+
+      const memDb = getMemoryDb()
+      const memoryQuerySeed = [
+        ctx.message,
+        ...ctx.history
+          .slice(-4)
+          .filter((h) => h.role === 'user')
+          .map((h) => h.text),
+      ].join('\n')
+
+      const seen = new Set<string>()
+      const formatMemoryLine = (m: { category?: string; title?: string; content?: string; pinned?: boolean }) => {
+        const category = String(m.category || 'note')
+        const title = String(m.title || 'Untitled').replace(/\s+/g, ' ').trim()
+        const snippet = String(m.content || '').replace(/\s+/g, ' ').trim().slice(0, 220)
+        const pin = m.pinned ? ' [pinned]' : ''
+        return `- [${category}]${pin} ${title}: ${snippet}`
+      }
+
+      const pinned = memDb.listPinned(agentId, 5)
+      const pinnedLines = pinned
+        .filter((m) => { if (!m?.id || seen.has(m.id)) return false; seen.add(m.id); return true })
+        .map(formatMemoryLine)
+
+      const relevantSlice = Math.max(2, 6 - pinnedLines.length)
+      const relevantLookup = memDb.searchWithLinked(memoryQuerySeed, agentId, 1, 10, 14)
+      const relevant = relevantLookup.entries.slice(0, relevantSlice)
+      const recent = memDb.list(agentId, 12).slice(0, 6)
+      const relevantByTier = partitionMemoriesByTier(relevant)
+      const recentByTier = partitionMemoriesByTier(recent)
+
+      const relevantLines = relevantByTier.durable
+        .filter((m) => { if (!m?.id || seen.has(m.id)) return false; seen.add(m.id); return true })
+        .map(formatMemoryLine)
+
+      const archiveLines = relevantByTier.archive
+        .filter((m) => { if (!m?.id || seen.has(m.id)) return false; seen.add(m.id); return true })
+        .map(formatMemoryLine)
+
+      const recentLines = recentByTier.durable
+        .filter((m) => { if (!m?.id || seen.has(m.id)) return false; seen.add(m.id); return true })
+        .map(formatMemoryLine)
+
+      const recentArchiveLines = recentByTier.archive
+        .filter((m) => { if (!m?.id || seen.has(m.id)) return false; seen.add(m.id); return true })
+        .map(formatMemoryLine)
+
+      const parts: string[] = []
+      if (pinnedLines.length) {
+        parts.push(['## Pinned Memories', 'Always-loaded memories marked as important.', ...pinnedLines].join('\n'))
+      }
+      if (relevantLines.length) {
+        parts.push(['## Relevant Memory Hits', 'These memories were retrieved by relevance for the current objective.', ...relevantLines].join('\n'))
+      }
+      if (archiveLines.length) {
+        parts.push(['## Session Archive Hits', 'Past conversation snapshots that may restore context from older chats.', ...archiveLines].join('\n'))
+      }
+      if (recentLines.length) {
+        parts.push(['## Recent Memory Notes', 'Recent durable notes that may still apply.', ...recentLines].join('\n'))
+      }
+      if (recentArchiveLines.length) {
+        parts.push(['## Recent Session Archives', 'Recently synced conversation archives you can search instead of relying on stale live context.', ...recentArchiveLines].join('\n'))
+      }
+
+      // Memory Policy
+      parts.push([
+        '## My Memory',
+        'I have long-term memory that persists across conversations. I use it naturally — I don\'t wait to be asked to remember things.',
+        'Memory tiers: working memory is short-lived, durable memory stores stable facts and decisions, and session archives capture older conversation context for search.',
+        '',
+        '**Things worth remembering:**',
+        '- What the user likes, dislikes, or has corrected me on',
+        '- Important decisions, outcomes, and lessons learned',
+        '- What I\'ve discovered about projects, codebases, or environments',
+        '- Problems I\'ve hit and how I solved them',
+        '- Who people are and how they relate to each other',
+        '- Configuration details and environment specifics that I\'ll need again',
+        '',
+        '**Not worth cluttering my memory with:**',
+        '- Throwaway acknowledgments or small talk',
+        '- Work-in-progress that\'ll change soon (use category "working" for scratch notes)',
+        '- Things already in my system prompt',
+        '- Something I\'ve already stored',
+        '',
+        '**Good habits:**',
+        '- Give memories clear titles ("User prefers dark mode" not "Note 1")',
+        '- Use categories: preference, fact, learning, project, identity, decision',
+        '- Search session archives before assuming older conversation context is still in the live chat history',
+        '- Check what I already know before storing something new',
+        '- When I learn something that corrects old knowledge, update or remove the old memory',
+      ].join('\n'))
+
+      // Pre-compaction consolidation nudge
+      const msgCount = ctx.history.filter(m => m.role === 'user' || m.role === 'assistant').length
+      if (msgCount > 20) {
+        parts.push([
+          '## Reflection & Consolidation Reminder',
+          'This conversation is getting long and I might lose older context soon.',
+          'Save anything important I\'ve learned, decided, or discovered to memory now. Only what matters, not every detail.',
+        ].join('\n'))
+      }
+
+      return parts.join('\n\n') || null
+    },
+    afterToolExec: (ctx) => {
+      const agentId = ctx.session.agentId
+      if (!agentId) return
+      const inp = ctx.input
+      if (!inp || typeof inp !== 'object') return
+      const action = typeof inp.action === 'string' ? inp.action : ''
+      let title: string | null = null
+      if (ctx.toolName === 'manage_tasks') {
+        if (action === 'create') title = `Created task: ${inp.title || 'Untitled'}`
+        else if (ctx.output && /status.*completed|completed.*successfully/i.test(ctx.output)) title = `Completed task: ${inp.title || inp.taskId || 'unknown'}`
+      }
+      if (ctx.toolName === 'manage_schedules' && action === 'create') title = `Created schedule: ${inp.name || 'Untitled'}`
+      if (ctx.toolName === 'manage_agents' && action === 'create') title = `Created agent: ${inp.name || 'Untitled'}`
+      if (!title) return
+      try {
+        const memDb = getMemoryDb()
+        memDb.add({ agentId, sessionId: ctx.session.id, category: 'breadcrumb', title, content: '' })
+      } catch { /* breadcrumbs are best-effort */ }
+    },
+    afterChatTurn: (ctx) => {
+      if (ctx.internal) return
+      if (ctx.source !== 'chat' && ctx.source !== 'connector') return
+      const agentId = ctx.session.agentId
+      if (!agentId) return
+      const msg = (ctx.message || '').trim()
+      const resp = (ctx.response || '').trim()
+      if (msg.length < 20 || resp.length < 40) return
+      if (/^(ok|okay|cool|thanks|thx|got it|nice)[.! ]*$/i.test(msg)) return
+      if (resp === 'HEARTBEAT_OK') return
+      const now = Date.now()
+      const last = typeof ctx.session.lastAutoMemoryAt === 'number' ? ctx.session.lastAutoMemoryAt : 0
+      if (last > 0 && now - last < 5 * 60 * 1000) return
+      try {
+        const memDb = getMemoryDb()
+        const compactMessage = msg.replace(/\s+/g, ' ').slice(0, 220)
+        const compactResponse = resp.replace(/\s+/g, ' ').slice(0, 700)
+        const autoTitle = `[auto] ${compactMessage.slice(0, 90)}`
+        const content = `source: ${ctx.source}\nuser_request: ${compactMessage}\nassistant_outcome: ${compactResponse}`
+        memDb.add({ agentId, sessionId: ctx.session.id, category: 'execution', title: autoTitle, content })
+        ctx.session.lastAutoMemoryAt = now
+      } catch { /* auto-memory is best-effort */ }
+    },
+    getCapabilityDescription: () => 'I have long-term memory (`memory_tool`) — I can remember things across conversations and recall them when needed.',
+    getOperatingGuidance: () => [
+      'Memory: search before major tasks, store concise notes after meaningful steps. Platform preloads context each turn.',
+      'For open goals, form a hypothesis and execute — do not keep re-asking broad questions.',
+    ],
+  } as PluginHooks,
   tools: [
     {
       name: 'memory_tool',
@@ -155,7 +324,7 @@ const MemoryPlugin: Plugin = {
 getPluginManager().registerBuiltin('memory', MemoryPlugin)
 
 export function buildMemoryTools(bctx: ToolBuildContext) {
-  if (!bctx.hasTool('memory')) return []
+  if (!bctx.hasPlugin('memory')) return []
   
   return [
     tool(