cyberia 2.8.885

package/bin/file.js

@@ -0,0 +1,197 @@
+import fs from 'fs-extra';
+
+import { loggerFactory } from '../src/server/logger.js';
+import {
+  cap,
+  getCapVariableName,
+  getDirname,
+  newInstance,
+  uniqueArray,
+} from '../src/client/components/core/CommonJs.js';
+import { shellCd, shellExec } from '../src/server/process.js';
+import walk from 'ignore-walk';
+import { validateTemplatePath } from '../src/server/conf.js';
+
+const logger = loggerFactory(import.meta);
+
+logger.info('argv', process.argv);
+
+let [exe, dir, type] = process.argv;
+let rawPath = process.argv[3].replaceAll(`'`, '');
+let toPath = process.argv[4].replaceAll(`'`, '');
+
+let path = `${rawPath}`.split('/');
+path.pop();
+path = path.join('/');
+
+const file = `${rawPath}`.split('/').pop();
+const ext = file.split('.')[1];
+let name = getCapVariableName(file.split('.')[0]);
+
+logger.info('File metadata', { path, file, ext, name });
+
+try {
+  let content = '';
+  switch (type) {
+    case 'update-template':
+    case 'copy-src':
+      console.log({ rawPath, toPath });
+
+      // this function returns a promise, but you can also pass a cb
+      // if you like that approach better.
+      let result = await new Promise((resolve) =>
+        walk(
+          {
+            path: rawPath, // root dir to start in. defaults to process.cwd()
+            ignoreFiles: [`.gitignore`], // list of filenames. defaults to ['.ignore']
+            includeEmpty: false, // true to include empty dirs, default false
+            follow: false, // true to follow symlink dirs, default false
+          },
+          (...args) => resolve(args[1]),
+        ),
+      );
+
+      result = result.filter((path) => !path.startsWith('.git'));
+
+      console.log('copy paths', result);
+
+      if (type === 'update-template') {
+        if (!fs.existsSync(toPath))
+          shellExec(`cd .. && underpost clone ${process.env.GITHUB_USERNAME}/pwa-microservices-template`);
+        else {
+          shellExec(`cd ${toPath} && git reset && git checkout . && git clean -f -d`);
+          shellExec(`underpost pull ${toPath} ${process.env.GITHUB_USERNAME}/pwa-microservices-template`);
+          shellExec(`sudo rm -rf ${toPath}/engine-private`);
+          shellExec(`sudo rm -rf ${toPath}/logs`);
+        }
+      } else {
+        fs.removeSync(toPath);
+      }
+
+      for (const copyPath of result) {
+        const folder = getDirname(`${toPath}/${copyPath}`);
+        const absolutePath = `${rawPath}/${copyPath}`;
+
+        if (type === 'update-template' && !validateTemplatePath(absolutePath)) continue;
+
+        if (!fs.existsSync(folder)) fs.mkdirSync(folder, { recursive: true });
+
+        logger.info('build', `${toPath}/${copyPath}`);
+
+        fs.copyFileSync(absolutePath, `${toPath}/${copyPath}`);
+      }
+
+      if (type === 'update-template') {
+        fs.copySync(`./.vscode`, `../pwa-microservices-template/.vscode`);
+        // fs.copySync(`./.github`, `../pwa-microservices-template/.github`);
+        fs.copySync(`./src/client/public/default`, `../pwa-microservices-template/src/client/public/default`);
+
+        for (const checkoutPath of ['README.md', 'package-lock.json', 'package.json'])
+          shellExec(`cd ../pwa-microservices-template && git checkout ${checkoutPath}`);
+
+        for (const deletePath of [
+          './.github',
+          './manifests/deployment/dd-lampp-development',
+          './manifests/deployment/dd-cyberia-development',
+          './manifests/deployment/dd-core-development',
+          './manifests/deployment/dd-template-development',
+          'bin/web3.js',
+          'bin/cyberia.js',
+          'bin/cyberia0.js',
+        ]) {
+          if (fs.existsSync(deletePath)) fs.removeSync('../pwa-microservices-template/' + deletePath);
+        }
+
+        fs.mkdirSync(`../pwa-microservices-template/.github/workflows`, {
+          recursive: true,
+        });
+        for (const _path of [
+          `./.github/workflows/pwa-microservices-template-page.cd.yml`,
+          `./.github/workflows/pwa-microservices-template-test.ci.yml`,
+          `./.github/workflows/npmpkg.ci.yml`,
+          `./.github/workflows/ghpkg.ci.yml`,
+          `./.github/workflows/publish.ci.yml`,
+          `./.github/workflows/release.cd.yml`,
+          './src/ws/IoInterface.js',
+          './src/ws/IoServer.js',
+        ])
+          fs.copyFileSync(_path, `../pwa-microservices-template/${_path}`);
+
+        const originPackageJson = JSON.parse(fs.readFileSync('./package.json', 'utf8'));
+        const templatePackageJson = JSON.parse(fs.readFileSync('../pwa-microservices-template/package.json', 'utf8'));
+
+        const name = templatePackageJson.name;
+        const description = templatePackageJson.description;
+        const dev = templatePackageJson.scripts.dev;
+        const build = templatePackageJson.scripts.build;
+
+        templatePackageJson.dependencies = originPackageJson.dependencies;
+        templatePackageJson.devDependencies = originPackageJson.devDependencies;
+        templatePackageJson.version = originPackageJson.version;
+        templatePackageJson.scripts = originPackageJson.scripts;
+        templatePackageJson.name = name;
+        templatePackageJson.description = description;
+        // templatePackageJson.scripts.dev = dev;
+        // templatePackageJson.scripts.build = build;
+        templatePackageJson.keywords = uniqueArray(
+          ['pwa', 'microservices', 'template', 'builder'].concat(templatePackageJson.keywords),
+        );
+        delete templatePackageJson.scripts['update-template'];
+        fs.writeFileSync(
+          '../pwa-microservices-template/package.json',
+          JSON.stringify(templatePackageJson, null, 4),
+          'utf8',
+        );
+
+        const originPackageLockJson = JSON.parse(fs.readFileSync('./package-lock.json', 'utf8'));
+        const templatePackageLockJson = JSON.parse(
+          fs.readFileSync('../pwa-microservices-template/package-lock.json', 'utf8'),
+        );
+        const originBasePackageLock = newInstance(templatePackageLockJson.packages['']);
+        templatePackageLockJson.version = originPackageLockJson.version;
+        templatePackageLockJson.packages = originPackageLockJson.packages;
+        templatePackageLockJson.packages[''].name = originBasePackageLock.name;
+        templatePackageLockJson.packages[''].version = originPackageLockJson.version;
+        templatePackageLockJson.packages[''].hasInstallScript = originBasePackageLock.hasInstallScript;
+        templatePackageLockJson.packages[''].license = originBasePackageLock.license;
+        fs.writeFileSync(
+          '../pwa-microservices-template/package-lock.json',
+          JSON.stringify(templatePackageLockJson, null, 4),
+          'utf8',
+        );
+        const badges = fs
+          .readFileSync(`./README.md`, 'utf8')
+          .split(`<!-- badges -->`)[1]
+          .split(`<!-- end-badges -->`)[0];
+        let originMd = fs.readFileSync(`../pwa-microservices-template/README.md`, 'utf8');
+
+        originMd =
+          originMd.split(`<!-- badges -->`)[0] +
+          `<!-- badges -->` +
+          badges +
+          `<!-- end-badges -->` +
+          originMd.split(`<!-- end-badges -->`)[1];
+
+        const splitKeyword = '## underpost ci/cd cli';
+        fs.writeFileSync(
+          `../pwa-microservices-template/README.md`,
+          originMd.split(`<!-- -->`)[0] +
+            `<!-- -->
+${splitKeyword + fs.readFileSync(`./README.md`, 'utf8').split(splitKeyword)[1]}`,
+          'utf8',
+        );
+      }
+
+      break;
+    case 'create':
+      const buildPath = `${path}/${name}${ext ? `.${ext}` : ''}`;
+      logger.info('Build path', buildPath);
+      fs.mkdirSync(path, { recursive: true });
+      fs.writeFileSync(buildPath, content, 'utf8');
+    default:
+      logger.error('not found operator');
+      break;
+  }
+} catch (error) {
+  logger.error(error, error.stack);
+}

