@alumbwe/anvil 1.0.42 → 1.0.49

package/vendor/@anvil/common/src/tools/params/__tests__/render-ui.test.ts

@@ -1,65 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-
-import { parseRenderUIButtonWidget } from '../tool/render-ui'
-
-describe('parseRenderUIButtonWidget', () => {
-  it('preserves the resolved URL exactly', () => {
-    const link =
-      'https://index.trygravity.ai/go/resend?token=a%2Fb&opaque=(keep)'
-
-    expect(
-      parseRenderUIButtonWidget({
-        type: 'button',
-        text: ' Get Resend ',
-        link,
-        variant: 'secondary',
-      }),
-    ).toEqual({
-      type: 'button',
-      text: 'Get Resend',
-      link,
-      variant: 'secondary',
-    })
-  })
-
-  it('defaults the visual variant and rejects unsafe or unresolved links', () => {
-    expect(
-      parseRenderUIButtonWidget({
-        type: 'button',
-        text: 'Open',
-        link: 'https://example.com',
-      }),
-    ).toEqual({
-      type: 'button',
-      text: 'Open',
-      link: 'https://example.com',
-      variant: 'primary',
-    })
-
-    expect(
-      parseRenderUIButtonWidget({
-        type: 'button',
-        text: 'Bad',
-        link: 'javascript:alert(1)',
-      }),
-    ).toBeNull()
-    expect(
-      parseRenderUIButtonWidget({
-        type: 'button',
-        text: 'Padded',
-        link: ' https://example.com ',
-      }),
-    ).toBeNull()
-    expect(
-      parseRenderUIButtonWidget({
-        type: 'button',
-        text: 'Unresolved',
-        link: {
-          source: 'gravity_index',
-          search_id: 's1',
-          service_slug: 'resend',
-        },
-      }),
-    ).toBeNull()
-  })
-})

package/vendor/@anvil/common/src/tools/params/tool/__tests__/run-terminal-command-timeout.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-
-import {
-  clampTerminalTimeoutSeconds,
-  MAX_TERMINAL_TIMEOUT_SECONDS,
-} from '../run-terminal-command'
-
-describe('clampTerminalTimeoutSeconds', () => {
-  it('clamps the exaggerated budgets models actually pick', () => {
-    // Reported from production: 3-minute, 10-minute and 50-minute waits for
-    // work that finishes in seconds. Nothing in the runtime bounded these —
-    // the model's number reached the client verbatim.
-    expect(clampTerminalTimeoutSeconds(3000)).toBe(MAX_TERMINAL_TIMEOUT_SECONDS)
-    expect(clampTerminalTimeoutSeconds(1800)).toBe(MAX_TERMINAL_TIMEOUT_SECONDS)
-    expect(clampTerminalTimeoutSeconds(601)).toBe(MAX_TERMINAL_TIMEOUT_SECONDS)
-  })
-
-  it('leaves ordinary budgets alone', () => {
-    expect(clampTerminalTimeoutSeconds(30)).toBe(30)
-    expect(clampTerminalTimeoutSeconds(180)).toBe(180)
-    expect(clampTerminalTimeoutSeconds(MAX_TERMINAL_TIMEOUT_SECONDS)).toBe(
-      MAX_TERMINAL_TIMEOUT_SECONDS,
-    )
-  })
-
-  it('preserves the -1 no-timeout sentinel', () => {
-    // The explicit escape hatch for genuinely open-ended commands. Clamping it
-    // to 600 would silently break `cli/src/commands/router.ts`, which passes -1
-    // deliberately.
-    expect(clampTerminalTimeoutSeconds(-1)).toBe(-1)
-  })
-
-  it('leaves an absent value to the schema default', () => {
-    expect(clampTerminalTimeoutSeconds(undefined)).toBeUndefined()
-  })
-
-  it('treats nonsense values as the default rather than an instant timeout', () => {
-    // 0 or a stray negative is a malformed choice, not a request to fail
-    // immediately — which is what passing it through would cause.
-    expect(clampTerminalTimeoutSeconds(0)).toBe(30)
-    expect(clampTerminalTimeoutSeconds(-5)).toBe(30)
-    expect(clampTerminalTimeoutSeconds(Number.NaN)).toBe(
-      MAX_TERMINAL_TIMEOUT_SECONDS,
-    )
-    expect(clampTerminalTimeoutSeconds(Number.POSITIVE_INFINITY)).toBe(
-      MAX_TERMINAL_TIMEOUT_SECONDS,
-    )
-  })
-})

package/vendor/@anvil/common/src/types/__tests__/dynamic-agent-template.test.ts

