Remove legacy IPC aliases

mamoreau-devolutions · Copilot · mamoreau-devolutions · commit f691b10cd16d · 2026-05-06T11:15:02.000-04:00
Drop the pre-merge background-api and automation compatibility layer so the branch exposes only the final IPC argument names, endpoint metadata path, and public verb-based CLI surface.

Co-authored-by: Copilot &lt;223556219+Copilot@users.noreply.github.com&gt;
diff --git a/docs/CLI.md b/docs/CLI.md
@@ -51,7 +51,6 @@ Related environment variables:
   - `--source` maps to `--package-source`
 - Boolean options use explicit values such as `--enabled true` or `--wait false`.
 - `--detach` is shorthand for asynchronous package operations (`--wait false`).
-- The internal `--automation ...` mode still exists for compatibility, but the public CLI is the verb-based surface documented here.
 
 ## Command reference
 
diff --git a/src/UniGetUI.Interface.IpcApi/IpcCliCommandRunner.cs b/src/UniGetUI.Interface.IpcApi/IpcCliCommandRunner.cs
@@ -15,8 +15,6 @@ public enum IpcCliExitCode
 
 public static class IpcCliCommandRunner
 {
-    public const string LegacyCommandArgument = "--automation";
-
     public static async Task<int> RunAsync(
         IReadOnlyList<string> args,
         TextWriter output,
@@ -30,7 +28,11 @@ TextWriter error
             return (int)IpcCliExitCode.Success;
         }
 
-        if (parseResult.Status != IpcCliParseStatus.Success || parseResult.EffectiveArgs is null)
+        if (
+            parseResult.Status != IpcCliParseStatus.Success
+            || parseResult.Command is null
+            || parseResult.EffectiveArgs is null
+        )
         {
             return await WriteErrorAsync(
                 output,
@@ -40,8 +42,7 @@ TextWriter error
         }
 
         args = parseResult.EffectiveArgs;
-        int basePos = args.ToList().IndexOf(LegacyCommandArgument);
-        string subcommand = args[basePos + 1].Trim().ToLowerInvariant();
+        string subcommand = parseResult.Command.Trim().ToLowerInvariant();
 
         try
         {
diff --git a/src/UniGetUI.Interface.IpcApi/IpcCliSyntax.cs b/src/UniGetUI.Interface.IpcApi/IpcCliSyntax.cs
@@ -10,6 +10,7 @@ internal enum IpcCliParseStatus
 
 internal sealed record IpcCliParseResult(
     IpcCliParseStatus Status,
+    string? Command = null,
     string[]? EffectiveArgs = null,
     string? Message = null
 );
@@ -91,8 +92,8 @@ internal static IpcCliParseResult Parse(IReadOnlyList<string> args)
             return new(IpcCliParseStatus.Help);
         }
 
-        string? legacyCommand = TryMapLegacyCommand(path, out List<string> injectedArgs);
-        if (legacyCommand is null)
+        string? command = TryMapCommand(path, out List<string> injectedArgs);
+        if (command is null)
         {
             return new(
                 IpcCliParseStatus.NotIpcCommand,
@@ -109,17 +110,12 @@ internal static IpcCliParseResult Parse(IReadOnlyList<string> args)
             }
         }
 
-        RewriteArgumentAliases(legacyCommand, remainingArgs);
+        RewriteArgumentAliases(command, remainingArgs);
 
         return new(
             IpcCliParseStatus.Success,
-            [
-                .. leadingGlobalArgs,
-                IpcCliCommandRunner.LegacyCommandArgument,
-                legacyCommand,
-                .. injectedArgs,
-                .. remainingArgs,
-            ]
+            Command: command,
+            EffectiveArgs: [.. leadingGlobalArgs, .. injectedArgs, .. remainingArgs]
         );
     }
 
@@ -189,7 +185,7 @@ private static string NormalizeToken(string token)
         };
     }
 
-    private static string? TryMapLegacyCommand(string[] path, out List<string> injectedArgs)
+    private static string? TryMapCommand(string[] path, out List<string> injectedArgs)
     {
         injectedArgs = [];
 
@@ -297,20 +293,20 @@ private static string NormalizeToken(string token)
     }
 
     private static string Inject(
-        string legacyCommand,
+        string command,
         List<string> injectedArgs,
         params string[] args
     )
     {
         injectedArgs.AddRange(args);
-        return legacyCommand;
+        return command;
     }
 
