Merge remote-tracking branch 'refs/remotes/origin/main'

Author: MasterJ93

Sources/ATProtoKit/APIReference/ATProtoBlueskyAPI/PostRecord/CreatePostRecord.swift

@@ -240,6 +240,72 @@ extension ATProtoBluesky {
     /// }
     /// ```
     ///
+    /// # Adding Audience Controls
+    /// You can control who can reply to your post and whether it can be embedded by other posts.
+    ///
+    /// ## Controlling Replies (Threadgate)
+    /// Use the `replyControls` parameter to restrict who can reply:
+    ///
+    /// ```swift
+    /// do {
+    ///     let postResult = try await atProtoBluesky.createPostRecord(
+    ///         text: "Only my followers can reply to this post!",
+    ///         replyControls: [.allowFollowers]
+    ///     )
+    ///
+    ///     print(postResult)
+    /// } catch {
+    ///     throw error
+    /// }
+    /// ```
+    ///
+    /// You can combine multiple rules:
+    ///
+    /// ```swift
+    /// do {
+    ///     let postResult = try await atProtoBluesky.createPostRecord(
+    ///         text: "Only people I follow or who follow me can reply.",
+    ///         replyControls: [.allowFollowers, .allowFollowing]
+    ///     )
+    ///
+    ///     print(postResult)
+    /// } catch {
+    ///     throw error
+    /// }
+    /// ```
+    ///
+    /// ## Disabling Embedding (Postgate)
+    /// Use the `embeddingRules` parameter to prevent others from quoting your post:
+    ///
+    /// ```swift
+    /// do {
+    ///     let postResult = try await atProtoBluesky.createPostRecord(
+    ///         text: "This post cannot be quoted by others.",
+    ///         embeddingRules: [.disable]
+    ///     )
+    ///
+    ///     print(postResult)
+    /// } catch {
+    ///     throw error
+    /// }
+    /// ```
+    ///
+    /// You can combine both audience controls:
+    ///
+    /// ```swift
+    /// do {
+    ///     let postResult = try await atProtoBluesky.createPostRecord(
+    ///         text: "Followers only replies, no quotes allowed.",
+    ///         replyControls: [.allowFollowers],
+    ///         embeddingRules: [.disable]
+    ///     )
+    ///
+    ///     print(postResult)
+    /// } catch {
+    ///     throw error
+    /// }
+    /// ```
+    ///
     /// - Parameters:
     ///   - text: The text that's directly displayed in the post record. Current limit is
     ///   300 characters.
@@ -254,6 +320,10 @@ extension ATProtoBluesky {
     ///   - labels: An array of labels made by the user. Optional. Defaults to `nil`.
     ///   - tags: An array of tags for the post record. Optional. Defaults to `nil`.
     ///   - creationDate: The date of the post record. Defaults to `Date.now`.
+    ///   - replyControls: An array of rules to control who can reply to the post. Optional.
+    ///   Defaults to `nil`. When provided, a threadgate record is created for the post.
+    ///   - embeddingRules: An array of rules to control embedding of the post. Optional.
+    ///   Defaults to `nil`. When provided, a postgate record is created for the post.
     ///   - recordKey: The record key of the collection. Optional. Defaults to `nil`.
     ///   - shouldValidate: Indicates whether the record should be validated. Optional.
     ///   Defaults to `true`.
@@ -268,6 +338,8 @@ extension ATProtoBluesky {
         labels: ComAtprotoLexicon.Label.SelfLabelsDefinition? = nil,
         tags: [String]? = nil,
         creationDate: Date = Date(),
+        replyControls: [ThreadgateAllowRule]? = nil,
+        embeddingRules: [PostgateEmbeddingRule]? = nil,
         recordKey: String? = nil,
         shouldValidate: Bool? = true,
         swapCommit: String? = nil
@@ -432,6 +504,81 @@ extension ATProtoBluesky {
 
             try await Task.sleep(nanoseconds: 500_000_000)
 
+            // Create threadgate record if reply controls are specified.
+            // nil = no threadgate (everyone can reply)
+            // [] = threadgate with empty allow (nobody can reply)
+            // [rules] = threadgate with those rules
+            if let replyControls = replyControls {
+                let postRecordKey = try ATProtoTools().parseURI(record.recordURI).recordKey
+
+                var threadgateAllowArray: [AppBskyLexicon.Feed.ThreadgateRecord.ThreadgateUnion] = []
+                let cappedReplyControls = Array(replyControls.prefix(5))
+
+                for replyControl in cappedReplyControls {
+                    switch replyControl {
+                        case .allowMentions:
+                            threadgateAllowArray.append(.mentionRule(AppBskyLexicon.Feed.ThreadgateRecord.MentionRule()))
+                        case .allowFollowers:
+                            threadgateAllowArray.append(.followerRule(AppBskyLexicon.Feed.ThreadgateRecord.FollowerRule()))
+                        case .allowFollowing:
+                            threadgateAllowArray.append(.followingRule(AppBskyLexicon.Feed.ThreadgateRecord.FollowingRule()))
+                        case .allowList(listURI: let listURI):
+                            threadgateAllowArray.append(.listRule(AppBskyLexicon.Feed.ThreadgateRecord.ListRule(listURI: listURI)))
+                    }
+                }
+
+                // Empty allow array means nobody can reply
+                let threadgateRecord = AppBskyLexicon.Feed.ThreadgateRecord(
+                    postURI: record.recordURI,
+                    allow: threadgateAllowArray,
+                    createdAt: creationDate,
+                    hiddenReplies: nil
+                )
+
+                _ = try await atProtoKitInstance.createRecord(
+                    repositoryDID: session.sessionDID,
+                    collection: "app.bsky.feed.threadgate",
+                    recordKey: postRecordKey,
+                    shouldValidate: shouldValidate,
+                    record: UnknownType.record(threadgateRecord),
+                    swapCommit: nil
+                )
+
+                try await Task.sleep(nanoseconds: 500_000_000)
+            }
+
+            // Create postgate record if embedding rules are specified.
+            if let embeddingRules = embeddingRules, embeddingRules.isEmpty == false {
+                let postRecordKey = try ATProtoTools().parseURI(record.recordURI).recordKey
+
+                var postgateEmbedRules: [AppBskyLexicon.Feed.PostgateRecord.EmbeddingRulesUnion] = []
+
+                for rule in embeddingRules {
+                    switch rule {
+                        case .disable:
+                            postgateEmbedRules.append(.disabledRule(AppBskyLexicon.Feed.PostgateRecord.DisableRule()))
+                    }
+                }
+
+                let postgateRecord = AppBskyLexicon.Feed.PostgateRecord(
+                    createdAt: creationDate,
+                    postURI: record.recordURI,
+                    detachedEmbeddingURIs: nil,
+                    embeddingRules: postgateEmbedRules.isEmpty ? nil : postgateEmbedRules
+                )
+
+                _ = try await atProtoKitInstance.createRecord(
+                    repositoryDID: session.sessionDID,
+                    collection: "app.bsky.feed.postgate",
+                    recordKey: postRecordKey,
+                    shouldValidate: shouldValidate,
+                    record: UnknownType.record(postgateRecord),
+                    swapCommit: nil
+                )
+
+                try await Task.sleep(nanoseconds: 500_000_000)
+            }
+
             return record
         } catch {
             throw error
@@ -468,7 +615,7 @@ extension ATProtoBluesky {
             )
 
             let embedImage = AppBskyLexicon.Embed.ImagesDefinition.Image(
-                imageBlob: blobReference.blob,
+                imageBlob: blobReference,
                 altText: image.altText ?? "",
                 aspectRatio: image.aspectRatio
             )
@@ -634,7 +781,7 @@ extension ATProtoBluesky {
                     imageData: caption.file
                 )
 
-                captionReferences.append(AppBskyLexicon.Embed.VideoDefinition.Caption(language: caption.language.identifier, fileBlob: blobReference.blob))
+                captionReferences.append(AppBskyLexicon.Embed.VideoDefinition.Caption(language: caption.language.identifier, fileBlob: blobReference))
             }
         }
 
@@ -688,7 +835,7 @@ extension ATProtoBluesky {
                         accessToken: accessToken,
                         filename: "\(ATProtoTools().generateRandomString())_thumbnail.jpg",
                         imageData: imageData
-                    ).blob
+                    )
                 } else {
                     thumbnailImage = nil
                 }

