@swarmclawai/swarmclaw 0.7.2 → 0.7.3

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')
+  })
+})

package/src/lib/server/approvals-auto-approve.test.ts

@@ -0,0 +1,205 @@
+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-auto-'))
+  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 auto-approve', () => {
+  it('auto-approves tool access and plugin scaffolds when configured', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const approvalsMod = await import('./src/lib/server/approvals.ts')
+      const dataDirMod = await import('./src/lib/server/data-dir.ts')
+      const storage = storageMod.default || storageMod
+      const approvals = approvalsMod.default || approvalsMod
+      const dataDir = dataDirMod.DATA_DIR || dataDirMod.default?.DATA_DIR || dataDirMod['module.exports']?.DATA_DIR
+
+      storage.saveSettings({
+        approvalAutoApproveCategories: ['tool_access', 'plugin_scaffold'],
+      })
+
+      const now = Date.now()
+      storage.saveSessions({
+        session_auto: {
+          id: 'session_auto',
+          name: 'Auto Approval Test',
+          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,
+          lastActiveAt: now,
+          sessionType: 'human',
+          agentId: 'default',
+          plugins: [],
+        },
+      })
+
+      const toolApproval = await approvals.requestApprovalMaybeAutoApprove({
+        category: 'tool_access',
+        title: 'Enable Plugin: shell',
+        data: { toolId: 'shell', pluginId: 'shell' },
+        sessionId: 'session_auto',
+        agentId: 'default',
+      })
+
+      const pluginApproval = await approvals.requestApprovalMaybeAutoApprove({
+        category: 'plugin_scaffold',
+        title: 'Scaffold Plugin: auto-test.js',
+        data: {
+          filename: 'auto-test.js',
+          code: 'module.exports = { name: \"AutoTestPlugin\" }',
+          createdByAgentId: 'default',
+        },
+        sessionId: 'session_auto',
+        agentId: 'default',
+      })
+
+      const sessions = storage.loadSessions()
+      const pluginsDir = await import('node:path').then((path) => path.join(dataDir, 'plugins'))
+      const pluginPath = await import('node:path').then((path) => path.join(pluginsDir, 'auto-test.js'))
+
+      console.log(JSON.stringify({
+        categories: approvals.listAutoApprovableApprovalCategories(),
+        toolApprovalStatus: toolApproval.status,
+        pluginApprovalStatus: pluginApproval.status,
+        sessionPlugins: sessions.session_auto.plugins,
+        pluginExists: (await import('node:fs')).existsSync(pluginPath),
+      }))
+    `)
+
+    assert.equal(output.toolApprovalStatus, 'approved')
+    assert.equal(output.pluginApprovalStatus, 'approved')
+    assert.equal(Array.isArray(output.categories), true)
+    assert.equal(output.categories.includes('wallet_transfer'), true)
+    assert.equal(output.sessionPlugins.includes('shell'), true)
+    assert.equal(output.pluginExists, true)
+  })
+
+  it('can disable approvals platform-wide for fully autonomous execution', () => {
+    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
+
+      storage.saveSettings({
+        approvalsEnabled: false,
+      })
+
+      const approval = await approvals.requestApprovalMaybeAutoApprove({
+        category: 'human_loop',
+        title: 'Need an answer',
+        description: 'Should be auto-approved because approvals are disabled platform-wide.',
+        data: { question: 'Proceed?' },
+        agentId: 'default',
+        sessionId: null,
+      })
+
+      const stored = storage.loadApprovals()[approval.id]
+      console.log(JSON.stringify({
+        approvalStatus: approval.status,
+        storedStatus: stored?.status || null,
+      }))
+    `)
+
+    assert.equal(output.approvalStatus, 'approved')
+    assert.equal(output.storedStatus, 'approved')
+  })
+
+  it('adds a pending approval request message to the chat session when approvals are enabled', () => {
+    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({
+        approvalsEnabled: true,
+        approvalAutoApproveCategories: [],
+      })
+      storage.saveSessions({
+        session_chat: {
+          id: 'session_chat',
+          name: 'Approval Chat Test',
+          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,
+          lastActiveAt: now,
+          sessionType: 'human',
+          agentId: 'default',
+          plugins: [],
+        },
+      })
+
+      const approval = await approvals.requestApprovalMaybeAutoApprove({
+        category: 'tool_access',
+        title: 'Enable Plugin: shell',
+        description: 'Need shell access for a task.',
+        data: { toolId: 'shell', pluginId: 'shell' },
+        sessionId: 'session_chat',
+        agentId: 'default',
+      })
+
+      const session = storage.loadSessions().session_chat
+      const lastMessage = session.messages.at(-1)
+      console.log(JSON.stringify({
+        approvalStatus: approval.status,
+        messageCount: session.messages.length,
+        lastMessage,
+      }))
+    `)
+
+    assert.equal(output.approvalStatus, 'pending')
+    assert.equal(output.messageCount, 1)
+    assert.equal(output.lastMessage.role, 'assistant')
+    assert.equal(output.lastMessage.kind, 'system')
+    assert.match(output.lastMessage.text, /\"type\":\"plugin_request\"/)
+    assert.match(output.lastMessage.text, /\"pluginId\":\"shell\"/)
+  })
+})