@alumbwe/anvil 1.0.0

package/src/utils/anvil-client.ts

@@ -0,0 +1,217 @@
+import { API_KEY_ENV_VAR } from '@anvil/common/old-constants'
+import { AskUserBridge } from '@anvil/common/utils/ask-user-bridge'
+import { AnvilClient } from '@anvil/sdk'
+
+import { getAuthTokenDetails } from './auth'
+import { getCliEnv, getSystemProcessEnv } from './env'
+import { loadAgentDefinitions } from './local-agent-registry'
+import { logger } from './logger'
+import { createTraceWriter } from './trace-writer'
+import { terminalCommandBroker } from './terminal-command-broker'
+import { getRgPath } from '../native/ripgrep'
+import { getProjectRoot } from '../project-files'
+
+import type { ClientToolCall } from '@anvil/common/tools/list'
+
+let clientInstance: AnvilClient | null = null
+
+/**
+ * Recursively removes undefined values from an object to ensure clean JSON serialization.
+ * This prevents issues with APIs that don't accept explicit undefined values.
+ */
+function removeUndefinedValues<T>(obj: T): T {
+  if (obj === null || obj === undefined) {
+    return obj
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(removeUndefinedValues) as T
+  }
+  if (typeof obj === 'object') {
+    const result: Record<string, unknown> = {}
+    for (const [key, value] of Object.entries(obj)) {
+      if (value !== undefined) {
+        result[key] = removeUndefinedValues(value)
+      }
+    }
+    return result as T
+  }
+  return obj
+}
+
+/**
+ * Reset the cached AnvilClient instance.
+ * This should be called after login to ensure the client is re-initialized with new credentials.
+ */
+export function resetAnvilClient(): void {
+  clientInstance = null
+}
+
+export async function getAnvilClient(): Promise<AnvilClient | null> {
+  if (!clientInstance) {
+    const { token: apiKey } = getAuthTokenDetails()
+
+    if (!apiKey) {
+      logger.warn(
+        {},
+        `No authentication token found. Please run the login flow or set ${API_KEY_ENV_VAR}.`,
+      )
+      return null
+    }
+
+    const projectRoot = getProjectRoot()
+
+    // Set up ripgrep path for SDK to use
+    const env = getCliEnv()
+    if (env.ANVIL_IS_BINARY) {
+      try {
+        const rgPath = await getRgPath()
+        // Note: We still set process.env here because SDK reads from it
+        getSystemProcessEnv().ANVIL_RG_PATH = rgPath
+      } catch (error) {
+        logger.error(error, 'Failed to set up ripgrep binary for SDK')
+      }
+    }
+
+    try {
+      const agentDefinitions = loadAgentDefinitions()
+      clientInstance = new AnvilClient({
+        apiKey,
+        cwd: projectRoot,
+        agentDefinitions,
+        logger,
+        traceWriter: createTraceWriter(),
+        terminalCommandBroker,
+        overrideTools: {
+          ask_user: async (input: ClientToolCall<'ask_user'>['input']) => {
+            const askUserResponse = await AskUserBridge.request(
+              'cli-override',
+              input.questions,
+            )
+            const response = askUserResponse as {
+              answers?: Array<{ questionIndex: number; selectedOption: string }>
+              skipped?: boolean
+            }
+            return [
+              {
+                type: 'json',
+                value: removeUndefinedValues(response),
+              },
+            ]
+          },
+        },
+      })
+    } catch (error) {
+      logger.error(error, 'Failed to initialize AnvilClient')
+      return null
+    }
+  }
+
+  return clientInstance
+}
+
+export function getToolDisplayInfo(toolName: string): {
+  name: string
+  type: string
+} {
+  const TOOL_NAME_OVERRIDES: Record<string, string> = {
+    list_directory: 'List Directories',
+  }
+
+  const capitalizeWords = (str: string) => {
+    return str.replace(/_/g, ' ').replace(/\b\w/g, (l) => l.toUpperCase())
+  }
+
+  return {
+    name: TOOL_NAME_OVERRIDES[toolName] ?? capitalizeWords(toolName),
+    type: 'tool',
+  }
+}
+
+function toYaml(obj: any, indent = 0): string {
+  const spaces = '  '.repeat(indent)
+
+  if (obj === null || obj === undefined) {
+    return 'null'
+  }
+
+  if (typeof obj === 'string') {
+    if (obj.includes('\n')) {
+      const lines = obj.split('\n')
+      return (
+        '|\n' + lines.map((line) => '  '.repeat(indent + 1) + line).join('\n')
+      )
+    }
+    return obj.includes(':') || obj.includes('#') ? `"${obj}"` : obj
+  }
+
+  if (typeof obj === 'number' || typeof obj === 'boolean') {
+    return String(obj)
+  }
+
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) return '[]'
+    return (
+      '\n' +
+      obj
+        .map((item) => spaces + '- ' + toYaml(item, indent + 1).trimStart())
+        .join('\n')
+    )
+  }
+
+  if (typeof obj === 'object') {
+    const entries = Object.entries(obj)
+    if (entries.length === 0) return '{}'
+
+    return entries
+      .map(([key, value]) => {
+        const yamlValue = toYaml(value, indent + 1)
+        if (
+          typeof value === 'object' &&
+          value !== null &&
+          !Array.isArray(value) &&
+          Object.keys(value).length > 0
+        ) {
+          return `${spaces}${key}:\n${yamlValue}`
+        }
+        if (typeof value === 'string' && value.includes('\n')) {
+          return `${spaces}${key}: ${yamlValue}`
+        }
+        return `${spaces}${key}: ${yamlValue}`
+      })
+      .join('\n')
+  }
+
+  return String(obj)
+}
+
+export function formatToolOutput(output: unknown): string {
+  if (!output) return ''
+
+  if (Array.isArray(output)) {
+    return output
+      .map((item) => {
+        if (item.type === 'json') {
+          // Handle errorMessage in the value object
+          if (
+            item.value &&
+            typeof item.value === 'object' &&
+            'errorMessage' in item.value
+          ) {
+            return String(item.value.errorMessage)
+          }
+          return toYaml(item.value)
+        }
+        if (item.type === 'text') {
+          return item.text || ''
+        }
+        return String(item)
+      })
+      .join('\n')
+  }
+
+  if (typeof output === 'string') {
+    return output
+  }
+
+  return toYaml(output)
+}

