chore(pin): sync with Kubo — options-based Add and typed List; tests + isolated node

PinApi: replace overloads with AddAsync(path, PinAddOptions); map Recursive/Name to recursive and name query params
PinApi: implement ListAsync(PinType) mapping to type=direct|indirect|recursive|all (omitted for all)
FileSystemApi: honor AddFileOptions.Pin (pin=true/false) when adding files
Tests: Add_WithName, Add_WithName_NonRecursive, List_WithType_All
TestFixture: start fresh Kubo via bootstrapper on 11501/18080; bootstrap peers; teardown

Author: Arlodotexe

src/CoreApi/FileSystemApi.cs

@@ -270,7 +270,7 @@ private string[] ToApiOptions(AddFileOptions? options)
                 opts.Add($"nocopy={options.NoCopy.ToString().ToLowerInvariant()}");
 
             if (options.Pin is not null)
-                opts.Add("pin=false");
+                opts.Add($"pin={options.Pin.ToString().ToLowerInvariant()}");
 
             if (options.Wrap is not null)
                 opts.Add($"wrap-with-directory={options.Wrap.ToString().ToLowerInvariant()}");

src/CoreApi/PinApi.cs

@@ -5,6 +5,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using System;
 
 namespace Ipfs.Http
 {
@@ -17,15 +18,22 @@ internal PinApi(IpfsClient ipfs)
             this.ipfs = ipfs;
         }
 
-        public async Task<IEnumerable<Cid>> AddAsync(string path, bool recursive = true, CancellationToken cancel = default(CancellationToken))
+        public async Task<IEnumerable<Cid>> AddAsync(string path, PinAddOptions options, CancellationToken cancel = default)
         {
-            var opts = "recursive=" + recursive.ToString().ToLowerInvariant();
-            var json = await ipfs.DoCommandAsync("pin/add", cancel, path, opts);
-            return ((JArray)JObject.Parse(json)["Pins"])
-                .Select(p => (Cid)(string)p);
+            options ??= new PinAddOptions();
+            var optList = new List<string>
+            {
+                "recursive=" + options.Recursive.ToString().ToLowerInvariant()
+            };
+            if (!string.IsNullOrEmpty(options.Name))
+            {
+                optList.Add("name=" + options.Name);
+            }
+            var json = await ipfs.DoCommandAsync("pin/add", cancel, path, optList.ToArray());
+            return ((JArray)JObject.Parse(json)["Pins"]) .Select(p => (Cid)(string)p);
         }
 
-        public async Task<IEnumerable<Cid>> ListAsync(CancellationToken cancel = default(CancellationToken))
+        public async Task<IEnumerable<Cid>> ListAsync(CancellationToken cancel = default)
         {
             var json = await ipfs.DoCommandAsync("pin/ls", cancel);
             var keys = (JObject)(JObject.Parse(json)["Keys"]);

test/CoreApi/PinApiTest.cs

@@ -1,4 +1,5 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Ipfs.CoreApi;
 using System.Linq;
 using System.Threading.Tasks;
 
@@ -16,14 +17,23 @@ public void List()
             Assert.IsTrue(pins.Count() > 0);
         }
 
+        [TestMethod]
+        public async Task List_WithType_All()
+        {
+            var ipfs = TestFixture.Ipfs;
+            var pins = await ipfs.Pin.ListAsync(PinType.All);
+            Assert.IsNotNull(pins);
+            Assert.IsTrue(pins.Count() > 0);
+        }
+
         [TestMethod]
         public async Task Add_Remove()
         {
             var ipfs = TestFixture.Ipfs;
             var result = await ipfs.FileSystem.AddTextAsync("I am pinned");
             var id = result.Id;
 
-            var pins = await ipfs.Pin.AddAsync(id);
+            var pins = await ipfs.Pin.AddAsync(id, new PinAddOptions { Recursive = true });
             Assert.IsTrue(pins.Any(pin => pin == id));
             var all = await ipfs.Pin.ListAsync();
             Assert.IsTrue(all.Any(pin => pin == id));
@@ -34,5 +44,38 @@ public async Task Add_Remove()
             Assert.IsFalse(all.Any(pin => pin == id));
         }
 
