poad 2.5.4 → 2.5.6

package/0.txt

@@ -0,0 +1,16 @@
+docker run 
+  --platform=linux/amd64 
+  --rm 
+  -v ~/prj/omneedia/infra/aio/data:/data 
+  -e OMNEEDIA_GATEWAY_URL=http://localhost:8000 
+  -e DATA_VOLUME_MOUNTPOINT=/data 
+  -e POSTGRES_PASSWORD=dreams 
+  -p 5432:5432 
+  -p 8000:8000 
+  -e ADMIN_API_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlIjoic3VwYWJhc2VfYWRtaW4iLCJpc3MiOiJzdXBhYmFzZS1kZW1vIiwiaWF0IjoxNjQxNzY5MjAwLCJleHAiOjE3OTk1MzU2MDB9.Y9mSNVuTw2TdfryoaqM5wySvwQemGGWfSe9ixcklVfM 
+  -e JWT_SECRET=277e90e7515dbf46bf76ddabfbfa6fa04a11966f4e7550ef3330a31258c49be95944a87c97b725defb264dbb772567592b8a91849115dce1ece7b949a668900ac0738a8d0a89db4a48d77706474e4ea34d20134ac889b73f7ecd732b046bdce7b7367fb9f56638eed1db1bba916a5e674a472ed443d316127b6176a2a6066ca08bffd97ed47ef9f1cfe22c668afca3f7d0011352d113e4315803c35787a3c2bc16424ab02a88452ab7c04ad48143c11f2616c148f85461842afcf28295a0281281c69f2df6344476286425290f7721470c9f92576ece15f275feac53a3dd6763eb0d88bbcdc9391c64f62c4bf556c131f49a5de9de9e914f544c42a5ef33ca10 
+  -e ANON_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlIjoiYW5vbiIsImlhdCI6MTcyNjg2MTQ4OH0.fsIJu0uDoMBBxXnHuoXtMlwF4sGHxkFGkLpFDfKuV9g 
+  -e SERVICE_ROLE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyAgCiAgICAicm9sZSI6ICJzZXJ2aWNlX3JvbGUiLAogICAgImlzcyI6ICJzdXBhYmFzZS1kZW1vIiwKICAgICJpYXQiOiAxNjQxNzY5MjAwLAogICAgImV4cCI6IDE3OTk1MzU2MDAKfQ.DaYlNEoUrrEn2Ig7tqibS-PHK5vgusbcbo7X36XVt4Q 
+  poadio/engine 
+  &>data/service.log 
+  &

package/global/cli.js

@@ -0,0 +1,13 @@
+/**
+ *
+ * @label [BETA]
+ * @label [EXPERIMENTAL]
+ * @label [DOCKER]
+ * @label [AI]
+ *
+ */
+module.exports = {
+  install: `Install poad environment`,
+  init: `Init poad project`,
+  start: 'Start containers for poad local development',
+};

package/global/init.js

@@ -0,0 +1,42 @@
+module.exports = async (args) => {
+  const path = require('path');
+  const jwt = require('jsonwebtoken');
+  const { findFreePorts } = require('../utils/ports');
+  const { generateSecret } = require('../utils/jwtkey');
+  const json2toml = require('json2toml');
+  const fs = require('fs').promises;
+  const generateUniqueId = require('generate-unique-id');
+  const anon = {
+    role: 'anon',
+    iss: 'poad',
+  };
+  const service = {
+    role: 'service',
+    iss: 'poad',
+  };
+  const admin = {
+    role: 'admin',
+    iss: 'poad',
+  };
+  let config = {};
+  config.project_id = path.basename(process.cwd());
+  config.project_uuid = generateUniqueId();
+  await fs.mkdir(path.join(process.cwd(), 'poad', 'data'), { recursive: true });
+  const ports = await findFreePorts(3);
+  config.db = {
+    port: ports[0],
+  };
+  config.web = {
+    port: ports[1],
+  };
+  const key = generateSecret();
+  config.auth = {
+    jwt_expiry: 3600,
+    secret: key,
+    anon: jwt.sign(anon, key),
+    service: jwt.sign(service, key),
+    admin: jwt.sign(admin, key),
+  };
+  const toml = json2toml(config);
+  await fs.writeFile(path.join(process.cwd(), 'poad', 'config.toml'), toml);
+};

