Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

15.4 KB
Raw Blame
import { env } from '../config/env.js'
import { AppError } from '../errors/index.js'
import { autonomousEnvironmentConfig, type AutonomousEnvironment } from './autonomousEnvironment.js'
import { createCircuitBreaker, CircuitOpenError, type CircuitBreaker } from './circuitBreaker.js'
import { logger } from '../utils/logger.js'

type JsonObject = Record<string, unknown>

export interface CampaignPlan {
  id: number
  code: 'free' | 'pro' | 'max' | 'remote' | 'provider'
  name: string
  amount: number
  currency: string
  metadata: JsonObject
}

export interface CheckoutInput {
  email: string
  planId: number
  referenceId: string
  referenceCode?: string
  successUrl: string
  failureUrl: string
  origin: string
}

export interface CheckoutResult {
  sessionId?: string
  redirectUrl?: string
}

export interface CampaignDevice {
  deviceId: string
  subscription?: CampaignSubscription
  llmApiKey?: string
  dailyUsage?: number
}

export interface CampaignSubscription {
  id?: string
  campaignCode?: string
  referenceId?: string
  planId?: number
  planName?: string
  status?: number
  startAt?: Date
  endAt?: Date
  cancelledAt?: Date
}

function object(value: unknown): JsonObject | undefined {
  return value != null && typeof value === 'object' && !Array.isArray(value) ? value as JsonObject : undefined
}

function unwrap(raw: unknown): unknown {
  const body = object(raw)
  if (!body) return raw
  if (body.status !== undefined && body.status !== 1 && body.status !== true && body.status !== 'success') {
    const message = typeof body.message === 'string' ? body.message : 'Autonomous BFF rejected the request'
    throw new AppError(message, 503, 'BILLING_UPSTREAM_ERROR')
  }
  return body.data ?? body.result ?? raw
}

function firstObject(raw: unknown): JsonObject {
  const value = unwrap(raw)
  if (Array.isArray(value)) return object(value[0]) ?? {}
  const obj = object(value) ?? {}
  for (const key of ['device', 'checkout', 'checkout_session', 'subscription_plan']) {
    const nested = object(obj[key])
    if (nested) return nested
  }
  return obj
}

function str(obj: JsonObject, ...keys: string[]): string | undefined {
  for (const key of keys) {
    const value = obj[key]
    if (typeof value === 'string' && value.trim()) return value.trim()
    if (typeof value === 'number' && Number.isFinite(value)) return String(value)
  }
}

function num(obj: JsonObject, ...keys: string[]): number | undefined {
  const value = str(obj, ...keys)
  if (value === undefined) return undefined
  const parsed = Number(value)
  return Number.isFinite(parsed) ? parsed : undefined
}

function date(obj: JsonObject, ...keys: string[]): Date | undefined {
  for (const key of keys) {
    const value = obj[key]
    const timestamp = object(value)
    if (timestamp) {
      // Campaign APIs serialize protobuf timestamps as { seconds, nanos } rather than ISO strings.
      const seconds = num(timestamp, 'seconds')
      const nanos = num(timestamp, 'nanos') ?? 0
      if (seconds !== undefined) {
        const parsed = new Date(seconds * 1000 + nanos / 1_000_000)
        if (!Number.isNaN(parsed.getTime())) return parsed
      }
    }
    if (typeof value !== 'string' && typeof value !== 'number') continue
    const parsed = typeof value === 'number'
      ? new Date(value < 10_000_000_000 ? value * 1000 : value)
      : new Date(value)
    if (!Number.isNaN(parsed.getTime())) return parsed
  }
}

export function parseSubscription(subscription: JsonObject): CampaignSubscription {
  return {
    id: str(subscription, 'id', '_id', 'subscription_id', 'subscriptionId'),
    campaignCode: str(subscription, 'campaign_code', 'campaignCode', 'code'),
    referenceId: str(subscription, 'reference_id', 'referenceId'),
    planId: num(subscription, 'plan_id', 'planId'),
    planName: str(subscription, 'plan_name', 'planName', 'name'),
    status: num(subscription, 'status', 'subscription_status', 'subscriptionStatus'),
    startAt: date(subscription, 'start_date', 'startDate', 'started_at', 'startedAt'),
    endAt: date(subscription, 'end_date', 'endDate', 'expires_at', 'expiresAt'),
    cancelledAt: date(subscription, 'cancelled_date', 'cancelledDate', 'canceled_at', 'cancelled_at'),
  }
}

