@swarmclawai/swarmclaw 1.4.0 → 1.4.3

package/src/app/api/chats/chat-route.test.ts

@@ -0,0 +1,68 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
+
+test('chat route rejects malformed JSON with a 400 before queueing work', () => {
+  const output = runWithTempDataDir<{
+    status: number
+    payload: { error?: string }
+    runCount: number
+  }>(`
+    const storageMod = await import('./src/lib/server/storage')
+    const routeMod = await import('./src/app/api/chats/[id]/chat/route')
+    const runsMod = await import('@/lib/server/runtime/session-run-manager')
+    const storage = storageMod.default || storageMod
+    const route = routeMod.default || routeMod
+    const runs = runsMod.default || runsMod
+
+    const now = Date.now()
+    storage.saveAgents({
+      agent_1: {
+        id: 'agent_1',
+        name: 'Malformed Agent',
+        provider: 'openai',
+        model: 'gpt-4o-mini',
+        extensions: [],
+        createdAt: now,
+        updatedAt: now,
+      },
+    })
+    storage.saveSessions({
+      sess_1: {
+        id: 'sess_1',
+        name: 'Malformed Session',
+        cwd: process.env.WORKSPACE_DIR,
+        user: 'workbench',
+        provider: 'openai',
+        model: 'gpt-4o-mini',
+        claudeSessionId: null,
+        messages: [],
+        createdAt: now,
+        lastActiveAt: now,
+        sessionType: 'human',
+        agentId: 'agent_1',
+        extensions: [],
+      },
+    })
+
+    const response = await route.POST(
+      new Request('http://local/api/chats/sess_1/chat', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: '{bad-json',
+      }),
+      { params: Promise.resolve({ id: 'sess_1' }) },
+    )
+
+    console.log(JSON.stringify({
+      status: response.status,
+      payload: await response.json(),
+      runCount: runs.listRuns({ sessionId: 'sess_1' }).length,
+    }))
+  `, { prefix: 'swarmclaw-chat-route-invalid-json-' })
+
+  assert.equal(output.status, 400)
+  assert.equal(output.payload.error, 'Invalid or missing request body')
+  assert.equal(output.runCount, 0)
+})

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

@@ -0,0 +1,97 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
+
+test('connector doctor route rejects malformed JSON with a 400', () => {
+  const output = runWithTempDataDir<{
+    status: number
+    payload: { error?: string }
+  }>(`
+    const repoMod = await import('./src/lib/server/connectors/connector-repository')
+    const routeMod = await import('./src/app/api/connectors/[id]/doctor/route')
+    const repo = repoMod.default || repoMod
+    const route = routeMod.default || routeMod
+
+    repo.saveConnectors({
+      conn_1: {
+        id: 'conn_1',
+        name: 'Doctor Test',
+        platform: 'discord',
+        agentId: 'agent_1',
+        chatroomId: null,
+        credentialId: null,
+        config: {},
+        isEnabled: true,
+        status: 'running',
+        createdAt: 1,
+        updatedAt: 1,
+      },
+    })
+
+    const response = await route.POST(new Request('http://local/api/connectors/conn_1/doctor', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: '{bad-json',
+    }), { params: Promise.resolve({ id: 'conn_1' }) })
+
+    console.log(JSON.stringify({
+      status: response.status,
+      payload: await response.json(),
+    }))
+  `, { prefix: 'swarmclaw-connector-doctor-route-' })
+
+  assert.equal(output.status, 400)
+  assert.equal(output.payload.error, 'Invalid or missing request body')
+})
+
+test('connector doctor route returns a preview report for valid input', () => {
+  const output = runWithTempDataDir<{
+    status: number
+    payload: { warnings?: string[]; policy?: { mode?: string } }
+  }>(`
+    const repoMod = await import('./src/lib/server/connectors/connector-repository')
+    const routeMod = await import('./src/app/api/connectors/[id]/doctor/route')
+    const repo = repoMod.default || repoMod
+    const route = routeMod.default || routeMod
+
+    repo.saveConnectors({
+      conn_1: {
+        id: 'conn_1',
+        name: 'Doctor Test',
+        platform: 'discord',
+        agentId: 'agent_1',
+        chatroomId: null,
+        credentialId: null,
+        config: {},
+        isEnabled: true,
+        status: 'running',
+        createdAt: 1,
+        updatedAt: 1,
+      },
+    })
+
+    const response = await route.POST(new Request('http://local/api/connectors/conn_1/doctor', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        sampleMsg: {
+          channelId: 'channel-1',
+          channelName: 'general',
+          senderId: 'user-1',
+          senderName: 'User',
+          text: 'hello',
+        },
+      }),
+    }), { params: Promise.resolve({ id: 'conn_1' }) })
+
+    console.log(JSON.stringify({
+      status: response.status,
+      payload: await response.json(),
+    }))
+  `, { prefix: 'swarmclaw-connector-doctor-route-' })
+
+  assert.equal(output.status, 200)
+  assert.ok(Array.isArray(output.payload.warnings))
+  assert.ok(output.payload.policy)
+})

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

