Add file transfer, agents panel, connection settings, toolbar TextBlock fix, UpdateAgentRunner error logging

Author: sharpninja

.vscode/settings.json

@@ -5,5 +5,6 @@
       "path": "pwsh.exe",
       "args": ["-NoProfile"]
     }
-  }
+  },
+  "fusion-360-helper.enabled": false
 }

GitVersion.yml

@@ -2,7 +2,11 @@
 # See https://gitversion.net/docs/reference/configuration
 workflow: GitHubFlow/v1
 # Start at 1.0.0 when no version tag exists yet
-next-version: 0.1.19
+next-version: 0.1.23
+
+
+
+
 
 
 

src/RemoteAgent.App.Logic/AgentSessionClient.cs

@@ -13,6 +13,7 @@ public interface IAgentSessionClient : IAgentInteractionSession
     string? PerRequestContext { get; set; }
     event Action? ConnectionStateChanged;
     event Action<ChatMessage>? MessageReceived;
+    event Action<FileTransfer>? FileTransferReceived;
 
     Task ConnectAsync(
         string host,
@@ -47,6 +48,7 @@ public sealed class AgentSessionClient(Func<MediaChunk, string>? mediaTextFormat
 
     public event Action? ConnectionStateChanged;
     public event Action<ChatMessage>? MessageReceived;
+    public event Action<FileTransfer>? FileTransferReceived;
 
     public async Task ConnectAsync(
         string host,
@@ -207,6 +209,23 @@ private async Task ReceiveLoop(CancellationToken ct)
             while (await _call.ResponseStream.MoveNext(ct))
             {
                 var incoming = _call.ResponseStream.Current;
+
+                // Handle file transfers separately: raise dedicated event + chat notification.
+                if (incoming.PayloadCase == ServerMessage.PayloadOneofCase.FileTransfer && incoming.FileTransfer != null)
+                {
+                    var ft = incoming.FileTransfer;
+                    FileTransferReceived?.Invoke(ft);
+                    var sizeText = ft.TotalSize < 1024 ? $"{ft.TotalSize} B" : $"{ft.TotalSize / 1024.0:F1} KB";
+                    var chatMsg = new ChatMessage
+                    {
+                        IsUser = false,
+                        Text = $"\U0001F4C1 File received: {ft.RelativePath} ({sizeText})",
+                        FileTransferPath = ft.RelativePath
+                    };
+                    MessageReceived?.Invoke(chatMsg);
+                    continue;
+                }
+
                 var mapped = MapServerMessage(incoming);
                 if (mapped != null)
                     MessageReceived?.Invoke(mapped);

src/RemoteAgent.App.Logic/ChatMessage.cs

@@ -39,6 +39,9 @@ public class ChatMessage : INotifyPropertyChanged
     /// <summary>Message priority (FR-3.1). Notify causes a system notification; tap opens the app (FR-3.2, FR-3.3).</summary>
     public ChatMessagePriority Priority { get; init; } = ChatMessagePriority.Normal;
 
+    /// <summary>When set, indicates this message represents a file transfer. Contains the relative path of the transferred file.</summary>
+    public string? FileTransferPath { get; init; }
+
     /// <summary>Plain text for display: event message or raw text (no markdown).</summary>
     public string DisplayText => IsEvent ? (EventMessage ?? "") : Text;
 

src/RemoteAgent.App.Logic/ServerApiClient.cs

@@ -351,11 +351,53 @@ private static InvalidOperationException CreateGrpcFailure(string operation, Rpc
         return new Metadata { { "x-api-key", apiKey.Trim() } };
     }
 
-    public static string BuildBaseUrl(string host, int port)
-    {
-        return port == 443 ? $"https://{host}" : $"http://{host}:{port}";
-    }
-}
+    public static string BuildBaseUrl(string host, int port)
+    {
+        return port == 443 ? $"https://{host}" : $"http://{host}:{port}";
+    }
+
+    public static Task<ListAgentRunnersResponse?> ListAgentRunnersAsync(
+        string host,
+        int port,
+        string? apiKey = null,
+        CancellationToken ct = default,
+        bool throwOnError = false)
+        => ExecuteGrpcAsync(
+            host,
+            port,
+            apiKey,
+            "List agent runners",
+            throwOnError,
+            ct,
+            (client, headers, token) => client.ListAgentRunnersAsync(new ListAgentRunnersRequest(), headers, deadline: null, cancellationToken: token).ResponseAsync);
+
+    public static Task<UpdateAgentRunnerResponse?> UpdateAgentRunnerAsync(
+        string host,
+        int port,
+        string runnerId,
+        string? command = null,
+        string? arguments = null,
+        int maxConcurrentSessions = 0,
+        bool setAsDefault = false,
+        string? apiKey = null,
+        CancellationToken ct = default,
+        bool throwOnError = false)
+        => ExecuteGrpcAsync(
+            host,
+            port,
+            apiKey,
+            "Update agent runner",
+            throwOnError,
+            ct,
+            (client, headers, token) => client.UpdateAgentRunnerAsync(new UpdateAgentRunnerRequest
+            {
+                RunnerId = runnerId,
+                Command = command ?? "",
+                Arguments = arguments ?? "",
+                MaxConcurrentSessions = maxConcurrentSessions,
+                SetAsDefault = setAsDefault
+            }, headers, deadline: null, cancellationToken: token).ResponseAsync);
+}
 
 public sealed record SessionCapacitySnapshot(
     bool CanCreateSession,

src/RemoteAgent.App/Services/AgentGatewayClientService.cs

@@ -17,6 +17,7 @@ public AgentGatewayClientService(ILocalMessageStore? store = null)
         _sessionClient = new AgentSessionClient(FormatReceivedMedia);
         _sessionClient.ConnectionStateChanged += () => ConnectionStateChanged?.Invoke();
         _sessionClient.MessageReceived += OnSessionClientMessageReceived;
+        _sessionClient.FileTransferReceived += OnFileTransferReceived;
     }
 
     public ObservableCollection<ChatMessage> Messages { get; } = new();
@@ -109,6 +110,18 @@ private void OnSessionClientMessageReceived(ChatMessage chat)
         });
     }
 
