@swarmclawai/swarmclaw 0.7.2 → 0.7.4

package/src/lib/server/runtime-settings.test.ts

@@ -0,0 +1,119 @@
+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-runtime-settings-'))
+  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('runtime settings defaults', () => {
+  it('backfills explicit runtime defaults for clean installs', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const runtimeMod = await import('./src/lib/server/runtime-settings.ts')
+      const storage = storageMod.default || storageMod
+      const runtime = runtimeMod.default || runtimeMod
+      console.log(JSON.stringify({
+        settings: storage.loadSettings(),
+        runtime: runtime.loadRuntimeSettings(),
+      }))
+    `)
+
+    assert.equal(output.settings.loopMode, 'bounded')
+    assert.equal(output.settings.agentLoopRecursionLimit, 60)
+    assert.equal(output.settings.orchestratorLoopRecursionLimit, 80)
+    assert.equal(output.settings.legacyOrchestratorMaxTurns, 16)
+    assert.equal(output.settings.ongoingLoopMaxIterations, 250)
+    assert.equal(output.settings.ongoingLoopMaxRuntimeMinutes, 60)
+    assert.equal(output.settings.delegationMaxDepth, 3)
+    assert.equal(output.settings.shellCommandTimeoutSec, 30)
+    assert.equal(output.settings.claudeCodeTimeoutSec, 1800)
+    assert.equal(output.settings.cliProcessTimeoutSec, 1800)
+    assert.equal(output.settings.heartbeatIntervalSec, 1800)
+    assert.equal(output.settings.heartbeatAckMaxChars, 300)
+    assert.equal(output.settings.heartbeatShowOk, false)
+    assert.equal(output.settings.heartbeatShowAlerts, true)
+    assert.equal(output.settings.heartbeatTarget, null)
+    assert.equal(output.settings.heartbeatPrompt, null)
+    assert.equal(output.runtime.agentLoopRecursionLimit, 60)
+    assert.equal(output.runtime.orchestratorLoopRecursionLimit, 80)
+    assert.equal(output.runtime.legacyOrchestratorMaxTurns, 16)
+  })
+
+  it('clamps invalid persisted runtime settings into the supported range', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const runtimeMod = await import('./src/lib/server/runtime-settings.ts')
+      const storage = storageMod.default || storageMod
+      const runtime = runtimeMod.default || runtimeMod
+
+      storage.saveSettings({
+        loopMode: 'invalid',
+        agentLoopRecursionLimit: 999,
+        orchestratorLoopRecursionLimit: -5,
+        legacyOrchestratorMaxTurns: 0,
+        ongoingLoopMaxIterations: 999999,
+        ongoingLoopMaxRuntimeMinutes: -1,
+        delegationMaxDepth: 99,
+        shellCommandTimeoutSec: 0,
+        claudeCodeTimeoutSec: 999999,
+        cliProcessTimeoutSec: 'abc',
+        heartbeatIntervalSec: 999999,
+        heartbeatAckMaxChars: -50,
+        heartbeatShowOk: 'yes',
+        heartbeatShowAlerts: 'off',
+        heartbeatTarget: '   ',
+        heartbeatPrompt: '   ',
+      })
+
+      console.log(JSON.stringify({
+        settings: storage.loadSettings(),
+        runtime: runtime.loadRuntimeSettings(),
+      }))
+    `)
+
+    assert.equal(output.settings.loopMode, 'bounded')
+    assert.equal(output.settings.agentLoopRecursionLimit, 200)
+    assert.equal(output.settings.orchestratorLoopRecursionLimit, 1)
+    assert.equal(output.settings.legacyOrchestratorMaxTurns, 1)
+    assert.equal(output.settings.ongoingLoopMaxIterations, 5000)
+    assert.equal(output.settings.ongoingLoopMaxRuntimeMinutes, 0)
+    assert.equal(output.settings.delegationMaxDepth, 12)
+    assert.equal(output.settings.shellCommandTimeoutSec, 1)
+    assert.equal(output.settings.claudeCodeTimeoutSec, 7200)
+    assert.equal(output.settings.cliProcessTimeoutSec, 1800)
+    assert.equal(output.settings.heartbeatIntervalSec, 86400)
+    assert.equal(output.settings.heartbeatAckMaxChars, 0)
+    assert.equal(output.settings.heartbeatShowOk, true)
+    assert.equal(output.settings.heartbeatShowAlerts, false)
+    assert.equal(output.settings.heartbeatTarget, null)
+    assert.equal(output.settings.heartbeatPrompt, null)
+    assert.equal(output.runtime.ongoingLoopMaxRuntimeMs, null)
+  })
+})

