feat: add workspace app icons to tray window (#86)

Closes #50

Author: deansheather

App/App.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
         <OutputType>WinExe</OutputType>
         <TargetFramework>net8.0-windows10.0.19041.0</TargetFramework>
@@ -16,7 +16,7 @@
         <!-- To use CommunityToolkit.Mvvm.ComponentModel.ObservablePropertyAttribute: -->
         <LangVersion>preview</LangVersion>
         <!-- We have our own implementation of main with exception handling -->
-        <DefineConstants>DISABLE_XAML_GENERATED_MAIN</DefineConstants>
+        <DefineConstants>DISABLE_XAML_GENERATED_MAIN;DISABLE_XAML_GENERATED_BREAK_ON_UNHANDLED_EXCEPTION</DefineConstants>
 
         <AssemblyName>Coder Desktop</AssemblyName>
         <ApplicationIcon>coder.ico</ApplicationIcon>
@@ -57,6 +57,7 @@
     <ItemGroup>
         <PackageReference Include="CommunityToolkit.Mvvm" Version="8.4.0" />
         <PackageReference Include="CommunityToolkit.WinUI.Controls.Primitives" Version="8.2.250402" />
+        <PackageReference Include="CommunityToolkit.WinUI.Extensions" Version="8.2.250402" />
         <PackageReference Include="DependencyPropertyGenerator" Version="1.5.0">
             <PrivateAssets>all</PrivateAssets>
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

App/App.xaml.cs

@@ -11,6 +11,7 @@
 using Coder.Desktop.App.Views;
 using Coder.Desktop.App.Views.Pages;
 using Coder.Desktop.CoderSdk.Agent;
+using Coder.Desktop.CoderSdk.Coder;
 using Coder.Desktop.Vpn;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
@@ -19,9 +20,9 @@
 using Microsoft.UI.Xaml;
 using Microsoft.Win32;
 using Microsoft.Windows.AppLifecycle;
+using Microsoft.Windows.AppNotifications;
 using Serilog;
 using LaunchActivatedEventArgs = Microsoft.UI.Xaml.LaunchActivatedEventArgs;
-using Microsoft.Windows.AppNotifications;
 
 namespace Coder.Desktop.App;
 
@@ -64,8 +65,11 @@ public App()
             loggerConfig.ReadFrom.Configuration(builder.Configuration);
         });
 
+        services.AddSingleton<ICoderApiClientFactory, CoderApiClientFactory>();
         services.AddSingleton<IAgentApiClientFactory, AgentApiClientFactory>();
 
+        services.AddSingleton<ICredentialBackend>(_ =>
+            new WindowsCredentialBackend(WindowsCredentialBackend.CoderCredentialsTargetName));
         services.AddSingleton<ICredentialManager, CredentialManager>();
         services.AddSingleton<IRpcController, RpcController>();
 
@@ -95,6 +99,8 @@ public App()
         services.AddTransient<TrayWindowLoginRequiredPage>();
         services.AddTransient<TrayWindowLoginRequiredViewModel>();
         services.AddTransient<TrayWindowLoginRequiredPage>();
+        services.AddSingleton<IAgentAppViewModelFactory, AgentAppViewModelFactory>();
+        services.AddSingleton<IAgentViewModelFactory, AgentViewModelFactory>();
         services.AddTransient<TrayWindowViewModel>();
         services.AddTransient<TrayWindowMainPage>();
         services.AddTransient<TrayWindow>();

App/Controls/ExpandChevron.xaml

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<UserControl
+    x:Class="Coder.Desktop.App.Controls.ExpandChevron"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:animatedVisuals="using:Microsoft.UI.Xaml.Controls.AnimatedVisuals"
+    mc:Ignorable="d">
+
+    <Grid>
+        <AnimatedIcon
+            Grid.Column="0"
+            x:Name="ChevronIcon"
+            Width="16"
+            Height="16"
+            Margin="0,0,8,0"
+            RenderTransformOrigin="0.5, 0.5"
+            Foreground="{x:Bind Foreground, Mode=OneWay}"
+            HorizontalAlignment="Center"
+            VerticalAlignment="Center"
+            AnimatedIcon.State="NormalOff">
+
+            <animatedVisuals:AnimatedChevronRightDownSmallVisualSource />
+            <AnimatedIcon.FallbackIconSource>
+                <FontIconSource Glyph="&#xE76C;" />
+            </AnimatedIcon.FallbackIconSource>
+        </AnimatedIcon>
+    </Grid>
+</UserControl>

App/Controls/ExpandChevron.xaml.cs

@@ -0,0 +1,19 @@
+using DependencyPropertyGenerator;
+using Microsoft.UI.Xaml.Controls;
+
+namespace Coder.Desktop.App.Controls;
+
+[DependencyProperty<bool>("IsOpen", DefaultValue = false)]
+public sealed partial class ExpandChevron : UserControl
+{
+    public ExpandChevron()
+    {
+        InitializeComponent();
+    }
+
+    partial void OnIsOpenChanged(bool oldValue, bool newValue)
+    {
+        var newState = newValue ? "NormalOn" : "NormalOff";
+        AnimatedIcon.SetState(ChevronIcon, newState);
+    }
+}

App/Controls/ExpandContent.xaml

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<UserControl
+    x:Class="Coder.Desktop.App.Controls.ExpandContent"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:toolkit="using:CommunityToolkit.WinUI"
+    mc:Ignorable="d">
+
+    <Grid x:Name="CollapsiblePanel" Opacity="0" Visibility="Collapsed" toolkit:UIElementExtensions.ClipToBounds="True">
+        <Grid.RenderTransform>
+            <TranslateTransform x:Name="SlideTransform" Y="-10" />
+        </Grid.RenderTransform>
+
+        <VisualStateManager.VisualStateGroups>
+            <VisualStateGroup>
+                <VisualState x:Name="ExpandedState">
+                    <Storyboard>
+                        <DoubleAnimation
+                            Storyboard.TargetName="CollapsiblePanel"
+                            Storyboard.TargetProperty="Opacity"
+                            To="1"
+                            Duration="0:0:0.2" />
+                        <DoubleAnimation
+                            Storyboard.TargetName="SlideTransform"
+                            Storyboard.TargetProperty="Y"
+                            To="0"
+                            Duration="0:0:0.2" />
+                    </Storyboard>
+                </VisualState>
+
+                <VisualState x:Name="CollapsedState">
+                    <Storyboard Completed="{x:Bind CollapseAnimation_Completed}">
+                        <DoubleAnimation
+                            Storyboard.TargetName="CollapsiblePanel"
+                            Storyboard.TargetProperty="Opacity"
+                            To="0"
+                            Duration="0:0:0.2" />
+                        <DoubleAnimation
+                            Storyboard.TargetName="SlideTransform"
+                            Storyboard.TargetProperty="Y"
+                            To="-10"
+                            Duration="0:0:0.2" />
+                    </Storyboard>
+                </VisualState>
+            </VisualStateGroup>
+        </VisualStateManager.VisualStateGroups>
+    </Grid>
+</UserControl>

App/Controls/ExpandContent.xaml.cs

@@ -0,0 +1,39 @@
+using DependencyPropertyGenerator;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+using Microsoft.UI.Xaml.Markup;
+
+namespace Coder.Desktop.App.Controls;
+
+[ContentProperty(Name = nameof(Children))]
+[DependencyProperty<bool>("IsOpen", DefaultValue = false)]
+public sealed partial class ExpandContent : UserControl
+{
+    public UIElementCollection Children => CollapsiblePanel.Children;
+
+    public ExpandContent()
+    {
+        InitializeComponent();
+    }
+
+    public void CollapseAnimation_Completed(object? sender, object args)
+    {
+        // Hide the panel completely when the collapse animation is done. This
+        // cannot be done with keyframes for some reason.
+        //
+        // Without this, the space will still be reserved for the panel.
+        CollapsiblePanel.Visibility = Visibility.Collapsed;
+    }
+
+    partial void OnIsOpenChanged(bool oldValue, bool newValue)
+    {
+        var newState = newValue ? "ExpandedState" : "CollapsedState";
+
+        // The animation can't set visibility when starting or ending the
+        // animation.
+        if (newValue)
+            CollapsiblePanel.Visibility = Visibility.Visible;
+
+        VisualStateManager.GoToState(this, newState, true);
+    }
+}

App/Converters/DependencyObjectSelector.cs

@@ -156,6 +156,15 @@ private void UpdateSelectedObject()
         ClearValue(SelectedObjectProperty);
     }
 
+    private static void VerifyReferencesProperty(IObservableVector<DependencyObject> references)
+    {
+        // Ensure unique keys and that the values are DependencyObjectSelectorItem<K, V>.
+        var items = references.OfType<DependencyObjectSelectorItem<TK, TV>>().ToArray();
+        var keys = items.Select(i => i.Key).Distinct().ToArray();
+        if (keys.Length != references.Count)
+            throw new ArgumentException("ObservableCollection Keys must be unique.");
+    }
+
     // Called when the References property is replaced.
     private static void ReferencesPropertyChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
     {
@@ -166,12 +175,16 @@ private static void ReferencesPropertyChanged(DependencyObject obj, DependencyPr
             oldValue.VectorChanged -= self.OnVectorChangedReferences;
         var newValue = args.NewValue as DependencyObjectCollection;
         if (newValue != null)
+        {
+            VerifyReferencesProperty(newValue);
             newValue.VectorChanged += self.OnVectorChangedReferences;
+        }
     }
 
     // Called when the References collection changes without being replaced.
     private void OnVectorChangedReferences(IObservableVector<DependencyObject> sender, IVectorChangedEventArgs args)
     {
+        VerifyReferencesProperty(sender);
         UpdateSelectedObject();
     }
 

App/Models/CredentialModel.cs

@@ -1,22 +1,24 @@
+using System;
+
 namespace Coder.Desktop.App.Models;
 
 public enum CredentialState
 {
     // Unknown means "we haven't checked yet"
     Unknown,
 
-    // Invalid means "we checked and there's either no saved credentials or they are not valid"
+    // Invalid means "we checked and there's either no saved credentials, or they are not valid"
     Invalid,
 
-    // Valid means "we checked and there are saved credentials and they are valid"
+    // Valid means "we checked and there are saved credentials, and they are valid"
     Valid,
 }
 
 public class CredentialModel
 {
     public CredentialState State { get; init; } = CredentialState.Unknown;
 
-    public string? CoderUrl { get; init; }
+    public Uri? CoderUrl { get; init; }
     public string? ApiToken { get; init; }
 
     public string? Username { get; init; }

App/Program.cs

@@ -63,11 +63,9 @@ private static void Main(string[] args)
                 notificationManager.NotificationInvoked += app.HandleNotification;
                 notificationManager.Register();
                 if (activationArgs.Kind != ExtendedActivationKind.Launch)
-                {
                     // this means we were activated without having already launched, so handle
                     // the activation as well.
                     app.OnActivated(null, activationArgs);
-                }
             });
         }
         catch (Exception e)

