squidclaw 1.1.0 → 1.3.0

package/lib/middleware/ai-process.js

@@ -0,0 +1,20 @@
+/**
+ * Core AI processing — sends message to agent, gets response
+ */
+import { logger } from '../core/logger.js';
+
+export async function aiProcessMiddleware(ctx, next) {
+  if (ctx.handled) return;
+
+  const result = await ctx.agent.processMessage(ctx.contactId, ctx.message, ctx.metadata);
+  
+  ctx.response = {
+    messages: result.messages || [],
+    reaction: result.reaction || null,
+    image: result.image || null,
+    _reminder: result._reminder || null,
+  };
+  ctx.metadata.originalType = ctx.metadata.originalType || null;
+  
+  await next();
+}

package/lib/middleware/allowlist.js

@@ -0,0 +1,15 @@
+/**
+ * Allowlist middleware — blocks unauthorized senders
+ */
+export async function allowlistMiddleware(ctx, next) {
+  const allowFrom = ctx.config.channels?.[ctx.platform]?.allowFrom;
+  if (allowFrom && allowFrom !== '*') {
+    const senderId = ctx.contactId.replace('tg_', '');
+    const allowed = Array.isArray(allowFrom) ? allowFrom.includes(senderId) : String(allowFrom) === senderId;
+    if (!allowed) {
+      ctx.handled = true;
+      return;
+    }
+  }
+  await next();
+}

package/lib/middleware/api-key-detect.js

@@ -0,0 +1,17 @@
+/**
+ * Detects and saves API keys pasted in chat
+ */
+export async function apiKeyDetectMiddleware(ctx, next) {
+  const { detectApiKey, saveApiKey, getKeyConfirmation } = await import('../features/self-config.js');
+  
+  const keyDetected = detectApiKey(ctx.message);
+  if (keyDetected && keyDetected.provider !== 'unknown') {
+    saveApiKey(keyDetected.provider, keyDetected.key);
+    const { loadConfig } = await import('../core/config.js');
+    ctx.engine.config = loadConfig();
+    ctx.config = ctx.engine.config;
+    await ctx.reply(getKeyConfirmation(keyDetected.provider));
+    return;
+  }
+  await next();
+}

package/lib/middleware/auto-links.js