+    private static void OnFileTransferReceived(FileTransfer fileTransfer)
+    {
+        try
+        {
+            FileSaveService.SaveFileTransfer(fileTransfer);
+        }
+        catch
+        {
+            // File save failures are non-fatal; the chat message already shows the transfer.
+        }
+    }
+
     private static string FormatReceivedMedia(MediaChunk media)
     {
         try

src/RemoteAgent.App/Services/FileSaveService.cs

@@ -0,0 +1,41 @@
+using RemoteAgent.Proto;
+
+namespace RemoteAgent.App.Services;
+
+/// <summary>Saves files received via <see cref="FileTransfer"/> to the device, preserving the relative path hierarchy
+/// under the app data directory. On Android, files are stored under AppDataDirectory/RemoteAgent/Files/.</summary>
+public static class FileSaveService
+{
+    /// <summary>Saves a file transfer to local storage preserving the directory hierarchy from
+    /// <see cref="FileTransfer.RelativePath"/>. Returns the saved path for display, or null on failure.</summary>
+    public static string? SaveFileTransfer(FileTransfer fileTransfer)
+    {
+        if (fileTransfer.Content == null || fileTransfer.Content.Length == 0)
+            return null;
+
+        var relativePath = fileTransfer.RelativePath;
+        if (string.IsNullOrWhiteSpace(relativePath))
+            relativePath = $"file_{DateTime.UtcNow:yyyyMMdd_HHmmss}.bin";
+
+        // Normalize to forward slashes and sanitize
+        relativePath = relativePath.Replace('\\', '/');
+
+        // Build the full path under AppDataDirectory/RemoteAgent/Files/
+        var basePath = Path.Combine(FileSystem.AppDataDirectory, "RemoteAgent", "Files");
+        var fullPath = Path.Combine(basePath, relativePath.Replace('/', Path.DirectorySeparatorChar));
+
+        try
+        {
+            var directory = Path.GetDirectoryName(fullPath);
+            if (!string.IsNullOrEmpty(directory))
+                Directory.CreateDirectory(directory);
+
+            File.WriteAllBytes(fullPath, fileTransfer.Content.ToByteArray());
+            return relativePath;
+        }
+        catch
+        {
+            return null;
+        }
+    }
+}

src/RemoteAgent.Desktop/App.axaml.cs

@@ -146,7 +146,8 @@ private static void ConfigureServices(IServiceCollection services)
         services.AddTransient<IRequestHandler<Requests.SaveAppLogRequest, CommandResult>, SaveAppLogHandler>();
         services.AddTransient<IRequestHandler<Requests.CopyStatusLogRequest, CommandResult>, CopyStatusLogHandler>();
         services.AddTransient<IRequestHandler<Requests.OpenLogsFolderRequest, CommandResult>, OpenLogsFolderHandler>();
-        services.AddTransient<IRequestHandler<Requests.SetPairingUserRequest, CommandResult>, SetPairingUserHandler>();
+        services.AddTransient<IRequestHandler<Requests.RefreshAgentsRequest, CommandResult>, RefreshAgentsHandler>();
+        services.AddTransient<IRequestHandler<Requests.SetPairingUserRequest, CommandResult>, SetPairingUserHandler>();
         services.AddSingleton<IPairingUserDialog>(sp => new AvaloniaPairingUserDialog());
 
         services.AddSingleton<MainWindowViewModel>();

src/RemoteAgent.Desktop/Handlers/OpenNewSessionHandler.cs

@@ -18,14 +18,19 @@ public async Task<CommandResult> HandleAsync(
             return CommandResult.Fail("No owner window available.");
 
         var workspace = request.Workspace;
+        var availableAgents = workspace.Agents.Agents
+            .Select(a => a.AgentId)
+            .ToList();
+
         var defaults = new ConnectionSettingsDefaults(
             workspace.Host,
             workspace.Port,
             workspace.SelectedConnectionMode,
             workspace.SelectedAgentId,
             workspace.ApiKey,
             workspace.PerRequestContext,
-            workspace.ConnectionModes);
+            workspace.ConnectionModes,
+            availableAgents);
 
         var result = await dialogService.ShowAsync(ownerWindow, defaults, cancellationToken);
         if (result is null)

src/RemoteAgent.Desktop/Handlers/RefreshAgentsHandler.cs

@@ -0,0 +1,108 @@
+using RemoteAgent.App.Logic;
+using RemoteAgent.App.Logic.Cqrs;
+using RemoteAgent.Desktop.Infrastructure;
+using RemoteAgent.Desktop.Requests;
+
+namespace RemoteAgent.Desktop.Handlers;
+
+public sealed class RefreshAgentsHandler(IServerCapacityClient client)
+    : IRequestHandler<RefreshAgentsRequest, CommandResult>
+{
+    public async Task<CommandResult> HandleAsync(RefreshAgentsRequest request, CancellationToken cancellationToken = default)
+    {
+        // Try the new ListAgentRunners API first (provides full runner details).
+        try
+        {
+            var runnersResponse = await ServerApiClient.ListAgentRunnersAsync(
+                request.Host, request.Port, request.ApiKey, cancellationToken, throwOnError: true);
+
+            if (runnersResponse != null)
+            {
+                // Also get server version via GetServerInfo.
+                var serverInfo = await client.GetServerInfoAsync(request.Host, request.Port, request.ApiKey, cancellationToken);
+                request.Workspace.ServerVersion = serverInfo?.ServerVersion ?? "";
+
+                var agents = new List<AgentSnapshot>();
+                foreach (var runner in runnersResponse.Runners)
+                {
+                    var isDefault = string.Equals(runner.RunnerId, request.CurrentDefaultAgentId, StringComparison.OrdinalIgnoreCase)
+                                    || runner.IsDefault;
+                    var remaining = runner.MaxConcurrentSessions > 0
+                        ? runner.MaxConcurrentSessions - runner.ActiveSessionCount
+                        : (int?)null;
+                    agents.Add(new AgentSnapshot(
+                        runner.RunnerId,
+                        runner.ActiveSessionCount,
+                        runner.MaxConcurrentSessions > 0 ? runner.MaxConcurrentSessions : null,
+                        remaining,
+                        isDefault,
+                        runner.RunnerType,
+                        runner.Command,
+                        runner.Arguments,
+                        runner.Description));
+                }
+
+                request.Workspace.Agents.Clear();
+                foreach (var agent in agents)
+                    request.Workspace.Agents.Add(agent);
+
+                request.Workspace.SelectedAgent = request.Workspace.Agents.FirstOrDefault(a => a.IsDefault)
+                    ?? request.Workspace.Agents.FirstOrDefault();
+
+                request.Workspace.AgentsStatus = $"Loaded {agents.Count} agent runner(s) from server v{request.Workspace.ServerVersion}.";
+                return CommandResult.Ok();
+            }
+        }
+        catch
+        {
+            // Fall through to legacy approach if ListAgentRunners is not available.
+        }
+
+        // Legacy fallback: use GetServerInfo + per-agent CheckSessionCapacity.
+        var info = await client.GetServerInfoAsync(request.Host, request.Port, request.ApiKey, cancellationToken);
+        if (info == null)
+        {
+            request.Workspace.AgentsStatus = "Failed to retrieve server info.";
+            return CommandResult.Fail("Failed to retrieve server info.");
+        }
+
+        request.Workspace.ServerVersion = info.ServerVersion;
+
+        var legacyAgents = new List<AgentSnapshot>();
+        foreach (var agentId in info.AvailableAgents)
+        {
+            var isDefault = string.Equals(agentId, request.CurrentDefaultAgentId, StringComparison.OrdinalIgnoreCase);
+            try
+            {
+                var capacity = await client.GetCapacityAsync(request.Host, request.Port, agentId, request.ApiKey, cancellationToken);
+                if (capacity != null)
+                {
+                    legacyAgents.Add(new AgentSnapshot(
+                        agentId,
+                        capacity.AgentActiveSessionCount,
+                        capacity.AgentMaxConcurrentSessions,
+                        capacity.RemainingAgentCapacity,
+                        isDefault));
+                }
+                else
+                {
+                    legacyAgents.Add(new AgentSnapshot(agentId, 0, null, null, isDefault));
+                }
+            }
+            catch
+            {
+                legacyAgents.Add(new AgentSnapshot(agentId, 0, null, null, isDefault));
+            }
+        }
+
+        request.Workspace.Agents.Clear();
+        foreach (var agent in legacyAgents)
+            request.Workspace.Agents.Add(agent);
+
+        request.Workspace.SelectedAgent = request.Workspace.Agents.FirstOrDefault(a => a.IsDefault)
+            ?? request.Workspace.Agents.FirstOrDefault();
+
+        request.Workspace.AgentsStatus = $"Loaded {legacyAgents.Count} agent(s) from server v{info.ServerVersion}.";
+        return CommandResult.Ok();
+    }
+}