package/src/lib/server/runtime-settings.ts

@@ -1,15 +1,6 @@
 import type { LoopMode } from '@/types'
 import {
-  DEFAULT_AGENT_LOOP_RECURSION_LIMIT,
-  DEFAULT_CLAUDE_CODE_TIMEOUT_SEC,
-  DEFAULT_CLI_PROCESS_TIMEOUT_SEC,
-  DEFAULT_DELEGATION_MAX_DEPTH,
-  DEFAULT_LEGACY_ORCHESTRATOR_MAX_TURNS,
-  DEFAULT_LOOP_MODE,
-  DEFAULT_ONGOING_LOOP_MAX_ITERATIONS,
-  DEFAULT_ONGOING_LOOP_MAX_RUNTIME_MINUTES,
-  DEFAULT_ORCHESTRATOR_LOOP_RECURSION_LIMIT,
-  DEFAULT_SHELL_COMMAND_TIMEOUT_SEC,
+  normalizeRuntimeSettingFields,
 } from '@/lib/runtime-loop'
 import { loadSettings } from './storage'
 
@@ -26,92 +17,21 @@ export interface RuntimeSettings {
   cliProcessTimeoutMs: number
 }
 
-function parseIntSetting(value: unknown, fallback: number, min: number, max: number): number {
-  const parsed = typeof value === 'number'
-    ? value
-    : typeof value === 'string'
-      ? Number.parseInt(value, 10)
-      : Number.NaN
-  if (!Number.isFinite(parsed)) return fallback
-  const int = Math.trunc(parsed)
-  return Math.max(min, Math.min(max, int))
-}
-
-function parseLoopMode(value: unknown): LoopMode {
-  return value === 'ongoing' ? 'ongoing' : DEFAULT_LOOP_MODE
-}
-
 export function loadRuntimeSettings(): RuntimeSettings {
   const settings = loadSettings()
-  const loopMode = parseLoopMode(settings.loopMode)
-
-  const agentLoopRecursionLimit = parseIntSetting(
-    settings.agentLoopRecursionLimit,
-    DEFAULT_AGENT_LOOP_RECURSION_LIMIT,
-    1,
-    200,
-  )
-  const orchestratorLoopRecursionLimit = parseIntSetting(
-    settings.orchestratorLoopRecursionLimit,
-    DEFAULT_ORCHESTRATOR_LOOP_RECURSION_LIMIT,
-    1,
-    300,
-  )
-  const legacyOrchestratorMaxTurns = parseIntSetting(
-    settings.legacyOrchestratorMaxTurns,
-    DEFAULT_LEGACY_ORCHESTRATOR_MAX_TURNS,
-    1,
-    300,
-  )
-  const delegationMaxDepth = parseIntSetting(
-    settings.delegationMaxDepth,
-    DEFAULT_DELEGATION_MAX_DEPTH,
-    1,
-    12,
-  )
-  const ongoingLoopMaxIterations = parseIntSetting(
-    settings.ongoingLoopMaxIterations,
-    DEFAULT_ONGOING_LOOP_MAX_ITERATIONS,
-    10,
-    5000,
-  )
-  const ongoingLoopMaxRuntimeMinutes = parseIntSetting(
-    settings.ongoingLoopMaxRuntimeMinutes,
-    DEFAULT_ONGOING_LOOP_MAX_RUNTIME_MINUTES,
-    0,
-    1440,
-  )
-
-  const shellCommandTimeoutSec = parseIntSetting(
-    settings.shellCommandTimeoutSec,
-    DEFAULT_SHELL_COMMAND_TIMEOUT_SEC,
-    1,
-    600,
-  )
-  const claudeCodeTimeoutSec = parseIntSetting(
-    settings.claudeCodeTimeoutSec,
-    DEFAULT_CLAUDE_CODE_TIMEOUT_SEC,
-    5,
-    7200,
-  )
-  const cliProcessTimeoutSec = parseIntSetting(
-    settings.cliProcessTimeoutSec,
-    DEFAULT_CLI_PROCESS_TIMEOUT_SEC,
-    10,
-    7200,
-  )
+  const normalized = normalizeRuntimeSettingFields(settings)
 
   return {
-    loopMode,
-    agentLoopRecursionLimit,
-    orchestratorLoopRecursionLimit,
-    legacyOrchestratorMaxTurns,
-    delegationMaxDepth,
-    ongoingLoopMaxIterations,
-    ongoingLoopMaxRuntimeMs: ongoingLoopMaxRuntimeMinutes > 0 ? ongoingLoopMaxRuntimeMinutes * 60_000 : null,
-    shellCommandTimeoutMs: shellCommandTimeoutSec * 1000,
-    claudeCodeTimeoutMs: claudeCodeTimeoutSec * 1000,
-    cliProcessTimeoutMs: cliProcessTimeoutSec * 1000,
+    loopMode: normalized.loopMode as LoopMode,
+    agentLoopRecursionLimit: normalized.agentLoopRecursionLimit,
+    orchestratorLoopRecursionLimit: normalized.orchestratorLoopRecursionLimit,
+    legacyOrchestratorMaxTurns: normalized.legacyOrchestratorMaxTurns,
+    delegationMaxDepth: normalized.delegationMaxDepth,
+    ongoingLoopMaxIterations: normalized.ongoingLoopMaxIterations,
+    ongoingLoopMaxRuntimeMs: normalized.ongoingLoopMaxRuntimeMinutes > 0 ? normalized.ongoingLoopMaxRuntimeMinutes * 60_000 : null,
+    shellCommandTimeoutMs: normalized.shellCommandTimeoutSec * 1000,
+    claudeCodeTimeoutMs: normalized.claudeCodeTimeoutSec * 1000,
+    cliProcessTimeoutMs: normalized.cliProcessTimeoutSec * 1000,
   }
 }
 

