dex-termux-cli 0.3.0-beta.3 → 0.3.0-beta.5

package/src/commands/sessions.js

@@ -0,0 +1,347 @@
+import fs from 'node:fs/promises';
+import net from 'node:net';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { getHomeDirectory } from '../utils/platform.js';
+
+const SESSION_REGISTRY_FILE = 'sessions.json';
+const SESSION_SOCKET_FILE = 'sessions.sock';
+const ESCAPE_BYTE = '\x1d';
+
+export async function runSessionsCommand(parsed = {}) {
+  const action = normalizeSessionAction(parsed.topic);
+
+  if (action === 'unknown') {
+    printSessionsUsage();
+    return;
+  }
+
+  const client = await connectSessionsClient();
+
+  if (action === 'list') {
+    const response = await sendRequest(client, { action: 'list' });
+    printSessionsList(response.sessions || []);
+    client.end();
+    return;
+  }
+
+  if (action === 'new') {
+    const response = await sendRequest(client, {
+      action: 'new',
+      name: parsed.target || '',
+      cwd: process.cwd(),
+      cols: getTerminalCols(),
+      rows: getTerminalRows(),
+    });
+
+    if (!response.session?.id) {
+      throw new Error('No pude crear la sesion PTY.');
+    }
+
+    await attachToSession(client, response.session);
+    return;
+  }
+
+  if (action === 'attach') {
+    if (!parsed.target) {
+      throw new Error('Debes indicar el id o nombre de la sesion. Usa: dex sessions attach <id|nombre>');
+    }
+
+    const response = await sendRequest(client, {
+      action: 'attach',
+      selector: parsed.target,
+      cols: getTerminalCols(),
+      rows: getTerminalRows(),
+    });
+
+    if (!response.session?.id) {
+      throw new Error(`No pude adjuntar la sesion: ${parsed.target}`);
+    }
+
+    await attachToSession(client, response.session);
+    return;
+  }
+
+  if (action === 'kill') {
+    if (!parsed.target) {
+      throw new Error('Debes indicar el id o nombre de la sesion. Usa: dex sessions kill <id|nombre>');
+    }
+
+    const response = await sendRequest(client, {
+      action: 'kill',
+      selector: parsed.target,
+    });
+
+    console.log(`Sesion cerrada: ${response.session?.name || parsed.target}`);
+    client.end();
+  }
+}
+
+async function connectSessionsClient() {
+  await ensureSessionsDaemon();
+  const socketPath = getSessionSocketPath();
+
+  return await new Promise((resolve, reject) => {
+    const client = net.createConnection(socketPath);
+    client.setEncoding('utf8');
+    client.once('connect', () => resolve(client));
+    client.once('error', reject);
+  });
+}
+
+async function ensureSessionsDaemon() {
+  if (await canPingSessionsDaemon()) {
+    return;
+  }
+
+  await fs.mkdir(path.dirname(getSessionSocketPath()), { recursive: true });
+
+  const child = spawn(process.execPath, ['./bin/dex', '--sessions-daemon'], {
+    cwd: process.cwd(),
+    detached: true,
+    stdio: 'ignore',
+    env: process.env,
+  });
+  child.unref();
+
+  for (let attempt = 0; attempt < 30; attempt += 1) {
+    await delay(100);
+    if (await canPingSessionsDaemon()) {
+      return;
+    }
+  }
+
+  throw new Error('No pude iniciar el daemon de sesiones Dex.');
+}
+
+async function canPingSessionsDaemon() {
+  const socketPath = getSessionSocketPath();
+
+  try {
+    await fs.access(socketPath);
+  } catch {
+    return false;
+  }
+
+  try {
+    const client = await new Promise((resolve, reject) => {
+      const socket = net.createConnection(socketPath);
+      socket.setEncoding('utf8');
+      socket.once('connect', () => resolve(socket));
+      socket.once('error', reject);
+    });
+    const response = await sendRequest(client, { action: 'ping' });
+    client.end();
+    return response.ok === true;
+  } catch {
+    return false;
+  }
+}
+
+async function sendRequest(client, message) {
+  return await new Promise((resolve, reject) => {
+    let buffer = '';
+
+    const onData = (chunk) => {
+      buffer += chunk;
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (!line.trim()) {
+          continue;
+        }
+
+        const payload = JSON.parse(line);
+        cleanup();
+
+        if (payload.error) {
+          reject(new Error(payload.error));
+          return;
+        }
+
+        resolve(payload);
+        return;
+      }
+    };
+
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+
+    const cleanup = () => {
+      client.off('data', onData);
+      client.off('error', onError);
+    };
+
+    client.on('data', onData);
+    client.on('error', onError);
+    client.write(JSON.stringify(message) + '\n');
+  });
+}
+
+async function attachToSession(client, session) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    client.end();
+    throw new Error('El attach de sesiones necesita una terminal interactiva.');
+  }
+
+  process.stdout.write(`\n[Dex attach] ${session.name}  Ctrl+] para volver a Dex\n\n`);
+
+  return await new Promise((resolve) => {
+    let buffer = '';
+
+    const cleanup = () => {
+      client.off('data', onSocketData);
+      client.off('close', onSocketClose);
+      client.off('error', onSocketError);
+      process.stdin.off('data', onInput);
+      if (typeof process.stdin.setRawMode === 'function') {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.pause();
+      client.end();
+    };
+
+    const finish = (message = '') => {
+      cleanup();
+      if (message) {
+        process.stdout.write(message);
+      }
+      resolve();
+    };
+
+    const onSocketData = (chunk) => {
+      buffer += chunk;
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (!line.trim()) {
+          continue;
+        }
+
+        const payload = JSON.parse(line);
+
+        if (payload.type === 'data') {
+          process.stdout.write(Buffer.from(payload.data, 'base64'));
+          continue;
+        }
+
+        if (payload.type === 'exit') {
+          finish('\n[Dex attach] sesion finalizada\n');
+          return;
+        }
+
+        if (payload.type === 'detached') {
+          finish('\n[Dex attach] sesion desacoplada\n');
+          return;
+        }
+      }
+    };
+
+    const onSocketClose = () => {
+      finish('\n[Dex attach] conexion cerrada\n');
+    };
+
+    const onSocketError = (error) => {
+      finish(`\n[Dex attach] error: ${error.message}\n`);
+    };
+
+    const onInput = (chunk) => {
+      const raw = Buffer.from(chunk);
+
+      if (raw.toString('utf8') === ESCAPE_BYTE) {
+        client.write(JSON.stringify({ action: 'detach', sessionId: session.id }) + '\n');
+        return;
+      }
+
+      client.write(JSON.stringify({ action: 'input', sessionId: session.id, data: raw.toString('base64') }) + '\n');
+    };
+
+    client.on('data', onSocketData);
+    client.on('close', onSocketClose);
+    client.on('error', onSocketError);
+
+    if (typeof process.stdin.setRawMode === 'function') {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    process.stdin.on('data', onInput);
+  });
+}
+
+function printSessionsList(sessions) {
+  console.log('Dex Sessions');
+  console.log('');
+
+  if (!sessions.length) {
+    console.log('No hay sesiones registradas.');
+    console.log('');
+    printSessionsUsage();
+    return;
+  }
+
+  for (const session of sessions) {
+    console.log(`${session.id}  ${session.name}`);
+    console.log(`Estado : ${session.status}`);
+    console.log(`Shell  : ${session.shell}`);
+    console.log(`Ruta   : ${session.cwd}`);
+    console.log(`PID    : ${session.pid}`);
+    console.log('');
+  }
+}
+
+function normalizeSessionAction(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (!normalized) {
+    return 'list';
+  }
+
+  if (['new', 'create'].includes(normalized)) {
+    return 'new';
+  }
+
+  if (['attach', 'open', 'use'].includes(normalized)) {
+    return 'attach';
+  }
+
+  if (['kill', 'close', 'rm', 'remove'].includes(normalized)) {
+    return 'kill';
+  }
+
+  if (['list', 'ls'].includes(normalized)) {
+    return 'list';
+  }
+
+  return 'unknown';
+}
+
+function printSessionsUsage() {
+  console.log('Uso:');
+  console.log('  dex sessions');
+  console.log('  dex sessions new <nombre>');
+  console.log('  dex sessions attach <id|nombre>');
+  console.log('  dex sessions kill <id|nombre>');
+}
+
+function getSessionSocketPath() {
+  return path.join(getHomeDirectory(), '.config', 'dex', SESSION_SOCKET_FILE);
+}
+
+export function getSessionRegistryPath() {
+  return path.join(getHomeDirectory(), '.config', 'dex', SESSION_REGISTRY_FILE);
+}
+
+function getTerminalCols() {
+  return Number.parseInt(process.env.COLUMNS || '80', 10) || 80;
+}
+
+function getTerminalRows() {
+  return Number.parseInt(process.env.LINES || '24', 10) || 24;
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/commands/tree.js

@@ -7,12 +7,19 @@ 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 TREE_DEPTH_PRESETS = {
+  mini: 2,
+  med: 4,
+  max: Number.POSITIVE_INFINITY,
+};
+
+export async function runTreeCommand({ target, scope, depth, hasCustomDepth, treeViewPreset }) {
   const config = await loadUserConfig();
   const platformMode = resolvePlatformMode(config);
   const scopeOptions = getScopeOptions(platformMode);
   const selectedScope = scope || await chooseSearchScope(scopeOptions);
   const root = resolveScopeRoot(selectedScope, scopeOptions);
+  const resolvedTreeView = resolveTreeView({ depth, hasCustomDepth, treeViewPreset, config });
 
   if (!root) {
     throw new Error(`Alcance no valido: ${selectedScope}`);
@@ -57,9 +64,29 @@ export async function runTreeCommand({ target, scope, depth }) {
   const report = await buildTreeReport({
     root: resolvedTarget,
     label: cleanTarget,
-    depth,
+    depth: resolvedTreeView.depth,
     limit: 120,
   });
 
-  console.log(formatTreeReport(report));
+  console.log(formatTreeReport({
+    ...report,
+    depthLabel: resolvedTreeView.label,
+  }));
+}
+
+export function resolveTreeView({ depth, hasCustomDepth, treeViewPreset, config }) {
+  if (hasCustomDepth) {
+    return {
+      depth,
+      label: `manual (${depth})`,
+    };
+  }
+
+  const preset = treeViewPreset || config.ui?.treeViewPreset || 'max';
+  const normalizedPreset = TREE_DEPTH_PRESETS[preset] ? preset : 'max';
+
+  return {
+    depth: TREE_DEPTH_PRESETS[normalizedPreset],
+    label: normalizedPreset,
+  };
 }

package/src/core/args.js

@@ -7,6 +7,8 @@ export function parseArgs(argv) {
     target: '',
     scope: '',
     depth: 2,
+    hasCustomDepth: false,
+    treeViewPreset: '',
   };
 
   for (let index = 0; index < argv.length; index += 1) {
@@ -47,6 +49,26 @@ export function parseArgs(argv) {
       continue;
     }
 
+    if (token === 'sessions' || token === 'session' || token === '--sessions') {
+      parsed.command = 'sessions';
+      const next = argv[index + 1];
+      if (next && !next.startsWith('-')) {
+        parsed.topic = next;
+        index += 1;
+      }
+      const target = argv[index + 1];
+      if (target && !target.startsWith('-')) {
+        parsed.target = target;
+        index += 1;
+      }
+      continue;
+    }
+
+    if (token === '--sessions-daemon') {
+      parsed.command = 'sessions-daemon';
+      continue;
+    }
+
     if (token === '-b' || token === '--buscar' || token === '--search' || token === 'search') {
       parsed.command = 'search';
       const next = argv[index + 1];
@@ -105,11 +127,27 @@ export function parseArgs(argv) {
       const next = argv[index + 1];
       if (next) {
         parsed.depth = normalizeDepth(next);
+        parsed.hasCustomDepth = true;
         index += 1;
       }
       continue;
     }
 
+    if (token === '--mini') {
+      parsed.treeViewPreset = 'mini';
+      continue;
+    }
+
+    if (token === '--med' || token === '--medio') {
+      parsed.treeViewPreset = 'med';
+      continue;
+    }
+
+    if (token === '--max' || token === '--maximo') {
+      parsed.treeViewPreset = 'max';
+      continue;
+    }
+
     if (!parsed.pattern && parsed.command === 'search') {
       parsed.pattern = token;
       continue;

package/src/core/config.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { getHomeDirectory, normalizePlatformMode } from '../utils/platform.js';
+import { getDefaultLinuxSetupTheme, normalizeLinuxSetupTheme } from '../utils/prompt-theme.js';
 
 const DEFAULT_CONFIG = {
   features: {
@@ -10,6 +11,8 @@ const DEFAULT_CONFIG = {
   },
   ui: {
     promptContextPosition: 'right',
+    treeViewPreset: 'max',
+    linuxSetup: getDefaultLinuxSetupTheme(),
   },
   runtime: {
     platformMode: 'auto',
@@ -74,6 +77,19 @@ export async function setPromptContextPosition(position) {
   return saveUserConfig(nextConfig);
 }
 
+export async function setTreeViewPreset(preset) {
+  const config = await loadUserConfig();
+  const nextConfig = {
+    ...config,
+    ui: {
+      ...config.ui,
+      treeViewPreset: normalizeTreeViewPreset(preset),
+    },
+  };
+
+  return saveUserConfig(nextConfig);
+}
+
 export async function setPlatformMode(platformMode) {
   const config = await loadUserConfig();
   const normalized = normalizePlatformMode(platformMode);
@@ -154,6 +170,8 @@ function mergeConfig(config) {
       ...DEFAULT_CONFIG.ui,
       ...(config.ui || {}),
       promptContextPosition: normalizePromptContextPosition(config.ui?.promptContextPosition),
+      treeViewPreset: normalizeTreeViewPreset(config.ui?.treeViewPreset),
+      linuxSetup: normalizeLinuxSetupTheme(config.ui?.linuxSetup || {}),
     },
     runtime: {
       ...DEFAULT_CONFIG.runtime,
@@ -174,6 +192,9 @@ function cloneDefaultConfig() {
     },
     ui: {
       ...DEFAULT_CONFIG.ui,
+      linuxSetup: {
+        ...DEFAULT_CONFIG.ui.linuxSetup,
+      },
     },
     runtime: {
       ...DEFAULT_CONFIG.runtime,
@@ -187,3 +208,19 @@ function cloneDefaultConfig() {
 function normalizePromptContextPosition(position) {
   return ['right', 'inline', 'off'].includes(position) ? position : DEFAULT_CONFIG.ui.promptContextPosition;
 }
+
+export function normalizeTreeViewPreset(preset) {
+  if (preset === 'mini') {
+    return 'mini';
+  }
+
+  if (preset === 'med' || preset === 'medio') {
+    return 'med';
+  }
+
+  if (preset === 'max' || preset === 'maximo') {
+    return 'max';
+  }
+
+  return DEFAULT_CONFIG.ui.treeViewPreset;
+}

package/src/ui/output.js

@@ -20,19 +20,24 @@ export function printHelp(platformMode = '') {
 
   printBlock('Comandos principales', [
     'dex -m              menu visual',
+    'dex sessions        lista o gestiona sesiones PTY',
     'dex -v              version local y publicada',
     'dex -c              contexto del proyecto actual',
     'dex -b "archivo"    buscar archivos o carpetas',
     'dex -e ls           explicar un comando',
-    'dex -t src          arbol guiado de una ruta',
+    'dex -t src --mini   arbol guiado de una ruta',
     '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 o Linux',
   ]);
 
   printBlock('Uso rapido', [
+    'dex sessions',
+    'dex sessions new dev',
+    'dex sessions attach dev',
     'dex -b "*.js" --scope actual',
-    'dex -t . --depth 3 --scope actual',
+    'dex -t . --med --scope actual',
+    'dex -t proyectos --max --scope actual',
     'dex -c',
     'dex --prompt-context',
     'dex --prompt-project-root',
@@ -47,6 +52,7 @@ export function printHelp(platformMode = '') {
     '-v --version        version',
     '-c --context        contexto',
     '-m --menu           menu',
+    'sessions            multiplexor PTY de Dex',
     '-b --buscar         buscar',
     '-e --explicar       explicar',
     '-t --tree           arbol',
@@ -54,7 +60,10 @@ export function printHelp(platformMode = '') {
     '-r --seguro         shell segura',
     '-a --android        Android',
     '-s --scope          scope',
-    '-d --depth          profundidad',
+    '-d --depth          profundidad manual',
+    '--mini              vista corta',
+    '--med --medio       vista media',
+    '--max --maximo      vista completa',
   ]);
 
   console.log(dim('Configuracion: ' + getUserConfigPath()));
@@ -105,7 +114,7 @@ export function formatTreeReport(report) {
 
   lines.push('Punto  : ' + report.label);
   lines.push('Ruta   : ' + report.root);
-  lines.push('Prof.  : ' + report.depth);
+  lines.push('Vista  : ' + (report.depthLabel || report.depth));
   lines.push('Modo   : vista guiada de carpetas y archivos');
   lines.push('');
   lines.push('Mapa:');
@@ -113,8 +122,8 @@ export function formatTreeReport(report) {
   lines.push('');
   lines.push('Resumen: ' + report.directories + ' carpetas, ' + report.files + ' archivos visibles.');
 
-  if (report.truncatedByDepth) {
-    lines.push('Nota   : hay mas niveles abajo. Prueba con --depth ' + (report.depth + 1) + '.');
+  if (report.truncatedByDepth && Number.isFinite(report.depth)) {
+    lines.push('Nota   : hay mas niveles abajo. Prueba con --med, --max o --depth ' + (report.depth + 1) + '.');
   }
 
   if (report.truncatedByLimit) {

package/src/utils/fs-tree.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { detectProjectContext } from './project-context.js';
 
 const COLORS = {
   reset: '\x1b[0m',
@@ -8,7 +9,8 @@ const COLORS = {
 };
 
 export async function buildTreeReport({ root, label, depth = 2, limit = 120 }) {
-  const lines = [formatDirectoryLabel(`${path.basename(root) || root}/`)];
+  const detectionCache = new Map();
+  const lines = [await formatProjectDirectoryLabel(root, `${path.basename(root) || root}/`, detectionCache)];
   const counters = {
     directories: 0,
     files: 0,
@@ -59,7 +61,7 @@ export async function buildTreeReport({ root, label, depth = 2, limit = 120 }) {
       const childPrefix = `${prefix}${isLast ? '    ' : '│   '}`;
       const fullPath = path.join(currentPath, entry.name);
       const label = entry.isDirectory()
-        ? formatDirectoryLabel(`${entry.name}/`)
+        ? await formatProjectDirectoryLabel(fullPath, `${entry.name}/`, detectionCache)
         : entry.name;
 
       lines.push(`${prefix}${branch}${label}`);
@@ -89,6 +91,36 @@ export async function buildTreeReport({ root, label, depth = 2, limit = 120 }) {
   }
 }
 
+async function formatProjectDirectoryLabel(directoryPath, directoryLabel, detectionCache) {
+  const decoratedLabel = await decorateDirectoryLabel(directoryPath, directoryLabel, detectionCache);
+  return formatDirectoryLabel(decoratedLabel);
+}
+
+async function decorateDirectoryLabel(directoryPath, directoryLabel, detectionCache) {
+  const cached = detectionCache.get(directoryPath);
+  if (cached !== undefined) {
+    return cached ? `${directoryLabel} ${cached}` : directoryLabel;
+  }
+
+  let suffix = '';
+
+  try {
+    const context = await detectProjectContext(directoryPath);
+    if (
+      context &&
+      context.detectionKind !== 'nested-implicit' &&
+      path.resolve(context.projectRoot || '') === path.resolve(directoryPath)
+    ) {
+      suffix = `[${context.label}]`;
+    }
+  } catch {
+    suffix = '';
+  }
+
+  detectionCache.set(directoryPath, suffix);
+  return suffix ? `${directoryLabel} ${suffix}` : directoryLabel;
+}
+
 function formatDirectoryLabel(value) {
   if (!process.stdout.isTTY) {
     return value;