@swarmclawai/swarmclaw 0.2.0

package/src/app/api/orchestrator/run/route.ts

@@ -0,0 +1,43 @@
+import { NextResponse } from 'next/server'
+import crypto from 'crypto'
+import { loadAgents, loadTasks, saveTasks } from '@/lib/server/storage'
+import { enqueueTask } from '@/lib/server/queue'
+
+export async function POST(req: Request) {
+  const { agentId, task } = await req.json()
+  if (!agentId || !task) {
+    return NextResponse.json({ error: 'agentId and task are required' }, { status: 400 })
+  }
+
+  const agents = loadAgents()
+  const agent = agents[agentId]
+  if (!agent) {
+    return NextResponse.json({ error: 'Agent not found' }, { status: 404 })
+  }
+
+  // Create a board task and enqueue it
+  const taskId = crypto.randomBytes(4).toString('hex')
+  const now = Date.now()
+  const tasks = loadTasks()
+  tasks[taskId] = {
+    id: taskId,
+    title: task.slice(0, 80),
+    description: task,
+    status: 'backlog',
+    agentId,
+    sessionId: null,
+    result: null,
+    error: null,
+    createdAt: now,
+    updatedAt: now,
+    queuedAt: null,
+    startedAt: null,
+    completedAt: null,
+  }
+  saveTasks(tasks)
+
+  // Enqueue — this sets status to queued and kicks the worker
+  enqueueTask(taskId)
+
+  return NextResponse.json({ ok: true, taskId })
+}

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

@@ -0,0 +1,58 @@
+import { NextResponse } from 'next/server'
+import fs from 'fs'
+import path from 'path'
+
+const PLUGINS_DIR = path.join(process.cwd(), 'data', 'plugins')
+
+export async function POST(req: Request) {
+  const body = await req.json()
+  const { url, filename } = body
+
+  // Validate URL
+  if (!url || typeof url !== 'string' || !url.startsWith('https://')) {
+    return NextResponse.json(
+      { error: 'URL must be a valid HTTPS URL' },
+      { status: 400 },
+    )
+  }
+
+  // Validate filename
+  if (!filename || typeof filename !== 'string' || !filename.endsWith('.js')) {
+    return NextResponse.json(
+      { error: 'Filename must end in .js' },
+      { status: 400 },
+    )
+  }
+
+  // Path traversal protection
+  const sanitized = path.basename(filename)
+  if (sanitized !== filename || filename.includes('..')) {
+    return NextResponse.json(
+      { error: 'Invalid filename' },
+      { status: 400 },
+    )
+  }
+
+  try {
+    const res = await fetch(url)
+    if (!res.ok) {
+      throw new Error(`Download failed: ${res.status}`)
+    }
+    const code = await res.text()
+
+    // Ensure plugins directory exists
+    if (!fs.existsSync(PLUGINS_DIR)) {
+      fs.mkdirSync(PLUGINS_DIR, { recursive: true })
+    }
+
+    const dest = path.join(PLUGINS_DIR, sanitized)
+    fs.writeFileSync(dest, code, 'utf8')
+
+    return NextResponse.json({ ok: true, filename: sanitized })
+  } catch (err: any) {
+    return NextResponse.json(
+      { error: 'Failed to install plugin', message: err.message },
+      { status: 500 },
+    )
+  }
+}

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

@@ -0,0 +1,33 @@
+import { NextResponse } from 'next/server'
+
+const REGISTRY_URL = 'https://swarmclaw.ai/registry/plugins.json'
+const CACHE_TTL = 5 * 60 * 1000 // 5 minutes
+
+let cache: { data: any; fetchedAt: number } | null = null
+
+export async function GET() {
+  const now = Date.now()
+
+  if (cache && now - cache.fetchedAt < CACHE_TTL) {
+    return NextResponse.json(cache.data)
+  }
+
+  try {
+    const res = await fetch(REGISTRY_URL, { cache: 'no-store' })
+    if (!res.ok) {
+      throw new Error(`Registry returned ${res.status}`)
+    }
+    const data = await res.json()
+    cache = { data, fetchedAt: now }
+    return NextResponse.json(data)
+  } catch (err: any) {
+    // Return stale cache if available
+    if (cache) {
+      return NextResponse.json(cache.data)
+    }
+    return NextResponse.json(
+      { error: 'Failed to fetch plugin registry', message: err.message },
+      { status: 502 },
+    )
+  }
+}

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

