squidclaw 0.6.1 → 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

@@ -43,6 +43,53 @@ 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();

package/lib/engine.js

@@ -93,6 +93,69 @@ 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();

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.1",
+  "version": "0.7.0",
   "description": "\ud83e\udd91 AI agent platform \u2014 human-like agents for WhatsApp, Telegram & more",
   "main": "lib/engine.js",
   "bin": {