dex-termux-cli 0.2.3 → 0.3.0-beta.1

package/src/commands/install.js

@@ -10,6 +10,7 @@ import {
 } from '../core/config.js';
 import { printSection } from '../ui/output.js';
 import { detectProjectContext } from '../utils/project-context.js';
+import { isAndroidStoragePath, resolvePlatformMode, shouldRestrictProjectToAndroidStorage } from '../utils/platform.js';
 
 const RUNTIME_CANDIDATES = {
   python: [
@@ -23,6 +24,7 @@ const RUNTIME_CANDIDATES = {
   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'],
+  java: ['java', '/data/data/com.termux/files/usr/bin/java'],
 };
 
 const RUNTIME_PACKAGES = {
@@ -32,6 +34,7 @@ const RUNTIME_PACKAGES = {
   ruby: ['ruby'],
   go: ['golang'],
   rust: ['rust'],
+  java: [],
 };
 
 const RUNTIME_SMOKE_TESTS = {
@@ -41,20 +44,31 @@ const RUNTIME_SMOKE_TESTS = {
   ruby: ['-e', 'puts "dex-ok"'],
   go: ['version'],
   rust: ['--version'],
+  java: ['--version'],
 };
 
 const TOOL_CANDIDATES = {
   npm: ['npm', '/data/data/com.termux/files/usr/bin/npm'],
   composer: ['composer', '/data/data/com.termux/files/usr/bin/composer'],
+  bundle: ['bundle', '/data/data/com.termux/files/usr/bin/bundle'],
+  cargo: ['cargo', '/data/data/com.termux/files/usr/bin/cargo'],
+  mvn: ['mvn', '/data/data/com.termux/files/usr/bin/mvn'],
+  gradle: ['gradle', '/data/data/com.termux/files/usr/bin/gradle'],
 };
 
 const TOOL_SMOKE_TESTS = {
   npm: ['--version'],
   composer: ['--version'],
+  bundle: ['--version'],
+  cargo: ['--version'],
+  mvn: ['--version'],
+  gradle: ['--version'],
 };
 
 const TOOL_PACKAGES = {
   composer: ['composer'],
+  mvn: [],
+  gradle: [],
 };
 
 const PYTHON_IMPORT_TO_PACKAGE = {
@@ -97,31 +111,38 @@ export async function runInstallCommand() {
   }
 
   const projectContext = await detectProjectContext();
+  const platformMode = resolvePlatformMode(config);
   if (!projectContext) {
-    throw new Error('No pude detectar el lenguaje del proyecto actual.');
+    throw new Error('No pude detectar el lenguaje del proyecto actual. Entra al root del proyecto o a una subcarpeta que pertenezca a uno.');
   }
 
-  const projectRoot = process.cwd();
+  const currentDir = process.cwd();
+  const projectRoot = projectContext.projectRoot || currentDir;
   const projectKey = getProjectKey(projectRoot);
   const storedProjectState = config.projects?.[projectKey] || null;
   const installMode = await detectInstallMode(projectContext.type, projectRoot);
-  const runtime = await ensureRuntimeAvailable(projectContext.type);
+  const runtime = await ensureRuntimeAvailable(projectContext.type, platformMode);
 
   if (!runtime) {
-    throw new Error(`No encontre el runtime para ${projectContext.label} y no pude instalarlo con pkg.`);
+    throw new Error(platformMode === 'termux'
+      ? `No encontre el runtime para ${projectContext.label} en este entorno y tampoco pude instalarlo con pkg.`
+      : `No encontre el runtime para ${projectContext.label}. En modo Linux instala el runtime manualmente y luego vuelve a correr dex -i.`);
   }
 
   if (!installMode) {
     throw new Error(
-      `Detecte ${projectContext.label} y el runtime ya esta listo, pero Dex todavia no sabe instalar dependencias para ese lenguaje.`,
+      `Detecte ${projectContext.label} en ${projectRoot}, pero no encontre un archivo o patron de instalacion que Dex sepa usar todavia.`,
     );
   }
 
-  const installCommand = await ensureInstallCommandAvailable(runtime, installMode);
-  const preferSafeMode = shouldUseSafeMode(projectContext.type, projectRoot, storedProjectState);
+  const installCommand = await ensureInstallCommandAvailable(runtime, installMode, platformMode);
+  const preferSafeMode = shouldUseSafeMode(projectContext.type, projectRoot, storedProjectState, platformMode);
 
   printSection('Instalar Proyecto');
   console.log(`Proyecto : ${projectRoot}`);
+  if (currentDir !== projectRoot) {
+    console.log(`Desde    : ${currentDir}`);
+  }
   console.log(`Lenguaje : ${projectContext.label}`);
   console.log(`Modo     : ${installMode.label}`);
   console.log(`Runtime  : ${runtime}`);
@@ -144,6 +165,7 @@ export async function runInstallCommand() {
       projectKey,
       projectContext,
       reason: storedProjectState?.lastFailureReason || 'preferencia guardada',
+      platformMode,
     });
     return;
   }
@@ -158,12 +180,15 @@ export async function runInstallCommand() {
     return;
   }
 
+  console.log('Dex nota: la instalacion normal fallo. Revisando rescate seguro...');
+  console.log('');
+
   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.');
+  if (shouldRestrictProjectToAndroidStorage(platformMode) && !isAndroidStoragePath(projectRoot)) {
+    throw new Error('La instalacion normal fallo y el proyecto no esta en Android storage. En Termux, el rescate automatico solo se aplica a proyectos dentro de /sdcard o /storage/emulated/0.');
   }
 
   await saveProjectState(projectKey, {
@@ -185,6 +210,7 @@ export async function runInstallCommand() {
     projectKey,
     projectContext,
     reason: 'fallo instalacion normal en Android storage',
+    platformMode,
   });
 }
 
@@ -196,12 +222,13 @@ async function runSafeInstall({
   projectKey,
   projectContext,
   reason,
+  platformMode,
 }) {
   if (!supportsSafeMode(projectContext.type)) {
     throw new Error(`El modo seguro directo aun no existe para ${projectContext.label}.`);
   }
 
-  if (!isAndroidStoragePath(projectRoot)) {
+  if (shouldRestrictProjectToAndroidStorage(platformMode) && !isAndroidStoragePath(projectRoot)) {
     throw new Error('El modo seguro directo solo existe para proyectos dentro de Android storage.');
   }
 
@@ -213,7 +240,7 @@ async function runSafeInstall({
     console.log(`Regreso  : ${projectRoot}`);
     console.log('');
 
-    await ensurePythonSystemPackages(installMode);
+    await ensurePythonSystemPackages(installMode, platformMode);
     await ensureRescueVenv(runtime, venvDir);
 
     const rescuePython = path.join(venvDir, 'bin', 'python');
@@ -260,7 +287,7 @@ async function runSafeInstall({
     console.log(`Origen   : ${projectRoot}`);
     console.log('');
 
-    await syncProjectToSafeWorkspace(projectRoot, safeProjectDir);
+    await syncProjectToSafeWorkspace(projectRoot, safeProjectDir, projectContext.type);
 
     const rescueExitCode = await runCommand(installCommand, installMode.args, safeProjectDir);
     if (rescueExitCode !== 0) {
@@ -305,7 +332,7 @@ async function runSafeInstall({
     console.log(`Origen   : ${projectRoot}`);
     console.log('');
 
-    await syncProjectToSafeWorkspace(projectRoot, safeProjectDir);
+    await syncProjectToSafeWorkspace(projectRoot, safeProjectDir, projectContext.type);
 
     const rescueExitCode = await runCommand(installCommand, installMode.args, safeProjectDir);
     if (rescueExitCode !== 0) {
@@ -342,13 +369,58 @@ async function runSafeInstall({
     return;
   }
 
+  if (projectContext.type === 'ruby' || projectContext.type === 'go' || projectContext.type === 'rust' || projectContext.type === 'java') {
+    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, projectContext.type);
+
+    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: getSafeModeKind(projectContext.type),
+        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: getSafeModeKind(projectContext.type),
+      safeWorkspacePath: safeProjectDir,
+      updatedAt: new Date().toISOString(),
+      lastSuccessAt: new Date().toISOString(),
+    });
+
+    console.log(`Instalacion completada usando espacio seguro de Dex para ${projectContext.label}.`);
+    console.log(`Seguro   : ${safeProjectDir}`);
+    return;
+  }
+
   throw new Error(`El modo seguro directo aun no existe para ${projectContext.label}.`);
 }
 
-function shouldUseSafeMode(projectType, projectRoot, projectState) {
+function shouldUseSafeMode(projectType, projectRoot, projectState, platformMode) {
   return Boolean(
     supportsSafeMode(projectType)
-      && isAndroidStoragePath(projectRoot)
+      && (!shouldRestrictProjectToAndroidStorage(platformMode) || isAndroidStoragePath(projectRoot))
       && projectState?.preferSafeInstall,
   );
 }
@@ -412,6 +484,105 @@ async function detectInstallMode(projectType, projectRoot) {
     }
   }
 
+  if (projectType === 'ruby') {
+    const gemfileLockPath = path.join(projectRoot, 'Gemfile.lock');
+    if (await pathExists(gemfileLockPath)) {
+      return {
+        label: 'Gemfile.lock',
+        commandType: 'tool',
+        tool: 'bundle',
+        args: ['install'],
+      };
+    }
+
+    const gemfilePath = path.join(projectRoot, 'Gemfile');
+    if (await pathExists(gemfilePath)) {
+      return {
+        label: 'Gemfile',
+        commandType: 'tool',
+        tool: 'bundle',
+        args: ['install'],
+      };
+    }
+  }
+
+  if (projectType === 'go') {
+    const goModPath = path.join(projectRoot, 'go.mod');
+    if (await pathExists(goModPath)) {
+      return {
+        label: 'go.mod',
+        commandType: 'runtime',
+        args: ['mod', 'download'],
+      };
+    }
+  }
+
+  if (projectType === 'rust') {
+    const cargoLockPath = path.join(projectRoot, 'Cargo.lock');
+    if (await pathExists(cargoLockPath)) {
+      return {
+        label: 'Cargo.lock',
+        commandType: 'tool',
+        tool: 'cargo',
+        args: ['fetch'],
+      };
+    }
+
+    const cargoTomlPath = path.join(projectRoot, 'Cargo.toml');
+    if (await pathExists(cargoTomlPath)) {
+      return {
+        label: 'Cargo.toml',
+        commandType: 'tool',
+        tool: 'cargo',
+        args: ['fetch'],
+      };
+    }
+  }
+
+  if (projectType === 'java') {
+    const mavenWrapper = await findJavaWrapper(projectRoot, ['mvnw']);
+    const gradleWrapper = await findJavaWrapper(projectRoot, ['gradlew']);
+    const pomPath = path.join(projectRoot, 'pom.xml');
+    const gradlePath = path.join(projectRoot, 'build.gradle');
+    const gradleKtsPath = path.join(projectRoot, 'build.gradle.kts');
+
+    if (mavenWrapper && await pathExists(pomPath)) {
+      return {
+        label: path.basename(mavenWrapper),
+        commandType: 'local-script',
+        script: mavenWrapper,
+        args: ['dependency:go-offline'],
+      };
+    }
+
+    if (await pathExists(pomPath)) {
+      return {
+        label: 'pom.xml',
+        commandType: 'tool',
+        tool: 'mvn',
+        args: ['dependency:go-offline'],
+      };
+    }
+
+    if (gradleWrapper && (await pathExists(gradlePath) || await pathExists(gradleKtsPath))) {
+      return {
+        label: path.basename(gradleWrapper),
+        commandType: 'local-script',
+        script: gradleWrapper,
+        args: ['dependencies'],
+      };
+    }
+
+    if (await pathExists(gradlePath) || await pathExists(gradleKtsPath)) {
+      return {
+        label: (await pathExists(gradleKtsPath)) ? 'build.gradle.kts' : 'build.gradle',
+        commandType: 'tool',
+        tool: 'gradle',
+        args: ['dependencies'],
+      };
+    }
+  }
+
   if (projectType !== 'python') {
     return null;
   }
@@ -456,18 +627,24 @@ async function detectInstallMode(projectType, projectRoot) {
   return null;
 }
 
-async function ensureInstallCommandAvailable(runtime, installMode) {
+async function ensureInstallCommandAvailable(runtime, installMode, platformMode) {
   if (installMode.commandType === 'runtime') {
     return runtime;
   }
 
+  if (installMode.commandType === 'local-script' && installMode.script) {
+    return installMode.script;
+  }
+
   if (installMode.commandType === 'tool' && installMode.tool) {
-    const tool = await ensureToolAvailable(installMode.tool);
+    const tool = await ensureToolAvailable(installMode.tool, platformMode);
     if (tool) {
       return tool;
     }
 
-    throw new Error(`No encontre la herramienta ${installMode.tool} para completar la instalacion segura.`);
+    throw new Error(platformMode === 'termux'
+      ? `No encontre la herramienta ${installMode.tool} para completar la instalacion segura.`
+      : `No encontre la herramienta ${installMode.tool}. En modo Linux instalala manualmente y vuelve a correr dex -i.`);
   }
 
   throw new Error('Dex no pudo resolver el comando de instalacion para este proyecto.');
@@ -593,12 +770,16 @@ function extractPythonImports(source) {
   return modules;
 }
 
-async function ensureRuntimeAvailable(projectType) {
+async function ensureRuntimeAvailable(projectType, platformMode) {
   const runtime = await findRuntimeExecutable(projectType);
   if (runtime) {
     return runtime;
   }
 
+  if (platformMode !== 'termux') {
+    return '';
+  }
+
   const installed = await installRuntimeWithPkg(projectType);
   if (!installed) {
     return '';
@@ -635,12 +816,16 @@ async function findToolExecutable(toolName) {
   return '';
 }
 
-async function ensureToolAvailable(toolName) {
+async function ensureToolAvailable(toolName, platformMode) {
   const tool = await findToolExecutable(toolName);
   if (tool) {
     return tool;
   }
 
+  if (platformMode !== 'termux') {
+    return '';
+  }
+
   const installed = await installToolWithPkg(toolName);
   if (!installed) {
     return '';
@@ -701,7 +886,11 @@ function throwPkgInstallError(projectType, output) {
   throw new Error(`No pude instalar ${projectType} con pkg. Revisa la salida anterior para ver el motivo exacto.`);
 }
 
-async function ensurePythonSystemPackages(installMode) {
+async function ensurePythonSystemPackages(installMode, platformMode) {
+  if (platformMode !== 'termux') {
+    return;
+  }
+
   const packages = gatherSystemPackagesForPythonInstall(installMode);
   if (!packages.length) {
     return;
@@ -868,9 +1057,37 @@ function getSafeProjectWorkspacePath(projectRoot, projectType) {
   return path.join(home, '.dex', 'projects', safeKind, `${safeName}-${digest}`);
 }
 
-async function syncProjectToSafeWorkspace(projectRoot, safeProjectDir) {
+async function syncProjectToSafeWorkspace(projectRoot, safeProjectDir, projectType) {
   await fs.mkdir(safeProjectDir, { recursive: true });
+  await resetDirectoryContents(safeProjectDir);
   await copyDirectoryRecursive(projectRoot, safeProjectDir);
+  await writeSafeWorkspaceMeta(safeProjectDir, projectRoot, projectType);
+}
+
+async function resetDirectoryContents(targetDir) {
+  let entries = [];
+
+  try {
+    entries = await fs.readdir(targetDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    await fs.rm(path.join(targetDir, entry.name), { recursive: true, force: true });
+  }
+}
+
+async function writeSafeWorkspaceMeta(safeProjectDir, projectRoot, projectType) {
+  const metadataPath = path.join(safeProjectDir, '.dex-workspace.json');
+  const metadata = {
+    projectRoot,
+    projectType,
+    generatedAt: new Date().toISOString(),
+  };
+
+  await fs.writeFile(metadataPath, `${JSON.stringify(metadata, null, 2)}
+`, 'utf8');
 }
 
 async function copyDirectoryRecursive(sourceDir, targetDir) {
@@ -904,11 +1121,21 @@ async function copyDirectoryRecursive(sourceDir, targetDir) {
 
 function shouldSkipSafeCopy(name) {
   return name === '.git'
-    || name === 'node_modules'
-    || name === 'vendor'
+    || name === '.gradle'
+    || name === '.idea'
+    || name === '.vscode'
+    || name === '.mypy_cache'
+    || name === '.pytest_cache'
+    || name === '.ruff_cache'
     || name === '.venv'
     || name === 'venv'
-    || name === '__pycache__';
+    || name === '__pycache__'
+    || name === 'node_modules'
+    || name === 'vendor'
+    || name === 'target'
+    || name === 'dist'
+    || name === 'build'
+    || name === 'bin';
 }
 
 async function pathExists(targetPath) {
@@ -920,12 +1147,20 @@ async function pathExists(targetPath) {
   }
 }
 
-function isAndroidStoragePath(projectRoot) {
-  return projectRoot.startsWith('/sdcard') || projectRoot.startsWith('/storage/emulated/0');
+
+async function findJavaWrapper(projectRoot, names) {
+  for (const name of names) {
+    const targetPath = path.join(projectRoot, name);
+    if (await pathExists(targetPath)) {
+      return targetPath;
+    }
+  }
+
+  return '';
 }
 
 function supportsSafeMode(projectType) {
-  return projectType === 'python' || projectType === 'node' || projectType === 'php';
+  return projectType === 'python' || projectType === 'node' || projectType === 'php' || projectType === 'ruby' || projectType === 'go' || projectType === 'rust' || projectType === 'java';
 }
 
 function getSafeModeKind(projectType) {
@@ -941,6 +1176,22 @@ function getSafeModeKind(projectType) {
     return 'php-workspace';
   }
 
+  if (projectType === 'ruby') {
+    return 'ruby-workspace';
+  }
+
+  if (projectType === 'go') {
+    return 'go-workspace';
+  }
+
+  if (projectType === 'rust') {
+    return 'rust-workspace';
+  }
+
+  if (projectType === 'java') {
+    return 'java-workspace';
+  }
+
   return '';
 }
 

package/src/commands/menu.js

@@ -1,4 +1,10 @@
-import { loadUserConfig, setFeatureEnabled, setPromptContextPosition } from '../core/config.js';
+import {
+  loadUserConfig,
+  setFeatureEnabled,
+  setPlatformMode,
+  setPromptContextPosition,
+} from '../core/config.js';
+import { formatPlatformMode, resolvePlatformMode } from '../utils/platform.js';
 import { runContextCommand } from './context.js';
 import { runExplainCommand } from './explain.js';
 import { runSafeShellCommand } from './safe-shell.js';
@@ -8,6 +14,7 @@ import { runVersionCommand } from './version.js';
 import {
   chooseFeatureToggle,
   chooseMenuAction,
+  choosePlatformMode,
   choosePromptContextPosition,
   chooseSearchPatternFromMenu,
   chooseSettingsAction,
@@ -77,11 +84,25 @@ async function runSettingsMenu() {
       return;
     }
 
+    if (action === 'platform-mode') {
+      const currentMode = formatPlatformMode(resolvePlatformMode(config));
+      const mode = await choosePlatformMode(currentMode);
+
+      if (mode === 'back') {
+        continue;
+      }
+
+      await setPlatformMode(mode);
+      console.log('Modo de plataforma: ' + formatPlatformModeLabel(mode) + '.');
+      console.log('');
+      continue;
+    }
+
     if (action === 'toggle-android-shortcut') {
       const toggle = await chooseFeatureToggle(
         config.features.androidShortcut,
         'Acceso rapido a Android',
-        'permite usar dex -a o dex --android',
+        'permite usar dex -a',
       );
 
       if (toggle === 'back') {
@@ -130,7 +151,7 @@ async function runSettingsMenu() {
       const toggle = await chooseFeatureToggle(
         config.features.smartProjectInstall,
         'Instalacion segura de proyectos',
-        'instala dependencias y si falta el runtime intenta traerlo con pkg',
+        'rescata instalaciones y puede instalar runtimes con pkg en Termux',
       );
 
       if (toggle === 'back') {
@@ -156,3 +177,15 @@ function formatPromptContextPosition(position) {
 
   return 'a la derecha';
 }
+
+function formatPlatformModeLabel(mode) {
+  if (mode === 'linux') {
+    return 'linux';
+  }
+
+  if (mode === 'termux') {
+    return 'termux';
+  }
+
+  return 'auto';
+}