@swarmclawai/swarmclaw 0.7.1 → 0.7.3

package/src/lib/providers/claude-cli.ts

@@ -43,7 +43,7 @@ export function streamClaudeCliChat({ session, message, imagePath, systemPrompt,
   }
 
   // Add MCP servers for enabled tools
-  const tools: string[] = session.tools || []
+  const tools: string[] = session.plugins || []
   let mcpConfigPath: string | null = null
   if (tools.includes('browser')) {
     const proxyScript = path.join(process.cwd(), 'src/lib/server/playwright-proxy.mjs')

package/src/lib/server/agent-assignment.test.ts

@@ -0,0 +1,112 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import type { Agent } from '@/types'
+import {
+  isDelegationTaskPayload,
+  resolveDelegatorAgentId,
+  resolveManagedAgentAssignment,
+  validateManagedAgentAssignment,
+} from './agent-assignment'
+
+const now = Date.now()
+const agents: Record<string, Agent> = {
+  molly: {
+    id: 'molly',
+    name: 'Molly',
+    description: '',
+    systemPrompt: '',
+    provider: 'openai',
+    model: 'gpt-4o',
+    createdAt: now,
+    updatedAt: now,
+  },
+  writer: {
+    id: 'writer',
+    name: 'Writer',
+    description: '',
+    systemPrompt: '',
+    provider: 'openai',
+    model: 'gpt-4o',
+    createdAt: now,
+    updatedAt: now,
+  },
+}
+
+describe('resolveManagedAgentAssignment', () => {
+  it('resolves explicit aliases to concrete agent ids', () => {
+    const resolved = resolveManagedAgentAssignment({ assignee: 'Writer' }, agents, 'molly')
+    assert.equal(resolved.agentId, 'writer')
+    assert.equal(resolved.source, 'explicit')
+  })
+
+  it('resolves description-based delegation before scope checks', () => {
+    const resolved = resolveManagedAgentAssignment(
+      { description: 'Please delegate this to @Writer and let them handle the draft.' },
+      agents,
+      'molly',
+    )
+    assert.equal(resolved.agentId, 'writer')
+    assert.equal(resolved.source, 'description')
+  })
+})
+
+describe('validateManagedAgentAssignment', () => {
+  it('blocks assigning another agent when scope is self', () => {
+    const resolved = resolveManagedAgentAssignment({ assignee: 'writer' }, agents, 'molly')
+    const error = validateManagedAgentAssignment({
+      resourceLabel: 'tasks',
+      agents,
+      assignScope: 'self',
+      currentAgentId: 'molly',
+      targetAgentId: resolved.agentId,
+      unresolvedReference: resolved.unresolvedReference,
+    })
+    assert.match(error || '', /only assign tasks to yourself/i)
+  })
+
+  it('allows self-assignment in self scope', () => {
+    const resolved = resolveManagedAgentAssignment({ agentId: 'molly' }, agents, 'molly')
+    const error = validateManagedAgentAssignment({
+      resourceLabel: 'tasks',
+      agents,
+      assignScope: 'self',
+      currentAgentId: 'molly',
+      targetAgentId: resolved.agentId,
+      unresolvedReference: resolved.unresolvedReference,
+    })
+    assert.equal(error, null)
+  })
+
+  it('rejects unknown explicit agent references', () => {
+    const resolved = resolveManagedAgentAssignment({ agentId: 'missing-agent' }, agents, 'molly')
+    const error = validateManagedAgentAssignment({
+      resourceLabel: 'tasks',
+      agents,
+      assignScope: 'all',
+      currentAgentId: 'molly',
+      targetAgentId: resolved.agentId,
+      unresolvedReference: resolved.unresolvedReference,
+    })
+    assert.match(error || '', /unknown agent "missing-agent"/i)
+  })
+
+  it('rejects self-delegation using resolved agent ids', () => {
+    const payload = {
+      agentId: 'molly',
+      sourceType: 'delegation',
+      delegatedByAgentId: 'Molly',
+    }
+    const resolved = resolveManagedAgentAssignment(payload, agents, 'molly')
+    const error = validateManagedAgentAssignment({
+      resourceLabel: 'tasks',
+      agents,
+      assignScope: 'all',
+      currentAgentId: 'molly',
+      targetAgentId: resolved.agentId,
+      unresolvedReference: resolved.unresolvedReference,
+      isDelegation: isDelegationTaskPayload(payload),
+      delegatorAgentId: resolveDelegatorAgentId(payload, agents, 'molly'),
+    })
+    assert.match(error || '', /different agent id/i)
+  })
+})

package/src/lib/server/agent-assignment.ts

@@ -0,0 +1,169 @@
+import type { Agent } from '@/types'
+import { resolveAgentReference, resolveTaskAgentFromDescription } from './task-mention'
+
+export const MANAGED_AGENT_REFERENCE_KEYS = [
+  'agentId',
+  'agent_id',
+  'assignedAgentId',
+  'assigned_agent_id',
+  'assignedToAgentId',
+  'assigned_to_agent_id',
+  'assigneeId',
+  'assignee_id',
+  'assignedAgent',
+  'assigned_agent',
+  'assignedTo',
+  'assigned_to',
+  'assignee',
+  'agent',
+  'owner',
+] as const
+
+type AssignmentSource = 'explicit' | 'description' | 'fallback' | 'none'
+
+export interface ManagedAgentAssignmentResolution {
+  agentId: string | null
+  explicitReference: string | null
+  unresolvedReference: string | null
+  source: AssignmentSource
+  hadExplicitInput: boolean
+}
+
+function firstNonEmptyString(
+  parsed: Record<string, unknown>,
+  keys: readonly string[],
+): string | null {
+  for (const key of keys) {
+    const raw = parsed[key]
+    if (typeof raw !== 'string') continue
+    const trimmed = raw.trim()
+    if (trimmed) return trimmed
+  }
+  return null
+}
+
+export function hasManagedAgentAssignmentInput(
+  parsed: Record<string, unknown>,
+  keys: readonly string[] = MANAGED_AGENT_REFERENCE_KEYS,
+): boolean {
+  return keys.some((key) => Object.prototype.hasOwnProperty.call(parsed, key))
+}
+
+export function resolveManagedAgentAssignment(
+  parsed: Record<string, unknown>,
+  agents: Record<string, Agent>,
+  fallbackAgentId?: string | null,
+  opts?: {
+    allowDescription?: boolean
+    keys?: readonly string[]
+  },
+): ManagedAgentAssignmentResolution {
+  const keys = opts?.keys ?? MANAGED_AGENT_REFERENCE_KEYS
+  const explicitReference = firstNonEmptyString(parsed, keys)
+  const hadExplicitInput = hasManagedAgentAssignmentInput(parsed, keys)
+  if (explicitReference) {
+    const resolved = resolveAgentReference(explicitReference, agents)
+    return {
+      agentId: resolved,
+      explicitReference,
+      unresolvedReference: resolved ? null : explicitReference,
+      source: 'explicit',
+      hadExplicitInput,
+    }
+  }
+
+  if (opts?.allowDescription !== false) {
+    const description = typeof parsed.description === 'string' ? parsed.description.trim() : ''
+    if (description) {
+      const resolvedFromDescription = resolveTaskAgentFromDescription(description, '', agents).trim()
+      if (resolvedFromDescription) {
+        return {
+          agentId: resolvedFromDescription,
+          explicitReference: null,
+          unresolvedReference: null,
+          source: 'description',
+          hadExplicitInput,
+        }
+      }
+    }
+  }
+
+  const fallback = typeof fallbackAgentId === 'string' ? fallbackAgentId.trim() : ''
+  if (fallback) {
+    return {
+      agentId: fallback,
+      explicitReference: null,
+      unresolvedReference: null,
+      source: 'fallback',
+      hadExplicitInput,
+    }
+  }
+
+  return {
+    agentId: null,
+    explicitReference: null,
+    unresolvedReference: null,
+    source: 'none',
+    hadExplicitInput,
+  }
+}
+
+export function resolveDelegatorAgentId(
+  parsed: Record<string, unknown>,
+  agents: Record<string, Agent>,
+  fallbackAgentId?: string | null,
+): string | null {
+  const explicitDelegator = typeof parsed.delegatedByAgentId === 'string'
+    ? parsed.delegatedByAgentId.trim()
+    : ''
+  if (explicitDelegator) {
+    return resolveAgentReference(explicitDelegator, agents) || explicitDelegator
+  }
+  const fallback = typeof fallbackAgentId === 'string' ? fallbackAgentId.trim() : ''
+  return fallback || null
+}
+
+export function isDelegationTaskPayload(parsed: Record<string, unknown>): boolean {
+  const sourceType = typeof parsed.sourceType === 'string' ? parsed.sourceType.trim().toLowerCase() : ''
+  if (sourceType === 'delegation') return true
+  if (typeof parsed.delegatedFromTaskId === 'string' && parsed.delegatedFromTaskId.trim()) return true
+  if (typeof parsed.delegatedByAgentId === 'string' && parsed.delegatedByAgentId.trim()) return true
+  return false
+}
+
+export function validateManagedAgentAssignment(params: {
+  resourceLabel: string
+  agents: Record<string, Agent>
+  assignScope: 'self' | 'all'
+  currentAgentId?: string | null
+  targetAgentId?: string | null
+  unresolvedReference?: string | null
+  isDelegation?: boolean
+  delegatorAgentId?: string | null
+}): string | null {
+  const currentAgentId = typeof params.currentAgentId === 'string' ? params.currentAgentId.trim() : ''
+  const targetAgentId = typeof params.targetAgentId === 'string' ? params.targetAgentId.trim() : ''
+  const unresolvedReference = typeof params.unresolvedReference === 'string' ? params.unresolvedReference.trim() : ''
+  const delegatorAgentId = typeof params.delegatorAgentId === 'string' ? params.delegatorAgentId.trim() : ''
+
+  if (unresolvedReference) {
+    return `Error: Unknown agent "${unresolvedReference}". Use an existing agent ID or exact agent name.`
+  }
+
+  if (targetAgentId && !params.agents[targetAgentId]) {
+    return `Error: Unknown agent "${targetAgentId}". Use an existing agent ID or exact agent name.`
+  }
+
+  if (params.assignScope === 'self' && currentAgentId && targetAgentId && targetAgentId !== currentAgentId) {
+    return `Error: You can only assign ${params.resourceLabel} to yourself ("${currentAgentId}"). To assign to other agents, ask a user to enable "Assign to Other Agents" in your agent settings.`
+  }
+
+  if (params.isDelegation && targetAgentId) {
+    const comparisonId = delegatorAgentId || currentAgentId
+    if (comparisonId && targetAgentId === comparisonId) {
+      return 'Error: Delegation target must be a different agent ID. Create a normal self-task instead of delegating to yourself.'
+    }
+  }
+
+  return null
+}

package/src/lib/server/approval-connector-notify.test.ts

@@ -0,0 +1,253 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { describe, it } from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../..')
+
+function runWithTempDataDir(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-approval-connector-'))
+  try {
+    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        DATA_DIR: tempDir,
+        WORKSPACE_DIR: path.join(tempDir, 'workspace'),
+      },
+      encoding: 'utf-8',
+    })
+    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    const lines = (result.stdout || '')
+      .trim()
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+    const jsonLine = [...lines].reverse().find((line) => line.startsWith('{'))
+    return JSON.parse(jsonLine || '{}')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+describe('approval connector reminders', () => {
+  it('resolves a due approval to the session connector target and records one-shot delivery state', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const approvalsMod = await import('./src/lib/server/approvals.ts')
+      const storage = storageMod.default || storageMod
+      const approvals = approvalsMod.default || approvalsMod
+
+      const now = Date.now()
+      storage.saveSettings({
+        approvalConnectorNotifyEnabled: true,
+        approvalConnectorNotifyDelaySec: 60,
+      })
+      storage.saveAgents({
+        agent_1: {
+          id: 'agent_1',
+          name: 'Molly',
+          description: 'Test agent',
+          systemPrompt: 'You are Molly.',
+          provider: 'openai',
+          model: 'gpt-test',
+          plugins: [],
+          createdAt: now,
+          updatedAt: now,
+        },
+      })
+      storage.saveSessions({
+        session_1: {
+          id: 'session_1',
+          name: 'Connector session',
+          cwd: process.cwd(),
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          credentialId: null,
+          apiEndpoint: null,
+          claudeSessionId: null,
+          codexThreadId: null,
+          opencodeSessionId: null,
+          delegateResumeIds: { claudeCode: null, codex: null, opencode: null, gemini: null },
+          messages: [
+            {
+              role: 'user',
+              text: 'Please ask me before spending money.',
+              time: now - 1_000,
+              source: { connectorId: 'conn-1', channelId: 'chat-42', threadId: 'topic-7' },
+            },
+          ],
+          createdAt: now - 120_000,
+          lastActiveAt: now - 1_000,
+          sessionType: 'human',
+          agentId: 'agent_1',
+          plugins: [],
+          connectorContext: {
+            connectorId: 'conn-1',
+            platform: 'telegram',
+            channelId: 'chat-42',
+            threadId: 'topic-7',
+            lastInboundAt: now - 1_000,
+          },
+        },
+      })
+
+      const approval = approvals.requestApproval({
+        category: 'human_loop',
+        title: 'Approve plugin install',
+        description: 'Need permission to install a plugin.',
+        data: {},
+        sessionId: 'session_1',
+        agentId: 'agent_1',
+      })
+
+      const dueAt = approval.createdAt + 61_000
+      const reminders = approvals.listPendingApprovalsNeedingConnectorNotification({
+        now: dueAt,
+        runningConnectors: [
+          { id: 'conn-1', agentId: 'agent_1', supportsSend: true, configuredTargets: [], recentChannelId: 'chat-42' },
+        ],
+      })
+
+      approvals.markApprovalConnectorNotificationSent(approval.id, {
+        at: dueAt,
+        connectorId: 'conn-1',
+        channelId: 'chat-42',
+        threadId: 'topic-7',
+        messageId: 'msg-9',
+      })
+
+      const afterSend = approvals.listPendingApprovalsNeedingConnectorNotification({
+        now: dueAt + 1_000,
+        runningConnectors: [
+          { id: 'conn-1', agentId: 'agent_1', supportsSend: true, configuredTargets: [], recentChannelId: 'chat-42' },
+        ],
+      })
+
+      const storedApproval = storage.loadApprovals()[approval.id]
+      console.log(JSON.stringify({
+        reminderCount: reminders.length,
+        reminder: reminders[0],
+        afterSendCount: afterSend.length,
+        storedApproval,
+      }))
+    `)
+
+    assert.equal(output.reminderCount, 1)
+    assert.equal(output.reminder.connectorId, 'conn-1')
+    assert.equal(output.reminder.channelId, 'chat-42')
+    assert.equal(output.reminder.threadId, 'topic-7')
+    assert.match(output.reminder.text, /Molly is waiting for your approval/i)
+    assert.equal(output.afterSendCount, 0)
+    assert.equal(output.storedApproval.connectorNotification.sentAt > 0, true)
+    assert.equal(output.storedApproval.connectorNotification.messageId, 'msg-9')
+  })
+
+  it('falls back to a running owned connector and respects retry cooldowns after failed sends', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const approvalsMod = await import('./src/lib/server/approvals.ts')
+      const storage = storageMod.default || storageMod
+      const approvals = approvalsMod.default || approvalsMod
+
+      const now = Date.now()
+      storage.saveSettings({
+        approvalConnectorNotifyEnabled: true,
+        approvalConnectorNotifyDelaySec: 30,
+      })
+      storage.saveAgents({
+        agent_2: {
+          id: 'agent_2',
+          name: 'Writer',
+          description: 'Test agent',
+          systemPrompt: 'You are Writer.',
+          provider: 'openai',
+          model: 'gpt-test',
+          plugins: [],
+          createdAt: now,
+          updatedAt: now,
+        },
+      })
+      storage.saveSessions({
+        session_plain: {
+          id: 'session_plain',
+          name: 'Non-connector session',
+          cwd: process.cwd(),
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          credentialId: null,
+          apiEndpoint: null,
+          claudeSessionId: null,
+          codexThreadId: null,
+          opencodeSessionId: null,
+          delegateResumeIds: { claudeCode: null, codex: null, opencode: null, gemini: null },
+          messages: [],
+          createdAt: now - 60_000,
+          lastActiveAt: now - 1_000,
+          sessionType: 'human',
+          agentId: 'agent_2',
+          plugins: [],
+        },
+      })
+
+      const approval = approvals.requestApproval({
+        category: 'task_tool',
+        title: 'Approve outbound outreach',
+        description: 'Need your approval before sending a message.',
+        data: {},
+        sessionId: 'session_plain',
+        agentId: 'agent_2',
+      })
+
+      const dueAt = approval.createdAt + 31_000
+      const first = approvals.listPendingApprovalsNeedingConnectorNotification({
+        now: dueAt,
+        runningConnectors: [
+          { id: 'conn-fallback', agentId: 'agent_2', supportsSend: true, configuredTargets: [], recentChannelId: 'dm-88' },
+        ],
+      })
+
+      approvals.markApprovalConnectorNotificationAttempt(approval.id, {
+        at: dueAt,
+        connectorId: 'conn-fallback',
+        channelId: 'dm-88',
+        lastError: 'connector temporarily unavailable',
+      })
+
+      const withinCooldown = approvals.listPendingApprovalsNeedingConnectorNotification({
+        now: dueAt + 5_000,
+        runningConnectors: [
+          { id: 'conn-fallback', agentId: 'agent_2', supportsSend: true, configuredTargets: [], recentChannelId: 'dm-88' },
+        ],
+      })
+
+      const afterCooldown = approvals.listPendingApprovalsNeedingConnectorNotification({
+        now: dueAt + (10 * 60_000) + 1_000,
+        runningConnectors: [
+          { id: 'conn-fallback', agentId: 'agent_2', supportsSend: true, configuredTargets: [], recentChannelId: 'dm-88' },
+        ],
+      })
+
+      const storedApproval = storage.loadApprovals()[approval.id]
+      console.log(JSON.stringify({
+        firstCount: first.length,
+        fallbackConnectorId: first[0]?.connectorId || null,
+        fallbackChannelId: first[0]?.channelId || null,
+        withinCooldownCount: withinCooldown.length,
+        afterCooldownCount: afterCooldown.length,
+        storedApproval,
+      }))
+    `)
+
+    assert.equal(output.firstCount, 1)
+    assert.equal(output.fallbackConnectorId, 'conn-fallback')
+    assert.equal(output.fallbackChannelId, 'dm-88')
+    assert.equal(output.withinCooldownCount, 0)
+    assert.equal(output.afterCooldownCount, 1)
+    assert.equal(output.storedApproval.connectorNotification.lastError, 'connector temporarily unavailable')
+  })
+})