@@ -0,0 +1,21 @@
+import { NextResponse } from 'next/server'
+import { getPluginManager } from '@/lib/server/plugins'
+
+export async function GET() {
+  const manager = getPluginManager()
+  return NextResponse.json(manager.listPlugins())
+}
+
+export async function POST(req: Request) {
+  const body = await req.json()
+  const { filename, enabled } = body
+
+  if (!filename || typeof enabled !== 'boolean') {
+    return NextResponse.json({ error: 'filename and enabled required' }, { status: 400 })
+  }
+
+  const manager = getPluginManager()
+  manager.setEnabled(filename, enabled)
+
+  return NextResponse.json({ ok: true })
+}

package/src/app/api/preview-server/route.ts

@@ -0,0 +1,339 @@
+import { NextResponse } from 'next/server'
+import { spawn, type ChildProcess } from 'child_process'
+import http from 'http'
+import fs from 'fs'
+import path from 'path'
+import { localIP } from '@/lib/server/storage'
+
+// ---------------------------------------------------------------------------
+// MIME types for static server
+// ---------------------------------------------------------------------------
+
+const MIME_MAP: Record<string, string> = {
+  '.html': 'text/html', '.htm': 'text/html', '.css': 'text/css',
+  '.js': 'application/javascript', '.mjs': 'application/javascript',
+  '.json': 'application/json', '.svg': 'image/svg+xml',
+  '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif', '.webp': 'image/webp', '.ico': 'image/x-icon',
+  '.woff': 'font/woff', '.woff2': 'font/woff2', '.ttf': 'font/ttf',
+  '.mp4': 'video/mp4', '.webm': 'video/webm',
+  '.txt': 'text/plain', '.md': 'text/plain',
+}
+
+// ---------------------------------------------------------------------------
+// Server tracking
+// ---------------------------------------------------------------------------
+
+interface PreviewServer {
+  type: 'static' | 'npm'
+  server?: http.Server   // static server
+  proc?: ChildProcess    // npm process
+  port: number
+  dir: string
+  startedAt: number
+  log: string
+}
+
+const globalKey = '__swarmclaw_preview_servers__' as const
+const servers: Map<string, PreviewServer> = (globalThis as unknown as Record<string, unknown>)[globalKey] as Map<string, PreviewServer>
+  ?? ((globalThis as unknown as Record<string, unknown>)[globalKey] = new Map<string, PreviewServer>())
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function resolveServeDir(filePath: string): string {
+  const resolved = path.resolve(filePath)
+  try {
+    return fs.statSync(resolved).isDirectory() ? resolved : path.dirname(resolved)
+  } catch {
+    return path.dirname(resolved)
+  }
+}
+
+function dirKey(dir: string): string {
+  return dir.replace(/\//g, '_')
+}
+
+function findFreePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const srv = http.createServer()
+    srv.listen(0, () => {
+      const addr = srv.address()
+      const port = typeof addr === 'object' && addr ? addr.port : 0
+      srv.close(() => resolve(port))
+    })
+    srv.on('error', reject)
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Project type detection
+// ---------------------------------------------------------------------------
+
+interface ProjectInfo {
+  type: 'npm' | 'static'
+  devCommand?: string[]   // e.g. ['npm', 'run', 'dev']
+  framework?: string      // e.g. 'vite', 'next', 'cra'
+}
+
+function detectProject(dir: string): ProjectInfo {
+  const pkgPath = path.join(dir, 'package.json')
+  if (!fs.existsSync(pkgPath)) {
+    return { type: 'static' }
+  }
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
+    const scripts = pkg.scripts || {}
+    const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) }
+
+    // Detect framework
+    let framework = 'node'
+    if (deps.next) framework = 'next'
+    else if (deps.vite || deps['@vitejs/plugin-react']) framework = 'vite'
+    else if (deps['react-scripts']) framework = 'cra'
+    else if (deps.astro) framework = 'astro'
+    else if (deps.nuxt) framework = 'nuxt'
+    else if (deps.svelte || deps['@sveltejs/kit']) framework = 'svelte'
+    else if (deps.vue) framework = 'vue'
+    else if (deps.angular || deps['@angular/core']) framework = 'angular'
+
+    // Pick the best dev command
+    if (scripts.dev) {
+      return { type: 'npm', devCommand: ['npm', 'run', 'dev'], framework }
+    }
+    if (scripts.start) {
+      return { type: 'npm', devCommand: ['npm', 'start'], framework }
+    }
+    if (scripts.serve) {
+      return { type: 'npm', devCommand: ['npm', 'run', 'serve'], framework }
+    }
+
+    return { type: 'static', framework }
+  } catch {
+    return { type: 'static' }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Static file server
+// ---------------------------------------------------------------------------
+
+function createStaticServer(dir: string): http.Server {
+  return http.createServer((req, res) => {
+    res.setHeader('Access-Control-Allow-Origin', '*')
+
+    let reqPath = decodeURIComponent((req.url || '/').split('?')[0])
+    if (reqPath === '/') reqPath = '/index.html'
+
+    const filePath = path.join(dir, reqPath)
+    const normalizedFile = path.resolve(filePath)
+
+    if (!normalizedFile.startsWith(dir)) {
+      res.writeHead(403)
+      res.end('Forbidden')
+      return
+    }
+
+    const candidates = [
+      normalizedFile,
+      normalizedFile + '.html',
+      path.join(normalizedFile, 'index.html'),
+    ]
+
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+        const ext = path.extname(candidate).toLowerCase()
+        res.writeHead(200, { 'Content-Type': MIME_MAP[ext] || 'application/octet-stream' })
+        fs.createReadStream(candidate).pipe(res)
+        return
+      }
+    }
+
+    if (fs.existsSync(normalizedFile) && fs.statSync(normalizedFile).isDirectory()) {
+      const files = fs.readdirSync(normalizedFile)
+      const links = files.map((f) => `<li><a href="${reqPath.replace(/\/$/, '')}/${f}">${f}</a></li>`).join('\n')
+      res.writeHead(200, { 'Content-Type': 'text/html' })
+      res.end(`<!DOCTYPE html><html><head><title>Index of ${reqPath}</title><style>body{font-family:monospace;padding:20px;background:#1a1a2e;color:#e0e0e0}a{color:#60a5fa}</style></head><body><h2>Index of ${reqPath}</h2><ul>${links}</ul></body></html>`)
+      return
+    }
+
+    res.writeHead(404)
+    res.end('Not found')
+  })
+}
+
+// ---------------------------------------------------------------------------
+// npm dev server
+// ---------------------------------------------------------------------------
+
+async function startNpmServer(dir: string, command: string[], port: number): Promise<PreviewServer> {
+  // Install deps if node_modules missing
+  if (!fs.existsSync(path.join(dir, 'node_modules'))) {
+    console.log(`[preview] Installing dependencies in ${dir}`)
+    await new Promise<void>((resolve, reject) => {
+      const install = spawn('npm', ['install'], { cwd: dir, stdio: 'pipe' })
+      install.on('close', (code) => code === 0 ? resolve() : reject(new Error(`npm install exited ${code}`)))
+      install.on('error', reject)
+    })
+  }
+
+  const env = {
+    ...process.env,
+    PORT: String(port),
+    FORCE_COLOR: '0',
+    BROWSER: 'none',  // CRA: don't open browser
+  }
+
+  // Add --port flag for common frameworks
+  const args = [...command.slice(1)]
+  const cmdName = command[0]
+
+  const proc = spawn(cmdName, [...args, '--', '--port', String(port), '--host', '0.0.0.0'], {
+    cwd: dir,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env,
+  })
+
+  let log = ''
+  let detectedPort = port
+  const urlRe = /https?:\/\/(?:localhost|0\.0\.0\.0|127\.0\.0\.1|[\d.]+):(\d+)/
+
+  const onData = (chunk: Buffer) => {
+    const text = chunk.toString()
+    log += text
+    if (log.length > 10000) log = log.slice(-5000)
+    const match = text.match(urlRe)
+    if (match) {
+      detectedPort = parseInt(match[1], 10)
+      const entry = servers.get(dirKey(dir))
+      if (entry) entry.port = detectedPort
+    }
+  }
+
+  proc.stdout?.on('data', onData)
+  proc.stderr?.on('data', onData)
+
+  const entry: PreviewServer = {
+    type: 'npm',
+    proc,
+    port,
+    dir,
+    startedAt: Date.now(),
+    log: '',
+  }
+
+  proc.on('close', () => {
+    servers.delete(dirKey(dir))
+    console.log(`[preview] npm server stopped for ${dir}`)
+  })
+  proc.on('error', () => servers.delete(dirKey(dir)))
+
+  servers.set(dirKey(dir), entry)
+
+  // Wait for the server to start and detect the actual port
+  await new Promise((resolve) => setTimeout(resolve, 5000))
+  entry.port = detectedPort
+  entry.log = log
+
+  return entry
+}
+
+// ---------------------------------------------------------------------------
+// API handler
+// ---------------------------------------------------------------------------
+
+function buildResponse(srv: PreviewServer) {
+  return {
+    running: true,
+    type: srv.type,
+    port: srv.port,
+    url: `http://localhost:${srv.port}`,
+    networkUrl: `http://${localIP()}:${srv.port}`,
+    dir: srv.dir,
+  }
+}
+
+export async function POST(req: Request) {
+  const { action, path: filePath } = await req.json()
+
+  if (!filePath || typeof filePath !== 'string') {
+    return NextResponse.json({ error: 'Missing path' }, { status: 400 })
+  }
+
+  const dir = resolveServeDir(filePath)
+  const key = dirKey(dir)
+
+  if (action === 'start') {
+    if (servers.has(key)) {
+      return NextResponse.json(buildResponse(servers.get(key)!))
+    }
+
+    if (!fs.existsSync(dir)) {
+      return NextResponse.json({ error: 'Directory not found' }, { status: 404 })
+    }
+
+    const project = detectProject(dir)
+    const port = await findFreePort()
+
+    if (project.type === 'npm' && project.devCommand) {
+      console.log(`[preview] Detected ${project.framework} project in ${dir}, running: ${project.devCommand.join(' ')}`)
+      try {
+        const entry = await startNpmServer(dir, project.devCommand, port)
+        return NextResponse.json({
+          ...buildResponse(entry),
+          framework: project.framework,
+        })
+      } catch (err: unknown) {
+        console.error(`[preview] npm server failed, falling back to static:`, err)
+        // Fall through to static server
+      }
+    }
+
+    // Static file server
+    const server = createStaticServer(dir)
+    await new Promise<void>((resolve, reject) => {
+      server.listen(port, '0.0.0.0', () => resolve())
+      server.on('error', reject)
+    })
+
+    const entry: PreviewServer = { type: 'static', server, port, dir, startedAt: Date.now(), log: '' }
+    servers.set(key, entry)
+    console.log(`[preview] Started static server for ${dir} on port ${port}`)
+
+    return NextResponse.json(buildResponse(entry))
+
+  } else if (action === 'stop') {
+    if (servers.has(key)) {
+      const srv = servers.get(key)!
+      if (srv.type === 'npm' && srv.proc) {
+        try { srv.proc.kill('SIGTERM') } catch {}
+        try { if (srv.proc.pid) process.kill(-srv.proc.pid, 'SIGTERM') } catch {}
+      }
+      if (srv.server) srv.server.close()
+      servers.delete(key)
+      console.log(`[preview] Stopped server for ${dir}`)
+    }
+    return NextResponse.json({ running: false, dir })
+
+  } else if (action === 'status') {
+    if (servers.has(key)) {
+      return NextResponse.json(buildResponse(servers.get(key)!))
+    }
+    return NextResponse.json({ running: false, dir })
+
+  } else if (action === 'list') {
+    const list = Array.from(servers.values()).map((s) => ({
+      ...buildResponse(s),
+      startedAt: s.startedAt,
+    }))
+    return NextResponse.json({ servers: list })
+
+  } else if (action === 'detect') {
+    const project = detectProject(dir)
+    return NextResponse.json({ dir, ...project })
+  }
+
+  return NextResponse.json({ error: 'Invalid action' }, { status: 400 })
+}