@@ -0,0 +1,14 @@
+/**
+ * Auto-detect and read URLs in messages
+ */
+export async function autoLinksMiddleware(ctx, next) {
+  const urlRegex = /https?:\/\/[^\s<>"')\]]+/gi;
+  if (urlRegex.test(ctx.message) && ctx.engine.toolRouter?.browser) {
+    try {
+      const { extractAndReadLinks } = await import('../features/auto-links.js');
+      const content = await extractAndReadLinks(ctx.message, ctx.engine.toolRouter.browser);
+      if (content) ctx.metadata._linkContext = content;
+    } catch {}
+  }
+  await next();
+}

package/lib/middleware/auto-memory.js

@@ -0,0 +1,9 @@
+/**
+ * Extract facts from messages automatically
+ */
+export async function autoMemoryMiddleware(ctx, next) {
+  if (ctx.engine.autoMemory) {
+    try { await ctx.engine.autoMemory.extract(ctx.agentId, ctx.contactId, ctx.message); } catch {}
+  }
+  await next();
+}

package/lib/middleware/commands.js

@@ -0,0 +1,121 @@
+/**
+ * Handle slash commands: /help, /status, /backup, /memories, /tasks, /usage
+ */
+export async function commandsMiddleware(ctx, next) {
+  const msg = ctx.message.trim();
+  const cmd = msg.startsWith('/') ? msg.split(' ')[0].toLowerCase() : null;
+  
+  // Also match plain text commands
+  const textCmd = msg.toLowerCase();
+
+  if (cmd === '/help') {
+    await ctx.reply([
+      '🦑 *Commands*', '',
+      '/status — model, uptime, usage stats',
+      '/backup — save me to a backup file',
+      '/memories — what I remember about you',
+      '/tasks — your todo list',
+      '/usage — spending report',
+      '/help — this message',
+      '', 'Just chat normally! 🦑',
+    ].join('\n'));
+    return;
+  }
+
+  if (cmd === '/status' || textCmd === 'status') {
+    const uptime = process.uptime();
+    const h = Math.floor(uptime / 3600);
+    const m = Math.floor((uptime % 3600) / 60);
+    const usage = await ctx.storage.getUsage(ctx.agentId) || {};
+    const tokens = (usage.input_tokens || 0) + (usage.output_tokens || 0);
+    const fmtT = tokens >= 1e6 ? (tokens/1e6).toFixed(1)+'M' : tokens >= 1e3 ? (tokens/1e3).toFixed(1)+'K' : String(tokens);
+    const waOn = Object.values(ctx.engine.whatsappManager?.getStatuses() || {}).some(s => s.connected);
+
+    await ctx.reply([
+      `🦑 *${ctx.agent?.name || ctx.agentId} Status*`,
+      '────────────────────',
+      `🧠 Model: ${ctx.agent?.model || 'unknown'}`,
+      `⏱️ Uptime: ${h}h ${m}m`,
+      `💬 Messages: ${usage.messages || 0}`,
+      `🪙 Tokens: ${fmtT}`,
+      `💰 Cost: $${(usage.cost_usd || 0).toFixed(4)}`,
+      '────────────────────',
+      `📱 WhatsApp: ${waOn ? '✅' : '❌'}`,
+      `✈️ Telegram: ${ctx.engine.telegramManager ? '✅' : '❌'}`,
+      '────────────────────',
+      `⚡ Skills: 20+`,
+      `🗣️ Language: ${ctx.agent?.language || 'bilingual'}`,
+    ].join('\n'));
+    return;
+  }
+
+  if (cmd === '/backup' || (textCmd.includes('backup') && textCmd.includes('yourself'))) {
+    try {
+      const { AgentBackup } = await import('../features/backup.js');
+      const { mkdirSync } = await import('fs');
+      const backup = await AgentBackup.create(ctx.agentId, ctx.engine.home, ctx.storage);
+      const filename = (ctx.agent?.name || ctx.agentId) + '_backup_' + new Date().toISOString().slice(0, 10) + '.json';
+      mkdirSync(ctx.engine.home + '/backups', { recursive: true });
+      await AgentBackup.saveToFile(backup, ctx.engine.home + '/backups/' + filename);
+      const size = (JSON.stringify(backup).length / 1024).toFixed(1);
+      await ctx.reply([
+        '💾 *Backup Complete!*', '',
+        '📦 ' + filename,
+        '📏 ' + size + ' KB',
+        '💬 ' + (backup.conversations?.length || 0) + ' messages',
+        '🧠 ' + (backup.memories?.length || 0) + ' memories',
+        '', 'I am safe! 🦑',
+      ].join('\n'));
+    } catch (err) {
+      await ctx.reply('❌ Backup failed: ' + err.message);
+    }
+    return;
+  }
+
+  if (cmd === '/memories' || cmd === '/remember') {
+    const memories = await ctx.storage.getMemories(ctx.agentId);
+    if (memories.length === 0) {
+      await ctx.reply('🧠 No memories yet. Tell me things!');
+    } else {
+      const list = memories.slice(0, 20).map(m => '• ' + m.key + ': ' + m.value).join('\n');
+      await ctx.reply('🧠 *What I Remember*\n\n' + list);
+    }
+    return;
+  }
+
+  if (cmd === '/tasks' || cmd === '/todo') {
+    try {
+      const { TaskManager } = await import('../tools/tasks.js');
+      const tm = new TaskManager(ctx.storage);
+      const tasks = tm.list(ctx.agentId, ctx.contactId);
+      if (tasks.length === 0) {
+        await ctx.reply('📋 No pending tasks! Tell me to add one.');
+      } else {
+        const list = tasks.map((t, i) => (i + 1) + '. ' + t.task).join('\n');
+        await ctx.reply('📋 *Your Tasks*\n\n' + list);
+      }
+    } catch (err) {
+      await ctx.reply('❌ ' + err.message);
+    }
+    return;
+  }
+
+  if (cmd === '/usage') {
+    try {
+      const { UsageAlerts } = await import('../features/usage-alerts.js');
+      const ua = new UsageAlerts(ctx.storage);
+      const s = await ua.getSummary(ctx.agentId);
+      const fmtT = (n) => n >= 1e6 ? (n/1e6).toFixed(1)+'M' : n >= 1e3 ? (n/1e3).toFixed(1)+'K' : String(n);
+      await ctx.reply([
+        '📊 *Usage Report*', '',
+        '*Today:*', '  💬 ' + s.today.calls + ' msgs · 🪙 ' + fmtT(s.today.tokens) + ' tokens · 💰 $' + s.today.cost, '',
+        '*30 days:*', '  💬 ' + s.month.calls + ' msgs · 🪙 ' + fmtT(s.month.tokens) + ' tokens · 💰 $' + s.month.cost,
+      ].join('\n'));
+    } catch (err) {
+      await ctx.reply('❌ ' + err.message);
+    }
+    return;
+  }
+
+  await next();
+}

package/lib/middleware/media.js

@@ -0,0 +1,108 @@
+/**
+ * Process media: voice → transcribe, image → analyze, document → ingest
+ */
+import { logger } from '../core/logger.js';
+
+export async function mediaMiddleware(ctx, next) {
+  if (!ctx.metadata._ctx || !ctx.metadata.mediaType) {
+    await next();
+    return;
+  }
+
+  const token = ctx.config.channels?.telegram?.token;
+  
+  try {
+    if (ctx.metadata.mediaType === 'audio') {
+      await _transcribeVoice(ctx, token);
+    } else if (ctx.metadata.mediaType === 'image') {
+      await _analyzeImage(ctx, token);
+    } else if (ctx.metadata.mediaType === 'document') {
+      await _ingestDocument(ctx, token);
+      if (ctx.handled) return;
+    }
+  } catch (err) {
+    logger.error('media', 'Processing error: ' + err.message);
+  }
+
+  await next();
+}
+
+async function _transcribeVoice(ctx, token) {
+  const file = await ctx.metadata._ctx.getFile();
+  const url = `https://api.telegram.org/file/bot${token}/${file.file_path}`;
+  const buffer = Buffer.from(await (await fetch(url)).arrayBuffer());
+
+  const groqKey = ctx.config.ai?.providers?.groq?.key;
+  const openaiKey = ctx.config.ai?.providers?.openai?.key;
+  const apiKey = groqKey || openaiKey;
+  if (!apiKey) return;
+
+  const apiUrl = groqKey ? 'https://api.groq.com/openai/v1/audio/transcriptions' : 'https://api.openai.com/v1/audio/transcriptions';
+  const model = groqKey ? 'whisper-large-v3' : 'whisper-1';
+
+  const form = new FormData();
+  form.append('file', new Blob([buffer], { type: 'audio/ogg' }), 'voice.ogg');
+  form.append('model', model);
+
+  const res = await fetch(apiUrl, { method: 'POST', headers: { 'Authorization': 'Bearer ' + apiKey }, body: form });
+  const data = await res.json();
+  if (data.text) {
+    ctx.message = '[Voice note]: "' + data.text + '"';
+    ctx.metadata.originalType = 'voice';
+    logger.info('media', 'Transcribed: ' + data.text.slice(0, 50));
+  }
+}
+
+async function _analyzeImage(ctx, token) {
+  const photos = ctx.metadata._ctx.message?.photo;
+  if (!photos?.length) return;
+
+  const photo = photos[photos.length - 1];
+  const file = await ctx.metadata._ctx.api.getFile(photo.file_id);
+  const url = `https://api.telegram.org/file/bot${token}/${file.file_path}`;
+  const buffer = Buffer.from(await (await fetch(url)).arrayBuffer());
+  const base64 = buffer.toString('base64');
+
+  const anthropicKey = ctx.config.ai?.providers?.anthropic?.key;
+  if (!anthropicKey) return;
+
+  const caption = ctx.message.replace('[📸 Image]', '').trim();
+  const prompt = caption || 'What is in this image? Be concise.';
+
+  const res = await fetch('https://api.anthropic.com/v1/messages', {
+    method: 'POST',
+    headers: { 'x-api-key': anthropicKey, 'content-type': 'application/json', 'anthropic-version': '2023-06-01' },
+    body: JSON.stringify({
+      model: 'claude-sonnet-4-20250514',
+      max_tokens: 300,
+      messages: [{ role: 'user', content: [
+        { type: 'image', source: { type: 'base64', media_type: 'image/jpeg', data: base64 } },
+        { type: 'text', text: prompt },
+      ]}],
+    }),
+  });
+  const data = await res.json();
+  const analysis = data.content?.[0]?.text;
+  if (analysis) {
+    ctx.message = caption
+      ? `[Image: "${caption}"] ${analysis}`
+      : `[Image] ${analysis}`;
+    logger.info('media', 'Analyzed image: ' + analysis.slice(0, 50));
+  }
+}
+
+async function _ingestDocument(ctx, token) {
+  const file = await ctx.metadata._ctx.getFile();
+  const url = `https://api.telegram.org/file/bot${token}/${file.file_path}`;
+  const buffer = Buffer.from(await (await fetch(url)).arrayBuffer());
+  const filename = ctx.message.match(/Document: (.+?)\]/)?.[1] || 'file.txt';
+
+  try {
+    const { DocIngester } = await import('../features/doc-ingest.js');
+    const ingester = new DocIngester(ctx.storage, ctx.engine.knowledgeBase, ctx.engine.home);
+    const result = await ingester.ingest(ctx.agentId, buffer, filename, ctx.metadata.mimeType);
+    await ctx.reply(`📄 *Document absorbed!*\n📁 ${filename}\n📊 ${result.chunks} chunks\n📝 ${result.chars} chars\n\nAsk me anything about it! 🦑`);
+  } catch (err) {
+    ctx.message = `[Document: ${filename}] (Error: ${err.message})`;
+  }
+}

