@alumbwe/anvil 1.0.20 → 1.0.21

package/vendor/@anvil/common/src/env-schema.ts

@@ -0,0 +1,95 @@
+import z from 'zod/v4'
+
+export const CLIENT_ENV_PREFIX = 'NEXT_PUBLIC_'
+
+export const clientEnvSchema = z.object({
+  NEXT_PUBLIC_CB_ENVIRONMENT: z.enum(['dev', 'test', 'prod']),
+  NEXT_PUBLIC_ANVIL_APP_URL: z.url().min(1),
+  NEXT_PUBLIC_SUPPORT_EMAIL: z.email().min(1),
+  NEXT_PUBLIC_POSTHOG_API_KEY: z.string().min(1),
+  NEXT_PUBLIC_POSTHOG_HOST_URL: z.url().min(1),
+  NEXT_PUBLIC_GRAVITY_PIXEL_ID: z.uuid().optional(),
+  NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY: z.string().min(1),
+  NEXT_PUBLIC_STRIPE_CUSTOMER_PORTAL: z.url().min(1),
+  NEXT_PUBLIC_GOOGLE_SITE_VERIFICATION_ID: z.string().optional(),
+  NEXT_PUBLIC_WEB_PORT: z.coerce.number().min(1000),
+  /** Cloudflare Turnstile site key for the signup challenge. Public by design —
+   *  the secret half is server-only (`TURNSTILE_SECRET_KEY`). Optional so a dev
+   *  checkout without Turnstile configured still boots; the server gate decides
+   *  whether a missing key means "skip" or "refuse". */
+  NEXT_PUBLIC_TURNSTILE_SITE_KEY: z.string().min(1).optional(),
+  /**
+   * Google reCAPTCHA site keys — BOTH versions, which run together rather than
+   * as alternatives. v3 scores the session invisibly; v2 asks the human to click
+   * a box. Public by design; the secret halves are `RECAPTCHA_V2_SECRET_KEY` and
+   * `RECAPTCHA_V3_SECRET_KEY`.
+   *
+   * These are two separate registrations in the reCAPTCHA console with two
+   * separate secrets, and the versions are NOT interchangeable: using a v2 key
+   * where a v3 one is expected throws `Invalid site key type`, mints no token,
+   * and is indistinguishable at the gate from a bot. Either may be omitted to
+   * run only the other; both optional so a dev checkout still boots.
+   */
+  NEXT_PUBLIC_RECAPTCHA_V2_SITE_KEY: z.string().min(1).optional(),
+  NEXT_PUBLIC_RECAPTCHA_V3_SITE_KEY: z.string().min(1).optional(),
+  /**
+   * Whether the v2 widget is a checkbox everyone clicks or an invisible check.
+   *
+   * `checkbox` buys nothing against bots that `invisible` does not: both are the
+   * same key type hitting the same risk engine, and both escalate to the same
+   * image challenge when Google is suspicious. The choice is purely how much
+   * friction to show a clean user, which is why it is one env value and not a
+   * design. NOTE that the key itself is registered as one or the other, so this
+   * has to match the registration — an invisible-registered key rejects
+   * `checkbox` outright.
+   *
+   * Optional rather than `.default('checkbox')`, with the default applied at the
+   * point of use. A `.default()` here would make this the only field in this
+   * schema whose OUTPUT type is required, and `clientEnv` is built as an object
+   * literal by fixtures across agent-runtime, evals and web — so it breaks all
+   * of them at the type level over a value none of them care about. Adding a
+   * DEFAULTED client env var is quietly a breaking change; an optional one is
+   * not.
+   */
+  NEXT_PUBLIC_RECAPTCHA_V2_SIZE: z.enum(['checkbox', 'invisible']).optional(),
+  /** Human Behavior session-replay write key for Anvil Web. Public by
+   *  design — it only authorizes ingestion. Optional so a dev checkout without
+   *  it boots with replay simply switched off. */
+  NEXT_PUBLIC_HUMANBEHAVIOR_API_KEY: z.string().min(1).optional(),
+  /** Overrides the SDK's default ingestion host; only set to point a
+   *  deployment at a non-default Human Behavior endpoint. */
+  NEXT_PUBLIC_HUMANBEHAVIOR_INGESTION_URL: z.url().optional(),
+} satisfies Record<`${typeof CLIENT_ENV_PREFIX}${string}`, any>)
+export const clientEnvVars = clientEnvSchema.keyof().options
+export type ClientEnvVar = (typeof clientEnvVars)[number]
+export type ClientInput = {
+  [K in (typeof clientEnvVars)[number]]: string | undefined
+}
+export type ClientEnv = z.infer<typeof clientEnvSchema>
+
+// Bun will inject all these values, so we need to reference them individually (no for-loops)
+export const clientProcessEnv: ClientInput = {
+  NEXT_PUBLIC_CB_ENVIRONMENT: process.env.NEXT_PUBLIC_CB_ENVIRONMENT,
+  NEXT_PUBLIC_ANVIL_APP_URL: process.env.NEXT_PUBLIC_ANVIL_APP_URL,
+  NEXT_PUBLIC_SUPPORT_EMAIL: process.env.NEXT_PUBLIC_SUPPORT_EMAIL,
+  NEXT_PUBLIC_POSTHOG_API_KEY: process.env.NEXT_PUBLIC_POSTHOG_API_KEY,
+  NEXT_PUBLIC_POSTHOG_HOST_URL: process.env.NEXT_PUBLIC_POSTHOG_HOST_URL,
+  NEXT_PUBLIC_GRAVITY_PIXEL_ID: process.env.NEXT_PUBLIC_GRAVITY_PIXEL_ID,
+  NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY:
+    process.env.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY,
+  NEXT_PUBLIC_STRIPE_CUSTOMER_PORTAL:
+    process.env.NEXT_PUBLIC_STRIPE_CUSTOMER_PORTAL,
+  NEXT_PUBLIC_GOOGLE_SITE_VERIFICATION_ID:
+    process.env.NEXT_PUBLIC_GOOGLE_SITE_VERIFICATION_ID,
+  NEXT_PUBLIC_WEB_PORT: process.env.NEXT_PUBLIC_WEB_PORT,
+  NEXT_PUBLIC_TURNSTILE_SITE_KEY: process.env.NEXT_PUBLIC_TURNSTILE_SITE_KEY,
+  NEXT_PUBLIC_RECAPTCHA_V2_SITE_KEY:
+    process.env.NEXT_PUBLIC_RECAPTCHA_V2_SITE_KEY,
+  NEXT_PUBLIC_RECAPTCHA_V3_SITE_KEY:
+    process.env.NEXT_PUBLIC_RECAPTCHA_V3_SITE_KEY,
+  NEXT_PUBLIC_RECAPTCHA_V2_SIZE: process.env.NEXT_PUBLIC_RECAPTCHA_V2_SIZE,
+  NEXT_PUBLIC_HUMANBEHAVIOR_API_KEY:
+    process.env.NEXT_PUBLIC_HUMANBEHAVIOR_API_KEY,
+  NEXT_PUBLIC_HUMANBEHAVIOR_INGESTION_URL:
+    process.env.NEXT_PUBLIC_HUMANBEHAVIOR_INGESTION_URL,
+}

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

