@swarmclawai/swarmclaw 1.9.3 → 1.9.5

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/app/api/tasks/task-workspace-route.test.ts

@@ -81,9 +81,13 @@ test('PUT /api/tasks/:id provisions an execution workspace and preview links', a
   assert.equal(response.status, 200)
   const body = await response.json() as BoardTask
   assert.equal(body.executionWorkspace?.sourceCwd, '/source/repo')
+  assert.equal(body.executionWorkspace?.context?.taskId, 'task-route-workspace')
+  assert.equal(body.executionWorkspace?.envHints?.some((hint) => hint.key === 'WORKSPACE_CWD'), true)
   assert.equal(body.previewLinks?.[0]?.url, 'http://127.0.0.1:3456')
   assert.equal(body.runtimeServices?.[0]?.name, 'Next dev')
   assert.equal(fs.existsSync(body.executionWorkspace?.path || ''), true)
+  assert.equal(fs.existsSync(body.executionWorkspace?.contextPath || ''), true)
+  assert.equal(fs.existsSync(body.executionWorkspace?.envPath || ''), true)
 })
 
 test('GET /api/tasks returns computed blocked liveness without persisting a task patch', async () => {

package/src/cli/index.js

@@ -273,6 +273,8 @@ const COMMAND_GROUPS = [
       cmd('delete', 'DELETE', '/gateways/:id', 'Delete a gateway profile'),
       cmd('health', 'GET', '/gateways/:id/health', 'Run a gateway health check'),
       cmd('topology', 'GET', '/gateways/:id/topology', 'Refresh and return one gateway topology snapshot'),
+      cmd('environments', 'GET', '/gateways/:id/environments', 'List OpenClaw gateway execution environments'),
+      cmd('environment-status', 'GET', '/gateways/:id/environments/:environmentId', 'Get one OpenClaw gateway execution environment status'),
       cmd('fleet', 'GET', '/gateways/fleet', 'Refresh and return fleet-wide gateway topology'),
     ],
   },

package/src/cli/spec.js

@@ -221,6 +221,8 @@ const COMMAND_GROUPS = {
       delete: { description: 'Delete a gateway profile', method: 'DELETE', path: '/gateways/:id', params: ['id'] },
       health: { description: 'Run a gateway health check', method: 'GET', path: '/gateways/:id/health', params: ['id'] },
       topology: { description: 'Refresh and return one gateway topology snapshot', method: 'GET', path: '/gateways/:id/topology', params: ['id'] },
+      environments: { description: 'List OpenClaw gateway execution environments', method: 'GET', path: '/gateways/:id/environments', params: ['id'] },
+      'environment-status': { description: 'Get one OpenClaw gateway execution environment status', method: 'GET', path: '/gateways/:id/environments/:environmentId', params: ['id', 'environmentId'] },
       fleet: { description: 'Refresh and return fleet-wide gateway topology', method: 'GET', path: '/gateways/fleet' },
     },
   },

package/src/components/providers/provider-list.tsx

