Skip to main content

Plugin API Reference

This reference is generated directly from the plugin contract assemblies and their XML documentation comments, so it always reflects the extension surface of the installed version. Types are grouped by namespace. Interfaces you implement in a plugin are listed first within each group.

LANCommander.SDK.Plugins​

ILobbyProvider​

interface — LANCommander.SDK.Plugins.ILobbyProvider

Implemented by launcher plugins that can find multiplayer lobbies for an installed game, for example the lobbies a player's friends are hosting on a platform like Steam. Register the implementation in ConfigureServices.

Methods

  • Task<IEnumerable<GameLobby>> GetLobbiesAsync(LobbyQuery query, CancellationToken cancellationToken)
    • Returns the lobbies currently available for the game.

IPlugin​

interface — LANCommander.SDK.Plugins.IPlugin

The entry point contract every LANCommander plugin implements. Plugins are discovered from the host's Plugins drop-in folder and loaded once at startup.

Properties

  • string Id { get; }
    • Stable, globally unique identifier (e.g. "com.acme.myplugin").
  • string Name { get; }
    • Human readable display name.
  • string Version { get; }
    • Plugin version (SemVer recommended).
  • string Author { get; }
    • Plugin author.

Methods

  • void ConfigureServices(IServiceCollection services)
    • Registers the plugin's own services into the host's DI container. Called during host startup before the service provider is built, so implementations must only register services and must not attempt to resolve them.
  • Task InitializeAsync(PluginContext context, CancellationToken cancellationToken)
    • Asynchronous startup hook, invoked after the host's service provider is built. Use this to resolve services, subscribe to lifecycle events, register UI extensions, etc.

IPluginEventBus​

interface — LANCommander.SDK.Plugins.IPluginEventBus

A minimal in-process, strongly-typed event aggregator that lets plugins react to host lifecycle events (game install/launch/uninstall, login, etc.). Registered as a singleton in both hosts.

Methods

  • IDisposable Subscribe<TEvent>(Func<TEvent, CancellationToken, Task> handler)
    • Subscribes a handler to events of type TEvent.
  • Task PublishAsync<TEvent>(TEvent event, CancellationToken cancellationToken)
    • Publishes an event to all subscribed handlers. Each handler is awaited and isolated so a throwing handler cannot break the publisher or other handlers.

IPluginPowerShellExtension​

interface — LANCommander.SDK.Plugins.IPluginPowerShellExtension

Implemented by plugins that want to add PowerShell cmdlets or script modules into the LANCommander runspace. Register the implementation in ConfigureServices; the SDK's PowerShell runspace picks up all registered extensions when a script is executed.

Methods

  • IEnumerable<Type> GetCmdletTypes()
    • Returns cmdlet types (classes decorated with [Cmdlet]) to register into each runspace.
  • IEnumerable<string> GetModulePaths()
    • Returns absolute paths to PowerShell script modules (.psm1/.psd1) shipped with the plugin that should be imported into each runspace.

GameLobby​

record — LANCommander.SDK.Plugins.GameLobby

A multiplayer lobby the player can join.

Properties

  • string Id { get; init; }
    • The lobby's id on the platform that hosts it.
  • string HostName { get; init; }
    • Name of the player hosting the lobby, shown as "Join {HostName}'s lobby".
  • string JoinArguments { get; init; }
    • Arguments appended to the game's primary action to join the lobby, for example +connect_lobby 109775241055537385.

LANCommanderPluginAttribute​

attribute — LANCommander.SDK.Plugins.LANCommanderPluginAttribute

Assembly-level attribute that marks an assembly as a LANCommander plugin and declares its entry point and compatibility metadata. This is the primary discovery mechanism used by the loader.

Properties

  • Type EntryPoint { get; }
    • The concrete type implementing IPlugin that serves as the entry point.
  • string Id { get; set; }
    • Optional override for the plugin id; when null the loader falls back to the instance's Id.
  • string MinHostVersion { get; set; }
    • Minimum compatible host (SDK) version, inclusive. Null means no lower bound.
  • string MaxHostVersion { get; set; }
    • Maximum compatible host (SDK) version, inclusive. Null means no upper bound.
  • PluginHost Hosts { get; set; }
    • The hosts this plugin supports. Defaults to both server and launcher.

LoadedPlugin​

record — LANCommander.SDK.Plugins.LoadedPlugin

A plugin the loader has configured: its entry point and the manifest it was loaded from.

Properties

  • IPlugin Plugin { get; init; }
  • PluginManifest Manifest { get; init; }

LobbyQuery​

record — LANCommander.SDK.Plugins.LobbyQuery

The installed game a ILobbyProvider is asked to find lobbies for.

Properties

  • Guid GameId { get; init; }
    • Id of the game.
  • string InstallDirectory { get; init; }
    • Directory the game is installed in.
  • IReadOnlyList<Game> Manifests { get; init; }
    • The manifests of the game and its installed addons.

PluginBootstrap​

class — LANCommander.SDK.Plugins.PluginBootstrap

Convenience helper that centralizes plugin discovery so every host wires it identically. Call ConfigurePlugins as the last step while populating the service collection (before building the provider), then call InitializeAllAsync on the returned loader after the provider is built.

Methods

  • PluginLoaderService ConfigurePlugins(IServiceCollection services, PluginHost host)
    • Discovers plugins for host from <config>/Plugins, lets each register its services into services, and registers the loader as a singleton so the same instance can drive Phase 2 initialization.

PluginContext​

class — LANCommander.SDK.Plugins.PluginContext

Runtime context handed to a plugin during InitializeAsync.

Properties

  • PluginHost Host { get; init; }
    • The host the plugin is running inside (a single value, never a flags combination).
  • IServiceProvider Services { get; init; }
    • The host service provider scoped to the current InitializeAsync call. Resolve services needed during initialization, but do not retain this provider or scoped services after initialization completes.
  • string PluginDirectory { get; init; }
    • Absolute path to the folder the plugin was loaded from.
  • ILogger Logger { get; init; }
    • Logger scoped to the plugin.

PluginEventBus​

class — LANCommander.SDK.Plugins.PluginEventBus

Methods

  • IDisposable Subscribe<TEvent>(Func<TEvent, CancellationToken, Task> handler)
  • Task PublishAsync<TEvent>(TEvent event, CancellationToken cancellationToken)

PluginLoadContext​

class — LANCommander.SDK.Plugins.PluginLoadContext

An isolated AssemblyLoadContext for a single plugin. Uses an AssemblyDependencyResolver to resolve the plugin's private dependencies while deferring host-provided assemblies (the SDK, DI abstractions, Avalonia, etc.) to the default context so that shared types keep a single identity across the ALC boundary.

PluginLoaderService​

class — LANCommander.SDK.Plugins.PluginLoaderService

Discovers, loads, and initializes plugins from a drop-in folder. Split into two phases to match the "build the DI container once" constraint: DiscoverAndConfigure runs while the host is still populating its IServiceCollection (before the provider is built).InitializeAllAsync runs after the provider has been built.