package/lib/middleware/pipeline.js

@@ -0,0 +1,87 @@
+/**
+ * 🦑 Message Pipeline
+ * Clean middleware-based message processing
+ * 
+ * Flow: message → [middleware1] → [middleware2] → ... → response
+ * Each middleware can: modify context, short-circuit (return response), or pass through
+ */
+
+import { logger } from '../core/logger.js';
+
+export class MessagePipeline {
+  constructor() {
+    this.middleware = [];
+  }
+
+  /**
+   * Add middleware to the pipeline
+   * @param {string} name - middleware name for logging
+   * @param {Function} fn - async (ctx, next) => void
+   */
+  use(name, fn) {
+    this.middleware.push({ name, fn });
+  }
+
+  /**
+   * Process a message through the pipeline
+   * @param {object} ctx - message context
+   * @returns {object} ctx with response populated
+   */
+  async process(ctx) {
+    let index = 0;
+
+    const next = async () => {
+      if (index >= this.middleware.length) return;
+      if (ctx.handled) return; // short-circuited
+
+      const mw = this.middleware[index++];
+      try {
+        await mw.fn(ctx, next);
+      } catch (err) {
+        logger.error('pipeline', `Middleware "${mw.name}" error: ${err.message}`);
+        // Don't crash — continue to next middleware
+        await next();
+      }
+    };
+
+    await next();
+    return ctx;
+  }
+}
+
+/**
+ * Create a message context object
+ */
+export function createContext(engine, agentId, contactId, message, metadata) {
+  return {
+    // Input
+    engine,
+    agentId,
+    contactId,
+    message,        // mutable — middleware can modify
+    originalMessage: message,
+    metadata,
+    platform: metadata.platform || 'telegram',
+    
+    // Agent
+    agent: engine.agentManager.get(agentId),
+    config: engine.config,
+    storage: engine.storage,
+    
+    // State (middleware populates these)
+    handled: false,       // true = stop pipeline, send response
+    response: null,       // { messages: string[], reaction: string|null, image: object|null, voice: Buffer|null, _reminder: object|null }
+    linkContext: null,     // fetched URL content
+    memoryExtracted: [],   // auto-extracted facts
+    
+    // Helpers
+    reply: async function(text) {
+      this.handled = true;
+      this.response = { messages: [text] };
+    },
+    replyMulti: async function(messages) {
+      this.handled = true;
+      this.response = { messages };
+    },
+  };
+}