Sources/ATProtoKit/APIReference/ATProtoBlueskyAPI/ProfileRecord/CreateProfileRecord.swift

@@ -136,7 +136,7 @@ extension ATProtoBluesky {
         websiteURL: URL? = nil,
         avatarImage: ATProtoTools.ImageQuery? = nil,
         bannerImage: ATProtoTools.ImageQuery? = nil,
-        labels: [ComAtprotoLexicon.Label.SelfLabelsDefinition]? = nil,
+        labels: ComAtprotoLexicon.Label.SelfLabelsDefinition? = nil,
         joinedViaStarterPack: ComAtprotoLexicon.Repository.StrongReference? = nil,
         pinnedPost: ComAtprotoLexicon.Repository.StrongReference? = nil,
         recordKey: String? = nil,
@@ -214,22 +214,14 @@ extension ATProtoBluesky {
             }
         }
 
-        // labels
-        var labelsArray: [AppBskyLexicon.Actor.ProfileRecord.LabelsUnion]? = nil
-        if let labels = labels {
-            for label in labels {
-                labelsArray?.append(.selfLabel(label))
-            }
-        }
-
         let profileRecord = AppBskyLexicon.Actor.ProfileRecord(
             displayName: displayNameText,
             description: descriptionText,
             pronouns: pronounsText,
             websiteURL: website,
             avatarBlob: profileAvatarImage,
             bannerBlob: profileBannerImage,
-            labels: labelsArray,
+            labels: (labels != nil) ? .selfLabel(labels!) : nil,
             joinedViaStarterPack: joinedViaStarterPack,
             pinnedPost: pinnedPost,
             createdAt: Date()

Sources/ATProtoKit/APIReference/ATProtoBlueskyAPI/ProfileRecord/UpdateProfileRecord.swift

@@ -73,7 +73,7 @@ extension ATProtoBluesky {
         var newWebsiteURL: URL? = profile.websiteURL
         var newAvatarImage: ComAtprotoLexicon.Repository.UploadBlobOutput? = profile.avatarBlob
         var newBannerImage: ComAtprotoLexicon.Repository.UploadBlobOutput? = profile.bannerBlob
-        var newLabels: [AppBskyLexicon.Actor.ProfileRecord.LabelsUnion]? = profile.labels
+        var newLabels: AppBskyLexicon.Actor.ProfileRecord.LabelsUnion? = profile.labels
         var newJoinedViaStarterPack: ComAtprotoLexicon.Repository.StrongReference? = profile.joinedViaStarterPack
         var newPinnedPost: ComAtprotoLexicon.Repository.StrongReference? = profile.pinnedPost
 
@@ -161,17 +161,12 @@ extension ATProtoBluesky {
                     }
                 case .labels(let labelsField):
                     // Check if the field is nil. If so, set the labels variable to nil and break out of the case early.
-                    if labelsField == nil {
+                    if let labelsField {
+                        newLabels = .selfLabel(labelsField)
+                    } else {
                         newLabels = nil
-
-                        break
-                    }
-
-                    if let labelsField = labelsField {
-                        for labelField in labelsField {
-                            newLabels?.append(.selfLabel(labelField))
-                        }
                     }
+                    
                 case .joinedViaStarterPack(let joinedViaStarterPackField):
                     // Check if the field is nil. If so, set the joinedViaStarterPack variable to nil and break out of the case early.
                     if joinedViaStarterPackField == nil {
@@ -250,7 +245,7 @@ extension ATProtoBluesky {
         /// An array of user-defined labels.
         ///
         /// - Parameter with: The object to update the record with. Optional. Defaults to `nil`.
-        case labels(with: [ComAtprotoLexicon.Label.SelfLabelsDefinition]? = nil)
+        case labels(with: ComAtprotoLexicon.Label.SelfLabelsDefinition? = nil)
 
         /// A strong reference to the starter pack the user used to join Bluesky.
         ///

…I/AppBskyBookmarkGetBookmarkMethod.swift …/AppBskyBookmarkGetBookmarksMethod.swiftSources/ATProtoKit/APIReference/AppBskyAPI/AppBskyBookmarkGetBookmarkMethod.swift renamed to Sources/ATProtoKit/APIReference/AppBskyAPI/AppBskyBookmarkGetBookmarksMethod.swift Sources/ATProtoKit/APIReference/AppBskyAPI/AppBskyBookmarkGetBookmarkMethod.swift renamed to Sources/ATProtoKit/APIReference/AppBskyAPI/AppBskyBookmarkGetBookmarksMethod.swift

@@ -43,7 +43,7 @@ extension ATProtoKit {
         let accessToken = try await keychain.retrieveAccessToken()
         let sessionURL = session.serviceEndpoint.absoluteString
 
-        guard let requestURL = URL(string: "\(sessionURL)/xrpc/app.bsky.bookmark.getBookmark") else {
+        guard let requestURL = URL(string: "\(sessionURL)/xrpc/app.bsky.bookmark.getBookmarks") else {
             throw ATRequestPrepareError.invalidRequestURL
         }
 

Sources/ATProtoKit/APIReference/ComAtprotoAPI/ComAtprotoRepoUploadBlobMethod.swift

@@ -28,7 +28,7 @@ extension ATProtoKit {
     ///   - accessToken: The access token for authorization.
     ///   - filename: The filename of the blob to upload.
     ///   - imageData: The data of the blob to upload.
-    /// - Returns: A `BlobContainer` instance with the upload result.
+    /// - Returns: An `UploadBlobOutput` instance with the upload result.
     ///
     /// - Throws: An ``ATProtoError``-conforming error type, depending on the issue. Go to
     /// ``ATAPIError`` and ``ATRequestPrepareError`` for more details.
@@ -37,7 +37,7 @@ extension ATProtoKit {
         accessToken: String,
         filename: String,
         imageData: Data
-    ) async throws -> ComAtprotoLexicon.Repository.BlobContainer {
+    ) async throws -> ComAtprotoLexicon.Repository.UploadBlobOutput {
         guard let requestURL = URL(string: "\(pdsURL)/xrpc/com.atproto.repo.uploadBlob") else {
             throw ATRequestPrepareError.invalidRequestURL
         }
@@ -52,12 +52,22 @@ extension ATProtoKit {
                 authorizationValue: "Bearer \(accessToken)")
             request.httpBody = imageData
 
+            // The `com.atproto.repo.uploadBlob` endpoint wraps its result in a
+            // `blob` key (`{"blob": {...}}`), unlike record fields where the blob
+            // appears inline. Decode the wrapper and return its blob so uploads
+            // don't fail looking for `ref` at the response root.
             let response = try await apiClientService.sendRequest(request,
-                                                      decodeTo: ComAtprotoLexicon.Repository.BlobContainer.self)
+                                                      decodeTo: UploadBlobResponse.self)
 
-            return response
+            return response.blob
         } catch {
             throw error
         }
     }
 }
+
+/// The response envelope for `com.atproto.repo.uploadBlob`, which returns the
+/// uploaded blob under a `blob` key.
+private struct UploadBlobResponse: Decodable {
+    let blob: ComAtprotoLexicon.Repository.UploadBlobOutput
+}

Sources/ATProtoKit/APIReference/SessionManager/AppleSecureKeychain.swift

@@ -181,6 +181,13 @@ public actor AppleSecureKeychain: SecureKeychainProtocol {
 
     /// Saves or updates a keychain item.
     ///
+    /// Items are stored with `kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly` so that
+    /// background tasks (e.g. push-driven refresh) can read session tokens while the device
+    /// is locked. Without this attribute, the keychain default is `kSecAttrAccessibleWhenUnlocked`,
+    /// which causes `SecItemCopyMatching` to return `errSecInteractionNotAllowed` for any
+    /// access attempted while the screen is locked — silently breaking background refresh.
+    /// `ThisDeviceOnly` prevents tokens from migrating via iCloud Keychain or encrypted backups.
+    ///
     /// - Parameters:
     ///   - value: The keychain value.
     ///   - key: The keychain key.
@@ -195,8 +202,13 @@ public actor AppleSecureKeychain: SecureKeychainProtocol {
             kSecAttrService: serviceName,
         ]
 
+        // Including `kSecAttrAccessible` in the update dictionary upgrades the accessibility
+        // of items previously written with the default attribute, so existing installs
+        // migrate to the background-readable policy on the next save without needing a
+        // delete+re-add cycle.
         let updateAttributes: [CFString: Any] = [
-            kSecValueData: data
+            kSecValueData: data,
+            kSecAttrAccessible: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
         ]
 
         let status = SecItemUpdate(query as CFDictionary, updateAttributes as CFDictionary)
@@ -207,6 +219,7 @@ public actor AppleSecureKeychain: SecureKeychainProtocol {
             case errSecItemNotFound:
                 var newItem = query
                 newItem[kSecValueData] = data
+                newItem[kSecAttrAccessible] = kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
                 let addStatus = SecItemAdd(newItem as CFDictionary, nil)
                 guard addStatus == errSecSuccess else {
                     throw ApplSecureKeychainError.unhandledStatus(status: addStatus)

Sources/ATProtoKit/ATProtoKit.docc/Extensions/Lexicons/Models/com.atproto/ComAtprotoRepository.md

@@ -57,6 +57,5 @@
 ### com.atproto.repo.uploadBlob
 
 - ``ComAtprotoLexicon/Repository/UploadBlobRequestBody``
-- ``ComAtprotoLexicon/Repository/BlobContainer``
 - ``ComAtprotoLexicon/Repository/UploadBlobOutput``
 - ``ComAtprotoLexicon/Repository/BlobReference``