// Per account plane: a billing service that keeps failing is answered for at once, not after its timeout on every call.
const UNAVAILABLE_CODES = new Set(['BILLING_SERVICE_UNAVAILABLE', 'BILLING_UPSTREAM_ERROR'])
const breakers = new Map<AutonomousEnvironment, CircuitBreaker>()

function bffBreaker(autonomousEnv: AutonomousEnvironment): CircuitBreaker {
  let breaker = breakers.get(autonomousEnv)
  if (!breaker) {
    breaker = createCircuitBreaker({
      name: `autonomous-bff:${autonomousEnv}`,
      isFailure: (err) => !(err instanceof AppError) || UNAVAILABLE_CODES.has(err.code ?? ''),
      onStateChange: (state) => {
        if (state === 'open') logger.warn('[bff] billing service unreachable; failing fast', { autonomousEnv })
        else logger.info('[bff] billing service circuit', { autonomousEnv, state })
      },
    })
    breakers.set(autonomousEnv, breaker)
  }
  return breaker
}

/** Test seam. */
export function resetBffBreakers(): void {
  breakers.clear()
}

async function request(
  autonomousEnv: AutonomousEnvironment,
  path: string,
  opts: { token?: string; method?: string; body?: unknown; origin?: string } = {},
): Promise<unknown> {
  try {
    return await bffBreaker(autonomousEnv).run(() => send(autonomousEnv, path, opts))
  } catch (err) {
    if (err instanceof CircuitOpenError) throw new AppError('Autonomous billing service unavailable', 503, 'BILLING_SERVICE_UNAVAILABLE')
    throw err
  }
}

async function send(
  autonomousEnv: AutonomousEnvironment,
  path: string,
  opts: { token?: string; method?: string; body?: unknown; origin?: string },
): Promise<unknown> {
  let response: Response
  try {
    const environment = autonomousEnvironmentConfig(autonomousEnv)
    // Autonomous validates Origin separately from success_url/failure_url. A staging account used
    // from the production Machine UI must still present the staging allowlisted origin upstream, while
    // Stripe callbacks continue returning to the actual Machine web origin carried in the request body.
    const upstreamOrigin = opts.origin ? environment.checkoutOrigin : undefined
    response = await fetch(new URL(path, environment.bffUrl), {
      method: opts.method ?? 'GET',
      headers: {
        Accept: 'application/json',
        location: 'en-US',
        ...(opts.body !== undefined ? { 'Content-Type': 'application/json' } : {}),
        ...(opts.token ? { Authorization: `Bearer ${opts.token}` } : {}),
        ...(upstreamOrigin ? { Origin: upstreamOrigin } : {}),
      },
      ...(opts.body !== undefined ? { body: JSON.stringify(opts.body) } : {}),
      signal: AbortSignal.timeout(env.AUTONOMOUS_BFF_TIMEOUT_MS),
    })
  } catch {
    throw new AppError('Autonomous billing service unavailable', 503, 'BILLING_SERVICE_UNAVAILABLE')
  }
  if (response.status === 401 || response.status === 403) {
    // The app auth middleware has already validated this same token through the profile API. Do not
    // report an upstream billing authorization failure as the Machine SSO session expiring: the web
    // would refresh once and then incorrectly log the user out.
    throw new AppError(
      'Autonomous billing service rejected the account session',
      502,
      'BILLING_UPSTREAM_UNAUTHORIZED',
    )
  }
  if (response.status === 404) {
    if (opts.method === 'DELETE') return undefined
    throw new AppError('Campaign device not found', 404, 'BILLING_DEVICE_NOT_FOUND')
  }
  if (!response.ok) {
    throw new AppError('Autonomous billing service unavailable', 503, 'BILLING_SERVICE_UNAVAILABLE')
  }
  if (response.status === 204) return undefined
  try { return await response.json() } catch {
    throw new AppError('Autonomous billing service returned invalid data', 503, 'BILLING_UPSTREAM_ERROR')
  }
}