package/src/lib/server/schedule-normalization.ts

@@ -0,0 +1,187 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { WORKSPACE_DIR } from './data-dir'
+
+type SchedulePayload = Record<string, unknown>
+
+export interface NormalizeScheduleOptions {
+  cwd?: string | null
+  now?: number
+}
+
+export type NormalizeScheduleResult =
+  | { ok: true; value: SchedulePayload }
+  | { ok: false; error: string }
+
+const SCRIPT_FILE_EXT = /\.(py|js|mjs|cjs|ts|tsx|sh|bash|zsh|rb|php|pl)$/i
+const DIRECT_SCRIPT_RUNNERS = new Set(['python', 'python3', 'python3.11', 'node', 'bash', 'sh', 'zsh', 'ruby', 'tsx', 'ts-node'])
+const VALID_STATUSES = new Set(['active', 'paused', 'completed', 'failed'])
+
+function trimString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+function normalizeScheduleType(value: unknown): 'cron' | 'interval' | 'once' {
+  if (value === 'cron' || value === 'interval' || value === 'once') return value
+  return 'interval'
+}
+
+function normalizePositiveInt(value: unknown): number | null {
+  const parsed = typeof value === 'number'
+    ? value
+    : typeof value === 'string'
+      ? Number.parseInt(value, 10)
+      : Number.NaN
+  if (!Number.isFinite(parsed)) return null
+  const intValue = Math.trunc(parsed)
+  return intValue > 0 ? intValue : null
+}
+
+function isWithinDirectory(parent: string, child: string): boolean {
+  const relative = path.relative(path.resolve(parent), path.resolve(child))
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative))
+}
+
+function resolveRelativePath(baseDir: string, candidate: string): string | null {
+  const trimmed = trimString(candidate)
+  if (!trimmed) return null
+  if (path.isAbsolute(trimmed)) {
+    const resolvedAbsolute = path.resolve(trimmed)
+    return isWithinDirectory(baseDir, resolvedAbsolute) ? resolvedAbsolute : null
+  }
+  const resolved = path.resolve(baseDir, trimmed)
+  return isWithinDirectory(baseDir, resolved) ? resolved : null
+}
+
+function tokenizeCommand(command: string): string[] {
+  return String(command || '').match(/(?:[^\s"'`]+|"[^"]*"|'[^']*')+/g) || []
+}
+
+function unquoteToken(token: string): string {
+  if ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith('\'') && token.endsWith('\''))) {
+    return token.slice(1, -1)
+  }
+  return token
+}
+
+function looksLikeScriptPath(token: string): boolean {
+  return SCRIPT_FILE_EXT.test(token) || token.includes('/') || token.includes(path.sep)
+}
+
+function extractScriptPathFromCommand(command: string): string | null {
+  const tokens = tokenizeCommand(command).map(unquoteToken).filter(Boolean)
+  if (!tokens.length) return null
+
+  const commandName = path.basename(tokens[0] || '').toLowerCase()
+  let startIndex = 1
+  if (commandName === 'npx' && tokens[1]) {
+    const nestedRunner = path.basename(tokens[1]).toLowerCase()
+    if (nestedRunner === 'tsx' || nestedRunner === 'ts-node') startIndex = 2
+  } else if (commandName === 'deno' && tokens[1] === 'run') {
+    startIndex = 2
+  } else if (!DIRECT_SCRIPT_RUNNERS.has(commandName)) {
+    startIndex = 0
+  }
+
+  for (let index = startIndex; index < tokens.length; index += 1) {
+    const candidate = tokens[index]
+    if (!candidate || candidate.startsWith('-')) continue
+    if (!looksLikeScriptPath(candidate)) continue
+    return candidate
+  }
+
+  return null
+}
+
+function deriveTaskPrompt(payload: SchedulePayload): string {
+  const explicitTaskPrompt = trimString(payload.taskPrompt)
+  if (explicitTaskPrompt) return explicitTaskPrompt
+
+  const command = trimString(payload.command)
+  if (command) {
+    return `Execute the command \`${command}\` from this schedule's working directory and report the result, including any errors.`
+  }
+
+  const filePath = trimString(payload.path)
+  if (!filePath) return ''
+
+  const action = trimString(payload.action).toLowerCase()
+  if (action === 'run_script') {
+    return `Run the script at \`${filePath}\` from this schedule's working directory and report the result, including any errors.`
+  }
+
+  return `Use the file at \`${filePath}\` to complete this scheduled task and report the result.`
+}
+
+function validateScheduleArtifacts(payload: SchedulePayload, baseDir: string): string | null {
+  const action = trimString(payload.action).toLowerCase()
+  const filePath = trimString(payload.path)
+  const command = trimString(payload.command)
+
+  if (action === 'run_script' && !filePath) {
+    return 'run_script schedules require a path.'
+  }
+
+  if (filePath) {
+    const resolved = resolveRelativePath(baseDir, filePath)
+    if (!resolved) return `schedule path must stay inside ${baseDir}: ${filePath}`
+    if (!fs.existsSync(resolved)) return `schedule path not found: ${filePath}`
+  }
+
+  if (!command) return null
+  const commandScriptPath = extractScriptPathFromCommand(command)
+  if (!commandScriptPath) return null
+  const resolved = resolveRelativePath(baseDir, commandScriptPath)
+  if (!resolved) return `schedule command references a path outside ${baseDir}: ${commandScriptPath}`
+  if (!fs.existsSync(resolved)) return `schedule command references a missing file: ${commandScriptPath}`
+  return null
+}
+
+export function normalizeSchedulePayload(payload: SchedulePayload, opts: NormalizeScheduleOptions = {}): NormalizeScheduleResult {
+  const now = typeof opts.now === 'number' ? opts.now : Date.now()
+  const baseDir = path.resolve(trimString(opts.cwd) || WORKSPACE_DIR)
+  const normalized: SchedulePayload = {
+    ...payload,
+    scheduleType: normalizeScheduleType(payload.scheduleType),
+  }
+  const action = trimString(normalized.action)
+  const command = trimString(normalized.command)
+  const filePath = trimString(normalized.path)
+  if (action) normalized.action = action
+  if (command) normalized.command = command
+  if (filePath) normalized.path = filePath
+
+  const status = trimString(normalized.status).toLowerCase()
+  normalized.status = VALID_STATUSES.has(status) ? status : 'active'
+
+  const agentId = trimString(normalized.agentId)
+  if (!agentId) {
+    return { ok: false, error: 'Error: schedules require a target agentId.' }
+  }
+  normalized.agentId = agentId
+
+  const taskPrompt = deriveTaskPrompt(normalized)
+  if (!taskPrompt) {
+    return { ok: false, error: 'Error: schedules require a taskPrompt, command, or action/path payload.' }
+  }
+  normalized.taskPrompt = taskPrompt
+
+  const validationError = validateScheduleArtifacts(normalized, baseDir)
+  if (validationError) return { ok: false, error: `Error: ${validationError}` }
+
+  if (normalized.nextRunAt == null) {
+    if (normalized.scheduleType === 'once') {
+      const runAt = normalizePositiveInt(normalized.runAt)
+      if (runAt != null) normalized.nextRunAt = runAt
+    } else if (normalized.scheduleType === 'interval') {
+      const intervalMs = normalizePositiveInt(normalized.intervalMs)
+      if (intervalMs != null) normalized.nextRunAt = now + intervalMs
+    }
+  }
+
+  return { ok: true, value: normalized }
+}
+
+export function extractScheduleCommandScriptPath(command: string): string | null {
+  return extractScriptPathFromCommand(command)
+}

package/src/lib/server/scheduler.ts

@@ -6,6 +6,7 @@ import { pushMainLoopEventToMainSessions } from './main-agent-loop'
 import { getScheduleSignatureKey } from '@/lib/schedule-dedupe'
 import { enqueueSystemEvent } from './system-events'
 import { requestHeartbeatNow } from './heartbeat-wake'
+import { processDueWatchJobs } from './watch-jobs'
 
 const TICK_INTERVAL = 60_000 // 60 seconds
 let intervalId: ReturnType<typeof setInterval> | null = null
@@ -73,6 +74,7 @@ function computeNextRuns() {
 
 async function tick() {
   const now = Date.now()
+  await processDueWatchJobs(now)
   const schedules = loadSchedules()
   const agents = loadAgents()
   const tasks = loadTasks()

package/src/lib/server/session-archive-memory.test.ts

@@ -0,0 +1,85 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import type { Session } from '@/types'
+import { buildSessionArchiveMarkdown, buildSessionArchivePayload } from './session-archive-memory'
+
+test('buildSessionArchivePayload summarizes session transcript and metadata', () => {
+  const session = {
+    id: 'session-1',
+    name: 'Support Thread',
+    cwd: process.cwd(),
+    user: 'Alice',
+    provider: 'openai',
+    model: 'gpt-4.1',
+    claudeSessionId: null,
+    codexThreadId: null,
+    opencodeSessionId: null,
+    createdAt: Date.parse('2026-03-05T00:00:00.000Z'),
+    lastActiveAt: Date.parse('2026-03-05T10:00:00.000Z'),
+    sessionType: 'human',
+    messages: [
+      { role: 'user', text: 'Can you help me debug this issue?', time: 1 },
+      { role: 'assistant', text: 'Yes, show me the stack trace.', time: 2, toolEvents: [{ name: 'files', input: '{}' }] },
+    ],
+    identityState: { personaLabel: 'Debugger' },
+  } as Session
+
+  const payload = buildSessionArchivePayload(session, { name: 'Swarmy' })
+
+  assert.ok(payload)
+  assert.equal(payload?.title, 'Session archive: Support Thread')
+  assert.match(payload?.content || '', /Transcript excerpt:/)
+  assert.match(payload?.content || '', /Swarmy/)
+  assert.equal(payload?.metadata.tier, 'archive')
+  assert.equal(payload?.references[0]?.type, 'session')
+})
+
+test('buildSessionArchiveMarkdown creates a portable markdown snapshot', () => {
+  const session = {
+    id: 'session-3',
+    name: 'Architecture Review',
+    cwd: process.cwd(),
+    user: 'Alice',
+    provider: 'openai',
+    model: 'gpt-4.1',
+    claudeSessionId: null,
+    codexThreadId: null,
+    opencodeSessionId: null,
+    createdAt: Date.parse('2026-03-05T00:00:00.000Z'),
+    lastActiveAt: Date.parse('2026-03-05T10:00:00.000Z'),
+    sessionType: 'human',
+    messages: [
+      { role: 'user', text: 'Summarize the new connector policy.', time: 1 },
+      { role: 'assistant', text: 'It now uses scoped sessions and freshness resets.', time: 2 },
+    ],
+    identityState: { personaLabel: 'Reviewer' },
+  } as Session
+
+  const payload = buildSessionArchivePayload(session, { name: 'Swarmy' })
+  assert.ok(payload)
+
+  const markdown = buildSessionArchiveMarkdown(session, payload!, { name: 'Swarmy' })
+  assert.match(markdown, /^# Session archive: Architecture Review/m)
+  assert.match(markdown, /## Archive Snapshot/)
+  assert.match(markdown, /## Transcript Excerpt/)
+  assert.match(markdown, /\*\*Swarmy\*\*/)
+})
+
+test('buildSessionArchivePayload skips trivial sessions', () => {
+  const session = {
+    id: 'session-2',
+    name: 'Too Short',
+    cwd: process.cwd(),
+    user: 'Bob',
+    provider: 'openai',
+    model: 'gpt-4.1',
+    claudeSessionId: null,
+    codexThreadId: null,
+    opencodeSessionId: null,
+    createdAt: 1,
+    lastActiveAt: 1,
+    messages: [{ role: 'user', text: 'hi', time: 1 }],
+  } as Session
+
+  assert.equal(buildSessionArchivePayload(session), null)
+})