@alumbwe/anvil 1.0.20 → 1.0.22

package/vendor/@anvil/common/src/util/agent-name-normalization.ts

@@ -0,0 +1,38 @@
+export const DEFAULT_ORG_PREFIX = 'anvil/'
+
+/**
+ * Resolves an agent ID by trying multiple strategies:
+ * 1. Direct lookup in registry
+ * 2. Try with DEFAULT_ORG_PREFIX for spawnable agents
+ * 3. Return null if not found
+ *
+ * This provides a more robust alternative to string concatenation
+ * and handles the common case where users reference spawnable agents
+ * without the org prefix.
+ */
+export function resolveAgentId(
+  agentId: string,
+  agentRegistry: Record<string, any>,
+): string | null {
+  // Handle empty or invalid input
+  if (!agentId || typeof agentId !== 'string') {
+    return null
+  }
+
+  // Try direct lookup first
+  if (agentId in agentRegistry) {
+    return agentId
+  }
+
+  // Try with DEFAULT_ORG_PREFIX for spawnable agents
+  // Only add prefix if the agent ID doesn't already contain a slash
+  // (to avoid double-prefixing or interfering with other org prefixes)
+  if (!agentId.includes('/')) {
+    const prefixedAgentId = `${DEFAULT_ORG_PREFIX}${agentId}`
+    if (prefixedAgentId in agentRegistry) {
+      return prefixedAgentId
+    }
+  }
+
+  return null
+}

package/vendor/@anvil/common/src/util/agent-name-resolver.ts

@@ -0,0 +1,86 @@
+import { AGENT_PERSONAS } from '../constants/agents'
+
+export interface AgentInfo {
+  id: string
+  displayName: string
+  purpose?: string
+  isBuiltIn: boolean
+}
+
+/**
+ * Get all built-in agents (excluding hidden ones)
+ */
+export function getBuiltInAgents(): AgentInfo[] {
+  return Object.entries(AGENT_PERSONAS)
+    .filter(([, persona]) => !('hidden' in persona) || !persona.hidden)
+    .map(([agentId, persona]) => ({
+      id: agentId,
+      displayName: persona.displayName,
+      purpose: persona.purpose,
+      isBuiltIn: true,
+    }))
+}
+
+/**
+ * Convert local agent configs to AgentInfo array
+ */
+export function getLocalAgents(
+  localAgents: Record<string, { displayName: string; purpose?: string }>,
+): AgentInfo[] {
+  return Object.entries(localAgents).map(([agentId, config]) => ({
+    id: agentId,
+    displayName: config.displayName,
+    purpose: config.purpose,
+    isBuiltIn: false,
+  }))
+}
+
+/**
+ * Get all agents (built-in + local)
+ */
+export function getAllAgents(
+  localAgents: Record<string, { displayName: string; purpose?: string }> = {},
+): AgentInfo[] {
+  return [...getBuiltInAgents(), ...getLocalAgents(localAgents)]
+}
+
+/**
+ * Resolve display name to agent ID
+ */
+export function resolveNameToId(
+  displayName: string,
+  localAgents: Record<string, { displayName: string; purpose?: string }> = {},
+): string | null {
+  const agents = getAllAgents(localAgents)
+  const agent = agents.find(
+    (a) => a.displayName.toLowerCase() === displayName.toLowerCase(),
+  )
+  return agent?.id || null
+}
+
+/**
+ * Resolve agent ID to display name
+ */
+function resolveIdToName(
+  agentId: string,
+  localAgents: Record<string, { displayName: string; purpose?: string }> = {},
+): string | null {
+  const agents = getAllAgents(localAgents)
+  const agent = agents.find((a) => a.id === agentId)
+  return agent?.displayName || null
+}
+
+/**
+ * Get agent display name from ID or name, with fallback
+ */
+export function getAgentDisplayName(
+  agentIdOrName: string,
+  localAgents: Record<string, { displayName: string; purpose?: string }> = {},
+): string {
+  return (
+    resolveIdToName(agentIdOrName, localAgents) ||
+    (resolveNameToId(agentIdOrName, localAgents)
+      ? agentIdOrName
+      : agentIdOrName)
+  )
+}

package/vendor/@anvil/common/src/util/analytics-dispatcher.ts

