squidclaw 2.0.0 → 2.2.0

package/lib/core/agent-tools-mixin.js

@@ -58,6 +58,8 @@ export function addToolSupport(agent, toolRouter, knowledgeBase) {
       const fullResponse = result.messages.join('\n');
       toolRouter._currentContactId = contactId;
       toolRouter.storage = agent.storage;
+      toolRouter._currentContactId = contactId;
+      toolRouter._currentPlatform = metadata?.platform;
       const toolResult = await toolRouter.processResponse(fullResponse, agent.id);
 
       if (toolResult.toolUsed && toolResult.toolName === 'remind' && toolResult.reminderTime) {
@@ -71,6 +73,14 @@ export function addToolSupport(agent, toolRouter, knowledgeBase) {
         return result;
       }
 
+      // File attachment (pptx, etc)
+      if (toolResult.toolUsed && toolResult.filePath) {
+        result.filePath = toolResult.filePath;
+        result.fileName = toolResult.fileName;
+        result.messages = [toolResult.toolResult || 'Here\'s your file! 📎'];
+        return result;
+      }
+
       if (toolResult.toolUsed && (toolResult.imageBase64 || toolResult.imageUrl)) {
         // Image generated — pass through directly
         result.image = { base64: toolResult.imageBase64, url: toolResult.imageUrl, mimeType: toolResult.mimeType };

package/lib/features/allowlist-manager.js

@@ -0,0 +1,105 @@
+/**
+ * 🦑 Allowlist Manager
+ * Manage who can talk to the agent via chat commands or AI tool
+ */
+
+import { loadConfig, saveConfig, getHome } from '../core/config.js';
+import { logger } from '../core/logger.js';
+
+export class AllowlistManager {
+  constructor(engine) {
+    this.engine = engine;
+  }
+
+  /**
+   * Get current allowlist for a platform
+   */
+  list(platform = 'telegram') {
+    const config = loadConfig();
+    const allowFrom = config.channels?.[platform]?.allowFrom;
+    if (!allowFrom || allowFrom === '*') return { mode: 'open', list: [] };
+    const list = Array.isArray(allowFrom) ? allowFrom : [String(allowFrom)];
+    return { mode: 'restricted', list };
+  }
+
+  /**
+   * Add someone to the allowlist
+   */
+  add(platform, id) {
+    const config = loadConfig();
+    if (!config.channels) config.channels = {};
+    if (!config.channels[platform]) config.channels[platform] = {};
+
+    let allowFrom = config.channels[platform].allowFrom;
+    
+    if (!allowFrom || allowFrom === '*') {
+      // First time — also include current entries
+      config.channels[platform].allowFrom = [String(id)];
+    } else if (Array.isArray(allowFrom)) {
+      if (!allowFrom.includes(String(id))) {
+        allowFrom.push(String(id));
+      }
+    } else {
+      // Single value → convert to array
+      config.channels[platform].allowFrom = [String(allowFrom), String(id)];
+    }
+
+    saveConfig(config);
+    this.engine.config = config;
+    logger.info('allowlist', `Added ${id} to ${platform} allowlist`);
+    return true;
+  }
+
+  /**
+   * Remove someone from the allowlist
+   */
+  remove(platform, id) {
+    const config = loadConfig();
+    const allowFrom = config.channels?.[platform]?.allowFrom;
+    if (!allowFrom || allowFrom === '*') return false;
+
+    if (Array.isArray(allowFrom)) {
+      config.channels[platform].allowFrom = allowFrom.filter(a => a !== String(id));
+      if (config.channels[platform].allowFrom.length === 0) {
+        config.channels[platform].allowFrom = '*'; // No one left = open
+      }
+    } else if (String(allowFrom) === String(id)) {
+      config.channels[platform].allowFrom = '*';
+    }
+
+    saveConfig(config);
+    this.engine.config = config;
+    logger.info('allowlist', `Removed ${id} from ${platform} allowlist`);
+    return true;
+  }
+
+  /**
+   * Open to everyone
+   */
+  openAll(platform) {
+    const config = loadConfig();
+    if (config.channels?.[platform]) {
+      config.channels[platform].allowFrom = '*';
+    }
+    saveConfig(config);
+    this.engine.config = config;
+    return true;
+  }
+
+  /**
+   * Lock down — only allowlist can message
+   */
+  lockDown(platform) {
+    // Just make sure allowFrom is an array (not '*')
+    const config = loadConfig();
+    if (config.channels?.[platform]) {
+      const cur = config.channels[platform].allowFrom;
+      if (!cur || cur === '*') {
+        config.channels[platform].allowFrom = [];
+      }
+    }
+    saveConfig(config);
+    this.engine.config = config;
+    return true;
+  }
+}

package/lib/middleware/ai-process.js

@@ -12,6 +12,8 @@ export async function aiProcessMiddleware(ctx, next) {
     messages: result.messages || [],
     reaction: result.reaction || null,
     image: result.image || null,
+    filePath: result.filePath || null,
+    fileName: result.fileName || null,
     _reminder: result._reminder || null,
   };
   ctx.metadata.originalType = ctx.metadata.originalType || null;

package/lib/middleware/commands.js

@@ -16,7 +16,12 @@ export async function commandsMiddleware(ctx, next) {
       '/memories — what I remember about you',
       '/tasks — your todo list',
       '/usage — spending report',
-      '/notes — notes',
+      '/allow <id> — allow someone to text me',
+              '/block <id> — block someone',
+              '/allowlist — show allowed users',
+              '/lockdown — restrict to allowlist only',
+              '/open — allow everyone',
+              '/notes — notes',
               '/contacts — contact book',
               '/briefing — daily briefing',
               '/summary — summarize chat',
@@ -127,6 +132,65 @@ export async function commandsMiddleware(ctx, next) {
     return;
   }
 
+  if (cmd === '/allow') {
+    const args = msg.slice(7).trim();
+    if (!args) { await ctx.reply('Usage: /allow <user_id or phone>'); return; }
+    try {
+      const { AllowlistManager } = await import('../features/allowlist-manager.js');
+      const am = new AllowlistManager(ctx.engine);
+      am.add(ctx.platform, args);
+      await ctx.reply('✅ Allowed *' + args + '* to message me');
+    } catch (err) { await ctx.reply('❌ ' + err.message); }
+    return;
+  }
+
+  if (cmd === '/block') {
+    const args = msg.slice(7).trim();
+    if (!args) { await ctx.reply('Usage: /block <user_id or phone>'); return; }
+    try {
+      const { AllowlistManager } = await import('../features/allowlist-manager.js');
+      const am = new AllowlistManager(ctx.engine);
+      am.remove(ctx.platform, args);
+      await ctx.reply('🚫 Blocked *' + args + '* from messaging me');
+    } catch (err) { await ctx.reply('❌ ' + err.message); }
+    return;
+  }
+
+  if (cmd === '/allowlist') {
+    try {
+      const { AllowlistManager } = await import('../features/allowlist-manager.js');
+      const am = new AllowlistManager(ctx.engine);
+      const { mode, list } = am.list(ctx.platform);
+      if (mode === 'open') {
+        await ctx.reply('🔓 *Open Mode* — anyone can message me\n\nUse /allow <id> to start restricting');
+      } else {
+        const lines = list.map(id => '• ' + id).join('\n');
+        await ctx.reply('🔒 *Restricted Mode*\n\nAllowed:\n' + lines + '\n\nUse /allow <id> or /block <id>');
+      }
+    } catch (err) { await ctx.reply('❌ ' + err.message); }
+    return;
+  }
+
+  if (cmd === '/open') {
+    try {
+      const { AllowlistManager } = await import('../features/allowlist-manager.js');
+      const am = new AllowlistManager(ctx.engine);
+      am.openAll(ctx.platform);
+      await ctx.reply('🔓 Open mode — anyone can message me now');
+    } catch (err) { await ctx.reply('❌ ' + err.message); }
+    return;
+  }
+
+  if (cmd === '/lockdown') {
+    try {
+      const { AllowlistManager } = await import('../features/allowlist-manager.js');
+      const am = new AllowlistManager(ctx.engine);
+      am.lockDown(ctx.platform);
+      await ctx.reply('🔒 Locked down — only allowlisted users can message me');
+    } catch (err) { await ctx.reply('❌ ' + err.message); }
+    return;
+  }
+
   if (cmd === '/notes') {
     try {
       const { NotesManager } = await import('../tools/notes.js');

package/lib/middleware/response-sender.js

@@ -29,6 +29,27 @@ export async function responseSenderMiddleware(ctx, next) {
 
   // Send via appropriate channel
   if (ctx.platform === 'telegram' && tm) {
+    // Send file attachment (pptx, etc)
+    if (response.filePath) {
+      try {
+        const { readFileSync } = await import('fs');
+        const { InputFile } = await import('grammy');
+        const bot = tm.getBotForAgent?.(agentId) || tm.bots?.values()?.next()?.value;
+        if (bot) {
+          const buffer = readFileSync(response.filePath);
+          await bot.api.sendDocument(contactId.replace('tg_', ''), new InputFile(buffer, response.fileName || 'file'), {
+            caption: response.messages?.[0] || '',
+          });
+          // Skip normal message sending
+          await next();
+          return;
+        }
+      } catch (err) {
+        logger.error('sender', 'File send failed: ' + err.message);
+        // Fall through to text
+      }
+    }
+
     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);

package/lib/tools/pptx.js

@@ -0,0 +1,146 @@
+/**
+ * 🦑 PowerPoint Generator
+ * Create .pptx presentations from AI-generated content
+ */
+
+import { logger } from '../core/logger.js';
+import { writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+export class PptxGenerator {
+  constructor() {
+    this.outputDir = '/tmp/squidclaw-pptx';
+    mkdirSync(this.outputDir, { recursive: true });
+  }
+
+  /**
+   * Create a presentation from structured content
+   * @param {string} title - Presentation title
+   * @param {Array} slides - [{title, content, bullets?, notes?}]
+   * @param {object} options - {theme, author}
+   */
+  async create(title, slides, options = {}) {
+    const pptxgen = (await import('pptxgenjs')).default;
+    const pres = new pptxgen();
+
+    // Metadata
+    pres.author = options.author || 'Squidclaw AI';
+    pres.title = title;
+    pres.subject = title;
+
+    // Theme colors
+    const themes = {
+      dark: { bg: '1a1a2e', title: 'e94560', text: 'eaeaea', accent: '0f3460' },
+      light: { bg: 'ffffff', title: '2d3436', text: '636e72', accent: '0984e3' },
+      blue: { bg: '0f3460', title: 'e94560', text: 'eaeaea', accent: '16213e' },
+      green: { bg: '1b4332', title: 'b7e4c7', text: 'd8f3dc', accent: '2d6a4f' },
+      corporate: { bg: 'ffffff', title: '2c3e50', text: '34495e', accent: '3498db' },
+      red: { bg: '2d0000', title: 'ff6b6b', text: 'ffe0e0', accent: '4a0000' },
+    };
+    const theme = themes[options.theme] || themes.corporate;
+
+    // Title slide
+    const titleSlide = pres.addSlide();
+    titleSlide.background = { color: theme.bg };
+    titleSlide.addText(title, {
+      x: 0.5, y: 1.5, w: 9, h: 1.5,
+      fontSize: 36, bold: true, color: theme.title,
+      align: 'center',
+    });
+    if (options.subtitle) {
+      titleSlide.addText(options.subtitle, {
+        x: 0.5, y: 3.2, w: 9, h: 0.8,
+        fontSize: 18, color: theme.text, align: 'center',
+      });
+    }
+    titleSlide.addText(new Date().toLocaleDateString('en-US', { year: 'numeric', month: 'long', day: 'numeric' }), {
+      x: 0.5, y: 4.5, w: 9, h: 0.5,
+      fontSize: 12, color: theme.text, align: 'center', italic: true,
+    });
+
+    // Content slides
+    for (const slide of slides) {
+      const s = pres.addSlide();
+      s.background = { color: theme.bg };
+
+      // Slide title
+      s.addText(slide.title || '', {
+        x: 0.5, y: 0.3, w: 9, h: 0.8,
+        fontSize: 24, bold: true, color: theme.title,
+      });
+
+      // Accent line
+      s.addShape(pres.ShapeType.rect, {
+        x: 0.5, y: 1.1, w: 2, h: 0.04, fill: { color: theme.title },
+      });
+
+      if (slide.bullets && slide.bullets.length > 0) {
+        // Bullet points
+        const bulletText = slide.bullets.map(b => ({
+          text: b,
+          options: { fontSize: 16, color: theme.text, bullet: { code: '2022' }, paraSpaceAfter: 8 },
+        }));
+        s.addText(bulletText, {
+          x: 0.5, y: 1.4, w: 9, h: 3.5,
+        });
+      } else if (slide.content) {
+        // Paragraph content
+        s.addText(slide.content, {
+          x: 0.5, y: 1.4, w: 9, h: 3.5,
+          fontSize: 16, color: theme.text,
+          valign: 'top', wrap: true,
+        });
+      }
+
+      // Slide notes
+      if (slide.notes) {
+        s.addNotes(slide.notes);
+      }
+
+      // Slide number
+      s.addText(String(slides.indexOf(slide) + 2), {
+        x: 9, y: 5, w: 0.5, h: 0.3,
+        fontSize: 10, color: theme.text, align: 'right',
+      });
+    }
+
+    // Save
+    const filename = title.replace(/[^a-zA-Z0-9\u0600-\u06FF ]/g, '').replace(/\s+/g, '_').slice(0, 50) + '.pptx';
+    const filepath = join(this.outputDir, filename);
+    
+    const data = await pres.write({ outputType: 'nodebuffer' });
+    writeFileSync(filepath, data);
+
+    logger.info('pptx', `Created: ${filepath} (${slides.length} slides)`);
+    return { filepath, filename, slideCount: slides.length + 1 }; // +1 for title slide
+  }
+
+  /**
+   * Parse AI-generated content into slides
+   * Format: "## Slide Title\n- bullet 1\n- bullet 2\n\n## Next Slide..."
+   */
+  static parseContent(text) {
+    const slides = [];
+    const sections = text.split(/^## /gm).filter(s => s.trim());
+
+    for (const section of sections) {
+      const lines = section.trim().split('\n');
+      const title = lines[0].trim();
+      const bullets = [];
+      let content = '';
+
+      for (let i = 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith('- ') || line.startsWith('• ') || line.startsWith('* ')) {
+          bullets.push(line.replace(/^[-•*]\s*/, ''));
+        } else if (line) {
+          content += (content ? '\n' : '') + line;
+        }
+      }
+
+      slides.push({ title, bullets: bullets.length > 0 ? bullets : null, content: content || null });
+    }
+
+    return slides;
+  }
+}

package/lib/tools/router.js

@@ -59,6 +59,30 @@ export class ToolRouter {
         'Send an email.');
     }
 
+    tools.push('', '### Create PowerPoint',
+      '---TOOL:pptx:Title of Presentation---',
+      'Create a .pptx PowerPoint file. After calling this, generate slides using markdown format:',
+      '## Slide Title',
+      '- Bullet point 1',
+      '- Bullet point 2',
+      '',
+      '## Another Slide',
+      '- More content',
+      '',
+      'Use ---TOOL:pptx_slides:## Slide 1\n- Point 1\n- Point 2\n\n## Slide 2\n- Point 3--- to generate the actual file.',
+      'Theme options after pipe: dark, light, blue, green, corporate, red',
+      'Example: ---TOOL:pptx_slides:title|theme|## Slide 1\n- point---');
+
+    tools.push('', '### Allow User',
+      '---TOOL:allow:user_id_or_phone---',
+      'Add someone to the allowlist so they can message you.',
+      '', '### Block User',
+      '---TOOL:block:user_id_or_phone---',
+      'Remove someone from the allowlist.',
+      '', '### Show Allowlist',
+      '---TOOL:allowlist:show---',
+      'Show who is currently allowed to message.');
+
     tools.push('', '### Save Note',
       '---TOOL:note:content of the note---',
       'Save a personal note for the user.',
@@ -211,6 +235,86 @@ export class ToolRouter {
           }
           break;
         }
+        case 'pptx':
+        case 'pptx_slides':
+        case 'powerpoint':
+        case 'presentation': {
+          try {
+            const { PptxGenerator } = await import('./pptx.js');
+            const gen = new PptxGenerator();
+            
+            // Parse: title|theme|content or just content
+            const parts = toolArg.split('|');
+            let title, theme, slideContent;
+            
+            if (parts.length >= 3) {
+              title = parts[0].trim();
+              theme = parts[1].trim();
+              slideContent = parts.slice(2).join('|');
+            } else if (parts.length === 2) {
+              title = parts[0].trim();
+              slideContent = parts[1];
+              theme = 'corporate';
+            } else {
+              // Try to extract title from first ## heading
+              const firstH2 = toolArg.match(/^##\s+(.+)/m);
+              title = firstH2 ? firstH2[1] : 'Presentation';
+              slideContent = toolArg;
+              theme = 'corporate';
+            }
+            
+            const slides = PptxGenerator.parseContent(slideContent);
+            if (slides.length === 0) {
+              toolResult = 'No slides found. Use ## headings and - bullet points.';
+              break;
+            }
+            
+            const result = await gen.create(title, slides, { theme });
+            
+            // Return file path for sending
+            return {
+              toolUsed: true,
+              toolName: 'pptx',
+              toolResult: 'PowerPoint created: ' + result.filename + ' (' + result.slideCount + ' slides)',
+              filePath: result.filepath,
+              fileName: result.filename,
+              cleanResponse
+            };
+          } catch (err) {
+            toolResult = 'PowerPoint failed: ' + err.message;
+          }
+          break;
+        }
+        case 'allow': {
+          try {
+            const { AllowlistManager } = await import('../features/allowlist-manager.js');
+            const am = new AllowlistManager(this._engine);
+            const platform = this._currentPlatform || 'telegram';
+            am.add(platform, toolArg);
+            toolResult = 'Allowed ' + toolArg + ' to message you ✅';
+          } catch (err) { toolResult = 'Failed: ' + err.message; }
+          break;
+        }
+        case 'block': {
+          try {
+            const { AllowlistManager } = await import('../features/allowlist-manager.js');
+            const am = new AllowlistManager(this._engine);
+            const platform = this._currentPlatform || 'telegram';
+            am.remove(platform, toolArg);
+            toolResult = 'Blocked ' + toolArg + ' ✅';
+          } catch (err) { toolResult = 'Failed: ' + err.message; }
+          break;
+        }
+        case 'allowlist': {
+          try {
+            const { AllowlistManager } = await import('../features/allowlist-manager.js');
+            const am = new AllowlistManager(this._engine);
+            const platform = this._currentPlatform || 'telegram';
+            const { mode, list } = am.list(platform);
+            toolResult = mode === 'open' ? 'Open — anyone can message' : 'Restricted to: ' + list.join(', ');
+          } catch (err) { toolResult = 'Failed: ' + err.message; }
+          break;
+        }
         case 'note': {
           const { NotesManager } = await import('./notes.js');
           const nm = new NotesManager(this.storage);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squidclaw",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "🦑 AI agent platform — human-like agents for WhatsApp, Telegram & more",
   "main": "lib/engine.js",
   "bin": {
@@ -49,6 +49,7 @@
     "node-edge-tts": "^1.2.10",
     "pdfjs-dist": "^5.4.624",
     "pino": "^10.3.1",
+    "pptxgenjs": "^4.0.1",
     "puppeteer-core": "^24.37.5",
     "qrcode-terminal": "^0.12.0",
     "sharp": "^0.34.5",