@swarmclawai/swarmclaw 0.9.4 → 0.9.6

package/src/lib/server/connectors/manager.test.ts

@@ -994,7 +994,7 @@ describe('sanitizeConnectorOutboundContent', () => {
       storage.saveAgents({
         agent_1: {
           id: 'agent_1',
-          name: 'Hal',
+          name: 'Nova',
           provider: 'test-provider',
           model: 'test-model',
           plugins: [],
@@ -1020,7 +1020,7 @@ describe('sanitizeConnectorOutboundContent', () => {
       storage.saveSessions({
         agent_thread: {
           id: 'agent_thread',
-          name: 'Hal',
+          name: 'Nova',
           cwd: process.env.WORKSPACE_DIR,
           user: 'default',
           provider: 'test-provider',
@@ -1040,16 +1040,16 @@ describe('sanitizeConnectorOutboundContent', () => {
         sessionId: null,
         category: 'identity/preferences',
         title: 'Wife communication rule',
-        content: 'Wayde\\'s wife (+44 7958 047282): Do NOT respond unless she addresses Hal directly or mentions Hal directly. If unsure, verify whether the message is for Wayde or Hal before responding.',
+        content: 'Riley\\'s partner (+44 7700 900111): Do NOT respond unless she addresses Nova directly or mentions Nova directly. If unsure, verify whether the message is meant for the agent before responding.',
       })
 
       const connector = storage.loadConnectors().conn_1
       const response = await manager.routeConnectorMessageForTest(connector, {
         platform: 'whatsapp',
-        channelId: '447958047282@s.whatsapp.net',
-        senderId: '447958047282@s.whatsapp.net',
-        senderName: 'Wayde Wife',
-        text: 'Dinner is ready for Wayde.',
+        channelId: '447700900111@s.whatsapp.net',
+        senderId: '447700900111@s.whatsapp.net',
+        senderName: 'Riley Partner',
+        text: 'Dinner is ready for Riley.',
         messageId: 'in-quiet-1',
         isGroup: false,
       })
@@ -1070,6 +1070,128 @@ describe('sanitizeConnectorOutboundContent', () => {
     assert.equal(output.mainThreadMessageCount, 0)
   })
 
+  it('does not suppress other senders just because their name appears inside the matched quiet-boundary memory', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage')
+      const managerMod = await import('./src/lib/server/connectors/manager')
+      const providersMod = await import('./src/lib/providers/index')
+      const pluginsMod = await import('./src/lib/server/plugins')
+      const memoryDbMod = await import('./src/lib/server/memory/memory-db')
+      const storage = storageMod.default || storageMod
+      const manager = managerMod.default || managerMod
+      const providers = providersMod.default || providersMod
+      const plugins = pluginsMod.default || pluginsMod
+      const memoryDbApi = memoryDbMod.default || memoryDbMod
+      const memoryDb = memoryDbApi.getMemoryDb()
+
+      let providerCalls = 0
+      const now = Date.now()
+      providers.PROVIDERS['test-provider'] = {
+        id: 'test-provider',
+        name: 'Test Provider',
+        models: ['test-model'],
+        requiresApiKey: false,
+        requiresEndpoint: false,
+        handler: {
+          streamChat: async (opts) => {
+            providerCalls += 1
+            opts.write('data: ' + JSON.stringify({ t: 'r', text: 'Replying to Riley normally' }) + '\\n')
+            return ''
+          },
+        },
+      }
+
+      plugins.getPluginManager().registerBuiltin('test-quiet-boundary-connector-plugin-allow-riley', {
+        name: 'Test Quiet Boundary Connector Plugin Allow Riley',
+        connectors: [{
+          id: 'test-quiet-allow-riley',
+          name: 'Test Quiet Allow Riley',
+          description: 'Quiet boundary false-positive test connector',
+          startListener: async () => async () => {},
+          sendMessage: async () => ({ messageId: 'unused' }),
+        }],
+      })
+
+      storage.saveSettings({})
+      storage.saveAgents({
+        agent_1: {
+          id: 'agent_1',
+          name: 'Nova',
+          provider: 'test-provider',
+          model: 'test-model',
+          plugins: [],
+          threadSessionId: 'agent_thread',
+          createdAt: now,
+          updatedAt: now,
+        },
+      })
+      storage.saveConnectors({
+        conn_1: {
+          id: 'conn_1',
+          name: 'WhatsApp',
+          platform: 'test-quiet-allow-riley',
+          agentId: 'agent_1',
+          credentialId: null,
+          config: { inboundDebounceMs: 0 },
+          isEnabled: true,
+          status: 'stopped',
+          createdAt: now,
+          updatedAt: now,
+        },
+      })
+      storage.saveSessions({
+        agent_thread: {
+          id: 'agent_thread',
+          name: 'Nova',
+          cwd: process.env.WORKSPACE_DIR,
+          user: 'default',
+          provider: 'test-provider',
+          model: 'test-model',
+          claudeSessionId: null,
+          messages: [],
+          createdAt: now,
+          lastActiveAt: now,
+          sessionType: 'human',
+          agentId: 'agent_1',
+          plugins: [],
+        },
+      })
+
+      memoryDb.add({
+        agentId: 'agent_1',
+        sessionId: null,
+        category: 'identity/preferences',
+        title: 'Wife communication rule',
+        content: 'Riley\\'s partner (+44 7700 900111): Do NOT respond unless she addresses Nova directly or mentions Nova directly. If unsure, verify whether the message is meant for the agent before responding.',
+      })
+
+      const connector = storage.loadConnectors().conn_1
+      const response = await manager.routeConnectorMessageForTest(connector, {
+        platform: 'whatsapp',
+        channelId: '447700900123@s.whatsapp.net',
+        senderId: '447700900123@s.whatsapp.net',
+        senderName: 'Riley',
+        text: 'Did you see the last update?',
+        messageId: 'in-quiet-riley-1',
+        isGroup: false,
+      })
+
+      const sessions = storage.loadSessions()
+      const directSession = Object.values(sessions).find((entry) => entry.id !== 'agent_thread')
+      console.log(JSON.stringify({
+        response,
+        providerCalls,
+        directSessionMessageCount: directSession?.messages?.length || 0,
+        mainThreadMessageCount: sessions.agent_thread?.messages?.length || 0,
+      }))
+    `)
+
+    assert.equal(output.response, 'Replying to Riley normally')
+    assert.equal(output.providerCalls, 1)
+    assert.equal(output.directSessionMessageCount, 2)
+    assert.equal(output.mainThreadMessageCount, 2)
+  })
+
   it('requires an explicit target when a shared thread only has mirrored connector history', () => {
     const output = runWithTempDataDir(`
       const fs = await import('node:fs')

package/src/lib/server/plugins.test.ts

@@ -90,6 +90,269 @@ describe('plugin manager hook execution', () => {
     assert.deepEqual(withEnable, { original: true, patched: true })
   })
 
+  it('merges beforePromptBuild context and preserves first system prompt override', async () => {
+    const pluginA = uniquePluginId('before_prompt_build_a')
+    const pluginB = uniquePluginId('before_prompt_build_b')
+    const session = {
+      id: 'prompt-hook-session',
+      name: 'Prompt Hook Session',
+      cwd: process.cwd(),
+      user: 'tester',
+      provider: 'openai',
+      model: 'gpt-test',
+      claudeSessionId: null,
+      messages: [],
+      createdAt: Date.now(),
+      lastActiveAt: Date.now(),
+      plugins: [pluginA, pluginB],
+    }
+
+    getPluginManager().registerBuiltin(pluginA, {
+      name: 'Before Prompt Build A',
+      hooks: {
+        beforePromptBuild: () => ({
+          systemPrompt: 'system A',
+          prependContext: 'context A',
+          prependSystemContext: 'prepend A',
+        }),
+      },
+    })
+    getPluginManager().registerBuiltin(pluginB, {
+      name: 'Before Prompt Build B',
+      hooks: {
+        beforePromptBuild: () => ({
+          systemPrompt: 'system B',
+          prependContext: 'context B',
+          appendSystemContext: 'append B',
+        }),
+      },
+    })
+
+    const result = await getPluginManager().runBeforePromptBuild(
+      {
+        session,
+        prompt: 'base prompt',
+        message: 'hello',
+        history: [],
+        messages: [],
+      },
+      { enabledIds: [pluginA, pluginB] },
+    )
+
+    assert.deepEqual(result, {
+      systemPrompt: 'system A',
+      prependContext: 'context A\n\ncontext B',
+      prependSystemContext: 'prepend A',
+      appendSystemContext: 'append B',
+    })
+  })
+
+  it('applies beforeToolCall params merges and block results before legacy beforeToolExec', async () => {
+    const pluginA = uniquePluginId('before_tool_call_a')
+    const pluginB = uniquePluginId('before_tool_call_b')
+    const session = {
+      id: 'tool-hook-session',
+      name: 'Tool Hook Session',
+      cwd: process.cwd(),
+      user: 'tester',
+      provider: 'openai',
+      model: 'gpt-test',
+      claudeSessionId: null,
+      messages: [],
+      createdAt: Date.now(),
+      lastActiveAt: Date.now(),
+      plugins: [pluginA, pluginB],
+    }
+
+    getPluginManager().registerBuiltin(pluginA, {
+      name: 'Before Tool Call A',
+      hooks: {
+        beforeToolCall: () => ({
+          params: { patched: true },
+          warning: 'tool warning',
+        }),
+      },
+    })
+    getPluginManager().registerBuiltin(pluginB, {
+      name: 'Before Tool Call B',
+      hooks: {
+        beforeToolCall: ({ input }) => ({
+          block: true,
+          blockReason: `blocked with patched=${String(input?.patched)}`,
+        }),
+        beforeToolExec: () => ({ shouldNotRun: true }),
+      },
+    })
+
+    const result = await getPluginManager().runBeforeToolCall(
+      {
+        session,
+        toolName: 'shell',
+        input: { original: true },
+        runId: 'run-1',
+      },
+      { enabledIds: [pluginA, pluginB] },
+    )
+
+    assert.deepEqual(result, {
+      input: { original: true, patched: true },
+      blockReason: 'blocked with patched=true',
+      warning: 'tool warning',
+    })
+  })
+
+  it('applies beforeModelResolve overrides in plugin order', async () => {
+    const pluginA = uniquePluginId('before_model_resolve_a')
+    const pluginB = uniquePluginId('before_model_resolve_b')
+    const session = {
+      id: 'model-resolve-session',
+      name: 'Model Resolve Session',
+      cwd: process.cwd(),
+      user: 'tester',
+      provider: 'openai',
+      model: 'gpt-test',
+      claudeSessionId: null,
+      messages: [],
+      createdAt: Date.now(),
+      lastActiveAt: Date.now(),
+      plugins: [pluginA, pluginB],
+    }
+
+    getPluginManager().registerBuiltin(pluginA, {
+      name: 'Before Model Resolve A',
+      hooks: {
+        beforeModelResolve: () => ({
+          providerOverride: 'ollama',
+          modelOverride: 'llama-a',
+        }),
+      },
+    })
+    getPluginManager().registerBuiltin(pluginB, {
+      name: 'Before Model Resolve B',
+      hooks: {
+        beforeModelResolve: () => ({
+          modelOverride: 'llama-b',
+          apiEndpointOverride: 'http://127.0.0.1:11434',
+        }),
+      },
+    })
+
+    const result = await getPluginManager().runBeforeModelResolve(
+      {
+        session,
+        prompt: 'base prompt',
+        message: 'hello',
+        provider: session.provider,
+        model: session.model,
+        apiEndpoint: null,
+      },
+      { enabledIds: [pluginA, pluginB] },
+    )
+
+    assert.deepEqual(result, {
+      providerOverride: 'ollama',
+      modelOverride: 'llama-b',
+      apiEndpointOverride: 'http://127.0.0.1:11434',
+    })
+  })
+
+  it('chains toolResultPersist and beforeMessageWrite hooks', async () => {
+    const pluginA = uniquePluginId('tool_result_persist_a')
+    const pluginB = uniquePluginId('before_message_write_b')
+    const session = {
+      id: 'message-write-session',
+      name: 'Message Write Session',
+      cwd: process.cwd(),
+      user: 'tester',
+      provider: 'openai',
+      model: 'gpt-test',
+      claudeSessionId: null,
+      messages: [],
+      createdAt: Date.now(),
+      lastActiveAt: Date.now(),
+      plugins: [pluginA, pluginB],
+    }
+
+    getPluginManager().registerBuiltin(pluginA, {
+      name: 'Tool Result Persist A',
+      hooks: {
+        toolResultPersist: ({ message, toolName }) => ({
+          ...message,
+          text: `${message.text} [tool:${toolName}]`,
+        }),
+      },
+    })
+    getPluginManager().registerBuiltin(pluginB, {
+      name: 'Before Message Write B',
+      hooks: {
+        beforeMessageWrite: ({ message }) => ({
+          message: {
+            ...message,
+            text: `${message.text} [persisted]`,
+          },
+        }),
+      },
+    })
+
+    const persisted = await getPluginManager().runToolResultPersist(
+      {
+        session,
+        message: {
+          role: 'assistant',
+          text: 'tool output',
+          time: Date.now(),
+        },
+        toolName: 'shell',
+        toolCallId: 'call-1',
+      },
+      { enabledIds: [pluginA, pluginB] },
+    )
+    const writeResult = await getPluginManager().runBeforeMessageWrite(
+      {
+        session,
+        message: persisted,
+        phase: 'assistant_final',
+        runId: 'run-1',
+      },
+      { enabledIds: [pluginA, pluginB] },
+    )
+
+    assert.equal(writeResult.block, false)
+    assert.equal(writeResult.message.text, 'tool output [tool:shell] [persisted]')
+  })
+
+  it('blocks subagent spawning when a plugin hook rejects it', async () => {
+    const pluginId = uniquePluginId('subagent_spawning')
+
+    getPluginManager().registerBuiltin(pluginId, {
+      name: 'Subagent Spawning Hook',
+      hooks: {
+        subagentSpawning: () => ({
+          status: 'error',
+          error: 'blocked by lifecycle hook',
+        }),
+      },
+    })
+
+    const result = await getPluginManager().runSubagentSpawning(
+      {
+        parentSessionId: 'parent-1',
+        agentId: 'agent-1',
+        agentName: 'Agent One',
+        message: 'do the work',
+        cwd: process.cwd(),
+        mode: 'run',
+        threadRequested: false,
+      },
+      { enabledIds: [pluginId] },
+    )
+
+    assert.deepEqual(result, {
+      status: 'error',
+      error: 'blocked by lifecycle hook',
+    })
+  })
+
   it('chains text transforms in plugin order', async () => {
     const pluginA = uniquePluginId('transform_a')
     const pluginB = uniquePluginId('transform_b')