@swarmclawai/swarmclaw 0.2.0

package/src/lib/server/context-manager.ts

@@ -0,0 +1,232 @@
+import type { Message, ProviderType } from '@/types'
+import { getMemoryDb } from './memory-db'
+
+// --- Context window sizes (tokens) per provider/model ---
+
+const PROVIDER_CONTEXT_WINDOWS: Record<string, number> = {
+  // Anthropic
+  'claude-opus-4-6': 200_000,
+  'claude-sonnet-4-6': 200_000,
+  'claude-haiku-4-5-20251001': 200_000,
+  'claude-sonnet-4-5-20250514': 200_000,
+  // OpenAI
+  'gpt-4o': 128_000,
+  'gpt-4o-mini': 128_000,
+  'gpt-4.1': 1_047_576,
+  'gpt-4.1-mini': 1_047_576,
+  'gpt-4.1-nano': 1_047_576,
+  'o3': 200_000,
+  'o3-mini': 128_000,
+  'o4-mini': 200_000,
+  // Codex CLI
+  'gpt-5.3-codex': 1_047_576,
+  'gpt-5.2-codex': 1_047_576,
+  'gpt-5.1-codex': 1_047_576,
+  'gpt-5-codex': 1_047_576,
+  'gpt-5-codex-mini': 1_047_576,
+  // Google Gemini
+  'gemini-2.5-pro': 1_048_576,
+  'gemini-2.5-flash': 1_048_576,
+  'gemini-2.5-flash-lite': 1_048_576,
+  // DeepSeek
+  'deepseek-chat': 64_000,
+  'deepseek-reasoner': 64_000,
+  // Mistral
+  'mistral-large-latest': 128_000,
+  'mistral-small-latest': 128_000,
+  'magistral-medium-2506': 128_000,
+  'devstral-small-latest': 128_000,
+  // xAI
+  'grok-3': 131_072,
+  'grok-3-fast': 131_072,
+  'grok-3-mini': 131_072,
+  'grok-3-mini-fast': 131_072,
+}
+
+const PROVIDER_DEFAULT_WINDOWS: Record<string, number> = {
+  anthropic: 200_000,
+  'claude-cli': 200_000,
+  openai: 128_000,
+  'codex-cli': 1_047_576,
+  'opencode-cli': 200_000,
+  google: 1_048_576,
+  deepseek: 64_000,
+  groq: 32_768,
+  together: 32_768,
+  mistral: 128_000,
+  xai: 131_072,
+  fireworks: 32_768,
+  ollama: 8_192,
+  openclaw: 128_000,
+}
+
+/** Get context window size for a model, falling back to provider default */
+export function getContextWindowSize(provider: string, model: string): number {
+  return PROVIDER_CONTEXT_WINDOWS[model]
+    || PROVIDER_DEFAULT_WINDOWS[provider]
+    || 8_192
+}
+
+// --- Token estimation ---
+
+/** Rough token estimate: ~4 chars per token for English text */
+export function estimateTokens(text: string): number {
+  if (!text) return 0
+  return Math.ceil(text.length / 4)
+}
+
+/** Estimate total tokens for a message array */
+export function estimateMessagesTokens(messages: Message[]): number {
+  let total = 0
+  for (const m of messages) {
+    // Role + overhead per message (~4 tokens)
+    total += 4
+    total += estimateTokens(m.text)
+    if (m.toolEvents) {
+      for (const te of m.toolEvents) {
+        total += estimateTokens(te.name) + estimateTokens(te.input)
+        if (te.output) total += estimateTokens(te.output)
+      }
+    }
+  }
+  return total
+}
+
+// --- Context status ---
+
+export interface ContextStatus {
+  estimatedTokens: number
+  contextWindow: number
+  percentUsed: number
+  messageCount: number
+  strategy: 'ok' | 'warning' | 'critical'
+}
+
+export function getContextStatus(
+  messages: Message[],
+  systemPromptTokens: number,
+  provider: string,
+  model: string,
+): ContextStatus {
+  const contextWindow = getContextWindowSize(provider, model)
+  const messageTokens = estimateMessagesTokens(messages)
+  const estimatedTokens = messageTokens + systemPromptTokens
+  const percentUsed = Math.round((estimatedTokens / contextWindow) * 100)
+  return {
+    estimatedTokens,
+    contextWindow,
+    percentUsed,
+    messageCount: messages.length,
+    strategy: percentUsed >= 90 ? 'critical' : percentUsed >= 70 ? 'warning' : 'ok',
+  }
+}
+
+// --- Memory consolidation ---
+
+/** Extract important facts from old messages before pruning */
+export function consolidateToMemory(
+  messages: Message[],
+  agentId: string | null,
+  sessionId: string,
+): number {
+  if (!agentId) return 0
+  const db = getMemoryDb()
+  let stored = 0
+
+  for (const m of messages) {
+    if (m.role !== 'assistant' || !m.text) continue
+    // Look for decisions, commitments, key facts
+    const text = m.text
+    const hasDecision = /\b(decided|decision|agreed|committed|will do|plan is|approach is|chosen|selected)\b/i.test(text)
+    const hasKeyFact = /\b(important|critical|note|remember|key point|constraint|requirement|deadline)\b/i.test(text)
+    const hasResult = /\b(result|found|discovered|concluded|completed|built|created|deployed)\b/i.test(text)
+
+    if (hasDecision || hasKeyFact || hasResult) {
+      // Create a concise summary (first 500 chars)
+      const summary = text.length > 500 ? text.slice(0, 500) + '...' : text
+      const category = hasDecision ? 'decision' : hasResult ? 'result' : 'note'
+      const title = `[auto-consolidated] ${text.slice(0, 60).replace(/\n/g, ' ')}`
+
+      db.add({
+        agentId,
+        sessionId,
+        category,
+        title,
+        content: summary,
+      })
+      stored++
+    }
+  }
+  return stored
+}
+
+// --- Compaction strategies ---
+
+export interface CompactionResult {
+  messages: Message[]
+  prunedCount: number
+  memoriesStored: number
+  summaryAdded: boolean
+}
+
+/** Sliding window: keep last N messages */
+export function slidingWindowCompact(
+  messages: Message[],
+  keepLastN: number,
+): Message[] {
+  if (messages.length <= keepLastN) return messages
+  return messages.slice(-keepLastN)
+}
+
+/** Summarize old messages, keep recent ones */
+export async function summarizeAndCompact(opts: {
+  messages: Message[]
+  keepLastN: number
+  agentId: string | null
+  sessionId: string
+  generateSummary: (text: string) => Promise<string>
+}): Promise<CompactionResult> {
+  const { messages, keepLastN, agentId, sessionId, generateSummary } = opts
+  if (messages.length <= keepLastN) {
+    return { messages, prunedCount: 0, memoriesStored: 0, summaryAdded: false }
+  }
+
+  const oldMessages = messages.slice(0, -keepLastN)
+  const recentMessages = messages.slice(-keepLastN)
+
+  // Consolidate important info to memory before pruning
+  const memoriesStored = consolidateToMemory(oldMessages, agentId, sessionId)
+
+  // Build text for summarization
+  const conversationText = oldMessages
+    .map((m) => `${m.role}: ${m.text}`)
+    .join('\n\n')
+
+  const summary = await generateSummary(conversationText)
+
+  const summaryMessage: Message = {
+    role: 'assistant',
+    text: `[Context Summary]\n${summary}`,
+    time: Date.now(),
+    kind: 'system',
+  }
+
+  return {
+    messages: [summaryMessage, ...recentMessages],
+    prunedCount: oldMessages.length,
+    memoriesStored,
+    summaryAdded: true,
+  }
+}
+
+/** Auto-compact: triggers when estimated tokens exceed threshold */
+export function shouldAutoCompact(
+  messages: Message[],
+  systemPromptTokens: number,
+  provider: string,
+  model: string,
+  triggerPercent = 80,
+): boolean {
+  const status = getContextStatus(messages, systemPromptTokens, provider, model)
+  return status.percentUsed >= triggerPercent
+}

