add default run_terminal_command implementation

Author: charleslien

sdk/src/client.ts

@@ -4,6 +4,7 @@ import os from 'os'
 import { CODEBUFF_BINARY } from './constants'
 import { changeFile } from './tools/change-file'
 import { getFiles } from './tools/read-files'
+import { runTerminalCommand } from './tools/run-terminal-command'
 import { WebSocketHandler } from './websocket-client'
 import {
   PromptResponseSchema,
@@ -215,7 +216,9 @@ export class CodebuffClient {
     return getFiles(filePath, this.cwd)
   }
 
-  private async handleToolCall(action: ServerAction<'tool-call-request'>) {
+  private async handleToolCall(
+    action: ServerAction<'tool-call-request'>,
+  ): ReturnType<WebSocketHandler['handleToolCall']> {
     const toolName = action.toolName
     const input = action.input
     let result: string
@@ -234,32 +237,39 @@ export class CodebuffClient {
         const r = changeFile(input, this.cwd)
         result = r.toolResultMessage
       } else if (toolName === 'run_terminal_command') {
-        throw new Error(
-          'run_terminal_command not implemented in SDK yet; please provide an override.',
-        )
+        const r = await runTerminalCommand({
+          ...input,
+          cwd: input.cwd ?? this.cwd,
+        } as Parameters<typeof runTerminalCommand>[0])
+        result = r.output
       } else {
         throw new Error(
           `Tool not implemented in SDK. Please provide an override or modify your agent to not use this tool: ${toolName}`,
         )
       }
     } catch (error) {
       return {
-        type: 'tool-call-response',
-        requestId: action.requestId,
         success: false,
-        result:
-          error && typeof error === 'object' && 'message' in error
-            ? error.message
-            : typeof error === 'string'
-              ? error
-              : 'Unknown error',
+        output: {
+          type: 'text',
+          value:
+            error &&
+            typeof error === 'object' &&
+            'message' in error &&
+            typeof error.message === 'string'
+              ? error.message
+              : typeof error === 'string'
+                ? error
+                : 'Unknown error',
+        },
       }
     }
     return {
-      type: 'tool-call-response',
-      requestId: action.requestId,
       success: true,
-      result,
+      output: {
+        type: 'text',
+        value: result,
+      },
     }
   }
 }

sdk/src/tools/run-terminal-command.ts

@@ -0,0 +1,100 @@
+import { spawn } from 'child_process'
+import * as os from 'os'
+import * as path from 'path'
+
+import { buildArray } from '../../../common/src/util/array'
+
+export function runTerminalCommand({
+  command,
+  process_type,
+  cwd,
+  timeout_seconds,
+}: {
+  command: string
+  process_type: 'SYNC' | 'BACKGROUND'
+  cwd: string
+  timeout_seconds: number
+}): Promise<{ output: string }> {
+  if (process_type === 'BACKGROUND') {
+    throw new Error('BACKGROUND process_type not implemented')
+  }
+
+  return new Promise((resolve, reject) => {
+    const isWindows = os.platform() === 'win32'
+    const shell = isWindows ? 'cmd.exe' : 'bash'
+    const shellArgs = isWindows ? ['/c'] : ['-c']
+
+    // Resolve cwd to absolute path
+    const resolvedCwd = path.resolve(cwd)
+
+    const childProcess = spawn(shell, [...shellArgs, command], {
+      cwd: resolvedCwd,
+      env: {
+        ...process.env,
+        FORCE_COLOR: '1',
+        CLICOLOR: '1',
+        CLICOLOR_FORCE: '1',
+      },
+      stdio: 'pipe',
+    })
+
+    let stdout = ''
+    let stderr = ''
+    let timer: NodeJS.Timeout | null = null
+    let processFinished = false
+
+    // Set up timeout if timeout_seconds >= 0 (infinite timeout when < 0)
+    if (timeout_seconds >= 0) {
+      timer = setTimeout(() => {
+        if (!processFinished) {
+          processFinished = true
+          childProcess.kill('SIGTERM')
+          reject(
+            new Error(`Command timed out after ${timeout_seconds} seconds`),
+          )
+        }
+      }, timeout_seconds * 1000)
+    }
+
+    // Collect stdout
+    childProcess.stdout.on('data', (data: Buffer) => {
+      stdout += data.toString()
+    })
+
+    // Collect stderr
+    childProcess.stderr.on('data', (data: Buffer) => {
+      stderr += data.toString()
+    })
+
+    // Handle process completion
+    childProcess.on('close', (exitCode) => {
+      if (processFinished) return
+      processFinished = true
+
+      if (timer) {
+        clearTimeout(timer)
+      }
+
+      // Include stderr in stdout for compatibility with existing behavior
+      const combinedOutput = buildArray([
+        `\`\`\`stdout\n${stdout}\`\`\``,
+        stderr && `\`\`\`stderr\n${stderr}\`\`\``,
+        exitCode !== null && `\`\`\`exit_code\n${exitCode}\`\`\``,
+      ]).join('\n\n')
+
+      resolve({ output: combinedOutput })
+    })
+
+    // Handle spawn errors
+    childProcess.on('error', (error) => {
+      if (processFinished) return
+      processFinished = true
+
+      if (timer) {
+        clearTimeout(timer)
+      }
+
+      reject(new Error(`Failed to spawn command: ${error.message}`))
+    })
+  })
+}