@@ -1,20 +0,0 @@
-import type { AgentDefinition } from '../../templates/initial-agents-dir/types/agent-definition'
-import type { publishedTools } from '../../tools/constants'
-import type { DynamicAgentDefinition } from '../dynamic-agent-template'
-
-// Create a version of DynamicAgentDefinition where handleSteps is compatible with AgentDefinition
-
-type DynamicAgentDefinitionHandleSteps = Omit<
-  DynamicAgentDefinition,
-  'handleSteps' | 'toolNames'
-> & {
-  handleSteps?: AgentDefinition['handleSteps']
-  toolNames?: (typeof publishedTools | (string & {}))[number][]
-}
-// Don't remove these lines! And don't change the values away from true!
-const _typecheck1: DynamicAgentDefinitionHandleSteps = {} as AgentDefinition
-const _typecheck2: AgentDefinition = {} as DynamicAgentDefinitionHandleSteps
-const _keyTypecheck1: keyof AgentDefinition =
-  {} as keyof DynamicAgentDefinitionHandleSteps
-const _keyTypecheck2: keyof DynamicAgentDefinitionHandleSteps =
-  {} as keyof AgentDefinition

package/vendor/@anvil/common/src/util/__tests__/ad-user-agent.test.ts

@@ -1,26 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { getAdUserAgent } from '../ad-user-agent'
-
-describe('getAdUserAgent', () => {
-  test.each([
-    ['darwin', 'Macintosh; Intel Mac OS X'],
-    ['win32', 'Windows NT 10.0'],
-    ['linux', 'X11; Linux x86_64'],
-  ])('returns a browser-like UA for %s', (platform, osFragment) => {
-    const userAgent = getAdUserAgent(platform)
-
-    expect(userAgent).toContain(osFragment)
-    expect(userAgent).toContain('Chrome/')
-    expect(userAgent).not.toStartWith('Bun/')
-  })
-
-  test('falls back to Linux for an unknown platform', () => {
-    expect(getAdUserAgent('other')).toBe(getAdUserAgent('linux'))
-  })
-
-  test('accepts the device OS names used by the ads API', () => {
-    expect(getAdUserAgent('macos')).toBe(getAdUserAgent('darwin'))
-    expect(getAdUserAgent('windows')).toBe(getAdUserAgent('win32'))
-  })
-})

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

@@ -1,122 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-
-import { AnalyticsEvent } from '@anvil/common/constants/analytics-events'
-
-import { createAnalyticsDispatcher } from '../analytics-dispatcher'
-
-describe('analytics dispatcher', () => {
-  const level = 'info'
-  const msg = 'hello'
-
-  it('no-ops in dev environment', () => {
-    const dispatcher = createAnalyticsDispatcher({
-      envName: 'dev',
-      bufferWhenNoUser: true,
-    })
-
-    const out = dispatcher.process({
-      data: { eventId: AnalyticsEvent.APP_LAUNCHED, userId: 'u' },
-      level,
-      msg,
-    })
-
-    expect(out).toEqual([])
-  })
-
-  it('emits payload when event and user are present', () => {
-    const dispatcher = createAnalyticsDispatcher({ envName: 'prod' })
-
-    const out = dispatcher.process({
-      data: { eventId: AnalyticsEvent.APP_LAUNCHED, userId: 'u' },
-      level,
-      msg,
-    })
-
-    expect(out).toHaveLength(1)
-    expect(out[0]).toMatchObject({
-      event: AnalyticsEvent.APP_LAUNCHED,
-      userId: 'u',
-      properties: expect.objectContaining({
-        userId: 'u',
-        level,
-        msg,
-      }),
-    })
-  })
-
-  it('buffers when no user and flushes once user appears', () => {
-    const dispatcher = createAnalyticsDispatcher({
-      envName: 'prod',
-      bufferWhenNoUser: true,
-    })
-
-    // Missing user; should buffer
-    const first = dispatcher.process({
-      data: { eventId: AnalyticsEvent.APP_LAUNCHED },
-      level,
-      msg,
-    })
-    expect(first).toEqual([])
-
-    // With user; should flush buffered event first, then this one
-    const second = dispatcher.process({
-      data: {
-        eventId: AnalyticsEvent.AGENT_STEP,
-        userId: 'user-1',
-      },
-      level,
-      msg,
-    })
-
-    expect(second).toHaveLength(2)
-    expect(second[0]).toMatchObject({
-      event: AnalyticsEvent.APP_LAUNCHED,
-      userId: 'user-1',
-    })
-    expect(second[1]).toMatchObject({
-      event: AnalyticsEvent.AGENT_STEP,
-      userId: 'user-1',
-    })
-  })
-
-  it('uses fallbackUserId when rebuilding buffered events', () => {
-    const dispatcher = createAnalyticsDispatcher({
-      envName: 'prod',
-      bufferWhenNoUser: true,
-    })
-
-    dispatcher.process({
-      data: { eventId: AnalyticsEvent.APP_LAUNCHED },
-      level,
-      msg,
-    })
-
-    const out = dispatcher.process({
-      data: {
-        eventId: AnalyticsEvent.AGENT_STEP,
-      },
-      level,
-      msg,
-      fallbackUserId: 'fallback-user',
-    })
-
-    expect(out).toHaveLength(2)
-    expect(out[0].userId).toBe('fallback-user')
-    expect(out[1].userId).toBe('fallback-user')
-  })
-
-  it('ignores unknown events even when buffering is on', () => {
-    const dispatcher = createAnalyticsDispatcher({
-      envName: 'prod',
-      bufferWhenNoUser: true,
-    })
-
-    const out = dispatcher.process({
-      data: { eventId: 'not-real' },
-      level,
-      msg,
-    })
-
-    expect(out).toEqual([])
-  })
-})

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

