@danieltmn/tamnora 0.1.0 → 0.2.0

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

@@ -0,0 +1,267 @@
+import { runAgent, createTools, resolveMode } from './core.js';
+import { resolveExistingDir } from './workspace.js';
+
+const API = 'https://api.telegram.org';
+
+const HELP = [
+  'Tamnora Harness — bot',
+  '',
+  '/new — nueva sesión',
+  '/status — proveedor, modelo, modo y sesión',
+  '/model <id> — cambia el modelo',
+  '/provider <id> — cambia el proveedor',
+  '/mode plan|build — cambia el modo',
+  '/stop — cancela la respuesta en curso',
+  '/help — esta ayuda',
+  '',
+  'Cualquier otro texto se envía al agente.',
+].join('\n');
+
+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;
+}
+
+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;
+}
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+/**
+ * Bot de Telegram por long polling (no necesita URL publica). Los chats
+ * autorizados conversan con el mismo engine del harness; cada chat mapea a una
+ * sesion. Devuelve `{ stop }` o `null` si no hay token.
+ */
+export function startTelegramBot(ctx, { token, allowedChatIds = [], log = () => {} } = {}) {
+  if (!token) return null;
+  const allowed = new Set(allowedChatIds.map(String));
+  const controllers = new Map();
+  let running = true;
+  let offset = 0;
+
+  const authorized = (chatId) => allowed.size > 0 && allowed.has(String(chatId));
+  const sessionKey = (chatId) => `telegram:chat:${chatId}`;
+
+  async function send(chatId, text) {
+    let first = null;
+    for (const chunk of splitMessage(text)) {
+      const result = await tg(token, 'sendMessage', { chat_id: chatId, text: chunk, disable_web_page_preview: true });
+      if (!first) first = result;
+    }
+    return first;
+  }
+
+  async function edit(chatId, messageId, text) {
+    const parts = splitMessage(text);
+    await tg(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(token, 'sendMessage', { chat_id: chatId, text: parts[i], disable_web_page_preview: true }).catch(() => null);
+    }
+  }
+
+  function ensureSession(chatId) {
+    const key = sessionKey(chatId);
+    let sessionId = ctx.store.getSetting(key);
+    if (!sessionId || !ctx.store.getSession(sessionId)) {
+      sessionId = ctx.store.createSession({
+        title: `Telegram ${chatId}`,
+        provider: ctx.effectiveProviderId(),
+        model: ctx.effectiveModel(),
+        cwd: ctx.cwd,
+        meta: { telegramChatId: String(chatId) },
+      });
+      ctx.store.setSetting(key, sessionId);
+    }
+    return sessionId;
+  }
+
+  async function run(chatId, input) {
+    const sessionId = ensureSession(chatId);
+    const session = ctx.store.getSession(sessionId);
+    const providerId = session.provider || ctx.effectiveProviderId();
+    const model = session.model || ctx.effectiveModel();
+    if (!model) {
+      await send(chatId, 'Falta el modelo. Usá /model <id> o configurá uno en Ajustes.');
+      return;
+    }
+    const mode = resolveMode(ctx.effectiveMode());
+    const cwd = resolveExistingDir(session.cwd || ctx.cwd);
+    const history = ctx.store.getMessages(sessionId);
+
+    let mcp = null;
+    try {
+      mcp = await ctx.getMcp();
+    } catch {
+      mcp = null;
+    }
+
+    const local = createTools({
+      root: cwd,
+      enabled: mode.tools ?? undefined,
+      permissions: ctx.config.permissions,
+      yes: false,
+      mcp,
+    });
+    const exposeAdmin = !mode.tools;
+    const admin = ctx.agentTools;
+    const definitions = exposeAdmin ? [...local.definitions, ...admin.definitions] : local.definitions;
+    const execute = (name, args, context) =>
+      exposeAdmin && admin.handles(name)
+        ? admin.execute(name, args, { approve: async () => false })
+        : local.execute(name, args, context);
+    const { provider, config } = ctx.resolveProvider({
+      ...ctx.providerSettings(providerId),
+      apiKey: ctx.apiKeyFor(providerId),
+    });
+    const basePrompt = await ctx.systemPromptFor(cwd);
+    const messages = [
+      { role: 'system', content: mode.systemPrompt ? `${basePrompt}\n\n${mode.systemPrompt}` : basePrompt },
+      ...history,
+      { role: 'user', content: input },
+    ];
+
+    const controller = new AbortController();
+    controllers.set(String(chatId), controller);
+    const message = await send(chatId, '…');
+    let full = '';
+    let lastEdit = 0;
+
+    try {
+      const result = await runAgent({
+        provider,
+        config,
+        model,
+        messages,
+        tools: definitions,
+        execute,
+        signal: controller.signal,
+        maxRounds: ctx.config.maxRounds,
+        onEvent(event) {
+          if (event.type !== 'text') return;
+          full = event.full;
+          const now = Date.now();
+          if (now - lastEdit > 1200) {
+            lastEdit = now;
+            edit(chatId, message.message_id, full || '…');
+          }
+        },
+      });
+      await edit(chatId, message.message_id, result.content?.trim() || full || '(sin texto)');
+      const newMessages = result.messages.slice(1 + history.length);
+      ctx.store.addMessages(sessionId, newMessages);
+      ctx.store.touchSession(sessionId, { provider: providerId, model });
+    } catch (error) {
+      await edit(chatId, message.message_id, error?.name === 'AbortError' ? 'Cancelado.' : `Error: ${error?.message ?? error}`);
+    } finally {
+      controllers.delete(String(chatId));
+      mcp?.close?.();
+    }
+  }
+
+  async function handleCommand(chatId, text) {
+    const [raw, ...rest] = text.slice(1).split(/\s+/);
+    const cmd = raw.toLowerCase();
+    const arg = rest.join(' ').trim();
+    const sessionId = ctx.store.getSetting(sessionKey(chatId));
+    if (cmd === 'start' || cmd === 'help' || cmd === 'ayuda') return send(chatId, HELP);
+    if (cmd === 'new' || cmd === 'nueva') {
+      ctx.store.setSetting(sessionKey(chatId), null);
+      return send(chatId, 'Nueva sesión. Mandá tu mensaje.');
+    }
+    if (cmd === 'status') {
+      const session = sessionId ? ctx.store.getSession(sessionId) : null;
+      return send(
+        chatId,
+        `proveedor: ${session?.provider || ctx.effectiveProviderId()}\nmodelo: ${session?.model || ctx.effectiveModel() || '—'}\nmodo: ${ctx.effectiveMode()}\nsesión: ${session?.title || '—'}`
+      );
+    }
+    if (cmd === 'model') {
+      if (!arg) return send(chatId, `modelo actual: ${ctx.effectiveModel() || '—'}`);
+      ctx.store.setSetting('activeModel', arg);
+      if (sessionId) ctx.store.touchSession(sessionId, { model: arg });
+      return send(chatId, `modelo: ${arg}`);
+    }
+    if (cmd === 'provider') {
+      if (!arg) return send(chatId, `proveedor actual: ${ctx.effectiveProviderId()}`);
+      ctx.store.setSetting('activeProvider', arg);
+      if (sessionId) ctx.store.touchSession(sessionId, { provider: arg });
+      return send(chatId, `proveedor: ${arg}`);
+    }
+    if (cmd === 'mode' || cmd === 'modo') {
+      if (!arg) return send(chatId, `modo actual: ${ctx.effectiveMode()}`);
+      const id = arg.toLowerCase() === 'build' ? 'agent' : arg.toLowerCase();
+      ctx.store.setSetting('activeMode', resolveMode(id).id);
+      return send(chatId, `modo: ${resolveMode(id).label}`);
+    }
+    if (cmd === 'stop' || cmd === 'parar') {
+      controllers.get(String(chatId))?.abort();
+      return send(chatId, 'Cancelando…');
+    }
+    return send(chatId, `Comando desconocido: /${cmd}.\n\n${HELP}`);
+  }
+
+  async function handleMessage(message) {
+    const chatId = String(message.chat.id);
+    if (!authorized(chatId)) {
+      await send(chatId, `No autorizado. Tu chat id es ${chatId}; agregalo a telegram.allowedChatIds para habilitarlo.`);
+      return;
+    }
+    const text = String(message.text ?? '').trim();
+    if (!text) return;
+    if (text.startsWith('/')) return handleCommand(chatId, text);
+    return run(chatId, text);
+  }
+
+  async function loop() {
+    while (running) {
+      let updates = [];
+      try {
+        updates = await tg(token, 'getUpdates', { offset, timeout: 25, allowed_updates: ['message'] });
+      } catch (error) {
+        if (error.status === 401 || error.status === 404) {
+          log(`telegram: token inválido (${error.message}); se detiene el bot.`);
+          running = false;
+          return;
+        }
+        await sleep(3000);
+        continue;
+      }
+      for (const update of updates) {
+        offset = update.update_id + 1;
+        if (update.message?.text) {
+          handleMessage(update.message).catch((error) => log(`telegram: ${error?.message ?? error}`));
+        }
+      }
+    }
+  }
+
+  // Arranca en segundo plano; no bloquea el server.
+  loop().catch((error) => log(`telegram: ${error?.message ?? error}`));
+
+  return {
+    stop() {
+      running = false;
+      for (const controller of controllers.values()) controller.abort();
+      controllers.clear();
+    },
+  };
+}