Properties

  • IReadOnlyList<PluginManifest> LoadedPlugins { get; }
    • Plugins successfully loaded and configured during discovery.
  • IReadOnlyList<LoadedPlugin> Plugins { get; }
    • The loaded plugins' entry points alongside their manifests.

Methods

  • void DiscoverAndConfigure(IServiceCollection services, PluginHost host, string pluginsRoot, string hostVersion, ILogger logger)
    • Phase 1: scans pluginsRoot for plugins, loads each into its own PluginLoadContext, applies host + version gates, instantiates the entry point, and lets it register services. A failure in one plugin never aborts the batch.
  • Task InitializeAllAsync(IServiceProvider serviceProvider, CancellationToken cancellationToken)
    • Phase 2: invokes InitializeAsync for every loaded plugin, each within its own DI scope. A failure in one plugin never aborts the others.
  • bool IsVersionCompatible(string hostVersion, string min, string max)
    • Whether hostVersion falls within the inclusive SemVer bounds a plugin declares. A host version that cannot be parsed never blocks a plugin.

PluginManifest​

class — LANCommander.SDK.Plugins.PluginManifest

Parsed metadata describing a discovered plugin, derived from its LANCommanderPluginAttribute.

Properties

  • string Id { get; init; }
  • Type EntryPoint { get; init; }
  • string MinHostVersion { get; init; }
  • string MaxHostVersion { get; init; }
  • PluginHost Hosts { get; init; }
  • Assembly Assembly { get; init; }
    • The assembly the plugin was loaded from.
  • string Directory { get; init; }
    • Absolute path to the folder the plugin was loaded from.

Methods

  • PluginManifest FromAttribute(LANCommanderPluginAttribute attribute, Assembly assembly, string directory)
    • Builds a manifest from an assembly-level plugin attribute.

PluginPackageTypes​

class — LANCommander.SDK.Plugins.PluginPackageTypes

The NuGet package types a plugin package declares. Every plugin package declares Plugin, plus the type of each host it runs on; hosts search their package sources for their own type.

Methods

  • string For(PluginHost host)
    • The package type a host searches for.
  • IReadOnlyList<string> All(PluginHost hosts)
    • Every package type a plugin targeting hosts declares.

PluginHost​

enum — LANCommander.SDK.Plugins.PluginHost

Identifies which LANCommander host a plugin targets. Used both as a single value (the host a plugin is being loaded into) and as a flags set (the hosts a plugin declares support for).

ValueDescription
None = 0
Server = 1
Launcher = 2

LANCommander.SDK.Plugins.Events​

GameAfterExitEvent​

record — LANCommander.SDK.Plugins.Events.GameAfterExitEvent

Raised immediately after a launched game process exits.

Properties

  • Guid GameId { get; init; }
  • string InstallDirectory { get; init; }

GameBeforeLaunchEvent​

record — LANCommander.SDK.Plugins.Events.GameBeforeLaunchEvent

Raised immediately before a game's executable is launched.

Properties

  • Guid GameId { get; init; }
  • string InstallDirectory { get; init; }
  • string Action { get; init; }

GameInstallFailedEvent​

record — LANCommander.SDK.Plugins.Events.GameInstallFailedEvent

Raised when a game install fails.

Properties

  • Guid GameId { get; init; }
  • string InstallDirectory { get; init; }

GameInstalledEvent​

record — LANCommander.SDK.Plugins.Events.GameInstalledEvent

Raised after a game has finished installing.

Properties

  • Guid GameId { get; init; }
  • string InstallDirectory { get; init; }

GameInstallingEvent​

record — LANCommander.SDK.Plugins.Events.GameInstallingEvent

Raised just before a game install begins.

Properties

  • Guid GameId { get; init; }
  • string InstallDirectory { get; init; }

GameUninstalledEvent​

record — LANCommander.SDK.Plugins.Events.GameUninstalledEvent

Raised after a game has finished uninstalling.

Properties

  • Guid GameId { get; init; }

GameUninstallingEvent​

record — LANCommander.SDK.Plugins.Events.GameUninstallingEvent

Raised just before a game is uninstalled.

Properties

  • Guid GameId { get; init; }
  • string InstallDirectory { get; init; }

InstallQueueChangedEvent​

record — LANCommander.SDK.Plugins.Events.InstallQueueChangedEvent

Raised whenever the install/download queue changes.

UserLoggedInEvent​

record — LANCommander.SDK.Plugins.Events.UserLoggedInEvent

Raised after a user successfully logs in.

Properties

  • Guid UserId { get; init; }
  • string UserName { get; init; }

UserLoggedOutEvent​

record — LANCommander.SDK.Plugins.Events.UserLoggedOutEvent

Raised after a user logs out.

Properties

  • Guid UserId { get; init; }
  • string UserName { get; init; }

LANCommander.Launcher.Plugins.Extensions​

IContextMenuExtension​

interface — LANCommander.Launcher.Plugins.Extensions.IContextMenuExtension

Adds items to a game's context menu. Implementations are resolved from DI and their items appended to the consolidated game menu shown on covers and list rows.

Properties

  • int Order { get; }
    • Relative position among extension items; lower values appear first.

Methods

  • IEnumerable<Control> BuildMenuItems(Guid gameId)
    • Builds the menu items shown for the given game (typically MenuItems).

IFooterExtension​

interface — LANCommander.Launcher.Plugins.Extensions.IFooterExtension

Adds a control to the launcher shell's footer. Implementations are resolved from DI and rendered, ordered by Order, alongside the built-in footer items.

Properties

  • int Order { get; }
    • Relative position among extension items; lower values appear first.

Methods

  • Control BuildContent()
    • Builds the control rendered in the footer.

IGameDetailTabExtension​

interface — LANCommander.Launcher.Plugins.Extensions.IGameDetailTabExtension

Adds an additional tab to a game's detail view. Implementations are resolved from DI and appended, ordered by Order, after the built-in tabs.

Properties

  • string Header { get; }
    • Header shown on the tab.
  • int Order { get; }
    • Relative position among extension tabs; lower values appear first.

Methods

  • Control BuildContent(Guid gameId)
    • Builds the control rendered inside the tab for the given game.

IGameManageSectionExtension​

interface — LANCommander.Launcher.Plugins.Extensions.IGameManageSectionExtension

Adds an additional section to a game's "Manage" dialog. Implementations are resolved from DI and appended, ordered by Order, after the built-in sections (Options, Modify, Versions) in the left-hand navigation.

Properties

  • string Title { get; }
    • Label shown for the section in the dialog's navigation menu.
  • string IconValue { get; }
    • Phosphor icon name shown next to the section in the navigation menu.
  • int Order { get; }
    • Relative position among extension sections; lower values appear first.

Methods

  • Control BuildContent(Guid gameId)
    • Builds the control rendered in the section's content pane for the given game.

INavigationPageExtension​

