@pired/lightroom-mcp 3.1.0

package/dist/LightroomMCP.lrplugin/HandlerSpots.lua

@@ -0,0 +1,313 @@
+local LrApplication = import 'LrApplication'
+
+local PhotoLookup = require 'PhotoLookup'
+local Log = require 'Log'
+
+local SpotsHandler = {}
+
+-- =====================================================================
+-- Spot removal (the Develop module's spot heal/clone tool)
+-- =====================================================================
+--
+-- Lightroom stores spot removal in the `RetouchInfo` develop setting. The
+-- SDK returns it as a table that is a LIST of spot strings; each string is
+-- the classic ACR flat format:
+--
+--   ( x, y ), ( type ), ( srcX, srcY ), ( radius ), ( f ), ( o ), ( flags )
+--
+-- where x/y/srcX/srcY are normalized coordinates (0..1), type is "heal" or
+-- "clone", radius is normalized, and the trailing groups are preserved
+-- verbatim when round-tripping. Because Adobe does not document this format,
+-- this handler never rewrites existing entries (they are appended to
+-- byte-identical) and verifies the write by reading the photo back.
+
+local MAX_SPOTS_PER_REQUEST = 50
+
+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
+
+SpotsHandler.clamp01 = clamp01
+
+local function requirePhotoId(args)
+    if args.photo_id == nil or args.photo_id == "" then
+        error("photo_id is required")
+    end
+end
+
+-- Extract every "( ... )" group from a flat spot string.
+local function extractGroups(s)
+    local groups = {}
+    for group in s:gmatch("%b()") do
+        table.insert(groups, group:sub(2, -2))
+    end
+    return groups
+end
+
+local function parseNumberList(group)
+    local numbers = {}
+    for token in group:gmatch("[-+]?%d+%.?%d*") do
+        table.insert(numbers, tonumber(token))
+    end
+    return numbers
+end
+
+-- Parse one flat spot string into a descriptive table. Unknown/extra groups
+-- are preserved raw so callers always see the original data.
+function SpotsHandler.parseSpotString(s)
+    if type(s) ~= "string" or s == "" then return nil end
+    local groups = extractGroups(s)
+    if #groups < 4 then return nil end
+
+    local center = parseNumberList(groups[1])
+    local kind = groups[2] and groups[2]:gsub("^%s+", ""):gsub("%s+$", "") or nil
+    local source = parseNumberList(groups[3])
+    local radius = tonumber(groups[4]:match("[-+]?%d+%.?%d*"))
+
+    local rawTail = {}
+    for i = 5, #groups do
+        -- Trim so round-trips keep the canonical "( 1 ), ( 1 ), ( 0 )" spacing
+        -- regardless of how much whitespace the source string carried.
+        table.insert(rawTail, (groups[i]:gsub("^%s+", ""):gsub("%s+$", "")))
+    end
+
+    return {
+        x = center[1],
+        y = center[2],
+        type = (kind == "clone") and "clone" or "heal",
+        source_x = source[1],
+        source_y = source[2],
+        radius = radius,
+        tail = rawTail,
+        raw = s,
+    }
+end
+
+-- Serialize one spot back into the flat format. The tail groups are kept
+-- verbatim from the original entry when available.
+local function buildSpotString(spot)
+    local fmt = string.format
+    local function num(v)
+        return fmt("%.6f", v)
+    end
+
+    local x = clamp01(spot.x)
+    local y = clamp01(spot.y)
+    local radius = tonumber(spot.radius) or 0.05
+    if radius < 0 then radius = 0.05 end
+    if radius > 1 then radius = 1 end
+
+    local kind = (spot.type == "clone") and "clone" or "heal"
+
+    -- Source defaults to an offset left of the spot; Lightroom will usually
+    -- recompute a better one automatically, but a deterministic fallback
+    -- guarantees the heal never samples the spot itself.
+    local srcX = tonumber(spot.source_x)
+    local srcY = tonumber(spot.source_y)
+    if srcX == nil or srcY == nil then
+        srcX = x - (radius * 3)
+        if srcX < 0 then srcX = x + (radius * 3) end
+        if srcX > 1 then srcX = clamp01(x) end
+        srcY = y
+    end
+
+    local tail
+    if type(spot.tail) == "table" and #spot.tail >= 3 then
+        tail = { spot.tail[1], spot.tail[2], spot.tail[3] }
+    else
+        tail = { "1", "1", "0" }
+    end
+
+    return "( " .. num(x) .. ", " .. num(y) .. " ), ( " .. kind .. " ), ( "
+        .. num(srcX) .. ", " .. num(srcY) .. " ), ( " .. num(radius)
+        .. " ), ( " .. tail[1] .. " ), ( " .. tail[2] .. " ), ( " .. tail[3] .. " )"
+end
+
+function SpotsHandler.clamp01(v)
+    return clamp01(v)
+end
+
+-- Normalize whatever getDevelopSettings() returned into an array of strings.
+-- Observed shapes: nil, {}, { "spot1" }, { "spot1", "spot2" }, or a single
+-- string (defensive). Tables of tables (newer formats) are passed through
+-- untouched so data is never corrupted by a guess.
+local function retouchEntriesToTable(retouchInfo)
+    if retouchInfo == nil then return {}, nil end
+    if type(retouchInfo) == "string" then
+        return { retouchInfo }, "string"
+    end
+    if type(retouchInfo) ~= "table" then
+        return {}, nil
+    end
+
+    local strings = {}
+    local others = {}
+    for _, entry in ipairs(retouchInfo) do
+        if type(entry) == "string" then
+            table.insert(strings, entry)
+        else
+            table.insert(others, entry)
+        end
+    end
+    return strings, (next(others) ~= nil) and others or nil
+end
+
+local function readRetouchInfo(photo)
+    local settings = photo:getDevelopSettings()
+    return retouchEntriesToTable(settings.RetouchInfo)
+end
+
+local function applyRetouchInfo(photo, entries, historyName)
+    photo:applyDevelopSettings({
+        EnableRetouch = (#entries > 0),
+        RetouchInfo = entries,
+    }, historyName)
+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
+
+function SpotsHandler.getSpots(args)
+    args = args or {}
+    requirePhotoId(args)
+
+    local catalog = LrApplication.activeCatalog()
+    local photo = resolveOnePhoto(catalog, args.photo_id)
+
+    local entries, others = readRetouchInfo(photo)
+    local spots = {}
+    for _, entry in ipairs(entries) do
+        local parsed = SpotsHandler.parseSpotString(entry)
+        if parsed then
+            table.insert(spots, parsed)
+        else
+            -- Not the classic flat format; surface it raw instead of hiding it.
+            table.insert(spots, { raw = entry, unparsed = true })
+        end
+    end
+
+    Log.info(string.format("get_spots: %d spots on photo %s", #spots, tostring(args.photo_id)))
+
+    return {
+        success = true,
+        photo_id = photo.localIdentifier,
+        count = #spots,
+        spots = spots,
+        additional_raw_entries = others,
+    }
+end
+
+function SpotsHandler.addSpots(args)
+    args = args or {}
+    requirePhotoId(args)
+
+    local newSpots = args.spots
+    if type(newSpots) ~= "table" or #newSpots == 0 then
+        error("spots is required (array of {x, y, radius, type, source_x?, source_y?})")
+    end
+    if #newSpots > MAX_SPOTS_PER_REQUEST then
+        error("spots must contain at most " .. MAX_SPOTS_PER_REQUEST .. " entries")
+    end
+
+    for i, spot in ipairs(newSpots) do
+        if type(spot) ~= "table" or spot.x == nil or spot.y == nil then
+            error("spots[" .. i .. "] must include numeric x and y (normalized 0..1)")
+        end
+        if spot.type ~= nil and spot.type ~= "heal" and spot.type ~= "clone" then
+            error("spots[" .. i .. "].type must be 'heal' or 'clone'")
+        end
+    end
+
+    local catalog = LrApplication.activeCatalog()
+    local photo = resolveOnePhoto(catalog, args.photo_id)
+
+    -- Existing entries are preserved byte-identical.
+    local entries = readRetouchInfo(photo)
+    local beforeCount = #entries
+
+    for _, spot in ipairs(newSpots) do
+        table.insert(entries, buildSpotString(spot))
+    end
+
+    local appliedSettings
+    catalog:withWriteAccessDo("Add Spot Removal", function()
+        applyRetouchInfo(photo, entries, "MCP Add Spots")
+        appliedSettings = true
+    end)
+
+    -- Verify by reading back: if this Lightroom version refuses RetouchInfo
+    -- writes, say so instead of reporting success.
+    local afterEntries, _ = readRetouchInfo(photo)
+    local verified = #afterEntries
+    local took = verified > beforeCount
+
+    Log.info(string.format("add_spots: %d before, %d after on photo %s",
+        beforeCount, verified, tostring(args.photo_id)))
+
+    if not took then
+        return {
+            success = false,
+            photo_id = photo.localIdentifier,
+            before_count = beforeCount,
+            after_count = verified,
+            applied = false,
+            message = "Lightroom did not accept the RetouchInfo write on this version. "
+                .. "Draw one spot manually on the photo, then retry: existing entries are "
+                .. "used as a template and round-trip safely.",
+        }
+    end
+
+    return {
+        success = true,
+        applied = true,
+        photo_id = photo.localIdentifier,
+        before_count = beforeCount,
+        after_count = verified,
+        added = #newSpots,
+        message = string.format("Added %d spot(s); photo now has %d.", #newSpots, verified),
+    }
+end
+
+function SpotsHandler.clearSpots(args)
+    args = args or {}
+    requirePhotoId(args)
+
+    local catalog = LrApplication.activeCatalog()
+    local photo = resolveOnePhoto(catalog, args.photo_id)
+
+    local entries, _ = readRetouchInfo(photo)
+    local beforeCount = #entries
+
+    catalog:withWriteAccessDo("Clear Spot Removal", function()
+        applyRetouchInfo(photo, {}, "MCP Clear Spots")
+    end)
+
+    local afterEntries, _ = readRetouchInfo(photo)
+    local cleared = #afterEntries == 0
+
+    Log.info(string.format("clear_spots: %d before, %d after on photo %s",
+        beforeCount, #afterEntries, tostring(args.photo_id)))
+
+    return {
+        success = cleared,
+        photo_id = photo.localIdentifier,
+        before_count = beforeCount,
+        after_count = #afterEntries,
+        message = cleared
+            and string.format("Removed all %d spot(s).", beforeCount)
+            or string.format("Clear was not verified (%d spots still present); this Lightroom version may require removing them from the Develop panel.", #afterEntries),
+    }
+end
+
+return SpotsHandler

package/dist/LightroomMCP.lrplugin/HandlerWatermark.lua

@@ -0,0 +1,59 @@
+local LrPathUtils = import 'LrPathUtils'
+local LrFileUtils = import 'LrFileUtils'
+
+local Log = require 'Log'
+
+local WatermarkHandler = {}
+
+-- =====================================================================
+-- Watermark presets
+-- =====================================================================
+--
+-- Lightroom stores watermark presets as files under
+-- <appPrefs>/Watermark Presets/<preset name>.watermark, where <appPrefs> is
+-- the root of Lightroom's own preferences folder (getStandardFilePath
+-- ("appPrefs"), i.e. %APPDATA%\Adobe\Lightroom on Windows). Enumerating that
+-- directory gives the exact names the export watermarking option expects.
+
+function WatermarkHandler.listWatermarks(_args)
+    local appPrefs = LrPathUtils.getStandardFilePath("appPrefs")
+    if not appPrefs then
+        error("Could not resolve Lightroom's preferences folder on this system")
+    end
+
+    local presetsDir = LrPathUtils.child(appPrefs, "Watermark Presets")
+
+    local names = {}
+    local ok, entries = pcall(function() return LrFileUtils.directoryContents(presetsDir) end)
+    if ok and type(entries) == "table" then
+        for _, entry in ipairs(entries) do
+            if type(entry) == "string" then
+                local name = entry:match("^(.*)%.watermark$")
+                if name and name ~= "" then
+                    table.insert(names, name)
+                end
+            end
+        end
+    end
+
+    table.sort(names, function(a, b) return a:lower() < b:lower() end)
+
+    Log.info(string.format("list_watermarks: %d presets found", #names))
+
+    local result = {
+        success = true,
+        watermarks = names,
+        count = #names,
+        presets_dir = presetsDir,
+    }
+
+    if #names == 0 then
+        result.message = "No watermark presets found. Create them in Lightroom via "
+            .. "Edit > Edit Watermarks..., then this tool (and export_photos' watermark option) "
+            .. "can reference them by name."
+    end
+
+    return result
+end
+
+return WatermarkHandler

package/dist/LightroomMCP.lrplugin/Info.lua

@@ -0,0 +1,25 @@
+return {
+    LrSdkVersion = 8.0,
+    LrSdkMinimumVersion = 8.0,
+
+    LrToolkitIdentifier = 'com.lightroom.mcp',
+    LrPluginName = "Lightroom MCP AI",
+
+    LrPluginInfoUrl = "https://github.com/pired/lightroom-mcp",
+
+    VERSION = { major=3, minor=1, revision=0, build=0 },
+
+    LrPluginInfoProvider = 'PluginInfoProvider.lua',
+    LrInitPlugin = 'PluginInit.lua',
+    -- LrForceInitPlugin forces eager load on Lr launch, but ONLY if the
+    -- plugin also exposes at least one menu item — see LrLibraryMenuItems
+    -- below. Adobe's own remote_control_socket sample uses this pattern.
+    LrForceInitPlugin = true,
+
+    LrLibraryMenuItems = {
+        {
+            title = "Lightroom MCP — Show Status",
+            file = "MenuShowStatus.lua",
+        },
+    },
+}

package/dist/LightroomMCP.lrplugin/JSON.lua

@@ -0,0 +1,270 @@
+-- Simple JSON encoder/decoder for Lightroom
+local JSON = {}
+
+local SHORT_ESCAPES = {
+    ['\n'] = '\\n',
+    ['\r'] = '\\r',
+    ['\t'] = '\\t',
+    ['\b'] = '\\b',
+    ['\f'] = '\\f',
+}
+
+-- Control characters are illegal raw inside a JSON string, so anything without
+-- a short escape has to go out as \u00XX. Emitting them raw produced responses
+-- the MCP server could not parse.
+local function escapeString(s)
+    local escaped = s:gsub('[\\"]', '\\%0'):gsub('%c', function(c)
+        return SHORT_ESCAPES[c] or string.format('\\u%04x', c:byte())
+    end)
+    return escaped
+end
+
+-- Lightroom runs Lua 5.1: no utf8 library, so encode the code point by hand.
+local function codepointToUtf8(cp)
+    if cp < 0x80 then
+        return string.char(cp)
+    elseif cp < 0x800 then
+        return string.char(0xC0 + math.floor(cp / 0x40), 0x80 + (cp % 0x40))
+    elseif cp < 0x10000 then
+        return string.char(
+            0xE0 + math.floor(cp / 0x1000),
+            0x80 + (math.floor(cp / 0x40) % 0x40),
+            0x80 + (cp % 0x40))
+    end
+    return string.char(
+        0xF0 + math.floor(cp / 0x40000),
+        0x80 + (math.floor(cp / 0x1000) % 0x40),
+        0x80 + (math.floor(cp / 0x40) % 0x40),
+        0x80 + (cp % 0x40))
+end
+
+-- Reads one \uXXXX escape at `pos` (which points at the backslash), pairing a
+-- high surrogate with the low surrogate that follows. A lone surrogate becomes
+-- U+FFFD rather than an error: JSON.stringify emits those for unpaired code
+-- units, and erroring would drop the whole request.
+local function decodeUnicodeEscape(str, pos)
+    local hex = str:sub(pos + 2, pos + 5)
+    if not hex:match('^%x%x%x%x$') then
+        error('Invalid unicode escape: \\u' .. hex)
+    end
+    local cp = tonumber(hex, 16)
+    local nextPos = pos + 6
+
+    if cp >= 0xD800 and cp <= 0xDBFF then
+        if str:sub(nextPos, nextPos + 1) == '\\u' then
+            local lowHex = str:sub(nextPos + 2, nextPos + 5)
+            local low = lowHex:match('^%x%x%x%x$') and tonumber(lowHex, 16)
+            if low and low >= 0xDC00 and low <= 0xDFFF then
+                cp = 0x10000 + (cp - 0xD800) * 0x400 + (low - 0xDC00)
+                nextPos = nextPos + 6
+            else
+                cp = 0xFFFD
+            end
+        else
+            cp = 0xFFFD
+        end
+    elseif cp >= 0xDC00 and cp <= 0xDFFF then
+        cp = 0xFFFD
+    end
+
+    return codepointToUtf8(cp), nextPos
+end
+
+function JSON:encode(obj)
+    local function encode_value(v)
+        local t = type(v)
+        if t == "string" then
+            return '"' .. escapeString(v) .. '"'
+        elseif t == "number" or t == "boolean" then
+            return tostring(v)
+        elseif t == "table" then
+            -- An empty Lua table is ambiguous. Encoding it as {} broke every
+            -- client iterating an empty result list (changes.map is not a
+            -- function); an empty object rendered as [] is harmless by
+            -- comparison, so empty means array here.
+            local is_array = next(v) == nil or #v > 0
+            if is_array then
+                local values = {}
+                for i, item in ipairs(v) do
+                    table.insert(values, encode_value(item))
+                end
+                return "[" .. table.concat(values, ",") .. "]"
+            else
+                local key_value_pairs = {}
+                for k, val in pairs(v) do
+                    table.insert(key_value_pairs, encode_value(tostring(k)) .. ":" .. encode_value(val))
+                end
+                return "{" .. table.concat(key_value_pairs, ",") .. "}"
+            end
+        elseif t == "nil" then
+            return "null"
+        else
+            return '"' .. tostring(v) .. '"'
+        end
+    end
+    return encode_value(obj)
+end
+
+function JSON:decode(str)
+    local pos = 1
+
+    local function skip_whitespace()
+        while pos <= #str and str:sub(pos, pos):match("%s") do
+            pos = pos + 1
+        end
+    end
+
+    local function decode_value()
+        skip_whitespace()
+        local char = str:sub(pos, pos)
+
+        if char == '"' then
+            -- String
+            pos = pos + 1
+            local chars = {}
+            while pos <= #str do
+                local current = str:sub(pos, pos)
+                if current == '"' then
+                    pos = pos + 1
+                    return table.concat(chars)
+                elseif current == '\\' then
+                    local escaped = str:sub(pos + 1, pos + 1)
+                    if escaped == 'u' then
+                        local text, nextPos = decodeUnicodeEscape(str, pos)
+                        table.insert(chars, text)
+                        pos = nextPos
+                    else
+                        if escaped == '"' or escaped == '\\' or escaped == '/' then
+                            table.insert(chars, escaped)
+                        elseif escaped == 'n' then
+                            table.insert(chars, '\n')
+                        elseif escaped == 'r' then
+                            table.insert(chars, '\r')
+                        elseif escaped == 't' then
+                            table.insert(chars, '\t')
+                        elseif escaped == 'b' then
+                            table.insert(chars, string.char(8))
+                        elseif escaped == 'f' then
+                            table.insert(chars, string.char(12))
+                        else
+                            error("Invalid escape sequence: \\" .. tostring(escaped))
+                        end
+                        pos = pos + 2
+                    end
+                else
+                    table.insert(chars, current)
+                    pos = pos + 1
+                end
+            end
+            error("Unterminated string")
+        elseif char == '{' then
+            -- Object
+            pos = pos + 1
+            local obj = {}
+            skip_whitespace()
+            if str:sub(pos, pos) == '}' then
+                pos = pos + 1
+                return obj
+            end
+            while true do
+                skip_whitespace()
+                local key = decode_value()
+                skip_whitespace()
+                if str:sub(pos, pos) ~= ':' then
+                    error("Expected ':'")
+                end
+                pos = pos + 1
+                local value = decode_value()
+                obj[key] = value
+                skip_whitespace()
+                char = str:sub(pos, pos)
+                if char == '}' then
+                    pos = pos + 1
+                    break
+                elseif char == ',' then
+                    pos = pos + 1
+                else
+                    error("Expected ',' or '}'")
+                end
+            end
+            return obj
+        elseif char == '[' then
+            -- Array
+            pos = pos + 1
+            local arr = {}
+            skip_whitespace()
+            if str:sub(pos, pos) == ']' then
+                pos = pos + 1
+                return arr
+            end
+            while true do
+                local value = decode_value()
+                table.insert(arr, value)
+                skip_whitespace()
+                char = str:sub(pos, pos)
+                if char == ']' then
+                    pos = pos + 1
+                    break
+                elseif char == ',' then
+                    pos = pos + 1
+                else
+                    error("Expected ',' or ']'")
+                end
+            end
+            return arr
+        elseif char == 't' and str:sub(pos, pos + 3) == 'true' then
+            pos = pos + 4
+            return true
+        elseif char == 'f' and str:sub(pos, pos + 4) == 'false' then
+            pos = pos + 5
+            return false
+        elseif char == 'n' and str:sub(pos, pos + 3) == 'null' then
+            pos = pos + 4
+            return nil
+        elseif char:match("[%-0-9]") then
+            -- Number
+            local start = pos
+            if char == '-' then
+                pos = pos + 1
+            end
+            while pos <= #str and str:sub(pos, pos):match("[0-9]") do
+                pos = pos + 1
+            end
+            if pos <= #str and str:sub(pos, pos) == '.' then
+                pos = pos + 1
+                while pos <= #str and str:sub(pos, pos):match("[0-9]") do
+                    pos = pos + 1
+                end
+            end
+            -- Exponent form is core JSON and JSON.stringify emits it for
+            -- magnitudes past 1e21. Without this the scanner stopped at the
+            -- 'e', and the whole request failed to decode.
+            local exponent = str:sub(pos, pos)
+            if exponent == 'e' or exponent == 'E' then
+                pos = pos + 1
+                local sign = str:sub(pos, pos)
+                if sign == '+' or sign == '-' then
+                    pos = pos + 1
+                end
+                while str:sub(pos, pos):match("[0-9]") do
+                    pos = pos + 1
+                end
+            end
+            -- tonumber returns nil for a malformed number such as "1e", "1e+"
+            -- or a lone "-". Returning that nil would drop the field silently
+            -- and read as null; a malformed number is a parse error.
+            local numberText = str:sub(start, pos - 1)
+            local value = tonumber(numberText)
+            if value == nil then
+                error("Invalid number: " .. numberText)
+            end
+            return value
+        else
+            error("Unexpected character: " .. char)
+        end
+    end
+
+    return decode_value()
+end
+
+return JSON