package/src/lib/server/cost.ts

@@ -0,0 +1,31 @@
+// Model cost table: [inputCostPer1M, outputCostPer1M] in USD
+const MODEL_COSTS: Record<string, [number, number]> = {
+  // Anthropic
+  'claude-opus-4-6': [15, 75],
+  'claude-sonnet-4-6': [3, 15],
+  'claude-haiku-4-5-20251001': [0.8, 4],
+  'claude-sonnet-4-5-20250514': [3, 15],
+  // OpenAI
+  'gpt-4o': [2.5, 10],
+  'gpt-4o-mini': [0.15, 0.6],
+  'gpt-4.1': [2, 8],
+  'gpt-4.1-mini': [0.4, 1.6],
+  'gpt-4.1-nano': [0.1, 0.4],
+  'o3': [10, 40],
+  'o3-mini': [1.1, 4.4],
+  'o4-mini': [1.1, 4.4],
+  // OpenAI embeddings
+  'text-embedding-3-small': [0.02, 0],
+  'text-embedding-3-large': [0.13, 0],
+}
+
+export function estimateCost(model: string, inputTokens: number, outputTokens: number): number {
+  const costs = MODEL_COSTS[model]
+  if (!costs) return 0
+  const [inputRate, outputRate] = costs
+  return (inputTokens * inputRate + outputTokens * outputRate) / 1_000_000
+}
+
+export function getModelCosts(): Record<string, [number, number]> {
+  return { ...MODEL_COSTS }
+}

