@intranefr/superbackend 1.6.6 → 1.6.7

package/src/cli/agent-chat.js

@@ -0,0 +1,369 @@
+#!/usr/bin/env node
+
+require('dotenv').config(process.env.MODE ? { path: `.env.${process.env.MODE}` } : {});
+process.env.TUI_MODE = 'true';
+const { ScriptBase } = require('../helpers/scriptBase');
+const agentService = require('../services/agent.service');
+const llmService = require('../services/llm.service');
+const Agent = require('../models/Agent');
+const JsonConfig = require('../models/JsonConfig');
+const term = require('terminal-kit').terminal;
+
+class AgentChatTUI extends ScriptBase {
+  constructor() {
+    super({
+      name: 'AgentChatTUI',
+      autoDisconnect: true,
+      timeout: 3600000
+    });
+    this.chatId = `tui-${Date.now()}`;
+    this.escCount = 0;
+    this.escTimer = null;
+    this.abortController = null;
+    this.isProcessing = false;
+  }
+
+  getRelativeTime(date) {
+    const now = new Date();
+    const diff = now - new Date(date);
+    const seconds = Math.floor(diff / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+
+    if (seconds < 60) return 'just now';
+    if (minutes < 60) return `${minutes}m ago`;
+    if (hours < 24) return `${hours}h ago`;
+    if (days < 7) return `${days}d ago`;
+    return new Date(date).toLocaleDateString();
+  }
+
+  async execute(context) {
+    term.clear();
+    term.bold.cyan('--- SuperBackend AI Agent TUI ---\n\n');
+
+    const agents = await Agent.find().lean();
+    if (agents.length === 0) {
+      term.red('❌ No agents found. Please create an agent in the admin UI first.\n');
+      return;
+    }
+
+    term.white('Available Agents:\n');
+    agents.forEach((a, i) => {
+      term.white(`${i + 1}. `).cyan(`${a.name} `).gray(`(${a.model})\n`);
+    });
+    term.white(`${agents.length + 1}. `).red('Exit\n');
+
+    term.white('\nSelect an agent (number): ');
+    const choice = await term.inputField().promise;
+    const index = parseInt(choice, 10) - 1;
+
+    if (isNaN(index) || index < 0 || index >= agents.length) {
+      if (index === agents.length) {
+        term.green('\nGoodbye!\n');
+        return;
+      }
+      term.red('\nInvalid selection.\n');
+      return;
+    }
+
+    const selectedAgent = agents[index];
+    this.selectedAgent = selectedAgent;
+    const senderId = 'cli-user';
+
+    term.clear();
+    term.bold.cyan(`\n--- Chatting with: ${selectedAgent.name} ---\n\n`);
+
+    term.on('key', (name) => {
+      if (name === 'ESCAPE') {
+        if (!this.isProcessing) return;
+        
+        this.escCount++;
+        if (this.escCount === 1) {
+          this.drawStatusBar(' Press ESC again to stop operation ', 'bgRed');
+          
+          this.escTimer = setTimeout(() => {
+            this.escCount = 0;
+            this.drawStatusBar();
+          }, 2000);
+        } else if (this.escCount >= 2) {
+          if (this.abortController) {
+            this.abortController.abort();
+            this.drawStatusBar(' 🛑 Aborting... ', 'bgYellow', 'black');
+            setTimeout(() => this.drawStatusBar(), 1000);
+          }
+          this.escCount = 0;
+          if (this.escTimer) clearTimeout(this.escTimer);
+        }
+      } else if (name === 'CTRL_C') {
+        term.grabInput(false);
+        process.exit();
+      }
+    });
+
+    term.grabInput(true);
+    
+    term.scrollingRegion(1, term.height - 2);
+    
+    this.drawStatusBar();
+
+    term.on('resize', (width, height) => {
+        term.scrollingRegion(1, height - 2);
+        this.drawStatusBar();
+    });
+
+    while (true) {
+      term.bold.cyan(`\n[${this.chatId.slice(-8)}] You: `);
+      const input = await term.inputField().promise;
+      term('\n');
+      
+      const cmd = input.toLowerCase().trim();
+      if (['exit', 'quit', '\\q'].includes(cmd)) {
+        term.bold.green('\n👋 Ending session...\n');
+        break;
+      }
+
+      if (cmd === '/compact') {
+        term.bold.yellow('✨ Compacting session... ');
+        try {
+          const result = await agentService.compactSession(selectedAgent._id, this.chatId);
+          if (result.success) {
+            term.bold.green(`Done! Created snapshot: ${result.snapshotId}\n`);
+          } else {
+            term.bold.red(`Failed: ${result.message}\n`);
+          }
+        } catch (err) {
+          term.bold.red(`Error: ${err.message}\n`);
+        }
+        continue;
+      }
+
+      if (cmd === '/new') {
+        this.chatId = `tui-${Date.now()}`;
+        this.drawStatusBar();
+        term.bold.green(`\n🆕 Started new session: ${this.chatId}\n`);
+        continue;
+      }
+
+      if (cmd === '/sessions') {
+        const sessionConfigs = await JsonConfig.find({
+          alias: { $regex: /^agent-session-tui-/ }
+        })
+        .sort({ updatedAt: -1 })
+        .limit(10)
+        .lean();
+
+        term.bold.white('\n--- Recent TUI Sessions ---\n');
+        if (sessionConfigs.length === 0) {
+          term.gray('No recent sessions found.\n');
+        } else {
+          sessionConfigs.forEach((c, i) => {
+            const data = JSON.parse(c.jsonRaw);
+            const labelDisplay = data.label ? `^c[${data.label}] ` : '';
+            const timeAgo = this.getRelativeTime(c.updatedAt);
+            term.white(`${i + 1}. `).cyan(`${labelDisplay}`).bold(`${data.id} `).gray(`(${timeAgo})\n`);
+            term.gray(`   Tokens: ${data.totalTokens || 0} | Snapshot: ${data.lastSnapshotId || 'None'}\n`);
+          });
+        }
+        
+        term.bold.white('\nSelect session number (or Enter to cancel): ');
+        const sessionChoice = await term.inputField().promise;
+        if (sessionChoice.trim()) {
+          const sIndex = parseInt(sessionChoice, 10) - 1;
+          if (!isNaN(sIndex) && sIndex >= 0 && sIndex < sessionConfigs.length) {
+            const selectedSession = JSON.parse(sessionConfigs[sIndex].jsonRaw);
+            this.chatId = selectedSession.id;
+            this.drawStatusBar();
+            const labelDisplay = selectedSession.label ? ` (${selectedSession.label})` : '';
+            term.bold.green(`\n🔄 Switched to session: ${this.chatId}${labelDisplay}\n`);
+          } else {
+            term.bold.red('\nInvalid selection.\n');
+          }
+        } else {
+          term('\n');
+        }
+        continue;
+      }
+
+      if (cmd.startsWith('/rename')) {
+        const newLabel = input.replace('/rename', '').trim();
+        if (!newLabel) {
+          term.bold.red('❌ Please provide a label: /rename My Session Label\n');
+          continue;
+        }
+        
+        term.bold.yellow('✨ Renaming session... ');
+        try {
+          const result = await agentService.renameSession(this.chatId, newLabel);
+          if (result.success) {
+            term.bold.green(`Done! Session renamed to: ${result.label}\n`);
+          } else {
+            term.bold.red(`Failed: ${result.message}\n`);
+          }
+        } catch (err) {
+          term.bold.red(`Error: ${err.message}\n`);
+        }
+        continue;
+      }
+
+      if (!input.trim()) continue;
+
+      this.isProcessing = true;
+      this.abortController = new AbortController();
+      
+      let thinkingSpinner = null;
+      let hasErasedInitialThinking = false;
+
+      try {
+        let hasStartedContent = false;
+        let hasStartedReasoning = false;
+        
+        this.drawStatusBar(` ⏳ Starting Loop... `, 'bgYellow', 'black');
+
+        const response = await agentService.processMessage(selectedAgent._id, {
+          content: input,
+          senderId,
+          chatId: this.chatId
+        }, {
+          abortSignal: this.abortController.signal,
+          onProgress: async (p) => {
+            if (p.status === 'reasoning') {
+                if (!hasStartedReasoning) {
+                    hasStartedReasoning = true;
+                    this.drawStatusBar(` 🧠 Loop ${p.iteration || '?'} | thinking... `);
+                    term.column(1).eraseLine();
+                    hasErasedInitialThinking = true;
+                    term.bold.magenta(`${selectedAgent.name} (thinking): `).gray.italic('\n');
+                }
+                term.gray.italic(p.token);
+            } else if (p.status === 'streaming_content') {
+                if (thinkingSpinner) {
+                    thinkingSpinner.animate(false);
+                    thinkingSpinner = null;
+                }
+                if (!hasStartedContent) {
+                    hasStartedContent = true;
+                    this.drawStatusBar(` ✍️ Loop ${p.iteration || '?'} | responding... `);
+                    if (hasStartedReasoning) {
+                        term('\n\n');
+                    } else {
+                        term.column(1).eraseLine();
+                        hasErasedInitialThinking = true;
+                    }
+                    term.bold.magenta(`${selectedAgent.name}: `);
+                }
+                term.white(p.token);
+            } else if (p.status === 'thinking') {
+                hasStartedContent = false;
+                hasStartedReasoning = false;
+                this.drawStatusBar(` ⏳ Loop ${p.iteration}/${p.maxIterations} | thinking... `, 'bgYellow', 'black');
+                
+                if (!hasErasedInitialThinking && !thinkingSpinner) {
+                    term.bold.magenta(`${selectedAgent.name}: `);
+                    thinkingSpinner = await term.spinner('dots');
+                }
+            } else if (p.status === 'executing_tools') {
+                this.drawStatusBar(` 🛠️  Loop ${p.iteration || '?'} | preparing tools... `, 'bgCyan', 'black');
+            } else if (p.status === 'executing_tool') {
+                this.drawStatusBar(` ⚙️  Loop ${p.iteration || '?'} | ${p.tool}... `, 'bgCyan', 'black');
+            } else if (p.status === 'initializing') {
+                this.drawStatusBar(` 🚀 ${p.message} `, 'bgBlue', 'white');
+            }
+          }
+        });
+        
+        const { text, usage, chatId: sessionChatId } = response;
+        this.chatId = sessionChatId;
+        
+        if (thinkingSpinner) thinkingSpinner.animate(false);
+        this.drawStatusBar();
+        
+        if (this.abortController.signal.aborted) {
+            throw new Error('Operation aborted');
+        }
+
+        if (!hasStartedContent) {
+            if (!hasErasedInitialThinking) term.column(1).eraseLine();
+            term.bold.magenta(`${selectedAgent.name}: `).white(text + '\n');
+        } else {
+            term('\n');
+        }
+
+        if (usage) {
+          const contextLength = await llmService.getModelContextLength(selectedAgent.model, selectedAgent.providerKey);
+          const currentTokens = usage.total_tokens || (usage.prompt_tokens + usage.completion_tokens);
+          this.drawStatusBar(null, null, null, { tokens: currentTokens, max: contextLength });
+        }
+      } catch (err) {
+        if (thinkingSpinner) thinkingSpinner.animate(false);
+        term.column(1).eraseLine();
+        if (err.message === 'Operation aborted' || err.message.includes('aborted')) {
+          term.bold.yellow('⚠️ Operation cancelled by user.\n');
+        } else {
+          term.bold.red(`❌ Error: ${err.message}\n`);
+        }
+      } finally {
+        this.isProcessing = false;
+        this.abortController = null;
+        this.escCount = 0;
+      }
+    }
+  }
+
+  drawStatusBar(message = null, bgColor = 'bgBlue', textColor = 'white', meta = {}) {
+    term.saveCursor();
+    
+    term.moveTo(1, term.height - 1);
+    term.eraseLine();
+    term.gray(" Commands: '/new', '/sessions', '/compact', '/rename [label]', 'exit'");
+
+    term.moveTo(1, term.height);
+    term.eraseLine();
+    
+    if (message) {
+      term[bgColor][textColor](` ${message.trim()} `);
+    } else {
+      const id = this.chatId.slice(-8);
+      const agent = this.selectedAgent ? this.selectedAgent.name : 'No Agent';
+      const model = this.selectedAgent ? this.selectedAgent.model : 'No Model';
+      
+      term.bgCyan.black(` 🆔 ${id} `);
+      term.bgBlue.white(` 🤖 ${agent} `);
+      term.bgBlack.gray(` 🧠 ${model} `);
+      
+      if (meta.tokens || this.lastTokens) {
+        const tokens = meta.tokens || this.lastTokens;
+        const max = meta.max || this.lastMax;
+        this.lastTokens = tokens;
+        this.lastMax = max;
+
+        const formatNum = (num) => num >= 1000 ? (num / 1000).toFixed(1) + 'k' : num;
+        const formattedTokens = formatNum(tokens);
+        const formattedMax = formatNum(max);
+        const perc = max > 0 ? ((tokens / max) * 100).toFixed(1) : 0;
+        const color = perc > 80 ? 'bgRed' : perc > 50 ? 'bgYellow' : 'bgGreen';
+        term[color].black(` 📊 ${formattedTokens}/${formattedMax} (${perc}%) `);
+      }
+    }
+    
+    term.restoreCursor();
+  }
+
+  async cleanup() {
+    term.grabInput(false);
+    term.scrollingRegion(1, term.height);
+    term.moveTo(1, term.height).eraseLine();
+    await new Promise(r => setTimeout(r, 100));
+  }
+}
+
+// Handle direct execution (not as a script)
+if (require.main === module) {
+  const tui = new AgentChatTUI();
+  tui.run().catch(err => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+  });
+}
+
+module.exports = AgentChatTUI;

