@alumbwe/anvil 1.0.20 → 1.0.22

package/vendor/@anvil/common/src/project-file-tree.ts

@@ -0,0 +1,355 @@
+import path from 'path'
+
+import * as ignore from 'ignore'
+import { sortBy } from 'lodash'
+
+import { DEFAULT_IGNORED_PATHS } from './constants/paths'
+import { isEnvTemplateFilePath } from './util/env-file-path'
+import { fileExists, isValidProjectRoot } from './util/file'
+import { isPathInside } from './util/path'
+import {
+  addIgnoreFileContents,
+  isIgnoredByIgnoreChain,
+  PROJECT_IGNORE_FILES,
+} from './util/project-ignore'
+
+import type { AnvilFileSystem } from './types/filesystem'
+import type { DirectoryNode, FileTreeNode } from './util/file'
+import type { DirIgnore } from './util/project-ignore'
+
+/**
+ * Logs file tree errors in debug mode only.
+ * Errors are logged but not thrown to preserve tree-building behavior.
+ *
+ * File tree operations commonly encounter expected errors (permissions,
+ * deleted files) that are not fatal. We only log in debug mode to avoid
+ * noisy output during normal operation.
+ */
+function logFileTreeError(
+  operation: string,
+  filePath: string,
+  error: unknown,
+): void {
+  // Only log in debug mode to avoid noisy output
+  if (!process.env.DEBUG && !process.env.ANVIL_DEBUG) {
+    return
+  }
+
+  const err = error as { code?: string } | undefined
+  const code = err?.code
+  const errorMessage = error instanceof Error ? error.message : String(error)
+
+  console.debug(
+    `[FileTree] ${operation} failed for "${filePath}"${
+      code ? ` (${code})` : ''
+    }: ${errorMessage}`,
+  )
+}
+
+export const DEFAULT_MAX_FILES = 10_000
+
+/**
+ * Everything downstream of the file tree is POSIX-only: `ignore` matches
+ * nothing but forward slashes, and glob patterns come from the model in that
+ * form too. `path.relative` returns backslashes on Windows, and `ignore`
+ * answers `false` for them instead of throwing — so nested rules like `build/`
+ * or `node_modules` silently stop pruning and the crawl burns its file budget
+ * on build output before it ever reaches the source tree.
+ */
+function toPosixPath(p: string): string {
+  return p.replace(/\\/g, '/')
+}
+
+function createDefaultIgnore(allowEnvTemplate = false): ignore.Ignore {
+  const defaultIgnore = ignore.default()
+  for (const pattern of DEFAULT_IGNORED_PATHS) {
+    if (allowEnvTemplate && (pattern === '.env' || pattern === '.env.*')) {
+      continue
+    }
+    defaultIgnore.add(pattern)
+  }
+  return defaultIgnore
+}
+
+// When the project root is the home directory (or an ancestor), a full scan
+// could crawl the user's entire disk. Instead of disabling the file tree
+// entirely, do a shallow capped scan so @ mentions still surface
+// `project/docs/file.md`-style paths.
+export const SHALLOW_SCAN_MAX_DEPTH = 3
+const SHALLOW_SCAN_MAX_FILES = 2_000
+const SHALLOW_SCAN_MAX_DIRS = 500
+
+/** Whether `getProjectFileTree` will shallow-scan this root (see above). */
+export function isShallowScanRoot(
+  projectRoot: string | undefined,
+): projectRoot is string {
+  return !!projectRoot && !isValidProjectRoot(projectRoot)
+}
+
+export async function getProjectFileTree(params: {
+  projectRoot: string
+  maxFiles?: number
+  fs: AnvilFileSystem
+}): Promise<FileTreeNode[]> {
+  const withDefaults = { maxFiles: DEFAULT_MAX_FILES, ...params }
+  const { projectRoot, fs } = withDefaults
+  let { maxFiles } = withDefaults
+  let maxDepth = Infinity
+  let maxDirs = Infinity
+
+  const _start = Date.now()
+  const defaultIgnore = createDefaultIgnore()
+
+  if (isShallowScanRoot(projectRoot)) {
+    defaultIgnore.add('.*')
+    maxDepth = SHALLOW_SCAN_MAX_DEPTH
+    maxFiles = Math.min(maxFiles, SHALLOW_SCAN_MAX_FILES)
+    maxDirs = SHALLOW_SCAN_MAX_DIRS
+  }
+
+  const root: DirectoryNode = {
+    name: path.basename(projectRoot),
+    type: 'directory',
+    children: [],
+    filePath: '',
+  }
+  const queue: {
+    node: DirectoryNode
+    fullPath: string
+    ignores: DirIgnore[]
+    depth: number
+  }[] = [
+    {
+      node: root,
+      fullPath: projectRoot,
+      ignores: [{ base: '', ig: defaultIgnore }],
+      depth: 0,
+    },
+  ]
+  let totalFiles = 0
+  let dirsScanned = 0
+
+  while (queue.length > 0 && totalFiles < maxFiles && dirsScanned < maxDirs) {
+    const { node, fullPath, ignores, depth } = queue.shift()!
+    dirsScanned++
+    const dirIgnores = [
+      ...ignores,
+      {
+        base: toPosixPath(path.relative(projectRoot, fullPath)),
+        ig: await parseGitignore({ fullDirPath: fullPath, fs }),
+      },
+    ]
+
+    try {
+      const files = await fs.readdir(fullPath)
+      for (const file of files) {
+        if (totalFiles >= maxFiles) break
+
+        const filePath = path.join(fullPath, file)
+        const relativeFilePath = toPosixPath(path.relative(projectRoot, filePath))
+
+        if (isIgnoredByIgnoreChain(dirIgnores, relativeFilePath)) continue
+
+        try {
+          const stats = await fs.stat(filePath)
+          if (stats.isDirectory()) {
+            const childNode: DirectoryNode = {
+              name: file,
+              type: 'directory',
+              children: [],
+              filePath: relativeFilePath,
+            }
+            node.children.push(childNode)
+            // Past maxDepth the directory still shows up as a node above, but
+            // its contents are not scanned.
+            if (depth + 1 < maxDepth) {
+              queue.push({
+                node: childNode,
+                fullPath: filePath,
+                ignores: dirIgnores,
+                depth: depth + 1,
+              })
+            }
+          } else {
+            const lastReadTime = stats.atimeMs
+            node.children.push({
+              name: file,
+              type: 'file',
+              lastReadTime,
+              filePath: relativeFilePath,
+            })
+            totalFiles++
+          }
+        } catch (error: unknown) {
+          // File may be inaccessible due to permissions or may have been deleted.
+          // Log with context for debugging, but continue building the tree.
+          logFileTreeError('fs.stat', filePath, error)
+        }
+      }
+    } catch (error: unknown) {
+      // Directory may be inaccessible due to permissions.
+      // Log with context for debugging, but continue building the tree.
+      logFileTreeError('fs.readdir', fullPath, error)
+    }
+  }
+  return root.children
+}
+
+async function parseGitignoreWithMode(params: {
+  fullDirPath: string
+  fs: AnvilFileSystem
+  throwOnReadError: boolean
+}): Promise<ignore.Ignore> {
+  const { fullDirPath, fs, throwOnReadError } = params
+
+  const ig = ignore.default()
+  const directoryEntries = throwOnReadError
+    ? new Set(await fs.readdir(fullDirPath))
+    : undefined
+
+  for (const fileName of PROJECT_IGNORE_FILES) {
+    const ignoreFilePath = path.join(fullDirPath, fileName)
+    if (directoryEntries) {
+      if (!directoryEntries.has(fileName)) continue
+    } else {
+      const ignoreFileExists = await fileExists({ filePath: ignoreFilePath, fs })
+      if (!ignoreFileExists) continue
+    }
+
+    let ignoreContent: string
+    try {
+      ignoreContent = await fs.readFile(ignoreFilePath, 'utf8')
+    } catch (error: unknown) {
+      // Resilient file-tree callers continue without unreadable rules. Access
+      // checks can opt into throwing so their caller can fail closed.
+      logFileTreeError('fs.readFile (ignore file)', ignoreFilePath, error)
+      if (throwOnReadError) throw error
+      continue
+    }
+    addIgnoreFileContents(ig, ignoreContent, (pattern, error) =>
+      logFileTreeError('ignore.add (pattern)', pattern, error),
+    )
+  }
+
+  return ig
+}
+
+export async function parseGitignore(params: {
+  fullDirPath: string
+  fs: AnvilFileSystem
+}): Promise<ignore.Ignore> {
+  return parseGitignoreWithMode({ ...params, throwOnReadError: false })
+}
+
+export function getAllFilePaths(
+  nodes: FileTreeNode[],
+  basePath: string = '',
+): string[] {
+  return nodes.flatMap((node) => {
+    if (node.type === 'file') {
+      return [path.join(basePath, node.name)]
+    }
+    return getAllFilePaths(node.children || [], path.join(basePath, node.name))
+  })
+}
+
+export interface PathInfo {
+  path: string
+  isDirectory: boolean
+}
+
+export function getAllPathsWithDirectories(
+  nodes: FileTreeNode[],
+  basePath: string = '',
+): PathInfo[] {
+  return nodes.flatMap((node) => {
+    const nodePath = basePath ? path.join(basePath, node.name) : node.name
+    if (node.type === 'file') {
+      return [{ path: nodePath, isDirectory: false }]
+    }
+    // Include the directory itself, plus recurse into children
+    const dirEntry: PathInfo = { path: nodePath, isDirectory: true }
+    const children = getAllPathsWithDirectories(node.children || [], nodePath)
+    return [dirEntry, ...children]
+  })
+}
+
+export function flattenTree(nodes: FileTreeNode[]): FileTreeNode[] {
+  return nodes.flatMap((node) => {
+    if (node.type === 'file') {
+      return [node]
+    }
+    return flattenTree(node.children ?? [])
+  })
+}
+
+export function getLastReadFilePaths(
+  flattenedNodes: FileTreeNode[],
+  count: number,
+) {
+  return sortBy(
+    flattenedNodes.filter((node) => node.lastReadTime),
+    'lastReadTime',
+  )
+    .reverse()
+    .slice(0, count)
+    .map((node) => node.filePath)
+}
+
+export async function isFileIgnored(params: {
+  filePath: string
+  projectRoot: string
+  fs: AnvilFileSystem
+  /** Allow the env template past built-in rules while strictly applying project rules. */
+  allowEnvTemplate?: boolean
+}): Promise<boolean> {
+  const {
+    filePath,
+    projectRoot,
+    fs,
+    allowEnvTemplate: allowEnvTemplateRequested = false,
+  } = params
+  const allowEnvTemplate =
+    allowEnvTemplateRequested && isEnvTemplateFilePath(filePath)
+
+  const resolvedProjectRoot = path.resolve(projectRoot)
+  const fullFilePath = path.resolve(resolvedProjectRoot, filePath)
+  if (!isPathInside(resolvedProjectRoot, fullFilePath)) return false
+
+  const defaultIgnore = createDefaultIgnore(allowEnvTemplate)
+
+  const relativeFilePath = toPosixPath(
+    path.relative(resolvedProjectRoot, fullFilePath),
+  )
+
+  // Get ignore patterns from the directory containing the file and all parent directories
+  const dirIgnores: DirIgnore[] = []
+  let currentDir = path.dirname(fullFilePath)
+  while (true) {
+    let ig: ignore.Ignore
+    try {
+      ig = await parseGitignoreWithMode({
+        fullDirPath: currentDir,
+        fs,
+        throwOnReadError: allowEnvTemplate,
+      })
+    } catch (error) {
+      if (allowEnvTemplate) return true
+      throw error
+    }
+    dirIgnores.push({
+      base: toPosixPath(path.relative(resolvedProjectRoot, currentDir)),
+      ig,
+    })
+    if (path.relative(resolvedProjectRoot, currentDir) === '') break
+
+    const parentDir = path.dirname(currentDir)
+    if (parentDir === currentDir) break
+    currentDir = parentDir
+  }
+
+  return isIgnoredByIgnoreChain(
+    [{ base: '', ig: defaultIgnore }, ...dirIgnores.reverse()],
+    relativeFilePath,
+  )
+}

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

