@cocreate/server 1.2.1 → 1.5.0

package/.github/workflows/automated.yml

@@ -1,8 +1,10 @@
 name: Automated Workflow
+
 on:
   push:
     branches:
       - master
+
 jobs:
   about:
     runs-on: ubuntu-latest
@@ -18,27 +20,37 @@ jobs:
         with:
           direction: overwrite-github
           githubToken: "${{ secrets.GITHUB }}"
+
   release:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
-      - name: Setup Node.js
-        uses: actions/setup-node@v3
+        uses: actions/checkout@v4
         with:
-          node-version: 14
-      - name: Semantic Release
-        uses: cycjimmy/semantic-release-action@v3
-        id: semantic
+          fetch-depth: 0 # Required so semantic-release can trace git tags/history
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
         with:
-          extra_plugins: |
-            @semantic-release/changelog
+          node-version: 22
+
+      - name: Install Semantic Release & Plugins
+        # Installs semantic-release and its plugins on the runner
+        run: |
+          npm install -g semantic-release \
+            @semantic-release/changelog \
+            @semantic-release/npm \
+            @semantic-release/github \
             @semantic-release/git
-            @semantic-release/github
+
+      - name: Run Semantic Release (Native)
+        id: semantic
+        # This will automatically pick up your export default config file in the repository root
+        run: npx semantic-release
         env:
-          GITHUB_TOKEN: "${{ secrets.GITHUB }}"
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
           NPM_TOKEN: "${{ secrets.NPM_TOKEN }}"
+
     outputs:
       new_release_published: "${{ steps.semantic.outputs.new_release_published }}"
-      new_release_version: "${{ steps.semantic.outputs.new_release_version }}"
-
+      new_release_version: "${{ steps.semantic.outputs.new_release_version }}"

package/.github/workflows/manual.yml

@@ -14,8 +14,7 @@ jobs:
         env:
             DRY_RUN: ${{ github.event.inputs.dry_run }}
             GITHUB_TOKEN: "${{ secrets.GITHUB }}"
-            NPM_TOKEN: "${{ secrets.NPM_TOKEN }}"
-
+  
         steps:
             - name: Checkout
               uses: actions/checkout@v3

package/CHANGELOG.md

