@cocreate/server 1.2.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/server",
-  "version": "1.2.0",
+  "version": "1.4.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,8 +36,9 @@
     "type": "GitHub Sponsors ❤",
     "url": "https://github.com/sponsors/CoCreate-app"
   },
+  "type": "module",
   "main": "./src/index.js",
   "dependencies": {
-    "@cocreate/acme": "^1.2.12"
+    "@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;