interface — LANCommander.Launcher.Plugins.Extensions.INavigationPageExtension

Adds a top-level navigable destination reachable from the launcher shell. The view model is registered with the IViewRegistry so the shell's content control can render the associated view when navigated to.

Properties

  • string Label { get; }
    • Label shown for the navigation entry.
  • int Order { get; }
    • Relative position among extension destinations; lower values appear first.
  • Type ViewModelType { get; }
    • The view model type used both as the navigation target and the registry key.

Methods

  • PluginViewModelBase CreateViewModel()
    • Creates the view model instance shown when the destination is activated.
  • Control BuildView()
    • Builds the control that renders ViewModelType.

ISettingsPageExtension​

interface — LANCommander.Launcher.Plugins.Extensions.ISettingsPageExtension

Adds an additional section to the launcher's settings page. Implementations are resolved from DI and appended, ordered by Order, beneath the built-in settings sections.

Properties

  • string Title { get; }
    • Heading shown for the section.
  • int Order { get; }
    • Relative position among extension sections; lower values appear first.

Methods

  • Control BuildContent()
    • Builds the control rendered inside the section.

LANCommander.Launcher.Plugins​

IViewRegistry​

interface — LANCommander.Launcher.Plugins.IViewRegistry

Maps view model types to the Avalonia controls that render them. Seeded at startup with the launcher's built-in mappings and extended at runtime by plugins that add navigable views. Consumers apply AsDataTemplate to a ContentControl so content is resolved by view model type, replacing the previously hard-coded inline XAML data templates.

Methods

  • void Register(Type viewModelType, Func<Control> factory)
    • Register a control factory for the given view model type.
  • void Register<TViewModel>(Func<Control> factory)
    • Register a control factory for TViewModel.
  • IDataTemplate AsDataTemplate()
    • Build an IDataTemplate backed by the current registrations. Matching prefers the most-derived registered type, preserving the launcher's existing rule that DepotGameDetailViewModel resolves before its GameDetailViewModel base.

PluginViewModelBase​

class — LANCommander.Launcher.Plugins.PluginViewModelBase

