Sunder package development.

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
    <AvaloniaUseCompiledBindingsByDefault>true</AvaloniaUseCompiledBindingsByDefault>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Avalonia" Version="12.0.3" />
    <PackageReference Include="Sunder.Sdk" Version="*" />
    <PackageReference Include="Sunder.Package.Build" Version="*" PrivateAssets="all" />
  </ItemGroup>
</Project>

using Sunder.Sdk.Packaging;

[assembly: SunderPackage(
    Id = "my.company.package",
    Name = "My Package",
    Summary = "Adds a custom Sunder workspace.",
    Icon = "assets/icon.png")]

using Microsoft.Extensions.DependencyInjection;
using Sunder.Sdk.Abstractions;

namespace MyCompany.Package;

public sealed class PackageModule : ISunderPackageModule
{
    public void ConfigureServices(IServiceCollection services, IPackageContext context)
    {
        services.AddTransient<MyViewModel>();
    }

    public void RegisterContributions(IPackageContributionRegistry registry, IServiceProvider services)
    {
        registry.RegisterPackageView<MyView>(new PackageViewRegistration(
            id: "my.company.package.main",
            name: "My Package"));
    }
}

public void ConfigureServices(IServiceCollection services, IPackageContext context)
{
    services.AddSingleton(new MyPackageEnvironment(
        context.PackageId,
        context.Version,
        context.InstallPath,
        context.Storage.DataRootPath));

    services.AddSingleton(context.Storage);
    services.AddSingleton(context.Configuration);
    services.AddSingleton(context.Secrets);
    services.AddSingleton(context.Logging);
}

public void RegisterContributions(IPackageContributionRegistry registry, IServiceProvider services)
{
    registry.RegisterPackageView<MyView>(new PackageViewRegistration(
        id: "my.company.package.main",
        name: "My Package",
        icon: "assets/icon.png"));

    registry.RegisterSettingsView<MySettingsView>();
    registry.RegisterBackgroundService<MyBackgroundService>();
    registry.RegisterConfigurationSchema(MyConfiguration.Schema);
    registry.RegisterExtension(MyExtensionPoints.Providers, services.GetRequiredService<MyProvider>());
}

using Avalonia.Controls;
using Sunder.Sdk.Abstractions;

public sealed class MyWorkspaceFactory : IPackageWorkspaceFactory
{
    public Control CreateRootView(IServiceProvider services)
    {
        return new MyView
        {
            DataContext = services.GetRequiredService<MyViewModel>()
        };
    }
}

registry.RegisterPackageViewFactory<MyWorkspaceFactory>(new PackageViewRegistration(
    id: "my.company.package.workspace",
    name: "Workspace",
    defaultPlacement: PackageViewPlacement.Middle,
    showInHotbarByDefault: true));

public sealed class MyBackgroundService : IPackageBackgroundService
{
    public Task StartAsync(CancellationToken cancellationToken = default)
    {
        // Start timers, subscriptions, or package-owned workers here.
        return Task.CompletedTask;
    }

    public Task StopAsync(CancellationToken cancellationToken = default)
    {
        // Stop work quickly when the package is deactivated.
        return Task.CompletedTask;
    }
}

using Sunder.Sdk.Configuration;

registry.RegisterConfigurationSchema(new PackageConfigurationSchema(
    PackageId: "my.company.package",
    PackageDisplayName: "My Package",
    Summary: "Package settings.",
    Sections:
    [
        new PackageConfigurationSection(
            SectionId: "general",
            Title: "General",
            Description: null,
            Fields:
            [
                new PackageConfigurationField(
                    Key: "enabled",
                    Label: "Enabled",
                    Kind: PackageConfigurationFieldKind.Boolean,
                    DefaultValue: "true"),
                new PackageConfigurationField(
                    Key: "api-key",
                    Label: "API key",
                    Kind: PackageConfigurationFieldKind.Secret,
                    Description: "Stored through the package secret store."),
                new PackageConfigurationField(
                    Key: "mode",
                    Label: "Mode",
                    Kind: PackageConfigurationFieldKind.Select,
                    DefaultValue: "balanced",
                    Options:
                    [
                        new PackageConfigurationOption("fast", "Fast"),
                        new PackageConfigurationOption("balanced", "Balanced")
                    ])
            ])
    ]));

var enabled = bool.TryParse(context.Configuration.GetValue("enabled"), out var parsed) && parsed;
var mode = context.Configuration.GetValue("mode") ?? "balanced";
var apiKey = context.Secrets.GetSecret("api-key");

if (string.IsNullOrWhiteSpace(apiKey))
{
    await context.Logging.Events.WarningAsync(
        "my.company.package.configuration.missing_secret",
        "The API key has not been configured.",
        cancellationToken: cancellationToken);
}

