@alumbwe/anvil 1.0.20 → 1.0.21

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

@@ -0,0 +1,143 @@
+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'],
+    })
+  })
+})

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

@@ -0,0 +1,202 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+  addDaysToDateKey,
+  calculateAnvilStreak,
+  getAnvilDailyStreakRewardPool,
+  getAnvilStreakGlmBonusUnits,
+  getAnvilUsageDateKey,
+} from '../anvil-streak'
+
+function usageDatesFrom(startDateKey: string, count: number): string[] {
+  return Array.from({ length: count }, (_, index) =>
+    addDaysToDateKey(startDateKey, index),
+  )
+}
+
+describe('anvil streak helpers', () => {
+  test('formats usage dates in the Anvil reset timezone', () => {
+    expect(getAnvilUsageDateKey(new Date('2026-05-27T06:30:00.000Z'))).toBe(
+      '2026-05-26',
+    )
+    expect(getAnvilUsageDateKey(new Date('2026-05-27T08:30:00.000Z'))).toBe(
+      '2026-05-27',
+    )
+  })
+
+  test('adds days across month boundaries', () => {
+    expect(addDaysToDateKey('2026-03-01', -1)).toBe('2026-02-28')
+    expect(addDaysToDateKey('2024-03-01', -1)).toBe('2024-02-29')
+    expect(addDaysToDateKey('2026-12-31', 1)).toBe('2027-01-01')
+  })
+
+  test('counts a streak that includes today', () => {
+    expect(
+      calculateAnvilStreak({
+        todayDateKey: '2026-05-27',
+        usageDates: ['2026-05-25', '2026-05-23', '2026-05-27', '2026-05-26'],
+      }),
+    ).toEqual({
+      streak: 3,
+      todayUsed: true,
+      lastUsageDate: '2026-05-27',
+    })
+  })
+
+  test('keeps yesterday-anchored streaks alive before today is used', () => {
+    expect(
+      calculateAnvilStreak({
+        todayDateKey: '2026-05-27',
+        usageDates: ['2026-05-26', '2026-05-25', '2026-05-24'],
+      }),
+    ).toEqual({
+      streak: 3,
+      todayUsed: false,
+      lastUsageDate: '2026-05-26',
+    })
+  })
+
+  test('returns zero after a missed full day', () => {
+    expect(
+      calculateAnvilStreak({
+        todayDateKey: '2026-05-27',
+        usageDates: ['2026-05-25', '2026-05-24'],
+      }),
+    ).toEqual({
+      streak: 0,
+      todayUsed: false,
+      lastUsageDate: '2026-05-25',
+    })
+  })
+})
+
+describe('anvil streak rewards', () => {
+  test('grants one weekly GLM session per completed 7 days, capped at 4', () => {
+    const expected: Array<[streak: number, units: number]> = [
+      [7, 1],
+      [8, 1],
+      [13, 1],
+      [14, 2],
+      [21, 3],
+      [28, 4],
+      [42, 4],
+    ]
+    for (const [streak, units] of expected) {
+      expect(
+        getAnvilStreakGlmBonusUnits({
+          todayDateKey: addDaysToDateKey('2026-07-01', streak - 1),
+          usageDates: usageDatesFrom('2026-07-01', streak),
+        }),
+      ).toBe(units)
+    }
+  })
+
+  test('returns zero for empty and six-day usage histories', () => {
+    expect(
+      getAnvilStreakGlmBonusUnits({
+        todayDateKey: '2026-07-13',
+        usageDates: [],
+      }),
+    ).toBe(0)
+    expect(
+      getAnvilStreakGlmBonusUnits({
+        todayDateKey: '2026-07-13',
+        usageDates: usageDatesFrom('2026-07-07', 6),
+      }),
+    ).toBe(0)
+  })
+
+  test('a yesterday-anchored 28-day streak earns the max through the bounded window', () => {
+    // Mirrors the web quota query, which fetches only 28 days back from today:
+    // the oldest still-active max-tier streak (today unused) must be fully
+    // visible inside that window.
+    expect(
+      getAnvilStreakGlmBonusUnits({
+        todayDateKey: addDaysToDateKey('2026-07-01', 28),
+        usageDates: usageDatesFrom('2026-07-01', 28),
+      }),
+    ).toBe(4)
+  })
+
+  test('refills GLM before the first use of a new week while the streak is alive', () => {
+    expect(
+      getAnvilStreakGlmBonusUnits({
+        todayDateKey: '2026-07-13',
+        usageDates: usageDatesFrom('2026-07-06', 7),
+      }),
+    ).toBe(1)
+  })
+
+  test('removes the live GLM entitlement after a missed full day', () => {
+    expect(
+      getAnvilStreakGlmBonusUnits({
+        todayDateKey: '2026-07-14',
+        usageDates: usageDatesFrom('2026-07-06', 7),
+      }),
+    ).toBe(0)
+  })
+
+  test('full access persists only the daily premium bonus', () => {
+    expect(
+      getAnvilDailyStreakRewardPool({
+        streak: 7,
+        todayUsed: true,
+        accessTier: 'full',
+      }),
+    ).toBe('premium')
+  })
+
+  test('full access grants the daily premium bonus throughout the streak', () => {
+    expect(
+      getAnvilDailyStreakRewardPool({
+        streak: 8,
+        todayUsed: true,
+        accessTier: 'full',
+      }),
+    ).toBe('premium')
+    expect(
+      getAnvilDailyStreakRewardPool({
+        streak: 13,
+        todayUsed: true,
+        accessTier: 'full',
+      }),
+    ).toBe('premium')
+  })
+
+  test('limited access grants the limited bonus every day at streak >= 7', () => {
+    // The threshold day and later days both grant the bonus.
+    expect(
+      getAnvilDailyStreakRewardPool({
+        streak: 14,
+        todayUsed: true,
+        accessTier: 'limited',
+      }),
+    ).toBe('limited')
+    expect(
+      getAnvilDailyStreakRewardPool({
+        streak: 9,
+        todayUsed: true,
+        accessTier: 'limited',
+      }),
+    ).toBe('limited')
+  })
+
+  test('no daily reward below seven days or before today is used', () => {
+    expect(
+      getAnvilDailyStreakRewardPool({
+        streak: 6,
+        todayUsed: true,
+        accessTier: 'full',
+      }),
+    ).toBeNull()
+    // Streak is at 7 only because yesterday anchored it; the user hasn't used
+    // Anvil today, so no bonus is earned yet.
+    expect(
+      getAnvilDailyStreakRewardPool({
+        streak: 7,
+        todayUsed: false,
+        accessTier: 'full',
+      }),
+    ).toBeNull()
+  })
+})