@@ -0,0 +1,82 @@
+
+import {
+  getAnalyticsEventId,
+  toTrackableAnalyticsPayload,
+  type AnalyticsLogData,
+  type TrackableAnalyticsPayload,
+} from './analytics-log'
+
+type EnvName = 'dev' | 'test' | 'prod' | string
+
+export type AnalyticsDispatchInput = {
+  data: unknown
+  level: string
+  msg: string
+  fallbackUserId?: string
+}
+
+export type AnalyticsDispatchPayload = TrackableAnalyticsPayload
+
+/**
+ * Minimal, runtime-agnostic router for analytics events.
+ * Handles:
+ *  - Dev gating (no-op in dev)
+ *  - Optional buffering until a userId is available
+ *  - Reusing the shared payload builder for consistency
+ */
+export function createAnalyticsDispatcher({
+  envName,
+  bufferWhenNoUser = false,
+}: {
+  envName: EnvName
+  bufferWhenNoUser?: boolean
+}) {
+  const buffered: AnalyticsDispatchInput[] = []
+  const isDevEnv = envName === 'dev'
+
+  function flushBufferWithUser(
+    userId: string,
+  ): AnalyticsDispatchPayload[] {
+    if (!buffered.length) {
+      return []
+    }
+
+    const toSend: AnalyticsDispatchPayload[] = []
+    for (const item of buffered.splice(0)) {
+      const rebuilt = toTrackableAnalyticsPayload({
+        ...item,
+        fallbackUserId: userId,
+      })
+      if (rebuilt) {
+        toSend.push(rebuilt)
+      }
+    }
+    return toSend
+  }
+
+  function process(
+    input: AnalyticsDispatchInput,
+  ): AnalyticsDispatchPayload[] {
+    if (isDevEnv) {
+      return []
+    }
+
+    const payload = toTrackableAnalyticsPayload(input)
+    if (payload) {
+      const toSend = flushBufferWithUser(payload.userId)
+      toSend.push(payload)
+      return toSend
+    }
+
+    if (
+      bufferWhenNoUser &&
+      getAnalyticsEventId(input.data as AnalyticsLogData)
+    ) {
+      buffered.push(input)
+    }
+
+    return []
+  }
+
+  return { process }
+}

package/vendor/@anvil/common/src/util/analytics-log.ts

@@ -0,0 +1,78 @@
+import { AnalyticsEvent } from '@anvil/common/constants/analytics-events'
+
+// Build PostHog payloads from log data in a single, shared place
+export type AnalyticsLogData = {
+  eventId?: unknown
+  userId?: unknown
+  user_id?: unknown
+  user?: { id?: unknown }
+  [key: string]: unknown
+}
+
+export type TrackableAnalyticsPayload = {
+  event: AnalyticsEvent
+  userId: string
+  properties: Record<string, unknown>
+}
+
+const analyticsEvents = new Set<AnalyticsEvent>(Object.values(AnalyticsEvent))
+
+const toStringOrNull = (value: unknown): string | null =>
+  typeof value === 'string' ? value : null
+
+const getUserId = (
+  record: AnalyticsLogData,
+  fallbackUserId?: string,
+): string | null =>
+  toStringOrNull(record.userId) ??
+  toStringOrNull(record.user_id) ??
+  toStringOrNull(record.user?.id) ??
+  toStringOrNull(fallbackUserId)
+
+export function getAnalyticsEventId(data: unknown): AnalyticsEvent | null {
+  if (!data || typeof data !== 'object') {
+    return null
+  }
+  const eventId = (data as AnalyticsLogData).eventId
+  return analyticsEvents.has(eventId as AnalyticsEvent)
+    ? (eventId as AnalyticsEvent)
+    : null
+}
+
+export function toTrackableAnalyticsPayload({
+  data,
+  level,
+  msg,
+  fallbackUserId,
+}: {
+  data: unknown
+  level: string
+  msg: string
+  fallbackUserId?: string
+}): TrackableAnalyticsPayload | null {
+  if (!data || typeof data !== 'object') {
+    return null
+  }
+
+  const record = data as AnalyticsLogData
+  const eventId = getAnalyticsEventId(record)
+  if (!eventId) {
+    return null
+  }
+
+  const userId = getUserId(record, fallbackUserId)
+
+  if (!userId) {
+    return null
+  }
+
+  return {
+    event: eventId,
+    userId,
+    properties: {
+      ...record,
+      level,
+      msg,
+    },
+  }
+}

package/vendor/@anvil/common/src/util/analytics-sampling.ts

