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

package/src/commands/safe-shell.js

@@ -5,6 +5,7 @@ import { spawn } from 'node:child_process';
 import { loadUserConfig } from '../core/config.js';
 import { detectProjectContext } from '../utils/project-context.js';
 import { resolveInteractiveShell } from '../utils/shell.js';
+import { isAndroidStoragePath, resolvePlatformMode, shouldRestrictProjectToAndroidStorage } from '../utils/platform.js';
 
 export async function runSafeShellCommand() {
   const config = await loadUserConfig();
@@ -13,20 +14,23 @@ export async function runSafeShellCommand() {
     throw new Error('La instalacion segura de proyectos esta desactivada. Activa esa funcion antes de abrir el modo seguro.');
   }
 
-  const projectRoot = process.cwd();
+  const currentDir = process.cwd();
   const projectContext = await detectProjectContext();
+  const platformMode = resolvePlatformMode(config);
 
   if (!projectContext || !supportsSafeMode(projectContext.type)) {
-    throw new Error('El modo seguro de Dex por ahora solo existe para proyectos Python, Node y PHP.');
+    throw new Error('El modo seguro de Dex por ahora solo existe para proyectos Python, Node, PHP, Ruby, Go, Rust y Java.');
   }
 
-  if (!isAndroidStoragePath(projectRoot)) {
-    throw new Error('El modo seguro de Dex por ahora se usa en proyectos Python, Node o PHP dentro de Android storage.');
+  const projectRoot = projectContext.projectRoot || currentDir;
+
+  if (shouldRestrictProjectToAndroidStorage(platformMode) && !isAndroidStoragePath(projectRoot)) {
+    throw new Error('El modo seguro de Dex en Termux por ahora se usa en proyectos Python, Node, PHP, Ruby, Go, Rust o Java dentro de Android storage.');
   }
 
   const projectKey = getProjectKey(projectRoot);
   const projectState = config.projects && config.projects[projectKey] ? config.projects[projectKey] : null;
-  const interactiveShell = await resolveInteractiveShell();
+  const interactiveShell = await resolveInteractiveShell(platformMode);
   const reason = projectState && projectState.preferSafeInstall
     ? 'Este proyecto ya quedo marcado para modo seguro.'
     : 'Entrando al entorno seguro manual de Dex.';
@@ -46,6 +50,9 @@ export async function runSafeShellCommand() {
 
     console.log('Modo Dex : shell segura para ' + path.basename(projectRoot));
     console.log('Proyecto : ' + projectRoot);
+    if (currentDir !== projectRoot) {
+      console.log('Desde    : ' + currentDir);
+    }
     console.log('Entorno  : ' + venvDir);
     console.log('Python   : ' + rescuePython);
     console.log('Shell    : ' + interactiveShell.shellName + ' interactiva');
@@ -61,6 +68,9 @@ export async function runSafeShellCommand() {
       DEX_CONTEXT: 'safe-shell',
       DEX_SAFE_PROJECT: projectRoot,
       DEX_SAFE_PROJECT_KEY: projectKey,
+      DEX_SAFE_WORKSPACE: projectRoot,
+      DEX_SAFE_LABEL: 'PYTHON SAFE',
+      DEX_SAFE_RUNTIME: 'python',
     });
     return;
   }
@@ -74,14 +84,18 @@ export async function runSafeShellCommand() {
     try {
       await fs.access(packageJsonPath);
       await fs.access(nodeModulesDir);
+      await ensureSafeWorkspaceMatchesProject(safeProjectDir, projectRoot, projectContext.type);
     } catch {
-      throw new Error('No encontre el espacio seguro de este proyecto Node. Corre dex -i primero para prepararlo.');
+      throw new Error('No encontre un espacio seguro valido para este proyecto Node. Corre dex -i primero para recrearlo.');
     }
 
     const nextPath = nodeBinDir + ':' + (process.env.PATH || '');
 
     console.log('Modo Dex : shell segura para ' + path.basename(projectRoot));
     console.log('Proyecto : ' + projectRoot);
+    if (currentDir !== projectRoot) {
+      console.log('Desde    : ' + currentDir);
+    }
     console.log('Seguro   : ' + safeProjectDir);
     console.log('Modulos  : ' + nodeModulesDir);
     console.log('Shell    : ' + interactiveShell.shellName + ' interactiva');
@@ -97,6 +111,8 @@ export async function runSafeShellCommand() {
       DEX_SAFE_PROJECT: projectRoot,
       DEX_SAFE_PROJECT_KEY: projectKey,
       DEX_SAFE_WORKSPACE: safeProjectDir,
+      DEX_SAFE_LABEL: 'NODE SAFE',
+      DEX_SAFE_RUNTIME: 'node',
     });
     return;
   }