var profilePath = context.Storage.Files.GetPath("profiles/default.json");
Directory.CreateDirectory(Path.GetDirectoryName(profilePath)!);

await File.WriteAllTextAsync(profilePath, profileJson, cancellationToken);

await context.Storage.State.SetValueAsync(
    "sync.lastRun",
    DateTimeOffset.UtcNow.ToString("O"),
    cancellationToken);

var lastRun = await context.Storage.State.GetValueAsync("sync.lastRun", cancellationToken);

using Sunder.Sdk.Notifications;

await notificationService.PublishAsync(new PackageNotificationRequest(
    Title: "Import complete",
    Message: "Your package import finished successfully.",
    DisplayMode: PackageNotificationDisplayMode.ToastAndTray,
    Severity: PackageNotificationSeverity.Success),
    cancellationToken);

public sealed class MyViewModel(IPackageShellViewService shellViewService)
{
    public async Task PinAndOpenAsync(CancellationToken cancellationToken)
    {
        await shellViewService.AddViewToDefaultHotbarAsync(
            "my.company.package.main",
            openPanel: true,
            parameters: new Dictionary<string, string?> { ["itemId"] = "42" },
            cancellationToken: cancellationToken);
    }
}

public sealed class MyView : UserControl, IPackageViewNavigationTarget
{
    public ValueTask OnNavigatedToAsync(
        PackageViewNavigationContext context,
        CancellationToken cancellationToken = default)
    {
        if (DataContext is MyViewModel viewModel
            && context.Parameters.TryGetValue("itemId", out var itemId))
        {
            viewModel.OpenItem(itemId);
        }

        return ValueTask.CompletedTask;
    }
}

using Sunder.Sdk.Authentication;
using Sunder.Sdk.Abstractions;

services.AddSingleton<MyOAuthHandler>();
services.AddSingleton<IPackageCallbackHandler>(serviceProvider => serviceProvider.GetRequiredService<MyOAuthHandler>());
services.AddSingleton<IPackageAuthHandler>(serviceProvider => serviceProvider.GetRequiredService<MyOAuthHandler>());

public sealed class MyOAuthHandler : IPackageAuthHandler
{
    private const string PackageId = "my.company.package";

    public ValueTask<PackageAuthStatus> GetStatusAsync(CancellationToken cancellationToken = default)
    {
        return ValueTask.FromResult(new PackageAuthStatus(
            PackageId,
            PackageAuthStatusKind.NotConnected,
            "Not connected.",
            CanAuthorize: true,
            CanDisconnect: false));
    }

    public Task<PackageAuthSessionStartResult?> StartAuthorizationAsync(
        PackageAuthSessionStartContext context,
        CancellationToken cancellationToken = default)
    {
        var launchUrl = "https://identity.example/authorize?redirect_uri="
            + Uri.EscapeDataString(context.CallbackUri.ToString());

        return Task.FromResult<PackageAuthSessionStartResult?>(new PackageAuthSessionStartResult(
            PackageId,
            context.AuthSessionId,
            PackageAuthFlowKind.Browser,
            launchUrl,
            "Continue in your browser."));
    }

    public Task<PackageAuthStatus> CompleteAuthorizationAsync(
        PackageAuthSessionCompletionContext context,
        CancellationToken cancellationToken = default)
    {
        return Task.FromResult(new PackageAuthStatus(
            PackageId,
            PackageAuthStatusKind.Connected,
            "Connected.",
            CanAuthorize: false,
            CanDisconnect: true));
    }

    public Task<PackageAuthStatus> DisconnectAsync(CancellationToken cancellationToken = default)
    {
        return Task.FromResult(new PackageAuthStatus(
            PackageId,
            PackageAuthStatusKind.NotConnected,
            "Disconnected.",
            CanAuthorize: true,
            CanDisconnect: false));
    }
}

<UserControl xmlns="https://github.com/avaloniaui"
             Background="{DynamicResource Sunder.Brush.Surface.Base}">
  <Border Background="{DynamicResource Sunder.Brush.Surface.Raised}"
          BorderBrush="{DynamicResource Sunder.Brush.Border.Subtle}"
          CornerRadius="{DynamicResource Sunder.Radius.Medium}">
    <StackPanel Spacing="{DynamicResource Sunder.Spacing.Medium}">
      <TextBlock Text="Package view"
                 FontSize="{DynamicResource Sunder.FontSize.SectionTitle}"
                 Foreground="{DynamicResource Sunder.Brush.Foreground.Primary}" />
      <TextBlock Text="Uses shell semantic resources."
                 Foreground="{DynamicResource Sunder.Brush.Foreground.Secondary}" />
    </StackPanel>
  </Border>
