cyberia 3.1.3 → 3.2.5

package/src/server/ipfs-client.js

@@ -244,7 +244,11 @@ const unpinCid = async (cid) => {
     });
     if (!clusterRes.ok) {
       const text = await clusterRes.text();
-      logger.warn(`IPFS Cluster unpin failed (${clusterRes.status}): ${text}`);
+      if (clusterRes.status === 404) {
+        logger.info(`IPFS Cluster unpin – CID already not pinned: ${cid}`);
+      } else {
+        logger.warn(`IPFS Cluster unpin failed (${clusterRes.status}): ${text}`);
+      }
     } else {
       logger.info(`IPFS Cluster unpin OK – CID: ${cid}`);
     }
@@ -428,6 +432,25 @@ const IpfsClient = {
   listClusterPins,
   listKuboPins,
   removeMfsPath,
+  /**
+   * Check whether a single CID is currently pinned on the local Kubo node.
+   * Uses the pin/ls?arg=<cid> endpoint which returns only that one pin
+   * (much cheaper than fetching the full list).
+   *
+   * @param {string} cid - IPFS Content Identifier to check.
+   * @returns {Promise<boolean>} true when the CID is pinned.
+   */
+  isCidPinned: async (cid) => {
+    const kuboUrl = getIpfsApiUrl();
+    try {
+      const res = await fetch(`${kuboUrl}/api/v0/pin/ls?arg=${encodeURIComponent(cid)}&type=all`, { method: 'POST' });
+      if (!res.ok) return false;
+      const json = await res.json();
+      return !!(json.Keys && json.Keys[cid]);
+    } catch {
+      return false;
+    }
+  },
 };
 
 export { IpfsClient };

package/src/server/object-layer.js

