nio-cat 0.6.1 → 0.8.0

package/src/telegram.js

@@ -0,0 +1,311 @@
+'use strict';
+// Telegram: el teu bot (BotFather) parla amb aquest ordinador per long polling. És una connexió
+// de sortida, així que no necessita túnel. Només els xats de la llista blanca poden donar ordres;
+// la resta s'ignoren (només en queda constància perquè els puguis autoritzar des de l'app).
+//
+// Des de Telegram: escriure o enviar una nota de veu (continua la conversa o n'obre una de nova),
+// /nova <text>, /estat, /atura, /ajuda. Hi arriben els avisos, i les aprovacions amb botons.
+const config = require('./config');
+const voice = require('./voice');
+
+const httpErr = (status, message) => Object.assign(new Error(message), { status });
+const TOKEN_RE = /^\d{5,15}:[\w-]{30,60}$/;
+const clip = (s, n) => (String(s).length > n ? `${String(s).slice(0, n)}…` : String(s));
+
+class Telegram {
+  constructor({ cfg, hub, audit, available = () => ['claude', 'codex'] }) {
+    this.cfg = cfg;
+    this.hub = hub;
+    this.audit = audit || { add() {} };
+    this.available = available;
+    this.chatOf = new Map(); // sessió -> xat que l'ha començada
+    this.running = false;
+    this.me = null;
+    hub.on('notice', (n, s) => this.onNotice(n, s).catch(() => {}));
+    hub.on('out', (m) => this.onHub(m));
+  }
+
+  get t() {
+    return this.cfg.telegram || {};
+  }
+  base() {
+    return (this.t.api || 'https://api.telegram.org').replace(/\/$/, '');
+  }
+  async call(method, body, { timeout = 15000 } = {}) {
+    const r = await fetch(`${this.base()}/bot${this.t.token}/${method}`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body || {}),
+      signal: AbortSignal.timeout(timeout),
+    });
+    const j = await r.json().catch(() => ({}));
+    if (!j.ok) throw httpErr(r.status === 401 ? 400 : 502, `Telegram: ${j.description || r.status}`);
+    return j.result;
+  }
+
+  allowed(id) {
+    return (this.t.allowed || []).some((a) => String(a.id) === String(id));
+  }
+
+  // ---------- bucle de long polling
+  start() {
+    if (this.running || !this.t.token) return;
+    this.running = true;
+    this.loop();
+  }
+  stop() {
+    this.running = false;
+    this.ctrl?.abort();
+  }
+  async loop() {
+    let wait = 1000;
+    while (this.running && this.t.token) {
+      try {
+        if (!this.me) this.me = await this.call('getMe');
+        this.ctrl = new AbortController();
+        const r = await fetch(`${this.base()}/bot${this.t.token}/getUpdates`, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ offset: this.offset, timeout: this.t.pollTimeout ?? 50, allowed_updates: ['message', 'callback_query'] }),
+          signal: this.ctrl.signal,
+        });
+        const j = await r.json();
+        if (!j.ok) throw new Error(j.description || r.status);
+        for (const u of j.result) {
+          this.offset = u.update_id + 1;
+          await this.onUpdate(u).catch((e) => this.audit.add({ type: 'telegram', what: `Error: ${e.message}` }));
+        }
+        wait = 1000;
+      } catch (e) {
+        if (!this.running) return;
+        await new Promise((res) => setTimeout(res, wait));
+        wait = Math.min(60000, wait * 2);
+      }
+    }
+  }
+
+  // ---------- missatges entrants
+  async onUpdate(u) {
+    if (u.callback_query) return this.onCallback(u.callback_query);
+    const m = u.message;
+    if (!m || !m.chat) return;
+    const chat = m.chat.id;
+    const who = [m.from?.first_name, m.from?.last_name].filter(Boolean).join(' ') || m.chat.title || m.from?.username || String(chat);
+    if (!this.allowed(chat)) {
+      // Fora de la llista: no responem res. Només ho anotem perquè el puguis autoritzar des de l'app.
+      const t = (this.cfg.telegram.pending = (this.t.pending || []).filter((p) => String(p.id) !== String(chat)));
+      t.unshift({ id: chat, name: who, username: m.from?.username || null, t: Date.now() });
+      this.cfg.telegram.pending = t.slice(0, 10);
+      config.save(this.cfg);
+      return;
+    }
+    let text = (m.text || m.caption || '').trim();
+    if (m.voice || m.audio) {
+      const f = m.voice || m.audio;
+      try {
+        const audio = await this.download(f.file_id);
+        text = (await voice.transcribe(this.cfg, audio, f.mime_type || 'audio/ogg')).text;
+        if (!text) return this.send(chat, 'No he entès la nota de veu.');
+        await this.send(chat, `🎙 «${clip(text, 500)}»`);
+      } catch (e) {
+        return this.send(chat, `No he pogut transcriure la nota de veu: ${e.message}`);
+      }
+    }
+    if (!text) return;
+    const [cmd, ...rest] = text.split(/\s+/);
+    const arg = rest.join(' ').trim();
+    switch (cmd.replace(/@.*$/, '').toLowerCase()) {
+      case '/start':
+      case '/ajuda':
+      case '/help':
+        return this.send(chat, 'Escriu-me què vols que facin els agents d’aquest ordinador (o envia una nota de veu).\n\n/nova <text> — comença una conversa nova\n/estat — què està fent cada agent\n/atura — atura la conversa en curs\n\nT’avisaré quan calgui una aprovació o quan acabi una feina.');
+      case '/estat': {
+        const list = this.hub.list().filter((s) => s.state === 'running' || s.state === 'waiting').slice(0, 10);
+        return this.send(chat, list.length ? list.map((s) => `• ${s.title || 'Sessió'} — ${s.state === 'waiting' ? 'espera el teu permís' : 'treballant'}`).join('\n') : 'Cap agent treballant ara mateix.');
+      }
+      case '/atura': {
+        const sid = this.t.last?.[chat];
+        return this.send(chat, sid && this.hub.stop(sid) ? 'Aturat.' : 'No hi ha res en marxa.');
+      }
+      case '/nova':
+        if (!arg) return this.send(chat, 'Escriu què ha de fer després de /nova.');
+        return this.startSession(chat, arg, who, true);
+      default:
+        if (cmd.startsWith('/')) return this.send(chat, 'No conec aquesta ordre. Escriu /ajuda.');
+        return this.startSession(chat, text, who, false);
+    }
+  }
+
+  async startSession(chat, text, who, fresh) {
+    const last = this.t.last?.[chat];
+    const s = !fresh && last ? this.hub.get(last) : null;
+    try {
+      if (s && (s.state === 'running' || s.state === 'waiting')) return this.send(chat, 'L’agent encara està treballant en l’anterior. Espera o escriu /atura.');
+      let sid = s?.id;
+      if (!sid) {
+        const avail = this.available();
+        const agent = avail.includes(this.t.agent) ? this.t.agent : ['claude', 'codex'].find((a) => avail.includes(a)) || avail[0];
+        const ns = this.hub.create({ agent, cwd: this.t.cwd || this.cfg.roots?.[0], mode: this.t.mode || 'preguntar', title: '' });
+        sid = ns.id;
+        this.cfg.telegram.last = { ...(this.t.last || {}), [chat]: sid };
+        config.save(this.cfg);
+      }
+      this.chatOf.set(sid, chat);
+      this.hub.send(sid, text, this.hookUrl ? this.hookUrl() : undefined);
+      this.audit.add({ type: 'telegram', what: `Missatge de Telegram: ${clip(text, 120)}`, by: `Telegram · ${who}`, session: sid });
+      return this.send(chat, '👌 Hi treballo.');
+    } catch (e) {
+      return this.send(chat, `No he pogut començar: ${e.message}`);
+    }
+  }
+
+  async onCallback(q) {
+    const chat = q.message?.chat?.id;
+    if (!this.allowed(chat)) return this.call('answerCallbackQuery', { callback_query_id: q.id, text: 'No autoritzat' }).catch(() => {});
+    const m = String(q.data || '').match(/^a:([\w-]+):(allow|deny)$/);
+    if (!m) return this.call('answerCallbackQuery', { callback_query_id: q.id }).catch(() => {});
+    const who = [q.from?.first_name, q.from?.last_name].filter(Boolean).join(' ') || q.from?.username || 'Telegram';
+    const a = this.hub.decide(m[1], m[2], undefined, `Telegram · ${who}`);
+    await this.call('answerCallbackQuery', { callback_query_id: q.id, text: a ? (m[2] === 'allow' ? 'Aprovat' : 'Rebutjat') : 'Ja estava resolt' }).catch(() => {});
+    if (q.message) {
+      const verdict = a ? (m[2] === 'allow' ? '✅ Aprovat' : '❌ Rebutjat') : 'Ja estava resolt';
+      await this.call('editMessageText', { chat_id: chat, message_id: q.message.message_id, text: `${q.message.text || ''}\n\n${verdict}` }).catch(() => {});
+    }
+  }
+
+  // ---------- avisos sortints
+  async onNotice(n, s) {
+    if (!this.t.token || this.t.notify === false) return;
+    const chats = (this.t.allowed || []).map((a) => a.id);
+    if (!chats.length) return;
+    const text = `${n.title}\n${n.body || ''}`.trim();
+    if (n.approval) {
+      const a = this.hub.approvals.get(n.approval);
+      const why = a?.reason ? `\n\nMotiu: ${clip(a.reason, 300)}` : '';
+      const detail = a ? `\n\n${clip(a.input?.command || a.input?.file_path || JSON.stringify(a.input || {}), 600)}` : '';
+      for (const c of chats) {
+        await this.call('sendMessage', {
+          chat_id: c,
+          text: clip(`${text}${detail}${why}`, 3800),
+          reply_markup: { inline_keyboard: [[{ text: '✅ Aprova', callback_data: `a:${n.approval}:allow` }, { text: '❌ Rebutja', callback_data: `a:${n.approval}:deny` }]] },
+        }).catch(() => {});
+      }
+      return;
+    }
+    // Les feines que ha començat Telegram ja reben la resposta sencera (onHub); aquí la resta.
+    if (s && this.chatOf.has(s.id)) return;
+    for (const c of chats) await this.send(c, text);
+  }
+
+  onHub(m) {
+    if (m.type !== 'event' || m.event?.kind !== 'status' || m.event.state === 'running') return;
+    const chat = this.chatOf.get(m.session);
+    if (!chat) return;
+    const s = this.hub.get(m.session);
+    const evs = s ? s.events : [];
+    const start = evs.map((e) => e.kind).lastIndexOf('user');
+    const texts = evs.slice(start + 1).filter((e) => e.kind === 'text').map((e) => e.text);
+    const err = evs.slice(start + 1).reverse().find((e) => e.kind === 'error');
+    const out = m.event.state === 'error' ? `⚠️ ${err?.text || 'Hi ha hagut un error'}` : texts.join('\n\n') || 'Fet.';
+    this.send(chat, clip(out, 3900)).catch(() => {});
+  }
+
+  send(chat, text) {
+    return this.call('sendMessage', { chat_id: chat, text: clip(text, 4000) }).catch(() => {});
+  }
+
+  async download(fileId) {
+    const f = await this.call('getFile', { file_id: fileId });
+    const r = await fetch(`${this.base()}/file/bot${this.t.token}/${f.file_path}`, { signal: AbortSignal.timeout(30000) });
+    if (!r.ok) throw new Error(`no he pogut baixar l’àudio (${r.status})`);
+    return Buffer.from(await r.arrayBuffer());
+  }
+
+  // ---------- configuració des de l'app (el testimoni del bot no surt mai de l'ordinador)
+  status() {
+    const t = this.t;
+    return {
+      configured: !!t.token,
+      bot: this.me ? { username: this.me.username, name: this.me.first_name } : null,
+      running: this.running,
+      allowed: t.allowed || [],
+      pending: (t.pending || []).filter((p) => !this.allowed(p.id)),
+      agent: t.agent || null,
+      cwd: t.cwd || this.cfg.roots?.[0] || null,
+      mode: t.mode || 'preguntar',
+      notify: t.notify !== false,
+      voice: !!voice.pick(this.cfg, 'stt'),
+    };
+  }
+
+  routes() {
+    const save = () => config.save(this.cfg);
+    return [
+      { method: 'GET', path: '/api/telegram', handler: () => this.status() },
+      {
+        method: 'PUT',
+        path: '/api/telegram',
+        handler: async ({ body }) => {
+          const t = (this.cfg.telegram = this.cfg.telegram || {});
+          if (body.token === null) {
+            this.stop();
+            delete t.token;
+            this.me = null;
+          } else if (typeof body.token === 'string' && body.token.trim()) {
+            const tok = body.token.trim();
+            if (!TOKEN_RE.test(tok)) throw httpErr(400, 'Aquest no sembla un testimoni de BotFather (123456:ABC…)');
+            const prev = t.token;
+            t.token = tok;
+            try {
+              this.me = await this.call('getMe');
+            } catch (e) {
+              t.token = prev;
+              throw httpErr(400, `Telegram no accepta aquest testimoni: ${e.message}`);
+            }
+            this.stop();
+            this.offset = undefined;
+          }
+          if (['claude', 'codex', 'demo'].includes(body.agent)) t.agent = body.agent;
+          if (['llegir', 'preguntar', 'tot'].includes(body.mode)) t.mode = body.mode;
+          if (typeof body.cwd === 'string' && body.cwd) t.cwd = body.cwd;
+          if (typeof body.notify === 'boolean') t.notify = body.notify;
+          save();
+          if (t.token) setTimeout(() => this.start(), 0);
+          return this.status();
+        },
+      },
+      {
+        method: 'POST',
+        path: '/api/telegram/allow',
+        handler: ({ body, device }) => {
+          const t = (this.cfg.telegram = this.cfg.telegram || {});
+          const id = Number(body.id);
+          if (!Number.isSafeInteger(id)) throw httpErr(400, 'Identificador de xat no vàlid');
+          const p = (t.pending || []).find((x) => Number(x.id) === id);
+          t.allowed = (t.allowed || []).filter((a) => Number(a.id) !== id);
+          t.allowed.push({ id, name: String(body.name || p?.name || id).slice(0, 60), added: Date.now() });
+          t.pending = (t.pending || []).filter((x) => Number(x.id) !== id);
+          save();
+          this.audit.add({ type: 'device', what: `Xat de Telegram autoritzat: ${t.allowed.at(-1).name}`, by: device?.name });
+          this.send(id, 'Fet: ja pots parlar amb els agents d’aquest ordinador. Escriu /ajuda.');
+          return this.status();
+        },
+      },
+      {
+        method: 'DELETE',
+        path: /^\/api\/telegram\/allow\/(-?\d+)$/,
+        handler: ({ params, device }) => {
+          const t = this.cfg.telegram || {};
+          const gone = (t.allowed || []).find((a) => String(a.id) === params[0]);
+          t.allowed = (t.allowed || []).filter((a) => String(a.id) !== params[0]);
+          t.pending = (t.pending || []).filter((a) => String(a.id) !== params[0]);
+          save();
+          if (gone) this.audit.add({ type: 'device', what: `Xat de Telegram tret: ${gone.name}`, by: device?.name });
+          return this.status();
+        },
+      },
+    ];
+  }
+}
+
+module.exports = { Telegram, TOKEN_RE };

