theus-cli-linux-x64 0.2.84

package/vendor/theus-arsenal/scripts/lib/package-manager.js

@@ -0,0 +1,434 @@
+/**
+ * Detección y selección del gestor de paquetes
+ * Detecta automáticamente el gestor de paquetes preferido o permite elegirlo
+ *
+ * Soporta: npm, pnpm, yarn, bun
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { commandExists, getTheusDir, readFile, writeFile } = require('./utils');
+
+// Definiciones de gestores de paquetes
+const PACKAGE_MANAGERS = {
+  npm: {
+    name: 'npm',
+    lockFile: 'package-lock.json',
+    installCmd: 'npm install',
+    runCmd: 'npm run',
+    execCmd: 'npx',
+    testCmd: 'npm test',
+    buildCmd: 'npm run build',
+    devCmd: 'npm run dev'
+  },
+  pnpm: {
+    name: 'pnpm',
+    lockFile: 'pnpm-lock.yaml',
+    installCmd: 'pnpm install',
+    runCmd: 'pnpm',
+    execCmd: 'pnpm dlx',
+    testCmd: 'pnpm test',
+    buildCmd: 'pnpm build',
+    devCmd: 'pnpm dev'
+  },
+  yarn: {
+    name: 'yarn',
+    lockFile: 'yarn.lock',
+    installCmd: 'yarn',
+    runCmd: 'yarn',
+    execCmd: 'yarn dlx',
+    testCmd: 'yarn test',
+    buildCmd: 'yarn build',
+    devCmd: 'yarn dev'
+  },
+  bun: {
+    name: 'bun',
+    lockFile: 'bun.lockb',
+    installCmd: 'bun install',
+    runCmd: 'bun run',
+    execCmd: 'bunx',
+    testCmd: 'bun test',
+    buildCmd: 'bun run build',
+    devCmd: 'bun run dev'
+  }
+};
+
+// Orden de prioridad para la detección
+const DETECTION_PRIORITY = ['pnpm', 'bun', 'yarn', 'npm'];
+
+// Ruta del archivo de configuración
+function getConfigPath() {
+  return path.join(getTheusDir(), 'package-manager.json');
+}
+
+/**
+ * Carga la configuración guardada del gestor de paquetes
+ */
+function loadConfig() {
+  const configPath = getConfigPath();
+  const content = readFile(configPath);
+
+  if (content) {
+    try {
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+/**
+ * Guarda la configuración del gestor de paquetes
+ */
+function saveConfig(config) {
+  const configPath = getConfigPath();
+  writeFile(configPath, JSON.stringify(config, null, 2));
+}
+
+/**
+ * Detecta el gestor de paquetes a partir del lock file en el directorio del proyecto
+ */
+function detectFromLockFile(projectDir = process.cwd()) {
+  for (const pmName of DETECTION_PRIORITY) {
+    const pm = PACKAGE_MANAGERS[pmName];
+    const lockFilePath = path.join(projectDir, pm.lockFile);
+
+    if (fs.existsSync(lockFilePath)) {
+      return pmName;
+    }
+  }
+  return null;
+}
+
+/**
+ * Detecta el gestor de paquetes a partir del campo packageManager de package.json
+ */
+function detectFromPackageJson(projectDir = process.cwd()) {
+  const packageJsonPath = path.join(projectDir, 'package.json');
+  const content = readFile(packageJsonPath);
+
+  if (content) {
+    try {
+      const pkg = JSON.parse(content);
+      if (pkg.packageManager) {
+        // Formato: "pnpm@8.6.0" o simplemente "pnpm"
+        const pmName = pkg.packageManager.split('@')[0];
+        if (PACKAGE_MANAGERS[pmName]) {
+          return pmName;
+        }
+      }
+    } catch {
+      // package.json inválido
+    }
+  }
+  return null;
+}
+
+/**
+ * Obtiene los gestores de paquetes disponibles (instalados en el sistema)
+ *
+ * ADVERTENCIA: esta función lanza procesos hijo (where.exe en Windows, which
+ * en Unix) por cada gestor de paquetes. NO la llames durante los hooks de
+ * inicio de sesión: puede exceder el límite de spawns de Bun en Windows y
+ * congelar el plugin. Usa detectFromLockFile() o detectFromPackageJson()
+ * en las rutas calientes.
+ */
+function getAvailablePackageManagers() {
+  const available = [];
+
+  for (const pmName of Object.keys(PACKAGE_MANAGERS)) {
+    if (commandExists(pmName)) {
+      available.push(pmName);
+    }
+  }
+
+  return available;
+}
+
+/**
+ * Obtiene el gestor de paquetes a usar para el proyecto actual
+ *
+ * Prioridad de detección:
+ * 1. Variable de entorno THEUS_PACKAGE_MANAGER
+ * 2. Configuración específica del proyecto (en .theus/package-manager.json)
+ * 3. Campo packageManager de package.json
+ * 4. Detección por lock file
+ * 5. Preferencia global del usuario (package-manager.json en el directorio de datos de Theus)
+ * 6. npm por defecto (sin lanzar procesos hijo)
+ *
+ * @param {object} options - Opciones
+ * @param {string} options.projectDir - Directorio del proyecto donde detectar (por defecto: cwd)
+ * @returns {object} - { name, config, source }
+ */
+function getPackageManager(options = {}) {
+  const { projectDir = process.cwd() } = options;
+
+  // 1. Revisa la variable de entorno
+  const envPm = process.env.THEUS_PACKAGE_MANAGER;
+  if (envPm && PACKAGE_MANAGERS[envPm]) {
+    return {
+      name: envPm,
+      config: PACKAGE_MANAGERS[envPm],
+      source: 'environment'
+    };
+  }
+
+  // 2. Revisa la configuración específica del proyecto
+  const projectConfigPath = path.join(projectDir, '.theus', 'package-manager.json');
+  const projectConfig = readFile(projectConfigPath);
+  if (projectConfig) {
+    try {
+      const config = JSON.parse(projectConfig);
+      if (config.packageManager && PACKAGE_MANAGERS[config.packageManager]) {
+        return {
+          name: config.packageManager,
+          config: PACKAGE_MANAGERS[config.packageManager],
+          source: 'project-config'
+        };
+      }
+    } catch {
+      // Configuración inválida
+    }
+  }
+
+  // 3. Revisa el campo packageManager de package.json
+  const fromPackageJson = detectFromPackageJson(projectDir);
+  if (fromPackageJson) {
+    return {
+      name: fromPackageJson,
+      config: PACKAGE_MANAGERS[fromPackageJson],
+      source: 'package.json'
+    };
+  }
+
+  // 4. Revisa el lock file
+  const fromLockFile = detectFromLockFile(projectDir);
+  if (fromLockFile) {
+    return {
+      name: fromLockFile,
+      config: PACKAGE_MANAGERS[fromLockFile],
+      source: 'lock-file'
+    };
+  }
+
+  // 5. Revisa la preferencia global del usuario
+  const globalConfig = loadConfig();
+  if (globalConfig && globalConfig.packageManager && PACKAGE_MANAGERS[globalConfig.packageManager]) {
+    return {
+      name: globalConfig.packageManager,
+      config: PACKAGE_MANAGERS[globalConfig.packageManager],
+      source: 'global-config'
+    };
+  }
+
+  // 6. npm por defecto (siempre disponible con Node.js)
+  // NOTA: antes esto llamaba a getAvailablePackageManagers(), que lanza
+  // procesos hijo (where.exe/which) por cada gestor. Eso congelaba el plugin
+  // en Windows porque los hooks de inicio de sesión corren durante el
+  // arranque de Bun y los procesos lanzados exceden su límite de spawns.
+  // Los pasos 1-5 ya cubren toda la detección por configuración y archivos.
+  // Si ninguno coincidió, npm es el valor por defecto seguro.
+  return {
+    name: 'npm',
+    config: PACKAGE_MANAGERS.npm,
+    source: 'default'
+  };
+}
+
+/**
+ * Establece el gestor de paquetes preferido del usuario (global)
+ */
+function setPreferredPackageManager(pmName) {
+  if (!PACKAGE_MANAGERS[pmName]) {
+    throw new Error(`Gestor de paquetes desconocido: ${pmName}`);
+  }
+
+  const config = loadConfig() || {};
+  config.packageManager = pmName;
+  config.setAt = new Date().toISOString();
+
+  try {
+    saveConfig(config);
+  } catch (err) {
+    throw new Error(`No se pudo guardar la preferencia de gestor de paquetes: ${err.message}`);
+  }
+
+  return config;
+}
+
+/**
+ * Establece el gestor de paquetes preferido del proyecto
+ */
+function setProjectPackageManager(pmName, projectDir = process.cwd()) {
+  if (!PACKAGE_MANAGERS[pmName]) {
+    throw new Error(`Gestor de paquetes desconocido: ${pmName}`);
+  }
+
+  const configDir = path.join(projectDir, '.theus');
+  const configPath = path.join(configDir, 'package-manager.json');
+
+  const config = {
+    packageManager: pmName,
+    setAt: new Date().toISOString()
+  };
+
+  try {
+    writeFile(configPath, JSON.stringify(config, null, 2));
+  } catch (err) {
+    throw new Error(`No se pudo guardar la configuración del gestor de paquetes en ${configPath}: ${err.message}`);
+  }
+  return config;
+}
+
+// Caracteres permitidos en nombres de scripts/binarios: alfanuméricos, guion,
+// guion bajo, punto, barra y @. Esto previene la inyección de metacaracteres
+// de shell sin impedir paquetes con scope (p. ej., @scope/pkg)
+const SAFE_NAME_REGEX = /^[@a-zA-Z0-9_./-]+$/;
+
+/**
+ * Obtiene el comando para ejecutar un script
+ * @param {string} script - Nombre del script (p. ej., "dev", "build", "test")
+ * @param {object} options - { projectDir }
+ * @throws {Error} Si el nombre del script contiene caracteres no seguros
+ */
+function getRunCommand(script, options = {}) {
+  if (!script || typeof script !== 'string') {
+    throw new Error('El nombre del script debe ser una cadena no vacía');
+  }
+  if (!SAFE_NAME_REGEX.test(script)) {
+    throw new Error(`El nombre del script contiene caracteres no seguros: ${script}`);
+  }
+
+  const pm = getPackageManager(options);
+
+  switch (script) {
+    case 'install':
+      return pm.config.installCmd;
+    case 'test':
+      return pm.config.testCmd;
+    case 'build':
+      return pm.config.buildCmd;
+    case 'dev':
+      return pm.config.devCmd;
+    default:
+      return `${pm.config.runCmd} ${script}`;
+  }
+}
+
+// Caracteres permitidos en argumentos: alfanuméricos, espacios, guiones, puntos,
+// barras, igual, dos puntos, comas, comillas, @. Rechaza metacaracteres de shell
+// como ; | & ` $ ( ) { } < > !
+const SAFE_ARGS_REGEX = /^[@a-zA-Z0-9\s_./:=,'"*+-]+$/;
+
+/**
+ * Obtiene el comando para ejecutar el binario de un paquete
+ * @param {string} binary - Nombre del binario (p. ej., "prettier", "eslint")
+ * @param {string} args - Argumentos a pasar
+ * @throws {Error} Si el nombre del binario o los argumentos contienen caracteres no seguros
+ */
+function getExecCommand(binary, args = '', options = {}) {
+  if (!binary || typeof binary !== 'string') {
+    throw new Error('El nombre del binario debe ser una cadena no vacía');
+  }
+  if (!SAFE_NAME_REGEX.test(binary)) {
+    throw new Error(`El nombre del binario contiene caracteres no seguros: ${binary}`);
+  }
+  if (args && typeof args === 'string' && !SAFE_ARGS_REGEX.test(args)) {
+    throw new Error(`Los argumentos contienen caracteres no seguros: ${args}`);
+  }
+
+  const pm = getPackageManager(options);
+  return `${pm.config.execCmd} ${binary}${args ? ' ' + args : ''}`;
+}
+
+/**
+ * Mensaje interactivo para la selección del gestor de paquetes
+ * Devuelve un mensaje para que el agente lo muestre al usuario
+ *
+ * NOTA: NO lanza procesos hijo para comprobar disponibilidad.
+ * Lista todos los gestores soportados y explica cómo configurar la preferencia.
+ */
+function getSelectionPrompt() {
+  let message = '[PackageManager] No se detectó una preferencia de gestor de paquetes.\n';
+  message += 'Gestores de paquetes soportados: ' + Object.keys(PACKAGE_MANAGERS).join(', ') + '\n';
+  message += '\nPara establecer tu gestor de paquetes preferido:\n';
+  message += '  - Global: define la variable de entorno THEUS_PACKAGE_MANAGER\n';
+  message += '  - O agrega a package-manager.json en el directorio de datos de Theus: {"packageManager": "pnpm"}\n';
+  message += '  - O agrega a package.json: {"packageManager": "pnpm@8"}\n';
+  message += '  - O agrega un lock file a tu proyecto (p. ej., pnpm-lock.yaml)\n';
+
+  return message;
+}
+
+// Escapa los metacaracteres de regex de una cadena antes de interpolarla en un patrón
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Genera un patrón regex que coincide con los comandos de todos los gestores de paquetes
+ * @param {string} action - Patrón de acción (p. ej., "run dev", "install", "test")
+ */
+function getCommandPattern(action) {
+  const patterns = [];
+
+  // Recorta espacios de la acción para tolerar espacios al inicio/final
+  const trimmedAction = action.trim();
+
+  if (trimmedAction === 'dev') {
+    patterns.push(
+      'npm run dev',
+      'pnpm( run)? dev',
+      'yarn dev',
+      'bun run dev'
+    );
+  } else if (trimmedAction === 'install') {
+    patterns.push(
+      'npm install',
+      'pnpm install',
+      'yarn( install)?',
+      'bun install'
+    );
+  } else if (trimmedAction === 'test') {
+    patterns.push(
+      'npm test',
+      'pnpm test',
+      'yarn test',
+      'bun test'
+    );
+  } else if (trimmedAction === 'build') {
+    patterns.push(
+      'npm run build',
+      'pnpm( run)? build',
+      'yarn build',
+      'bun run build'
+    );
+  } else {
+    // Comando run genérico — escapa los metacaracteres de regex en la acción
+    const escaped = escapeRegex(trimmedAction);
+    patterns.push(
+      `npm run ${escaped}`,
+      `pnpm( run)? ${escaped}`,
+      `yarn ${escaped}`,
+      `bun run ${escaped}`
+    );
+  }
+
+  return `(${patterns.join('|')})`;
+}
+
+module.exports = {
+  PACKAGE_MANAGERS,
+  DETECTION_PRIORITY,
+  getPackageManager,
+  setPreferredPackageManager,
+  setProjectPackageManager,
+  getAvailablePackageManagers,
+  detectFromLockFile,
+  detectFromPackageJson,
+  getRunCommand,
+  getExecCommand,
+  getSelectionPrompt,
+  getCommandPattern
+};

package/vendor/theus-arsenal/scripts/lib/path-safety.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Helpers de contención de rutas para operaciones de archivos dirigidas por
+ * el estado de instalación.
+ *
+ * Los archivos de estado de instalación son locales al proyecto y, por lo
+ * tanto, controlables por un atacante (un repo clonado/bifurcado puede traer
+ * un archivo de estado manipulado, p. ej. `.theus/theus-install-state.json`).
+ * Las operaciones de reparación/desinstalación/auto-actualización reproducen
+ * operaciones registradas, así que cada destino de escritura/borrado DEBE
+ * quedar confinado a la raíz confiable derivada del adaptador — nunca
+ * confiarse desde el propio archivo de estado.
+ */
+
+function safeRealpath(target) {
+  try {
+    return fs.realpathSync(path.resolve(target));
+  } catch {
+    return path.resolve(target);
+  }
+}
+
+/**
+ * Canonicaliza una ruta que puede no existir todavía: aplica realpath a su
+ * ancestro existente más cercano y luego vuelve a añadir la cola faltante.
+ * Esto derrota los escapes por symlink en los que un directorio intermedio
+ * es un enlace simbólico que apunta fuera de la raíz.
+ */
+function realpathNearestExisting(target) {
+  let current = path.resolve(target);
+  const tail = [];
+  while (!fs.existsSync(current)) {
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    tail.unshift(path.basename(current));
+    current = parent;
+  }
+  const real = safeRealpath(current);
+  return tail.length > 0 ? path.join(real, ...tail) : real;
+}
+
+/**
+ * Verdadero cuando `target` se resuelve a `root` mismo o a una ruta debajo
+ * de él, con los symlinks resueltos en ambos lados.
+ */
+function isWithinRoot(target, root) {
+  if (!root) {
+    return false;
+  }
+  const realRoot = safeRealpath(root);
+  const realTarget = realpathNearestExisting(target);
+  if (realTarget === realRoot) {
+    return true;
+  }
+  const rel = path.relative(realRoot, realTarget);
+  return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
+/**
+ * Guarda de fallo cerrado: lanza un error salvo que `target` esté contenido
+ * dentro de `root`. Devuelve la ruta canonicalizada del destino en caso de éxito.
+ */
+function assertWithinTrustedRoot(target, root, action = 'write') {
+  if (!target || typeof target !== 'string') {
+    throw new Error(`Operación '${action}' rechazada: falta la ruta de destino.`);
+  }
+  if (!root) {
+    throw new Error(`Operación '${action}' rechazada para '${target}': no se resolvió una raíz de instalación confiable.`);
+  }
+  if (!isWithinRoot(target, root)) {
+    throw new Error(`Operación '${action}' rechazada fuera de la raíz de instalación: '${target}' no está dentro de '${root}'.`);
+  }
+  return realpathNearestExisting(target);
+}
+
+module.exports = {
+  realpathNearestExisting,
+  isWithinRoot,
+  assertWithinTrustedRoot
+};