@alumbwe/anvil 1.0.20 → 1.0.21

package/vendor/@anvil/common/src/__tests__/reddit-capi.test.ts

@@ -0,0 +1,132 @@
+import { createHash } from 'node:crypto'
+
+import { describe, expect, test } from 'bun:test'
+
+import {
+  buildRedditCustomConversionBody,
+  redditConversionId,
+  RedditCapiDeliveryError,
+  sendRedditCustomConversion,
+} from '../reddit-capi'
+
+const sha256 = (value: string) =>
+  createHash('sha256').update(value).digest('hex')
+
+describe('Reddit CAPI', () => {
+  test('builds a documented v3 custom-event payload', () => {
+    const body = buildRedditCustomConversionBody({
+      customEventName: 'FirstPrompt',
+      conversionId: 'conversion-1',
+      actionSource: 'WEBSITE',
+      eventSourceUrl: 'https://anvil.com/chat?utm_source=reddit',
+      testId: 'test-123',
+      eventAt: 123,
+      user: {
+        email: 'Al.ice+Apple@Example.Com',
+        externalId: ' user-123 ',
+        ipAddress: '203.0.113.10',
+        userAgent: 'Browser',
+        clickId: 'reddit-click',
+        uuid: 'pixel-uuid',
+      },
+    })
+
+    expect(body).toEqual({
+      data: {
+        test_id: 'test-123',
+        events: [
+          {
+            event_at: 123,
+            action_source: 'WEBSITE',
+            event_source_url:
+              'https://anvil.com/chat?utm_source=reddit&rdt_cid=reddit-click',
+            type: {
+              tracking_type: 'CUSTOM',
+              custom_event_name: 'FirstPrompt',
+            },
+            click_id: 'reddit-click',
+            metadata: { conversion_id: 'conversion-1' },
+            user: {
+              email: sha256('alice@example.com'),
+              external_id: sha256('user-123'),
+              ip_address: '203.0.113.10',
+              user_agent: 'Browser',
+              uuid: 'pixel-uuid',
+            },
+          },
+        ],
+      },
+    })
+    expect(body.data.events[0]?.user).not.toHaveProperty('click_id')
+    expect(body.data).not.toHaveProperty('partner')
+  })
+
+  test('uses a stable opaque conversion id per user and event', () => {
+    expect(redditConversionId('FirstPrompt', 'user-123')).toBe(
+      sha256('FirstPrompt:user-123'),
+    )
+    expect(redditConversionId('Retention1d', 'user-123')).not.toBe(
+      redditConversionId('FirstPrompt', 'user-123'),
+    )
+  })
+
+  test('retries one transient failure', async () => {
+    let attempts = 0
+    const result = await sendRedditCustomConversion({
+      enabled: true,
+      accessToken: 'secret',
+      customEventName: 'Retention1d',
+      conversionId: 'conversion-1',
+      actionSource: 'OTHER',
+      user: { externalId: 'user-1' },
+      sleepImpl: async () => {},
+      fetchImpl: (async () => {
+        attempts += 1
+        return attempts === 1
+          ? new Response('retry', { status: 503 })
+          : Response.json({ data: { message: 'ok' } })
+      }) as unknown as typeof fetch,
+    })
+
+    expect(result).toBe('sent')
+    expect(attempts).toBe(2)
+  })
+
+  test('does not retry permanent failures', async () => {
+    let attempts = 0
+    await expect(
+      sendRedditCustomConversion({
+        enabled: true,
+        accessToken: 'secret',
+        customEventName: 'FirstPrompt',
+        conversionId: 'conversion-1',
+        actionSource: 'WEBSITE',
+        user: { externalId: 'user-1' },
+        sleepImpl: async () => {},
+        fetchImpl: (async () => {
+          attempts += 1
+          return new Response('invalid', { status: 400 })
+        }) as unknown as typeof fetch,
+      }),
+    ).rejects.toBeInstanceOf(RedditCapiDeliveryError)
+    expect(attempts).toBe(1)
+  })
+
+  test('is disabled without production enablement or a token', async () => {
+    let called = false
+    const result = await sendRedditCustomConversion({
+      enabled: false,
+      accessToken: 'secret',
+      customEventName: 'FirstPrompt',
+      conversionId: 'conversion-1',
+      actionSource: 'WEBSITE',
+      user: {},
+      fetchImpl: (async () => {
+        called = true
+        return Response.json({})
+      }) as unknown as typeof fetch,
+    })
+    expect(result).toBe('disabled')
+    expect(called).toBe(false)
+  })
+})

