@pired/lightroom-mcp 3.1.0

package/dist/LightroomMCP.lrplugin/HandlerExport.lua

@@ -0,0 +1,149 @@
+local LrApplication = import 'LrApplication'
+local LrExportSession = import 'LrExportSession'
+local LrFileUtils = import 'LrFileUtils'
+local LrPathUtils = import 'LrPathUtils'
+
+local PhotoLookup = require 'PhotoLookup'
+local Log = require 'Log'
+
+local ExportHandler = {}
+
+-- Lightroom's default collision handling is "ask", which opens a modal
+-- ("The following files already exist") and blocks the export task until a
+-- human clicks. Over the bridge that hangs the request until the server
+-- timeout and queues every later request behind it, so re-exporting the same
+-- photo to the same folder wedged the plugin. Never prompt.
+local COLLISION_HANDLING = {
+    rename = 'rename',
+    overwrite = 'overwrite',
+    skip = 'skip',
+}
+local DEFAULT_COLLISION_HANDLING = 'rename'
+
+local EXPORT_FORMATS = {
+    jpeg = 'JPEG',
+    png = 'PNG',
+    tiff = 'TIFF',
+    original = 'ORIGINAL',
+}
+
+function ExportHandler.exportPhotos(args)
+    if not args.photo_ids or #args.photo_ids == 0 then
+        error("photo_ids is required")
+    end
+
+    if not args.destination then
+        error("destination is required")
+    end
+
+    local catalog = LrApplication.activeCatalog()
+
+    -- Resolve photos under read access, then RELEASE the lock before
+    -- exporting. doExportOnCurrentTask() can run for minutes on a large
+    -- batch; holding catalog read access for that whole span blocks every
+    -- other handler (list_collections, get_selected_photos, ...) and on
+    -- macOS wedged the bridge until a manual restart (issue #128).
+    -- LrExportSession acquires its own catalog access during rendering, so
+    -- the lock is only needed for the lookup itself.
+    local photosToExport = {}
+    catalog:withReadAccessDo(function()
+        local resolved = PhotoLookup.resolveMany(catalog, args.photo_ids)
+        for _, entry in ipairs(resolved) do
+            if entry.photo then
+                table.insert(photosToExport, entry.photo)
+            end
+        end
+    end)
+
+    if #photosToExport == 0 then
+        error("No photos found to export")
+    end
+
+    -- destinationType=specificFolder makes LR honour
+    -- LR_export_destinationPathPrefix; sourceFolder ignores it and
+    -- writes next to the original. LR_format is set in the
+    -- format-specific block below.
+    local collisionHandling = args.on_existing or DEFAULT_COLLISION_HANDLING
+    if not COLLISION_HANDLING[collisionHandling] then
+        error("on_existing must be one of: rename, overwrite, skip")
+    end
+
+    local exportSettings = {
+        LR_export_destinationType = 'specificFolder',
+        LR_export_destinationPathPrefix = args.destination,
+        LR_export_useSubfolder = false,
+        LR_jpeg_quality = args.quality or 90,
+        LR_collisionHandling = COLLISION_HANDLING[collisionHandling],
+    }
+
+    -- Set dimensions if specified
+    if args.width or args.height then
+        exportSettings.LR_size_doConstrain = true
+        exportSettings.LR_size_maxWidth = args.width
+        exportSettings.LR_size_maxHeight = args.height
+        exportSettings.LR_size_resizeType = 'longEdge'
+    end
+
+    -- Handle different formats
+    local requestedFormat = args.format
+    if requestedFormat ~= nil and type(requestedFormat) ~= "string" then
+        error("format must be one of: jpeg, png, tiff, original")
+    end
+
+    local formatKey = requestedFormat and requestedFormat:lower() or 'jpeg'
+    local resolvedFormat = EXPORT_FORMATS[formatKey]
+    if not resolvedFormat then
+        error("format must be one of: jpeg, png, tiff, original")
+    end
+
+    exportSettings.LR_format = resolvedFormat
+    if resolvedFormat == 'JPEG' then
+        exportSettings.LR_export_colorSpace = 'sRGB'
+    elseif resolvedFormat == 'TIFF' then
+        exportSettings.LR_tiff_compressionMethod = 'compressionMethod_LZW'
+    end
+
+    -- Watermarking: the export dialog's Watermarking section binds a table
+    -- with watermarkEnabled + watermarkSelection (preset name, as listed by
+    -- the list_watermarks tool). Watermarking is only applied to JPEG/PNG/
+    -- TIFF exports, never to 'original'.
+    if args.watermark then
+        if type(args.watermark) ~= "string" or args.watermark == "" then
+            error("watermark must be the name of a watermark preset")
+        end
+        if resolvedFormat == 'ORIGINAL' then
+            error("watermark cannot be applied when exporting the original format")
+        end
+        exportSettings.watermarking = {
+            watermarkEnabled = true,
+            watermarkSelection = args.watermark,
+        }
+    end
+
+    -- Create export session
+    local exportSession = LrExportSession {
+        photosToExport = photosToExport,
+        exportSettings = exportSettings,
+    }
+
+    -- Execute export (outside the read-access block above)
+    exportSession:doExportOnCurrentTask()
+    local exportedCount = #photosToExport
+
+    Log.info(string.format("Exported %d photos to: %s", exportedCount, args.destination))
+
+    local result = {
+        success = true,
+        exported = exportedCount,
+        destination = args.destination,
+        message = string.format("Exported %d photos to %s", exportedCount, args.destination)
+    }
+    if args.watermark then
+        result.watermark = args.watermark
+        result.message = result.message .. string.format(" with watermark '%s'", args.watermark)
+    end
+
+    return result
+end
+
+return ExportHandler

package/dist/LightroomMCP.lrplugin/HandlerImport.lua

@@ -0,0 +1,108 @@
+local LrApplication = import 'LrApplication'
+local LrTasks = import 'LrTasks'
+local LrFileUtils = import 'LrFileUtils'
+local LrPathUtils = import 'LrPathUtils'
+
+local Log = require 'Log'
+
+local ImportHandler = {}
+
+function ImportHandler.importPhotos(args)
+    if not args.source_path then
+        error("source_path is required")
+    end
+
+    -- LrFileUtils.exists returns 'file' / 'directory' / false. Use it for the
+    -- directory check too: LrFileUtils.isDirectory is absent on some Lightroom
+    -- Classic runtimes (nil there, e.g. 15.3.1 -- issue #129), whereas exists
+    -- is stable across supported versions.
+    local sourceKind = LrFileUtils.exists(args.source_path)
+    if not sourceKind then
+        error("Source path does not exist: " .. args.source_path)
+    end
+
+    local catalog = LrApplication.activeCatalog()
+    local importedCount = 0
+
+    -- Enumerate source files OUTSIDE any catalog lock; the filesystem walk
+    -- needs no catalog access.
+    local photosToImport = {}
+    if sourceKind == 'directory' then
+        -- Import all photos from directory, including nested subfolders.
+        -- LrFileUtils.files lists only the immediate directory, so a source
+        -- organized as shoot/roll subfolders (the common Lightroom layout)
+        -- enumerated nothing and failed with "No photos found to import".
+        for file in LrFileUtils.recursiveFiles(args.source_path) do
+            -- extension() is on LrPathUtils; LrFileUtils has no such field, so
+            -- the previous call was nil and raised "attempt to call field
+            -- 'extension' (a nil value)" on every directory import.
+            local ext = LrPathUtils.extension(file):lower()
+            if ext == 'jpg' or ext == 'jpeg' or ext == 'png' or
+               ext == 'tif' or ext == 'tiff' or ext == 'dng' or
+               ext == 'cr2' or ext == 'nef' or ext == 'arw' then
+                table.insert(photosToImport, file)
+            end
+        end
+    else
+        -- Import single photo
+        table.insert(photosToImport, args.source_path)
+    end
+
+    if #photosToImport == 0 then
+        error("No photos found to import")
+    end
+
+    -- Add each photo in its OWN write transaction rather than holding the
+    -- exclusive catalog write lock across the whole batch. A large import
+    -- runs for minutes, and one batch-wide withWriteAccessDo would block
+    -- every other handler (reads included) for that entire span -- the same
+    -- bridge wedge the export handler was restructured to avoid (issue #128),
+    -- and now longer-lived since import_photos was given a 5-minute server
+    -- timeout. addPhoto cannot acquire its own isolated access the way
+    -- LrExportSession does, so a per-photo lock is the bounded-hold
+    -- equivalent: the lock is released between photos, letting queued
+    -- handlers interleave.
+    local addedPhotos = {}
+    for _, filePath in ipairs(photosToImport) do
+        catalog:withWriteAccessDo("Import Photo", function()
+            local photo = catalog:addPhoto(filePath)
+            if photo then
+                table.insert(addedPhotos, photo)
+                importedCount = importedCount + 1
+            end
+        end)
+    end
+
+    -- Add to collection if specified, in its own short write transaction.
+    if args.collection_name and #addedPhotos > 0 then
+        catalog:withWriteAccessDo("Add Imported Photos to Collection", function()
+            local targetCollection = nil
+            local collections = catalog:getChildCollections()
+
+            for _, collection in ipairs(collections) do
+                if collection:getName() == args.collection_name then
+                    targetCollection = collection
+                    break
+                end
+            end
+
+            if targetCollection then
+                targetCollection:addPhotos(addedPhotos)
+                Log.info(string.format("Added %d imported photos to collection: %s",
+                    #addedPhotos, args.collection_name))
+            else
+                Log.warn("Collection not found: " .. args.collection_name)
+            end
+        end)
+    end
+
+    Log.info(string.format("Imported %d photos from: %s", importedCount, args.source_path))
+
+    return {
+        success = true,
+        imported = importedCount,
+        message = string.format("Imported %d photos", importedCount)
+    }
+end
+
+return ImportHandler

package/dist/LightroomMCP.lrplugin/HandlerLocalAdjustments.lua

@@ -0,0 +1,330 @@
+local LrApplication = import 'LrApplication'
+
+local PhotoLookup = require 'PhotoLookup'
+local Log = require 'Log'
+
+local LocalAdjustmentsHandler = {}
+
+-- =====================================================================
+-- Local adjustments (linear and radial gradient masks)
+-- =====================================================================
+--
+-- Lightroom Classic 11+ stores local adjustments in the MaskGroupBasedCorrections
+-- develop setting (a table). Adobe does not document the table's internal
+-- shape, but it mirrors the public XMP schema:
+--
+--   {
+--     What = "Correction",
+--     CorrectionAmount = 1.0,
+--     CorrectionActive = true,
+--     LocalExposure2012 = <EV>,           -- fractions -1..1 except exposure
+--     LocalContrast2012 = <-1..1>,
+--     ... further Local* sliders ...
+--     CorrectionMasks = {
+--       { What = "Mask/Gradient",
+--         MaskValue = 1.0,
+--         ZeroX = .., ZeroY = .., FullX = .., FullY = .. },     -- linear
+--       -- or, for radial:
+--       { What = "Mask/CircularGradient",
+--         MaskValue = 1.0, Top = .., Left = .., Bottom = .., Right = ..,
+--         Angle = 0, Feather = 50, Flipped = false,
+--         CenterValue = 1, PerimeterValue = 0 },
+--     },
+--     CorrectionRangeMask = { ... default range mask ... },
+--   }
+--
+-- To stay robust across Lightroom versions this handler:
+--   * never rewrites existing corrections (the new one is appended);
+--   * when the photo already has corrections, clones the structure of one as
+--     a template so unknown per-version fields survive the round-trip;
+--   * verifies the write by reading the corrections back and reports
+--     honestly when a version refuses it.
+
+local function clamp01(v)
+    if v == nil then return 0 end
+    if v < 0 then return 0 end
+    if v > 1 then return 1 end
+    return v
+end
+
+local function clampRange(v, min, max)
+    if v == nil then return 0 end
+    if v < min then return min end
+    if v > max then return max end
+    return v
+end
+
+-- UI units (-100..100) to the XMP fraction (-1..1) the corrections use.
+local function sliderToFraction(v)
+    return clampRange(v, -100, 100) / 100
+end
+
+local function deepCopy(v)
+    if type(v) ~= "table" then return v end
+    local copy = {}
+    for k, val in pairs(v) do
+        copy[k] = deepCopy(val)
+    end
+    return copy
+end
+
+local function resolveOnePhoto(catalog, photoId)
+    local photo = nil
+    catalog:withReadAccessDo(function()
+        photo = PhotoLookup.resolveOne(catalog, photoId)
+    end)
+    if not photo then
+        error("Photo not found: " .. tostring(photoId))
+    end
+    return photo
+end
+
+-- MaskGroupBasedCorrections as a table; tolerates nil, string and weird shapes.
+local function readCorrections(photo)
+    local settings = photo:getDevelopSettings()
+    local value = settings.MaskGroupBasedCorrections
+    if type(value) == "table" then return value end
+    return {}
+end
+
+-- Pick a correction to clone the structure from: prefer one whose masks array
+-- holds a mask of the wanted type so geometry keys stay consistent.
+local function findTemplate(corrections, maskWhat)
+    for _, correction in ipairs(corrections) do
+        if type(correction) == "table" and type(correction.CorrectionMasks) == "table" then
+            for _, mask in ipairs(correction.CorrectionMasks) do
+                if type(mask) == "table" and mask.What == maskWhat then
+                    return correction
+                end
+            end
+        end
+    end
+    return nil
+end
+
+local LINEAR_MASK = "Mask/Gradient"
+local RADIAL_MASK = "Mask/CircularGradient"
+
+-- Geometry for a linear gradient from center + angle + span.
+-- Angle 0 means the effect grows upward (bottom -> top); 90 grows to the
+-- right; both endpoints are clamped to the image.
+local function linearMaskGeometry(args)
+    local cx = clamp01(tonumber(args.center_x) or 0.5)
+    local cy = clamp01(tonumber(args.center_y) or 0.5)
+    local angle = clampRange(tonumber(args.angle) or 0, -360, 360)
+    local span = clampRange(tonumber(args.span) or 0.6, 0.02, 2)
+
+    local radians = math.rad(angle)
+    local dx = math.sin(radians) * span / 2
+    local dy = -math.cos(radians) * span / 2
+
+    return {
+        ZeroX = clamp01(cx - dx),
+        ZeroY = clamp01(cy - dy),
+        FullX = clamp01(cx + dx),
+        FullY = clamp01(cy + dy),
+    }
+end
+
+local function radialMaskGeometry(args)
+    local cx = clamp01(tonumber(args.center_x) or 0.5)
+    local cy = clamp01(tonumber(args.center_y) or 0.5)
+    local rx = clampRange(tonumber(args.radius_x) or tonumber(args.radius) or 0.3, 0.01, 1)
+    local ry = clampRange(tonumber(args.radius_y) or tonumber(args.radius) or 0.3, 0.01, 1)
+
+    return {
+        Top = clamp01(cy - ry),
+        Left = clamp01(cx - rx),
+        Bottom = clamp01(cy + ry),
+        Right = clamp01(cx + rx),
+        Angle = 0,
+        Feather = clampRange(tonumber(args.feather) or 50, 0, 100),
+        Flipped = args.invert == true,
+    }
+end
+
+-- The full set of local sliders Lightroom understands, with their XMP names.
+-- Exposure is in EV like the global slider; everything else is -1..1.
+local LOCAL_SLIDERS = {
+    { arg = "exposure", key = "LocalExposure2012", ev = true },
+    { arg = "contrast", key = "LocalContrast2012" },
+    { arg = "highlights", key = "LocalHighlights2012" },
+    { arg = "shadows", key = "LocalShadows2012" },
+    { arg = "whites", key = "LocalWhites2012" },
+    { arg = "blacks", key = "LocalBlacks2012" },
+    { arg = "clarity", key = "LocalClarity2012" },
+    { arg = "dehaze", key = "LocalDehaze" },
+    { arg = "saturation", key = "LocalSaturation" },
+    { arg = "sharpness", key = "LocalSharpness" },
+    { arg = "noise_reduction", key = "LocalLuminanceNoise" },
+    { arg = "temperature", key = "LocalTemperature" },
+    { arg = "tint", key = "LocalTint" },
+}
+
+local function hasAnySlider(args)
+    for _, slider in ipairs(LOCAL_SLIDERS) do
+        if args[slider.arg] ~= nil then return true end
+    end
+    return false
+end
+
+local function applyLocalSliders(correction, args)
+    for _, slider in ipairs(LOCAL_SLIDERS) do
+        local value = args[slider.arg]
+        if value ~= nil then
+            if slider.ev then
+                correction[slider.key] = clampRange(value, -5, 5)
+            else
+                correction[slider.key] = sliderToFraction(value)
+            end
+        end
+    end
+end
+
+function LocalAdjustmentsHandler.readLocalAdjustments(args)
+    args = args or {}
+    if args.photo_id == nil or args.photo_id == "" then
+        error("photo_id is required")
+    end
+
+    local catalog = LrApplication.activeCatalog()
+    local photo = resolveOnePhoto(catalog, args.photo_id)
+
+    local corrections = readCorrections(photo)
+
+    Log.info(string.format("read_local_adjustments: %d corrections on photo %s",
+        #corrections, tostring(args.photo_id)))
+
+    return {
+        success = true,
+        photo_id = photo.localIdentifier,
+        count = #corrections,
+        corrections = corrections,
+        note = "MaskGroupBasedCorrections as stored by this Lightroom version. "
+            .. "Use add_local_adjustment to append linear/radial masks; existing corrections are never modified.",
+    }
+end
+
+function LocalAdjustmentsHandler.addLocalAdjustment(args)
+    args = args or {}
+    if args.photo_id == nil or args.photo_id == "" then
+        error("photo_id is required")
+    end
+
+    local maskType = args.mask_type
+    if maskType ~= "linear" and maskType ~= "radial" then
+        error("mask_type must be 'linear' or 'radial'")
+    end
+
+    if not hasAnySlider(args) then
+        error("at least one adjustment setting is required (e.g. exposure, contrast, saturation)")
+    end
+
+    local catalog = LrApplication.activeCatalog()
+    local photo = resolveOnePhoto(catalog, args.photo_id)
+
+    local corrections = readCorrections(photo)
+    local beforeCount = #corrections
+
+    local maskWhat = (maskType == "linear") and LINEAR_MASK or RADIAL_MASK
+    local flow = clampRange(tonumber(args.flow) or 1, 0, 1)
+
+    -- Build on a template cloned from an existing correction of the same mask
+    -- type when present, so per-version fields survive; otherwise use the
+    -- canonical structure observed in Lightroom-written XMP.
+    local template = findTemplate(corrections, maskWhat)
+    local correction
+    if template then
+        correction = deepCopy(template)
+    else
+        correction = {
+            What = "Correction",
+            CorrectionAmount = 1.0,
+            CorrectionActive = true,
+            -- Legacy PV2003/2010 sliders (always zero in modern edits) kept
+            -- for structural parity with Lightroom-written files.
+            LocalExposure = 0,
+            LocalSaturation = 0,
+            LocalContrast = 0,
+            LocalClarity = 0,
+            LocalSharpness = 0,
+            LocalBrightness = 0,
+            LocalToningHue = 240,
+            LocalToningSaturation = 0,
+            LocalDefringe = 0,
+            LocalMoire = 0,
+            CorrectionRangeMask = {
+                ColorAmount = 0.5,
+                DepthFeather = 0.5,
+                DepthMax = 1.0,
+                DepthMin = 0.0,
+                LumFeather = 0.5,
+                LumMax = 1.0,
+                LumMin = 0.0,
+                Type = 0,
+                Version = "+2",
+            },
+        }
+    end
+
+    applyLocalSliders(correction, args)
+
+    local geometry = (maskType == "linear")
+        and linearMaskGeometry(args)
+        or radialMaskGeometry(args)
+
+    local maskEntry = {
+        What = maskWhat,
+        MaskValue = flow,
+    }
+    for k, v in pairs(geometry) do
+        maskEntry[k] = v
+    end
+
+    -- A new adjustment carries exactly one mask; drop any masks the template
+    -- carried over from a multi-mask correction.
+    correction.CorrectionMasks = { maskEntry }
+
+    table.insert(corrections, correction)
+
+    catalog:withWriteAccessDo("Add Local Adjustment", function()
+        photo:applyDevelopSettings({
+            EnableMaskGroupBasedCorrections = true,
+            MaskGroupBasedCorrections = corrections,
+        }, "MCP Add Local Adjustment")
+    end)
+
+    -- Verify by reading back.
+    local afterCorrections = readCorrections(photo)
+    local took = #afterCorrections > beforeCount
+
+    Log.info(string.format("add_local_adjustment: %d before, %d after on photo %s",
+        beforeCount, #afterCorrections, tostring(args.photo_id)))
+
+    if not took then
+        return {
+            success = false,
+            applied = false,
+            photo_id = photo.localIdentifier,
+            before_count = beforeCount,
+            after_count = #afterCorrections,
+            message = "Lightroom did not accept the MaskGroupBasedCorrections write on this version. "
+                .. "Draw one gradient/radial mask manually on the photo, then retry: the existing "
+                .. "correction is then used as a structure template and round-trips safely.",
+        }
+    end
+
+    return {
+        success = true,
+        applied = true,
+        photo_id = photo.localIdentifier,
+        mask_type = maskType,
+        before_count = beforeCount,
+        after_count = #afterCorrections,
+        geometry = geometry,
+        message = string.format("Added %s local adjustment (photo now has %d).",
+            maskType, #afterCorrections),
+    }
+end
+
+return LocalAdjustmentsHandler