257 lines
10 KiB
C#
257 lines
10 KiB
C#
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.AspNetCore.RateLimiting;
|
|
using System.Security.Claims;
|
|
using Nexus.Api.DTOs;
|
|
using Nexus.Api.Integrations;
|
|
using Nexus.Api.Repositories;
|
|
using Nexus.Api.Services;
|
|
|
|
namespace Nexus.Api.Controllers;
|
|
|
|
[ApiController]
|
|
[Route("api/v1/agents")]
|
|
public class AgentsController(
|
|
IAgentService agentService,
|
|
IAgentRuntime runtime,
|
|
IActivityRepository activityRepo,
|
|
IAgentConfigService agentConfigService,
|
|
IDashboardService dashboardService,
|
|
ILogger<AgentsController> logger) : ControllerBase
|
|
{
|
|
[HttpGet]
|
|
public async Task<IResult> GetAgents(CancellationToken ct)
|
|
{
|
|
var agents = await agentService.GetAgentsAsync(ct);
|
|
return Results.Ok(agents.Select(a => new AgentListResponse(
|
|
a.Id, a.Name, a.Role, a.Model, a.Status.ToString(), a.LastSeen, a.Workspace, a.Description)));
|
|
}
|
|
|
|
[HttpGet("{id}")]
|
|
public async Task<IResult> GetAgent(string id, CancellationToken ct)
|
|
{
|
|
var agent = await agentService.GetAgentAsync(id, ct);
|
|
if (agent is null) return Results.NotFound();
|
|
return Results.Ok(new AgentDetailResponse(
|
|
agent.Id, agent.Name, agent.Role, agent.Model, agent.Status.ToString(),
|
|
agent.LastSeen, agent.Workspace, agent.AgentDir, agent.Description,
|
|
agent.SubAgents, agent.IdentityName));
|
|
}
|
|
|
|
[HttpGet("{id}/activity")]
|
|
public async Task<IResult> GetAgentActivity(string id, CancellationToken ct)
|
|
{
|
|
var items = await activityRepo.GetByAgentAsync(id, 50, ct);
|
|
var activity = items
|
|
.Select(x => new AgentActivityResponse(x.Id, x.Type, x.Message, x.CreatedAt, "activity"))
|
|
.ToList();
|
|
|
|
var gatewayEntries = await dashboardService.GetAgentActivityAsync(id, 10);
|
|
foreach (var entry in gatewayEntries)
|
|
activity.Add(new AgentActivityResponse(null, "thinking", entry.Text, entry.Timestamp, entry.Source, entry.Time));
|
|
|
|
return Results.Ok(activity
|
|
.OrderByDescending(x => x.At)
|
|
.Take(50));
|
|
}
|
|
|
|
[HttpGet("{id}/summary")]
|
|
public async Task<IResult> GetAgentSummary(string id, CancellationToken ct)
|
|
{
|
|
var recent = await activityRepo.GetByAgentAsync(id, 25, ct);
|
|
var gatewayEntries = await dashboardService.GetAgentActivityAsync(id, 8);
|
|
return Results.Ok(AgentSummaryBuilder.Build(recent, gatewayEntries, DateTimeOffset.UtcNow));
|
|
}
|
|
|
|
[HttpPost("{id}/command")]
|
|
[EnableRateLimiting("agents")]
|
|
public async Task<IResult> SendCommand(string id, [FromBody] AgentCommandRequest request, CancellationToken ct)
|
|
{
|
|
var message = request.Message?.Trim();
|
|
if (string.IsNullOrWhiteSpace(message) || message.Length > 8000)
|
|
return Results.ValidationProblem(new Dictionary<string, string[]> { ["message"] = ["Message must contain between 1 and 8000 characters."] });
|
|
|
|
var conversationId = $"nexus-command-{id}-{Guid.NewGuid():N}";
|
|
|
|
try
|
|
{
|
|
var result = await runtime.ChatAsync(message, conversationId, id, ct);
|
|
await activityRepo.AddAsync(new Data.ActivityEvent { Type = "agent", Message = $"Command sent to agent {id}: {message[..Math.Min(message.Length, 80)]}" }, ct);
|
|
return Results.Ok(new AgentCommandResponse(result.Runtime, result.AgentId, result.ConversationId, result.Content));
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
logger.LogWarning(exception, "Agent command failed for {AgentId}", id);
|
|
return Results.Problem(
|
|
title: "Agent command failed",
|
|
detail: $"Could not send command to agent {id}: {exception.Message}",
|
|
statusCode: StatusCodes.Status503ServiceUnavailable);
|
|
}
|
|
}
|
|
|
|
// ── Config Editor ──
|
|
|
|
[HttpGet("{id}/config")]
|
|
public IResult GetConfig(string id)
|
|
=> Results.Ok(agentConfigService.GetConfigFiles(id));
|
|
|
|
[HttpGet("{id}/config/{fileName}")]
|
|
public async Task<IResult> GetConfigFile(string id, string fileName, CancellationToken ct)
|
|
{
|
|
var file = await agentConfigService.GetConfigFileAsync(id, fileName, ct);
|
|
return file is null
|
|
? Results.NotFound()
|
|
: Results.Ok(new { file.FileName, file.Content, file.Size, file.ModifiedAt });
|
|
}
|
|
|
|
[HttpPut("{id}/config/{fileName}")]
|
|
[Authorize(Roles = "owner")]
|
|
public async Task<IResult> SaveConfigFile(string id, string fileName, [FromBody] SaveConfigRequest request, CancellationToken ct)
|
|
{
|
|
if (request.Content is null)
|
|
return Results.BadRequest(new { error = "Content is required." });
|
|
|
|
try
|
|
{
|
|
var attempt = await agentConfigService.SaveConfigFileAsync(id, fileName, request.Content, ct);
|
|
var caller = DescribeCaller(HttpContext.User);
|
|
|
|
if (attempt.Failure is not null)
|
|
{
|
|
await activityRepo.AddAsync(new Data.ActivityEvent
|
|
{
|
|
Type = "config_audit",
|
|
Message = $"Config save rejected agent={id} file={fileName} caller={caller} validation={attempt.Failure.Validation.Status} backup={attempt.Failure.Backup.Status} reload={attempt.Failure.ReloadCheck.Status} code={attempt.Failure.Code}",
|
|
}, ct);
|
|
|
|
return Results.ValidationProblem(new Dictionary<string, string[]>
|
|
{
|
|
["content"] = attempt.Failure.Validation.Errors.ToArray()
|
|
});
|
|
}
|
|
|
|
var result = attempt.SaveResult!;
|
|
|
|
await activityRepo.AddAsync(new Data.ActivityEvent
|
|
{
|
|
Type = "config_audit",
|
|
Message = $"Config save agent={id} file={fileName} caller={caller} validation={result.Validation.Status} backup={result.Backup.Status} reload={result.ReloadCheck.Status}",
|
|
}, ct);
|
|
|
|
return Results.Ok(new
|
|
{
|
|
result.FileName,
|
|
result.Size,
|
|
result.ModifiedAt,
|
|
result.Validation,
|
|
result.Backup,
|
|
ReloadCheck = result.ReloadCheck
|
|
});
|
|
}
|
|
catch (UnauthorizedAccessException ex)
|
|
{
|
|
logger.LogError(ex, "Permission denied saving config file {FileName} for agent {AgentId}", fileName, id);
|
|
return Results.Problem(
|
|
title: "Permission denied",
|
|
detail: $"Cannot write config file '{fileName}' for agent '{id}'. The target path may be owned by a different user.",
|
|
statusCode: StatusCodes.Status500InternalServerError);
|
|
}
|
|
catch (IOException ex)
|
|
{
|
|
logger.LogError(ex, "I/O error saving config file {FileName} for agent {AgentId}", fileName, id);
|
|
return Results.Problem(
|
|
title: "File write error",
|
|
detail: $"Failed to write config file '{fileName}' for agent '{id}': {ex.Message}",
|
|
statusCode: StatusCodes.Status500InternalServerError);
|
|
}
|
|
}
|
|
|
|
private static string DescribeCaller(ClaimsPrincipal user)
|
|
{
|
|
var subject = user.FindFirst(ClaimTypes.NameIdentifier)?.Value
|
|
?? user.FindFirst(ClaimTypes.Email)?.Value
|
|
?? user.Identity?.Name
|
|
?? "unknown";
|
|
|
|
var role = user.FindFirst(ClaimTypes.Role)?.Value ?? "owner";
|
|
return $"{role}:{subject}".ToLowerInvariant();
|
|
}
|
|
}
|
|
|
|
public sealed record AgentActivityResponse(
|
|
long? Id,
|
|
string Type,
|
|
string Message,
|
|
DateTimeOffset At,
|
|
string Source,
|
|
string? RelativeTime = null
|
|
);
|
|
|
|
public sealed record AgentSummaryResponse(
|
|
AgentSummaryItemResponse Now,
|
|
AgentSummaryItemResponse Today,
|
|
DateTimeOffset GeneratedAt
|
|
);
|
|
|
|
public sealed record AgentSummaryItemResponse(
|
|
string Text,
|
|
string Source,
|
|
DateTimeOffset? Timestamp
|
|
);
|
|
|
|
public static class AgentSummaryBuilder
|
|
{
|
|
public static AgentSummaryResponse Build(
|
|
IReadOnlyList<Nexus.Api.Data.ActivityEvent> activity,
|
|
IReadOnlyList<Nexus.Api.Models.AgentActivityEntry> gatewayEntries,
|
|
DateTimeOffset nowUtc)
|
|
{
|
|
var points = activity
|
|
.Select(entry => new SummaryPoint(entry.Message, entry.CreatedAt, "nexus-activity"))
|
|
.Concat(gatewayEntries.Select(entry => new SummaryPoint(entry.Text, entry.Timestamp, entry.Source)))
|
|
.Select(point => point with { Text = AgentActivityText.RedactForDisplay(point.Text) })
|
|
.Where(point => !string.IsNullOrWhiteSpace(point.Text))
|
|
.OrderByDescending(point => point.Timestamp)
|
|
.ToList();
|
|
|
|
var current = points.FirstOrDefault();
|
|
var now = current is null
|
|
? new AgentSummaryItemResponse("Keine aktuelle Aktivitaet.", "none", null)
|
|
: new AgentSummaryItemResponse(current.Text, current.Source, current.Timestamp);
|
|
|
|
var windowStart = nowUtc.AddHours(-24);
|
|
var todayPoints = points
|
|
.Where(point => point.Timestamp >= windowStart)
|
|
.ToList();
|
|
|
|
AgentSummaryItemResponse today;
|
|
if (todayPoints.Count == 0)
|
|
{
|
|
today = new AgentSummaryItemResponse("Heute keine verwertbaren Checkpoints.", "none", null);
|
|
}
|
|
else
|
|
{
|
|
var snippets = todayPoints
|
|
.Select(point => point.Text)
|
|
.Distinct(StringComparer.OrdinalIgnoreCase)
|
|
.Take(3)
|
|
.ToList();
|
|
|
|
var extraCount = Math.Max(0, todayPoints.Count - snippets.Count);
|
|
var text = $"Letzte 24h: {string.Join(" | ", snippets)}";
|
|
if (extraCount > 0)
|
|
text += $" (+{extraCount} weitere)";
|
|
|
|
var source = todayPoints.Select(point => point.Source).Distinct(StringComparer.OrdinalIgnoreCase).Count() == 1
|
|
? todayPoints[0].Source
|
|
: "derived-mixed";
|
|
|
|
today = new AgentSummaryItemResponse(text, source, todayPoints[0].Timestamp);
|
|
}
|
|
|
|
return new AgentSummaryResponse(now, today, nowUtc);
|
|
}
|
|
|
|
private sealed record SummaryPoint(string Text, DateTimeOffset Timestamp, string Source);
|
|
}
|