@xtr-dev/rondevu-server 0.2.4 → 0.4.0

package/src/app.ts

@@ -3,11 +3,12 @@ import { cors } from 'hono/cors';
 import { Storage } from './storage/types.ts';
 import { Config } from './config.ts';
 import { createAuthMiddleware, getAuthenticatedPeerId } from './middleware/auth.ts';
-import { generatePeerId, encryptPeerId, validateUsernameClaim, validateServicePublish, validateServiceFqn } from './crypto.ts';
+import { generatePeerId, encryptPeerId, validateUsernameClaim, validateServicePublish, validateServiceFqn, parseServiceFqn, isVersionCompatible } from './crypto.ts';
 import type { Context } from 'hono';
 
 /**
  * Creates the Hono application with username and service-based WebRTC signaling
+ * RESTful API design - v0.11.0
  */
 export function createApp(storage: Storage, config: Config) {
   const app = new Hono();
@@ -61,7 +62,7 @@ export function createApp(storage: Storage, config: Config) {
 
   /**
    * POST /register
-   * Register a new peer (still needed for peer ID generation)
+   * Register a new peer
    */
   app.post('/register', async (c) => {
     try {
@@ -78,19 +79,50 @@ export function createApp(storage: Storage, config: Config) {
     }
   });
 
-  // ===== Username Management =====
+  // ===== User Management (RESTful) =====
 
   /**
-   * POST /usernames/claim
+   * GET /users/:username
+   * Check if username is available or get claim info
+   */
+  app.get('/users/:username', async (c) => {
+    try {
+      const username = c.req.param('username');
+
+      const claimed = await storage.getUsername(username);
+
+      if (!claimed) {
+        return c.json({
+          username,
+          available: true
+        }, 200);
+      }
+
+      return c.json({
+        username: claimed.username,
+        available: false,
+        claimedAt: claimed.claimedAt,
+        expiresAt: claimed.expiresAt,
+        publicKey: claimed.publicKey
+      }, 200);
+    } catch (err) {
+      console.error('Error checking username:', err);
+      return c.json({ error: 'Internal server error' }, 500);
+    }
+  });
+
+  /**
+   * POST /users/:username
    * Claim a username with cryptographic proof
    */
-  app.post('/usernames/claim', async (c) => {
+  app.post('/users/:username', async (c) => {
     try {
+      const username = c.req.param('username');
       const body = await c.req.json();
-      const { username, publicKey, signature, message } = body;
+      const { publicKey, signature, message } = body;
 
-      if (!username || !publicKey || !signature || !message) {
-        return c.json({ error: 'Missing required parameters: username, publicKey, signature, message' }, 400);
+      if (!publicKey || !signature || !message) {
+        return c.json({ error: 'Missing required parameters: publicKey, signature, message' }, 400);
       }
 
       // Validate claim
@@ -112,7 +144,7 @@ export function createApp(storage: Storage, config: Config) {
           username: claimed.username,
           claimedAt: claimed.claimedAt,
           expiresAt: claimed.expiresAt
-        }, 200);
+        }, 201);
       } catch (err: any) {
         if (err.message?.includes('already claimed')) {
           return c.json({ error: 'Username already claimed by different public key' }, 409);
@@ -126,68 +158,104 @@ export function createApp(storage: Storage, config: Config) {
   });
 
   /**
-   * GET /usernames/:username
-   * Check if username is available or get claim info
+   * GET /users/:username/services/:fqn
+   * Get service by username and FQN with semver-compatible matching
    */
-  app.get('/usernames/:username', async (c) => {
+  app.get('/users/:username/services/:fqn', async (c) => {
     try {
       const username = c.req.param('username');
+      const serviceFqn = decodeURIComponent(c.req.param('fqn'));
 
-      const claimed = await storage.getUsername(username);
+      // Parse the requested FQN
+      const parsed = parseServiceFqn(serviceFqn);
+      if (!parsed) {
+        return c.json({ error: 'Invalid service FQN format' }, 400);
+      }
 
-      if (!claimed) {
+      const { serviceName, version: requestedVersion } = parsed;
+
+      // Find all services with matching service name
+      const matchingServices = await storage.findServicesByName(username, serviceName);
+
+      if (matchingServices.length === 0) {
+        return c.json({ error: 'Service not found' }, 404);
+      }
+
+      // Filter to compatible versions
+      const compatibleServices = matchingServices.filter(service => {
+        const serviceParsed = parseServiceFqn(service.serviceFqn);
+        if (!serviceParsed) return false;
+        return isVersionCompatible(requestedVersion, serviceParsed.version);
+      });
+
+      if (compatibleServices.length === 0) {
         return c.json({
-          username,
-          available: true
-        }, 200);
+          error: 'No compatible version found',
+          message: `Requested ${serviceFqn}, but no compatible versions available`
+        }, 404);
       }
 
-      return c.json({
-        username: claimed.username,
-        available: false,
-        claimedAt: claimed.claimedAt,
-        expiresAt: claimed.expiresAt,
-        publicKey: claimed.publicKey
-      }, 200);
-    } catch (err) {
-      console.error('Error checking username:', err);
-      return c.json({ error: 'Internal server error' }, 500);
-    }
-  });
+      // Use the first compatible service (most recently created)
+      const service = compatibleServices[0];
 
-  /**
-   * GET /usernames/:username/services
-   * List services for a username (privacy-preserving)
-   */
-  app.get('/usernames/:username/services', async (c) => {
-    try {
-      const username = c.req.param('username');
+      // Get the UUID for this service
+      const uuid = await storage.queryService(username, service.serviceFqn);
+
+      if (!uuid) {
+        return c.json({ error: 'Service index not found' }, 500);
+      }
 
-      const services = await storage.listServicesForUsername(username);
+      // Get all offers for this service
+      const serviceOffers = await storage.getOffersForService(service.id);
+
+      if (serviceOffers.length === 0) {
+        return c.json({ error: 'No offers found for this service' }, 404);
+      }
+
+      // Find an unanswered offer
+      const availableOffer = serviceOffers.find(offer => !offer.answererPeerId);
+
+      if (!availableOffer) {
+        return c.json({
+          error: 'No available offers',
+          message: 'All offers from this service are currently in use. Please try again later.'
+        }, 503);
+      }
 
       return c.json({
-        username,
-        services
+        uuid: uuid,
+        serviceId: service.id,
+        username: service.username,
+        serviceFqn: service.serviceFqn,
+        offerId: availableOffer.id,
+        sdp: availableOffer.sdp,
+        isPublic: service.isPublic,
+        metadata: service.metadata ? JSON.parse(service.metadata) : undefined,
+        createdAt: service.createdAt,
+        expiresAt: service.expiresAt
       }, 200);
     } catch (err) {
-      console.error('Error listing services:', err);
+      console.error('Error getting service:', err);
       return c.json({ error: 'Internal server error' }, 500);
     }
   });
 
-  // ===== Service Management =====
-
   /**
-   * POST /services
-   * Publish a service
+   * POST /users/:username/services
+   * Publish a service with one or more offers (RESTful endpoint)
    */
-  app.post('/services', authMiddleware, async (c) => {
+  app.post('/users/:username/services', authMiddleware, async (c) => {
+    let serviceFqn: string | undefined;
+    let createdOffers: any[] = [];
+
     try {
+      const username = c.req.param('username');
       const body = await c.req.json();
-      const { username, serviceFqn, sdp, ttl, isPublic, metadata, signature, message } = body;
+      serviceFqn = body.serviceFqn;
+      const { offers, ttl, isPublic, metadata, signature, message } = body;
 
-      if (!username || !serviceFqn || !sdp) {
-        return c.json({ error: 'Missing required parameters: username, serviceFqn, sdp' }, 400);
+      if (!serviceFqn || !offers || !Array.isArray(offers) || offers.length === 0) {
+        return c.json({ error: 'Missing required parameters: serviceFqn, offers (must be non-empty array)' }, 400);
       }
 
       // Validate service FQN
@@ -212,13 +280,24 @@ export function createApp(storage: Storage, config: Config) {
         return c.json({ error: 'Invalid signature for username' }, 403);
       }
 
-      // Validate SDP
-      if (typeof sdp !== 'string' || sdp.length === 0) {
-        return c.json({ error: 'Invalid SDP' }, 400);
+      // Delete existing service if one exists (upsert behavior)
+      const existingUuid = await storage.queryService(username, serviceFqn);
+      if (existingUuid) {
+        const existingService = await storage.getServiceByUuid(existingUuid);
+        if (existingService) {
+          await storage.deleteService(existingService.id, username);
+        }
       }
 
-      if (sdp.length > 64 * 1024) {
-        return c.json({ error: 'SDP too large (max 64KB)' }, 400);
+      // Validate all offers
+      for (const offer of offers) {
+        if (!offer.sdp || typeof offer.sdp !== 'string' || offer.sdp.length === 0) {
+          return c.json({ error: 'Invalid SDP in offers array' }, 400);
+        }
+
+        if (offer.sdp.length > 64 * 1024) {
+          return c.json({ error: 'SDP too large (max 64KB)' }, 400);
+        }
       }
 
       // Calculate expiry
@@ -229,94 +308,79 @@ export function createApp(storage: Storage, config: Config) {
       );
       const expiresAt = Date.now() + offerTtl;
 
-      // Create offer first
-      const offers = await storage.createOffers([{
+      // Prepare offer requests
+      const offerRequests = offers.map(offer => ({
         peerId,
-        sdp,
+        sdp: offer.sdp,
         expiresAt
-      }]);
+      }));
 
-      if (offers.length === 0) {
-        return c.json({ error: 'Failed to create offer' }, 500);
-      }
-
-      const offer = offers[0];
-
-      // Create service
+      // Create service with offers
       const result = await storage.createService({
         username,
         serviceFqn,
-        offerId: offer.id,
         expiresAt,
         isPublic: isPublic || false,
-        metadata: metadata ? JSON.stringify(metadata) : undefined
+        metadata: metadata ? JSON.stringify(metadata) : undefined,
+        offers: offerRequests
       });
 
+      createdOffers = result.offers;
+
+      // Return full service details with all offers
       return c.json({
-        serviceId: result.service.id,
         uuid: result.indexUuid,
-        offerId: offer.id,
+        serviceFqn: serviceFqn,
+        username: username,
+        serviceId: result.service.id,
+        offers: result.offers.map(o => ({
+          offerId: o.id,
+          sdp: o.sdp,
+          createdAt: o.createdAt,
+          expiresAt: o.expiresAt
+        })),
+        isPublic: result.service.isPublic,
+        metadata: metadata,
+        createdAt: result.service.createdAt,
         expiresAt: result.service.expiresAt
       }, 201);
     } catch (err) {
       console.error('Error creating service:', err);
-      return c.json({ error: 'Internal server error' }, 500);
+      console.error('Error details:', {
+        message: (err as Error).message,
+        stack: (err as Error).stack,
+        username: c.req.param('username'),
+        serviceFqn,
+        offerIds: createdOffers.map(o => o.id)
+      });
+      return c.json({
+        error: 'Internal server error',
+        details: (err as Error).message
+      }, 500);
     }
   });
 
   /**
-   * GET /services/:uuid
-   * Get service details by index UUID
+   * DELETE /users/:username/services/:fqn
+   * Delete a service by username and FQN (RESTful)
    */
-  app.get('/services/:uuid', async (c) => {
+  app.delete('/users/:username/services/:fqn', authMiddleware, async (c) => {
     try {
-      const uuid = c.req.param('uuid');
-
-      const service = await storage.getServiceByUuid(uuid);
+      const username = c.req.param('username');
+      const serviceFqn = decodeURIComponent(c.req.param('fqn'));
 
-      if (!service) {
+      // Find service by username and FQN
+      const uuid = await storage.queryService(username, serviceFqn);
+      if (!uuid) {
         return c.json({ error: 'Service not found' }, 404);
       }
 
-      // Get associated offer
-      const offer = await storage.getOfferById(service.offerId);
-
-      if (!offer) {
-        return c.json({ error: 'Associated offer not found' }, 404);
-      }
-
-      return c.json({
-        serviceId: service.id,
-        username: service.username,
-        serviceFqn: service.serviceFqn,
-        offerId: service.offerId,
-        sdp: offer.sdp,
-        isPublic: service.isPublic,
-        metadata: service.metadata ? JSON.parse(service.metadata) : undefined,
-        createdAt: service.createdAt,
-        expiresAt: service.expiresAt
-      }, 200);
-    } catch (err) {
-      console.error('Error getting service:', err);
-      return c.json({ error: 'Internal server error' }, 500);
-    }
-  });
-
-  /**
-   * DELETE /services/:serviceId
-   * Delete a service (requires ownership)
-   */
-  app.delete('/services/:serviceId', authMiddleware, async (c) => {
-    try {
-      const serviceId = c.req.param('serviceId');
-      const body = await c.req.json();
-      const { username } = body;
-
-      if (!username) {
-        return c.json({ error: 'Missing required parameter: username' }, 400);
+      const service = await storage.getServiceByUuid(uuid);
+      if (!service) {
+        return c.json({ error: 'Service not found' }, 404);
       }
 
-      const deleted = await storage.deleteService(serviceId, username);
+      const deleted = await storage.deleteService(service.id, username);
 
       if (!deleted) {
         return c.json({ error: 'Service not found or not owned by this username' }, 404);
@@ -329,157 +393,68 @@ export function createApp(storage: Storage, config: Config) {
     }
   });
 
+  // ===== Service Management (Legacy - for UUID-based access) =====
+
   /**
-   * POST /index/:username/query
-   * Query service by FQN (returns UUID)
+   * GET /services/:uuid
+   * Get service details by index UUID (kept for privacy)
    */
-  app.post('/index/:username/query', async (c) => {
+  app.get('/services/:uuid', async (c) => {
     try {
-      const username = c.req.param('username');
-      const body = await c.req.json();
-      const { serviceFqn } = body;
-
-      if (!serviceFqn) {
-        return c.json({ error: 'Missing required parameter: serviceFqn' }, 400);
-      }
+      const uuid = c.req.param('uuid');
 
-      const uuid = await storage.queryService(username, serviceFqn);
+      const service = await storage.getServiceByUuid(uuid);
 
-      if (!uuid) {
+      if (!service) {
         return c.json({ error: 'Service not found' }, 404);
       }
 
-      return c.json({
-        uuid,
-        allowed: true
-      }, 200);
-    } catch (err) {
-      console.error('Error querying service:', err);
-      return c.json({ error: 'Internal server error' }, 500);
-    }
-  });
-
-  // ===== Offer Management (Core WebRTC) =====
+      // Get all offers for this service
+      const serviceOffers = await storage.getOffersForService(service.id);
 
-  /**
-   * POST /offers
-   * Create offers (direct, no service - for testing/advanced users)
-   */
-  app.post('/offers', authMiddleware, async (c) => {
-    try {
-      const body = await c.req.json();
-      const { offers } = body;
-
-      if (!Array.isArray(offers) || offers.length === 0) {
-        return c.json({ error: 'Missing or invalid required parameter: offers (must be non-empty array)' }, 400);
-      }
-
-      if (offers.length > config.maxOffersPerRequest) {
-        return c.json({ error: `Too many offers (max ${config.maxOffersPerRequest})` }, 400);
+      if (serviceOffers.length === 0) {
+        return c.json({ error: 'No offers found for this service' }, 404);
       }
 
-      const peerId = getAuthenticatedPeerId(c);
-
-      // Validate and prepare offers
-      const validated = offers.map((offer: any) => {
-        const { sdp, ttl, secret } = offer;
-
-        if (typeof sdp !== 'string' || sdp.length === 0) {
-          throw new Error('Invalid SDP in offer');
-        }
-
-        if (sdp.length > 64 * 1024) {
-          throw new Error('SDP too large (max 64KB)');
-        }
-
-        const offerTtl = Math.min(
-          Math.max(ttl || config.offerDefaultTtl, config.offerMinTtl),
-          config.offerMaxTtl
-        );
+      // Find an unanswered offer
+      const availableOffer = serviceOffers.find(offer => !offer.answererPeerId);
 
-        return {
-          peerId,
-          sdp,
-          expiresAt: Date.now() + offerTtl,
-          secret: secret ? String(secret).substring(0, 128) : undefined
-        };
-      });
-
-      const created = await storage.createOffers(validated);
-
-      return c.json({
-        offers: created.map(offer => ({
-          id: offer.id,
-          peerId: offer.peerId,
-          expiresAt: offer.expiresAt,
-          createdAt: offer.createdAt,
-          hasSecret: !!offer.secret
-        }))
-      }, 201);
-    } catch (err: any) {
-      console.error('Error creating offers:', err);
-      return c.json({ error: err.message || 'Internal server error' }, 500);
-    }
-  });
-
-  /**
-   * GET /offers/mine
-   * Get authenticated peer's offers
-   */
-  app.get('/offers/mine', authMiddleware, async (c) => {
-    try {
-      const peerId = getAuthenticatedPeerId(c);
-      const offers = await storage.getOffersByPeerId(peerId);
+      if (!availableOffer) {
+        return c.json({
+          error: 'No available offers',
+          message: 'All offers from this service are currently in use. Please try again later.'
+        }, 503);
+      }
 
       return c.json({
-        offers: offers.map(offer => ({
-          id: offer.id,
-          sdp: offer.sdp,
-          createdAt: offer.createdAt,
-          expiresAt: offer.expiresAt,
-          lastSeen: offer.lastSeen,
-          hasSecret: !!offer.secret,
-          answererPeerId: offer.answererPeerId,
-          answered: !!offer.answererPeerId
-        }))
+        uuid: uuid,
+        serviceId: service.id,
+        username: service.username,
+        serviceFqn: service.serviceFqn,
+        offerId: availableOffer.id,
+        sdp: availableOffer.sdp,
+        isPublic: service.isPublic,
+        metadata: service.metadata ? JSON.parse(service.metadata) : undefined,
+        createdAt: service.createdAt,
+        expiresAt: service.expiresAt
       }, 200);
     } catch (err) {
-      console.error('Error getting offers:', err);
+      console.error('Error getting service:', err);
       return c.json({ error: 'Internal server error' }, 500);
     }
   });
 
-  /**
-   * DELETE /offers/:offerId
-   * Delete an offer
-   */
-  app.delete('/offers/:offerId', authMiddleware, async (c) => {
-    try {
-      const offerId = c.req.param('offerId');
-      const peerId = getAuthenticatedPeerId(c);
-
-      const deleted = await storage.deleteOffer(offerId, peerId);
-
-      if (!deleted) {
-        return c.json({ error: 'Offer not found or not owned by this peer' }, 404);
-      }
-
-      return c.json({ success: true }, 200);
-    } catch (err) {
-      console.error('Error deleting offer:', err);
-      return c.json({ error: 'Internal server error' }, 500);
-    }
-  });
+  // ===== Service-Based WebRTC Signaling =====
 
   /**
-   * POST /offers/:offerId/answer
-   * Answer an offer
+   * POST /services/:uuid/answer
+   * Answer a service offer
    */
-  app.post('/offers/:offerId/answer', authMiddleware, async (c) => {
+  app.post('/services/:uuid/answer', authMiddleware, async (c) => {
     try {
-      const offerId = c.req.param('offerId');
+      const uuid = c.req.param('uuid');
       const body = await c.req.json();
-      const { sdp, secret } = body;
+      const { sdp } = body;
 
       if (!sdp) {
         return c.json({ error: 'Missing required parameter: sdp' }, 400);
@@ -493,55 +468,82 @@ export function createApp(storage: Storage, config: Config) {
         return c.json({ error: 'SDP too large (max 64KB)' }, 400);
       }
 
+      // Get the service by UUID
+      const service = await storage.getServiceByUuid(uuid);
+      if (!service) {
+        return c.json({ error: 'Service not found' }, 404);
+      }
+
+      // Get available offer from service
+      const serviceOffers = await storage.getOffersForService(service.id);
+      const availableOffer = serviceOffers.find(offer => !offer.answererPeerId);
+
+      if (!availableOffer) {
+        return c.json({ error: 'No available offers' }, 503);
+      }
+
       const answererPeerId = getAuthenticatedPeerId(c);
 
-      const result = await storage.answerOffer(offerId, answererPeerId, sdp, secret);
+      const result = await storage.answerOffer(availableOffer.id, answererPeerId, sdp);
 
       if (!result.success) {
         return c.json({ error: result.error }, 400);
       }
 
-      return c.json({ success: true }, 200);
+      return c.json({
+        success: true,
+        offerId: availableOffer.id
+      }, 200);
     } catch (err) {
-      console.error('Error answering offer:', err);
+      console.error('Error answering service:', err);
       return c.json({ error: 'Internal server error' }, 500);
     }
   });
 
   /**
-   * GET /offers/answers
-   * Get answers for authenticated peer's offers
+   * GET /services/:uuid/answer
+   * Get answer for a service (offerer polls this)
    */
-  app.get('/offers/answers', authMiddleware, async (c) => {
+  app.get('/services/:uuid/answer', authMiddleware, async (c) => {
     try {
+      const uuid = c.req.param('uuid');
       const peerId = getAuthenticatedPeerId(c);
-      const offers = await storage.getAnsweredOffers(peerId);
+
+      // Get the service by UUID
+      const service = await storage.getServiceByUuid(uuid);
+      if (!service) {
+        return c.json({ error: 'Service not found' }, 404);
+      }
+
+      // Get offers for this service owned by the requesting peer
+      const serviceOffers = await storage.getOffersForService(service.id);
+      const myOffer = serviceOffers.find(offer => offer.peerId === peerId && offer.answererPeerId);
+
+      if (!myOffer || !myOffer.answerSdp) {
+        return c.json({ error: 'Offer not yet answered' }, 404);
+      }
 
       return c.json({
-        answers: offers.map(offer => ({
-          offerId: offer.id,
-          answererPeerId: offer.answererPeerId,
-          answerSdp: offer.answerSdp,
-          answeredAt: offer.answeredAt
-        }))
+        offerId: myOffer.id,
+        answererId: myOffer.answererPeerId,
+        sdp: myOffer.answerSdp,
+        answeredAt: myOffer.answeredAt
       }, 200);
     } catch (err) {
-      console.error('Error getting answers:', err);
+      console.error('Error getting service answer:', err);
       return c.json({ error: 'Internal server error' }, 500);
     }
   });
 
-  // ===== ICE Candidate Exchange =====
-
   /**
-   * POST /offers/:offerId/ice-candidates
-   * Add ICE candidates for an offer
+   * POST /services/:uuid/ice-candidates
+   * Add ICE candidates for a service
    */
-  app.post('/offers/:offerId/ice-candidates', authMiddleware, async (c) => {
+  app.post('/services/:uuid/ice-candidates', authMiddleware, async (c) => {
     try {
-      const offerId = c.req.param('offerId');
+      const uuid = c.req.param('uuid');
       const body = await c.req.json();
-      const { candidates } = body;
+      const { candidates, offerId } = body;
 
       if (!Array.isArray(candidates) || candidates.length === 0) {
         return c.json({ error: 'Missing or invalid required parameter: candidates' }, 400);
@@ -549,8 +551,27 @@ export function createApp(storage: Storage, config: Config) {
 
       const peerId = getAuthenticatedPeerId(c);
 
+      // Get the service by UUID
+      const service = await storage.getServiceByUuid(uuid);
+      if (!service) {
+        return c.json({ error: 'Service not found' }, 404);
+      }
+
+      // If offerId is provided, use it; otherwise find the peer's offer
+      let targetOfferId = offerId;
+      if (!targetOfferId) {
+        const serviceOffers = await storage.getOffersForService(service.id);
+        const myOffer = serviceOffers.find(offer =>
+          offer.peerId === peerId || offer.answererPeerId === peerId
+        );
+        if (!myOffer) {
+          return c.json({ error: 'No offer found for this peer' }, 404);
+        }
+        targetOfferId = myOffer.id;
+      }
+
       // Get offer to determine role
-      const offer = await storage.getOfferById(offerId);
+      const offer = await storage.getOfferById(targetOfferId);
       if (!offer) {
         return c.json({ error: 'Offer not found' }, 404);
       }
@@ -558,27 +579,47 @@ export function createApp(storage: Storage, config: Config) {
       // Determine role
       const role = offer.peerId === peerId ? 'offerer' : 'answerer';
 
-      const count = await storage.addIceCandidates(offerId, peerId, role, candidates);
+      const count = await storage.addIceCandidates(targetOfferId, peerId, role, candidates);
 
-      return c.json({ count }, 200);
+      return c.json({ count, offerId: targetOfferId }, 200);
     } catch (err) {
-      console.error('Error adding ICE candidates:', err);
+      console.error('Error adding ICE candidates to service:', err);
       return c.json({ error: 'Internal server error' }, 500);
     }
   });
 
   /**
-   * GET /offers/:offerId/ice-candidates
-   * Get ICE candidates for an offer
+   * GET /services/:uuid/ice-candidates
+   * Get ICE candidates for a service
    */
-  app.get('/offers/:offerId/ice-candidates', authMiddleware, async (c) => {
+  app.get('/services/:uuid/ice-candidates', authMiddleware, async (c) => {
     try {
-      const offerId = c.req.param('offerId');
+      const uuid = c.req.param('uuid');
       const since = c.req.query('since');
+      const offerId = c.req.query('offerId');
       const peerId = getAuthenticatedPeerId(c);
 
+      // Get the service by UUID
+      const service = await storage.getServiceByUuid(uuid);
+      if (!service) {
+        return c.json({ error: 'Service not found' }, 404);
+      }
+
+      // If offerId is provided, use it; otherwise find the peer's offer
+      let targetOfferId = offerId;
+      if (!targetOfferId) {
+        const serviceOffers = await storage.getOffersForService(service.id);
+        const myOffer = serviceOffers.find(offer =>
+          offer.peerId === peerId || offer.answererPeerId === peerId
+        );
+        if (!myOffer) {
+          return c.json({ error: 'No offer found for this peer' }, 404);
+        }
+        targetOfferId = myOffer.id;
+      }
+
       // Get offer to determine role
-      const offer = await storage.getOfferById(offerId);
+      const offer = await storage.getOfferById(targetOfferId);
       if (!offer) {
         return c.json({ error: 'Offer not found' }, 404);
       }
@@ -587,16 +628,17 @@ export function createApp(storage: Storage, config: Config) {
       const targetRole = offer.peerId === peerId ? 'answerer' : 'offerer';
       const sinceTimestamp = since ? parseInt(since, 10) : undefined;
 
-      const candidates = await storage.getIceCandidates(offerId, targetRole, sinceTimestamp);
+      const candidates = await storage.getIceCandidates(targetOfferId, targetRole, sinceTimestamp);
 
       return c.json({
         candidates: candidates.map(c => ({
           candidate: c.candidate,
           createdAt: c.createdAt
-        }))
+        })),
+        offerId: targetOfferId
       }, 200);
     } catch (err) {
-      console.error('Error getting ICE candidates:', err);
+      console.error('Error getting ICE candidates for service:', err);
       return c.json({ error: 'Internal server error' }, 500);
     }
   });