package/bin/hwt.js

@@ -0,0 +1,49 @@
+import fs from 'fs-extra';
+
+import { loggerFactory } from '../src/server/logger.js';
+
+const logger = loggerFactory(import.meta);
+
+logger.info('argv', process.argv);
+
+const [exe, dir, operator, templateId, publicPath] = process.argv;
+
+// engine for 'html-website-templates'
+
+try {
+  switch (operator) {
+    case 'set-base':
+      {
+        switch (parseInt(templateId)) {
+          // Horizontal Scroll One Page Template Website
+          case 0:
+            {
+              fs.writeFile(
+                `${publicPath}/index.html`,
+                fs
+                  .readFileSync(`${publicPath}/index.html`, 'utf8')
+                  .replace(`<ul class="menu">`, `<ul class="menu hidden">`)
+                  .replaceAll(`<section class="slide fade-6 kenBurns">`, `<section class="fade-6 kenBurns hidden">`)
+                  .replace(`<section class="fade-6 kenBurns hidden">`, `<section class="slide fade-6 kenBurns">`)
+                  .replaceAll(
+                    `<nav class="panel bottom forceMobileView">`,
+                    `<nav class="panel bottom forceMobileView hidden">`,
+                  ),
+
+                'utf8',
+              );
+            }
+            break;
+
+          default:
+            break;
+        }
+      }
+      break;
+
+    default:
+      break;
+  }
+} catch (error) {
+  logger.error(error, error.stack);
+}

