@alumbwe/anvil 1.0.19 → 1.0.20

package/src/utils/anvil-streak-line.ts

@@ -0,0 +1,93 @@
+// The label/dots/perk-note logic is shared with Anvil Desktop and lives in
+// common; this module re-exports it and adds the terminal rendering and layout
+// gating only the CLI needs.
+export {
+  ANVIL_STREAK_WEEK,
+  getAnvilStreakBonusNote,
+} from '@anvil/common/util/anvil-streak-line'
+export type { AnvilStreakLine } from '@anvil/common/util/anvil-streak-line'
+
+import {
+  ANVIL_STREAK_WEEK,
+  getAnvilStreakBonusNote,
+  getAnvilStreakLine as getSharedAnvilStreakLine,
+} from '@anvil/common/util/anvil-streak-line'
+
+import type { AnvilStreakLine } from '@anvil/common/util/anvil-streak-line'
+
+const ANVIL_STREAK_BONUS_MIN_HEIGHT = 30
+
+/** Columns between the count label and its progress dots. */
+export const ANVIL_STREAK_LABEL_GAP = 2
+
+/** Columns kept clear between the heading and the streak when they share a
+ *  row. The heading row is laid out space-between inside a shrink-to-fit
+ *  column, so when the row is the widest child there is no free space to
+ *  distribute and the two would otherwise render flush against each other
+ *  ("Start coding for free18 day streak"). This is the floor, and the same
+ *  number decides whether they may share a row at all. */
+export const ANVIL_STREAK_INLINE_GAP = 3
+
+/** Progress glyphs for a terminal — the same ●/○ pair the shared module and
+ *  the desktop app use. Bullet and middle dot were tried here because U+25CF
+ *  is missing from a few terminal fonts and lands as a tofu box, but • and ·
+ *  differ only in size: at a glance a partial week and a full one look alike,
+ *  which is the whole point of the row. Filled-vs-hollow reads instantly, and
+ *  the CLI already bets on ●/○ for its agent status indicators, so a font that
+ *  can't draw them is already visibly broken elsewhere.
+ *
+ *  If a font ever fails these, █/░ (Block Elements) is the fallback pair: the
+ *  ASCII logo and the progress bar are built from them, so anything that
+ *  renders the CLI at all renders those. */
+const TERMINAL_DOT_CHARS = { filled: '●', empty: '○' }
+
+/** The streak line as the CLI draws it. */
+export function getAnvilStreakLine(
+  streak: number,
+): AnvilStreakLine | null {
+  return getSharedAnvilStreakLine(streak, TERMINAL_DOT_CHARS)
+}
+
+/** Rendered width of the streak, e.g. "18 day streak  ●●●●●●●+". */
+export function getAnvilStreakInlineWidth(line: AnvilStreakLine): number {
+  return line.label.length + ANVIL_STREAK_LABEL_GAP + line.dots.length
+}
+
+/** What a user with no streak yet is about to earn. The empty slot is measured
+ *  against it so the row doesn't move on day one. */
+const DAY_ONE_LINE = getAnvilStreakLine(1)!
+
+/** Whether the heading and the streak can share a row with the inline gap left
+ *  clear between them. A streak long enough to widen its own label (or a
+ *  narrow terminal) pushes the streak onto its own line instead of letting the
+ *  two collide. */
+export function fitsAnvilStreakOnHeadingRow(params: {
+  /** null when the user has no streak yet — measured as day one. */
+  line: AnvilStreakLine | null
+  headingWidth: number
+  availableWidth: number
+}): boolean {
+  return (
+    params.headingWidth +
+      ANVIL_STREAK_INLINE_GAP +
+      getAnvilStreakInlineWidth(params.line ?? DAY_ONE_LINE) <=
+    params.availableWidth
+  )
+}
+
+/** Returns the earned perk note only when the landing layout can show it
+ * without crowding the picker or wrapping onto additional rows. */
+export function getAnvilStreakBonusNoteForLayout(params: {
+  streak: number
+  accessTier: 'full' | 'limited'
+  terminalHeight: number
+  availableWidth: number
+}): string | null {
+  if (params.streak < ANVIL_STREAK_WEEK) return null
+  if (params.terminalHeight < ANVIL_STREAK_BONUS_MIN_HEIGHT) return null
+
+  const note = getAnvilStreakBonusNote(params)
+  if (!note || note.length > params.availableWidth) return null
+
+  return note
+}

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 }
+}