package/harness/packages/server/src/routes/chat.js

@@ -123,7 +123,7 @@ export function registerChat(route, ctx) {
           sse.event('permission_resolved', { askId, allow });
           return allow;
         };
-    const { definitions, execute } = createTools({
+    const local = createTools({
       root: sessionCwd,
       enabled,
       permissions: ctx.config.permissions,
@@ -131,6 +131,14 @@ export function registerChat(route, ctx) {
       onAsk,
       mcp,
     });
+    // En modo plan (solo lectura) no exponemos las tools de administración.
+    const exposeAdmin = !mode.tools;
+    const admin = ctx.agentTools;
+    const definitions = exposeAdmin ? [...local.definitions, ...admin.definitions] : local.definitions;
+    const execute = (name, args, context) =>
+      exposeAdmin && admin.handles(name)
+        ? admin.execute(name, args, { approve: autoApprove ? async () => true : onAsk })
+        : local.execute(name, args, context);
 
     const { provider, config } = ctx.resolveProvider({
       ...ctx.providerSettings(providerId),

package/harness/packages/server/src/routes/mcp.js

@@ -1,5 +1,7 @@
 import { buildMcpRegistry, mcpTransport } from '../lib/core.js';
-import { sendJson } from '../lib/http.js';
+import { readJson, sendJson, sendError } from '../lib/http.js';
+
+const ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,39}$/i;
 
 function safeTransport(server) {
   try {
@@ -9,17 +11,49 @@ function safeTransport(server) {
   }
 }
 
+function listServers(ctx) {
+  return ctx.mergedMcpServers().map((server) => ({
+    id: server.id,
+    name: server.name ?? server.id,
+    transport: safeTransport(server),
+    enabled: server.enabled !== false,
+    source: server.source ?? 'config',
+    command: server.command ?? null,
+    args: Array.isArray(server.args) ? server.args : [],
+    url: server.url ?? null,
+    env: server.env ?? null,
+  }));
+}
+
+function parseServer(body, id) {
+  const transport = body.transport === 'http' ? 'http' : 'stdio';
+  const command = String(body.command ?? '').trim();
+  const url = String(body.url ?? '').trim();
+  if (transport === 'stdio' && !command) throw new Error('Un servidor stdio necesita "command".');
+  if (transport === 'http' && !url) throw new Error('Un servidor http necesita "url".');
+  const args = Array.isArray(body.args)
+    ? body.args.map((a) => String(a))
+    : String(body.args ?? '')
+        .split(/\s+/)
+        .filter(Boolean);
+  return {
+    id,
+    name: String(body.name ?? id).trim() || id,
+    transport,
+    command: transport === 'stdio' ? command : null,
+    url: transport === 'http' ? url : null,
+    enabled: body.enabled !== false,
+    config: { args, env: body.env ?? null },
+  };
+}
+
 export function registerMcp(route, ctx) {
   route('GET', '/api/mcp', async ({ res, query }) => {
-    const servers = (ctx.config.mcp ?? []).map((server) => ({
-      id: server.id,
-      name: server.name,
-      transport: safeTransport(server),
-      enabled: server.enabled !== false,
-    }));
+    const servers = listServers(ctx);
 
     if (query.get('connect')) {
-      const registry = await buildMcpRegistry(ctx.config.mcp ?? []);
+      const connectable = ctx.mergedMcpServers().filter((s) => s.enabled !== false);
+      const registry = await buildMcpRegistry(connectable);
       try {
         for (const server of servers) {
           const session = registry.sessions.find((s) => s.server.id === server.id);
@@ -47,4 +81,33 @@ export function registerMcp(route, ctx) {
 
     sendJson(res, 200, { servers });
   });
+
+  route('PUT', '/api/mcp/servers/:id', async ({ req, res, params }) => {
+    const id = String(params.id);
+    if (!ID_PATTERN.test(id)) return sendError(res, 400, 'Id de servidor inválido.');
+    const body = await readJson(req);
+    let record;
+    try {
+      record = parseServer(body, id);
+    } catch (error) {
+      return sendError(res, 400, error.message);
+    }
+    ctx.store.saveMcpServer(record);
+    await ctx.reloadMcp();
+    sendJson(res, 200, { servers: listServers(ctx) });
+  });
+
+  route('DELETE', '/api/mcp/servers/:id', async ({ res, params }) => {
+    const id = String(params.id);
+    const stored = ctx.store.listMcpServers().some((s) => s.id === id);
+    if (!stored) return sendError(res, 404, 'Ese servidor está definido en tamnora.json y no se borra desde acá.');
+    ctx.store.deleteMcpServer(id);
+    await ctx.reloadMcp();
+    sendJson(res, 200, { servers: listServers(ctx) });
+  });
+
+  route('POST', '/api/mcp/reload', async ({ res }) => {
+    await ctx.reloadMcp();
+    sendJson(res, 200, { ok: true, servers: listServers(ctx) });
+  });
 }

package/harness/packages/server/src/routes/preview.js

@@ -0,0 +1,58 @@
+import { startTunnel } from '../lib/core.js';
+import { readJson, sendJson, sendError } from '../lib/http.js';
+
+/**
+ * Preview de un dev server para acceso remoto: abre un tunel aparte al puerto
+ * del proceso (asi el celular puede embeber la app aunque este detras del
+ * tunel del harness). Devuelve `{ close }` para liberar el tunel al apagar.
+ */
+export function registerPreview(route, ctx) {
+  let tunnel = null;
+
+  route('GET', '/api/preview', ({ res }) => {
+    sendJson(res, 200, { tunnel: tunnel ? { url: tunnel.url, port: tunnel.port } : null });
+  });
+
+  route('POST', '/api/preview/tunnel', async ({ req, res }) => {
+    const body = await readJson(req);
+    const port = Number(body.port);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) return sendError(res, 400, 'Puerto inválido.');
+    if (tunnel) {
+      try {
+        tunnel.stop?.();
+      } catch {
+        // ignore
+      }
+      tunnel = null;
+    }
+    const provider = ctx.config.preview?.provider || 'tunnelmole';
+    try {
+      const started = await startTunnel(port, provider);
+      tunnel = { url: started.url, port, stop: started.stop };
+      sendJson(res, 200, { tunnel: { url: tunnel.url, port } });
+    } catch (error) {
+      sendError(res, 502, `No se pudo abrir el túnel: ${error.message}`);
+    }
+  });
+
+  route('DELETE', '/api/preview/tunnel', ({ res }) => {
+    try {
+      tunnel?.stop?.();
+    } catch {
+      // ignore
+    }
+    tunnel = null;
+    sendJson(res, 200, { ok: true });
+  });
+
+  return {
+    close() {
+      try {
+        tunnel?.stop?.();
+      } catch {
+        // ignore
+      }
+      tunnel = null;
+    },
+  };
+}

package/harness/packages/server/src/routes/procs.js

@@ -0,0 +1,47 @@
+import { detectProcs } from '../lib/core.js';
+import { readJson, sendJson, sendError } from '../lib/http.js';
+import { resolveExistingDir } from '../lib/workspace.js';
+
+export function registerProcs(route, ctx) {
+  route('GET', '/api/procs', ({ res }) => {
+    sendJson(res, 200, { enabled: ctx.procsEnabled, allow: ctx.procs.allowed, procs: ctx.procs.list() });
+  });
+
+  route('GET', '/api/procs/detect', ({ res, query }) => {
+    let dir;
+    try {
+      dir = resolveExistingDir(query.get('cwd') || ctx.cwd);
+    } catch (error) {
+      return sendError(res, 400, error.message);
+    }
+    sendJson(res, 200, { cwd: dir, chips: detectProcs(dir) });
+  });
+
+  route('POST', '/api/procs/start', async ({ req, res }) => {
+    if (!ctx.procsEnabled) return sendError(res, 403, 'Los procesos están deshabilitados (processes.enabled = false).');
+    const body = await readJson(req);
+    let dir;
+    try {
+      dir = resolveExistingDir(body.cwd || ctx.cwd);
+    } catch (error) {
+      return sendError(res, 400, error.message);
+    }
+    try {
+      const proc = ctx.procs.start({ cwd: dir, command: body.command, args: body.args, port: body.port });
+      sendJson(res, 201, { proc });
+    } catch (error) {
+      sendError(res, 400, error.message);
+    }
+  });
+
+  route('GET', '/api/procs/:id/logs', ({ res, params, query }) => {
+    const data = ctx.procs.logs(params.id, Number(query.get('since')) || 0);
+    if (!data) return sendError(res, 404, 'Proceso no encontrado.');
+    sendJson(res, 200, data);
+  });
+
+  route('POST', '/api/procs/:id/stop', ({ res, params }) => {
+    if (!ctx.procs.stop(params.id)) return sendError(res, 404, 'Proceso no encontrado.');
+    sendJson(res, 200, { ok: true });
+  });
+}

package/harness/packages/server/src/routes/sessions.js

@@ -154,4 +154,14 @@ export function registerSessions(route, ctx) {
     ctx.store.deleteSession(params.id);
     sendJson(res, 200, { ok: true });
   });
+
+  route('GET', '/api/projects', ({ res }) => {
+    sendJson(res, 200, { projects: ctx.store.listProjects() });
+  });
+
+  route('DELETE', '/api/projects', ({ res, query }) => {
+    if (!query.has('cwd')) return sendError(res, 400, 'Falta "cwd".');
+    const removed = ctx.store.deleteSessionsByCwd(query.get('cwd'));
+    sendJson(res, 200, { ok: true, ...removed });
+  });
 }

package/harness/packages/server/src/routes/skills.js

@@ -0,0 +1,61 @@
+import { readJson, sendJson, sendError } from '../lib/http.js';
+import {
+  SKILL_ID_PATTERN,
+  skillsView,
+  findSkill,
+  writeSkill,
+  removeSkill,
+  setSkillEnabled,
+} from '../lib/skills.js';
+
+export function registerSkills(route, ctx) {
+  route('GET', '/api/skills', ({ res }) => {
+    sendJson(res, 200, { skills: skillsView(ctx) });
+  });
+
+  route('GET', '/api/skills/:id', ({ res, params }) => {
+    const skill = findSkill(ctx, params.id);
+    if (!skill) return sendError(res, 404, 'Skill no encontrada.');
+    sendJson(res, 200, {
+      skill: {
+        id: skill.id,
+        name: skill.name || skill.id,
+        description: skill.description || '',
+        when: skill.when || '',
+        body: skill.body,
+        removable: Boolean(skill.home),
+      },
+    });
+  });
+
+  route('PUT', '/api/skills/:id', async ({ req, res, params }) => {
+    const id = String(params.id);
+    if (!SKILL_ID_PATTERN.test(id)) return sendError(res, 400, 'Id de skill inválido (a-z, 0-9, - y _).');
+    const body = await readJson(req);
+    if (!String(body.body ?? '').trim()) return sendError(res, 400, 'La skill necesita un cuerpo.');
+    await writeSkill(id, {
+      name: body.name,
+      description: body.description,
+      when: body.when,
+      body: body.body,
+    });
+    sendJson(res, 200, { skills: skillsView(ctx) });
+  });
+
+  route('DELETE', '/api/skills/:id', async ({ res, params }) => {
+    const skill = findSkill(ctx, params.id);
+    if (!skill) return sendError(res, 404, 'Skill no encontrada.');
+    if (!skill.home) return sendError(res, 400, 'Esa skill vive en el workspace y no se borra desde acá.');
+    await removeSkill(skill.id);
+    setSkillEnabled(ctx.store, skill.id, true);
+    sendJson(res, 200, { skills: skillsView(ctx) });
+  });
+
+  route('POST', '/api/skills/:id/toggle', async ({ res, params }) => {
+    const skill = findSkill(ctx, params.id);
+    if (!skill) return sendError(res, 404, 'Skill no encontrada.');
+    const enabled = !skillsView(ctx).find((s) => s.id === skill.id)?.enabled;
+    setSkillEnabled(ctx.store, skill.id, enabled);
+    sendJson(res, 200, { id: skill.id, enabled, skills: skillsView(ctx) });
+  });
+}