package/bin/index.js

@@ -0,0 +1,145 @@
+#! /usr/bin/env node
+
+import dotenv from 'dotenv';
+import { Command } from 'commander';
+import fs from 'fs-extra';
+import { shellExec, shellCd } from '../src/server/process.js';
+import { loggerFactory } from '../src/server/logger.js';
+import { DataBaseProvider } from '../src/db/DataBaseProvider.js';
+import {
+  pngDirectoryIteratorByObjectLayerType,
+  frameFactory,
+  getKeyFramesDirectionsFromNumberFolderDirection,
+  buildImgFromTile,
+  generateRandomStats,
+  itemTypes,
+} from '../src/server/object-layer.js';
+
+import crypto from 'crypto';
+
+shellCd(`/home/dd/engine`);
+
+const logger = loggerFactory(import.meta);
+
+const deployId = process.env.DEFAULT_DEPLOY_ID;
+const host = process.env.DEFAULT_DEPLOY_HOST;
+const path = process.env.DEFAULT_DEPLOY_PATH;
+
+const confServerPath = `./engine-private/conf/${deployId}/conf.server.json`;
+const confServer = JSON.parse(fs.readFileSync(confServerPath, 'utf8'));
+const { db } = confServer[host][path];
+
+db.host = db.host.replace('127.0.0.1', 'mongodb-0.mongodb-service');
+
+logger.info('env', {
+  deployId,
+  host,
+  path,
+  db,
+});
+
+await DataBaseProvider.load({
+  apis: ['object-layer'],
+  host,
+  path,
+  db,
+});
+
+const ObjectLayer = DataBaseProvider.instance[`${host}${path}`].mongoose.models.ObjectLayer;
+
+await ObjectLayer.deleteMany();
+
+const program = new Command();
+
+const version = JSON.parse(fs.readFileSync('./package.json', 'utf8')).version;
+
+program
+  .name('cyberia')
+  .description(
+    `    cyberia online network object layer management ${version}
+    https://www.cyberiaonline.com/object-layer-engine`,
+  )
+  .version(version);
+
+program
+  .command('ol')
+  .option('--import [object-layer-type]', 'Commas separated object layer types e.g. skin,floors')
+  .option('--show-frame <show-frame-input>', 'View object layer frame e.g. anon_08_0')
+  .option('--env-path <env-path>', 'Env path e.g. ./engine-private/conf/dd-cyberia/.env.development')
+  .action(async (options = { import: false, showFrame: '', envPath: '' }) => {
+    if (!options.envPath) options.envPath = `./engine-private/conf/dd-cyberia/.env.production`;
+
+    dotenv.config({ path: options.envPath, override: true });
+
+    const objectLayers = {};
+
+    if (options.import || options.showFrame) {
+      const argItemTypes = options.import === 'all' ? Object.keys(itemTypes) : options.import.split(',');
+      for (const argItemType of argItemTypes) {
+        await pngDirectoryIteratorByObjectLayerType(
+          argItemType,
+          async ({ path, objectLayerType, objectLayerId, direction, frame }) => {
+            if (options.showFrame && !`${objectLayerId}_${direction}_${frame}`.match(options.showFrame)) return;
+            console.log(path, { objectLayerType, objectLayerId, direction, frame });
+            if (!objectLayers[objectLayerId]) {
+              const metadataPath = `./src/client/public/cyberia/assets/${objectLayerType}/${objectLayerId}/metadata.json`;
+              const metadata = fs.existsSync(metadataPath) ? JSON.parse(fs.readFileSync(metadataPath, 'utf8')) : null;
+              objectLayers[objectLayerId] = metadata
+                ? metadata
+                : {
+                    data: {
+                      render: {
+                        frame_duration: 250,
+                        is_stateless: false,
+                      },
+                      item: {
+                        id: objectLayerId,
+                        type: objectLayerType,
+                        description: '',
+                        activable: true,
+                      },
+                      stats: generateRandomStats(),
+                    },
+                  };
+              objectLayers[objectLayerId].data.render.colors = [];
+              objectLayers[objectLayerId].data.render.frames = {};
+            }
+            const frameFactoryResult = await frameFactory(path, objectLayers[objectLayerId].data.render.colors);
+            objectLayers[objectLayerId].data.render.colors = frameFactoryResult.colors;
+            for (const objectLayerFrameDirection of getKeyFramesDirectionsFromNumberFolderDirection(direction)) {
+              if (!objectLayers[objectLayerId].data.render.frames[objectLayerFrameDirection])
+                objectLayers[objectLayerId].data.render.frames[objectLayerFrameDirection] = [];
+              objectLayers[objectLayerId].data.render.frames[objectLayerFrameDirection].push(frameFactoryResult.frame);
+            }
+          },
+        );
+      }
+      for (const objectLayerId of Object.keys(objectLayers)) {
+        objectLayers[objectLayerId].sha256 = crypto
+          .createHash('sha256')
+          .update(JSON.stringify(objectLayers[objectLayerId].data))
+          .digest('hex');
+        console.log(await ObjectLayer.create(objectLayers[objectLayerId]));
+      }
+    }
+    if (options.showFrame) {
+      const [objectLayerId, direction, frame] = options.showFrame.split('_');
+      const objectLayerFrameDirection = getKeyFramesDirectionsFromNumberFolderDirection(direction)[0];
+
+      await buildImgFromTile({
+        tile: {
+          map_color: objectLayers[objectLayerId].data.render.colors,
+          frame_matrix: objectLayers[objectLayerId].data.render.frames[objectLayerFrameDirection][0],
+        },
+        cellPixelDim: 20,
+        opacityFilter: (x, y, color) => 255,
+        imagePath: `./${options.showFrame}.png`,
+      });
+
+      shellExec(`firefox ./${options.showFrame}.png`);
+    }
+    await DataBaseProvider.instance[`${host}${path}`].mongoose.close();
+  })
+  .description('Object layer management');
+
+program.parse();

