dex-termux-cli 0.1.0

package/src/commands/install.js

@@ -0,0 +1,1013 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import {
+  clearProjectState,
+  getUserConfigPath,
+  loadUserConfig,
+  saveProjectState,
+} from '../core/config.js';
+import { printSection } from '../ui/output.js';
+import { detectProjectContext } from '../utils/project-context.js';
+
+const RUNTIME_CANDIDATES = {
+  python: [
+    'python3',
+    'python',
+    '/data/data/com.termux/files/usr/bin/python3',
+    '/data/data/com.termux/files/usr/bin/python',
+  ],
+  node: ['node', '/data/data/com.termux/files/usr/bin/node'],
+  php: ['php', '/data/data/com.termux/files/usr/bin/php'],
+  ruby: ['ruby', '/data/data/com.termux/files/usr/bin/ruby'],
+  go: ['go', '/data/data/com.termux/files/usr/bin/go'],
+  rust: ['rustc', '/data/data/com.termux/files/usr/bin/rustc'],
+};
+
+const RUNTIME_PACKAGES = {
+  python: ['python'],
+  node: ['nodejs'],
+  php: ['php'],
+  ruby: ['ruby'],
+  go: ['golang'],
+  rust: ['rust'],
+};
+
+const RUNTIME_SMOKE_TESTS = {
+  python: ['-c', 'print("dex-ok")'],
+  node: ['-e', 'console.log("dex-ok")'],
+  php: ['-r', 'echo "dex-ok";'],
+  ruby: ['-e', 'puts "dex-ok"'],
+  go: ['version'],
+  rust: ['--version'],
+};
+
+const TOOL_CANDIDATES = {
+  npm: ['npm', '/data/data/com.termux/files/usr/bin/npm'],
+  composer: ['composer', '/data/data/com.termux/files/usr/bin/composer'],
+};
+
+const TOOL_SMOKE_TESTS = {
+  npm: ['--version'],
+  composer: ['--version'],
+};
+
+const TOOL_PACKAGES = {
+  composer: ['composer'],
+};
+
+const PYTHON_IMPORT_TO_PACKAGE = {
+  PIL: 'Pillow',
+  cv2: 'opencv-python',
+  discord: 'discord.py',
+  dotenv: 'python-dotenv',
+  flask: 'Flask',
+  nextcord: 'nextcord',
+  numpy: 'numpy',
+  pandas: 'pandas',
+  pyrogram: 'pyrogram',
+  pytz: 'pytz',
+  requests: 'requests',
+  telebot: 'pyTelegramBotAPI',
+  telegram: 'python-telegram-bot',
+  yaml: 'PyYAML',
+};
+
+const PYTHON_SYSTEM_PACKAGE_HINTS = {
+  Pillow: ['libjpeg-turbo', 'libpng', 'freetype', 'libwebp', 'libtiff'],
+};
+
+const PYTHON_STDLIB_MODULES = new Set([
+  'abc', 'argparse', 'array', 'asyncio', 'base64', 'calendar', 'collections', 'concurrent', 'contextlib',
+  'copy', 'csv', 'dataclasses', 'datetime', 'decimal', 'difflib', 'enum', 'functools', 'glob', 'hashlib',
+  'heapq', 'html', 'http', 'importlib', 'inspect', 'io', 'itertools', 'json', 'logging', 'math', 'numbers',
+  'operator', 'os', 'pathlib', 'pickle', 'platform', 'queue', 'random', 're', 'secrets', 'shutil', 'signal',
+  'socket', 'sqlite3', 'statistics', 'string', 'subprocess', 'sys', 'tempfile', 'threading', 'time',
+  'traceback', 'typing', 'unittest', 'urllib', 'uuid', 'warnings', 'weakref', 'xml', 'zipfile',
+]);
+
+export async function runInstallCommand() {
+  const config = await loadUserConfig();
+
+  if (!config.features.smartProjectInstall) {
+    throw new Error(
+      `La instalacion segura de proyectos esta desactivada. Activa features.smartProjectInstall en ${getUserConfigPath()}`,
+    );
+  }
+
+  const projectContext = await detectProjectContext();
+  if (!projectContext) {
+    throw new Error('No pude detectar el lenguaje del proyecto actual.');
+  }
+
+  const projectRoot = process.cwd();
+  const projectKey = getProjectKey(projectRoot);
+  const storedProjectState = config.projects?.[projectKey] || null;
+  const installMode = await detectInstallMode(projectContext.type, projectRoot);
+  const runtime = await ensureRuntimeAvailable(projectContext.type);
+
+  if (!runtime) {
+    throw new Error(`No encontre el runtime para ${projectContext.label} y no pude instalarlo con pkg.`);
+  }
+
+  if (!installMode) {
+    throw new Error(
+      `Detecte ${projectContext.label} y el runtime ya esta listo, pero Dex todavia no sabe instalar dependencias para ese lenguaje.`,
+    );
+  }
+
+  const installCommand = await ensureInstallCommandAvailable(runtime, installMode);
+  const preferSafeMode = shouldUseSafeMode(projectContext.type, projectRoot, storedProjectState);
+
+  printSection('Instalar Proyecto');
+  console.log(`Proyecto : ${projectRoot}`);
+  console.log(`Lenguaje : ${projectContext.label}`);
+  console.log(`Modo     : ${installMode.label}`);
+  console.log(`Runtime  : ${runtime}`);
+  console.log(`Comando  : ${installCommand} ${installMode.args.join(' ')}`);
+  console.log(`Perfil   : ${preferSafeMode ? 'modo seguro directo' : 'modo normal primero'}`);
+  console.log('Prueba   : runtime verificado por Dex');
+
+  if (installMode.packages?.length) {
+    console.log(`Paquetes : ${installMode.packages.join(', ')}`);
+  }
+
+  console.log('');
+
+  if (preferSafeMode) {
+    await runSafeInstall({
+      projectRoot,
+      runtime,
+      installCommand,
+      installMode,
+      projectKey,
+      projectContext,
+      reason: storedProjectState?.lastFailureReason || 'preferencia guardada',
+    });
+    return;
+  }
+
+  console.log('Intento 1: instalacion normal dentro del proyecto.');
+  console.log('');
+
+  const directExitCode = await runCommand(installCommand, installMode.args, projectRoot);
+  if (directExitCode === 0) {
+    await clearProjectState(projectKey);
+    console.log('Instalacion completada sin entorno extra.');
+    return;
+  }
+
+  if (!supportsSafeMode(projectContext.type)) {
+    throw new Error(`La instalacion fallo y el rescate automatico aun no existe para ${projectContext.label}.`);
+  }
+
+  if (!isAndroidStoragePath(projectRoot)) {
+    throw new Error('La instalacion fallo y el proyecto no esta en Android storage. No aplique rescate automatico.');
+  }
+
+  await saveProjectState(projectKey, {
+    path: projectRoot,
+    language: projectContext.type,
+    preferSafeInstall: true,
+    lastFailureReason: 'fallo instalacion normal en Android storage',
+    installModeLabel: installMode.label,
+    packages: installMode.packages || [],
+    safeMode: getSafeModeKind(projectContext.type),
+    updatedAt: new Date().toISOString(),
+  });
+
+  await runSafeInstall({
+    projectRoot,
+    runtime,
+    installCommand,
+    installMode,
+    projectKey,
+    projectContext,
+    reason: 'fallo instalacion normal en Android storage',
+  });
+}
+
+async function runSafeInstall({
+  projectRoot,
+  runtime,
+  installCommand,
+  installMode,
+  projectKey,
+  projectContext,
+  reason,
+}) {
+  if (!supportsSafeMode(projectContext.type)) {
+    throw new Error(`El modo seguro directo aun no existe para ${projectContext.label}.`);
+  }
+
+  if (!isAndroidStoragePath(projectRoot)) {
+    throw new Error('El modo seguro directo solo existe para proyectos dentro de Android storage.');
+  }
+
+  if (projectContext.type === 'python') {
+    const venvDir = getRescueVenvPath(projectRoot);
+    console.log(`Modo Dex : entrando directo al entorno seguro (${reason}).`);
+    console.log(`Base HOME: ${process.env.HOME || '/data/data/com.termux/files/home'}`);
+    console.log(`Entorno  : ${venvDir}`);
+    console.log(`Regreso  : ${projectRoot}`);
+    console.log('');
+
+    await ensurePythonSystemPackages(installMode);
+    await ensureRescueVenv(runtime, venvDir);
+
+    const rescuePython = path.join(venvDir, 'bin', 'python');
+    const rescueExitCode = await runCommand(rescuePython, installMode.args, projectRoot);
+    if (rescueExitCode !== 0) {
+      await saveProjectState(projectKey, {
+        path: projectRoot,
+        language: projectContext.type,
+        preferSafeInstall: true,
+        lastFailureReason: 'fallo tambien en entorno seguro',
+        installModeLabel: installMode.label,
+        packages: installMode.packages || [],
+        safeMode: 'python-venv',
+        safeWorkspacePath: venvDir,
+        updatedAt: new Date().toISOString(),
+      });
+
+      throw new Error('La instalacion tambien fallo dentro del entorno seguro.');
+    }
+
+    await saveProjectState(projectKey, {
+      path: projectRoot,
+      language: projectContext.type,
+      preferSafeInstall: true,
+      lastFailureReason: '',
+      installModeLabel: installMode.label,
+      packages: installMode.packages || [],
+      safeMode: 'python-venv',
+      safeWorkspacePath: venvDir,
+      updatedAt: new Date().toISOString(),
+      lastSuccessAt: new Date().toISOString(),
+    });
+
+    console.log('Instalacion completada usando entorno seguro de Dex.');
+    console.log(`Venv     : ${venvDir}`);
+    return;
+  }
+
+  if (projectContext.type === 'node') {
+    const safeProjectDir = getSafeProjectWorkspacePath(projectRoot, projectContext.type);
+    console.log(`Modo Dex : entrando directo al entorno seguro (${reason}).`);
+    console.log(`Base HOME: ${process.env.HOME || '/data/data/com.termux/files/home'}`);
+    console.log(`Seguro   : ${safeProjectDir}`);
+    console.log(`Origen   : ${projectRoot}`);
+    console.log('');
+
+    await syncProjectToSafeWorkspace(projectRoot, safeProjectDir);
+
+    const rescueExitCode = await runCommand(installCommand, installMode.args, safeProjectDir);
+    if (rescueExitCode !== 0) {
+      await saveProjectState(projectKey, {
+        path: projectRoot,
+        language: projectContext.type,
+        preferSafeInstall: true,
+        lastFailureReason: 'fallo tambien en entorno seguro',
+        installModeLabel: installMode.label,
+        packages: installMode.packages || [],
+        safeMode: 'node-workspace',
+        safeWorkspacePath: safeProjectDir,
+        updatedAt: new Date().toISOString(),
+      });
+
+      throw new Error('La instalacion tambien fallo dentro del entorno seguro.');
+    }
+
+    await saveProjectState(projectKey, {
+      path: projectRoot,
+      language: projectContext.type,
+      preferSafeInstall: true,
+      lastFailureReason: '',
+      installModeLabel: installMode.label,
+      packages: installMode.packages || [],
+      safeMode: 'node-workspace',
+      safeWorkspacePath: safeProjectDir,
+      updatedAt: new Date().toISOString(),
+      lastSuccessAt: new Date().toISOString(),
+    });
+
+    console.log('Instalacion completada usando espacio seguro de Dex para Node.');
+    console.log(`Seguro   : ${safeProjectDir}`);
+    return;
+  }
+
+  if (projectContext.type === 'php') {
+    const safeProjectDir = getSafeProjectWorkspacePath(projectRoot, projectContext.type);
+    console.log(`Modo Dex : entrando directo al entorno seguro (${reason}).`);
+    console.log(`Base HOME: ${process.env.HOME || '/data/data/com.termux/files/home'}`);
+    console.log(`Seguro   : ${safeProjectDir}`);
+    console.log(`Origen   : ${projectRoot}`);
+    console.log('');
+
+    await syncProjectToSafeWorkspace(projectRoot, safeProjectDir);
+
+    const rescueExitCode = await runCommand(installCommand, installMode.args, safeProjectDir);
+    if (rescueExitCode !== 0) {
+      await saveProjectState(projectKey, {
+        path: projectRoot,
+        language: projectContext.type,
+        preferSafeInstall: true,
+        lastFailureReason: 'fallo tambien en entorno seguro',
+        installModeLabel: installMode.label,
+        packages: installMode.packages || [],
+        safeMode: 'php-workspace',
+        safeWorkspacePath: safeProjectDir,
+        updatedAt: new Date().toISOString(),
+      });
+
+      throw new Error('La instalacion tambien fallo dentro del entorno seguro.');
+    }
+
+    await saveProjectState(projectKey, {
+      path: projectRoot,
+      language: projectContext.type,
+      preferSafeInstall: true,
+      lastFailureReason: '',
+      installModeLabel: installMode.label,
+      packages: installMode.packages || [],
+      safeMode: 'php-workspace',
+      safeWorkspacePath: safeProjectDir,
+      updatedAt: new Date().toISOString(),
+      lastSuccessAt: new Date().toISOString(),
+    });
+
+    console.log('Instalacion completada usando espacio seguro de Dex para PHP.');
+    console.log(`Seguro   : ${safeProjectDir}`);
+    return;
+  }
+
+  throw new Error(`El modo seguro directo aun no existe para ${projectContext.label}.`);
+}
+
+function shouldUseSafeMode(projectType, projectRoot, projectState) {
+  return Boolean(
+    supportsSafeMode(projectType)
+      && isAndroidStoragePath(projectRoot)
+      && projectState?.preferSafeInstall,
+  );
+}
+
+function getProjectKey(projectRoot) {
+  return createHash('sha1').update(projectRoot).digest('hex');
+}
+
+async function detectInstallMode(projectType, projectRoot) {
+  if (projectType === 'node') {
+    const packageLockPath = path.join(projectRoot, 'package-lock.json');
+    if (await pathExists(packageLockPath)) {
+      return {
+        label: 'package-lock.json',
+        commandType: 'tool',
+        tool: 'npm',
+        args: ['ci'],
+      };
+    }
+
+    const shrinkwrapPath = path.join(projectRoot, 'npm-shrinkwrap.json');
+    if (await pathExists(shrinkwrapPath)) {
+      return {
+        label: 'npm-shrinkwrap.json',
+        commandType: 'tool',
+        tool: 'npm',
+        args: ['ci'],
+      };
+    }
+
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    if (await pathExists(packageJsonPath)) {
+      return {
+        label: 'package.json',
+        commandType: 'tool',
+        tool: 'npm',
+        args: ['install'],
+      };
+    }
+  }
+
+  if (projectType === 'php') {
+    const composerLockPath = path.join(projectRoot, 'composer.lock');
+    if (await pathExists(composerLockPath)) {
+      return {
+        label: 'composer.lock',
+        commandType: 'tool',
+        tool: 'composer',
+        args: ['install', '--no-interaction'],
+      };
+    }
+
+    const composerJsonPath = path.join(projectRoot, 'composer.json');
+    if (await pathExists(composerJsonPath)) {
+      return {
+        label: 'composer.json',
+        commandType: 'tool',
+        tool: 'composer',
+        args: ['install', '--no-interaction'],
+      };
+    }
+  }
+
+  if (projectType !== 'python') {
+    return null;
+  }
+
+  const requirementsPath = path.join(projectRoot, 'requirements.txt');
+  if (await pathExists(requirementsPath)) {
+    return {
+      label: 'requirements.txt',
+      commandType: 'runtime',
+      args: ['-m', 'pip', 'install', '-r', 'requirements.txt'],
+    };
+  }
+
+  const pyprojectPath = path.join(projectRoot, 'pyproject.toml');
+  if (await pathExists(pyprojectPath)) {
+    return {
+      label: 'pyproject.toml',
+      commandType: 'runtime',
+      args: ['-m', 'pip', 'install', '.'],
+    };
+  }
+
+  const setupPath = path.join(projectRoot, 'setup.py');
+  if (await pathExists(setupPath)) {
+    return {
+      label: 'setup.py',
+      commandType: 'runtime',
+      args: ['-m', 'pip', 'install', '.'],
+    };
+  }
+
+  const inferredPackages = await inferPythonPackagesFromImports(projectRoot);
+  if (inferredPackages.length) {
+    return {
+      label: 'imports detectados del proyecto',
+      commandType: 'runtime',
+      args: ['-m', 'pip', 'install', ...inferredPackages],
+      packages: inferredPackages,
+    };
+  }
+
+  return null;
+}
+
+async function ensureInstallCommandAvailable(runtime, installMode) {
+  if (installMode.commandType === 'runtime') {
+    return runtime;
+  }
+
+  if (installMode.commandType === 'tool' && installMode.tool) {
+    const tool = await ensureToolAvailable(installMode.tool);
+    if (tool) {
+      return tool;
+    }
+
+    throw new Error(`No encontre la herramienta ${installMode.tool} para completar la instalacion segura.`);
+  }
+
+  throw new Error('Dex no pudo resolver el comando de instalacion para este proyecto.');
+}
+
+async function inferPythonPackagesFromImports(projectRoot) {
+  const files = await collectPythonFiles(projectRoot);
+  const localModules = await collectLocalPythonModules(projectRoot);
+  const packages = new Set();
+
+  for (const filePath of files) {
+    const raw = await fs.readFile(filePath, 'utf8').catch(() => '');
+    const modules = extractPythonImports(raw);
+
+    for (const moduleName of modules) {
+      if (PYTHON_STDLIB_MODULES.has(moduleName)) {
+        continue;
+      }
+
+      if (localModules.has(moduleName)) {
+        continue;
+      }
+
+      const packageName = PYTHON_IMPORT_TO_PACKAGE[moduleName];
+      if (packageName) {
+        packages.add(packageName);
+      }
+    }
+  }
+
+  return [...packages].sort();
+}
+
+async function collectPythonFiles(rootDir) {
+  const found = [];
+  await walkPythonTree(rootDir, found);
+  return found;
+}
+
+async function walkPythonTree(currentDir, found) {
+  let entries = [];
+
+  try {
+    entries = await fs.readdir(currentDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    if (entry.name === '__pycache__' || entry.name === '.git' || entry.name === '.venv' || entry.name === 'venv') {
+      continue;
+    }
+
+    const fullPath = path.join(currentDir, entry.name);
+
+    if (entry.isDirectory()) {
+      await walkPythonTree(fullPath, found);
+      continue;
+    }
+
+    if (entry.isFile() && entry.name.endsWith('.py')) {
+      found.push(fullPath);
+    }
+  }
+}
+
+async function collectLocalPythonModules(projectRoot) {
+  const names = new Set();
+  let entries = [];
+
+  try {
+    entries = await fs.readdir(projectRoot, { withFileTypes: true });
+  } catch {
+    return names;
+  }
+
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith('.py')) {
+      names.add(path.basename(entry.name, '.py'));
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      names.add(entry.name);
+    }
+  }
+
+  return names;
+}
+
+function extractPythonImports(source) {
+  const modules = new Set();
+  const lines = source.split(/\r?\n/);
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    if (!trimmed || trimmed.startsWith('#')) {
+      continue;
+    }
+
+    let match = trimmed.match(/^import\s+(.+)$/);
+    if (match) {
+      const parts = match[1].split(',');
+      for (const part of parts) {
+        const topLevel = part.trim().split(/\s+as\s+/)[0].split('.')[0].trim();
+        if (topLevel) {
+          modules.add(topLevel);
+        }
+      }
+      continue;
+    }
+
+    match = trimmed.match(/^from\s+([A-Za-z_][\w.]*)\s+import\s+/);
+    if (match) {
+      const topLevel = match[1].split('.')[0].trim();
+      if (topLevel) {
+        modules.add(topLevel);
+      }
+    }
+  }
+
+  return modules;
+}
+
+async function ensureRuntimeAvailable(projectType) {
+  const runtime = await findRuntimeExecutable(projectType);
+  if (runtime) {
+    return runtime;
+  }
+
+  const installed = await installRuntimeWithPkg(projectType);
+  if (!installed) {
+    return '';
+  }
+
+  return findRuntimeExecutable(projectType);
+}
+
+async function findRuntimeExecutable(projectType) {
+  const candidates = RUNTIME_CANDIDATES[projectType] || [];
+  const smokeArgs = RUNTIME_SMOKE_TESTS[projectType] || ['--version'];
+
+  for (const candidate of candidates) {
+    const ok = await canRun(candidate, smokeArgs);
+    if (ok) {
+      return candidate;
+    }
+  }
+
+  return '';
+}
+
+async function findToolExecutable(toolName) {
+  const candidates = TOOL_CANDIDATES[toolName] || [];
+  const smokeArgs = TOOL_SMOKE_TESTS[toolName] || ['--version'];
+
+  for (const candidate of candidates) {
+    const ok = await canRun(candidate, smokeArgs);
+    if (ok) {
+      return candidate;
+    }
+  }
+
+  return '';
+}
+
+async function ensureToolAvailable(toolName) {
+  const tool = await findToolExecutable(toolName);
+  if (tool) {
+    return tool;
+  }
+
+  const installed = await installToolWithPkg(toolName);
+  if (!installed) {
+    return '';
+  }
+
+  return findToolExecutable(toolName);
+}
+
+async function installToolWithPkg(toolName) {
+  const packages = TOOL_PACKAGES[toolName] || [];
+
+  if (!packages.length) {
+    return false;
+  }
+
+  console.log(`Herramienta faltante: ${toolName}. Intentando instalar con pkg...`);
+  console.log(`Paquetes : ${packages.join(', ')}`);
+  console.log('');
+
+  return installPackagesWithPkg(packages, toolName);
+}
+
+async function installRuntimeWithPkg(projectType) {
+  const packages = RUNTIME_PACKAGES[projectType] || [];
+
+  if (!packages.length) {
+    return false;
+  }
+
+  console.log(`Runtime faltante para ${projectType}. Intentando instalar con pkg...`);
+  console.log(`Paquetes : ${packages.join(', ')}`);
+  console.log('');
+
+  return installPackagesWithPkg(packages, projectType);
+}
+
+function throwPkgInstallError(projectType, output) {
+  const normalized = output.toLowerCase();
+
+  if (normalized.includes('no mirror or mirror group selected') || normalized.includes('termux-change-repo')) {
+    throw new Error(
+      `No pude instalar ${projectType} porque Termux no tiene mirrors configurados. Ejecuta termux-change-repo, luego pkg update, y despues vuelve a correr dex -i.`,
+    );
+  }
+
+  if (normalized.includes('temporary failure resolving') || normalized.includes('failed to fetch') || normalized.includes('could not resolve')) {
+    throw new Error(
+      `No pude instalar ${projectType} con pkg por un problema de red o repositorios. Revisa tu conexion, corre pkg update y vuelve a intentar.`,
+    );
+  }
+
+  if (normalized.includes('permission denied')) {
+    throw new Error(
+      `pkg no pudo instalar ${projectType} por permisos insuficientes o entorno bloqueado. Revisa Termux y vuelve a intentarlo.`,
+    );
+  }
+
+  throw new Error(`No pude instalar ${projectType} con pkg. Revisa la salida anterior para ver el motivo exacto.`);
+}
+
+async function ensurePythonSystemPackages(installMode) {
+  const packages = gatherSystemPackagesForPythonInstall(installMode);
+  if (!packages.length) {
+    return;
+  }
+
+  console.log('Dex nota: preparando paquetes nativos de Termux para este proyecto.');
+  console.log(`Sistema  : ${packages.join(', ')}`);
+  console.log('');
+
+  await installPackagesWithPkg(packages, 'dependencias nativas de Python');
+}
+
+function gatherSystemPackagesForPythonInstall(installMode) {
+  const packages = new Set();
+  const projectPackages = installMode.packages || [];
+
+  for (const packageName of projectPackages) {
+    const hintedPackages = PYTHON_SYSTEM_PACKAGE_HINTS[packageName] || [];
+    for (const hintedPackage of hintedPackages) {
+      packages.add(hintedPackage);
+    }
+  }
+
+  return [...packages];
+}
+
+async function installPackagesWithPkg(packages, label) {
+  const pkgBinary = await findPkgBinary();
+
+  if (!pkgBinary || !packages.length) {
+    return false;
+  }
+
+  const result = await runCommandCapture(
+    pkgBinary,
+    ['install', '-y', ...packages],
+    process.env.HOME || '/data/data/com.termux/files/home',
+  );
+
+  if (result.stdout.trim()) {
+    process.stdout.write(result.stdout);
+    if (!result.stdout.endsWith('\n')) {
+      process.stdout.write('\n');
+    }
+  }
+
+  if (result.stderr.trim()) {
+    process.stderr.write(result.stderr);
+    if (!result.stderr.endsWith('\n')) {
+      process.stderr.write('\n');
+    }
+  }
+
+  if (result.exitCode === 0) {
+    return true;
+  }
+
+  throwPkgInstallError(label, result.output);
+  return false;
+}
+
+async function findPkgBinary() {
+  const candidates = ['pkg', '/data/data/com.termux/files/usr/bin/pkg'];
+
+  for (const candidate of candidates) {
+    if (candidate.includes('/')) {
+      if (await pathExists(candidate)) {
+        return candidate;
+      }
+
+      continue;
+    }
+
+    const ok = await canRun(candidate, ['help']);
+    if (ok) {
+      return candidate;
+    }
+  }
+
+  return '';
+}
+
+async function ensureRescueVenv(basePython, venvDir) {
+  const rescuePython = path.join(venvDir, 'bin', 'python');
+  if (await pathExists(rescuePython)) {
+    return;
+  }
+
+  await fs.mkdir(path.dirname(venvDir), { recursive: true });
+
+  let exitCode = await runCommand(
+    basePython,
+    ['-m', 'venv', venvDir],
+    process.env.HOME || '/data/data/com.termux/files/home',
+  );
+
+  if (exitCode === 0 && (await pathExists(rescuePython))) {
+    return;
+  }
+
+  console.log('Dex nota: el soporte de entorno virtual no estaba listo. Intentando prepararlo...');
+  console.log('');
+
+  await ensureVirtualenvSupport(basePython);
+
+  exitCode = await runCommand(
+    basePython,
+    ['-m', 'virtualenv', venvDir],
+    process.env.HOME || '/data/data/com.termux/files/home',
+  );
+
+  if (exitCode !== 0 || !(await pathExists(rescuePython))) {
+    throw new Error('No pude crear el entorno seguro en HOME ni preparando virtualenv automaticamente.');
+  }
+}
+
+async function ensureVirtualenvSupport(basePython) {
+  const home = process.env.HOME || '/data/data/com.termux/files/home';
+
+  await runCommand(basePython, ['-m', 'ensurepip', '--upgrade'], home).catch(() => 1);
+
+  const pipCandidates = [
+    ['-m', 'pip', '--version'],
+    ['-m', 'pip3', '--version'],
+  ];
+
+  let pipReady = false;
+  for (const args of pipCandidates) {
+    if (await canRun(basePython, args)) {
+      pipReady = true;
+      break;
+    }
+  }
+
+  if (!pipReady) {
+    throw new Error('No pude preparar pip para crear el entorno seguro.');
+  }
+
+  const installExitCode = await runCommand(
+    basePython,
+    ['-m', 'pip', 'install', '--upgrade', 'pip', 'virtualenv'],
+    home,
+  );
+
+  if (installExitCode !== 0) {
+    throw new Error('No pude instalar virtualenv para preparar el entorno seguro.');
+  }
+}
+
+function getRescueVenvPath(projectRoot) {
+  const home = process.env.HOME || '/data/data/com.termux/files/home';
+  const digest = createHash('sha1').update(projectRoot).digest('hex').slice(0, 8);
+  const baseName = path.basename(projectRoot).toLowerCase().replace(/[^a-z0-9._-]+/g, '-');
+  const safeName = baseName || 'project';
+  return path.join(home, '.dex', 'venvs', `${safeName}-${digest}`);
+}
+
+function getSafeProjectWorkspacePath(projectRoot, projectType) {
+  const home = process.env.HOME || '/data/data/com.termux/files/home';
+  const digest = createHash('sha1').update(projectRoot).digest('hex').slice(0, 8);
+  const baseName = path.basename(projectRoot).toLowerCase().replace(/[^a-z0-9._-]+/g, '-');
+  const safeName = baseName || projectType || 'project';
+  const safeKind = projectType || 'project';
+  return path.join(home, '.dex', 'projects', safeKind, `${safeName}-${digest}`);
+}
+
+async function syncProjectToSafeWorkspace(projectRoot, safeProjectDir) {
+  await fs.mkdir(safeProjectDir, { recursive: true });
+  await copyDirectoryRecursive(projectRoot, safeProjectDir);
+}
+
+async function copyDirectoryRecursive(sourceDir, targetDir) {
+  let entries = [];
+
+  try {
+    entries = await fs.readdir(sourceDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    if (shouldSkipSafeCopy(entry.name)) {
+      continue;
+    }
+
+    const sourcePath = path.join(sourceDir, entry.name);
+    const targetPath = path.join(targetDir, entry.name);
+
+    if (entry.isDirectory()) {
+      await fs.mkdir(targetPath, { recursive: true });
+      await copyDirectoryRecursive(sourcePath, targetPath);
+      continue;
+    }
+
+    if (entry.isFile()) {
+      await fs.copyFile(sourcePath, targetPath);
+    }
+  }
+}
+
+function shouldSkipSafeCopy(name) {
+  return name === '.git'
+    || name === 'node_modules'
+    || name === 'vendor'
+    || name === '.venv'
+    || name === 'venv'
+    || name === '__pycache__';
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isAndroidStoragePath(projectRoot) {
+  return projectRoot.startsWith('/sdcard') || projectRoot.startsWith('/storage/emulated/0');
+}
+
+function supportsSafeMode(projectType) {
+  return projectType === 'python' || projectType === 'node' || projectType === 'php';
+}
+
+function getSafeModeKind(projectType) {
+  if (projectType === 'python') {
+    return 'python-venv';
+  }
+
+  if (projectType === 'node') {
+    return 'node-workspace';
+  }
+
+  if (projectType === 'php') {
+    return 'php-workspace';
+  }
+
+  return '';
+}
+
+function runCommand(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: 'inherit',
+      env: process.env,
+    });
+
+    child.on('error', reject);
+    child.on('exit', (code, signal) => {
+      if (signal) {
+        reject(new Error(`El comando termino por senal: ${signal}`));
+        return;
+      }
+
+      resolve(code || 0);
+    });
+  });
+}
+
+function runCommandCapture(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: process.env,
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (chunk) => {
+      stdout += String(chunk);
+    });
+
+    child.stderr.on('data', (chunk) => {
+      stderr += String(chunk);
+    });
+
+    child.on('error', reject);
+    child.on('exit', (code, signal) => {
+      if (signal) {
+        reject(new Error(`El comando termino por senal: ${signal}`));
+        return;
+      }
+
+      resolve({
+        exitCode: code || 0,
+        stdout,
+        stderr,
+        output: `${stdout}\n${stderr}`,
+      });
+    });
+  });
+}
+
+function canRun(command, args) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, {
+      stdio: 'ignore',
+      env: process.env,
+    });
+
+    child.on('error', () => resolve(false));
+    child.on('exit', (code) => resolve(code === 0));
+  });
+}