+        [TestMethod]
+        public async Task Add_WithName()
+        {
+            var ipfs = TestFixture.Ipfs;
+            var result = await ipfs.FileSystem.AddTextAsync("I am pinned with a name");
+            var id = result.Id;
+            var name = $"tdd-{System.Guid.NewGuid()}";
+
+            var pins = await ipfs.Pin.AddAsync(id, new PinAddOptions { Name = name, Recursive = true });
+            Assert.IsTrue(pins.Any(pin => pin == id));
+
+            var all = await ipfs.Pin.ListAsync();
+            Assert.IsTrue(all.Any(pin => pin == id));
+
+            // cleanup
+            await ipfs.Pin.RemoveAsync(id);
+        }
+
+        [TestMethod]
+        public async Task Add_WithName_NonRecursive()
+        {
+            var ipfs = TestFixture.Ipfs;
+            var result = await ipfs.FileSystem.AddTextAsync("I am pinned non-recursive with a name", new Ipfs.CoreApi.AddFileOptions { Pin = false });
+            var id = result.Id;
+            var name = $"tdd-nr-{System.Guid.NewGuid()}";
+
+            var pins = await ipfs.Pin.AddAsync(id, new PinAddOptions { Name = name, Recursive = false });
+            Assert.IsTrue(pins.Any(pin => pin == id));
+
+            // cleanup
+            await ipfs.Pin.RemoveAsync(id, recursive: false);
+        }
+
     }
 }

test/IpfsHttpClientTests.csproj

@@ -13,6 +13,7 @@
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.9.0" />
     <PackageReference Include="MSTest.TestAdapter" Version="3.3.1" />
     <PackageReference Include="MSTest.TestFramework" Version="3.3.1" />
+    <PackageReference Include="OwlCore.Kubo" Version="0.21.1" />
   </ItemGroup>
 
   <ItemGroup>

test/TestFixture.cs

