@xtr-dev/rondevu-server 0.3.0 → 0.4.0

package/README.md

@@ -240,10 +240,10 @@ Unpublish a service (requires authentication and ownership)
 }
 ```
 
-### Offer Management (Low-level)
+### WebRTC Signaling (Service-Based)
 
-#### `POST /offers`
-Create one or more offers (requires authentication)
+#### `POST /services/:uuid/answer`
+Answer a service offer (requires authentication)
 
 **Headers:**
 - `Authorization: Bearer {peerId}:{secret}`
@@ -251,46 +251,80 @@ Create one or more offers (requires authentication)
 **Request:**
 ```json
 {
-  "offers": [
-    {
-      "sdp": "v=0...",
-      "ttl": 300000
-    }
-  ]
+  "sdp": "v=0..."
 }
 ```
 
-#### `GET /offers/mine`
-List all offers owned by authenticated peer
+**Response:**
+```json
+{
+  "success": true,
+  "offerId": "offer-hash"
+}
+```
 
-#### `DELETE /offers/:offerId`
-Delete a specific offer
+#### `GET /services/:uuid/answer`
+Get answer for a service (offerer polls this)
 
-#### `POST /offers/:offerId/answer`
-Answer an offer (locks it to answerer)
+**Headers:**
+- `Authorization: Bearer {peerId}:{secret}`
 
-**Request:**
+**Response:**
 ```json
 {
-  "sdp": "v=0..."
+  "offerId": "offer-hash",
+  "answererId": "answerer-peer-id",
+  "sdp": "v=0...",
+  "answeredAt": 1733404800000
 }
 ```
 
-#### `GET /offers/:offerId/answer`
-Get answer for a specific offer
+**Note:** Returns 404 if not yet answered
+
+#### `POST /services/:uuid/ice-candidates`
+Post ICE candidates for a service (requires authentication)
 
-#### `POST /offers/:offerId/ice-candidates`
-Post ICE candidates for an offer
+**Headers:**
+- `Authorization: Bearer {peerId}:{secret}`
 
 **Request:**
 ```json
 {
-  "candidates": ["candidate:1 1 UDP..."]
+  "candidates": ["candidate:1 1 UDP..."],
+  "offerId": "optional-offer-id"
+}
+```
+
+**Response:**
+```json
+{
+  "count": 1,
+  "offerId": "offer-hash"
+}
+```
+
+**Note:** If `offerId` is omitted, the server will auto-detect the peer's offer
+
+#### `GET /services/:uuid/ice-candidates?since=1234567890&offerId=optional-offer-id`
+Get ICE candidates from the other peer (requires authentication)
+
+**Headers:**
+- `Authorization: Bearer {peerId}:{secret}`
+
+**Response:**
+```json
+{
+  "candidates": [
+    {
+      "candidate": "candidate:1 1 UDP...",
+      "createdAt": 1733404800000
+    }
+  ],
+  "offerId": "offer-hash"
 }
 ```
 
-#### `GET /offers/:offerId/ice-candidates?since=1234567890`
-Get ICE candidates from the other peer
+**Note:** Returns candidates from the opposite role (offerer gets answerer candidates and vice versa)
 
 ## Configuration
 

package/dist/index.js

@@ -607,6 +607,36 @@ function validateServiceFqn(fqn) {
   }
   return { valid: true };
 }
+function parseVersion(version) {
+  const match = version.match(/^([0-9]+)\.([0-9]+)\.([0-9]+)(-[a-z0-9.-]+)?$/);
+  if (!match) return null;
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: parseInt(match[3], 10),
+    prerelease: match[4]?.substring(1)
+    // Remove leading dash
+  };
+}
+function isVersionCompatible(requested, available) {
+  const req = parseVersion(requested);
+  const avail = parseVersion(available);
+  if (!req || !avail) return false;
+  if (req.major !== avail.major) return false;
+  if (req.major === 0 && req.minor !== avail.minor) return false;
+  if (avail.minor < req.minor) return false;
+  if (avail.minor === req.minor && avail.patch < req.patch) return false;
+  if (req.prerelease && req.prerelease !== avail.prerelease) return false;
+  return true;
+}
+function parseServiceFqn(fqn) {
+  const parts = fqn.split("@");
+  if (parts.length !== 2) return null;
+  return {
+    serviceName: parts[0],
+    version: parts[1]
+  };
+}
 function validateTimestamp(timestamp) {
   if (typeof timestamp !== "number" || !Number.isFinite(timestamp)) {
     return { valid: false, error: "Timestamp must be a finite number" };
@@ -814,37 +844,40 @@ function createApp(storage, config) {
       return c.json({ error: "Internal server error" }, 500);
     }
   });
-  app.get("/users/:username/services", async (c) => {
-    try {
-      const username = c.req.param("username");
-      const services = await storage.listServicesForUsername(username);
-      return c.json({
-        username,
-        services
-      }, 200);
-    } catch (err2) {
-      console.error("Error listing services:", err2);
-      return c.json({ error: "Internal server error" }, 500);
-    }
-  });
   app.get("/users/:username/services/:fqn", async (c) => {
     try {
       const username = c.req.param("username");
       const serviceFqn = decodeURIComponent(c.req.param("fqn"));
-      const uuid = await storage.queryService(username, serviceFqn);
-      if (!uuid) {
-        return c.json({ error: "Service not found" }, 404);
+      const parsed = parseServiceFqn(serviceFqn);
+      if (!parsed) {
+        return c.json({ error: "Invalid service FQN format" }, 400);
       }
-      const service = await storage.getServiceByUuid(uuid);
-      if (!service) {
+      const { serviceName, version: requestedVersion } = parsed;
+      const matchingServices = await storage.findServicesByName(username, serviceName);
+      if (matchingServices.length === 0) {
         return c.json({ error: "Service not found" }, 404);
       }
-      const initialOffer = await storage.getOfferById(service.offerId);
-      if (!initialOffer) {
-        return c.json({ error: "Associated offer not found" }, 404);
+      const compatibleServices = matchingServices.filter((service2) => {
+        const serviceParsed = parseServiceFqn(service2.serviceFqn);
+        if (!serviceParsed) return false;
+        return isVersionCompatible(requestedVersion, serviceParsed.version);
+      });
+      if (compatibleServices.length === 0) {
+        return c.json({
+          error: "No compatible version found",
+          message: `Requested ${serviceFqn}, but no compatible versions available`
+        }, 404);
       }
-      const peerOffers = await storage.getOffersByPeerId(initialOffer.peerId);
-      const availableOffer = peerOffers.find((offer) => !offer.answererPeerId);
+      const service = compatibleServices[0];
+      const uuid = await storage.queryService(username, service.serviceFqn);
+      if (!uuid) {
+        return c.json({ error: "Service index not found" }, 500);
+      }
+      const serviceOffers = await storage.getOffersForService(service.id);
+      if (serviceOffers.length === 0) {
+        return c.json({ error: "No offers found for this service" }, 404);
+      }
+      const availableOffer = serviceOffers.find((offer) => !offer.answererPeerId);
       if (!availableOffer) {
         return c.json({
           error: "No available offers",
@@ -870,14 +903,14 @@ function createApp(storage, config) {
   });
   app.post("/users/:username/services", authMiddleware, async (c) => {
     let serviceFqn;
-    let offers = [];
+    let createdOffers = [];
     try {
       const username = c.req.param("username");
       const body = await c.req.json();
       serviceFqn = body.serviceFqn;
-      const { sdp, ttl, isPublic, metadata, signature, message } = body;
-      if (!serviceFqn || !sdp) {
-        return c.json({ error: "Missing required parameters: serviceFqn, sdp" }, 400);
+      const { offers, ttl, isPublic, metadata, signature, message } = body;
+      if (!serviceFqn || !offers || !Array.isArray(offers) || offers.length === 0) {
+        return c.json({ error: "Missing required parameters: serviceFqn, offers (must be non-empty array)" }, 400);
       }
       const fqnValidation = validateServiceFqn(serviceFqn);
       if (!fqnValidation.valid) {
@@ -901,11 +934,13 @@ function createApp(storage, config) {
           await storage.deleteService(existingService.id, username);
         }
       }
-      if (typeof sdp !== "string" || sdp.length === 0) {
-        return c.json({ error: "Invalid SDP" }, 400);
-      }
-      if (sdp.length > 64 * 1024) {
-        return c.json({ error: "SDP too large (max 64KB)" }, 400);
+      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);
+        }
       }
       const peerId = getAuthenticatedPeerId(c);
       const offerTtl = Math.min(
@@ -913,30 +948,31 @@ function createApp(storage, config) {
         config.offerMaxTtl
       );
       const expiresAt = Date.now() + offerTtl;
-      offers = await storage.createOffers([{
+      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];
+      }));
       const result = await storage.createService({
         username,
         serviceFqn,
-        offerId: offer.id,
         expiresAt,
         isPublic: isPublic || false,
-        metadata: metadata ? JSON.stringify(metadata) : void 0
+        metadata: metadata ? JSON.stringify(metadata) : void 0,
+        offers: offerRequests
       });
+      createdOffers = result.offers;
       return c.json({
         uuid: result.indexUuid,
         serviceFqn,
         username,
         serviceId: result.service.id,
-        offerId: offer.id,
-        sdp: offer.sdp,
+        offers: result.offers.map((o) => ({
+          offerId: o.id,
+          sdp: o.sdp,
+          createdAt: o.createdAt,
+          expiresAt: o.expiresAt
+        })),
         isPublic: result.service.isPublic,
         metadata,
         createdAt: result.service.createdAt,
@@ -949,7 +985,7 @@ function createApp(storage, config) {
         stack: err2.stack,
         username: c.req.param("username"),
         serviceFqn,
-        offerId: offers[0]?.id
+        offerIds: createdOffers.map((o) => o.id)
       });
       return c.json({
         error: "Internal server error",
@@ -986,12 +1022,11 @@ function createApp(storage, config) {
       if (!service) {
         return c.json({ error: "Service not found" }, 404);
       }
-      const initialOffer = await storage.getOfferById(service.offerId);
-      if (!initialOffer) {
-        return c.json({ error: "Associated offer not found" }, 404);
+      const serviceOffers = await storage.getOffersForService(service.id);
+      if (serviceOffers.length === 0) {
+        return c.json({ error: "No offers found for this service" }, 404);
       }
-      const peerOffers = await storage.getOffersByPeerId(initialOffer.peerId);
-      const availableOffer = peerOffers.find((offer) => !offer.answererPeerId);
+      const availableOffer = serviceOffers.find((offer) => !offer.answererPeerId);
       if (!availableOffer) {
         return c.json({
           error: "No available offers",
@@ -1015,113 +1050,11 @@ function createApp(storage, config) {
       return c.json({ error: "Internal server error" }, 500);
     }
   });
-  app.post("/offers", authMiddleware, async (c) => {
+  app.post("/services/:uuid/answer", authMiddleware, async (c) => {
     try {
+      const uuid = c.req.param("uuid");
       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);
-      }
-      const peerId = getAuthenticatedPeerId(c);
-      const validated = offers.map((offer) => {
-        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
-        );
-        return {
-          peerId,
-          sdp,
-          expiresAt: Date.now() + offerTtl,
-          secret: secret ? String(secret).substring(0, 128) : void 0
-        };
-      });
-      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 (err2) {
-      console.error("Error creating offers:", err2);
-      return c.json({ error: err2.message || "Internal server error" }, 500);
-    }
-  });
-  app.get("/offers/mine", authMiddleware, async (c) => {
-    try {
-      const peerId = getAuthenticatedPeerId(c);
-      const offers = await storage.getOffersByPeerId(peerId);
-      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
-        }))
-      }, 200);
-    } catch (err2) {
-      console.error("Error getting offers:", err2);
-      return c.json({ error: "Internal server error" }, 500);
-    }
-  });
-  app.get("/offers/:offerId", authMiddleware, async (c) => {
-    try {
-      const offerId = c.req.param("offerId");
-      const offer = await storage.getOfferById(offerId);
-      if (!offer) {
-        return c.json({ error: "Offer not found" }, 404);
-      }
-      return c.json({
-        id: offer.id,
-        peerId: offer.peerId,
-        sdp: offer.sdp,
-        createdAt: offer.createdAt,
-        expiresAt: offer.expiresAt,
-        answererPeerId: offer.answererPeerId,
-        answered: !!offer.answererPeerId,
-        answerSdp: offer.answerSdp
-      }, 200);
-    } catch (err2) {
-      console.error("Error getting offer:", err2);
-      return c.json({ error: "Internal server error" }, 500);
-    }
-  });
-  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 (err2) {
-      console.error("Error deleting offer:", err2);
-      return c.json({ error: "Internal server error" }, 500);
-    }
-  });
-  app.post("/offers/:offerId/answer", authMiddleware, async (c) => {
-    try {
-      const offerId = c.req.param("offerId");
-      const body = await c.req.json();
-      const { sdp, secret } = body;
+      const { sdp } = body;
       if (!sdp) {
         return c.json({ error: "Missing required parameter: sdp" }, 400);
       }
@@ -1131,83 +1064,126 @@ function createApp(storage, config) {
       if (sdp.length > 64 * 1024) {
         return c.json({ error: "SDP too large (max 64KB)" }, 400);
       }
+      const service = await storage.getServiceByUuid(uuid);
+      if (!service) {
+        return c.json({ error: "Service not found" }, 404);
+      }
+      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 (err2) {
-      console.error("Error answering offer:", err2);
+      console.error("Error answering service:", err2);
       return c.json({ error: "Internal server error" }, 500);
     }
   });
-  app.get("/offers/:offerId/answer", authMiddleware, async (c) => {
+  app.get("/services/:uuid/answer", authMiddleware, async (c) => {
     try {
-      const offerId = c.req.param("offerId");
+      const uuid = c.req.param("uuid");
       const peerId = getAuthenticatedPeerId(c);
-      const offer = await storage.getOfferById(offerId);
-      if (!offer) {
-        return c.json({ error: "Offer not found" }, 404);
-      }
-      if (offer.peerId !== peerId) {
-        return c.json({ error: "Not authorized to view this answer" }, 403);
+      const service = await storage.getServiceByUuid(uuid);
+      if (!service) {
+        return c.json({ error: "Service not found" }, 404);
       }
-      if (!offer.answererPeerId || !offer.answerSdp) {
+      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({
-        offerId: offer.id,
-        answererId: offer.answererPeerId,
-        sdp: offer.answerSdp,
-        answeredAt: offer.answeredAt
+        offerId: myOffer.id,
+        answererId: myOffer.answererPeerId,
+        sdp: myOffer.answerSdp,
+        answeredAt: myOffer.answeredAt
       }, 200);
     } catch (err2) {
-      console.error("Error getting answer:", err2);
+      console.error("Error getting service answer:", err2);
       return c.json({ error: "Internal server error" }, 500);
     }
   });
-  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);
       }
       const peerId = getAuthenticatedPeerId(c);
-      const offer = await storage.getOfferById(offerId);
+      const service = await storage.getServiceByUuid(uuid);
+      if (!service) {
+        return c.json({ error: "Service not found" }, 404);
+      }
+      let targetOfferId = offerId;
+      if (!targetOfferId) {
+        const serviceOffers = await storage.getOffersForService(service.id);
+        const myOffer = serviceOffers.find(
+          (offer2) => offer2.peerId === peerId || offer2.answererPeerId === peerId
+        );
+        if (!myOffer) {
+          return c.json({ error: "No offer found for this peer" }, 404);
+        }
+        targetOfferId = myOffer.id;
+      }
+      const offer = await storage.getOfferById(targetOfferId);
       if (!offer) {
         return c.json({ error: "Offer not found" }, 404);
       }
       const role = offer.peerId === peerId ? "offerer" : "answerer";
-      const count = await storage.addIceCandidates(offerId, peerId, role, candidates);
-      return c.json({ count }, 200);
+      const count = await storage.addIceCandidates(targetOfferId, peerId, role, candidates);
+      return c.json({ count, offerId: targetOfferId }, 200);
     } catch (err2) {
-      console.error("Error adding ICE candidates:", err2);
+      console.error("Error adding ICE candidates to service:", err2);
       return c.json({ error: "Internal server error" }, 500);
     }
   });
-  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);
-      const offer = await storage.getOfferById(offerId);
+      const service = await storage.getServiceByUuid(uuid);
+      if (!service) {
+        return c.json({ error: "Service not found" }, 404);
+      }
+      let targetOfferId = offerId;
+      if (!targetOfferId) {
+        const serviceOffers = await storage.getOffersForService(service.id);
+        const myOffer = serviceOffers.find(
+          (offer2) => offer2.peerId === peerId || offer2.answererPeerId === peerId
+        );
+        if (!myOffer) {
+          return c.json({ error: "No offer found for this peer" }, 404);
+        }
+        targetOfferId = myOffer.id;
+      }
+      const offer = await storage.getOfferById(targetOfferId);
       if (!offer) {
         return c.json({ error: "Offer not found" }, 404);
       }
       const targetRole = offer.peerId === peerId ? "answerer" : "offerer";
       const sinceTimestamp = since ? parseInt(since, 10) : void 0;
-      const candidates = await storage.getIceCandidates(offerId, targetRole, sinceTimestamp);
+      const candidates = await storage.getIceCandidates(targetOfferId, targetRole, sinceTimestamp);
       return c.json({
         candidates: candidates.map((c2) => ({
           candidate: c2.candidate,
           createdAt: c2.createdAt
-        }))
+        })),
+        offerId: targetOfferId
       }, 200);
     } catch (err2) {
-      console.error("Error getting ICE candidates:", err2);
+      console.error("Error getting ICE candidates for service:", err2);
       return c.json({ error: "Internal server error" }, 500);
     }
   });
@@ -1362,7 +1338,6 @@ var SQLiteStorage = class {
     const offersWithIds = await Promise.all(
       offers.map(async (offer) => ({
         ...offer,
-        serviceId: offer.serviceId || null,
         id: offer.id || await generateOfferHash(offer.sdp)
       }))
     );
@@ -1386,7 +1361,7 @@ var SQLiteStorage = class {
         created.push({
           id: offer.id,
           peerId: offer.peerId,
-          serviceId: offer.serviceId,
+          serviceId: offer.serviceId || void 0,
           sdp: offer.sdp,
           createdAt: now,
           expiresAt: offer.expiresAt,
@@ -1693,6 +1668,15 @@ var SQLiteStorage = class {
     const row = stmt.get(username, serviceFqn, Date.now());
     return row ? row.uuid : null;
   }
+  async findServicesByName(username, serviceName) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM services
+      WHERE username = ? AND service_fqn LIKE ? AND expires_at > ?
+      ORDER BY created_at DESC
+    `);
+    const rows = stmt.all(username, `${serviceName}@%`, Date.now());
+    return rows.map((row) => this.rowToService(row));
+  }
   async deleteService(serviceId, username) {
     const stmt = this.db.prepare(`
       DELETE FROM services