App/Services/CredentialManager.cs

@@ -21,7 +21,7 @@ public class RawCredentials
 [JsonSerializable(typeof(RawCredentials))]
 public partial class RawCredentialsJsonContext : JsonSerializerContext;
 
-public interface ICredentialManager
+public interface ICredentialManager : ICoderApiClientCredentialProvider
 {
     public event EventHandler<CredentialModel> CredentialsChanged;
 
@@ -59,7 +59,8 @@ public interface ICredentialBackend
 /// </summary>
 public class CredentialManager : ICredentialManager
 {
-    private const string CredentialsTargetName = "Coder.Desktop.App.Credentials";
+    private readonly ICredentialBackend Backend;
+    private readonly ICoderApiClientFactory CoderApiClientFactory;
 
     // _opLock is held for the full duration of SetCredentials, and partially
     // during LoadCredentials. _opLock protects _inFlightLoad, _loadCts, and
@@ -79,14 +80,6 @@ public class CredentialManager : ICredentialManager
     // immediate).
     private volatile CredentialModel? _latestCredentials;
 
-    private ICredentialBackend Backend { get; } = new WindowsCredentialBackend(CredentialsTargetName);
-
-    private ICoderApiClientFactory CoderApiClientFactory { get; } = new CoderApiClientFactory();
-
-    public CredentialManager()
-    {
-    }
-
     public CredentialManager(ICredentialBackend backend, ICoderApiClientFactory coderApiClientFactory)
     {
         Backend = backend;
@@ -108,6 +101,20 @@ public CredentialModel GetCachedCredentials()
         };
     }
 
+    // Implements ICoderApiClientCredentialProvider
+    public CoderApiClientCredential? GetCoderApiClientCredential()
+    {
+        var latestCreds = _latestCredentials;
+        if (latestCreds is not { State: CredentialState.Valid } || latestCreds.CoderUrl is null)
+            return null;
+
+        return new CoderApiClientCredential
+        {
+            CoderUrl = latestCreds.CoderUrl,
+            ApiToken = latestCreds.ApiToken ?? "",
+        };
+    }
+
     public async Task<string?> GetSignInUri()
     {
         try
@@ -253,6 +260,12 @@ private async Task<CredentialModel> PopulateModel(RawCredentials? credentials, C
                 State = CredentialState.Invalid,
             };
 
+        if (!Uri.TryCreate(credentials.CoderUrl, UriKind.Absolute, out var uri))
+            return new CredentialModel
+            {
+                State = CredentialState.Invalid,
+            };
+
         BuildInfo buildInfo;
         User me;
         try
@@ -279,7 +292,7 @@ private async Task<CredentialModel> PopulateModel(RawCredentials? credentials, C
         return new CredentialModel
         {
             State = CredentialState.Valid,
-            CoderUrl = credentials.CoderUrl,
+            CoderUrl = uri,
             ApiToken = credentials.ApiToken,
             Username = me.Username,
         };
@@ -298,6 +311,8 @@ private void UpdateState(CredentialModel newModel)
 
 public class WindowsCredentialBackend : ICredentialBackend
 {
+    public const string CoderCredentialsTargetName = "Coder.Desktop.App.Credentials";
+
     private readonly string _credentialsTargetName;
 
     public WindowsCredentialBackend(string credentialsTargetName)

App/Services/RpcController.cs

@@ -170,7 +170,7 @@ public async Task StartVpn(CancellationToken ct = default)
             {
                 Start = new StartRequest
                 {
-                    CoderUrl = credentials.CoderUrl,
+                    CoderUrl = credentials.CoderUrl?.ToString(),
                     ApiToken = credentials.ApiToken,
                 },
             }, ct);

App/Services/UserNotifier.cs

@@ -27,4 +27,3 @@ public Task ShowErrorNotification(string title, string message, CancellationToke
         return Task.CompletedTask;
     }
 }
-

App/DisplayScale.cs renamed to App/Utils/DisplayScale.cs

@@ -3,7 +3,7 @@
 using Microsoft.UI.Xaml;
 using WinRT.Interop;
 
-namespace Coder.Desktop.App;
+namespace Coder.Desktop.App.Utils;
 
 /// <summary>
 ///     A static utility class to house methods related to the visual scale of the display monitor.

App/Utils/ModelUpdate.cs

@@ -0,0 +1,105 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Coder.Desktop.App.Utils;
+
+public interface IModelUpdateable<in T>
+{
+    /// <summary>
+    ///     Applies changes from obj to `this` if they represent the same
+    ///     object based on some identifier like an ID or fixed name.
+    /// </summary>
+    /// <returns>
+    ///     True if the two objects represent the same item and the changes
+    ///     were applied.
+    /// </returns>
+    public bool TryApplyChanges(T obj);
+}
+
+/// <summary>
+///     A static utility class providing methods for applying model updates
+///     with as little UI updates as possible.
+///     The main goal of the utilities in this class is to prevent redraws in
+///     ItemsRepeater items when nothing has changed.
+/// </summary>
+public static class ModelUpdate
+{
+    /// <summary>
+    ///     Takes all items in `update` and either applies them to existing
+    ///     items in `target`, or adds them to `target` if there are no
+    ///     matching items.
+    ///     Any items in `target` that don't have a corresponding item in
+    ///     `update` will be removed from `target`.
+    ///     Items are inserted in their correct sort position according to
+    ///     `sorter`. It's assumed that the target list is already sorted by
+    ///     `sorter`.
+    /// </summary>
+    /// <param name="target">Target list to be updated</param>
+    /// <param name="update">Incoming list to apply to `target`</param>
+    /// <param name="sorter">
+    ///     Comparison to use for sorting. Note that the sort order does not
+    ///     need to be the ID/name field used in the <c>IModelUpdateable</c>
+    ///     implementation, and can be by any order.
+    ///     New items will be sorted after existing items.
+    /// </param>
+    public static void ApplyLists<T>(IList<T> target, IEnumerable<T> update, Comparison<T> sorter)
+        where T : IModelUpdateable<T>
+    {
+        var newItems = update.ToList();
+
+        // Update and remove existing items. We use index-based for loops here
+        // because we remove items, and removing items while using the list as
+        // an IEnumerable will throw an exception.
+        for (var i = 0; i < target.Count; i++)
+        {
+            // Even though we're removing items before a "break", we still use
+            // index-based for loops here to avoid exceptions.
+            for (var j = 0; j < newItems.Count; j++)
+            {
+                if (!target[i].TryApplyChanges(newItems[j])) continue;
+
+                // Prevent it from being added below, or checked again. We
+                // don't need to decrement `j` here because we're breaking
+                // out of this inner loop.
+                newItems.RemoveAt(j);
+                goto OuterLoopEnd; // continue outer loop
+            }
+
+            // A merge couldn't occur, so we need to remove the old item and
+            // decrement `i` for the next iteration.
+            target.RemoveAt(i);
+            i--;
+
+            // Rider fights `dotnet format` about whether there should be a
+            // space before the semicolon or not.
+#pragma warning disable format
+        OuterLoopEnd: ;
+#pragma warning restore format
+        }
+
+        // Add any items that were missing into their correct sorted place.
+        // It's assumed the list is already sorted.
+        foreach (var newItem in newItems)
+        {
+            for (var i = 0; i < target.Count; i++)
+                // If the new item sorts before the current item, insert it
+                // after.
+                if (sorter(newItem, target[i]) < 0)
+                {
+                    target.Insert(i, newItem);
+                    goto OuterLoopEnd;
+                }
+
+            // Handle the case where target is empty or the new item is
+            // equal to or after every other item.
+            target.Add(newItem);
+
+            // Rider fights `dotnet format` about whether there should be a
+            // space before the semicolon or not.
+#pragma warning disable format
+        OuterLoopEnd: ;
+#pragma warning restore format
+        }
+    }
+}

App/Utils/TitleBarIcon.cs

@@ -1,19 +1,16 @@
-using System;
 using Microsoft.UI;
 using Microsoft.UI.Windowing;
 using Microsoft.UI.Xaml;
-using Microsoft.UI.Xaml.Controls.Primitives;
 using WinRT.Interop;
 
-namespace Coder.Desktop.App.Utils
+namespace Coder.Desktop.App.Utils;
+
+public static class TitleBarIcon
 {
-    public static class TitleBarIcon
+    public static void SetTitlebarIcon(Window window)
     {
-        public static void SetTitlebarIcon(Window window)
-        {
-            var hwnd = WindowNative.GetWindowHandle(window);
-            var windowId = Win32Interop.GetWindowIdFromWindow(hwnd);
-            AppWindow.GetFromWindowId(windowId).SetIcon("coder.ico");
-        }
+        var hwnd = WindowNative.GetWindowHandle(window);
+        var windowId = Win32Interop.GetWindowIdFromWindow(hwnd);
+        AppWindow.GetFromWindowId(windowId).SetIcon("coder.ico");
     }
 }

App/ViewModels/AgentAppViewModel.cs

@@ -0,0 +1,188 @@
+using System;
+using System.Linq;
+using Windows.System;
+using Coder.Desktop.App.Models;
+using Coder.Desktop.App.Services;
+using Coder.Desktop.App.Utils;
+using Coder.Desktop.CoderSdk;
+using Coder.Desktop.Vpn.Proto;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using Microsoft.Extensions.Logging;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+using Microsoft.UI.Xaml.Controls.Primitives;
+using Microsoft.UI.Xaml.Media;
+using Microsoft.UI.Xaml.Media.Imaging;
+
+namespace Coder.Desktop.App.ViewModels;
+
+public interface IAgentAppViewModelFactory
+{
+    public AgentAppViewModel Create(Uuid id, string name, Uri appUri, Uri? iconUrl);
+}
+
+public class AgentAppViewModelFactory(ILogger<AgentAppViewModel> childLogger, ICredentialManager credentialManager)
+    : IAgentAppViewModelFactory
+{
+    public AgentAppViewModel Create(Uuid id, string name, Uri appUri, Uri? iconUrl)
+    {
+        return new AgentAppViewModel(childLogger, credentialManager)
+        {
+            Id = id,
+            Name = name,
+            AppUri = appUri,
+            IconUrl = iconUrl,
+        };
+    }
+}
+
+public partial class AgentAppViewModel : ObservableObject, IModelUpdateable<AgentAppViewModel>
+{
+    private const string SessionTokenUriVar = "$SESSION_TOKEN";
+
+    private readonly ILogger<AgentAppViewModel> _logger;
+    private readonly ICredentialManager _credentialManager;
+
+    public required Uuid Id { get; init; }
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(Details))]
+    public required partial string Name { get; set; }
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(Details))]
+    public required partial Uri AppUri { get; set; }
+
+    [ObservableProperty] public partial Uri? IconUrl { get; set; }
+
+    [ObservableProperty] public partial ImageSource IconImageSource { get; set; }
+
+    [ObservableProperty] public partial bool UseFallbackIcon { get; set; } = true;
+
+    public string Details =>
+        (string.IsNullOrWhiteSpace(Name) ? "(no name)" : Name) + ":\n\n" + AppUri;
+
+    public AgentAppViewModel(ILogger<AgentAppViewModel> logger, ICredentialManager credentialManager)
+    {
+        _logger = logger;
+        _credentialManager = credentialManager;
+
+        // Apply the icon URL to the icon image source when it is updated.
+        IconImageSource = UpdateIcon();
+        PropertyChanged += (_, args) =>
+        {
+            if (args.PropertyName == nameof(IconUrl))
+                IconImageSource = UpdateIcon();
+        };
+    }
+
+    public bool TryApplyChanges(AgentAppViewModel obj)
+    {
+        if (Id != obj.Id) return false;
+
+        // To avoid spurious UI updates which cause flashing, don't actually
+        // write to values unless they've changed.
+        if (Name != obj.Name)
+            Name = obj.Name;
+        if (AppUri != obj.AppUri)
+            AppUri = obj.AppUri;
+        if (IconUrl != obj.IconUrl)
+        {
+            UseFallbackIcon = true;
+            IconUrl = obj.IconUrl;
+        }
+
+        return true;
+    }
+
+    private ImageSource UpdateIcon()
+    {
+        if (IconUrl is null || (IconUrl.Scheme != "http" && IconUrl.Scheme != "https"))
+        {
+            UseFallbackIcon = true;
+            return new BitmapImage();
+        }
+
+        // Determine what image source to use based on extension, use a
+        // BitmapImage as last resort.
+        var ext = IconUrl.AbsolutePath.Split('/').LastOrDefault()?.Split('.').LastOrDefault();
+        // TODO: this is definitely a hack, URLs shouldn't need to end in .svg
+        if (ext is "svg")
+        {
+            // TODO: Some SVGs like `/icon/cursor.svg` contain PNG data and
+            //       don't render at all.
+            var svg = new SvgImageSource(IconUrl);
+            svg.Opened += (_, _) => _logger.LogDebug("app icon opened (svg): {uri}", IconUrl);
+            svg.OpenFailed += (_, args) =>
+                _logger.LogDebug("app icon failed to open (svg): {uri}: {Status}", IconUrl, args.Status);
+            return svg;
+        }
+
+        var bitmap = new BitmapImage(IconUrl);
+        bitmap.ImageOpened += (_, _) => _logger.LogDebug("app icon opened (bitmap): {uri}", IconUrl);
+        bitmap.ImageFailed += (_, args) =>
+            _logger.LogDebug("app icon failed to open (bitmap): {uri}: {ErrorMessage}", IconUrl, args.ErrorMessage);
+        return bitmap;
+    }
+
+    public void OnImageOpened(object? sender, RoutedEventArgs e)
+    {
+        UseFallbackIcon = false;
+    }
+
+    public void OnImageFailed(object? sender, RoutedEventArgs e)
+    {
+        UseFallbackIcon = true;
+    }
+
+    [RelayCommand]
+    private void OpenApp(object parameter)
+    {
+        try
+        {
+            var uri = AppUri;
+
+            // http and https URLs should already be filtered out by
+            // AgentViewModel, but as a second line of defence don't do session
+            // token var replacement on those URLs.
+            if (uri.Scheme is not "http" and not "https")
+            {
+                var cred = _credentialManager.GetCachedCredentials();
+                if (cred.State is CredentialState.Valid && cred.ApiToken is not null)
+                    uri = new Uri(uri.ToString().Replace(SessionTokenUriVar, cred.ApiToken));
+            }
+
+            if (uri.ToString().Contains(SessionTokenUriVar))
+                throw new Exception(
+                    $"URI contains {SessionTokenUriVar} variable but could not be replaced (http and https URLs cannot contain {SessionTokenUriVar})");
+
+            _ = Launcher.LaunchUriAsync(uri);
+        }
+        catch (Exception e)
+        {
+            _logger.LogWarning(e, "could not parse or launch app");
+
+            if (parameter is not FrameworkElement frameworkElement) return;
+            var flyout = new Flyout
+            {
+                Content = new TextBlock
+                {
+                    Text = $"Could not open app: {e.Message}",
+                    Margin = new Thickness(4),
+                    TextWrapping = TextWrapping.Wrap,
+                },
+                FlyoutPresenterStyle = new Style(typeof(FlyoutPresenter))
+                {
+                    Setters =
+                    {
+                        new Setter(ScrollViewer.HorizontalScrollModeProperty, ScrollMode.Disabled),
+                        new Setter(ScrollViewer.HorizontalScrollBarVisibilityProperty, ScrollBarVisibility.Disabled),
+                    },
+                },
+            };
+            FlyoutBase.SetAttachedFlyout(frameworkElement, flyout);
+            FlyoutBase.ShowAttachedFlyout(frameworkElement);
+        }
+    }
+}

