squidclaw 0.6.0 → 0.7.0

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

@@ -6,10 +6,11 @@
 import { logger } from '../core/logger.js';
 
 export class ChannelHub {
-  constructor(agentManager, whatsappManager, storage) {
+  constructor(agentManager, whatsappManager, storage, telegramManager) {
     this.agentManager = agentManager;
     this.whatsappManager = whatsappManager;
     this.storage = storage;
+    this.telegramManager = telegramManager || null;
 
     // Wire up WhatsApp message handler
     this.whatsappManager.onMessage = this._handleWhatsAppMessage.bind(this);
@@ -42,6 +43,88 @@ export class ChannelHub {
       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\'m 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();
+      const h = Math.floor(uptime / 3600);
+      const m = Math.floor((uptime % 3600) / 60);
+      const usage = await this.storage.getUsage(agentId) || {};
+      const convos = await this.storage.getConversationCount?.(agentId) || 0;
+      const config = agent.config || {};
+      
+      const status = [
+        '🦑 *' + (agent.name || agentId) + ' Status*',
+        '────────────────────',
+        '🧠 Model: ' + (agent.model || 'unknown'),
+        '⏱️ Uptime: ' + h + 'h ' + m + 'm',
+        '💬 Messages: ' + (usage.messages || 0),
+        '🪙 Tokens: ' + formatTokens((usage.input_tokens || 0) + (usage.output_tokens || 0)),
+        '💰 Cost: $' + (usage.cost_usd || 0).toFixed(4),
+        '────────────────────',
+        '📱 WhatsApp: ' + (metadata.platform === 'whatsapp' ? '✅ connected' : '—'),
+        '✈️ Telegram: ' + (metadata.platform === 'telegram' ? '✅ connected' : '—'),
+        '────────────────────',
+        '⚡ Skills: web search, page reader, vision, voice, memory',
+        '🗣️ Language: ' + (agent.language || 'bilingual'),
+      ];
+      
+      try {
+        if (metadata.platform === 'telegram' || metadata._ctx) {
+          await this.telegramManager?.sendMessage(agentId, contactId, status.join('\n'), metadata);
+        } else {
+          await this.whatsappManager?.sendMessage(agentId, contactId, status.join('\n'));
+        }
+      } catch {}
+      return;
+    }
+
     // Process message through agent
     const result = await agent.processMessage(contactId, message, metadata);
 
@@ -101,3 +184,10 @@ export class ChannelHub {
     }
   }
 }
+
+
+function formatTokens(n) {
+  if (n >= 1000000) return (n / 1000000).toFixed(1) + 'M';
+  if (n >= 1000) return (n / 1000).toFixed(1) + 'K';
+  return String(n);
+}

package/lib/engine.js

@@ -93,6 +93,99 @@ export class SquidclawEngine {
             if (!allowed) 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\'m 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();
+            const h = Math.floor(uptime / 3600);
+            const m = Math.floor((uptime % 3600) / 60);
+            const usage = await this.storage.getUsage(agentId) || {};
+            const tokens = (usage.input_tokens || 0) + (usage.output_tokens || 0);
+            const fmtT = tokens >= 1000000 ? (tokens/1000000).toFixed(1)+'M' : tokens >= 1000 ? (tokens/1000).toFixed(1)+'K' : String(tokens);
+            const waOn = Object.values(this.whatsappManager?.getStatuses() || {}).some(s => s.connected);
+            
+            const lines = [
+              `🦑 *${agent.name || agentId} Status*`,
+              '────────────────────',
+              `🧠 Model: ${agent.model || 'unknown'}`,
+              `⏱️ Uptime: ${h}h ${m}m`,
+              `💬 Messages: ${usage.messages || 0}`,
+              `🪙 Tokens: ${fmtT}`,
+              `💰 Cost: $${(usage.cost_usd || 0).toFixed(4)}`,
+              '────────────────────',
+              `📱 WhatsApp: ${waOn ? '✅' : '❌'}`,
+              '✈️ Telegram: ✅ connected',
+              '────────────────────',
+              '⚡ Skills: search, reader, vision, voice, memory',
+              `🗣️ Language: ${agent.language || 'bilingual'}`,
+            ];
+            
+            await this.telegramManager.sendMessage(agentId, contactId, lines.join('\n'), metadata);
+            return;
+          }
+
           const result = await agent.processMessage(contactId, message, metadata);
           
           if (result.reaction && metadata.messageId) {
@@ -138,7 +231,7 @@ export class SquidclawEngine {
     console.log(`  📱 WhatsApp: ${connected}/${agents.length} connected`);
 
     // 5. Channel Hub
-    this.channelHub = new ChannelHub(this.agentManager, this.whatsappManager, this.storage);
+    this.channelHub = new ChannelHub(this.agentManager, this.whatsappManager, this.storage, this.telegramManager);
     addMediaSupport(this.channelHub, this.config, this.home);
 
     // 6. Heartbeat

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/package.json

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