@@ -111,14 +127,18 @@ export async function runSafeShellCommand() {
     try {
       await fs.access(composerJsonPath);
       await fs.access(vendorDir);
+      await ensureSafeWorkspaceMatchesProject(safeProjectDir, projectRoot, projectContext.type);
     } catch {
-      throw new Error('No encontre el espacio seguro de este proyecto PHP. Corre dex -i primero para prepararlo.');
+      throw new Error('No encontre un espacio seguro valido para este proyecto PHP. Corre dex -i primero para recrearlo.');
     }
 
     const nextPath = vendorBinDir + ':' + (process.env.PATH || '');
 
     console.log('Modo Dex : shell segura para ' + path.basename(projectRoot));
     console.log('Proyecto : ' + projectRoot);
+    if (currentDir !== projectRoot) {
+      console.log('Desde    : ' + currentDir);
+    }
     console.log('Seguro   : ' + safeProjectDir);
     console.log('Vendor   : ' + vendorDir);
     console.log('Shell    : ' + interactiveShell.shellName + ' interactiva');
@@ -137,7 +157,154 @@ export async function runSafeShellCommand() {
       DEX_SAFE_PROJECT: projectRoot,
       DEX_SAFE_PROJECT_KEY: projectKey,
       DEX_SAFE_WORKSPACE: safeProjectDir,
+      DEX_SAFE_LABEL: 'PHP SAFE',
+      DEX_SAFE_RUNTIME: 'php',
+    });
+    return;
+  }
+
+  if (projectContext.type === 'ruby') {
+    const safeProjectDir = getSafeProjectWorkspacePath(projectRoot, projectContext.type);
+    const gemfilePath = path.join(safeProjectDir, 'Gemfile');
+
+    try {
+      await fs.access(gemfilePath);
+      await ensureSafeWorkspaceMatchesProject(safeProjectDir, projectRoot, projectContext.type);
+    } catch {
+      throw new Error('No encontre un espacio seguro valido para este proyecto Ruby. Corre dex -i primero para recrearlo.');
+    }
+
+    console.log('Modo Dex : shell segura para ' + path.basename(projectRoot));
+    console.log('Proyecto : ' + projectRoot);
+    if (currentDir !== projectRoot) {
+      console.log('Desde    : ' + currentDir);
+    }
+    console.log('Seguro   : ' + safeProjectDir);
+    console.log('Shell    : ' + interactiveShell.shellName + ' interactiva');
+    console.log('Nota     : ' + reason);
+    console.log('Usa ruby, bundle o bundle exec desde aqui.');
+    console.log('Esta shell abre la copia segura del proyecto dentro de HOME.');
+    console.log('Escribe exit para volver a tu shell normal.');
+    console.log('');
+
+    await openSafeShell(interactiveShell, safeProjectDir, {
+      DEX_CONTEXT: 'safe-shell',
+      DEX_SAFE_PROJECT: projectRoot,
+      DEX_SAFE_PROJECT_KEY: projectKey,
+      DEX_SAFE_WORKSPACE: safeProjectDir,
+      DEX_SAFE_LABEL: 'RUBY SAFE',
+      DEX_SAFE_RUNTIME: 'ruby',
+    });
+    return;
+  }
+
+  if (projectContext.type === 'go') {
+    const safeProjectDir = getSafeProjectWorkspacePath(projectRoot, projectContext.type);
+    const goModPath = path.join(safeProjectDir, 'go.mod');
+
+    try {
+      await fs.access(goModPath);
+      await ensureSafeWorkspaceMatchesProject(safeProjectDir, projectRoot, projectContext.type);
+    } catch {
+      throw new Error('No encontre un espacio seguro valido para este proyecto Go. Corre dex -i primero para recrearlo.');
+    }
+
+    console.log('Modo Dex : shell segura para ' + path.basename(projectRoot));
+    console.log('Proyecto : ' + projectRoot);
+    if (currentDir !== projectRoot) {
+      console.log('Desde    : ' + currentDir);
+    }
+    console.log('Seguro   : ' + safeProjectDir);
+    console.log('Shell    : ' + interactiveShell.shellName + ' interactiva');
+    console.log('Nota     : ' + reason);
+    console.log('Usa go run, go test o go build desde aqui.');
+    console.log('Esta shell abre la copia segura del proyecto dentro de HOME.');
+    console.log('Escribe exit para volver a tu shell normal.');
+    console.log('');
+
+    await openSafeShell(interactiveShell, safeProjectDir, {
+      DEX_CONTEXT: 'safe-shell',
+      DEX_SAFE_PROJECT: projectRoot,
+      DEX_SAFE_PROJECT_KEY: projectKey,
+      DEX_SAFE_WORKSPACE: safeProjectDir,
+      DEX_SAFE_LABEL: 'GO SAFE',
+      DEX_SAFE_RUNTIME: 'go',
     });
+    return;
+  }
+
+  if (projectContext.type === 'rust') {
+    const safeProjectDir = getSafeProjectWorkspacePath(projectRoot, projectContext.type);
+    const cargoTomlPath = path.join(safeProjectDir, 'Cargo.toml');
+
+    try {
+      await fs.access(cargoTomlPath);
+      await ensureSafeWorkspaceMatchesProject(safeProjectDir, projectRoot, projectContext.type);
+    } catch {
+      throw new Error('No encontre un espacio seguro valido para este proyecto Rust. Corre dex -i primero para recrearlo.');
+    }
+
+    console.log('Modo Dex : shell segura para ' + path.basename(projectRoot));
+    console.log('Proyecto : ' + projectRoot);
+    if (currentDir !== projectRoot) {
+      console.log('Desde    : ' + currentDir);
+    }
+    console.log('Seguro   : ' + safeProjectDir);
+    console.log('Shell    : ' + interactiveShell.shellName + ' interactiva');
+    console.log('Nota     : ' + reason);
+    console.log('Usa cargo build, cargo test o cargo run desde aqui.');
+    console.log('Esta shell abre la copia segura del proyecto dentro de HOME.');
+    console.log('Escribe exit para volver a tu shell normal.');
+    console.log('');
+
+    await openSafeShell(interactiveShell, safeProjectDir, {
+      DEX_CONTEXT: 'safe-shell',
+      DEX_SAFE_PROJECT: projectRoot,
+      DEX_SAFE_PROJECT_KEY: projectKey,
+      DEX_SAFE_WORKSPACE: safeProjectDir,
+      DEX_SAFE_LABEL: 'RUST SAFE',
+      DEX_SAFE_RUNTIME: 'rust',
+    });
+    return;
+  }
+
+  if (projectContext.type === 'java') {
+    const safeProjectDir = getSafeProjectWorkspacePath(projectRoot, projectContext.type);
+    const pomPath = path.join(safeProjectDir, 'pom.xml');
+    const gradlePath = path.join(safeProjectDir, 'build.gradle');
+    const gradleKtsPath = path.join(safeProjectDir, 'build.gradle.kts');
+
+    try {
+      await ensureSafeWorkspaceMatchesProject(safeProjectDir, projectRoot, projectContext.type);
+      if (!(await hasJavaBuildFiles(pomPath, gradlePath, gradleKtsPath))) {
+        throw new Error('missing-java-build-files');
+      }
+    } catch {
+      throw new Error('No encontre un espacio seguro valido para este proyecto Java. Corre dex -i primero para recrearlo.');
+    }
+
+    console.log('Modo Dex : shell segura para ' + path.basename(projectRoot));
+    console.log('Proyecto : ' + projectRoot);
+    if (currentDir !== projectRoot) {
+      console.log('Desde    : ' + currentDir);
+    }
+    console.log('Seguro   : ' + safeProjectDir);
+    console.log('Shell    : ' + interactiveShell.shellName + ' interactiva');
+    console.log('Nota     : ' + reason);
+    console.log('Usa mvn, ./mvnw, gradle o ./gradlew desde aqui segun el proyecto.');
+    console.log('Esta shell abre la copia segura del proyecto dentro de HOME.');
+    console.log('Escribe exit para volver a tu shell normal.');
+    console.log('');
+
+    await openSafeShell(interactiveShell, safeProjectDir, {
+      DEX_CONTEXT: 'safe-shell',
+      DEX_SAFE_PROJECT: projectRoot,
+      DEX_SAFE_PROJECT_KEY: projectKey,
+      DEX_SAFE_WORKSPACE: safeProjectDir,
+      DEX_SAFE_LABEL: 'JAVA SAFE',
+      DEX_SAFE_RUNTIME: 'java',
+    });
+    return;
   }
 }
 