</UserControl>

using Sunder.Sdk.Packaging;

[assembly: SunderPackage(
    Id = "my.company.extension",
    Name = "My Extension",
    Summary = "Extends another Sunder package.",
    Icon = "assets/icon.png")]

[assembly: SunderPackageDependency(
    PackageId = "my.company.host",
    VersionRange = ">=1.0.0 <2.0.0")]

public interface IMyProvider
{
    string ProviderId { get; }
}

public static class MyExtensionPoints
{
    public static readonly PackageExtensionPoint<IMyProvider> Providers = new("my.company.host:providers");
}

registry.RegisterExtension(
    MyExtensionPoints.Providers,
    services.GetRequiredService<MyProvider>());

var providers = extensionCatalog.GetExtensions(MyExtensionPoints.Providers);
foreach (var provider in providers)
{
    Console.WriteLine(provider.ProviderId);
}

if (extensionCatalog is IPackageExtensionCatalogMonitor monitor)
{
    monitor.Changed += (_, args) =>
    {
        if (args.IncludesExtensionPoint(MyExtensionPoints.Providers.Id))
        {
            RefreshProviders();
        }
    };
}

MyPackage/bin/Debug/net10.0/sunder-dev/
  sunder-package.json
  lib/
    MyPackage.dll
    MyPackage.pdb
    MyPackage.deps.json
    MyPackage.runtimeconfig.json
  assets/
    icon.png

dotnet msbuild .\MyPackage\MyPackage.csproj `
  -t:PackSunderPackage `
  -p:Configuration=Release `
  -p:SunderPackageOutputPath=.\artifacts\packages\

$env:SUNDER_APP_PATH = "C:\Path\To\Sunder.App.exe"
.\run-sunder-dev.ps1

$env:SUNDER_RUNTIME_HOST_PATH = "C:\Path\To\Sunder.Runtime.Host.exe"
.\debug-sunder-runtime.ps1 -RuntimeUrl http://127.0.0.1:5276

Path.Combine(
    Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
    "Sunder",
    "logs")

Path.Combine(
    Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
    "Sunder",
    "Packages",
    "my.company.package",
    "logs")

May 13 10:21:45 workstation my.company.package[1234]: level=info event=my.company.package.import.completed msg="Import completed." item_count=42 package_version=1.0.0 source=events source_name=inbox

using Microsoft.Extensions.Logging;
using Sunder.Sdk.Logging;

var logger = context.LoggerFactory.CreateLogger("my.company.package.import");
logger.LogInformation("Import started for {SourceName}", sourceName);

try
{
    await importer.RunAsync(cancellationToken);
    await context.Logging.Events.InformationAsync(
        "my.company.package.import.completed",
        "Import completed.",
        new Dictionary<string, object?>
        {
            ["source.name"] = sourceName,
            ["item.count"] = itemCount,
        },
        cancellationToken);
}
catch (Exception ex)
{
    await context.Logging.Events.ErrorAsync(
        "my.company.package.import.failed",
        "Import failed.",
        new Dictionary<string, object?> { ["source.name"] = sourceName },
        ex,
        cancellationToken);
}

{
  "manifestVersion": 1,
  "id": "my.company.package",
  "name": "My Package",
  "summary": "Adds a custom Sunder workspace.",
  "version": "1.0.0",
  "entryAssembly": "MyPackage.dll",
  "icon": "assets/icon.png",
  "dependsOn": [
    {
      "packageId": "my.company.host",
      "versionRange": ">=1.0.0 <2.0.0"
    }
  ],
  "sdkApiVersion": 1,
  "sdkPackageVersion": "1.0.0",
  "requiredSdkCapabilities": ["core.v1", "packaging.v1", "contributions.v1", "views.v1"],
  "sdkVersion": "1.0.0",
  "targetFramework": "net10.0"
}

MyPackage/
  Assets/
    icon.png
  PackageMetadata.cs

[assembly: SunderPackage(
    Id = "my.company.package",
    Name = "My Package",
    Icon = "assets/icon.png")]

.sunderpkg
  manifest/
    sunder-package.json
    content-index.json
  payload/
    lib/
    assets/

sunder --help
sunder search my.company
sunder info my.company.package
sunder list --runtime-url http://127.0.0.1:5275/

sunder auth login
sunder auth status
sunder auth logout

sunder yank my.company.package 1.0.0
sunder unyank my.company.package 1.0.0
sunder deprecate my.company.package 1.0.0 --message "Use 1.1.0 instead."
sunder undeprecate my.company.package 1.0.0
sunder dist-tag list my.company.package
sunder dist-tag delete my.company.package beta