@swarmclawai/swarmclaw 1.2.6 → 1.2.8

package/src/types/task.ts

@@ -0,0 +1,140 @@
+import type { MissionSummary } from './mission'
+import type { GoalContract } from './app-settings'
+
+// --- Task Board ---
+
+export type BoardTaskStatus = 'backlog' | 'queued' | 'running' | 'completed' | 'failed' | 'cancelled' | 'archived' | 'deferred'
+
+export interface TaskComment {
+  id: string
+  author: string         // agent name or 'user'
+  agentId?: string     // if from an agent
+  text: string
+  createdAt: number
+}
+
+export interface TaskQualityGateConfig {
+  enabled?: boolean
+  minResultChars?: number
+  minEvidenceItems?: number
+  requireVerification?: boolean
+  requireArtifact?: boolean
+  requireReport?: boolean
+}
+
+export interface BoardTask {
+  id: string
+  title: string
+  description: string
+  status: BoardTaskStatus
+  agentId: string
+  missionId?: string | null
+  protocolRunId?: string | null
+  missionSummary?: MissionSummary | null
+  projectId?: string
+  goalContract?: GoalContract | null
+  cwd?: string | null
+  file?: string | null
+  sessionId?: string | null
+  completionReportPath?: string | null
+  result?: string | null
+  error?: string | null
+  outputFiles?: string[]
+  artifacts?: Array<{
+    url: string
+    type: 'image' | 'video' | 'pdf' | 'file'
+    filename: string
+  }>
+  comments?: TaskComment[]
+  images?: string[]
+  createdByAgentId?: string | null
+  createdInSessionId?: string | null
+  followupConnectorId?: string | null
+  followupChannelId?: string | null
+  followupThreadId?: string | null
+  followupSenderId?: string | null
+  followupSenderName?: string | null
+  delegatedByAgentId?: string | null
+  delegatedFromTaskId?: string | null
+  delegationDepth?: number | null
+  createdAt: number
+  updatedAt: number
+  queuedAt?: number | null
+  startedAt?: number | null
+  completedAt?: number | null
+  archivedAt?: number | null
+  attempts?: number
+  maxAttempts?: number
+  retryBackoffSec?: number
+  retryScheduledAt?: number | null
+  runNumber?: number
+  totalRuns?: number
+  totalCompleted?: number
+  totalFailed?: number
+  sourceType?: 'schedule' | 'delegation' | 'manual' | 'import'
+  sourceScheduleId?: string | null
+  sourceScheduleName?: string | null
+  sourceScheduleKey?: string | null
+  externalSource?: {
+    source: string
+    id?: string | null
+    repo?: string | null
+    number?: number | null
+    state?: string | null
+    labels?: string[]
+    assignee?: string | null
+    url?: string | null
+  } | null
+  lastActivityAt?: number | null
+  deferredReason?: string | null
+  deadLetteredAt?: number | null
+  cliResumeId?: string | null
+  cliProvider?: string | null
+  claudeResumeId?: string | null
+  codexResumeId?: string | null
+  opencodeResumeId?: string | null
+  geminiResumeId?: string | null
+  checkpoint?: {
+    lastRunId?: string | null
+    lastSessionId?: string | null
+    note?: string | null
+    updatedAt: number
+  } | null
+  validation?: {
+    ok: boolean
+    reasons: string[]
+    checkedAt: number
+  } | null
+  // Parent/child task hierarchy (user-created subtasks)
+  parentTaskId?: string | null
+  subtaskIds?: string[]
+  // Task dependencies (DAG)
+  blockedBy?: string[]
+  blocks?: string[]
+  // Task tags
+  tags?: string[]
+  // Due date
+  dueAt?: number | null
+  // Custom fields
+  customFields?: Record<string, string | number | boolean>
+  // Priority
+  priority?: 'low' | 'medium' | 'high' | 'critical'
+  // Dedup fingerprint
+  fingerprint?: string
+  qualityGate?: TaskQualityGateConfig | null
+  // Competitive task claiming (pool mode)
+  assignmentMode?: 'direct' | 'pool'
+  poolCandidateAgentIds?: string[]
+  claimedByAgentId?: string | null
+  claimedAt?: number | null
+  requiredCapabilities?: string[]
+  // Upstream task results (populated by cascadeUnblock when dependencies complete)
+  upstreamResults?: Array<{
+    taskId: string
+    taskTitle: string
+    agentId: string | null
+    resultPreview: string | null
+  }>
+  repairRunId?: string | null
+  lastRepairAttemptAt?: number | null
+}

