@swarmclawai/swarmclaw 1.9.4 → 1.9.6

package/src/app/api/portability/import/route.test.ts

@@ -1,39 +1,18 @@
 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 test 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-portability-import-'))
-  try {
-    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
-      cwd: repoRoot,
-      env: {
-        ...process.env,
-        DATA_DIR: path.join(tempDir, 'data'),
-        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 })
-  }
-}
+import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
 
 test('POST /api/portability/import validates manifest arrays before importing', () => {
-  const output = runWithTempDataDir(`
+  const output = runWithTempDataDir<{
+    invalidStatus: number
+    invalidError: string | null
+    invalidPaths: string[]
+    validStatus: number
+    validAgentsCreated: number | null
+    validSkillsCreated: number | null
+    validSchedulesCreated: number | null
+  }>(`
     const routeMod = await import('./src/app/api/portability/import/route')
     const route = routeMod.default || routeMod
 
@@ -78,3 +57,225 @@ test('POST /api/portability/import validates manifest arrays before importing',
   assert.equal(output.validSkillsCreated, 0)
   assert.equal(output.validSchedulesCreated, 0)
 })
+
+test('POST /api/portability/import preserves v2 bundle resources after validation', () => {
+  const output = runWithTempDataDir<{
+    status: number
+    created: Record<string, number>
+    projectId: string | null
+    agentId: string | null
+    agentProjectId: string | null
+    agentSkillIds: string[]
+    agentMcpServerIds: string[]
+    agentGoalId: string | null
+    skillId: string | null
+    skillProjectId: string | null
+    skillAgentIds: string[]
+    scheduleProjectId: string | null
+    scheduleParticipantIds: string[]
+    scheduleFacilitatorId: string | null
+    scheduleObserverIds: string[]
+    chatroomId: string | null
+    chatroomAgentIds: string[]
+    connectorAgentId: string | null
+    connectorChatroomId: string | null
+    connectorEnabled: boolean | null
+    mcpId: string | null
+    mcpEnvKeys: string[]
+    goalId: string | null
+    goalProjectId: string | null
+    goalAgentId: string | null
+    needsCredentials: string[]
+  }>(`
+    const routeMod = await import('./src/app/api/portability/import/route')
+    const storageMod = await import('./src/lib/server/storage')
+    const agentRepoMod = await import('./src/lib/server/agents/agent-repository')
+    const skillRepoMod = await import('./src/lib/server/skills/skill-repository')
+    const scheduleRepoMod = await import('./src/lib/server/schedules/schedule-repository')
+    const chatroomRepoMod = await import('./src/lib/server/chatrooms/chatroom-repository')
+    const connectorRepoMod = await import('./src/lib/server/connectors/connector-repository')
+    const route = routeMod.default || routeMod
+    const storage = storageMod.default || storageMod
+    const agentRepo = agentRepoMod.default || agentRepoMod
+    const skillRepo = skillRepoMod.default || skillRepoMod
+    const scheduleRepo = scheduleRepoMod.default || scheduleRepoMod
+    const chatroomRepo = chatroomRepoMod.default || chatroomRepoMod
+    const connectorRepo = connectorRepoMod.default || connectorRepoMod
+    const { loadProjects, loadMcpServers, loadGoals } = storage
+    const { loadAgents } = agentRepo
+    const { loadSkills } = skillRepo
+    const { loadSchedules } = scheduleRepo
+    const { loadChatrooms } = chatroomRepo
+    const { loadConnectors } = connectorRepo
+
+    const response = await route.POST(new Request('http://local/api/portability/import', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        formatVersion: 2,
+        exportedAt: '2026-05-05T00:00:00.000Z',
+        scope: { kind: 'project', originalProjectId: 'project-1', projectName: 'Launch Room' },
+        projects: [{
+          originalId: 'project-1',
+          name: 'Launch Room',
+          description: 'Shipping workspace',
+          objective: 'Ship the fix',
+        }],
+        skills: [{
+          originalId: 'skill-1',
+          originalProjectId: 'project-1',
+          originalAgentIds: ['agent-1'],
+          name: 'Release Skill',
+          content: 'Ship carefully',
+          scope: 'agent',
+        }],
+        mcpServers: [{
+          originalId: 'mcp-1',
+          name: 'Local Tools',
+          transport: 'stdio',
+          command: 'node',
+          args: ['tool.js'],
+          envKeys: ['API_TOKEN'],
+          credentialsScrubbed: true,
+        }],
+        agents: [{
+          originalId: 'agent-1',
+          name: 'Release Lead',
+          description: 'Owns launch execution',
+          systemPrompt: 'Ship safely',
+          provider: 'openai',
+          model: 'gpt-4o-mini',
+          projectId: 'project-1',
+          skillIds: ['skill-1'],
+          mcpServerIds: ['mcp-1'],
+          goalId: 'goal-1',
+        }],
+        schedules: [{
+          originalId: 'schedule-1',
+          originalAgentId: 'agent-1',
+          name: 'Launch Check',
+          projectId: 'project-1',
+          taskPrompt: 'Check release readiness',
+          taskMode: 'protocol',
+          protocolTemplateId: 'template-1',
+          protocolParticipantAgentIds: ['agent-1'],
+          protocolFacilitatorAgentId: 'agent-1',
+          protocolObserverAgentIds: ['agent-1'],
+          protocolConfig: { phase: 'ship' },
+          scheduleType: 'interval',
+          intervalMs: 60000,
+        }],
+        chatrooms: [{
+          originalId: 'room-1',
+          originalAgentIds: ['agent-1'],
+          name: 'Launch Room Chat',
+          chatMode: 'parallel',
+          autoAddress: true,
+          routingRules: [{
+            type: 'keyword',
+            keywords: ['release'],
+            originalAgentId: 'agent-1',
+            priority: 1,
+          }],
+        }],
+        connectors: [{
+          originalId: 'connector-1',
+          originalAgentId: 'agent-1',
+          originalChatroomId: 'room-1',
+          name: 'Launch Slack',
+          platform: 'slack',
+          isEnabled: false,
+          config: { channel: 'launch' },
+          credentialsScrubbed: true,
+        }],
+        goals: [{
+          originalId: 'goal-1',
+          originalProjectId: 'project-1',
+          originalAgentId: 'agent-1',
+          title: 'Ship fix',
+          level: 'project',
+          objective: 'Release the portability fix',
+          status: 'active',
+        }],
+        extensions: [{ name: 'builtin-checks' }],
+      }),
+    }))
+    const payload = await response.json()
+    const project = Object.values(loadProjects()).find((item) => item.name === 'Launch Room')
+    const agent = Object.values(loadAgents()).find((item) => item.name === 'Release Lead')
+    const skill = Object.values(loadSkills()).find((item) => item.name === 'Release Skill')
+    const schedule = Object.values(loadSchedules()).find((item) => item.name === 'Launch Check')
+    const chatroom = Object.values(loadChatrooms()).find((item) => item.name === 'Launch Room Chat')
+    const connector = Object.values(loadConnectors()).find((item) => item.name === 'Launch Slack')
+    const mcp = Object.values(loadMcpServers()).find((item) => item.name === 'Local Tools')
+    const goal = Object.values(loadGoals()).find((item) => item.title === 'Ship fix')
+
+    console.log(JSON.stringify({
+      status: response.status,
+      created: {
+        agents: payload.agents.created,
+        skills: payload.skills.created,
+        schedules: payload.schedules.created,
+        connectors: payload.connectors.created,
+        chatrooms: payload.chatrooms.created,
+        mcpServers: payload.mcpServers.created,
+        projects: payload.projects.created,
+        goals: payload.goals.created,
+      },
+      projectId: project?.id || null,
+      agentId: agent?.id || null,
+      agentProjectId: agent?.projectId || null,
+      agentSkillIds: agent?.skillIds || [],
+      agentMcpServerIds: agent?.mcpServerIds || [],
+      agentGoalId: agent?.goalId || null,
+      skillId: skill?.id || null,
+      skillProjectId: skill?.projectId || null,
+      skillAgentIds: skill?.agentIds || [],
+      scheduleProjectId: schedule?.projectId || null,
+      scheduleParticipantIds: schedule?.protocolParticipantAgentIds || [],
+      scheduleFacilitatorId: schedule?.protocolFacilitatorAgentId || null,
+      scheduleObserverIds: schedule?.protocolObserverAgentIds || [],
+      chatroomId: chatroom?.id || null,
+      chatroomAgentIds: chatroom?.agentIds || [],
+      connectorAgentId: connector?.agentId || null,
+      connectorChatroomId: connector?.chatroomId || null,
+      connectorEnabled: connector?.isEnabled ?? null,
+      mcpId: mcp?.id || null,
+      mcpEnvKeys: Object.keys(mcp?.env || {}),
+      goalId: goal?.id || null,
+      goalProjectId: goal?.projectId || null,
+      goalAgentId: goal?.agentId || null,
+      needsCredentials: payload.mcpServers.needsCredentials,
+    }))
+  `)
+
+  assert.equal(output.status, 200)
+  assert.deepEqual(output.created, {
+    agents: 1,
+    skills: 1,
+    schedules: 1,
+    connectors: 1,
+    chatrooms: 1,
+    mcpServers: 1,
+    projects: 1,
+    goals: 1,
+  })
+  assert.equal(output.agentProjectId, output.projectId)
+  assert.deepEqual(output.agentSkillIds, [output.skillId])
+  assert.deepEqual(output.agentMcpServerIds, [output.mcpId])
+  assert.equal(output.agentGoalId, output.goalId)
+  assert.equal(output.skillProjectId, output.projectId)
+  assert.deepEqual(output.skillAgentIds, [output.agentId])
+  assert.equal(output.scheduleProjectId, output.projectId)
+  assert.deepEqual(output.scheduleParticipantIds, [output.agentId])
+  assert.equal(output.scheduleFacilitatorId, output.agentId)
+  assert.deepEqual(output.scheduleObserverIds, [output.agentId])
+  assert.deepEqual(output.chatroomAgentIds, [output.agentId])
+  assert.equal(output.connectorAgentId, output.agentId)
+  assert.equal(output.connectorChatroomId, output.chatroomId)
+  assert.equal(output.connectorEnabled, false)
+  assert.deepEqual(output.mcpEnvKeys, ['API_TOKEN'])
+  assert.equal(output.goalProjectId, output.projectId)
+  assert.equal(output.goalAgentId, output.agentId)
+  assert.deepEqual(output.needsCredentials, ['Local Tools'])
+})

package/src/app/api/portability/import/route.ts

@@ -16,11 +16,11 @@ export async function POST(req: Request) {
   }
 
   try {
-    const result = importConfig(parsed.data as PortableManifest)
+    const result = importConfig(parsed.data as unknown as PortableManifest)
     return NextResponse.json(result)
   } catch (err) {
     const message = err instanceof Error ? err.message : 'Failed to import manifest'
-    if (/^Unsupported format version /i.test(message)) {
+    if (message.startsWith('Unsupported format version ')) {
       return NextResponse.json({ error: message }, { status: 400 })
     }
     return NextResponse.json({ error: message }, { status: 500 })

package/src/cli/index.js

@@ -231,8 +231,10 @@ const COMMAND_GROUPS = [
       cmd('scenarios', 'GET', '/eval/scenarios', 'List available eval scenarios'),
       cmd('suites', 'GET', '/eval/suites', 'List available eval suites (core, swe-bench-lite, gaia-l1, ...)'),
       cmd('status', 'GET', '/eval/run', 'Get eval run status'),
+      cmd('environment', 'GET', '/eval/environments', 'Preview validation environment readiness for an eval'),
       cmd('run', 'POST', '/eval/run', 'Run an eval scenario against an agent', { expectsJsonBody: true }),
       cmd('suite', 'POST', '/eval/suite', 'Run a full eval suite against an agent (pass { suite: "swe-bench-lite" } in body)', { expectsJsonBody: true }),
+      cmd('environment-prepare', 'POST', '/eval/environments', 'Prepare validation environment readiness for an eval', { expectsJsonBody: true }),
     ],
   },
   {

package/src/components/quality/quality-workspace.tsx

@@ -17,7 +17,7 @@ import {
 } from '@/lib/quality/quality-summary'
 import { cn } from '@/lib/utils'
 import { useAppStore } from '@/stores/use-app-store'
-import type { EvalRun, EvalSuiteResult } from '@/lib/server/eval/types'
+import type { EvalEnvironmentPlan, EvalRun, EvalSuiteResult } from '@/lib/server/eval/types'
 import type { Agent, ApprovalRequest, SessionRunRecord } from '@/types'
 
 type QualityTab = 'overview' | 'evals' | 'approvals' | 'runs'
@@ -105,6 +105,96 @@ function EmptyState({ title, description }: { title: string; description: string
   )
 }
 
+function environmentStatusClass(status: EvalEnvironmentPlan['status']): string {
+  if (status === 'ready') return 'border-emerald-500/25 bg-emerald-500/10 text-emerald-200'
+  if (status === 'warning') return 'border-amber-500/25 bg-amber-500/10 text-amber-200'
+  return 'border-rose-500/25 bg-rose-500/10 text-rose-200'
+}
+
+function checkClass(level: 'info' | 'warn' | 'error'): string {
+  if (level === 'error') return 'border-rose-500/20 bg-rose-500/[0.05] text-rose-200'
+  if (level === 'warn') return 'border-amber-500/20 bg-amber-500/[0.05] text-amber-200'
+  return 'border-white/[0.06] bg-white/[0.025] text-text-3'
+}
+
+function EvalEnvironmentPanel({ plan, loading, onRefresh }: {
+  plan: EvalEnvironmentPlan | null
+  loading: boolean
+  onRefresh: () => void
+}) {
+  return (
+    <div className="rounded-[12px] border border-white/[0.06] bg-white/[0.025] px-3 py-3">
+      <div className="flex items-start justify-between gap-3">
+        <div>
+          <div className="text-[13px] font-800 text-text">Validation environment</div>
+          <p className="mt-1 text-[11px] leading-relaxed text-text-3/65">
+            Preflight checks, workspace context, and generated files for the selected eval.
+          </p>
+        </div>
+        <button
+          type="button"
+          onClick={onRefresh}
+          disabled={loading}
+          className="shrink-0 rounded-[8px] border border-white/[0.08] px-2 py-1 text-[10px] font-800 text-text-2 transition-colors hover:bg-white/[0.06] disabled:opacity-40"
+        >
+          {loading ? 'Checking' : 'Refresh'}
+        </button>
+      </div>
+      {!plan ? (
+        <div className="mt-3 text-[11px] text-text-3/60">{loading ? 'Checking readiness...' : 'Choose an agent and scenario.'}</div>
+      ) : (
+        <div className="mt-3 flex flex-col gap-3">
+          <div className="flex flex-wrap items-center gap-2">
+            <span className={cn('rounded-full border px-2 py-1 text-[10px] font-800 uppercase tracking-[0.08em]', environmentStatusClass(plan.status))}>
+              {plan.status}
+            </span>
+            {plan.target && (
+              <span className="rounded-full bg-white/[0.05] px-2 py-1 text-[10px] font-700 text-text-3">
+                {plan.target.kind} - {plan.target.label}
+              </span>
+            )}
+            <span className="rounded-full bg-white/[0.05] px-2 py-1 text-[10px] font-700 text-text-3">
+              {plan.requiredTools.length} tool{plan.requiredTools.length === 1 ? '' : 's'}
+            </span>
+            <span className="rounded-full bg-white/[0.05] px-2 py-1 text-[10px] font-700 text-text-3">
+              {plan.generatedFiles.length} file{plan.generatedFiles.length === 1 ? '' : 's'}
+            </span>
+          </div>
+          {plan.target?.environmentLabel && (
+            <div className="rounded-[10px] border border-white/[0.06] bg-white/[0.02] px-3 py-2 text-[11px] text-text-3/70">
+              Environment: <span className="font-700 text-text-2">{plan.target.environmentLabel}</span>
+              {plan.target.environmentStatus ? ` (${plan.target.environmentStatus})` : ''}
+            </div>
+          )}
+          <div className="flex flex-col gap-1.5">
+            {plan.checks.slice(0, 4).map((check) => (
+              <div key={`${check.code}:${check.message}`} className={cn('rounded-[9px] border px-2.5 py-2 text-[11px] leading-relaxed', checkClass(check.level))}>
+                <span className="font-800 uppercase tracking-[0.08em]">{check.level}</span>
+                <span className="ml-2">{check.message}</span>
+              </div>
+            ))}
+            {plan.checks.length > 4 && (
+              <div className="text-[10px] text-text-3/55">+{plan.checks.length - 4} more check{plan.checks.length - 4 === 1 ? '' : 's'}</div>
+            )}
+          </div>
+          <div className="flex flex-wrap gap-1.5">
+            {plan.generatedFiles.slice(0, 5).map((file) => (
+              <span key={`${file.kind}:${file.path}`} className="rounded-full bg-white/[0.04] px-2 py-1 text-[10px] font-700 text-text-3">
+                {file.path}
+              </span>
+            ))}
+            {plan.generatedFiles.length > 5 && (
+              <span className="rounded-full bg-white/[0.04] px-2 py-1 text-[10px] font-700 text-text-3">
+                +{plan.generatedFiles.length - 5}
+              </span>
+            )}
+          </div>
+        </div>
+      )}
+    </div>
+  )
+}
+
 export function QualityWorkspace() {
   const router = useRouter()
   const searchParams = useSearchParams()
@@ -127,6 +217,8 @@ export function QualityWorkspace() {
   const [selectedSuite, setSelectedSuite] = useState('core')
   const [selectedScenarioId, setSelectedScenarioId] = useState('')
   const [evalBusy, setEvalBusy] = useState<string | null>(null)
+  const [evalEnvironmentPlan, setEvalEnvironmentPlan] = useState<EvalEnvironmentPlan | null>(null)
+  const [evalEnvironmentLoading, setEvalEnvironmentLoading] = useState(false)
   const [approvalBusy, setApprovalBusy] = useState<string | null>(null)
 
   useEffect(() => {
@@ -170,6 +262,27 @@ export function QualityWorkspace() {
     }
   }, [])
 
+  const loadEvalEnvironmentPlan = useCallback(async (opts: { refreshGateway?: boolean } = {}) => {
+    if (!selectedAgentId) {
+      setEvalEnvironmentPlan(null)
+      return
+    }
+    const params = new URLSearchParams({ agentId: selectedAgentId })
+    if (selectedScenarioId) params.set('scenarioId', selectedScenarioId)
+    else if (selectedSuite) params.set('suite', selectedSuite)
+    if (opts.refreshGateway) params.set('refreshGateway', 'true')
+    setEvalEnvironmentLoading(true)
+    try {
+      const plan = await api<EvalEnvironmentPlan>('GET', `/eval/environments?${params.toString()}`, undefined, { timeoutMs: opts.refreshGateway ? 20_000 : 8_000 })
+      setEvalEnvironmentPlan(plan)
+    } catch (err) {
+      setEvalEnvironmentPlan(null)
+      toast.error(err instanceof Error ? err.message : 'Unable to validate eval environment')
+    } finally {
+      setEvalEnvironmentLoading(false)
+    }
+  }, [selectedAgentId, selectedScenarioId, selectedSuite])
+
   useEffect(() => {
     void loadQualityData()
   }, [loadQualityData])
@@ -184,6 +297,10 @@ export function QualityWorkspace() {
     if (!selectedScenarioId && scenarios[0]) setSelectedScenarioId(scenarios[0].id)
   }, [scenarios, selectedScenarioId])
 
+  useEffect(() => {
+    void loadEvalEnvironmentPlan()
+  }, [loadEvalEnvironmentPlan])
+
   useEffect(() => {
     if (!suites.some((suite) => suite.name === selectedSuite) && suites[0]) {
       setSelectedSuite(suites[0].name)
@@ -208,34 +325,56 @@ export function QualityWorkspace() {
       toast.error('Choose an agent and scenario first')
       return
     }
+    if (evalEnvironmentPlan?.status === 'blocked') {
+      toast.error('Fix the validation environment before running this eval')
+      return
+    }
     setEvalBusy(`scenario:${selectedScenarioId}`)
     try {
-      await api<EvalRun>('POST', '/eval/run', { agentId: selectedAgentId, scenarioId: selectedScenarioId }, { timeoutMs: 180_000 })
+      await api<EvalRun>('POST', '/eval/run', {
+        agentId: selectedAgentId,
+        scenarioId: selectedScenarioId,
+        gatewayProfileId: evalEnvironmentPlan?.target?.gatewayProfileId || null,
+        environmentId: evalEnvironmentPlan?.target?.environmentId || null,
+        refreshGateway: evalEnvironmentPlan?.target?.kind === 'gateway',
+      }, { timeoutMs: 180_000 })
       toast.success('Eval scenario completed')
       await loadQualityData({ silent: true })
+      await loadEvalEnvironmentPlan()
     } catch (err) {
       toast.error(err instanceof Error ? err.message : 'Eval scenario failed')
     } finally {
       setEvalBusy(null)
     }
-  }, [loadQualityData, selectedAgentId, selectedScenarioId])
+  }, [evalEnvironmentPlan, loadEvalEnvironmentPlan, loadQualityData, selectedAgentId, selectedScenarioId])
 
   const runSuite = useCallback(async (suiteName: string) => {
     if (!selectedAgentId) {
       toast.error('Choose an agent first')
       return
     }
+    if (evalEnvironmentPlan?.status === 'blocked') {
+      toast.error('Fix the validation environment before running this suite')
+      return
+    }
     setEvalBusy(`suite:${suiteName}`)
     try {
-      const result = await api<EvalSuiteResult>('POST', '/eval/suite', { agentId: selectedAgentId, suite: suiteName }, { timeoutMs: 300_000 })
+      const result = await api<EvalSuiteResult>('POST', '/eval/suite', {
+        agentId: selectedAgentId,
+        suite: suiteName,
+        gatewayProfileId: evalEnvironmentPlan?.target?.gatewayProfileId || null,
+        environmentId: evalEnvironmentPlan?.target?.environmentId || null,
+        refreshGateway: evalEnvironmentPlan?.target?.kind === 'gateway',
+      }, { timeoutMs: 300_000 })
       toast.success(`Suite completed at ${Math.round(result.percentage)}%`)
       await loadQualityData({ silent: true })
+      await loadEvalEnvironmentPlan()
     } catch (err) {
       toast.error(err instanceof Error ? err.message : 'Eval suite failed')
     } finally {
       setEvalBusy(null)
     }
-  }, [loadQualityData, selectedAgentId])
+  }, [evalEnvironmentPlan, loadEvalEnvironmentPlan, loadQualityData, selectedAgentId])
 
   const actOnApproval = useCallback(async (approval: ApprovalRequest, approved: boolean) => {
     setApprovalBusy(approval.id)
@@ -456,6 +595,11 @@ export function QualityWorkspace() {
                       </div>
                     </div>
                   )}
+                  <EvalEnvironmentPanel
+                    plan={evalEnvironmentPlan}
+                    loading={evalEnvironmentLoading}
+                    onRefresh={() => void loadEvalEnvironmentPlan({ refreshGateway: true })}
+                  />
                   <button
                     type="button"
                     onClick={() => openMissionTemplate('release-candidate-qa')}