package/vendor/@anvil/common/src/util/__tests__/anvil-usage-summary.test.ts

@@ -0,0 +1,193 @@
+import { describe, expect, it } from 'bun:test'
+
+import {
+  buildAnvilUsageGrid,
+  buildAnvilUsageSummary,
+  calculateLongestAnvilStreak,
+} from '../anvil-usage-summary'
+
+describe('calculateLongestAnvilStreak', () => {
+  it('finds the longest run rather than the most recent one', () => {
+    expect(
+      calculateLongestAnvilStreak([
+        '2026-08-01',
+        '2026-08-02',
+        '2026-08-03',
+        '2026-08-04',
+        // gap
+        '2026-08-10',
+        '2026-08-11',
+      ]),
+    ).toBe(4)
+  })
+
+  it('does not extend a run across a gap, unlike the current streak', () => {
+    // The current streak deliberately survives "used yesterday, not yet today"
+    // because the day is not over. A historical run has no such grace.
+    expect(calculateLongestAnvilStreak(['2026-08-01', '2026-08-03'])).toBe(1)
+  })
+
+  it('counts each day once when the input repeats or arrives unsorted', () => {
+    expect(
+      calculateLongestAnvilStreak([
+        '2026-08-03',
+        '2026-08-01',
+        '2026-08-02',
+        '2026-08-02',
+      ]),
+    ).toBe(3)
+  })
+
+  it('is zero with no history', () => {
+    expect(calculateLongestAnvilStreak([])).toBe(0)
+  })
+
+  it('handles a run across a month boundary', () => {
+    expect(
+      calculateLongestAnvilStreak([
+        '2026-07-30',
+        '2026-07-31',
+        '2026-08-01',
+      ]),
+    ).toBe(3)
+  })
+})
+
+describe('buildAnvilUsageSummary', () => {
+  const activeDates = ['2026-08-10', '2026-08-11', '2026-08-12']
+
+  it('reports the current and longest streak together', () => {
+    const summary = buildAnvilUsageSummary({
+      activeDates: [
+        // A four-day run that has since lapsed...
+        '2026-07-01',
+        '2026-07-02',
+        '2026-07-03',
+        '2026-07-04',
+        // ...and a shorter one running right now.
+        '2026-08-11',
+        '2026-08-12',
+      ],
+      todayDateKey: '2026-08-12',
+    })
+
+    expect(summary.streak.current).toBe(2)
+    expect(summary.streak.longest).toBe(4)
+    expect(summary.streak.todayUsed).toBe(true)
+    expect(summary.streak.lastUsageDate).toBe('2026-08-12')
+  })
+
+  it('counts all-time active days regardless of the map window', () => {
+    const summary = buildAnvilUsageSummary({
+      activeDates,
+      todayDateKey: '2026-08-12',
+      windowDays: 2,
+    })
+
+    // The window covers 08-11 and 08-12; 08-10 falls outside it but still
+    // counts toward the account's history.
+    expect(summary.activeDates).toEqual(['2026-08-11', '2026-08-12'])
+    expect(summary.allTimeActiveDays).toBe(3)
+  })
+
+  it('drops days after today rather than letting a fast clock inflate totals', () => {
+    const summary = buildAnvilUsageSummary({
+      activeDates: [...activeDates, '2026-08-13'],
+      todayDateKey: '2026-08-12',
+    })
+
+    expect(summary.allTimeActiveDays).toBe(3)
+    expect(summary.streak.lastUsageDate).toBe('2026-08-12')
+  })
+
+  it('sorts and dedupes unordered input before walking the streak', () => {
+    const summary = buildAnvilUsageSummary({
+      activeDates: ['2026-08-12', '2026-08-10', '2026-08-11', '2026-08-11'],
+      todayDateKey: '2026-08-12',
+    })
+
+    expect(summary.streak.current).toBe(3)
+    expect(summary.activeDates).toEqual(activeDates)
+    expect(summary.allTimeActiveDays).toBe(3)
+  })
+
+  it('carries a null recent window through rather than inventing zeros', () => {
+    // The token aggregate caps itself with a statement timeout; a timeout must
+    // read as "unknown" downstream, never as "you sent nothing".
+    const summary = buildAnvilUsageSummary({
+      activeDates,
+      todayDateKey: '2026-08-12',
+      recent: null,
+    })
+
+    expect(summary.recent).toBeNull()
+  })
+
+  it('passes the recent window through when it resolved', () => {
+    const summary = buildAnvilUsageSummary({
+      activeDates,
+      todayDateKey: '2026-08-12',
+      recent: {
+        days: 7,
+        messages: 12,
+        inputTokens: 300,
+        cacheReadTokens: 50,
+        outputTokens: 50,
+        totalTokens: 400,
+      },
+    })
+
+    expect(summary.recent?.messages).toBe(12)
+    expect(summary.recent?.totalTokens).toBe(400)
+  })
+})
+
+describe('buildAnvilUsageGrid', () => {
+  // 2026-08-12 is a Wednesday (weekday 3).
+  const todayDateKey = '2026-08-12'
+  const todayWeekday = 3
+
+  it('pads to whole weeks so every row is one weekday', () => {
+    const grid = buildAnvilUsageGrid({
+      activeDates: [],
+      todayDateKey,
+      windowDays: 365,
+      todayWeekday,
+    })
+
+    expect(grid.length % 7).toBe(0)
+  })
+
+  it('places today at its own weekday in the final column', () => {
+    const grid = buildAnvilUsageGrid({
+      activeDates: [],
+      todayDateKey,
+      windowDays: 365,
+      todayWeekday,
+    })
+
+    const lastColumn = grid.slice(grid.length - 7)
+    expect(lastColumn[todayWeekday]).toMatchObject({ date: todayDateKey })
+    // Everything after today in the final column is padding, not a quiet day —
+    // those dates have not happened yet.
+    expect(lastColumn.slice(todayWeekday + 1).every((cell) => cell === null)).toBe(
+      true,
+    )
+  })
+
+  it('marks active days and fills the rest as quiet', () => {
+    const grid = buildAnvilUsageGrid({
+      activeDates: ['2026-08-11'],
+      todayDateKey,
+      windowDays: 3,
+      todayWeekday,
+    })
+
+    const cells = grid.filter((cell) => cell !== null)
+    expect(cells).toEqual([
+      { date: '2026-08-10', active: false },
+      { date: '2026-08-11', active: true },
+      { date: '2026-08-12', active: false },
+    ])
+  })
+})

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

