ucpify 1.0.0

package/src/cli.ts

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import * as fs from 'fs';
+import * as path from 'path';
+import { MerchantConfigSchema, MerchantConfig } from './schema';
+import { createExpressApp } from './express-app';
+
+const program = new Command();
+
+program
+  .name('ucp-server')
+  .description('Generate and run a UCP-compliant server for merchants')
+  .version('1.0.0');
+
+program
+  .command('init')
+  .description('Create a sample merchant configuration file')
+  .option('-o, --output <file>', 'Output file path', 'merchant-config.json')
+  .action((options) => {
+    const sampleConfig: MerchantConfig = {
+      name: 'My Store',
+      domain: 'http://localhost:3000',
+      currency: 'USD',
+      terms_url: 'https://example.com/terms',
+      privacy_url: 'https://example.com/privacy',
+      tax_rate: 0.08,
+      port: 3000,
+      items: [
+        {
+          id: 'item_001',
+          title: 'Classic T-Shirt',
+          description: 'A comfortable cotton t-shirt',
+          price: 2500, // $25.00 in cents
+          sku: 'TSH-001',
+        },
+        {
+          id: 'item_002',
+          title: 'Premium Hoodie',
+          description: 'Warm and stylish hoodie',
+          price: 5999, // $59.99 in cents
+          sku: 'HOO-001',
+        },
+      ],
+      shipping_options: [
+        {
+          id: 'standard',
+          title: 'Standard Shipping',
+          description: 'Arrives in 5-7 business days',
+          price: 500, // $5.00
+          estimated_days: '5-7 business days',
+        },
+        {
+          id: 'express',
+          title: 'Express Shipping',
+          description: 'Arrives in 2-3 business days',
+          price: 1500, // $15.00
+          estimated_days: '2-3 business days',
+        },
+        {
+          id: 'overnight',
+          title: 'Overnight Shipping',
+          description: 'Arrives next business day',
+          price: 2999, // $29.99
+          estimated_days: '1 business day',
+        },
+      ],
+      payment_handlers: [
+        {
+          namespace: 'com.stripe',
+          id: 'stripe_handler',
+          config: {
+            publishable_key: 'pk_test_...',
+          },
+        },
+        {
+          namespace: 'com.paypal',
+          id: 'paypal_handler',
+          config: {
+            client_id: 'your_paypal_client_id',
+          },
+        },
+      ],
+    };
+
+    fs.writeFileSync(options.output, JSON.stringify(sampleConfig, null, 2));
+    console.log(`✅ Created sample config at: ${options.output}`);
+    console.log('\n📝 Edit this file to configure your products, shipping, and payment handlers.');
+    console.log(`\n🚀 Run: npx ts-node src/cli.ts serve ${options.output}`);
+  });
+
+program
+  .command('serve')
+  .description('Start the UCP server from a configuration file')
+  .argument('<config>', 'Path to merchant configuration JSON file')
+  .option('-p, --port <number>', 'Port to run on (overrides config)')
+  .option('--no-db', 'Use in-memory storage instead of SQLite')
+  .action((configPath, options) => {
+    try {
+      const configFile = path.resolve(configPath);
+      if (!fs.existsSync(configFile)) {
+        console.error(`❌ Config file not found: ${configFile}`);
+        process.exit(1);
+      }
+
+      const rawConfig = JSON.parse(fs.readFileSync(configFile, 'utf-8'));
+      const config = MerchantConfigSchema.parse(rawConfig);
+
+      if (options.port) {
+        config.port = parseInt(options.port, 10);
+      }
+
+      const useDb = options.db !== false;
+      const app = createExpressApp(config, { useDb });
+      const port = config.port;
+      const storageType = useDb ? 'SQLite' : 'In-memory';
+
+      app.listen(port, () => {
+        console.log(`
+╔══════════════════════════════════════════════════════════════╗
+║                    🛒 UCP Server Running                     ║
+╠══════════════════════════════════════════════════════════════╣
+║  Merchant: ${config.name.padEnd(49)}║
+║  Domain:   ${config.domain.padEnd(49)}║
+║  Port:     ${String(port).padEnd(49)}║
+║  Storage:  ${storageType.padEnd(49)}║
+╠══════════════════════════════════════════════════════════════╣
+║  Endpoints:                                                  ║
+║  • GET  /.well-known/ucp              - UCP Profile          ║
+║  • POST /ucp/v1/checkout-sessions     - Create Checkout      ║
+║  • GET  /ucp/v1/checkout-sessions/:id - Get Checkout         ║
+║  • PUT  /ucp/v1/checkout-sessions/:id - Update Checkout      ║
+║  • POST /ucp/v1/checkout-sessions/:id/complete - Complete    ║
+║  • POST /ucp/v1/checkout-sessions/:id/cancel   - Cancel      ║
+║  • GET  /ucp/v1/orders                - List Orders          ║
+║  • GET  /ucp/v1/orders/:id            - Get Order            ║
+║  • GET  /ucp/v1/items                 - Product Catalog      ║
+║  • GET  /health                       - Health Check         ║
+╚══════════════════════════════════════════════════════════════╝
+
+🔗 UCP Profile: http://localhost:${port}/.well-known/ucp
+📦 Products: ${config.items.length} items loaded
+🚚 Shipping: ${config.shipping_options.length} options available
+💳 Payment Handlers: ${config.payment_handlers.length} configured
+💾 Storage: ${storageType}${useDb ? ' (./data/ucp.db)' : ''}
+        `);
+      });
+    } catch (error) {
+      console.error('❌ Error:', error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('validate')
+  .description('Validate a merchant configuration file')
+  .argument('<config>', 'Path to merchant configuration JSON file')
+  .action((configPath) => {
+    try {
+      const configFile = path.resolve(configPath);
+      if (!fs.existsSync(configFile)) {
+        console.error(`❌ Config file not found: ${configFile}`);
+        process.exit(1);
+      }
+
+      const rawConfig = JSON.parse(fs.readFileSync(configFile, 'utf-8'));
+      const config = MerchantConfigSchema.parse(rawConfig);
+
+      console.log('✅ Configuration is valid!');
+      console.log(`\n📊 Summary:`);
+      console.log(`   • Name: ${config.name}`);
+      console.log(`   • Domain: ${config.domain}`);
+      console.log(`   • Currency: ${config.currency}`);
+      console.log(`   • Tax Rate: ${(config.tax_rate * 100).toFixed(2)}%`);
+      console.log(`   • Products: ${config.items.length}`);
+      console.log(`   • Shipping Options: ${config.shipping_options.length}`);
+      console.log(`   • Payment Handlers: ${config.payment_handlers.length}`);
+    } catch (error) {
+      console.error('❌ Validation failed:', error);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/src/config.ts

@@ -0,0 +1,27 @@
+import 'dotenv/config';
+
+export const config = {
+  // Server
+  port: parseInt(process.env.PORT || '3000', 10),
+  nodeEnv: process.env.NODE_ENV || 'development',
+  
+  // Database
+  databasePath: process.env.DATABASE_PATH || './data/ucp.db',
+  
+  // Logging
+  logLevel: process.env.LOG_LEVEL || 'info',
+  
+  // UCP
+  domain: process.env.UCP_DOMAIN || 'http://localhost:3000',
+  
+  // Stripe
+  stripeSecretKey: process.env.STRIPE_SECRET_KEY || '',
+  stripeWebhookSecret: process.env.STRIPE_WEBHOOK_SECRET || '',
+  
+  // PayPal
+  paypalClientId: process.env.PAYPAL_CLIENT_ID || '',
+  paypalClientSecret: process.env.PAYPAL_CLIENT_SECRET || '',
+  paypalMode: (process.env.PAYPAL_MODE || 'sandbox') as 'sandbox' | 'live',
+};
+
+export type Config = typeof config;

package/src/db.ts

@@ -0,0 +1,94 @@
+import Database, { Database as DatabaseType } from 'better-sqlite3';
+import { config } from './config';
+import { logger } from './logger';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Ensure data directory exists
+const dataDir = path.dirname(config.databasePath);
+if (!fs.existsSync(dataDir)) {
+  fs.mkdirSync(dataDir, { recursive: true });
+}
+
+export const db: DatabaseType = new Database(config.databasePath);
+
+// Enable WAL mode for better concurrent access
+db.pragma('journal_mode = WAL');
+
+// Initialize schema
+const schema = `
+CREATE TABLE IF NOT EXISTS checkouts (
+  id TEXT PRIMARY KEY,
+  status TEXT NOT NULL,
+  currency TEXT NOT NULL,
+  buyer_json TEXT,
+  fulfillment_json TEXT,
+  payment_json TEXT,
+  totals_json TEXT NOT NULL,
+  links_json TEXT NOT NULL,
+  messages_json TEXT,
+  continue_url TEXT,
+  expires_at TEXT,
+  order_json TEXT,
+  payment_intent_id TEXT,
+  paypal_order_id TEXT,
+  payment_provider TEXT,
+  payment_status TEXT DEFAULT 'none',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS line_items (
+  id TEXT NOT NULL,
+  checkout_id TEXT NOT NULL,
+  item_json TEXT NOT NULL,
+  quantity INTEGER NOT NULL,
+  totals_json TEXT,
+  PRIMARY KEY (id, checkout_id),
+  FOREIGN KEY (checkout_id) REFERENCES checkouts(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS orders (
+  id TEXT PRIMARY KEY,
+  checkout_id TEXT NOT NULL,
+  permalink_url TEXT,
+  buyer_json TEXT,
+  line_items_json TEXT NOT NULL,
+  totals_json TEXT NOT NULL,
+  fulfillment_json TEXT,
+  payment_intent_id TEXT,
+  paypal_order_id TEXT,
+  payment_provider TEXT,
+  payment_status TEXT DEFAULT 'pending',
+  created_at TEXT NOT NULL,
+  FOREIGN KEY (checkout_id) REFERENCES checkouts(id)
+);
+
+CREATE TABLE IF NOT EXISTS inventory (
+  item_id TEXT PRIMARY KEY,
+  stock INTEGER NOT NULL DEFAULT 0,
+  reserved INTEGER NOT NULL DEFAULT 0,
+  updated_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_line_items_checkout ON line_items(checkout_id);
+CREATE INDEX IF NOT EXISTS idx_orders_checkout ON orders(checkout_id);
+CREATE INDEX IF NOT EXISTS idx_checkouts_status ON checkouts(status);
+`;
+
+db.exec(schema);
+logger.info({ path: config.databasePath }, 'Database initialized');
+
+// Helper functions
+export function getDb(): Database.Database {
+  return db;
+}
+
+export function isDbHealthy(): boolean {
+  try {
+    db.prepare('SELECT 1').get();
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/express-app.ts

@@ -0,0 +1,344 @@
+import express, { Request, Response, NextFunction } from 'express';
+import rateLimit from 'express-rate-limit';
+import { UCPServer } from './ucp-server';
+import { UCPServerDB } from './ucp-server-db';
+import { MerchantConfig, UCP_VERSION, CreateCheckoutRequestSchema, UpdateCheckoutRequestSchema } from './schema';
+import { isDbHealthy, db } from './db';
+import { logger } from './logger';
+import { constructWebhookEvent, isStripeConfigured } from './stripe';
+import { getPayPalOrder, capturePayPalOrder } from './paypal';
+
+type UCPServerType = UCPServer | UCPServerDB;
+
+// Rate limiters
+const apiLimiter = rateLimit({
+  windowMs: 60 * 1000, // 1 minute
+  max: 100, // 100 requests per minute
+  standardHeaders: true,
+  legacyHeaders: false,
+  message: { error: 'Too many requests, please try again later' },
+});
+
+const checkoutLimiter = rateLimit({
+  windowMs: 60 * 1000,
+  max: 20, // 20 checkout creates per minute
+  standardHeaders: true,
+  legacyHeaders: false,
+  message: { error: 'Too many checkout requests' },
+});
+
+export function createExpressApp(config: MerchantConfig, options?: { useDb?: boolean }): express.Application {
+  const app = express();
+  const ucpServer: UCPServerType = options?.useDb 
+    ? new UCPServerDB(config) 
+    : new UCPServer(config);
+  const useDb = options?.useDb ?? false;
+
+  // Apply rate limiting to API routes
+  app.use('/ucp/v1/', apiLimiter);
+
+  // Stripe webhook needs raw body - must come before json parser
+  app.post('/webhooks/stripe', express.raw({ type: 'application/json' }), (req: Request, res: Response) => {
+    const signature = req.headers['stripe-signature'] as string;
+    if (!signature) {
+      res.status(400).json({ error: 'Missing stripe-signature header' });
+      return;
+    }
+
+    const event = constructWebhookEvent(req.body, signature);
+    if (!event) {
+      res.status(400).json({ error: 'Invalid webhook signature' });
+      return;
+    }
+
+    logger.info({ eventType: event.type, eventId: event.id }, 'Stripe webhook received');
+
+    switch (event.type) {
+      case 'payment_intent.succeeded': {
+        const paymentIntent = event.data.object as { id: string; metadata?: { checkout_id?: string; order_id?: string } };
+        const checkoutId = paymentIntent.metadata?.checkout_id;
+        const orderId = paymentIntent.metadata?.order_id;
+        
+        if (checkoutId && useDb) {
+          db.prepare(`UPDATE checkouts SET payment_status = 'succeeded', updated_at = ? WHERE id = ?`)
+            .run(new Date().toISOString(), checkoutId);
+          if (orderId) {
+            db.prepare(`UPDATE orders SET payment_status = 'succeeded' WHERE id = ?`).run(orderId);
+          }
+          logger.info({ checkoutId, orderId, paymentIntentId: paymentIntent.id }, 'Payment succeeded');
+        }
+        break;
+      }
+      case 'payment_intent.payment_failed': {
+        const paymentIntent = event.data.object as { id: string; metadata?: { checkout_id?: string; order_id?: string }; last_payment_error?: { message?: string } };
+        const checkoutId = paymentIntent.metadata?.checkout_id;
+        const orderId = paymentIntent.metadata?.order_id;
+        
+        if (checkoutId && useDb) {
+          db.prepare(`UPDATE checkouts SET payment_status = 'failed', updated_at = ? WHERE id = ?`)
+            .run(new Date().toISOString(), checkoutId);
+          if (orderId) {
+            db.prepare(`UPDATE orders SET payment_status = 'failed' WHERE id = ?`).run(orderId);
+          }
+          logger.error({ 
+            checkoutId, orderId, paymentIntentId: paymentIntent.id,
+            error: paymentIntent.last_payment_error?.message 
+          }, 'Payment failed');
+        }
+        break;
+      }
+    }
+
+    res.json({ received: true });
+  });
+
+  // PayPal webhook - capture completed orders
+  app.post('/webhooks/paypal', express.json(), async (req: Request, res: Response) => {
+    const eventType = req.body.event_type;
+    const resource = req.body.resource;
+
+    logger.info({ eventType, resourceId: resource?.id }, 'PayPal webhook received');
+
+    if (eventType === 'CHECKOUT.ORDER.APPROVED' && resource?.id) {
+      try {
+        // Capture the payment
+        const capturedOrder = await capturePayPalOrder(resource.id);
+        if (capturedOrder && capturedOrder.status === 'COMPLETED') {
+          // Get the checkout ID from the order
+          const orderDetails = await getPayPalOrder(resource.id);
+          const checkoutId = orderDetails?.customId;
+          
+          if (checkoutId && useDb) {
+            const now = new Date().toISOString();
+            db.prepare(`UPDATE checkouts SET payment_status = 'succeeded', updated_at = ? WHERE paypal_order_id = ?`)
+              .run(now, resource.id);
+            db.prepare(`UPDATE orders SET payment_status = 'succeeded' WHERE paypal_order_id = ?`)
+              .run(resource.id);
+            logger.info({ checkoutId, paypalOrderId: resource.id }, 'PayPal payment captured and succeeded');
+          }
+        }
+      } catch (error) {
+        logger.error({ error, paypalOrderId: resource.id }, 'Failed to capture PayPal order');
+      }
+    } else if (eventType === 'PAYMENT.CAPTURE.DENIED' && resource?.id) {
+      if (useDb) {
+        const now = new Date().toISOString();
+        db.prepare(`UPDATE checkouts SET payment_status = 'failed', updated_at = ? WHERE paypal_order_id = ?`)
+          .run(now, resource.supplementary_data?.related_ids?.order_id);
+        db.prepare(`UPDATE orders SET payment_status = 'failed' WHERE paypal_order_id = ?`)
+          .run(resource.supplementary_data?.related_ids?.order_id);
+        logger.error({ paypalOrderId: resource.id }, 'PayPal payment denied');
+      }
+    }
+
+    res.json({ received: true });
+  });
+
+  app.use(express.json());
+
+  // Request logging middleware
+  app.use((req: Request, res: Response, next: NextFunction) => {
+    const start = Date.now();
+    res.on('finish', () => {
+      logger.info({
+        method: req.method,
+        path: req.path,
+        status: res.statusCode,
+        duration: Date.now() - start,
+      }, 'Request completed');
+    });
+    next();
+  });
+
+  // CORS middleware
+  app.use((_req: Request, res: Response, next: NextFunction) => {
+    res.header('Access-Control-Allow-Origin', '*');
+    res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+    res.header('Access-Control-Allow-Headers', 'Content-Type, UCP-Agent, Authorization');
+    next();
+  });
+
+  // UCP Discovery endpoint
+  app.get('/.well-known/ucp', (_req: Request, res: Response) => {
+    res.json(ucpServer.getProfile());
+  });
+
+  // Create Checkout Session
+  app.post('/ucp/v1/checkout-sessions', checkoutLimiter, (req: Request, res: Response) => {
+    const parsed = CreateCheckoutRequestSchema.safeParse(req.body);
+    if (!parsed.success) {
+      res.status(400).json({ error: 'Validation failed', details: parsed.error.issues });
+      return;
+    }
+    try {
+      const session = ucpServer.createCheckout(parsed.data);
+      res.status(201).json(session);
+    } catch (error) {
+      res.status(400).json({ error: 'Invalid request', details: String(error) });
+    }
+  });
+
+  // Get Checkout Session
+  app.get('/ucp/v1/checkout-sessions/:id', (req: Request, res: Response) => {
+    const id = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+    const session = ucpServer.getCheckout(id);
+    if (!session) {
+      res.status(404).json({ error: 'Checkout session not found' });
+      return;
+    }
+    res.json(session);
+  });
+
+  // Update Checkout Session
+  app.put('/ucp/v1/checkout-sessions/:id', (req: Request, res: Response) => {
+    const parsed = UpdateCheckoutRequestSchema.safeParse(req.body);
+    if (!parsed.success) {
+      res.status(400).json({ error: 'Validation failed', details: parsed.error.issues });
+      return;
+    }
+    try {
+      const id = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+      const session = ucpServer.updateCheckout(id, parsed.data);
+      if (!session) {
+        res.status(404).json({ error: 'Checkout session not found' });
+        return;
+      }
+      res.json(session);
+    } catch (error) {
+      res.status(400).json({ error: 'Invalid request', details: String(error) });
+    }
+  });
+
+  // Complete Checkout
+  app.post('/ucp/v1/checkout-sessions/:id/complete', async (req: Request, res: Response) => {
+    const id = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+    try {
+      const result = await ucpServer.completeCheckout(id);
+      if ('error' in result) {
+        res.status(400).json(result);
+        return;
+      }
+      res.status(201).json(result);
+    } catch (error) {
+      logger.error({ error, checkoutId: id }, 'Failed to complete checkout');
+      res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+
+  // Cancel Checkout
+  app.post('/ucp/v1/checkout-sessions/:id/cancel', (req: Request, res: Response) => {
+    const id = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+    const session = ucpServer.cancelCheckout(id);
+    if (!session) {
+      res.status(404).json({ error: 'Checkout session not found' });
+      return;
+    }
+    res.json(session);
+  });
+
+  // Get Order
+  app.get('/ucp/v1/orders/:id', (req: Request, res: Response) => {
+    const id = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+    const order = ucpServer.getOrder(id);
+    if (!order) {
+      res.status(404).json({ error: 'Order not found' });
+      return;
+    }
+    res.json(order);
+  });
+
+  // List Orders
+  app.get('/ucp/v1/orders', (_req: Request, res: Response) => {
+    res.json(ucpServer.listOrders());
+  });
+
+  // Product catalog (convenience endpoint)
+  app.get('/ucp/v1/items', (_req: Request, res: Response) => {
+    res.json(ucpServer.getConfig().items);
+  });
+
+  // Admin stats endpoint
+  app.get('/admin/stats', (_req: Request, res: Response) => {
+    if (!useDb) {
+      res.status(501).json({ error: 'Stats require database mode' });
+      return;
+    }
+    try {
+      const checkoutStats = db.prepare(`
+        SELECT status, COUNT(*) as count FROM checkouts GROUP BY status
+      `).all() as { status: string; count: number }[];
+      
+      const orderStats = db.prepare(`
+        SELECT payment_status, payment_provider, COUNT(*) as count 
+        FROM orders GROUP BY payment_status, payment_provider
+      `).all() as { payment_status: string; payment_provider: string; count: number }[];
+      
+      const revenueResult = db.prepare(`
+        SELECT SUM(json_extract(totals_json, '$[?(@.type=="total")].amount')) as total
+        FROM orders WHERE payment_status = 'succeeded'
+      `).get() as { total: number | null };
+      
+      const todayOrders = db.prepare(`
+        SELECT COUNT(*) as count FROM orders 
+        WHERE date(created_at) = date('now')
+      `).get() as { count: number };
+
+      res.json({
+        checkouts: Object.fromEntries(checkoutStats.map(s => [s.status, s.count])),
+        orders: {
+          by_payment_status: Object.fromEntries(orderStats.map(s => [`${s.payment_provider || 'none'}_${s.payment_status}`, s.count])),
+          today: todayOrders.count,
+        },
+        revenue: {
+          total_succeeded: revenueResult.total || 0,
+        },
+        timestamp: new Date().toISOString(),
+      });
+    } catch (error) {
+      logger.error({ error }, 'Failed to get admin stats');
+      res.status(500).json({ error: 'Failed to get stats' });
+    }
+  });
+
+  // Admin dashboard HTML
+  app.get('/admin', (_req: Request, res: Response) => {
+    res.send(`<!DOCTYPE html>
+<html><head><title>UCP Admin</title>
+<style>
+  body { font-family: system-ui; max-width: 800px; margin: 40px auto; padding: 20px; }
+  .card { background: #f5f5f5; padding: 20px; border-radius: 8px; margin: 10px 0; }
+  .stat { font-size: 2em; font-weight: bold; color: #333; }
+  .label { color: #666; font-size: 0.9em; }
+  .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; }
+  h1 { color: #333; }
+</style>
+</head><body>
+<h1>🛒 UCP Server Admin</h1>
+<div class="grid" id="stats">Loading...</div>
+<script>
+fetch('/admin/stats').then(r=>r.json()).then(d=>{
+  document.getElementById('stats').innerHTML = \`
+    <div class="card"><div class="stat">\${Object.values(d.checkouts).reduce((a,b)=>a+b,0)}</div><div class="label">Total Checkouts</div></div>
+    <div class="card"><div class="stat">\${d.checkouts.completed||0}</div><div class="label">Completed</div></div>
+    <div class="card"><div class="stat">\${d.orders.today||0}</div><div class="label">Orders Today</div></div>
+    <div class="card"><div class="stat">$\${(d.revenue.total_succeeded/100).toFixed(2)}</div><div class="label">Revenue</div></div>
+  \`;
+}).catch(e=>document.getElementById('stats').innerHTML='Error loading stats');
+</script>
+</body></html>`);
+  });
+
+  // Health check
+  app.get('/health', (_req: Request, res: Response) => {
+    const dbHealthy = isDbHealthy();
+    const status = dbHealthy ? 'ok' : 'degraded';
+    res.status(dbHealthy ? 200 : 503).json({ 
+      status, 
+      ucp_version: UCP_VERSION,
+      database: dbHealthy ? 'connected' : 'disconnected',
+      timestamp: new Date().toISOString(),
+    });
+  });
+
+  return app;
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export { MerchantConfigSchema, ItemSchema, ShippingOptionSchema, PaymentHandlerSchema } from './schema';
+export type { MerchantConfig, Item, ShippingOption, PaymentHandler, CheckoutSession, Order } from './schema';
+export { UCPServer } from './ucp-server';
+export { createExpressApp } from './express-app';

package/src/logger.ts

@@ -0,0 +1,12 @@
+import pino from 'pino';
+import { config } from './config';
+
+export const logger = pino({
+  level: config.logLevel,
+  transport: config.nodeEnv === 'development' 
+    ? { target: 'pino-pretty', options: { colorize: true } }
+    : undefined,
+  base: { service: 'ucp-server' },
+});
+
+export type Logger = typeof logger;