package/src/types/working-state.ts

@@ -0,0 +1,211 @@
+import type { MissionStatus, MissionPhase, MissionWaitState } from './mission'
+
+export type WorkingStateStatus = 'idle' | 'progress' | 'blocked' | 'waiting' | 'completed'
+export type WorkingStateItemStatus = 'active' | 'resolved' | 'superseded'
+
+export interface EvidenceRef {
+  id: string
+  type: 'tool' | 'message' | 'mission' | 'task' | 'artifact' | 'error' | 'approval'
+  summary: string
+  value?: string | null
+  toolName?: string | null
+  toolCallId?: string | null
+  runId?: string | null
+  sessionId?: string | null
+  missionId?: string | null
+  taskId?: string | null
+  createdAt: number
+}
+
+export interface WorkingPlanStep {
+  id: string
+  text: string
+  status: WorkingStateItemStatus
+  createdAt: number
+  updatedAt: number
+}
+
+export interface WorkingFact {
+  id: string
+  statement: string
+  source: 'user' | 'tool' | 'assistant' | 'mission' | 'system'
+  status: WorkingStateItemStatus
+  evidenceIds?: string[]
+  createdAt: number
+  updatedAt: number
+}
+
+export interface WorkingArtifact {
+  id: string
+  label: string
+  kind: 'file' | 'url' | 'approval' | 'message' | 'other'
+  path?: string | null
+  url?: string | null
+  sourceTool?: string | null
+  status: WorkingStateItemStatus
+  evidenceIds?: string[]
+  createdAt: number
+  updatedAt: number
+}
+
+export interface WorkingDecision {
+  id: string
+  summary: string
+  rationale?: string | null
+  status: WorkingStateItemStatus
+  evidenceIds?: string[]
+  createdAt: number
+  updatedAt: number
+}
+
+export interface WorkingBlocker {
+  id: string
+  summary: string
+  kind?: 'approval' | 'credential' | 'human_input' | 'external_dependency' | 'error' | 'other' | null
+  nextAction?: string | null
+  status: WorkingStateItemStatus
+  evidenceIds?: string[]
+  createdAt: number
+  updatedAt: number
+}
+
+export interface WorkingQuestion {
+  id: string
+  question: string
+  status: WorkingStateItemStatus
+  evidenceIds?: string[]
+  createdAt: number
+  updatedAt: number
+}
+
+export interface WorkingHypothesis {
+  id: string
+  statement: string
+  confidence?: 'low' | 'medium' | 'high' | null
+  status: WorkingStateItemStatus
+  evidenceIds?: string[]
+  createdAt: number
+  updatedAt: number
+}
+
+export interface WorkingPlanStepPatch {
+  id?: string | null
+  text: string
+  status?: WorkingStateItemStatus | null
+}
+
+export interface WorkingFactPatch {
+  id?: string | null
+  statement: string
+  source?: WorkingFact['source'] | null
+  status?: WorkingStateItemStatus | null
+  evidenceIds?: string[]
+}
+
+export interface WorkingArtifactPatch {
+  id?: string | null
+  label: string
+  kind?: WorkingArtifact['kind'] | null
+  path?: string | null
+  url?: string | null
+  sourceTool?: string | null
+  status?: WorkingStateItemStatus | null
+  evidenceIds?: string[]
+}
+
+export interface WorkingDecisionPatch {
+  id?: string | null
+  summary: string
+  rationale?: string | null
+  status?: WorkingStateItemStatus | null
+  evidenceIds?: string[]
+}
+
+export interface WorkingBlockerPatch {
+  id?: string | null
+  summary: string
+  kind?: WorkingBlocker['kind']
+  nextAction?: string | null
+  status?: WorkingStateItemStatus | null
+  evidenceIds?: string[]
+}
+
+export interface WorkingQuestionPatch {
+  id?: string | null
+  question: string
+  status?: WorkingStateItemStatus | null
+  evidenceIds?: string[]
+}
+
+export interface WorkingHypothesisPatch {
+  id?: string | null
+  statement: string
+  confidence?: WorkingHypothesis['confidence']
+  status?: WorkingStateItemStatus | null
+  evidenceIds?: string[]
+}
+
+export interface WorkingStatePatch {
+  objective?: string | null
+  summary?: string | null
+  constraints?: string[]
+  successCriteria?: string[]
+  status?: WorkingStateStatus | null
+  nextAction?: string | null
+  planSteps?: WorkingPlanStepPatch[]
+  factsUpsert?: WorkingFactPatch[]
+  artifactsUpsert?: WorkingArtifactPatch[]
+  decisionsAppend?: WorkingDecisionPatch[]
+  blockersUpsert?: WorkingBlockerPatch[]
+  questionsUpsert?: WorkingQuestionPatch[]
+  hypothesesUpsert?: WorkingHypothesisPatch[]
+  evidenceAppend?: EvidenceRef[]
+  supersedeIds?: string[]
+}
+
+export interface SessionWorkingState {
+  sessionId: string
+  missionId?: string | null
+  objective?: string | null
+  summary?: string | null
+  constraints: string[]
+  successCriteria: string[]
+  status: WorkingStateStatus
+  nextAction?: string | null
+  planSteps: WorkingPlanStep[]
+  confirmedFacts: WorkingFact[]
+  artifacts: WorkingArtifact[]
+  decisions: WorkingDecision[]
+  blockers: WorkingBlocker[]
+  openQuestions: WorkingQuestion[]
+  hypotheses: WorkingHypothesis[]
+  evidenceRefs: EvidenceRef[]
+  createdAt: number
+  updatedAt: number
+  lastCompactedAt?: number | null
+}
+
+export interface ExecutionBriefPlanStep {
+  text: string
+  status: WorkingStateItemStatus
+}
+
+export interface ExecutionBrief {
+  sessionId?: string | null
+  missionId?: string | null
+  objective: string | null
+  summary: string | null
+  status: WorkingStateStatus
+  nextAction: string | null
+  plan: ExecutionBriefPlanStep[]
+  blockers: string[]
+  facts: string[]
+  artifacts: string[]
+  constraints: string[]
+  successCriteria: string[]
+  missionStatus?: MissionStatus | null
+  missionPhase?: MissionPhase | null
+  waitState?: MissionWaitState | null
+  evidenceRefs: EvidenceRef[]
+  parentContext: string | null
+}