package/vendor/@anvil/common/src/__tests__/response-ad-positions.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+  responseAdNodePositions,
+  responseAdSlotCount,
+  RESPONSE_AD_FIRST_NODE_COUNT,
+  RESPONSE_AD_NODE_STEP,
+} from '../util/response-ad-positions'
+
+describe('responseAdNodePositions', () => {
+  test('places nothing in a response too short to intersperse', () => {
+    expect(responseAdNodePositions({ nodeCount: 0, adCount: 3 })).toEqual([])
+    expect(responseAdNodePositions({ nodeCount: 1, adCount: 3 })).toEqual([])
+    expect(responseAdNodePositions({ nodeCount: 2, adCount: 3 })).toEqual([])
+  })
+
+  test('keeps the first ad after two nodes, then spaces ads every three nodes', () => {
+    expect(RESPONSE_AD_FIRST_NODE_COUNT).toBe(2)
+    expect(RESPONSE_AD_NODE_STEP).toBe(3)
+    expect(responseAdNodePositions({ nodeCount: 2, adCount: 4 })).toEqual([])
+    expect(responseAdNodePositions({ nodeCount: 3, adCount: 4 })).toEqual([1])
+    expect(responseAdNodePositions({ nodeCount: 4, adCount: 4 })).toEqual([1])
+    expect(responseAdNodePositions({ nodeCount: 6, adCount: 4 })).toEqual([1, 4])
+    expect(responseAdNodePositions({ nodeCount: 9, adCount: 4 })).toEqual([1, 4, 7])
+  })
+
+  test('eligible display slots are not capped at eight', () => {
+    expect(responseAdSlotCount({ nodeCount: 2 })).toBe(0)
+    expect(responseAdSlotCount({ nodeCount: 3 })).toBe(1)
+    expect(responseAdSlotCount({ nodeCount: 24 })).toBe(8)
+    expect(responseAdSlotCount({ nodeCount: 27 })).toBe(9)
+    expect(responseAdNodePositions({ nodeCount: 27, adCount: 9 })).toEqual([
+      1, 4, 7, 10, 13, 16, 19, 22, 25,
+    ])
+  })
+
+  test('never places more ads than provided', () => {
+    expect(responseAdNodePositions({ nodeCount: 20, adCount: 2 })).toEqual([1, 4])
+    expect(responseAdNodePositions({ nodeCount: 20, adCount: 0 })).toEqual([])
+  })
+
+  test('positions are stable as the streaming response appends nodes', () => {
+    let previous: number[] = []
+    for (let nodeCount = 0; nodeCount <= 12; nodeCount++) {
+      const next = responseAdNodePositions({ nodeCount, adCount: 3 })
+      expect(next.slice(0, previous.length)).toEqual(previous)
+      previous = next
+    }
+  })
+
+  test('allows the first-ad offset to differ from recurring spacing', () => {
+    expect(
+      responseAdNodePositions({
+        nodeCount: 8,
+        adCount: 3,
+        firstAdAfterNodes: 3,
+        step: 2,
+      }),
+    ).toEqual([2, 4, 6])
+  })
+
+  test('clamps non-positive placement settings to one', () => {
+    expect(
+      responseAdNodePositions({
+        nodeCount: 4,
+        adCount: 3,
+        firstAdAfterNodes: 0,
+        step: 0,
+      }),
+    ).toEqual([0, 1, 2])
+  })
+})

package/vendor/@anvil/common/src/__tests__/user-state.test.ts

