@pired/lightroom-mcp 3.1.0

package/dist/LightroomMCP.lrplugin/HandlerCatalog.lua

@@ -0,0 +1,256 @@
+-- HandlerCatalog.lua
+-- Catalog-level inventory tools: folders, keyword tree and the Library view
+-- filter. Ported from znznzna/lightroom-cli (MIT) CatalogModule.lua and
+-- adapted to this plugin's gate/verification conventions.
+
+local LrApplication = import 'LrApplication'
+
+local Log = require 'Log'
+
+local CatalogHandler = {}
+
+-- =====================================================================
+-- list_folders — folder tree with photo counts
+-- =====================================================================
+--
+-- LrCatalog:getFolders() returns the root folders shown in the Folders
+-- panel; each LrFolder exposes getPath()/getName()/getPhotos(false|true)/
+-- getChildren()/getParent(). Folders have no localIdentifier, so the path
+-- doubles as the id (same convention as lightroom-cli). The tree is walked
+-- inside a read gate — these are plain catalog reads like the collection
+-- enumeration in HandlerCollections (unlike getAllPhotos/findPhotos, they
+-- do not yield, see issues #124/#134 for the calls that must stay outside).
+
+function CatalogHandler.listFolders(args)
+    args = args or {}
+    local includeSubfolders = args.include_subfolders == true
+
+    local catalog = LrApplication.activeCatalog()
+
+    local folders = nil
+    catalog:withReadAccessDo(function()
+        folders = catalog:getFolders() or {}
+    end)
+
+    local function describeFolder(folder, depth)
+        local path = folder:getPath()
+        local entry = {
+            id = path,
+            name = folder:getName(),
+            path = path,
+            type = folder:type(),
+            depth = depth,
+            photo_count = #(folder:getPhotos(false) or {}),
+            total_photo_count = #(folder:getPhotos(true) or {}),
+        }
+
+        local parent = folder:getParent()
+        if parent then
+            entry.parent = parent:getPath()
+        end
+
+        if includeSubfolders then
+            entry.subfolders = {}
+            local children = folder:getChildren() or {}
+            for _, child in ipairs(children) do
+                table.insert(entry.subfolders, describeFolder(child, depth + 1))
+            end
+        end
+
+        return entry
+    end
+
+    local result = {}
+    for _, folder in ipairs(folders) do
+        table.insert(result, describeFolder(folder, 0))
+    end
+
+    Log.info(string.format("listFolders: %d root folder(s), subfolders=%s",
+        #result, tostring(includeSubfolders)))
+
+    return {
+        success = true,
+        folders = result,
+        count = #result,
+        include_subfolders = includeSubfolders,
+        message = string.format("Found %d root folder(s)", #result),
+    }
+end
+
+-- =====================================================================
+-- list_keywords — keyword tree entries with photo counts
+-- =====================================================================
+--
+-- LrCatalog:getKeywords() returns the top-level keyword objects; each one
+-- exposes getName()/getPhotos(). The SDK does not expose a child-keyword
+-- walk, so this lists the flat top-level set (same coverage as
+-- lightroom-cli's `catalog keywords`). Use set_keywords to attach them.
+
+function CatalogHandler.listKeywords(args)
+    args = args or {}
+
+    local catalog = LrApplication.activeCatalog()
+
+    local keywords = nil
+    catalog:withReadAccessDo(function()
+        keywords = catalog:getKeywords() or {}
+    end)
+
+    local result = {}
+    for _, keyword in ipairs(keywords) do
+        local ok, name = pcall(function() return keyword:getName() end)
+        local okCount, photos = pcall(function() return keyword:getPhotos() end)
+        table.insert(result, {
+            id = keyword.localIdentifier,
+            name = ok and name or nil,
+            photo_count = (okCount and type(photos) == "table") and #photos or 0,
+        })
+    end
+
+    table.sort(result, function(a, b) return tostring(a.name) < tostring(b.name) end)
+
+    Log.info(string.format("listKeywords: %d keyword(s)", #result))
+
+    return {
+        success = true,
+        keywords = result,
+        count = #result,
+        message = string.format("Found %d top-level keyword(s)", #result),
+    }
+end
+
+-- =====================================================================
+-- manage_view_filter — Library grid filter (get / set / clear)
+-- =====================================================================
+--
+-- catalog:setViewFilter(filterDesc) applies the Library filter bar; the
+-- descriptor uses the same { combine, { criteria, operation, value } }
+-- shape as findPhotos (documented for LrCatalog:setViewFilter in the SDK).
+-- lightroom-cli calls it without a write gate (their tested
+-- implementation, CatalogModule.lua:1637) — matched here, pcall-wrapped
+-- so an LrC version that does gate it surfaces as an honest error instead
+-- of wedging the bridge. `clear` passes an empty descriptor, which LrC
+-- treats as "no filter" (the Filters Off state).
+
+local MAX_VIEW_FILTER_RULES = 20
+
+local function buildViewFilterDesc(rules, combine)
+    local desc = { combine = combine or "intersect" }
+    for i, rule in ipairs(rules) do
+        if type(rule) ~= "table" then
+            error("rules[" .. i .. "] must be an object", 0)
+        end
+        if type(rule.criteria) ~= "string" or rule.criteria == "" then
+            error("rules[" .. i .. "].criteria is required (e.g. 'keywords', 'rating', 'filename', 'cameraModel', 'copyName')", 0)
+        end
+        if type(rule.operation) ~= "string" or rule.operation == "" then
+            error("rules[" .. i .. "].operation is required (e.g. 'all', 'any', '==', '>=', 'in', 'startsWith')", 0)
+        end
+        if rule.value == nil then
+            error("rules[" .. i .. "].value is required", 0)
+        end
+        local r = {
+            criteria = rule.criteria,
+            operation = rule.operation,
+            value = tostring(rule.value),
+        }
+        if rule.value2 ~= nil then r.value2 = tostring(rule.value2) end
+        table.insert(desc, r)
+    end
+    return desc
+end
+
+function CatalogHandler.manageViewFilter(args)
+    args = args or {}
+    local action = args.action or "get"
+
+    if action ~= "get" and action ~= "set" and action ~= "clear" then
+        error("action must be 'get', 'set' or 'clear'", 0)
+    end
+
+    local catalog = LrApplication.activeCatalog()
+
+    if action == "get" then
+        local current = nil
+        local ok, err = pcall(function()
+            catalog:withReadAccessDo(function()
+                current = catalog:getCurrentViewFilter()
+            end)
+        end)
+        if not ok then
+            -- Fall back to a bare call the way lightroom-cli reads it.
+            local bareOk, bareErr = pcall(function()
+                return catalog:getCurrentViewFilter()
+            end)
+            if not bareOk then
+                error("getCurrentViewFilter failed: " .. tostring(err) .. " / " .. tostring(bareErr), 0)
+            end
+            current = bareErr
+        end
+        return {
+            success = true,
+            action = "get",
+            filter = current,
+            has_filter = type(current) == "table" and next(current) ~= nil,
+            message = "Current Library view filter read"
+                .. (type(current) == "table" and next(current) ~= nil and "" or " (no filter active)"),
+        }
+    end
+
+    if action == "set" then
+        local rules = args.rules
+        if type(rules) ~= "table" or #rules == 0 then
+            error("rules is required when action is 'set'", 0)
+        end
+        if #rules > MAX_VIEW_FILTER_RULES then
+            error("rules must contain at most " .. MAX_VIEW_FILTER_RULES .. " entries", 0)
+        end
+        local combine = args.combine or "intersect"
+        if combine ~= "intersect" and combine ~= "union" then
+            error("combine must be 'intersect' (AND, default) or 'union' (OR)", 0)
+        end
+
+        local desc = buildViewFilterDesc(rules, combine)
+
+        local ok, err = pcall(function()
+            catalog:setViewFilter(desc)
+        end)
+        if not ok then
+            error("setViewFilter failed: " .. tostring(err), 0)
+        end
+
+        Log.info(string.format("manageViewFilter: set %d rule(s)", #rules))
+
+        return {
+            success = true,
+            action = "set",
+            rule_count = #rules,
+            combine = combine,
+            message = string.format("Library view filter set (%d rule(s))", #rules),
+        }
+    end
+
+    -- action == "clear"
+    local ok, err = pcall(function()
+        catalog:setViewFilter(nil)
+    end)
+    if not ok then
+        -- Some LrC builds reject nil; an empty descriptor is the fallback.
+        local emptyOk, emptyErr = pcall(function()
+            catalog:setViewFilter({})
+        end)
+        if not emptyOk then
+            error("could not clear the view filter: " .. tostring(err) .. " / " .. tostring(emptyErr), 0)
+        end
+    end
+
+    Log.info("manageViewFilter: cleared")
+
+    return {
+        success = true,
+        action = "clear",
+        message = "Library view filter cleared",
+    }
+end
+
+return CatalogHandler

package/dist/LightroomMCP.lrplugin/HandlerCollections.lua

@@ -0,0 +1,337 @@
+local LrApplication = import 'LrApplication'
+
+local PhotoLookup = require 'PhotoLookup'
+local Log = require 'Log'
+
+local CollectionsHandler = {}
+
+function CollectionsHandler.listCollections(args)
+    args = args or {}
+    local catalog = LrApplication.activeCatalog()
+    local all = {}
+
+    local limit = tonumber(args.limit) or 100
+    if limit < 0 then limit = 0 end
+    local offset = tonumber(args.offset) or 0
+    if offset < 0 then offset = 0 end
+
+    catalog:withReadAccessDo(function()
+        for _, collection in ipairs(catalog:getChildCollections()) do
+            table.insert(all, {
+                name = collection:getName(),
+                type = collection:type(),
+                photoCount = #collection:getPhotos(),
+            })
+        end
+
+        local function addCollectionsFromSet(collSet, prefix)
+            for _, coll in ipairs(collSet:getChildCollections()) do
+                table.insert(all, {
+                    name = prefix .. coll:getName(),
+                    parent = collSet:getName(),
+                    type = coll:type(),
+                    photoCount = #coll:getPhotos(),
+                })
+            end
+            for _, childSet in ipairs(collSet:getChildCollectionSets()) do
+                addCollectionsFromSet(childSet, prefix .. childSet:getName() .. " / ")
+            end
+        end
+
+        for _, set in ipairs(catalog:getChildCollectionSets()) do
+            addCollectionsFromSet(set, set:getName() .. " / ")
+        end
+    end)
+
+    local total = #all
+    local last = math.min(offset + limit, total)
+    local slice = {}
+    for i = offset + 1, last do
+        table.insert(slice, all[i])
+    end
+
+    Log.info(string.format("Found %d collections, returning %d (offset=%d, limit=%d)",
+        total, #slice, offset, limit))
+
+    return {
+        count = total,
+        collections = slice,
+        has_more = (offset + #slice) < total,
+    }
+end
+
+function CollectionsHandler.createCollection(args)
+    if type(args.name) ~= "string" or args.name:match("^%s*$") then
+        error("name is required")
+    end
+
+    local catalog = LrApplication.activeCatalog()
+    local collectionName = args.name
+
+    -- add_to_collection addresses collections by name, so a second collection
+    -- with the same name makes that lookup ambiguous: photos would silently
+    -- land in whichever one enumerates first.
+    for _, collection in ipairs(catalog:getChildCollections()) do
+        if collection:getName() == collectionName then
+            error("Collection already exists: " .. collectionName)
+        end
+    end
+
+    catalog:withWriteAccessDo("Create Collection", function()
+        catalog:createCollection(collectionName)
+        Log.info("Created collection: " .. collectionName)
+    end)
+
+    return {
+        success = true,
+        message = "Collection created: " .. collectionName
+    }
+end
+
+function CollectionsHandler.addToCollection(args)
+    if not args.collection_name then
+        error("collection_name is required")
+    end
+
+    if not args.photo_ids or #args.photo_ids == 0 then
+        error("photo_ids is required")
+    end
+
+    local catalog = LrApplication.activeCatalog()
+    local addedCount = 0
+    local missingIds = {}
+    local missingCount = 0
+
+    catalog:withWriteAccessDo("Add Photos to Collection", function()
+        -- Find the collection
+        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
+
+        -- Also search in collection sets
+        if not targetCollection then
+            local collectionSets = catalog:getChildCollectionSets()
+            local function findInSet(collSet)
+                local setCollections = collSet:getChildCollections()
+                for _, coll in ipairs(setCollections) do
+                    if coll:getName() == args.collection_name then
+                        return coll
+                    end
+                end
+
+                local childSets = collSet:getChildCollectionSets()
+                for _, childSet in ipairs(childSets) do
+                    local found = findInSet(childSet)
+                    if found then
+                        return found
+                    end
+                end
+
+                return nil
+            end
+
+            for _, set in ipairs(collectionSets) do
+                targetCollection = findInSet(set)
+                if targetCollection then
+                    break
+                end
+            end
+        end
+
+        if not targetCollection then
+            error("Collection not found: " .. args.collection_name)
+        end
+
+        -- Find and add photos
+        local photosToAdd = {}
+        local resolved = PhotoLookup.resolveMany(catalog, args.photo_ids)
+        for _, entry in ipairs(resolved) do
+            if entry.photo then
+                table.insert(photosToAdd, entry.photo)
+            else
+                missingCount = missingCount + 1
+                missingIds[missingCount] = tostring(entry.id)
+            end
+        end
+
+        if #photosToAdd > 0 then
+            targetCollection:addPhotos(photosToAdd)
+            addedCount = #photosToAdd
+        end
+    end)
+
+    Log.info(string.format("Added %d photos to collection: %s", addedCount, args.collection_name))
+
+    -- Unresolvable ids used to vanish into a "success" with added=0, leaving the
+    -- caller no way to tell a typo'd id from an empty add.
+    return {
+        success = true,
+        added = addedCount,
+        missing = missingIds,
+        message = string.format("Added %d photos to collection (%d ids not found)",
+            addedCount, missingCount)
+    }
+end
+
+-- =====================================================================
+-- create_collection_set — folder that groups collections
+-- =====================================================================
+--
+-- catalog:createCollectionSet(name, targetSet, position) works like
+-- createCollection. The parent is addressed by name like every other
+-- collection tool here; an optional parent set keeps collections
+-- organized in the Catalog panel.
+
+function CollectionsHandler.createCollectionSet(args)
+    if type(args.name) ~= "string" or args.name:match("^%s*$") then
+        error("name is required")
+    end
+
+    local parentName = args.parent_set_name
+
+    local catalog = LrApplication.activeCatalog()
+
+    local parentSet = nil
+    if parentName ~= nil and parentName ~= "" then
+        catalog:withReadAccessDo(function()
+            for _, set in ipairs(catalog:getChildCollectionSets()) do
+                if set:getName() == parentName then
+                    parentSet = set
+                    break
+                end
+            end
+        end)
+        if not parentSet then
+            error("Parent collection set not found: " .. parentName)
+        end
+    end
+
+    local createdSet = nil
+    catalog:withWriteAccessDo("Create Collection Set", function()
+        createdSet = catalog:createCollectionSet(args.name, parentSet, true)
+    end)
+
+    if not createdSet then
+        error("createCollectionSet returned no set (duplicate name?)")
+    end
+
+    local verifiedName = nil
+    pcall(function() verifiedName = createdSet:getName() end)
+
+    Log.info(string.format("Created collection set '%s'", args.name))
+
+    local result = {
+        success = true,
+        name = args.name,
+        verified_name = verifiedName,
+        parent = parentName,
+        message = string.format("Collection set created: %s", args.name),
+    }
+    if verifiedName == nil then
+        result.warning = "Set created but its name could not be read back."
+    end
+    return result
+end
+
+-- =====================================================================
+-- get_collection_photos — photos inside a named collection
+-- =====================================================================
+--
+-- The same recursive by-name lookup addToCollection uses, then a paginated
+-- listing with the fields harnesses need to keep working (id, path,
+-- filename, rating, label). Ported from lightroom-cli getCollectionPhotos,
+-- which addresses collections by localIdentifier; names fit this fork's
+-- conventions better (list_collections exposes names).
+
+function CollectionsHandler.getCollectionPhotos(args)
+    if type(args.collection_name) ~= "string" or args.collection_name == "" then
+        error("collection_name is required")
+    end
+
+    local limit = math.floor(tonumber(args.limit) or 100)
+    if limit < 0 then limit = 0 end
+    local offset = math.floor(tonumber(args.offset) or 0)
+    if offset < 0 then offset = 0 end
+
+    local catalog = LrApplication.activeCatalog()
+
+    -- Find the collection by name, top level first, then inside sets
+    -- (recursive, same walk as addToCollection).
+    local targetCollection = nil
+    catalog:withReadAccessDo(function()
+        for _, collection in ipairs(catalog:getChildCollections()) do
+            if collection:getName() == args.collection_name then
+                targetCollection = collection
+                break
+            end
+        end
+
+        if not targetCollection then
+            local function findInSet(collSet)
+                for _, coll in ipairs(collSet:getChildCollections()) do
+                    if coll:getName() == args.collection_name then
+                        return coll
+                    end
+                end
+                for _, childSet in ipairs(collSet:getChildCollectionSets()) do
+                    local found = findInSet(childSet)
+                    if found then return found end
+                end
+                return nil
+            end
+
+            for _, set in ipairs(catalog:getChildCollectionSets()) do
+                targetCollection = findInSet(set)
+                if targetCollection then break end
+            end
+        end
+    end)
+
+    if not targetCollection then
+        error("Collection not found: " .. args.collection_name)
+    end
+
+    local allPhotos = nil
+    catalog:withReadAccessDo(function()
+        allPhotos = targetCollection:getPhotos() or {}
+    end)
+
+    local total = #allPhotos
+
+    local results = {}
+    local last = math.min(offset + limit, total)
+    catalog:withReadAccessDo(function()
+        for i = offset + 1, last do
+            local photo = allPhotos[i]
+            table.insert(results, {
+                id = photo.localIdentifier,
+                path = photo:getRawMetadata('path'),
+                filename = photo:getFormattedMetadata('fileName'),
+                rating = photo:getRawMetadata('rating'),
+                color_label = photo:getRawMetadata('label'),
+            })
+        end
+    end)
+
+    Log.info(string.format("getCollectionPhotos('%s'): %d photo(s), returning %d",
+        args.collection_name, total, #results))
+
+    return {
+        success = true,
+        collection = args.collection_name,
+        count = total,
+        photos = results,
+        returned = #results,
+        offset = offset,
+        has_more = (offset + #results) < total,
+        message = string.format("Collection '%s' has %d photo(s)", args.collection_name, total),
+    }
+end
+
+return CollectionsHandler