@@ -0,0 +1,24 @@
+import { clientEnvSchema, clientProcessEnv } from './env-schema'
+
+const parsedEnv = clientEnvSchema.safeParse(clientProcessEnv)
+if (!parsedEnv.success) {
+  console.error('Environment validation failed:', parsedEnv.error.issues)
+  throw new Error(`Invalid environment configuration: ${parsedEnv.error.message}`)
+}
+
+export const env = parsedEnv.data
+
+// Only log environment in non-production
+if (env.NEXT_PUBLIC_CB_ENVIRONMENT !== 'prod') {
+  console.log('Using environment:', env.NEXT_PUBLIC_CB_ENVIRONMENT)
+}
+
+// Derived environment constants for convenience
+export const IS_DEV = env.NEXT_PUBLIC_CB_ENVIRONMENT === 'dev'
+export const IS_TEST = env.NEXT_PUBLIC_CB_ENVIRONMENT === 'test'
+export const IS_PROD = env.NEXT_PUBLIC_CB_ENVIRONMENT === 'prod'
+export const IS_CI = process.env.ANVIL_GITHUB_ACTIONS === 'true'
+
+// Debug flag for logging analytics events in dev mode
+// Set to true when actively debugging analytics - affects both CLI and backend
+export const DEBUG_ANALYTICS = false