function planCode(raw: JsonObject): CampaignPlan['code'] | undefined {
  const haystack = [str(raw, 'code', 'plan_code', 'slug'), str(raw, 'name', 'plan_name', 'title')]
    .filter(Boolean).join(' ').toLowerCase()
  // `provider` is tested BEFORE `pro` for readability only — the word boundary in /\bpro\b/ already
  // prevents "provider" from matching it. An upstream code this function does not recognise is
  // dropped by the caller, so a new tier appearing upstream is invisible here rather than fatal.
  if (/\bfree\b/.test(haystack)) return 'free'
  if (/\bprovider\b/.test(haystack)) return 'provider'
  if (/\bpro\b/.test(haystack)) return 'pro'
  if (/\bmax\b/.test(haystack)) return 'max'
  if (/\bremote\b/.test(haystack)) return 'remote'
  return undefined
}

export async function fetchCampaignPlans(autonomousEnv: AutonomousEnvironment): Promise<CampaignPlan[]> {
  const raw = unwrap(await request(autonomousEnv, `/api/v1/stand-to-earn/device/${encodeURIComponent(env.HARNESS_CAMPAIGN_CODE)}/subscription-plans`))
  const root = object(raw)
  const rows = Array.isArray(raw) ? raw : Array.isArray(root?.plans) ? root.plans : Array.isArray(root?.items) ? root.items : []
  const parsed: CampaignPlan[] = []
  for (const value of rows) {
    const p = object(value)
    if (!p) continue
    const frequencies = Array.isArray(p.frequencies) ? p.frequencies : []
    const monthly = frequencies.map(object).find((f) => f?.frequency === 'month') ?? object(frequencies[0])
    const id = num(monthly ?? p, 'id', 'plan_id')
    const code = planCode(p)
    if (!id || !code) continue
    parsed.push({
      id,
      code,
      name: str(p, 'name', 'plan_name', 'title') ?? code,
      amount: num(monthly ?? p, 'amount', 'price', 'price_usd') ?? 0,
      currency: (str(monthly ?? p, 'currency') ?? '').toUpperCase(),
      metadata: p,
    })
  }
  return parsed
}

export async function createCampaignDevice(autonomousEnv: AutonomousEnvironment, token: string): Promise<string> {
  const obj = firstObject(await request(autonomousEnv, '/api/v1/stand-to-earn/device', {
    token,
    method: 'POST',
    body: { device_type: env.HARNESS_DEVICE_TYPE, timezone: env.HARNESS_DEVICE_TIMEZONE_DEFAULT },
  }))
  const deviceId = str(obj, 'device_id', 'deviceId', 'id')
  if (!deviceId) throw new AppError('Autonomous billing service did not return a device id', 503, 'BILLING_UPSTREAM_ERROR')
  return deviceId
}

function checkoutBody(input: CheckoutInput): JsonObject {
  return {
    email: input.email,
    campaign_code: env.HARNESS_CAMPAIGN_CODE,
    plan_id: input.planId,
    reference_id: input.referenceId,
    quantity: 1,
    use_stripe_hosted_subscription: true,
    success_url: input.successUrl,
    failure_url: input.failureUrl,
  }
}

export async function createCheckout(autonomousEnv: AutonomousEnvironment, token: string, input: CheckoutInput): Promise<CheckoutResult> {
  const obj = firstObject(await request(autonomousEnv, '/api/v1/checkout/stripe/checkout-session', {
    token,
    method: 'POST',
    origin: input.origin,
    body: checkoutBody(input),
  }))
  const sessionId = str(obj, 'checkout_session_id', 'session_id', 'checkoutSessionId', 'sessionId', 'id')
  const redirectUrl = str(obj, 'redirect_url', 'checkout_url', 'redirectUrl', 'checkoutUrl', 'url')
  if (redirectUrl) {
    try {
      if (new URL(redirectUrl).protocol !== 'https:') throw new Error('not https')
    } catch {
      throw new AppError('Autonomous billing service returned an invalid checkout URL', 503, 'BILLING_UPSTREAM_ERROR')
    }
  }
  return { ...(sessionId ? { sessionId } : {}), ...(redirectUrl ? { redirectUrl } : {}) }
}