@@ -475,10 +475,14 @@ export function ProviderList({ inSidebar }: { inSidebar?: boolean }) {
               <div className="text-[12px] font-800 text-text">Gateway fleet topology</div>
               <div className="mt-1 text-[11px] text-text-3/70">
                 {gatewayFleetTopology.totals.connectedGatewayCount}/{gatewayFleetTopology.totals.gatewayCount} gateways connected ·{' '}
-                {gatewayFleetTopology.totals.connectedNodeCount}/{gatewayFleetTopology.totals.nodeCount} nodes connected
+                {gatewayFleetTopology.totals.connectedNodeCount}/{gatewayFleetTopology.totals.nodeCount} nodes connected ·{' '}
+                {gatewayFleetTopology.totals.availableEnvironmentCount || 0}/{gatewayFleetTopology.totals.environmentCount || 0} environments available
               </div>
             </div>
             <div className="flex flex-wrap gap-2 text-[11px] text-text-3/70">
+              <span className="rounded-full border border-white/[0.06] bg-white/[0.03] px-2.5 py-1">
+                {gatewayFleetTopology.totals.environmentCount || 0} environments
+              </span>
               <span className="rounded-full border border-white/[0.06] bg-white/[0.03] px-2.5 py-1">
                 {gatewayFleetTopology.totals.sessionCount || 0} sessions
               </span>
@@ -536,6 +540,7 @@ export function ProviderList({ inSidebar }: { inSidebar?: boolean }) {
             const topologyErrors = topology?.errors || []
             const pendingPairings = (stats?.pendingNodePairings || 0) + (stats?.pendingDevicePairings || 0)
             const topologyErrorCount = topologyErrors.length || stats?.lastTopologyErrorCount || 0
+            const environments = topology?.environments || []
             return (
           <div
             key={gateway.id}
@@ -602,6 +607,12 @@ export function ProviderList({ inSidebar }: { inSidebar?: boolean }) {
                     {stats?.connectedNodeCount ?? 0}/{stats?.nodeCount ?? 0} nodes · {stats?.pairedDeviceCount ?? 0} devices
                   </div>
                 </div>
+                <div className="rounded-[10px] border border-white/[0.05] bg-white/[0.02] px-3 py-2">
+                  <div className="uppercase tracking-[0.08em] text-text-3/50">Environments</div>
+                  <div className="mt-1 text-text-2">
+                    {stats?.availableEnvironmentCount ?? 0}/{stats?.environmentCount ?? 0} available
+                  </div>
+                </div>
                 <div className="rounded-[10px] border border-white/[0.05] bg-white/[0.02] px-3 py-2">
                   <div className="uppercase tracking-[0.08em] text-text-3/50">Sessions</div>
                   <div className="mt-1 text-text-2">
@@ -616,6 +627,28 @@ export function ProviderList({ inSidebar }: { inSidebar?: boolean }) {
                 </div>
               </div>
             )}
+            {!inSidebar && environments.length > 0 && (
+              <div className="mt-3 flex flex-wrap gap-1.5">
+                {environments.slice(0, 4).map((environment) => (
+                  <span
+                    key={`${gateway.id}-${environment.id}`}
+                    className={`rounded-full border px-2 py-0.5 text-[10px] font-700 uppercase tracking-[0.08em] ${
+                      environment.status === 'available'
+                        ? 'border-emerald-400/20 bg-emerald-400/[0.06] text-emerald-300'
+                        : 'border-white/[0.06] bg-white/[0.03] text-text-3/70'
+                    }`}
+                    title={environment.capabilities?.join(', ') || environment.id}
+                  >
+                    {environment.label || environment.id}
+                  </span>
+                ))}
+                {environments.length > 4 && (
+                  <span className="rounded-full border border-white/[0.06] bg-white/[0.03] px-2 py-0.5 text-[10px] font-700 uppercase tracking-[0.08em] text-text-3/70">
+                    +{environments.length - 4}
+                  </span>
+                )}
+              </div>
+            )}
             {!inSidebar && (pendingPairings > 0 || topologyErrorCount > 0) && (
               <div className={`mt-3 rounded-[10px] border px-3 py-2 text-[11px] leading-relaxed ${
                 topologyErrorCount > 0

package/src/components/tasks/task-sheet.tsx

@@ -462,6 +462,31 @@ export function TaskSheet() {
             {editing.executionWorkspace?.path && (
               <code className="block text-[12px] text-text-3 font-mono break-all">{editing.executionWorkspace.path}</code>
             )}
+            {(editing.executionWorkspace?.contextPath || editing.executionWorkspace?.envPath) && (
+              <div className="grid grid-cols-1 gap-2 text-[11px] text-text-3/70">
+                {editing.executionWorkspace.contextPath && (
+                  <div className="rounded-[10px] border border-white/[0.05] bg-white/[0.02] px-3 py-2">
+                    <div className="uppercase tracking-[0.08em] text-text-3/50">Context</div>
+                    <code className="mt-1 block break-all text-text-2">{editing.executionWorkspace.contextPath}</code>
+                  </div>
+                )}
+                {editing.executionWorkspace.envPath && (
+                  <div className="rounded-[10px] border border-white/[0.05] bg-white/[0.02] px-3 py-2">
+                    <div className="uppercase tracking-[0.08em] text-text-3/50">Env</div>
+                    <code className="mt-1 block break-all text-text-2">{editing.executionWorkspace.envPath}</code>
+                  </div>
+                )}
+              </div>
+            )}
+            {editing.executionWorkspace?.envHints?.length ? (
+              <div className="flex flex-wrap gap-1.5">
+                {editing.executionWorkspace.envHints.slice(0, 8).map((hint) => (
+                  <InfoChip key={hint.key} tone="neutral" title={hint.value}>
+                    <span className="max-w-[220px] truncate">{hint.key}</span>
+                  </InfoChip>
+                ))}
+              </div>
+            ) : null}
             {previewLinks.length > 0 && (
               <div className="flex flex-wrap gap-2">
                 {previewLinks.map((link) => (
@@ -942,6 +967,31 @@ export function TaskSheet() {
             {editing.executionWorkspace?.path && (
               <code className="block text-[12px] text-text-3 font-mono break-all">{editing.executionWorkspace.path}</code>
             )}
+            {(editing.executionWorkspace?.contextPath || editing.executionWorkspace?.envPath) && (
+              <div className="grid grid-cols-1 gap-2 text-[11px] text-text-3/70">
+                {editing.executionWorkspace.contextPath && (
+                  <div className="rounded-[10px] border border-white/[0.05] bg-white/[0.02] px-3 py-2">
+                    <div className="uppercase tracking-[0.08em] text-text-3/50">Context</div>
+                    <code className="mt-1 block break-all text-text-2">{editing.executionWorkspace.contextPath}</code>
+                  </div>
+                )}
+                {editing.executionWorkspace.envPath && (
+                  <div className="rounded-[10px] border border-white/[0.05] bg-white/[0.02] px-3 py-2">
+                    <div className="uppercase tracking-[0.08em] text-text-3/50">Env</div>
+                    <code className="mt-1 block break-all text-text-2">{editing.executionWorkspace.envPath}</code>
+                  </div>
+                )}
+              </div>
+            )}
+            {editing.executionWorkspace?.envHints?.length ? (
+              <div className="flex flex-wrap gap-1.5">
+                {editing.executionWorkspace.envHints.slice(0, 8).map((hint) => (
+                  <InfoChip key={hint.key} tone="neutral" title={hint.value}>
+                    <span className="max-w-[220px] truncate">{hint.key}</span>
+                  </InfoChip>
+                ))}
+              </div>
+            ) : null}
             {previewLinks.length > 0 && (
               <div className="flex flex-wrap gap-2">
                 {previewLinks.map((link) => (

package/src/features/gateways/queries.ts

@@ -3,6 +3,7 @@ import { api } from '@/lib/app/api-client'
 import { credentialQueryKeys } from '@/features/credentials/queries'
 import type {
   GatewayProfile,
+  OpenClawEnvironmentSummary,
   OpenClawDevicePairRequest,
   OpenClawGatewayFleetTopology,
   OpenClawGatewayPresenceEntry,
@@ -60,6 +61,7 @@ export interface RefreshGatewayTopologyResult {
   pairedDevices: OpenClawPairedDevice[]
   sessions: OpenClawGatewaySession[]
   presence: OpenClawGatewayPresenceEntry[]
+  environments: OpenClawEnvironmentSummary[]
   errors: OpenClawGatewayRpcError[]
   topology: OpenClawGatewayTopology
 }
@@ -190,6 +192,7 @@ export function useRefreshGatewayTopologyMutation() {
         pairedDevices: topology.pairedDevices,
         sessions: topology.sessions,
         presence: topology.presence,
+        environments: topology.environments,
         errors: topology.errors,
         topology,
       }

package/src/lib/server/gateways/gateway-profile-service.ts

@@ -70,6 +70,8 @@ function normalizeStats(value: unknown): OpenClawGatewayStats | null {
     externalRuntimeCount: normalizeNullableNumber(stats.externalRuntimeCount) ?? undefined,
     sessionCount: normalizeNullableNumber(stats.sessionCount) ?? undefined,
     presenceCount: normalizeNullableNumber(stats.presenceCount) ?? undefined,
+    environmentCount: normalizeNullableNumber(stats.environmentCount) ?? undefined,
+    availableEnvironmentCount: normalizeNullableNumber(stats.availableEnvironmentCount) ?? undefined,
     lastTopologyCheckedAt: normalizeNullableNumber(stats.lastTopologyCheckedAt) ?? undefined,
     lastTopologyErrorCount: normalizeNullableNumber(stats.lastTopologyErrorCount) ?? undefined,
     lastTopologyError: normalizeText(stats.lastTopologyError),

package/src/lib/server/gateways/gateway-topology.test.ts

@@ -1,7 +1,11 @@
 import assert from 'node:assert/strict'
 import { describe, it } from 'node:test'
 
-import { buildOpenClawGatewayTopology, getOpenClawGatewayFleetTopology } from './gateway-topology'
+import {
+  buildOpenClawGatewayTopology,
+  getOpenClawGatewayEnvironmentStatus,
+  getOpenClawGatewayFleetTopology,
+} from './gateway-topology'
 import type { GatewayProfile, OpenClawGatewayStats } from '@/types'
 
 const now = 1_800_000_000_000
@@ -60,6 +64,25 @@ describe('OpenClaw gateway topology', () => {
         },
         'sessions.list': { sessions: [{ sessionId: 'session_1', title: 'Release room' }] },
         'system-presence': { presence: [{ deviceId: 'phone_1', mode: 'active' }] },
+        'environments.list': {
+          environments: [
+            {
+              id: 'gateway',
+              type: 'local',
+              label: 'Gateway local',
+              status: 'available',
+              capabilities: ['agent.run', 'sessions', 'tools', 'workspace'],
+            },
+            {
+              id: 'node:node_1',
+              type: 'node',
+              label: 'Mac Studio',
+              status: 'available',
+              capabilities: ['shell.exec'],
+            },
+            { id: 'node:node_2', type: 'node', label: 'Builder', status: 'unavailable' },
+          ],
+        },
       }) as never,
       persistStats: (id, input) => {
         assert.equal(id, 'gateway_1')
@@ -77,6 +100,10 @@ describe('OpenClaw gateway topology', () => {
     assert.equal(topology.stats.pairedDeviceCount, 1)
     assert.equal(topology.stats.sessionCount, 1)
     assert.equal(topology.stats.presenceCount, 1)
+    assert.equal(topology.stats.environmentCount, 3)
+    assert.equal(topology.stats.availableEnvironmentCount, 2)
+    assert.equal(topology.environments[0]?.id, 'gateway')
+    assert.equal(topology.environments[1]?.capabilities?.[0], 'shell.exec')
     assert.equal(topology.stats.pendingPairingCount, 2)
     assert.equal(topology.stats.hasErrors, false)
     assert.equal(topology.stats.lastTopologyCheckedAt, now)
@@ -92,15 +119,17 @@ describe('OpenClaw gateway topology', () => {
         'device.pair.list': { pending: [], paired: [] },
         'sessions.list': new Error('sessions unavailable'),
         'system-presence': new Error('presence unavailable'),
+        'environments.list': new Error('environments unavailable'),
       }) as never,
       persistStats: (id, input) => ({ ...profile({ id }), stats: input.stats as OpenClawGatewayStats }),
     })
 
     assert.equal(topology.nodes.length, 1)
     assert.equal(topology.sessions.length, 0)
-    assert.deepEqual(topology.errors.map((error) => error.method), ['sessions.list', 'system-presence'])
+    assert.equal(topology.environments.length, 2)
+    assert.deepEqual(topology.errors.map((error) => error.method), ['sessions.list', 'system-presence', 'environments.list'])
     assert.equal(topology.stats.hasErrors, true)
-    assert.equal(topology.stats.lastTopologyErrorCount, 2)
+    assert.equal(topology.stats.lastTopologyErrorCount, 3)
     assert.equal(topology.stats.lastTopologyError, 'sessions unavailable')
   })
 
@@ -113,6 +142,7 @@ describe('OpenClaw gateway topology', () => {
     assert.equal(topology.connected, false)
     assert.equal(topology.stats.hasErrors, true)
     assert.equal(topology.stats.nodeCount, 0)
+    assert.equal(topology.stats.environmentCount, 0)
     assert.equal(topology.errors[0]?.method, 'gateway.connect')
   })
 
@@ -132,6 +162,11 @@ describe('OpenClaw gateway topology', () => {
         'device.pair.list': { pending: [], paired: [] },
         'sessions.list': { sessions: target?.profileId === 'gateway_a' ? [{ id: 'session_a' }] : [] },
         'system-presence': { presence: [] },
+        'environments.list': {
+          environments: target?.profileId === 'gateway_a'
+            ? [{ id: 'gateway', type: 'local', status: 'available' }]
+            : [{ id: 'gateway', type: 'local', status: 'available' }, { id: 'node:node_b', type: 'node', status: 'unavailable' }],
+        },
       }) as never,
       persistStats: (id, input) => ({
         ...(id === 'gateway_a' ? first : second),
@@ -144,8 +179,29 @@ describe('OpenClaw gateway topology', () => {
     assert.equal(fleet.totals.connectedGatewayCount, 2)
     assert.equal(fleet.totals.nodeCount, 2)
     assert.equal(fleet.totals.connectedNodeCount, 1)
+    assert.equal(fleet.totals.environmentCount, 3)
+    assert.equal(fleet.totals.availableEnvironmentCount, 2)
     assert.equal(fleet.totals.pendingNodePairings, 1)
     assert.equal(fleet.totals.sessionCount, 1)
     assert.equal(fleet.gateways.length, 2)
   })
+
+  it('returns direct environment status through the gateway protocol', async () => {
+    const calls: Array<{ method: string; params?: Record<string, unknown> }> = []
+    const status = await getOpenClawGatewayEnvironmentStatus('gateway_1', 'node:node_1', {
+      now: () => now,
+      getGatewayProfile: () => profile(),
+      ensureGatewayConnected: async () => ({
+        connected: true,
+        rpc: async (method: string, params?: Record<string, unknown>) => {
+          calls.push({ method, params })
+          return { id: 'node:node_1', type: 'node', label: 'Mac Studio', status: 'available', capabilities: ['shell.exec'] }
+        },
+      }) as never,
+    })
+
+    assert.equal(status?.environment?.id, 'node:node_1')
+    assert.equal(status?.environment?.status, 'available')
+    assert.deepEqual(calls, [{ method: 'environments.status', params: { environmentId: 'node:node_1' } }])
+  })
 })