App/ViewModels/AgentViewModel.cs

@@ -1,11 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using Windows.ApplicationModel.DataTransfer;
+using Coder.Desktop.App.Services;
+using Coder.Desktop.App.Utils;
+using Coder.Desktop.CoderSdk;
+using Coder.Desktop.CoderSdk.Coder;
+using Coder.Desktop.Vpn.Proto;
+using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
+using Microsoft.Extensions.Logging;
+using Microsoft.UI.Dispatching;
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Controls;
 using Microsoft.UI.Xaml.Controls.Primitives;
 
 namespace Coder.Desktop.App.ViewModels;
 
+public interface IAgentViewModelFactory
+{
+    public AgentViewModel Create(IAgentExpanderHost expanderHost, Uuid id, string hostname, string hostnameSuffix,
+        AgentConnectionStatus connectionStatus, Uri dashboardBaseUrl, string? workspaceName);
+}
+
+public class AgentViewModelFactory(
+    ILogger<AgentViewModel> childLogger,
+    ICoderApiClientFactory coderApiClientFactory,
+    ICredentialManager credentialManager,
+    IAgentAppViewModelFactory agentAppViewModelFactory) : IAgentViewModelFactory
+{
+    public AgentViewModel Create(IAgentExpanderHost expanderHost, Uuid id, string hostname, string hostnameSuffix,
+        AgentConnectionStatus connectionStatus, Uri dashboardBaseUrl, string? workspaceName)
+    {
+        return new AgentViewModel(childLogger, coderApiClientFactory, credentialManager, agentAppViewModelFactory,
+            expanderHost, id)
+        {
+            Hostname = hostname,
+            HostnameSuffix = hostnameSuffix,
+            ConnectionStatus = connectionStatus,
+            DashboardBaseUrl = dashboardBaseUrl,
+            WorkspaceName = workspaceName,
+        };
+    }
+}
+
 public enum AgentConnectionStatus
 {
     Green,
@@ -14,17 +56,307 @@ public enum AgentConnectionStatus
     Gray,
 }
 
-public partial class AgentViewModel
+public partial class AgentViewModel : ObservableObject, IModelUpdateable<AgentViewModel>
 {
-    public required string Hostname { get; set; }
+    private const string DefaultDashboardUrl = "https://coder.com";
+    private const int MaxAppsPerRow = 6;
+
+    // These are fake UUIDs, for UI purposes only. Display apps don't exist on
+    // the backend as real app resources and therefore don't have an ID.
+    private static readonly Uuid VscodeAppUuid = new("819828b1-5213-4c3d-855e-1b74db6ddd19");
+    private static readonly Uuid VscodeInsidersAppUuid = new("becf1e10-5101-4940-a853-59af86468069");
+
+    private readonly ILogger<AgentViewModel> _logger;
+    private readonly ICoderApiClientFactory _coderApiClientFactory;
+    private readonly ICredentialManager _credentialManager;
+    private readonly IAgentAppViewModelFactory _agentAppViewModelFactory;
 
-    public required string HostnameSuffix { get; set; } // including leading dot
+    // The AgentViewModel only gets created on the UI thread.
+    private readonly DispatcherQueue _dispatcherQueue =
+        DispatcherQueue.GetForCurrentThread();
 
-    public required AgentConnectionStatus ConnectionStatus { get; set; }
+    private readonly IAgentExpanderHost _expanderHost;
+
+    // This isn't an ObservableProperty because the property itself never
+    // changes. We add an event listener for the collection changing in the
+    // constructor.
+    public readonly ObservableCollection<AgentAppViewModel> Apps = [];
+
+    public readonly Uuid Id;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(FullHostname))]
+    public required partial string Hostname { get; set; }
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(FullHostname))]
+    public required partial string HostnameSuffix { get; set; } // including leading dot
 
     public string FullHostname => Hostname + HostnameSuffix;
 
