refactor(cli): move validateAgent from index.ts to cli.ts; update tests to import from cli; centralize agent validation and startup display logic

🤖 Generated with Codebuff
Co-Authored-By: Codebuff <noreply@codebuff.com>

Author: brandonkachen

npm-app/src/__tests__/validate-agent-passthrough.test.ts

@@ -8,7 +8,7 @@ import {
   mock,
 } from 'bun:test'
 
-import { validateAgent } from '../index'
+import { validateAgent } from '../cli'
 import * as SpinnerMod from '../utils/spinner'
 
 describe('validateAgent agent pass-through', () => {

npm-app/src/cli.ts

@@ -22,10 +22,13 @@ import {
   gray,
   green,
   magenta,
+  red,
   yellow,
 } from 'picocolors'
 
 import { loadLocalAgents, loadedAgents } from './agents/load-agents'
+import { backendUrl } from './config'
+import { createAuthHeaders } from './utils/auth-headers'
 import {
   killAllBackgroundProcesses,
   sendKillSignalToAllBackgroundProcesses,
@@ -146,6 +149,72 @@ function getCachedLocalAgentInfo(): Record<
   return cachedLocalAgentInfo
 }
 
+/**
+ * Validates an agent name against local and remote agents
+ * @param agent The agent name to validate
+ * @param localAgents Optional local agents to check against
+ * @returns The display name of the agent if valid, undefined otherwise
+ */
+export async function validateAgent(
+  agent: string,
+  localAgents?: Record<string, any>,
+): Promise<string | undefined> {
+  const agents = localAgents ?? {}
+
+  // if local agents are loaded, they're already validated
+  const localById = agents?.[agent]
+  const localByDisplay = Object.values(agents ?? {}).find(
+    (a: any) => a?.displayName === agent,
+  )
+  if (localById || localByDisplay) {
+    // Display the resolved agent name for local agents too
+    const displayName = (localById?.displayName ||
+      localByDisplay?.displayName ||
+      localById?.id ||
+      agent) as string
+    // Delete the inline console.log to centralize logging in the caller
+    return displayName
+  }
+
+  Spinner.get().start('Checking agent...')
+  try {
+    const url = `${backendUrl}/api/agents/validate-name?agentId=${encodeURIComponent(agent)}`
+
+    // Use helper to create headers with x-codebuff-api-key
+    const headers = createAuthHeaders()
+
+    const resp = await fetch(url, {
+      method: 'GET',
+      headers,
+    })
+    // Include optional fields from backend, notably displayName
+    const data: {
+      valid?: boolean
+      normalizedId?: string
+      displayName?: string
+    } = await resp.json().catch(() => ({}) as any)
+
+    if (resp.ok && data.valid) {
+      // Delete inline console logging here to centralize in caller
+      return data.displayName
+    }
+
+    if (resp.ok && !data.valid) {
+      console.error(red(`\nUnknown agent: ${bold(agent)}. Exiting.`))
+      process.exit(1)
+    }
+  } catch {
+    console.error(
+      yellow(
+        `\nCould not validate agent due to a network error. Proceeding...`,
+      ),
+    )
+  } finally {
+    Spinner.get().stop()
+  }
+  return undefined
+}
+
 const PROMPT_HISTORY_PATH = path.join(CONFIG_DIR, 'prompt_history.json')
 
 // Paste detection constants
@@ -631,10 +700,16 @@ export class CLI {
     } else {
       // Normal interactive mode
       if (client.user) {
-        displayGreeting(this.costMode, client.user.name)
+        // Validate agent and display name before greeting if agent is specified
+        if (this.agent) {
+          const agents = await loadLocalAgents({ verbose: false })
+          const resolvedName = await validateAgent(this.agent, agents)
+          if (resolvedName) {
+            console.log(green(`\nAgent: ${bold(resolvedName)}`))
+          }
+        }
 
-        // Agent name will be displayed by validateAgent when resolved
-        // No need to display here to avoid race conditions
+        displayGreeting(this.costMode, client.user.name)
       } else {
         console.log(
           `Welcome to Codebuff! Give us a sec to get your account set up...`,

npm-app/src/index.ts

@@ -25,66 +25,11 @@ import { logAndHandleStartup } from './startup-process-handler'
 import { recreateShell } from './terminal/run-command'
 import { validateAgentDefinitionsIfAuthenticated } from './utils/agent-validation'
 import { initAnalytics, trackEvent } from './utils/analytics'
-import { createAuthHeaders } from './utils/auth-headers'
 import { logger } from './utils/logger'
-import { Spinner } from './utils/spinner'
 
 import type { CliOptions } from './types'
 
-export async function validateAgent(
-  agent: string,
-  localAgents?: Record<string, any>,
-): Promise<string | undefined> {
-  const agents = localAgents ?? {}
 
-  // if local agents are loaded, they're already validated
-  if (
-    !!agents?.[agent] ||
-    !!Object.values(agents ?? {}).find((a: any) => a?.displayName === agent)
-  )
-    return
-
-  Spinner.get().start('Checking agent...')
-  try {
-    const url = `${backendUrl}/api/agents/validate-name?agentId=${encodeURIComponent(agent)}`
-
-    // Use helper to create headers with x-codebuff-api-key
-    const headers = createAuthHeaders()
-
-    const resp = await fetch(url, {
-      method: 'GET',
-      headers,
-    })
-    // Include optional fields from backend, notably displayName
-    const data: {
-      valid?: boolean
-      normalizedId?: string
-      displayName?: string
-    } = await resp.json().catch(() => ({}) as any)
-
-    if (resp.ok && data.valid) {
-      // Console log the agent name immediately when resolved
-      if (data.displayName) {
-        console.log(green(`\nAgent: ${bold(data.displayName)}`))
-      }
-      return data.displayName
-    }
-
-    if (resp.ok && !data.valid) {
-      console.error(red(`\nUnknown agent: ${bold(agent)}. Exiting.`))
-      process.exit(1)
-    }
-  } catch {
-    console.error(
-      yellow(
-        `\nCould not validate agent due to a network error. Proceeding...`,
-      ),
-    )
-  } finally {
-    Spinner.get().stop()
-  }
-  return undefined
-}
 
 async function codebuff({
   initialInput,
@@ -111,19 +56,16 @@ async function codebuff({
 
   const initFileContextPromise = initProjectFileContextWithWorker(projectRoot)
 
-  // Ensure validation runs strictly after local agent load/display
+  // Load agents and validate definitions
   const loadAndValidatePromise: Promise<void> = loadLocalAgents({
     verbose: true,
-  }).then(async (agents) => {
+  }).then((agents) => {
     validateAgentDefinitionsIfAuthenticated(Object.values(agents))
 
     const codebuffConfig = loadCodebuffConfig()
     if (!agent) {
       displayLoadedAgents(codebuffConfig)
-      return
     }
-
-    await validateAgent(agent, agents)
   })
 
   const readyPromise = Promise.all([