-    private static void RewriteArgumentAliases(string legacyCommand, List<string> args)
+    private static void RewriteArgumentAliases(string command, List<string> args)
     {
         for (int i = 0; i < args.Count; i++)
         {
-            args[i] = legacyCommand switch
+            args[i] = command switch
             {
                 "get-operation" or "get-operation-output" or "wait-operation" or "cancel-operation"
                     or "retry-operation" or "reorder-operation" or "forget-operation"
diff --git a/src/UniGetUI.Interface.IpcApi/IpcTransport.cs b/src/UniGetUI.Interface.IpcApi/IpcTransport.cs
@@ -28,23 +28,15 @@ string NamedPipeName
     public const string TransportArgument = "--ipc-api-transport";
     public const string TcpPortArgument = "--ipc-api-port";
     public const string NamedPipeArgument = "--ipc-api-pipe-name";
-    public const string LegacyTransportArgument = "--background-api-transport";
-    public const string LegacyTcpPortArgument = "--background-api-port";
-    public const string LegacyNamedPipeArgument = "--background-api-pipe-name";
-
     public const string CliTransportArgument = "--transport";
     public const string CliTcpPortArgument = "--tcp-port";
     public const string CliNamedPipeArgument = "--pipe-name";
 
     public const string TransportEnvironmentVariable = "UNIGETUI_IPC_API_TRANSPORT";
     public const string TcpPortEnvironmentVariable = "UNIGETUI_IPC_API_PORT";
     public const string NamedPipeEnvironmentVariable = "UNIGETUI_IPC_API_PIPE_NAME";
-    public const string LegacyTransportEnvironmentVariable = "UNIGETUI_API_TRANSPORT";
-    public const string LegacyTcpPortEnvironmentVariable = "UNIGETUI_API_PORT";
-    public const string LegacyNamedPipeEnvironmentVariable = "UNIGETUI_API_PIPE_NAME";
 
-    private const string EndpointMetadataDirectoryName = "BackgroundApiEndpoints";
-    private const string LegacyEndpointMetadataFileName = "BackgroundApiEndpoint.json";
+    private const string EndpointMetadataDirectoryName = "IpcApiEndpoints";
 
     public Uri BaseAddress =>
         TransportKind == IpcTransportKind.NamedPipe
@@ -72,9 +64,6 @@ string NamedPipeName
     public static string EndpointMetadataDirectoryPath =>
         Path.Join(CoreData.UniGetUIUserConfigurationDirectory, EndpointMetadataDirectoryName);
 
-    private static string LegacyEndpointMetadataPath =>
-        Path.Join(CoreData.UniGetUIUserConfigurationDirectory, LegacyEndpointMetadataFileName);
-
     public static IpcTransportOptions LoadForServer(IReadOnlyList<string>? args = null)
     {
         args ??= Environment.GetCommandLineArgs();
@@ -104,7 +93,6 @@ public static IpcTransportOptions LoadForClient(IReadOnlyList<string>? args = nu
     public void Persist(string sessionId, string token, string sessionKind, int processId)
     {
         Directory.CreateDirectory(EndpointMetadataDirectoryPath);
-        DeleteLegacyPersistedMetadata();
 
         var metadata = new IpcEndpointRegistration
         {
@@ -141,8 +129,6 @@ public static void DeletePersistedMetadata(string? sessionId = null)
                 {
                     Directory.Delete(EndpointMetadataDirectoryPath, recursive: true);
                 }
-
-                DeleteLegacyPersistedMetadata();
                 return;
             }
 
@@ -191,48 +177,6 @@ internal static IReadOnlyList<IpcEndpointRegistration> LoadPersistedRegistration
             Logger.Warn(ex);
         }
 
-        try
-        {
-            if (File.Exists(LegacyEndpointMetadataPath))
-            {
-                var legacyMetadata = JsonSerializer.Deserialize<IpcStatus>(
-                    File.ReadAllText(LegacyEndpointMetadataPath),
-                    new JsonSerializerOptions(SerializationHelpers.DefaultOptions)
-                    {
-                        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
-                        WriteIndented = true,
-                    }
-                );
-
-                if (legacyMetadata is not null)
-                {
-                    registrations.Add(
-                        new IpcEndpointRegistration
-                        {
-                            SessionId = "legacy",
-                            SessionKind = GuiSessionKind,
-                            Token = string.Empty,
-                            Transport = ParseTransport(
-                                legacyMetadata.Transport,
-                                Default.TransportKind
-                            ),
-                            TcpPort = legacyMetadata.TcpPort > 0
-                                ? legacyMetadata.TcpPort
-                                : DefaultTcpPort,
-                            NamedPipeName = string.IsNullOrWhiteSpace(legacyMetadata.NamedPipeName)
-                                ? DefaultNamedPipeName
-                                : legacyMetadata.NamedPipeName,
-                        }
-                    );
-                }
-            }
-        }
-        catch (Exception ex)
-        {
-            Logger.Warn("Could not load legacy IPC API endpoint metadata");
-            Logger.Warn(ex);
-        }
-
         return registrations;
     }
 
@@ -270,21 +214,9 @@ internal static bool HasExplicitClientOverride(IReadOnlyList<string> args)
             || args.Contains(TransportArgument)
             || args.Contains(TcpPortArgument)
             || args.Contains(NamedPipeArgument)
-            || args.Contains(LegacyTransportArgument)
-            || args.Contains(LegacyTcpPortArgument)
-            || args.Contains(LegacyNamedPipeArgument)
             || !string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable(TransportEnvironmentVariable))
             || !string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable(TcpPortEnvironmentVariable))
-            || !string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable(NamedPipeEnvironmentVariable))
-            || !string.IsNullOrWhiteSpace(
-                Environment.GetEnvironmentVariable(LegacyTransportEnvironmentVariable)
-            )
-            || !string.IsNullOrWhiteSpace(
-                Environment.GetEnvironmentVariable(LegacyTcpPortEnvironmentVariable)
-            )
-            || !string.IsNullOrWhiteSpace(
-                Environment.GetEnvironmentVariable(LegacyNamedPipeEnvironmentVariable)
-            );
+            || !string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable(NamedPipeEnvironmentVariable));
     }
 
     private static string GetEndpointMetadataPath(string sessionId)
