obol-ai 0.1.0

package/src/telegram.js

@@ -0,0 +1,377 @@
+const { Bot, GrammyError, HttpError } = require('grammy');
+const {
+  isFirstRun, markFirstRunComplete, FIRST_RUN_SYSTEM,
+  parseSetupResponse, cleanResponse, writePersonalityFromSetup,
+} = require('./first-run');
+const { loadConfig } = require('./config');
+const { isPostSetupDone, runPostSetup } = require('./post-setup');
+const { BackgroundRunner } = require('./background');
+const { shouldEvolve, evolve } = require('./evolve');
+
+
+function createBot(telegramConfig, claude, memory, messageLog) {
+  const bot = new Bot(telegramConfig.token);
+  const allowedUsers = new Set(telegramConfig.allowedUsers || []);
+  const firstRunHistory = []; // Separate history for onboarding conversation
+  const bg = new BackgroundRunner();
+
+  // Auth middleware
+  bot.use(async (ctx, next) => {
+    if (allowedUsers.size > 0 && !allowedUsers.has(ctx.from?.id)) {
+      return; // Silently ignore unauthorized users
+    }
+    await next();
+  });
+
+  // Set bot commands menu
+  bot.api.setMyCommands([
+    { command: 'new', description: 'Start a fresh conversation' },
+    { command: 'tasks', description: 'Show running background tasks' },
+    { command: 'status', description: 'Bot status and uptime' },
+    { command: 'backup', description: 'Trigger GitHub backup now' },
+    { command: 'clean', description: 'Audit and fix workspace' },
+  ]).catch(() => {}); // Best effort
+
+  // Handle /start
+  bot.command('start', async (ctx) => {
+    await ctx.reply('🪙 OBOL is ready. Just send me a message.');
+  });
+
+  // Handle /memory commands
+  bot.command('memory', async (ctx) => {
+    if (!memory) return ctx.reply('Memory not configured.');
+    const args = ctx.message.text.split(' ').slice(1);
+    const sub = args[0];
+
+    if (sub === 'search' && args[1]) {
+      const results = await memory.search(args.slice(1).join(' '));
+      if (results.length === 0) return ctx.reply('No memories found.');
+      const text = results.map((m, i) =>
+        `${i + 1}. [${m.category}] ${m.content.substring(0, 100)}`
+      ).join('\n');
+      return ctx.reply(`🔍 Found ${results.length}:\n\n${text}`);
+    }
+
+    if (sub === 'stats') {
+      const stats = await memory.stats();
+      return ctx.reply(`📊 ${stats.total} memories\n\n${stats.breakdown}`);
+    }
+
+    return ctx.reply('Usage: /memory search <query> | /memory stats');
+  });
+
+  // Handle /new — fresh conversation
+  bot.command('new', async (ctx) => {
+    claude.clearHistory(ctx.chat.id);
+    await ctx.reply('🪙 Fresh start. What\'s up?');
+  });
+
+  // Handle /status
+  bot.command('status', async (ctx) => {
+    const uptime = process.uptime();
+    const mem = (process.memoryUsage().rss / 1024 / 1024).toFixed(0);
+    const h = Math.floor(uptime / 3600);
+    const m = Math.floor((uptime % 3600) / 60);
+    const running = bg.getStatus();
+
+    let text = `🪙 OBOL Status\n\n`;
+    text += `⏱️ Uptime: ${h}h ${m}m\n`;
+    text += `💾 Memory: ${mem}MB\n`;
+    text += `⚡ Tasks: ${running.length} running\n`;
+
+    if (memory) {
+      const stats = await memory.stats().catch(() => null);
+      if (stats) text += `🧠 Memories: ${stats.total}`;
+    }
+
+    await ctx.reply(text);
+  });
+
+  // Handle /backup
+  bot.command('backup', async (ctx) => {
+    try {
+      const config = loadConfig();
+      if (!config?.github) return ctx.reply('GitHub backup not configured.');
+      const { runBackup } = require('./backup');
+      await ctx.reply('📦 Running backup...');
+      await runBackup(config.github);
+      await ctx.reply('✅ Backup complete');
+    } catch (e) {
+      await ctx.reply(`⚠️ Backup failed: ${e.message}`);
+    }
+  });
+
+  // Handle /forget
+  bot.command('forget', async (ctx) => {
+    if (!memory) return ctx.reply('Memory not configured.');
+    const id = ctx.message.text.split(' ')[1];
+    if (!id) return ctx.reply('Usage: /forget <memory-id>');
+    try {
+      await memory.forget(id);
+      await ctx.reply(`🗑️ Forgotten: ${id}`);
+    } catch (e) {
+      await ctx.reply(`⚠️ ${e.message}`);
+    }
+  });
+
+  // Handle /recent
+  bot.command('recent', async (ctx) => {
+    if (!memory) return ctx.reply('Memory not configured.');
+    const results = await memory.recent({ limit: 10 });
+    if (results.length === 0) return ctx.reply('No memories yet.');
+    const text = results.map((m, i) => {
+      const time = new Date(m.created_at).toLocaleTimeString('en-GB', { hour: '2-digit', minute: '2-digit' });
+      return `${i + 1}. [${time}] [${m.category}] ${m.content.substring(0, 80)}`;
+    }).join('\n');
+    await ctx.reply(`🕐 Recent memories:\n\n${text}`);
+  });
+
+  // Handle /today
+  bot.command('today', async (ctx) => {
+    if (!memory) return ctx.reply('Memory not configured.');
+    const results = await memory.byDate('today', { limit: 20 });
+    if (results.length === 0) return ctx.reply('Nothing stored today yet.');
+    const text = results.map((m, i) => {
+      const time = new Date(m.created_at).toLocaleTimeString('en-GB', { hour: '2-digit', minute: '2-digit' });
+      return `${i + 1}. [${time}] [${m.category}] ${m.content.substring(0, 80)}`;
+    }).join('\n');
+    await ctx.reply(`📅 Today (${results.length} memories):\n\n${text}`);
+  });
+
+  // Handle /clean — audit and fix workspace
+  bot.command('clean', async (ctx) => {
+    const { cleanWorkspace } = require('./clean');
+    await ctx.replyWithChatAction('typing');
+    try {
+      const result = await cleanWorkspace();
+      if (result.issues.length === 0) {
+        await ctx.reply('✨ Workspace is clean. Nothing out of place.');
+      } else {
+        const text = `🧹 Found ${result.issues.length} issue(s):\n\n` +
+          result.issues.map(i => `${i.action === 'deleted' ? '🗑️' : '📦'} ${i.path} → ${i.action}`).join('\n') +
+          (result.errors.length > 0 ? `\n\n⚠️ ${result.errors.length} error(s):\n${result.errors.join('\n')}` : '');
+        await ctx.reply(text);
+      }
+    } catch (e) {
+      await ctx.reply(`⚠️ Clean failed: ${e.message}`);
+    }
+  });
+
+  // Handle /tasks — show running background tasks
+  bot.command('tasks', async (ctx) => {
+    const running = bg.getStatus();
+    if (running.length === 0) {
+      return ctx.reply('No background tasks running.');
+    }
+    const text = running.map(t =>
+      `⏳ #${t.id}: ${t.task}... (${t.elapsed})`
+    ).join('\n');
+    return ctx.reply(`Running tasks:\n\n${text}`);
+  });
+
+  // Handle all text messages
+  bot.on('message:text', async (ctx) => {
+    const userMessage = ctx.message.text;
+    const userId = ctx.from.id;
+    const userName = ctx.from.first_name || 'User';
+
+    try {
+      // Show typing indicator
+      await ctx.replyWithChatAction('typing');
+
+      // Log user message
+      messageLog?.log(ctx.chat.id, 'user', userMessage);
+
+      let response;
+
+      // First-run onboarding — OBOL learns about the user through conversation
+      if (isFirstRun()) {
+        firstRunHistory.push({ role: 'user', content: userMessage });
+
+        const msg = await claude.client.messages.create({
+          model: 'claude-sonnet-4-20250514',
+          max_tokens: 4096,
+          system: FIRST_RUN_SYSTEM,
+          messages: firstRunHistory,
+        });
+
+        const fullText = msg.content.filter(b => b.type === 'text').map(b => b.text).join('\n');
+        firstRunHistory.push({ role: 'assistant', content: fullText });
+
+        // Check if OBOL has gathered enough info
+        const setup = parseSetupResponse(fullText);
+        if (setup?.ready) {
+          const config = loadConfig();
+          writePersonalityFromSetup(setup, config?.bot?.name);
+          markFirstRunComplete();
+          // Reload personality in claude instance
+          claude.reloadPersonality?.();
+
+          // Run post-setup tasks (pass, swap, firewall)
+          if (!isPostSetupDone()) {
+            const config = loadConfig({ resolve: false });
+            await runPostSetup(config, async (msg) => {
+              await ctx.reply(msg).catch(() => {});
+            });
+          }
+        }
+
+        response = cleanResponse(fullText);
+      } else {
+        // Normal operation
+        response = await claude.chat(userMessage, {
+          userId,
+          userName,
+          chatId: ctx.chat.id,
+          bg,
+          ctx,
+        });
+      }
+
+      // Log assistant response
+      messageLog?.log(ctx.chat.id, 'assistant', response);
+
+      // Check if it's time for soul evolution
+      if (messageLog && await shouldEvolve().catch(() => false)) {
+        // Run evolution in background — don't block the response
+        setImmediate(async () => {
+          try {
+            const result = await evolve(claude.client, messageLog, memory);
+            claude.reloadPersonality?.();
+            let msg = `🪙 Evolution #${result.evolutionNumber} complete.`;
+
+            if (result.scriptsFixed) {
+              msg += '\n🔧 Fixed a test regression automatically.';
+            } else if (result.scriptsRolledBack) {
+              msg += '\n⚠️ Rolled back a script refactor — tests couldn\'t be fixed.';
+            }
+
+            if (result.upgrades && result.upgrades.length > 0) {
+              msg += '\n\n🆕 **New capabilities:**';
+              for (const u of result.upgrades) {
+                msg += `\n• **${u.name}** — ${u.description}`;
+                if (u.command) msg += ` → \`${u.command}\``;
+              }
+            }
+
+            if (result.deployedApps && result.deployedApps.length > 0) {
+              msg += '\n\n🚀 **Deployed:**';
+              for (const app of result.deployedApps) {
+                if (app.url) {
+                  msg += `\n• ${app.name} → ${app.url}`;
+                } else if (app.error) {
+                  msg += `\n• ${app.name} — deploy failed: ${app.error.substring(0, 100)}`;
+                }
+              }
+            }
+
+            if (result.changelog) {
+              msg += `\n\n_${result.changelog}_`;
+            }
+
+            await ctx.reply(msg, { parse_mode: 'Markdown' }).catch(() =>
+              ctx.reply(msg).catch(() => {})
+            );
+          } catch (e) {
+            console.error('Evolution failed:', e.message);
+          }
+        });
+      }
+
+      // Send response (split if too long)
+      if (response.length > 4096) {
+        const chunks = splitMessage(response, 4096);
+        for (const chunk of chunks) {
+          await ctx.reply(chunk, { parse_mode: 'Markdown' }).catch(() =>
+            ctx.reply(chunk) // Fallback without markdown if parsing fails
+          );
+        }
+      } else {
+        await ctx.reply(response, { parse_mode: 'Markdown' }).catch(() =>
+          ctx.reply(response)
+        );
+      }
+    } catch (e) {
+      console.error('Message handling error:', e.message);
+      await ctx.reply('⚠️ Something went wrong. Check logs with `obol logs`.');
+    }
+  });
+
+  // Handle photos/documents
+  bot.on('message:photo', async (ctx) => {
+    await ctx.reply('📷 Image support coming soon.');
+  });
+
+  // Global error handler — catch everything, never crash
+  bot.catch((err) => {
+    const ctx = err.ctx;
+    const e = err.error;
+    console.error(`[bot.catch] Error while handling update ${ctx?.update?.update_id}:`);
+
+    if (e instanceof GrammyError) {
+      console.error(`  Grammy error: ${e.description}`);
+    } else if (e instanceof HttpError) {
+      console.error(`  HTTP error: ${e.message}`);
+    } else {
+      console.error(`  Unknown error:`, e?.message || e);
+    }
+
+    // Try to notify the user, but don't let that fail either
+    ctx?.reply?.('⚠️ Something went wrong. I\'m still alive though.').catch(() => {});
+  });
+
+  // Wrap bot.start with auto-restart on polling failures
+  const originalStart = bot.start.bind(bot);
+  bot.start = async function startWithResilience(opts = {}) {
+    const MAX_RETRIES = 10;
+    const BASE_DELAY = 1000;
+    let retries = 0;
+
+    const attempt = async () => {
+      try {
+        retries = 0; // Reset on successful start
+        await originalStart({
+          ...opts,
+          onStart: (info) => {
+            console.log(`  Bot: @${info.username}`);
+            opts.onStart?.(info);
+          },
+        });
+      } catch (e) {
+        retries++;
+        if (retries > MAX_RETRIES) {
+          console.error(`💀 Polling failed ${MAX_RETRIES} times. Giving up.`);
+          process.exit(1);
+        }
+        const delay = Math.min(BASE_DELAY * Math.pow(2, retries - 1), 60000);
+        console.error(`⚠️ Polling error (attempt ${retries}/${MAX_RETRIES}): ${e.message}`);
+        console.error(`  Retrying in ${delay / 1000}s...`);
+        await new Promise(r => setTimeout(r, delay));
+        return attempt();
+      }
+    };
+
+    return attempt();
+  };
+
+  return bot;
+}
+
+function splitMessage(text, maxLength) {
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLength) {
+      chunks.push(remaining);
+      break;
+    }
+    // Find last newline before limit
+    let splitAt = remaining.lastIndexOf('\n', maxLength);
+    if (splitAt === -1 || splitAt < maxLength / 2) splitAt = maxLength;
+    chunks.push(remaining.substring(0, splitAt));
+    remaining = remaining.substring(splitAt).trimStart();
+  }
+  return chunks;
+}
+
+module.exports = { createBot };

