@alumbwe/anvil 1.0.19 → 1.0.20

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/anvil-instance-owner.ts

@@ -0,0 +1,66 @@
+import fs from 'fs'
+import path from 'path'
+
+import { getConfigDir } from './auth'
+import { logger } from './logger'
+
+interface AnvilInstanceOwner {
+  instanceId: string
+  pid: number
+}
+
+const OWNER_FILE = 'anvil-instance-owner.json'
+
+const getOwnerPath = (): string => path.join(getConfigDir(), OWNER_FILE)
+
+function readOwner(): AnvilInstanceOwner | null {
+  try {
+    const raw = fs.readFileSync(getOwnerPath(), 'utf8')
+    const parsed = JSON.parse(raw) as Partial<AnvilInstanceOwner>
+    if (
+      typeof parsed.instanceId !== 'string' ||
+      typeof parsed.pid !== 'number'
+    ) {
+      return null
+    }
+    return {
+      instanceId: parsed.instanceId,
+      pid: parsed.pid,
+    }
+  } catch {
+    return null
+  }
+}
+
+function isProcessRunning(pid: number): boolean {
+  if (!Number.isInteger(pid) || pid <= 0) return false
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === 'EPERM'
+  }
+}
+
+export function recordAnvilInstanceOwner(instanceId: string): void {
+  try {
+    fs.mkdirSync(getConfigDir(), { recursive: true })
+    fs.writeFileSync(
+      getOwnerPath(),
+      JSON.stringify({ instanceId, pid: process.pid }, null, 2),
+    )
+  } catch (error) {
+    logger.debug(
+      { error: error instanceof Error ? error.message : String(error) },
+      '[anvil-session] Failed to record local owner',
+    )
+  }
+}
+
+export function isAnvilInstanceOwnedByDeadLocalProcess(
+  instanceId: string,
+): boolean {
+  const owner = readOwner()
+  if (!owner || owner.instanceId !== instanceId) return false
+  return !isProcessRunning(owner.pid)
+}

package/src/utils/anvil-model-navigation.ts

@@ -0,0 +1,50 @@
+export type AnvilModelNavigationDirection = 'forward' | 'backward'
+
+const FORWARD_KEY_NAMES = new Set(['right', 'down'])
+const BACKWARD_KEY_NAMES = new Set(['left', 'up'])
+const FORWARD_TAB_SEQUENCES = new Set(['\t', '\x1b[9u'])
+const BACKWARD_TAB_SEQUENCES = new Set([
+  '\x1b[Z',
+  '\x1b[9;2u',
+  '\x1b[27;2;9~',
+])
+
+export function nextAnvilModelId(params: {
+  modelIds: readonly string[]
+  focusedId: string
+  direction: AnvilModelNavigationDirection
+}): string | null {
+  const { modelIds, focusedId, direction } = params
+  if (modelIds.length === 0) return null
+
+  const currentIdx = modelIds.indexOf(focusedId)
+  if (currentIdx === -1) return modelIds[0] ?? null
+
+  const step = direction === 'forward' ? 1 : -1
+  return modelIds[(currentIdx + step + modelIds.length) % modelIds.length]
+}
+
+export function anvilModelNavigationDirectionForKey(key: {
+  name?: string
+  shift?: boolean
+  sequence?: string
+  raw?: string
+}): AnvilModelNavigationDirection | null {
+  const name = (key.name ?? '').toLowerCase()
+  const sequence = key.sequence ?? key.raw ?? ''
+
+  if (FORWARD_KEY_NAMES.has(name)) return 'forward'
+  if (BACKWARD_KEY_NAMES.has(name)) return 'backward'
+
+  if (
+    (name === 'tab' && Boolean(key.shift)) ||
+    BACKWARD_TAB_SEQUENCES.has(sequence)
+  ) {
+    return 'backward'
+  }
+  if (name === 'tab' || FORWARD_TAB_SEQUENCES.has(sequence)) {
+    return 'forward'
+  }
+
+  return null
+}

package/src/utils/anvil-premium-reset.ts