@@ -309,29 +241,26 @@ IpcTransportOptions fallback
         string? transportValue = GetArgumentValue(
             args,
             includeCliAliases
-                ? [CliTransportArgument, TransportArgument, LegacyTransportArgument]
-                : [TransportArgument, LegacyTransportArgument]
+                ? [CliTransportArgument, TransportArgument]
+                : [TransportArgument]
         );
         transportValue ??= Environment.GetEnvironmentVariable(TransportEnvironmentVariable);
-        transportValue ??= Environment.GetEnvironmentVariable(LegacyTransportEnvironmentVariable);
 
         string? portValue = GetArgumentValue(
             args,
             includeCliAliases
-                ? [CliTcpPortArgument, TcpPortArgument, LegacyTcpPortArgument]
-                : [TcpPortArgument, LegacyTcpPortArgument]
+                ? [CliTcpPortArgument, TcpPortArgument]
+                : [TcpPortArgument]
         );
         portValue ??= Environment.GetEnvironmentVariable(TcpPortEnvironmentVariable);
-        portValue ??= Environment.GetEnvironmentVariable(LegacyTcpPortEnvironmentVariable);
 
         string? pipeValue = GetArgumentValue(
             args,
             includeCliAliases
-                ? [CliNamedPipeArgument, NamedPipeArgument, LegacyNamedPipeArgument]
-                : [NamedPipeArgument, LegacyNamedPipeArgument]
+                ? [CliNamedPipeArgument, NamedPipeArgument]
+                : [NamedPipeArgument]
         );
         pipeValue ??= Environment.GetEnvironmentVariable(NamedPipeEnvironmentVariable);
-        pipeValue ??= Environment.GetEnvironmentVariable(LegacyNamedPipeEnvironmentVariable);
 
         var transport = ParseTransport(transportValue, fallback.TransportKind);
         int tcpPort = ParseTcpPort(portValue, fallback.TcpPort);
@@ -340,14 +269,6 @@ IpcTransportOptions fallback
         return new IpcTransportOptions(transport, tcpPort, pipeName);
     }
 