@@ -1,102 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-
-import { AnalyticsEvent } from '@anvil/common/constants/analytics-events'
-
-import {
-  getAnalyticsEventId,
-  toTrackableAnalyticsPayload,
-  type AnalyticsLogData,
-} from '../analytics-log'
-
-describe('analytics-log helpers', () => {
-  const baseMsg = 'hello'
-  const baseLevel = 'info'
-
-  it('returns null for non-object data', () => {
-    expect(
-      toTrackableAnalyticsPayload({ data: null, level: baseLevel, msg: baseMsg }),
-    ).toBeNull()
-    expect(
-      toTrackableAnalyticsPayload({ data: 'x', level: baseLevel, msg: baseMsg }),
-    ).toBeNull()
-  })
-
-  it('returns null when eventId is missing or unknown', () => {
-    expect(
-      toTrackableAnalyticsPayload({
-        data: {},
-        level: baseLevel,
-        msg: baseMsg,
-      }),
-    ).toBeNull()
-
-    expect(
-      toTrackableAnalyticsPayload({
-        data: { eventId: 'not-real' },
-        level: baseLevel,
-        msg: baseMsg,
-      }),
-    ).toBeNull()
-  })
-
-  it('returns null when user cannot be resolved', () => {
-    expect(
-      toTrackableAnalyticsPayload({
-        data: { eventId: AnalyticsEvent.AGENT_STEP },
-        level: baseLevel,
-        msg: baseMsg,
-      }),
-    ).toBeNull()
-  })
-
-  it('builds payload when event and userId exist', () => {
-    const payload = toTrackableAnalyticsPayload({
-      data: { eventId: AnalyticsEvent.APP_LAUNCHED, userId: 'u1', extra: 123 },
-      level: baseLevel,
-      msg: baseMsg,
-    })!
-
-    expect(payload.event).toBe(AnalyticsEvent.APP_LAUNCHED)
-    expect(payload.userId).toBe('u1')
-    expect(payload.properties).toMatchObject({
-      userId: 'u1',
-      extra: 123,
-      level: baseLevel,
-      msg: baseMsg,
-    })
-  })
-
-  it('falls back to nested and underscored user ids', () => {
-    const fromUser = toTrackableAnalyticsPayload({
-      data: { eventId: AnalyticsEvent.APP_LAUNCHED, user: { id: 'nested' } },
-      level: baseLevel,
-      msg: baseMsg,
-    })
-    expect(fromUser?.userId).toBe('nested')
-
-    const fromUnderscore = toTrackableAnalyticsPayload({
-      data: { eventId: AnalyticsEvent.APP_LAUNCHED, user_id: 'underscored' },
-      level: baseLevel,
-      msg: baseMsg,
-    })
-    expect(fromUnderscore?.userId).toBe('underscored')
-  })
-
-  it('uses fallbackUserId when no user fields exist', () => {
-    const payload = toTrackableAnalyticsPayload({
-      data: { eventId: AnalyticsEvent.APP_LAUNCHED },
-      level: baseLevel,
-      msg: baseMsg,
-      fallbackUserId: 'fallback',
-    })!
-
-    expect(payload.userId).toBe('fallback')
-  })
-
-  it('getAnalyticsEventId returns only known events', () => {
-    const data: AnalyticsLogData = { eventId: AnalyticsEvent.APP_LAUNCHED }
-    expect(getAnalyticsEventId(data)).toBe(AnalyticsEvent.APP_LAUNCHED)
-    expect(getAnalyticsEventId({ eventId: 'nope' })).toBeNull()
-    expect(getAnalyticsEventId(null)).toBeNull()
-  })
-})

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

