costhawk 1.0.0

package/costcanary/lib/pricing.ts

@@ -0,0 +1,292 @@
+import { prisma } from './prisma';
+import { Provider } from '@prisma/client';
+
+// Initialize Redis if available (optional dependency)
+let redis: { get: (key: string) => Promise<string | null>; setex: (key: string, ttl: number, value: string) => Promise<void>; del: (...keys: string[]) => Promise<void>; keys: (pattern: string) => Promise<string[]> } | null = null;
+try {
+  if (process.env.REDIS_URL) {
+    const Redis = require('ioredis');
+    redis = new Redis(process.env.REDIS_URL);
+  }
+} catch (error) {
+  // DEBUG: console.log('[pricing] Redis not available, using database only');
+}
+const CACHE_TTL = 60 * 10; // 10 minutes
+
+export interface PriceRow {
+  provider: Provider;
+  canonicalModel: string;
+  versionId: string;
+  unitInputPer1k: number;
+  unitOutputPer1k: number;
+}
+
+export interface UsageData {
+  input?: number;
+  output?: number;
+  prompt?: number;
+  completion?: number;
+  total?: number;
+}
+
+export interface CostBreakdown {
+  input: number;
+  output: number;
+  costIn: number;
+  costOut: number;
+  total: number;
+}
+
+/**
+ * Get the active pricing for a specific provider and model
+ * Uses Redis caching if available
+ */
+export async function getActivePrice(
+  provider: Provider,
+  canonicalModel: string
+): Promise<PriceRow | null> {
+  if (!canonicalModel) return null;
+  
+  const cacheKey = `price:${provider}:${canonicalModel}`;
+  
+  // Try Redis cache first
+  if (redis) {
+    try {
+      const cached = await redis.get(cacheKey);
+      if (cached) {
+        // DEBUG: console.log(`[pricing] Cache hit for ${provider}:${canonicalModel}`);
+        try {
+          return JSON.parse(cached);
+        } catch (parseError) {
+          // DEBUG: console.error('[pricing] Failed to parse cached value:', parseError);
+          // Continue to database query
+        }
+      }
+    } catch (error) {
+      // DEBUG: console.error('[pricing] Redis error:', error);
+    }
+  }
+  
+  // Query database for active pricing
+  try {
+    const version = await prisma.pricingVersion.findFirst({
+      where: { 
+        provider, 
+        isActive: true 
+      },
+      orderBy: { createdAt: 'desc' },
+      include: {
+        models: {
+          where: { 
+            provider, 
+            canonicalModel 
+          },
+          take: 1
+        },
+      },
+    });
+    
+    const priceModel = version?.models[0];
+    if (!priceModel) {
+      // DEBUG: console.warn(`[pricing] No pricing found for ${provider}:${canonicalModel}`);
+      return null;
+    }
+
+    const priceRow: PriceRow = {
+      provider,
+      canonicalModel,
+      versionId: version.id,
+      unitInputPer1k: Number(priceModel.unitInputPer1k),
+      unitOutputPer1k: Number(priceModel.unitOutputPer1k),
+    };
+    
+    // Cache in Redis
+    if (redis) {
+      try {
+        await redis.setex(cacheKey, CACHE_TTL, JSON.stringify(priceRow));
+        // DEBUG: console.log(`[pricing] Cached ${provider}:${canonicalModel}`);
+      } catch (error) {
+        // DEBUG: console.error('[pricing] Redis cache error:', error);
+      }
+    }
+    
+    return priceRow;
+  } catch (error) {
+    // DEBUG: console.error('[pricing] Database error:', error);
+    return null;
+  }
+}
+
+/**
+ * Compute cost based on token usage and pricing
+ */
+export function computeCost(
+  usage: UsageData,
+  price: PriceRow
+): CostBreakdown {
+  // Normalize token counts (handle OpenAI, Anthropic, and common formats)
+  // Anthropic uses input_tokens/output_tokens, OpenAI uses prompt_tokens/completion_tokens
+  // We also accept input/output for normalized formats
+  const usageAny = usage as Record<string, unknown>;
+  const inputTokens =
+    (typeof usageAny.input_tokens === 'number' ? usageAny.input_tokens : 0) ||
+    (typeof usage.input === 'number' ? usage.input : 0) ||
+    (typeof usage.prompt === 'number' ? usage.prompt : 0) ||
+    (typeof usageAny.prompt_tokens === 'number' ? usageAny.prompt_tokens : 0) ||
+    0;
+  const outputTokens =
+    (typeof usageAny.output_tokens === 'number' ? usageAny.output_tokens : 0) ||
+    (typeof usage.output === 'number' ? usage.output : 0) ||
+    (typeof usage.completion === 'number' ? usage.completion : 0) ||
+    (typeof usageAny.completion_tokens === 'number' ? usageAny.completion_tokens : 0) ||
+    0;
+  
+  // Calculate costs (prices are per 1000 tokens)
+  const costIn = (inputTokens / 1000) * price.unitInputPer1k;
+  const costOut = (outputTokens / 1000) * price.unitOutputPer1k;
+  const total = +(costIn + costOut).toFixed(6);
+  
+  return {
+    input: inputTokens,
+    output: outputTokens,
+    costIn: +costIn.toFixed(6),
+    costOut: +costOut.toFixed(6),
+    total,
+  };
+}
+
+/**
+ * Clear the pricing cache (useful after updating prices)
+ */
+export async function clearPricingCache(
+  provider?: Provider,
+  model?: string
+): Promise<void> {
+  if (!redis) return;
+  
+  try {
+    if (provider && model) {
+      // Clear specific model
+      await redis.del(`price:${provider}:${model}`);
+      // DEBUG: console.log(`[pricing] Cleared cache for ${provider}:${model}`);
+    } else if (provider) {
+      // Clear all models for provider
+      const keys = await redis.keys(`price:${provider}:*`);
+      if (keys.length > 0) {
+        await redis.del(...keys);
+        // DEBUG: console.log(`[pricing] Cleared ${keys.length} cache entries for ${provider}`);
+      }
+    } else {
+      // Clear all pricing cache
+      const keys = await redis.keys('price:*');
+      if (keys.length > 0) {
+        await redis.del(...keys);
+        // DEBUG: console.log(`[pricing] Cleared all ${keys.length} pricing cache entries`);
+      }
+    }
+  } catch (error) {
+    // DEBUG: console.error('[pricing] Error clearing cache:', error);
+  }
+}
+
+/**
+ * Get fallback pricing for a model (hardcoded as backup)
+ * This ensures the system works even if database pricing isn't set up
+ *
+ * Prices are per 1K tokens (divide by 1000 from per-1M pricing)
+ * Last updated: December 2025
+ */
+export function getFallbackPrice(
+  provider: Provider,
+  model: string
+): PriceRow | null {
+  const fallbackPrices: Partial<Record<Provider, Record<string, { input: number; output: number }>>> = {
+    [Provider.OPENAI]: {
+      // GPT-5 (December 2025) - $1.25/$10 per 1M
+      'gpt-5': { input: 0.00125, output: 0.01 },
+      'gpt-5-mini': { input: 0.00025, output: 0.002 },
+      // GPT-4o series (still available)
+      'gpt-4o': { input: 0.0025, output: 0.01 },
+      'gpt-4o-mini': { input: 0.00015, output: 0.0006 },
+      'gpt-4o-audio-preview': { input: 0.0025, output: 0.01 },
+      // o1/o3 reasoning models
+      'o1': { input: 0.015, output: 0.06 },
+      'o1-mini': { input: 0.0011, output: 0.0044 },
+      'o1-preview': { input: 0.015, output: 0.06 },
+      'o3-mini': { input: 0.0011, output: 0.0044 },
+      // Legacy models
+      'gpt-4-turbo': { input: 0.01, output: 0.03 },
+      'gpt-4': { input: 0.03, output: 0.06 },
+      'gpt-3.5-turbo': { input: 0.0005, output: 0.0015 },
+    },
+    [Provider.ANTHROPIC]: {
+      // Claude 4.5 (December 2025) - correct API model IDs
+      'claude-opus-4-5': { input: 0.005, output: 0.025 },
+      'claude-opus-4-5-20251101': { input: 0.005, output: 0.025 },
+      'claude-sonnet-4-5': { input: 0.003, output: 0.015 },
+      'claude-sonnet-4-5-20250929': { input: 0.003, output: 0.015 },
+      // Claude 3.5 - widely used
+      'claude-3-5-sonnet-20241022': { input: 0.003, output: 0.015 },
+      'claude-3-5-sonnet-20240620': { input: 0.003, output: 0.015 },
+      'claude-3-5-sonnet-latest': { input: 0.003, output: 0.015 },
+      'claude-3-5-haiku-20241022': { input: 0.0008, output: 0.004 },
+      'claude-3-5-haiku-latest': { input: 0.0008, output: 0.004 },
+      // Legacy Claude 3
+      'claude-3-opus-20240229': { input: 0.015, output: 0.075 },
+      'claude-3-opus-latest': { input: 0.015, output: 0.075 },
+      'claude-3-sonnet-20240229': { input: 0.003, output: 0.015 },
+      'claude-3-haiku-20240307': { input: 0.00025, output: 0.00125 },
+    },
+    [Provider.GOOGLE]: {
+      // Gemini 2.0 (December 2025)
+      'gemini-2.0-flash': { input: 0.0001, output: 0.0004 },
+      'gemini-2.0-flash-exp': { input: 0.0001, output: 0.0004 },
+      'gemini-2.0-pro': { input: 0.00035, output: 0.0015 },
+      // Gemini 1.5 (still available)
+      'gemini-1.5-pro': { input: 0.00125, output: 0.005 },
+      'gemini-1.5-pro-latest': { input: 0.00125, output: 0.005 },
+      'gemini-1.5-flash': { input: 0.0006, output: 0.0024 },
+      'gemini-1.5-flash-latest': { input: 0.0006, output: 0.0024 },
+      'gemini-1.5-flash-8b': { input: 0.0000375, output: 0.00015 },
+      // Legacy
+      'gemini-pro': { input: 0.0005, output: 0.0015 },
+    },
+  };
+  
+  const providerPrices = fallbackPrices[provider];
+  if (!providerPrices) return null;
+  
+  // Try exact match first
+  let pricing = providerPrices[model];
+  
+  // If not found, try partial match
+  if (!pricing) {
+    const modelKey = Object.keys(providerPrices).find(key =>
+      model.toLowerCase().includes(key.toLowerCase()) ||
+      key.toLowerCase().includes(model.toLowerCase())
+    );
+    if (modelKey) {
+      pricing = providerPrices[modelKey];
+    }
+  }
+  
+  if (!pricing) {
+    // Use first available as default
+    const values = Object.values(providerPrices);
+    if (values.length > 0) {
+      pricing = values[0];
+    }
+  }
+  
+  if (!pricing) {
+    return null;
+  }
+  
+  return {
+    provider,
+    canonicalModel: model,
+    versionId: 'fallback',
+    unitInputPer1k: pricing.input,
+    unitOutputPer1k: pricing.output,
+  };
+}

