squidclaw 2.0.0 → 2.1.0

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/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/tools/router.js

@@ -59,6 +59,16 @@ export class ToolRouter {
         'Send an email.');
     }
 
+    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 +221,36 @@ export class ToolRouter {
           }
           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.1.0",
   "description": "🦑 AI agent platform — human-like agents for WhatsApp, Telegram & more",
   "main": "lib/engine.js",
   "bin": {