Match the app's attachment pipeline in pn disk mode

- Classify the primary video/audio attachment by uniform type, like
  the app's AttachmentType.from, with video taking precedence over
  audio, replacing the extension allowlists that hardcoded webm as
  video and missed formats such as mkv
- Convert HEIC attachments to JPEG named <basename>.jpg
- Strip the GPS dictionary from JPEG attachments; unlike the app's
  removeGPSInfo, the rewrite preserves the encoded image data and the
  remaining metadata instead of re-encoding
- Conversion or stripping failures fall back to a plain copy
- Test covers uniform-type classification, real GPS EXIF removal, and
  an actual HEIC-to-JPEG conversion, skipping when HEIC encoding is
  unavailable

Closes the remaining items from #466.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: livid

Planet/versioning.xcconfig

@@ -1 +1 @@
-CURRENT_PROJECT_VERSION = 2822
+CURRENT_PROJECT_VERSION = 2823

PlanetCLI/PNDiskStore.swift

@@ -1,5 +1,7 @@
 import AppKit
 import Foundation
+import ImageIO
+import UniformTypeIdentifiers
 
 struct PNLibraryDoctorResult: Codable {
     let libraryPath: String
@@ -460,9 +462,7 @@ final class PNDiskStore {
         }
         var names = replace ? [] : existing
         for attachment in attachments {
-            let name = attachment.lastPathComponent
-            let target = publicBase.appendingPathComponent(name, isDirectory: false)
-            try copyReplacing(attachment, to: target)
+            let name = try copyAttachment(attachment, into: publicBase)
             if !names.contains(name) {
                 names.append(name)
             }
@@ -472,6 +472,59 @@ final class PNDiskStore {
         return (names, video, audio)
     }
 
+    /// Copy one attachment into the public folder, matching the app's
+    /// attachment pipeline: HEIC images become `<basename>.jpg` and JPEG
+    /// images are rewritten without GPS metadata. Falls back to a plain
+    /// copy when conversion or stripping fails.
+    private func copyAttachment(_ source: URL, into publicBase: URL) throws -> String {
+        let ext = source.pathExtension.lowercased()
+        if ext == "heic", let jpeg = jpegData(fromImageAt: source) {
+            let name = source.deletingPathExtension().lastPathComponent + ".jpg"
+            try jpeg.write(to: publicBase.appendingPathComponent(name, isDirectory: false), options: .atomic)
+            return name
+        }
+        let name = source.lastPathComponent
+        let target = publicBase.appendingPathComponent(name, isDirectory: false)
+        if ext == "jpg" || ext == "jpeg", let stripped = gpsStrippedImageData(fromImageAt: source) {
+            try stripped.write(to: target, options: .atomic)
+            return name
+        }
+        try copyReplacing(source, to: target)
+        return name
+    }
+
+    private func jpegData(fromImageAt url: URL) -> Data? {
+        guard let image = NSImage(contentsOf: url),
+              let tiff = image.tiffRepresentation,
+              let bitmap = NSBitmapImageRep(data: tiff)
+        else {
+            return nil
+        }
+        return bitmap.representation(using: .jpeg, properties: [:])
+    }
+
+    /// Rewrite an image without its GPS dictionary, preserving the encoded
+    /// image data and the remaining metadata.
+    private func gpsStrippedImageData(fromImageAt url: URL) -> Data? {
+        guard let source = CGImageSourceCreateWithURL(url as CFURL, nil),
+              let type = CGImageSourceGetType(source)
+        else {
+            return nil
+        }
+        let count = CGImageSourceGetCount(source)
+        guard count > 0 else { return nil }
+        let output = NSMutableData()
+        guard let destination = CGImageDestinationCreateWithData(output, type, count, nil) else {
+            return nil
+        }
+        let removeGPS = [kCGImagePropertyGPSDictionary: kCFNull as Any] as CFDictionary
+        for index in 0..<count {
+            CGImageDestinationAddImageFromSource(destination, source, index, removeGPS)
+        }
+        guard CGImageDestinationFinalize(destination) else { return nil }
+        return output as Data
+    }
+
     private func publicArticleRecord(from article: PNArticleRecord, planet: PNPlanetRecord) -> PNPublicArticleRecord {
         PNPublicArticleRecord(
             articleType: article.articleType ?? 0,
@@ -742,11 +795,21 @@ final class PNDiskStore {
         return String(text.prefix(180)).pnTrimmed
     }
 
+    // Classify by uniform type like the app's AttachmentType.from, with video
+    // taking precedence over audio for types that conform to both.
     private func isVideo(_ name: String) -> Bool {
-        ["mp4", "m4v", "mov", "avi", "mpeg", "mpg", "webm"].contains((name as NSString).pathExtension.lowercased())
+        guard let type = contentType(forName: name) else { return false }
+        return type.conforms(to: .movie) || type.conforms(to: .video)
     }
 
     private func isAudio(_ name: String) -> Bool {
-        ["aac", "mp3", "m4a", "ogg", "wav", "webm"].contains((name as NSString).pathExtension.lowercased())
+        guard let type = contentType(forName: name), !isVideo(name) else { return false }
+        return type.conforms(to: .audio)
+    }
+
+    private func contentType(forName name: String) -> UTType? {
+        let ext = (name as NSString).pathExtension
+        guard !ext.isEmpty else { return nil }
+        return UTType(filenameExtension: ext)
     }
 }

PlanetCLITests/PNDiskStoreTests.swift

@@ -1,4 +1,6 @@
 import AppKit
+import ImageIO
+import UniformTypeIdentifiers
 import XCTest
 
 final class PNDiskStoreTests: XCTestCase {
@@ -189,6 +191,42 @@ final class PNDiskStoreTests: XCTestCase {
         XCTAssertEqual(publicArticle?.attachments, [])
     }
 
+    func testDiskAttachmentsMatchAppPipeline() throws {
+        let sandbox = try PNTestSandbox()
+        defer { sandbox.cleanup() }
+
+        let store = PNDiskStore(root: sandbox.libraryURL)
+        let planet = try store.createPlanet(name: "Pipeline Planet", about: "", template: nil, avatar: nil)
+        defer { _ = try? store.deletePlanet(planet) }
+
+        // Primary video/audio classified by uniform type, video first.
+        let movie = try sandbox.makeTextFixture(name: "clip.mov", contents: "fake")
+        let song = try sandbox.makeTextFixture(name: "song.mp3", contents: "fake")
+        let blob = try sandbox.makeTextFixture(name: "data.bin", contents: "fake")
+        var article = try store.createArticle(planet: planet, title: "Media", content: "x", date: nil, attachments: [movie, song, blob])
+        XCTAssertEqual(article.videoFilename, "clip.mov")
+        XCTAssertEqual(article.audioFilename, "song.mp3")
+
+        // GPS metadata is stripped from JPEG attachments.
+        let jpegWithGPS = try makeJPEGWithGPSFixture(named: "gps.jpg", in: sandbox)
+        XCTAssertNotNil(gpsDictionary(at: jpegWithGPS), "Fixture should carry GPS metadata.")
+        article = try store.addAttachments(planet: planet, article: article, attachments: [jpegWithGPS])
+        XCTAssertTrue(article.attachments?.contains("gps.jpg") == true)
+        let publicJPEG = store.articlePublicPath(article, in: planet).appendingPathComponent("gps.jpg", isDirectory: false)
+        XCTAssertNil(gpsDictionary(at: publicJPEG))
+        XCTAssertNotNil(NSBitmapImageRep(data: try Data(contentsOf: publicJPEG)), "Stripped JPEG should remain a valid image.")
+
+        // HEIC attachments are converted to <basename>.jpg.
+        guard let heic = makeHEICFixture(named: "photo.heic", in: sandbox) else {
+            throw XCTSkip("HEIC encoding is unavailable on this machine.")
+        }
+        article = try store.addAttachments(planet: planet, article: article, attachments: [heic])
+        XCTAssertTrue(article.attachments?.contains("photo.jpg") == true)
+        XCTAssertFalse(article.attachments?.contains("photo.heic") == true)
+        let converted = store.articlePublicPath(article, in: planet).appendingPathComponent("photo.jpg", isDirectory: false)
+        XCTAssertEqual(Array(try Data(contentsOf: converted).prefix(2)), [0xFF, 0xD8], "Converted file should be a JPEG.")
+    }
+
     func testPartialUUIDSelectorsResolveWithExactMatchPrecedence() throws {
         let sandbox = try PNTestSandbox()
         defer { sandbox.cleanup() }
@@ -301,6 +339,64 @@ final class PNDiskStoreTests: XCTestCase {
         XCTAssertEqual(parsed.arguments, ["planet", "list"])
     }
 
+    private func makeJPEGWithGPSFixture(named name: String, in sandbox: PNTestSandbox) throws -> URL {
+        let base = try sandbox.makeImageFixture(name: "base-\(name)", width: 40, height: 40)
+        let data = try Data(contentsOf: base)
+        guard let source = CGImageSourceCreateWithData(data as CFData, nil),
+              let type = CGImageSourceGetType(source)
+        else {
+            throw PNError.diskError("Unable to read JPEG fixture source.")
+        }
+        let url = sandbox.root.appendingPathComponent(name, isDirectory: false)
+        guard let destination = CGImageDestinationCreateWithURL(url as CFURL, type, 1, nil) else {
+            throw PNError.diskError("Unable to create JPEG fixture destination.")
+        }
+        let gps: [CFString: Any] = [
+            kCGImagePropertyGPSLatitude: 37.7749,
+            kCGImagePropertyGPSLongitude: 122.4194,
+        ]
+        CGImageDestinationAddImageFromSource(destination, source, 0, [kCGImagePropertyGPSDictionary: gps] as CFDictionary)
+        guard CGImageDestinationFinalize(destination) else {
+            throw PNError.diskError("Unable to write JPEG fixture with GPS metadata.")
+        }
+        return url
+    }
+
+    private func gpsDictionary(at url: URL) -> [CFString: Any]? {
+        guard let source = CGImageSourceCreateWithURL(url as CFURL, nil),
+              let properties = CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [CFString: Any]
+        else {
+            return nil
+        }
+        return properties[kCGImagePropertyGPSDictionary] as? [CFString: Any]
+    }
+
+    private func makeHEICFixture(named name: String, in sandbox: PNTestSandbox) -> URL? {
+        guard let bitmap = NSBitmapImageRep(
+            bitmapDataPlanes: nil,
+            pixelsWide: 40,
+            pixelsHigh: 40,
+            bitsPerSample: 8,
+            samplesPerPixel: 4,
+            hasAlpha: true,
+            isPlanar: false,
+            colorSpaceName: .deviceRGB,
+            bytesPerRow: 0,
+            bitsPerPixel: 0
+        ), let cgImage = bitmap.cgImage else {
+            return nil
+        }
+        let url = sandbox.root.appendingPathComponent(name, isDirectory: false)
+        guard let destination = CGImageDestinationCreateWithURL(url as CFURL, UTType.heic.identifier as CFString, 1, nil) else {
+            return nil
+        }
+        CGImageDestinationAddImage(destination, cgImage, nil)
+        guard CGImageDestinationFinalize(destination) else {
+            return nil
+        }
+        return url
+    }
+
     private func writePlanetFixture(_ planet: PNPlanetRecord, in libraryURL: URL) throws {
         let directory = libraryURL
             .appendingPathComponent("My", isDirectory: true)

Technotes/CLI.md

@@ -187,7 +187,7 @@ Human-readable tables are the default. `--json` is the machine-readable mode.
 - `article attachment add <path>...` appends files, like `update --attachment`.
 - `article attachment delete <name>...` removes named attachments one by one.
 
-In API mode, append/replace map to the `attachmentMode=append|replace` query parameter on the article-modify route, and the `attachment` subcommands map to the `/attachments` sub-routes. Disk mode performs the equivalent file operations directly. Disk mode does not perform the app's HEIC-to-JPEG conversion or GPS stripping, and classifies the primary video/audio file by extension rather than by uniform type.
+In API mode, append/replace map to the `attachmentMode=append|replace` query parameter on the article-modify route, and the `attachment` subcommands map to the `/attachments` sub-routes. Disk mode performs the equivalent file operations directly and matches the app's attachment pipeline: HEIC attachments are converted to JPEG named `<basename>.jpg`, GPS metadata is stripped from JPEG attachments without re-encoding the image, and the primary video/audio file is classified by uniform type with video taking precedence.
 
 In API mode the app serves reads and planet deletion for archived planets, but rejects content mutations and publish with HTTP 400 because archived planets are excluded from publishing. Disk mode does not enforce this and will mutate archived planet files when asked.