package/src/app/api/providers/[id]/models/route.ts

@@ -0,0 +1,29 @@
+import { NextResponse } from 'next/server'
+import { loadModelOverrides, saveModelOverrides } from '@/lib/server/storage'
+import { getProviderList } from '@/lib/providers'
+
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const overrides = loadModelOverrides()
+  const providers = getProviderList()
+  const provider = providers.find((p) => p.id === id)
+  if (!provider) return new NextResponse(null, { status: 404 })
+  return NextResponse.json({ models: provider.models, hasOverride: !!overrides[id] })
+}
+
+export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const body = await req.json()
+  const overrides = loadModelOverrides()
+  overrides[id] = body.models || []
+  saveModelOverrides(overrides)
+  return NextResponse.json({ models: overrides[id] })
+}
+
+export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const overrides = loadModelOverrides()
+  delete overrides[id]
+  saveModelOverrides(overrides)
+  return NextResponse.json({ ok: true })
+}

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

@@ -0,0 +1,34 @@
+import { NextResponse } from 'next/server'
+import { loadProviderConfigs, saveProviderConfigs } from '@/lib/server/storage'
+
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const configs = loadProviderConfigs()
+  const config = configs[id]
+  if (!config) return new NextResponse(null, { status: 404 })
+  return NextResponse.json(config)
+}
+
+export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const body = await req.json()
+  const configs = loadProviderConfigs()
+  const existing = configs[id]
+  if (!existing) return new NextResponse(null, { status: 404 })
+  configs[id] = { ...existing, ...body, id, updatedAt: Date.now() }
+  saveProviderConfigs(configs)
+  return NextResponse.json(configs[id])
+}
+
+export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const configs = loadProviderConfigs()
+  if (!configs[id]) return new NextResponse(null, { status: 404 })
+  // Only allow deleting custom providers
+  if (configs[id].type === 'builtin') {
+    return NextResponse.json({ error: 'Cannot delete built-in providers' }, { status: 400 })
+  }
+  delete configs[id]
+  saveProviderConfigs(configs)
+  return NextResponse.json({ ok: true })
+}