-    public required string DashboardUrl { get; set; }
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(ShowExpandAppsMessage))]
+    [NotifyPropertyChangedFor(nameof(ExpandAppsMessage))]
+    public required partial AgentConnectionStatus ConnectionStatus { get; set; }
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(DashboardUrl))]
+    public required partial Uri DashboardBaseUrl { get; set; }
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(DashboardUrl))]
+    public required partial string? WorkspaceName { get; set; }
+
+    [ObservableProperty] public partial bool IsExpanded { get; set; } = false;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(ShowExpandAppsMessage))]
+    [NotifyPropertyChangedFor(nameof(ExpandAppsMessage))]
+    public partial bool FetchingApps { get; set; } = false;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(ShowExpandAppsMessage))]
+    [NotifyPropertyChangedFor(nameof(ExpandAppsMessage))]
+    public partial bool AppFetchErrored { get; set; } = false;
+
+    // We only show 6 apps max, which fills the entire width of the tray
+    // window.
+    public IEnumerable<AgentAppViewModel> VisibleApps => Apps.Count > MaxAppsPerRow ? Apps.Take(MaxAppsPerRow) : Apps;
+
+    public bool ShowExpandAppsMessage => ExpandAppsMessage != null;
+
+    public string? ExpandAppsMessage
+    {
+        get
+        {
+            if (ConnectionStatus == AgentConnectionStatus.Gray)
+                return "Your workspace is offline.";
+            if (FetchingApps && Apps.Count == 0)
+                // Don't show this message if we have any apps already. When
+                // they finish loading, we'll just update the screen with any
+                // changes.
+                return "Fetching workspace apps...";
+            if (AppFetchErrored && Apps.Count == 0)
+                // There's very limited screen real estate here so we don't
+                // show the actual error message.
+                return "Could not fetch workspace apps.";
+            if (Apps.Count == 0)
+                return "No apps to show.";
+            return null;
+        }
+    }
+
+    public string DashboardUrl
+    {
+        get
+        {
+            if (string.IsNullOrWhiteSpace(WorkspaceName)) return DashboardBaseUrl.ToString();
+            try
+            {
+                return new Uri(DashboardBaseUrl, $"/@me/{WorkspaceName}").ToString();
+            }
+            catch
+            {
+                return DefaultDashboardUrl;
+            }
+        }
+    }
+
+    public AgentViewModel(ILogger<AgentViewModel> logger, ICoderApiClientFactory coderApiClientFactory,
+        ICredentialManager credentialManager, IAgentAppViewModelFactory agentAppViewModelFactory,
+        IAgentExpanderHost expanderHost, Uuid id)
+    {
+        _logger = logger;
+        _coderApiClientFactory = coderApiClientFactory;
+        _credentialManager = credentialManager;
+        _agentAppViewModelFactory = agentAppViewModelFactory;
+        _expanderHost = expanderHost;
+
+        Id = id;
+
+        PropertyChanged += (_, args) =>
+        {
+            if (args.PropertyName == nameof(IsExpanded))
+            {
+                _expanderHost.HandleAgentExpanded(Id, IsExpanded);
+
+                // Every time the drawer is expanded, re-fetch all apps.
+                if (IsExpanded && !FetchingApps)
+                    FetchApps();
+            }
+        };
+
+        // Since the property value itself never changes, we add event
+        // listeners for the underlying collection changing instead.
+        Apps.CollectionChanged += (_, _) =>
+        {
+            OnPropertyChanged(new PropertyChangedEventArgs(nameof(VisibleApps)));
+            OnPropertyChanged(new PropertyChangedEventArgs(nameof(ShowExpandAppsMessage)));
+            OnPropertyChanged(new PropertyChangedEventArgs(nameof(ExpandAppsMessage)));
+        };
+    }
+
+    public bool TryApplyChanges(AgentViewModel model)
+    {
+        if (Id != model.Id) return false;
+
+        // To avoid spurious UI updates which cause flashing, don't actually
+        // write to values unless they've changed.
+        if (Hostname != model.Hostname)
+            Hostname = model.Hostname;
+        if (HostnameSuffix != model.HostnameSuffix)
+            HostnameSuffix = model.HostnameSuffix;
+        if (ConnectionStatus != model.ConnectionStatus)
+            ConnectionStatus = model.ConnectionStatus;
+        if (DashboardBaseUrl != model.DashboardBaseUrl)
+            DashboardBaseUrl = model.DashboardBaseUrl;
+        if (WorkspaceName != model.WorkspaceName)
+            WorkspaceName = model.WorkspaceName;
+
+        // Apps are not set externally.
+
+        return true;
+    }
+
+    [RelayCommand]
+    private void ToggleExpanded()
+    {
+        SetExpanded(!IsExpanded);
+    }
+
+    public void SetExpanded(bool expanded)
+    {
+        if (IsExpanded == expanded) return;
+        // This will bubble up to the TrayWindowViewModel because of the
+        // PropertyChanged handler.
+        IsExpanded = expanded;
+    }
+
+    partial void OnConnectionStatusChanged(AgentConnectionStatus oldValue, AgentConnectionStatus newValue)
+    {
+        if (IsExpanded && newValue is not AgentConnectionStatus.Gray) FetchApps();
+    }
+
+    private void FetchApps()
+    {
+        if (FetchingApps) return;
+        FetchingApps = true;
+
+        // If the workspace is off, then there's no agent and there's no apps.
+        if (ConnectionStatus == AgentConnectionStatus.Gray)
+        {
+            FetchingApps = false;
+            Apps.Clear();
+            return;
+        }
+
+        // API client creation could fail, which would leave FetchingApps true.
+        ICoderApiClient client;
+        try
+        {
+            client = _coderApiClientFactory.Create(_credentialManager);
+        }
+        catch
+        {
+            FetchingApps = false;
+            throw;
+        }
+
+        var cts = new CancellationTokenSource(TimeSpan.FromSeconds(15));
+        client.GetWorkspaceAgent(Id.ToString(), cts.Token).ContinueWith(t =>
+        {
+            cts.Dispose();
+            ContinueFetchApps(t);
+        }, CancellationToken.None);
+    }
+
+    private void ContinueFetchApps(Task<WorkspaceAgent> task)
+    {
+        // Ensure we're on the UI thread.
+        if (!_dispatcherQueue.HasThreadAccess)
+        {
+            _dispatcherQueue.TryEnqueue(() => ContinueFetchApps(task));
+            return;
+        }
+
+        FetchingApps = false;
+        AppFetchErrored = !task.IsCompletedSuccessfully;
+        if (!task.IsCompletedSuccessfully)
+        {
+            _logger.LogWarning(task.Exception, "Could not fetch workspace agent");
+            return;
+        }
+
+        var workspaceAgent = task.Result;
+        var apps = new List<AgentAppViewModel>();
+        foreach (var app in workspaceAgent.Apps)
+        {
+            if (!app.External || !string.IsNullOrEmpty(app.Command)) continue;
+
+            if (!Uri.TryCreate(app.Url, UriKind.Absolute, out var appUri))
+            {
+                _logger.LogWarning("Could not parse app URI '{Url}' for '{DisplayName}', app will not appear in list",
+                    app.Url,
+                    app.DisplayName);
+                continue;
+            }
+
+            // HTTP or HTTPS external apps are usually things like
+            // wikis/documentation, which clutters up the app.
+            if (appUri.Scheme is "http" or "https")
+                continue;
+
+            // Icon parse failures are not fatal, we will just use the fallback
+            // icon.
+            _ = Uri.TryCreate(DashboardBaseUrl, app.Icon, out var iconUrl);
+
+            apps.Add(_agentAppViewModelFactory.Create(app.Id, app.DisplayName, appUri, iconUrl));
+        }
+
+        foreach (var displayApp in workspaceAgent.DisplayApps)
+        {
+            if (displayApp is not WorkspaceAgent.DisplayAppVscode and not WorkspaceAgent.DisplayAppVscodeInsiders)
+                continue;
+
+            var id = VscodeAppUuid;
+            var displayName = "VS Code";
+            var icon = "/icon/code.svg";
+            var scheme = "vscode";
+            if (displayApp is WorkspaceAgent.DisplayAppVscodeInsiders)
+            {
+                id = VscodeInsidersAppUuid;
+                displayName = "VS Code Insiders";
+                icon = "/icon/code-insiders.svg";
+                scheme = "vscode-insiders";
+            }
+
+            Uri appUri;
+            try
+            {
+                appUri = new UriBuilder
+                {
+                    Scheme = scheme,
+                    Host = "vscode-remote",
+                    Path = $"/ssh-remote+{FullHostname}/{workspaceAgent.ExpandedDirectory}",
+                }.Uri;
+            }
+            catch (Exception e)
+            {
+                _logger.LogWarning(e, "Could not craft app URI for display app {displayApp}, app will not appear in list",
+                    displayApp);
+                continue;
+            }
+
+            // Icon parse failures are not fatal, we will just use the fallback
+            // icon.
+            _ = Uri.TryCreate(DashboardBaseUrl, icon, out var iconUrl);
+
+            apps.Add(_agentAppViewModelFactory.Create(id, displayName, appUri, iconUrl));
+        }
+
+        // Sort by name.
+        ModelUpdate.ApplyLists(Apps, apps, (a, b) => string.Compare(a.Name, b.Name, StringComparison.Ordinal));
+    }
 
     [RelayCommand]
     private void CopyHostname(object parameter)

App/ViewModels/FileSyncListViewModel.cs

@@ -339,7 +339,8 @@ public void OpenRemotePathSelectDialog()
         pickerViewModel.PathSelected += OnRemotePathSelected;
 
         _remotePickerWindow = new DirectoryPickerWindow(pickerViewModel);
