feat(command): Add configurable timeout options for command execution

src/ModularPipelines/Context/Command.cs

@@ -301,15 +301,25 @@ private async Task<CommandResult> Of(CliWrap.Command command,
 
         var inputToLog = options.InputLoggingManipulator == null ? command.ToString() : options.InputLoggingManipulator(command.ToString());
 
+        // Only create timeout token if ExecutionTimeout is specified to avoid unnecessary allocations
+        using var timeoutCancellationToken = options.ExecutionTimeout.HasValue
+            ? new CancellationTokenSource(options.ExecutionTimeout.Value)
+            : null;
+
+        // Link the timeout token with the passed cancellation token, or just wrap the original if no timeout
+        using var linkedCancellationToken = timeoutCancellationToken != null
+            ? CancellationTokenSource.CreateLinkedTokenSource(timeoutCancellationToken.Token, cancellationToken)
+            : CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+
         using var forcefulCancellationToken = new CancellationTokenSource();
 
-        await using var registration = cancellationToken.Register(() =>
+        await using var registration = linkedCancellationToken.Token.Register(() =>
         {
             try
             {
                 if (forcefulCancellationToken.Token.CanBeCanceled)
                 {
-                    forcefulCancellationToken.CancelAfter(TimeSpan.FromSeconds(30));
+                    forcefulCancellationToken.CancelAfter(options.GracefulShutdownTimeout);
                 }
             }
             catch (ObjectDisposedException)
@@ -324,7 +334,7 @@ private async Task<CommandResult> Of(CliWrap.Command command,
                 .WithStandardOutputPipe(PipeTarget.ToStringBuilder(standardOutputStringBuilder))
                 .WithStandardErrorPipe(PipeTarget.ToStringBuilder(standardErrorStringBuilder))
                 .WithValidation(CommandResultValidation.None)
-                .ExecuteAsync(forcefulCancellationToken.Token, cancellationToken).ConfigureAwait(false);
+                .ExecuteAsync(forcefulCancellationToken.Token, linkedCancellationToken.Token).ConfigureAwait(false);
 
             standardOutput = options.OutputLoggingManipulator == null ? standardOutputStringBuilder.ToString() : options.OutputLoggingManipulator(standardOutputStringBuilder.ToString());
             standardError = options.OutputLoggingManipulator == null ? standardErrorStringBuilder.ToString() : options.OutputLoggingManipulator(standardErrorStringBuilder.ToString());

src/ModularPipelines/Options/CommandLineOptions.cs

@@ -60,5 +60,26 @@ public record CommandLineOptions
     /// </summary>
     public bool ThrowOnNonZeroExitCode { get; init; } = true;
 
+    /// <summary>
+    /// Gets or sets the maximum time allowed for the command to complete.
+    /// </summary>
+    /// <remarks>
+    /// <para>When set, the command will be cancelled if it exceeds this duration.</para>
+    /// <para>If the command does not complete within the timeout, a <see cref="System.OperationCanceledException"/> will be thrown.</para>
+    /// <para>If not set (null), the command will run until completion or until the passed cancellation token is cancelled.</para>
+    /// </remarks>
+    public TimeSpan? ExecutionTimeout { get; init; }
+
+    /// <summary>
+    /// Gets or sets the time to wait for graceful shutdown before forcefully terminating the process.
+    /// </summary>
+    /// <remarks>
+    /// <para>When a command is cancelled (either via <see cref="ExecutionTimeout"/> or an external cancellation token),
+    /// the process is first asked to terminate gracefully. If it does not terminate within this duration,
+    /// it will be forcefully killed.</para>
+    /// <para>Default is 30 seconds.</para>
+    /// </remarks>
+    public TimeSpan GracefulShutdownTimeout { get; init; } = TimeSpan.FromSeconds(30);
+
     internal bool InternalDryRun { get; set; }
 }