@swarmclawai/swarmclaw 0.7.7 → 0.8.0

package/src/app/api/gateways/health-route.test.ts

@@ -0,0 +1,135 @@
+import assert from 'node:assert/strict'
+import { afterEach, test } from 'node:test'
+
+import { persistGatewayHealthResult } from './[id]/health/route'
+import { loadGatewayProfiles, saveGatewayProfiles } from '@/lib/server/storage'
+
+const originalGateways = loadGatewayProfiles()
+
+afterEach(() => {
+  saveGatewayProfiles(originalGateways)
+})
+
+test('persistGatewayHealthResult stores healthy verification details', () => {
+  const gateways = loadGatewayProfiles()
+  gateways['gateway-health-test'] = {
+    id: 'gateway-health-test',
+    name: 'Gateway Health Test',
+    provider: 'openclaw',
+    endpoint: 'http://127.0.0.1:18789/v1',
+    wsUrl: 'ws://127.0.0.1:18789',
+    credentialId: 'credential-1',
+    status: 'unknown',
+    notes: null,
+    tags: ['smoke'],
+    lastError: 'previous error',
+    lastCheckedAt: null,
+    lastModelCount: null,
+    discoveredHost: '127.0.0.1',
+    discoveredPort: 18789,
+    deployment: {
+      method: 'imported',
+      useCase: 'single-vps',
+    },
+    stats: null,
+    isDefault: false,
+    createdAt: 1,
+    updatedAt: 1,
+  }
+  saveGatewayProfiles(gateways)
+
+  const now = 1_777_777_777_000
+  const updated = persistGatewayHealthResult('gateway-health-test', {
+    ok: true,
+    endpoint: 'http://127.0.0.1:18789/v1',
+    wsUrl: 'ws://127.0.0.1:18789',
+    wsConnected: true,
+    httpCompatible: true,
+    authProvided: true,
+    model: 'default',
+    models: ['default', 'glm-5:cloud'],
+    modelsStatus: 200,
+    chatStatus: 200,
+    message: 'Gateway verified successfully.',
+  }, now)
+
+  const saved = loadGatewayProfiles()['gateway-health-test']
+  assert.ok(updated)
+  assert.equal(saved.status, 'healthy')
+  assert.equal(saved.lastCheckedAt, now)
+  assert.equal(saved.lastError, null)
+  assert.equal(saved.lastModelCount, 2)
+  assert.equal(saved.updatedAt, now)
+  assert.equal(saved.deployment?.method, 'imported')
+  assert.equal(saved.deployment?.lastVerifiedAt, now)
+  assert.equal(saved.deployment?.lastVerifiedOk, true)
+  assert.equal(saved.deployment?.lastVerifiedMessage, 'Gateway verified successfully.')
+})
+
+test('persistGatewayHealthResult stores degraded/offline failures with the right message', () => {
+  const gateways = loadGatewayProfiles()
+  gateways['gateway-health-failure-test'] = {
+    id: 'gateway-health-failure-test',
+    name: 'Gateway Health Failure Test',
+    provider: 'openclaw',
+    endpoint: 'http://127.0.0.1:18888/v1',
+    wsUrl: 'ws://127.0.0.1:18888',
+    credentialId: null,
+    status: 'unknown',
+    notes: null,
+    tags: [],
+    lastError: null,
+    lastCheckedAt: null,
+    lastModelCount: null,
+    discoveredHost: '127.0.0.1',
+    discoveredPort: 18888,
+    deployment: null,
+    stats: null,
+    isDefault: false,
+    createdAt: 1,
+    updatedAt: 1,
+  }
+  saveGatewayProfiles(gateways)
+
+  const degraded = persistGatewayHealthResult('gateway-health-failure-test', {
+    ok: false,
+    endpoint: 'http://127.0.0.1:18888/v1',
+    wsUrl: 'ws://127.0.0.1:18888',
+    wsConnected: false,
+    httpCompatible: null,
+    authProvided: true,
+    model: null,
+    models: [],
+    modelsStatus: null,
+    chatStatus: null,
+    message: 'ignored',
+    error: 'Token rejected.',
+  }, 2_000)
+  assert.ok(degraded)
+  let saved = loadGatewayProfiles()['gateway-health-failure-test']
+  assert.equal(saved.status, 'degraded')
+  assert.equal(saved.lastError, 'Token rejected.')
+  assert.equal(saved.deployment?.lastVerifiedOk, false)
+  assert.equal(saved.deployment?.lastVerifiedMessage, 'Token rejected.')
+
+  const offline = persistGatewayHealthResult('gateway-health-failure-test', {
+    ok: false,
+    endpoint: 'http://127.0.0.1:18888/v1',
+    wsUrl: 'ws://127.0.0.1:18888',
+    wsConnected: false,
+    httpCompatible: null,
+    authProvided: false,
+    model: null,
+    models: [],
+    modelsStatus: null,
+    chatStatus: null,
+    message: 'ignored',
+    hint: 'Gateway unreachable.',
+  }, 3_000)
+  assert.ok(offline)
+  saved = loadGatewayProfiles()['gateway-health-failure-test']
+  assert.equal(saved.status, 'offline')
+  assert.equal(saved.lastError, 'Gateway unreachable.')
+  assert.equal(saved.deployment?.lastVerifiedOk, false)
+  assert.equal(saved.deployment?.lastVerifiedMessage, 'Gateway unreachable.')
+})

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