-        _remotePickerWindow.SetParent(_window);
+        if (_window is not null)
+            _remotePickerWindow.SetParent(_window);
         _remotePickerWindow.Closed += (_, _) =>
         {
             _remotePickerWindow = null;

App/ViewModels/TrayWindowViewModel.cs

@@ -1,10 +1,14 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
 using System.Linq;
 using System.Threading.Tasks;
 using Coder.Desktop.App.Models;
 using Coder.Desktop.App.Services;
+using Coder.Desktop.App.Utils;
 using Coder.Desktop.App.Views;
+using Coder.Desktop.CoderSdk;
 using Coder.Desktop.Vpn.Proto;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
@@ -13,23 +17,38 @@
 using Microsoft.UI.Dispatching;
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Controls;
-using Exception = System.Exception;
 
 namespace Coder.Desktop.App.ViewModels;
 
-public partial class TrayWindowViewModel : ObservableObject
+public interface IAgentExpanderHost
+{
+    public void HandleAgentExpanded(Uuid id, bool expanded);
+}
+
+public partial class TrayWindowViewModel : ObservableObject, IAgentExpanderHost
 {
     private const int MaxAgents = 5;
     private const string DefaultDashboardUrl = "https://coder.com";
 
     private readonly IServiceProvider _services;
     private readonly IRpcController _rpcController;
     private readonly ICredentialManager _credentialManager;
+    private readonly IAgentViewModelFactory _agentViewModelFactory;
 
     private FileSyncListWindow? _fileSyncListWindow;
 
     private DispatcherQueue? _dispatcherQueue;
 
+    // When we transition from 0 online workspaces to >0 online workspaces, the
+    // first agent will be expanded. This bool tracks whether this has occurred
+    // yet (or if the user has expanded something themselves).
+    private bool _hasExpandedAgent;
+
+    // This isn't an ObservableProperty because the property itself never
+    // changes. We add an event listener for the collection changing in the
+    // constructor.
+    public readonly ObservableCollection<AgentViewModel> Agents = [];
+
     [ObservableProperty]
     [NotifyPropertyChangedFor(nameof(ShowEnableSection))]
     [NotifyPropertyChangedFor(nameof(ShowWorkspacesHeader))]
@@ -49,13 +68,6 @@ public partial class TrayWindowViewModel : ObservableObject
     [NotifyPropertyChangedFor(nameof(ShowFailedSection))]
     public partial string? VpnFailedMessage { get; set; } = null;
 
-    [ObservableProperty]
-    [NotifyPropertyChangedFor(nameof(VisibleAgents))]
-    [NotifyPropertyChangedFor(nameof(ShowNoAgentsSection))]
-    [NotifyPropertyChangedFor(nameof(ShowAgentsSection))]
-    [NotifyPropertyChangedFor(nameof(ShowAgentOverflowButton))]
-    public partial List<AgentViewModel> Agents { get; set; } = [];
-
     public bool ShowEnableSection => VpnFailedMessage is null && VpnLifecycle is not VpnLifecycle.Started;
 
     public bool ShowWorkspacesHeader => VpnFailedMessage is null && VpnLifecycle is VpnLifecycle.Started;
@@ -76,14 +88,43 @@ public partial class TrayWindowViewModel : ObservableObject
 
     public IEnumerable<AgentViewModel> VisibleAgents => ShowAllAgents ? Agents : Agents.Take(MaxAgents);
 
-    [ObservableProperty] public partial string DashboardUrl { get; set; } = "https://coder.com";
+    [ObservableProperty] public partial string DashboardUrl { get; set; } = DefaultDashboardUrl;
 
     public TrayWindowViewModel(IServiceProvider services, IRpcController rpcController,
-        ICredentialManager credentialManager)
+        ICredentialManager credentialManager, IAgentViewModelFactory agentViewModelFactory)
     {
         _services = services;
         _rpcController = rpcController;
         _credentialManager = credentialManager;
+        _agentViewModelFactory = agentViewModelFactory;
+
+        // Since the property value itself never changes, we add event
+        // listeners for the underlying collection changing instead.
+        Agents.CollectionChanged += (_, _) =>
+        {
+            OnPropertyChanged(new PropertyChangedEventArgs(nameof(VisibleAgents)));
+            OnPropertyChanged(new PropertyChangedEventArgs(nameof(ShowNoAgentsSection)));
+            OnPropertyChanged(new PropertyChangedEventArgs(nameof(ShowAgentsSection)));
+            OnPropertyChanged(new PropertyChangedEventArgs(nameof(ShowAgentOverflowButton)));
+        };
+    }
+
+    // Implements IAgentExpanderHost
+    public void HandleAgentExpanded(Uuid id, bool expanded)
+    {
+        // Ensure we're on the UI thread.
+        if (_dispatcherQueue == null) return;
+        if (!_dispatcherQueue.HasThreadAccess)
+        {
+            _dispatcherQueue.TryEnqueue(() => HandleAgentExpanded(id, expanded));
+            return;
+        }
+
+        if (!expanded) return;
+        _hasExpandedAgent = true;
+        // Collapse every other agent.
+        foreach (var otherAgent in Agents.Where(a => a.Id != id))
+            otherAgent.SetExpanded(false);
     }
 
     public void Initialize(DispatcherQueue dispatcherQueue)
@@ -93,8 +134,8 @@ public void Initialize(DispatcherQueue dispatcherQueue)
         _rpcController.StateChanged += (_, rpcModel) => UpdateFromRpcModel(rpcModel);
         UpdateFromRpcModel(_rpcController.GetState());
 
-        _credentialManager.CredentialsChanged += (_, credentialModel) => UpdateFromCredentialsModel(credentialModel);
-        UpdateFromCredentialsModel(_credentialManager.GetCachedCredentials());
+        _credentialManager.CredentialsChanged += (_, credentialModel) => UpdateFromCredentialModel(credentialModel);
+        UpdateFromCredentialModel(_credentialManager.GetCachedCredentials());
     }
 
     private void UpdateFromRpcModel(RpcModel rpcModel)
@@ -107,37 +148,30 @@ private void UpdateFromRpcModel(RpcModel rpcModel)
             return;
         }
 
-        // As a failsafe, if RPC is disconnected we disable the switch. The
-        // Window should not show the current Page if the RPC is disconnected.
-        if (rpcModel.RpcLifecycle is RpcLifecycle.Disconnected)
+        // As a failsafe, if RPC is disconnected (or we're not signed in) we
+        // disable the switch. The Window should not show the current Page if
+        // the RPC is disconnected.
+        var credentialModel = _credentialManager.GetCachedCredentials();
+        if (rpcModel.RpcLifecycle is RpcLifecycle.Disconnected || credentialModel.State is not CredentialState.Valid ||
+            credentialModel.CoderUrl == null)
         {
             VpnLifecycle = VpnLifecycle.Unknown;
             VpnSwitchActive = false;
-            Agents = [];
+            Agents.Clear();
             return;
         }
 
         VpnLifecycle = rpcModel.VpnLifecycle;
         VpnSwitchActive = rpcModel.VpnLifecycle is VpnLifecycle.Starting or VpnLifecycle.Started;
 
-        // Get the current dashboard URL.
-        var credentialModel = _credentialManager.GetCachedCredentials();
-        Uri? coderUri = null;
-        if (credentialModel.State == CredentialState.Valid && !string.IsNullOrWhiteSpace(credentialModel.CoderUrl))
-            try
-            {
-                coderUri = new Uri(credentialModel.CoderUrl, UriKind.Absolute);
-            }
-            catch
-            {
-                // Ignore
-            }
-
         // Add every known agent.
         HashSet<ByteString> workspacesWithAgents = [];
         List<AgentViewModel> agents = [];
         foreach (var agent in rpcModel.Agents)
         {
+            if (!Uuid.TryFrom(agent.Id.Span, out var uuid))
+                continue;
+
             // Find the FQDN with the least amount of dots and split it into
             // prefix and suffix.
             var fqdn = agent.Fqdn
@@ -156,75 +190,95 @@ private void UpdateFromRpcModel(RpcModel rpcModel)
             }
 
             var lastHandshakeAgo = DateTime.UtcNow.Subtract(agent.LastHandshake.ToDateTime());
+            var connectionStatus = lastHandshakeAgo < TimeSpan.FromMinutes(5)
+                ? AgentConnectionStatus.Green
+                : AgentConnectionStatus.Yellow;
             workspacesWithAgents.Add(agent.WorkspaceId);
             var workspace = rpcModel.Workspaces.FirstOrDefault(w => w.Id == agent.WorkspaceId);
 
-            agents.Add(new AgentViewModel
-            {
-                Hostname = fqdnPrefix,
-                HostnameSuffix = fqdnSuffix,
-                ConnectionStatus = lastHandshakeAgo < TimeSpan.FromMinutes(5)
-                    ? AgentConnectionStatus.Green
-                    : AgentConnectionStatus.Yellow,
-                DashboardUrl = WorkspaceUri(coderUri, workspace?.Name),
-            });
+            agents.Add(_agentViewModelFactory.Create(
+                this,
+                uuid,
+                fqdnPrefix,
+                fqdnSuffix,
+                connectionStatus,
+                credentialModel.CoderUrl,
+                workspace?.Name));
         }
 
         // For every stopped workspace that doesn't have any agents, add a
         // dummy agent row.
         foreach (var workspace in rpcModel.Workspaces.Where(w =>
                      w.Status == Workspace.Types.Status.Stopped && !workspacesWithAgents.Contains(w.Id)))
-            agents.Add(new AgentViewModel
-            {
-                // We just assume that it's a single-agent workspace.
-                Hostname = workspace.Name,
+        {
+            if (!Uuid.TryFrom(workspace.Id.Span, out var uuid))
+                continue;
+
+            agents.Add(_agentViewModelFactory.Create(
+                this,
+                // Workspace ID is fine as a stand-in here, it shouldn't
+                // conflict with any agent IDs.
+                uuid,
+                // We assume that it's a single-agent workspace.
+                workspace.Name,
                 // TODO: this needs to get the suffix from the server
-                HostnameSuffix = ".coder",
-                ConnectionStatus = AgentConnectionStatus.Gray,
-                DashboardUrl = WorkspaceUri(coderUri, workspace.Name),
-            });
+                ".coder",
+                AgentConnectionStatus.Gray,
+                credentialModel.CoderUrl,
+                workspace.Name));
+        }
 
         // Sort by status green, red, gray, then by hostname.
-        agents.Sort((a, b) =>
+        ModelUpdate.ApplyLists(Agents, agents, (a, b) =>
         {
             if (a.ConnectionStatus != b.ConnectionStatus)
                 return a.ConnectionStatus.CompareTo(b.ConnectionStatus);
             return string.Compare(a.FullHostname, b.FullHostname, StringComparison.Ordinal);
         });
-        Agents = agents;
 
         if (Agents.Count < MaxAgents) ShowAllAgents = false;
-    }
 
-    private string WorkspaceUri(Uri? baseUri, string? workspaceName)
-    {
-        if (baseUri == null) return DefaultDashboardUrl;
-        if (string.IsNullOrWhiteSpace(workspaceName)) return baseUri.ToString();
-        try
-        {
-            return new Uri(baseUri, $"/@me/{workspaceName}").ToString();
-        }
-        catch
+        var firstOnlineAgent = agents.FirstOrDefault(a => a.ConnectionStatus != AgentConnectionStatus.Gray);
+        if (firstOnlineAgent is null)
+            _hasExpandedAgent = false;
+        if (!_hasExpandedAgent && firstOnlineAgent is not null)
         {
-            return DefaultDashboardUrl;
+            firstOnlineAgent.SetExpanded(true);
+            _hasExpandedAgent = true;
         }
     }
 
-    private void UpdateFromCredentialsModel(CredentialModel credentialModel)
+    private void UpdateFromCredentialModel(CredentialModel credentialModel)
     {
         // Ensure we're on the UI thread.
         if (_dispatcherQueue == null) return;
         if (!_dispatcherQueue.HasThreadAccess)
         {
-            _dispatcherQueue.TryEnqueue(() => UpdateFromCredentialsModel(credentialModel));
+            _dispatcherQueue.TryEnqueue(() => UpdateFromCredentialModel(credentialModel));
             return;
         }
 
+        // CredentialModel updates trigger RpcStateModel updates first. This
+        // resolves an issue on startup where the window would be locked for 5
+        // seconds, even if all startup preconditions have been met:
+        //
+        // 1. RPC state updates, but credentials are invalid so the window
+        //    enters the invalid loading state to prevent interaction.
+        // 2. Credential model finally becomes valid after reaching out to the
+        //    server to check credentials.
+        // 3. UpdateFromCredentialModel previously did not re-trigger RpcModel
+        //    update.
+        // 4. Five seconds after step 1, a new RPC state update would come in
+        //    and finally unlock the window.
+        //
+        // Calling UpdateFromRpcModel at step 3 resolves this issue.
+        UpdateFromRpcModel(_rpcController.GetState());
+
         // HACK: the HyperlinkButton crashes the whole app if the initial URI
         // or this URI is invalid. CredentialModel.CoderUrl should never be
         // null while the Page is active as the Page is only displayed when
         // CredentialModel.Status == Valid.
-        DashboardUrl = credentialModel.CoderUrl ?? DefaultDashboardUrl;
+        DashboardUrl = credentialModel.CoderUrl?.ToString() ?? DefaultDashboardUrl;
     }
 
     public void VpnSwitch_Toggled(object sender, RoutedEventArgs e)