-    private static void DeleteLegacyPersistedMetadata()
-    {
-        if (File.Exists(LegacyEndpointMetadataPath))
-        {
-            File.Delete(LegacyEndpointMetadataPath);
-        }
-    }
-
     private static IpcTransportKind ParseTransport(
         string? value,
         IpcTransportKind fallback
diff --git a/src/UniGetUI.Tests/IpcCliSyntaxTests.cs b/src/UniGetUI.Tests/IpcCliSyntaxTests.cs
diff --git a/src/UniGetUI/MainWindow.xaml.cs b/src/UniGetUI/MainWindow.xaml.cs

Original file line number	Diff line number	Diff line change
`@@ -15,8 +15,6 @@ public enum IpcCliExitCode`
`15`	`15`
`16`	`16`	`public static class IpcCliCommandRunner`
`17`	`17`	`{`
`18`		`- public const string LegacyCommandArgument = "--automation";`
`19`		`-`
`20`	`18`	`public static async Task<int> RunAsync(`
`21`	`19`	`IReadOnlyList<string> args,`
`22`	`20`	`TextWriter output,`
`@@ -30,7 +28,11 @@ TextWriter error`
`30`	`28`	`return (int)IpcCliExitCode.Success;`
`31`	`29`	`}`
`32`	`30`
`33`		`- if (parseResult.Status != IpcCliParseStatus.Success \|\| parseResult.EffectiveArgs is null)`
	`31`	`+ if (`
	`32`	`+ parseResult.Status != IpcCliParseStatus.Success`
	`33`	`+ \|\| parseResult.Command is null`
	`34`	`+ \|\| parseResult.EffectiveArgs is null`
	`35`	`+ )`
`34`	`36`	`{`
`35`	`37`	`return await WriteErrorAsync(`
`36`	`38`	`output,`
`@@ -40,8 +42,7 @@ TextWriter error`
`40`	`42`	`}`
`41`	`43`
`42`	`44`	`args = parseResult.EffectiveArgs;`
`43`		`- int basePos = args.ToList().IndexOf(LegacyCommandArgument);`
`44`		`- string subcommand = args[basePos + 1].Trim().ToLowerInvariant();`
	`45`	`+ string subcommand = parseResult.Command.Trim().ToLowerInvariant();`
`45`	`46`
`46`	`47`	`try`
`47`	`48`	`{`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@ internal enum IpcCliParseStatus`
`10`	`10`
`11`	`11`	`internal sealed record IpcCliParseResult(`
`12`	`12`	`IpcCliParseStatus Status,`
	`13`	`+ string? Command = null,`
`13`	`14`	`string[]? EffectiveArgs = null,`
`14`	`15`	`string? Message = null`
`15`	`16`	`);`
`@@ -91,8 +92,8 @@ internal static IpcCliParseResult Parse(IReadOnlyList<string> args)`
`91`	`92`	`return new(IpcCliParseStatus.Help);`
`92`	`93`	`}`
`93`	`94`
`94`		`- string? legacyCommand = TryMapLegacyCommand(path, out List<string> injectedArgs);`
`95`		`- if (legacyCommand is null)`
	`95`	`+ string? command = TryMapCommand(path, out List<string> injectedArgs);`
	`96`	`+ if (command is null)`
`96`	`97`	`{`
`97`	`98`	`return new(`
`98`	`99`	`IpcCliParseStatus.NotIpcCommand,`
`@@ -109,17 +110,12 @@ internal static IpcCliParseResult Parse(IReadOnlyList<string> args)`
`109`	`110`	`}`
`110`	`111`	`}`
`111`	`112`
`112`		`- RewriteArgumentAliases(legacyCommand, remainingArgs);`
	`113`	`+ RewriteArgumentAliases(command, remainingArgs);`
`113`	`114`
`114`	`115`	`return new(`
`115`	`116`	`IpcCliParseStatus.Success,`
`116`		`- [`
`117`		`- .. leadingGlobalArgs,`
`118`		`- IpcCliCommandRunner.LegacyCommandArgument,`
`119`		`- legacyCommand,`
`120`		`- .. injectedArgs,`
`121`		`- .. remainingArgs,`
`122`		`- ]`
	`117`	`+ Command: command,`
	`118`	`+ EffectiveArgs: [.. leadingGlobalArgs, .. injectedArgs, .. remainingArgs]`
`123`	`119`	`);`
`124`	`120`	`}`
`125`	`121`
`@@ -189,7 +185,7 @@ private static string NormalizeToken(string token)`
`189`	`185`	`};`
`190`	`186`	`}`
`191`	`187`
`192`		`- private static string? TryMapLegacyCommand(string[] path, out List<string> injectedArgs)`
	`188`	`+ private static string? TryMapCommand(string[] path, out List<string> injectedArgs)`
`193`	`189`	`{`
`194`	`190`	`injectedArgs = [];`
`195`	`191`
`@@ -297,20 +293,20 @@ private static string NormalizeToken(string token)`
`297`	`293`	`}`
`298`	`294`
`299`	`295`	`private static string Inject(`
`300`		`- string legacyCommand,`
	`296`	`+ string command,`
`301`	`297`	`List<string> injectedArgs,`
`302`	`298`	`params string[] args`
`303`	`299`	`)`
`304`	`300`	`{`
`305`	`301`	`injectedArgs.AddRange(args);`
`306`		`- return legacyCommand;`
	`302`	`+ return command;`
`307`	`303`	`}`
`308`	`304`
`309`		`- private static void RewriteArgumentAliases(string legacyCommand, List<string> args)`
	`305`	`+ private static void RewriteArgumentAliases(string command, List<string> args)`
`310`	`306`	`{`
`311`	`307`	`for (int i = 0; i < args.Count; i++)`
`312`	`308`	`{`
`313`		`- args[i] = legacyCommand switch`
	`309`	`+ args[i] = command switch`
`314`	`310`	`{`
`315`	`311`	`"get-operation" or "get-operation-output" or "wait-operation" or "cancel-operation"`
`316`	`312`	`or "retry-operation" or "reorder-operation" or "forget-operation"`