zyn-ai 1.2.0 → 1.3.0

package/src/tools/index.js

@@ -7,6 +7,16 @@ const fsp = fs.promises;
 const {
   MAX_FILE_LINES,
 } = require('../config');
+const {
+  buildApiHeaders,
+  buildCloneUrl,
+  getApiBaseUrl,
+  listGitSecrets,
+  normalizeProfileName,
+  removeGitSecret,
+  resolveGitProfile,
+  upsertGitSecret,
+} = require('../utils/secretStorage');
 const { resolveInputPath } = require('../utils/pathUtils');
 const {
   formatLineRange,
@@ -28,7 +38,9 @@ const TOOL_DEFINITIONS = [
   { name: 'fetch_url', usage: '{ url, selector?, attribute?, limit?, headers? }' },
   { name: 'web_search', usage: '{ query }' },
   { name: 'web_read', usage: '{ url }' },
+  { name: 'create_canvas_image', usage: '{ width, height, background?, elements?, format?, outputPath? }' },
 ];
+const REGISTERED_TOOLS = new Set(TOOL_DEFINITIONS.map(tool => tool.name));
 
 function getToolPromptText() {
   return [
@@ -94,6 +106,17 @@ function getToolPromptText() {
     '  Descarga una pagina web y la convierte a texto legible (sin HTML).',
     '  Ideal para leer articulos, documentacion o contenido de paginas.',
     '  Ejemplo: {"type":"tool","tool":"web_read","args":{"url":"https://docs.example.com/guide"}}',
+    '',
+    '## Imagen profesional con Jimp',
+    '',
+    'create_canvas_image { width, height, background?, elements?, format?, outputPath? }',
+    '  Crea imagenes desde cero usando Jimp con composicion por elementos.',
+    '  width/height son obligatorios. background puede ser color HEX (#RRGGBB o #RRGGBBAA).',
+    '  elements permite combinar rect, circle/ellipse, line, text e image.',
+    '  Usa este flujo profesional: definir lienzo -> capas base -> tipografia -> detalles -> exportacion.',
+    '  Ejemplo:',
+    '  {"type":"tool","tool":"create_canvas_image","args":{"width":1200,"height":628,"background":"#0f172a","format":"png","outputPath":"generated/cover.png","elements":[{"type":"rect","x":48,"y":48,"w":1104,"h":532,"radius":24,"fill":"#111827"},{"type":"text","x":96,"y":120,"fontSize":32,"text":"Quarterly Business Report"}]}}',
+    '',
   ].join('\n');
 }
 
@@ -137,6 +160,8 @@ function describeToolCall(call) {
       const readUrl = cleanUrl(call.args.url || '');
       return `Leyendo ${shortText(readUrl, 60)}`;
     }
+    case 'create_canvas_image':
+      return `Creando imagen ${call.args.width || '?'}x${call.args.height || '?'}`;
     default:
       return call.tool;
   }
@@ -751,6 +776,9 @@ async function webReadTool(args, state, paint) {
 }
 
 async function executeToolCall(call, state, ui) {
+  if (!call || typeof call.tool !== 'string' || !REGISTERED_TOOLS.has(call.tool)) {
+    throw new Error(`Herramienta no registrada: ${call?.tool || 'desconocida'}`);
+  }
   ui.logEvent(state, 'tool', describeToolCall(call));
 
   const startTime = Date.now();
@@ -796,6 +824,9 @@ async function executeToolCall(call, state, ui) {
     case 'web_read':
       result = await webReadTool(call.args, state, ui.paint);
       break;
+    case 'create_canvas_image':
+      result = await createCanvasImageTool(call.args, state, ui.paint);
+      break;
     default:
       throw new Error(`Herramienta no soportada: ${call.tool}`);
   }
@@ -819,6 +850,9 @@ function buildOllamaInstallCommand() {
 
 function parseDirectAction(input) {
   const text = input.trim();
+  if (/^(git|npm|node|pnpm|yarn)\s+/.test(text)) {
+    return { tool: 'run_command', args: { command: text } };
+  }
 
   const runMatch = text.match(/^(?:ejecuta|corre)\s+(?:el\s+)?comando\s+([\s\S]+)$/i);
   if (runMatch) {
@@ -1002,3 +1036,245 @@ module.exports = {
   parseDirectAction,
   printTools,
 };
+
+
+function getGitSecretLabel(provider, name = '') {
+  const key = normalizeProfileName(provider);
+  if (key === 'custom') return name ? `custom:${name}` : 'custom';
+  return key;
+}
+
+function parseColor(value, fallback = 0x000000ff) {
+  if (typeof value !== 'string' || !value.trim()) return fallback;
+  const raw = value.trim().replace('#', '');
+  if (/^[0-9a-f]{6}$/i.test(raw)) return Number.parseInt(`${raw}ff`, 16) >>> 0;
+  if (/^[0-9a-f]{8}$/i.test(raw)) return Number.parseInt(raw, 16) >>> 0;
+  return fallback;
+}
+
+function drawRect(image, x, y, w, h, color) {
+  const left = Math.max(0, Math.floor(Number(x) || 0));
+  const top = Math.max(0, Math.floor(Number(y) || 0));
+  const width = Math.max(1, Math.floor(Number(w) || 0));
+  const height = Math.max(1, Math.floor(Number(h) || 0));
+  image.scan(left, top, width, height, function (px, py, idx) {
+    this.bitmap.data.writeUInt32BE(color >>> 0, idx);
+  });
+}
+
+function drawRoundRect(image, x, y, w, h, radius, color) {
+  const left = Math.max(0, Math.floor(Number(x) || 0));
+  const top = Math.max(0, Math.floor(Number(y) || 0));
+  const width = Math.max(1, Math.floor(Number(w) || 0));
+  const height = Math.max(1, Math.floor(Number(h) || 0));
+  const r = Math.max(0, Math.min(Number(radius) || 0, Math.floor(width / 2), Math.floor(height / 2)));
+  if (r <= 0) return drawRect(image, left, top, width, height, color);
+
+  image.scan(left, top, width, height, function (px, py, idx) {
+    const cx = px < left + r ? left + r : px >= left + width - r ? left + width - r - 1 : px;
+    const cy = py < top + r ? top + r : py >= top + height - r ? top + height - r - 1 : py;
+    const dx = px - cx;
+    const dy = py - cy;
+    if ((dx * dx) + (dy * dy) <= r * r) {
+      this.bitmap.data.writeUInt32BE(color >>> 0, idx);
+    }
+  });
+}
+
+function drawLine(image, x1, y1, x2, y2, color) {
+  const sx = Number(x1 || 0);
+  const sy = Number(y1 || 0);
+  const tx = Number(x2 || 0);
+  const ty = Number(y2 || 0);
+  const steps = Math.max(1, Math.ceil(Math.max(Math.abs(tx - sx), Math.abs(ty - sy))));
+  for (let i = 0; i <= steps; i++) {
+    const x = Math.round(sx + ((tx - sx) * i / steps));
+    const y = Math.round(sy + ((ty - sy) * i / steps));
+    if (x >= 0 && y >= 0 && x < image.bitmap.width && y < image.bitmap.height) {
+      image.setPixelColor(color, x, y);
+    }
+  }
+}
+
+async function createCanvasImageTool(args, state, paint) {
+  const { Jimp, loadFont } = require('jimp');
+  const pluginPrintMain = require.resolve('@jimp/plugin-print');
+  const fontsPath = path.join(path.dirname(pluginPrintMain), 'fonts.js');
+  const fonts = require(fontsPath);
+  const width = Math.max(1, Number(args.width || 0));
+  const height = Math.max(1, Number(args.height || 0));
+  if (!width || !height) {
+    throw new Error('create_canvas_image requiere width y height');
+  }
+
+  const format = String(args.format || 'png').toLowerCase();
+  const safeFormat = ['png', 'jpg', 'jpeg', 'webp', 'bmp', 'gif', 'tiff'].includes(format) ? format : 'png';
+  const fileExt = safeFormat === 'jpeg' ? 'jpg' : safeFormat;
+  const outputPath = resolveInputPath(args.outputPath || path.join('generated', `image-${Date.now()}.${fileExt}`), state.cwd);
+
+  const allowed = await askConfirmation(state.rl, 'Crear imagen', `${width}x${height}\nFormato: ${safeFormat}\nSalida: ${outputPath}`, paint, state);
+  if (!allowed) return 'Creacion de imagen cancelada por el usuario.';
+
+  const bg = args.background && typeof args.background === 'object'
+    ? args.background.color || args.background.fill || '#ffffff'
+    : args.background || '#ffffff';
+  const image = new Jimp({ width, height, color: parseColor(bg, 0xffffffff) });
+  const elements = Array.isArray(args.elements) ? args.elements.filter(Boolean) : [];
+
+  for (const element of elements) {
+    if (!element || typeof element !== 'object') continue;
+    const type = String(element.type || 'text').toLowerCase();
+    if (type === 'rect') {
+      const color = parseColor(element.fill || element.color || '#000000', 0x000000ff);
+      if (element.radius) drawRoundRect(image, element.x || 0, element.y || 0, element.w || element.width || 0, element.h || element.height || 0, element.radius || 0, color);
+      else drawRect(image, element.x || 0, element.y || 0, element.w || element.width || 0, element.h || element.height || 0, color);
+      continue;
+    }
+    if (type === 'line') {
+      drawLine(image, element.x1 || 0, element.y1 || 0, element.x2 || 0, element.y2 || 0, parseColor(element.stroke || '#000000', 0x000000ff));
+      continue;
+    }
+    if (type === 'circle' || type === 'ellipse') {
+      const color = parseColor(element.fill || element.color || '#000000', 0x000000ff);
+      const cx = Number(element.x || 0);
+      const cy = Number(element.y || 0);
+      const rx = Math.max(1, Number(element.rx || element.r || element.radius || element.width || 0));
+      const ry = Math.max(1, Number(element.ry || element.r || element.radius || element.height || rx));
+      image.scan(0, 0, image.bitmap.width, image.bitmap.height, function (px, py, idx) {
+        const dx = (px - cx) / rx;
+        const dy = (py - cy) / ry;
+        if ((dx * dx) + (dy * dy) <= 1) {
+          this.bitmap.data.writeUInt32BE(color >>> 0, idx);
+        }
+      });
+      continue;
+    }
+    if (type === 'image') {
+      const src = element.src || element.url || element.path;
+      if (!src) continue;
+      const loaded = await Jimp.read(src.startsWith('http') || src.startsWith('data:') ? src : resolveInputPath(src, state.cwd));
+      const x = Number(element.x || 0);
+      const y = Number(element.y || 0);
+      const w = Math.max(1, Number(element.w || element.width || loaded.bitmap.width));
+      const h = Math.max(1, Number(element.h || element.height || loaded.bitmap.height));
+      const clone = loaded.clone().resize({ w, h });
+      image.composite(clone, x, y);
+      continue;
+    }
+
+    const text = String(element.text || '');
+    if (!text) continue;
+    const size = Math.max(8, Math.min(64, Number(element.fontSize || 32)));
+    const font = await loadFont(
+      size <= 8 ? fonts.SANS_8_BLACK :
+      size <= 16 ? fonts.SANS_16_BLACK :
+      size <= 32 ? fonts.SANS_32_BLACK :
+      fonts.SANS_64_BLACK,
+    );
+    image.print({ font, x: Number(element.x || 0), y: Number(element.y || 0), maxWidth: element.maxWidth ? Number(element.maxWidth) : undefined }, text);
+  }
+
+  await fs.promises.mkdir(path.dirname(outputPath), { recursive: true });
+  await image.write(outputPath);
+  return [`Imagen creada: ${outputPath}`, `Formato: ${safeFormat}`, `Tamano: ${width}x${height}`, `Elementos: ${elements.length}`].join('\\n');
+}
+
+
+async function gitSecretSetTool(args) {
+  const provider = normalizeProfileName(args.provider || '');
+  if (!provider) throw new Error('git_secret_set requiere provider');
+  if (!args.token || typeof args.token !== 'string') throw new Error('git_secret_set requiere token');
+  const saved = upsertGitSecret(provider, args);
+  return `Credencial guardada: ${getGitSecretLabel(provider, saved?.name || args.name || '')}`;
+}
+
+async function gitSecretListTool(args) {
+  const provider = normalizeProfileName(args.provider || '');
+  const name = String(args.name || '').trim();
+  const secrets = listGitSecrets();
+  const filtered = secrets.filter(secret => {
+    if (!provider) return true;
+    if (provider === 'custom') return !name || secret.key === `custom:${name}`;
+    return secret.key === provider;
+  });
+  if (!filtered.length) return 'No hay credenciales Git guardadas.';
+  return filtered.map(secret => [
+    `${secret.key}`,
+    `  username: ${secret.username || '-'}`,
+    `  apiBaseUrl: ${secret.apiBaseUrl || '-'}`,
+    `  cloneBaseUrl: ${secret.cloneBaseUrl || '-'}`,
+    `  authHeader: ${secret.authHeader || '-'}`,
+    `  token: ${secret.token}`,
+  ].join('\n')).join('\n\n');
+}
+
+async function gitSecretRemoveTool(args) {
+  const provider = normalizeProfileName(args.provider || '');
+  if (!provider) throw new Error('git_secret_remove requiere provider');
+  const name = String(args.name || '').trim();
+  const removed = removeGitSecret(provider, name);
+  return removed ? `Credencial eliminada: ${getGitSecretLabel(provider, name)}` : 'No encontre esa credencial.';
+}
+
+async function gitCloneRepoTool(args, state, paint) {
+  const repoUrl = String(args.repoUrl || '').trim();
+  if (!repoUrl) throw new Error('git_clone_repo requiere repoUrl');
+  const provider = normalizeProfileName(args.provider || '');
+  const name = String(args.name || '').trim();
+  const profile = provider ? resolveGitProfile(provider, name) : null;
+  const finalUrl = buildCloneUrl(repoUrl, profile || {});
+  const destination = args.destination ? resolveInputPath(args.destination, state.cwd) : '';
+  const timeoutMs = Math.max(1000, Number.isFinite(Number(args.timeoutMs)) ? Number(args.timeoutMs) : 10 * 60 * 1000);
+
+  const allowed = await askConfirmation(state.rl, 'Clonar repositorio', [
+    repoUrl,
+    profile ? `Provider: ${provider}${name ? ` (${name})` : ''}` : 'Provider: direct',
+    destination ? `Destino: ${destination}` : null,
+    `Timeout: ${timeoutMs}ms`,
+  ].filter(Boolean).join('\n'), paint, state);
+  if (!allowed) return 'Clonado cancelado por el usuario.';
+
+  const result = await runProcess('git', ['clone', ...(args.branch ? ['--branch', String(args.branch)] : []), finalUrl, ...(destination ? [destination] : [])], { cwd: state.cwd, timeoutMs });
+  const lines = [`Exit code: ${result.code}`];
+  if (result.timedOut) lines.push('Timeout: el clon fue detenido por tiempo.');
+  if (result.stdout.trim()) lines.push(`STDOUT:\n${result.stdout.trim()}`);
+  if (result.stderr.trim()) lines.push(`STDERR:\n${result.stderr.trim()}`);
+  return lines.join('\n\n');
+}
+
+async function gitApiRequestTool(args, state, paint) {
+  const provider = normalizeProfileName(args.provider || '');
+  if (!provider) throw new Error('git_api_request requiere provider');
+  const pathValue = String(args.path || '').trim();
+  if (!pathValue) throw new Error('git_api_request requiere path');
+  const name = String(args.name || '').trim();
+  const profile = resolveGitProfile(provider, name);
+  if (!profile) throw new Error(`No hay credenciales para ${provider}${provider === 'custom' && name ? `:${name}` : ''}`);
+  const baseUrl = getApiBaseUrl(provider, profile);
+  if (!baseUrl) throw new Error(`No hay apiBaseUrl para ${provider}`);
+  const url = `${baseUrl.replace(/\/+$/, '')}/${pathValue.replace(/^\/+/, '')}`;
+  const timeoutMs = Math.max(1000, Number.isFinite(Number(args.timeoutMs)) ? Number(args.timeoutMs) : 15000);
+  const method = String(args.method || 'GET').toUpperCase();
+  const headers = buildApiHeaders(provider, profile, args.headers && typeof args.headers === 'object' ? args.headers : {});
+
+  const allowed = await askConfirmation(state.rl, 'Git API request', `${method} ${url}\nTimeout: ${timeoutMs}ms`, paint, state);
+  if (!allowed) return 'Request cancelado por el usuario.';
+
+  const axios = require('axios');
+  const response = await axios({
+    url,
+    method,
+    headers: {
+      'User-Agent': 'Zyn/1.0',
+      Accept: 'application/json, text/plain, */*',
+      ...headers,
+    },
+    data: args.body && typeof args.body === 'object' ? args.body : args.body,
+    timeout: timeoutMs,
+    responseType: 'text',
+    validateStatus: () => true,
+  });
+
+  const text = typeof response.data === 'string' ? response.data : JSON.stringify(response.data, null, 2);
+  return `Status: ${response.status}\n\n${text}`;
+}

package/src/tui/app.mjs

@@ -17,9 +17,17 @@ const {
   DEFAULT_MODEL_KEY,
   MODELS,
 } = require('../config');
+const { normalizeLanguage } = require('../i18n');
 
 const h = React.createElement;
+function getTuiLang() {
+  return normalizeLanguage(global.__zynCurrentLanguage || 'en');
+}
+function uiText(en, es) {
+  return getTuiLang() === 'es' ? es : en;
+}
 const MAX_THINKING_LINES = 20;
+const MAX_PASTE_PREVIEW = 200;
 const SPIN_MS = 80;
 
 const SPIN_FRAMES = ['\u280b', '\u2819', '\u2839', '\u2838', '\u283c', '\u2834', '\u2826', '\u2827', '\u2807', '\u280f'];
@@ -372,7 +380,7 @@ function Banner({ model, resumed, width, cwd }) {
     return s + ' '.repeat(Math.max(0, inner - s.length));
   };
 
-  const sessionLabel = resumed ? 'sesion reanudada' : 'sesion nueva';
+  const sessionLabel = resumed ? uiText('session resumed', 'sesion reanudada') : uiText('new session', 'sesion nueva');
   const cwdShort = cwd && cwd.length > inner - 6 ? '...' + cwd.slice(-(inner - 9)) : (cwd || '.');
 
   return h(Box, { flexDirection: 'column', paddingTop: 1, paddingBottom: 0 },
@@ -429,10 +437,15 @@ function EventLine({ kind, title, detail }) {
   };
   const { sym, color } = cfg[kind] || cfg.info;
 
-  return h(Box, { paddingLeft: 5, gap: 1 },
-    h(Text, { color }, sym),
-    h(Text, { color: kind === 'tool' ? T.textDim : T.textMuted }, title),
-    detail ? h(Text, { color: T.textGhost }, detail) : null,
+  const compactTitle = String(title || '').replace(/\s{2,}/g, ' ').trim();
+  const compactDetail = String(detail || '').replace(/\s{2,}/g, ' ').trim();
+
+  return h(Box, { paddingLeft: 3, flexDirection: 'column' },
+    h(Box, { gap: 1 },
+      h(Text, { color }, sym),
+      h(Text, { color: kind === 'tool' ? T.textDim : T.textMuted, wrap: 'wrap' }, compactTitle),
+    ),
+    compactDetail ? h(Box, { paddingLeft: 2 }, h(Text, { color: T.textGhost, wrap: 'wrap' }, compactDetail)) : null,
   );
 }
 
@@ -441,7 +454,7 @@ function UserMessage({ text }) {
     h(Box, { flexDirection: 'column' },
       h(Box, { gap: 1, marginBottom: 0 },
         h(Text, { color: T.accent, bold: true }, '\u29bf'),
-        h(Text, { color: T.textDim, bold: true }, 'You'),
+        h(Text, { color: T.textDim, bold: true }, uiText('You', 'Tú')),
       ),
       h(Box, { paddingLeft: 2 },
         h(Text, { color: T.text, wrap: 'wrap' }, text),
@@ -465,17 +478,17 @@ function ThinkingBlock({ text, elapsed, live, width }) {
   const pulseChar = live ? SPIN_FRAMES[Math.floor(Date.now() / SPIN_MS) % SPIN_FRAMES.length] : '\u25d0';
 
   const label = live
-    ? pulseChar + '  Pensando...'
-    : '\u25d0  Penso ' + elapsed + 's';
+    ? pulseChar + '  ' + uiText('Thinking...', 'Pensando...')
+    : '\u25d0  ' + uiText('Thought for ', 'Pensó durante ') + elapsed + 's';
 
-  return h(Box, { flexDirection: 'column', paddingLeft: 5, marginTop: 1 },
+  return h(Box, { flexDirection: 'column', paddingLeft: 3, marginTop: 1 },
     h(Text, { color: T.textGhost }, label),
     lines.length > 0
-      ? h(Box, { flexDirection: 'column', paddingLeft: 2 },
+      ? h(Box, { flexDirection: 'column', paddingLeft: 1 },
           ...lines.map((line, i) =>
             h(Text, { key: String(i), color: T.textInvis, wrap: 'wrap' }, line),
           ),
-          more > 0 ? h(Text, { color: T.textGhost }, '\u00b7\u00b7\u00b7 ' + more + ' lineas mas') : null,
+          more > 0 ? h(Text, { color: T.textGhost }, '\u00b7\u00b7\u00b7 ' + more + ' ' + uiText('more lines', 'líneas más')) : null,
         )
       : null,
   );
@@ -534,10 +547,10 @@ function ConfirmBar({ title, detail }) {
       : null,
     h(Box, { marginTop: 0, paddingLeft: 2, gap: 2 },
       h(Text, { color: T.green, bold: true }, '[y]'),
-      h(Text, { color: T.textMuted }, 'permitir'),
+      h(Text, { color: T.textMuted }, uiText('allow', 'permitir')),
       h(Text, { color: T.textInvis }, '\u00b7'),
       h(Text, { color: T.red, bold: true }, '[n]'),
-      h(Text, { color: T.textMuted }, 'denegar'),
+      h(Text, { color: T.textMuted }, uiText('deny', 'denegar')),
     ),
   );
 }
@@ -566,13 +579,13 @@ function StatusBar({ model, processing, width, turnCount }) {
           ? h(Text, { color: T.accentSoft }, SPIN_FRAMES[frame])
           : null,
         turnCount > 0
-          ? h(Text, { color: T.textInvis }, '\u00b7 ' + turnCount + (turnCount === 1 ? ' turno' : ' turnos'))
+          ? h(Text, { color: T.textInvis }, '\u00b7 ' + turnCount + ' ' + uiText(turnCount === 1 ? 'turn' : 'turns', turnCount === 1 ? 'turno' : 'turnos'))
           : null,
       ),
       h(Box, { gap: 1 },
         h(Text, { color: T.textInvis }, '/help'),
         h(Text, { color: T.textInvis }, '\u00b7'),
-        h(Text, { color: T.textInvis }, 'esc salir'),
+        h(Text, { color: T.textInvis }, uiText('esc exit', 'esc salir')),
       ),
     ),
   );
@@ -709,8 +722,10 @@ function InputBar({ onSubmit, processing }) {
     }
 
     if (input && !key.ctrl && !key.meta) {
-      setValue(v => v.slice(0, cursor) + input + v.slice(cursor));
-      setCursor(c => c + input.length);
+      const normalizedInput = input.replace(/\r\n/g, '\n');
+      const safeInput = normalizedInput.includes('\n') ? normalizedInput.replace(/\n/g, ' ') : normalizedInput;
+      setValue(v => v.slice(0, cursor) + safeInput + v.slice(cursor));
+      setCursor(c => c + safeInput.length);
       setSuggestIdx(0);
     }
   });
@@ -721,7 +736,7 @@ function InputBar({ onSubmit, processing }) {
   const after = value.slice(cursor + 1);
 
   const promptColor = processing ? T.amber : T.accent;
-  const placeholder = processing ? ' En cola — escribe y se procesará después...' : ' Escribe un mensaje...';
+  const placeholder = processing ? uiText(' Queued — type and it will run later...', ' En cola — escribe y se procesará después...') : uiText(' Type a message...', ' Escribe un mensaje...');
 
   const inputLine = h(Box, { paddingLeft: 3, paddingRight: 3, paddingTop: 0, paddingBottom: 0, marginTop: 1 },
     h(Text, { color: promptColor }, processing ? '\u{1F4E9} ' : '\u276f '),
@@ -749,7 +764,7 @@ function InputBar({ onSubmit, processing }) {
     inputLine,
     h(Box, { flexDirection: 'column', paddingLeft: 5, marginTop: 0 },
       hasMore && windowStart > 0
-        ? h(Text, { color: T.textInvis }, '  \u2191 mas')
+        ? h(Text, { color: T.textInvis }, '  \u2191 ' + uiText('more', 'más'))
         : null,
       ...visible.map((cmd, i) => {
         const realIdx = windowStart + i;
@@ -766,10 +781,10 @@ function InputBar({ onSubmit, processing }) {
         );
       }),
       hasMore && windowStart + maxVisible < suggestions.length
-        ? h(Text, { color: T.textInvis }, '  \u2193 mas')
+        ? h(Text, { color: T.textInvis }, '  \u2193 ' + uiText('more', 'más'))
         : null,
       h(Box, { paddingTop: 0 },
-        h(Text, { color: T.textInvis }, 'Tab completar \u00b7 \u2191\u2193 navegar'),
+        h(Text, { color: T.textInvis }, uiText('Tab complete · ↑↓ navigate', 'Tab completar · ↑↓ navegar')),
       ),
     ),
   );
@@ -777,19 +792,20 @@ function InputBar({ onSubmit, processing }) {
 
 function App({ store, state, onSubmit }) {
   useStore(store);
+  global.__zynCurrentLanguage = state?.language || 'en';
   const { exit } = useApp();
   const { width } = useDimensions();
 
   const modelKey   = state?.activeModel || DEFAULT_MODEL_KEY;
   const modelLabel = state?.concuerdo
-    ? 'Concuerdo · ' + Object.values(MODELS).map(m => m.label).join(', ')
+    ? uiText('Concord · ', 'Concuerdo · ') + Object.values(MODELS).map(m => m.label).join(', ')
     : (MODELS[modelKey]?.label || modelKey).toLowerCase();
 
   const handleInput = useCallback((text) => {
     if (text === '/exit' || text === '/quit') {
       if (store.processing) {
         store.pendingExit = true;
-        store.addEvent('info', 'saliendo al terminar el turno actual');
+        store.addEvent('info', uiText('exiting after current turn', 'saliendo al terminar el turno actual'));
         return;
       }
       exit();
@@ -809,10 +825,10 @@ function App({ store, state, onSubmit }) {
             state.abortCurrentTurn();
           }
           store.pendingExit = false;
-          store.addEvent('warn', 'agente detenido', 'Interrumpido con ESC x2');
+          store.addEvent('warn', uiText('agent stopped', 'agente detenido'), uiText('Interrupted with ESC x2', 'Interrumpido con ESC x2'));
         } else {
           store.lastEscapeAt = now;
-          store.addEvent('info', 'pulsa ESC otra vez', 'para detener el agente');
+          store.addEvent('info', uiText('press ESC again', 'pulsa ESC otra vez'), uiText('to stop the agent', 'para detener el agente'));
         }
         return;
       }
@@ -914,7 +930,7 @@ export async function startTUI(options = {}) {
   const processInput = async (input) => {
     if (input === '/exit' || input === '/quit') {
       store.pendingExit = true;
-      store.addEvent('info', 'hasta luego');
+      store.addEvent('info', uiText('bye', 'hasta luego'));
       return;
     }
 
@@ -942,9 +958,9 @@ export async function startTUI(options = {}) {
           const clean = lines.filter(l => l.trim()).join('\n');
           if (clean) store.addItem({ type: 'system', text: clean });
         }
-        if (!handled) store.addEvent('warn', 'comando no reconocido', input);
+        if (!handled) store.addEvent('warn', uiText('command not recognized', 'comando no reconocido'), input);
       } catch (err) {
-        store.addEvent('error', 'error', err.message);
+        store.addEvent('error', uiText('error', 'error'), err.message);
       } finally {
         console.log = origLog;
         console.error = origError;
@@ -983,6 +999,13 @@ export async function startTUI(options = {}) {
   let appInstance = null;
 
   const handleSubmit = async (input) => {
+    if (typeof input === 'string' && input.length > MAX_PASTE_PREVIEW) {
+      store.addEvent(
+        'info',
+        `[ ${uiText('Pasted Text', 'Texto pegado')} of ${input.length} ${uiText('Characters', 'Caracteres')} ]`,
+        input.slice(0, MAX_PASTE_PREVIEW) + '...'
+      );
+    }
     if (input.startsWith('/') && store.processing) {
       await processInput(input);
       return;