@@ -273,13 +327,13 @@ private static string MaybeUnwrapTunnelError(Exception e)
     }
 
     [RelayCommand]
-    public void ToggleShowAllAgents()
+    private void ToggleShowAllAgents()
     {
         ShowAllAgents = !ShowAllAgents;
     }
 
     [RelayCommand]
-    public void ShowFileSyncListWindow()
+    private void ShowFileSyncListWindow()
     {
         // This is safe against concurrent access since it all happens in the
         // UI thread.
@@ -295,7 +349,7 @@ public void ShowFileSyncListWindow()
     }
 
     [RelayCommand]
-    public void SignOut()
+    private void SignOut()
     {
         if (VpnLifecycle is not VpnLifecycle.Stopped)
             return;

App/Views/DirectoryPickerWindow.xaml.cs

@@ -1,14 +1,14 @@
 using System;
 using System.Runtime.InteropServices;
 using Windows.Graphics;
+using Coder.Desktop.App.Utils;
 using Coder.Desktop.App.ViewModels;
 using Coder.Desktop.App.Views.Pages;
 using Microsoft.UI.Windowing;
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Media;
 using WinRT.Interop;
 using WinUIEx;
-using Coder.Desktop.App.Utils;
 
 namespace Coder.Desktop.App.Views;
 

App/Views/FileSyncListWindow.xaml.cs

@@ -1,8 +1,8 @@
+using Coder.Desktop.App.Utils;
 using Coder.Desktop.App.ViewModels;
 using Coder.Desktop.App.Views.Pages;
 using Microsoft.UI.Xaml.Media;
 using WinUIEx;
-using Coder.Desktop.App.Utils;
 
 namespace Coder.Desktop.App.Views;
 
@@ -23,5 +23,4 @@ public FileSyncListWindow(FileSyncListViewModel viewModel)
 
         this.CenterOnScreen();
     }
-
 }

App/Views/Pages/SignInTokenPage.xaml

@@ -87,14 +87,14 @@
             <Button
                 Content="Back" HorizontalAlignment="Right"
                 Command="{x:Bind ViewModel.TokenPage_BackCommand, Mode=OneWay}"
-                CommandParameter="{x:Bind SignInWindow, Mode=OneWay}" />
+                CommandParameter="{x:Bind SignInWindow}" />
 
             <Button
                 Content="Sign In"
                 HorizontalAlignment="Left"
                 Style="{StaticResource AccentButtonStyle}"
                 Command="{x:Bind ViewModel.TokenPage_SignInCommand, Mode=OneWay}"
-                CommandParameter="{x:Bind SignInWindow, Mode=OneWay}" />
+                CommandParameter="{x:Bind SignInWindow}" />
         </StackPanel>
     </StackPanel>
 </Page>

App/Views/Pages/SignInUrlPage.xaml

@@ -62,7 +62,7 @@
             Content="Next"
             HorizontalAlignment="Center"
             Command="{x:Bind ViewModel.UrlPage_NextCommand, Mode=OneWay}"
-            CommandParameter="{x:Bind SignInWindow, Mode=OneWay}"
+            CommandParameter="{x:Bind SignInWindow}"
             Style="{StaticResource AccentButtonStyle}" />
     </StackPanel>
 </Page>

App/Views/Pages/TrayWindowMainPage.xaml

@@ -1,12 +1,12 @@
 using System;
 using Windows.Graphics;
 using Coder.Desktop.App.Controls;
+using Coder.Desktop.App.Utils;
 using Coder.Desktop.App.ViewModels;
 using Coder.Desktop.App.Views.Pages;
 using Microsoft.UI.Windowing;
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Media;
-using Coder.Desktop.App.Utils;
 
 namespace Coder.Desktop.App.Views;
 

App/Views/SignInWindow.xaml.cs

@@ -6,6 +6,7 @@
 using Coder.Desktop.App.Controls;
 using Coder.Desktop.App.Models;
 using Coder.Desktop.App.Services;
+using Coder.Desktop.App.Utils;
 using Coder.Desktop.App.Views.Pages;
 using CommunityToolkit.Mvvm.Input;
 using Microsoft.UI;
@@ -24,6 +25,7 @@ public sealed partial class TrayWindow : Window
     private const int WIDTH = 300;
 
     private NativeApi.POINT? _lastActivatePosition;
+    private int _maxHeightSinceLastActivation;
 
     private readonly IRpcController _rpcController;
     private readonly ICredentialManager _credentialManager;
@@ -138,30 +140,22 @@ public void SetRootFrame(Page page)
 
     private void RootFrame_SizeChanged(object sender, SizedFrameEventArgs e)
     {
-        ResizeWindow(e.NewSize.Height);
-        MoveWindow();
+        MoveAndResize(e.NewSize.Height);
     }
 
-    private void ResizeWindow()
+    private void MoveAndResize(double height)
     {
-        ResizeWindow(RootFrame.GetContentSize().Height);
-    }
-
-    private void ResizeWindow(double height)
-    {
-        if (height <= 0) height = 100; // will be resolved next frame typically
-
-        var scale = DisplayScale.WindowScale(this);
-        var newWidth = (int)(WIDTH * scale);
-        var newHeight = (int)(height * scale);
-        AppWindow.Resize(new SizeInt32(newWidth, newHeight));
+        var size = CalculateWindowSize(height);
+        var pos = CalculateWindowPosition(size);
+        var rect = new RectInt32(pos.X, pos.Y, size.Width, size.Height);
+        AppWindow.MoveAndResize(rect);
     }
 
     private void MoveResizeAndActivate()
     {
         SaveCursorPos();
-        ResizeWindow();
-        MoveWindow();
+        _maxHeightSinceLastActivation = 0;
+        MoveAndResize(RootFrame.GetContentSize().Height);
         AppWindow.Show();
         NativeApi.SetForegroundWindow(WindowNative.GetWindowHandle(this));
     }
@@ -178,15 +172,33 @@ private void SaveCursorPos()
             _lastActivatePosition = null;
     }
 
-    private void MoveWindow()
+    private SizeInt32 CalculateWindowSize(double height)
     {
-        AppWindow.Move(GetWindowPosition());
+        if (height <= 0) height = 100; // will be resolved next frame typically
+
+        var scale = DisplayScale.WindowScale(this);
+        var newWidth = (int)(WIDTH * scale);
+        var newHeight = (int)(height * scale);
+        // Store the maximum height we've seen for positioning purposes.
+        if (newHeight > _maxHeightSinceLastActivation)
+            _maxHeightSinceLastActivation = newHeight;
+
+        return new SizeInt32(newWidth, newHeight);
     }
 
-    private PointInt32 GetWindowPosition()
+    private PointInt32 CalculateWindowPosition(SizeInt32 size)
     {
-        var height = AppWindow.Size.Height;
-        var width = AppWindow.Size.Width;
+        var width = size.Width;
+        var height = size.Height;
+        // For positioning purposes, pretend the window is the maximum size it
+        // has been since it was last activated. This has the affect of
+        // allowing the window to move up to accomodate more content, but
+        // prevents it from moving back down when the window shrinks again.
+        //
+        // Prevents a lot of jittery behavior with app drawers.
+        if (height < _maxHeightSinceLastActivation)
+            height = _maxHeightSinceLastActivation;
+
         var cursorPosition = _lastActivatePosition;
         if (cursorPosition is null)
         {

App/Views/TrayWindow.xaml.cs

@@ -18,6 +18,16 @@
           "Microsoft.WindowsAppSDK": "1.6.250108002"
         }
       },
+      "CommunityToolkit.WinUI.Extensions": {
+        "type": "Direct",
+        "requested": "[8.2.250402, )",
+        "resolved": "8.2.250402",
+        "contentHash": "rAOYzNX6kdUeeE1ejGd6Q8B+xmyZvOrWFUbqCgOtP8OQsOL66en9ZQTtzxAlaaFC4qleLvnKcn8FJFBezujOlw==",
+        "dependencies": {
+          "CommunityToolkit.Common": "8.2.1",
+          "Microsoft.WindowsAppSDK": "1.6.250108002"
+        }
+      },
       "DependencyPropertyGenerator": {
         "type": "Direct",
         "requested": "[1.5.0, )",
@@ -142,15 +152,6 @@
         "resolved": "8.2.1",
         "contentHash": "LWuhy8cQKJ/MYcy3XafJ916U3gPH/YDvYoNGWyQWN11aiEKCZszzPOTJAOvBjP9yG8vHmIcCyPUt4L82OK47Iw=="
       },
