cyberia 3.0.3 → 3.2.5

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
  */
@@ -82,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
  */
@@ -374,7 +374,7 @@ export class ObjectLayerEngine {
   }
 
   // ──────────────────────────────────────────────────────────────────────────
-  // Centralized document lifecycle methods
+  // Document lifecycle methods
   // ──────────────────────────────────────────────────────────────────────────
 
   /**
@@ -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, {
-        new: true,
+    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,49 +776,92 @@ 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,
-        { new: true },
-      );
-      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 = '';
 
-    // 3. Persist ObjectLayer update
+    // 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);
+
+      // 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, {
-        new: true,
+        returnDocument: 'after',
       }).populate('objectLayerRenderFramesId');
       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) {
@@ -818,56 +909,72 @@ export class ObjectLayerEngine {
   }
 
   /**
-   * Internal helper that generates an atlas sprite sheet and then finalizes the SHA-256 / IPFS CID.
+   * 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 - 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.
+   * @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
-   * @private
    */
-  static async _generateAtlasAndFinalize({ objectLayer, ObjectLayer, atlasServiceContext, isNew }) {
-    const { req, res, options, AtlasSpriteSheetService, IpfsClient: ipfsClient, createPinRecord } = atlasServiceContext;
+  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`);
+    }
 
-    // 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);
+    const sha256 = ObjectLayerEngine.computeSha256(objectLayer.data);
+
+    // 1. Already have a canonical CID persisted
+    if (objectLayer.cid) {
+      return { cid: objectLayer.cid, sha256, source: 'db' };
     }
 
-    // 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,
-    });
+    // 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}`);
+      }
+    }
 
-    return objectLayer;
+    // 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' };
   }
 }
 
-/**
- * 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.
 // ──────────────────────────────────────────────────────────────────────────
@@ -963,3 +1070,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}
@@ -46,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/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), {