ts-trainingpeaks 0.1.0

package/src/http.ts

@@ -0,0 +1,265 @@
+/**
+ * HTTP Client for TrainingPeaks API
+ * Handles cookies, authentication, and API requests
+ */
+
+import type { TPCookie } from './types'
+
+export interface HttpClientOptions {
+  baseUrl?: string
+  timeout?: number
+  userAgent?: string
+}
+
+export class HttpClient {
+  private cookies: Map<string, TPCookie> = new Map()
+  private baseUrl: string
+  private timeout: number
+  private userAgent: string
+
+  constructor(options: HttpClientOptions = {}) {
+    this.baseUrl = options.baseUrl || 'https://home.trainingpeaks.com'
+    this.timeout = options.timeout || 30000
+    this.userAgent = options.userAgent || 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+  }
+
+  setCookies(cookies: TPCookie[]): void {
+    for (const cookie of cookies) {
+      const key = `${cookie.domain || ''}:${cookie.name}`
+      this.cookies.set(key, cookie)
+    }
+  }
+
+  getCookies(): TPCookie[] {
+    return Array.from(this.cookies.values())
+  }
+
+  clearCookies(): void {
+    this.cookies.clear()
+  }
+
+  private getCookieHeader(url: string): string {
+    const parsed = new URL(url)
+    const matching: TPCookie[] = []
+
+    for (const cookie of this.cookies.values()) {
+      // Check domain match
+      if (cookie.domain) {
+        const domain = cookie.domain.startsWith('.') ? cookie.domain.slice(1) : cookie.domain
+        if (!parsed.hostname.endsWith(domain) && parsed.hostname !== domain) {
+          continue
+        }
+      }
+
+      // Check path match
+      if (cookie.path && !parsed.pathname.startsWith(cookie.path)) {
+        continue
+      }
+
+      // Check secure
+      if (cookie.secure && parsed.protocol !== 'https:') {
+        continue
+      }
+
+      // Check expiration
+      if (cookie.expires && cookie.expires < new Date()) {
+        continue
+      }
+
+      matching.push(cookie)
+    }
+
+    return matching.map(c => `${c.name}=${c.value}`).join('; ')
+  }
+
+  private extractCookies(response: Response, url: string): void {
+    const setCookies = response.headers.getSetCookie()
+    const parsedUrl = new URL(url)
+
+    for (const cookieStr of setCookies) {
+      const cookie = this.parseCookie(cookieStr, parsedUrl.hostname)
+      if (cookie) {
+        const key = `${cookie.domain || ''}:${cookie.name}`
+        this.cookies.set(key, cookie)
+      }
+    }
+  }
+
+  private parseCookie(cookieStr: string, defaultDomain: string): TPCookie | null {
+    const parts = cookieStr.split(';').map(p => p.trim())
+    const [nameValue, ...attrs] = parts
+
+    if (!nameValue || !nameValue.includes('=')) return null
+
+    const [name, ...valueParts] = nameValue.split('=')
+    const value = valueParts.join('=')
+
+    const cookie: TPCookie = {
+      name: name.trim(),
+      value: value.trim(),
+      domain: defaultDomain,
+      path: '/',
+    }
+
+    for (const attr of attrs) {
+      const [key, ...attrValueParts] = attr.split('=')
+      const attrKey = key.trim().toLowerCase()
+      const attrValue = attrValueParts.join('=').trim()
+
+      switch (attrKey) {
+        case 'domain':
+          cookie.domain = attrValue
+          break
+        case 'path':
+          cookie.path = attrValue
+          break
+        case 'expires':
+          cookie.expires = new Date(attrValue)
+          break
+        case 'max-age':
+          const maxAge = parseInt(attrValue, 10)
+          if (maxAge) cookie.expires = new Date(Date.now() + maxAge * 1000)
+          break
+        case 'secure':
+          cookie.secure = true
+          break
+        case 'httponly':
+          cookie.httpOnly = true
+          break
+      }
+    }
+
+    return cookie
+  }
+
+  async request<T>(
+    method: string,
+    path: string,
+    options: {
+      body?: unknown
+      headers?: Record<string, string>
+      params?: Record<string, string | number | boolean | undefined>
+    } = {}
+  ): Promise<T> {
+    let url = path.startsWith('http') ? path : `${this.baseUrl}${path}`
+
+    // Add query params
+    if (options.params) {
+      const searchParams = new URLSearchParams()
+      for (const [key, value] of Object.entries(options.params)) {
+        if (value !== undefined) {
+          searchParams.set(key, String(value))
+        }
+      }
+      const queryString = searchParams.toString()
+      if (queryString) {
+        url += (url.includes('?') ? '&' : '?') + queryString
+      }
+    }
+
+    const headers: Record<string, string> = {
+      'User-Agent': this.userAgent,
+      'Accept': 'application/json, text/plain, */*',
+      'Accept-Language': 'en-US,en;q=0.9',
+      ...options.headers,
+    }
+
+    // Add cookies
+    const cookieHeader = this.getCookieHeader(url)
+    if (cookieHeader) {
+      headers['Cookie'] = cookieHeader
+    }
+
+    // Add body
+    let body: string | undefined
+    if (options.body !== undefined) {
+      if (typeof options.body === 'object') {
+        headers['Content-Type'] = headers['Content-Type'] || 'application/json'
+        body = JSON.stringify(options.body)
+      }
+      else if (typeof options.body === 'string') {
+        body = options.body
+      }
+    }
+
+    const controller = new AbortController()
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout)
+
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body,
+        signal: controller.signal,
+        redirect: 'follow',
+      })
+
+      clearTimeout(timeoutId)
+
+      // Extract cookies from response
+      this.extractCookies(response, url)
+
+      if (!response.ok) {
+        const text = await response.text()
+        throw new Error(`HTTP ${response.status}: ${text}`)
+      }
+
+      const contentType = response.headers.get('content-type')
+      if (contentType?.includes('application/json')) {
+        return await response.json() as T
+      }
+
+      return await response.text() as T
+    }
+    catch (error) {
+      clearTimeout(timeoutId)
+      if (error instanceof Error && error.name === 'AbortError') {
+        throw new Error(`Request timeout: ${url}`)
+      }
+      throw error
+    }
+  }
+
+  async get<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
+    return this.request<T>('GET', path, { params })
+  }
+
+  async post<T>(path: string, body?: unknown, headers?: Record<string, string>): Promise<T> {
+    return this.request<T>('POST', path, { body, headers })
+  }
+
+  async put<T>(path: string, body?: unknown): Promise<T> {
+    return this.request<T>('PUT', path, { body })
+  }
+
+  async delete<T>(path: string): Promise<T> {
+    return this.request<T>('DELETE', path)
+  }
+
+  // Save cookies to disk
+  async saveCookies(path: string): Promise<void> {
+    const cookies = this.getCookies()
+    await Bun.write(path, JSON.stringify(cookies, null, 2))
+  }
+
+  // Load cookies from disk
+  async loadCookies(path: string): Promise<void> {
+    try {
+      const file = Bun.file(path)
+      const content = await file.text()
+      const cookies = JSON.parse(content) as TPCookie[]
+
+      // Convert date strings back to Date objects
+      for (const cookie of cookies) {
+        if (cookie.expires) {
+          cookie.expires = new Date(cookie.expires)
+        }
+      }
+
+      this.setCookies(cookies)
+    }
+    catch {
+      // File doesn't exist or is invalid, ignore
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export { TrainingPeaks, default } from './TrainingPeaks'
+export type { TrainingPeaksConfig } from './TrainingPeaks'
+export * from './types'
+export { Browser } from './browser'
+export { HttpClient } from './http'

package/src/types.ts

@@ -0,0 +1,319 @@
+export interface TPCredentials {
+  username: string
+  password: string
+}
+
+export interface TPTokens {
+  accessToken: string
+  refreshToken?: string
+  expiresAt?: number
+  userId?: number
+  accountType?: 'athlete' | 'coach'
+}
+
+export interface TPCookie {
+  name: string
+  value: string
+  domain?: string
+  path?: string
+  expires?: Date
+  secure?: boolean
+  httpOnly?: boolean
+}
+
+export interface TPAthlete {
+  Id: number
+  UserId?: number
+  FirstName: string
+  LastName: string
+  Email?: string
+  DateOfBirth?: string
+  Gender?: string
+  City?: string
+  State?: string
+  Country?: string
+  Weight?: number
+  ProfilePhotoUrl?: string
+  IsCoach?: boolean
+  IsPremium?: boolean
+  ThresholdPower?: number
+  ThresholdHeartRate?: number
+  ThresholdPace?: number
+}
+
+export interface TPCoachAthlete extends TPAthlete {
+  AthleteId: number
+  CoachId: number
+  Status: string
+  LastActivity?: string
+  CompliancePercent?: number
+}
+
+export interface TPAthleteGroup {
+  id: number
+  coachId: number
+  name: string
+  athleteIds: number[]
+  isDefault: boolean
+}
+
+export interface TPWorkout {
+  workoutId: number
+  athleteId: number
+  workoutDay: string
+  title: string
+  description?: string
+  coachComments?: string
+  workoutComments?: unknown[]
+  workoutTypeValueId: number
+  completed: boolean | null
+  // Planned metrics
+  totalTimePlanned?: number
+  distancePlanned?: number
+  tssPlanned?: number
+  ifPlanned?: number
+  velocityPlanned?: number
+  caloriesPlanned?: number
+  energyPlanned?: number
+  elevationGainPlanned?: number
+  // Actual metrics
+  totalTime?: number
+  distance?: number
+  energy?: number
+  calories?: number
+  // Heart rate
+  heartRateAverage?: number
+  heartRateMinimum?: number
+  heartRateMaximum?: number
+  // Power
+  powerAverage?: number
+  powerMaximum?: number
+  normalizedPowerActual?: number
+  normalizedSpeedActual?: number
+  if?: number
+  tssActual?: number
+  // Cadence
+  cadenceAverage?: number
+  cadenceMaximum?: number
+  // Speed
+  velocityAverage?: number
+  velocityMaximum?: number
+  // Elevation
+  elevationGain?: number
+  elevationLoss?: number
+  elevationMinimum?: number
+  elevationAverage?: number
+  elevationMaximum?: number
+  // Temperature
+  tempMin?: number
+  tempAvg?: number
+  tempMax?: number
+  // RPE/Feeling
+  rpe?: number
+  feeling?: number
+  // Compliance
+  complianceDurationPercent?: number
+  complianceDistancePercent?: number
+  complianceTssPercent?: number
+  // Other
+  structure?: TPWorkoutStructureResponse
+  userTags?: string[] | null
+  syncedTo?: string[]
+  orderOnDay?: number
+  personalRecordCount?: number
+  lastModifiedDate?: string
+  isLocked?: boolean | null
+  startTime?: string | null
+  startTimePlanned?: string | null
+  sharedWorkoutInformationKey?: string
+  publicSettingValue?: number
+  code?: string | null
+  equipmentBikeId?: number | null
+  equipmentShoeId?: number | null
+  poolLengthOptionId?: number | null
+  workoutSubTypeId?: number | null
+  workoutDeviceSource?: string | null
+}
+
+export interface TPWorkoutStructureResponse {
+  structure: TPWorkoutStructureStep[]
+  polyline?: number[][]
+  primaryLengthMetric?: string
+  primaryIntensityMetric?: string
+  primaryIntensityTargetOrRange?: string
+}
+
+export interface TPWorkoutStructureStep {
+  type: 'step' | 'repetition'
+  name?: string
+  length: {
+    value: number
+    unit: string
+  }
+  steps?: TPWorkoutStructureStep[]
+  targets?: {
+    minValue?: number
+    maxValue?: number
+  }[]
+  intensityClass?: string
+  openDuration?: boolean
+  begin?: number
+  end?: number
+}
+
+// Workout type IDs returned by API
+export const TPWorkoutTypeIds = {
+  Swim: 1,
+  Bike: 2,
+  Run: 3,
+  Brick: 4,
+  XTrain: 5,
+  Strength: 6,
+  Custom: 7,
+  Walk: 8,
+  Hike: 9,
+  Row: 10,
+  Ski: 11,
+  Other: 100,
+} as const
+
+export type TPWorkoutTypeId = typeof TPWorkoutTypeIds[keyof typeof TPWorkoutTypeIds]
+
+export type TPWorkoutType =
+  | 'Swim'
+  | 'Bike'
+  | 'Run'
+  | 'Brick'
+  | 'XTrain'
+  | 'Strength'
+  | 'Custom'
+  | 'Walk'
+  | 'Hike'
+  | 'Row'
+  | 'Ski'
+  | 'Other'
+
+export function getWorkoutTypeName(typeId: number): TPWorkoutType {
+  const map: Record<number, TPWorkoutType> = {
+    1: 'Swim',
+    2: 'Bike',
+    3: 'Run',
+    4: 'Brick',
+    5: 'XTrain',
+    6: 'Strength',
+    7: 'Custom',
+    8: 'Walk',
+    9: 'Hike',
+    10: 'Row',
+    11: 'Ski',
+  }
+  return map[typeId] || 'Other'
+}
+
+export interface TPDailySummary {
+  Date: string
+  TssTotal?: number
+  DurationTotal?: number
+  DistanceTotal?: number
+  CaloriesTotal?: number
+  WorkoutsPlanned?: number
+  WorkoutsCompleted?: number
+  CompliancePercent?: number
+}
+
+export interface TPMetrics {
+  Date: string
+  Weight?: number
+  RestingHeartRate?: number
+  HrvRmssd?: number
+  SleepHours?: number
+  SleepQuality?: number
+  Fatigue?: number
+  Mood?: number
+  Motivation?: number
+  Stress?: number
+  Soreness?: number
+  Injury?: number
+  Steps?: number
+  CaloriesConsumed?: number
+  Comments?: string
+}
+
+export interface TPCalendarDay {
+  Date: string
+  Workouts: TPWorkout[]
+  Metrics?: TPMetrics
+  Notes?: string[]
+}
+
+export interface TPPerformanceChart {
+  StartDate: string
+  EndDate: string
+  Ctl: number[]  // Chronic Training Load (fitness)
+  Atl: number[]  // Acute Training Load (fatigue)
+  Tsb: number[]  // Training Stress Balance (form)
+  Tss: number[]  // Training Stress Score
+}
+
+export interface TPActivityFile {
+  Id: number
+  FileName: string
+  FileType: string
+  UploadDate: string
+  ProcessedDate?: string
+  Status: string
+  WorkoutId?: number
+}
+
+export interface TPUploadResult {
+  Success: boolean
+  FileId?: number
+  WorkoutId?: number
+  Message?: string
+  Errors?: string[]
+}
+
+export interface TPSearchParams {
+  startDate?: Date
+  endDate?: Date
+  workoutTypes?: TPWorkoutType[]
+  completed?: boolean
+  limit?: number
+  offset?: number
+}
+
+export interface TPLibraryWorkout {
+  Id: number
+  Title: string
+  Description?: string
+  WorkoutType: TPWorkoutType
+  Duration?: number
+  Distance?: number
+  Tss?: number
+  Structure?: TPWorkoutStructureResponse
+  Tags?: string[]
+  IsPublic?: boolean
+  CreatedDate?: string
+  ModifiedDate?: string
+}
+
+export interface TPPlan {
+  Id: number
+  Name: string
+  Description?: string
+  StartDate?: string
+  EndDate?: string
+  AthleteId?: number
+  CoachId?: number
+  Status: string
+  Weeks?: TPPlanWeek[]
+}
+
+export interface TPPlanWeek {
+  WeekNumber: number
+  StartDate: string
+  EndDate: string
+  Description?: string
+  PlannedTss?: number
+  PlannedDuration?: number
+}