package/bin/ssl.js

@@ -0,0 +1,63 @@
+import fs from 'fs';
+import read from 'read';
+import dotenv from 'dotenv';
+import { getRootDirectory, pbcopy, shellExec } from '../src/server/process.js';
+import { loggerFactory } from '../src/server/logger.js';
+import { Cmd, loadConf } from '../src/server/conf.js';
+import { buildSSL } from '../src/server/ssl.js';
+
+dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+await logger.setUpInfo();
+
+const [exe, dir, deployId, hosts] = process.argv;
+
+try {
+  let cmd;
+  await loadConf(deployId);
+  shellExec(Cmd.conf(deployId));
+  const confServer = JSON.parse(fs.readFileSync(`./conf/conf.server.json`, 'utf8'));
+  for (const host of hosts.split(',')) {
+    if (host in confServer) {
+      const directory = confServer[host]['/']?.['directory'] ? confServer[host]['/']['directory'] : undefined;
+      cmd = `sudo certbot certonly --webroot --webroot-path ${
+        directory ? directory : `${getRootDirectory()}/public/${host}`
+      } --cert-name ${host} -d ${host}`;
+      // directory ? directory : `${getRootDirectory()}/public/${host}`
+      // directory ? directory : `${getRootDirectory()}/public/www.${host.split('.').slice(-2).join('.')}`
+
+      // You can get multi domain cert by specifying (extra) -d
+      // For example
+      // certbot -d example.com -d example.net -d www.example.org
+
+      // delete all file (no increment live folder)
+      // certbot delete --cert-name <domain>
+
+      logger.info(`Run the following command`, cmd);
+      try {
+        await pbcopy(cmd);
+        await read({ prompt: 'Command copy to clipboard, press enter to continue.\n' });
+      } catch (error) {
+        logger.error(error);
+      }
+      // Certificate
+      if (process.argv.includes('build')) await buildSSL(host);
+      logger.info('Certificate saved', host);
+    } else throw new Error(`host not found: ${host}`);
+  }
+  // check for renewal conf:
+  // /etc/letsencrypt/renewal
+  // /etc/letsencrypt/live
+  cmd = `sudo certbot renew --dry-run`;
+  try {
+    await pbcopy(cmd);
+  } catch (error) {
+    logger.error(error);
+  }
+  logger.info(`run the following command for renewal. Command copy to clipboard`, cmd);
+  logger.info(`success install SLL`, hosts);
+} catch (error) {
+  logger.error(error, error.stack);
+}

