@sym-bot/sym 0.1.0 → 0.2.0

package/integrations/telegram/bot.js

@@ -0,0 +1,418 @@
+#!/usr/bin/env node
+'use strict';
+
+const http = require('http');
+const crypto = require('crypto');
+const { SymNode } = require('../../lib/node');
+
+// ── Configuration ──────────────────────────────────────────────
+
+const token = process.env.TELEGRAM_BOT_TOKEN;
+if (!token) {
+  console.error('Set TELEGRAM_BOT_TOKEN environment variable');
+  process.exit(1);
+}
+
+const WEBHOOK_URL = process.env.WEBHOOK_URL;
+if (!WEBHOOK_URL) {
+  console.error('Set WEBHOOK_URL environment variable (e.g. https://sym-telegram-bot.onrender.com)');
+  process.exit(1);
+}
+
+const PORT = Number(process.env.PORT) || 3000;
+const RELAY_URL = process.env.SYM_RELAY_URL || 'wss://sym-relay.onrender.com';
+const RELAY_TOKEN = process.env.SYM_RELAY_TOKEN || null;
+const MAX_SESSIONS = Number(process.env.MAX_SESSIONS) || 100;
+const IDLE_TIMEOUT_MS = Number(process.env.IDLE_TIMEOUT_MS) || 30 * 60 * 1000; // 30 min
+
+// Webhook secret path — hash of bot token prevents unauthorized posts.
+const WEBHOOK_PATH = `/webhook/${crypto.createHash('sha256').update(token).digest('hex').slice(0, 16)}`;
+
+const TG_API = `https://api.telegram.org/bot${token}`;
+
+// ── Telegram Bot API (zero dependencies) ──────────────────────
+
+async function tgSendMessage(chatId, text) {
+  try {
+    await fetch(`${TG_API}/sendMessage`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ chat_id: chatId, text }),
+    });
+  } catch {}
+}
+
+async function tgSetWebhook(url) {
+  const res = await fetch(`${TG_API}/setWebhook`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ url }),
+  });
+  const data = await res.json();
+  if (!data.ok) throw new Error(data.description || 'setWebhook failed');
+}
+
+// ── Message Router ────────────────────────────────────────────
+
+function handleUpdate(update) {
+  const msg = update.message;
+  if (!msg || !msg.text) return;
+
+  const chatId = msg.chat.id;
+  const text = msg.text;
+
+  // Route commands
+  if (text.startsWith('/start')) return handleStart(chatId);
+  if (text === '/stop') return handleStop(chatId);
+  if (text === '/peers') return handlePeers(chatId);
+  if (text.startsWith('/mood ')) return handleMood(chatId, text.slice(6));
+  if (text.startsWith('/remember ')) return handleRemember(chatId, text.slice(10));
+  if (text.startsWith('/recall ')) return handleRecall(chatId, text.slice(8));
+  if (!text.startsWith('/')) return handlePlainText(chatId, text);
+}
+
+// ── Session Manager ────────────────────────────────────────────
+
+const sessions = new Map(); // chatId → { node, lastActivity, couplingDecisions }
+
+function getSession(chatId) {
+  const session = sessions.get(chatId);
+  if (session) session.lastActivity = Date.now();
+  return session || null;
+}
+
+async function createSession(chatId) {
+  // Evict oldest idle session if at capacity
+  if (sessions.size >= MAX_SESSIONS) {
+    let oldest = null;
+    for (const [id, s] of sessions) {
+      if (!oldest || s.lastActivity < oldest.activity) {
+        oldest = { id, activity: s.lastActivity };
+      }
+    }
+    if (oldest) await destroySession(oldest.id);
+  }
+
+  const nodeName = `tg-${chatId}`;
+  const node = new SymNode({
+    name: nodeName,
+    cognitiveProfile: 'Telegram user mesh bridge — relays mood signals and messages between a Telegram user and the SYM mesh',
+    relay: RELAY_URL,
+    relayToken: RELAY_TOKEN,
+    moodThreshold: 0.8,
+    silent: true,
+  });
+
+  const session = {
+    node,
+    lastActivity: Date.now(),
+    couplingDecisions: new Map(),
+  };
+
+  // ── Mesh Events → This Chat Only ──────────────────────────
+  node.on('peer-joined', ({ name }) => {
+    tgSendMessage(chatId, `[mesh] ${name} joined`);
+  });
+
+  node.on('peer-left', ({ name }) => {
+    tgSendMessage(chatId, `[mesh] ${name} left`);
+  });
+
+  node.on('message', (from, content) => {
+    tgSendMessage(chatId, `[${from}] ${content}`);
+  });
+
+  node.on('mood-accepted', ({ from, mood, drift }) => {
+    tgSendMessage(chatId, `[mood] ${from}: ${mood} (drift: ${drift.toFixed(3)})`);
+  });
+
+  node.on('memory-received', ({ from, entry }) => {
+    tgSendMessage(chatId, `[memory] ${from}: ${entry.content}`);
+  });
+
+  node.on('coupling-decision', ({ peer, decision, drift }) => {
+    const prev = session.couplingDecisions.get(peer);
+    if (prev === decision) return;
+    session.couplingDecisions.set(peer, decision);
+    tgSendMessage(chatId, `[coupling] ${peer}: ${decision} (drift: ${drift.toFixed(3)})`);
+  });
+
+  sessions.set(chatId, session);
+  await node.start();
+  console.log(`Session started: ${nodeName} (${sessions.size}/${MAX_SESSIONS})`);
+  return session;
+}
+
+async function destroySession(chatId) {
+  const session = sessions.get(chatId);
+  if (!session) return;
+  session.node.stop();
+  sessions.delete(chatId);
+  console.log(`Session stopped: tg-${chatId} (${sessions.size}/${MAX_SESSIONS})`);
+}
+
+// ── Idle Cleanup ───────────────────────────────────────────────
+
+setInterval(() => {
+  const now = Date.now();
+  for (const [chatId, session] of sessions) {
+    if (now - session.lastActivity > IDLE_TIMEOUT_MS) {
+      tgSendMessage(chatId, 'Mesh session idle — disconnected. Send /start to reconnect.');
+      destroySession(chatId);
+    }
+  }
+}, 60_000);
+
+// ── Command Handlers ──────────────────────────────────────────
+
+async function handleStart(chatId) {
+  let session = getSession(chatId);
+  if (!session) {
+    session = await createSession(chatId);
+  }
+
+  tgSendMessage(chatId, [
+    `Connected to SYM mesh as "${session.node.name}".`,
+    '',
+    'Commands:',
+    '/peers — connected mesh peers',
+    '/mood <text> — broadcast mood to mesh',
+    '/remember <text> — store memory in mesh',
+    '/recall <query> — search mesh memories',
+    '/stop — disconnect from mesh',
+    '',
+    'Or just type how you feel — it broadcasts to the mesh.',
+  ].join('\n'));
+}
+
+async function handleStop(chatId) {
+  if (!sessions.has(chatId)) {
+    tgSendMessage(chatId, 'No active session. Send /start to connect.');
+    return;
+  }
+  await destroySession(chatId);
+  tgSendMessage(chatId, 'Disconnected from SYM mesh.');
+}
+
+function handlePeers(chatId) {
+  const session = getSession(chatId);
+  if (!session) { tgSendMessage(chatId, 'Send /start first.'); return; }
+
+  const peers = session.node.peers();
+  if (peers.length === 0) {
+    tgSendMessage(chatId, 'No peers connected.');
+    return;
+  }
+  const lines = peers.map(p =>
+    `${p.name} — ${p.coupling} (drift: ${p.drift ?? 'pending'})`
+  );
+  tgSendMessage(chatId, lines.join('\n'));
+}
+
+function handleMood(chatId, mood) {
+  const session = getSession(chatId);
+  if (!session) { tgSendMessage(chatId, 'Send /start first.'); return; }
+
+  session.node.broadcastMood(mood);
+  session.node.remember(`User mood: ${mood}`, { tags: ['mood', 'telegram'] });
+  const peers = session.node.peers();
+  tgSendMessage(chatId, `Mood broadcast to ${peers.length} peer(s): "${mood}"`);
+}
+
+function handleRemember(chatId, content) {
+  const session = getSession(chatId);
+  if (!session) { tgSendMessage(chatId, 'Send /start first.'); return; }
+
+  const entry = session.node.remember(content, { tags: ['telegram'] });
+  const peers = session.node.peers();
+  const coupled = peers.filter(p => p.coupling !== 'rejected');
+  tgSendMessage(chatId, `Stored and shared with ${coupled.length}/${peers.length} peer(s). Key: ${entry.key}`);
+}
+
+async function handleRecall(chatId, query) {
+  const session = getSession(chatId);
+  if (!session) { tgSendMessage(chatId, 'Send /start first.'); return; }
+
+  // 1. Check Supabase for latest feed
+  const { digest, folder } = await getLatestFeed();
+
+  if (digest) {
+    tgSendMessage(chatId, digest);
+    return;
+  }
+
+  if (folder) {
+    // No digest yet — broadcast need to the mesh
+    tgSendMessage(chatId, 'Generating digest...');
+    session.node.send(`digest-needed:${folder}`);
+
+    // Listen for digest-ready from a mesh peer
+    const onMessage = async (from, content) => {
+      if (content === `digest-ready:${folder}`) {
+        session.node.removeListener('message', onMessage);
+        clearTimeout(timeout);
+        const { digest: d } = await getLatestFeed();
+        if (d) {
+          tgSendMessage(chatId, d);
+        } else {
+          tgSendMessage(chatId, 'Digest generated but could not be retrieved.');
+        }
+      }
+    };
+    session.node.on('message', onMessage);
+
+    // Timeout after 60s
+    const timeout = setTimeout(() => {
+      session.node.removeListener('message', onMessage);
+      tgSendMessage(chatId, 'Digest generation timed out. Try again later.');
+    }, 60000);
+    return;
+  }
+
+  // 2. Fall back to local mesh memories
+  const results = session.node.recall(query);
+  if (results.length === 0) {
+    tgSendMessage(chatId, 'No feed available yet today. Next fetch runs every 6 hours.');
+    return;
+  }
+  const lines = results.map(r => {
+    const source = r._source || r.source || 'unknown';
+    const tags = (r.tags || []).length > 0 ? ` (${r.tags.join(', ')})` : '';
+    return `[${source}] ${r.content}${tags}`;
+  });
+  tgSendMessage(chatId, lines.join('\n'));
+}
+
+// ── Supabase Knowledge Feed ──────────────────────────────────
+
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY;
+const SUPABASE_BUCKET = process.env.SUPABASE_BUCKET || 'sym-knowledge-feed';
+
+function supabaseHeaders() {
+  return { 'Authorization': `Bearer ${SUPABASE_KEY}`, 'apikey': SUPABASE_KEY };
+}
+
+function todayPrefix() {
+  const now = new Date();
+  return now.getFullYear().toString()
+    + String(now.getMonth() + 1).padStart(2, '0')
+    + String(now.getDate()).padStart(2, '0');
+}
+
+/**
+ * Get the latest feed folder and its digest (if available).
+ * Returns { folder, digest } — digest is null if not yet generated.
+ */
+async function getLatestFeed() {
+  if (!SUPABASE_URL || !SUPABASE_KEY) return { folder: null, digest: null };
+
+  try {
+    const listRes = await fetch(
+      `${SUPABASE_URL}/storage/v1/object/list/${SUPABASE_BUCKET}`,
+      {
+        method: 'POST',
+        headers: { ...supabaseHeaders(), 'Content-Type': 'application/json' },
+        body: JSON.stringify({ prefix: 'twitter/', limit: 100, sortBy: { column: 'name', order: 'desc' } }),
+      }
+    );
+    if (!listRes.ok) return { folder: null, digest: null };
+    const folders = await listRes.json();
+    const todayFolders = folders.map(f => f.name).filter(n => n.startsWith(todayPrefix()));
+    if (todayFolders.length === 0) return { folder: null, digest: null };
+
+    const latest = todayFolders[0];
+
+    // Check for digest
+    const res = await fetch(
+      `${SUPABASE_URL}/storage/v1/object/${SUPABASE_BUCKET}/twitter/${latest}/digest.md`,
+      { headers: supabaseHeaders() }
+    );
+    if (res.ok) {
+      const text = await res.text();
+      return { folder: latest, digest: text };
+    }
+
+    return { folder: latest, digest: null };
+  } catch {
+    return { folder: null, digest: null };
+  }
+}
+
+function handlePlainText(chatId, text) {
+  const session = getSession(chatId);
+  if (!session) return;
+
+  session.node.broadcastMood(text);
+  session.node.remember(`User mood: ${text}`, { tags: ['mood', 'telegram'] });
+  const peers = session.node.peers();
+  tgSendMessage(chatId, `Mood broadcast to ${peers.length} peer(s)`);
+}
+
+// ── HTTP Server (webhook receiver + health) ───────────────────
+
+const server = http.createServer((req, res) => {
+  if (req.method === 'GET' && req.url === '/health') {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      status: 'ok',
+      sessions: sessions.size,
+      maxSessions: MAX_SESSIONS,
+      uptime: process.uptime(),
+    }));
+    return;
+  }
+
+  if (req.method === 'POST' && req.url === WEBHOOK_PATH) {
+    let body = '';
+    req.on('data', (chunk) => { body += chunk; });
+    req.on('end', () => {
+      try {
+        const update = JSON.parse(body);
+        handleUpdate(update);
+      } catch (err) {
+        console.error('Failed to process webhook update:', err.message);
+      }
+      res.writeHead(200);
+      res.end('ok');
+    });
+    return;
+  }
+
+  res.writeHead(404);
+  res.end();
+});
+
+// ── Startup ────────────────────────────────────────────────────
+
+server.listen(PORT, async () => {
+  const webhookUrl = `${WEBHOOK_URL}${WEBHOOK_PATH}`;
+  try {
+    await tgSetWebhook(webhookUrl);
+    console.log(`Webhook registered: ${WEBHOOK_URL}${WEBHOOK_PATH.slice(0, 20)}...`);
+  } catch (err) {
+    console.error('Failed to set webhook:', err.message);
+    process.exit(1);
+  }
+
+  console.log(`SYM Telegram bridge running (webhook mode, multi-tenant)`);
+  console.log(`HTTP server: port ${PORT}`);
+  console.log(`Relay: ${RELAY_URL}`);
+  console.log(`Max sessions: ${MAX_SESSIONS}, idle timeout: ${IDLE_TIMEOUT_MS / 1000}s`);
+});
+
+// ── Graceful Shutdown ──────────────────────────────────────────
+
+async function shutdown() {
+  console.log('Shutting down...');
+  // Keep webhook registered — Render free tier spins down on idle.
+  // Telegram's next POST will wake the instance, which re-registers on startup.
+  server.close();
+  for (const [, session] of sessions) {
+    session.node.stop();
+  }
+  process.exit(0);
+}
+
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);