@@ -0,0 +1,254 @@
+import { createHash } from 'node:crypto'
+
+import { IS_PROD } from '@anvil/common/env'
+import { extractClientIp } from '@anvil/common/util/rate-limit'
+import type { Logger } from '@anvil/common/types/contracts/logger'
+import type { RedditCapiEventName } from '@anvil/common/util/reddit-capi-events'
+
+export type { RedditCapiEventName }
+
+/** Reddit Ads pixel ID (public, also used for CAPI endpoint). */
+export const REDDIT_PIXEL_ID = 'a2_j6o59svbxzzn'
+
+const REDDIT_CAPI_ENDPOINT = `https://ads-api.reddit.com/api/v3/pixels/${REDDIT_PIXEL_ID}/conversion_events`
+
+export type RedditActionSource = 'WEBSITE' | 'APP' | 'PHYSICAL_STORE' | 'OTHER'
+
+export type RedditCapiUser = {
+  email?: string | null
+  externalId?: string | null
+  ipAddress?: string | null
+  userAgent?: string | null
+  clickId?: string | null
+  uuid?: string | null
+}
+
+function sha256(value: string): string {
+  return createHash('sha256').update(value).digest('hex')
+}
+
+function normalizeEmail(email: string): string {
+  const normalized = email.trim().toLowerCase()
+  const atIndex = normalized.lastIndexOf('@')
+  if (atIndex <= 0 || atIndex === normalized.length - 1) {
+    return normalized
+  }
+  const local = normalized.slice(0, atIndex)
+  const domain = normalized.slice(atIndex + 1)
+  return `${local.split('+')[0]?.replaceAll('.', '')}@${domain}`
+}
+
+export function buildRedditCapiUserPayload(user: RedditCapiUser) {
+  const payload: Record<string, string> = {}
+
+  if (user.email) {
+    payload.email = sha256(normalizeEmail(user.email))
+  }
+  if (user.externalId) {
+    payload.external_id = sha256(user.externalId.trim())
+  }
+  if (user.ipAddress) {
+    payload.ip_address = user.ipAddress
+  }
+  if (user.userAgent) {
+    payload.user_agent = user.userAgent
+  }
+  if (user.uuid) {
+    payload.uuid = user.uuid
+  }
+
+  return Object.keys(payload).length > 0 ? payload : undefined
+}
+
+export type SendRedditCustomConversionParams = {
+  /** Conversion access token from Reddit Events Manager (env-provided; no-op when unset). */
+  accessToken: string | undefined
+  customEventName: RedditCapiEventName
+  conversionId: string
+  actionSource: RedditActionSource
+  eventAt?: number
+  eventSourceUrl?: string
+  testId?: string
+  user: RedditCapiUser
+  fetchImpl?: typeof fetch
+  logger?: Logger
+  enabled?: boolean
+  sleepImpl?: (ms: number) => Promise<void>
+}
+
+export type RedditCapiDeliveryResult = 'sent' | 'disabled'
+
+export class RedditCapiDeliveryError extends Error {
+  constructor(
+    message: string,
+    readonly status?: number,
+  ) {
+    super(message)
+    this.name = 'RedditCapiDeliveryError'
+  }
+}
+
+function eventSourceUrlWithClickId(
+  eventSourceUrl: string | undefined,
+  clickId: string | null | undefined,
+): string | undefined {
+  if (!eventSourceUrl || !clickId) return eventSourceUrl
+  try {
+    const url = new URL(eventSourceUrl)
+    if (!url.searchParams.has('rdt_cid')) {
+      url.searchParams.set('rdt_cid', clickId)
+    }
+    return url.toString()
+  } catch {
+    return eventSourceUrl
+  }
+}
+
+export function buildRedditCustomConversionBody(
+  params: Pick<
+    SendRedditCustomConversionParams,
+    | 'customEventName'
+    | 'conversionId'
+    | 'actionSource'
+    | 'eventAt'
+    | 'eventSourceUrl'
+    | 'testId'
+    | 'user'
+  >,
+) {
+  const user = buildRedditCapiUserPayload(params.user)
+  const eventSourceUrl = eventSourceUrlWithClickId(
+    params.eventSourceUrl,
+    params.user.clickId,
+  )
+
+  return {
+    data: {
+      ...(params.testId ? { test_id: params.testId } : {}),
+      events: [
+        {
+          event_at: params.eventAt ?? Date.now(),
+          action_source: params.actionSource,
+          ...(eventSourceUrl ? { event_source_url: eventSourceUrl } : {}),
+          type: {
+            tracking_type: 'CUSTOM',
+            custom_event_name: params.customEventName,
+          },
+          ...(params.user.clickId ? { click_id: params.user.clickId } : {}),
+          metadata: {
+            conversion_id: params.conversionId,
+          },
+          ...(user ? { user } : {}),
+        },
+      ],
+    },
+  }
+}
+
+function isRetryableStatus(status: number): boolean {
+  return status === 408 || status === 429 || status >= 500
+}
+
+const sleep = (ms: number) =>
+  new Promise<void>((resolve) => setTimeout(resolve, ms))
+
+/** Deliver one custom event, retrying one transient failure. */
+export async function sendRedditCustomConversion(
+  params: SendRedditCustomConversionParams,
+): Promise<RedditCapiDeliveryResult> {
+  if (!(params.enabled ?? IS_PROD) || !params.accessToken) {
+    return 'disabled'
+  }
+
+  const fetchImpl = params.fetchImpl ?? fetch
+  const body = buildRedditCustomConversionBody(params)
+  const sleepImpl = params.sleepImpl ?? sleep
+
+  for (let attempt = 1; attempt <= 2; attempt += 1) {
+    try {
+      const response = await fetchImpl(REDDIT_CAPI_ENDPOINT, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${params.accessToken}`,
+          'Content-Type': 'application/json',
+          'User-Agent': 'anvil/1.0 (reddit-capi)',
+        },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(3_000),
+      })
+      if (response.ok) {
+        params.logger?.info(
+          {
+            customEventName: params.customEventName,
+            conversionId: params.conversionId,
+            attempt,
+          },
+          'Reddit CAPI conversion delivered',
+        )
+        return 'sent'
+      }
+
+      const responseBody = (await response.text().catch(() => '')).slice(0, 500)
+      if (attempt === 1 && isRetryableStatus(response.status)) {
+        await sleepImpl(100)
+        continue
+      }
+      throw new RedditCapiDeliveryError(
+        `Reddit CAPI rejected ${params.customEventName} (${response.status}): ${responseBody}`,
+        response.status,
+      )
+    } catch (error) {
+      if (
+        attempt === 1 &&
+        (!(error instanceof RedditCapiDeliveryError) ||
+          (error.status !== undefined && isRetryableStatus(error.status)))
+      ) {
+        await sleepImpl(100)
+        continue
+      }
+      params.logger?.warn(
+        {
+          error,
+          customEventName: params.customEventName,
+          conversionId: params.conversionId,
+          attempt,
+        },
+        'Reddit CAPI conversion request failed',
+      )
+      if (error instanceof RedditCapiDeliveryError) throw error
+      throw new RedditCapiDeliveryError(
+        `Reddit CAPI request failed for ${params.customEventName}`,
+      )
+    }
+  }
+
+  throw new RedditCapiDeliveryError(
+    `Reddit CAPI request failed for ${params.customEventName}`,
+  )
+}
+
+export function redditConversionId(
+  event: RedditCapiEventName,
+  userId: string,
+): string {
+  return sha256(`${event}:${userId}`)
+}
+
+/**
+ * Identity fields shared by every server-side Reddit conversion call, built
+ * from the incoming request's headers. Surface-specific attribution (click id,
+ * uuid) is layered on by callers that have it.
+ */
+export function redditUserFromRequestHeaders(params: {
+  userId: string
+  email?: string | null
+  headers: { get(name: string): string | null }
+}): RedditCapiUser {
+  const ip = extractClientIp(params.headers)
+  return {
+    email: params.email,
+    externalId: params.userId,
+    ipAddress: ip === 'unknown' ? undefined : ip,
+    userAgent: params.headers.get('user-agent')?.trim() || undefined,
+  }
+}

package/vendor/@anvil/common/src/schemas/feedback.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod/v4'
+
+import {
+  FEEDBACK_CATEGORIES,
+  FEEDBACK_SOURCES,
+  MAX_ERRORS,
+  MAX_ERROR_ID_LENGTH,
+  MAX_ERROR_MESSAGE_LENGTH,
+  MAX_RECENT_MESSAGES,
+  MESSAGE_VARIANTS,
+} from '../constants/feedback'
+
+export const feedbackRequestSchema = z.object({
+  text: z.string().trim().min(1),
+  category: z.enum(FEEDBACK_CATEGORIES),
+  type: z.enum(['message', 'general']),
+  clientFeedbackId: z.string().uuid().optional(),
+  source: z.enum(FEEDBACK_SOURCES).optional(),
+  appVersion: z.string().max(100).optional(),
+  platform: z.string().max(100).optional(),
+  messageId: z.string().min(1).max(200).optional(),
+  messageVariant: z.enum(MESSAGE_VARIANTS).optional(),
+  completionTime: z.string().max(50).optional(),
+  credits: z.number().nonnegative().finite().optional(),
+  agentMode: z.string().max(100).optional(),
+  sessionCreditsUsed: z.number().nonnegative().finite().optional(),
+  recentMessages: z
+    .array(
+      z.object({
+        type: z.enum(MESSAGE_VARIANTS),
+        id: z.string().max(200),
+        completionTime: z.string().max(50).optional(),
+        credits: z.number().nonnegative().finite().optional(),
+      }),
+    )
+    .max(MAX_RECENT_MESSAGES)
+    .optional(),
+  errors: z
+    .array(
+      z.object({
+        id: z.string().max(MAX_ERROR_ID_LENGTH),
+        message: z.string().max(MAX_ERROR_MESSAGE_LENGTH),
+      }),
+    )
+    .max(MAX_ERRORS)
+    .optional(),
+}).refine(
+  (data) => data.type !== 'message' || (data.messageId != null && data.messageId !== ''),
+  { message: 'messageId is required when type is "message"', path: ['messageId'] },
+)
+
+export type FeedbackRequest = z.infer<typeof feedbackRequestSchema>