package/global/install.js

@@ -0,0 +1,49 @@
+module.exports = async (args) => {
+  const chalk = require('chalk');
+  const Docker = require('dockerode');
+  const cliProgress = require('cli-progress');
+
+  const docker = new Docker();
+  const imageName = 'poadio/engine:latest';
+  const platform = 'linux/amd64';
+
+  // Create a new progress bar
+  const progressBar = new cliProgress.SingleBar(
+    {},
+    cliProgress.Presets.shades_classic
+  );
+
+  console.log(chalk.bold('\nInstalling poad environment...'));
+
+  docker.pull(imageName, { platform }, (err, stream) => {
+    if (err) {
+      console.error('Error pulling image:', err);
+      return;
+    }
+
+    let downloadedSize = 0;
+    let totalSize = 0;
+
+    docker.modem.followProgress(stream, onFinished, onProgress);
+
+    function onProgress(event) {
+      if (event.progressDetail && event.progressDetail.total) {
+        if (totalSize === 0) {
+          totalSize = event.progressDetail.total;
+          progressBar.start(totalSize, 0);
+        }
+        downloadedSize = event.progressDetail.current;
+        progressBar.update(downloadedSize);
+      }
+    }
+
+    function onFinished(err, output) {
+      progressBar.stop();
+      if (err) {
+        console.error('Error:', err);
+      } else {
+        console.log(chalk.bold('poad environment installed successfully.'));
+      }
+    }
+  });
+};

package/global/start.js