package/src/cli/agent-list.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+require('dotenv').config(process.env.MODE ? { path: `.env.${process.env.MODE}` } : {});
+const Agent = require('../models/Agent');
+
+async function listAgents() {
+  try {
+    const agents = await Agent.find().lean();
+    
+    if (agents.length === 0) {
+      console.log('❌ No agents found. Please create an agent in the admin UI first.');
+      return;
+    }
+
+    console.log('\n🤖 Available Agents:\n');
+    agents.forEach((agent, index) => {
+      console.log(`${index + 1}. ${agent.name} (${agent.model})`);
+      if (agent.systemPrompt) {
+        const prompt = agent.systemPrompt.substring(0, 100);
+        console.log(`   "${prompt}${agent.systemPrompt.length > 100 ? '...' : ''}"`);
+      }
+      if (agent.tools && agent.tools.length > 0) {
+        console.log(`   Tools: ${agent.tools.join(', ')}`);
+      }
+      console.log('');
+    });
+    
+    console.log(`Total: ${agents.length} agent(s)`);
+    console.log('\n💡 To start chatting: npx @intranefr/superbackend agent-chat');
+    
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+  }
+}
+
+// Handle direct execution
+if (require.main === module) {
+  listAgents();
+}
+
+module.exports = { listAgents };

