squidclaw 0.6.1 → 0.7.1

package/lib/api/server.js

@@ -271,3 +271,31 @@ export function addKnowledgeRoutes(app, engine) {
     }
   });
 }
+
+// ── Backup & Restore ──
+export function addBackupRoutes(app, engine) {
+  app.post('/api/agents/:id/backup', async (req, res) => {
+    try {
+      const { AgentBackup } = await import('../features/backup.js');
+      const backup = await AgentBackup.create(req.params.id, engine.home, engine.storage);
+      const filename = `${backup.agent.name || req.params.id}_backup_${new Date().toISOString().slice(0,10)}.json`;
+      const path = `/tmp/${filename}`;
+      await AgentBackup.saveToFile(backup, path);
+      res.json({ status: 'ok', path, size: JSON.stringify(backup).length, agent: backup.agent.name });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/agents/restore', async (req, res) => {
+    const { path } = req.body;
+    if (!path) return res.status(400).json({ error: 'path required' });
+    try {
+      const { AgentBackup } = await import('../features/backup.js');
+      const result = await AgentBackup.restore(path, engine.home, engine.storage);
+      res.json({ status: 'restored', ...result });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+}

package/lib/channels/hub.js

@@ -43,6 +43,64 @@ export class ChannelHub {
       return;
     }
 
+    // Handle API key detection
+    const { detectApiKey, saveApiKey, getKeyConfirmation, detectSkillRequest, checkSkillAvailable, getKeyRequestMessage } = await import('../features/self-config.js');
+    
+    const keyDetected = detectApiKey(message);
+    if (keyDetected && keyDetected.provider !== 'unknown') {
+      saveApiKey(keyDetected.provider, keyDetected.key);
+      const confirmation = getKeyConfirmation(keyDetected.provider);
+      await this.whatsappManager.sendMessage(agentId, contactId, confirmation);
+      return;
+    }
+
+    // Handle /help
+    if (message.trim() === '/help') {
+      const helpText = [
+        '🦑 *Commands*', '',
+        '/status — model, uptime, usage',
+        '/backup — save me to a backup file',
+        '/memories — what I remember',
+        '/help — this message',
+        '', 'Just chat normally! 🦑',
+      ];
+      await this.whatsappManager.sendMessage(agentId, contactId, helpText.join('\n'));
+      return;
+    }
+
+    // Handle /backup
+    if (message.trim() === '/backup' || (message.toLowerCase().includes('backup') && message.toLowerCase().includes('yourself'))) {
+      try {
+        const { AgentBackup } = await import('../features/backup.js');
+        const { mkdirSync } = await import('fs');
+        const home = (await import('../core/config.js')).getHome();
+        mkdirSync(home + '/backups', { recursive: true });
+        const backup = await AgentBackup.create(agentId, home, this.storage);
+        const filename = (agent.name || agentId) + '_backup_' + new Date().toISOString().slice(0,10) + '.json';
+        await AgentBackup.saveToFile(backup, home + '/backups/' + filename);
+        const size = (JSON.stringify(backup).length / 1024).toFixed(1);
+        await this.whatsappManager.sendMessage(agentId, contactId, 
+          '💾 *Backup Complete!*\n\n📦 ' + filename + '\n📏 ' + size + ' KB\n💬 ' + (backup.conversations?.length || 0) + ' messages\n🧠 ' + (backup.memories?.length || 0) + ' memories\n\nI am safe! 🦑');
+      } catch (err) {
+        await this.whatsappManager.sendMessage(agentId, contactId, '❌ Backup failed: ' + err.message);
+      }
+      return;
+    }
+
+    // Handle /memories
+    if (message.trim() === '/memories') {
+      try {
+        const memories = await this.storage.getMemories(agentId);
+        if (memories.length === 0) {
+          await this.whatsappManager.sendMessage(agentId, contactId, '🧠 No memories yet!');
+        } else {
+          const memList = memories.slice(0, 20).map(m => '• ' + m.key + ': ' + m.value).join('\n');
+          await this.whatsappManager.sendMessage(agentId, contactId, '🧠 *What I Remember*\n\n' + memList);
+        }
+      } catch {}
+      return;
+    }
+
     // Handle /status command
     if (message.trim() === '/status' || message.trim().toLowerCase() === 'status') {
       const uptime = process.uptime();
@@ -78,6 +136,20 @@ export class ChannelHub {
       return;
     }
 
+    // Check if asking for unavailable skill
+    const skillRequest = detectSkillRequest(message);
+    if (skillRequest) {
+      const config = (await import('../core/config.js')).loadConfig();
+      const availability = checkSkillAvailable(skillRequest, config);
+      if (!availability.available) {
+        const keyMsg = getKeyRequestMessage(skillRequest);
+        if (keyMsg) {
+          await this.whatsappManager.sendMessage(agentId, contactId, keyMsg);
+          return;
+        }
+      }
+    }
+
     // Process message through agent
     const result = await agent.processMessage(contactId, message, metadata);
 

package/lib/engine.js

@@ -93,6 +93,80 @@ export class SquidclawEngine {
             if (!allowed) return;
           }
 
+          // Handle API key detection — user pasting a key
+          const { detectApiKey, saveApiKey, getKeyConfirmation, detectSkillRequest, checkSkillAvailable, getKeyRequestMessage } = await import('./features/self-config.js');
+          
+          const keyDetected = detectApiKey(message);
+          if (keyDetected && keyDetected.provider !== 'unknown') {
+            saveApiKey(keyDetected.provider, keyDetected.key);
+            const confirmation = getKeyConfirmation(keyDetected.provider);
+            await this.telegramManager.sendMessage(agentId, contactId, confirmation, metadata);
+            return;
+          }
+
+          // Handle /help command
+          if (message.trim() === '/help') {
+            const helpText = [
+              '🦑 *Commands*',
+              '',
+              '/status — model, uptime, usage stats',
+              '/backup — save me to a backup file',
+              '/memories — what I remember about you',
+              '/help — this message',
+              '',
+              'Just chat normally — I\'ll search the web, remember things, and help! 🦑',
+            ];
+            await this.telegramManager.sendMessage(agentId, contactId, helpText.join('\n'), metadata);
+            return;
+          }
+
+          // Handle /backup command
+          if (message.trim() === '/backup' || message.trim().toLowerCase() === 'backup yourself' || message.trim().toLowerCase().includes('backup')) {
+            if (message.toLowerCase().includes('backup') && (message.toLowerCase().includes('yourself') || message.toLowerCase().includes('your') || message.trim() === '/backup')) {
+              try {
+                const { AgentBackup } = await import('./features/backup.js');
+                const backup = await AgentBackup.create(agentId, this.home, this.storage);
+                const filename = (agent.name || agentId) + '_backup_' + new Date().toISOString().slice(0,10) + '.json';
+                const path = this.home + '/backups/' + filename;
+                const { mkdirSync } = await import('fs');
+                mkdirSync(this.home + '/backups', { recursive: true });
+                await AgentBackup.saveToFile(backup, path);
+                const size = (JSON.stringify(backup).length / 1024).toFixed(1);
+                const lines = [
+                  '💾 *Backup Complete!*',
+                  '',
+                  '📦 File: ' + filename,
+                  '📏 Size: ' + size + ' KB',
+                  '💬 Messages: ' + (backup.conversations?.length || 0),
+                  '🧠 Memories: ' + (backup.memories?.length || 0),
+                  '📄 Files: ' + Object.keys(backup.files).length,
+                  '',
+                  'I am safe! You can resurrect me anytime with this file 🦑',
+                ];
+                await this.telegramManager.sendMessage(agentId, contactId, lines.join('\n'), metadata);
+              } catch (err) {
+                await this.telegramManager.sendMessage(agentId, contactId, '❌ Backup failed: ' + err.message, metadata);
+              }
+              return;
+            }
+          }
+
+          // Handle /memories command
+          if (message.trim() === '/memories' || message.trim() === '/remember') {
+            try {
+              const memories = await this.storage.getMemories(agentId);
+              if (memories.length === 0) {
+                await this.telegramManager.sendMessage(agentId, contactId, '🧠 No memories yet. Tell me things and I\'ll remember!', metadata);
+              } else {
+                const memList = memories.slice(0, 20).map(m => '• ' + m.key + ': ' + m.value).join('\n');
+                await this.telegramManager.sendMessage(agentId, contactId, '🧠 *What I Remember*\n\n' + memList, metadata);
+              }
+            } catch (err) {
+              await this.telegramManager.sendMessage(agentId, contactId, '🧠 Memory error: ' + err.message, metadata);
+            }
+            return;
+          }
+
           // Handle /status command
           if (message.trim() === '/status' || message.trim().toLowerCase() === 'status') {
             const uptime = process.uptime();
@@ -123,6 +197,19 @@ export class SquidclawEngine {
             return;
           }
 
+          // Check if user is asking for a skill we don't have
+          const skillRequest = detectSkillRequest(message);
+          if (skillRequest) {
+            const availability = checkSkillAvailable(skillRequest, this.config);
+            if (!availability.available) {
+              const keyMsg = getKeyRequestMessage(skillRequest);
+              if (keyMsg) {
+                await this.telegramManager.sendMessage(agentId, contactId, keyMsg, metadata);
+                return;
+              }
+            }
+          }
+
           const result = await agent.processMessage(contactId, message, metadata);
           
           if (result.reaction && metadata.messageId) {

package/lib/features/backup.js

@@ -0,0 +1,138 @@
+/**
+ * 🦑 Agent Backup & Restore
+ * Saves everything about an agent to a single JSON file
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from 'fs';
+import { join, basename } from 'path';
+
+export class AgentBackup {
+  
+  /**
+   * Create a full backup of an agent — soul, memory, conversations, config
+   */
+  static async create(agentId, home, storage) {
+    const agentDir = join(home, 'agents', agentId);
+    if (!existsSync(agentDir)) throw new Error('Agent not found: ' + agentId);
+
+    const backup = {
+      version: '1.0',
+      type: 'squidclaw-agent-backup',
+      createdAt: new Date().toISOString(),
+      agent: {},
+      files: {},
+      conversations: [],
+      memories: [],
+      usage: null,
+    };
+
+    // Read agent manifest
+    const manifestPath = join(agentDir, 'agent.json');
+    if (existsSync(manifestPath)) {
+      backup.agent = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    }
+
+    // Read all .md and .json files in agent dir
+    const readDir = (dir, prefix) => {
+      if (!existsSync(dir)) return;
+      for (const file of readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = join(dir, file.name);
+        const key = prefix ? prefix + '/' + file.name : file.name;
+        if (file.isDirectory()) {
+          readDir(fullPath, key);
+        } else if (file.name.endsWith('.md') || file.name.endsWith('.json') || file.name.endsWith('.txt')) {
+          backup.files[key] = readFileSync(fullPath, 'utf8');
+        }
+      }
+    };
+    readDir(agentDir, '');
+
+    // Get conversations from DB
+    if (storage) {
+      try {
+        const convos = storage.db.prepare(
+          'SELECT * FROM messages WHERE agent_id = ? ORDER BY created_at DESC LIMIT 500'
+        ).all(agentId);
+        backup.conversations = convos;
+      } catch {}
+
+      // Get memories
+      try {
+        const memories = storage.db.prepare(
+          'SELECT * FROM memories WHERE agent_id = ?'
+        ).all(agentId);
+        backup.memories = memories;
+      } catch {}
+
+      // Get usage
+      try {
+        backup.usage = storage.db.prepare(
+          'SELECT SUM(input_tokens) as input_tokens, SUM(output_tokens) as output_tokens, SUM(cost_usd) as cost_usd, COUNT(*) as calls FROM usage WHERE agent_id = ?'
+        ).get(agentId);
+      } catch {}
+    }
+
+    return backup;
+  }
+
+  /**
+   * Save backup to file
+   */
+  static async saveToFile(backup, outputPath) {
+    writeFileSync(outputPath, JSON.stringify(backup, null, 2));
+    return outputPath;
+  }
+
+  /**
+   * Restore agent from backup file
+   */
+  static async restore(backupPath, home, storage) {
+    const backup = JSON.parse(readFileSync(backupPath, 'utf8'));
+    
+    if (backup.type !== 'squidclaw-agent-backup') {
+      throw new Error('Invalid backup file');
+    }
+
+    const agentId = backup.agent.id;
+    const agentDir = join(home, 'agents', agentId);
+
+    // Recreate directory structure
+    mkdirSync(join(agentDir, 'memory'), { recursive: true });
+
+    // Restore all files
+    for (const [key, content] of Object.entries(backup.files)) {
+      const filePath = join(agentDir, key);
+      const dir = join(filePath, '..');
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(filePath, content);
+    }
+
+    // Restore conversations to DB
+    if (storage && backup.conversations.length > 0) {
+      const insert = storage.db.prepare(
+        'INSERT OR IGNORE INTO messages (id, agent_id, contact_id, role, content, created_at) VALUES (?, ?, ?, ?, ?, ?)'
+      );
+      const tx = storage.db.transaction(() => {
+        for (const msg of backup.conversations) {
+          insert.run(msg.id, msg.agent_id, msg.contact_id, msg.role, msg.content, msg.created_at);
+        }
+      });
+      tx();
+    }
+
+    // Restore memories
+    if (storage && backup.memories.length > 0) {
+      const insert = storage.db.prepare(
+        'INSERT OR IGNORE INTO memories (id, agent_id, key, value, created_at) VALUES (?, ?, ?, ?, ?)'
+      );
+      const tx = storage.db.transaction(() => {
+        for (const mem of backup.memories) {
+          insert.run(mem.id, mem.agent_id, mem.key, mem.value, mem.created_at);
+        }
+      });
+      tx();
+    }
+
+    return { agentId, name: backup.agent.name, filesRestored: Object.keys(backup.files).length };
+  }
+}

package/lib/features/self-config.js

@@ -0,0 +1,197 @@
+/**
+ * 🦑 Self-Configuration
+ * Agent can request and add API keys through chat
+ */
+
+import { loadConfig, saveConfig } from '../core/config.js';
+import { logger } from '../core/logger.js';
+
+// Skills that need specific API keys
+const SKILL_REQUIREMENTS = {
+  'image_generation': {
+    name: 'Image Generation',
+    providers: [
+      { id: 'openai', label: 'OpenAI (DALL-E)', keyUrl: 'platform.openai.com/api-keys', keyPrefix: 'sk-' },
+      { id: 'google', label: 'Google (Gemini/Imagen)', keyUrl: 'aistudio.google.dev/apikey', keyPrefix: 'AI' },
+    ],
+  },
+  'vision': {
+    name: 'Image Understanding',
+    providers: [
+      { id: 'anthropic', label: 'Anthropic (Claude Vision)', keyUrl: 'console.anthropic.com/keys', keyPrefix: 'sk-ant-' },
+      { id: 'openai', label: 'OpenAI (GPT-4 Vision)', keyUrl: 'platform.openai.com/api-keys', keyPrefix: 'sk-' },
+    ],
+  },
+  'voice_tts': {
+    name: 'Voice Notes (TTS)',
+    providers: [
+      { id: 'edge', label: 'Microsoft Edge TTS (FREE)', keyPrefix: null },
+      { id: 'openai', label: 'OpenAI TTS', keyUrl: 'platform.openai.com/api-keys', keyPrefix: 'sk-' },
+    ],
+  },
+  'transcription': {
+    name: 'Voice Transcription',
+    providers: [
+      { id: 'groq', label: 'Groq Whisper (FREE)', keyUrl: 'console.groq.com/keys', keyPrefix: 'gsk_' },
+      { id: 'openai', label: 'OpenAI Whisper', keyUrl: 'platform.openai.com/api-keys', keyPrefix: 'sk-' },
+    ],
+  },
+  'web_search': {
+    name: 'Web Search',
+    providers: [
+      { id: 'duckduckgo', label: 'DuckDuckGo (FREE)', keyPrefix: null },
+    ],
+  },
+  'code_execution': {
+    name: 'Code Execution',
+    providers: [
+      { id: 'local', label: 'Local (sandboxed)', keyPrefix: null },
+    ],
+  },
+};
+
+// Detect what skill the user is asking for
+export function detectSkillRequest(message) {
+  const lower = message.toLowerCase();
+  
+  if (lower.match(/generat.*image|create.*image|draw|make.*picture|dall.?e|imagen|image.*generat/)) {
+    return 'image_generation';
+  }
+  if (lower.match(/analyz.*image|understand.*image|what.*this.*photo|vision|see.*image|look.*at/)) {
+    return 'vision';
+  }
+  if (lower.match(/voice.*note|speak|tts|text.*to.*speech|send.*voice/)) {
+    return 'voice_tts';
+  }
+  if (lower.match(/transcrib|speech.*to.*text|whisper/)) {
+    return 'transcription';
+  }
+  if (lower.match(/run.*code|execut.*code|python|javascript/)) {
+    return 'code_execution';
+  }
+  return null;
+}
+
+// Check if we have the key for a skill
+export function checkSkillAvailable(skill, config) {
+  const req = SKILL_REQUIREMENTS[skill];
+  if (!req) return { available: true };
+
+  for (const prov of req.providers) {
+    if (!prov.keyPrefix) return { available: true, provider: prov }; // Free skill
+    const key = config.ai?.providers?.[prov.id]?.key;
+    if (key && key !== 'local' && key.length > 5) {
+      return { available: true, provider: prov };
+    }
+  }
+
+  return { available: false, skill: req, requirements: req.providers.filter(p => p.keyPrefix) };
+}
+
+// Generate "I need a key" message
+export function getKeyRequestMessage(skill) {
+  const req = SKILL_REQUIREMENTS[skill];
+  if (!req) return null;
+
+  const providers = req.providers.filter(p => p.keyPrefix);
+  if (providers.length === 0) return null;
+
+  const lines = [
+    `🔑 I need an API key to ${req.name.toLowerCase()}!`,
+    '',
+  ];
+
+  for (const prov of providers) {
+    lines.push(`*${prov.label}*`);
+    lines.push(`Get yours at: ${prov.keyUrl}`);
+    lines.push('');
+  }
+
+  lines.push('Just paste the key here and I will add it myself! 🦑');
+
+  return lines.join('\n');
+}
+
+// Detect if a message is an API key
+export function detectApiKey(message) {
+  const trimmed = message.trim();
+  
+  // Anthropic
+  if (trimmed.startsWith('sk-ant-')) {
+    return { provider: 'anthropic', key: trimmed };
+  }
+  // OpenAI
+  if (trimmed.startsWith('sk-') && !trimmed.startsWith('sk-ant-') && trimmed.length > 20) {
+    return { provider: 'openai', key: trimmed };
+  }
+  // Groq
+  if (trimmed.startsWith('gsk_')) {
+    return { provider: 'groq', key: trimmed };
+  }
+  // Google
+  if (trimmed.startsWith('AI') && trimmed.length > 20 && !trimmed.includes(' ')) {
+    return { provider: 'google', key: trimmed };
+  }
+  // Together
+  if (trimmed.length > 40 && !trimmed.includes(' ') && /^[a-f0-9]+$/.test(trimmed)) {
+    return { provider: 'together', key: trimmed };
+  }
+  // Generic long token
+  if (trimmed.length > 30 && !trimmed.includes(' ') && !trimmed.includes('\n')) {
+    return { provider: 'unknown', key: trimmed };
+  }
+
+  return null;
+}
+
+// Save an API key to config
+export function saveApiKey(provider, key) {
+  const config = loadConfig();
+  config.ai = config.ai || { providers: {} };
+  config.ai.providers = config.ai.providers || {};
+  config.ai.providers[provider] = config.ai.providers[provider] || {};
+  config.ai.providers[provider].key = key;
+  saveConfig(config);
+  
+  logger.info('self-config', `API key saved for provider: ${provider}`);
+  return true;
+}
+
+// Get confirmation message after key is saved
+export function getKeyConfirmation(provider) {
+  const providerNames = {
+    anthropic: 'Anthropic (Claude)',
+    openai: 'OpenAI',
+    google: 'Google (Gemini)',
+    groq: 'Groq',
+    together: 'Together AI',
+    cerebras: 'Cerebras',
+    mistral: 'Mistral',
+  };
+
+  const skills = {
+    anthropic: ['Chat (Claude)', 'Image Understanding', 'Code Analysis'],
+    openai: ['Chat (GPT-4o)', 'Image Generation (DALL-E)', 'Voice (Whisper + TTS)', 'Image Understanding'],
+    google: ['Chat (Gemini)', 'Image Generation (Imagen)', 'Embeddings'],
+    groq: ['Chat (Llama)', 'Voice Transcription (Whisper) — FREE'],
+    together: ['Chat (Llama, DeepSeek)'],
+    cerebras: ['Chat (Llama) — FREE'],
+    mistral: ['Chat (Mistral)'],
+  };
+
+  const name = providerNames[provider] || provider;
+  const newSkills = skills[provider] || ['Chat'];
+
+  const lines = [
+    `✅ *${name} key added!*`,
+    '',
+    '🆕 New skills unlocked:',
+    ...newSkills.map(s => `  • ${s}`),
+    '',
+    'I am now more powerful! Try asking me to use these 🦑',
+  ];
+
+  return lines.join('\n');
+}
+
+export { SKILL_REQUIREMENTS };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squidclaw",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "description": "\ud83e\udd91 AI agent platform \u2014 human-like agents for WhatsApp, Telegram & more",
   "main": "lib/engine.js",
   "bin": {