@metabob/minibob 0.1.2

package/src/cli/acp-server.ts

@@ -0,0 +1,377 @@
+/**
+ * ACP Server Command
+ *
+ * Launch standalone ACP server for external agent integration.
+ *
+ * Modes:
+ * - stdio: JSON-RPC over stdin/stdout (for editor extensions, CLI piping)
+ * - http: HTTP server on specified port (default)
+ * - websocket: WebSocket server for streaming
+ */
+
+import { parseArgs, formatHelp, printInfo, exitWithError } from './index'
+import { loadConfig } from '../config'
+import { ACPSession, handleACPRequest, type ACPServerConfig } from '../acp'
+import { createToolHandlers, getAllToolDefinitions, type ToolHandler } from '../tools'
+import type { ACPMessage } from '../types'
+
+export interface ACPServerOptions {
+  mode?: 'stdio' | 'http' | 'websocket'
+  port?: number
+  noTools?: boolean
+  tools?: string[]
+  denyTools?: string[]
+  system?: string
+}
+
+/**
+ * Run ACP server command
+ */
+export async function launchACPServer(args: string[]): Promise<void> {
+  const { flags, values } = parseArgs(args)
+
+  // Show help
+  if (flags.help || flags.h) {
+    console.log(formatHelp('acp', 'Launch standalone ACP server', [
+      { flag: '--mode <mode>', description: 'stdio, http, websocket', default: 'http' },
+      { flag: '--port <port>', description: 'Port for http/websocket mode', default: '8080' },
+      { flag: '--no-tools', description: 'Disable tool access (prompt only)' },
+      { flag: '--tools <list>', description: 'Comma-separated whitelist of allowed tools' },
+      { flag: '--deny-tools <list>', description: 'Comma-separated blacklist of denied tools' },
+      { flag: '--system <file>', description: 'Custom system prompt from file' },
+      { flag: '--help, -h', description: 'Show this help message' },
+    ]))
+    return
+  }
+
+  const options: ACPServerOptions = {
+    mode: (values.mode as 'stdio' | 'http' | 'websocket') || 'http',
+    port: values.port ? parseInt(values.port) : 8080,
+    noTools: flags['no-tools'],
+    tools: values.tools?.split(',').map((t) => t.trim()),
+    denyTools: values['deny-tools']?.split(',').map((t) => t.trim()),
+    system: values.system,
+  }
+
+  // Load configuration
+  const config = await loadConfig()
+
+  // Load custom system prompt if specified
+  let systemPrompt: string | undefined
+  if (options.system) {
+    try {
+      systemPrompt = await Bun.file(options.system).text()
+    } catch {
+      exitWithError(`Could not read system prompt file: ${options.system}`)
+    }
+  }
+
+  const acpConfig: ACPServerConfig = {
+    provider: config.provider,
+    apiKey: config.apiKey,
+    model: config.model,
+    workingDirectory: config.workingDirectory,
+    systemPrompt,
+  }
+
+  // Filter tools based on options
+  const toolFilter = createToolFilter(options)
+
+  switch (options.mode) {
+    case 'stdio':
+      await runStdioServer(acpConfig, toolFilter)
+      break
+    case 'websocket':
+      await runWebSocketServer(acpConfig, options.port!, toolFilter)
+      break
+    case 'http':
+    default:
+      await runHttpServer(acpConfig, options.port!, toolFilter)
+      break
+  }
+}
+
+/**
+ * Create tool filter based on options
+ */
+function createToolFilter(options: ACPServerOptions): (name: string) => boolean {
+  if (options.noTools) {
+    return () => false
+  }
+
+  return (name: string) => {
+    // Check whitelist
+    if (options.tools && options.tools.length > 0) {
+      return options.tools.includes(name)
+    }
+
+    // Check blacklist
+    if (options.denyTools && options.denyTools.length > 0) {
+      return !options.denyTools.includes(name)
+    }
+
+    return true
+  }
+}
+
+/**
+ * Run stdio mode server
+ */
+async function runStdioServer(
+  config: ACPServerConfig,
+  toolFilter: (name: string) => boolean
+): Promise<void> {
+  printInfo('ACP server running in stdio mode')
+  printInfo('Send JSON messages to stdin, receive responses on stdout')
+
+  const sessions = new Map<string, ACPSession>()
+
+  // Read lines from stdin
+  const reader = Bun.stdin.stream().getReader()
+  const decoder = new TextDecoder()
+  let buffer = ''
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+
+      buffer += decoder.decode(value, { stream: true })
+
+      // Process complete lines
+      const lines = buffer.split('\n')
+      buffer = lines.pop() || ''
+
+      for (const line of lines) {
+        if (!line.trim()) continue
+
+        try {
+          const message = JSON.parse(line) as ACPMessage & { sessionId?: string }
+
+          // Get or create session
+          const sessionId = message.sessionId || `stdio_${Date.now()}`
+          let session = sessions.get(sessionId)
+          if (!session) {
+            session = new ACPSession(config, sessionId)
+            sessions.set(sessionId, session)
+          }
+
+          // Handle message
+          const responses = await session.handleMessage(message)
+
+          // Write responses to stdout
+          for (const response of responses) {
+            const responseWithSession = { ...response, sessionId }
+            console.log(JSON.stringify(responseWithSession))
+          }
+        } catch (error) {
+          console.log(
+            JSON.stringify({
+              type: 'error',
+              error: error instanceof Error ? error.message : String(error),
+            })
+          )
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock()
+  }
+}
+
+/**
+ * Run HTTP mode server
+ */
+async function runHttpServer(
+  config: ACPServerConfig,
+  port: number,
+  toolFilter: (name: string) => boolean
+): Promise<void> {
+  const server = Bun.serve({
+    port,
+    hostname: '0.0.0.0',
+
+    fetch(request) {
+      const url = new URL(request.url)
+
+      // Health check
+      if (url.pathname === '/health') {
+        return new Response(JSON.stringify({ status: 'ok', mode: 'acp-server' }), {
+          headers: { 'Content-Type': 'application/json' },
+        })
+      }
+
+      // ACP endpoint
+      if (url.pathname === '/acp' && request.method === 'POST') {
+        return handleACPRequest(config, request)
+      }
+
+      // List available tools
+      if (url.pathname === '/tools' && request.method === 'GET') {
+        const allTools = getAllToolDefinitions()
+        const filteredTools = allTools.filter((t) => toolFilter(t.name))
+        return new Response(JSON.stringify({ tools: filteredTools }), {
+          headers: { 'Content-Type': 'application/json' },
+        })
+      }
+
+      return new Response(
+        JSON.stringify({
+          error: 'Not found',
+          endpoints: ['GET /health', 'POST /acp', 'GET /tools'],
+        }),
+        {
+          status: 404,
+          headers: { 'Content-Type': 'application/json' },
+        }
+      )
+    },
+  })
+
+  console.log(`\nACP server running at http://0.0.0.0:${port}`)
+  console.log('\nEndpoints:')
+  console.log('  GET  /health  - Health check')
+  console.log('  POST /acp     - ACP protocol handler')
+  console.log('  GET  /tools   - List available tools')
+  console.log('\nExample request:')
+  console.log(`  curl -X POST http://localhost:${port}/acp \\`)
+  console.log(`    -H "Content-Type: application/json" \\`)
+  console.log(`    -d '{"type":"prompt","messages":[{"role":"user","content":"Hello!"}]}'`)
+  console.log('\nPress Ctrl+C to stop')
+
+  // Handle graceful shutdown
+  process.on('SIGINT', () => {
+    console.log('\n\nShutting down...')
+    server.stop()
+    process.exit(0)
+  })
+
+  process.on('SIGTERM', () => {
+    console.log('\n\nShutting down...')
+    server.stop()
+    process.exit(0)
+  })
+}
+
+/**
+ * Run WebSocket mode server
+ */
+async function runWebSocketServer(
+  config: ACPServerConfig,
+  port: number,
+  toolFilter: (name: string) => boolean
+): Promise<void> {
+  const sessions = new Map<WebSocket, ACPSession>()
+
+  const server = Bun.serve({
+    port,
+    hostname: '0.0.0.0',
+
+    fetch(request, server) {
+      const url = new URL(request.url)
+
+      // Health check
+      if (url.pathname === '/health') {
+        return new Response(JSON.stringify({ status: 'ok', mode: 'acp-websocket' }), {
+          headers: { 'Content-Type': 'application/json' },
+        })
+      }
+
+      // WebSocket upgrade
+      if (url.pathname === '/acp/stream') {
+        const upgraded = server.upgrade(request)
+        if (!upgraded) {
+          return new Response('WebSocket upgrade failed', { status: 400 })
+        }
+        return undefined
+      }
+
+      return new Response(
+        JSON.stringify({
+          error: 'Not found',
+          endpoints: ['GET /health', 'WS /acp/stream'],
+        }),
+        {
+          status: 404,
+          headers: { 'Content-Type': 'application/json' },
+        }
+      )
+    },
+
+    websocket: {
+      open(ws) {
+        const sessionId = `ws_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`
+        const session = new ACPSession(config, sessionId)
+        sessions.set(ws, session)
+
+        // Send hello
+        ws.send(
+          JSON.stringify({
+            type: 'hello',
+            sessionId,
+            version: '1.0',
+            capabilities: ['prompt', 'tool_call'],
+          })
+        )
+      },
+
+      async message(ws, message) {
+        const session = sessions.get(ws)
+        if (!session) {
+          ws.send(JSON.stringify({ type: 'error', error: 'Session not found' }))
+          return
+        }
+
+        try {
+          const data = JSON.parse(
+            typeof message === 'string' ? message : message.toString()
+          ) as ACPMessage
+
+          const responses = await session.handleMessage(data)
+          for (const response of responses) {
+            ws.send(JSON.stringify(response))
+          }
+        } catch (error) {
+          ws.send(
+            JSON.stringify({
+              type: 'error',
+              error: error instanceof Error ? error.message : String(error),
+            })
+          )
+        }
+      },
+
+      close(ws) {
+        sessions.delete(ws)
+      },
+    },
+  })
+
+  console.log(`\nACP WebSocket server running at ws://0.0.0.0:${port}/acp/stream`)
+  console.log('\nEndpoints:')
+  console.log('  GET /health     - Health check')
+  console.log('  WS  /acp/stream - WebSocket ACP endpoint')
+  console.log('\nPress Ctrl+C to stop')
+
+  // Handle graceful shutdown
+  process.on('SIGINT', () => {
+    console.log('\n\nShutting down...')
+    server.stop()
+    process.exit(0)
+  })
+
+  process.on('SIGTERM', () => {
+    console.log('\n\nShutting down...')
+    server.stop()
+    process.exit(0)
+  })
+}
+
+// CLI entry point
+if (import.meta.main) {
+  const args = process.argv.slice(2)
+  launchACPServer(args).catch((error) => {
+    console.error('ACP server failed:', error)
+    process.exit(1)
+  })
+}