cyberia 3.0.3 → 3.2.5

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);
 
@@ -16,7 +16,7 @@ const volumeHostPath = '/home/dd';
 const enginePath = '/home/dd/engine';
 const cronVolumeName = 'underpost-cron-container-volume';
 const shareEnvVolumeName = 'underpost-share-env';
-const underpostContainerEnvPath = '/usr/lib/node_modules/underpost/.env';
+const underpostContainerEnvDir = '/usr/lib/node_modules/underpost';
 
 /**
  * Generates a Kubernetes CronJob YAML manifest string.
@@ -33,7 +33,9 @@ const underpostContainerEnvPath = '/usr/lib/node_modules/underpost/.env';
  * @param {string} [params.cmd] - Optional pre-script commands to run before cron execution
  * @param {boolean} [params.suspend=false] - Whether the CronJob is suspended
  * @param {boolean} [params.dryRun=false] - Pass --dry-run flag to the cron command inside the container
- * @param {boolean} [params.ssh=false] - Execute backup commands via SSH on the remote node
+ * @param {boolean} [params.k3s=false] - Pass --k3s flag to the cron command inside the container
+ * @param {boolean} [params.kind=false] - Pass --kind flag to the cron command inside the container
+ * @param {boolean} [params.kubeadm=false] - Pass --kubeadm flag to the cron command inside the container
  * @returns {string} Kubernetes CronJob YAML manifest
  * @memberof UnderpostCron
  */
@@ -49,7 +51,9 @@ const cronJobYamlFactory = ({
   cmd,
   suspend = false,
   dryRun = false,
-  ssh = false,
+  k3s = false,
+  kind = false,
+  kubeadm = false,
 }) => {
   const containerImage = image || `underpost/underpost-engine:${Underpost.version}`;
 
@@ -60,10 +64,12 @@ const cronJobYamlFactory = ({
     .replace(/^-|-$/g, '')
     .substring(0, 52);
 
-  const cmdPart = cmd ? `${cmd} && ` : '';
-  const cronBin = dev ? 'node bin' : 'underpost';
-  const flags = `${git ? '--git ' : ''}${dev ? '--dev ' : ''}${dryRun ? '--dry-run ' : ''}${ssh ? '--ssh ' : ''}`;
-  const cronCommand = `${cmdPart}${cronBin} cron ${flags}${deployList} ${jobList}`;
+  const cronBin = 'node bin'; // dev ? 'node bin' : 'underpost';
+  const flags = `${git ? '--git ' : ''}${dev ? '--dev ' : ''}${dryRun ? '--dry-run ' : ''}${k3s ? '--k3s ' : ''}${kind ? '--kind ' : ''}${kubeadm ? '--kubeadm ' : ''}`;
+  const commands = [`cd ${enginePath}`]; // `node bin run secret`
+  if (cmd) commands.push(cmd);
+  commands.push(`${cronBin} cron ${deployList} ${jobList} ${flags}`);
+  const fullCommand = commands.join(' &&\n                  ');
 
   return `apiVersion: batch/v1
 kind: CronJob
@@ -95,13 +101,12 @@ spec:
                 - /bin/sh
                 - -c
                 - >
-                  ${cronCommand}
+                  ${fullCommand}
               volumeMounts:
                 - mountPath: ${enginePath}
                   name: ${cronVolumeName}
-                - mountPath: ${underpostContainerEnvPath}
+                - mountPath: ${underpostContainerEnvDir}
                   name: ${shareEnvVolumeName}
-                  subPath: .env
           volumes:
             - hostPath:
                 path: ${enginePath}
@@ -183,7 +188,6 @@ class UnderpostCron {
      * @param {boolean} [options.kubeadm] - Use kubeadm cluster context (apply directly on host)
      * @param {boolean} [options.dryRun] - Preview cron jobs without executing them
      * @param {boolean} [options.createJobNow] - After applying, immediately create a Job from each CronJob (requires --apply)
-     * @param {boolean} [options.ssh] - Execute backup commands via SSH on the remote node
      * @memberof UnderpostCron
      */
     callback: async function (
@@ -191,6 +195,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);
@@ -226,7 +231,6 @@ class UnderpostCron {
      * @param {boolean} [options.k3s] - k3s cluster context (apply directly on host)
      * @param {boolean} [options.kind] - kind cluster context (apply via kind-worker container)
      * @param {boolean} [options.kubeadm] - kubeadm cluster context (apply directly on host)
-     * @param {boolean} [options.ssh] - Execute backup commands via SSH on the remote node
      * @memberof UnderpostCron
      */
     setupDeployStart: async function (deployId, options = {}) {
@@ -268,21 +272,19 @@ class UnderpostCron {
         logger.warn(`package.json not found for deploy-id: ${deployId}`, { path: packageJsonPath });
       }
 
-      // Generate and apply cron job manifests for this deploy-id
       await Underpost.cron.generateK8sCronJobs({
         deployId,
         namespace: options.namespace,
         image: options.image,
         apply: options.apply,
         createJobNow: options.createJobNow,
-        git: true,
-        dev: true,
-        kubeadm: true,
-        ssh: true,
-        cmd: ` cd ${enginePath} && node bin env ${deployId} production`,
-        k3s: false,
-        kind: false,
-        dryRun: false,
+        git: !!options.git,
+        dev: !!options.dev,
+        kubeadm: !!options.kubeadm,
+        cmd: options.cmd || `node bin env ${deployId} production`,
+        k3s: !!options.k3s,
+        kind: !!options.kind,
+        dryRun: !!options.dryRun,
       });
     },
 
@@ -304,7 +306,6 @@ class UnderpostCron {
      * @param {boolean} [options.kubeadm=false] - kubeadm cluster context (apply directly on host)
      * @param {boolean} [options.createJobNow=false] - After applying, create a Job from each CronJob immediately
      * @param {boolean} [options.dryRun=false] - Pass --dry-run=client to kubectl commands
-     * @param {boolean} [options.ssh=false] - Execute backup commands via SSH on the remote node
      * @memberof UnderpostCron
      */
     generateK8sCronJobs: async function (options = {}) {
@@ -361,7 +362,9 @@ class UnderpostCron {
           cmd: options.cmd,
           suspend: false,
           dryRun: !!options.dryRun,
-          ssh: !!options.ssh,
+          k3s: !!options.k3s,
+          kind: !!options.kind,
+          kubeadm: !!options.kubeadm,
         });
 
         const yamlFilePath = `${outputDir}/${cronJobName}.yaml`;

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,8 @@ class Dns {
    * @returns {Promise<void>}
    */
   static async callback(deployList) {
+    // loadCronDeployEnv();
+
     const isOnline = await Dns.isInternetConnection();
 
     if (!isOnline) return;
@@ -288,16 +287,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 +363,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 +398,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/ipfs-client.js

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

package/src/server/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