✨ Add option to set original file name when encrypting a file #84

Author: xecrets

src/Xecrets.Cli/Operation/EncryptToOperation.cs

@@ -56,21 +56,31 @@ public Task<Status> DryAsync(Parameters parameters)
         IStandardIoDataStore fromStore = New<IStandardIoDataStore>(parameters.Arg1);
         if (fromStore.IsStdIo && !fromStore.IsNamedStdIo)
         {
-            return Task.FromResult(new Status(XfStatusCode.InvalidOption, "Encryption is not supported from an unnamed standard input stream."));
+            return Task.FromResult(new Status(XfStatusCode.InvalidOption,
+                "Encryption is not supported from an unnamed standard input stream."));
         }
 
         if (!New<IFileVerify>().CanReadFromFile(fromStore))
         {
-            return Task.FromResult(new Status(XfStatusCode.CannotRead, "Can't read from '{0}'.".Format(fromStore.Name)));
+            return Task.FromResult(new Status(XfStatusCode.CannotRead,
+                "Can't read from '{0}'.".Format(fromStore.Name)));
         }
         if (!fromStore.IsEncryptable)
         {
-            return Task.FromResult(new Status(XfStatusCode.FileUnavailable, "Encryption of '{0}' is not supported, it may be a system file or hidden.".Format(parameters.CurrentOp.Arg1)));
+            return Task.FromResult(new Status(XfStatusCode.FileUnavailable,
+                "Encryption of '{0}' is not supported, it may be a system file or hidden.".Format(parameters.CurrentOp.Arg1)));
+        }
+        if (fromStore.IsNamedStdIo && parameters.Arg3.Length > 0)
+        {
+            return Task.FromResult(new Status(XfStatusCode.InvalidOption,
+                $"Cannot specify both original name '{parameters.Arg3}' and stdin alias '{fromStore.AliasName}'."));
         }
 
         if (parameters.ProgrammaticUse && FileLargerThanLicenseLimit(fromStore))
         {
-            return Task.FromResult(new Status(XfStatusCode.Unlicensed, "'{0}' is too large for encryption. When using options for programmatic use, a valid maintenance subscription is required for files > 1 MB, or use a GPL build.".Format(parameters.CurrentOp.Arg1)));
+            return Task.FromResult(new Status(XfStatusCode.Unlicensed,
+                "'{0}' is too large for encryption. When using options for programmatic use, a valid maintenance " +
+                "subscription is required for files > 1 MB, or use a GPL build.".Format(parameters.CurrentOp.Arg1)));
         }
 
         parameters.TotalsTracker.AddWorkItem(fromStore.Length());
@@ -121,7 +131,8 @@ public Task<Status> RealAsync(Parameters parameters)
             {
                 toFreeStore = new AsciiArmorDataStore(toFreeStore);
             }
-            encryption.EncryptTo(toFreeStore, fromStore.AliasName,
+            string originalName = parameters.Arg3.Length > 0 ? parameters.Arg3 : fromStore.AliasName;
+            encryption.EncryptTo(toFreeStore, originalName,
                 parameters.Compress ? AxCryptOptions.EncryptWithCompression : AxCryptOptions.EncryptWithoutCompression);
         }
 

src/Xecrets.Cli/OptionsParser.cs

@@ -56,8 +56,8 @@ private ExportableOptionCollection BuildOptionSet(List<ParsedOp> parsed, List<st
                 "{encrypted} {clear}:Decrypt a file to the given file path.",
                 (ora, op, from, to) => ora.Add(op, from, to) },
             {"e|encrypt-to={}", XfOpCode.EncryptTo,
-                "{clear} {encrypted}:Encrypt a file to the given file path.",
-                (ora, op, from, to) => ora.Add(op, from, to) },
+                "{clear} {encrypted} [{original}]:Encrypt a file to given file path w/optional original name.",
+                (ora, op, from, to) => ora.AddOneRunning(op, from, to) },
             {"f|file=", XfOpCode.OptionsFromFile,
                 "{name}:Take options from a file (programmatic).",
                 (ora, op, name) => { ora.Add(op); RecursivelyParseFromFile(name, parsed, extra); } },
@@ -276,13 +276,26 @@ public void Add(XfOpCode opCode, string p1, string p2)
             RunningAction = _noop;
         }
 
