@swarmclawai/swarmclaw 0.7.3 → 0.7.4

package/src/lib/server/eval/runner.ts

@@ -1,3 +1,5 @@
+import fs from 'node:fs'
+import path from 'node:path'
 import { genId } from '@/lib/id'
 import type { EvalScenario, EvalRun, EvalSuiteResult } from './types'
 import { getScenario, EVAL_SCENARIOS } from './scenarios'
@@ -5,8 +7,15 @@ import { scoreCriteria } from './scorer'
 import { saveEvalRun } from './store'
 import { loadSessions, saveSessions, loadAgents, loadCredentials, decryptKey } from '../storage'
 import { executeSessionChatTurn } from '../chat-execution'
+import { WORKSPACE_DIR } from '../data-dir'
 import type { Session } from '@/types'
 
+export function resolveEvalSessionCwd(runId: string): string {
+  const dir = path.join(WORKSPACE_DIR, 'evals', runId)
+  fs.mkdirSync(dir, { recursive: true })
+  return dir
+}
+
 export async function runEvalScenario(scenarioId: string, agentId: string): Promise<EvalRun> {
   const scenario = getScenario(scenarioId)
   if (!scenario) throw new Error(`Unknown eval scenario: ${scenarioId}`)
@@ -18,6 +27,7 @@ export async function runEvalScenario(scenarioId: string, agentId: string): Prom
   const runId = genId()
   const sessionId = `eval-${runId}`
   const now = Date.now()
+  const sessionCwd = resolveEvalSessionCwd(runId)
 
   const run: EvalRun = {
     id: runId,
@@ -36,7 +46,7 @@ export async function runEvalScenario(scenarioId: string, agentId: string): Prom
   const evalSession: Session = {
     id: sessionId,
     name: `Eval: ${scenario.name}`,
-    cwd: process.cwd(),
+    cwd: sessionCwd,
     user: 'eval-runner',
     provider: (agent.provider as Session['provider']) ?? 'anthropic',
     model: (agent.model as string) ?? '',

package/src/lib/server/eval/store.ts

@@ -1,8 +1,9 @@
 import Database from 'better-sqlite3'
 import path from 'path'
 import type { EvalRun } from './types'
+import { DATA_DIR } from '../data-dir'
 
-const DB_PATH = path.join(process.cwd(), 'data', 'eval-runs.db')
+const DB_PATH = path.join(DATA_DIR, 'eval-runs.db')
 
 let db: Database.Database | null = null
 

package/src/lib/server/heartbeat-service.ts

@@ -1,5 +1,11 @@
 import fs from 'fs'
 import path from 'path'
+import {
+  DEFAULT_HEARTBEAT_ACK_MAX_CHARS,
+  DEFAULT_HEARTBEAT_INTERVAL_SEC,
+  DEFAULT_HEARTBEAT_SHOW_ALERTS,
+  DEFAULT_HEARTBEAT_SHOW_OK,
+} from '@/lib/heartbeat-defaults'
 import { loadAgents, loadSessions, loadSettings } from './storage'
 import { enqueueSessionRun, getSessionRunState } from './session-run-manager'
 import { log } from './logger'
@@ -275,7 +281,7 @@ function resolveNum(obj: Record<string, any>, key: string, current: number): num
 
 function heartbeatConfigForSession(session: any, settings: Record<string, any>, agents: Record<string, any>): HeartbeatConfig {
   // Global defaults — 30 min interval (was 120s)
-  let intervalSec = resolveInterval(settings, 1800)
+  let intervalSec = resolveInterval(settings, DEFAULT_HEARTBEAT_INTERVAL_SEC)
   const globalPrompt = (typeof settings.heartbeatPrompt === 'string' && settings.heartbeatPrompt.trim())
     ? settings.heartbeatPrompt.trim()
     : DEFAULT_HEARTBEAT_PROMPT
@@ -283,9 +289,9 @@ function heartbeatConfigForSession(session: any, settings: Record<string, any>,
   let enabled = intervalSec > 0
   let prompt = globalPrompt
   let model: string | null = resolveStr(settings, 'heartbeatModel', null)
-  let ackMaxChars = resolveNum(settings, 'heartbeatAckMaxChars', 300)
-  let showOk = resolveBool(settings, 'heartbeatShowOk', false)
-  let showAlerts = resolveBool(settings, 'heartbeatShowAlerts', true)
+  let ackMaxChars = resolveNum(settings, 'heartbeatAckMaxChars', DEFAULT_HEARTBEAT_ACK_MAX_CHARS)
+  let showOk = resolveBool(settings, 'heartbeatShowOk', DEFAULT_HEARTBEAT_SHOW_OK)
+  let showAlerts = resolveBool(settings, 'heartbeatShowAlerts', DEFAULT_HEARTBEAT_SHOW_ALERTS)
   let target: string | null = resolveStr(settings, 'heartbeatTarget', null)
 
   // Agent layer overrides

package/src/lib/server/main-agent-loop.ts

@@ -66,11 +66,13 @@ export interface HandleMainLoopRunResultInput {
   estimatedCost?: number
 }
 
-export function isMainSession(_session: unknown): boolean {
+export function isMainSession(session: unknown): boolean {
+  void session
   return false
 }
 
-export function buildMainLoopHeartbeatPrompt(_session: unknown, fallbackPrompt: string): string {
+export function buildMainLoopHeartbeatPrompt(session: unknown, fallbackPrompt: string): string {
+  void session
   return fallbackPrompt
 }
 
@@ -82,18 +84,23 @@ export function stripMainLoopMetaForPersistence(text: string): string {
     .trim()
 }
 
-export function getMainLoopStateForSession(_sessionId: string): MainLoopState | null {
+export function getMainLoopStateForSession(sessionId: string): MainLoopState | null {
+  void sessionId
   return null
 }
 
-export function setMainLoopStateForSession(_sessionId: string, _patch: Partial<MainLoopState>): MainLoopState | null {
+export function setMainLoopStateForSession(sessionId: string, patch: Partial<MainLoopState>): MainLoopState | null {
+  void sessionId
+  void patch
   return null
 }
 
-export function pushMainLoopEventToMainSessions(_input: PushMainLoopEventInput): number {
+export function pushMainLoopEventToMainSessions(input: PushMainLoopEventInput): number {
+  void input
   return 0
 }
 
-export function handleMainLoopRunResult(_input: HandleMainLoopRunResultInput): MainLoopFollowupRequest | null {
+export function handleMainLoopRunResult(input: HandleMainLoopRunResultInput): MainLoopFollowupRequest | null {
+  void input
   return null
 }

package/src/lib/server/openclaw-exec-config.ts

@@ -8,7 +8,8 @@ const DEFAULT_CONFIG: ExecApprovalConfig = {
 }
 
 /** Fetch the gateway's global exec approval config. */
-export async function getExecConfig(_agentId?: string): Promise<ExecApprovalSnapshot> {
+export async function getExecConfig(agentId?: string): Promise<ExecApprovalSnapshot> {
+  void agentId
   const gw = await ensureGatewayConnected()
   if (!gw) throw new Error('Gateway not connected')
 
@@ -21,10 +22,11 @@ export async function getExecConfig(_agentId?: string): Promise<ExecApprovalSnap
 
 /** Save exec approval config with hash-based conflict retry (up to 3 attempts) */
 export async function setExecConfig(
-  _agentId: string,
+  agentId: string,
   config: ExecApprovalConfig,
   baseHash: string,
 ): Promise<{ ok: boolean; hash: string }> {
+  void agentId
   const gw = await ensureGatewayConnected()
   if (!gw) throw new Error('Gateway not connected')
 

package/src/lib/server/openclaw-gateway.ts

@@ -3,6 +3,7 @@ import { randomUUID } from 'crypto'
 import { wsConnect, buildOpenClawConnectParams } from '../providers/openclaw'
 import { loadAgents, loadCredentials, decryptKey } from './storage'
 import { notify, notifyWithPayload } from './ws-hub'
+import { getGatewayProfile, getGatewayProfiles, resolvePrimaryAgentRoute } from './agent-runtime-config'
 
 // --- Types ---
 
@@ -19,19 +20,22 @@ type EventHandler = (payload: unknown) => void
 const GK = '__swarmclaw_ocgateway__' as const
 
 interface GatewayState {
-  instance: OpenClawGateway | null
+  instances: Map<string, OpenClawGateway>
+  activeKey: string | null
 }
 
 function getState(): GatewayState {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const g = globalThis as any
-  if (!g[GK]) g[GK] = { instance: null }
+  if (!g[GK]) g[GK] = { instances: new Map<string, OpenClawGateway>(), activeKey: null }
   return g[GK] as GatewayState
 }
 
 // --- Helper: resolve gateway config from first OpenClaw agent ---
 
 interface GatewayConfig {
+  key: string
+  profileId?: string | null
   wsUrl: string
   token: string | undefined
 }
@@ -43,27 +47,79 @@ function normalizeWsUrl(raw: string): string {
   return url.replace(/^http:/i, 'ws:').replace(/^https:/i, 'wss:')
 }
 
-export function resolveGatewayConfig(): GatewayConfig | null {
-  const agents = loadAgents({ includeTrashed: true })
+function resolveTokenForCredential(credentialId?: string | null): string | undefined {
+  const id = typeof credentialId === 'string' && credentialId.trim() ? credentialId.trim() : ''
+  if (!id) return undefined
   const creds = loadCredentials()
+  const cred = creds[id]
+  if (!cred?.encryptedKey) return undefined
+  try {
+    return decryptKey(cred.encryptedKey)
+  } catch {
+    return undefined
+  }
+}
+
+export function resolveGatewayConfig(target?: {
+  profileId?: string | null
+  agentId?: string | null
+}): GatewayConfig | null {
+  const profileId = typeof target?.profileId === 'string' ? target.profileId.trim() : ''
+  if (profileId) {
+    const profile = getGatewayProfile(profileId)
+    if (!profile) return null
+    return {
+      key: `profile:${profile.id}`,
+      profileId: profile.id,
+      wsUrl: profile.wsUrl ? normalizeWsUrl(profile.wsUrl) : normalizeWsUrl(profile.endpoint),
+      token: resolveTokenForCredential(profile.credentialId),
+    }
+  }
+
+  const agentId = typeof target?.agentId === 'string' ? target.agentId.trim() : ''
+  if (agentId) {
+    const agents = loadAgents({ includeTrashed: true })
+    const agent = agents[agentId]
+    const route = resolvePrimaryAgentRoute(agent)
+    if (route?.provider === 'openclaw') {
+      return {
+        key: route.gatewayProfileId ? `profile:${route.gatewayProfileId}` : `agent:${agentId}`,
+        profileId: route.gatewayProfileId ?? null,
+        wsUrl: normalizeWsUrl(route.apiEndpoint || 'ws://127.0.0.1:18789'),
+        token: resolveTokenForCredential(route.credentialId),
+      }
+    }
+  }
+
+  const gatewayProfiles = getGatewayProfiles('openclaw')
+  if (gatewayProfiles[0]) {
+    const profile = gatewayProfiles[0]
+    return {
+      key: `profile:${profile.id}`,
+      profileId: profile.id,
+      wsUrl: profile.wsUrl ? normalizeWsUrl(profile.wsUrl) : normalizeWsUrl(profile.endpoint),
+      token: resolveTokenForCredential(profile.credentialId),
+    }
+  }
+
+  const agents = loadAgents({ includeTrashed: true })
   for (const agent of Object.values(agents)) {
     if (agent?.provider !== 'openclaw') continue
     const wsUrl = agent.apiEndpoint
       ? normalizeWsUrl(agent.apiEndpoint)
       : 'ws://127.0.0.1:18789'
-    let token: string | undefined
-    if (agent.credentialId) {
-      const cred = creds[agent.credentialId]
-      if (cred?.encryptedKey) {
-        try { token = decryptKey(cred.encryptedKey) } catch { /* ignore */ }
-      }
+    return {
+      key: `agent:${agent.id}`,
+      profileId: agent.gatewayProfileId ?? null,
+      wsUrl,
+      token: resolveTokenForCredential(agent.credentialId),
     }
-    return { wsUrl, token }
   }
   return null
 }
 
 export function hasOpenClawAgents(): boolean {
+  if (getGatewayProfiles('openclaw').length > 0) return true
   const agents = loadAgents({ includeTrashed: true })
   return Object.values(agents).some((a) => a?.provider === 'openclaw' && !a.trashedAt)
 }
@@ -253,47 +309,78 @@ export class OpenClawGateway {
 
 // --- Singleton access ---
 
-export function getGateway(): OpenClawGateway | null {
-  return getState().instance
+export function getGateway(profileId?: string | null): OpenClawGateway | null {
+  const state = getState()
+  const key = typeof profileId === 'string' && profileId.trim() ? `profile:${profileId.trim()}` : null
+  if (key) {
+    return state.instances.get(key) || null
+  }
+  if (state.activeKey) {
+    return state.instances.get(state.activeKey) || null
+  }
+  for (const instance of state.instances.values()) {
+    if (instance.connected) return instance
+  }
+  return null
 }
 
-export async function ensureGatewayConnected(): Promise<OpenClawGateway | null> {
+export async function ensureGatewayConnected(target?: {
+  profileId?: string | null
+  agentId?: string | null
+}): Promise<OpenClawGateway | null> {
   const state = getState()
-  if (state.instance?.connected) return state.instance
-
-  const config = resolveGatewayConfig()
+  const config = resolveGatewayConfig(target)
   if (!config) return null
-
-  if (!state.instance) {
-    state.instance = new OpenClawGateway()
+  const existing = state.instances.get(config.key)
+  if (existing?.connected) {
+    state.activeKey = config.key
+    return existing
   }
 
-  const ok = await state.instance.connect(config.wsUrl, config.token)
-  return ok ? state.instance : null
+  const instance = existing || new OpenClawGateway()
+  state.instances.set(config.key, instance)
+  const ok = await instance.connect(config.wsUrl, config.token)
+  if (ok) {
+    state.activeKey = config.key
+    return instance
+  }
+  return null
 }
 
-export function disconnectGateway() {
+export function disconnectGateway(profileId?: string | null) {
   const state = getState()
-  if (state.instance) {
-    state.instance.disconnect()
-    state.instance = null
+  const key = typeof profileId === 'string' && profileId.trim() ? `profile:${profileId.trim()}` : null
+  if (key) {
+    const instance = state.instances.get(key)
+    if (instance) {
+      instance.disconnect()
+      state.instances.delete(key)
+      if (state.activeKey === key) state.activeKey = null
+    }
+    return
+  }
+  for (const [instanceKey, instance] of state.instances.entries()) {
+    instance.disconnect()
+    state.instances.delete(instanceKey)
   }
+  state.activeKey = null
 }
 
 /** Manual connect with explicit URL/token (used by gateway connection panel) */
-export async function manualConnect(url?: string, token?: string): Promise<boolean> {
+export async function manualConnect(url?: string, token?: string, profileId?: string | null): Promise<boolean> {
   const state = getState()
-  if (state.instance?.connected) {
-    state.instance.disconnect()
+  const config = resolveGatewayConfig({ profileId: profileId || null })
+  const key = profileId ? `profile:${profileId}` : '__manual__'
+  const instance = state.instances.get(key) || new OpenClawGateway()
+  if (instance.connected) {
+    instance.disconnect()
   }
-
-  const config = resolveGatewayConfig()
+  state.instances.set(key, instance)
   const wsUrl = url ? normalizeWsUrl(url) : config?.wsUrl ?? 'ws://127.0.0.1:18789'
   const resolvedToken = token ?? config?.token
-
-  if (!state.instance) {
-    state.instance = new OpenClawGateway()
+  const ok = await instance.connect(wsUrl, resolvedToken)
+  if (ok) {
+    state.activeKey = key
   }
-
-  return state.instance.connect(wsUrl, resolvedToken)
+  return ok
 }

package/src/lib/server/orchestrator-lg.ts

@@ -612,8 +612,7 @@ export async function executeLangGraphOrchestrator(
   const completeMatch = finalResult.match(/ORCHESTRATION_COMPLETE:\s*([\s\S]+)/)
   const summary = completeMatch ? completeMatch[1].trim() : finalResult
   
-  // Append meta so the main-loop knows we are done
-  return `${summary}\n\n[MAIN_LOOP_META] {"status":"ok", "follow_up":false, "summary":${JSON.stringify(summary.slice(0, 300))}, "mission_task_id":${JSON.stringify(taskId || null)}}`
+  return summary
 }
 
 /**

package/src/lib/server/orchestrator.ts

@@ -86,6 +86,7 @@ async function executeOrchestratorLegacy(
   sessionId: string,
   taskId?: string,
 ): Promise<string> {
+  void taskId
   const allAgents = loadAgents()
   const sessions = loadSessions()
   const session = sessions[sessionId]
@@ -241,7 +242,7 @@ async function executeOrchestratorLegacy(
 
       if (cmd.done) {
         result = cmd.summary || fullText
-        return `${result}\n\n[MAIN_LOOP_META] {"status":"ok", "follow_up":false, "summary":${JSON.stringify(result.slice(0, 300))}, "mission_task_id":${JSON.stringify(taskId || null)}}`
+        return result
       }
     }
 
@@ -256,7 +257,7 @@ async function executeOrchestratorLegacy(
     result = `Loop stopped after reaching max turns (${maxTurns}).`
   }
 
-  return `${result}\n\n[MAIN_LOOP_META] {"status":"ok", "follow_up":false, "summary":${JSON.stringify(result.slice(0, 300))}, "mission_task_id":${JSON.stringify(taskId || null)}}`
+  return result
 }
 
 async function executeSubTask(

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

@@ -3,7 +3,7 @@ import { describe, it } from 'node:test'
 import fs from 'node:fs'
 import path from 'node:path'
 import { getPluginManager, normalizeMarketplacePluginUrl, sanitizePluginFilename } from './plugins'
-import { canonicalizePluginId, expandPluginIds } from './tool-aliases'
+import { canonicalizePluginId, expandPluginIds, pluginIdMatches } from './tool-aliases'
 import { DATA_DIR } from './data-dir'
 
 let testPluginSeq = 0
@@ -33,6 +33,14 @@ describe('plugin id canonicalization', () => {
     assert.equal(expanded.includes('ask_human'), true)
     assert.equal(expanded.includes('human_loop'), true)
   })
+
+  it('does not expand a specific platform tool back into manage_platform', () => {
+    const expanded = expandPluginIds(['manage_schedules'])
+    assert.equal(expanded.includes('manage_schedules'), true)
+    assert.equal(expanded.includes('manage_platform'), false)
+    assert.equal(pluginIdMatches(['manage_platform'], 'manage_schedules'), true)
+    assert.equal(pluginIdMatches(['manage_schedules'], 'manage_platform'), false)
+  })
 })
 
 describe('plugin install helpers', () => {

package/src/lib/server/plugins.ts

@@ -510,12 +510,22 @@ class PluginManager {
     if (this.watcher) return
     try {
       this.ensurePluginDirs()
-      this.watcher = fs.watch(PLUGINS_DIR, (_eventType, filename) => {
+      const watcher = fs.watch(PLUGINS_DIR, (_eventType, filename) => {
         if (!filename || (!filename.endsWith('.js') && !filename.endsWith('.mjs'))) return
         this.loaded = false
         notify('plugins')
       })
-      this.watcher.unref?.()
+      watcher.on('error', (err: unknown) => {
+        log.warn('plugins', 'Plugin watcher disabled after runtime watch failure', {
+          error: err instanceof Error ? err.message : String(err),
+        })
+        if (this.watcher === watcher) {
+          try { watcher.close() } catch { /* ignore */ }
+          this.watcher = null
+        }
+      })
+      watcher.unref?.()
+      this.watcher = watcher
     } catch (err: unknown) {
       log.warn('plugins', 'Failed to watch plugins directory', {
         error: err instanceof Error ? err.message : String(err),