feat(aws-marketplace): bill a listing's LLM usage to AWS through a per-period metering tally

apps/sim/app/api/cron/aws-marketplace-meter/route.ts

@@ -0,0 +1,67 @@
+import { createLogger } from '@sim/logger'
+import { generateShortId } from '@sim/utils/id'
+import { type NextRequest, NextResponse } from 'next/server'
+import { verifyCronAuth } from '@/lib/auth/internal'
+import { isAwsMarketplaceEnabled } from '@/lib/billing/aws-marketplace/config'
+import { meterAwsMarketplaceUsage } from '@/lib/billing/aws-marketplace/metering'
+import { acquireLock, releaseLock } from '@/lib/core/config/redis'
+import { runDetached } from '@/lib/core/utils/background'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+
+const logger = createLogger('AwsMarketplaceMeterCron')
+
+const LOCK_KEY = 'aws-marketplace-meter-lock'
+/** Outlasts a run comfortably; the schedule runs every 15 minutes. */
+const LOCK_TTL_SECONDS = 10 * 60
+
+export const dynamic = 'force-dynamic'
+
+/**
+ * Records newly closed hours of usage owed through AWS Marketplace and sends AWS what it has not
+ * accepted yet. Acknowledges the cron call at once and works in the background; a Redis lock keeps
+ * runs from overlapping, and the ledger makes a replayed run harmless. A no-op on deployments
+ * where no configured listing bills usage.
+ */
+export const GET = withRouteHandler(async (request: NextRequest) => {
+  const authError = verifyCronAuth(request, 'AWS Marketplace metering')
+  if (authError) {
+    return authError
+  }
+
+  if (!isAwsMarketplaceEnabled()) {
+    return NextResponse.json({
+      success: true,
+      message: 'AWS Marketplace is not configured – skipped',
+      status: 'skip',
+    })
+  }
+
+  const lockValue = generateShortId()
+  const locked = await acquireLock(LOCK_KEY, lockValue, LOCK_TTL_SECONDS, {
+    reclaimOnFailure: true,
+  })
+  if (!locked) {
+    return NextResponse.json(
+      {
+        success: true,
+        message: 'AWS Marketplace metering already in progress – skipped',
+        status: 'skip',
+      },
+      { status: 202 }
+    )
+  }
+
+  runDetached('aws-marketplace-meter', async () => {
+    try {
+      const summary = await meterAwsMarketplaceUsage()
+      if (summary) logger.info('AWS Marketplace metering completed', { ...summary })
+    } finally {
+      await releaseLock(LOCK_KEY, lockValue).catch(() => {})
+    }
+  })
+
+  return NextResponse.json(
+    { success: true, message: 'AWS Marketplace metering started', status: 'started' },
+    { status: 202 }
+  )
+})

apps/sim/lib/billing/aws-marketplace/lifecycle.integration.ts

@@ -743,6 +743,28 @@ describe('linking a claimed license', () => {
     })
   })
 
+  it('starts the license usage at the first link and keeps it when the same organization links again', async () => {
+    const fresh = await createClaimedLicense()
+    entitlementsByLicense.set(fresh.licenseArn, [currentEntitlement()])
+    const before = Date.now()
+
+    await link(ownerId, { licenseId: fresh.id, claimToken: fresh.token })
+
+    const linkedAt = (await readLicense(fresh.licenseArn))?.organizationLinkedAt
+    expect(linkedAt?.getTime()).toBeGreaterThanOrEqual(before - 1000)
+
+    const firstLinkedAt = new Date(Date.now() - 5 * 60 * 60 * 1000)
+    const relinked = await createClaimedLicense({
+      organizationId,
+      organizationLinkedAt: firstLinkedAt,
+    })
+    entitlementsByLicense.set(relinked.licenseArn, [currentEntitlement()])
+
+    await link(ownerId, { licenseId: relinked.id, claimToken: relinked.token })
+
+    expect((await readLicense(relinked.licenseArn))?.organizationLinkedAt).toEqual(firstLinkedAt)
+  })
+
   it('refuses to move a license already linked to another organization', async () => {
     const otherOwnerId = await createUser()
     const otherOrganizationId = await createOrganization([{ userId: otherOwnerId, role: 'owner' }])
@@ -1457,10 +1479,20 @@ describe('license events across listings', () => {
 
     expect(await reconcileAwsMarketplaceLicenses()).toMatchObject({ applied: 1, discarded: 0 })
     expect(deleted).toEqual(['r-0'])
-    expect(await readLicense(licenseArn)).toMatchObject({
-      status: 'inactive',
-      dimension: 'platform',
-    })
+    const lapsed = await readLicense(licenseArn)
+    expect(lapsed).toMatchObject({ status: 'inactive', dimension: 'platform' })
+    expect(lapsed?.endedAt).toBeInstanceOf(Date)
+
+    deliverOnce([licenseUpdated(licenseArn, undefined, undefined, USAGE_PRODUCT)])
+    await reconcileAwsMarketplaceLicenses()
+    expect((await readLicense(licenseArn))?.endedAt).toEqual(lapsed?.endedAt)
+
+    entitlementsByLicense.set(licenseArn, [
+      currentEntitlement({ ProductCode: USAGE_PRODUCT, Dimension: 'platform' }),
+    ])
+    deliverOnce([licenseUpdated(licenseArn, undefined, undefined, USAGE_PRODUCT)])
+    await reconcileAwsMarketplaceLicenses()
+    expect(await readLicense(licenseArn)).toMatchObject({ status: 'active', endedAt: null })
   })
 })