+        public void Add(XfOpCode opCode, string p1, string p2, string p3)
+        {
+            _parsed.Add(new ParsedOp(opCode, p1, p2, p3));
+            RunningAction = _noop;
+        }
+
         public void AddOneRunning(XfOpCode opCode, string first)
         {
             var op = new ParsedOp(opCode, first);
             _parsed.Add(op);
             RunningAction = (s) => { op.Arguments.Add(s); RunningAction = _noop; };
         }
 
+        public void AddOneRunning(XfOpCode opCode, string first, string second)
+        {
+            ParsedOp op = new(opCode, first, second);
+            _parsed.Add(op);
+            RunningAction = (s) => { op.Arguments.Add(s); RunningAction = _noop; };
+        }
+
         public void AddManyRunning(XfOpCode opCode, string first)
         {
             var op = new ParsedOp(opCode, first);
@@ -291,6 +304,17 @@ public void AddManyRunning(XfOpCode opCode, string first)
         }
     }
 
+    private sealed class MyActionOption(string prototype, string description, int count,
+        Action<OptionValueCollection> action) : OptionBase(prototype, description, count)
+    {
+        protected override void OnParseComplete(OptionContext c)
+        {
+            ArgumentNullException.ThrowIfNull(c);
+
+            action(c.OptionValues);
+        }
+    }
+
     private class ExportableOptionCollection(Version cliVersion, RunningArguments ora) : OptionSetCollection
     {
         /// <summary>
@@ -331,6 +355,21 @@ public void Add(string prototype, XfOpCode opCode, string description, Action<Ru
             _ = Add(prototype, description, (p1, p2) => action(ora, opCode, p1, p2));
             Export.Add(new ExportableOption((int)opCode, prototype, string.Join(':', (description?.Split(':').Skip(1).ToArray() ?? []))));
         }
+
+        public void Add(string prototype, string description, Action<string, string, string> action)
+        {
+            ArgumentNullException.ThrowIfNull(action);
+            
+            OptionBase p = new MyActionOption(prototype, description, 3,
+                    delegate (OptionValueCollection v) { action(v[0], v[1], v[2]); });
+            Add(p);
+        }
+
+        public void Add(string prototype, XfOpCode opCode, string description, Action<RunningArguments, XfOpCode, string, string, string> action)
+        {
+            Add(prototype, description, (p1, p2, p3) => action(ora, opCode, p1, p2, p3));
+            Export.Add(new ExportableOption((int)opCode, prototype, string.Join(':', (description?.Split(':').Skip(1).ToArray() ?? []))));
+        }
     }
 
     private void RecursivleyParseArguments(IEnumerable<string> args, List<ParsedOp> parsedOps, List<string> extra)

src/Xecrets.Cli/ParsedOp.cs

@@ -44,4 +44,6 @@ public ParsedOp(XfOpCode opCode, bool flag)
     public string Arg1 { get { return Arguments.Count > 0 ? Arguments[0] : string.Empty; } }
 
     public string Arg2 { get { return Arguments.Count > 1 ? Arguments[1] : string.Empty; } }
+
+    public string Arg3 { get { return Arguments.Count > 2 ? Arguments[2] : string.Empty; } }
 }

src/Xecrets.Cli/Public/XfExportVersion.cs

@@ -37,5 +37,13 @@ namespace Xecrets.Cli.Public;
 /// </summary>
 public static class XfExportVersion
 {
-    public static Version CliVersion => new(2, 1);
+    /// <summary>
+    /// The version of the Xecrets Cli API.
+    /// </summary>
+    /// <remarks>
+    /// 2.0 -> 2024-09-26 Change parameter names to Arg1 and Arg2 in JSON logger
+    /// 2.1 -> 2024-10-01 Add --sigint posix signal handling
+    /// 2.2 -> 2024-10-09 Add third optional argument to --encrypt-to for original name
+    /// </remarks>
+    public static Version CliVersion => new(2, 2);
 }

src/Xecrets.Cli/Run/Parameters.cs

@@ -65,6 +65,8 @@ internal class Parameters(OptionsParser parser) : IDisposable
 
     public string Arg2 => CurrentOp.Arg2;
 
+    public string Arg3 => CurrentOp.Arg3;
+
     public KnownPublicKeys LoadedPublicKeys { get; } = new KnownPublicKeys();
 
     public OptionsParser Parser { get; } = parser;