@@ -32,6 +32,8 @@ function normalizeDeployment(value: unknown): OpenClawDeploymentConfig | null {
     useCase: normalizeText(deployment.useCase) as OpenClawDeploymentConfig['useCase'],
     exposure: normalizeText(deployment.exposure) as OpenClawDeploymentConfig['exposure'],
     managedBy: normalizeText(deployment.managedBy) as OpenClawDeploymentConfig['managedBy'],
+    localInstanceId: normalizeText(deployment.localInstanceId),
+    localPort: normalizeNullableNumber(deployment.localPort),
     targetHost: normalizeText(deployment.targetHost),
     sshHost: normalizeText(deployment.sshHost),
     sshUser: normalizeText(deployment.sshUser),

package/src/app/api/mcp-servers/route.test.ts

@@ -0,0 +1,130 @@
+import assert from 'node:assert/strict'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import test, { afterEach } from 'node:test'
+
+import { GET as getMcpServer, PUT as updateMcpServer, DELETE as deleteMcpServer } from './[id]/route'
+import { POST as runMcpConformance } from './[id]/conformance/route'
+import { POST as invokeMcpTool } from './[id]/invoke/route'
+import { POST as testMcpServer } from './[id]/test/route'
+import { GET as listMcpTools } from './[id]/tools/route'
+import { GET as listMcpServers, POST as createMcpServer } from './route'
+import { loadMcpServers, saveMcpServers } from '@/lib/server/storage'
+
+const originalMcpServers = loadMcpServers()
+const fixturePath = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '../../../lib/server/__fixtures__/fake-mcp-stdio-server.mjs',
+)
+
+function routeParams(id: string) {
+  return { params: Promise.resolve({ id }) }
+}
+
+afterEach(() => {
+  saveMcpServers(originalMcpServers)
+})
+
+test('MCP server routes exercise a live stdio server end to end', async () => {
+  const createResponse = await createMcpServer(new Request('http://local/api/mcp-servers', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      name: 'smoke',
+      transport: 'stdio',
+      command: process.execPath,
+      args: [fixturePath],
+    }),
+  }))
+  assert.equal(createResponse.status, 200)
+  const created = await createResponse.json() as Record<string, unknown>
+  const serverId = String(created.id)
+  assert.equal(created.name, 'smoke')
+
+  const listResponse = await listMcpServers(new Request('http://local/api/mcp-servers'))
+  assert.equal(listResponse.status, 200)
+  const listed = await listResponse.json() as Record<string, Record<string, unknown>>
+  assert.equal(listed[serverId]?.name, 'smoke')
+
+  const detailResponse = await getMcpServer(new Request(`http://local/api/mcp-servers/${serverId}`), routeParams(serverId))
+  assert.equal(detailResponse.status, 200)
+  const detail = await detailResponse.json() as Record<string, unknown>
+  assert.equal(detail.command, process.execPath)
+
+  const healthResponse = await testMcpServer(new Request(`http://local/api/mcp-servers/${serverId}/test`, {
+    method: 'POST',
+  }), routeParams(serverId))
+  assert.equal(healthResponse.status, 200)
+  const health = await healthResponse.json() as Record<string, unknown>
+  assert.equal(health.ok, true)
+  assert.deepEqual(health.tools, ['mcp_smoke_ping', 'mcp_smoke_echo'])
+
+  const toolsResponse = await listMcpTools(new Request(`http://local/api/mcp-servers/${serverId}/tools`), routeParams(serverId))
+  assert.equal(toolsResponse.status, 200)
+  const tools = await toolsResponse.json() as Array<Record<string, unknown>>
+  assert.deepEqual(tools.map((tool) => tool.name), ['ping', 'echo'])
+
+  const invokeResponse = await invokeMcpTool(new Request(`http://local/api/mcp-servers/${serverId}/invoke`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      toolName: 'echo',
+      args: JSON.stringify({ message: 'hello from route test' }),
+    }),
+  }), routeParams(serverId))
+  assert.equal(invokeResponse.status, 200)
+  const invokePayload = await invokeResponse.json() as Record<string, unknown>
+  assert.equal(invokePayload.ok, true)
+  assert.equal(invokePayload.text, 'echo: hello from route test')
+
+  const conformanceResponse = await runMcpConformance(new Request(`http://local/api/mcp-servers/${serverId}/conformance`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ smokeToolName: 'ping' }),
+  }), routeParams(serverId))
+  assert.equal(conformanceResponse.status, 200)
+  const conformance = await conformanceResponse.json() as Record<string, unknown>
+  assert.equal(conformance.ok, true)
+  assert.equal(conformance.toolsCount, 2)
+  assert.equal(conformance.smokeToolName, 'ping')
+
+  const updateResponse = await updateMcpServer(new Request(`http://local/api/mcp-servers/${serverId}`, {
+    method: 'PUT',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ name: 'smoke-renamed' }),
+  }), routeParams(serverId))
+  assert.equal(updateResponse.status, 200)
+  const updated = await updateResponse.json() as Record<string, unknown>
+  assert.equal(updated.name, 'smoke-renamed')
+
+  const deleteResponse = await deleteMcpServer(new Request(`http://local/api/mcp-servers/${serverId}`, {
+    method: 'DELETE',
+  }), routeParams(serverId))
+  assert.equal(deleteResponse.status, 200)
+  assert.equal(loadMcpServers()[serverId], undefined)
+})
+
+test('MCP invoke route validates required fields before connecting', async () => {
+  const serverId = 'mcp-validate-smoke'
+  const servers = loadMcpServers()
+  servers[serverId] = {
+    id: serverId,
+    name: 'smoke',
+    transport: 'stdio',
+    command: process.execPath,
+    args: [fixturePath],
+    createdAt: 1,
+    updatedAt: 1,
+  }
+  saveMcpServers(servers)
+
+  const response = await invokeMcpTool(new Request(`http://local/api/mcp-servers/${serverId}/invoke`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ args: {} }),
+  }), routeParams(serverId))
+
+  assert.equal(response.status, 400)
+  const payload = await response.json() as Record<string, unknown>
+  assert.equal(payload.error, 'toolName is required')
+})