package/src/voice.js

@@ -0,0 +1,164 @@
+'use strict';
+// Veu: transcripció (STT) i lectura en veu alta (TTS) amb les claus de l'usuari.
+// Les claus viuen en aquest ordinador (~/.nio/config.json → voice) i mai no tornen a l'app.
+// L'àudio fa: mòbil → aquest ordinador → proveïdor. Proveïdors intercanviables: ElevenLabs i OpenAI.
+const config = require('./config');
+
+const httpErr = (status, message) => Object.assign(new Error(message), { status });
+const MAX_AUDIO = 25 * 1024 * 1024;
+
+const PROVIDERS = {
+  elevenlabs: {
+    name: 'ElevenLabs',
+    async stt(key, audio, mime, lang) {
+      const fd = new FormData();
+      fd.append('file', new Blob([audio], { type: mime || 'audio/webm' }), 'audio');
+      fd.append('model_id', 'scribe_v1');
+      if (lang) fd.append('language_code', lang);
+      const r = await fetch('https://api.elevenlabs.io/v1/speech-to-text', { method: 'POST', headers: { 'xi-api-key': key }, body: fd });
+      if (!r.ok) throw httpErr(502, `ElevenLabs: ${await errText(r)}`);
+      return (await r.json()).text || '';
+    },
+    async tts(key, text, opts) {
+      const voice = opts.voice || 'JBFqnCBsd6RMkjVDRZzb';
+      const r = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${encodeURIComponent(voice)}?output_format=mp3_44100_64`, {
+        method: 'POST',
+        headers: { 'xi-api-key': key, 'content-type': 'application/json' },
+        body: JSON.stringify({ text, model_id: opts.model || 'eleven_multilingual_v2' }),
+      });
+      if (!r.ok) throw httpErr(502, `ElevenLabs: ${await errText(r)}`);
+      return Buffer.from(await r.arrayBuffer());
+    },
+  },
+  openai: {
+    name: 'OpenAI',
+    async stt(key, audio, mime, lang) {
+      const fd = new FormData();
+      fd.append('file', new Blob([audio], { type: mime || 'audio/webm' }), `audio.${ext(mime)}`);
+      fd.append('model', 'gpt-4o-mini-transcribe');
+      if (lang) fd.append('language', lang);
+      const r = await fetch('https://api.openai.com/v1/audio/transcriptions', { method: 'POST', headers: { Authorization: `Bearer ${key}` }, body: fd });
+      if (!r.ok) throw httpErr(502, `OpenAI: ${await errText(r)}`);
+      return (await r.json()).text || '';
+    },
+    async tts(key, text, opts) {
+      const r = await fetch('https://api.openai.com/v1/audio/speech', {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${key}`, 'content-type': 'application/json' },
+        body: JSON.stringify({ model: opts.model || 'gpt-4o-mini-tts', voice: opts.voice || 'alloy', input: text, response_format: 'mp3' }),
+      });
+      if (!r.ok) throw httpErr(502, `OpenAI: ${await errText(r)}`);
+      return Buffer.from(await r.arrayBuffer());
+    },
+  },
+};
+
+function ext(mime) {
+  return /ogg/.test(mime || '') ? 'ogg' : /mp4|m4a|aac/.test(mime || '') ? 'm4a' : /mpeg|mp3/.test(mime || '') ? 'mp3' : /wav/.test(mime || '') ? 'wav' : 'webm';
+}
+async function errText(r) {
+  const t = await r.text().catch(() => '');
+  try {
+    const j = JSON.parse(t);
+    return (j.detail?.message || j.detail || j.error?.message || j.error || t).toString().slice(0, 200);
+  } catch {
+    return `${r.status} ${t.slice(0, 160)}`;
+  }
+}
+
+const cfgOf = (cfg) => cfg.voice || {};
+// Proveïdor per a cada cosa: el triat, si en té la clau; si no, qualsevol que en tingui.
+function pick(cfg, which) {
+  const v = cfgOf(cfg), keys = v.keys || {};
+  const want = v[which] || v.provider;
+  if (want && keys[want]) return want;
+  return Object.keys(PROVIDERS).find((p) => keys[p]) || null;
+}
+
+function status(cfg) {
+  const v = cfgOf(cfg), keys = v.keys || {};
+  return {
+    providers: Object.fromEntries(Object.entries(PROVIDERS).map(([id, p]) => [id, { name: p.name, key: keys[id] ? `…${keys[id].slice(-4)}` : null }])),
+    stt: pick(cfg, 'stt'),
+    tts: pick(cfg, 'tts'),
+    speak: !!v.speak,
+    lang: v.lang || 'ca',
+    voice: v.voice || {},
+  };
+}
+
+async function transcribe(cfg, audio, mime) {
+  const p = pick(cfg, 'stt');
+  if (!p) throw httpErr(400, 'Aquest ordinador no té cap clau de veu. Posa-la a Ajustos → Veu.');
+  if (!audio?.length) throw httpErr(400, 'No hi ha àudio');
+  return { text: (await PROVIDERS[p].stt(cfg.voice.keys[p], audio, mime, cfgOf(cfg).lang || 'ca')).trim(), provider: p };
+}
+
+async function speak(cfg, text) {
+  const p = pick(cfg, 'tts');
+  if (!p) throw httpErr(400, 'Aquest ordinador no té cap clau de veu. Posa-la a Ajustos → Veu.');
+  const clean = String(text || '').replace(/```[\s\S]*?```/g, ' (codi) ').replace(/[*_`#>]/g, '').trim().slice(0, 2500);
+  if (!clean) throw httpErr(400, 'No hi ha text per llegir');
+  return PROVIDERS[p].tts(cfg.voice.keys[p], clean, cfgOf(cfg).voice?.[p] || {});
+}
+
+function readRaw(req, limit = MAX_AUDIO) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on('data', (c) => {
+      size += c.length;
+      if (size > limit) { reject(httpErr(413, 'L’àudio és massa llarg')); req.destroy(); } else chunks.push(c);
+    });
+    req.on('end', () => resolve(Buffer.concat(chunks)));
+    req.on('error', reject);
+  });
+}
+
+function routes(cfg) {
+  return [
+    { method: 'GET', path: '/api/voice', handler: () => status(cfg) },
+    {
+      method: 'PUT',
+      path: '/api/voice',
+      handler: ({ body }) => {
+        const v = (cfg.voice = cfg.voice || {});
+        v.keys = v.keys || {};
+        for (const id of Object.keys(PROVIDERS)) {
+          const k = body.keys?.[id];
+          if (k === null || k === '') delete v.keys[id];
+          else if (typeof k === 'string' && k.trim()) {
+            if (!/^[\w.-]{16,200}$/.test(k.trim())) throw httpErr(400, `La clau de ${PROVIDERS[id].name} no té bon aspecte`);
+            v.keys[id] = k.trim();
+          }
+        }
+        for (const w of ['stt', 'tts']) if (body[w] === null || PROVIDERS[body[w]]) v[w] = body[w] || undefined;
+        if (typeof body.speak === 'boolean') v.speak = body.speak;
+        if (typeof body.lang === 'string' && /^[a-z]{2}$/.test(body.lang)) v.lang = body.lang;
+        if (body.voice && typeof body.voice === 'object') {
+          v.voice = v.voice || {};
+          for (const id of Object.keys(PROVIDERS)) if (body.voice[id]) v.voice[id] = { voice: String(body.voice[id].voice || '').slice(0, 80) || undefined, model: String(body.voice[id].model || '').slice(0, 80) || undefined };
+        }
+        config.save(cfg);
+        return status(cfg);
+      },
+    },
+    {
+      method: 'POST',
+      path: '/api/voice/stt',
+      raw: true,
+      handler: async ({ req }) => transcribe(cfg, await readRaw(req), String(req.headers['content-type'] || 'audio/webm').split(';')[0]),
+    },
+    {
+      method: 'POST',
+      path: '/api/voice/tts',
+      handler: async ({ res, body }) => {
+        const mp3 = await speak(cfg, body.text);
+        res.writeHead(200, { 'content-type': 'audio/mpeg', 'content-length': mp3.length, 'cache-control': 'no-store' });
+        res.end(mp3);
+      },
+    },
+  ];
+}
+
+module.exports = { routes, transcribe, speak, status, pick, PROVIDERS };