@danieltmn/tamnora 0.21.2 → 0.23.0

package/harness/packages/server/src/auth.js

@@ -125,17 +125,19 @@ export function requireCsrf(app, req, res) {
 // ---------------------------------------------------------------------------
 // Bloqueo por intentos fallidos (en memoria: el server es un proceso).
 // ---------------------------------------------------------------------------
-// La clave usa remoteAddress: X-Forwarded-For lo controla el cliente y con un
-// header falsificado se rotaba de IP y se esquivaba el bloqueo.
+// La clave es solo la IP: con `ip|usuario` cada intento con un nombre distinto
+// tenia su propio contador y el bloqueo se esquivaba rotando el username. Y el
+// usuario se ignora a proposito: X-Forwarded-For lo controla el cliente y con
+// un header falsificado se rotaba de IP y se esquivaba el bloqueo.
 const MAX_ATTEMPTS = 5;
 const WINDOW_MS = 15 * 60 * 1000;
 const LOCK_MS = 15 * 60 * 1000;
 const MAX_KEYS = 256;
 const attempts = new Map();
 
-function clientKey(req, user) {
+function clientKey(req) {
   const ip = (req.socket && req.socket.remoteAddress) || 'desconocido';
-  return `${ip}|${String(user || '').trim().toLowerCase()}`;
+  return String(ip);
 }
 
 function sweepStale(now) {
@@ -146,18 +148,18 @@ function sweepStale(now) {
   }
 }
 
-export function loginLockRemaining(req, user) {
+export function loginLockRemaining(req) {
   const now = Date.now();
-  const st = attempts.get(clientKey(req, user));
+  const st = attempts.get(clientKey(req));
   if (!st || !st.lockUntil) return 0;
   const left = st.lockUntil - now;
   return left > 0 ? Math.ceil(left / 1000) : 0;
 }
 
-export function loginRecordFailure(req, user) {
+export function loginRecordFailure(req) {
   const now = Date.now();
   sweepStale(now);
-  const key = clientKey(req, user);
+  const key = clientKey(req);
   let st = attempts.get(key);
   if (!st || (!st.lockUntil && now - st.first > WINDOW_MS)) st = { count: 0, first: now, lockUntil: 0 };
   st.count += 1;
@@ -165,6 +167,6 @@ export function loginRecordFailure(req, user) {
   attempts.set(key, st);
 }
 
-export function loginClear(req, user) {
-  attempts.delete(clientKey(req, user));
+export function loginClear(req) {
+  attempts.delete(clientKey(req));
 }

package/harness/packages/server/src/lib/agentRun.js

@@ -49,7 +49,12 @@ export function combineLifecycle(handlers = []) {
     for (const handler of active) {
       const out = await Promise.resolve()
         .then(() => handler(event))
-        .catch(() => undefined);
+        .catch((error) => {
+          // El run no se corta por un handler, pero el fallo no puede ser
+          // invisible: sin esto un hook/regla roto desaparece sin rastro.
+          process.stderr.write(`tamnora: handler de ciclo de vida falló: ${error?.message ?? error}\n`);
+          return undefined;
+        });
       if (out && typeof out === 'object' && typeof out.inject === 'string' && out.inject.trim()) {
         injects.push(out.inject);
       }

package/harness/packages/server/src/lib/channels/telegram/api.js

@@ -0,0 +1,102 @@
+// Cliente crudo del API de Telegram. Nada de logica del canal aca: solo la
+// llamada HTTP, con sus variantes (json y multipart) y el manejo de errores.
+
+const API = 'https://api.telegram.org';
+
+async function tg(token, method, payload) {
+  const res = await fetch(`${API}/bot${token}/${method}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload ?? {}),
+  });
+  let data = null;
+  try {
+    data = await res.json();
+  } catch {
+    data = null;
+  }
+  if (!data?.ok) {
+    const error = new Error(data?.description || `HTTP ${res.status}`);
+    error.status = res.status;
+    throw error;
+  }
+  return data.result;
+}
+
+/** Variante multipart de `tg` (sendVoice/sendAudio llevan el archivo adjunto). */
+async function tgForm(token, method, form) {
+  const res = await fetch(`${API}/bot${token}/${method}`, { method: 'POST', body: form });
+  let data = null;
+  try {
+    data = await res.json();
+  } catch {
+    data = null;
+  }
+  if (!data?.ok) {
+    const error = new Error(data?.description || `HTTP ${res.status}`);
+    error.status = res.status;
+    throw error;
+  }
+  return data.result;
+}
+
+async function downloadFile(token, fileId) {
+  const file = await tg(token, 'getFile', { file_id: fileId });
+  const res = await fetch(`${API}/file/bot${token}/${file.file_path}`);
+  if (!res.ok) throw new Error(`no se pudo bajar el archivo (HTTP ${res.status})`);
+  return Buffer.from(await res.arrayBuffer());
+}
+
+/** Valida un token consultando `getMe`. Devuelve `{ ok, username, name }` o `{ ok:false, error }`. */
+export async function getTelegramBotInfo(token) {
+  if (!token) return { ok: false, error: 'Falta el token.' };
+  try {
+    const result = await tg(token, 'getMe', {});
+    return { ok: true, username: result?.username ?? null, name: result?.first_name ?? null };
+  } catch (error) {
+    return { ok: false, error: error?.message ?? String(error) };
+  }
+}
+
+/** Telegram corta los mensajes largos: se parten y se mandan de a trozos. */
+function splitMessage(text, max = 3900) {
+  const value = String(text ?? '').trim() || '(sin texto)';
+  const parts = [];
+  for (let i = 0; i < value.length; i += max) parts.push(value.slice(i, i + max));
+  return parts;
+}
+
+/** Manda `text` a un chat (partido si hace falta) y devuelve el primer mensaje. */
+async function send(T, chatId, text, extra = {}) {
+  let first = null;
+  for (const chunk of splitMessage(text)) {
+    const result = await tg(T.token, 'sendMessage', {
+      chat_id: chatId,
+      text: chunk,
+      disable_web_page_preview: true,
+      ...extra,
+    });
+    if (!first) first = result;
+  }
+  return first;
+}
+
+/** Edita un mensaje ya enviado (el resto del texto sale como mensajes nuevos). */
+async function edit(T, chatId, messageId, text) {
+  const parts = splitMessage(text);
+  await tg(T.token, 'editMessageText', {
+    chat_id: chatId,
+    message_id: messageId,
+    text: parts[0],
+    disable_web_page_preview: true,
+  }).catch(() => null);
+  for (let i = 1; i < parts.length; i++) {
+    await tg(T.token, 'sendMessage', {
+      chat_id: chatId,
+      text: parts[i],
+      disable_web_page_preview: true,
+    }).catch(() => null);
+  }
+}
+
+export { API, downloadFile, edit, send, splitMessage, tg, tgForm };

package/harness/packages/server/src/lib/channels/telegram/commands.js

@@ -0,0 +1,309 @@
+// Mensajes entrantes de Telegram: comandos (`/proyecto`, `/model`, ...), notas
+// de voz, fotos y los botones de los paneles.
+
+import { resolveMode, listProviderModels, PROVIDER_META } from '../../core.js';
+import { downloadFile, send, tg } from './api.js';
+import { enviarNotaDeVoz } from './media.js';
+import {
+  activeSessionId,
+  projectLabel,
+  projectRoot,
+  resolveProjectArg,
+  selectProject,
+  sendProjectPicker,
+} from './projects.js';
+import { resumirSesion, run } from './run.js';
+import { transcribeAudio } from '../../transcribe.js';
+
+const HELP = [
+  'Tamnora Harness — bot',
+  '',
+  '/proyecto [nombre] — elegí el proyecto (sin argumento: lista)',
+  '/new — nueva sesión (vuelve a preguntar el proyecto)',
+  '/resumen — resumen en texto de la conversación',
+  '/audioresumen — el resumen como nota de voz',
+  '/menu — panel con botones (modelo, modo, proveedor)',
+  '/status — proveedor, modelo, modo, proyecto y sesión',
+  '/model [id] — cambia el modelo (sin id: lista con botones)',
+  '/provider [id] — cambia el proveedor (sin id: lista)',
+  '/mode [plan|build] — cambia el modo (sin arg: panel)',
+  '/estricto [on|off] — el agente hace solo lo pedido (sin arg: alterna)',
+  '/stop — cancela la respuesta en curso',
+  '/help — esta ayuda',
+  '',
+  'Podés mandar texto, imágenes o notas de voz.',
+].join('\n');
+
+function transcribe(T, buffer, filename) {
+  return transcribeAudio(T.ctx, {
+    buffer,
+    filename,
+    providerId: T.transcribeProvider || undefined,
+    model: T.transcribeModel,
+  });
+}
+
+export async function sendMenu(T, chatId) {
+  const sessionId = activeSessionId(T, chatId);
+  const session = sessionId ? T.ctx.store.getSession(sessionId) : null;
+  const providerId = session?.provider || T.ctx.effectiveProviderId();
+  const model = session?.model || T.ctx.effectiveModel() || '-';
+  const mode = resolveMode(T.ctx.effectiveMode());
+  const text = [
+    '⚙ Panel',
+    `proyecto: ${session ? projectLabel(session) : '(elegí con /proyecto)'}`,
+    `proveedor: ${providerId}`,
+    `modelo: ${model}`,
+    `modo: ${mode.label}`,
+  ].join('\n');
+  await send(T, chatId, text, {
+    reply_markup: {
+      inline_keyboard: [
+        [
+          { text: mode.id === 'plan' ? '⚙ Plan' : 'Plan', callback_data: 'mode:plan' },
+          { text: mode.id === 'agent' ? '⚙ Build' : 'Build', callback_data: 'mode:agent' },
+        ],
+        [
+          { text: 'modelos', callback_data: 'menu:models' },
+          { text: 'proveedores', callback_data: 'menu:providers' },
+        ],
+        [
+          { text: '?? proyecto', callback_data: 'menu:project' },
+          { text: '?? nueva', callback_data: 'menu:new' },
+        ],
+        [{ text: '⚙ detener', callback_data: 'menu:stop' }],
+      ],
+    },
+  });
+}
+
+export async function sendModels(T, chatId) {
+  const sessionId = activeSessionId(T, chatId);
+  const session = sessionId ? T.ctx.store.getSession(sessionId) : null;
+  const providerId = session?.provider || T.ctx.effectiveProviderId();
+  const models = await listProviderModels({
+    ...T.ctx.providerSettings(providerId),
+    apiKey: T.ctx.apiKeyFor(providerId),
+  }).catch(() => []);
+
+  const current = session?.model || T.ctx.effectiveModel();
+  if (!models?.length) return send(T, chatId, 'No pude listar modelos. Usá /model <id>.');
+  const capped = models.slice(0, 12);
+  T.modelChoices.set(String(chatId), capped.map((m) => m.id));
+  const rows = capped.map((m, i) => [
+    { text: `${m.id === current ? '? ' : ''}${m.label || m.id}`, callback_data: `model:${i}` },
+  ]);
+  rows.push([{ text: '< panel', callback_data: 'menu:home' }]);
+  await send(T, chatId, `Modelos de ${providerId} (elegí uno):`, { reply_markup: { inline_keyboard: rows } });
+  if (models.length > capped.length) {
+    send(T, chatId, `Hay ${models.length} modelos; mostré 12. Para otro, usá /model <id>.`).catch(() => {});
+  }
+}
+
+export async function sendProviders(T, chatId) {
+  const custom = T.ctx.customProviderDefs?.() ?? [];
+  const ids = [...new Set([...PROVIDER_META.map((p) => p.id), ...custom.map((p) => p.id)])];
+  const current = T.ctx.effectiveProviderId();
+  const rows = ids.map((id) => [{ text: `${id === current ? '? ' : ''}${id}`, callback_data: `provider:${id}` }]);
+  rows.push([{ text: '< panel', callback_data: 'menu:home' }]);
+  await send(T, chatId, 'Proveedores (elegí uno):', { reply_markup: { inline_keyboard: rows } });
+}
+
+export async function handleCommand(T, chatId, text) {
+  const [raw, ...rest] = text.slice(1).split(/\s+/);
+  const cmd = raw.toLowerCase();
+  const arg = rest.join(' ').trim();
+  const sessionId = activeSessionId(T, chatId);
+  if (cmd === 'start') {
+    if (sessionId) {
+      return send(T, chatId, `Hola. Proyecto actual: «${projectLabel(T.ctx.store.getSession(sessionId))}».\n\n${HELP}`);
+    }
+    return sendProjectPicker(T, chatId, { text: 'Hola. ¿En qué proyecto vas a trabajar?' });
+  }
+  if (cmd === 'help' || cmd === 'ayuda') return send(T, chatId, HELP);
+  if (cmd === 'menu' || cmd === 'panel' || cmd === 'config') return sendMenu(T, chatId);
+  if (cmd === 'new' || cmd === 'nueva') {
+    T.ctx.store.setSetting(T.sessionKey(chatId), null);
+    T.pendingInputs.delete(String(chatId));
+    return sendProjectPicker(T, chatId, { text: 'Nueva sesión. ¿En qué proyecto vas a trabajar?' });
+  }
+  if (cmd === 'proyecto' || cmd === 'proyectos' || cmd === 'project') {
+    if (!arg) return sendProjectPicker(T, chatId);
+    const projectPath = resolveProjectArg(T, arg);
+    if (!projectPath) {
+      return send(T, chatId, `No encontré el proyecto "${arg}". Usá /proyecto sin argumento para ver la lista.`);
+    }
+    return selectProject(T, chatId, projectPath);
+  }
+  if (cmd === 'status') {
+    const session = sessionId ? T.ctx.store.getSession(sessionId) : null;
+    return send(
+      T,
+      chatId,
+      `proyecto: ${session ? projectLabel(session) : '-'}\nproveedor: ${session?.provider || T.ctx.effectiveProviderId()}\nmodelo: ${session?.model || T.ctx.effectiveModel() || '-'}\nmodo: ${T.ctx.effectiveMode()}\nsolo lo pedido: ${T.ctx.store.getSetting('strictScope') === true ? 'sí' : 'no'}\nsesión: ${session?.title || '-'}`,
+    );
+  }
+  if (cmd === 'resumen' || cmd === 'resume') {
+    if (!sessionId) return send(T, chatId, 'No hay una conversación todavía. Elegí un proyecto con /proyecto.');
+    const data = await resumirSesion(T, sessionId).catch((error) => ({ error: error.message }));
+    if (data.error) return send(T, chatId, `No pude resumir: ${data.error}`);
+    return send(T, chatId, `?📝 Resumen\n\n${data.summary}`);
+  }
+  if (cmd === 'audioresumen' || cmd === 'audio-resumen') {
+    if (!sessionId) return send(T, chatId, 'No hay una conversación todavía. Elegí un proyecto con /proyecto.');
+    await send(T, chatId, '?📝 Preparando el resumen.');
+    const data = await resumirSesion(T, sessionId).catch((error) => ({ error: error.message }));
+    if (data.error) return send(T, chatId, `No pude resumir: ${data.error}`);
+    await send(T, chatId, `?📝 Resumen\n\n${data.summary}`);
+    return enviarNotaDeVoz(T, chatId, data.summary);
+  }
+  if (cmd === 'model' || cmd === 'modelo') {
+    if (!arg) return sendModels(T, chatId);
+    T.ctx.store.setSetting('activeModel', arg);
+    if (sessionId) T.ctx.store.touchSession(sessionId, { model: arg });
+    return send(T, chatId, `modelo: ${arg}`);
+  }
+  if (cmd === 'provider' || cmd === 'proveedor') {
+    if (!arg) return sendProviders(T, chatId);
+    T.ctx.store.setSetting('activeProvider', arg);
+    if (sessionId) T.ctx.store.touchSession(sessionId, { provider: arg });
+    return send(T, chatId, `proveedor: ${arg}`);
+  }
+  if (cmd === 'mode' || cmd === 'modo') {
+    if (!arg) return sendMenu(T, chatId);
+    const id = arg.toLowerCase() === 'build' ? 'agent' : arg.toLowerCase();
+    T.ctx.store.setSetting('activeMode', resolveMode(id).id);
+    return send(T, chatId, `modo: ${resolveMode(id).label}`);
+  }
+  if (cmd === 'stop' || cmd === 'parar') {
+    T.controllers.get(String(chatId))?.abort();
+    return send(T, chatId, 'Cancelando.');
+  }
+  if (cmd === 'estricto' || cmd === 'strict') {
+    const current = T.ctx.store.getSetting('strictScope') === true;
+    const value = arg ? /^(on|si|sí|1|true)$/i.test(arg) : !current;
+    T.ctx.store.setSetting('strictScope', value);
+    return send(T, chatId, `solo lo pedido: ${value ? 'activado' : 'desactivado'}`);
+  }
+  return send(T, chatId, `Comando desconocido: /${cmd}.\n\n${HELP}`);
+}
+
+export async function handleVoice(T, chatId, voice) {
+  await send(T, chatId, '?📝 Transcribiendo.');
+  try {
+    const buffer = await downloadFile(T.token, voice.file_id);
+    const text = await transcribe(T, buffer, voice.file_name || 'audio.ogg');
+    if (!text) return send(T, chatId, 'No pude transcribir el audio.');
+    await send(T, chatId, `?? ${text}`);
+    return deliver(T, chatId, text);
+  } catch (error) {
+    return send(T, chatId, `No pude procesar el audio: ${error.message}`);
+  }
+}
+
+/** Entrega un mensaje: si no hay proyecto elegido, primero pregunta cuál. */
+export async function deliver(T, chatId, input, images = []) {
+  if (!activeSessionId(T, chatId)) {
+    T.pendingInputs.set(String(chatId), { input, images });
+    return sendProjectPicker(T, chatId);
+  }
+  return run(T, chatId, input, images);
+}
+
+export async function handleMessage(T, message) {
+  const chatId = String(message.chat.id);
+  if (!T.authorized(chatId)) {
+    await send(T, chatId, `No autorizado. Tu chat id es ${chatId}; agregalo a telegram.allowedChatIds para habilitarlo.`);
+    return;
+  }
+  const text = String(message.text ?? message.caption ?? '').trim();
+  if (text.startsWith('/')) {
+    await handleCommand(T, chatId, text);
+    return;
+  }
+  if (message.voice || message.audio) {
+    await handleVoice(T, chatId, message.voice ?? message.audio);
+    return;
+  }
+  if (message.photo?.length) {
+    try {
+      const largest = message.photo[message.photo.length - 1];
+      const buffer = await downloadFile(T.token, largest.file_id);
+      const dataUrl = `data:image/jpeg;base64,${buffer.toString('base64')}`;
+      await deliver(T, chatId, text || '(imagen)', [dataUrl]);
+    } catch (error) {
+      await send(T, chatId, `No pude procesar la imagen: ${error.message}`);
+    }
+    return;
+  }
+  if (text) await deliver(T, chatId, text);
+}
+
+export async function handleCallback(T, query) {
+  const chatId = String(query.message?.chat.id ?? '');
+  const [kind, a, b] = String(query.data ?? '').split(':');
+  let toast = '';
+
+  if (kind === 'perm') {
+    const all = b === 'all';
+    T.ctx.approvals.decide(a, b === 'allow' || all);
+    const sessionId = T.askSessions.get(a);
+    if (sessionId) T.askSessions.delete(a);
+    if (all && sessionId) T.ctx.setAutoApprove?.(sessionId, true);
+    toast = all ? 'Permitidos todos' : b === 'allow' ? 'Permitido' : 'Denegado';
+  } else if (kind === 'proj') {
+    if (a === 'root') {
+      await selectProject(T, chatId, projectRoot(T));
+      toast = 'Proyecto elegido';
+    } else {
+      const choice = (T.projectChoices.get(chatId) ?? [])[Number(a)];
+      if (choice) {
+        await selectProject(T, chatId, choice.path);
+        toast = `Proyecto ${choice.name}`;
+      } else {
+        toast = 'Elegí de nuevo';
+      }
+    }
+  } else if (kind === 'mode') {
+    T.ctx.store.setSetting('activeMode', resolveMode(a).id);
+    toast = `Modo ${resolveMode(a).label}`;
+  } else if (kind === 'provider') {
+    T.ctx.store.setSetting('activeProvider', a);
+    const sid = activeSessionId(T, chatId);
+    if (sid) T.ctx.store.touchSession(sid, { provider: a });
+    toast = `Proveedor ${a}`;
+  } else if (kind === 'model') {
+    const id = (T.modelChoices.get(chatId) ?? [])[Number(a)];
+    if (id) {
+      T.ctx.store.setSetting('activeModel', id);
+      const sid = activeSessionId(T, chatId);
+      if (sid) T.ctx.store.touchSession(sid, { model: id });
+      toast = `Modelo ${id}`;
+    }
+  } else if (kind === 'menu') {
+    if (a === 'models') await sendModels(T, chatId);
+    else if (a === 'providers') await sendProviders(T, chatId);
+    else if (a === 'home') await sendMenu(T, chatId);
+    else if (a === 'project') await sendProjectPicker(T, chatId, { text: 'Elegí el proyecto:' });
+    else if (a === 'new') {
+      T.ctx.store.setSetting(T.sessionKey(chatId), null);
+      T.pendingInputs.delete(String(chatId));
+      await sendProjectPicker(T, chatId, { text: 'Nueva sesión. ¿En qué proyecto vas a trabajar?' });
+    } else if (a === 'stop') {
+      T.controllers.get(chatId)?.abort();
+      await send(T, chatId, 'Cancelando.');
+    }
+    toast = 'ok';
+  }
+
+  await tg(T.token, 'answerCallbackQuery', { callback_query_id: query.id, text: toast }).catch(() => null);
+  // Solo los permisos cierran su tarjeta; el panel conserva los botones.
+  if (kind === 'perm' && query.message) {
+    await tg(T.token, 'editMessageReplyMarkup', {
+      chat_id: query.message.chat.id,
+      message_id: query.message.message_id,
+    }).catch(() => null);
+  }
+}
+
+export { HELP };

package/harness/packages/server/src/lib/channels/telegram/media.js

@@ -0,0 +1,64 @@
+// Entrega de multimedia a un chat: fotos (capturas del tool `screenshot`) y
+// notas de voz (TTS). Un fallo del servicio no debe romper el run.
+
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { sintetizar, MAX_TEXTO, screenshotsDir } from '../../core.js';
+import { mp3AOgg } from '../../ffmpeg.js';
+import { resolveTts } from '../../ttsSettings.js';
+import { tgForm } from './api.js';
+
+/**
+ * Nota de voz con un texto cualquiera. Con ffmpeg manda OGG/Opus
+ * (`sendVoice`, aparece como nota de voz); sin ffmpeg cae a audio MP3.
+ */
+export async function enviarNotaDeVoz(T, chatId, texto, { voice, rate, pitch } = {}) {
+  const tts = resolveTts(T.ctx.app);
+  const frase = String(texto ?? '').trim().slice(0, MAX_TEXTO);
+  if (!frase) return;
+  try {
+    const mp3 = await sintetizar(frase, {
+      voice: voice || tts.voice,
+      rate: rate || tts.rate,
+      pitch: pitch || tts.pitch,
+    });
+    const ogg = await mp3AOgg(mp3);
+    const form = new FormData();
+    form.append('chat_id', chatId);
+    if (ogg) {
+      form.append('voice', new Blob([ogg], { type: 'audio/ogg' }), 'resumen.ogg');
+      await tgForm(T.token, 'sendVoice', form);
+    } else {
+      form.append('audio', new Blob([mp3], { type: 'audio/mpeg' }), 'resumen.mp3');
+      await tgForm(T.token, 'sendAudio', form);
+    }
+  } catch (error) {
+    T.log(`telegram: nota de voz falló: ${error?.message ?? error}`);
+  }
+}
+
+/** Manda una imagen (una captura del tool `screenshot`). */
+export async function enviarFoto(T, chatId, buffer, caption) {
+  try {
+    const form = new FormData();
+    form.append('chat_id', chatId);
+    if (caption) form.append('caption', String(caption).slice(0, 1000));
+    form.append('photo', new Blob([buffer], { type: 'image/png' }), 'captura.png');
+    await tgForm(T.token, 'sendPhoto', form);
+  } catch (error) {
+    T.log(`telegram: foto falló: ${error?.message ?? error}`);
+  }
+}
+
+/** Entrega una captura guardada en la casa (por nombre, sin path traversal). */
+export async function enviarCaptura(T, chatId, name, caption) {
+  const safe = String(name ?? '');
+  if (!/^[a-z0-9][a-z0-9-]*\.png$/i.test(safe)) return;
+  let buffer;
+  try {
+    buffer = await readFile(path.join(screenshotsDir(), safe));
+  } catch {
+    return;
+  }
+  await enviarFoto(T, chatId, buffer, caption);
+}

package/harness/packages/server/src/lib/channels/telegram/projects.js

@@ -0,0 +1,102 @@
+// Elegir proyecto: un chat de Telegram arranca eligiendo en qué carpeta de la
+// raíz trabajar, y cada proyecto tiene su propia sesión del harness.
+
+import path from 'node:path';
+import { resolveExistingDir, listSubdirs } from '../../workspace.js';
+import { send } from './api.js';
+
+export const MAX_PROJECTS = 24;
+
+/** Carpeta raíz para elegir proyecto: la predeterminada de la consola o el cwd. */
+export function projectRoot(T) {
+  const stored = T.ctx.store.getSetting('defaultCwd');
+  const candidate = stored || T.root || T.ctx.cwd;
+  try {
+    return resolveExistingDir(candidate);
+  } catch {
+    return T.ctx.cwd;
+  }
+}
+
+export function listProjects(T) {
+  try {
+    return listSubdirs(projectRoot(T)).map((dir) => ({ name: dir.name, path: dir.path }));
+  } catch {
+    return [];
+  }
+}
+
+export function projectLabel(session) {
+  const cwd = session?.cwd || '';
+  return cwd ? path.basename(cwd) : 'sin carpeta';
+}
+
+/** Un proyecto está habilitado si alguna pestaña abierta de la consola lo usa. */
+export function projectIsOpen(T, session) {
+  const ids = T.ctx.presence?.ids?.() ?? [];
+  if (!ids.length) return false;
+  const cwd = session?.cwd || '';
+  return ids.some((id) => {
+    const open = T.ctx.store.getSession(id);
+    return open && (open.cwd || '') === cwd;
+  });
+}
+
+export function activeSessionId(T, chatId) {
+  const id = T.ctx.store.getSetting(T.sessionKey(chatId));
+  if (id && T.ctx.store.getSession(id)) return id;
+  return null;
+}
+
+export function createSessionForProject(T, chatId, cwd) {
+  const sessionId = T.ctx.store.createSession({
+    title: path.basename(cwd) || `Telegram ${chatId}`,
+    provider: T.ctx.effectiveProviderId(),
+    model: T.ctx.effectiveModel(),
+    cwd,
+    meta: { telegramChatId: String(chatId) },
+  });
+  T.ctx.store.setSetting(T.sessionKey(chatId), sessionId);
+  T.ctx.store.setSetting(T.reverseKey(sessionId), String(chatId));
+  return sessionId;
+}
+
+export function resolveProjectArg(T, arg) {
+  const value = String(arg ?? '').trim();
+  if (!value) return null;
+  if (/[\\/]/.test(value) || /^[a-zA-Z]:/.test(value)) return value;
+  const projects = listProjects(T);
+  const exact = projects.find((p) => p.name.toLowerCase() === value.toLowerCase());
+  if (exact) return exact.path;
+  const matches = projects.filter((p) => p.name.toLowerCase().includes(value.toLowerCase()));
+  return matches.length === 1 ? matches[0].path : null;
+}
+
+export async function sendProjectPicker(T, chatId, { text } = {}) {
+  const base = projectRoot(T);
+  const all = listProjects(T);
+  const shown = all.slice(0, MAX_PROJECTS);
+  T.projectChoices.set(String(chatId), shown);
+  const rows = shown.map((project, index) => [{ text: project.name, callback_data: `proj:${index}` }]);
+  rows.push([{ text: `?? usar «${path.basename(base)}»`, callback_data: 'proj:root' }]);
+  const intro = text || '¿En qué proyecto vas a trabajar?';
+  await send(T, chatId, `${intro}\n\nraíz: ${base}`, { reply_markup: { inline_keyboard: rows } });
+  if (all.length > shown.length) {
+    await send(T, chatId, `Hay ${all.length} proyectos; mostré ${shown.length}. Para otro, usá /proyecto <nombre>.`);
+  }
+}
+
+export async function selectProject(T, chatId, projectPath) {
+  let cwd;
+  try {
+    cwd = resolveExistingDir(projectPath);
+  } catch (error) {
+    return send(T, chatId, `No pude usar ese proyecto: ${error.message}`);
+  }
+  createSessionForProject(T, chatId, cwd);
+  const key = String(chatId);
+  const pending = T.pendingInputs.get(key);
+  T.pendingInputs.delete(key);
+  await send(T, chatId, `Proyecto «${path.basename(cwd)}».${pending ? '' : ' Mandá tu mensaje.'}`);
+  if (pending) T.run(T, chatId, pending.input, pending.images).catch((error) => T.log(`telegram: ${error?.message ?? error}`));
+}