@@ -167,12 +334,46 @@ function getComposerHome() {
   return path.join(home, '.dex', 'composer');
 }
 
-function isAndroidStoragePath(projectRoot) {
-  return projectRoot.startsWith('/sdcard') || projectRoot.startsWith('/storage/emulated/0');
+async function hasJavaBuildFiles(pomPath, gradlePath, gradleKtsPath) {
+  return Boolean(await pathExists(pomPath) || await pathExists(gradlePath) || await pathExists(gradleKtsPath));
+}
+
+async function ensureSafeWorkspaceMatchesProject(safeProjectDir, projectRoot, projectType) {
+  const metadataPath = path.join(safeProjectDir, '.dex-workspace.json');
+  let metadataRaw = '';
+
+  try {
+    metadataRaw = await fs.readFile(metadataPath, 'utf8');
+  } catch {
+    return;
+  }
+
+  try {
+    const metadata = JSON.parse(metadataRaw);
+    if (metadata.projectRoot && metadata.projectRoot !== projectRoot) {
+      throw new Error('workspace-root-mismatch');
+    }
+    if (metadata.projectType && metadata.projectType !== projectType) {
+      throw new Error('workspace-type-mismatch');
+    }
+  } catch (error) {
+    if (error && (error.message === 'workspace-root-mismatch' || error.message === 'workspace-type-mismatch')) {
+      throw error;
+    }
+  }
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 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 openSafeShell(interactiveShell, cwd, envPatch) {

package/src/commands/search.js

@@ -1,8 +1,10 @@
 import fs from 'node:fs/promises';
+import { loadUserConfig } from '../core/config.js';
 import { chooseSearchScope } from '../ui/prompt.js';
 import { formatSearchResults, printSection } from '../ui/output.js';
 import { getScopeOptions, resolveScopeRoot } from '../core/scopes.js';
 import { searchEntries } from '../utils/fs-search.js';
+import { resolvePlatformMode } from '../utils/platform.js';
 
 export async function runSearchCommand({ pattern, scope }) {
   const cleanPattern = (pattern || '').trim();
@@ -11,7 +13,9 @@ export async function runSearchCommand({ pattern, scope }) {
     throw new Error('Debes indicar un patron. Ejemplo: dex -b "archivo"');
   }
 
-  const scopeOptions = getScopeOptions();
+  const config = await loadUserConfig();
+  const platformMode = resolvePlatformMode(config);
+  const scopeOptions = getScopeOptions(platformMode);
   const selectedScope = scope || await chooseSearchScope(scopeOptions);
   const root = resolveScopeRoot(selectedScope, scopeOptions);
 

package/src/commands/tree.js

@@ -1,12 +1,16 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { loadUserConfig } from '../core/config.js';
 import { chooseSearchScope } from '../ui/prompt.js';
 import { formatTreeReport, printSection } from '../ui/output.js';
 import { getScopeOptions, resolveScopeRoot } from '../core/scopes.js';
 import { buildTreeReport } from '../utils/fs-tree.js';
+import { resolvePlatformMode } from '../utils/platform.js';
 
 export async function runTreeCommand({ target, scope, depth }) {
-  const scopeOptions = getScopeOptions();
+  const config = await loadUserConfig();
+  const platformMode = resolvePlatformMode(config);
+  const scopeOptions = getScopeOptions(platformMode);
   const selectedScope = scope || await chooseSearchScope(scopeOptions);
   const root = resolveScopeRoot(selectedScope, scopeOptions);
 

package/src/core/args.js

@@ -32,6 +32,16 @@ export function parseArgs(argv) {
       continue;
     }
 
+    if (token === '--prompt-project-root') {
+      parsed.command = 'prompt-project-root';
+      continue;
+    }
+
+    if (token === '--prompt-project-path') {
+      parsed.command = 'prompt-project-path';
+      continue;
+    }
+
     if (token === '-m' || token === '--menu' || token === 'menu') {
       parsed.command = 'menu';
       continue;

package/src/core/config.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { getHomeDirectory, normalizePlatformMode } from '../utils/platform.js';
 
 const DEFAULT_CONFIG = {
   features: {
@@ -10,12 +11,14 @@ const DEFAULT_CONFIG = {
   ui: {
     promptContextPosition: 'right',
   },
+  runtime: {
+    platformMode: 'auto',
+  },
   projects: {},
 };
 
 export function getUserConfigPath() {
-  const home = process.env.HOME || '/data/data/com.termux/files/home';
-  return path.join(home, '.config', 'dex', 'config.json');
+  return path.join(getHomeDirectory(), '.config', 'dex', 'config.json');
 }
 
 export async function loadUserConfig() {
@@ -71,6 +74,33 @@ export async function setPromptContextPosition(position) {
   return saveUserConfig(nextConfig);
 }
 
+export async function setPlatformMode(platformMode) {
+  const config = await loadUserConfig();
+  const normalized = normalizePlatformMode(platformMode);
+  const nextFeatures = {
+    ...config.features,
+  };
+
+  if (normalized === 'linux') {
+    nextFeatures.androidShortcut = false;
+    nextFeatures.projectBadge = true;
+    nextFeatures.smartProjectInstall = true;
+  }
+
+  if (normalized === 'termux') {
+    nextFeatures.androidShortcut = true;
+  }
+
+  return saveUserConfig({
+    ...config,
+    features: nextFeatures,
+    runtime: {
+      ...config.runtime,
+      platformMode: normalized,
+    },
+  });
+}
+
 export async function saveProjectState(projectKey, projectState) {
   const config = await loadUserConfig();
   const nextConfig = {
@@ -124,6 +154,11 @@ function mergeConfig(config) {
       ...(config.ui || {}),
       promptContextPosition: normalizePromptContextPosition(config.ui?.promptContextPosition),
     },
+    runtime: {
+      ...DEFAULT_CONFIG.runtime,
+      ...(config.runtime || {}),
+      platformMode: normalizePlatformMode(config.runtime?.platformMode),
+    },
     projects: {
       ...DEFAULT_CONFIG.projects,
       ...(config.projects || {}),
@@ -139,6 +174,9 @@ function cloneDefaultConfig() {
     ui: {
       ...DEFAULT_CONFIG.ui,
     },
+    runtime: {
+      ...DEFAULT_CONFIG.runtime,
+    },
     projects: {
       ...DEFAULT_CONFIG.projects,
     },

package/src/core/scopes.js

@@ -1,9 +1,14 @@
 import path from 'node:path';
+import {
+  canUseAndroidFeatures,
+  getAndroidStorageRoot,
+  getHomeDirectory,
+  getHomeScopeDescription,
+  getHomeScopeLabel,
+} from '../utils/platform.js';
 
-export function getScopeOptions() {
-  const home = process.env.HOME || '/data/data/com.termux/files/home';
-
-  return [
+export function getScopeOptions(platformMode) {
+  const options = [
     {
       key: 'actual',
       label: 'Carpeta actual',
@@ -12,20 +17,25 @@ export function getScopeOptions() {
     },
     {
       key: 'home',
-      label: 'Home de Termux',
-      root: home,
-      description: 'Busca dentro de tu entorno principal de Termux.',
+      label: getHomeScopeLabel(platformMode),
+      root: getHomeDirectory(),
+      description: getHomeScopeDescription(platformMode),
     },
-    {
+  ];
+
+  if (canUseAndroidFeatures(platformMode)) {
+    options.push({
       key: 'android',
       label: 'Almacenamiento Android',
-      root: '/sdcard',
+      root: getAndroidStorageRoot(platformMode),
       description: 'Busca dentro del almacenamiento compartido accesible.',
-    },
-  ];
+    });
+  }
+
+  return options;
 }
 
-export function resolveScopeRoot(scopeKey, options = getScopeOptions()) {
+export function resolveScopeRoot(scopeKey, options = []) {
   const found = options.find((option) => option.key === scopeKey);
   return found ? path.resolve(found.root) : '';
 }

package/src/ui/output.js

@@ -12,7 +12,8 @@ const ANSI = {
 export function printHelp() {
   printBanner();
   console.log('');
-  console.log('  Explorar, entender y preparar proyectos desde Termux y Android storage.');
+  console.log('  Explorar, entender y preparar proyectos desde Termux o Linux.');
+  console.log('  Android storage aparece cuando el modo de plataforma lo permite.');
   console.log('');
 
   printBlock('Comandos principales', [
@@ -22,22 +23,23 @@ export function printHelp() {
     'dex -b "archivo"    buscar archivos o carpetas',
     'dex -e ls           explicar un comando',
     'dex -t src          arbol guiado de una ruta',
-    'dex -i              instalar dependencias del proyecto',
-    'dex -r              abrir modo seguro del proyecto',
+    'dex -i              instalar dependencias del proyecto detectado',
+    'dex -r              abrir modo seguro del proyecto (Py/Node/PHP/Ruby/Go/Rust/Java)',
     'dex -a              acceso rapido a Android',
   ]);
 
   printBlock('Uso rapido', [
     'dex -b "*.js" --scope actual',
-    'dex -t . --depth 3',
+    'dex -t . --depth 3 --scope actual',
     'dex -c',
     'dex --prompt-context',
+    'dex-project-context --root',
   ]);
 
   printBlock('Scopes', [
     'actual              carpeta donde estas parado',
-    'home                tu HOME de Termux',
-    'android             almacenamiento accesible',
+    'home                tu HOME del entorno actual',
+    'android             almacenamiento accesible en modo Termux',
   ]);
 
   printBlock('Atajos', [

package/src/ui/prompt.js

@@ -3,14 +3,14 @@ import { moveCursor, cursorTo } from 'node:readline';
 import { stdin as input, stdout as output } from 'node:process';
 
 const ANSI = {
-  clearDown: '\x1B[0J',
-  cyan: '\x1B[36m',
-  dim: '\x1B[2m',
-  green: '\x1B[32m',
-  red: '\x1B[31m',
-  reset: '\x1B[0m',
-  yellow: '\x1B[33m',
-  bold: '\x1B[1m',
+  clearDown: '',
+  cyan: '',
+  dim: '',
+  green: '',
+  red: '',
+  reset: '',
+  yellow: '',
+  bold: '',
 };
 
 export async function chooseSearchScope(options) {
@@ -20,7 +20,7 @@ export async function chooseSearchScope(options) {
     getValue: (option) => option.key,
     getLines: (option) => [option.label, option.description, option.root],
     prompt: 'Scope [1-' + options.length + ', Enter=1]: ',
-    errorMessage: 'Opcion no valida. Usa un numero o actual/home/android.',
+    errorMessage: 'Opcion no valida. Usa un numero o una clave valida.',
     directMatch: (answer) => options.find((option) => option.key === answer.toLowerCase())?.key,
   });
 }
@@ -47,7 +47,7 @@ export async function chooseMenuAction() {
     { key: 'safe-shell', label: 'Entrar al modo seguro', hint: 'abre el proyecto con el entorno correcto' },
     { key: 'version', label: 'Ver version de Dex', hint: 'compara local contra la version publicada' },
     { key: 'context', label: 'Ver contexto del proyecto', hint: 'detecta el lenguaje del proyecto actual' },
-    { key: 'settings', label: 'Ajustes y funciones', hint: 'activa extras y mueve el badge del prompt' },
+    { key: 'settings', label: 'Ajustes y funciones', hint: 'activa extras, plataforma y prompt' },
     { key: 'help', label: 'Ver ayuda', hint: 'muestra comandos y ejemplos' },
     { key: 'exit', label: 'Salir', hint: 'cerrar el menu' },
   ];
@@ -67,11 +67,17 @@ export async function chooseMenuAction() {
 
 export async function chooseSettingsAction(config) {
   const options = [
+    {
+      key: 'platform-mode',
+      label: 'Modo de plataforma',
+      status: formatPlatformMode(config.runtime?.platformMode || 'auto'),
+      usage: 'elige auto, termux o linux',
+    },
     {
       key: 'toggle-android-shortcut',
       label: 'Acceso rapido a Android',
       status: formatStatus(config.features.androidShortcut),
-      usage: 'permite dex -a',
+      usage: 'permite dex -a en Termux',
     },
     {
       key: 'toggle-project-badge',
@@ -89,7 +95,7 @@ export async function chooseSettingsAction(config) {
       key: 'toggle-smart-project-install',
       label: 'Instalacion segura de proyectos',
       status: formatStatus(config.features.smartProjectInstall),
-      usage: 'rescata instalaciones y puede instalar runtimes con pkg',
+      usage: 'rescata instalaciones y usa modo seguro por lenguaje',
     },
     {
       key: 'back',
@@ -113,7 +119,7 @@ export async function chooseSettingsAction(config) {
       ];
     },
     prompt: 'Ajuste [1-' + options.length + ', Enter=1]: ',
-    errorMessage: 'Opcion no valida. Usa 1, 2, 3, 4 o 5.',
+    errorMessage: 'Opcion no valida. Usa 1, 2, 3, 4, 5 o 6.',
     directMatch: (answer) => options.find((option) => option.key === answer.toLowerCase())?.key,
     style: 'card',
     introLines: ['Activa solo lo que quieras ver todos los dias.'],
@@ -165,6 +171,51 @@ export async function choosePromptContextPosition(currentPosition) {
   });
 }
 
+export async function choosePlatformMode(currentMode) {
+  const options = [
+    {
+      key: 'auto',
+      label: 'Auto',
+      usage: 'detecta si estas en Termux o Linux segun el entorno real',
+    },
+    {
+      key: 'termux',
+      label: 'Modo Termux',
+      usage: 'activa comportamiento centrado en Android storage y Termux',
+    },
+    {
+      key: 'linux',
+      label: 'Modo Linux',
+      usage: 'desactiva Android y asume un entorno Linux puro',
+    },
+    {
+      key: 'back',
+      label: 'Volver',
+    },
+  ];
+
+  return chooseNumericOption({
+    title: 'Modo de plataforma',
+    options,
+    getValue: (option) => option.key,
+    getLines: (option) => {
+      if (option.key === 'back') {
+        return [option.label];
+      }
+
+      return [
+        option.label,
+        'Uso    : ' + option.usage,
+      ];
+    },
+    prompt: 'Modo [1-' + options.length + ', Enter=1]: ',
+    errorMessage: 'Opcion no valida. Usa 1, 2, 3 o 4.',
+    directMatch: (answer) => options.find((option) => option.key === answer.toLowerCase())?.key,
+    style: 'card',
+    introLines: ['Actual: ' + formatPlatformMode(currentMode)],
+  });
+}
+
 export async function chooseFeatureToggle(currentValue, featureName, description) {
   const options = [
     {
@@ -371,6 +422,18 @@ function formatPromptPosition(position) {
   return 'derecha';
 }
 
+function formatPlatformMode(mode) {
+  if (mode === 'linux') {
+    return 'linux';
+  }
+
+  if (mode === 'termux') {
+    return 'termux';
+  }
+
+  return 'auto';
+}
+
 function colorize(text, color, weight = '') {
   if (!output.isTTY) {
     return text;