package/src/test-utils.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+/**
+ * Shared test utilities for OBOL.
+ * Used by both core tests and Opus-generated script tests.
+ *
+ * Usage:
+ *   const { test, run, runFail, report } = require('obol/src/test-utils');
+ *
+ *   test('should do X', () => {
+ *     const out = run('my-script.js', '--flag value');
+ *     if (!out.includes('expected')) throw new Error('missing expected output');
+ *   });
+ *
+ *   report();
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+
+let passed = 0;
+let failed = 0;
+let suiteName = '';
+
+/**
+ * Set the suite name (printed as header)
+ */
+function suite(name) {
+  suiteName = name;
+  console.log(`\n${name}`);
+}
+
+/**
+ * Run a single test case
+ */
+function test(name, fn) {
+  try {
+    fn();
+    passed++;
+    console.log(`  ✅ ${name}`);
+  } catch (e) {
+    failed++;
+    console.error(`  ❌ ${name}: ${e.message}`);
+  }
+}
+
+/**
+ * Execute a script and return stdout. Throws on non-zero exit.
+ * @param {string} scriptPath - Absolute path or relative to cwd
+ * @param {string} args - CLI arguments
+ * @param {object} opts - { env, timeout, cwd }
+ */
+function run(scriptPath, args = '', opts = {}) {
+  const ext = path.extname(scriptPath);
+  const cmd = ext === '.sh' ? 'bash' : 'node';
+  const timeout = opts.timeout || 30000;
+  return execSync(`${cmd} "${scriptPath}" ${args}`, {
+    encoding: 'utf-8',
+    timeout,
+    cwd: opts.cwd || process.cwd(),
+    env: { ...process.env, ...opts.env },
+    stdio: ['pipe', 'pipe', 'pipe'],
+  }).trim();
+}
+
+/**
+ * Execute a script expecting failure (non-zero exit).
+ * Returns true if it failed, false if it succeeded (which is unexpected).
+ */
+function runFail(scriptPath, args = '', opts = {}) {
+  try {
+    run(scriptPath, args, opts);
+    return false; // Should have failed
+  } catch {
+    return true; // Expected failure
+  }
+}
+
+/**
+ * Assert helper — throws if condition is false
+ */
+function assert(condition, message) {
+  if (!condition) throw new Error(message || 'assertion failed');
+}
+
+/**
+ * Assert two values are equal
+ */
+function assertEqual(actual, expected, message) {
+  if (actual !== expected) {
+    throw new Error(message || `expected "${expected}", got "${actual}"`);
+  }
+}
+
+/**
+ * Assert string includes substring
+ */
+function assertIncludes(str, substr, message) {
+  if (!str.includes(substr)) {
+    throw new Error(message || `expected "${str}" to include "${substr}"`);
+  }
+}
+
+/**
+ * Print results and exit with appropriate code
+ */
+function report() {
+  console.log(`\n${passed} passed, ${failed} failed`);
+  if (failed > 0) process.exit(1);
+}
+
+module.exports = { suite, test, run, runFail, assert, assertEqual, assertIncludes, report };