@@ -0,0 +1,30 @@
+import { describe, test, expect } from 'bun:test'
+
+import { getUserState, UserState } from '../old-constants'
+
+describe('getUserState', () => {
+  test('returns LOGGED_OUT for unauthenticated users regardless of credits', () => {
+    expect(getUserState(false, 1000)).toBe(UserState.LOGGED_OUT)
+    expect(getUserState(false, 0)).toBe(UserState.LOGGED_OUT)
+  })
+
+  test('returns GOOD_STANDING for users with >= 100 credits', () => {
+    expect(getUserState(true, 100)).toBe(UserState.GOOD_STANDING)
+    expect(getUserState(true, 500)).toBe(UserState.GOOD_STANDING)
+  })
+
+  test('returns ATTENTION_NEEDED for users with 20-99 credits', () => {
+    expect(getUserState(true, 99)).toBe(UserState.ATTENTION_NEEDED)
+    expect(getUserState(true, 20)).toBe(UserState.ATTENTION_NEEDED)
+  })
+
+  test('returns CRITICAL for users with 1-19 credits', () => {
+    expect(getUserState(true, 19)).toBe(UserState.CRITICAL)
+    expect(getUserState(true, 1)).toBe(UserState.CRITICAL)
+  })
+
+  test('returns DEPLETED for users with 0 or fewer credits', () => {
+    expect(getUserState(true, 0)).toBe(UserState.DEPLETED)
+    expect(getUserState(true, -100)).toBe(UserState.DEPLETED)
+  })
+})

package/vendor/@anvil/common/src/actions.ts

@@ -0,0 +1,215 @@
+import { z } from 'zod/v4'
+
+import type { GrantType } from './types/grant'
+import type { MCPConfig } from './types/mcp'
+import type { ToolMessage } from './types/messages/anvil-message'
+import type {
+  TextPart,
+  ImagePart,
+  ToolResultOutput,
+} from './types/messages/content-part'
+import type { PrintModeEvent } from './types/print-mode'
+import type { AgentOutput, SessionState, ToolCall } from './types/session-state'
+import type { ProjectFileContext } from './util/file'
+
+export const FileChangeSchema = z.object({
+  type: z.enum(['patch', 'file']),
+  path: z.string(),
+  content: z.string(),
+})
+export type FileChange = z.infer<typeof FileChangeSchema>
+export const CHANGES = z.array(FileChangeSchema)
+export type FileChanges = z.infer<typeof CHANGES>
+
+type ClientActionPrompt = {
+  type: 'prompt'
+  promptId: string
+  prompt: string | undefined
+  content?: (TextPart | ImagePart)[]
+  promptParams?: Record<string, any> // Additional json params.
+  fingerprintId: string
+  authToken?: string
+  costMode?: string
+  sessionState: SessionState
+  toolResults: ToolMessage[]
+  model?: string
+  repoUrl?: string
+  agentId?: string
+}
+
+type ClientActionReadFilesResponse = {
+  type: 'read-files-response'
+  files: Record<string, string | null>
+  requestId?: string
+}
+
+type ClientActionInit = {
+  type: 'init'
+  fingerprintId: string
+  authToken?: string
+  fileContext: ProjectFileContext
+  repoUrl?: string
+}
+
+type ClientActionToolCallResponse = {
+  type: 'tool-call-response'
+  requestId: string
+  output: ToolResultOutput[]
+}
+
+type ClientActionCancelUserInput = {
+  type: 'cancel-user-input'
+  authToken: string
+  promptId: string
+}
+
+type ClientActionMcpToolData = {
+  type: 'mcp-tool-data'
+  requestId: string
+  tools: {
+    name: string
+    description?: string
+    inputSchema: { type: 'object';[k: string]: unknown }
+  }[]
+}
+
+type ClientActionAny =
+  | ClientActionPrompt
+  | ClientActionReadFilesResponse
+  | ClientActionInit
+  | ClientActionToolCallResponse
+  | ClientActionCancelUserInput
+  | ClientActionMcpToolData
+type ClientActionType = ClientActionAny['type']
+export type ClientAction<T extends ClientActionType = ClientActionType> = {
+  [K in ClientActionType]: Extract<
+    ClientActionAny,
+    {
+      type: K
+    }
+  >
+}[T]
+
+type ServerActionResponseChunk = {
+  type: 'response-chunk'
+  userInputId: string
+  chunk: string | PrintModeEvent
+}
+
+type ServerActionSubagentResponseChunk = {
+  type: 'subagent-response-chunk'
+  userInputId: string
+  agentId: string
+  agentType: string
+  chunk: string
+  prompt?: string
+  forwardToPrompt?: boolean
+}
+
+type ServerActionHandleStepsLogChunk = {
+  type: 'handlesteps-log-chunk'
+  userInputId: string
+  agentId: string
+  level: 'debug' | 'info' | 'warn' | 'error'
+  data: any
+  message?: string
+}
+
+export type PromptResponse = {
+  type: 'prompt-response'
+  promptId: string
+  sessionState: SessionState
+  toolCalls?: ToolCall[]
+  toolResults?: ToolMessage[]
+  output?: AgentOutput
+}
+
+type ServerActionReadFiles = {
+  type: 'read-files'
+  filePaths: string[]
+  requestId: string
+}
+
+type ServerActionToolCallRequest = {
+  type: 'tool-call-request'
+  userInputId: string
+  requestId: string
+  toolName: string
+  input: Record<string, any>
+  timeout?: number
+  mcpConfig?: MCPConfig
+}
+
+export type InitResponse = {
+  type: 'init-response'
+  message?: string
+  agentNames?: Record<string, string>
+} & Omit<UsageResponse, 'type'>
+
+export type UsageResponse = {
+  type: 'usage-response'
+  usage: number
+  remainingBalance: number
+  balanceBreakdown?: Record<GrantType, number>
+  next_quota_reset: Date | null
+  autoTopupAdded?: number
+  autoTopupEnabled?: boolean
+}
+
+export type MessageCostResponse = {
+  type: 'message-cost-response'
+  promptId: string
+  credits: number
+  agentId?: string
+}
+
+type ServerActionActionError = {
+  type: 'action-error'
+  message: string
+  error?: string
+  remainingBalance?: number
+}
+
+type ServerActionPromptError = {
+  type: 'prompt-error'
+  userInputId: string
+  message: string
+  error?: string
+  remainingBalance?: number
+}
+
+type ServerActionRequestReconnect = {
+  // The server is imminently going to shutdown, and the client should reconnect
+  type: 'request-reconnect'
+}
+
+type ServerActionRequestMcpToolData = {
+  type: 'request-mcp-tool-data'
+  requestId: string
+  mcpConfig: MCPConfig
+  toolNames?: string[]
+}
+
+type ServerActionAny =
+  | ServerActionResponseChunk
+  | ServerActionSubagentResponseChunk
+  | ServerActionHandleStepsLogChunk
+  | PromptResponse
+  | ServerActionReadFiles
+  | ServerActionToolCallRequest
+  | InitResponse
+  | UsageResponse
+  | MessageCostResponse
+  | ServerActionActionError
+  | ServerActionPromptError
+  | ServerActionRequestReconnect
+  | ServerActionRequestMcpToolData
+type ServerActionType = ServerActionAny['type']
+export type ServerAction<T extends ServerActionType = ServerActionType> = {
+  [K in ServerActionType]: Extract<
+    ServerActionAny,
+    {
+      type: K
+    }
+  >
+}[T]