@@ -0,0 +1,55 @@
+import { ANVIL_PREMIUM_SESSION_RESET_TIMEZONE } from '@anvil/common/constants/anvil-models'
+import { getZonedDayBounds } from '@anvil/common/util/zoned-time'
+
+import type { AnvilSessionRateLimitByModel } from '@anvil/common/types/anvil-session'
+
+export function getAnvilPremiumResetAt(params: {
+  rateLimitsByModel?: AnvilSessionRateLimitByModel
+  nowMs: number
+}): Date {
+  const { rateLimitsByModel, nowMs } = params
+  const serverResetAt = rateLimitsByModel
+    ? Object.values(rateLimitsByModel)[0]?.resetAt
+    : undefined
+  const parsedServerResetAt = serverResetAt ? new Date(serverResetAt) : null
+
+  if (
+    parsedServerResetAt &&
+    Number.isFinite(parsedServerResetAt.getTime())
+  ) {
+    return parsedServerResetAt
+  }
+
+  return getZonedDayBounds(
+    new Date(nowMs),
+    ANVIL_PREMIUM_SESSION_RESET_TIMEZONE,
+  ).resetsAt
+}
+
+/**
+ * Human "resets in …" countdown. Daily pools stop at hours (`withDays` off);
+ * a multi-day window (e.g. a lapsed reset) sets `withDays` so it reads as "2d 5h"
+ * instead of a 100-hour figure.
+ */
+export function formatAnvilPremiumResetCountdown(
+  resetAt: Date,
+  nowMs: number,
+  { withDays = false }: { withDays?: boolean } = {},
+): string {
+  const diffMs = resetAt.getTime() - nowMs
+  if (!Number.isFinite(diffMs) || diffMs <= 0) return 'now'
+
+  const totalMinutes = Math.max(1, Math.floor(diffMs / 60_000))
+  if (withDays) {
+    const days = Math.floor(totalMinutes / (60 * 24))
+    if (days > 0) {
+      const hours = Math.floor((totalMinutes % (60 * 24)) / 60)
+      return hours === 0 ? `${days}d` : `${days}d ${hours}h`
+    }
+  }
+  const hours = Math.floor(totalMinutes / 60)
+  const minutes = totalMinutes % 60
+
+  if (hours === 0) return `${minutes}m`
+  return minutes === 0 ? `${hours}h` : `${hours}h ${minutes}m`
+}

package/src/utils/anvil-referral-cache.ts

@@ -0,0 +1,51 @@
+import { getReferralInfo } from '@anvil/common/types/anvil-session'
+
+import type { AnvilAccessTier } from '@anvil/common/constants/anvil-models'
+import type { AnvilReferralInfo } from '@anvil/common/types/anvil-session'
+import type { AnvilSessionResponse } from '../types/anvil-session'
+
+/**
+ * Process-wide cache of the most recent referral block the server sent for
+ * each access tier.
+ *
+ * The server only attaches `referral` to `none` (landing) responses — once the
+ * user joins (queued/active) or ends a session (ended) it's dropped from the
+ * payload. That breaks the return-to-landing flow: after a session ends the
+ * slot DELETE leaves an `ended` row, so the landing GET sees `ended` (no
+ * referral) until that row is swept, which would otherwise blank the GLM
+ * referral banner for the whole visit. Caching the last-known block lets the
+ * picker re-render it immediately; a later clean `none` GET refreshes it.
+ */
+let referralByAccessTier: Partial<
+  Record<AnvilAccessTier, AnvilReferralInfo>
+> = {}
+
+/** Remember the referral block whenever a response includes one, so it can be
+ *  carried across the join → end → return-to-landing round-trip. Active/ended
+ *  responses intentionally omit it and keep the prior value; an authoritative
+ *  `none` response without it clears stale metadata for that tier. */
+export function rememberReferral(session: AnvilSessionResponse | null): void {
+  const referral = getReferralInfo(session)
+  const accessTier =
+    session && 'accessTier' in session ? session.accessTier : undefined
+  // Full- and limited-tier referral blocks have different meanings. Never
+  // cache one without the tier needed to interpret it safely.
+  if (!accessTier) return
+  if (referral) {
+    referralByAccessTier[accessTier] = referral
+  } else if (session?.status === 'none') {
+    delete referralByAccessTier[accessTier]
+  }
+}
+
+/** The last referral block seen for this tier, if any. */
+export function getCachedReferral(
+  accessTier: AnvilAccessTier | undefined,
+): AnvilReferralInfo | undefined {
+  return accessTier ? referralByAccessTier[accessTier] : undefined
+}
+
+/** Clear account-scoped referral metadata when its session owner unmounts. */
+export function clearReferralCache(): void {
+  referralByAccessTier = {}
+}

package/src/utils/anvil-session-api.ts