@@ -0,0 +1,255 @@
+import { AnalyticsEvent } from '../constants/analytics-events'
+
+const DEFAULT_SAMPLED_RATE = 0.01
+
+const SAMPLED_EVENT_RATES: Partial<Record<AnalyticsEvent, number>> = {
+  [AnalyticsEvent.AGENT_STEP]: DEFAULT_SAMPLED_RATE,
+  [AnalyticsEvent.CLI_LOG]: DEFAULT_SAMPLED_RATE,
+  [AnalyticsEvent.FEEDBACK_BUTTON_HOVERED]: DEFAULT_SAMPLED_RATE,
+  [AnalyticsEvent.FOLLOWUP_CLICKED]: DEFAULT_SAMPLED_RATE,
+  [AnalyticsEvent.CLI_INLINE_AD_SLOT_ELIGIBLE]: DEFAULT_SAMPLED_RATE,
+  [AnalyticsEvent.SLASH_COMMAND_USED]: DEFAULT_SAMPLED_RATE,
+  [AnalyticsEvent.SLASH_MENU_ACTIVATED]: DEFAULT_SAMPLED_RATE,
+  [AnalyticsEvent.TOOL_USE]: DEFAULT_SAMPLED_RATE,
+}
+
+const ALWAYS_TRACK_EVENTS = new Set<AnalyticsEvent>([
+  // DAU is measured from MESSAGE_SENT, so it must never be sampled.
+  AnalyticsEvent.MESSAGE_SENT,
+  // Engaged-time is summed from event counts, so it must never be sampled.
+  AnalyticsEvent.PRODUCT_ACTIVE_MINUTE,
+  AnalyticsEvent.APP_LAUNCHED,
+  AnalyticsEvent.CHANGE_DIRECTORY,
+  AnalyticsEvent.FINGERPRINT_GENERATED,
+  AnalyticsEvent.INVALID_COMMAND,
+  AnalyticsEvent.KNOWLEDGE_FILE_UPDATED,
+  AnalyticsEvent.LOGIN,
+  AnalyticsEvent.LOGIN_STARTED,
+  AnalyticsEvent.LOGIN_FAILED,
+  AnalyticsEvent.LOGIN_TIMEOUT,
+  AnalyticsEvent.LOGIN_ABORTED,
+  // Desktop surface events are low-volume; keep them whole so the app's launch /
+  // login / activity funnels aren't decimated by the 1% default sample.
+  AnalyticsEvent.DESKTOP_APP_LAUNCHED,
+  // Both halves of the sign-in funnel, or its conversion rate is a ratio of two
+  // differently-sampled numbers.
+  AnalyticsEvent.DESKTOP_LOGIN_STARTED,
+  AnalyticsEvent.DESKTOP_LOGIN,
+  // Rare, and the only evidence a sign-in failed at all — a sampled one is a
+  // support ticket with nothing behind it.
+  AnalyticsEvent.DESKTOP_LOGIN_FAILED,
+  AnalyticsEvent.DESKTOP_LOGOUT,
+  AnalyticsEvent.DESKTOP_THREAD_CREATED,
+  AnalyticsEvent.DESKTOP_PROJECT_OPENED,
+  AnalyticsEvent.DESKTOP_TURN_COMPLETED,
+  // Low-volume recovery funnel. Sampling any stage independently would make
+  // creation-to-success and repeated-failure rates impossible to measure.
+  AnalyticsEvent.DESKTOP_FAILED_TURN_RECOVERY,
+  // Rare reliability signal — every stalled turn must be counted, never sampled.
+  AnalyticsEvent.DESKTOP_TURN_STALLED,
+  // Its counterpart (an explained silence). Same reasoning: rare, and only
+  // useful if every one is counted.
+  AnalyticsEvent.DESKTOP_TURN_BACKGROUND_WAIT,
+  // Feature adoption is measured as UNIQUE USERS per feature. At desktop's
+  // ~1-2k DAU a 1% sample would leave a feature used by 2% of users with
+  // roughly zero sampled users — the number is unrecoverable from a sample, so
+  // this one is never sampled. Volume is controlled at the emit site instead
+  // (intent-only actions + per-session dedupe), not by throwing away users.
+  AnalyticsEvent.DESKTOP_FEATURE_USED,
+  AnalyticsEvent.DESKTOP_HARNESS_CHANGED,
+  AnalyticsEvent.DESKTOP_MODEL_CHANGED,
+  AnalyticsEvent.DESKTOP_SKILL_RUN,
+  AnalyticsEvent.DESKTOP_CODEX_RESOLUTION,
+  // Rare operational signal. Sampling would make per-version failure rates
+  // misleading precisely when a Windows-only regression affects few installs.
+  AnalyticsEvent.TERMINAL_BROKER_SPAWN_FAILED,
+  AnalyticsEvent.TERMINAL_WATCHDOG_FAILED,
+  AnalyticsEvent.TERMINAL_COMMAND_COMPLETED,
+  AnalyticsEvent.UPDATE_ANVIL_FAILED,
+  AnalyticsEvent.USER_INPUT,
+  AnalyticsEvent.USER_INPUT_COMPLETE,
+])
+
+type AnalyticsProperties = Record<string, unknown> | undefined
+
+function getStringProperty(
+  properties: AnalyticsProperties,
+  key: string,
+): string | undefined {
+  const value = properties?.[key]
+  return typeof value === 'string' && value.trim() ? value : undefined
+}
+
+function getPropertyUserId(
+  properties: AnalyticsProperties,
+): string | undefined {
+  const direct =
+    getStringProperty(properties, 'userId') ??
+    getStringProperty(properties, 'user_id') ??
+    getStringProperty(properties, 'distinct_id')
+  if (direct) {
+    return direct
+  }
+
+  const user = properties?.user
+  if (user && typeof user === 'object') {
+    const id = (user as { id?: unknown }).id
+    return typeof id === 'string' && id.trim() ? id : undefined
+  }
+
+  return undefined
+}
+
+function splitEnvList(value: string | undefined): Set<string> {
+  return new Set(
+    (value ?? '')
+      .split(',')
+      .map((item) => item.trim())
+      .filter(Boolean),
+  )
+}
+
+function isTruthyEnv(value: string | undefined): boolean {
+  return value === '1' || value === 'true' || value === 'yes'
+}
+
+export function isFullTelemetryEnabled(params: {
+  distinctId?: string
+  properties?: AnalyticsProperties
+}): boolean {
+  if (isTruthyEnv(process.env.ANVIL_FULL_TELEMETRY)) {
+    return true
+  }
+
+  const ids = splitEnvList(
+    process.env.ANVIL_FULL_TELEMETRY_IDS ??
+      process.env.ANVIL_FULL_TELEMETRY_USER_IDS,
+  )
+  if (ids.size === 0) {
+    return false
+  }
+
+  const candidates = [
+    params.distinctId,
+    getPropertyUserId(params.properties),
+    getStringProperty(params.properties, 'userEmail'),
+    getStringProperty(params.properties, 'email'),
+  ].filter(
+    (value): value is string => typeof value === 'string' && value.length > 0,
+  )
+
+  return candidates.some((candidate) => ids.has(candidate))
+}
+
+function getEventSampleRate(
+  event: AnalyticsEvent,
+  properties: AnalyticsProperties,
+): number {
+  const level = getStringProperty(properties, 'level')?.toLowerCase()
+  if (
+    event === AnalyticsEvent.CLI_LOG &&
+    (level === 'error' || level === 'fatal')
+  ) {
+    return 1
+  }
+
+  if (ALWAYS_TRACK_EVENTS.has(event)) {
+    return 1
+  }
+
+  return SAMPLED_EVENT_RATES[event] ?? 1
+}
+
+/**
+ * Deterministic sampling for high-volume logs/events: hashes a stable key
+ * (typically a userId) so the same key is always in or out of the sample and
+ * per-key funnels stay coherent. Callers should record the rate on sampled
+ * rows (e.g. `sampleRate: 0.02`) so counts can be re-inflated in queries.
+ */
+export function shouldSampleByKey(key: string, rate: number): boolean {
+  if (rate >= 1) return true
+  if (rate <= 0) return false
+  return hashString(key) / 0xffffffff < rate
+}
+
+function hashString(input: string): number {
+  let hash = 2166136261
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i)
+    hash = Math.imul(hash, 16777619)
+  }
+  return hash >>> 0
+}
+
+function getSamplingKey(params: {
+  event: AnalyticsEvent
+  distinctId?: string
+  properties?: AnalyticsProperties
+}): string {
+  return (
+    params.distinctId ??
+    getPropertyUserId(params.properties) ??
+    getStringProperty(params.properties, 'clientSessionId') ??
+    getStringProperty(params.properties, 'userInputId') ??
+    params.event
+  )
+}
+
+export function shouldTrackAnalyticsEvent(params: {
+  event: AnalyticsEvent
+  distinctId?: string
+  properties?: AnalyticsProperties
+}): boolean {
+  if (isFullTelemetryEnabled(params)) {
+    return true
+  }
+
+  const rate = getEventSampleRate(params.event, params.properties)
+  if (rate >= 1) {
+    return true
+  }
+  if (rate <= 0) {
+    return false
+  }
+
+  const bucket =
+    hashString(`${params.event}:${getSamplingKey(params)}`) / 0xffffffff
+  return bucket < rate
+}
+
+function valueKind(value: unknown): string {
+  if (Array.isArray(value)) {
+    return 'array'
+  }
+  if (value === null) {
+    return 'null'
+  }
+  return typeof value
+}
+
+export function summarizeAnalyticsValue(
+  value: unknown,
+): Record<string, unknown> {
+  if (value === null || value === undefined) {
+    return { kind: valueKind(value) }
+  }
+
+  if (typeof value === 'string') {
+    return { kind: 'string', length: value.length }
+  }
+
+  if (Array.isArray(value)) {
+    return { kind: 'array', length: value.length }
+  }
+
+  if (typeof value === 'object') {
+    const keys = Object.keys(value as Record<string, unknown>)
+    return {
+      kind: 'object',
+      keyCount: keys.length,
+      keys: keys.slice(0, 25),
+    }
+  }
+
+  return { kind: valueKind(value) }
+}

