@swarmclawai/swarmclaw 0.9.2 → 0.9.4

package/src/lib/server/session-reset-policy.test.ts

@@ -28,8 +28,16 @@ function makeSession(overrides: Partial<Session> = {}): Session {
 
 test('inferSessionResetType distinguishes direct, group, and thread sessions', () => {
   assert.equal(inferSessionResetType(makeSession()), 'direct')
-  assert.equal(inferSessionResetType(makeSession({ connectorContext: { isGroup: true } })), 'group')
-  assert.equal(inferSessionResetType(makeSession({ connectorContext: { threadId: 'thread-1' } })), 'thread')
+  assert.equal(inferSessionResetType(makeSession({
+    name: 'connector:group',
+    user: 'connector',
+    connectorContext: { isGroup: true },
+  })), 'group')
+  assert.equal(inferSessionResetType(makeSession({
+    name: 'connector:thread',
+    user: 'connector',
+    connectorContext: { threadId: 'thread-1' },
+  })), 'thread')
 })
 
 test('resolveSessionResetPolicy falls back to type defaults', () => {
@@ -37,7 +45,13 @@ test('resolveSessionResetPolicy falls back to type defaults', () => {
   assert.equal(direct.mode, 'idle')
   assert.equal(direct.idleTimeoutSec, 12 * 60 * 60)
 
-  const thread = resolveSessionResetPolicy({ session: makeSession({ connectorContext: { threadId: 'thread-1' } }) })
+  const thread = resolveSessionResetPolicy({
+    session: makeSession({
+      name: 'connector:thread',
+      user: 'connector',
+      connectorContext: { threadId: 'thread-1' },
+    }),
+  })
   assert.equal(thread.mode, 'idle')
   assert.equal(thread.idleTimeoutSec, 4 * 60 * 60)
 })

package/src/lib/server/session-reset-policy.ts

@@ -1,4 +1,5 @@
 import type { Agent, AppSettings, Session, SessionResetMode, SessionResetType } from '@/types'
+import { isDirectConnectorSession } from '@/lib/server/connectors/session-kind'
 
 export interface ResolvedSessionResetPolicy {
   type: SessionResetType
@@ -140,9 +141,10 @@ export function inferSessionResetType(
   opts?: { isGroup?: boolean | null; threadId?: string | null },
 ): SessionResetType {
   if ((session?.sessionType as string | undefined) === 'orchestrated') return 'main'
-  const threadId = opts?.threadId ?? session?.connectorContext?.threadId ?? null
+  const connectorContext = isDirectConnectorSession(session) ? session?.connectorContext : null
+  const threadId = opts?.threadId ?? connectorContext?.threadId ?? null
   if (threadId) return 'thread'
-  const isGroup = opts?.isGroup ?? session?.connectorContext?.isGroup ?? false
+  const isGroup = opts?.isGroup ?? connectorContext?.isGroup ?? false
   return isGroup ? 'group' : 'direct'
 }
 

package/src/lib/server/session-tools/connector.ts

@@ -13,6 +13,7 @@ import { normalizeToolInputArgs } from './normalize-tool-args'
 import { safeJsonParseObject } from '../json-utils'
 import { tryResolvePathWithinBaseDir } from '../path-utils'
 import { dedup, errorMessage } from '@/lib/shared-utils'
+import { isDirectConnectorSession } from '../connectors/session-kind'
 
 const CONNECTOR_ACTION_DEDUPE_TTL_MS = 30_000
 const CONNECTOR_TURN_SEND_TTL_MS = 180_000
@@ -341,11 +342,14 @@ function trimToString(value: unknown): string {
 
 function resolveSessionConnectorTargets(
   session: {
+    user?: string
+    name?: string
     connectorContext?: Record<string, unknown>
     messages?: Array<Record<string, unknown>>
   } | null | undefined,
   connectorId: string,
 ): Array<{ channelId: string; senderId?: string; senderName?: string }> {
+  if (!isDirectConnectorSession(session)) return []
   const targets: Array<{ channelId: string; senderId?: string; senderName?: string }> = []
   const seen = new Set<string>()
   const pushTarget = (target: { channelId: string; senderId?: string; senderName?: string } | null) => {
@@ -368,6 +372,7 @@ function resolveSessionConnectorTargets(
 
   const messages = Array.isArray(session?.messages) ? session.messages : []
   for (let i = messages.length - 1; i >= 0; i -= 1) {
+    if (messages[i]?.historyExcluded === true) continue
     const source = messages[i]?.source as Record<string, unknown> | undefined
     if (!source || trimToString(source.connectorId) !== connectorId) continue
     const channelId = trimToString(source.channelId)
@@ -386,8 +391,9 @@ function pickChannelTarget(params: {
   connector: { config?: Record<string, string> }
   connectorId: string
   to?: string
-  recentChannelId: string | null
   currentSession?: {
+    user?: string
+    name?: string
     connectorContext?: Record<string, unknown>
     messages?: Array<Record<string, unknown>>
   } | null
@@ -421,9 +427,6 @@ function pickChannelTarget(params: {
     const outbound = connector.config?.outboundTarget?.trim()
     if (outbound) channelId = outbound
   }
-  if (!channelId && params.recentChannelId) {
-    channelId = params.recentChannelId
-  }
   if (!channelId) {
     const allowed = parseCsv(connector.config?.allowedJids)
     if (allowed.length) channelId = allowed[0]
@@ -562,7 +565,6 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
     const {
       listRunningConnectors,
       sendConnectorMessage,
-      getConnectorRecentChannelId,
       scheduleConnectorFollowUp,
       performConnectorMessageAction,
     } = await import('../connectors/manager')
@@ -646,6 +648,7 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
 
     const currentSession = bctx.resolveCurrentSession?.()
     const sessionId = bctx.ctx?.sessionId || currentSession?.id || undefined
+    const connectorScopedSessionId = isDirectConnectorSession(currentSession) ? sessionId : undefined
 
     if (actionName === 'send' || actionName === 'send_voice_note' || actionName === 'schedule_followup') {
       const settings = loadSettings()
@@ -662,7 +665,6 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
         connector,
         connectorId: selected.id,
         to,
-        recentChannelId: getConnectorRecentChannelId(selected.id),
         currentSession,
       })
       if (target.error) return target.error
@@ -728,7 +730,7 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
         const sent = await sendConnectorMessage({
           connectorId: selected.id, channelId, text: '', mediaPath: voicePath, mimeType: outboundMimeType,
           fileName: fileName?.trim() || 'voicenote.mp3', caption: caption?.trim() || undefined, ptt: ptt ?? true,
-          sessionId,
+          sessionId: connectorScopedSessionId,
           replyToMessageId: replyToMessageId?.trim() || undefined,
           threadId: threadId?.trim() || undefined,
         })
@@ -768,7 +770,7 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
           connectorId: selected.id,
           channelId,
           text: followupText,
-          sessionId,
+          sessionId: connectorScopedSessionId,
           delaySec: followupDelay,
           dedupeKey: dedupeKey?.trim() || undefined,
           imageUrl: media.imageUrl,
@@ -793,7 +795,7 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
 
       const sent = await sendConnectorMessage({
         connectorId: selected.id, channelId, text: message?.trim() || '',
-        sessionId,
+        sessionId: connectorScopedSessionId,
         imageUrl: media.imageUrl, fileUrl: media.fileUrl, mediaPath: media.mediaPath,
         mimeType: mimeType?.trim() || undefined, fileName: fileName?.trim() || undefined,
         caption: caption?.trim() || undefined,
@@ -815,7 +817,6 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
         connector: resolved.connector,
         connectorId: selected.id,
         to,
-        recentChannelId: getConnectorRecentChannelId(selected.id),
         currentSession,
       })
       if (target.error) return target.error

package/src/lib/server/session-tools/crud.ts

@@ -46,6 +46,8 @@ import { safePath, findBinaryOnPath } from './context'
 import { normalizeToolInputArgs } from './normalize-tool-args'
 import type { BoardTask } from '@/types'
 import { dedup } from '@/lib/shared-utils'
+import { isDirectConnectorSession } from '../connectors/session-kind'
+import { buildManageSkillsDescription, executeManageSkillsAction } from './skills'
 
 // ---------------------------------------------------------------------------
 // Document helpers
@@ -258,8 +260,10 @@ function deriveScheduleFollowupTarget(sessionId: string | null | undefined): {
     }
   }
 
-  const contextTarget = pickSourceFields(session.connectorContext || undefined)
-  if (contextTarget.followupConnectorId && contextTarget.followupChannelId) return contextTarget
+  if (isDirectConnectorSession(session as { user?: string; name?: string })) {
+    const contextTarget = pickSourceFields(session.connectorContext || undefined)
+    if (contextTarget.followupConnectorId && contextTarget.followupChannelId) return contextTarget
+  }
 
   const messages = Array.isArray(session.messages) ? session.messages : []
   for (let i = messages.length - 1; i >= 0; i -= 1) {
@@ -447,12 +451,17 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
       if (ctx?.projectId) {
         description += `\n\nCurrent project context: "${ctx.projectName || ctx.projectId}" (projectId "${ctx.projectId}"). Omit "projectId" to link the secret to this active project.`
       }
+    } else if (toolKey === 'manage_skills') {
+      description = buildManageSkillsDescription()
     }
 
     tools.push(
       tool(
         async (rawArgs) => {
           const normalized = normalizeToolInputArgs((rawArgs ?? {}) as Record<string, unknown>)
+          if (toolKey === 'manage_skills') {
+            return executeManageSkillsAction(normalized, bctx)
+          }
           const action = normalized.action as string | undefined
           const id = normalized.id as string | undefined
           const data = normalized.data as string | undefined
@@ -881,11 +890,36 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
         {
           name: toolKey,
           description,
-          schema: z.object({
-            action: z.enum(['list', 'get', 'create', 'update', 'delete']).describe('The CRUD action to perform'),
-            id: z.string().optional().describe('Resource ID (required for get, update, delete)'),
-            data: z.string().optional().describe('JSON string of fields for create/update'),
-          }).passthrough(),
+          schema: toolKey === 'manage_skills'
+            ? z.object({
+                action: z.enum([
+                  'list',
+                  'get',
+                  'create',
+                  'update',
+                  'delete',
+                  'status',
+                  'search_available',
+                  'recommend_for_task',
+                  'attach',
+                  'install',
+                ]).describe('The manage_skills action to perform'),
+                id: z.string().optional().describe('Stored skill ID or runtime skill selector'),
+                skillId: z.string().optional().describe('Alternate skill selector'),
+                name: z.string().optional().describe('Skill name or marketplace name'),
+                query: z.string().optional().describe('Search query or task description'),
+                task: z.string().optional().describe('Task description for skill recommendation'),
+                url: z.string().optional().describe('Remote skill URL for install'),
+                approvalId: z.string().optional().describe('Approved install request id'),
+                attach: z.boolean().optional().describe('Attach the skill to the current agent after install'),
+                agentId: z.string().optional().describe('Target agent id for attach'),
+                data: z.string().optional().describe('JSON string of fields for create/update'),
+              }).passthrough()
+            : z.object({
+                action: z.enum(['list', 'get', 'create', 'update', 'delete']).describe('The CRUD action to perform'),
+                id: z.string().optional().describe('Resource ID (required for get, update, delete)'),
+                data: z.string().optional().describe('JSON string of fields for create/update'),
+              }).passthrough(),
         },
       ),
     )

package/src/lib/server/session-tools/delegate.ts

@@ -931,13 +931,13 @@ const DelegatePlugin: Plugin = {
   name: 'Core Delegate',
   description: 'Delegate complex multi-file tasks to specialized CLI backends or other agents.',
   hooks: {
-    getCapabilityDescription: () => 'I can hand off deep coding work to Claude Code, Codex, or Gemini CLI (`delegate`) for complex multi-file refactors and code generation. Resume IDs may come back via `[delegate_meta]`.',
-    getOperatingGuidance: () => ['CRITICAL: `execute_command` (not delegation) for running servers, installs, scripts. Delegation sessions end and kill processes.', 'Delegate only for deep multi-file code work: refactors, debugging, generation, test suites.'],
+    getCapabilityDescription: () => 'I can hand off coding work to Claude Code, Codex, OpenCode, or Gemini CLI (`delegate`) for file creation, refactoring, debugging, code generation, and multi-file edits. Resume IDs may come back via `[delegate_meta]`.',
+    getOperatingGuidance: () => ['CRITICAL: `execute_command` (not delegation) for running servers, installs, scripts. Delegation sessions end and kill processes.', 'Delegate for code tasks: writing/creating files, refactors, debugging, generation, test suites, data exports to files.'],
   } as PluginHooks,
   tools: [
     {
       name: 'delegate',
-      description: 'Delegate to a specialized backend (Claude, Codex, OpenCode, Gemini). Supports background jobs with action=status|list|wait|cancel.',
+      description: 'Delegate to a specialized backend (Claude, Codex, OpenCode, Gemini) for code tasks: writing files, refactoring, debugging, code generation, and multi-file edits. Supports background jobs with action=status|list|wait|cancel.',
       parameters: {
         type: 'object',
         properties: {

package/src/lib/server/session-tools/index.ts

@@ -45,6 +45,7 @@ import { buildExtractTools } from './extract'
 import { buildTableTools } from './table'
 import { buildCrawlTools } from './crawl'
 import { buildGoogleWorkspaceTools } from './google-workspace'
+import { buildSkillRuntimeTools } from './skill-runtime'
 import './connector'
 import { normalizeToolInputArgs } from './normalize-tool-args'
 import { enforceFileAccessPolicy } from './file-access-policy'
@@ -172,6 +173,7 @@ export async function buildSessionTools(cwd: string, enabledPlugins: string[], c
       ['calendar', buildCalendarTools],
       ['replicate', buildReplicateTools],
       ['google_workspace', buildGoogleWorkspaceTools],
+      ['use_skill', buildSkillRuntimeTools],
       ['mailbox', buildMailboxTools],
       ['ask_human', buildHumanLoopTools],
       ['document', buildDocumentTools],

package/src/lib/server/session-tools/manage-skills.test.ts

@@ -0,0 +1,194 @@
+import { after, before, describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import type { Agent, Skill } from '@/types'
+
+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 workspaceDir = ''
+let buildCrudTools: Awaited<typeof import('./crud')>['buildCrudTools']
+let loadSkills: Awaited<typeof import('../storage')>['loadSkills']
+let loadAgent: Awaited<typeof import('../storage')>['loadAgent']
+let saveAgents: Awaited<typeof import('../storage')>['saveAgents']
+let saveSessions: Awaited<typeof import('../storage')>['saveSessions']
+let upsertApproval: Awaited<typeof import('../storage')>['upsertApproval']
+
+function buildManageSkillsTool() {
+  const tools = buildCrudTools({
+    cwd: workspaceDir,
+    ctx: { sessionId: 'skill-session', agentId: 'agent-skill-test', platformAssignScope: 'self' },
+    hasPlugin: (name) => name === 'manage_skills',
+    hasTool: (name) => name === 'manage_skills',
+    cleanupFns: [],
+    commandTimeoutMs: 1_000,
+    claudeTimeoutMs: 1_000,
+    cliProcessTimeoutMs: 1_000,
+    persistDelegateResumeId: () => {},
+    readStoredDelegateResumeId: () => null,
+    resolveCurrentSession: () => null,
+    activePlugins: ['manage_skills', 'google_workspace'],
+  })
+  const tool = tools.find((entry) => entry.name === 'manage_skills')
+  assert.ok(tool, 'expected manage_skills tool')
+  return tool!
+}
+
+before(async () => {
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-manage-skills-'))
+  workspaceDir = path.join(tempDir, 'workspace')
+  process.env.DATA_DIR = path.join(tempDir, 'data')
+  process.env.WORKSPACE_DIR = workspaceDir
+  process.env.SWARMCLAW_BUILD_MODE = '1'
+  fs.mkdirSync(process.env.DATA_DIR, { recursive: true })
+  fs.mkdirSync(workspaceDir, { recursive: true })
+
+  const crudMod = await import('./crud')
+  buildCrudTools = crudMod.buildCrudTools
+
+  const storageMod = await import('../storage')
+  loadSkills = storageMod.loadSkills
+  loadAgent = storageMod.loadAgent
+  saveAgents = storageMod.saveAgents
+  saveSessions = storageMod.saveSessions
+  upsertApproval = storageMod.upsertApproval
+
+  saveAgents({
+    'agent-skill-test': {
+      id: 'agent-skill-test',
+      name: 'Skill Tester',
+      provider: 'openai',
+      model: 'gpt-test',
+      plugins: ['manage_skills'],
+      tools: ['manage_skills'],
+      skillIds: [],
+      platformAssignScope: 'self',
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    } satisfies Agent,
+  })
+  saveSessions({
+    'skill-session': {
+      id: 'skill-session',
+      name: 'Skill Session',
+      cwd: workspaceDir,
+      user: 'tester',
+      provider: 'openai',
+      model: 'gpt-test',
+      messages: [],
+      createdAt: Date.now(),
+      lastActiveAt: Date.now(),
+      sessionType: 'human',
+      agentId: 'agent-skill-test',
+      plugins: ['manage_skills'],
+      heartbeatEnabled: false,
+    },
+  })
+})
+
+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('manage_skills runtime actions', () => {
+  it('status reports resolved local skills with eligibility and metadata', async () => {
+    const manageSkills = buildManageSkillsTool()
+    const created = await manageSkills.invoke({
+      action: 'create',
+      name: 'workspace-helper',
+      description: 'Automate workspace docs.',
+      content: '# Workspace Helper\nUse the workspace workflow.',
+      toolNames: ['google_workspace'],
+      capabilities: ['docs', 'workspace'],
+    })
+    const createdSkill = JSON.parse(String(created)) as Skill
+
+    const raw = await manageSkills.invoke({ action: 'status', query: 'workspace docs' })
+    const result = JSON.parse(String(raw)) as Array<Record<string, unknown>>
+
+    const statusEntry = result.find((entry) => entry.storageId === createdSkill.id)
+    assert.ok(statusEntry)
+    assert.equal(statusEntry?.eligible, true)
+    assert.deepEqual(statusEntry?.toolNames, ['google_workspace'])
+  })
+
+  it('attach materializes a discovered project skill and binds it to the current agent', async () => {
+    const localSkillDir = path.join(workspaceDir, 'skills', 'project-helper')
+    fs.mkdirSync(localSkillDir, { recursive: true })
+    fs.writeFileSync(path.join(localSkillDir, 'SKILL.md'), `---
+name: project-helper
+description: Project-local helper.
+metadata:
+  openclaw:
+    toolNames: [google_workspace]
+---
+# Project Helper
+
+Use the project helper.
+`)
+
+    const manageSkills = buildManageSkillsTool()
+    const raw = await manageSkills.invoke({
+      action: 'attach',
+      name: 'project-helper',
+    })
+    const result = JSON.parse(String(raw)) as Record<string, unknown>
+    const skillId = String(result.skillId || '')
+    const agent = loadAgent('agent-skill-test') as Agent
+
+    assert.ok(skillId)
+    assert.ok(loadSkills()[skillId], 'discovered skill copied into managed storage')
+    assert.ok(agent.skillIds?.includes(skillId), 'skill attached to current agent')
+  })
+
+  it('install is approval-gated and can install a remote skill after approval', async () => {
+    const manageSkills = buildManageSkillsTool()
+    const firstRaw = await manageSkills.invoke({
+      action: 'install',
+      name: 'remote-helper',
+      url: 'https://clawhub.ai/skills/remote-helper',
+      content: '# Remote Helper\nUse the remote helper.',
+      attach: true,
+    })
+    const first = JSON.parse(String(firstRaw)) as Record<string, unknown>
+    const approval = first.approval as { id: string }
+
+    assert.equal(first.requiresApproval, true)
+    assert.ok(approval?.id)
+
+    upsertApproval(approval.id, {
+      ...(first.approval as Record<string, unknown>),
+      status: 'approved',
+      updatedAt: Date.now(),
+    })
+
+    const secondRaw = await manageSkills.invoke({
+      action: 'install',
+      name: 'remote-helper',
+      url: 'https://clawhub.ai/skills/remote-helper',
+      content: '# Remote Helper\nUse the remote helper.',
+      attach: true,
+      approvalId: approval.id,
+    })
+    const second = JSON.parse(String(secondRaw)) as Record<string, unknown>
+    const installedSkill = second.skill as Skill
+    const agent = loadAgent('agent-skill-test') as Agent
+
+    assert.equal(second.ok, true)
+    assert.ok(installedSkill?.id)
+    assert.ok(loadSkills()[installedSkill.id])
+    assert.ok(agent.skillIds?.includes(installedSkill.id), 'approved install can attach to the agent')
+  })
+})