@@ -0,0 +1,243 @@
+import { env } from '@anvil/common/env'
+import {
+  ANVIL_COMPACT_SESSION_HEADER,
+  ANVIL_INSTANCE_HEADER,
+  ANVIL_MODEL_HEADER,
+} from '@anvil/common/constants/anvil-models'
+
+import { useAnvilSessionStore } from '../state/anvil-session-store'
+import { getAuthTokenDetails } from './auth'
+import { IS_ANVIL } from './constants'
+
+import type { AnvilSessionResponse } from '../types/anvil-session'
+import type { AnvilSessionServerResponse } from '@anvil/common/types/anvil-session'
+
+const SESSION_FETCH_TIMEOUT_MS = 20_000
+export type AnvilSessionMethod = 'POST' | 'GET' | 'DELETE'
+
+export class AnvilSessionRequestError extends Error {
+  constructor(
+    message: string,
+    readonly statusCode: number,
+    readonly retryAfterMs?: number,
+    readonly errorCode?: string,
+  ) {
+    super(message)
+    this.name = 'AnvilSessionRequestError'
+  }
+}
+
+export function isAnvilSessionTimeoutError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    (error.name === 'TimeoutError' || /timeout|timed out/i.test(error.message))
+  )
+}
+
+export type AnvilSessionFailureDisposition = 'retry' | 'stop' | 'unknown'
+
+/** How the poll loop should handle a failed request.
+ *
+ * A POST without a response may already have rotated the active instance, so
+ * repeating it is unsafe without protocol-level idempotency. HTTP 408, 429,
+ * and 503 responses are the exception: edge rejection or admission shedding
+ * produces them before the session mutation can commit. GET is read-only and
+ * can retry transient failures normally. */
+export function classifyAnvilSessionRequestFailure(
+  method: Extract<AnvilSessionMethod, 'POST' | 'GET'>,
+  error: unknown,
+): AnvilSessionFailureDisposition {
+  if (method === 'POST') {
+    if (!(error instanceof AnvilSessionRequestError)) return 'unknown'
+    // These responses are produced before the session mutation can commit:
+    // 408/429 come from an edge or unparsed response (the endpoint's typed
+    // rate-limit responses are returned above), and a 503 means no handler was
+    // available or admission shed the request. Retrying them cannot repeat a
+    // successful takeover.
+    if ([408, 429, 503].includes(error.statusCode)) {
+      return 'retry'
+    }
+    return error.statusCode >= 400 && error.statusCode < 500
+      ? 'stop'
+      : 'unknown'
+  }
+
+  if (!(error instanceof AnvilSessionRequestError)) return 'retry'
+  return error.statusCode === 408 ||
+    error.statusCode === 429 ||
+    error.statusCode >= 500
+    ? 'retry'
+    : 'stop'
+}
+
+export function parseRetryAfterMs(
+  value: string | null,
+  nowMs = Date.now(),
+): number | undefined {
+  if (!value) return undefined
+  const seconds = Number(value)
+  if (Number.isFinite(seconds) && seconds >= 0) {
+    const milliseconds = seconds * 1_000
+    return Number.isFinite(milliseconds) ? Math.ceil(milliseconds) : undefined
+  }
+  const dateMs = Date.parse(value)
+  return Number.isFinite(dateMs) ? Math.max(0, dateMs - nowMs) : undefined
+}
+
+/** Combine the caller's abort signal with a per-request timeout. */
+export function sessionFetchSignal(
+  signal: AbortSignal | undefined,
+  timeoutMs: number = SESSION_FETCH_TIMEOUT_MS,
+): AbortSignal {
+  const timeout = AbortSignal.timeout(timeoutMs)
+  return signal ? AbortSignal.any([signal, timeout]) : timeout
+}
+
+function sessionEndpoint(): string {
+  const base = (
+    env.NEXT_PUBLIC_ANVIL_APP_URL || 'https://codebuff.com'
+  ).replace(/\/$/, '')
+  return `${base}/api/v1/anvil/session`
+}
+
+export async function callAnvilSession(
+  method: AnvilSessionMethod,
+  token: string,
+  opts: {
+    instanceId?: string
+    model?: string
+    signal?: AbortSignal
+    compact?: boolean
+  } = {},
+): Promise<AnvilSessionServerResponse> {
+  const headers: Record<string, string> = { Authorization: `Bearer ${token}` }
+  if (method === 'GET' && opts.instanceId) {
+    headers[ANVIL_INSTANCE_HEADER] = opts.instanceId
+  }
+  if (method === 'GET' && opts.compact) {
+    headers[ANVIL_COMPACT_SESSION_HEADER] = '1'
+  }
+  if (method === 'POST' && opts.model) {
+    headers[ANVIL_MODEL_HEADER] = opts.model
+  }
+
+  const response = await fetch(sessionEndpoint(), {
+    method,
+    headers,
+    signal: sessionFetchSignal(opts.signal),
+  })
+
+  if (response.status === 404) {
+    return { status: 'none' }
+  }
+
+  if (response.status === 403) {
+    const body = (await response
+      .json()
+      .catch(() => null)) as AnvilSessionServerResponse | null
+    if (
+      body &&
+      (body.status === 'country_blocked' || body.status === 'banned')
+    ) {
+      return body
+    }
+  }
+
+  if (response.status === 409 && method === 'POST') {
+    const body = (await response
+      .json()
+      .catch(() => null)) as AnvilSessionServerResponse | null
+    if (
+      body &&
+      (body.status === 'model_locked' || body.status === 'model_unavailable')
+    ) {
+      return body
+    }
+  }
+
+  if (response.status === 429 && method === 'POST') {
+    const body = (await response
+      .json()
+      .catch(() => null)) as AnvilSessionServerResponse | null
+    if (
+      body &&
+      (body.status === 'rate_limited' ||
+        body.status === 'spend_limited' ||
+        body.status === 'ip_capped')
+    ) {
+      return body
+    }
+  }
+
+  if (!response.ok) {
+    const text = await response.text().catch(() => '')
+    let errorCode: string | undefined
+    try {
+      const body = JSON.parse(text) as { error?: unknown }
+      if (typeof body.error === 'string') errorCode = body.error
+    } catch {
+      // Non-JSON errors have no machine-readable code.
+    }
+    throw new AnvilSessionRequestError(
+      `anvil session ${method} failed: ${response.status} ${text.slice(0, 200)}`,
+      response.status,
+      parseRetryAfterMs(response.headers.get('retry-after')),
+      errorCode,
+    )
+  }
+
+  return (await response.json()) as AnvilSessionServerResponse
+}
+
+/** A compact poll omits quota fields that were already returned by admission.
+ * Keep that snapshot only for the same active session; null tells the poller
+ * to fetch one full response before compacting again. */
+export function mergeCompactActiveSession(
+  current: AnvilSessionResponse | null,
+  next: AnvilSessionServerResponse,
+): AnvilSessionServerResponse | null {
+  if (
+    current?.status !== 'active' ||
+    next.status !== 'active' ||
+    current.instanceId !== next.instanceId ||
+    current.model !== next.model
+  ) {
+    return null
+  }
+  return {
+    ...next,
+    rateLimit: next.rateLimit ?? current.rateLimit,
+    rateLimitsByModel: next.rateLimitsByModel ?? current.rateLimitsByModel,
+  }
+}
+
+export function holdsLiveAnvilSlot(
+  current: AnvilSessionResponse | null,
+): boolean {
+  if (!current) return false
+  return (
+    current.status === 'active' ||
+    (current.status === 'ended' && Boolean(current.instanceId))
+  )
+}
+
+/** Best-effort DELETE of the caller's session row when it holds a live slot. */
+export async function releaseAnvilSlot(): Promise<void> {
+  const current = useAnvilSessionStore.getState().session
+  if (!holdsLiveAnvilSlot(current)) return
+
+  const { token } = getAuthTokenDetails()
+  if (!token) return
+
+  try {
+    await callAnvilSession('DELETE', token)
+  } catch {
+    // The server-side sweep is the backstop.
+  }
+}
+
+/** Release the Anvil slot on exit paths that skip React unmount. */
+export async function endAnvilSessionBestEffort(): Promise<void> {
+  if (!IS_ANVIL) return
+  await releaseAnvilSlot()
+}

package/src/utils/anvil-session-display.ts

@@ -0,0 +1,21 @@
+export const ANVIL_COUNTDOWN_VISIBLE_MS = 5 * 60_000
+
+export const formatAnvilSessionCountdown = (ms: number): string => {
+  if (ms <= 0) return 'expiring…'
+  const totalSeconds = Math.ceil(ms / 1000)
+  const m = Math.floor(totalSeconds / 60)
+  const s = totalSeconds % 60
+  return `${m}:${s.toString().padStart(2, '0')}`
+}
+
+export const formatAnvilSessionRemaining = (ms: number): string => {
+  if (ms <= 0) return 'expiring…'
+  if (ms < ANVIL_COUNTDOWN_VISIBLE_MS) {
+    return `${formatAnvilSessionCountdown(ms)} left`
+  }
+  const totalMinutes = Math.ceil(ms / 60_000)
+  if (totalMinutes < 60) return `${totalMinutes}m left`
+  const hours = Math.floor(totalMinutes / 60)
+  const minutes = totalMinutes % 60
+  return minutes === 0 ? `${hours}h left` : `${hours}h ${minutes}m left`
+}