@swarmclawai/swarmclaw 0.7.6 → 0.7.8

package/README.md

@@ -54,11 +54,15 @@ The deployment flow stays **in-house and official-only**:
 
 Supported VPS presets currently include Hetzner, DigitalOcean, Vultr, Linode, Lightsail, Google Cloud, Azure, OCI, and a generic Ubuntu host path. Smart defaults prefill the gateway token, endpoint, storage paths, and copy-paste commands so the resulting gateway can be saved into SwarmClaw with minimal manual editing.
 
+For existing hosts, SwarmClaw can also push the same official-image bundle **over SSH** and then keep remote lifecycle controls attached to that saved gateway profile: start, stop, restart, upgrade, backup, restore, and token rotation.
+
 The OpenClaw Control Plane in SwarmClaw adds:
 - Reload mode switching (`hot`, `hybrid`, `full`)
 - Config issue detection and guided repair
 - Remote history sync
 - Live execution approval handling
+- Gateway import/export JSON, clone flows, and richer external runtime fleet visibility
+- Agent and route-target preferences for steering work toward OpenClaw gateways by tags or use case (`local-dev`, `single-vps`, `private-tailnet`, `browser-heavy`, `team-control`)
 
 The Agent Inspector Panel lets you edit OpenClaw files (`SOUL.md`, `IDENTITY.md`, `USER.md`), tune personality/system behavior, and manage OpenClaw-compatible skills. SwarmClaw also supports importing OpenClaw `SKILL.md` files from URL.
 
@@ -79,8 +83,12 @@ CLI operators can use the same deploy surface without opening the UI:
 ```bash
 swarmclaw openclaw deploy-status
 swarmclaw openclaw deploy-local-start --data '{"port":18789}'
+swarmclaw openclaw deploy-local-restart --data '{"port":18789}'
 swarmclaw openclaw deploy-bundle --data '{"template":"docker","provider":"hetzner","target":"openclaw.example.com"}'
-swarmclaw openclaw deploy-bundle --data '{"template":"render","target":"https://openclaw.example.com"}'
+swarmclaw openclaw deploy-ssh --data '{"target":"openclaw.example.com","provider":"hetzner","ssh":{"host":"your-vps-ip"}}'
+swarmclaw openclaw remote-backup --data '{"ssh":{"host":"your-vps-ip"}}'
+swarmclaw openclaw remote-restore --data '{"backupPath":"/opt/openclaw/backups/openclaw-backup-123.tgz","ssh":{"host":"your-vps-ip"}}'
+swarmclaw openclaw deploy-verify --data '{"endpoint":"https://openclaw.example.com/v1"}'
 ```
 
 ## SwarmClaw ClawHub Skill
@@ -140,7 +148,7 @@ curl -fsSL https://raw.githubusercontent.com/swarmclawai/swarmclaw/main/install.
 ```
 
 The installer resolves the latest stable release tag and installs that version by default.
-To pin a version: `SWARMCLAW_VERSION=v0.7.6 curl ... | bash`
+To pin a version: `SWARMCLAW_VERSION=v0.7.8 curl ... | bash`
 
 Or run locally from the repo (friendly for non-technical users):
 
@@ -693,7 +701,7 @@ npm run update:easy     # safe update helper for local installs
 SwarmClaw uses tag-based releases (`vX.Y.Z`) as the stable channel.
 
 ```bash
