@alumbwe/anvil 1.0.0

package/src/login/constants.ts

@@ -0,0 +1,60 @@
+import { FREEBUFF_WEB_URL_PROD } from '@anvil/common/constants/hosts'
+import { env, IS_DEV } from '@anvil/common/env'
+
+import { IS_FREEBUFF } from '../utils/constants'
+
+// Get the website URL from environment or use default
+export const WEBSITE_URL = env.NEXT_PUBLIC_ANVIL_APP_URL
+
+// Freebuff login flow uses the freebuff web app instead of codebuff.com
+const FREEBUFF_WEB_URL = IS_DEV
+  ? 'http://localhost:3002'
+  : (env.NEXT_PUBLIC_FREEBUFF_APP_URL ?? FREEBUFF_WEB_URL_PROD)
+export const LOGIN_WEBSITE_URL = IS_FREEBUFF ? FREEBUFF_WEB_URL : WEBSITE_URL
+
+// Anvil ASCII Logo - ANSI Shadow figlet wordmark, compact version for
+// 80-width terminals. Spells ANVIL in the same block-lettering style as the
+// Codebuff brand mark: box-corners, shadow faces, two-tone (block + accent).
+export const LOGO = `
+ █████╗ ███╗   ██╗██╗   ██╗██╗██╗
+██╔══██╗████╗  ██║██║   ██║██║██║
+███████║██╔██╗ ██║██║   ██║██║██║
+██╔══██║██║╚██╗██║║██╗ ██╔╝██║██║
+██║  ██║██║ ╚████║╚█████╔╝ ██║███████╗
+╚═╝  ╚═╝╚═╝  ╚═══╝ ╚════╝  ╚═╝╚══════╝
+`
+
+export const LOGO_SMALL = `
+ █████╗ ███╗   ██╗██╗   ██╗██╗██╗
+██╔══██╗████╗  ██║██║   ██║██║██║
+███████║██╔██╗ ██║██║   ██║██║██║
+██╔══██║██║╚██╗██║║██╗ ██╔╝██║██║
+██║  ██║██║ ╚████║╚█████╔╝ ██║███████╗
+╚═╝  ╚═╝╚═╝  ╚═══╝ ╚════╝  ╚═╝╚══════╝
+`
+
+// Shadow/border characters that receive the sheen animation effect
+export const SHADOW_CHARS = new Set([
+  '╚',
+  '═',
+  '╝',
+  '║',
+  '╔',
+  '╗',
+  '╠',
+  '╣',
+  '╦',
+  '╩',
+  '╬',
+])
+
+// Modal sizing constants
+export const DEFAULT_TERMINAL_HEIGHT = 24
+export const MODAL_VERTICAL_MARGIN = 2 // Space for top positioning (1) + bottom margin (1)
+export const MAX_MODAL_BASE_HEIGHT = 22 // Maximum height when no warning banner
+export const WARNING_BANNER_HEIGHT = 3 // Height of invalid credentials banner (padding + text + padding)
+
+// Sheen animation constants
+export const SHEEN_WIDTH = 5
+export const SHEEN_STEP = 2 // Advance 2 positions per frame for efficiency
+export const SHEEN_INTERVAL_MS = 150

package/src/login/login-flow.ts

