@swarmclawai/swarmclaw 0.7.1 → 0.7.3

package/src/lib/server/cost.ts

@@ -1,4 +1,5 @@
-import type { Agent, UsageRecord } from '@/types'
+import type { Agent, UsageRecord, PluginDefinitionCost } from '@/types'
+import type { StructuredToolInterface } from '@langchain/core/tools'
 import { loadSessions, loadUsage } from './storage'
 
 // Model cost table: [inputCostPer1M, outputCostPer1M] in USD
@@ -65,6 +66,38 @@ export function getModelCosts(): Record<string, [number, number]> {
   return { ...MODEL_COSTS }
 }
 
+/**
+ * Estimate the number of tokens a tool definition occupies in the LLM context.
+ * Uses ~4 chars per token as a rough approximation.
+ */
+export function estimateToolDefinitionTokens(t: StructuredToolInterface): number {
+  let chars = (t.name || '').length + (t.description || '').length
+  try {
+    const schema = typeof t.schema === 'object' ? JSON.stringify(t.schema) : ''
+    chars += schema.length
+  } catch { /* ignore */ }
+  return Math.ceil(chars / 4)
+}
+
+/**
+ * Build per-plugin definition cost estimates from a set of tools and their plugin mapping.
+ */
+export function buildPluginDefinitionCosts(
+  tools: StructuredToolInterface[],
+  toolToPluginMap: Record<string, string>,
+): PluginDefinitionCost[] {
+  const totals = new Map<string, number>()
+  for (const t of tools) {
+    const pluginId = toolToPluginMap[t.name] || '_unknown'
+    const tokens = estimateToolDefinitionTokens(t)
+    totals.set(pluginId, (totals.get(pluginId) || 0) + tokens)
+  }
+  return Array.from(totals.entries()).map(([pluginId, estimatedTokens]) => ({
+    pluginId,
+    estimatedTokens,
+  }))
+}
+
 export interface AgentSpendWindows {
   hourly: number
   daily: number

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

@@ -22,6 +22,12 @@ import type { WebhookRetryEntry } from '@/types'
 import { createNotification } from '@/lib/server/create-notification'
 import { pingProvider, OPENAI_COMPATIBLE_DEFAULTS } from '@/lib/server/provider-health'
 import { runIntegrityMonitor } from '@/lib/server/integrity-monitor'
+import { recoverStaleDelegationJobs } from './delegation-jobs'
+import {
+  listPendingApprovalsNeedingConnectorNotification,
+  markApprovalConnectorNotificationAttempt,
+  markApprovalConnectorNotificationSent,
+} from './approvals'
 
 const QUEUE_CHECK_INTERVAL = 30_000 // 30 seconds
 const BROWSER_SWEEP_INTERVAL = 60_000 // 60 seconds
@@ -161,6 +167,7 @@ export function startDaemon(options?: { source?: string; manualStart?: boolean }
   try {
     validateCompletedTasksQueue()
     cleanupFinishedTaskSessions()
+    recoverStaleDelegationJobs()
     startScheduler()
     startQueueProcessor()
     startBrowserSweep()
@@ -413,14 +420,14 @@ async function processWebhookRetries() {
         claudeSessionId: null,
         codexThreadId: null,
         opencodeSessionId: null,
-        delegateResumeIds: { claudeCode: null, codex: null, opencode: null },
+        delegateResumeIds: { claudeCode: null, codex: null, opencode: null, gemini: null },
         messages: [],
         createdAt: ts,
         lastActiveAt: ts,
-        sessionType: 'orchestrated',
+        sessionType: 'human',
         agentId: agent.id,
         parentSessionId: null,
-        tools: agent.tools || [],
+        plugins: agent.plugins || agent.tools || [],
         heartbeatEnabled: (agent.heartbeatEnabled as boolean | undefined) ?? true,
         heartbeatIntervalSec: (agent.heartbeatIntervalSec as number | null | undefined) ?? null,
       }
@@ -664,6 +671,51 @@ async function runOpenClawGatewayHealthChecks() {
   }
 }
 
+async function runPendingApprovalConnectorNotifications(now: number) {
+  const running = listRunningConnectors()
+  const pending = listPendingApprovalsNeedingConnectorNotification({
+    now,
+    runningConnectors: running,
+  })
+  if (!pending.length) return
+
+  for (const reminder of pending) {
+    try {
+      const result = await sendConnectorMessage({
+        connectorId: reminder.connectorId,
+        channelId: reminder.channelId,
+        text: reminder.text,
+        threadId: reminder.threadId || undefined,
+      })
+      markApprovalConnectorNotificationSent(reminder.approvalId, {
+        at: now,
+        connectorId: result.connectorId,
+        channelId: result.channelId,
+        threadId: reminder.threadId || null,
+        messageId: result.messageId || null,
+      })
+      createNotification({
+        type: 'info',
+        title: 'Approval reminder sent',
+        message: 'A pending approval reminder was delivered over an active connector.',
+        dedupKey: `approval-connector-reminder:${reminder.approvalId}`,
+        entityType: 'approval',
+        entityId: reminder.approvalId,
+      })
+    } catch (err: unknown) {
+      const errorMsg = err instanceof Error ? err.message : String(err)
+      markApprovalConnectorNotificationAttempt(reminder.approvalId, {
+        at: now,
+        connectorId: reminder.connectorId,
+        channelId: reminder.channelId,
+        threadId: reminder.threadId || null,
+        lastError: errorMsg,
+      })
+      console.warn(`[daemon] Approval connector reminder failed for ${reminder.approvalId}: ${errorMsg}`)
+    }
+  }
+}
+
 async function runHealthChecks() {
   // Continuously keep the completed queue honest.
   validateCompletedTasksQueue()
@@ -739,6 +791,12 @@ async function runHealthChecks() {
     console.error('[daemon] OpenClaw gateway health check failed:', err instanceof Error ? err.message : String(err))
   }
 
+  try {
+    await runPendingApprovalConnectorNotifications(now)
+  } catch (err: unknown) {
+    console.error('[daemon] Approval connector reminder check failed:', err instanceof Error ? err.message : String(err))
+  }
+
   // Integrity drift monitoring for identity/config/plugin files.
   try {
     const integrity = runIntegrityMonitor(loadSettings())

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

@@ -19,3 +19,16 @@ function resolveWorkspaceDir(): string {
 }
 
 export const WORKSPACE_DIR = resolveWorkspaceDir()
+
+function resolveBrowserProfilesDir(): string {
+  if (process.env.BROWSER_PROFILES_DIR) return process.env.BROWSER_PROFILES_DIR
+  const external = path.join(os.homedir(), '.swarmclaw', 'browser-profiles')
+  try {
+    fs.mkdirSync(external, { recursive: true })
+    return external
+  } catch {
+    return path.join(DATA_DIR, 'browser-profiles')
+  }
+}
+
+export const BROWSER_PROFILES_DIR = resolveBrowserProfilesDir()

package/src/lib/server/delegation-jobs.test.ts

@@ -0,0 +1,140 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { after, before, describe, it } from 'node:test'
+
+const originalEnv = {
+  DATA_DIR: process.env.DATA_DIR,
+  WORKSPACE_DIR: process.env.WORKSPACE_DIR,
+  SWARMCLAW_BUILD_MODE: process.env.SWARMCLAW_BUILD_MODE,
+}
+
+let tempDir = ''
+let delegationJobs: typeof import('./delegation-jobs')
+
+before(async () => {
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-delegation-jobs-'))
+  process.env.DATA_DIR = path.join(tempDir, 'data')
+  process.env.WORKSPACE_DIR = path.join(tempDir, 'workspace')
+  process.env.SWARMCLAW_BUILD_MODE = '1'
+  delegationJobs = await import('./delegation-jobs')
+})
+
+after(() => {
+  if (originalEnv.DATA_DIR === undefined) delete process.env.DATA_DIR
+  else process.env.DATA_DIR = originalEnv.DATA_DIR
+  if (originalEnv.WORKSPACE_DIR === undefined) delete process.env.WORKSPACE_DIR
+  else process.env.WORKSPACE_DIR = originalEnv.WORKSPACE_DIR
+  if (originalEnv.SWARMCLAW_BUILD_MODE === undefined) delete process.env.SWARMCLAW_BUILD_MODE
+  else process.env.SWARMCLAW_BUILD_MODE = originalEnv.SWARMCLAW_BUILD_MODE
+  fs.rmSync(tempDir, { recursive: true, force: true })
+})
+
+describe('delegation-jobs', () => {
+  it('tracks a queued job through running and completion', () => {
+    const job = delegationJobs.createDelegationJob({
+      kind: 'delegate',
+      parentSessionId: 'session-1',
+      backend: 'codex',
+      task: 'Refactor the module',
+      cwd: process.cwd(),
+    })
+
+    const started = delegationJobs.startDelegationJob(job.id, { backend: 'codex' })
+    const completed = delegationJobs.completeDelegationJob(job.id, 'done')
+
+    assert.equal(started?.status, 'running')
+    assert.equal(completed?.status, 'completed')
+    assert.equal(completed?.resultPreview, 'done')
+    assert.equal(delegationJobs.listDelegationJobs({ parentSessionId: 'session-1' }).length >= 1, true)
+  })
+
+  it('keeps cancellation terminal even if late completions arrive', () => {
+    const job = delegationJobs.createDelegationJob({
+      kind: 'subagent',
+      parentSessionId: 'session-2',
+      agentId: 'agent-1',
+      task: 'Do the background work',
+      cwd: process.cwd(),
+    })
+
+    let cancelled = false
+    delegationJobs.startDelegationJob(job.id, { agentId: 'agent-1' })
+    delegationJobs.registerDelegationRuntime(job.id, {
+      cancel: () => {
+        cancelled = true
+      },
+    })
+
+    const stopped = delegationJobs.cancelDelegationJob(job.id)
+    const afterComplete = delegationJobs.completeDelegationJob(job.id, 'late success')
+    const afterFail = delegationJobs.failDelegationJob(job.id, 'late failure')
+
+    assert.equal(cancelled, true)
+    assert.equal(stopped?.status, 'cancelled')
+    assert.equal(afterComplete?.status, 'cancelled')
+    assert.equal(afterFail?.status, 'cancelled')
+  })
+
+  it('recovers stale running jobs as failed', () => {
+    const stale = delegationJobs.createDelegationJob({
+      kind: 'delegate',
+      parentSessionId: 'session-3',
+      backend: 'claude',
+      task: 'Stale job',
+      cwd: process.cwd(),
+    })
+
+    delegationJobs.startDelegationJob(stale.id)
+    delegationJobs.updateDelegationJob(stale.id, {
+      startedAt: Date.now() - 60_000,
+    })
+
+    const recovered = delegationJobs.recoverStaleDelegationJobs(-1)
+    const latest = delegationJobs.getDelegationJob(stale.id)
+
+    assert.equal(recovered >= 1, true)
+    assert.equal(latest?.status, 'failed')
+    assert.match(String(latest?.error || ''), /interrupted/i)
+  })
+
+  it('cancels all running jobs for a parent session', () => {
+    const jobA = delegationJobs.createDelegationJob({
+      kind: 'delegate',
+      parentSessionId: 'session-bulk',
+      backend: 'codex',
+      task: 'Task A',
+      cwd: process.cwd(),
+    })
+    const jobB = delegationJobs.createDelegationJob({
+      kind: 'subagent',
+      parentSessionId: 'session-bulk',
+      agentId: 'agent-2',
+      task: 'Task B',
+      cwd: process.cwd(),
+    })
+    const untouched = delegationJobs.createDelegationJob({
+      kind: 'delegate',
+      parentSessionId: 'other-session',
+      backend: 'claude',
+      task: 'Task C',
+      cwd: process.cwd(),
+    })
+
+    delegationJobs.startDelegationJob(jobA.id)
+    delegationJobs.startDelegationJob(jobB.id)
+    delegationJobs.startDelegationJob(untouched.id)
+
+    const cancelled = delegationJobs.cancelDelegationJobsForParentSession('session-bulk', 'Stopped by user')
+
+    assert.equal(cancelled, 2)
+    assert.equal(delegationJobs.getDelegationJob(jobA.id)?.status, 'cancelled')
+    assert.equal(delegationJobs.getDelegationJob(jobB.id)?.status, 'cancelled')
+    assert.equal(delegationJobs.getDelegationJob(untouched.id)?.status, 'running')
+    assert.equal(
+      delegationJobs.getDelegationJob(jobA.id)?.checkpoints?.some((entry) => entry.note === 'Stopped by user'),
+      true,
+    )
+  })
+})

package/src/lib/server/delegation-jobs.ts

@@ -0,0 +1,248 @@
+import { genId } from '@/lib/id'
+import type { DelegationJobArtifact, DelegationJobCheckpoint, DelegationJobRecord, DelegationJobStatus } from '@/types'
+import { loadDelegationJobs, upsertDelegationJob } from './storage'
+import { notify } from './ws-hub'
+
+interface DelegationRuntimeHandle {
+  cancel?: () => void
+}
+
+const runtimeKey = '__swarmclaw_delegation_job_runtime__' as const
+const runtimeScope = globalThis as typeof globalThis & {
+  [runtimeKey]?: Map<string, DelegationRuntimeHandle>
+}
+const runtimeHandles = runtimeScope[runtimeKey] ?? (runtimeScope[runtimeKey] = new Map())
+
+function now() {
+  return Date.now()
+}
+
+function isTerminalStatus(status: DelegationJobStatus | null | undefined): boolean {
+  return status === 'completed' || status === 'failed' || status === 'cancelled'
+}
+
+function notifyDelegationJobsChanged() {
+  notify('delegation_jobs')
+}
+
+export interface CreateDelegationJobInput {
+  kind: DelegationJobRecord['kind']
+  task: string
+  backend?: DelegationJobRecord['backend']
+  parentSessionId?: string | null
+  childSessionId?: string | null
+  agentId?: string | null
+  agentName?: string | null
+  cwd?: string | null
+}
+
+export function createDelegationJob(input: CreateDelegationJobInput): DelegationJobRecord {
+  const createdAt = now()
+  const job: DelegationJobRecord = {
+    id: genId(10),
+    kind: input.kind,
+    status: 'queued',
+    backend: input.backend ?? null,
+    parentSessionId: input.parentSessionId ?? null,
+    childSessionId: input.childSessionId ?? null,
+    agentId: input.agentId ?? null,
+    agentName: input.agentName ?? null,
+    cwd: input.cwd ?? null,
+    task: input.task,
+    result: null,
+    resultPreview: null,
+    error: null,
+    checkpoints: [{
+      at: createdAt,
+      note: 'Job queued',
+      status: 'queued',
+    }],
+    artifacts: [],
+    resumeId: null,
+    resumeIds: {},
+    createdAt,
+    updatedAt: createdAt,
+    startedAt: null,
+    completedAt: null,
+  }
+  upsertDelegationJob(job.id, job)
+  notifyDelegationJobsChanged()
+  return job
+}
+
+export function getDelegationJob(id: string): DelegationJobRecord | null {
+  const all = loadDelegationJobs()
+  const current = all[id]
+  if (!current || typeof current !== 'object') return null
+  return current as DelegationJobRecord
+}
+
+export function listDelegationJobs(filter?: {
+  parentSessionId?: string | null
+  status?: DelegationJobStatus | null
+}): DelegationJobRecord[] {
+  return Object.values(loadDelegationJobs())
+    .filter((job): job is DelegationJobRecord => !!job && typeof job === 'object')
+    .filter((job) => !filter?.parentSessionId || job.parentSessionId === filter.parentSessionId)
+    .filter((job) => !filter?.status || job.status === filter.status)
+    .sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0))
+}
+
+export function updateDelegationJob(
+  id: string,
+  patch: Partial<DelegationJobRecord>,
+): DelegationJobRecord | null {
+  const current = getDelegationJob(id)
+  if (!current) return null
+  const next: DelegationJobRecord = {
+    ...current,
+    ...patch,
+    updatedAt: now(),
+  }
+  upsertDelegationJob(id, next)
+  notifyDelegationJobsChanged()
+  return next
+}
+
+export function appendDelegationCheckpoint(
+  id: string,
+  note: string,
+  status?: DelegationJobStatus,
+): DelegationJobRecord | null {
+  const current = getDelegationJob(id)
+  if (!current) return null
+  if (isTerminalStatus(current.status) && status && status !== current.status) {
+    return current
+  }
+  const checkpoints = [...(current.checkpoints || []), { at: now(), note, status }]
+  return updateDelegationJob(id, {
+    status: isTerminalStatus(current.status) ? current.status : (status ?? current.status),
+    checkpoints: checkpoints.slice(-24),
+  })
+}
+
+export function startDelegationJob(id: string, patch?: Partial<DelegationJobRecord>): DelegationJobRecord | null {
+  const current = getDelegationJob(id)
+  if (!current) return null
+  if (isTerminalStatus(current.status)) return current
+  return updateDelegationJob(id, {
+    ...patch,
+    status: 'running',
+    startedAt: now(),
+  })
+}
+
+export function completeDelegationJob(
+  id: string,
+  result: string,
+  patch?: Partial<DelegationJobRecord>,
+): DelegationJobRecord | null {
+  runtimeHandles.delete(id)
+  const current = getDelegationJob(id)
+  if (!current) return null
+  if (isTerminalStatus(current.status)) return current
+  return updateDelegationJob(id, {
+    ...patch,
+    status: 'completed',
+    result,
+    resultPreview: result.slice(0, 1000),
+    error: null,
+    completedAt: now(),
+  })
+}
+
+export function failDelegationJob(id: string, error: string, patch?: Partial<DelegationJobRecord>): DelegationJobRecord | null {
+  runtimeHandles.delete(id)
+  const current = getDelegationJob(id)
+  if (!current) return null
+  if (isTerminalStatus(current.status)) return current
+  return updateDelegationJob(id, {
+    ...patch,
+    status: 'failed',
+    error,
+    completedAt: now(),
+  })
+}
+
+export function cancelDelegationJob(id: string): DelegationJobRecord | null {
+  const current = getDelegationJob(id)
+  if (!current) return null
+  if (isTerminalStatus(current.status)) return current
+  const runtime = runtimeHandles.get(id)
+  try {
+    runtime?.cancel?.()
+  } catch {
+    // best-effort cancel
+  }
+  runtimeHandles.delete(id)
+  const checkpoint: DelegationJobCheckpoint = {
+    at: now(),
+    note: 'Job cancelled',
+    status: 'cancelled',
+  }
+  return updateDelegationJob(id, {
+    status: 'cancelled',
+    completedAt: now(),
+    error: null,
+    checkpoints: [
+      ...(current.checkpoints || []),
+      checkpoint,
+    ].slice(-24),
+  })
+}
+
+export function cancelDelegationJobsForParentSession(
+  parentSessionId: string,
+  note = 'Parent session cancelled',
+): number {
+  if (!parentSessionId) return 0
+  const jobs = listDelegationJobs({ parentSessionId })
+    .filter((job) => job.status === 'queued' || job.status === 'running')
+  let cancelled = 0
+  for (const job of jobs) {
+    const next = cancelDelegationJob(job.id)
+    if (!next || next.status !== 'cancelled') continue
+    cancelled += 1
+    const checkpoints = Array.isArray(next.checkpoints) ? next.checkpoints : []
+    const last = checkpoints[checkpoints.length - 1]
+    if (!last || last.note !== note) {
+      const checkpoint: DelegationJobCheckpoint = {
+        at: now(),
+        note,
+        status: 'cancelled',
+      }
+      updateDelegationJob(job.id, {
+        checkpoints: [
+          ...checkpoints,
+          checkpoint,
+        ].slice(-24),
+      })
+    }
+  }
+  return cancelled
+}
+
+export function registerDelegationRuntime(id: string, handle: DelegationRuntimeHandle) {
+  runtimeHandles.set(id, handle)
+}
+
+export function appendDelegationArtifacts(id: string, artifacts: DelegationJobArtifact[]): DelegationJobRecord | null {
+  const current = getDelegationJob(id)
+  if (!current) return null
+  return updateDelegationJob(id, {
+    artifacts: [...(current.artifacts || []), ...artifacts].slice(-24),
+  })
+}
+
+export function recoverStaleDelegationJobs(maxAgeMs = 15 * 60_000): number {
+  const threshold = now() - maxAgeMs
+  const stale = listDelegationJobs().filter((job) =>
+    (job.status === 'queued' || job.status === 'running')
+    && !runtimeHandles.has(job.id)
+    && (job.updatedAt || job.createdAt) < threshold,
+  )
+  for (const job of stale) {
+    failDelegationJob(job.id, 'Delegation job was interrupted before completion.')
+  }
+  return stale.length
+}

package/src/lib/server/document-utils.test.ts

@@ -0,0 +1,47 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { describe, it } from 'node:test'
+import { extractDocumentArtifact, loadTabularFile, normalizeInlineRows, writeStructuredTable } from './document-utils'
+
+describe('document-utils', () => {
+  it('extracts structured tables from JSON arrays', async () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-doc-utils-'))
+    try {
+      const jsonPath = path.join(tempDir, 'people.json')
+      fs.writeFileSync(jsonPath, JSON.stringify([
+        { name: 'Ada', score: 10 },
+        { name: 'Grace', score: 9 },
+      ], null, 2))
+
+      const artifact = await extractDocumentArtifact(jsonPath)
+      assert.equal(artifact.method, 'json')
+      assert.equal(artifact.tables.length, 1)
+      assert.deepEqual(artifact.tables[0].headers, ['name', 'score'])
+      assert.equal(artifact.tables[0].rowCount, 2)
+    } finally {
+      fs.rmSync(tempDir, { recursive: true, force: true })
+    }
+  })
+
+  it('normalizes inline rows and round-trips CSV output', async () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-doc-utils-'))
+    try {
+      const table = normalizeInlineRows([
+        { city: 'London', population: 9 },
+        { city: 'Paris', population: 2 },
+      ])
+      const csvPath = path.join(tempDir, 'cities.csv')
+      const written = await writeStructuredTable(csvPath, table)
+      const loaded = await loadTabularFile(csvPath)
+
+      assert.equal(written.format, 'csv')
+      assert.deepEqual(loaded.headers, ['city', 'population'])
+      assert.equal(loaded.rowCount, 2)
+      assert.equal(String(loaded.rows[0].city), 'London')
+    } finally {
+      fs.rmSync(tempDir, { recursive: true, force: true })
+    }
+  })
+})