-      "CommunityToolkit.WinUI.Extensions": {
-        "type": "Transitive",
-        "resolved": "8.2.250402",
-        "contentHash": "rAOYzNX6kdUeeE1ejGd6Q8B+xmyZvOrWFUbqCgOtP8OQsOL66en9ZQTtzxAlaaFC4qleLvnKcn8FJFBezujOlw==",
-        "dependencies": {
-          "CommunityToolkit.Common": "8.2.1",
-          "Microsoft.WindowsAppSDK": "1.6.250108002"
-        }
-      },
       "Google.Protobuf": {
         "type": "Transitive",
         "resolved": "3.29.3",

App/packages.lock.json

@@ -27,6 +27,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tests.App", "Tests.App\Test
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MutagenSdk", "MutagenSdk\MutagenSdk.csproj", "{E2477ADC-03DA-490D-9369-79A4CC4A58D2}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tests.CoderSdk", "Tests.CoderSdk\Tests.CoderSdk.csproj", "{2BDEA023-FE75-476F-81DE-8EF90806C27C}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -239,6 +241,22 @@ Global
 		{E2477ADC-03DA-490D-9369-79A4CC4A58D2}.Release|x64.Build.0 = Release|Any CPU
 		{E2477ADC-03DA-490D-9369-79A4CC4A58D2}.Release|x86.ActiveCfg = Release|Any CPU
 		{E2477ADC-03DA-490D-9369-79A4CC4A58D2}.Release|x86.Build.0 = Release|Any CPU
+		{2BDEA023-FE75-476F-81DE-8EF90806C27C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2BDEA023-FE75-476F-81DE-8EF90806C27C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2BDEA023-FE75-476F-81DE-8EF90806C27C}.Debug|ARM64.ActiveCfg = Debug|Any CPU
+		{2BDEA023-FE75-476F-81DE-8EF90806C27C}.Debug|ARM64.Build.0 = Debug|Any CPU
+		{2BDEA023-FE75-476F-81DE-8EF90806C27C}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{2BDEA023-FE75-476F-81DE-8EF90806C27C}.Debug|x64.Build.0 = Debug|Any CPU
+		{2BDEA023-FE75-476F-81DE-8EF90806C27C}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{2BDEA023-FE75-476F-81DE-8EF90806C27C}.Debug|x86.Build.0 = Debug|Any CPU
+		{2BDEA023-FE75-476F-81DE-8EF90806C27C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2BDEA023-FE75-476F-81DE-8EF90806C27C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2BDEA023-FE75-476F-81DE-8EF90806C27C}.Release|ARM64.ActiveCfg = Release|Any CPU
+		{2BDEA023-FE75-476F-81DE-8EF90806C27C}.Release|ARM64.Build.0 = Release|Any CPU
+		{2BDEA023-FE75-476F-81DE-8EF90806C27C}.Release|x64.ActiveCfg = Release|Any CPU
+		{2BDEA023-FE75-476F-81DE-8EF90806C27C}.Release|x64.Build.0 = Release|Any CPU
+		{2BDEA023-FE75-476F-81DE-8EF90806C27C}.Release|x86.ActiveCfg = Release|Any CPU
+		{2BDEA023-FE75-476F-81DE-8EF90806C27C}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

Coder.Desktop.sln

@@ -5,6 +5,7 @@
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/INDENT_NESTED_LOCK_STMT/@EntryValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/INDENT_NESTED_USINGS_STMT/@EntryValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/INDENT_NESTED_WHILE_STMT/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/OUTDENT_STATEMENT_LABELS/@EntryValue">True</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CSharpFileLayoutPatterns/Pattern/@EntryValue">&lt;Patterns xmlns="urn:schemas-jetbrains-com:member-reordering-patterns"&gt;
   &lt;TypePattern DisplayName="Non-reorderable types" Priority="99999999"&gt;
     &lt;TypePattern.Match&gt;

Coder.Desktop.sln.DotSettings

@@ -5,6 +5,18 @@ namespace Coder.Desktop.CoderSdk.Coder;
 public interface ICoderApiClientFactory
 {
     public ICoderApiClient Create(string baseUrl);
+    public ICoderApiClient Create(ICoderApiClientCredentialProvider provider);
+}
+
+public class CoderApiClientCredential
+{
+    public required Uri CoderUrl { get; set; }
+    public required string ApiToken { get; set; }
+}
+
+public interface ICoderApiClientCredentialProvider
+{
+    public CoderApiClientCredential? GetCoderApiClientCredential();
 }
 
 public class CoderApiClientFactory : ICoderApiClientFactory
@@ -13,6 +25,23 @@ public ICoderApiClient Create(string baseUrl)
     {
         return new CoderApiClient(baseUrl);
     }
+
+    public ICoderApiClient Create(ICoderApiClientCredentialProvider provider)
+    {
+        var cred = provider.GetCoderApiClientCredential();
+        if (cred == null)
+            throw new InvalidOperationException(
+                "Cannot create Coder API client with invalid credential provider: credential is null");
+
+        var client = Create(cred.CoderUrl);
+        client.SetSessionToken(cred.ApiToken);
+        return client;
+    }
+
+    public ICoderApiClient Create(Uri baseUrl)
+    {
+        return new CoderApiClient(baseUrl);
+    }
 }
 
 public partial interface ICoderApiClient
@@ -24,6 +53,8 @@ public partial interface ICoderApiClient
 [JsonSerializable(typeof(Response))]
 [JsonSerializable(typeof(User))]
 [JsonSerializable(typeof(ValidationError))]
+[JsonSerializable(typeof(WorkspaceAgent))]
+[JsonSerializable(typeof(WorkspaceApp))]
 public partial class CoderApiJsonContext : JsonSerializerContext;
 
 /// <summary>

CoderSdk/Coder/CoderApiClient.cs

@@ -0,0 +1,38 @@
+namespace Coder.Desktop.CoderSdk.Coder;
+
+public partial interface ICoderApiClient
+{
+    public Task<WorkspaceAgent> GetWorkspaceAgent(string id, CancellationToken ct = default);
+}
+
+public class WorkspaceAgent
+{
+    public const string DisplayAppVscode = "vscode";
+    public const string DisplayAppVscodeInsiders = "vscode_insiders";
+
+    public string ExpandedDirectory { get; set; } = "";
+
+    public WorkspaceApp[] Apps { get; set; } = [];
+
+    // This isn't an enum to avoid future display apps breaking the desktop
+    // app.
+    public string[] DisplayApps { get; set; } = [];
+}
+
+public class WorkspaceApp
+{
+    public Uuid Id { get; set; } = Uuid.Zero;
+    public string Url { get; set; } = string.Empty;
+    public bool External { get; set; } = false;
+    public string DisplayName { get; set; } = string.Empty;
+    public string Command { get; set; } = string.Empty;
+    public string Icon { get; set; } = string.Empty;
+}
+
+public partial class CoderApiClient
+{
+    public Task<WorkspaceAgent> GetWorkspaceAgent(string id, CancellationToken ct = default)
+    {
+        return SendRequestNoBodyAsync<WorkspaceAgent>(HttpMethod.Get, "/api/v2/workspaceagents/" + id, ct);
+    }
+}

CoderSdk/Coder/WorkspaceAgents.cs

@@ -0,0 +1,180 @@
+using System.Globalization;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Coder.Desktop.CoderSdk;
+
+/// <summary>
+///     A simplistic UUIDv4 class that wraps a 16-byte array. We don't use the
+///     native Guid class because it has some weird reordering behavior due to
+///     legacy Windows stuff. This class is not guaranteed to provide full RFC
+///     4122 compliance, but it should provide enough coverage for Coder
+///     Desktop.
+/// </summary>
+[JsonConverter(typeof(UuidJsonConverter))]
+public class Uuid
+{
+    private readonly byte[] _bytes;
+
+    /// <summary>
+    ///     The (invalid) zero UUID.
+    /// </summary>
+    public static Uuid Zero { get; } = new();
+
+    public ReadOnlySpan<byte> Bytes => _bytes;
+
+    private Uuid()
+    {
+        _bytes = new byte[16];
+    }
+
+    public Uuid(ReadOnlySpan<byte> bytes)
+    {
+        if (bytes.Length != 16)
+            throw new ArgumentException($"UUID must be 16 bytes, but was {bytes.Length} bytes", nameof(bytes));
+        if (bytes[6] >> 4 != 0x4)
+            throw new ArgumentException("ID does not seem like a valid UUIDv4", nameof(bytes));
+        _bytes = bytes.ToArray();
+    }
+
+    public Uuid(string str)
+    {
+        if (str.Length != 36)
+            throw new ArgumentException($"UUID string must be 36 characters, but was {str.Length} characters",
+                nameof(str));
+
+        var currentIndex = 0;
+        _bytes = new byte[16];
+
+        for (var i = 0; i < 36; i++)
+        {
+            if (i is 8 or 13 or 18 or 23)
+            {
+                if (str[i] != '-')
+                    throw new ArgumentException("UUID string must have dashes at positions 8, 13, 18, and 23",
+                        nameof(str));
+                continue;
+            }
+
+            // Take two hex digits and convert them to a byte.
+            var hex = str[i..(i + 2)];
+            if (!byte.TryParse(hex, NumberStyles.HexNumber, null, out var b))
+                throw new ArgumentException($"UUID string has invalid hex digits at position {i}", nameof(str));
+            _bytes[currentIndex] = b;
+            currentIndex++;
+
+            // Advance the loop index by 1 as we processed two characters.
+            i++;
+        }
+
+        if (currentIndex != 16)
+            throw new ArgumentException($"UUID string must have 16 bytes, but was {currentIndex} bytes", nameof(str));
+        if (_bytes[6] >> 4 != 0x4)
+            throw new ArgumentException("ID does not seem like a valid UUIDv4", nameof(str));
+    }
+
+    public static bool TryFrom(ReadOnlySpan<byte> bytes, out Uuid uuid)
+    {
+        try
+        {
+            uuid = new Uuid(bytes);
+            return true;
+        }
+        catch
+        {
+            uuid = Zero;
+            return false;
+        }
+    }
+
+    public static bool TryParse(string str, out Uuid uuid)
+    {
+        try
+        {
+            uuid = new Uuid(str);
+            return true;
+        }
+        catch
+        {
+            uuid = Zero;
+            return false;
+        }
+    }
+
+    public override string ToString()
+    {
+        if (_bytes.Length != 16)
+            throw new ArgumentException($"UUID must be 16 bytes, but was {_bytes.Length} bytes", nameof(_bytes));
+
+        // Print every byte as hex, with dashes in the right places.
+        var sb = new StringBuilder(36);
+        for (var i = 0; i < 16; i++)
+        {
+            if (i is 4 or 6 or 8 or 10)
+                sb.Append('-');
+            sb.Append(_bytes[i].ToString("x2"));
+        }
+
+        return sb.ToString();
+    }
+
+    #region Uuid equality
+
+    public override bool Equals(object? obj)
+    {
+        return obj is Uuid other && Equals(other);
+    }
+
+    public bool Equals(Uuid? other)
+    {
+        return other is not null && _bytes.SequenceEqual(other._bytes);
+    }
+
+    public override int GetHashCode()
+    {
+        return _bytes.GetHashCode();
+    }
+
+    public static bool operator ==(Uuid left, Uuid right)
+    {
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(Uuid left, Uuid right)
+    {
+        return !left.Equals(right);
+    }
+
+    #endregion
+}
+
+public class UuidJsonConverter : JsonConverter<Uuid>
+{
+    public override Uuid? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.Null)
+            return null;
+
+        if (reader.TokenType != JsonTokenType.String)
+            throw new JsonException("Expected string token type for UUID");
+
+        var str = reader.GetString();
+        if (str == null)
+            return null;
+
+        try
+        {
+            return new Uuid(str);
+        }
+        catch (Exception ex)
+        {
+            throw new JsonException($"Invalid UUID string '{str}'", ex);
+        }
+    }
+
+    public override void Write(Utf8JsonWriter writer, Uuid value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.ToString());
+    }
+}

CoderSdk/Uuid.cs

@@ -29,7 +29,7 @@ public void EndToEnd()
         var converter = new FriendlyByteConverter();
         foreach (var (input, expected) in cases)
         {
-            var actual = converter.Convert(input, typeof(string), null, null);
+            var actual = converter.Convert(input, typeof(string), null!, null!);
             Assert.That(actual, Is.EqualTo(expected), $"case ({input.GetType()}){input}");
         }
     }

Tests.App/Converters/FriendlyByteConverterTest.cs