@@ -639,11 +639,12 @@ export class ObjectLayerEngine {
 
   /**
    * Creates new ObjectLayerRenderFrames and ObjectLayer documents in MongoDB from the
-   * provided data, computes an initial SHA-256, and optionally generates the atlas sprite sheet.
+   * provided data, with cut-over consistency: all CIDs (atlas PNG, atlas metadata, data JSON)
+   * are computed and pinned to IPFS BEFORE the ObjectLayer document is created or updated in
+   * MongoDB, so the object layer is never visible in queries with empty CIDs.
    *
-   * When `generateAtlas` is `true` (the default) the method delegates to
-   * `AtlasSpriteSheetService.generate` and then recomputes the definitive SHA-256
-   * (which now includes `data.render.cid`) and persists an IPFS CID.
+   * If an existing ObjectLayer with the same `data.item.id` is found, it is atomically
+   * replaced (findByIdAndUpdate) and the old ObjectLayerRenderFrames is cleaned up.
    *
    * @static
    * @param {Object} params - Parameters.
@@ -664,44 +665,95 @@ export class ObjectLayerEngine {
   }) {
     const { generateAtlas = true, atlasServiceContext = null } = createOptions;
 
-    // 1. Persist ObjectLayerRenderFrames
+    // 1. Persist ObjectLayerRenderFrames (not queried by the viewer table)
     const objectLayerRenderFramesDoc = await ObjectLayerRenderFrames.create(objectLayerRenderFramesData);
 
-    // 2. Attach reference + compute temporary SHA-256
+    // 2. Set up references in memory
     objectLayerData.objectLayerRenderFramesId = objectLayerRenderFramesDoc._id;
     if (!objectLayerData.data.render) objectLayerData.data.render = {};
-    objectLayerData.data.render.cid = objectLayerData.data.render.cid || '';
-    objectLayerData.sha256 = ObjectLayerEngine.computeSha256(objectLayerData.data);
+    objectLayerData.data.render.cid = '';
+    objectLayerData.data.render.metadataCid = '';
 
-    // 3. Upsert ObjectLayer (handle duplicate sha256 gracefully)
+    // 3. Stage atlas + IPFS CIDs BEFORE creating/updating the ObjectLayer
+    if (generateAtlas && atlasServiceContext) {
+      const {
+        req,
+        res,
+        options,
+        AtlasSpriteSheetService,
+        IpfsClient: ipfsClient,
+        createPinRecord,
+      } = atlasServiceContext;
+
+      try {
+        const stagingOL = {
+          data: objectLayerData.data,
+          objectLayerRenderFramesId: objectLayerRenderFramesDoc,
+        };
+        const result = await AtlasSpriteSheetService.generate(
+          { objectLayer: stagingOL, auth: req ? req.auth : undefined },
+          res,
+          options,
+          { skipObjectLayerSave: true },
+        );
+        objectLayerData.data.render.cid = result.atlasCid;
+        objectLayerData.data.render.metadataCid = result.atlasMetadataCid;
+        objectLayerData.atlasSpriteSheetId = result.atlasDoc._id;
+      } catch (atlasError) {
+        logger.error('Failed to generate atlas during staging:', atlasError);
+      }
+
+      // Compute final SHA-256 (includes render CIDs)
+      objectLayerData.sha256 = ObjectLayerEngine.computeSha256(objectLayerData.data);
+
+      // Pin data JSON to IPFS
+      if (ipfsClient) {
+        try {
+          const itemId = objectLayerData.data.item.id;
+          const mfsPath = `/object-layer/${itemId}/${itemId}_data.json`;
+          const ipfsResult = await ipfsClient.addJsonToIpfs(objectLayerData.data, `${itemId}_data.json`, mfsPath);
+          if (ipfsResult) {
+            objectLayerData.cid = ipfsResult.cid;
+            if (createPinRecord) {
+              await createPinRecord({ cid: ipfsResult.cid, resourceType: 'object-layer-data', mfsPath, options });
+            }
+          }
+        } catch (ipfsError) {
+          logger.warn('Failed to pin data JSON to IPFS:', ipfsError.message);
+        }
+      }
+    } else {
+      // No atlas generation - compute SHA-256 without render CIDs
+      objectLayerData.sha256 = ObjectLayerEngine.computeSha256(objectLayerData.data);
+    }
+
+    // 4. Atomic create/upsert - ObjectLayer is fully populated with all CIDs
     let objectLayer;
-    const existingObjectLayer = await ObjectLayer.findOne({ sha256: objectLayerData.sha256 });
-    if (existingObjectLayer) {
-      logger.info(`ObjectLayer with sha256 ${objectLayerData.sha256} already exists, updating...`);
-      objectLayer = await ObjectLayer.findByIdAndUpdate(existingObjectLayer._id, objectLayerData, {
+    const existingByItemId = await ObjectLayer.findOne({ 'data.item.id': objectLayerData.data.item.id });
+    if (existingByItemId) {
+      const oldRenderFramesId = existingByItemId.objectLayerRenderFramesId;
+      logger.info(
+        `ObjectLayer for item "${objectLayerData.data.item.id}" exists (${existingByItemId._id}), replacing atomically...`,
+      );
+      objectLayer = await ObjectLayer.findByIdAndUpdate(existingByItemId._id, objectLayerData, {
         returnDocument: 'after',
       }).populate('objectLayerRenderFramesId');
+      if (oldRenderFramesId && !oldRenderFramesId.equals(objectLayerRenderFramesDoc._id)) {
+        await ObjectLayerRenderFrames.findByIdAndDelete(oldRenderFramesId);
+      }
     } else {
       objectLayer = await (await ObjectLayer.create(objectLayerData)).populate('objectLayerRenderFramesId');
       logger.info(`ObjectLayer created successfully with id: ${objectLayer._id}`);
     }
 
-    // 4. Optional atlas generation + final SHA-256 / IPFS CID
-    if (generateAtlas && atlasServiceContext) {
-      objectLayer = await ObjectLayerEngine._generateAtlasAndFinalize({
-        objectLayer,
-        ObjectLayer,
-        atlasServiceContext,
-        isNew: true,
-      });
-    }
-
     return { objectLayer, objectLayerRenderFramesDoc };
   }
 
   /**
    * Updates an existing ObjectLayer and its ObjectLayerRenderFrames from the provided data,
-   * recomputes SHA-256, and optionally regenerates the atlas sprite sheet.
+   * with cut-over consistency: a new ObjectLayerRenderFrames is created, then atlas and all
+   * CIDs are staged BEFORE the live ObjectLayer is touched. The live document is updated
+   * atomically via findByIdAndUpdate only after all CIDs are computed.
    *
    * @static
    * @param {Object} params - Parameters.
@@ -724,27 +776,75 @@ export class ObjectLayerEngine {
   }) {
     const { generateAtlas = true, atlasServiceContext = null } = updateOptions;
 
-    // 1. Update or create ObjectLayerRenderFrames
-    let objectLayerRenderFramesDoc;
+    // 1. Load existing ObjectLayer to get old references
     const existingObjectLayer = await ObjectLayer.findById(objectLayerId);
-    if (existingObjectLayer && existingObjectLayer.objectLayerRenderFramesId) {
-      objectLayerRenderFramesDoc = await ObjectLayerRenderFrames.findByIdAndUpdate(
-        existingObjectLayer.objectLayerRenderFramesId,
-        objectLayerRenderFramesData,
-        { returnDocument: 'after' },
-      );
-      objectLayerData.objectLayerRenderFramesId = existingObjectLayer.objectLayerRenderFramesId;
-    } else {
-      objectLayerRenderFramesDoc = await ObjectLayerRenderFrames.create(objectLayerRenderFramesData);
-      objectLayerData.objectLayerRenderFramesId = objectLayerRenderFramesDoc._id;
+    if (!existingObjectLayer) {
+      throw new Error('ObjectLayer not found for update');
     }
+    const oldRenderFramesId = existingObjectLayer.objectLayerRenderFramesId;
+
+    // 2. Create NEW RenderFrames (avoid mutating old doc mid-update)
+    const objectLayerRenderFramesDoc = await ObjectLayerRenderFrames.create(objectLayerRenderFramesData);
+    objectLayerData.objectLayerRenderFramesId = objectLayerRenderFramesDoc._id;
 
-    // 2. Compute temporary SHA-256
+    // 3. Set up render CIDs
     if (!objectLayerData.data.render) objectLayerData.data.render = {};
-    objectLayerData.data.render.cid = objectLayerData.data.render.cid || '';
-    objectLayerData.sha256 = ObjectLayerEngine.computeSha256(objectLayerData.data);
+    objectLayerData.data.render.cid = '';
+    objectLayerData.data.render.metadataCid = '';
+
+    // 4. Stage atlas + IPFS CIDs BEFORE updating the ObjectLayer
+    if (generateAtlas && atlasServiceContext) {
+      const {
+        req,
+        res,
+        options,
+        AtlasSpriteSheetService,
+        IpfsClient: ipfsClient,
+        createPinRecord,
+      } = atlasServiceContext;
+
+      try {
+        const stagingOL = {
+          data: objectLayerData.data,
+          objectLayerRenderFramesId: objectLayerRenderFramesDoc,
+        };
+        const result = await AtlasSpriteSheetService.generate(
+          { objectLayer: stagingOL, auth: req ? req.auth : undefined },
+          res,
+          options,
+          { skipObjectLayerSave: true },
+        );
+        objectLayerData.data.render.cid = result.atlasCid;
+        objectLayerData.data.render.metadataCid = result.atlasMetadataCid;
+        objectLayerData.atlasSpriteSheetId = result.atlasDoc._id;
+      } catch (atlasError) {
+        logger.error('Failed to generate atlas during update staging:', atlasError);
+      }
+
+      // Compute final SHA-256 (includes render CIDs)
+      objectLayerData.sha256 = ObjectLayerEngine.computeSha256(objectLayerData.data);
 
-    // 3. Persist ObjectLayer update
+      // Pin data JSON to IPFS
+      if (ipfsClient) {
+        try {
+          const itemId = objectLayerData.data.item.id;
+          const mfsPath = `/object-layer/${itemId}/${itemId}_data.json`;
+          const ipfsResult = await ipfsClient.addJsonToIpfs(objectLayerData.data, `${itemId}_data.json`, mfsPath);
+          if (ipfsResult) {
+            objectLayerData.cid = ipfsResult.cid;
+            if (createPinRecord) {
+              await createPinRecord({ cid: ipfsResult.cid, resourceType: 'object-layer-data', mfsPath, options });
+            }
+          }
+        } catch (ipfsError) {
+          logger.warn('Failed to pin data JSON to IPFS:', ipfsError.message);
+        }
+      }
+    } else {
+      objectLayerData.sha256 = ObjectLayerEngine.computeSha256(objectLayerData.data);
+    }
+
+    // 5. Atomic update - ObjectLayer is fully populated with all CIDs
     let objectLayer;
     try {
       objectLayer = await ObjectLayer.findByIdAndUpdate(objectLayerId, objectLayerData, {
@@ -753,20 +853,15 @@ export class ObjectLayerEngine {
       if (!objectLayer) {
         throw new Error('ObjectLayer not found for update');
       }
-      logger.info(`ObjectLayer updated successfully with id: ${objectLayerId}`);
+      logger.info(`ObjectLayer updated atomically with id: ${objectLayerId}`);
     } catch (error) {
       logger.error('Error updating ObjectLayer:', error);
       throw error;
     }
 
-    // 4. Optional atlas generation + final SHA-256 / IPFS CID
-    if (generateAtlas && atlasServiceContext) {
-      objectLayer = await ObjectLayerEngine._generateAtlasAndFinalize({
-        objectLayer,
-        ObjectLayer,
-        atlasServiceContext,
-        isNew: false,
-      });
+    // 6. Clean up old RenderFrames
+    if (oldRenderFramesId && !oldRenderFramesId.equals(objectLayerRenderFramesDoc._id)) {
+      await ObjectLayerRenderFrames.findByIdAndDelete(oldRenderFramesId);
     }
 
     return { objectLayer, objectLayerRenderFramesDoc };
@@ -783,26 +878,22 @@ export class ObjectLayerEngine {
    * @param {Object} params.objectLayer - The mongoose ObjectLayer document (must be populated).
    * @param {Object} [params.ipfsClient=null] - The IpfsClient module; when `null`, IPFS pinning is skipped.
    * @param {function} [params.createPinRecord=null] - The `createPinRecord` helper; when `null`, pin records are skipped.
-   * @param {string} [params.userId] - Authenticated user ID for IPFS pin record creation.
    * @param {Object} [params.options] - Server options (host, path) forwarded to `createPinRecord`.
    * @returns {Promise<Object>} The saved ObjectLayer document.
    * @memberof CyberiaObjectLayer
    */
-  static async computeAndSaveFinalSha256({ objectLayer, ipfsClient = null, createPinRecord = null, userId, options }) {
+  static async computeAndSaveFinalSha256({ objectLayer, ipfsClient = null, createPinRecord = null, options }) {
     const finalSha256 = ObjectLayerEngine.computeSha256(objectLayer.data);
 
     if (ipfsClient) {
       try {
         const itemId = objectLayer.data.item.id;
-        const ipfsResult = await ipfsClient.addJsonToIpfs(
-          objectLayer.data,
-          `${itemId}_data.json`,
-          `/object-layer/${itemId}/${itemId}_data.json`,
-        );
+        const mfsPath = `/object-layer/${itemId}/${itemId}_data.json`;
+        const ipfsResult = await ipfsClient.addJsonToIpfs(objectLayer.data, `${itemId}_data.json`, mfsPath);
         if (ipfsResult) {
           objectLayer.cid = ipfsResult.cid;
-          if (userId && createPinRecord) {
-            await createPinRecord({ cid: ipfsResult.cid, userId, options });
+          if (createPinRecord) {
+            await createPinRecord({ cid: ipfsResult.cid, resourceType: 'object-layer-data', mfsPath, options });
           }
         }
       } catch (ipfsError) {
@@ -882,58 +973,8 @@ export class ObjectLayerEngine {
     );
     return { cid: `sha256:${sha256}`, sha256, source: 'sha256-fallback' };
   }
-
-  /**
-   * Internal helper that generates an atlas sprite sheet and then finalizes the SHA-256 / IPFS CID.
-   * @static
-   * @param {Object} params - Parameters.
-   * @param {Object} params.objectLayer - The mongoose ObjectLayer document.
-   * @param {Object} params.ObjectLayer - Mongoose ObjectLayer model (for re-reading).
-   * @param {Object} params.atlasServiceContext - Context with `{ req, res, options, AtlasSpriteSheetService, IpfsClient, createPinRecord }`.
-   * @param {boolean} params.isNew - Whether this is a newly created object layer (used for logging).
-   * @returns {Promise<Object>} The finalized ObjectLayer document.
-   * @memberof CyberiaObjectLayer
-   * @private
-   */
-  static async _generateAtlasAndFinalize({ objectLayer, ObjectLayer, atlasServiceContext, isNew }) {
-    const { req, res, options, AtlasSpriteSheetService, IpfsClient: ipfsClient, createPinRecord } = atlasServiceContext;
-
-    // Generate atlas sprite sheet
-    try {
-      await AtlasSpriteSheetService.generate(
-        { params: { id: objectLayer._id }, objectLayer, auth: req ? req.auth : undefined },
-        res,
-        options,
-      );
-    } catch (atlasError) {
-      logger.error(`Failed to auto-${isNew ? 'generate' : 'update'} atlas for ObjectLayer:`, atlasError);
-    }
-
-    // Re-read the objectLayer so data.render.cid is up-to-date
-    objectLayer = await ObjectLayer.findById(objectLayer._id).populate('objectLayerRenderFramesId');
-
-    // Compute definitive SHA-256 and IPFS CID
-    const userId = req && req.auth && req.auth.user ? req.auth.user._id : undefined;
-    objectLayer = await ObjectLayerEngine.computeAndSaveFinalSha256({
-      objectLayer,
-      ipfsClient: ipfsClient || null,
-      createPinRecord: createPinRecord || null,
-      userId,
-      options,
-    });
-
-    return objectLayer;
-  }
 }
 
-/**
- * Mapping of item type names to numerical IDs.
- * @constant
- * @type {{floor: number, skin: number, weapon: number, skill: number, coin: number}}
- * @memberof CyberiaObjectLayer
- */
-export const itemTypes = { floor: 0, skin: 1, weapon: 2, skill: 3, coin: 4 };
-
 // ──────────────────────────────────────────────────────────────────────────
 // Backward-compatible named exports matching the original destructured imports.
 // ──────────────────────────────────────────────────────────────────────────

package/src/server/peer.js

@@ -44,6 +44,14 @@ const logger = loggerFactory(import.meta);
  */
 const createPeerServer = async ({ port, origins, path }) => {
   logger.info('origins', origins);
+
+  // In development, allow the local client origin (peer runs on port+1 relative to the client)
+  if (process.env.NODE_ENV === 'development') {
+    const clientPort = port - 1;
+    const devOrigin = `http://localhost:${clientPort}`;
+    if (!origins.includes(devOrigin)) origins.push(devOrigin);
+  }
+
   /** @type {import('peer').IConfig} */
   const options = {
     port,

package/src/server/runtime.js

@@ -11,6 +11,7 @@ import * as promClient from 'prom-client';
 import { loggerFactory } from './logger.js';
 import { newInstance } from '../client/components/core/CommonJs.js';
 import { Lampp } from '../runtime/lampp/Lampp.js';
+import { WpService } from '../runtime/wp/Wp.js';
 import { getInstanceContext, readConfJson } from './conf.js';
 
 import ExpressService from '../runtime/express/Express.js';
@@ -71,6 +72,9 @@ const buildRuntime = async () => {
         valkey,
         apiBaseHost,
         useLocalSsl,
+        grpc,
+        repository,
+        wp,
       } = confServer[host][path];
 
       // Calculate context data
@@ -116,6 +120,7 @@ const buildRuntime = async () => {
             peer,
             valkey,
             apiBaseHost,
+            grpc,
             redirectTarget,
             rootHostPath,
             confSSR,
@@ -129,7 +134,7 @@ const buildRuntime = async () => {
 
         case 'lampp':
           {
-            const { disabled } = await Lampp.createApp({
+            const { disabled } = Lampp.createApp({
               port,
               host,
               path,
@@ -143,6 +148,25 @@ const buildRuntime = async () => {
             await Underpost.start.listenPortController(Underpost.start.listenServerFactory(), port, runningData);
           }
           break;
+
+        case 'wp':
+          {
+            const { disabled } = WpService.createApp({
+              port,
+              host,
+              pathRoute: path,
+              repository,
+              db,
+              wp,
+              redirect,
+              redirectTarget,
+              resetRouter: currentPort === initPort,
+            });
+            if (disabled) continue;
+            await Underpost.start.listenPortController(Underpost.start.listenServerFactory(), port, runningData);
+          }
+          break;
+
         default:
           break;
       }