@@ -1,14 +1,102 @@
-namespace Ipfs.Http
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using OwlCore.Kubo;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using OwlCore.Storage.System.IO;
+using OwlCore.Storage;
+using System.Diagnostics;
+
+namespace Ipfs.Http
 {
-    public static class TestFixture
+    [TestClass]
+    public class TestFixture
     {
-        /// <summary>
-        ///   Fiddler cannot see localhost traffic because .Net bypasses the network stack for localhost/127.0.0.1. 
-        ///   By using "127.0.0.1." (note trailing dot) fiddler will receive the traffic and if its not running
-        ///   the localhost will get it!
-        /// </summary>
-        //IpfsClient.DefaultApiUri = new Uri("http://127.0.0.1.:5001");
-
-        public static IpfsClient Ipfs = new IpfsClient();
+        // Publicly accessible client and API URI for tests.
+        public static IpfsClient Ipfs { get; private set; } = null!;
+        public static Uri? ApiUri { get; private set; }
+    private static KuboBootstrapper? Node;
+
+        [AssemblyInitialize]
+        public static void AssemblyInit(TestContext context)
+        {
+            try
+            {
+                OwlCore.Diagnostics.Logger.MessageReceived += (sender, args) => context.WriteLine(args.Message);
+
+                // Ensure the test runner has provided a deployment directory to use for working folders.
+                Assert.IsNotNull(context.DeploymentDirectory);
+
+                // Create a working folder and start a fresh Kubo node with default bootstrap peers.
+                var workingFolder = SafeCreateWorkingFolder(new SystemFolder(context.DeploymentDirectory), typeof(TestFixture).Namespace ?? "test").GetAwaiter().GetResult();
+
+                // Use non-default ports to avoid conflicts with any locally running node.
+                int apiPort = 11501;
+                int gatewayPort = 18080;
+
+                Node = CreateNodeAsync(workingFolder, "kubo-node", apiPort, gatewayPort).GetAwaiter().GetResult();
+                ApiUri = Node.ApiUri;
+                Ipfs = new IpfsClient(ApiUri.ToString());
+
+                context?.WriteLine($"Connected to existing Kubo node: {ApiUri}");
+            }
+            catch (Exception ex)
+            {
+                context?.WriteLine($"Kubo bootstrapper failed to start: {ex}");
+                throw;
+            }
+        }
+
+        public static async Task<KuboBootstrapper> CreateNodeAsync(SystemFolder workingDirectory, string nodeRepoName, int apiPort, int gatewayPort)
+        {
+            var nodeRepo = (SystemFolder)await workingDirectory.CreateFolderAsync(nodeRepoName, overwrite: true);
+
+            var node = new KuboBootstrapper(nodeRepo.Path)
+            {
+                ApiUri = new Uri($"http://127.0.0.1:{apiPort}"),
+                GatewayUri = new Uri($"http://127.0.0.1:{gatewayPort}"),
+                RoutingMode = DhtRoutingMode.AutoClient,
+                LaunchConflictMode = BootstrapLaunchConflictMode.Relaunch,
+                BinaryWorkingFolder = workingDirectory,
+                EnableFilestore = true,
+            };
+
+            OwlCore.Diagnostics.Logger.LogInformation($"Starting node {nodeRepoName}\n");
+
+            await node.StartAsync().ConfigureAwait(false);
+            await node.Client.IdAsync().ConfigureAwait(false);
+
+            Debug.Assert(node.Process != null);
+            return node;
+        }
+
+        public static async Task<SystemFolder> SafeCreateWorkingFolder(SystemFolder rootFolder, string name)
+        {
+            var testTempRoot = (SystemFolder)await rootFolder.CreateFolderAsync(name, overwrite: false);
+            await SetAllFileAttributesRecursive(testTempRoot, attributes => attributes & ~FileAttributes.ReadOnly).ConfigureAwait(false);
+
+            // Delete and recreate the folder.
+            return (SystemFolder)await rootFolder.CreateFolderAsync(name, overwrite: true).ConfigureAwait(false);
+        }
+
+        public static async Task SetAllFileAttributesRecursive(SystemFolder rootFolder, Func<FileAttributes, FileAttributes> transform)
+        {
+            await foreach (SystemFile file in rootFolder.GetFilesAsync())
+                file.Info.Attributes = transform(file.Info.Attributes);
+
+            await foreach (SystemFolder folder in rootFolder.GetFoldersAsync())
+                await SetAllFileAttributesRecursive(folder, transform).ConfigureAwait(false);
+        }
+
+        [AssemblyCleanup]
+        public static void AssemblyCleanup()
+        {
+            try
+            {
+                Node?.Dispose();
+            }
+            catch { }
+        }
     }
 }

test/TlsReproTest.cs

@@ -0,0 +1,31 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Linq;
+
+namespace Ipfs.Http
+{
+    [TestClass]
+    public class TlsReproTest
+    {
+        [TestMethod]
+        public void Real_Tls_MultiAddress_Should_Fail()
+        {
+            // Real multiaddr from long-running node that contains TLS
+            var realTlsAddr = "/dns4/45-86-153-40.k51qzi5uqu5dhssh49wibkxi3yw56ihw9uo7cxctyiqbfxpodudqo09swsxp1s.libp2p.direct/tcp/4001/tls/ws/p2p/12D3KooWEBaJd7msGiDjA5ATyMpVSEgja4xc6FXkxddaSM9DtHCT/p2p-circuit/p2p/12D3KooWEPx5LSWNGRtQFweBG9KMsfNjdogoeRisF9cU2s5RcrsJ";
+            
+            var addr = new MultiAddress(realTlsAddr);
+            OwlCore.Diagnostics.Logger.LogInformation($"Successfully parsed TLS multiaddr: {addr}");
+            
+            // Check if it contains the protocols we expect
+            var protocols = addr.Protocols.ToList();
+            OwlCore.Diagnostics.Logger.LogInformation($"Protocol count: {protocols.Count}");
+            
+            foreach(var protocol in protocols)
+            {
+                OwlCore.Diagnostics.Logger.LogInformation($"Protocol: {protocol.Name} (code: {protocol.Code})");
+            }
+            
+            Assert.IsNotNull(addr);
+        }
+    }
+}