package/costcanary/lib/prisma.ts

@@ -0,0 +1,52 @@
+import { PrismaClient } from '@prisma/client'
+
+declare global {
+  // eslint-disable-next-line no-var
+  var prisma: PrismaClient | undefined
+}
+
+// PrismaClient is attached to the `global` object in development to prevent
+// exhausting your database connection limit.
+//
+// Learn more:
+// https://pris.ly/d/help/next-js-best-practices
+
+const prismaClientSingleton = () => {
+  // Railway-specific: Use public URL if internal fails
+  const databaseUrl = process.env.DATABASE_PUBLIC_URL || process.env.DATABASE_URL;
+  
+  if (!databaseUrl) {
+    console.error('[Prisma] No database URL configured!');
+    console.error('[Prisma] DATABASE_URL:', !!process.env.DATABASE_URL);
+    console.error('[Prisma] DATABASE_PUBLIC_URL:', !!process.env.DATABASE_PUBLIC_URL);
+  }
+  
+  return new PrismaClient({
+    datasources: {
+      db: {
+        url: databaseUrl || 'postgresql://placeholder:placeholder@localhost:5432/placeholder'
+      }
+    },
+    log: process.env.NODE_ENV === 'development' 
+      ? ['query', 'error', 'warn'] 
+      : ['error'],
+  })
+}
+
+export const prisma = globalThis.prisma ?? prismaClientSingleton()
+
+if (process.env.NODE_ENV !== 'production') globalThis.prisma = prisma
+
+// Export types for use in the application
+export type { 
+  User, 
+  ApiKey, 
+  UsageLog, 
+  Budget, 
+  Alert, 
+  AuditLog,
+  Provider,
+  Period,
+  AlertType,
+  AuditAction
+} from '@prisma/client'