@@ -1,10 +1,34 @@
 import { NextResponse } from 'next/server'
+import { z } from 'zod'
+
 import { notFound } from '@/lib/server/collection-helpers'
 import { buildConnectorDoctorPreview, buildConnectorDoctorReport, type ConnectorDoctorPreviewInput } from '@/lib/server/connectors/doctor'
 import { loadConnectors } from '@/lib/server/connectors/connector-repository'
+import { safeParseBody } from '@/lib/server/safe-parse-body'
 
 export const dynamic = 'force-dynamic'
 
+const ConnectorDoctorPreviewSchema: z.ZodType<ConnectorDoctorPreviewInput> = z.object({
+  id: z.unknown().optional(),
+  name: z.unknown().optional(),
+  platform: z.unknown().optional(),
+  agentId: z.unknown().optional(),
+  chatroomId: z.unknown().optional(),
+  credentialId: z.unknown().optional(),
+  config: z.record(z.string(), z.unknown()).optional(),
+  sampleMsg: z.object({
+    channelId: z.string().optional(),
+    channelName: z.string().optional(),
+    senderId: z.string().optional(),
+    senderName: z.string().optional(),
+    text: z.string().optional(),
+    isGroup: z.boolean().optional(),
+    messageId: z.string().optional(),
+    replyToMessageId: z.string().optional(),
+    threadId: z.string().optional(),
+  }).passthrough().nullable().optional(),
+}).passthrough()
+
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const connectors = loadConnectors()
@@ -20,7 +44,8 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   const baseConnector = connectors[id]
   if (!baseConnector) return notFound()
 
-  const body = await req.json().catch(() => ({})) as ConnectorDoctorPreviewInput
+  const { data: body, error } = await safeParseBody(req, ConnectorDoctorPreviewSchema)
+  if (error) return error
   const connector = buildConnectorDoctorPreview({ baseConnector, input: body, fallbackId: id })
   return NextResponse.json(buildConnectorDoctorReport(connector, body.sampleMsg, { baseConnector }))
 }

package/src/app/api/connectors/connector-doctor-route.test.ts

@@ -0,0 +1 @@
+import './[id]/doctor/route.test'

package/src/app/api/logs/route.test.ts