@@ -0,0 +1,46 @@
+module.exports = async (args) => {
+  const Docker = require('dockerode');
+  const docker = new Docker();
+  const toml = require('toml');
+  const path = require('path');
+  const fs = require('fs').promises;
+  const { findPoadDir } = require('../utils/findpoad');
+  const root = findPoadDir(process.cwd());
+  const config = toml.parse(await fs.readFile(root, 'utf-8'));
+
+  const webPort = config.web.port;
+  const dbPort = config.db.port;
+
+  docker
+    .createContainer({
+      Image: 'poadio/engine',
+      Tty: false,
+      Env: [
+        'OMNEEDIA_GATEWAY_URL=http://localhost:' + config.web.port,
+        'DATA_VOLUME_MOUNTPOINT=/data',
+        'POSTGRES_PASSWORD=dreams',
+        'ADMIN_API_KEY=' + config.auth.admin,
+        'JWT_SECRET=' + config.auth.secret,
+        'ANON_KEY=' + config.auth.anon,
+        'SERVICE_ROLE_KEY=' + config.auth.service,
+      ],
+      HostConfig: {
+        PortBindings: {
+          '5432/tcp': [{ HostPort: config.db.port.toString() }],
+          '8000/tcp': [{ HostPort: config.web.port.toString() }],
+        },
+        Binds: [path.dirname(root) + '/data:/data'],
+        AutoRemove: true,
+      },
+      Platform: 'linux/amd64',
+    })
+    .then((container) => {
+      return container.start();
+    })
+    .then((container) => {
+      console.log('Container started successfully');
+    })
+    .catch((err) => {
+      console.error('Error:', err);
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poad",
-  "version": "2.5.4",
+  "version": "2.5.6",
   "main": "index.js",
   "license": "MIT",
   "bin": {
@@ -11,10 +11,14 @@
   },
   "dependencies": {
     "axios": "^1.7.7",
-    "box": "^0.0.4",
     "boxen": "^5.1.2",
     "chalk-v2": "^1.0.2",
+    "cli-progress": "^3.12.0",
+    "dockerode": "^4.0.2",
     "figlet": "^1.7.0",
+    "generate-unique-id": "^2.0.3",
+    "json2toml": "^6.1.1",
+    "jsonwebtoken": "^9.0.2",
     "log-beautify": "^1.2.0",
     "toml": "^3.0.0"
   }

package/poad.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+
+// import required modules
 const figlet = require('figlet');
 const chalk = require('chalk-v2');
 const fs = require('fs');
@@ -9,8 +11,13 @@ const os = require('os');
 const userHomeDir = os.homedir();
 const boxen = require('boxen');
 const axios = require('axios');
+const { parseArgs } = require('./utils/parseArgs');
+const { findPoadDir } = require('./utils/findpoad');
+
+const packageJsonPath = path.join(__dirname, 'package.json');
 
-const { version } = require('./package.json');
+const package = require(packageJsonPath);
+let args = process.argv.slice(2);
 
 // Function to check internet connection
 const checkInternetConnection = async () => {
@@ -22,31 +29,479 @@ const checkInternetConnection = async () => {
   }
 };
 
+// Locating the '.cadriciel' directory starting from the current working directory.
+const POAD_PATH = findPoadDir(process.cwd());
+const POAD_COMMAND = 'poad';
+const POAD_PERMALINK =
+  'https://raw.githubusercontent.com/poadio/permalink/refs/heads/main/poad.json';
+global.POAD_URI = '';
+
+// Path for version checking file.
+const VERSION_CHECK_FILE = path.join(userHomeDir, '.poad_last_check.json');
+const CACHE_FILE_PATH = path.join(userHomeDir, '.poad_cache.json');
+global.CACHE_URI = {};
+
+// Initialize command storage objects.
+var POAD_GLOBAL_COMMANDS = {};
+var POAD_COMMANDS = {};
+
+// Function to decide whether a version check is needed.
+const shouldCheckVersion = async () => {
+  try {
+    const data = fs.readFileSync(VERSION_CHECK_FILE, 'utf8');
+    const lastCheck = JSON.parse(data);
+    const lastCheckDate = new Date(lastCheck.date);
+    const diff = Date.now() - lastCheckDate.getTime();
+    const twelveHours = 12 * 60 * 60 * 1000;
+
+    return diff > twelveHours;
+  } catch (e) {
+    return true;
+  }
+};
+
+// Function to update the date of the last version check.
+const updateLastCheckDate = (version) => {
+  const data = JSON.stringify({ date: new Date(), version });
+  fs.writeFileSync(VERSION_CHECK_FILE, data, 'utf8');
+};
+
+// Function to check the current version of the package.
+const checkVersion = async () => {
+  if (!(await shouldCheckVersion())) {
+    let version = 0;
+    try {
+      version = JSON.parse(fs.readFileSync(VERSION_CHECK_FILE, 'utf8')).version;
+    } catch (e) {
+      version = 0;
+    }
+    return Promise.resolve(version);
+  }
+  return new Promise((resolve, reject) => {
+    const packageName = 'poad';
+    const child = spawn('npm', ['view', packageName, 'version'], {
+      shell: true,
+    });
+
+    let version = '';
+
+    child.stdout.on('data', (data) => {
+      version += data.toString();
+    });
+
+    child.stderr.on('data', (data) => {
+      console.error(`err: ${data}`);
+    });
+
+    child.on('error', (error) => {
+      console.error(`Erreur lors de l'exécution de npm view: ${error.message}`);
+      reject(error);
+    });
+
+    child.on('close', (code) => {
+      if (code !== 0) {
+        console.error(
+          `Le processus npm view s'est terminé avec le code ${code}`
+        );
+        return reject(
+          new Error('Erreur lors de la récupération de la version')
+        );
+      }
+
+      version = version.trim();
+      updateLastCheckDate(version);
+      resolve(version);
+    });
+  });
+};
+
+// Function to display the banner and the list of commands.
+const displayBanner = () => {
+  figlet('poad', function (err, data) {
+    console.log(chalk.cyan(data));
+    console.log(chalk.white.bold(`             version ${package.version}`));
+    console.log(' ');
+    console.log(
+      `${chalk.bold(' Usage :')} ${chalk.cyanBright(
+        POAD_COMMAND + ' <command>'
+      )} ${chalk.cyan('[<args>]')}`
+    );
+    console.log(' ');
+    console.log(chalk.bold(' Global commands :'));
+    console.log(' ');
+    display(POAD_GLOBAL_COMMANDS);
+    console.log(' ');
+    console.log(chalk.bold(' Project commands :'));
+    if (!POAD_PATH) {
+      console.log(`\n   You are not in a project directory.     `);
+      console.log(' ');
+    } else {
+      POAD_COMMANDS = loadPoadCommands(__dirname + '/project/cli.js');
+      console.log(' ');
+      display(POAD_COMMANDS);
+      console.log(' ');
+    }
+    console.log(' ');
+  });
+};
+
+// Function to load project specific commands.
+const loadPoadCommands = (path) => {
+  let POAD_COMMANDS = {};
+  try {
+    const cli = require(path);
+    for (let el in cli) {
+      if (cli[el].description) {
+        let subs = [];
+        for (let s in cli[el]) {
+          if (s !== 'description') subs.push({ title: s });
+        }
+        let description = '';
+        if (cli[el].description.indexOf(']') > -1) {
+          description = cli[el].description.split('] ')[1];
+          let lbl = cli[el].description
+            .split('] ')[0]
+            .replace('[', '')
+            .replace(']', '');
+          POAD_COMMANDS[el] = {
+            info: {
+              title: el,
+              description: description,
+              label: lbl.toLowerCase(),
+              sub: subs,
+            },
+          };
+        } else {
+          description = cli[el].description;
+          POAD_COMMANDS[el] = {
+            info: {
+              title: el,
+              description: cli[el].description,
+              sub: subs,
+            },
+          };
+        }
+      } else {
+        let description = '';
+        if (cli[el].indexOf(']') > -1) {
+          description = cli[el].split('] ')[1];
+          let lbl = cli[el].split('] ')[0].replace('[', '').replace(']', '');
+          POAD_COMMANDS[el] = {
+            info: {
+              title: el,
+              description: description,
+              label: lbl.toLowerCase(),
+            },
+          };
+        } else {
+          description = cli[el];
+          POAD_COMMANDS[el] = {
+            info: {
+              title: el,
+              description: description,
+            },
+          };
+        }
+      }
+    }
+    return POAD_COMMANDS;
+  } catch (e) {
+    console.log(e);
+  }
+};
+
 /**
- * Recursively searches for the '.cadriciel' directory.
- * @param {string} startPath - Starting path for the search.
- * @returns {string|null} Path of the found directory or null.
+ * Displays the subcommands and their descriptions for a given command.
+ *
+ * @param {string} path - The path of the command.
+ * @param {string} title - The title of the command.
+ * @param {string} description - The description of the command.
+ * @param {object} cli - The command line interface object.
  */
-function findCadricielDir(startPath) {
-  let currentPath = startPath;
+const displaySub = (path, title, description, cli) => {
+  POAD_COMMANDS = {};
+  delete cli.description;
+  for (let el in cli) {
+    if (cli[el].description) {
+      let subs = [];
+      for (let s in cli[el]) {
+        if (s !== 'description') subs.push({ title: s });
+      }
+      let description = '';
+      if (cli[el].description.indexOf(']') > -1) {
+        description = cli[el].description.split('] ')[1];
+        let lbl = cli[el].description
+          .split('] ')[0]
+          .replace('[', '')
+          .replace(']', '');
+        POAD_COMMANDS[el] = {
+          info: {
+            title: el,
+            description: description,
+            label: lbl.toLowerCase(),
+            sub: subs,
+          },
+        };
+      } else {
+        description = cli[el].description;
+        POAD_COMMANDS[el] = {
+          info: {
+            title: el,
+            description: cli[el].description,
+            sub: subs,
+          },
+        };
+      }
+    } else {
+      let description = '';
+      if (cli[el].indexOf(']') > -1) {
+        description = cli[el].split('] ')[1];
+        let lbl = cli[el].split('] ')[0].replace('[', '').replace(']', '');
+        POAD_COMMANDS[el] = {
+          info: {
+            title: el,
+            description: description,
+            label: lbl.toLowerCase(),
+          },
+        };
+      } else {
+        POAD_COMMANDS[el] = {
+          info: {
+            title: el,
+            description: cli[el],
+          },
+        };
+      }
+    }
+  }
+
+  console.log(
+    `${chalk.bold(' Usage :')} ${chalk.cyanBright(
+      POAD_COMMAND + ' ' + args.join(' ')
+    )} ${chalk.cyan('[<args>]')}`
+  );
+  console.log(' ');
+  display(POAD_COMMANDS);
+  console.log(' ');
+};
 
-  while (currentPath !== path.parse(currentPath).root) {
-    const potentialPath = path.join(currentPath, '.cadriciel/cli');
-    if (
-      fs.existsSync(potentialPath) &&
-      fs.statSync(potentialPath).isDirectory()
-    ) {
-      return potentialPath;
+// Function to parse commands.
+const parseCommand = (args) => {
+  const cli = require(__dirname + '/project/cli');
+  let cmd = cli;
+  let arguments = [];
+  let title = '';
+  let path = '';
+  for (let i = 0; i < args.length; i++) {
+    if (!cmd[args[i]]) arguments.push(args[i]);
+    else {
+      cmd = cmd[args[i]];
+      title = args[i];
+      path += ' ' + title;
     }
-    currentPath = path.dirname(currentPath); // Monter vers le répertoire parent.
   }
+  if (cmd.description) displaySub(path, title, cmd.description, cmd);
+  else {
+    ExecCommand(path.replace(/ /g, '/'), arguments);
+  }
+};
 
-  return null;
-}
+/**
+ * Fonction qui vérifie si un chemin existe dans un objet donné
+ * @param {object} obj - L'objet dans lequel chercher
+ * @param {Array} pathArray - Le tableau représentant le chemin
+ * @returns {*} - L'objet ou la valeur si le chemin existe, sinon null
+ */
+const getPathInObject = (obj, pathArray) => {
+  return pathArray.reduce((acc, key) => {
+    if (acc && acc[key]) {
+      return acc[key];
+    } else {
+      return null;
+    }
+  }, obj);
+};
 
-// Locating the '.cadriciel' directory starting from the current working directory.
-const CADRICIEL_PATH = findCadricielDir(process.cwd());
-const CADRICIEL_COMMAND = 'oa';
-const CADRICIEL_PERMALINK =
-  'https://gist.githubusercontent.com/zucatti/08b37516b23c08028a2b07694f0329b6/raw/cadriciel-url.json';
-global.CADRICIEL_URI = '';
+/**
+ * Fonction pour construire un chemin valide dans l'objet de commandes
+ * et séparer les arguments complémentaires
+ * @param {object} commands - L'objet contenant les commandes
+ * @param {Array} args - Le tableau d'arguments de la commande
+ * @returns {object} - Un objet avec dir (le chemin) et args (les arguments complémentaires)
+ */
+const parseCommandArgs = (commands, args) => {
+  let dir = []; // Stocke les parties valides du chemin
+  let complementaryArgs = []; // Stocke les arguments complémentaires
+  let currentCommands = commands; // Commence à la racine des commandes
+
+  for (let i = 0; i < args.length; i++) {
+    const currentPath = args[i];
+    if (currentCommands[currentPath]) {
+      // Si le chemin est valide, ajoute à dir et descend dans la structure
+      dir.push(currentPath);
+      currentCommands = currentCommands[currentPath];
+    } else {
+      // Dès que le chemin n'existe plus, on considère le reste comme des arguments complémentaires
+      complementaryArgs = args.slice(i);
+      break;
+    }
+  }
+
+  return {
+    dir: dir.join('/'), // Concatène le chemin avec des "/"
+    args: complementaryArgs, // Arguments supplémentaires
+  };
+};
+
+// Function to process entered commands.
+const processCommands = (args) => {
+  const command = args[0];
+  const maxWidth = 30;
+  const maxDescriptionLength = 50;
+
+  POAD_COMMANDS = loadPoadCommands(__dirname + '/project/cli.js');
+
+  if (POAD_GLOBAL_COMMANDS[command]) {
+    const px = parseCommandArgs(require(__dirname + '/global/cli'), args);
+    const unit = require(path.join(__dirname, 'global', px.dir));
+    unit(parseArgs(px.args));
+  } else {
+    if (POAD_COMMANDS[command]) {
+      console.log(' ');
+
+      const dir = args.join('/');
+      const px = parseCommandArgs(require(__dirname + '/project/cli'), args);
+
+      const unit = require(path.join(__dirname, 'project', px.dir));
+      return unit(parseArgs(px.args));
+    } else {
+      log.error('Unknown command : ' + command);
+      return displayBanner();
+    }
+  }
+};
+
+// Function to format command labels with chalk for color coding.
+const label = (o) => {
+  const caption = o.label;
+
+  if (caption === 'experimental') return chalk.red(' (' + caption + ')');
+  if (caption === 'alpha') return chalk.cyan(' (' + caption + ')');
+  if (caption === 'beta') return chalk.magenta(' (' + caption + ')');
+  if (caption === 'docker') return chalk.green(' (' + caption + ')');
+  if (caption === 'ai') return chalk.yellow(' (' + caption.toUpperCase() + ')');
+  return '';
+};
+
+// Function to execute commands.
+const ExecCommand = (p, args) => {
+  console.log(p, args);
+  const unit = require(__dirname + p);
+  const params = {
+    dir: {
+      home: `${userHomeDir}/.cadriciel`,
+      cadriciel: path.normalize(CADRICIEL_PATH + '/..'),
+      root: path.normalize(CADRICIEL_PATH + '/../..'),
+    },
+  };
+  unit(args, params);
+};
+
+// Function to format command descriptions.
+const formatDescription = (description, maxLength) => {
+  if (description.length <= maxLength) return description;
+
+  const breakPoint = description.lastIndexOf(' ', maxLength);
+  const firstPart = description.substring(0, breakPoint);
+  const secondPart = description.substring(breakPoint + 1).trim();
+
+  return firstPart + '\n                                    ' + secondPart;
+};
+
+// Function to display commands.
+const display = (commands) => {
+  const maxWidth = 30;
+  const maxDescriptionLength = 50;
+
+  for (let el in commands) {
+    let title = el;
+    if (commands[el].info.title != '---') {
+      if (commands[el].info) {
+        let description = commands[el].info.description;
+        if (commands[el].info.sub) {
+          title += ' <subcommand>';
+          const sc = [];
+          for (let i = 0; i < commands[el].info.sub.length; i++) {
+            sc.push(commands[el].info.sub[i].title);
+          }
+          description += chalk.white(' ');
+          description += chalk.grey(' (subcommands: ');
+          description += chalk.cyan(sc.join(', '));
+          description += chalk.grey(')');
+        }
+        const dots = '.'.repeat(maxWidth - title.length);
+
+        const formattedDesc = formatDescription(
+          description,
+          maxDescriptionLength
+        );
+
+        console.log(
+          '   ' +
+            chalk.cyanBright(title) +
+            ' ' +
+            chalk.grey(dots) +
+            ' ' +
+            label(commands[el].info) +
+            ' ' +
+            chalk.white(formattedDesc)
+        );
+      }
+    }
+  }
+};
+
+// Main function.
+const main = async () => {
+  let version = await checkVersion();
+  const current_version = require(__dirname + '/package.json').version;
+
+  if (version === null) {
+    version = current_version;
+  }
+  if (current_version != version) {
+    const message =
+      `A new version (${version}) is available. You can upgrade by running:\n` +
+      chalk.white.bold(`npm i -g poad@${version}`);
+
+    // Options pour le cadre
+    const boxenOptions = {
+      padding: 1,
+      margin: 1,
+      borderColor: 'yellow',
+      borderStyle: 'double',
+    };
+
+    // Mise en forme du message avec Chalk
+    const styledMessage = chalk.yellow(message);
+
+    // Création de l'encadré avec Boxen
+    const framedMessage = boxen(styledMessage, boxenOptions);
+
+    console.log(framedMessage);
+
+    POAD_GLOBAL_COMMANDS = loadPoadCommands(__dirname + '/global/cli.js');
+    process.argv.shift();
+    process.argv.shift();
+    if (process.argv.length <= 0) return displayBanner();
+    processCommands(process.argv);
+  } else {
+    POAD_GLOBAL_COMMANDS = loadPoadCommands(__dirname + '/global/cli.js');
+    process.argv.shift();
+    process.argv.shift();
+    if (process.argv.length <= 0) return displayBanner();
+    processCommands(process.argv);
+  }
+};
+
+main();

package/project/cli.js

@@ -0,0 +1,53 @@
+/**
+ *
+ * @label [BETA]
+ * @label [EXPERIMENTAL]
+ * @label [DOCKER]
+ * @label [AI]
+ *
+ */
+module.exports = {
+  info: `Information about your project`,
+  /*  status: `[AI] Vérification du statut de l'environnement`,
+  gen: {
+    description: 'Génération automatique des éléments clés pour votre projet',
+    db: {
+      description: `Utilitaires base de données`,
+      create: `[AI] Aide à la création de tables`,
+      ext: 'Gestion des extensions Postgres',
+      import: 'Importation de données',
+      models: 'Génération des modèles Client/Serveur',
+      query: '[AI] Aide à la génération de requêtes',
+      snapshot: '[BETA] Crée un snapshot de la base de données',
+      sql: '[EXPERIMENTAL] Création de repository à partir de SQL',
+    },
+    api: `Génération des API`,
+    component: `Génération de composant angular`,
+    page: `Génération de pages angular`,
+    project: `Gestion de projet`,
+    service: `Génération de services angular`,
+  },
+  logs: 'Affichage des logs des services',
+  project: {
+    description: 'Gestion de votre projet (mise à jour,logo) ',
+    api: `Génération des API`,
+  },
+  reset: "Arrête l'environnement et supprime les données",
+  restart: "Redémarrage d'un service particulier",
+  rm: {
+    description: `Suppression automatique des éléments clés pour votre projet`,
+    api: `Suppression d'une API`,
+    component: `Suppression de composant angular`,
+    db: {
+      description: `Suppression de base de données`,
+      ext: 'Suppression des extensions Postgres',
+      models: 'Suppression des modèles Client/Serveur',
+    },
+    page: `Suppression de pages angular`,
+    project: `Suppression de projet`,
+    service: `Suppression de services angular`,
+  },
+  start: "Démarrage de l'environnement",
+  stop: "Arrête l'environnement",
+  upgrade: `Mise à jour du runtime du cadriciel`,*/
+};

package/project/init.js

@@ -0,0 +1,9 @@
+module.exports = (args) => {
+  return {
+    info: {
+      title: 'init',
+      description: `Démarrage d'un projet poad.`,
+    },
+    start: async () => {},
+  };
+};

package/project/rm/api.js

@@ -0,0 +1,3 @@
+module.exports = async (args) => {
+  console.log(args);
+};

package/utils/findpoad.js

@@ -0,0 +1,23 @@
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * Recursively searches for the '.cadriciel' directory.
+ * @param {string} startPath - Starting path for the search.
+ * @returns {string|null} Path of the found directory or null.
+ */
+function findPoadDir(startPath) {
+  let currentPath = startPath;
+
+  while (currentPath !== path.parse(currentPath).root) {
+    const potentialPath = path.join(currentPath, 'poad', 'config.toml');
+    if (fs.existsSync(potentialPath)) {
+      return potentialPath;
+    }
+    currentPath = path.dirname(currentPath); // Monter vers le répertoire parent.
+  }
+
+  return null;
+}
+
+module.exports = { findPoadDir };

package/utils/jwtkey.js

@@ -0,0 +1,13 @@
+const crypto = require('crypto');
+
+/**
+ * Generate a secret key in hexadecimal format for signing a JWT
+ * @param {number} length - Length of the secret in bytes (default is 32 bytes)
+ * @returns {string} - Hexadecimal representation of the secret key
+ */
+const generateSecret = (length = 32) => {
+  // Generate random bytes and convert them to hexadecimal format
+  return crypto.randomBytes(length).toString('hex');
+};
+
+module.exports = { generateSecret };

package/utils/parseArgs.js

@@ -0,0 +1,35 @@
+/**
+ * Fonction pour parser une liste d'arguments en un objet clé-valeur
+ * @param {Array} args - Le tableau des arguments à parser
+ * @returns {object} - Un objet contenant les arguments parsés
+ */
+const parseArgs = (args) => {
+  const result = {};
+
+  args.forEach((arg) => {
+    // Vérifie si l'argument est sous forme clé=valeur
+    if (arg.includes('=')) {
+      const [key, value] = arg.split('=');
+
+      // Tente de convertir la valeur en nombre ou booléen si applicable, sinon garde-la en tant que chaîne
+      let parsedValue = value;
+      if (!isNaN(value)) {
+        parsedValue = Number(value); // Convertit en nombre si possible
+      } else if (
+        value.toLowerCase() === 'true' ||
+        value.toLowerCase() === 'false'
+      ) {
+        parsedValue = value.toLowerCase() === 'true'; // Convertit en booléen
+      }
+
+      result[key] = parsedValue;
+    } else {
+      // Si l'argument est un drapeau simple (par exemple 'x'), on le met à true
+      result[arg] = true;
+    }
+  });
+
+  return result;
+};
+
+module.exports = { parseArgs };

package/utils/ports.js

@@ -0,0 +1,59 @@
+const net = require('net');
+
+/**
+ * Check if a specific port is free
+ * @param {number} port
+ * @returns {Promise<boolean>}
+ */
+const isPortFree = (port) => {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+
+    server.once('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        resolve(false); // Port is in use
+      } else {
+        reject(err); // Unexpected error
+      }
+    });
+
+    server.once('listening', () => {
+      server.close(() => resolve(true)); // Port is free
+    });
+
+    server.listen(port);
+  });
+};
+
+/**
+ * Generate a random port within a specified range
+ * @param {number} min - Minimum port number
+ * @param {number} max - Maximum port number
+ * @returns {number}
+ */
+const getRandomPort = (min = 1024, max = 65535) => {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+
+/**
+ * Find a list of free ports, using randomized port numbers
+ * @param {number} count - Number of free ports to find
+ * @param {number} minPort - Minimum port number for randomization
+ * @param {number} maxPort - Maximum port number for randomization
+ * @returns {Promise<number[]>}
+ */
+const findFreePorts = async (count, minPort = 1024, maxPort = 65535) => {
+  const freePorts = new Set(); // Use a Set to avoid duplicate ports
+
+  while (freePorts.size < count) {
+    const port = getRandomPort(minPort, maxPort);
+
+    if (await isPortFree(port)) {
+      freePorts.add(port); // Add only if the port is free
+    }
+  }
+
+  return Array.from(freePorts);
+};
+
+module.exports = { findFreePorts };