cyberia 3.0.2 → 3.1.3

package/src/server/cron.js

@@ -8,7 +8,7 @@ import { loggerFactory } from './logger.js';
 import { shellExec } from './process.js';
 import fs from 'fs-extra';
 import Underpost from '../index.js';
-import { getUnderpostRootPath } from './conf.js';
+import { getUnderpostRootPath, loadCronDeployEnv } from './conf.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -191,6 +191,7 @@ class UnderpostCron {
       jobList = Object.keys(Underpost.cron.JOB).join(','),
       options = {},
     ) {
+      loadCronDeployEnv();
       if (options.setupStart) return await Underpost.cron.setupDeployStart(options.setupStart, options);
 
       if (options.generateK8sCronjobs) return await Underpost.cron.generateK8sCronJobs(options);

package/src/server/dns.js

@@ -5,7 +5,6 @@
  * @namespace UnderpostDns
  */
 import axios from 'axios';
-import dotenv from 'dotenv';
 import fs from 'fs';
 import validator from 'validator';
 import { loggerFactory } from './logger.js';
@@ -13,11 +12,9 @@ import dns from 'node:dns';
 import os from 'node:os';
 import { shellExec, pbcopy } from './process.js';
 import Underpost from '../index.js';
-import { writeEnv } from './conf.js';
+import { writeEnv, readConfJson, loadCronDeployEnv } from './conf.js';
 import { resolveDeployId } from './cron.js';
 
-dotenv.config();
-
 const logger = loggerFactory(import.meta);
 
 /**
@@ -268,6 +265,7 @@ class Dns {
    * @returns {Promise<void>}
    */
   static async callback(deployList) {
+    loadCronDeployEnv();
     const isOnline = await Dns.isInternetConnection();
 
     if (!isOnline) return;
@@ -288,16 +286,15 @@ class Dns {
 
       for (const _deployId of deployList.split(',')) {
         const deployId = _deployId.trim();
-        const privateCronConfPath = `./engine-private/conf/${deployId}/conf.cron.json`;
-        const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
 
-        if (!fs.existsSync(confCronPath)) {
-          logger.warn(`Cron config file not found for deployId: ${deployId} at ${confCronPath}`);
+        let confCronData;
+        try {
+          confCronData = readConfJson(deployId, 'cron', { resolve: true });
+        } catch (error) {
+          logger.warn(`Cron config file not found for deployId: ${deployId}`, { message: error.message });
           continue;
         }
 
-        const confCronData = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
-
         if (!confCronData.records) {
           logger.warn(`'records' field missing in cron config for deployId: ${deployId}`);
           continue;
@@ -365,8 +362,26 @@ class Dns {
        */
       dondominio: (options) => {
         const { user, api_key, host, dns, ip } = options;
+
+        // Validate that required credentials are present before making any request
+        if (!user || !api_key) {
+          logger.error(
+            `${dns} update aborted: missing credentials. ` +
+              `Ensure DDNS_USER and DDNS_API_KEY environment variables are set ` +
+              `or provide 'user' and 'api_key' in cron records configuration.`,
+            { host, hasUser: !!user, hasApiKey: !!api_key },
+          );
+          return Promise.resolve(false);
+        }
+
+        if (!host) {
+          logger.error(`${dns} update aborted: missing host. Set DDNS_HOST or provide 'host' in cron records.`);
+          return Promise.resolve(false);
+        }
+
         const url = `https://dondns.dondominio.com/json/?user=${user}&password=${api_key}&host=${host}&ip=${ip}`;
-        logger.info(`${dns} update ip url`, url);
+        // Log the update attempt without exposing the full URL containing credentials
+        logger.info(`${dns} update ip request`, { host, ip });
 
         // Prevent live IP update in non-production environments
         if (process.env.NODE_ENV !== 'production') {
@@ -382,7 +397,8 @@ class Dns {
               return resolve(true);
             })
             .catch((error) => {
-              logger.error(error, `${dns} update ip error: ${error.message}`);
+              // Only log the error message — the full error object contains the request URL with credentials
+              logger.error(`${dns} update ip error`, { message: error.message, host, ip });
               return resolve(false);
             });
         });

package/src/server/downloader.js

@@ -7,8 +7,6 @@
 import axios from 'axios';
 import fs from 'fs';
 import { loggerFactory } from './logger.js';
-import dotenv from 'dotenv';
-dotenv.config();
 
 const logger = loggerFactory(import.meta);
 

package/src/server/logger.js

@@ -6,16 +6,14 @@
 
 'use strict';
 
-import dotenv from 'dotenv';
 import winston from 'winston';
 import morgan from 'morgan';
-import colorize from 'json-colorizer';
+import { colorize, color } from 'json-colorizer';
 import colors from 'colors';
 import v8 from 'v8';
 import { clearTerminalStringColor, formatBytes } from '../client/components/core/CommonJs.js';
 
 colors.enable();
-dotenv.config();
 
 // Define your severity levels.
 // With them, You can create log files,
@@ -60,14 +58,34 @@ const format = (meta) =>
     winston.format.colorize({ all: true }),
     // Define the format of the message showing the timestamp, the level and the message
     winston.format.printf((info) => {
-      const symbols = Object.getOwnPropertySymbols(info);
+      const splatKey = Symbol.for('splat');
+      const splat = info[splatKey];
+      const hasSplat = Array.isArray(splat) && splat.length > 0 && splat[0] !== undefined;
+      let splatStr = '';
+      if (hasSplat) {
+        const seen = new WeakSet();
+        splatStr = JSON.stringify(
+          splat[0],
+          (key, value) => {
+            if (typeof value === 'function') return `[Function: ${value.name || 'anonymous'}]`;
+            if (typeof value === 'object' && value !== null) {
+              if (seen.has(value)) return '[Circular]';
+              seen.add(value);
+            }
+            return value;
+          },
+          4,
+        );
+      }
       return `${`[${meta}]`.green} ${info.timestamp} ${info.level} ${
-        symbols[1]
-          ? `${clearTerminalStringColor(info.message)}: ${colorize(JSON.stringify(info[symbols[1]][0], null, 4), {
+        hasSplat
+          ? `${clearTerminalStringColor(info.message)}: ${colorize(splatStr, {
               colors: {
-                STRING_KEY: 'green',
-                STRING_LITERAL: 'magenta.bold',
-                NUMBER_LITERAL: '#FF0000',
+                StringKey: color.green,
+                StringLiteral: color.magenta,
+                NumberLiteral: color.red,
+                BooleanLiteral: color.cyan,
+                NullLiteral: color.white,
               },
             })}`
           : info.message

package/src/server/object-layer.js

@@ -1,6 +1,6 @@
 /**
  * Provides utilities and engine logic for processing and managing Cyberia Online's object layer assets (skins, floors, weapons, etc.).
- * Centralizes shared logic consumed by both the Cyberia CLI and the REST API service layer.
+ * Shared logic consumed by both the Cyberia CLI and the REST API service layer.
  * @module src/server/object-layer.js
  * @namespace CyberiaObjectLayer
  */
@@ -47,8 +47,9 @@ const logger = loggerFactory(import.meta);
  * @property {string} [data.item.description] - Human-readable description.
  * @property {boolean} [data.item.activable] - Whether the item can be activated.
  * @property {Object} data.stats - Statistical attributes of the object layer.
- * @property {string} data.seed - Random UUID v4 for unique state generation.
- * @property {string} [data.atlasSpriteSheetCid] - IPFS CID for the consolidated atlas sprite sheet PNG.
+ * @property {Object} [data.render] - IPFS content identifiers for the consolidated atlas sprite sheet.
+ * @property {string} [data.render.cid] - IPFS CID for the consolidated atlas sprite sheet PNG.
+ * @property {string} [data.render.metadataCid] - IPFS CID for the atlas sprite sheet metadata JSON (fast-json-stable-stringify).
  * @property {ObjectLayerRenderFramesData} [objectLayerRenderFramesData] - Render frames data (transient, used before persisting).
  * @property {import('mongoose').Types.ObjectId} [objectLayerRenderFramesId] - Reference to persisted ObjectLayerRenderFrames document.
  * @property {string} [sha256] - SHA-256 hash of the object layer data.
@@ -81,7 +82,7 @@ const logger = loggerFactory(import.meta);
 
 /**
  * Engine class providing static utilities for Cyberia Online object layer asset processing,
- * frame extraction, directory iteration, image building, and centralized document creation logic.
+ * frame extraction, directory iteration, image building, and document creation logic.
  * @class ObjectLayerEngine
  * @memberof CyberiaObjectLayer
  */
@@ -373,7 +374,7 @@ export class ObjectLayerEngine {
   }
 
   // ──────────────────────────────────────────────────────────────────────────
-  // Centralized document lifecycle methods
+  // Document lifecycle methods
   // ──────────────────────────────────────────────────────────────────────────
 
   /**
@@ -445,7 +446,7 @@ export class ObjectLayerEngine {
             activable: true,
           },
           stats: metadata.data.stats || ObjectLayerEngine.generateRandomStats(),
-          seed: metadata.data.seed || crypto.randomUUID(),
+          ledger: metadata.data.ledger || { type: 'OFF_CHAIN' },
         },
       };
     } else {
@@ -458,7 +459,7 @@ export class ObjectLayerEngine {
             activable: true,
           },
           stats: ObjectLayerEngine.generateRandomStats(),
-          seed: crypto.randomUUID(),
+          ledger: { type: 'OFF_CHAIN' },
         },
       };
     }
@@ -501,7 +502,7 @@ export class ObjectLayerEngine {
   /**
    * Computes a SHA-256 hash of the given object layer data using deterministic JSON serialisation.
    * @static
-   * @param {Object} data - The `data` sub-document of an ObjectLayer (item, stats, seed, atlasSpriteSheetCid, …).
+   * @param {Object} data - The `data` sub-document of an ObjectLayer (item, stats, render).
    * @returns {string} Hex-encoded SHA-256 hash.
    * @memberof CyberiaObjectLayer
    */
@@ -642,7 +643,7 @@ export class ObjectLayerEngine {
    *
    * When `generateAtlas` is `true` (the default) the method delegates to
    * `AtlasSpriteSheetService.generate` and then recomputes the definitive SHA-256
-   * (which now includes `data.atlasSpriteSheetCid`) and persists an IPFS CID.
+   * (which now includes `data.render.cid`) and persists an IPFS CID.
    *
    * @static
    * @param {Object} params - Parameters.
@@ -668,7 +669,8 @@ export class ObjectLayerEngine {
 
     // 2. Attach reference + compute temporary SHA-256
     objectLayerData.objectLayerRenderFramesId = objectLayerRenderFramesDoc._id;
-    objectLayerData.data.atlasSpriteSheetCid = objectLayerData.data.atlasSpriteSheetCid || '';
+    if (!objectLayerData.data.render) objectLayerData.data.render = {};
+    objectLayerData.data.render.cid = objectLayerData.data.render.cid || '';
     objectLayerData.sha256 = ObjectLayerEngine.computeSha256(objectLayerData.data);
 
     // 3. Upsert ObjectLayer (handle duplicate sha256 gracefully)
@@ -677,7 +679,7 @@ export class ObjectLayerEngine {
     if (existingObjectLayer) {
       logger.info(`ObjectLayer with sha256 ${objectLayerData.sha256} already exists, updating...`);
       objectLayer = await ObjectLayer.findByIdAndUpdate(existingObjectLayer._id, objectLayerData, {
-        new: true,
+        returnDocument: 'after',
       }).populate('objectLayerRenderFramesId');
     } else {
       objectLayer = await (await ObjectLayer.create(objectLayerData)).populate('objectLayerRenderFramesId');
@@ -729,7 +731,7 @@ export class ObjectLayerEngine {
       objectLayerRenderFramesDoc = await ObjectLayerRenderFrames.findByIdAndUpdate(
         existingObjectLayer.objectLayerRenderFramesId,
         objectLayerRenderFramesData,
-        { new: true },
+        { returnDocument: 'after' },
       );
       objectLayerData.objectLayerRenderFramesId = existingObjectLayer.objectLayerRenderFramesId;
     } else {
@@ -738,14 +740,15 @@ export class ObjectLayerEngine {
     }
 
     // 2. Compute temporary SHA-256
-    objectLayerData.data.atlasSpriteSheetCid = objectLayerData.data.atlasSpriteSheetCid || '';
+    if (!objectLayerData.data.render) objectLayerData.data.render = {};
+    objectLayerData.data.render.cid = objectLayerData.data.render.cid || '';
     objectLayerData.sha256 = ObjectLayerEngine.computeSha256(objectLayerData.data);
 
     // 3. Persist ObjectLayer update
     let objectLayer;
     try {
       objectLayer = await ObjectLayer.findByIdAndUpdate(objectLayerId, objectLayerData, {
-        new: true,
+        returnDocument: 'after',
       }).populate('objectLayerRenderFramesId');
       if (!objectLayer) {
         throw new Error('ObjectLayer not found for update');
@@ -773,7 +776,7 @@ export class ObjectLayerEngine {
    * Recomputes the definitive SHA-256, pins the object layer data JSON to IPFS,
    * and persists both fields on the ObjectLayer document.
    *
-   * Intended for use after atlas generation has set `data.atlasSpriteSheetCid`.
+   * Intended for use after atlas generation has set `data.render.cid`.
    *
    * @static
    * @param {Object} params - Parameters.
@@ -814,6 +817,72 @@ export class ObjectLayerEngine {
     return objectLayer;
   }
 
+  /**
+   * Resolve the canonical CID for an Object Layer item from the database.
+   *
+   * The canonical CID is the IPFS content identifier of the stable-JSON-serialised
+   * `objectLayer.data` document (produced by `fast-json-stable-stringify`).  This is
+   * the CID that MUST be stored on-chain as the metadata CID so that any party can
+   * independently reproduce the hash from the same semantic payload.
+   *
+   * Resolution order:
+   *   1. If the ObjectLayer document already has a `.cid` field, use it.
+   *   2. Otherwise compute it on-the-fly via `ipfsClient.addJsonToIpfs` (pins the
+   *      data to IPFS as a side-effect) and persist it back to the document.
+   *   3. If IPFS is unreachable, fall back to a local SHA-256 so the caller at
+   *      least gets a content hash (prefixed with `sha256:` to distinguish it
+   *      from a real IPFS CID).
+   *
+   * @static
+   * @param {Object}  params
+   * @param {string}  params.itemId      – human-readable item identifier.
+   * @param {import('mongoose').Model} params.ObjectLayer – Mongoose ObjectLayer model.
+   * @param {Object}  [params.ipfsClient=null] – The IpfsClient module; when `null`, IPFS pinning is skipped and only SHA-256 fallback is returned.
+   * @param {Object}  [params.options]   – `{ host, path }` forwarded to pin helpers.
+   * @returns {Promise<{ cid: string, sha256: string, source: string }>}
+   * @memberof CyberiaObjectLayer
+   */
+  static async resolveCanonicalCid({ itemId, ObjectLayer, ipfsClient = null, options }) {
+    const objectLayer = await ObjectLayer.findOne({ 'data.item.id': itemId });
+    if (!objectLayer) {
+      throw new Error(`ObjectLayer "${itemId}" not found in database`);
+    }
+
+    const sha256 = ObjectLayerEngine.computeSha256(objectLayer.data);
+
+    // 1. Already have a canonical CID persisted
+    if (objectLayer.cid) {
+      return { cid: objectLayer.cid, sha256, source: 'db' };
+    }
+
+    // 2. Try to compute and persist via IPFS
+    if (ipfsClient) {
+      try {
+        const ipfsResult = await ipfsClient.addJsonToIpfs(
+          objectLayer.data,
+          `${itemId}_data.json`,
+          `/object-layer/${itemId}/${itemId}_data.json`,
+        );
+        if (ipfsResult) {
+          objectLayer.cid = ipfsResult.cid;
+          objectLayer.sha256 = sha256;
+          objectLayer.markModified('data');
+          await objectLayer.save();
+          logger.info(`Canonical CID computed and persisted for "${itemId}": ${ipfsResult.cid}`);
+          return { cid: ipfsResult.cid, sha256, source: 'ipfs' };
+        }
+      } catch (err) {
+        logger.warn(`IPFS unreachable while resolving canonical CID for "${itemId}": ${err.message}`);
+      }
+    }
+
+    // 3. Fallback – return a sha256:-prefixed content hash
+    logger.warn(
+      `Using SHA-256 fallback for "${itemId}" (IPFS unavailable). On-chain CID will not resolve via gateway.`,
+    );
+    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
@@ -840,7 +909,7 @@ export class ObjectLayerEngine {
       logger.error(`Failed to auto-${isNew ? 'generate' : 'update'} atlas for ObjectLayer:`, atlasError);
     }
 
-    // Re-read the objectLayer so data.atlasSpriteSheetCid is up-to-date
+    // 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
@@ -960,3 +1029,10 @@ export const computeAndSaveFinalSha256 = ObjectLayerEngine.computeAndSaveFinalSh
  * @memberof CyberiaObjectLayer
  */
 export const writeStaticFrameAssets = ObjectLayerEngine.writeStaticFrameAssets;
+
+/**
+ * @see {@link ObjectLayerEngine.resolveCanonicalCid}
+ * @function resolveCanonicalCid
+ * @memberof CyberiaObjectLayer
+ */
+export const resolveCanonicalCid = ObjectLayerEngine.resolveCanonicalCid;

package/src/server/peer.js

@@ -12,8 +12,6 @@ import dotenv from 'dotenv';
 import { loggerFactory } from './logger.js';
 import Underpost from '../index.js';
 
-dotenv.config();
-
 /**
  * Logger instance for this module, utilizing the framework's factory.
  * @type {function(*): void}

package/src/server/process.js

@@ -8,14 +8,11 @@
 // https://nodejs.org/api/process
 
 import shell from 'shelljs';
-import dotenv from 'dotenv';
 import { loggerFactory } from './logger.js';
 import clipboard from 'clipboardy';
 import Underpost from '../index.js';
 import { getNpmRootPath } from './conf.js';
 
-dotenv.config();
-
 const logger = loggerFactory(import.meta);
 
 /**
@@ -122,52 +119,6 @@ const shellCd = (cd, options = { disableLog: false }) => {
   return shell.cd(cd);
 };
 
-/**
- * Opens a new GNOME terminal and executes a command.
- * Note: This function is environment-specific (GNOME/Linux).
- * @memberof Process
- * @param {string} cmd - The command to execute in the new terminal.
- * @param {Object} [options] - Options for the terminal opening.
- * @param {boolean} [options.single=false] - If true, execute as a single session process using `setsid`.
- * @param {string} [options.chown] - Path to change ownership to the target user.
- * @returns {void}
- */
-const openTerminal = (cmd, options = { single: false }) => {
-  // Find the graphical user's UID from /run/user (prefer non-root UID, usually 1000)
-  const IDS = shellExec(`ls -1 /run/user`, { stdout: true, silent: true })
-    .split('\n')
-    .map((v) => v.trim())
-    .filter(Boolean);
-
-  const nonRootIds = IDS.filter((id) => id !== '0');
-  const ID = nonRootIds.length > 0 ? nonRootIds[0] : IDS[0];
-
-  if (!options.chown) options.chown = `/home/dd ${getNpmRootPath()}/underpost`;
-
-  shellExec(`chown -R ${ID}:${ID} ${options.chown}`);
-
-  // Run the terminal as the graphical user and use THAT user's runtime dir/bus.
-  const confCmd = `USER_GRAPHICAL=$(getent passwd "${ID}" | cut -d: -f1); \
-sudo -u "$USER_GRAPHICAL" env DISPLAY="$DISPLAY" \
-XDG_RUNTIME_DIR="/run/user/${ID}" \
-DBUS_SESSION_BUS_ADDRESS="unix:path=/run/user/${ID}/bus" \
-PATH="$PATH" \
-`;
-
-  if (options.single === true) {
-    // Run as a single session process
-    shellExec(`${confCmd} setsid gnome-terminal -- bash -ic '${cmd}; exec bash' >/dev/null 2>&1 &`, {
-      async: true,
-    });
-    return;
-  }
-  // Run asynchronously and disown
-  shellExec(`${confCmd} gnome-terminal -- bash -c '${cmd}; exec bash' >/dev/null 2>&1 & disown`, {
-    async: true,
-    stdout: true,
-  });
-};
-
 /**
  * Wraps a command to run it as a daemon process in a shell (keeping the process alive/terminal open).
  * @memberof Process
@@ -198,4 +149,4 @@ function pbcopy(data) {
   logger.info(`copied to clipboard`, clipboard.readSync());
 }
 
-export { ProcessController, getRootDirectory, shellExec, shellCd, pbcopy, openTerminal, getTerminalPid, daemonProcess };
+export { ProcessController, getRootDirectory, shellExec, shellCd, pbcopy, getTerminalPid, daemonProcess };

package/src/server/proxy.js

@@ -7,8 +7,6 @@
 'use strict';
 
 import express from 'express';
-import dotenv from 'dotenv';
-
 import { createProxyMiddleware } from 'http-proxy-middleware';
 import { loggerFactory, loggerMiddleware } from './logger.js';
 import { buildPortProxyRouter, buildProxyRouter, getTlsHosts, isDevProxyContext, isTlsDevProxy } from './conf.js';
@@ -17,8 +15,6 @@ import { shellExec } from './process.js';
 import fs from 'fs-extra';
 import Underpost from '../index.js';
 
-dotenv.config();
-
 const logger = loggerFactory(import.meta);
 
 /**
@@ -56,11 +52,12 @@ class ProxyService {
       // Proxy middleware options
       /** @type {import('http-proxy-middleware/dist/types').Options} */
       const options = {
+        pathFilter: proxyPath, // Use '/' as the general filter (v3 API)
         ws: true, // Enable websocket proxying
         target: `http://localhost:${parseInt(process.env.PORT - 1)}`, // Default target (should be overridden by router)
         router: {},
         // changeOrigin: true,
-        logLevel: 'debug',
+        logger: logger,
         xfwd: true, // Adds x-forward headers (Host, Proto, etc.)
         onProxyReq: (proxyReq, req, res, options) => {},
         pathRewrite: {},
@@ -74,8 +71,7 @@ class ProxyService {
         devProxyContext: process.env.NODE_ENV !== 'production',
       });
 
-      const filter = proxyPath; // Use '/' as the general filter
-      app.use(proxyPath, createProxyMiddleware(filter, options));
+      app.use(proxyPath, createProxyMiddleware(options));
 
       // Determine which server to start (HTTP or HTTPS) based on port and environment
       switch (process.env.NODE_ENV) {
@@ -115,7 +111,7 @@ class ProxyService {
               break;
           }
       }
-      logger.info('Proxy running', { port, options });
+      logger.info('Proxy running', { port, router: options.router });
       if (process.env.NODE_ENV === 'development')
         logger.info(
           Underpost.deploy.etcHostFactory(Object.keys(options.router), {

package/src/server/runtime.js

@@ -6,21 +6,17 @@
  * @namespace Runtime
  */
 
-import fs from 'fs-extra';
-import dotenv from 'dotenv';
 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 { getInstanceContext } from './conf.js';
+import { getInstanceContext, readConfJson } from './conf.js';
 
 import ExpressService from '../runtime/express/Express.js';
 
 import Underpost from '../index.js';
 
-dotenv.config();
-
 const logger = loggerFactory(import.meta);
 
 /**
@@ -48,9 +44,9 @@ const buildRuntime = async () => {
   const initPort = parseInt(process.env.PORT) + 1;
   let currentPort = initPort;
 
-  // Load Configuration
-  const confServer = JSON.parse(fs.readFileSync(`./conf/conf.server.json`, 'utf8'));
-  const confSSR = JSON.parse(fs.readFileSync(`./conf/conf.ssr.json`, 'utf8'));
+  // Load Configuration — resolve env: secret references at actual server runtime
+  const confServer = readConfJson(deployId, 'server', { resolve: true, loadReplicas: true });
+  const confSSR = readConfJson(deployId, 'ssr');
 
   // Iterate through hosts and paths
   for (const host of Object.keys(confServer)) {
@@ -83,6 +79,7 @@ const buildRuntime = async () => {
         redirect,
         singleReplica,
         replicas,
+        peer,
       });
 
       if (singleReplicaOffsetPortSum > 0) {

package/src/server/semantic-layer-generator.js

@@ -1052,6 +1052,7 @@ export function generateMultiFrame(options) {
         intelligence: hashMod(seed + ':intelligence', 11),
         utility: hashMod(seed + ':utility', 11),
       },
+      ledger: { type: 'OFF_CHAIN' },
       seed: seedToUUIDv4(seed + ':' + itemId),
     },
   };

package/src/server/ssr.js

@@ -5,7 +5,6 @@
  */
 
 import fs from 'fs-extra';
-import dotenv from 'dotenv';
 import vm from 'node:vm';
 
 import Underpost from '../index.js';
@@ -14,8 +13,6 @@ import { srcFormatted, JSONweb } from './client-formatted.js';
 import { loggerFactory } from './logger.js';
 import { getRootDirectory } from './process.js';
 
-dotenv.config();
-
 const logger = loggerFactory(import.meta);
 
 /**

package/src/server/start.js

@@ -147,27 +147,34 @@ class UnderpostStartUp {
      * @param {string} deployId - The ID of the deployment.
      * @param {string} env - The environment of the deployment.
      * @param {Object} options - Options for the build.
+     * @param {boolean} options.skipPullBase - Whether to skip pulling the base code and use the current workspace code directly.
      * @param {boolean} options.underpostQuicklyInstall - Whether to use underpost quickly install.
      * @memberof UnderpostStartUp
      */
-    async build(deployId = 'dd-default', env = 'development', options = { underpostQuicklyInstall: false }) {
+    async build(
+      deployId = 'dd-default',
+      env = 'development',
+      options = { underpostQuicklyInstall: false, skipPullBase: false },
+    ) {
       const buildBasePath = `/home/dd`;
       const repoName = `engine-${deployId.split('-')[1]}`;
-      shellExec(`cd ${buildBasePath} && underpost clone ${process.env.GITHUB_USERNAME}/${repoName}`);
-      shellExec(`mkdir -p ${buildBasePath}/engine`);
-      shellExec(`cd ${buildBasePath} && sudo cp -a ./${repoName}/. ./engine`);
-      shellExec(`cd ${buildBasePath} && sudo rm -rf ./${repoName}`);
-      shellExec(`cd ${buildBasePath}/engine && underpost clone ${process.env.GITHUB_USERNAME}/${repoName}-private`);
-      shellExec(`cd ${buildBasePath}/engine && sudo mv ./${repoName}-private ./engine-private`);
+      if (!options.skipPullBase) {
+        shellExec(`cd ${buildBasePath} && underpost clone ${process.env.GITHUB_USERNAME}/${repoName}`);
+        shellExec(`mkdir -p ${buildBasePath}/engine`);
+        shellExec(`cd ${buildBasePath} && sudo cp -a ./${repoName}/. ./engine`);
+        shellExec(`cd ${buildBasePath} && sudo rm -rf ./${repoName}`);
+        shellExec(`cd ${buildBasePath}/engine && underpost clone ${process.env.GITHUB_USERNAME}/${repoName}-private`);
+        shellExec(`cd ${buildBasePath}/engine && sudo mv ./${repoName}-private ./engine-private`);
+      }
       shellCd(`${buildBasePath}/engine`);
       shellExec(options?.underpostQuicklyInstall ? `underpost install` : `npm install`);
-      shellExec(`node bin/deploy conf ${deployId} ${env}`);
+      shellExec(`node bin env ${deployId} ${env}`);
       if (fs.existsSync('./engine-private/itc-scripts')) {
         const itcScripts = await fs.readdir('./engine-private/itc-scripts');
         for (const itcScript of itcScripts)
           if (itcScript.match(deployId)) shellExec(`node ./engine-private/itc-scripts/${itcScript}`);
       }
-      shellExec(`node bin/deploy build-full-client ${deployId}`);
+      shellExec(`node bin client ${deployId}`);
     },
     /**
      * Runs a deployment.
@@ -177,17 +184,17 @@ class UnderpostStartUp {
      * @memberof UnderpostStartUp
      */
     async run(deployId = 'dd-default', env = 'development', options = {}) {
-      const runCmd = env === 'production' ? 'run prod-img' : 'run dev-img';
+      const runCmd = env === 'production' ? 'run prod:container' : 'run dev:container';
       if (fs.existsSync(`./engine-private/replica`)) {
         const replicas = await fs.readdir(`./engine-private/replica`);
         for (const replica of replicas) {
           if (!replica.match(deployId)) continue;
-          shellExec(`node bin/deploy conf ${replica} ${env}`);
+          shellExec(`node bin env ${replica} ${env}`);
           shellExec(`npm ${runCmd} ${replica}`, { async: true });
           await awaitDeployMonitor(true);
         }
       }
-      shellExec(`node bin/deploy conf ${deployId} ${env}`);
+      shellExec(`node bin env ${deployId} ${env}`);
       shellExec(`npm ${runCmd} ${deployId}`, { async: true });
       await awaitDeployMonitor(true);
       Underpost.env.set('container-status', `${deployId}-${env}-running-deployment`);