Base type for view models supplied by plugins. Lives in this project (rather than the launcher's ViewModels assembly) so plugins can derive from it without taking a dependency on the launcher application itself, avoiding a circular reference.

ViewRegistry​

class — LANCommander.Launcher.Plugins.ViewRegistry

Methods

  • void Register(Type viewModelType, Func<Control> factory)
  • void Register<TViewModel>(Func<Control> factory)
  • IDataTemplate AsDataTemplate()

LANCommander.Server.Plugins​

IActionProvider​

interface — LANCommander.Server.Plugins.IActionProvider

Manages the actions of games (per version), tools and servers. Provided by the server; inject it into a scoped plugin service or page.

IArchiveProvider​

interface — LANCommander.Server.Plugins.IArchiveProvider

Lists and deletes archives. Provided by the server; inject it into a scoped plugin service or page. Archives are added by importing a package through IPackageImporter.

Methods

  • Task<IReadOnlyList<ArchiveInfo>> GetAsync(RecordOwner owner, CancellationToken cancellationToken)
    • The archives of a game, redistributable or tool, newest first. For a game, every version's archive unless the owner names a version.
  • Task<ArchiveInfo> GetArchiveAsync(Guid id, CancellationToken cancellationToken)
    • The archive with the given id, or null.
  • Task DeleteAsync(Guid id, CancellationToken cancellationToken)
    • Deletes an archive and its file. Does nothing when there is no such archive.

IGameProvider​

interface — LANCommander.Server.Plugins.IGameProvider

Lists and manages the server's games and add-ons, and their links, external ids and custom fields. Provided by the server; inject it into a scoped plugin service or page.

Methods

  • Task<IReadOnlyList<GameInfo>> GetAsync(CancellationToken cancellationToken)
    • Every game and add-on, ordered by title.
  • Task<GameInfo> GetAsync(Guid id, CancellationToken cancellationToken)
    • The game with the given id, or null.
  • Task<IReadOnlyList<GameInfo>> GetAddonsAsync(Guid baseGameId, CancellationToken cancellationToken)
    • The add-ons of a game, ordered by title.
  • Task<GameInfo> FindByExternalIdAsync(string provider, string externalId, CancellationToken cancellationToken)
    • The game recorded under an id in another service, or null.
  • Task<GameInfo> AddAsync(GameInfo game, CancellationToken cancellationToken)
    • Adds a game.
  • Task<GameInfo> UpdateAsync(GameInfo game, CancellationToken cancellationToken)
    • Writes every field of a game.
  • Task DeleteAsync(Guid id, CancellationToken cancellationToken)
    • Deletes a game along with its archives and media, files included. Does nothing when there is no such game.
  • Task<IReadOnlyList<Guid>> GetLinksAsync(Guid gameId, GameLinkKind kind, CancellationToken cancellationToken)
    • The ids of the records a game is linked to.
  • Task SetLinksAsync(Guid gameId, GameLinkKind kind, IEnumerable<Guid> ids, CancellationToken cancellationToken)
    • Replaces the records a game is linked to. An empty list unlinks them all.
  • Task<string> GetRedistributableOptionsAsync(Guid gameId, Guid redistributableId, CancellationToken cancellationToken)
    • The options a game's latest version passes to a redistributable, as JSON, or null.
  • Task SetRedistributableOptionsAsync(Guid gameId, Guid redistributableId, string optionsJson, CancellationToken cancellationToken)
    • Sets the options a game's latest version passes to a redistributable, as JSON.
  • Task<IReadOnlyList<GameExternalIdInfo>> GetExternalIdsAsync(Guid gameId, CancellationToken cancellationToken)
  • Task<GameExternalIdInfo> SetExternalIdAsync(Guid gameId, string provider, string externalId, CancellationToken cancellationToken)
    • Records the id a game goes by in a service, replacing any it had there.
  • Task RemoveExternalIdAsync(Guid gameId, string provider, CancellationToken cancellationToken)
    • Forgets the id a game goes by in a service. Does nothing when it has none there.
  • Task<IReadOnlyList<GameCustomFieldInfo>> GetCustomFieldsAsync(CancellationToken cancellationToken)
    • Every game's custom fields, including the owning game id. Use this for bulk identity or provenance checks without making a separate request for each game.
  • Task<IReadOnlyList<GameCustomFieldInfo>> GetCustomFieldsAsync(Guid gameId, CancellationToken cancellationToken)
  • Task<GameCustomFieldInfo> SetCustomFieldAsync(Guid gameId, string name, string value, CancellationToken cancellationToken)
    • Sets a custom field, adding it when the game has none by that name.
  • Task RemoveCustomFieldAsync(Guid gameId, string name, CancellationToken cancellationToken)
    • Removes a custom field. Does nothing when the game has none by that name.

IGameVersionProvider​

interface — LANCommander.Server.Plugins.IGameVersionProvider

Lists and manages the versions of games. Provided by the server; inject it into a scoped plugin service or page. A version's archive arrives through IPackageImporter.

Methods

  • Task<IReadOnlyList<GameVersionInfo>> GetAsync(Guid gameId, CancellationToken cancellationToken)
    • A game's versions, oldest first.
  • Task<GameVersionInfo> GetLatestAsync(Guid gameId, CancellationToken cancellationToken)
    • A game's latest version, or null when it has none yet.
  • Task<GameVersionInfo> GetOrCreateLatestAsync(Guid gameId, CancellationToken cancellationToken)
    • The latest version, creating an empty initial version only when the game has none. Does not create a new version or publish a draft when a version already exists.
  • Task<GameVersionInfo> GetVersionAsync(Guid id, CancellationToken cancellationToken)
    • The version with the given id, or null.
  • Task<GameVersionInfo> CreateAsync(Guid gameId, string version, string changelog, CancellationToken cancellationToken)
    • Adds a version after the game's latest, carrying over the latest's actions, scripts, save paths, option schema and redistributables. A draft latest version is published by this.
  • Task<GameVersionInfo> UpdateAsync(GameVersionInfo version, CancellationToken cancellationToken)
    • Writes a version's number, changelog, sort order, published state and option schema.
  • Task DeleteAsync(Guid id, CancellationToken cancellationToken)
    • Deletes a version along with its archive, file included, and its actions, scripts and save paths. Does nothing when there is no such version.
  • Task<IReadOnlyList<GameVersionRedistributableInfo>> GetRedistributablesAsync(Guid versionId, CancellationToken cancellationToken)
    • A version's redistributables and their per-version option values.
  • Task SetRedistributablesAsync(Guid versionId, IEnumerable<Guid> redistributableIds, CancellationToken cancellationToken)
    • Replaces a version's redistributables, preserving options for those kept. An empty list unlinks them all. The game's own list is mirrored according to the server's publishing rules.
  • Task SetRedistributableOptionsAsync(Guid versionId, Guid redistributableId, string optionsJson, CancellationToken cancellationToken)
    • Sets option values as JSON for a redistributable already linked to the version.

IKeyProvider​

interface — LANCommander.Server.Plugins.IKeyProvider

Manages the keys of games. Provided by the server; inject it into a scoped plugin service or page. UpdateAsync changes a key's value only.

Methods

  • Task<IReadOnlyList<KeyInfo>> AddRangeAsync(Guid gameId, IEnumerable<string> values, CancellationToken cancellationToken)
    • Adds several keys to a game, skipping blank values and ones it already has.
  • Task<KeyInfo> ReleaseAsync(Guid id, CancellationToken cancellationToken)
    • Frees a claimed key so it can be handed out again.

IMediaGrabberExtension​

interface — LANCommander.Server.Plugins.IMediaGrabberExtension

Adds a source to the server's media search, alongside the built-in ones such as HQ and SteamGridDB. Register an implementation in IPlugin.ConfigureServices.

Properties

  • string Name { get; }
    • The name the source is shown and filtered by in the media search. Must be unique among the server's sources.
  • IReadOnlyCollection<MediaType> SupportedMediaTypes { get; }
    • The kinds of media the source can find.
  • bool SupportsPaging { get; }
    • Whether the source returns results in pages. When false, the server asks only for page 0.

Methods

  • Task<IReadOnlyList<MediaGrabberItem>> SearchAsync(MediaType type, string keywords, int page, CancellationToken cancellationToken)
    • Searches for media of one kind. Only called for a type in SupportedMediaTypes. A failure is shown as the source's error without affecting the other sources.

IMediaProvider​

interface — LANCommander.Server.Plugins.IMediaProvider

Manages the media of games. Provided by the server; inject it into a scoped plugin service or page. New files are stored in the server's default media storage location.

Methods

  • Task<IReadOnlyList<MediaInfo>> GetAsync(Guid gameId, CancellationToken cancellationToken)
    • A game's media, ordered by type and sort order.
  • Task<MediaInfo> GetMediaAsync(Guid id, CancellationToken cancellationToken)
    • The media with the given id, or null.
  • Task<MediaInfo> AddAsync(Guid gameId, MediaInfo media, Stream file, CancellationToken cancellationToken)
    • Adds media to a game from a stream, which is read to the end.
  • Task<MediaInfo> AddFromUrlAsync(Guid gameId, MediaInfo media, string url, CancellationToken cancellationToken)
    • Adds media to a game, downloading the file from a URL.
  • Task<MediaInfo> UpdateAsync(MediaInfo media, CancellationToken cancellationToken)
    • Writes the name, type, source URL, MIME type and sort order of media. The file is untouched.
  • Task<MediaInfo> ReplaceFileAsync(Guid id, Stream file, CancellationToken cancellationToken)
    • Replaces the file of existing media.
  • Task<Stream> OpenReadAsync(Guid id, CancellationToken cancellationToken)
    • Opens the media's file for reading, or returns null when there is no such media or file.
  • Task DeleteAsync(Guid id, CancellationToken cancellationToken)
    • Deletes media and its file. Does nothing when there is no such media.

IMetadataLookup​

interface — LANCommander.Server.Plugins.IMetadataLookup

Looks up game metadata through the server's configured providers. Provided by the server; inject it into a scoped plugin service or page. Lookups do not import or change games.

Methods

  • IReadOnlyList<string> GetProviderNames()
    • The names of available providers, ordered case-insensitively.
  • Task<MetadataSearchPage> SearchGamesAsync(string providerName, string input, int limit, int offset, CancellationToken cancellationToken)
    • Searches a configured, available provider.
  • Task<Game> GetGameAsync(string providerName, string gameId, CancellationToken cancellationToken)
    • Fetches full metadata by the provider's game id, or null when it has no such game.

IMultiplayerModeProvider​

interface — LANCommander.Server.Plugins.IMultiplayerModeProvider

Manages the multiplayer modes of games. Provided by the server; inject it into a scoped plugin service or page.

IOwnedRecordProvider`1​

interface — LANCommander.Server.Plugins.IOwnedRecordProvider1`

Lists and manages records that belong to a game, redistributable, tool or server: actions, scripts, save paths and the like. Each provider accepts only the owners its records can have, and throws ArgumentException for any other.

Methods

  • Task<IReadOnlyList<TInfo>> GetAsync(RecordOwner owner, CancellationToken cancellationToken)
    • The owner's records. For a game's version-scoped records, those of the version the owner names, or of the latest version.
  • Task<TInfo> GetRecordAsync(Guid id, CancellationToken cancellationToken)
    • The record with the given id, or null.
  • Task<TInfo> AddAsync(RecordOwner owner, TInfo record, CancellationToken cancellationToken)
    • Adds a record to an owner. For a game's version-scoped records, to the version the owner names, or to the latest version.
  • Task<TInfo> UpdateAsync(TInfo record, CancellationToken cancellationToken)
    • Writes every field of a record. It stays with its owner.
  • Task DeleteAsync(Guid id, CancellationToken cancellationToken)
    • Deletes a record. Does nothing when there is no such record.

IPackageImporter​

interface — LANCommander.Server.Plugins.IPackageImporter

Imports LCX packages through the server's own import pipeline, the same one the import API and the import dialog use. Provided by the server; inject it into a scoped plugin service or page.

Methods

  • Task<PackageImportResult> ImportFileAsync(string packagePath, Guid? storageLocationId, ManifestType? manifestType, CancellationToken cancellationToken)
    • Imports every record in an LCX file the server can already read.
  • Task<PackageImportResult> ImportStreamAsync(Stream package, Guid? storageLocationId, ManifestType? manifestType, IProgress<long> copyProgress, CancellationToken cancellationToken)
    • Copies an LCX package stream to the server's temporary storage, then imports every record in it.

IRedistributableProvider​

interface — LANCommander.Server.Plugins.IRedistributableProvider

Lists and manages the server's redistributables. Provided by the server; inject it into a scoped plugin service or page. Their archives arrive through IPackageImporter, and their scripts are managed through IScriptProvider.

Methods

  • Task<IReadOnlyList<RedistributableInfo>> GetAsync(CancellationToken cancellationToken)
    • Every redistributable, ordered by name.
  • Task<RedistributableInfo> GetAsync(Guid id, CancellationToken cancellationToken)
    • The redistributable with the given id, or null.
  • Task<RedistributableInfo> FindAsync(string name, CancellationToken cancellationToken)
    • The redistributable with the given name, compared case-insensitively, or null.
  • Task<RedistributableInfo> AddAsync(RedistributableInfo redistributable, CancellationToken cancellationToken)
  • Task<RedistributableInfo> UpdateAsync(RedistributableInfo redistributable, CancellationToken cancellationToken)
    • Writes every field of a redistributable.
  • Task DeleteAsync(Guid id, CancellationToken cancellationToken)
    • Deletes a redistributable along with its archives, files included, unlinking it from every game. Does nothing when there is no such redistributable.

ISavePathProvider​

interface — LANCommander.Server.Plugins.ISavePathProvider

Manages the save paths of games, per version. Provided by the server; inject it into a scoped plugin service or page.

IScriptProvider​

interface — LANCommander.Server.Plugins.IScriptProvider

Manages the scripts of games (per version), redistributables, tools and servers. Provided by the server; inject it into a scoped plugin service or page.

IServerEndpointExtension​

interface — LANCommander.Server.Plugins.IServerEndpointExtension

Contributes HTTP endpoints to the server's API, for example for a launcher or another client to call. Register an implementation in IPlugin.ConfigureServices.

Properties

  • string RoutePrefix { get; }
    • The path segment the endpoints are mapped under: /api/Plugins/{RoutePrefix}. Letters, digits, ., - and _, starting with a letter or digit. Must be unique among plugins, ignoring case; extensions that share a prefix are all ignored.
  • PluginAccessPolicy Access { get; }
    • Who may call the endpoints. Defaults to administrators only.

Methods

  • void MapEndpoints(IEndpointRouteBuilder endpoints)
    • Maps the endpoints. endpoints is already rooted at /api/Plugins/{RoutePrefix} and carries the Access requirement, so routes are given relative to it. Called once, when the server starts.

IServerNavigationExtension​

interface — LANCommander.Server.Plugins.IServerNavigationExtension

Contributes a link to the server's primary navigation. Register an implementation in IPlugin.ConfigureServices.

Properties

  • string Id { get; }
    • Stable identifier used to detect duplicate contributions.
  • string Label { get; }
    • Text displayed in the server navigation.
  • string Href { get; }
    • Plugin application route, beginning with /Plugins/.
  • string Icon { get; }
    • Optional LANCommander icon name.
  • string Section { get; }
    • The section the entry is placed in, one of ServerNavigationSection. Null places it in the plugin area at the end of the navigation.
  • string After { get; }
    • The built-in entry in Section this entry follows: a link's route, e.g. /Settings/Users, or a group's ServerNavigationSection. Use Start to place it first; null, or an entry the section does not show, places it last.
  • int Order { get; }
    • Orders entries placed at the same spot; ties are sorted by label.
  • PluginAccessPolicy Access { get; }
    • Who may see this entry. Defaults to administrators only.

IServerProvider​

interface — LANCommander.Server.Plugins.IServerProvider

Lists and manages the server's game servers, with their consoles and HTTP paths. Provided by the server; inject it into a scoped plugin service or page. Their actions and scripts are managed through IActionProvider and IScriptProvider.

Methods

  • Task<IReadOnlyList<ServerInfo>> GetAsync(CancellationToken cancellationToken)
    • Every game server, ordered by name.
  • Task<ServerInfo> GetAsync(Guid id, CancellationToken cancellationToken)
    • The game server with the given id, or null.
  • Task<ServerInfo> AddAsync(ServerInfo server, CancellationToken cancellationToken)
  • Task<ServerInfo> UpdateAsync(ServerInfo server, CancellationToken cancellationToken)
    • Writes every field of a game server.
  • Task DeleteAsync(Guid id, CancellationToken cancellationToken)
    • Deletes a game server. Does nothing when there is no such game server.
  • Task<IReadOnlyList<ServerConsoleInfo>> GetConsolesAsync(Guid serverId, CancellationToken cancellationToken)
  • Task<ServerConsoleInfo> AddConsoleAsync(Guid serverId, ServerConsoleInfo console, CancellationToken cancellationToken)
  • Task<ServerConsoleInfo> UpdateConsoleAsync(ServerConsoleInfo console, CancellationToken cancellationToken)
  • Task DeleteConsoleAsync(Guid id, CancellationToken cancellationToken)
    • Deletes a console. Does nothing when there is no such console.
  • Task<IReadOnlyList<ServerHttpPathInfo>> GetHttpPathsAsync(Guid serverId, CancellationToken cancellationToken)
  • Task<ServerHttpPathInfo> AddHttpPathAsync(Guid serverId, ServerHttpPathInfo httpPath, CancellationToken cancellationToken)
  • Task<ServerHttpPathInfo> UpdateHttpPathAsync(ServerHttpPathInfo httpPath, CancellationToken cancellationToken)
  • Task DeleteHttpPathAsync(Guid id, CancellationToken cancellationToken)
    • Deletes an HTTP path. Does nothing when there is no such HTTP path.

IServerRouteAssemblyExtension​

interface — LANCommander.Server.Plugins.IServerRouteAssemblyExtension

Contributes an assembly containing routable Razor components to the server. Register an implementation in IPlugin.ConfigureServices.

Properties

  • Assembly Assembly { get; }
    • The assembly containing the plugin's routable components.

IStorageLocationProvider​

interface — LANCommander.Server.Plugins.IStorageLocationProvider

Lists the server's storage locations, for example to let an administrator pick where an import writes its archives. Provided by the server; inject it into a scoped plugin service or page.

Methods

  • Task<IReadOnlyList<StorageLocationInfo>> GetAsync(StorageLocationType type, CancellationToken cancellationToken)
    • The storage locations of the given type, the default first.

ITaxonomyProvider​

interface — LANCommander.Server.Plugins.ITaxonomyProvider

Lists and manages the server's taxonomy records: categories, collections, companies, engines, genres, platforms and tags. Provided by the server; inject it into a scoped plugin service or page. Games are linked to them through IGameProvider.

Methods

  • Task<IReadOnlyList<TaxonomyInfo>> GetAsync(TaxonomyKind kind, CancellationToken cancellationToken)
    • Every record of a kind, ordered by name.
  • Task<TaxonomyInfo> GetAsync(TaxonomyKind kind, Guid id, CancellationToken cancellationToken)
    • The record with the given id, or null.
  • Task<TaxonomyInfo> FindAsync(TaxonomyKind kind, string name, CancellationToken cancellationToken)
    • The record with the given name, compared case-insensitively, or null.
  • Task<TaxonomyInfo> GetOrAddAsync(TaxonomyKind kind, string name, CancellationToken cancellationToken)
    • The record with the given name, added first when there is none.
  • Task<TaxonomyInfo> AddAsync(TaxonomyKind kind, string name, CancellationToken cancellationToken)
    • Adds a record, even when one with the same name exists.
  • Task<TaxonomyInfo> RenameAsync(TaxonomyKind kind, Guid id, string name, CancellationToken cancellationToken)
  • Task DeleteAsync(TaxonomyKind kind, Guid id, CancellationToken cancellationToken)
    • Deletes a record, unlinking it from every game. Does nothing when there is no such record.

IToolProvider​

interface — LANCommander.Server.Plugins.IToolProvider

Lists and manages the server's tools. Provided by the server; inject it into a scoped plugin service or page. Their archives arrive through IPackageImporter, and their actions and scripts are managed through IActionProvider and IScriptProvider. The games a tool is linked to can be set from either side; see Tools.

Methods

  • Task<IReadOnlyList<ToolInfo>> GetAsync(CancellationToken cancellationToken)
    • Every tool, ordered by name.
  • Task<ToolInfo> GetAsync(Guid id, CancellationToken cancellationToken)
    • The tool with the given id, or null.
  • Task<ToolInfo> FindAsync(string name, CancellationToken cancellationToken)
    • The tool with the given name, compared case-insensitively, or null.
  • Task<ToolInfo> AddAsync(ToolInfo tool, CancellationToken cancellationToken)
  • Task<ToolInfo> UpdateAsync(ToolInfo tool, CancellationToken cancellationToken)
    • Writes every field of a tool.
  • Task DeleteAsync(Guid id, CancellationToken cancellationToken)
    • Deletes a tool along with its archives, files included, unlinking it from every game. Does nothing when there is no such tool.
  • Task<IReadOnlyList<Guid>> GetGamesAsync(Guid toolId, CancellationToken cancellationToken)
    • The ids of the games a tool is linked to.
  • Task SetGamesAsync(Guid toolId, IEnumerable<Guid> gameIds, CancellationToken cancellationToken)
    • Replaces the games a tool is linked to. An empty list unlinks them all.

ActionInfo​

record — LANCommander.Server.Plugins.ActionInfo

Something a launcher can run for a game, tool or server, such as starting it.

Properties

  • Guid Id { get; init; }
  • string Name { get; init; }
  • string Path { get; init; }
    • The executable, usually relative to {InstallDir}.
  • string Arguments { get; init; }
  • string WorkingDirectory { get; init; }
  • bool IsPrimary { get; init; }
    • Whether this is the action a launcher runs when asked to play.
  • int SortOrder { get; init; }
  • RuntimePlatform Platforms { get; init; }
    • The platforms the action runs on.
  • string OptionOverrides { get; init; }
    • Install option values the action overrides, as JSON.
  • RecordOwner Owner { get; init; }
    • Set by the server; ignored when writing.

ArchiveInfo​

record — LANCommander.Server.Plugins.ArchiveInfo

An archive of files for a game, redistributable or tool.

Properties

  • Guid Id { get; init; }
  • string Version { get; init; }
  • Guid StorageLocationId { get; init; }
  • Guid? GameId { get; init; }
  • Guid? GameVersionId { get; init; }
  • Guid? RedistributableId { get; init; }
  • Guid? ToolId { get; init; }
  • long CompressedSize { get; init; }
  • long UncompressedSize { get; init; }
  • DateTime CreatedOn { get; init; }

GameCustomFieldInfo​

record — LANCommander.Server.Plugins.GameCustomFieldInfo

A named value an administrator or plugin records against a game.

Properties

  • Guid Id { get; init; }
  • Guid GameId { get; init; }
  • string Name { get; init; }
  • string Value { get; init; }

GameExternalIdInfo​

record — LANCommander.Server.Plugins.GameExternalIdInfo

An id a game goes by in another service, such as a store.

Properties

  • Guid Id { get; init; }
  • Guid GameId { get; init; }
  • string Provider { get; init; }
    • The service, e.g. Steam or GOG.
  • string ExternalId { get; init; }

GameInfo​

record — LANCommander.Server.Plugins.GameInfo

A game or add-on on the server: its own fields only. Its links, children and files are managed through the methods of IGameProvider and the other providers.

Properties

  • Guid Id { get; init; }
    • Empty when adding a game, to have the server choose one.
  • string Title { get; init; }
  • string SortTitle { get; init; }
  • string DirectoryName { get; init; }
  • string Description { get; init; }
  • string Notes { get; init; }
  • DateTime? ReleasedOn { get; init; }
  • GameType Type { get; init; }
    • A main game, or one of the kinds of add-on.
  • Guid? BaseGameId { get; init; }
    • For an add-on, the game it adds to.
  • GameInstallLocation InstallTo { get; init; }
  • bool ShowInLibrary { get; init; }
  • bool Singleplayer { get; init; }
  • bool Published { get; init; }
    • Whether launchers are offered the game.
  • KeyAllocationMethod KeyAllocationMethod { get; init; }
  • string ValidKeyRegex { get; init; }
  • Guid? EngineId { get; init; }
    • The game's engine, an Engine record.
  • DateTime CreatedOn { get; init; }
    • Set by the server; ignored when writing.
  • DateTime UpdatedOn { get; init; }
    • Set by the server; ignored when writing.

GameVersionInfo​

record — LANCommander.Server.Plugins.GameVersionInfo

A version of a game. Each version has its own archive, actions, scripts, save paths, option schema and redistributables; the latest one is what an edit to the game changes.

Properties

  • Guid Id { get; init; }
  • Guid GameId { get; init; }
  • string Version { get; init; }
    • The version number, e.g. 1.2.0.
  • string Changelog { get; init; }
  • int SortOrder { get; init; }
    • Position among the game's versions; the highest is the latest.
  • bool Published { get; init; }
    • Whether launchers are offered the version.
  • string OptionSchema { get; init; }
    • The options the version's install offers, as an option schema, or null.
  • Guid? ArchiveId { get; init; }
    • The version's archive, if it has one. Set by the server; ignored when writing.
  • DateTime CreatedOn { get; init; }
    • Set by the server; ignored when writing.

GameVersionRedistributableInfo​

record — LANCommander.Server.Plugins.GameVersionRedistributableInfo

A redistributable required by a game version, with that version's option values as JSON.

Properties

  • RedistributableInfo Redistributable { get; init; }
  • string Options { get; init; }

KeyInfo​

record — LANCommander.Server.Plugins.KeyInfo

A CD key for a game, handed out to players as the game's allocation method decides.

Properties

  • Guid Id { get; init; }
  • string Value { get; init; }
  • KeyAllocationMethod? AllocationMethod { get; init; }
    • How the key was claimed, or null while it is free. Set by the server; ignored when writing.
  • Guid? ClaimedByUserId { get; init; }
    • Set by the server; ignored when writing.
  • string ClaimedByMacAddress { get; init; }
    • Set by the server; ignored when writing.
  • string ClaimedByIpv4Address { get; init; }
    • Set by the server; ignored when writing.
  • string ClaimedByComputerName { get; init; }
    • Set by the server; ignored when writing.
  • DateTime? ClaimedOn { get; init; }
    • Set by the server; ignored when writing.
  • RecordOwner Owner { get; init; }
    • Set by the server; ignored when writing.

MediaGrabberItem​

record — LANCommander.Server.Plugins.MediaGrabberItem

One result of an IMediaGrabberExtension search.

Properties

  • string Id { get; init; }
    • Identifies the result within the source.
  • MediaType Type { get; init; }
    • The kind of media the result is.
  • string SourceUrl { get; init; }
    • Where the server downloads the media from.
  • string ThumbnailUrl { get; init; }
    • A preview to show in the search results; may be the same as SourceUrl.
  • string MimeType { get; init; }
    • The MIME type of the media at SourceUrl.
  • string Group { get; init; }
    • Results with the same group are shown together, e.g. under the game they belong to.
  • string Name { get; init; }
    • The result's own title where the source has one, e.g. a video's name.
  • TimeSpan? Duration { get; init; }
    • Running time, for videos.
  • string Resolution { get; init; }
    • A video's frame height as people say it ("1080p"), where the source knows it.

MediaInfo​

record — LANCommander.Server.Plugins.MediaInfo

An image, video or other file shown for a game, such as its cover or icon.

Properties

  • Guid Id { get; init; }
  • string Name { get; init; }
  • MediaType Type { get; init; }
  • string SourceUrl { get; init; }
    • Where the file came from, if anywhere.
  • string MimeType { get; init; }
  • int SortOrder { get; init; }
  • string Crc32 { get; init; }
    • The file's checksum. Set by the server; ignored when writing.
  • Guid StorageLocationId { get; init; }
    • Set by the server; ignored when writing.
  • Guid GameId { get; init; }
    • Set by the server; ignored when writing.

MetadataGame​

record — LANCommander.Server.Plugins.MetadataGame

A game returned by one of the server's configured metadata providers.

Properties

  • string Id { get; init; }
    • The provider's game id, used to fetch the full metadata.
  • Game Data { get; init; }
    • The metadata supplied by the provider, not an imported server game.

MetadataSearchPage​

record — LANCommander.Server.Plugins.MetadataSearchPage

A page of metadata search results.

Properties

  • IReadOnlyList<MetadataGame> Results { get; init; }
  • bool More { get; init; }
  • int Limit { get; init; }
  • int Offset { get; init; }

MultiplayerModeInfo​

record — LANCommander.Server.Plugins.MultiplayerModeInfo

A way a game can be played with others.

Properties

  • Guid Id { get; init; }
  • MultiplayerType Type { get; init; }
  • NetworkProtocol NetworkProtocol { get; init; }
  • string Description { get; init; }
  • int MinPlayers { get; init; }
  • int MaxPlayers { get; init; }
  • int Spectators { get; init; }
  • RecordOwner Owner { get; init; }
    • Set by the server; ignored when writing.

PackageImportResult​

record — LANCommander.Server.Plugins.PackageImportResult

The outcome of an import run by IPackageImporter.

Properties

  • Guid RecordId { get; init; }
    • Id of the record the import created or updated.
  • ManifestType ManifestType { get; init; }
    • The kind of record the package held.
  • int ImportedCount { get; init; }
    • Number of records imported.

PluginAccessAttribute​

attribute — LANCommander.Server.Plugins.PluginAccessAttribute

Declares who may reach a plugin-contributed routable component.

Properties

  • PluginAccessPolicy Policy { get; }
    • The policy the server enforces for the decorated component.

PluginAccessPolicy​

class — LANCommander.Server.Plugins.PluginAccessPolicy

Describes who may reach a plugin-contributed surface, such as a page or a navigation entry.

Properties

  • PluginAccessLevel Level { get; }
    • The kind of requirement this policy enforces.
  • IReadOnlyList<string> RequiredRoles { get; }
    • The roles accepted when Level is Role. Empty for every other level.

Methods

  • PluginAccessPolicy RequireRoles(string[] roles)
    • Allows members of any of the supplied server-defined roles. Administrators also qualify.
  • bool IsSatisfiedBy(ClaimsPrincipal user)
    • Determines whether user satisfies this policy.

RedistributableInfo​

record — LANCommander.Server.Plugins.RedistributableInfo

Software games need installed alongside them, such as a runtime. Games link to redistributables through SetLinksAsync, or a game package's manifest.

Properties

  • Guid Id { get; init; }
    • Empty when adding a redistributable, to have the server choose one.
  • string Name { get; init; }
  • string Description { get; init; }
  • string Notes { get; init; }
  • string OptionSchema { get; init; }
    • The options games can pass it, as an option schema, or null.
  • string Version { get; init; }
    • The version of the newest archive, if any. Set by the server; ignored when writing.
  • DateTime CreatedOn { get; init; }
    • Set by the server; ignored when writing.
  • DateTime UpdatedOn { get; init; }
    • Set by the server; ignored when writing.

SavePathInfo​

record — LANCommander.Server.Plugins.SavePathInfo

A file, folder or registry path where a game keeps its saves.

Properties

  • Guid Id { get; init; }
  • SavePathType Type { get; init; }
  • string Path { get; init; }
  • string WorkingDirectory { get; init; }
  • bool IsRegex { get; init; }
    • Whether Path is a regular expression.
  • RuntimePlatform Platforms { get; init; }
    • The platforms the path applies to.
  • RecordOwner Owner { get; init; }
    • Set by the server; ignored when writing.

ScriptInfo​

record — LANCommander.Server.Plugins.ScriptInfo

A PowerShell script run at a point in the life of a game, redistributable, tool or server.

Properties

  • Guid Id { get; init; }
  • string Name { get; init; }
  • string Description { get; init; }
  • ScriptType Type { get; init; }
    • When the script runs, e.g. on install.
  • string Contents { get; init; }
  • bool RequiresAdmin { get; init; }
  • RuntimePlatform Platforms { get; init; }
    • The platforms the script runs on.
  • RecordOwner Owner { get; init; }
    • Set by the server; ignored when writing.

ServerConsoleInfo​

record — LANCommander.Server.Plugins.ServerConsoleInfo

A log file or RCON connection the LANCommander server shows for a game server.

Properties

  • Guid Id { get; init; }
  • Guid ServerId { get; init; }
    • Set by the server; ignored when writing.
  • string Name { get; init; }
  • ServerConsoleType Type { get; init; }
  • string Path { get; init; }
    • For a log file console: the file.
  • string Host { get; init; }
    • For an RCON console: the host to connect to.
  • int? Port { get; init; }
    • For an RCON console: the port to connect to.
  • string Password { get; init; }
    • For an RCON console: the password.

ServerHttpPathInfo​

record — LANCommander.Server.Plugins.ServerHttpPathInfo

A folder of the game server the LANCommander server serves over HTTP.

Properties

  • Guid Id { get; init; }
  • Guid ServerId { get; init; }
    • Set by the server; ignored when writing.
  • string LocalPath { get; init; }
    • The folder on disk.
  • string Path { get; init; }
    • The URL path it is served under.

ServerInfo​

record — LANCommander.Server.Plugins.ServerInfo

A dedicated game server the LANCommander server runs and monitors.

Properties

  • Guid Id { get; init; }
    • Empty when adding a server, to have the LANCommander server choose one.
  • string Name { get; init; }
  • Guid? GameId { get; init; }
    • The game the server is for, if any.
  • ServerHostEngine Engine { get; init; }
  • string Path { get; init; }
    • The executable to run.
  • string Arguments { get; init; }
  • string WorkingDirectory { get; init; }
  • string OnStartScriptPath { get; init; }
  • string OnStopScriptPath { get; init; }
  • bool UseShellExecute { get; init; }
  • ProcessTerminationMethod ProcessTerminationMethod { get; init; }
  • Guid? DockerHostId { get; init; }
    • For Docker: the Docker host.
  • string ContainerId { get; init; }
    • For Docker: the container.
  • Guid? RemoteHostId { get; init; }
    • For Remote: the LANCommander server that manages it.
  • Guid? RemoteServerId { get; init; }
    • For Remote: the server's id on that LANCommander server.
  • string Host { get; init; }
    • The address players connect to.
  • int Port { get; init; }
  • bool Autostart { get; init; }
  • ServerAutostartMethod AutostartMethod { get; init; }
  • int AutostartDelay { get; init; }
    • Seconds to wait before an automatic start.
  • DateTime CreatedOn { get; init; }
    • Set by the server; ignored when writing.
  • DateTime UpdatedOn { get; init; }
    • Set by the server; ignored when writing.

ServerNavigationAnchor​

class — LANCommander.Server.Plugins.ServerNavigationAnchor

Special values for After. Any other value is the route of a built-in link, or a ServerNavigationSection naming a built-in group.

ServerNavigationSection​

class — LANCommander.Server.Plugins.ServerNavigationSection

Identifiers of the server navigation sections a plugin entry can be placed in through Section. A group's identifier is also the After anchor that places an entry after the group.

StorageLocationInfo​

record — LANCommander.Server.Plugins.StorageLocationInfo

A storage location on the server.

Properties

  • Guid Id { get; init; }
    • Id to pass back to the server, for example as an import's storage location.
  • string Path { get; init; }
    • Where the location is on the server's file system.
  • StorageLocationType Type { get; init; }
    • What the location stores.
  • bool Default { get; init; }
    • Whether the server uses this location when none is chosen.

TaxonomyInfo​

record — LANCommander.Server.Plugins.TaxonomyInfo

A taxonomy record on the server.

Properties

  • Guid Id { get; init; }
  • TaxonomyKind Kind { get; init; }
  • string Name { get; init; }

ToolInfo​

record — LANCommander.Server.Plugins.ToolInfo

A program players can install alongside the games that use it, such as a mod manager.

Properties

  • Guid Id { get; init; }
    • Empty when adding a tool, to have the server choose one.
  • string Name { get; init; }
  • string Description { get; init; }
  • string Notes { get; init; }
  • bool AlwaysInstall { get; init; }
    • Whether the tool is installed with its games without asking.
  • DateTime CreatedOn { get; init; }
    • Set by the server; ignored when writing.
  • DateTime UpdatedOn { get; init; }
    • Set by the server; ignored when writing.

RecordOwner​

struct — LANCommander.Server.Plugins.RecordOwner

The record a child record (an action, script, save path, archive…) belongs to.

Properties

  • RecordOwnerKind Kind { get; init; }
    • What kind of record the owner is.
  • Guid Id { get; init; }
    • The owner's id.
  • Guid? VersionId { get; init; }
    • For a game's actions, scripts and save paths, the game version they belong to. Null means the game's latest version. Ignored for every other kind of owner and child.

Methods

  • RecordOwner Game(Guid id, Guid? versionId)
    • A game, or one of its versions.
  • RecordOwner Redistributable(Guid id)
  • RecordOwner Tool(Guid id)
  • RecordOwner Server(Guid id)

GameLinkKind​

enum — LANCommander.Server.Plugins.GameLinkKind

The kinds of record a game is linked to, other than its engine.

ValueDescription
Categories = 0Category records.
Collections = 1Collection records.
Developers = 2Company records.
Genres = 3Genre records.
Platforms = 4Platform records.
Publishers = 5Company records.
Tags = 6Tag records.
Redistributables = 7Redistributables, which the game's latest version installs alongside it.
Tools = 8Tools.

PluginAccessLevel​

enum — LANCommander.Server.Plugins.PluginAccessLevel

The kind of requirement a PluginAccessPolicy enforces.

ValueDescription
Administrator = 0Only members of the built-in administrator role. This is the default for any plugin surface that does not declare a policy.
AuthenticatedUser = 1Any signed-in user. Anonymous visitors are always rejected.
Role = 2Members of specific server-defined roles. Administrators always qualify.

RecordOwnerKind​

enum — LANCommander.Server.Plugins.RecordOwnerKind

The kinds of record that own actions, scripts and the other child records.

ValueDescription
Game = 0
Redistributable = 1
Tool = 2
Server = 3

ServerHostEngine​

enum — LANCommander.Server.Plugins.ServerHostEngine

Where a game server runs.

ValueDescription
Local = 0A process on the LANCommander server's machine.
Docker = 1A Docker container.
Remote = 2A server managed by another LANCommander server.

TaxonomyKind​

enum — LANCommander.Server.Plugins.TaxonomyKind

The kinds of taxonomy record: named records games are linked to.

ValueDescription
Category = 0
Collection = 1
Company = 2A developer or publisher.
Engine = 3
Genre = 4
Platform = 5
Tag = 6