@@ -1,143 +0,0 @@
-import { afterEach, describe, expect, it } from 'bun:test'
-
-import { AnalyticsEvent } from '@anvil/common/constants/analytics-events'
-
-import {
-  isFullTelemetryEnabled,
-  shouldTrackAnalyticsEvent,
-  summarizeAnalyticsValue,
-} from '../analytics-sampling'
-
-const ORIGINAL_ENV = {
-  ANVIL_FULL_TELEMETRY: process.env.ANVIL_FULL_TELEMETRY,
-  ANVIL_FULL_TELEMETRY_IDS: process.env.ANVIL_FULL_TELEMETRY_IDS,
-  ANVIL_FULL_TELEMETRY_USER_IDS:
-    process.env.ANVIL_FULL_TELEMETRY_USER_IDS,
-}
-
-function restoreEnv() {
-  for (const [key, value] of Object.entries(ORIGINAL_ENV)) {
-    if (value === undefined) {
-      delete process.env[key]
-    } else {
-      process.env[key] = value
-    }
-  }
-}
-
-describe('analytics sampling', () => {
-  afterEach(() => {
-    restoreEnv()
-  })
-
-  it('always tracks core CLI lifecycle events', () => {
-    expect(
-      shouldTrackAnalyticsEvent({
-        event: AnalyticsEvent.APP_LAUNCHED,
-        distinctId: 'user-1',
-      }),
-    ).toBe(true)
-    expect(
-      shouldTrackAnalyticsEvent({
-        event: AnalyticsEvent.USER_INPUT_COMPLETE,
-        distinctId: 'user-1',
-      }),
-    ).toBe(true)
-    expect(
-      shouldTrackAnalyticsEvent({
-        event: AnalyticsEvent.TERMINAL_BROKER_SPAWN_FAILED,
-        distinctId: 'user-1',
-      }),
-    ).toBe(true)
-    expect(
-      shouldTrackAnalyticsEvent({
-        event: AnalyticsEvent.TERMINAL_WATCHDOG_FAILED,
-        distinctId: 'user-1',
-      }),
-    ).toBe(true)
-  })
-
-  it('always tracks CLI error logs', () => {
-    expect(
-      shouldTrackAnalyticsEvent({
-        event: AnalyticsEvent.CLI_LOG,
-        distinctId: 'user-1',
-        properties: { level: 'error' },
-      }),
-    ).toBe(true)
-  })
-
-  it('samples high-volume events deterministically', () => {
-    const first = shouldTrackAnalyticsEvent({
-      event: AnalyticsEvent.TOOL_USE,
-      distinctId: 'user-1',
-    })
-    const second = shouldTrackAnalyticsEvent({
-      event: AnalyticsEvent.TOOL_USE,
-      distinctId: 'user-1',
-    })
-    const otherEvent = shouldTrackAnalyticsEvent({
-      event: AnalyticsEvent.AGENT_STEP,
-      distinctId: 'user-1',
-    })
-
-    expect(second).toBe(first)
-    expect(typeof otherEvent).toBe('boolean')
-  })
-
-  it('samples inline ad slot demand instead of ingesting every slot', () => {
-    const decisions = Array.from({ length: 1_000 }, (_, i) =>
-      shouldTrackAnalyticsEvent({
-        event: AnalyticsEvent.CLI_INLINE_AD_SLOT_ELIGIBLE,
-        distinctId: `inline-ad-user-${i}`,
-      }),
-    )
-
-    expect(decisions).toContain(true)
-    expect(decisions).toContain(false)
-  })
-
-  it('honors full telemetry env flags and allowlists', () => {
-    process.env.ANVIL_FULL_TELEMETRY = 'true'
-    expect(
-      isFullTelemetryEnabled({
-        distinctId: 'anyone',
-      }),
-    ).toBe(true)
-
-    delete process.env.ANVIL_FULL_TELEMETRY
-    process.env.ANVIL_FULL_TELEMETRY_IDS = 'user-2,person@example.com'
-
-    expect(
-      isFullTelemetryEnabled({
-        distinctId: 'user-2',
-      }),
-    ).toBe(true)
-    expect(
-      isFullTelemetryEnabled({
-        properties: { userEmail: 'person@example.com' },
-      }),
-    ).toBe(true)
-    expect(
-      isFullTelemetryEnabled({
-        distinctId: 'user-3',
-      }),
-    ).toBe(false)
-  })
-
-  it('summarizes values without retaining raw contents', () => {
-    expect(summarizeAnalyticsValue('secret text')).toEqual({
-      kind: 'string',
-      length: 11,
-    })
-    expect(summarizeAnalyticsValue(['a', 'b'])).toEqual({
-      kind: 'array',
-      length: 2,
-    })
-    expect(summarizeAnalyticsValue({ prompt: 'secret', count: 1 })).toEqual({
-      kind: 'object',
-      keyCount: 2,
-      keys: ['prompt', 'count'],
-    })
-  })
-})