package/src/lib/server/daemon-state.ts

@@ -0,0 +1,354 @@
+import { loadQueue, loadSchedules, loadSessions, saveSessions, loadConnectors } from './storage'
+import { processNext, cleanupFinishedTaskSessions, validateCompletedTasksQueue, recoverStalledRunningTasks } from './queue'
+import { startScheduler, stopScheduler } from './scheduler'
+import { sweepOrphanedBrowsers, getActiveBrowserCount } from './session-tools'
+import {
+  autoStartConnectors,
+  stopAllConnectors,
+  listRunningConnectors,
+  sendConnectorMessage,
+  startConnector,
+  getConnectorStatus,
+} from './connectors/manager'
+import { startHeartbeatService, stopHeartbeatService, getHeartbeatServiceStatus } from './heartbeat-service'
+
+const QUEUE_CHECK_INTERVAL = 30_000 // 30 seconds
+const BROWSER_SWEEP_INTERVAL = 60_000 // 60 seconds
+const BROWSER_MAX_AGE = 10 * 60 * 1000 // 10 minutes idle = orphaned
+const HEALTH_CHECK_INTERVAL = 120_000 // 2 minutes
+const STALE_MULTIPLIER = 4 // session is stale after N × heartbeat interval
+const STALE_MIN_MS = 4 * 60 * 1000 // minimum 4 minutes regardless of interval
+const STALE_AUTO_DISABLE_MULTIPLIER = 16 // auto-disable after much longer sustained staleness
+const STALE_AUTO_DISABLE_MIN_MS = 45 * 60 * 1000 // never auto-disable before 45 minutes
+const CONNECTOR_RESTART_BASE_MS = 30_000
+const CONNECTOR_RESTART_MAX_MS = 15 * 60 * 1000
+
+function parseBoolish(value: unknown, fallback: boolean): boolean {
+  if (typeof value === 'boolean') return value
+  if (typeof value !== 'string') return fallback
+  const normalized = value.trim().toLowerCase()
+  if (!normalized) return fallback
+  if (['1', 'true', 'yes', 'on'].includes(normalized)) return true
+  if (['0', 'false', 'no', 'off'].includes(normalized)) return false
+  return fallback
+}
+
+function daemonAutostartEnvEnabled(): boolean {
+  return parseBoolish(process.env.SWARMCLAW_DAEMON_AUTOSTART, true)
+}
+
+function parseHeartbeatIntervalSec(value: unknown, fallback = 120): number {
+  const parsed = typeof value === 'number'
+    ? value
+    : typeof value === 'string'
+      ? Number.parseInt(value, 10)
+      : Number.NaN
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.max(0, Math.min(3600, Math.trunc(parsed)))
+}
+
+function normalizeWhatsappTarget(raw?: string | null): string | null {
+  const input = (raw || '').trim()
+  if (!input) return null
+  if (input.includes('@')) return input
+  let digits = input.replace(/[^\d+]/g, '')
+  if (digits.startsWith('+')) digits = digits.slice(1)
+  if (digits.startsWith('0') && digits.length >= 10) {
+    digits = `44${digits.slice(1)}`
+  }
+  digits = digits.replace(/[^\d]/g, '')
+  return digits ? `${digits}@s.whatsapp.net` : null
+}
+
+// Store daemon state on globalThis to survive HMR reloads
+const gk = '__swarmclaw_daemon__' as const
+const ds: {
+  queueIntervalId: ReturnType<typeof setInterval> | null
+  browserSweepId: ReturnType<typeof setInterval> | null
+  healthIntervalId: ReturnType<typeof setInterval> | null
+  /** Session IDs we've already alerted as stale (alert-once semantics). */
+  staleSessionIds: Set<string>
+  connectorRestartState: Map<string, { lastAttemptAt: number; failCount: number }>
+  manualStopRequested: boolean
+  running: boolean
+  lastProcessedAt: number | null
+} = (globalThis as any)[gk] ?? ((globalThis as any)[gk] = {
+  queueIntervalId: null,
+  browserSweepId: null,
+  healthIntervalId: null,
+  staleSessionIds: new Set<string>(),
+  connectorRestartState: new Map<string, { lastAttemptAt: number; failCount: number }>(),
+  manualStopRequested: false,
+  running: false,
+  lastProcessedAt: null,
+})
+
+// Backfill fields for hot-reloaded daemon state objects from older code versions.
+if (!ds.staleSessionIds) ds.staleSessionIds = new Set<string>()
+if (!ds.connectorRestartState) ds.connectorRestartState = new Map<string, { lastAttemptAt: number; failCount: number }>()
+// Migrate from old issueLastAlertAt map if present (HMR across code versions)
+if ((ds as any).issueLastAlertAt) delete (ds as any).issueLastAlertAt
+if (ds.healthIntervalId === undefined) ds.healthIntervalId = null
+if (ds.manualStopRequested === undefined) ds.manualStopRequested = false
+
+export function ensureDaemonStarted(source = 'unknown'): boolean {
+  if (ds.running) return false
+  if (!daemonAutostartEnvEnabled()) return false
+  if (ds.manualStopRequested) return false
+  startDaemon({ source, manualStart: false })
+  return true
+}
+
+export function startDaemon(options?: { source?: string; manualStart?: boolean }) {
+  const source = options?.source || 'unknown'
+  const manualStart = options?.manualStart === true
+  if (manualStart) ds.manualStopRequested = false
+
+  if (ds.running) {
+    // In dev/HMR, daemon can already be flagged running while new interval types
+    // (for example health monitor) were introduced in newer code.
+    startQueueProcessor()
+    startBrowserSweep()
+    startHealthMonitor()
+    startHeartbeatService()
+    return
+  }
+  ds.running = true
+  console.log(`[daemon] Starting daemon (source=${source}, scheduler + queue processor + heartbeat)`)
+
+  validateCompletedTasksQueue()
+  cleanupFinishedTaskSessions()
+  startScheduler()
+  startQueueProcessor()
+  startBrowserSweep()
+  startHealthMonitor()
+  startHeartbeatService()
+
+  // Auto-start enabled connectors
+  autoStartConnectors().catch((err) => {
+    console.error('[daemon] Error auto-starting connectors:', err.message)
+  })
+}
+
+export function stopDaemon(options?: { source?: string; manualStop?: boolean }) {
+  const source = options?.source || 'unknown'
+  if (options?.manualStop === true) ds.manualStopRequested = true
+  if (!ds.running) return
+  ds.running = false
+  console.log(`[daemon] Stopping daemon (source=${source})`)
+
+  stopScheduler()
+  stopQueueProcessor()
+  stopBrowserSweep()
+  stopHealthMonitor()
+  stopHeartbeatService()
+  stopAllConnectors().catch(() => {})
+}
+
+function startBrowserSweep() {
+  if (ds.browserSweepId) return
+  ds.browserSweepId = setInterval(() => {
+    const count = getActiveBrowserCount()
+    if (count > 0) {
+      const cleaned = sweepOrphanedBrowsers(BROWSER_MAX_AGE)
+      if (cleaned > 0) {
+        console.log(`[daemon] Cleaned ${cleaned} orphaned browser(s), ${getActiveBrowserCount()} still active`)
+      }
+    }
+  }, BROWSER_SWEEP_INTERVAL)
+}
+
+function stopBrowserSweep() {
+  if (ds.browserSweepId) {
+    clearInterval(ds.browserSweepId)
+    ds.browserSweepId = null
+  }
+  // Kill all remaining browsers on shutdown
+  sweepOrphanedBrowsers(0)
+}
+
+function startQueueProcessor() {
+  if (ds.queueIntervalId) return
+  ds.queueIntervalId = setInterval(async () => {
+    const queue = loadQueue()
+    if (queue.length > 0) {
+      console.log(`[daemon] Processing ${queue.length} queued task(s)`)
+      await processNext()
+      ds.lastProcessedAt = Date.now()
+    }
+  }, QUEUE_CHECK_INTERVAL)
+}
+
+function stopQueueProcessor() {
+  if (ds.queueIntervalId) {
+    clearInterval(ds.queueIntervalId)
+    ds.queueIntervalId = null
+  }
+}
+
+async function sendHealthAlert(text: string) {
+  console.warn(`[health] ${text}`)
+  try {
+    const running = listRunningConnectors('whatsapp')
+    if (!running.length) return
+    const candidate = running[0]
+    const target = candidate.recentChannelId
+      || normalizeWhatsappTarget(candidate.configuredTargets[0] || null)
+    if (!target) return
+    await sendConnectorMessage({
+      connectorId: candidate.id,
+      channelId: target,
+      text: `⚠️ SwarmClaw health alert: ${text}`,
+    })
+  } catch {
+    // alerts are best effort; log-only fallback is acceptable
+  }
+}
+
+async function runConnectorHealthChecks(now: number) {
+  const connectors = loadConnectors()
+  for (const connector of Object.values(connectors) as any[]) {
+    if (!connector?.id) continue
+    if (connector.isEnabled !== true) {
+      ds.connectorRestartState.delete(connector.id)
+      continue
+    }
+
+    const runtimeStatus = getConnectorStatus(connector.id)
+    if (runtimeStatus === 'running') {
+      ds.connectorRestartState.delete(connector.id)
+      continue
+    }
+
+    const current = ds.connectorRestartState.get(connector.id) || { lastAttemptAt: 0, failCount: 0 }
+    const backoffMs = Math.min(
+      CONNECTOR_RESTART_MAX_MS,
+      CONNECTOR_RESTART_BASE_MS * (2 ** Math.min(6, current.failCount)),
+    )
+    if ((now - current.lastAttemptAt) < backoffMs) continue
+
+    current.lastAttemptAt = now
+    ds.connectorRestartState.set(connector.id, current)
+    try {
+      await startConnector(connector.id)
+      ds.connectorRestartState.delete(connector.id)
+      await sendHealthAlert(`Connector "${connector.name}" (${connector.platform}) was down and has been auto-restarted.`)
+    } catch (err: any) {
+      current.failCount += 1
+      ds.connectorRestartState.set(connector.id, current)
+      console.warn(`[health] Connector auto-restart failed for ${connector.name}: ${err?.message || String(err)}`)
+    }
+  }
+}
+
+async function runHealthChecks() {
+  // Continuously keep the completed queue honest.
+  validateCompletedTasksQueue()
+  recoverStalledRunningTasks()
+
+  // Keep heartbeat state in sync with task terminal states even without daemon restarts.
+  cleanupFinishedTaskSessions()
+
+  const sessions = loadSessions()
+  const now = Date.now()
+  const currentlyStale = new Set<string>()
+  let sessionsDirty = false
+
+  for (const session of Object.values(sessions) as any[]) {
+    if (!session?.id) continue
+    if (session.heartbeatEnabled !== true) continue
+
+    const intervalSec = parseHeartbeatIntervalSec(session.heartbeatIntervalSec, 120)
+    if (intervalSec <= 0) continue
+    const staleAfter = Math.max(intervalSec * STALE_MULTIPLIER * 1000, STALE_MIN_MS)
+    const lastActive = typeof session.lastActiveAt === 'number' ? session.lastActiveAt : 0
+    if (lastActive <= 0) continue
+
+    const staleForMs = now - lastActive
+    if (staleForMs > staleAfter) {
+      const autoDisableAfter = Math.max(intervalSec * STALE_AUTO_DISABLE_MULTIPLIER * 1000, STALE_AUTO_DISABLE_MIN_MS)
+      if (staleForMs > autoDisableAfter) {
+        session.heartbeatEnabled = false
+        session.lastActiveAt = now
+        sessionsDirty = true
+        ds.staleSessionIds.delete(session.id)
+        await sendHealthAlert(
+          `Auto-disabled heartbeat for stale session "${session.name || session.id}" after ${Math.round(staleForMs / 60_000)}m of inactivity.`,
+        )
+        continue
+      }
+
+      currentlyStale.add(session.id)
+      // Only alert on transition from healthy → stale (once per stale episode)
+      if (!ds.staleSessionIds.has(session.id)) {
+        ds.staleSessionIds.add(session.id)
+        await sendHealthAlert(
+          `Session "${session.name || session.id}" heartbeat appears stale (last active ${(Math.round(staleForMs / 1000))}s ago, interval ${intervalSec}s).`,
+        )
+      }
+    }
+  }
+
+  // Clear recovered sessions so they can re-alert if they go stale again later
+  for (const id of ds.staleSessionIds) {
+    if (!currentlyStale.has(id)) {
+      ds.staleSessionIds.delete(id)
+    }
+  }
+
+  if (sessionsDirty) saveSessions(sessions)
+
+  await runConnectorHealthChecks(now)
+}
+
+function startHealthMonitor() {
+  if (ds.healthIntervalId) return
+  ds.healthIntervalId = setInterval(() => {
+    runHealthChecks().catch((err) => {
+      console.error('[daemon] Health monitor tick failed:', err?.message || String(err))
+    })
+  }, HEALTH_CHECK_INTERVAL)
+}
+
+function stopHealthMonitor() {
+  if (ds.healthIntervalId) {
+    clearInterval(ds.healthIntervalId)
+    ds.healthIntervalId = null
+  }
+}
+
+export async function runDaemonHealthCheckNow() {
+  await runHealthChecks()
+}
+
+export function getDaemonStatus() {
+  const queue = loadQueue()
+  const schedules = loadSchedules()
+
+  // Find next scheduled task
+  let nextScheduled: number | null = null
+  for (const s of Object.values(schedules) as any[]) {
+    if (s.status === 'active' && s.nextRunAt) {
+      if (!nextScheduled || s.nextRunAt < nextScheduled) {
+        nextScheduled = s.nextRunAt
+      }
+    }
+  }
+
+  return {
+    running: ds.running,
+    schedulerActive: ds.running,
+    autostartEnabled: daemonAutostartEnvEnabled(),
+    manualStopRequested: ds.manualStopRequested,
+    queueLength: queue.length,
+    lastProcessed: ds.lastProcessedAt,
+    nextScheduled,
+    heartbeat: getHeartbeatServiceStatus(),
+    health: {
+      monitorActive: !!ds.healthIntervalId,
+      staleSessions: ds.staleSessionIds.size,
+      connectorsInBackoff: ds.connectorRestartState.size,
+      checkIntervalSec: Math.trunc(HEALTH_CHECK_INTERVAL / 1000),
+    },
+  }
+}

package/src/lib/server/data-dir.ts

@@ -0,0 +1,3 @@
+import path from 'path'
+
+export const DATA_DIR = process.env.DATA_DIR || path.join(process.cwd(), 'data')