package/lib/middleware/response-sender.js

@@ -0,0 +1,55 @@
+/**
+ * Send the response back to the user via the appropriate channel
+ */
+import { logger } from '../core/logger.js';
+
+export async function responseSenderMiddleware(ctx, next) {
+  if (!ctx.response) return;
+
+  const tm = ctx.engine.telegramManager;
+  const wm = ctx.engine.whatsappManager;
+  const { agentId, contactId, metadata, response } = ctx;
+
+  // Handle reminder
+  if (response._reminder && ctx.engine.reminders) {
+    ctx.engine.reminders.add(agentId, contactId, response._reminder.message, response._reminder.time, ctx.platform, metadata);
+  }
+
+  // Send reaction
+  if (response.reaction && metadata.messageId) {
+    try {
+      if (ctx.platform === 'telegram' && tm) {
+        await tm.sendReaction(agentId, contactId, metadata.messageId, response.reaction, metadata);
+      }
+    } catch {}
+  }
+
+  // No messages to send
+  if (!response.messages?.length && !response.image) return;
+
+  // Send via appropriate channel
+  if (ctx.platform === 'telegram' && tm) {
+    if (response.image) {
+      const photoData = response.image.url ? { url: response.image.url } : { base64: response.image.base64 };
+      await tm.sendPhoto(agentId, contactId, photoData, response.messages?.[0] || '', metadata);
+    } else if (metadata.originalType === 'voice' && response.messages.length === 1 && response.messages[0].length < 500) {
+      try {
+        const { VoiceReply } = await import('../features/voice-reply.js');
+        const vr = new VoiceReply(ctx.config);
+        const lang = /[\u0600-\u06FF]/.test(response.messages[0]) ? 'ar' : 'en';
+        const audio = await vr.generate(response.messages[0], { language: lang });
+        await tm.sendVoice(agentId, contactId, audio, metadata);
+      } catch {
+        await tm.sendMessages(agentId, contactId, response.messages, metadata);
+      }
+    } else {
+      await tm.sendMessages(agentId, contactId, response.messages, metadata);
+    }
+  } else if (wm) {
+    for (const msg of response.messages) {
+      await wm.sendMessage(agentId, contactId, msg);
+    }
+  }
+
+  await next();
+}