@@ -0,0 +1,140 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+  CONTEXT_PRUNING_COMPLETED_EVENT,
+  getAxiomOnlyLogEvent,
+  STREAM_RECOVERY_EVENT,
+} from '../axiom-only-log'
+
+describe('getAxiomOnlyLogEvent', () => {
+  test('sanitizes context-pruning metadata', () => {
+    expect(
+      getAxiomOnlyLogEvent({
+        axiomEvent: CONTEXT_PRUNING_COMPLETED_EVENT,
+        trigger_reason: 'context_limit',
+        client_session_id: 'turn-123',
+        dropped_user_entry_count: 2,
+        live_user_prompt_text_preserved: true,
+        prompt: 'must not leave the client',
+        nested: { secret: true },
+        context_token_count: Number.POSITIVE_INFINITY,
+      }),
+    ).toEqual({
+      event: CONTEXT_PRUNING_COMPLETED_EVENT,
+      data: {
+        trigger_reason: 'context_limit',
+        client_session_id: 'turn-123',
+        dropped_user_entry_count: 2,
+        live_user_prompt_text_preserved: true,
+      },
+    })
+  })
+
+  test('does not treat arbitrary events as Axiom-only', () => {
+    expect(
+      getAxiomOnlyLogEvent({
+        axiomEvent: 'untrusted.event',
+        prompt: 'secret',
+      }),
+    ).toBeNull()
+  })
+
+  test('does not treat an Object.prototype property name as a registered event', () => {
+    // The event name is caller-supplied (any logger.*(data, msg) call sets
+    // `data.axiomEvent`). Guards against ever matching it with a lookup keyed
+    // on that name (e.g. a plain-object registry), where 'constructor' would
+    // resolve through the prototype chain and get treated as registered —
+    // shipping `{}` in place of the log's real payload. Must be rejected like
+    // any other unknown event, via both the data-field and event-param path.
+    for (const poisonEvent of [
+      'constructor',
+      'toString',
+      'hasOwnProperty',
+      'valueOf',
+      '__proto__',
+    ]) {
+      expect(
+        getAxiomOnlyLogEvent({
+          axiomEvent: poisonEvent,
+          prompt: 'must not be silently dropped',
+        }),
+      ).toBeNull()
+      expect(
+        getAxiomOnlyLogEvent({ prompt: 'must not be silently dropped' }, poisonEvent),
+      ).toBeNull()
+    }
+  })
+
+  test('sanitizes the client wire format identified by its top-level event', () => {
+    expect(
+      getAxiomOnlyLogEvent(
+        {
+          dropped_user_entry_count: 2,
+          prompt: 'must not reach Axiom',
+        },
+        CONTEXT_PRUNING_COMPLETED_EVENT,
+      ),
+    ).toEqual({
+      event: CONTEXT_PRUNING_COMPLETED_EVENT,
+      data: { dropped_user_entry_count: 2 },
+    })
+  })
+
+  test('accepts an allowlisted top-level event with empty data', () => {
+    expect(getAxiomOnlyLogEvent(null, CONTEXT_PRUNING_COMPLETED_EVENT)).toEqual(
+      {
+        event: CONTEXT_PRUNING_COMPLETED_EVENT,
+        data: {},
+      },
+    )
+  })
+
+  test('sanitizes stream-recovery metadata', () => {
+    expect(
+      getAxiomOnlyLogEvent({
+        axiomEvent: STREAM_RECOVERY_EVENT,
+        metric: 'stream_recovery_detected',
+        source: 'stream-interrupted',
+        model: 'openrouter/anthropic/claude-sonnet-4.5',
+        agentId: 'base2',
+        runId: 'run-123',
+        userInputId: 'input-456',
+        finishReason: 'unknown',
+        hasYieldedContent: true,
+        consecutive: 2,
+        // Not in the allowlist: must not leak through.
+        userId: 'user-789',
+        message: 'must not leave the client',
+        messageHistory: [{ role: 'user', content: 'secret' }],
+      }),
+    ).toEqual({
+      event: STREAM_RECOVERY_EVENT,
+      data: {
+        metric: 'stream_recovery_detected',
+        source: 'stream-interrupted',
+        model: 'openrouter/anthropic/claude-sonnet-4.5',
+        agentId: 'base2',
+        runId: 'run-123',
+        userInputId: 'input-456',
+        finishReason: 'unknown',
+        hasYieldedContent: true,
+        consecutive: 2,
+      },
+    })
+  })
+
+  test('drops a stream-recovery field with the wrong value type', () => {
+    // consecutive must be a number; a string value for it (or any other
+    // type mismatch) is dropped rather than coerced.
+    expect(
+      getAxiomOnlyLogEvent({
+        axiomEvent: STREAM_RECOVERY_EVENT,
+        metric: 'stream_recovery_rescued',
+        consecutive: '2',
+      }),
+    ).toEqual({
+      event: STREAM_RECOVERY_EVENT,
+      data: { metric: 'stream_recovery_rescued' },
+    })
+  })
+})