package/src/app/api/providers/configs/route.ts

@@ -0,0 +1,7 @@
+import { NextResponse } from 'next/server'
+import { loadProviderConfigs } from '@/lib/server/storage'
+
+export async function GET() {
+  const configs = loadProviderConfigs()
+  return NextResponse.json(Object.values(configs))
+}

package/src/app/api/providers/ollama/route.ts

@@ -0,0 +1,30 @@
+import { NextResponse } from 'next/server'
+
+/** Fetch locally installed models from Ollama API */
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url)
+  const endpoint = searchParams.get('endpoint') || 'http://localhost:11434'
+
+  try {
+    const res = await fetch(`${endpoint.replace(/\/+$/, '')}/api/tags`, {
+      signal: AbortSignal.timeout(5000),
+    })
+    if (!res.ok) {
+      return NextResponse.json({ models: [], error: `Ollama returned ${res.status}` })
+    }
+    const data = await res.json()
+    const models = (data.models || []).map((m: any) => ({
+      name: m.name?.replace(/:latest$/, '') || m.name,
+      size: m.size,
+      modified: m.modified_at,
+    }))
+    return NextResponse.json({ models })
+  } catch (err: any) {
+    return NextResponse.json({
+      models: [],
+      error: err.code === 'ECONNREFUSED'
+        ? 'Ollama is not running'
+        : err.message || 'Failed to connect',
+    })
+  }
+}