-# example patch release (v0.7.6 style)
+# example patch release (v0.7.8 style)
 npm version patch
 git push origin main --follow-tags
 ```
@@ -703,15 +711,16 @@ On `v*` tags, GitHub Actions will:
 2. Create a GitHub Release
 3. Build and publish Docker images to `ghcr.io/swarmclawai/swarmclaw` (`:vX.Y.Z`, `:latest`, `:sha-*`)
 
-#### v0.7.6 Release Readiness Notes
+#### v0.7.8 Release Readiness Notes
 
-Before shipping `v0.7.6`, confirm the following user-facing changes are reflected in docs:
+Before shipping `v0.7.8`, confirm the following user-facing changes are reflected in docs:
 
-1. Sandbox docs are updated everywhere to reflect the current Deno-only `sandbox_exec` behavior and the guidance to prefer `http_request` for simple API calls.
-2. OpenClaw docs cover the current gateway/runtime behavior, including Smart Deploy, official-only Docker/repo paths, local one-click startup, and the main-provider-screen deploy entry points.
-3. Site and README install/version strings are updated to `v0.7.6`, including install snippets, release notes index text, and sidebar/footer labels.
-4. Release notes summarize the user-visible setup/auth/runtime changes from the current worktree, especially Smart Deploy, VPS presets, and onboarding/provider-screen improvements.
-5. CLI and tool docs include the new `openclaw deploy-*` surfaces and do not reference removed or non-functional bridges.
+1. Project docs explain the new project operating-system fields: objective, audience, pilot priorities, open objectives, credential requirements, success metrics, and heartbeat prompt/interval.
+2. Task and approval docs cover the new approval controls, task/project management toggles, and durable task continuation behavior (`continueFromTaskId`, dependency blocking, and session resume reuse).
+3. Connector/operator docs mention automatic connector recovery on disconnect or dev-server restart, including bounded exponential backoff instead of silent disablement.
+4. Chat/runtime docs note the project-aware agent context, Gemini resume-handle visibility, and improved web/connector input handling where relevant.
+5. Site and README install/version strings are updated to `v0.7.8`, including install snippets, release notes index text, and sidebar/footer labels.
+6. Release notes summarize the user-visible changes from the current worktree, especially project operating context, approval/task controls, connector resilience, and chat/runtime polish.
 
 ## CLI
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "0.7.6",
+  "version": "0.7.8",
   "description": "Self-hosted AI agent orchestration dashboard — manage LLM providers, orchestrate agent swarms, schedule tasks, and bridge agents to chat platforms.",
   "license": "MIT",
   "publishConfig": {

package/src/app/api/agents/[id]/route.ts

@@ -23,6 +23,16 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
         body.apiEndpoint,
       )
     }
+    if (body.preferredGatewayTags !== undefined) {
+      agent.preferredGatewayTags = Array.isArray(body.preferredGatewayTags)
+        ? body.preferredGatewayTags.filter((tag: unknown): tag is string => typeof tag === 'string' && tag.trim().length > 0)
+        : []
+    }
+    if (body.preferredGatewayUseCase !== undefined) {
+      agent.preferredGatewayUseCase = typeof body.preferredGatewayUseCase === 'string' && body.preferredGatewayUseCase.trim()
+        ? body.preferredGatewayUseCase.trim()
+        : null
+    }
     if (body.routingTargets !== undefined && Array.isArray(body.routingTargets)) {
       agent.routingTargets = body.routingTargets.map((target: Record<string, unknown>, index: number) => ({
         id: typeof target.id === 'string' && target.id.trim() ? target.id.trim() : `route-${index + 1}`,
@@ -37,6 +47,12 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
           typeof target.apiEndpoint === 'string' ? target.apiEndpoint : null,
         ),
         gatewayProfileId: target.gatewayProfileId ?? null,
+        preferredGatewayTags: Array.isArray(target.preferredGatewayTags)
+          ? target.preferredGatewayTags.filter((tag: unknown): tag is string => typeof tag === 'string' && tag.trim().length > 0)
+          : [],
+        preferredGatewayUseCase: typeof target.preferredGatewayUseCase === 'string' && target.preferredGatewayUseCase.trim()
+          ? target.preferredGatewayUseCase.trim()
+          : null,
         priority: typeof target.priority === 'number' ? target.priority : index + 1,
       }))
     }

package/src/app/api/agents/route.ts

@@ -64,6 +64,8 @@ export async function POST(req: Request) {
     fallbackCredentialIds: body.fallbackCredentialIds,
     apiEndpoint: normalizeProviderEndpoint(body.provider, body.apiEndpoint || null),
     gatewayProfileId: body.gatewayProfileId,
+    preferredGatewayTags: body.preferredGatewayTags,
+    preferredGatewayUseCase: body.preferredGatewayUseCase,
     routingStrategy: body.routingStrategy,
     routingTargets: body.routingTargets?.map((target) => ({
       ...target,

package/src/app/api/chats/[id]/route.ts

@@ -18,7 +18,20 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
   }
 
   const linkedAgent = nextAgentId ? loadAgents()[nextAgentId] : null
-  const linkedRoute = linkedAgent ? resolvePrimaryAgentRoute(linkedAgent) : null
+  const routePreferredGatewayTags = updates.routePreferredGatewayTags !== undefined
+    ? (Array.isArray(updates.routePreferredGatewayTags)
+      ? updates.routePreferredGatewayTags.filter((tag: unknown): tag is string => typeof tag === 'string' && tag.trim().length > 0)
+      : [])
+    : (sessions[id].routePreferredGatewayTags || [])
+  const routePreferredGatewayUseCase = updates.routePreferredGatewayUseCase !== undefined
+    ? (typeof updates.routePreferredGatewayUseCase === 'string' && updates.routePreferredGatewayUseCase.trim()
+      ? updates.routePreferredGatewayUseCase.trim()
+      : null)
+    : (sessions[id].routePreferredGatewayUseCase || null)
+  const linkedRoute = linkedAgent ? resolvePrimaryAgentRoute(linkedAgent, undefined, {
+    preferredGatewayTags: routePreferredGatewayTags,
+    preferredGatewayUseCase: routePreferredGatewayUseCase,
+  }) : null
 
   if (updates.name !== undefined) sessions[id].name = updates.name
   if (updates.cwd !== undefined) sessions[id].cwd = updates.cwd
@@ -39,6 +52,13 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
   if (updates.gatewayProfileId !== undefined) sessions[id].gatewayProfileId = updates.gatewayProfileId
   else if (agentIdUpdateProvided && linkedRoute) sessions[id].gatewayProfileId = linkedRoute.gatewayProfileId ?? null
 
+  if (updates.routePreferredGatewayTags !== undefined) {
+    sessions[id].routePreferredGatewayTags = routePreferredGatewayTags
+  }
+  if (updates.routePreferredGatewayUseCase !== undefined) {
+    sessions[id].routePreferredGatewayUseCase = routePreferredGatewayUseCase
+  }
+
   if (updates.plugins !== undefined) sessions[id].plugins = updates.plugins
   else if (agentIdUpdateProvided && linkedAgent) sessions[id].plugins = Array.isArray(linkedAgent.plugins) ? linkedAgent.plugins : []
 

package/src/app/api/chats/route.ts

@@ -61,7 +61,16 @@ export async function POST(req: Request) {
   const id = body.id || genId()
   const sessions = loadSessions()
   const agent = body.agentId ? loadAgents()[body.agentId] : null
-  const resolvedRoute = agent ? resolvePrimaryAgentRoute(agent) : null
+  const routePreferredGatewayTags = Array.isArray(body.routePreferredGatewayTags)
+    ? body.routePreferredGatewayTags.filter((tag: unknown): tag is string => typeof tag === 'string' && tag.trim().length > 0)
+    : []
+  const routePreferredGatewayUseCase = typeof body.routePreferredGatewayUseCase === 'string' && body.routePreferredGatewayUseCase.trim()
+    ? body.routePreferredGatewayUseCase.trim()
+    : null
+  const resolvedRoute = agent ? resolvePrimaryAgentRoute(agent, undefined, {
+    preferredGatewayTags: routePreferredGatewayTags,
+    preferredGatewayUseCase: routePreferredGatewayUseCase,
+  }) : null
   const requestedPlugins = Array.isArray(body.plugins) ? body.plugins : (Array.isArray(body.tools) ? body.tools : null)
   const resolvedPlugins = requestedPlugins ?? (Array.isArray(agent?.plugins) ? agent.plugins : (Array.isArray(agent?.tools) ? agent.tools : []))
 
@@ -83,6 +92,8 @@ export async function POST(req: Request) {
       body.provider || agent?.provider || 'claude-cli',
       body.apiEndpoint || agent?.apiEndpoint || null,
     ),
+    routePreferredGatewayTags,
+    routePreferredGatewayUseCase,
     claudeSessionId: null,
     codexThreadId: null,
     opencodeSessionId: null,
@@ -90,6 +101,7 @@ export async function POST(req: Request) {
       claudeCode: null,
       codex: null,
       opencode: null,
+      gemini: null,
     },
     messages: Array.isArray(body.messages) ? body.messages : [],
     createdAt: Date.now(), lastActiveAt: Date.now(),

package/src/app/api/connectors/[id]/route.ts

@@ -2,8 +2,10 @@ import { NextResponse } from 'next/server'
 import { loadConnectors, saveConnectors, logActivity } from '@/lib/server/storage'
 import { notify } from '@/lib/server/ws-hub'
 import { notFound } from '@/lib/server/collection-helpers'
+import { ensureDaemonStarted } from '@/lib/server/daemon-state'
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  ensureDaemonStarted('api/connectors/[id]:get')
   const { id } = await params
   const connectors = loadConnectors()
   const connector = connectors[id]
@@ -11,8 +13,21 @@ export async function GET(_req: Request, { params }: { params: Promise<{ id: str
 
   // Merge runtime status, QR code, and presence
   try {
-    const { getConnectorStatus, getConnectorQR, isConnectorAuthenticated, hasConnectorCredentials, getConnectorPresence } = await import('@/lib/server/connectors/manager')
-    connector.status = getConnectorStatus(id)
+    const { getConnectorStatus, getConnectorQR, isConnectorAuthenticated, hasConnectorCredentials, getConnectorPresence, getReconnectState } = await import('@/lib/server/connectors/manager')
+    const runtimeStatus = getConnectorStatus(id)
+    connector.status = runtimeStatus === 'running'
+      ? 'running'
+      : connector.lastError
+        ? 'error'
+        : 'stopped'
+    const rState = getReconnectState(id)
+    if (rState) {
+      const ext = connector as unknown as Record<string, unknown>
+      ext.reconnectAttempts = rState.attempts
+      ext.nextRetryAt = rState.nextRetryAt
+      ext.reconnectError = rState.error
+      ext.reconnectExhausted = rState.exhausted
+    }
     const qr = getConnectorQR(id)
     if (qr) connector.qrDataUrl = qr
     connector.authenticated = isConnectorAuthenticated(id)
@@ -26,6 +41,7 @@ export async function GET(_req: Request, { params }: { params: Promise<{ id: str
 }
 
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  ensureDaemonStarted('api/connectors/[id]:put')
   const { id } = await params
   const body = await req.json()
   const connectors = loadConnectors()
@@ -38,12 +54,14 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
     try {
       const manager = await import('@/lib/server/connectors/manager')
       if (body.action === 'start') {
+        manager.clearReconnectState(id)
         await manager.startConnector(id)
         logActivity({ entityType: 'connector', entityId: id, action: 'started', actor: 'user', summary: `Connector started: "${connector.name}"` })
       } else if (body.action === 'stop') {
         await manager.stopConnector(id)
         logActivity({ entityType: 'connector', entityId: id, action: 'stopped', actor: 'user', summary: `Connector stopped: "${connector.name}"` })
       } else {
+        manager.clearReconnectState(id)
         await manager.repairConnector(id)
         logActivity({ entityType: 'connector', entityId: id, action: 'started', actor: 'user', summary: `Connector repaired: "${connector.name}"` })
       }

package/src/app/api/connectors/route.ts

@@ -2,19 +2,26 @@ import { NextResponse } from 'next/server'
 import { genId } from '@/lib/id'
 import { loadConnectors, saveConnectors } from '@/lib/server/storage'
 import { notify } from '@/lib/server/ws-hub'
+import { ensureDaemonStarted } from '@/lib/server/daemon-state'
 import { ConnectorCreateSchema, formatZodError } from '@/lib/validation/schemas'
 import { z } from 'zod'
 import type { Connector } from '@/types'
 export const dynamic = 'force-dynamic'
 
 
-export async function GET(_req: Request) {
+export async function GET() {
+  ensureDaemonStarted('api/connectors:get')
   const connectors = loadConnectors()
   // Merge runtime status from manager
   try {
     const { getConnectorStatus, isConnectorAuthenticated, hasConnectorCredentials, getConnectorQR, getReconnectState } = await import('@/lib/server/connectors/manager')
     for (const c of Object.values(connectors) as Connector[]) {
-      c.status = getConnectorStatus(c.id)
+      const runtimeStatus = getConnectorStatus(c.id)
+      c.status = runtimeStatus === 'running'
+        ? 'running'
+        : c.lastError
+          ? 'error'
+          : 'stopped'
       if (c.platform === 'whatsapp') {
         c.authenticated = isConnectorAuthenticated(c.id)
         c.hasCredentials = hasConnectorCredentials(c.id)
@@ -28,6 +35,7 @@ export async function GET(_req: Request) {
         ext.reconnectAttempts = rState.attempts
         ext.nextRetryAt = rState.nextRetryAt
         ext.reconnectError = rState.error
+        ext.reconnectExhausted = rState.exhausted
       }
     }
   } catch { /* manager not loaded yet */ }
@@ -35,6 +43,7 @@ export async function GET(_req: Request) {
 }
 
 export async function POST(req: Request) {
+  ensureDaemonStarted('api/connectors:post')
   const raw = await req.json()
   const parsed = ConnectorCreateSchema.safeParse(raw)
   if (!parsed.success) {
@@ -72,13 +81,8 @@ export async function POST(req: Request) {
     try {
       const { startConnector } = await import('@/lib/server/connectors/manager')
       await startConnector(id)
-      connector.isEnabled = true
-      connector.status = 'running'
-      connectors[id] = connector
-      saveConnectors(connectors)
-      notify('connectors')
     } catch { /* auto-start is best-effort */ }
   }
 
-  return NextResponse.json(connector)
+  return NextResponse.json(loadConnectors()[id] || connector)
 }

package/src/app/api/external-agents/[id]/heartbeat/route.ts

@@ -15,6 +15,9 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   runtime.lastSeenAt = now
   runtime.updatedAt = now
   runtime.status = body.status || 'online'
+  if (typeof body.lifecycleState === 'string' && body.lifecycleState) runtime.lifecycleState = body.lifecycleState
+  if (typeof body.version === 'string') runtime.version = body.version || null
+  if (typeof body.lastHealthNote === 'string') runtime.lastHealthNote = body.lastHealthNote || null
   if (body.tokenStats && typeof body.tokenStats === 'object') {
     runtime.tokenStats = {
       ...(runtime.tokenStats || {}),

package/src/app/api/external-agents/[id]/route.ts

@@ -10,12 +10,44 @@ const ops: CollectionOps<any> = { load: loadExternalAgents, save: saveExternalAg
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const body = await req.json().catch(() => ({}))
-  const result = mutateItem(ops, id, (runtime) => ({
-    ...runtime,
-    ...body,
-    id,
-    updatedAt: Date.now(),
-  }))
+  const now = Date.now()
+  const result = mutateItem(ops, id, (runtime) => {
+    const action = typeof body.action === 'string' ? body.action : ''
+    const nextMetadata = body.metadata && typeof body.metadata === 'object'
+      ? { ...(runtime.metadata || {}), ...body.metadata }
+      : runtime.metadata
+
+    const next = {
+      ...runtime,
+      ...body,
+      id,
+      metadata: nextMetadata,
+      updatedAt: now,
+    }
+
+    if (action === 'activate') {
+      next.lifecycleState = 'active'
+      next.lastHealthNote = body.lastHealthNote || 'Runtime returned to active service.'
+    } else if (action === 'drain') {
+      next.lifecycleState = 'draining'
+      next.lastHealthNote = body.lastHealthNote || 'Runtime draining after current work.'
+    } else if (action === 'cordon') {
+      next.lifecycleState = 'cordoned'
+      next.lastHealthNote = body.lastHealthNote || 'Runtime cordoned from new work.'
+    } else if (action === 'restart') {
+      next.metadata = {
+        ...(next.metadata || {}),
+        controlRequest: {
+          action: 'restart',
+          requestedAt: now,
+          source: 'swarmclaw',
+        },
+      }
+      next.lastHealthNote = body.lastHealthNote || 'Restart requested from SwarmClaw.'
+    }
+
+    return next
+  })
   if (!result) return notFound()
   return NextResponse.json(result)
 }

package/src/app/api/external-agents/route.ts

@@ -1,7 +1,7 @@
 import { NextResponse } from 'next/server'
 import { genId } from '@/lib/id'
 import { formatZodError, ExternalAgentRegisterSchema } from '@/lib/validation/schemas'
-import { loadExternalAgents, saveExternalAgents } from '@/lib/server/storage'
+import { loadExternalAgents, loadGatewayProfiles, saveExternalAgents } from '@/lib/server/storage'
 import { notify } from '@/lib/server/ws-hub'
 import type { ExternalAgentRuntime } from '@/types'
 import { z } from 'zod'
@@ -13,9 +13,20 @@ function withDerivedStatus(record: ExternalAgentRuntime): ExternalAgentRuntime {
   const staleMs = 3 * 60_000
   if (!lastSeenAt) return { ...record, status: record.status || 'offline' }
   if (record.status === 'offline') return record
+  const gateways = loadGatewayProfiles()
+  const gateway = record.gatewayProfileId ? gateways[record.gatewayProfileId] as Record<string, unknown> | undefined : undefined
+  const gatewayTags = Array.isArray(gateway?.tags)
+    ? gateway?.tags.filter((tag): tag is string => typeof tag === 'string' && tag.trim().length > 0)
+    : []
+  const gatewayUseCase = gateway?.deployment && typeof gateway.deployment === 'object' && typeof (gateway.deployment as Record<string, unknown>).useCase === 'string'
+    ? (gateway.deployment as Record<string, unknown>).useCase as string
+    : null
   return {
     ...record,
     status: now - lastSeenAt > staleMs ? 'stale' : (record.status || 'online'),
+    lifecycleState: record.lifecycleState || 'active',
+    gatewayTags: record.gatewayTags?.length ? record.gatewayTags : gatewayTags,
+    gatewayUseCase: record.gatewayUseCase || gatewayUseCase,
   }
 }
 
@@ -53,6 +64,11 @@ export async function POST(req: Request) {
     gatewayProfileId: body.gatewayProfileId || null,
     capabilities: body.capabilities,
     labels: body.labels,
+    lifecycleState: body.lifecycleState || existing?.lifecycleState || 'active',
+    gatewayTags: body.gatewayTags,
+    gatewayUseCase: body.gatewayUseCase || null,
+    version: body.version || null,
+    lastHealthNote: body.lastHealthNote || null,
     metadata: body.metadata,
     tokenStats: body.tokenStats,
     lastHeartbeatAt: existing?.lastHeartbeatAt || now,

package/src/app/api/gateways/[id]/health/route.ts

@@ -20,6 +20,14 @@ export async function GET(_req: Request, { params }: { params: Promise<{ id: str
   gateway.lastCheckedAt = Date.now()
   gateway.lastError = result.ok ? null : (result.error || result.hint || 'Gateway health check failed.')
   gateway.lastModelCount = Array.isArray(result.models) ? result.models.length : 0
+  gateway.deployment = {
+    ...(gateway.deployment || {}),
+    lastVerifiedAt: Date.now(),
+    lastVerifiedOk: result.ok,
+    lastVerifiedMessage: result.ok
+      ? `Verified ${Array.isArray(result.models) ? result.models.length : 0} model${result.models?.length === 1 ? '' : 's'}`
+      : (result.error || result.hint || 'Gateway health check failed.'),
+  }
   gateway.updatedAt = Date.now()
   saveGatewayProfiles(gateways)
   notify('gateways')

package/src/app/api/gateways/[id]/route.ts

@@ -2,7 +2,7 @@ import { NextResponse } from 'next/server'
 import { normalizeOpenClawEndpoint } from '@/lib/openclaw-endpoint'
 import { loadAgents, loadGatewayProfiles, saveAgents, saveGatewayProfiles } from '@/lib/server/storage'
 import { mutateItem, notFound, type CollectionOps } from '@/lib/server/collection-helpers'
-import type { Agent, AgentRoutingTarget, GatewayProfile } from '@/types'
+import type { Agent, AgentRoutingTarget, GatewayProfile, OpenClawDeploymentConfig, OpenClawGatewayStats } from '@/types'
 
 const ops: CollectionOps<GatewayProfile> = {
   load: loadGatewayProfiles,
@@ -17,6 +17,56 @@ function normalizeTags(value: unknown): string[] {
     .filter(Boolean)
 }
 
+function normalizeText(value: unknown): string | null {
+  return typeof value === 'string' && value.trim() ? value.trim() : null
+}
+
+function normalizeNullableNumber(value: unknown): number | null {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null
+}
+
+function normalizeDeployment(value: unknown): OpenClawDeploymentConfig | null {
+  if (!value || typeof value !== 'object') return null
+  const deployment = value as Record<string, unknown>
+  return {
+    method: normalizeText(deployment.method) as OpenClawDeploymentConfig['method'],
+    provider: normalizeText(deployment.provider) as OpenClawDeploymentConfig['provider'],
+    remoteTarget: normalizeText(deployment.remoteTarget) as OpenClawDeploymentConfig['remoteTarget'],
+    useCase: normalizeText(deployment.useCase) as OpenClawDeploymentConfig['useCase'],
+    exposure: normalizeText(deployment.exposure) as OpenClawDeploymentConfig['exposure'],
+    managedBy: normalizeText(deployment.managedBy) as OpenClawDeploymentConfig['managedBy'],
+    targetHost: normalizeText(deployment.targetHost),
+    sshHost: normalizeText(deployment.sshHost),
+    sshUser: normalizeText(deployment.sshUser),
+    sshPort: normalizeNullableNumber(deployment.sshPort),
+    sshKeyPath: normalizeText(deployment.sshKeyPath),
+    sshTargetDir: normalizeText(deployment.sshTargetDir),
+    image: normalizeText(deployment.image),
+    version: normalizeText(deployment.version),
+    lastDeployAt: normalizeNullableNumber(deployment.lastDeployAt),
+    lastDeployAction: normalizeText(deployment.lastDeployAction),
+    lastDeployProcessId: normalizeText(deployment.lastDeployProcessId),
+    lastDeploySummary: normalizeText(deployment.lastDeploySummary),
+    lastVerifiedAt: normalizeNullableNumber(deployment.lastVerifiedAt),
+    lastVerifiedOk: typeof deployment.lastVerifiedOk === 'boolean' ? deployment.lastVerifiedOk : null,
+    lastVerifiedMessage: normalizeText(deployment.lastVerifiedMessage),
+    lastBackupPath: normalizeText(deployment.lastBackupPath),
+  }
+}
+
+function normalizeStats(value: unknown): OpenClawGatewayStats | null {
+  if (!value || typeof value !== 'object') return null
+  const stats = value as Record<string, unknown>
+  return {
+    nodeCount: normalizeNullableNumber(stats.nodeCount) ?? undefined,
+    connectedNodeCount: normalizeNullableNumber(stats.connectedNodeCount) ?? undefined,
+    pendingNodePairings: normalizeNullableNumber(stats.pendingNodePairings) ?? undefined,
+    pairedDeviceCount: normalizeNullableNumber(stats.pairedDeviceCount) ?? undefined,
+    pendingDevicePairings: normalizeNullableNumber(stats.pendingDevicePairings) ?? undefined,
+    externalRuntimeCount: normalizeNullableNumber(stats.externalRuntimeCount) ?? undefined,
+  }
+}
+
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const body = await req.json().catch(() => ({}))
@@ -39,6 +89,8 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
     if (body.lastModelCount !== undefined) gateway.lastModelCount = body.lastModelCount || null
     if (body.discoveredHost !== undefined) gateway.discoveredHost = body.discoveredHost || null
     if (body.discoveredPort !== undefined) gateway.discoveredPort = body.discoveredPort || null
+    if (body.deployment !== undefined) gateway.deployment = { ...(gateway.deployment || {}), ...(normalizeDeployment(body.deployment) || {}) }
+    if (body.stats !== undefined) gateway.stats = { ...(gateway.stats || {}), ...(normalizeStats(body.stats) || {}) }
     if (body.isDefault !== undefined) gateway.isDefault = body.isDefault === true
     gateway.updatedAt = Date.now()
     return gateway

package/src/app/api/gateways/route.ts

@@ -4,6 +4,7 @@ import { normalizeOpenClawEndpoint } from '@/lib/openclaw-endpoint'
 import { getGatewayProfiles } from '@/lib/server/agent-runtime-config'
 import { loadGatewayProfiles, saveGatewayProfiles } from '@/lib/server/storage'
 import { notify } from '@/lib/server/ws-hub'
+import type { OpenClawDeploymentConfig, OpenClawGatewayStats } from '@/types'
 export const dynamic = 'force-dynamic'
 
 function normalizeTags(value: unknown): string[] {
@@ -13,6 +14,56 @@ function normalizeTags(value: unknown): string[] {
     .filter(Boolean)
 }
 
+function normalizeText(value: unknown): string | null {
+  return typeof value === 'string' && value.trim() ? value.trim() : null
+}
+
+function normalizeNullableNumber(value: unknown): number | null {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null
+}
+
+function normalizeDeployment(value: unknown): OpenClawDeploymentConfig | null {
+  if (!value || typeof value !== 'object') return null
+  const deployment = value as Record<string, unknown>
+  return {
+    method: normalizeText(deployment.method) as OpenClawDeploymentConfig['method'],
+    provider: normalizeText(deployment.provider) as OpenClawDeploymentConfig['provider'],
+    remoteTarget: normalizeText(deployment.remoteTarget) as OpenClawDeploymentConfig['remoteTarget'],
+    useCase: normalizeText(deployment.useCase) as OpenClawDeploymentConfig['useCase'],
+    exposure: normalizeText(deployment.exposure) as OpenClawDeploymentConfig['exposure'],
+    managedBy: normalizeText(deployment.managedBy) as OpenClawDeploymentConfig['managedBy'],
+    targetHost: normalizeText(deployment.targetHost),
+    sshHost: normalizeText(deployment.sshHost),
+    sshUser: normalizeText(deployment.sshUser),
+    sshPort: normalizeNullableNumber(deployment.sshPort),
+    sshKeyPath: normalizeText(deployment.sshKeyPath),
+    sshTargetDir: normalizeText(deployment.sshTargetDir),
+    image: normalizeText(deployment.image),
+    version: normalizeText(deployment.version),
+    lastDeployAt: normalizeNullableNumber(deployment.lastDeployAt),
+    lastDeployAction: normalizeText(deployment.lastDeployAction),
+    lastDeployProcessId: normalizeText(deployment.lastDeployProcessId),
+    lastDeploySummary: normalizeText(deployment.lastDeploySummary),
+    lastVerifiedAt: normalizeNullableNumber(deployment.lastVerifiedAt),
+    lastVerifiedOk: typeof deployment.lastVerifiedOk === 'boolean' ? deployment.lastVerifiedOk : null,
+    lastVerifiedMessage: normalizeText(deployment.lastVerifiedMessage),
+    lastBackupPath: normalizeText(deployment.lastBackupPath),
+  }
+}
+
+function normalizeStats(value: unknown): OpenClawGatewayStats | null {
+  if (!value || typeof value !== 'object') return null
+  const stats = value as Record<string, unknown>
+  return {
+    nodeCount: normalizeNullableNumber(stats.nodeCount) ?? undefined,
+    connectedNodeCount: normalizeNullableNumber(stats.connectedNodeCount) ?? undefined,
+    pendingNodePairings: normalizeNullableNumber(stats.pendingNodePairings) ?? undefined,
+    pairedDeviceCount: normalizeNullableNumber(stats.pairedDeviceCount) ?? undefined,
+    pendingDevicePairings: normalizeNullableNumber(stats.pendingDevicePairings) ?? undefined,
+    externalRuntimeCount: normalizeNullableNumber(stats.externalRuntimeCount) ?? undefined,
+  }
+}
+
 export async function GET() {
   return NextResponse.json(getGatewayProfiles('openclaw'))
 }
@@ -46,6 +97,8 @@ export async function POST(req: Request) {
     lastModelCount: null,
     discoveredHost: typeof body.discoveredHost === 'string' ? body.discoveredHost : null,
     discoveredPort: typeof body.discoveredPort === 'number' ? body.discoveredPort : null,
+    deployment: normalizeDeployment(body.deployment),
+    stats: normalizeStats(body.stats),
     isDefault,
     createdAt: now,
     updatedAt: now,