package/src/app/api/openclaw/deploy/route.ts

@@ -1,6 +1,8 @@
 import { NextResponse } from 'next/server'
 import {
   buildOpenClawDeployBundle,
+  getOpenClawLocalDeployCollectionStatus,
+  getOpenClawRemoteDeployCollectionStatus,
   deployOpenClawOverSsh,
   getOpenClawLocalDeployStatus,
   getOpenClawRemoteDeployStatus,
@@ -96,9 +98,15 @@ function parseSsh(value: unknown): Partial<OpenClawSshConfig> | null {
 }
 
 export async function GET() {
+  const locals = getOpenClawLocalDeployCollectionStatus()
+  const remotes = getOpenClawRemoteDeployCollectionStatus()
   return NextResponse.json({
-    local: getOpenClawLocalDeployStatus(),
-    remote: getOpenClawRemoteDeployStatus(),
+    local: getOpenClawLocalDeployStatus(locals.primaryId),
+    locals: locals.items,
+    localPrimaryId: locals.primaryId,
+    remote: remotes.primaryId ? getOpenClawRemoteDeployStatus(remotes.primaryId) : null,
+    remotes: remotes.items,
+    remotePrimaryId: remotes.primaryId,
   })
 }
 
@@ -109,31 +117,44 @@ export async function POST(req: Request) {
   try {
     if (action === 'start-local') {
       const result = await startOpenClawLocalDeploy({
+        localId: typeof body.localId === 'string' ? body.localId : null,
+        name: typeof body.name === 'string' ? body.name : null,
         port: parsePort(body.port),
         token: typeof body.token === 'string' ? body.token : null,
+        makePrimary: body.makePrimary !== false,
       })
       return NextResponse.json({
         ok: true,
         local: result.local,
+        locals: result.locals,
+        localPrimaryId: result.locals.find((item) => item.isPrimary)?.id || result.local.id,
         token: result.token,
       })
     }
 
     if (action === 'stop-local') {
+      const result = stopOpenClawLocalDeploy(typeof body.localId === 'string' ? body.localId : null)
       return NextResponse.json({
         ok: true,
-        local: stopOpenClawLocalDeploy(),
+        local: result.local,
+        locals: result.locals,
+        localPrimaryId: result.locals.find((item) => item.isPrimary)?.id || result.local.id,
       })
     }
 
     if (action === 'restart-local') {
       const result = await restartOpenClawLocalDeploy({
+        localId: typeof body.localId === 'string' ? body.localId : null,
+        name: typeof body.name === 'string' ? body.name : null,
         port: parsePort(body.port),
         token: typeof body.token === 'string' ? body.token : null,
+        makePrimary: body.makePrimary !== false,
       })
       return NextResponse.json({
         ok: true,
         local: result.local,
+        locals: result.locals,
+        localPrimaryId: result.locals.find((item) => item.isPrimary)?.id || result.local.id,
         token: result.token,
       })
     }
@@ -157,6 +178,8 @@ export async function POST(req: Request) {
 
     if (action === 'ssh-deploy') {
       const result = await deployOpenClawOverSsh({
+        remoteId: typeof body.remoteId === 'string' ? body.remoteId : null,
+        name: typeof body.name === 'string' ? body.name : null,
         template: parseTemplate(body.template),
         target: typeof body.target === 'string' ? body.target : null,
         token: typeof body.token === 'string' ? body.token : null,
@@ -166,10 +189,14 @@ export async function POST(req: Request) {
         useCase: parseUseCase(body.useCase),
         exposure: parseExposure(body.exposure),
         ssh: parseSsh(body.ssh),
+        makePrimary: body.makePrimary !== false,
       })
+      const remotes = getOpenClawRemoteDeployCollectionStatus()
       return NextResponse.json({
         ok: result.ok,
-        remote: getOpenClawRemoteDeployStatus(),
+        remote: getOpenClawRemoteDeployStatus(result.remoteId || remotes.primaryId),
+        remotes: remotes.items,
+        remotePrimaryId: remotes.primaryId,
         processId: result.processId || null,
         token: result.token,
         bundle: result.bundle,
@@ -198,14 +225,20 @@ export async function POST(req: Request) {
       } as const
       const lifecycleAction = action as keyof typeof actionMap
       const result = await runOpenClawRemoteLifecycle({
+        remoteId: typeof body.remoteId === 'string' ? body.remoteId : null,
+        name: typeof body.name === 'string' ? body.name : null,
         action: actionMap[lifecycleAction],
         ssh: parseSsh(body.ssh),
         token: typeof body.token === 'string' ? body.token : null,
         backupPath: typeof body.backupPath === 'string' ? body.backupPath : null,
+        makePrimary: body.makePrimary !== false,
       })
+      const remotes = getOpenClawRemoteDeployCollectionStatus()
       return NextResponse.json({
         ok: result.ok,
-        remote: getOpenClawRemoteDeployStatus(),
+        remote: getOpenClawRemoteDeployStatus(result.remoteId || remotes.primaryId),
+        remotes: remotes.items,
+        remotePrimaryId: remotes.primaryId,
         processId: result.processId || null,
         token: result.token,
         summary: result.summary,

package/src/app/api/plugins/install/route.ts

@@ -1,22 +1,61 @@
 import { NextResponse } from 'next/server'
 import { getPluginManager, sanitizePluginFilename } from '@/lib/server/plugins'
+import {
+  inferPluginInstallSourceFromUrl,
+  inferPluginPublisherSourceFromUrl,
+  normalizePluginInstallSource,
+  normalizePluginPublisherSource,
+} from '@/lib/plugin-sources'
+import {
+  buildPluginInstallCorsHeaders,
+  resolvePluginInstallCorsOrigin,
+} from '@/lib/plugin-install-cors'
+
+function json(body: Record<string, unknown>, status: number, origin: string | null) {
+  return NextResponse.json(body, {
+    status,
+    headers: buildPluginInstallCorsHeaders(origin),
+  })
+}
+
+export async function OPTIONS(req: Request) {
+  const origin = resolvePluginInstallCorsOrigin(req.headers.get('origin'))
+  if (!origin) return NextResponse.json({ error: 'Origin not allowed' }, { status: 403 })
+  return new NextResponse(null, {
+    status: 204,
+    headers: buildPluginInstallCorsHeaders(origin),
+  })
+}
 
 export async function POST(req: Request) {
+  const origin = resolvePluginInstallCorsOrigin(req.headers.get('origin'))
   const body = await req.json()
   const url = typeof body?.url === 'string' ? body.url : ''
   const filename = typeof body?.filename === 'string' ? body.filename : ''
+  const installMethod = body?.installMethod === 'marketplace' ? 'marketplace' : 'manual'
+  const sourceLabel = normalizePluginPublisherSource(body?.sourceLabel)
+    || inferPluginPublisherSourceFromUrl(url)
+    || 'manual'
+  const installSource = normalizePluginInstallSource(body?.installSource)
+    || inferPluginInstallSourceFromUrl(url)
+    || 'manual'
 
   if (!url || !url.startsWith('https://')) {
-    return NextResponse.json(
+    return json(
       { error: 'URL must be a valid HTTPS URL' },
-      { status: 400 },
+      400,
+      origin,
     )
   }
 
   try {
     const sanitizedFilename = sanitizePluginFilename(filename)
-    const installed = await getPluginManager().installPluginFromUrl(url, sanitizedFilename)
-    return NextResponse.json({ ok: true, filename: installed.filename, hash: installed.sourceHash })
+    const installed = await getPluginManager().installPluginFromUrl(url, sanitizedFilename, {
+      source: installMethod,
+      sourceLabel,
+      installSource,
+    })
+    return json({ ok: true, filename: installed.filename, hash: installed.sourceHash }, 200, origin)
   } catch (err: unknown) {
     const msg = err instanceof Error ? err.message : String(err)
     const isTimeout = /abort|timeout/i.test(msg)
@@ -25,9 +64,10 @@ export async function POST(req: Request) {
       : isTimeout
         ? 504
         : 500
-    return NextResponse.json(
+    return json(
       { error: isTimeout ? 'Download timed out — the plugin URL may be unreachable' : msg },
-      { status },
+      status,
+      origin,
     )
   }
 }

package/src/app/api/plugins/marketplace/route.ts

@@ -1,11 +1,25 @@
 import { NextResponse } from 'next/server'
+import { inferPluginPublisherSourceFromUrl } from '@/lib/plugin-sources'
 import { searchClawHub } from '@/lib/server/clawhub-client'
+import type { PluginCatalogSource } from '@/types'
 
 export const dynamic = 'force-dynamic'
 
-const REGISTRY_URLS = [
-  'https://raw.githubusercontent.com/swarmclawai/swarmforge/main/registry.json',
-  'https://swarmclaw.ai/registry/plugins.json',
+interface RegistryPluginEntry {
+  id?: string
+  name?: string
+  description?: string
+  url?: string
+  author?: string
+  version?: string
+  tags?: string[]
+  openclaw?: boolean
+  downloads?: number
+}
+
+const REGISTRY_URLS: Array<{ url: string; catalogSource: PluginCatalogSource }> = [
+  { url: 'https://swarmclaw.ai/registry/plugins.json', catalogSource: 'swarmclaw-site' },
+  { url: 'https://raw.githubusercontent.com/swarmclawai/swarmforge/main/registry.json', catalogSource: 'swarmforge' },
 ]
 const CACHE_TTL = 5 * 60 * 1000 // 5 minutes
 
@@ -33,34 +47,43 @@ export async function GET(req: Request) {
   }
 
   const allPlugins: Record<string, unknown>[] = []
+  const registryPlugins = new Map<string, Record<string, unknown>>()
 
   // 1. Fetch SwarmClaw Registry
-  for (const registryUrl of REGISTRY_URLS) {
+  for (const registry of REGISTRY_URLS) {
     try {
-      const res = await fetch(registryUrl, { cache: 'no-store' })
+      const res = await fetch(registry.url, { cache: 'no-store' })
       if (!res.ok) continue
 
       const data = await res.json()
-      const filtered = (data as Array<{ name: string; description: string; url?: string }>).filter((p) => {
+      const entries = Array.isArray(data) ? data as RegistryPluginEntry[] : []
+      const filtered = entries.filter((p) => {
         if (!p || typeof p.name !== 'string' || typeof p.description !== 'string') return false
         return !query || p.name.toLowerCase().includes(query.toLowerCase()) || p.description.toLowerCase().includes(query.toLowerCase())
       })
 
-      allPlugins.push(...filtered.map((p: { id?: string; name?: string; url?: string }) => ({
-        ...p,
-        id: p.id || (p.name || '').toLowerCase().replace(/[^a-z0-9]/g, '_'),
-        url: normalizeRegistryPluginUrl(p.url) || p.url,
-        source: 'swarmclaw',
-      })))
-      break
+      for (const p of filtered) {
+        const normalizedUrl = normalizeRegistryPluginUrl(p.url) || p.url
+        const id = p.id || (p.name || '').toLowerCase().replace(/[^a-z0-9]/g, '_')
+        if (registryPlugins.has(id)) continue
+        registryPlugins.set(id, {
+          ...p,
+          id,
+          url: normalizedUrl,
+          source: inferPluginPublisherSourceFromUrl(normalizedUrl) || 'swarmforge',
+          catalogSource: registry.catalogSource,
+        })
+      }
     } catch (err: unknown) {
       console.warn('[marketplace] SC Registry failed:', {
-        registryUrl,
+        registryUrl: registry.url,
         error: err instanceof Error ? err.message : String(err),
       })
     }
   }
 
+  allPlugins.push(...registryPlugins.values())
+
   // 2. Fetch ClawHub Skills/Plugins
   try {
     const hubResults = await searchClawHub(query)
@@ -71,12 +94,22 @@ export async function GET(req: Request) {
       author: s.author,
       version: s.version || '1.0.0',
       url: s.url,
-      source: 'clawhub'
+      source: 'clawhub',
+      catalogSource: 'clawhub',
     })))
   } catch (err: unknown) {
     console.warn('[marketplace] ClawHub failed:', err instanceof Error ? err.message : String(err))
   }
 
+  allPlugins.sort((a, b) => {
+    const catalogA = typeof a.catalogSource === 'string' ? a.catalogSource : ''
+    const catalogB = typeof b.catalogSource === 'string' ? b.catalogSource : ''
+    if (catalogA !== catalogB) return catalogA.localeCompare(catalogB)
+    const nameA = typeof a.name === 'string' ? a.name : ''
+    const nameB = typeof b.name === 'string' ? b.name : ''
+    return nameA.localeCompare(nameB)
+  })
+
   // Update cache only for empty queries
   if (!query) {
     cache = { data: allPlugins, fetchedAt: now }