package/bin/util.js

@@ -0,0 +1,80 @@
+import fs from 'fs-extra';
+import si from 'systeminformation';
+import * as dir from 'path';
+
+import { loggerFactory } from '../src/server/logger.js';
+import { pbcopy } from '../src/server/process.js';
+import { buildKindPorts } from '../src/server/conf.js';
+
+const logger = loggerFactory(import.meta);
+
+logger.info('argv', process.argv);
+
+const operator = process.argv[2];
+
+try {
+  // let cmd;
+  switch (operator) {
+    case 'log':
+      console.log(fs.readFileSync(process.argv[3], 'utf8'));
+      break;
+
+    case 'system-info':
+      await (async () => {
+        for (const infoKey of Object.keys(si)) {
+          if (typeof si[infoKey] === 'function') {
+            //  'dockerInfo', 'vboxInfo'
+            if (!['osInfo', 'graphics', 'cpu'].includes(infoKey)) continue;
+            try {
+              const infoInstance = await si[infoKey]();
+              logger.info(infoKey, infoInstance);
+            } catch (error) {
+              logger.info('Not valid info function', infoKey);
+            }
+          }
+        }
+      })();
+      break;
+    case 'delete-empty-folder':
+      function cleanEmptyFoldersRecursively(folder) {
+        if (!fs.existsSync(folder)) {
+          logger.warn('Does not exist', folder);
+          return;
+        }
+        const isDir = fs.statSync(folder).isDirectory();
+        if (!isDir) return;
+
+        let files = fs.readdirSync(folder);
+        if (files.length > 0) {
+          files.forEach(function (file) {
+            const fullPath = dir.join(folder, file);
+            cleanEmptyFoldersRecursively(fullPath);
+          });
+
+          // re-evaluate files; after deleting subfolder
+          // we may have parent folder empty now
+          files = fs.readdirSync(folder);
+        }
+
+        if (files.length === 0) {
+          console.log('removing: ', folder);
+          try {
+            fs.rmdirSync(folder);
+          } catch (error) {
+            logger.error(error);
+          }
+          return;
+        }
+      }
+      cleanEmptyFoldersRecursively('./');
+      break;
+
+    case 'build-ports': {
+      pbcopy(buildKindPorts(process.argv[3], process.argv[4]));
+    }
+    default:
+      break;
+  }
+} catch (error) {
+  logger.error(error, error.stack);
+}

