nexus/backend/Controllers/DashboardController.cs

using Microsoft.AspNetCore.Mvc;
using Nexus.Api.Models;
using Nexus.Api.Services;

namespace Nexus.Api.Controllers;

[ApiController]
[Route("api/dashboard")]
public class DashboardController(OpenClawGatewayClient gateway, ILogger<DashboardController> logger)
    : ControllerBase
{
    /// <summary>
    /// Gateway health + session_status + subagents count.
    /// Returns HTTP 200 even when gateway is down (gatewayOk: false).
    /// </summary>
    [HttpGet("status")]
    public async Task<DashboardStatus> GetStatus()
    {
        try
        {
            return await gateway.GetStatusAsync();
        }
        catch (Exception ex)
        {
            logger.LogWarning(ex, "Dashboard status check failed");
            return new DashboardStatus(false, "Offline", 0, 0);
        }
    }

    /// <summary>
    /// Returns all agents with their current status.
    /// Combines sessions_list + sub_agents_list.
    /// </summary>
    [HttpGet("agents")]
    public async Task<List<DashboardAgentInfo>> GetAgents()
    {
        try
        {
            return await gateway.GetAgentsAsync();
        }
        catch (Exception ex)
        {
            logger.LogWarning(ex, "Dashboard agents fetch failed");
            return new List<DashboardAgentInfo>();
        }
    }

    /// <summary>
    /// Returns the latest assistant messages (operations/feed) from the Iris session.
    /// Filtered to role == "assistant" — those are the work feed entries.
    /// </summary>
    [HttpGet("operations")]
    public async Task<List<FeedEntry>> GetOperations([FromQuery] int limit = 20)
    {
        try
        {
            var messages = await gateway.GetSessionHistoryAsync("iris", Math.Clamp(limit, 1, 100));
            var feed = new List<FeedEntry>();

            foreach (var msg in messages)
            {
                if (!string.Equals(msg.Role, "assistant", StringComparison.OrdinalIgnoreCase))
                    continue;

                if (string.IsNullOrWhiteSpace(msg.Content))
                    continue;

                // Parse timestamp for display-friendly "time ago"
                var ts = ParseTimestamp(msg.Timestamp);
                var timeAgo = FormatTimeAgo(ts);

                // Extract a short agent indicator and action from content
                var (agent, action) = ExtractAgentAction(msg.Content);

                feed.Add(new FeedEntry(agent, action, msg.Timestamp, timeAgo));
            }

            return feed;
        }
        catch (Exception ex)
        {
            logger.LogWarning(ex, "Dashboard operations fetch failed");
            return new List<FeedEntry>();
        }
    }

    /// <summary>
    /// Send a chat message to the Iris session.
    /// </summary>
    [HttpPost("chat/send")]
    public async Task<ChatResponse> SendChat([FromBody] ChatRequest request)
    {
        if (string.IsNullOrWhiteSpace(request.Message))
            return new ChatResponse(false, null, "Message is required");

        try
        {
            var sessionKey = string.IsNullOrWhiteSpace(request.SessionKey)
                ? "iris"
                : request.SessionKey.Trim();

            return await gateway.SendChatMessageAsync(sessionKey, request.Message.Trim());
        }
        catch (Exception ex)
        {
            logger.LogWarning(ex, "Dashboard chat send failed");
            return new ChatResponse(false, null, "Gateway nicht erreichbar");
        }
    }

    /// <summary>
    /// Returns chat messages (user + assistant only, not tool messages).
    /// </summary>
    [HttpGet("chat/messages")]
    public async Task<List<MessageEntry>> GetMessages(
        [FromQuery] string? sessionKey,
        [FromQuery] int limit = 50,
        [FromQuery] int offset = 0)
    {
        try
        {
            var key = string.IsNullOrWhiteSpace(sessionKey) ? "iris" : sessionKey.Trim();
            var messages = await gateway.GetSessionHistoryAsync(key, Math.Clamp(limit, 1, 200), Math.Max(0, offset));

            // Filter: only user and assistant messages (exclude tool/system)
            return messages
                .Where(m => string.Equals(m.Role, "user", StringComparison.OrdinalIgnoreCase)
                         || string.Equals(m.Role, "assistant", StringComparison.OrdinalIgnoreCase))
                .ToList();
        }
        catch (Exception ex)
        {
            logger.LogWarning(ex, "Dashboard messages fetch failed");
            return new List<MessageEntry>();
        }
    }

    /// <summary>
    /// Returns the cron queue / pending tasks.
    /// </summary>
    [HttpGet("queue")]
    public async Task<List<QueueItem>> GetQueue()
    {
        try
        {
            return await gateway.GetQueueAsync();
        }
        catch (Exception ex)
        {
            logger.LogWarning(ex, "Dashboard queue fetch failed");
            return new List<QueueItem>();
        }
    }

    // ========== Helpers ==========

    private static DateTimeOffset ParseTimestamp(string timestamp)
    {
        if (DateTimeOffset.TryParse(timestamp, null, System.Globalization.DateTimeStyles.None, out var dt))
            return dt;
        return DateTimeOffset.UtcNow;
    }

    private static string FormatTimeAgo(DateTimeOffset ts)
    {
        var diff = DateTimeOffset.UtcNow - ts;
        if (diff.TotalMinutes < 1) return "just now";
        if (diff.TotalMinutes < 60) return $"{(int)diff.TotalMinutes}m ago";
        if (diff.TotalHours < 24) return $"{(int)diff.TotalHours}h ago";
        if (diff.TotalDays < 7) return $"{(int)diff.TotalDays}d ago";
        return ts.ToString("MMM dd");
    }

    private static (string Agent, string Action) ExtractAgentAction(string content)
    {
        // Take first line or first ~80 chars as the action summary
        var firstLine = content.Split('\n', 2)[0].Trim();
        var summary = firstLine.Length > 80 ? firstLine[..80] + "…" : firstLine;

        // Try to identify which agent this came from
        var agent = "Iris";
        foreach (var marker in new[] { "**Agent:**", "**Agent:** ", "*Agent:* ", "Agent:" })
        {
            var idx = content.IndexOf(marker, StringComparison.OrdinalIgnoreCase);
            if (idx >= 0)
            {
                var after = content[(idx + marker.Length)..].TrimStart();
                var end = after.IndexOfAny(['\n', '\r', ',', '.']);
                var found = end > 0 ? after[..end].Trim() : after.Split('\n', 2)[0].Trim();
                if (!string.IsNullOrWhiteSpace(found) && found.Length < 30)
                {
                    agent = found;
                    break;
                }
            }
        }

        // Try to find agent name at the start in brackets like [Agent: Iris]
        if (agent == "Iris")
        {
            var bracketMatch = System.Text.RegularExpressions.Regex.Match(content, @"\[Agent:\s*([^\]]+)\]");
            if (bracketMatch.Success)
                agent = bracketMatch.Groups[1].Value.Trim();
        }

        return (agent, summary);
    }
}