package/src/utils/arrays.ts

@@ -0,0 +1,117 @@
+/** Python-style range function */
+export function* range(start: number, stop?: number, step: number = 1) {
+  if (stop === undefined) {
+    stop = start
+    start = 0
+  }
+
+  if (step === 0) {
+    throw new Error('Step cannot be zero')
+  }
+
+  if (step > 0) {
+    for (let i = start; i < stop; i += step) {
+      yield i
+    }
+  } else {
+    for (let i = start; i > stop; i += step) {
+      yield i
+    }
+  }
+}
+
+export function repeated<T>(value: T, count: number): T[] {
+  return Array.from({ length: count }, () => value)
+}
+
+export class Queue<T> {
+  private _items: T[]
+  private _head: number
+  private _length: number
+  private _defaultCapacity: number
+
+  constructor(items: T[] | undefined = undefined, capacity: number = 100) {
+    this._defaultCapacity = capacity
+    if (!items) {
+      items = []
+    }
+    this._items = items.length
+      ? [
+          ...items,
+          ...repeated(undefined as T, Math.max(0, capacity - items.length)),
+        ]
+      : [undefined as T]
+    this._head = 0
+    this._length = items.length
+  }
+
+  static from<T>(iterable: Iterable<T>): Queue<T> {
+    return new Queue<T>([...iterable])
+  }
+
+  enqueue(...items: T[]) {
+    if (this._items.length < this._length + items.length) {
+      const newItems = [
+        ...repeated(undefined as T, this._length),
+        ...items,
+        ...repeated(undefined as T, this._length),
+      ]
+      for (let i = 0; i < this._length; i++) {
+        newItems[i] = this.at(i)!
+      }
+
+      this._items = newItems
+      this._head = 0
+      this._length += items.length
+      return
+    }
+
+    let index = (this._head + this._length) % this._items.length
+    for (const item of items) {
+      this._items[index] = item
+      index = (index + 1) % this._items.length
+    }
+    this._length += items.length
+  }
+
+  dequeue(): T | undefined {
+    if (this._length === 0) {
+      return undefined
+    }
+
+    const item = this._items[this._head]
+    this._items[this._head] = undefined as T
+    this._head = (this._head + 1) % this._items.length
+    this._length--
+    return item
+  }
+
+  peek(): T | undefined {
+    if (this._length === 0) {
+      return undefined
+    }
+    return this._items[this._head]
+  }
+
+  at(index: number): T | undefined {
+    if (index >= this._length || index < -this.length) {
+      return undefined
+    }
+    if (index < 0) {
+      return this._items[
+        (this._head + this._length + index) % this._items.length
+      ]
+    }
+    return this._items[(this._head + index) % this._items.length]
+  }
+
+  clear(): void {
+    this._items = repeated(undefined as T, this._defaultCapacity)
+    this._head = 0
+    this._length = 0
+  }
+
+  get length() {
+    return this._length
+  }
+}