package/vendor/@anvil/common/src/gravity-capi.ts

@@ -0,0 +1,207 @@
+export const GRAVITY_CAPI_ENDPOINT = 'https://api.trygravity.ai/gateway/events'
+export const GRAVITY_FIRST_MESSAGE_EVENT = 'FirstMessage'
+
+export const ANVIL_GRAVITY_SURFACES = [
+  'cli',
+  'desktop',
+  'web',
+  'cloud',
+  'chat',
+] as const
+export type AnvilGravitySurface = (typeof ANVIL_GRAVITY_SURFACES)[number]
+export type AnvilServiceGravitySurface = Extract<
+  AnvilGravitySurface,
+  'web' | 'cloud' | 'chat'
+>
+
+export function isAnvilGravitySurface(
+  value: unknown,
+): value is AnvilGravitySurface {
+  return ANVIL_GRAVITY_SURFACES.includes(value as AnvilGravitySurface)
+}
+
+export function isAnvilServiceGravitySurface(
+  value: unknown,
+): value is AnvilServiceGravitySurface {
+  return value === 'web' || value === 'cloud' || value === 'chat'
+}
+
+export type GravityCapiUserData = {
+  click_id?: string | null
+  visitor_id?: string | null
+  session_id?: string | null
+  client_user_agent?: string | null
+}
+
+/** Attribution and device data returned by window.gravityPixel.getCAPIData(). */
+export type GravityCapiData = {
+  user_data?: GravityCapiUserData | null
+  event_source_url?: string | null
+  client_context?: Record<string, unknown> | null
+}
+
+export type GravityConversionResult = {
+  event_id?: string
+  status?: string
+  attributed?: boolean
+  error?: unknown
+}
+
+function boundedString(value: unknown, maxLength: number): string | undefined {
+  return typeof value === 'string' && value.trim() && value.length <= maxLength
+    ? value
+    : undefined
+}
+
+function boundedObject(
+  value: unknown,
+  maxJsonLength: number,
+): Record<string, unknown> | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return undefined
+  }
+  try {
+    return new TextEncoder().encode(JSON.stringify(value)).byteLength <=
+      maxJsonLength
+      ? (value as Record<string, unknown>)
+      : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/** Sanitizes the untrusted browser result from gravityPixel.getCAPIData(). */
+export function sanitizeGravityCapiData(
+  raw: unknown,
+  fallbackEventSourceUrl?: unknown,
+): GravityCapiData | undefined {
+  const value =
+    raw && typeof raw === 'object' && !Array.isArray(raw)
+      ? (raw as Record<string, unknown>)
+      : undefined
+  const rawUser =
+    value?.user_data &&
+    typeof value.user_data === 'object' &&
+    !Array.isArray(value.user_data)
+      ? (value.user_data as Record<string, unknown>)
+      : undefined
+  const eventSourceUrl =
+    boundedString(fallbackEventSourceUrl, 8192) ??
+    boundedString(value?.event_source_url, 8192)
+  const clientContext = boundedObject(value?.client_context, 32_768)
+
+  if (!value && !eventSourceUrl) return undefined
+  return {
+    user_data: rawUser
+      ? {
+          click_id: boundedString(rawUser.click_id, 4096),
+          visitor_id: boundedString(rawUser.visitor_id, 4096),
+          session_id: boundedString(rawUser.session_id, 4096),
+          client_user_agent: boundedString(rawUser.client_user_agent, 4096),
+        }
+      : undefined,
+    event_source_url: eventSourceUrl,
+    client_context: clientContext,
+  }
+}
+
+export function gravityFirstMessageEventId(userId: string): string {
+  return `anvil-first-message-${userId}`
+}
+
+export function buildGravityFirstMessagePayload(params: {
+  userId: string
+  email?: string | null
+  surface: AnvilGravitySurface
+  gravity?: GravityCapiData | null
+  userAgent?: string | null
+  eventTime?: number
+}) {
+  const pixelUser = params.gravity?.user_data ?? {}
+  const userData = {
+    ...(pixelUser.click_id ? { click_id: pixelUser.click_id } : {}),
+    ...(pixelUser.visitor_id ? { visitor_id: pixelUser.visitor_id } : {}),
+    ...(pixelUser.session_id ? { session_id: pixelUser.session_id } : {}),
+    ...(pixelUser.client_user_agent || params.userAgent
+      ? {
+          client_user_agent:
+            pixelUser.client_user_agent ?? params.userAgent ?? undefined,
+        }
+      : {}),
+    ...(params.email ? { em: [params.email] } : {}),
+    external_id: [params.userId],
+  }
+
+  return {
+    data: [
+      {
+        event_name: GRAVITY_FIRST_MESSAGE_EVENT,
+        event_time: params.eventTime ?? Math.floor(Date.now() / 1000),
+        event_id: gravityFirstMessageEventId(params.userId),
+        action_source: 'website',
+        ...(params.gravity?.event_source_url
+          ? { event_source_url: params.gravity.event_source_url }
+          : {}),
+        user_data: userData,
+        ...(params.gravity?.client_context
+          ? { client_context: params.gravity.client_context }
+          : {}),
+        custom_data: {
+          content_name: 'Anvil first message',
+          content_category: params.surface,
+        },
+      },
+    ],
+  }
+}
+
+/**
+ * Sends the account-level first-message conversion. The caller owns retry and
+ * persistence; this function throws unless Gravity confirms a terminal result.
+ */
+export async function sendGravityFirstMessageConversion(params: {
+  apiKey: string
+  userId: string
+  email?: string | null
+  surface: AnvilGravitySurface
+  gravity?: GravityCapiData | null
+  userAgent?: string | null
+  fetchImpl?: typeof fetch
+}): Promise<GravityConversionResult> {
+  const fetchImpl = params.fetchImpl ?? fetch
+  const response = await fetchImpl(GRAVITY_CAPI_ENDPOINT, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${params.apiKey}`,
+      'Content-Type': 'application/json',
+      'User-Agent': 'anvil/1.0 (gravity-capi)',
+    },
+    body: JSON.stringify(buildGravityFirstMessagePayload(params)),
+    signal: AbortSignal.timeout(3_000),
+  })
+
+  const responseText = await response.text()
+  if (!response.ok) {
+    throw new Error(
+      `Gravity CAPI rejected FirstMessage (${response.status}): ${responseText.slice(0, 500)}`,
+    )
+  }
+
+  let body: { results?: GravityConversionResult[] }
+  try {
+    body = JSON.parse(responseText) as { results?: GravityConversionResult[] }
+  } catch {
+    throw new Error('Gravity CAPI returned invalid JSON for FirstMessage')
+  }
+
+  const result = body.results?.[0]
+  if (!result?.status) {
+    throw new Error('Gravity CAPI returned no result for FirstMessage')
+  }
+  if (!['ok', 'duplicate', 'test_ok', 'skipped'].includes(result.status)) {
+    throw new Error(
+      `Gravity CAPI failed FirstMessage with status ${result.status}`,
+    )
+  }
+  return result
+}

package/vendor/@anvil/common/src/mcp/client.ts

@@ -0,0 +1,233 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js'
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js'
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'
+
+import { getErrorObject } from '../util/error'
+
+import type { MCPConfig } from '../types/mcp'
+import type { ToolResultOutput } from '../types/messages/content-part'
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js'
+import type {
+  BlobResourceContents,
+  CallToolResult,
+  TextResourceContents,
+} from '@modelcontextprotocol/sdk/types.js'
+
+// Cap on how much of a failed stdio server's stderr we retain for the error
+// message — enough to show the real failure without unbounded growth.
+const STDERR_BUFFER_CAP = 8192
+
+const runningClients: Record<string, Client> = {}
+const listToolsCache: Record<
+  string,
+  ReturnType<typeof Client.prototype.listTools>
+> = {}
+
+/**
+ * Substitutes environment variable references ($VAR_NAME) in a string with their values.
+ * Supports both simple replacement ("$VAR_NAME") and interpolation ("Bearer $VAR_NAME").
+ */
+function substituteEnvInValue(value: string): string {
+  return value.replace(/\$([A-Z_][A-Z0-9_]*)/g, (match, varName) => {
+    const envValue = process.env[varName]
+    if (envValue === undefined) {
+      // Return original if env var not found
+      return match
+    }
+    return envValue
+  })
+}
+
+/**
+ * Substitutes environment variable references in all values of a record.
+ */
+function substituteEnvInRecord(
+  record: Record<string, string>,
+): Record<string, string> {
+  const result: Record<string, string> = {}
+  for (const [key, value] of Object.entries(record)) {
+    result[key] = substituteEnvInValue(value)
+  }
+  return result
+}
+
+function hashConfig(config: MCPConfig): string {
+  if (config.type === 'stdio') {
+    return JSON.stringify({
+      command: config.command,
+      args: config.args,
+      env: config.env,
+    })
+  }
+  if (config.type === 'http') {
+    return JSON.stringify({
+      type: 'http',
+      url: config.url,
+      params: config.params,
+    })
+  }
+  if (config.type === 'sse') {
+    return JSON.stringify({
+      type: 'sse',
+      url: config.url,
+      params: config.params,
+    })
+  }
+  config.type satisfies never
+  throw new Error(
+    `Internal error in hashConfig: invalid MCP config type ${config.type}`,
+  )
+}
+
+export async function getMCPClient(config: MCPConfig): Promise<string> {
+  let key = hashConfig(config)
+  if (key in runningClients) {
+    return key
+  }
+
+  let transport: Transport
+  // Buffer the child process's stderr so that a server which crashes during
+  // startup produces an actionable error instead of the opaque MCP SDK message
+  // "MCP error -32000: Connection closed".
+  let stderrBuffer = ''
+  if (config.type === 'stdio') {
+    const stdioTransport = new StdioClientTransport({
+      command: config.command,
+      args: config.args,
+      env: substituteEnvInRecord(config.env),
+      stderr: 'pipe',
+    })
+    // When stderr is 'pipe' the SDK exposes a PassThrough immediately (before
+    // the process is spawned), so attaching here captures even early output
+    // from a child that dies during the connection handshake.
+    stdioTransport.stderr?.on('data', (chunk: Buffer) => {
+      if (stderrBuffer.length < STDERR_BUFFER_CAP) {
+        stderrBuffer += chunk.toString('utf8')
+      }
+    })
+    transport = stdioTransport
+  } else {
+    const url = new URL(config.url)
+    for (const [key, value] of Object.entries(config.params)) {
+      url.searchParams.set(key, value)
+    }
+    const headers = substituteEnvInRecord(config.headers)
+    if (config.type === 'http') {
+      transport = new StreamableHTTPClientTransport(url, {
+        requestInit: {
+          headers,
+        },
+      })
+    } else if (config.type === 'sse') {
+      transport = new SSEClientTransport(url, {
+        requestInit: {
+          headers,
+        },
+      })
+    } else {
+      config.type satisfies never
+      throw new Error(`Internal error: invalid MCP config type ${config.type}`)
+    }
+  }
+
+  const client = new Client({
+    name: 'anvil',
+    version: '1.0.0',
+  })
+
+  try {
+    await client.connect(transport)
+  } catch (error) {
+    const baseMessage = getErrorObject(error).message
+    if (config.type === 'stdio') {
+      const commandStr = [config.command, ...(config.args ?? [])].join(' ')
+      const detail = stderrBuffer.trim()
+      throw new Error(
+        `${baseMessage}. Failed to start MCP server via \`${commandStr}\`. ` +
+          `Ensure the command is installed and runnable (e.g. an up-to-date ` +
+          `node/npm/npx, or python/uvx) and that any required env vars are set.` +
+          (detail ? `\nServer stderr:\n${detail}` : ''),
+      )
+    }
+    throw new Error(
+      `${baseMessage}. Failed to connect to MCP server at ${config.url}.`,
+    )
+  }
+  runningClients[key] = client
+
+  return key
+}
+
+export function listMCPTools(
+  clientId: string,
+  ...args: Parameters<typeof Client.prototype.listTools>
+): ReturnType<typeof Client.prototype.listTools> {
+  const client = runningClients[clientId]
+  if (!client) {
+    throw new Error(`listTools: client not found with id: ${clientId}`)
+  }
+  if (!listToolsCache[clientId]) {
+    listToolsCache[clientId] = client.listTools(...args)
+  }
+  return listToolsCache[clientId]
+}
+
+function getResourceData(
+  resource: TextResourceContents | BlobResourceContents,
+): string {
+  if ('text' in resource) return resource.text as string
+  if ('blob' in resource) return resource.blob as string
+  return ''
+}
+
+export async function callMCPTool(
+  clientId: string,
+  ...args: Parameters<typeof Client.prototype.callTool>
+): Promise<ToolResultOutput[]> {
+  const client = runningClients[clientId]
+  if (!client) {
+    throw new Error(`callTool: client not found with id: ${clientId}`)
+  }
+  const callResult = await client.callTool(...args)
+  const result = callResult as CallToolResult
+  const content = result.content
+
+  return content.map((c: (typeof content)[number]) => {
+    if (c.type === 'text') {
+      return {
+        type: 'json',
+        value: c.text,
+      } satisfies ToolResultOutput
+    }
+    if (c.type === 'audio') {
+      return {
+        type: 'media',
+        data: c.data,
+        mediaType: c.mimeType,
+      } satisfies ToolResultOutput
+    }
+    if (c.type === 'image') {
+      return {
+        type: 'media',
+        data: c.data,
+        mediaType: c.mimeType,
+      } satisfies ToolResultOutput
+    }
+    if (c.type === 'resource') {
+      return {
+        type: 'media',
+        data: getResourceData(c.resource),
+        mediaType: c.resource.mimeType ?? 'text/plain',
+      } satisfies ToolResultOutput
+    }
+    const fallbackValue =
+      'uri' in c && typeof (c as { uri: unknown }).uri === 'string'
+        ? (c as { uri: string }).uri
+        : JSON.stringify(c)
+    return {
+      type: 'json',
+      value: fallbackValue,
+    } satisfies ToolResultOutput
+  })
+}

package/vendor/@anvil/common/src/old-constants.ts

@@ -0,0 +1,10 @@
+/**
+ * @deprecated Import from '@anvil/common/constants' or specific files instead:
+ * - '@anvil/common/constants/model-config' for model-related constants
+ * - '@anvil/common/constants/limits' for billing and numeric limits
+ * - '@anvil/common/constants/ui' for auth/user state
+ * - '@anvil/common/constants/paths' for file paths and markers
+ *
+ * This file re-exports all constants for backwards compatibility.
+ */
+export * from './constants'