@@ -9,7 +9,7 @@ namespace Coder.Desktop.Tests.App.Services;
 [TestFixture]
 public class CredentialManagerTest
 {
-    private const string TestServerUrl = "https://dev.coder.com";
+    private const string TestServerUrl = "https://dev.coder.com/";
     private const string TestApiToken = "abcdef1234-abcdef1234567890ABCDEF";
     private const string TestUsername = "dean";
 
@@ -50,7 +50,7 @@ public async Task EndToEnd(CancellationToken ct)
             // Cached credential should be valid.
             cred = manager1.GetCachedCredentials();
             Assert.That(cred.State, Is.EqualTo(CredentialState.Valid));
-            Assert.That(cred.CoderUrl, Is.EqualTo(TestServerUrl));
+            Assert.That(cred.CoderUrl?.ToString(), Is.EqualTo(TestServerUrl));
             Assert.That(cred.ApiToken, Is.EqualTo(TestApiToken));
             Assert.That(cred.Username, Is.EqualTo(TestUsername));
 
@@ -62,7 +62,7 @@ public async Task EndToEnd(CancellationToken ct)
             var manager2 = new CredentialManager(credentialBackend, apiClientFactory.Object);
             cred = await manager2.LoadCredentials(ct).WaitAsync(ct);
             Assert.That(cred.State, Is.EqualTo(CredentialState.Valid));
-            Assert.That(cred.CoderUrl, Is.EqualTo(TestServerUrl));
+            Assert.That(cred.CoderUrl?.ToString(), Is.EqualTo(TestServerUrl));
             Assert.That(cred.ApiToken, Is.EqualTo(TestApiToken));
             Assert.That(cred.Username, Is.EqualTo(TestUsername));
 

Tests.App/Services/CredentialManagerTest.cs

@@ -0,0 +1,36 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+      <AssemblyName>Coder.Desktop.Tests.CoderSdk</AssemblyName>
+      <RootNamespace>Coder.Desktop.Tests.CoderSdk</RootNamespace>
+      <TargetFramework>net8.0</TargetFramework>
+      <ImplicitUsings>enable</ImplicitUsings>
+      <Nullable>enable</Nullable>
+
+      <IsPackable>false</IsPackable>
+      <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+      <PackageReference Include="coverlet.collector" Version="6.0.4">
+          <PrivateAssets>all</PrivateAssets>
+          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      </PackageReference>
+      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+      <PackageReference Include="NUnit" Version="4.3.2" />
+      <PackageReference Include="NUnit.Analyzers" Version="4.6.0">
+          <PrivateAssets>all</PrivateAssets>
+          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      </PackageReference>
+      <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+      <Using Include="NUnit.Framework" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\CoderSdk\CoderSdk.csproj" />
+  </ItemGroup>
+
+</Project>

Tests.App/Utils/ModelUpdateTest.cs

@@ -0,0 +1,141 @@
+using Coder.Desktop.CoderSdk;
+
+namespace Coder.Desktop.Tests.CoderSdk;
+
+[TestFixture]
+public class UuidTest
+{
+    private const string UuidStr = "df762f71-898c-44a2-84c6-8add83704266";
+
+    private static readonly byte[] UuidBytes =
+        [0xdf, 0x76, 0x2f, 0x71, 0x89, 0x8c, 0x44, 0xa2, 0x84, 0xc6, 0x8a, 0xdd, 0x83, 0x70, 0x42, 0x66];
+
+    [Test(Description = "Convert UUID bytes => Uuid")]
+    public void BytesToUuid()
+    {
+        var uuid = new Uuid(UuidBytes);
+        Assert.That(uuid.ToString(), Is.EqualTo(UuidStr));
+        Assert.That(uuid.Bytes.ToArray(), Is.EqualTo(UuidBytes));
+    }
+
+    [Test(Description = "Convert UUID string => Uuid")]
+    public void StringToUuid()
+    {
+        var uuid = new Uuid(UuidStr);
+        Assert.That(uuid.ToString(), Is.EqualTo(UuidStr));
+        Assert.That(uuid.Bytes.ToArray(), Is.EqualTo(UuidBytes));
+    }
+
+    [Test(Description = "Convert capitalized UUID string => Uuid")]
+    public void CapitalizedStringToUuid()
+    {
+        var uuid = new Uuid(UuidStr.ToUpper());
+        // The capitalized string should be discarded after parsing.
+        Assert.That(uuid.ToString(), Is.EqualTo(UuidStr));
+        Assert.That(uuid.Bytes.ToArray(), Is.EqualTo(UuidBytes));
+    }
+
+    [Test(Description = "Invalid length")]
+    public void InvalidLength()
+    {
+        var ex = Assert.Throws<ArgumentException>(() => _ = new Uuid([]));
+        Assert.That(ex.Message, Does.Contain("UUID must be 16 bytes, but was 0 bytes"));
+        ex = Assert.Throws<ArgumentException>(() => _ = new Uuid(UuidBytes.AsSpan(..^1)));
+        Assert.That(ex.Message, Does.Contain("UUID must be 16 bytes, but was 15 bytes"));
+        var longerBytes = UuidBytes.Append((byte)0x0).ToArray();
+        ex = Assert.Throws<ArgumentException>(() => _ = new Uuid(longerBytes));
+        Assert.That(ex.Message, Does.Contain("UUID must be 16 bytes, but was 17 bytes"));
+
+        ex = Assert.Throws<ArgumentException>(() => _ = new Uuid(""));
+        Assert.That(ex.Message, Does.Contain("UUID string must be 36 characters, but was 0 characters"));
+        ex = Assert.Throws<ArgumentException>(() => _ = new Uuid(UuidStr[..^1]));
+        Assert.That(ex.Message, Does.Contain("UUID string must be 36 characters, but was 35 characters"));
+        ex = Assert.Throws<ArgumentException>(() => _ = new Uuid(UuidStr + "0"));
+        Assert.That(ex.Message, Does.Contain("UUID string must be 36 characters, but was 37 characters"));
+    }
+
+    [Test(Description = "Invalid version")]
+    public void InvalidVersion()
+    {
+        var invalidVersionBytes = new byte[16];
+        Array.Copy(UuidBytes, invalidVersionBytes, UuidBytes.Length);
+        invalidVersionBytes[6] = (byte)(invalidVersionBytes[6] & 0x0f); // clear version nibble
+        var ex = Assert.Throws<ArgumentException>(() => _ = new Uuid(invalidVersionBytes));
+        Assert.That(ex.Message, Does.Contain("ID does not seem like a valid UUIDv4"));
+
+        var invalidVersionChars = UuidStr.ToCharArray();
+        invalidVersionChars[14] = '0'; // clear version nibble
+        ex = Assert.Throws<ArgumentException>(() => _ = new Uuid(new string(invalidVersionChars)));
+        Assert.That(ex.Message, Does.Contain("ID does not seem like a valid UUIDv4"));
+    }
+
+    [Test(Description = "Invalid string")]
+    public void InvalidString()
+    {
+        var hyphenMissing = UuidStr.Replace("-", "0");
+        var ex = Assert.Throws<ArgumentException>(() => _ = new Uuid(hyphenMissing));
+        Assert.That(ex.Message, Does.Contain("UUID string must have dashes at positions 8, 13, 18, and 23"));
+
+        var invalidHex = UuidStr.ToCharArray();
+        invalidHex[2] = 'g'; // invalid hex digit
+        ex = Assert.Throws<ArgumentException>(() => _ = new Uuid(new string(invalidHex)));
+        Assert.That(ex.Message, Does.Contain("UUID string has invalid hex digits at position 2"));
+    }
+
+    [Test(Description = "Try methods")]
+    public void Try()
+    {
+        Assert.That(Uuid.TryFrom(UuidBytes, out var uuid1), Is.True);
+        Assert.That(uuid1.Bytes.ToArray(), Is.EqualTo(UuidBytes));
+
+        Assert.That(Uuid.TryFrom([], out var uuid2), Is.False);
+        Assert.That(uuid2, Is.EqualTo(Uuid.Zero));
+
+        Assert.That(Uuid.TryParse(UuidStr, out var uuid3), Is.True);
+        Assert.That(uuid3.ToString(), Is.EqualTo(UuidStr));
+
+        Assert.That(Uuid.TryParse("", out var uuid4), Is.False);
+        Assert.That(uuid4, Is.EqualTo(Uuid.Zero));
+    }
+
+    [Test(Description = "Equality")]
+    public void Equality()
+    {
+        var differentUuidBytes = new byte[16];
+        Array.Copy(UuidBytes, differentUuidBytes, UuidBytes.Length);
+        differentUuidBytes[0] = (byte)(differentUuidBytes[0] + 1);
+
+        var uuid1 = new Uuid(UuidBytes);
+        var uuid2 = new Uuid(UuidBytes);
+        var uuid3 = new Uuid(differentUuidBytes);
+
+#pragma warning disable CS1718 // Comparison made to same variable
+#pragma warning disable NUnit2010 // Use Is.EqualTo constraint instead of direct comparison
+        // ReSharper disable EqualExpressionComparison
+        Assert.That(uuid1 == uuid1, Is.True);
+        Assert.That(uuid1 != uuid1, Is.False);
+        Assert.That(Uuid.Zero == Uuid.Zero, Is.True);
+        Assert.That(Uuid.Zero != Uuid.Zero, Is.False);
+        // ReSharper restore EqualExpressionComparison
+#pragma warning restore NUnit2010
+#pragma warning restore CS1718
+
+        Assert.That(uuid1 == uuid2, Is.True);
+        Assert.That(uuid2 == uuid1, Is.True);
+        Assert.That(uuid1 != uuid2, Is.False);
+        Assert.That(uuid2 != uuid1, Is.False);
+
+        Assert.That(uuid1 == uuid3, Is.False);
+        Assert.That(uuid3 == uuid1, Is.False);
+        Assert.That(uuid1 != uuid3, Is.True);
+        Assert.That(uuid3 != uuid1, Is.True);
+
+        Assert.That(uuid1.Equals(uuid2), Is.True);
+        Assert.That(uuid2.Equals(uuid1), Is.True);
+        Assert.That(uuid1.Equals(uuid3), Is.False);
+        Assert.That(uuid3.Equals(uuid1), Is.False);
+
+        Assert.That(uuid1.Equals(null!), Is.False);
+        Assert.That(uuid1.Equals(new object()), Is.False);
+    }
+}

Tests.CoderSdk/Tests.CoderSdk.csproj

@@ -13,6 +13,9 @@
         "requested": "[2.69.0, )",
         "resolved": "2.69.0",
         "contentHash": "W5hW4R1h19FCzKb8ToqIJMI5YxnQqGmREEpV8E5XkfCtLPIK5MSHztwQ8gZUfG8qu9fg5MhItjzyPRqQBjnrbA=="
+      },
+      "Coder.Desktop.CoderSdk": {
+        "type": "Project"
       }
     }
   }