package/src/utils/bash-messages.ts

@@ -0,0 +1,108 @@
+import { formatTimestamp } from './helpers'
+
+import type { PendingBashMessage } from '../types/store'
+import type { ChatMessage, ContentBlock } from '../types/chat'
+import type { ToolResultOutput } from '@anvil/common/types/messages/content-part'
+
+export function createRunTerminalToolResult(params: {
+  command: string
+  cwd: string
+  stdout: string | null
+  stderr: string | null
+  exitCode: number
+  errorMessage?: string
+}): ToolResultOutput[] {
+  const { command, cwd, stdout, stderr, exitCode, errorMessage } = params
+  if (errorMessage) {
+    return [
+      {
+        type: 'json' as const,
+        value: { command, startingCwd: cwd, errorMessage },
+      },
+    ]
+  }
+  return [
+    {
+      type: 'json' as const,
+      value: {
+        command,
+        startingCwd: cwd,
+        stdout: stdout || null,
+        stderr: stderr || null,
+        exitCode,
+      },
+    },
+  ]
+}
+
+export function buildBashHistoryMessages(params: {
+  command: string
+  cwd: string
+  toolCallId?: string
+  output?: string
+  isComplete?: boolean
+}): {
+  assistantMessage: ChatMessage
+  toolCallId: string
+} {
+  const { command, cwd, output = '...', isComplete = false } = params
+  const toolCallId = params.toolCallId ?? crypto.randomUUID()
+
+  const toolBlock: ContentBlock = {
+    type: 'tool',
+    toolName: 'run_terminal_command',
+    toolCallId,
+    input: { command },
+    output,
+  }
+
+  const assistantMessage: ChatMessage = {
+    id: `bash-result-${toolCallId}`,
+    variant: 'ai',
+    content: '',
+    blocks: [toolBlock],
+    timestamp: formatTimestamp(),
+    isComplete,
+    metadata: { bashCwd: cwd },
+  }
+
+  return { assistantMessage, toolCallId }
+}
+
+/**
+ * Format pending bash messages as context to prepend to the user's prompt.
+ * This provides the LLM with information about commands the user ran manually.
+ * Only includes completed (non-running) commands.
+ */
+export function formatBashContextForPrompt(
+  pendingBashMessages: PendingBashMessage[],
+): string {
+  // Only include completed commands
+  const completedCommands = pendingBashMessages.filter((msg) => !msg.isRunning)
+  
+  if (completedCommands.length === 0) {
+    return ''
+  }
+
+  const commandsContext = completedCommands
+    .map((bash) => {
+      const cwd = bash.cwd || process.cwd()
+      let result = `Command: ${bash.command}\nDirectory: ${cwd}\nExit code: ${bash.exitCode}`
+      if (bash.stdout) {
+        result += `\nStdout:\n${bash.stdout}`
+      }
+      if (bash.stderr) {
+        result += `\nStderr:\n${bash.stderr}`
+      }
+      return result
+    })
+    .join('\n\n---\n\n')
+
+  return `<user_terminal_commands>
+The user ran the following terminal command(s) before this message:
+
+${commandsContext}
+</user_terminal_commands>
+
+`
+}

package/src/utils/block-margins.ts

@@ -0,0 +1,35 @@
+import type { ContentBlock, TextContentBlock } from '../types/chat'
+
+/**
+ * Margin calculation result for a content block.
+ */
+export interface BlockMargins {
+  marginTop: number
+  marginBottom: number
+}
+
+/** Extracts margins for a text block, suppressing top margin after tool/agent blocks. */
+export function extractTextBlockMargins(
+  block: TextContentBlock,
+  prevBlock: ContentBlock | null,
+): BlockMargins {
+  const prevBlockSuppressesMargin =
+    prevBlock !== null &&
+    (prevBlock.type === 'tool' || prevBlock.type === 'agent')
+
+  const marginTop = prevBlockSuppressesMargin ? 0 : (block.marginTop ?? 0)
+  const marginBottom = block.marginBottom ?? 0
+
+  return { marginTop, marginBottom }
+}
+
+/** Extracts margins for an HTML block using explicit values without context adjustments. */
+export function extractHtmlBlockMargins(block: {
+  marginTop?: number
+  marginBottom?: number
+}): BlockMargins {
+  return {
+    marginTop: block.marginTop ?? 0,
+    marginBottom: block.marginBottom ?? 0,
+  }
+}