package/vendor/@anvil/common/src/analytics-core.ts

@@ -0,0 +1,69 @@
+import { PostHog } from 'posthog-node'
+
+/**
+ * Shared analytics core module.
+ * Provides common interfaces, types, and utilities used by both
+ * server-side (common/src/analytics.ts) and CLI (cli/src/utils/analytics.ts) analytics.
+ */
+
+/** Interface for PostHog client methods used for event capture */
+export interface AnalyticsClient {
+  capture: (params: {
+    distinctId: string
+    event: string
+    properties?: Record<string, any>
+  }) => void
+  flush: () => Promise<void>
+}
+
+/** Extended client interface with identify, alias, and exception capture (used by CLI) */
+export interface AnalyticsClientWithIdentify extends AnalyticsClient {
+  identify: (params: {
+    distinctId: string
+    properties?: Record<string, any>
+  }) => void
+  /** Links an alias (previous anonymous ID) to a distinctId (real user ID) */
+  alias: (data: { distinctId: string; alias: string }) => void
+  captureException: (
+    error: any,
+    distinctId: string,
+    properties?: Record<string, any>,
+  ) => void
+}
+
+/** Environment name type */
+export type AnalyticsEnvName = 'dev' | 'test' | 'prod'
+
+/** Base analytics configuration */
+export interface AnalyticsConfig {
+  envName: AnalyticsEnvName
+  posthogApiKey: string
+  posthogHostUrl: string
+}
+
+/** Options for creating a PostHog client */
+export interface PostHogClientOptions {
+  host: string
+  flushAt?: number
+  flushInterval?: number
+  enableExceptionAutocapture?: boolean
+}
+
+/**
+ * Default PostHog client factory.
+ * Creates a real PostHog client instance.
+ */
+export function createPostHogClient(
+  apiKey: string,
+  options: PostHogClientOptions,
+): AnalyticsClientWithIdentify {
+  return new PostHog(apiKey, options) as AnalyticsClientWithIdentify
+}
+
+/**
+ * Generates a unique anonymous ID for pre-login tracking.
+ * Uses crypto.randomUUID() for uniqueness.
+ */
+export function generateAnonymousId(): string {
+  return `anon_${crypto.randomUUID()}`
+}