package/vendor/@anvil/common/src/util/anvil-model-availability.ts

@@ -0,0 +1,102 @@
+/**
+ * One line answering "why these models?" for a user whose account resolved to
+ * the reduced catalog.
+ *
+ * Tone matters here: this is shown to users who, through no fault of their own,
+ * get the smaller model set. Frame it as model *availability* ("aren't
+ * available in BR yet"), never as restricted *access* ("limited mode",
+ * "blocked") — clear enough to answer the question for someone who goes
+ * looking, quiet enough to ignore for someone who doesn't. The VPN case is the
+ * one the user can act on, so it leads with the action.
+ *
+ * Shared by the CLI landing picker and the Desktop model menu so the two
+ * surfaces cannot drift — a user who reads it in one and asks support about the
+ * other should be told the same thing.
+ */
+
+import type {
+  AnvilIpPrivacySignal,
+  AnvilLimitedModeReason,
+} from '../types/anvil-session'
+
+const PRIVACY_SIGNAL_LABELS: Partial<Record<AnvilIpPrivacySignal, string>> = {
+  anonymous: 'anonymized network',
+  proxy: 'proxy',
+  relay: 'relay',
+  res_proxy: 'residential proxy',
+  tor: 'Tor',
+  vpn: 'VPN',
+  hosting: 'hosting network',
+  service: 'privacy service',
+}
+
+export function formatAnvilPrivacySignalList(
+  signals: readonly AnvilIpPrivacySignal[] | null | undefined,
+): string {
+  const labels = Array.from(
+    new Set(
+      signals
+        ?.map((signal) => PRIVACY_SIGNAL_LABELS[signal])
+        .filter((label): label is string => Boolean(label)) ?? [],
+    ),
+  )
+
+  if (labels.length === 0) {
+    return 'VPN, Tor, proxy, relay, or anonymized network'
+  }
+  if (labels.length === 1) return labels[0]
+  if (labels.length === 2) return `${labels[0]} or ${labels[1]}`
+  return `${labels.slice(0, -1).join(', ')}, or ${labels[labels.length - 1]}`
+}
+
+/** "BR" → "Brazil". Falls back to the raw code when the runtime can't
+ *  resolve it (malformed code, missing ICU data). */
+export function formatAnvilCountryName(countryCode: string): string {
+  try {
+    return (
+      new Intl.DisplayNames(['en'], { type: 'region' }).of(countryCode) ??
+      countryCode
+    )
+  } catch {
+    return countryCode
+  }
+}
+
+/**
+ * The one line to render next to the model list. Callers gate on the access
+ * tier: a full-access account has the whole catalog and needs no explanation.
+ *
+ * A missing/unknown reason still returns a line — the reduced catalog is
+ * visible either way, so saying nothing is the one option that leaves the
+ * question unanswered.
+ */
+export function getAnvilModelAvailabilityNotice(
+  reason: AnvilLimitedModeReason | null | undefined,
+): string {
+  const generic = "Some models aren't available on this connection"
+  if (!reason) return generic
+
+  const countryCode =
+    reason.countryCode && reason.countryCode !== 'UNKNOWN'
+      ? reason.countryCode
+      : null
+
+  switch (reason.countryBlockReason) {
+    case 'anonymous_network':
+      return `Using a ${formatAnvilPrivacySignalList(
+        reason.ipPrivacySignals,
+      )}? More models are available on a direct connection`
+    case 'country_not_allowed':
+      return `Some models aren't available in ${
+        countryCode ? formatAnvilCountryName(countryCode) : 'your region'
+      } yet`
+    case 'anonymized_or_unknown_country':
+    case 'missing_client_ip':
+    case 'unresolved_client_ip':
+      return "We couldn't confirm your region, so we're showing models available everywhere"
+    case 'ip_privacy_lookup_failed':
+      return "We couldn't finish a network check, so we're showing models available everywhere"
+    default:
+      return generic
+  }
+}