package/src/controllers/adminAgentsChat.controller.js

@@ -0,0 +1,172 @@
+const crypto = require('crypto');
+const Agent = require('../models/Agent');
+const JsonConfig = require('../models/JsonConfig');
+const agentService = require('../services/agent.service');
+
+function safeParse(raw, fallback = null) {
+  try {
+    return JSON.parse(raw);
+  } catch (_) {
+    return fallback;
+  }
+}
+
+exports.newSession = async (req, res) => {
+  try {
+    const { agentId } = req.body || {};
+    if (!agentId) return res.status(400).json({ error: 'agentId is required' });
+
+    const agent = await Agent.findById(agentId).select('_id').lean();
+    if (!agent) return res.status(404).json({ error: 'Agent not found' });
+
+    return res.json({ chatId: `web-${Date.now()}-${crypto.randomUUID().slice(0, 8)}` });
+  } catch (error) {
+    return res.status(500).json({ error: error.message });
+  }
+};
+
+exports.listSessions = async (req, res) => {
+  try {
+    const { agentId } = req.query;
+    const docs = await JsonConfig.find({ alias: { $regex: /^agent-session-/ } })
+      .sort({ updatedAt: -1 })
+      .limit(30)
+      .lean();
+
+    const items = docs
+      .map((doc) => {
+        const parsed = safeParse(doc.jsonRaw, {});
+        return {
+          id: parsed.id,
+          agentId: parsed.agentId,
+          label: parsed.label || null,
+          totalTokens: parsed.totalTokens || 0,
+          lastSnapshotId: parsed.lastSnapshotId || null,
+          updatedAt: doc.updatedAt,
+        };
+      })
+      .filter((x) => x.id)
+      .filter((x) => !agentId || String(x.agentId) === String(agentId));
+
+    return res.json({ items });
+  } catch (error) {
+    return res.status(500).json({ error: error.message });
+  }
+};
+
+exports.renameSession = async (req, res) => {
+  try {
+    const { chatId, label } = req.body || {};
+    if (!chatId || !label) return res.status(400).json({ error: 'chatId and label are required' });
+    const result = await agentService.renameSession(chatId, label);
+    if (!result.success) return res.status(400).json({ error: result.message || 'Failed to rename session' });
+    return res.json(result);
+  } catch (error) {
+    return res.status(500).json({ error: error.message });
+  }
+};
+
+exports.compactSession = async (req, res) => {
+  try {
+    const { agentId, chatId } = req.body || {};
+    if (!agentId || !chatId) return res.status(400).json({ error: 'agentId and chatId are required' });
+    const result = await agentService.compactSession(agentId, chatId);
+    if (!result.success) return res.status(400).json({ error: result.message || 'Failed to compact session' });
+    return res.json(result);
+  } catch (error) {
+    return res.status(500).json({ error: error.message });
+  }
+};
+
+exports.sendMessage = async (req, res) => {
+  try {
+    const { agentId, chatId, content } = req.body || {};
+    if (!agentId || !content) return res.status(400).json({ error: 'agentId and content are required' });
+
+    const senderId = String(req.session?.adminUser?._id || req.session?.user?._id || 'admin-web');
+    const response = await agentService.processMessage(
+      agentId,
+      { content, senderId, chatId },
+      {},
+    );
+
+    return res.json(response);
+  } catch (error) {
+    return res.status(500).json({ error: error.message });
+  }
+};
+
+exports.streamMessage = async (req, res) => {
+  try {
+    const { agentId, chatId, content } = req.body || {};
+    if (!agentId || !content) return res.status(400).json({ error: 'agentId and content are required' });
+
+    const senderId = String(req.session?.adminUser?._id || req.session?.user?._id || 'admin-web');
+
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    if (res.flushHeaders) res.flushHeaders();
+
+    const writeEvent = (event, payload) => {
+      res.write(`event: ${event}\n`);
+      res.write(`data: ${JSON.stringify(payload)}\n\n`);
+    };
+
+    writeEvent('status', { status: 'starting' });
+
+    const response = await agentService.processMessage(
+      agentId,
+      { content, senderId, chatId },
+      {
+        onProgress: (p) => writeEvent('progress', p),
+      },
+    );
+
+    writeEvent('done', response);
+    res.end();
+  } catch (error) {
+    res.write(`event: error\n`);
+    res.write(`data: ${JSON.stringify({ error: error.message })}\n\n`);
+    res.end();
+  }
+};
+
+exports.loadSessionMessages = async (req, res) => {
+  try {
+    const { chatId } = req.params;
+    console.log('[loadSessionMessages] Loading messages for chatId:', chatId);
+    if (!chatId) return res.status(400).json({ error: 'chatId is required' });
+
+    const doc = await JsonConfig.findOne({ 
+      'jsonRaw.id': chatId,
+      alias: { $regex: /^agent-session-/ }
+    }).lean();
+    
+    console.log('[loadSessionMessages] Found document:', !!doc);
+
+    if (!doc) return res.status(404).json({ error: 'Session not found' });
+
+    const parsed = safeParse(doc.jsonRaw, {});
+    const messages = parsed.messages || [];
+    console.log('[loadSessionMessages] Messages count:', messages.length);
+
+    return res.json({ 
+      chatId: parsed.id,
+      agentId: parsed.agentId,
+      label: parsed.label,
+      messages,
+      totalTokens: parsed.totalTokens || 0,
+      updatedAt: doc.updatedAt
+    });
+  } catch (error) {
+    console.error('[loadSessionMessages] Error:', error.message);
+    return res.status(500).json({ error: error.message });
+  }
+};
+
+exports.chatHealth = async (_req, res) => {
+  const uri = process.env.MONGODB_URI || '';
+  const dbName = uri.split('/').pop()?.split('?')[0] || 'unknown';
+  return res.json({ dbName });
+};