@@ -0,0 +1,204 @@
+import { AnalyticsEvent } from '@anvil/common/constants/analytics-events'
+
+import { createAnvilApiClient } from '../utils/anvil-api'
+
+import type {
+  AnvilApiClient,
+  LoginCodeResponse,
+} from '../utils/anvil-api'
+import type { Logger } from '@anvil/common/types/contracts/logger'
+
+// Re-export for backwards compatibility
+export type LoginUrlResponse = LoginCodeResponse
+
+/**
+ * Which surface initiated the login, recorded on every login-funnel event so
+ * the funnel can be segmented (e.g. modal sign-ins vs. the `login` command).
+ */
+export type LoginVia = 'modal' | 'plain_command'
+
+export interface GenerateLoginUrlDeps {
+  logger: Logger
+  apiClient?: AnvilApiClient
+  /**
+   * Emit a login-funnel analytics event. Injected so login-flow stays a pure,
+   * test-friendly module; callers wire in the real `trackEvent`. Omitted in
+   * tests, where it no-ops.
+   */
+  trackEvent?: (event: AnalyticsEvent, properties?: Record<string, any>) => void
+}
+
+export interface GenerateLoginUrlOptions {
+  baseUrl: string
+  fingerprintId: string
+  via?: LoginVia
+}
+
+export async function generateLoginUrl(
+  deps: GenerateLoginUrlDeps,
+  options: GenerateLoginUrlOptions,
+): Promise<LoginUrlResponse> {
+  const { logger, apiClient: providedApiClient, trackEvent } = deps
+  const { baseUrl, fingerprintId, via } = options
+
+  // A login attempt has begun. This is the top of the login sub-funnel; the
+  // gap between this and a successful `cli.login` is where users are lost.
+  trackEvent?.(AnalyticsEvent.LOGIN_STARTED, { via })
+
+  const apiClient =
+    providedApiClient ??
+    createAnvilApiClient({
+      baseUrl,
+    })
+
+  const response = await apiClient.loginCode({ fingerprintId })
+
+  if (!response.ok) {
+    logger.error(
+      {
+        status: response.status,
+        error: response.error,
+      },
+      '❌ Failed to request login URL',
+    )
+    trackEvent?.(AnalyticsEvent.LOGIN_FAILED, {
+      via,
+      reason: 'url_request',
+      status: response.status,
+    })
+    throw new Error('Failed to get login URL')
+  }
+
+  if (!response.data) {
+    logger.error(
+      { status: response.status },
+      '❌ Empty response from login URL',
+    )
+    trackEvent?.(AnalyticsEvent.LOGIN_FAILED, {
+      via,
+      reason: 'url_empty',
+      status: response.status,
+    })
+    throw new Error('Failed to get login URL')
+  }
+
+  return response.data
+}
+
+interface PollLoginStatusDeps {
+  sleep: (ms: number) => Promise<void>
+  logger: Logger
+  now?: () => number
+  apiClient?: AnvilApiClient
+  trackEvent?: (event: AnalyticsEvent, properties?: Record<string, any>) => void
+}
+
+interface PollLoginStatusOptions {
+  baseUrl: string
+  fingerprintId: string
+  fingerprintHash: string
+  expiresAt: string
+  intervalMs?: number
+  timeoutMs?: number
+  shouldContinue?: () => boolean
+  via?: LoginVia
+}
+
+export type PollLoginStatusResult =
+  | { status: 'success'; user: Record<string, unknown>; attempts: number }
+  | { status: 'timeout' }
+  | { status: 'aborted' }
+
+export async function pollLoginStatus(
+  deps: PollLoginStatusDeps,
+  options: PollLoginStatusOptions,
+): Promise<PollLoginStatusResult> {
+  const { sleep, logger, apiClient: providedApiClient, trackEvent } = deps
+  const {
+    baseUrl,
+    fingerprintId,
+    fingerprintHash,
+    expiresAt,
+    intervalMs = 5000,
+    timeoutMs = 5 * 60 * 1000,
+    shouldContinue,
+    via,
+  } = options
+
+  const now = deps.now ?? Date.now
+  const startTime = now()
+  let attempts = 0
+
+  const apiClient =
+    providedApiClient ??
+    createAnvilApiClient({
+      baseUrl,
+    })
+
+  while (true) {
+    if (shouldContinue && !shouldContinue()) {
+      logger.warn('🛑 Polling aborted by caller')
+      trackEvent?.(AnalyticsEvent.LOGIN_ABORTED, {
+        via,
+        attempts,
+        durationMs: now() - startTime,
+      })
+      return { status: 'aborted' }
+    }
+
+    if (now() - startTime >= timeoutMs) {
+      logger.warn('⌛️ Login polling timed out')
+      trackEvent?.(AnalyticsEvent.LOGIN_TIMEOUT, {
+        via,
+        attempts,
+        durationMs: now() - startTime,
+      })
+      return { status: 'timeout' }
+    }
+
+    attempts += 1
+
+    try {
+      const response = await apiClient.loginStatus({
+        fingerprintId,
+        fingerprintHash,
+        expiresAt,
+      })
+
+      if (!response.ok) {
+        if (response.status !== 401) {
+          logger.warn(
+            {
+              attempts,
+              status: response.status,
+              error: response.error,
+            },
+            '⚠️ Unexpected status while polling',
+          )
+        }
+        await sleep(intervalMs)
+        continue
+      }
+
+      if (response.data?.user && typeof response.data.user === 'object') {
+        return {
+          status: 'success',
+          user: response.data.user as Record<string, unknown>,
+          attempts,
+        }
+      }
+
+      await sleep(intervalMs)
+    } catch (error) {
+      logger.error(
+        {
+          attempts,
+          error: error instanceof Error ? error.message : String(error),
+        },
+        '💥 Network error during login status polling',
+      )
+      await sleep(intervalMs)
+      continue
+    }
+  }
+}