package/lib/middleware/skill-check.js

@@ -0,0 +1,15 @@
+/**
+ * Check if user is asking for a skill that needs an API key
+ */
+export async function skillCheckMiddleware(ctx, next) {
+  const { detectSkillRequest, checkSkillAvailable, getKeyRequestMessage } = await import('../features/self-config.js');
+  const skill = detectSkillRequest(ctx.message);
+  if (skill) {
+    const avail = checkSkillAvailable(skill, ctx.config);
+    if (!avail.available) {
+      const msg = getKeyRequestMessage(skill);
+      if (msg) { await ctx.reply(msg); return; }
+    }
+  }
+  await next();
+}

package/lib/middleware/typing.js

@@ -0,0 +1,26 @@
+/**
+ * Show typing indicator while AI processes
+ * Wraps the next() call with typing on/off
+ */
+export async function typingMiddleware(ctx, next) {
+  if (ctx.handled || ctx.platform !== 'telegram') {
+    await next();
+    return;
+  }
+
+  const chatId = ctx.metadata.chatId || ctx.contactId.replace('tg_', '');
+  const botInfo = ctx.engine.telegramManager?.bots?.get(ctx.agentId);
+  
+  let interval;
+  if (botInfo?.bot) {
+    const sendTyping = () => { try { botInfo.bot.api.sendChatAction(chatId, 'typing').catch(() => {}); } catch {} };
+    sendTyping();
+    interval = setInterval(sendTyping, 4000);
+  }
+
+  try {
+    await next();
+  } finally {
+    if (interval) clearInterval(interval);
+  }
+}

package/lib/middleware/usage-alerts.js

@@ -0,0 +1,19 @@
+/**
+ * Check spending thresholds and alert
+ */
+export async function usageAlertsMiddleware(ctx, next) {
+  await next(); // Run after AI responds
+  
+  if (ctx.engine.usageAlerts) {
+    try {
+      const alert = await ctx.engine.usageAlerts.check(ctx.agentId);
+      if (alert.alert) {
+        // Append alert to response
+        const alertMsg = '⚠️ *Usage Alert* — $' + alert.total + ' spent in 24h';
+        if (ctx.response?.messages) {
+          ctx.response.messages.push(alertMsg);
+        }
+      }
+    } catch {}
+  }
+}