@@ -0,0 +1,61 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
+
+test('logs route accepts client-side error reports and persists them', () => {
+  const output = runWithTempDataDir<{
+    status: number
+    payload: { ok?: boolean }
+    entries: Array<{ tag?: string; message?: string; data?: string }>
+  }>(`
+    const routeMod = await import('./src/app/api/logs/route')
+    const route = routeMod.default || routeMod
+
+    const postResponse = await route.POST(new Request('http://local/api/logs', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        source: 'error-boundary',
+        message: 'Client render failed',
+        componentStack: 'at DemoComponent',
+      }),
+    }))
+
+    const getResponse = await route.GET(new Request('http://local/api/logs?lines=5&search=Client%20render%20failed'))
+
+    console.log(JSON.stringify({
+      status: postResponse.status,
+      payload: await postResponse.json(),
+      entries: (await getResponse.json()).entries,
+    }))
+  `, { prefix: 'swarmclaw-logs-route-' })
+
+  assert.equal(output.status, 200)
+  assert.equal(output.payload.ok, true)
+  assert.ok(output.entries.some((entry) => entry.tag === 'error-boundary' && entry.message === 'Client render failed'))
+})
+
+test('logs route rejects malformed client error payloads with a 400', () => {
+  const output = runWithTempDataDir<{
+    status: number
+    payload: { error?: string }
+  }>(`
+    const routeMod = await import('./src/app/api/logs/route')
+    const route = routeMod.default || routeMod
+
+    const response = await route.POST(new Request('http://local/api/logs', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: '{bad-json',
+    }))
+
+    console.log(JSON.stringify({
+      status: response.status,
+      payload: await response.json(),
+    }))
+  `, { prefix: 'swarmclaw-logs-route-' })
+
+  assert.equal(output.status, 400)
+  assert.equal(output.payload.error, 'Invalid or missing request body')
+})

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

@@ -1,10 +1,25 @@
 import { NextResponse } from 'next/server'
 import fs from 'fs'
+import { z } from 'zod'
+
 import { APP_LOG_PATH } from '@/lib/server/data-dir'
+import { log } from '@/lib/server/logger'
+import { safeParseBody } from '@/lib/server/safe-parse-body'
 
 /** Max bytes to read from the tail of the log file (256 KB). */
 const TAIL_BYTES = 256 * 1024
 
+const ClientLogSchema = z.object({
+  source: z.string().trim().min(1).max(120).optional().default('client'),
+  message: z.string().trim().min(1).max(1000),
+  stack: z.string().max(8000).optional(),
+  componentStack: z.string().max(8000).optional(),
+  digest: z.string().max(200).optional(),
+  url: z.string().max(2000).optional(),
+  pathname: z.string().max(1000).optional(),
+  userAgent: z.string().max(1000).optional(),
+})
+
 export async function GET(req: Request) {
   const { searchParams } = new URL(req.url)
   const lines = parseInt(searchParams.get('lines') || '200', 10)
@@ -76,6 +91,26 @@ export async function DELETE() {
   }
 }
 
+export async function POST(req: Request) {
+  const { data: body, error } = await safeParseBody(req, ClientLogSchema)
+  if (error) return error
+
+  try {
+    log.error(body.source, body.message, {
+      stack: body.stack,
+      componentStack: body.componentStack,
+      digest: body.digest,
+      url: body.url,
+      pathname: body.pathname,
+      userAgent: body.userAgent,
+    })
+    return NextResponse.json({ ok: true })
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return NextResponse.json({ error: message }, { status: 500 })
+  }
+}
+
 function parseLine(line: string) {
   // Format: [2026-02-19T17:06:00.000Z] [INFO] [tag] message | data
   const match = line.match(/^\[([^\]]+)\]\s+\[(\w+)\]\s+\[([^\]]+)\]\s+(.*)$/)

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

@@ -0,0 +1,25 @@
+import { NextResponse } from 'next/server'
+
+export const dynamic = 'force-dynamic'
+
+const API_URL = process.env.SWARMDOCK_API_URL || 'https://swarmdock-api.onrender.com'
+
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url)
+  const type = searchParams.get('type') || 'tasks'
+  const limit = searchParams.get('limit') || '50'
+
+  const endpoint = type === 'agents' ? '/api/v1/agents' : '/api/v1/tasks'
+  try {
+    const res = await fetch(`${API_URL}${endpoint}?limit=${limit}`)
+    if (!res.ok) {
+      const text = await res.text().catch(() => 'Unknown error')
+      return NextResponse.json({ error: `SwarmDock API error ${res.status}: ${text}` }, { status: 502 })
+    }
+    const data = await res.json()
+    return NextResponse.json(data)
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : 'Failed to fetch'
+    return NextResponse.json({ error: message }, { status: 502 })
+  }
+}

package/src/app/api/swarmfeed/posts/route.ts

@@ -1,7 +1,8 @@
 import { NextResponse } from 'next/server'