package/vendor/@anvil/common/src/analytics.ts

@@ -0,0 +1,93 @@
+import { env, DEBUG_ANALYTICS } from '@anvil/common/env'
+
+import { createPostHogClient, type AnalyticsClient } from './analytics-core'
+import { AnalyticsEvent } from './constants/analytics-events'
+
+import type { TrackEventFn } from '@anvil/common/types/contracts/analytics'
+import type { Logger } from '@anvil/common/types/contracts/logger'
+
+let client: AnalyticsClient | undefined
+
+export async function flushAnalytics(logger?: Logger) {
+  if (!client) {
+    return
+  }
+  try {
+    await client.flush()
+  } catch (error) {
+    // Log the error but don't throw - flushing is best-effort
+    logger?.warn({ error }, 'Failed to flush analytics')
+
+    // Track the flush failure event (will be queued for next successful flush)
+    try {
+      client.capture({
+        distinctId: 'system',
+        event: AnalyticsEvent.FLUSH_FAILED,
+        properties: {
+          error: error instanceof Error ? error.message : String(error),
+        },
+      })
+    } catch {
+      // Silently ignore if we can't even track the failure
+    }
+  }
+}
+
+export function withDefaultProperties(
+  trackEventFn: TrackEventFn,
+  defaultProperties: Record<string, unknown>,
+): TrackEventFn {
+  return (params) => {
+    trackEventFn({
+      ...params,
+      properties: { ...defaultProperties, ...params.properties },
+    })
+  }
+}
+
+export function trackEvent({
+  event,
+  userId,
+  properties,
+  logger,
+}: {
+  event: AnalyticsEvent
+  userId: string
+  properties?: Record<string, any>
+  logger: Logger
+}) {
+  // Don't track events in non-production environments
+  if (env.NEXT_PUBLIC_CB_ENVIRONMENT !== 'prod') {
+    if (DEBUG_ANALYTICS) {
+      logger.debug({ event, userId, properties }, `[analytics] ${event}`)
+    }
+    return
+  }
+
+  if (!client) {
+    try {
+      client = createPostHogClient(env.NEXT_PUBLIC_POSTHOG_API_KEY, {
+        host: env.NEXT_PUBLIC_POSTHOG_HOST_URL,
+        flushAt: 1,
+        flushInterval: 0,
+      })
+    } catch (error) {
+      logger.warn({ error }, 'Failed to initialize analytics client')
+      return
+    }
+    logger.info(
+      { envName: env.NEXT_PUBLIC_CB_ENVIRONMENT },
+      'Analytics client initialized',
+    )
+  }
+
+  try {
+    client.capture({
+      distinctId: userId,
+      event,
+      properties,
+    })
+  } catch (error) {
+    logger.error({ error }, 'Failed to track event')
+  }
+}

package/vendor/@anvil/common/src/api-keys/constants.ts

@@ -0,0 +1,26 @@
+export const ALGORITHM = 'aes-256-gcm'
+export const IV_LENGTH = 12
+export const AUTH_TAG_LENGTH = 16
+
+// --- Define valid API Key Types ---
+// Used by db/schema.ts to define the pgEnum
+// and by crypto.ts for type safety.
+export const API_KEY_TYPES = ['anthropic', 'gemini', 'openai'] as const
+export type ApiKeyType = (typeof API_KEY_TYPES)[number] // Derive the type from the constant
+
+export const KEY_PREFIXES: Record<ApiKeyType, string> = {
+  anthropic: 'sk-ant-api03-',
+  gemini: 'AIzaSy',
+  openai: 'sk-proj-',
+}
+export const KEY_LENGTHS: Record<ApiKeyType, number> = {
+  anthropic: 108,
+  gemini: 39,
+  openai: 164,
+}
+
+export const READABLE_NAME: Record<ApiKeyType, string> = {
+  anthropic: 'Anthropic',
+  gemini: 'Gemini',
+  openai: 'Open AI',
+}