export async function completeCheckout(autonomousEnv: AutonomousEnvironment, token: string, sessionId: string, input: CheckoutInput): Promise<void> {
  const raw = await request(autonomousEnv, `/api/v1/checkout/stripe/checkout-complete/${encodeURIComponent(sessionId)}`, {
    token,
    method: 'POST',
    origin: input.origin,
    body: {
      ...checkoutBody(input),
      session_id: sessionId,
      ...(input.referenceCode ? { reference: input.referenceCode } : {}),
    },
  })
  // The BFF can report an application error in a HTTP 200 envelope. Do not silently continue to
  // device verification when checkout completion itself was rejected.
  unwrap(raw)
}

export async function getCampaignDevice(autonomousEnv: AutonomousEnvironment, token: string, deviceId: string): Promise<CampaignDevice> {
  const obj = firstObject(await request(autonomousEnv, `/api/v1/stand-to-earn/device/${encodeURIComponent(deviceId)}`, { token }))
  const subscription = object(obj.subscription)
  const parsedSubscription = subscription ? parseSubscription(subscription) : undefined
  const hasSubscription = !!parsedSubscription && Object.values(parsedSubscription).some((value) => value !== undefined)
  const dailyUsage = num(obj, 'daily_usage', 'dailyUsage')
  return {
    deviceId: str(obj, 'device_id', 'deviceId', 'id') ?? deviceId,
    llmApiKey: str(obj, 'llm_api_key', 'llmApiKey'),
    ...(dailyUsage !== undefined ? { dailyUsage: Math.max(0, dailyUsage) } : {}),
    ...(hasSubscription ? { subscription: parsedSubscription } : {}),
  }
}

export async function listCampaignSubscriptions(
  autonomousEnv: AutonomousEnvironment,
  token: string,
  campaignCode: string,
  referenceId: string,
): Promise<CampaignSubscription[]> {
  const query = new URLSearchParams({ campaign_code: campaignCode })
  query.append('reference_ids[]', referenceId)
  const raw = unwrap(await request(autonomousEnv, `/api/v1/me/subscriptions?${query.toString()}`, { token }))
  const root = object(raw)
  // Current BFF shape is {status:1,data:{data:[...],total:n}}. Keep the direct array/items aliases
  // for compatibility with older deployments.
  const rows = Array.isArray(raw)
    ? raw
    : Array.isArray(root?.data)
      ? root.data
      : Array.isArray(root?.subscriptions)
        ? root.subscriptions
        : Array.isArray(root?.items)
          ? root.items
          : []
  return rows.flatMap((value) => {
    const subscription = object(value)
    if (!subscription) return []
    return [parseSubscription(subscription)]
  })
}

export async function cancelCampaignSubscription(autonomousEnv: AutonomousEnvironment, token: string, subscriptionId: string): Promise<void> {
  const raw = await request(autonomousEnv, `/api/v1/me/subscriptions/${encodeURIComponent(subscriptionId)}/cancel`, {
    token,
    method: 'POST',
  })
  unwrap(raw)
}

export async function renewCampaignSubscription(autonomousEnv: AutonomousEnvironment, token: string, subscriptionId: string): Promise<void> {
  const raw = await request(autonomousEnv, `/api/v1/me/subscriptions/${encodeURIComponent(subscriptionId)}/renew`, {
    token,
    method: 'POST',
  })
  unwrap(raw)
}

/** Billing-safe device removal. Unlike raw DELETE, fire-intern also cancels the attached
 * subscription and releases any provider-side plan allocation before deleting the device. */
export async function fireCampaignDevice(autonomousEnv: AutonomousEnvironment, token: string, deviceId: string): Promise<void> {
  let raw: unknown
  try {
    raw = await request(autonomousEnv, `/api/v1/stand-to-earn/device/${encodeURIComponent(deviceId)}/fire-intern`, {
      token,
      method: 'POST',
    })
  } catch (err) {
    // A prior retry may already have fired the device. With no device left there is nothing that
    // can renew through this reference, so deletion remains idempotent.
    if (err instanceof AppError && err.code === 'BILLING_DEVICE_NOT_FOUND') return
    throw err
  }
  try { unwrap(raw) } catch (err) {
    if (err instanceof AppError && /not found/i.test(err.message)) return
    throw err
  }
}