package/src/views/settings/section-heartbeat.tsx

@@ -35,8 +35,8 @@ export function HeartbeatSection({ appSettings, patchSettings, inputClass }: Set
       setHeartbeatBulkNotice(
         `Stopped heartbeat on ${result.updatedSessions} session(s); cancelled ${result.cancelledQueued} queued run(s), aborted ${result.abortedRunning} running run(s).`,
       )
-    } catch (err: any) {
-      setHeartbeatBulkNotice(err?.message || 'Failed to disable heartbeat for all agents.')
+    } catch (err: unknown) {
+      setHeartbeatBulkNotice(err instanceof Error ? err.message : 'Failed to disable heartbeat for all agents.')
     } finally {
       setDisablingHeartbeats(false)
     }

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

@@ -1,281 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import { spawnSync } from 'child_process'
-import { UPLOAD_DIR } from '../storage'
-import { truncate, MAX_OUTPUT } from './context'
-import type { Session } from '@/types'
-import { normalizeToolInputArgs } from './normalize-tool-args'
-import { detectDocker } from '@/lib/server/sandbox/docker-detect'
-import {
-  ensureSessionSandbox,
-  resolveSandboxRuntimeStatus,
-  resolveSandboxWorkdir,
-  type AgentSandboxConfig,
-} from '@/lib/server/sandbox/session-runtime'
-import { buildDockerExecArgs } from '@/lib/server/runtime/process-manager'
-
-export type SandboxContext = {
-  sessionId?: string
-  cwd?: string
-  agentId?: string | null
-  config?: AgentSandboxConfig | null
-  resolveCurrentSession?: () => Session | null
-}
-
-const EXT_MAP: Record<string, string> = {
-  javascript: 'js',
-  typescript: 'ts',
-}
-
-function sandboxUnavailableError(reason: string): string {
-  return JSON.stringify({
-    error: reason,
-    guidance: [
-      'Install Docker Desktop to keep sandbox_exec inside a container.',
-      'Use http_request for straightforward API calls.',
-      'Use extension_creator plus manage_schedules for recurring automations.',
-    ],
-  })
-}
-
-function quoteShell(value: string): string {
-  return `'${value.replace(/'/g, `'\\''`)}'`
-}
-
-function createSandboxDir(baseCwd: string, sessionId: string): string {
-  const root = path.join(baseCwd, '.swarmclaw-sandbox')
-  fs.mkdirSync(root, { recursive: true })
-  return fs.mkdtempSync(path.join(root, `${sessionId}-`))
-}
-
-function collectArtifacts(params: {
-  sandboxDir: string
-  ignoredFiles: Set<string>
-}): Array<{ name: string; url: string }> {
-  const artifacts: { name: string; url: string }[] = []
-  try {
-    const files = fs.readdirSync(params.sandboxDir)
-    for (const file of files) {
-      if (params.ignoredFiles.has(file)) continue
-      const src = path.join(params.sandboxDir, file)
-      if (!fs.statSync(src).isFile()) continue
-      fs.mkdirSync(UPLOAD_DIR, { recursive: true })
-      const destName = `sandbox-${Date.now()}-${file}`
-      const dest = path.join(UPLOAD_DIR, destName)
-      fs.copyFileSync(src, dest)
-      artifacts.push({ name: file, url: `/api/uploads/${encodeURIComponent(destName)}` })
-    }
-  } catch {
-    // ignore artifact collection failures
-  }
-  return artifacts
-}
-
-function executeHostNode(params: {
-  sandboxDir: string
-  language: string
-  scriptFile: string
-  timeout: number
-}): {
-  runtime: 'host'
-  stdout: string
-  stderr: string
-  exitCode: number
-  timedOut: boolean
-} {
-  const tmpDir = path.join(params.sandboxDir, '.tmp')
-  fs.mkdirSync(tmpDir, { recursive: true })
-  const args = params.language === 'typescript'
-    ? ['--no-warnings=ExperimentalWarning', '--experimental-strip-types', params.scriptFile]
-    : [params.scriptFile]
-  const result = spawnSync(process.execPath, args, {
-    cwd: params.sandboxDir,
-    encoding: 'utf-8',
-    timeout: params.timeout,
-    maxBuffer: MAX_OUTPUT,
-    env: {
-      ...process.env,
-      HOME: params.sandboxDir,
-      TMPDIR: tmpDir,
-      WORKSPACE: params.sandboxDir,
-      SESSION_CWD: params.sandboxDir,
-      SWARMCLAW_SANDBOX_MODE: 'host',
-    },
-  })
-  return {
-    runtime: 'host',
-    stdout: truncate((result.stdout || '').toString(), MAX_OUTPUT),
-    stderr: truncate((result.stderr || '').toString(), MAX_OUTPUT),
-    exitCode: result.status ?? (result.error ? 1 : 0),
-    timedOut: !!(result.error?.message?.includes('ETIMEDOUT') || result.signal === 'SIGTERM'),
-  }
-}
-
-async function executeContainerNode(params: {
-  sandboxDir: string
-  language: string
-  scriptFile: string
-  timeout: number
-  context: SandboxContext
-}): Promise<{
-  runtime: 'container'
-  stdout: string
-  stderr: string
-  exitCode: number
-  timedOut: boolean
-}> {
-  const session = params.context.resolveCurrentSession?.() ?? null
-  const sandbox = await ensureSessionSandbox({
-    config: params.context.config,
-    session,
-    agentId: params.context.agentId ?? session?.agentId ?? null,
-    sessionId: params.context.sessionId ?? session?.id ?? null,
-    workspaceDir: params.context.cwd || process.cwd(),
-  })
-
-  if (!sandbox) {
-    throw new Error('Container sandbox is not active for this session.')
-  }
-
-  const tmpDir = path.join(params.sandboxDir, '.tmp')
-  fs.mkdirSync(tmpDir, { recursive: true })
-  const resolved = resolveSandboxWorkdir({
-    workspaceDir: sandbox.workspaceDir,
-    hostWorkdir: params.sandboxDir,
-    containerWorkdir: sandbox.containerWorkdir,
-  })
-  const containerCommand = params.language === 'typescript'
-    ? `node --no-warnings=ExperimentalWarning --experimental-strip-types ${quoteShell(params.scriptFile)}`
-    : `node ${quoteShell(params.scriptFile)}`
-  const result = spawnSync('docker', buildDockerExecArgs({
-    containerName: sandbox.containerName,
-    command: containerCommand,
-    workdir: resolved.containerWorkdir,
-    env: {
-      HOME: resolved.containerWorkdir,
-      TMPDIR: path.posix.join(resolved.containerWorkdir, '.tmp'),
-      WORKSPACE: sandbox.containerWorkdir,
-      SESSION_CWD: resolved.containerWorkdir,
-      SWARMCLAW_SANDBOX_MODE: 'container',
-    },
-  }), {
-    encoding: 'utf-8',
-    timeout: params.timeout,
-    maxBuffer: MAX_OUTPUT,
-  })
-
-  return {
-    runtime: 'container',
-    stdout: truncate((result.stdout || '').toString(), MAX_OUTPUT),
-    stderr: truncate((result.stderr || '').toString(), MAX_OUTPUT),
-    exitCode: result.status ?? (result.error ? 1 : 0),
-    timedOut: !!(result.error?.message?.includes('ETIMEDOUT') || result.signal === 'SIGTERM'),
-  }
-}
-
-export async function executeSandboxExec(args: unknown, context: SandboxContext) {
-  const normalized = normalizeToolInputArgs((args ?? {}) as Record<string, unknown>)
-  const language = normalized.language as string
-  const code = normalized.code as string
-  const timeoutSec = normalized.timeoutSec as number | undefined
-  const timeout = Math.min(Math.max(timeoutSec ?? 60, 5), 300) * 1000
-  const ext = EXT_MAP[language]
-  const sessionId = context.sessionId ?? 'unknown'
-  const cwd = context.cwd || process.cwd()
-
-  if (language !== 'javascript' && language !== 'typescript') {
-    return sandboxUnavailableError('sandbox_exec currently supports only JavaScript and TypeScript via Node.js.')
-  }
-
-  let sandboxDir: string | null = null
-  try {
-    sandboxDir = createSandboxDir(cwd, sessionId)
-    const sandboxRoot = sandboxDir
-    const scriptFile = `script.${ext}`
-    fs.writeFileSync(path.join(sandboxRoot, 'package.json'), JSON.stringify({ type: 'module' }), 'utf-8')
-    fs.writeFileSync(path.join(sandboxRoot, scriptFile), code, 'utf-8')
-
-    const warnings: string[] = []
-    const docker = detectDocker()
-    const runtimeResult = docker.available
-      ? await executeContainerNode({
-          sandboxDir: sandboxRoot,
-          language,
-          scriptFile,
-          timeout,
-          context,
-        }).catch((err: unknown) => {
-          warnings.push(err instanceof Error ? err.message : 'Container sandbox unavailable; used host Node fallback.')
-          return executeHostNode({
-            sandboxDir: sandboxRoot,
-            language,
-            scriptFile,
-            timeout,
-          })
-        })
-      : (() => {
-          warnings.push('Docker is not available; used host Node fallback.')
-          return executeHostNode({
-            sandboxDir: sandboxRoot,
-            language,
-            scriptFile,
-            timeout,
-          })
-        })()
-
-    const artifacts = collectArtifacts({
-      sandboxDir: sandboxRoot,
-      ignoredFiles: new Set([scriptFile, 'package.json']),
-    })
-
-    return JSON.stringify({
-      runtime: runtimeResult.runtime,
-      exitCode: runtimeResult.exitCode,
-      timedOut: runtimeResult.timedOut,
-      stdout: runtimeResult.stdout,
-      stderr: runtimeResult.stderr,
-      artifacts,
-      ...(warnings.length ? { warnings } : {}),
-    })
-  } catch (err: unknown) {
-    return JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
-  } finally {
-    if (sandboxDir) {
-      try { fs.rmSync(sandboxDir, { recursive: true, force: true }) } catch { /* ignore */ }
-    }
-  }
-}
-
-export async function executeListRuntimes(context: SandboxContext) {
-  const docker = detectDocker()
-  const session = context.resolveCurrentSession?.() ?? null
-  const status = resolveSandboxRuntimeStatus({
-    config: context.config,
-    session,
-    agentId: context.agentId ?? session?.agentId ?? null,
-    sessionId: context.sessionId ?? session?.id ?? null,
-  })
-
-  return JSON.stringify({
-    node: {
-      available: true,
-      version: process.version,
-      supportsTypeScript: true,
-    },
-    docker,
-    sandbox: {
-      enabledByConfig: Boolean(context.config?.enabled),
-      sandboxedForSession: status.sandboxed,
-      mode: status.mode,
-      scope: status.scope,
-      scopeKey: status.scopeKey,
-      executionMode: docker.available && status.sandboxed ? 'container' : 'host',
-      browserEnabledByConfig: context.config?.browser?.enabled === true,
-    },
-    guidance: docker.available
-      ? []
-      : ['Install Docker Desktop to keep shell, browser, and sandbox_exec inside containers.'],
-  })
-}
-
-// Execution functions (executeSandboxExec, executeListRuntimes) are kept for shell.ts to import.