-import { createPost, getFeed } from '@/lib/swarmfeed-client'
-import { getAgent } from '@/lib/server/agents/agent-repository'
+import { createPost, getFeed, registerAgent } from '@/lib/swarmfeed-client'
+import { getAgent, patchAgent } from '@/lib/server/agents/agent-repository'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
+import { log } from '@/lib/server/logger'
 import type { Agent } from '@/types'
 
 export const dynamic = 'force-dynamic'
@@ -37,15 +38,52 @@ export async function POST(req: Request) {
     return NextResponse.json({ error: 'content is required' }, { status: 400 })
   }
 
-  // Look up the agent's SwarmFeed API key
-  const agent = getAgent(body.agentId) as Agent | undefined
-  if (!agent?.swarmfeedApiKey) {
+  // Look up the agent and auto-register on SwarmFeed if needed
+  let agent = getAgent(body.agentId) as Agent | undefined
+  if (!agent) {
+    return NextResponse.json({ error: 'Agent not found' }, { status: 404 })
+  }
+  if (!agent.swarmfeedEnabled) {
     return NextResponse.json(
-      { error: 'Agent not registered on SwarmFeed. Enable SwarmFeed in agent settings first.' },
+      { error: 'SwarmFeed is not enabled for this agent. Enable it in agent settings first.' },
       { status: 400 },
     )
   }
 
+  // Auto-register if enabled but no API key yet
+  if (!agent.swarmfeedApiKey) {
+    const agentName = agent.name
+    try {
+      log.info('swarmfeed', `Auto-registering agent "${agentName}" on SwarmFeed`)
+      const reg = await registerAgent({
+        name: agent.name,
+        description: agent.description || agent.swarmfeedBio || `${agent.name} agent on SwarmClaw`,
+        framework: 'swarmclaw',
+        model: agent.model,
+        avatar: agent.avatarUrl || undefined,
+        bio: agent.swarmfeedBio || undefined,
+      })
+      patchAgent(agent.id, (current) => {
+        if (!current) return null
+        return {
+          ...current,
+          swarmfeedApiKey: reg.apiKey,
+          swarmfeedAgentId: reg.agentId,
+          swarmfeedJoinedAt: current.swarmfeedJoinedAt ?? Date.now(),
+          updatedAt: Date.now(),
+        }
+      })
+      agent = getAgent(body.agentId) as Agent | undefined
+      if (!agent?.swarmfeedApiKey) {
+        return NextResponse.json({ error: 'Registration succeeded but API key not saved' }, { status: 500 })
+      }
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : 'Registration failed'
+      log.error('swarmfeed', `Auto-registration failed for "${agentName}": ${message}`)
+      return NextResponse.json({ error: `SwarmFeed registration failed: ${message}` }, { status: 502 })
+    }
+  }
+
   try {
     const post = await createPost(agent.swarmfeedApiKey, {
       content: body.content.trim(),

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

@@ -25,6 +25,10 @@ export async function GET(req: Request) {
     const agents = Object.values(loadAgents()) as Agent[]
     const feedAgent = agents.find((a) => a.swarmfeedEnabled && a.swarmfeedApiKey)
     agentApiKey = feedAgent?.swarmfeedApiKey ?? undefined
+    // No registered agent — return empty feed instead of triggering a 401
+    if (!agentApiKey) {
+      return NextResponse.json({ posts: [], nextCursor: undefined })
+    }
   }
 
   try {

package/src/app/api/tts/route.test.ts

@@ -0,0 +1,82 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
+
+test('tts routes reject malformed JSON with a 400', () => {
+  const output = runWithTempDataDir<{
+    ttsStatus: number
+    ttsPayload: { error?: string }
+    streamStatus: number
+    streamPayload: { error?: string }
+  }>(`
+    const ttsRouteMod = await import('./src/app/api/tts/route')
+    const ttsStreamRouteMod = await import('./src/app/api/tts/stream/route')
+    const ttsRoute = ttsRouteMod.default || ttsRouteMod
+    const ttsStreamRoute = ttsStreamRouteMod.default || ttsStreamRouteMod
+
+    const ttsResponse = await ttsRoute.POST(new Request('http://local/api/tts', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: '{bad-json',
+    }))
+
+    const ttsStreamResponse = await ttsStreamRoute.POST(new Request('http://local/api/tts/stream', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: '{bad-json',
+    }))
+
+    console.log(JSON.stringify({
+      ttsStatus: ttsResponse.status,
+      ttsPayload: await ttsResponse.json(),
+      streamStatus: ttsStreamResponse.status,
+      streamPayload: await ttsStreamResponse.json(),
+    }))
+  `, { prefix: 'swarmclaw-tts-route-' })
+
+  assert.equal(output.ttsStatus, 400)
+  assert.equal(output.ttsPayload.error, 'Invalid or missing request body')
+  assert.equal(output.streamStatus, 400)
+  assert.equal(output.streamPayload.error, 'Invalid or missing request body')
+})
+
+test('tts routes reject empty text with a validation error', () => {
+  const output = runWithTempDataDir<{
+    ttsStatus: number
+    ttsPayload: { error?: string; issues?: Array<{ path: string; message: string }> }
+    streamStatus: number
+    streamPayload: { error?: string; issues?: Array<{ path: string; message: string }> }
+  }>(`
+    const ttsRouteMod = await import('./src/app/api/tts/route')
+    const ttsStreamRouteMod = await import('./src/app/api/tts/stream/route')
+    const ttsRoute = ttsRouteMod.default || ttsRouteMod
+    const ttsStreamRoute = ttsStreamRouteMod.default || ttsStreamRouteMod
+
+    const ttsResponse = await ttsRoute.POST(new Request('http://local/api/tts', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ text: '   ' }),
+    }))
+
+    const ttsStreamResponse = await ttsStreamRoute.POST(new Request('http://local/api/tts/stream', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ text: '   ' }),
+    }))
+
+    console.log(JSON.stringify({
+      ttsStatus: ttsResponse.status,
+      ttsPayload: await ttsResponse.json(),
+      streamStatus: ttsStreamResponse.status,
+      streamPayload: await ttsStreamResponse.json(),
+    }))
+  `, { prefix: 'swarmclaw-tts-route-' })
+
+  assert.equal(output.ttsStatus, 400)
+  assert.equal(output.ttsPayload.error, 'Validation failed')
+  assert.deepEqual(output.ttsPayload.issues, [{ path: 'text', message: 'No text provided' }])
+  assert.equal(output.streamStatus, 400)
+  assert.equal(output.streamPayload.error, 'Validation failed')
+  assert.deepEqual(output.streamPayload.issues, [{ path: 'text', message: 'No text provided' }])
+})

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

@@ -1,14 +1,21 @@
 import { NextResponse } from 'next/server'
+import { z } from 'zod'
+
 import { explainElevenLabsError, resolveElevenLabsConfig, synthesizeElevenLabsMp3 } from '@/lib/server/elevenlabs'
+import { safeParseBody } from '@/lib/server/safe-parse-body'
+
+const TtsRequestSchema = z.object({
+  text: z.string().trim().min(1, 'No text provided'),
+  voiceId: z.string().nullable().optional(),
+})
 
 export async function POST(req: Request) {
+  const { data: body, error } = await safeParseBody(req, TtsRequestSchema)
+  if (error) return error
+
   try {
-    const { text, voiceId } = await req.json()
-    if (!String(text || '').trim()) {
-      return new NextResponse('No text provided', { status: 400 })
-    }
-    resolveElevenLabsConfig(voiceId)
-    const audioBuffer = await synthesizeElevenLabsMp3({ text: String(text || ''), voiceId })
+    resolveElevenLabsConfig(body.voiceId)
+    const audioBuffer = await synthesizeElevenLabsMp3({ text: body.text, voiceId: body.voiceId })
     return new NextResponse(new Uint8Array(audioBuffer), {
       headers: {
         'Content-Type': 'audio/mpeg',

package/src/app/api/tts/stream/route.ts

@@ -1,12 +1,19 @@
+import { z } from 'zod'
+
 import { explainElevenLabsError, requestElevenLabsMp3Stream } from '@/lib/server/elevenlabs'
+import { safeParseBody } from '@/lib/server/safe-parse-body'
+
+const TtsStreamRequestSchema = z.object({
+  text: z.string().trim().min(1, 'No text provided'),
+  voiceId: z.string().nullable().optional(),
+})
 
 export async function POST(req: Request) {
+  const { data: body, error } = await safeParseBody(req, TtsStreamRequestSchema)
+  if (error) return error
+
   try {
-    const { text, voiceId } = await req.json()
-    if (!String(text || '').trim()) {
-      return new Response('No text provided', { status: 400 })
-    }
-    const apiRes = await requestElevenLabsMp3Stream({ text: String(text || ''), voiceId })
+    const apiRes = await requestElevenLabsMp3Stream({ text: body.text, voiceId: body.voiceId })
     return new Response(apiRes.body, {
       headers: {
         'Content-Type': 'audio/mpeg',

package/src/app/error.tsx

@@ -0,0 +1,32 @@
+'use client'
+
+import { useEffect } from 'react'
+
+import { ErrorFallback } from '@/components/layout/error-fallback'
+import { reportClientError } from '@/lib/app/report-client-error'
+
+export default function AppError({
+  error,
+  reset,
+}: {
+  error: Error & { digest?: string }
+  reset: () => void
+}) {
+  useEffect(() => {
+    reportClientError({
+      source: 'app-error',
+      error,
+      digest: error.digest,
+    })
+  }, [error])
+
+  return (
+    <ErrorFallback
+      message="A route-level error interrupted the current view. Try the request again or reload the app."
+      primaryLabel="Try Again"
+      onPrimaryAction={() => reset()}
+      secondaryLabel="Reload"
+      onSecondaryAction={() => window.location.reload()}
+    />
+  )
+}

package/src/app/global-error.tsx

@@ -0,0 +1,33 @@
+'use client'
+
+import { useEffect } from 'react'
+
+import './globals.css'
+
+import { ErrorFallback } from '@/components/layout/error-fallback'
+import { reportClientError } from '@/lib/app/report-client-error'
+
+export default function GlobalError({
+  error,
+}: {
+  error: Error & { digest?: string }
+}) {
+  useEffect(() => {
+    reportClientError({
+      source: 'global-error',
+      error,
+      digest: error.digest,
+    })
+  }, [error])
+
+  return (
+    <html lang="en" className="dark">
+      <body className="antialiased">
+        <ErrorFallback
+          message="A fatal application error occurred before the normal shell could recover. Reload the app to continue."
+          onPrimaryAction={() => window.location.reload()}
+        />
+      </body>
+    </html>
+  )
+}

package/src/app/marketplace/page.tsx

@@ -0,0 +1,7 @@
+'use client'
+
+import { MarketplacePage } from '@/features/swarmdock/marketplace-page'
+
+export default function MarketplaceRoute() {
+  return <MarketplacePage />
+}

package/src/cli/index.js

@@ -298,6 +298,9 @@ const COMMAND_GROUPS = [
     commands: [
       cmd('list', 'GET', '/logs', 'List logs (use --query lines=200, --query level=INFO,ERROR)'),
       cmd('clear', 'DELETE', '/logs', 'Clear logs file'),
+      cmd('report', 'POST', '/logs', 'Write a client/browser error entry to the application log', {
+        expectsJsonBody: true,
+      }),
     ],
   },
   {
@@ -803,6 +806,13 @@ const COMMAND_GROUPS = [
       cmd('post', 'POST', '/swarmfeed/posts', 'Create a post', { expectsJsonBody: true }),
     ],
   },
+  {
+    name: 'swarmdock',
+    description: 'SwarmDock marketplace',
+    commands: [
+      cmd('browse', 'GET', '/swarmdock', 'Browse SwarmDock marketplace tasks and agents'),
+    ],
+  },
 ]
 
 const GROUP_MAP = new Map(COMMAND_GROUPS.map((group) => [group.name, group]))