package/src/utils/auth.ts

@@ -0,0 +1,258 @@
+import fs from 'fs'
+import path from 'path'
+
+import { getCiEnv } from '@anvil/common/env-ci'
+import { getDirectDeepSeekApiKey } from '@anvil/common/constants/deepseek-direct'
+import { z } from 'zod'
+
+
+import { getApiClient, setApiClientAuthToken } from './anvil-api'
+import { getConfigDir as getConfigDirBase } from './config-dir'
+import { logger } from './logger'
+
+import type { CiEnv } from '@anvil/common/types/contracts/env'
+
+// User schema
+const userSchema = z.object({
+  id: z.string().optional(),
+  name: z.string(),
+  email: z.string(),
+  authToken: z.string(),
+  fingerprintId: z.string().optional(),
+  fingerprintHash: z.string().optional(),
+  credits: z.number().optional(),
+})
+
+export type User = z.infer<typeof userSchema>
+
+const credentialsSchema = z
+  .object({
+    default: userSchema.optional(),
+  })
+  .catchall(z.unknown())
+
+// Get the config directory path.
+// Re-exported as a wrapper (rather than a bare `export ... from`) so existing
+// tests can still `spyOn(authModule, 'getConfigDir')`.
+export const getConfigDir = (): string => getConfigDirBase()
+
+// Get the credentials file path
+export const getCredentialsPath = (): string => {
+  return path.join(getConfigDir(), 'credentials.json')
+}
+
+/**
+ * Parse user from JSON string
+ */
+const userFromJson = (
+  json: string,
+  profileName: string = 'default',
+): User | undefined => {
+  try {
+    const allCredentials = credentialsSchema.parse(JSON.parse(json))
+    const profile = allCredentials[profileName]
+    // Validate that the profile matches the user schema
+    const parsed = userSchema.safeParse(profile)
+    return parsed.success ? parsed.data : undefined
+  } catch (error) {
+    logger.error(
+      {
+        errorMessage: error instanceof Error ? error.message : String(error),
+        errorStack: error instanceof Error ? error.stack : undefined,
+        profileName,
+      },
+      'Error parsing user JSON',
+    )
+    return
+  }
+}
+
+/**
+ * Get user credentials from file system
+ * @returns User object or null if not found/authenticated
+ */
+export const getUserCredentials = (): User | null => {
+  const credentialsPath = getCredentialsPath()
+
+  // Read user credentials directly from file
+  if (!fs.existsSync(credentialsPath)) {
+    return null
+  }
+
+  try {
+    const credentialsFile = fs.readFileSync(credentialsPath, 'utf8')
+    const user = userFromJson(credentialsFile)
+    return user || null
+  } catch (error) {
+    logger.error(
+      {
+        error: error instanceof Error ? error.message : String(error),
+      },
+      'Error reading credentials',
+    )
+    return null
+  }
+}
+
+export type AuthTokenSource = 'credentials' | 'environment' | null
+
+export interface AuthTokenDetails {
+  token?: string
+  source: AuthTokenSource
+}
+
+/**
+ * Resolve the auth token and track where it came from.
+ */
+export const getAuthTokenDetails = (
+  ciEnv: CiEnv = getCiEnv(),
+): AuthTokenDetails => {
+  const userCredentials = getUserCredentials()
+  if (userCredentials?.authToken) {
+    return { token: userCredentials.authToken, source: 'credentials' }
+  }
+
+  const envToken = ciEnv.ANVIL_API_KEY
+  if (envToken) {
+    return { token: envToken, source: 'environment' }
+  }
+
+  // Direct-to-DeepSeek mode: the DeepSeek key doubles as the auth token so
+  // the CLI treats the user as authenticated without a Anvil backend.
+  const deepseekToken = getDirectDeepSeekApiKey()
+  if (deepseekToken) {
+    return { token: deepseekToken, source: 'environment' }
+  }
+
+  return { source: null }
+}
+
+/**
+ * Get the auth token from user credentials or environment variable
+ */
+export const getAuthToken = (): string | undefined => {
+  return getAuthTokenDetails().token
+}
+
+/**
+ * Check if the user has authentication credentials (but doesn't validate them)
+ */
+export const hasAuthCredentials = (): boolean => {
+  return !!getAuthTokenDetails().token
+}
+
+export interface AuthValidationResult {
+  authenticated: boolean
+  hasInvalidCredentials: boolean
+}
+
+/**
+ * Read existing credentials file, returns empty object if missing/invalid.
+ *
+ * Drops `chatgptOAuth`, which the removed ChatGPT integration wrote. Both
+ * callers spread this result straight back over the file, so the dead key —
+ * an OAuth access and refresh token for the user's ChatGPT account — is
+ * cleaned up the next time we write for any reason. Doing it here rather than
+ * in a startup pass means no extra write and no new race with login/logout;
+ * nothing reads the key anymore, and with /connect gone the user has no way
+ * to clear it themselves.
+ */
+const readCredentialsFile = (): Record<string, unknown> => {
+  const credentialsPath = getCredentialsPath()
+  if (!fs.existsSync(credentialsPath)) return {}
+  try {
+    const { chatgptOAuth: _removedIntegration, ...rest } = JSON.parse(
+      fs.readFileSync(credentialsPath, 'utf8'),
+    )
+    return rest
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * Save user credentials to file system.
+ */
+export const saveUserCredentials = (user: User): void => {
+  const configDir = getConfigDir()
+  const credentialsPath = getCredentialsPath()
+
+  try {
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true })
+    }
+
+    const updatedData = { ...readCredentialsFile(), default: user }
+    fs.writeFileSync(credentialsPath, JSON.stringify(updatedData, null, 2))
+  } catch (error) {
+    logger.error(
+      {
+        error: error instanceof Error ? error.message : String(error),
+      },
+      'Error saving credentials',
+    )
+    throw error
+  }
+}
+
+/**
+ * Clear user credentials from file system.
+ * Only removes the 'default' field, preserving other credentials.
+ */
+export const clearUserCredentials = (): void => {
+  const credentialsPath = getCredentialsPath()
+
+  try {
+    if (!fs.existsSync(credentialsPath)) return
+
+    const { default: _, ...rest } = readCredentialsFile()
+
+    if (Object.keys(rest).length === 0) {
+      fs.unlinkSync(credentialsPath)
+    } else {
+      fs.writeFileSync(credentialsPath, JSON.stringify(rest, null, 2))
+    }
+  } catch (error) {
+    logger.error(
+      {
+        error: error instanceof Error ? error.message : String(error),
+      },
+      'Error clearing credentials',
+    )
+    throw error
+  }
+}
+
+export async function logoutUser(): Promise<boolean> {
+  try {
+    const user = getUserCredentials()
+    if (user?.authToken) {
+      setApiClientAuthToken(user.authToken)
+      const apiClient = getApiClient()
+      try {
+        const response = await apiClient.logout({
+          userId: user.id,
+          fingerprintId: user.fingerprintId,
+          fingerprintHash: user.fingerprintHash,
+        })
+        if (!response.ok) {
+          logger.error(
+            { status: response.status, error: response.error },
+            'Logout request failed',
+          )
+        }
+      } catch (err) {
+        logger.error(err, 'Logout request error')
+      }
+    }
+  } catch (error) {
+    logger.error(error, 'Unexpected error preparing logout')
+  }
+
+  try {
+    clearUserCredentials()
+  } catch (error) {
+    logger.debug({ error }, 'Failed to clear credentials during logout')
+  }
+  return true
+}