package/src/app/api/providers/openclaw/health/route.ts

@@ -0,0 +1,23 @@
+import { NextResponse } from 'next/server'
+import { probeOpenClawHealth } from '@/lib/server/openclaw-health'
+
+function parseIntBounded(value: unknown, fallback: number, min: number, max: number): number {
+  const parsed = typeof value === 'number'
+    ? value
+    : typeof value === 'string'
+      ? Number.parseInt(value, 10)
+      : Number.NaN
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.max(min, Math.min(max, Math.trunc(parsed)))
+}
+
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url)
+  const endpoint = searchParams.get('endpoint')
+  const credentialId = searchParams.get('credentialId')
+  const token = searchParams.get('token')
+  const model = searchParams.get('model')
+  const timeoutMs = parseIntBounded(searchParams.get('timeoutMs'), 8000, 1000, 30000)
+  const result = await probeOpenClawHealth({ endpoint, credentialId, token, model, timeoutMs })
+  return NextResponse.json(result)
+}

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

@@ -0,0 +1,28 @@
+import { NextResponse } from 'next/server'
+import crypto from 'crypto'
+import { getProviderList } from '@/lib/providers'
+import { loadProviderConfigs, saveProviderConfigs } from '@/lib/server/storage'
+
+export async function GET() {
+  return NextResponse.json(getProviderList())
+}
+
+export async function POST(req: Request) {
+  const body = await req.json()
+  const configs = loadProviderConfigs()
+  const id = body.id || `custom-${crypto.randomBytes(4).toString('hex')}`
+  configs[id] = {
+    id,
+    name: body.name || 'Custom Provider',
+    type: 'custom',
+    baseUrl: body.baseUrl || '',
+    models: body.models || [],
+    requiresApiKey: body.requiresApiKey ?? true,
+    credentialId: body.credentialId || null,
+    isEnabled: body.isEnabled ?? true,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  }
+  saveProviderConfigs(configs)
+  return NextResponse.json(configs[id])
+}

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

@@ -0,0 +1,9 @@
+import { NextResponse } from 'next/server'
+import { getRunById } from '@/lib/server/session-run-manager'
+
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const run = getRunById(id)
+  if (!run) return NextResponse.json({ error: 'Run not found' }, { status: 404 })
+  return NextResponse.json(run)
+}

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

@@ -0,0 +1,13 @@
+import { NextResponse } from 'next/server'
+import { listRuns, type SessionRunStatus } from '@/lib/server/session-run-manager'
+
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url)
+  const sessionId = searchParams.get('sessionId') || undefined
+  const status = (searchParams.get('status') || undefined) as SessionRunStatus | undefined
+  const limitRaw = searchParams.get('limit')
+  const limit = limitRaw ? Number.parseInt(limitRaw, 10) : undefined
+
+  const runs = listRuns({ sessionId, status, limit })
+  return NextResponse.json(runs)
+}