package/src/login/plain-login.ts

@@ -0,0 +1,108 @@
+import { AnalyticsEvent } from '@anvil/common/constants/analytics-events'
+import { cyan, green, red, yellow, bold } from 'picocolors'
+
+import { LOGIN_WEBSITE_URL } from './constants'
+import { generateLoginUrl, pollLoginStatus } from './login-flow'
+import {
+  flushAnalytics,
+  identifyUser,
+  trackEvent,
+} from '../utils/analytics'
+import { saveUserCredentials } from '../utils/auth'
+import { IS_FREEBUFF } from '../utils/constants'
+import { getFingerprintId } from '../utils/fingerprint'
+import { logger } from '../utils/logger'
+
+import type { User } from '../utils/auth'
+
+/**
+ * Plain-text login flow that runs outside the TUI.
+ * Prints the login URL as plain text so the user can select and copy it
+ * using normal terminal text selection (Cmd+C / Ctrl+Shift+C).
+ *
+ * This is the escape hatch for remote/SSH environments where the TUI's
+ * clipboard and browser integration don't work.
+ */
+export async function runPlainLogin(): Promise<void> {
+  const fingerprintId = await getFingerprintId()
+
+  console.log()
+  console.log(bold(IS_FREEBUFF ? 'Freebuff Login' : 'Anvil Login'))
+  console.log()
+  console.log('Generating login URL...')
+
+  let loginData
+  try {
+    loginData = await generateLoginUrl(
+      { logger, trackEvent },
+      { baseUrl: LOGIN_WEBSITE_URL, fingerprintId, via: 'plain_command' },
+    )
+  } catch (error) {
+    console.error(
+      red(
+        `Failed to generate login URL: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      ),
+    )
+    process.exit(1)
+  }
+
+  console.log()
+  console.log('Open this URL in your browser to log in:')
+  console.log()
+  console.log(cyan(loginData.loginUrl))
+  console.log()
+  console.log(yellow('Please open the URL above manually to complete login.'))
+  console.log()
+  console.log('Waiting for login...')
+
+  const sleep = (ms: number) =>
+    new Promise<void>((resolve) => {
+      setTimeout(resolve, ms)
+    })
+
+  const result = await pollLoginStatus(
+    { sleep, logger, trackEvent },
+    {
+      baseUrl: LOGIN_WEBSITE_URL,
+      fingerprintId,
+      fingerprintHash: loginData.fingerprintHash,
+      expiresAt: loginData.expiresAt,
+      via: 'plain_command',
+    },
+  )
+
+  if (result.status === 'success') {
+    const user = result.user as User
+    saveUserCredentials(user)
+
+    // This flow runs outside the TUI and exits immediately, so the React-based
+    // login tracking never runs. Identify + track here (tagged `via`) so these
+    // logins aren't missing from the funnel, then flush before exiting since
+    // process.exit would otherwise drop the buffered PostHog events.
+    if (user.id) {
+      identifyUser(user.id, { email: user.email, freebuff: IS_FREEBUFF })
+      trackEvent(AnalyticsEvent.LOGIN, {
+        userId: user.id,
+        via: 'plain_command',
+        hasEmail: Boolean(user.email),
+        hasName: Boolean(user.name),
+      })
+      await flushAnalytics()
+    }
+
+    console.log()
+    console.log(green(`✓ Logged in as ${user.name} (${user.email})`))
+    console.log()
+    const cliName = IS_FREEBUFF ? 'freebuff' : 'anvil'
+    console.log('You can now run ' + cyan(cliName) + ' to start.')
+    process.exit(0)
+  } else if (result.status === 'timeout') {
+    console.error(red('Login timed out. Please try again.'))
+    process.exit(1)
+  } else {
+    console.error(red('Login was aborted.'))
+    process.exit(1)
+  }
+}

package/src/login/utils.ts

@@ -0,0 +1,183 @@
+/**
+ * Utility functions for the login screen component
+ */
+
+/**
+ * Calculates the relative luminance of a hex color to determine if it's light or dark mode
+ */
+export function isLightModeColor(hexColor: string): boolean {
+  if (!hexColor) return false
+
+  const hex = hexColor.replace('#', '')
+  if (hex.length < 6) {
+    return false
+  }
+
+  const r = parseInt(hex.substring(0, 2), 16)
+  const g = parseInt(hex.substring(2, 4), 16)
+  const b = parseInt(hex.substring(4, 6), 16)
+
+  const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255
+  return luminance > 0.5
+}
+
+/**
+ * Formats a URL for display by wrapping it at logical breakpoints
+ */
+export function formatUrl(url: string, maxWidth?: number): string[] {
+  if (!maxWidth || maxWidth <= 0 || url.length <= maxWidth) {
+    return [url]
+  }
+
+  const lines: string[] = []
+  let remaining = url
+
+  while (remaining.length > 0) {
+    if (remaining.length <= maxWidth) {
+      lines.push(remaining)
+      break
+    }
+
+    // Try to break at a logical point (after /, ?, &, =)
+    let breakPoint = maxWidth
+    for (let i = maxWidth - 1; i > maxWidth - 20 && i > 0; i--) {
+      if (['/', '?', '&', '='].includes(remaining[i])) {
+        breakPoint = i + 1
+        break
+      }
+    }
+
+    lines.push(remaining.substring(0, breakPoint))
+    remaining = remaining.substring(breakPoint)
+  }
+
+  return lines
+}
+
+/**
+ * Determines the color for a character based on its position relative to the sheen
+ * Block characters use blockColor, shadow/border characters animate to accent violet
+ * @param accentColor - The accent color to use for the sheen effect (typically theme.primary)
+ * @param blockColor - The color for solid block characters (white for dark mode, black for light mode)
+ * @param isReversing - Whether the sheen is in the reverse (unfill) phase
+ */
+export function getSheenColor(
+  char: string,
+  charIndex: number,
+  sheenPosition: number,
+  logoColor: string,
+  shadowChars: Set<string>,
+  accentColor: string = '#A78BFA',
+  blockColor: string = '#ffffff',
+  isReversing: boolean = false,
+): string {
+  // Block characters use the specified block color
+  if (char === '█') {
+    return blockColor
+  }
+
+  // Only apply sheen to shadow/border characters
+  if (!shadowChars.has(char)) {
+    return logoColor
+  }
+
+  if (isReversing) {
+    // Reverse phase: characters behind the sheen return to logoColor
+    if (charIndex <= sheenPosition) {
+      return logoColor
+    }
+    // Characters ahead of the sheen stay accent color
+    return accentColor
+  } else {
+    // Forward phase: characters at or behind the sheen get the accent color
+    if (charIndex <= sheenPosition) {
+      return accentColor
+    }
+    // Characters ahead of the sheen remain original color
+    return logoColor
+  }
+}
+
+/**
+ * Parses the logo string into individual lines
+ */
+export function parseLogoLines(logo: string): string[] {
+  return logo.split('\n').filter((line) => line.length > 0)
+}
+
+/**
+ * Calculates responsive layout dimensions based on terminal size
+ */
+export function calculateResponsiveLayout(
+  terminalWidth: number,
+  terminalHeight: number,
+) {
+  // Responsive breakpoints based on terminal height
+  const isVerySmall = terminalHeight < 15 // Minimal UI
+  const isSmall = terminalHeight >= 15 && terminalHeight < 20 // Compact UI
+  const isMedium = terminalHeight >= 20 && terminalHeight < 30 // Standard UI
+  const isLarge = terminalHeight >= 30 // Spacious UI
+
+  // Responsive breakpoints based on terminal width
+  const isNarrow = terminalWidth < 60
+
+  // Dynamic spacing based on terminal size - compressed to prevent scrolling
+  const containerPadding = isVerySmall ? 0 : 1
+  const headerMarginTop = 0
+  const headerMarginBottom = isVerySmall ? 0 : 1
+  const sectionMarginBottom = isVerySmall ? 0 : 1
+  const contentMaxWidth = Math.max(
+    10,
+    Math.min(terminalWidth - (containerPadding * 2 + 4), 80),
+  )
+
+  const maxUrlWidth = Math.min(terminalWidth - 10, 100)
+
+  return {
+    isVerySmall,
+    isSmall,
+    isMedium,
+    isLarge,
+    isNarrow,
+    containerPadding,
+    headerMarginTop,
+    headerMarginBottom,
+    sectionMarginBottom,
+    contentMaxWidth,
+    maxUrlWidth,
+  }
+}
+
+/**
+ * Calculates modal height based on terminal size and whether credentials are invalid
+ */
+export function calculateModalDimensions(
+  terminalHeight: number,
+  hasInvalidCredentials: boolean,
+  defaultHeight = 24,
+  verticalMargin = 2,
+  maxBaseHeight = 22,
+  warningBannerHeight = 3,
+) {
+  // Calculate available terminal height
+  const availableHeight = terminalHeight || defaultHeight
+
+  // Calculate base modal height (terminal height minus margins, capped at max)
+  const baseModalHeight = Math.min(
+    availableHeight - verticalMargin,
+    maxBaseHeight,
+  )
+
+  // Add warning banner height if credentials are invalid
+  const totalContentHeight =
+    baseModalHeight + (hasInvalidCredentials ? warningBannerHeight : 0)
+
+  // Final modal height cannot exceed available terminal height
+  const modalHeight = Math.min(totalContentHeight, availableHeight)
+
+  return {
+    modalHeight,
+    baseModalHeight,
+    availableHeight,
+  }
+}

package/src/native/ripgrep.ts

@@ -0,0 +1,80 @@
+import path from 'path'
+
+import { getBundledRgPath } from '@anvil/sdk'
+import { spawnSync } from 'bun'
+
+import { getCliEnv } from '../utils/env'
+import { logger } from '../utils/logger'
+
+const getRipgrepPath = async (): Promise<string> => {
+  const env = getCliEnv()
+  // In dev mode, use the SDK's bundled ripgrep binary
+  if (!env.ANVIL_IS_BINARY) {
+    return getBundledRgPath()
+  }
+
+  // Compiled mode - self-extract the embedded binary to the same directory as the current binary
+  const binaryDir = path.dirname(process.execPath)
+  const rgFileName = process.platform === 'win32' ? 'rg.exe' : 'rg'
+  const outPath = path.join(binaryDir, rgFileName)
+
+  // Check if already extracted
+  const outPathExists = await Bun.file(outPath).exists()
+  if (outPathExists) {
+    return outPath
+  }
+
+  // Extract the embedded binary
+  try {
+    // Use require() with literal paths to ensure the binary gets bundled into the compiled CLI
+    // This is necessary for Bun's binary compilation to include the ripgrep binary
+    let embeddedRgPath: string
+    
+    if (process.platform === 'darwin' && process.arch === 'arm64') {
+      embeddedRgPath = require('../../../sdk/dist/vendor/ripgrep/arm64-darwin/rg')
+    } else if (process.platform === 'darwin' && process.arch === 'x64') {
+      embeddedRgPath = require('../../../sdk/dist/vendor/ripgrep/x64-darwin/rg')
+    } else if (process.platform === 'linux' && process.arch === 'arm64') {
+      embeddedRgPath = require('../../../sdk/dist/vendor/ripgrep/arm64-linux/rg')
+    } else if (process.platform === 'linux' && process.arch === 'x64') {
+      embeddedRgPath = require('../../../sdk/dist/vendor/ripgrep/x64-linux/rg')
+    } else if (process.platform === 'win32' && process.arch === 'x64') {
+      embeddedRgPath = require('../../../sdk/dist/vendor/ripgrep/x64-win32/rg.exe')
+    } else {
+      throw new Error(`Unsupported platform: ${process.platform}-${process.arch}`)
+    }
+
+    // Copy SDK's bundled binary to binary directory for portability
+    const embeddedBuffer = await Bun.file(embeddedRgPath).arrayBuffer()
+    await Bun.write(outPath, embeddedBuffer)
+
+    // Make executable on Unix systems
+    if (process.platform !== 'win32') {
+      spawnSync(['chmod', '+x', outPath])
+    }
+
+    return outPath
+  } catch (error) {
+    logger.error({ error }, 'Failed to extract ripgrep binary')
+    // Fallback to SDK's bundled ripgrep if extraction fails
+    return getBundledRgPath()
+  }
+}
+
+// Cache the promise to avoid multiple extractions
+let rgPathPromise: Promise<string> | null = null
+
+export const getRgPath = (): Promise<string> => {
+  if (!rgPathPromise) {
+    rgPathPromise = getRipgrepPath()
+  }
+  return rgPathPromise
+}
+
+/**
+ * Reset the cached ripgrep path promise.
+ * Used primarily for testing to force re-extraction.
+ */
+export const resetRgPathCache = (): void => {
+  rgPathPromise = null
+}

package/src/polyfills/bun-strip-ansi.ts

@@ -0,0 +1,12 @@
+import { stripAnsi } from '@anvil/common/util/string'
+
+// Bun 1.2 removed Bun.stripANSI; provide a fallback for libraries that still call it.
+const bunGlobal = globalThis as typeof globalThis & {
+  Bun?: {
+    stripANSI?: (input: string) => string
+  }
+}
+
+if (bunGlobal.Bun && typeof bunGlobal.Bun.stripANSI !== 'function') {
+  bunGlobal.Bun.stripANSI = stripAnsi
+}