@@ -1,3 +1,42 @@
+# [1.5.0](https://github.com/CoCreate-app/CoCreate-server/compare/v1.4.0...v1.5.0) (2026-07-17)
+
+
+### Features
+
+* enhance worker configuration to reserve CPU core for master process ([0a05a51](https://github.com/CoCreate-app/CoCreate-server/commit/0a05a516b4917cafd508a81443855fb5956348bc))
+* replace Metrics with ServerTelemetry for enhanced performance monitoring ([c1de789](https://github.com/CoCreate-app/CoCreate-server/commit/c1de789aa938bc1fa07b95e40728c4fe348ace6b))
+* replace SocketMesh with ServerMesh and add ServerAutoscaler for improved orchestration ([02ac503](https://github.com/CoCreate-app/CoCreate-server/commit/02ac503f709a6d8d4dd680f5d660fc7025cecb1d))
+* set workerId for single Primary process and ensure SocketMesh initialization ([d80084a](https://github.com/CoCreate-app/CoCreate-server/commit/d80084af3e2b72ffa30157be9091d0110302d882))
+
+# [1.4.0](https://github.com/CoCreate-app/CoCreate-server/compare/v1.3.0...v1.4.0) (2026-07-16)
+
+
+### Features
+
+* enhance CoCreateServer with IPC routing and edge request handling ([4da9381](https://github.com/CoCreate-app/CoCreate-server/commit/4da9381214806b022c129a2d1a25a1a7ad0a6276))
+* update automated workflow and release configuration for improved semantic release handling ([8d442c2](https://github.com/CoCreate-app/CoCreate-server/commit/8d442c243f05a9daa8cdcd3241f26f4dfb18022b))
+
+# [1.3.0](https://github.com/CoCreate-app/CoCreate-server/compare/v1.2.2...v1.3.0) (2026-07-15)
+
+
+### Features
+
+* add infrastructure and IP resolution modules for cloud provider metadata retrieval ([bb7b6cf](https://github.com/CoCreate-app/CoCreate-server/commit/bb7b6cf06a8dcbae0f68c8d3c644ffc40d553d97))
+* enhance server initialization with improved configuration handling and dynamic module imports ([9bd44c3](https://github.com/CoCreate-app/CoCreate-server/commit/9bd44c32ad3be2274b53a0fc859bb05346c34f91))
+* integrate Acme, Nginx, SocketMesh, and Metrics modules for enhanced server capabilities ([1d84a1c](https://github.com/CoCreate-app/CoCreate-server/commit/1d84a1c061d8421433fcb93d183e768d63eada10))
+
+## [1.2.2](https://github.com/CoCreate-app/CoCreate-server/compare/v1.2.1...v1.2.2) (2026-07-14)
+
+
+### Bug Fixes
+
+* refactor server initialization to include API server and improve module loading ([97fe5bf](https://github.com/CoCreate-app/CoCreate-server/commit/97fe5bfa94b98020d042024e3969312684dd7a68))
+* removed post install ([7ecf61a](https://github.com/CoCreate-app/CoCreate-server/commit/7ecf61ae0e5dd37244ecdbfd9c1cf434ef36e676))
+* semantic version handling. Reorganize .gitignore for improved clarity and structure ([27f9506](https://github.com/CoCreate-app/CoCreate-server/commit/27f9506ddb71641dc93b32cef6224a194c8bd009))
+* Update GitHub Actions workflow to use latest versions of actions and Node.js ([043f46e](https://github.com/CoCreate-app/CoCreate-server/commit/043f46e0a3a16c8186ebc7189e00fdfbffd201f7))
+* update module export to ES6 syntax in release.config.js ([2643676](https://github.com/CoCreate-app/CoCreate-server/commit/2643676e58b1ceec917da4780e569b55d65d5abb))
+* update package.json and refactor index.js for module compatibility ([0e21383](https://github.com/CoCreate-app/CoCreate-server/commit/0e21383964b0280f020d9da82058133e7b4d7eed))
+
 ## [1.2.1](https://github.com/CoCreate-app/CoCreate-server/compare/v1.2.0...v1.2.1) (2025-05-01)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/server",
-  "version": "1.2.1",
+  "version": "1.5.0",
   "description": "A dynamic SSL certificate management and generation tool for proxies like NGINX, with a fallback to Node.js SSL termination. It seamlessly integrates HTTP, HTTPS, and ACME protocols to ensure secure, encrypted connections.",
   "keywords": [
     "ssl-certificate-management",
@@ -20,8 +20,7 @@
   "scripts": {
     "start": "npx webpack --config webpack.config.js",
     "build": "npx webpack --mode=production --config webpack.config.js",
-    "dev": "npx webpack --config webpack.config.js --watch",
-    "postinstall": "node -e \"const { execSync } = require('child_process'); try { execSync('coc --version', { stdio: 'ignore' }); } catch (error) { try { execSync('npm install -g @cocreate/cli', { stdio: 'inherit' }); console.log('Installed \"@cocreate/cli\" globally.'); } catch (error) { console.error('Failed to install \"@cocreate/cli\" globally:', error); } }\""
+    "dev": "npx webpack --config webpack.config.js --watch"
   },
   "repository": {
     "type": "git",
@@ -37,6 +36,7 @@
     "type": "GitHub Sponsors ❤",
     "url": "https://github.com/sponsors/CoCreate-app"
   },
+  "type": "module",
   "main": "./src/index.js",
   "dependencies": {
     "@cocreate/acme": "^1.3.0"

package/release.config.js

@@ -1,4 +1,4 @@
-module.exports = {
+export default {
   dryRun: false,
   branches: ["master"],
   plugins: [
@@ -10,12 +10,20 @@ module.exports = {
         changelogFile: "CHANGELOG.md",
       },
     ],
-    "@semantic-release/npm",
-    "@semantic-release/github",
+    "@semantic-release/npm", 
     [
-      "@semantic-release/git",
+      "@semantic-release/github", 
       {
+        successComment: false,
+        failTitle: false,
+      },
+    ],
+    [
+      "@semantic-release/git", 
+      {
+        // Only stage and commit the changelog and package.json
         assets: ["CHANGELOG.md", "package.json"],
+        message: "chore(release): ${nextRelease.version} [skip ci]",
       },
     ],
   ],

package/src/getInfrastructure.js

@@ -0,0 +1,362 @@
+/********************************************************************************
+ * Copyright (C) 2023 CoCreate and Contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ ********************************************************************************/
+
+import http from 'node:http';
+import https from 'node:https';
+import fs from 'node:fs';
+import os from 'node:os';
+
+const METADATA_IP = '169.254.169.254';
+const PROBE_TIMEOUT_MS = 500; // Fast timeout for parallel background probes
+
+/* STREAMING_CHUNK: Structuring the native network request wrapper... */
+/**
+ * Native, lightweight HTTP request wrapper supporting standard GET/PUT/POST operations.
+ */
+function request(options, data = null, useHttps = false) {
+    const client = useHttps ? https : http;
+    return new Promise((resolve, reject) => {
+        const req = client.request(options, (res) => {
+            if (res.statusCode < 200 || res.statusCode >= 300) {
+                reject(new Error(`Status Code: ${res.statusCode}`));
+                return;
+            }
+            let body = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => { body += chunk; });
+            res.on('end', () => { resolve(body); });
+        });
+
+        req.on('error', (err) => { reject(err); });
+        req.setTimeout(PROBE_TIMEOUT_MS, () => {
+            req.destroy();
+            reject(new Error('Request Timeout'));
+        });
+
+        if (data) {
+            req.write(data);
+        }
+        req.end();
+    });
+}
+
+/* STREAMING_CHUNK: Configuring AWS metadata IMDSv2 probe... */
+/**
+ * AWS IMDSv2 Probe: Acquires session token and retrieves instance metadata.
+ */
+async function probeAWS() {
+    const token = await request({
+        host: METADATA_IP,
+        path: '/latest/api/token',
+        method: 'PUT',
+        headers: { 'X-aws-ec2-metadata-token-ttl-seconds': '60' }
+    });
+
+    const docStr = await request({
+        host: METADATA_IP,
+        path: '/latest/dynamic/instance-identity/document',
+        method: 'GET',
+        headers: { 'X-aws-ec2-metadata-token': token }
+    });
+
+    const doc = JSON.parse(docStr);
+    return {
+        provider: 'aws',
+        region: doc.region,
+        zone: doc.availabilityZone,
+        instanceId: doc.instanceId,
+        instanceType: doc.instanceType
+    };
+}
+
+/* STREAMING_CHUNK: Configuring Google Cloud (GCP) metadata probe... */
+/**
+ * GCP Metadata Probe: Requests instance data with the mandatory Flavor header.
+ */
+async function probeGCP() {
+    const docStr = await request({
+        host: 'metadata.google.internal', 
+        path: '/computeMetadata/v1/instance/?recursive=true',
+        method: 'GET',
+        headers: { 'Metadata-Flavor': 'Google' }
+    });
+
+    const doc = JSON.parse(docStr);
+    const zone = doc.zone ? doc.zone.split('/').pop() : 'unknown';
+    const region = zone.slice(0, zone.lastIndexOf('-'));
+    const instanceType = doc.machineType ? doc.machineType.split('/').pop() : 'unknown';
+
+    return {
+        provider: 'gcp',
+        region,
+        zone,
+        instanceId: doc.id ? String(doc.id) : 'unknown',
+        instanceType
+    };
+}
+
+/* STREAMING_CHUNK: Configuring Azure metadata probe... */
+/**
+ * Microsoft Azure Probe: Requests metadata using the validation header.
+ */
+async function probeAzure() {
+    const docStr = await request({
+        host: METADATA_IP,
+        path: '/metadata/instance?api-version=2021-02-01',
+        method: 'GET',
+        headers: { 'Metadata': 'true' }
+    });
+
+    const doc = JSON.parse(docStr);
+    const compute = doc.compute || {};
+
+    return {
+        provider: 'azure',
+        region: compute.location || 'unknown',
+        zone: compute.zone || 'unknown',
+        instanceId: compute.vmId || 'unknown',
+        instanceType: compute.vmSize || 'unknown'
+    };
+}
+
+/* STREAMING_CHUNK: Configuring DigitalOcean metadata probe... */
+/**
+ * DigitalOcean Probe: Requests droplet metadata configuration.
+ */
+async function probeDigitalOcean() {
+    const docStr = await request({
+        host: METADATA_IP,
+        path: '/metadata/v1.json',
+        method: 'GET'
+    });
+
+    const doc = JSON.parse(docStr);
+    return {
+        provider: 'digitalocean',
+        region: doc.region || 'unknown',
+        zone: doc.region ? `${doc.region}-a` : 'unknown',
+        instanceId: doc.droplet_id ? String(doc.droplet_id) : 'unknown',
+        instanceType: doc.size || 'unknown'
+    };
+}
+
+/* STREAMING_CHUNK: Configuring Oracle Cloud (OCI) metadata probe... */
+/**
+ * Oracle Cloud (OCI) Probe: Validates via the Bearer Token header required by IMDSv2.
+ */
+async function probeOCI() {
+    const docStr = await request({
+        host: METADATA_IP,
+        path: '/opc/v2/instance/',
+        method: 'GET',
+        headers: { 'Authorization': 'Bearer Oracle' }
+    });
+
+    const doc = JSON.parse(docStr);
+    return {
+        provider: 'oracle',
+        region: doc.region || 'unknown',
+        zone: doc.faultDomain || 'unknown',
+        instanceId: doc.id || 'unknown',
+        instanceType: doc.shape || 'unknown'
+    };
+}
+
+/* STREAMING_CHUNK: Configuring Hetzner Cloud metadata probe... */
+/**
+ * Hetzner Cloud Probe: Requests basic instance parameters on Hetzner routes.
+ */
+async function probeHetzner() {
+    const docStr = await request({
+        host: METADATA_IP,
+        path: '/hetzner/v1/metadata',
+        method: 'GET'
+    });
+
+    const lines = docStr.split('\n');
+    const meta = {};
+    for (const line of lines) {
+        const splitIdx = line.indexOf(':');
+        if (splitIdx !== -1) {
+            const key = line.slice(0, splitIdx).trim();
+            const val = line.slice(splitIdx + 1).trim();
+            meta[key] = val;
+        }
+    }
+
+    const zone = meta['availability-zone'] || 'unknown';
+    const region = meta['region'] || (zone ? zone.slice(0, zone.lastIndexOf('-')) : 'unknown');
+
+    return {
+        provider: 'hetzner',
+        region,
+        zone,
+        instanceId: meta['instance-id'] || 'unknown',
+        instanceType: 'cloud-vm' 
+    };
+}
+
+/* STREAMING_CHUNK: Configuring Vultr and Equinix metadata probes... */
+/**
+ * Vultr Probe: Pulls metadata configurations from standard OpenStack mapping paths.
+ */
+async function probeVultr() {
+    const idStr = await request({
+        host: METADATA_IP,
+        path: '/v1/instance-v2-id',
+        method: 'GET'
+    });
+
+    const hostStr = await request({
+        host: METADATA_IP,
+        path: '/v1/hostname',
+        method: 'GET'
+    });
+
+    return {
+        provider: 'vultr',
+        region: 'vultr-global',
+        zone: 'vultr-zone',
+        instanceId: idStr ? idStr.trim() : 'unknown',
+        instanceType: hostStr ? hostStr.trim() : 'vultr-instance'
+    };
+}
+
+/**
+ * Equinix Metal Probe: Requests local bare metal profile metadata via direct secure gateway.
+ */
+async function probeEquinix() {
+    const docStr = await request({
+        host: 'metadata.platformequinix.com',
+        path: '/metadata',
+        method: 'GET'
+    }, null, true);
+
+    const doc = JSON.parse(docStr);
+    return {
+        provider: 'equinix-metal',
+        region: doc.metro || doc.facility || 'unknown',
+        zone: doc.facility || 'unknown',
+        instanceId: doc.id || 'unknown',
+        instanceType: doc.plan || 'baremetal-metal'
+    };
+}
+
+/* STREAMING_CHUNK: Resolving local physical hardware profiles... */
+/**
+ * Safely inspects Linux OS profiles to identify local Bare-Metal / Physical system models.
+ */
+function resolveBareMetalIdentity() {
+    try {
+        if (fs.existsSync('/sys/class/dmi/id/product_name')) {
+            const productName = fs.readFileSync('/sys/class/dmi/id/product_name', 'utf8').trim();
+            const vendorName = fs.existsSync('/sys/class/dmi/id/sys_vendor') 
+                ? fs.readFileSync('/sys/class/dmi/id/sys_vendor', 'utf8').trim() 
+                : 'BareMetal';
+
+            let isVirtual = false;
+            const virtualClues = ['qemu', 'kvm', 'virtualbox', 'vmware', 'xen'];
+            for (const clue of virtualClues) {
+                if (productName.toLowerCase().includes(clue) || vendorName.toLowerCase().includes(clue)) {
+                    isVirtual = true;
+                }
+            }
+
+            if (!isVirtual) {
+                return {
+                    provider: 'baremetal',
+                    region: 'on-premise',
+                    zone: 'on-premise-datacenter',
+                    instanceId: productName.replace(/\s+/g, '-').toLowerCase(),
+                    instanceType: `${vendorName}-${productName}`.replace(/\s+/g, '-').toLowerCase()
+                };
+            }
+        }
+    } catch (err) {
+        // Non-blocking fallback
+    }
+    return null;
+}
+
+/* STREAMING_CHUNK: Running the infallible infrastructure resolver... */
+/**
+ * Dynamically resolves the host's physical infrastructure environment.
+ * Runs exactly once during the server boot sequence. Guaranteed to never throw.
+ * 
+ * @param {string} masterInstanceId - The pre-configured fallback instance ID
+ * @returns {Promise<Object>} Resolved server.infrastructure payload
+ */
+export async function getInfrastructure(masterInstanceId) {
+    const localFallback = {
+        provider: 'local',
+        region: 'local',
+        zone: 'local',
+        instanceId: masterInstanceId,
+        instanceType: 'local'
+    };
+
+    try {
+        // Phase 1: Concurrently race cloud metadata IMDS probes
+        try {
+            const cloudMetadata = await Promise.any([
+                probeAWS(),
+                probeGCP(),
+                probeAzure(),
+                probeDigitalOcean(),
+                probeOCI(),
+                probeHetzner(),
+                probeVultr(),
+                probeEquinix()
+            ]);
+            if (cloudMetadata) {
+                return cloudMetadata;
+            }
+        } catch (err) {
+            // Proceed to local sweeps
+        }
+
+        // Phase 2: Detect local On-Prem Bare Metal Hardware
+        try {
+            const bareMetalInfo = resolveBareMetalIdentity();
+            if (bareMetalInfo) {
+                bareMetalInfo.instanceId = masterInstanceId;
+                return bareMetalInfo;
+            }
+        } catch (err) {
+            // Proceed to env checks
+        }
+
+        // Phase 3: Check Environment Variable Overrides
+        if (process.env.PROVIDER) {
+            return {
+                provider: process.env.PROVIDER,
+                region: process.env.REGION || 'unknown',
+                zone: process.env.ZONE || 'unknown',
+                instanceId: process.env.INSTANCE_ID || masterInstanceId,
+                instanceType: process.env.INSTANCE_TYPE || 'unknown'
+            };
+        }
+
+    } catch (globalErr) {
+        // Suppress any unexpected error contexts and fall back cleanly
+    }
+
+    // Phase 4: Developer Machine Fallback
+    return localFallback;
+}
+
+export default getInfrastructure;

package/src/getIp.js

@@ -0,0 +1,113 @@
+/********************************************************************************
+ * Copyright (C) 2023 CoCreate and Contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ ********************************************************************************/
+
+import https from 'node:https';
+import os from 'node:os';
+
+// Prioritized list of reliable public IP lookup APIs
+const IP_PROVIDERS = [
+    'https://api.ipify.org',
+    'https://icanhazip.com',
+    'https://ifconfig.me/ip',
+    'https://ipinfo.io/ip'
+];
+
+/**
+ * Initiates an HTTPS GET request to a specific IP provider with a hard timeout.
+ * 
+ * @param {string} url - The URL of the IP lookup provider 
+ * @param {number} timeoutMs - Max execution limit before canceling the promise
+ * @returns {Promise<string>} - Resolves with the plain-text IP address
+ */
+function fetchIpFromProvider(url, timeoutMs = 3000) {
+    return new Promise((resolve, reject) => {
+        const req = https.get(url, (res) => {
+            if (res.statusCode !== 200) {
+                reject(new Error(`Non-200 response code: ${res.statusCode}`));
+                return;
+            }
+
+            let data = '';
+            res.on('data', (chunk) => { data += chunk; });
+
+            res.on('end', () => {
+                const cleanIp = data.trim();
+                const ipv4Regex = /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/;
+                if (ipv4Regex.test(cleanIp)) {
+                    resolve(cleanIp);
+                } else {
+                    reject(new Error(`Returned invalid IP structure: "${cleanIp}"`));
+                }
+            });
+        });
+
+        req.on('error', (err) => { reject(err); });
+
+        req.setTimeout(timeoutMs, () => {
+            req.destroy();
+            reject(new Error(`Request timed out`));
+        });
+    });
+}
+
+/**
+ * Scans the local machine's physical network adapters to find the primary local IP.
+ * Used as a fallback if the machine has no active internet connection or is fully offline.
+ * 
+ * @returns {string} - Returns the first valid local IPv4 address, or '127.0.0.1'
+ */
+export function getLocalIPFallback() {
+    try {
+        const interfaces = os.networkInterfaces();
+        for (const devName in interfaces) {
+            const face = interfaces[devName];
+            for (let i = 0; i < face.length; i++) {
+                const alias = face[i];
+                // Check for standard IPv4 and exclude typical loopbacks
+                if (alias.family === 'IPv4' && alias.address !== '127.0.0.1' && !alias.internal) {
+                    return alias.address;
+                }
+            }
+        }
+    } catch (err) {
+        // Safe, non-blocking fallback context
+    }
+    return '127.0.0.1';
+}
+
+/**
+ * Robust universal public IP resolution function.
+ * Iterates through highly redundant public IP lookup services.
+ * Guaranteed to never throw errors.
+ * 
+ * @returns {Promise<string>} - The resolved public IP (or local IP if completely offline)
+ */
+export async function getIp() {
+    for (const url of IP_PROVIDERS) {
+        try {
+            const ip = await fetchIpFromProvider(url);
+            return ip;
+        } catch (error) {
+            // Suppress fallback exceptions to attempt the next endpoint seamlessly
+        }
+    }
+
+    // Offline / Air-Gapped Fallback
+    return getLocalIPFallback();
+}
+
+export default getIp;

package/src/index.js

@@ -1,38 +1,399 @@
-const Http = require('http');
-const Https = require('https');
-const tls = require('tls');
-const acme = require('@cocreate/acme')
-const fs = require('fs');
-
-let server = {
-    acme: new acme(),
-    http: Http.createServer(),
-    https: Https.createServer({ SNICallback: sniCallback })
-};
-
-function loadCertificates(domain) {
-    try {
-        return {
-            key: fs.readFileSync(`/etc/certificates/${domain}/private-key.pem`),
-            cert: fs.readFileSync(`/etc/certificates/${domain}/fullchain.pem`),
+/********************************************************************************
+ * Copyright (C) 2023 CoCreate and Contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ ********************************************************************************/
+
+import { EventEmitter } from 'node:events';
+import Http from 'node:http';
+import Https from 'node:https';
+import Acme from '@cocreate/acme';
+import ServerMesh from '@cocreate/server-mesh';
+import ServerAutoscaler from '@cocreate/server-autoscaler';
+import ServerTelemetry from '@cocreate/server-telemetry';
+
+import cluster from 'node:cluster';
+import os from 'node:os';
+import uid from '@cocreate/uuid';
+import Config from '@cocreate/config';
+import authenticate from '@cocreate/authenticate';
+import authorize from '@cocreate/authorize';
+
+import SocketServer from '@cocreate/socket-server';
+import CrudServer from '@cocreate/crud-server';
+import LazyLoader from '@cocreate/lazy-loader';
+import FileServer from '@cocreate/file-server';
+import ApiServer from '@cocreate/api';
+
+import { ObjectId } from '@cocreate/utils';
+
+// Dynamic environmental resolvers
+import resolveInfrastructure from './getInfrastructure.js';
+import getIP from './getIp.js';
+
+const isPrimary = cluster.isPrimary !== undefined ? cluster.isPrimary : cluster.isMaster;
+const id = process.env.SERVER_ID || ObjectId().toString();
+
+const sharedMap = new Map();
+const pendingPromises = new Map();
+const activeWorkers = new Map();
+
+export class CoCreateServer extends EventEmitter {
+    constructor() {
+        super();
+        this.id = id;
+        this.isPrimary = isPrimary;
+        
+        if (isPrimary) {
+            this.workers = activeWorkers;
+        } else {
+            this.workerId = parseInt(process.env.WORKER_ID, 10) || 1;
+        }
+        
+        this.totalWorkers = 0;
+        this.workerStorage = null;
+        this.isInitialized = false;
+        
+        this.organization_id = null;
+        this.host = null;
+        this.ip = null;
+        this.infrastructure = null;
+
+        // Create HTTP server for edge proxy ACME challenges and secure HTTPS redirects
+        this.http = Http.createServer((req, res) => {
+            const requestUrl = req.url || '/';
+            // 1. Allow ACME challenges to pass through over unencrypted HTTP
+            if (requestUrl.startsWith('/.well-known/acme-challenge/')) {
+                return this.handleEdgeRequest(req, res);
+            }
+            // 2. Force a 301 redirect to HTTPS for all other traffic
+            const host = req.headers.host ? req.headers.host.split(':')[0] : 'localhost';
+            res.writeHead(301, { "Location": `https://${host}${requestUrl}` });
+            res.end();
+        });
+        
+        this.https = null;
+        this.mesh = null;
+        this.autoscaler = null;
+        this.authenticate = authenticate;
+        this.authorize = authorize;
+        this.wsManager = null;
+        this.crud = null;
+        this.telemetry = null;
+        this.files = null;
+        this.loader = null;
+    }
+
+    send(payload) {
+        if (!payload || !payload.method) {
+            console.error("[@cocreate/server] Cannot route IPC send without a 'method' definition.");
+            return;
+        }
+
+        if (this.isPrimary) {
+            // --- MASTER SEND ROUTING PATHWAY ---
+            // 1. Dispatch locally on Master process unless explicitly bypassed
+            if (payload.master !== false) {
+                this.emit(payload.method, payload);
+            }
+
+            // 2. Compile target worker list dynamically using a flat ternary condition.
+            // This eliminates duplicate loops, nested blocks, and repeated try/catch statements.
+            const targetIds = payload.broadcast === true
+                ? Array.from(this.workers.keys())
+                : (Array.isArray(payload.workers) ? payload.workers : []);
+
+            // 3. Dispatch to all compiled destination targets in a single unified loop.
+            for (const wId of targetIds) {
+                const worker = this.workers.get(wId);
+                if (worker?.process && typeof worker.process.send === 'function') {
+                    try {
+                        worker.process.send({ ipcPayload: true, payload });
+                    } catch (err) {
+                        console.error(`[@cocreate/server] Failed sending to worker ${wId}:`, err);
+                    }
+                }
+            }
+        } else {
+            // --- WORKER SEND ROUTING PATHWAY ---
+            // 1. Emit locally on this worker so native listeners trigger immediately
+            this.emit(payload.method, payload);
+
+            // 2. Relay the message upstream to the Primary Orchestrator Process
+            if (typeof process.send === 'function') {
+                try {
+                    process.send({ ipcPayload: true, payload });
+                } catch (err) {
+                    console.error("[@cocreate/server] Failed sending upstream IPC payload to Master:", err);
+                }
+            }
+        }
+    }
+
+    async init() {
+        if (this.isInitialized) {
+            return this;
+        }
+
+        this.isInitialized = true;
+        setupIPC(this);
+
+        this.workerStorage = {
+            set: (key, value) => workerStorageManager(this, 'set', key, value),
+            get: (key) => workerStorageManager(this, 'get', key),
+            delete: (key) => workerStorageManager(this, 'delete', key),
+            size: () => workerStorageManager(this, 'size'),
+            clear: () => workerStorageManager(this, 'clear')
         };
-    } catch (error) {
-        console.error("Error loading certificates for domain:", domain);
-        throw error;  // Or handle it by returning default certificates
+
+        const config = await Config({
+            'organization_id': '',
+            'host': '',
+            'workers': ''
+        });
+
+        this.organization_id = config.organization_id || null;
+        this.host = config.host || null;
+
+        let configuredWorkers = config.workers;
+
+        if (configuredWorkers !== false && configuredWorkers !== 'false') {
+            const parsedWorkers = parseInt(configuredWorkers, 10);
+            if (parsedWorkers === -1) {
+                // Use total CPU cores minus 1 (minimum of 1) to reserve one core for the master process
+                this.totalWorkers = Math.max(1, os.cpus().length - 1);
+            } else {
+                this.totalWorkers = parsedWorkers || os.cpus().length;
+            }
+        }
+
+        // Explicitly set workerId = 1 on the single Primary process if workers configuration specifies no clustering (<= 1)
+        if (this.isPrimary && this.totalWorkers <= 1) {
+            this.workerId = 1;
+        }
+
+        // DB interface is booted first so that ServerMesh can cleanly read nodes and write startup heartbeats
+        this.crud = await CrudServer.init(this);
+
+        // Assign the ServerMesh globally. This guarantees both Workers and Primary can safely call "this.mesh.send"
+        this.mesh = ServerMesh;
+        this.autoscaler = ServerAutoscaler;
+
+        if (this.isPrimary) {
+            console.log(`[@cocreate/server] [PRIMARY] Orchestrator starting...`);
+            
+            this.ip = await getIP();
+            this.infrastructure = await resolveInfrastructure(this.id);
+            await this.mesh.init(this);
+            await this.autoscaler.init(this);
+
+            if (this.totalWorkers > 1) {
+                console.log(`[@cocreate/server] [PRIMARY] Orchestrator running with PID: ${process.pid}`);
+                for (let i = 0; i < this.totalWorkers; i++) {
+                    const currentWorkerId = i + 1;
+                    const worker = cluster.fork({ 
+                        WORKER_ID: currentWorkerId,
+                        SERVER_ID: this.id,
+                        SERVER_IP: this.ip,
+                        SERVER_INFRASTRUCTURE: JSON.stringify(this.infrastructure)
+                    });
+                    activeWorkers.set(currentWorkerId, {
+                        id: currentWorkerId,
+                        pid: worker.process.pid,
+                        process: worker
+                    });
+                }
+
+                // Supervise and automatically reboot dead or crashed worker processes
+                cluster.on('exit', (worker, code, signal) => {
+                    console.log(`[@cocreate/server] [PRIMARY] Worker ${worker.process.pid} exited (Code: ${code}, Signal: ${signal})`);
+                    let deadWorkerId = null;
+                    for (let [id, w] of activeWorkers.entries()) {
+                        if (w.pid === worker.process.pid) {
+                            deadWorkerId = id;
+                            activeWorkers.delete(id);
+                            break;
+                        }
+                    }
+                    const targetId = deadWorkerId || (activeWorkers.size + 1);
+                    
+                    const newWorker = cluster.fork({ 
+                        WORKER_ID: targetId,
+                        SERVER_ID: this.id, 
+                        SERVER_IP: this.ip,
+                        SERVER_INFRASTRUCTURE: JSON.stringify(this.infrastructure)
+                    });
+                    activeWorkers.set(targetId, {
+                        id: targetId,
+                        pid: newWorker.process.pid,
+                        process: newWorker
+                    });
+                });
+
+                // In clustered mode, only the Primary exits early. The workers handle the core traffic.
+                if (this.totalWorkers > 1) {
+                    return this;
+                }
+            }
+        }
+        
+        this.ip = process.env.SERVER_IP || await getIP();
+        
+        try {
+            this.infrastructure = process.env.SERVER_INFRASTRUCTURE 
+                ? JSON.parse(process.env.SERVER_INFRASTRUCTURE) 
+                : await resolveInfrastructure(this.id);
+        } catch (error) {
+            console.error(`[@cocreate/server] Worker ${process.pid} failed to parse pre-resolved infrastructure. Falling back...`, error);
+            this.infrastructure = await resolveInfrastructure(this.id);
+        }
+
+        // Initialize HTTPS & Ephemeral certificate via ACME
+        this.certificate = Acme;
+        this.https = Https.createServer({
+            SNICallback: (domain, cb) => this.certificate.sniCallback(domain, cb)
+        }, (req, res) => this.handleEdgeRequest(req, res));
+        await this.certificate.init(this);
+
+        // Standard core services
+        this.wsManager = new SocketServer(this);
+        this.api = await ApiServer.init(this);
+        this.files = FileServer.init(this);
+        this.loader = await LazyLoader.init(this);
+
+        // Initialize performance telemetry
+        this.telemetry = await ServerTelemetry.init(this);
+
+        // Bind directly to standard web ports (Requires setcap or root privileges)
+        const HTTP_PORT = process.env.HTTP_PORT || 80;
+        const HTTPS_PORT = process.env.HTTPS_PORT || 443;
+        const BIND_IP = process.env.BIND_IP || '0.0.0.0';
+        const processLabel = this.isPrimary ? `Primary (${process.pid})` : `Worker ${process.pid} (ID: ${this.workerId})`;
+
+        if (this.http) {
+            this.http.listen(HTTP_PORT, BIND_IP, () => {
+                console.log(`[@cocreate/server] ${processLabel} HTTP listening on ${BIND_IP}:${HTTP_PORT} (Redirects & ACME)`);
+            });
+        }
+
+        if (this.https) {
+            this.https.listen(HTTPS_PORT, BIND_IP, () => {
+                console.log(`[@cocreate/server] ${processLabel} HTTPS listening on ${BIND_IP}:${HTTPS_PORT} (Secure Edge & WSS)`);
+            });
+        }
+
+        return this;
+    }
+
+    async handleEdgeRequest(req, res) {
+        try {
+            const requestUrl = req.url || '/';
+            if (requestUrl.startsWith("/webhooks/")) {
+                if (this.loader) return this.loader.request(req, res);
+            }
+            if (this.files) return this.files.send(req, res);
+
+            res.writeHead(500, { "Content-Type": "text/plain" });
+            res.end("Internal Error: Files component missing");
+        } catch (error) {
+            res.writeHead(400, { "Content-Type": "text/plain" });
+            res.end("Invalid request routing context");
+        }
     }
 }
 
-async function sniCallback(domain, cb) {
-    try {
-        console.log('sni')
-        if (await server.acme.checkCertificate(domain)) {
-            const sslContext = tls.createSecureContext(loadCertificates(domain));
-            cb(null, sslContext);
-        } else return
-    } catch (error) {
-        console.error("Error in SNI callback for domain:", domain, error);
-        cb(error);  // handle error or use default context
+function executeLocalWorkerStorageOperation(method, key, value) {
+    switch (method) {
+        case 'set': sharedMap.set(key, value); return true;
+        case 'get': return sharedMap.get(key);
+        case 'delete': return sharedMap.delete(key);
+        case 'size': return sharedMap.size;
+        case 'clear': sharedMap.clear(); return true;
+        default: throw new Error(`Unsupported storage key operation: "${method}"`);
+    }
+}
+
+function workerStorageManager(serverCtx, method, key, value) {
+    return new Promise((resolve, reject) => {
+        try {
+            if (serverCtx.isPrimary) {
+                resolve(executeLocalWorkerStorageOperation(method, key, value));
+            } else {
+                const messageId = uid.generate();
+                pendingPromises.set(messageId, { resolve, reject });
+                process.send({ id: serverCtx.id, messageId, method, key, value });
+            }
+        } catch (error) {
+            reject(error);
+        }
+    });
+}
+
+function setupIPC(serverCtx) {
+    if (serverCtx.isPrimary) {
+        cluster.on('message', (worker, message) => {
+            // 1. Check for standard storage operations
+            if (message && message.id === serverCtx.id) {
+                try {
+                    message.value = executeLocalWorkerStorageOperation(message.method, message.key, message.value);
+                    worker.send(message);
+                } catch (error) {
+                    message.error = error.error;
+                    worker.send(message);
+                }
+            }
+            // 2. Routing logic for CoCreate Unified IPC Payloads
+            else if (message && message.ipcPayload && message.payload) {
+                const { payload } = message;
+                
+                // Track sending worker PID to worker mapping
+                let senderWorkerId = null;
+                for (const [wId, w] of serverCtx.workers.entries()) {
+                    if (w.pid === worker.process.pid) {
+                        senderWorkerId = wId;
+                        break;
+                    }
+                }
+                
+                // Expose sender metadata to routing logic
+                payload.senderWorkerId = senderWorkerId;
+                
+                // Pass it off to the primary orchestrator's central send method
+                serverCtx.send(payload);
+            }
+        });
+    } else {
+        process.on('message', (message) => {
+            // 1. Check for standard storage operations
+            if (message && message.id === serverCtx.id) {
+                const pending = pendingPromises.get(message.messageId);
+                if (pending) {
+                    pendingPromises.delete(message.messageId);
+                    if (message.error) {
+                        pending.reject(new Error(message.error));
+                    } else {
+                        pending.resolve(message.value);
+                    }
+                }
+            }
+            // 2. Incoming Unified IPC payload from Master -> Worker Process
+            else if (message && message.ipcPayload && message.payload) {
+                serverCtx.emit(message.payload.method, message.payload);
+            }
+        });
     }
 }
 
-module.exports = server;
+export default new CoCreateServer();