package/bin/vs.js

@@ -0,0 +1,74 @@
+import fs from 'fs-extra';
+import { shellExec } from '../src/server/process.js';
+import { loggerFactory } from '../src/server/logger.js';
+
+const logger = loggerFactory(import.meta);
+
+// const vsCodeRootPath = '/root/.vscode-root';
+// const vsProgram = 'code';
+
+const vsCodeRootPath = '/root/.windsurf';
+const vsProgram = 'windsurf';
+
+switch (process.argv[2]) {
+  case 'info': {
+    logger.info('Formatted', 'Ctrl shift I');
+    logger.info('Command', 'Ctrl shift P');
+    logger.info('Search', 'Ctrl shift F');
+    logger.info('Debug', 'Ctrl shift D');
+    logger.info('New File', 'Ctrl N');
+    logger.info('Change tab', 'Ctrl Tab');
+    logger.info('Fold All', 'Ctrl K + Ctrl 0');
+    logger.info('Unfold All', 'Ctrl K + Ctrl J');
+    logger.info('Close All tabs', 'Ctrl K + W');
+    logger.info('Go to line number', 'Ctrl G');
+    logger.info('Change current project folder', 'Ctrl K + Ctrl O');
+    logger.info('Open new vs windows', 'Ctrl Shift N');
+    logger.info('Close current vs windows', 'Ctrl Shift W');
+    logger.info('Preview md', 'Ctrl shift V');
+    logger.info('Open git changes', 'Ctrl G + G');
+    logger.warn('Terminal shortcut configure with command pallette', 'Ctl shift T');
+    break;
+  }
+  case 'import':
+    {
+      const extensions = JSON.parse(fs.readFileSync(`./.vscode/extensions.json`, 'utf8'));
+      extensions.recommendations.map((extension) => {
+        if (extension)
+          shellExec(
+            `sudo ${vsProgram} --user-data-dir="${vsCodeRootPath}" --no-sandbox --install-extension ${extension}`,
+          );
+      });
+    }
+    break;
+  case 'export':
+    {
+      shellExec(
+        `sudo ${vsProgram} --user-data-dir="${vsCodeRootPath}" --no-sandbox --list-extensions > vs-extensions.txt`,
+      );
+      fs.writeFileSync(
+        `./.vscode/extensions.json`,
+        JSON.stringify(
+          {
+            recommendations: fs
+              .readFileSync(`./vs-extensions.txt`, 'utf8')
+              .split(`\n`)
+              .filter((ext) => ext.trim()),
+          },
+          null,
+          4,
+        ),
+        'utf8',
+      );
+      fs.removeSync(`./vs-extensions.txt`);
+    }
+    break;
+
+  case 'clean': {
+    shellExec(`sudo rm -rf ${vsCodeRootPath}/*`);
+    break;
+  }
+  default:
+    shellExec(`sudo ${vsProgram} ${process.argv[2]} --user-data-dir="${vsCodeRootPath}" --no-sandbox`);
+    break;
+}