Add azmcp-storage-blob-upload command (#960)

* Add azmcp-storage-blob-upload command

* Update return of upload tool and update tests

* Result uses full file path

* etag -> eTag

* Change tool name

Author: alzimmermsft

CHANGELOG.md

@@ -16,6 +16,7 @@ The Azure MCP Server updates automatically by default whenever a new release com
   - `azmcp-quota-usage-check` - Check Azure resource usage and quota information for specific resource types and regions.
 - Added support for listing Azure Function Apps via the command `azmcp-functionapp-list`. [[#863](https://github.com/Azure/azure-mcp/pull/863)]
 - Added support for importing existing certificates into Azure Key Vault via the command `azmcp-keyvault-certificate-import`. This command accepts PFX or PEM certificate data (file path, base64, or raw PEM) with optional password protection. [[#968](https://github.com/Azure/azure-mcp/issues/968)]
+- Added `azmcp-storage-blob-upload`: Upload a local file to an Azure Storage blob with the option to overwrite if the blob already exists. Returns blob metadata including name, container, uploaded file, last modified time, ETag, MD5 hash, and overwrite status. [[#960](https://github.com/Azure/azure-mcp/pull/960)]
 
 ### Breaking Changes
 

README.md

@@ -88,6 +88,7 @@ The Azure MCP Server supercharges your agents with Azure context. Here are some
 * "Create a new storage account in East US with Data Lake support"
 * "Show me the tables in my Storage account"
 * "Get details about my Storage container"
+* "Upload my file to the blob container"
 * "List paths in my Data Lake file system"
 * "List files and directories in my File Share"
 * "Send a message to my storage queue"
@@ -264,6 +265,7 @@ The Azure MCP Server supercharges your agents with Azure context. Here are some
 * List and create Storage accounts
 * Get detailed information about specific Storage accounts
 * Manage blob containers and blobs
+* Upload files to blob containers
 * List and query Storage tables
 * List paths in Data Lake file systems
 * Get container properties and metadata

areas/storage/src/AzureMcp.Storage/Commands/Blob/BlobUploadCommand.cs

@@ -0,0 +1,90 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using AzureMcp.Core.Commands;
+using AzureMcp.Storage.Options;
+using AzureMcp.Storage.Options.Blob;
+using AzureMcp.Storage.Services;
+using Microsoft.Extensions.Logging;
+
+namespace AzureMcp.Storage.Commands.Blob;
+
+public sealed class BlobUploadCommand(ILogger<BlobUploadCommand> logger) : BaseBlobCommand<BlobUploadOptions>
+{
+    private const string CommandTitle = "Upload Local File to Blob";
+    private readonly ILogger<BlobUploadCommand> _logger = logger;
+
+    // Define options from OptionDefinitions
+    private readonly Option<string> _localFilePathOption = StorageOptionDefinitions.LocalFilePath;
+    private readonly Option<bool> _overwriteOption = StorageOptionDefinitions.Overwrite;
+
+    public override string Name => "upload";
+
+    public override string Description =>
+        """
+        Uploads a local file to a blob in Azure Storage with the option to overwrite if the blob already exists.
+        Returns details about the uploaded blob including last modified time, ETag, and content hash.
+        """;
+
+    public override string Title => CommandTitle;
+
+    public override ToolMetadata Metadata => new()
+    {
+        Destructive = true,
+        ReadOnly = false
+    };
+
+    protected override void RegisterOptions(Command command)
+    {
+        base.RegisterOptions(command);
+        command.AddOption(_localFilePathOption);
+        command.AddOption(_overwriteOption);
+    }
+
+    protected override BlobUploadOptions BindOptions(ParseResult parseResult)
+    {
+        var options = base.BindOptions(parseResult);
+        options.LocalFilePath = parseResult.GetValueForOption(_localFilePathOption);
+        options.Overwrite = parseResult.GetValueForOption(_overwriteOption);
+        return options;
+    }
+
+    public override async Task<CommandResponse> ExecuteAsync(CommandContext context, ParseResult parseResult)
+    {
+        var options = BindOptions(parseResult);
+
+        try
+        {
+            if (!Validate(parseResult.CommandResult, context.Response).IsValid)
+            {
+                return context.Response;
+            }
+
+            var storageService = context.GetService<IStorageService>();
+
+            var result = await storageService.UploadBlob(
+                options.Account!,
+                options.Container!,
+                options.Blob!,
+                options.LocalFilePath!,
+                options.Overwrite ?? false,
+                options.Subscription!,
+                options.Tenant,
+                options.RetryPolicy);
+
+            context.Response.Results = ResponseResult.Create(result, StorageJsonContext.Default.BlobUploadResult);
+
+            _logger.LogInformation("Successfully uploaded file {LocalFilePath} to blob {Blob} in container {Container} (Overwrite: {Overwrite}).",
+                options.LocalFilePath, options.Blob, options.Container, options.Overwrite);
+
+            return context.Response;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error uploading file {LocalFilePath} to blob {Blob} in container {Container} (Overwrite {Overwrite}).",
+                options.LocalFilePath, options.Blob, options.Container, options.Overwrite);
+            HandleException(context, ex);
+            return context.Response;
+        }
+    }
+}

areas/storage/src/AzureMcp.Storage/Commands/StorageJsonContext.cs

@@ -11,11 +11,13 @@
 using AzureMcp.Storage.Commands.Queue.Message;
 using AzureMcp.Storage.Commands.Share.File;
 using AzureMcp.Storage.Commands.Table;
+using AzureMcp.Storage.Models;
 
 namespace AzureMcp.Storage.Commands;
 
 [JsonSerializable(typeof(BlobListCommand.BlobListCommandResult))]
 [JsonSerializable(typeof(BlobDetailsCommand.BlobDetailsCommandResult))]
+[JsonSerializable(typeof(BlobUploadResult))]
 [JsonSerializable(typeof(BatchSetTierCommand.BatchSetTierCommandResult))]
 [JsonSerializable(typeof(AccountListCommand.AccountListCommandResult), TypeInfoPropertyName = "AccountListCommandResult")]
 [JsonSerializable(typeof(AccountDetailsCommand.AccountDetailsCommandResult), TypeInfoPropertyName = "AccountDetailsCommandResult")]

areas/storage/src/AzureMcp.Storage/Models/BlobUploadResult.cs

@@ -0,0 +1,13 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace AzureMcp.Storage.Models;
+
+public record BlobUploadResult(
+    string Blob,
+    string Container,
+    string UploadedFile,
+    DateTimeOffset LastModified,
+    string ETag,
+    string? MD5Hash
+);

areas/storage/src/AzureMcp.Storage/Options/Blob/BlobUploadOptions.cs

@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Text.Json.Serialization;
+
+namespace AzureMcp.Storage.Options.Blob;
+
+public class BlobUploadOptions : BaseBlobOptions
+{
+    [JsonPropertyName(StorageOptionDefinitions.LocalFilePathName)]
+    public string? LocalFilePath { get; set; }
+
+    [JsonPropertyName(StorageOptionDefinitions.OverwriteName)]
+    public bool? Overwrite { get; set; }
+}

areas/storage/src/AzureMcp.Storage/Options/StorageOptionDefinitions.cs

@@ -22,6 +22,8 @@ public static class StorageOptionDefinitions
     public const string MessageContent = "message";
     public const string TimeToLiveInSeconds = "time-to-live-in-seconds";
     public const string VisibilityTimeoutInSeconds = "visibility-timeout-in-seconds";
+    public const string LocalFilePathName = "local-file-path";
+    public const string OverwriteName = "overwrite";
     public const string LocationName = "location";
     public const string SkuName = "sku";
     public const string KindName = "kind";
@@ -234,4 +236,20 @@ public static class StorageOptionDefinitions
     {
         IsRequired = false
     };
+
+    public static readonly Option<string> LocalFilePath = new(
+        $"--{LocalFilePathName}",
+        "The local file path to read content from or to write content to. This should be the full path to the file on your local system."
+    )
+    {
+        IsRequired = true
+    };
+
+    public static readonly Option<bool> Overwrite = new(
+        $"--{OverwriteName}",
+        "Whether to overwrite content if it already exists. Defaults to false."
+    )
+    {
+        IsRequired = false
+    };
 }

areas/storage/src/AzureMcp.Storage/Services/IStorageService.cs

@@ -120,4 +120,14 @@ Task<QueueMessageSendResult> SendQueueMessage(
         string subscription,
         string? tenant = null,
         RetryPolicyOptions? retryPolicy = null);
+
+    Task<BlobUploadResult> UploadBlob(
+        string account,
+        string container,
+        string blob,
+        string localFilePath,
+        bool overwrite,
+        string subscription,
+        string? tenant = null,
+        RetryPolicyOptions? retryPolicy = null);
 }

areas/storage/src/AzureMcp.Storage/Services/StorageService.cs

@@ -784,4 +784,39 @@ private static StorageSkuName ParseStorageSkuName(string sku)
             _ => throw new ArgumentException($"Invalid access tier '{accessTier}'. Valid values are: Hot, Cool")
         };
     }
+
+    public async Task<BlobUploadResult> UploadBlob(
+        string account,
+        string container,
+        string blob,
+        string localFilePath,
+        bool overwrite,
+        string subscription,
+        string? tenant = null,
+        RetryPolicyOptions? retryPolicy = null)
+    {
+        ValidateRequiredParameters(account, container, blob, localFilePath, subscription);
+
+        if (!File.Exists(localFilePath))
+        {
+            throw new FileNotFoundException($"Local file not found: {localFilePath}");
+        }
+
+        var blobServiceClient = await CreateBlobServiceClient(account, tenant, retryPolicy);
+        var blobContainerClient = blobServiceClient.GetBlobContainerClient(container);
+        var blobClient = blobContainerClient.GetBlobClient(blob);
+
+        // Upload the file
+        using var fileStream = File.OpenRead(localFilePath);
+        var response = await blobClient.UploadAsync(fileStream, overwrite);
+
+        return new BlobUploadResult(
+            Blob: blob,
+            Container: container,
+            UploadedFile: localFilePath,
+            LastModified: response.Value.LastModified,
+            ETag: response.Value.ETag.ToString(),
+            MD5Hash: response.Value.ContentHash != null ? Convert.ToBase64String(response.Value.ContentHash) : null
+        );
+    }
 }

areas/storage/src/AzureMcp.Storage/StorageSetup.cs

@@ -98,6 +98,7 @@ access storage resources accessible to the authenticated user.
 
         blobs.AddCommand("list", new BlobListCommand(loggerFactory.CreateLogger<BlobListCommand>()));
         blobs.AddCommand("details", new BlobDetailsCommand(loggerFactory.CreateLogger<BlobDetailsCommand>()));
+        blobs.AddCommand("upload", new BlobUploadCommand(loggerFactory.CreateLogger<BlobUploadCommand>()));
 
         batch.AddCommand("set-tier", new BatchSetTierCommand(loggerFactory.CreateLogger<BatchSetTierCommand>()));