package/src/utils/bash-context-processor.ts

@@ -0,0 +1,47 @@
+import {
+  buildBashHistoryMessages,
+  createRunTerminalToolResult,
+  formatBashContextForPrompt,
+} from './bash-messages'
+
+import type { PendingBashMessage } from '../types/store'
+import type { ChatMessage } from '../types/chat'
+
+// Turns pending bash executions into chat history messages and prompt context.
+export const processBashContext = (
+  pendingBashMessages: PendingBashMessage[],
+): {
+  bashMessages: ChatMessage[]
+  bashContextForPrompt: string
+} => {
+  const bashContextForPrompt = formatBashContextForPrompt(pendingBashMessages)
+  const bashMessages: ChatMessage[] = []
+
+  for (const bash of pendingBashMessages) {
+    if (bash.addedToHistory) {
+      continue
+    }
+
+    const toolCallId = crypto.randomUUID()
+    const cwd = bash.cwd || process.cwd()
+    const toolResultOutput = createRunTerminalToolResult({
+      command: bash.command,
+      cwd,
+      stdout: bash.stdout || null,
+      stderr: bash.stderr || null,
+      exitCode: bash.exitCode,
+    })
+    const outputJson = JSON.stringify(toolResultOutput)
+    const { assistantMessage } = buildBashHistoryMessages({
+      command: bash.command,
+      cwd,
+      toolCallId,
+      output: outputJson,
+      isComplete: true,
+    })
+
+    bashMessages.push(assistantMessage)
+  }
+
+  return { bashMessages, bashContextForPrompt }
+}