package/costcanary/lib/railway-db.ts

@@ -0,0 +1,157 @@
+/**
+ * Railway-Specific Database Connection Utilities
+ * 
+ * Handles Railway's internal DNS resolution timing issues
+ * and provides fallback strategies for reliable database connectivity.
+ */
+
+import { PrismaClient } from '@prisma/client';
+
+interface DatabaseConnectionResult {
+  success: boolean;
+  client?: PrismaClient;
+  error?: string;
+  urlUsed?: string;
+}
+
+/**
+ * Creates a database connection with Railway-specific fallback logic
+ */
+export async function createRailwayDatabaseConnection(
+  retries = 3,
+  timeoutMs = 5000
+): Promise<DatabaseConnectionResult> {
+  const connectionStrategies = [
+    {
+      name: 'internal',
+      url: process.env.DATABASE_URL,
+      description: 'Railway internal URL'
+    },
+    {
+      name: 'public',
+      url: process.env.DATABASE_PUBLIC_URL,
+      description: 'Railway public URL'
+    }
+  ];
+
+  for (const strategy of connectionStrategies) {
+    if (!strategy.url) {
+      continue;
+    }
+
+    for (let attempt = 1; attempt <= retries; attempt++) {
+      try {
+        // Railway deployment logging
+        // eslint-disable-next-line no-console
+        console.log(`[Railway DB] Attempting ${strategy.description} (attempt ${attempt}/${retries})`)
+        
+        const client = new PrismaClient({
+          datasources: {
+            db: { url: strategy.url }
+          },
+          log: ['error']
+        });
+
+        // Test connection with timeout
+        const connectionTest = client.$queryRaw`SELECT 1 as test`;
+        const timeoutPromise = new Promise((_, reject) => 
+          setTimeout(() => reject(new Error('Connection timeout')), timeoutMs)
+        );
+
+        await Promise.race([connectionTest, timeoutPromise]);
+        
+        // eslint-disable-next-line no-console
+        console.log(`[Railway DB] ✅ Connected using ${strategy.description}`);
+        return {
+          success: true,
+          client,
+          urlUsed: strategy.name
+        };
+
+      } catch (error) {
+        // eslint-disable-next-line no-console
+        console.log(`[Railway DB] ❌ ${strategy.description} attempt ${attempt} failed:`, 
+          error instanceof Error ? error.message : 'Unknown error'
+        );
+        
+        if (attempt === retries) {
+          // eslint-disable-next-line no-console
+          console.log(`[Railway DB] All attempts failed for ${strategy.description}`);
+        } else {
+          // Wait before retry
+          await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+      }
+    }
+  }
+
+  return {
+    success: false,
+    error: 'All database connection strategies failed'
+  };
+}
+
+/**
+ * Tests database connectivity with multiple strategies
+ */
+export async function testDatabaseConnectivity(): Promise<{
+  healthy: boolean;
+  details: {
+    internal?: { success: boolean; latency?: number; error?: string };
+    public?: { success: boolean; latency?: number; error?: string };
+  };
+}> {
+  const details: {
+    internal?: { success: boolean; latency?: number; error?: string };
+    public?: { success: boolean; latency?: number; error?: string };
+  } = {};
+  
+  const strategies = [
+    { name: 'internal' as const, url: process.env.DATABASE_URL },
+    { name: 'public' as const, url: process.env.DATABASE_PUBLIC_URL }
+  ];
+
+  let anySuccessful = false;
+
+  for (const strategy of strategies) {
+    if (!strategy.url) {
+      details[strategy.name] = { success: false, error: 'URL not configured' };
+      continue;
+    }
+
+    try {
+      const startTime = Date.now();
+      
+      const client = new PrismaClient({
+        datasources: { db: { url: strategy.url } },
+        log: []
+      });
+
+      const timeoutPromise = new Promise((_, reject) => 
+        setTimeout(() => reject(new Error('Timeout')), 3000)
+      );
+
+      await Promise.race([
+        client.$queryRaw`SELECT 1 as test`,
+        timeoutPromise
+      ]);
+
+      await client.$disconnect();
+      
+      const latency = Date.now() - startTime;
+      details[strategy.name] = { success: true, latency };
+      anySuccessful = true;
+
+    } catch (error) {
+      details[strategy.name] = {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error'
+      };
+    }
+  }
+
+  return {
+    healthy: anySuccessful,
+    details
+  };
+}