This is page 2 of 5. Use http://codebase.md/mikechambers/adb-mcp?lines=false&page={x} to view the full context.
# Directory Structure
```
├── .gitattributes
├── .gitignore
├── adb-proxy-socket
│ ├── .gitignore
│ ├── package-lock.json
│ ├── package.json
│ ├── proxy.js
│ └── README.md
├── cep
│ ├── com.mikechambers.ae
│ │ ├── .debug
│ │ ├── commands.js
│ │ ├── CSXS
│ │ │ └── manifest.xml
│ │ ├── index.html
│ │ ├── jsx
│ │ │ └── json-polyfill.jsx
│ │ ├── lib
│ │ │ └── CSInterface.js
│ │ ├── main.js
│ │ └── style.css
│ └── com.mikechambers.ai
│ ├── .debug
│ ├── commands.js
│ ├── CSXS
│ │ └── manifest.xml
│ ├── index.html
│ ├── jsx
│ │ ├── json-polyfill.jsx
│ │ └── utils.jsx
│ ├── lib
│ │ └── CSInterface.js
│ ├── main.js
│ └── style.css
├── dxt
│ ├── build
│ ├── pr
│ │ └── manifest.json
│ └── ps
│ └── manifest.json
├── images
│ └── claud-attach-mcp.png
├── LICENSE.md
├── mcp
│ ├── .gitignore
│ ├── ae-mcp.py
│ ├── ai-mcp.py
│ ├── core.py
│ ├── fonts.py
│ ├── id-mcp.py
│ ├── logger.py
│ ├── pr-mcp.py
│ ├── ps-batch-play.py
│ ├── ps-mcp.py
│ ├── pyproject.toml
│ ├── requirements.txt
│ ├── socket_client.py
│ └── uv.lock
├── package-lock.json
├── README.md
└── uxp
├── id
│ ├── commands
│ │ └── index.js
│ ├── icons
│ │ ├── [email protected]
│ │ ├── [email protected]
│ │ ├── [email protected]
│ │ └── [email protected]
│ ├── index.html
│ ├── LICENSE
│ ├── main.js
│ ├── manifest.json
│ ├── package.json
│ ├── socket.io.js
│ └── style.css
├── pr
│ ├── commands
│ │ ├── consts.js
│ │ ├── core.js
│ │ ├── index.js
│ │ └── utils.js
│ ├── icons
│ │ ├── [email protected]
│ │ ├── [email protected]
│ │ ├── [email protected]
│ │ └── [email protected]
│ ├── index.html
│ ├── LICENSE
│ ├── main.js
│ ├── manifest.json
│ ├── package.json
│ ├── socket.io.js
│ └── style.css
└── ps
├── commands
│ ├── adjustment_layers.js
│ ├── core.js
│ ├── filters.js
│ ├── index.js
│ ├── layer_styles.js
│ ├── layers.js
│ ├── selection.js
│ └── utils.js
├── icons
│ ├── [email protected]
│ ├── [email protected]
│ ├── [email protected]
│ └── [email protected]
├── index.html
├── LICENSE
├── main.js
├── manifest.json
├── package.json
├── socket.io.js
└── style.css
```
# Files
--------------------------------------------------------------------------------
/uxp/pr/commands/core.js:
--------------------------------------------------------------------------------
```javascript
const fs = require("uxp").storage.localFileSystem;
const app = require("premierepro");
const constants = require("premierepro").Constants;
const {BLEND_MODES, TRACK_TYPE } = require("./consts.js")
const {
_getSequenceFromId,
_setActiveSequence,
setParam,
getParam,
addEffect,
findProjectItem,
execute,
getTrack,
getTrackItems
} = require("./utils.js")
const saveProject = async (command) => {
let project = await app.Project.getActiveProject()
project.save()
}
const saveProjectAs = async (command) => {
let project = await app.Project.getActiveProject()
const options = command.options;
const filePath = options.filePath;
project.saveAs(filePath)
}
const openProject = async (command) => {
const options = command.options;
const filePath = options.filePath;
await app.Project.open(filePath);
}
const importMedia = async (command) => {
let options = command.options
let paths = command.options.filePaths
let project = await app.Project.getActiveProject()
let root = await project.getRootItem()
let originalItems = await root.getItems()
//import everything into root
let rootFolderItems = await project.getRootItem()
let success = await project.importFiles(paths, true, rootFolderItems)
//TODO: what is not success?
let updatedItems = await root.getItems()
const addedItems = updatedItems.filter(
updatedItem => !originalItems.some(originalItem => originalItem.name === updatedItem.name)
);
let addedProjectItems = [];
for (const p of addedItems) {
addedProjectItems.push({ name: p.name });
}
return { addedProjectItems };
}
//note: right now, we just always add to the active sequence. Need to add support
//for specifying sequence
const addMediaToSequence = async (command) => {
let options = command.options
let itemName = options.itemName
let id = options.sequenceId
let project = await app.Project.getActiveProject()
let sequence = await _getSequenceFromId(id)
let insertItem = await findProjectItem(itemName, project)
let editor = await app.SequenceEditor.getEditor(sequence)
const insertionTime = await app.TickTime.createWithTicks(options.insertionTimeTicks.toString());
const videoTrackIndex = options.videoTrackIndex
const audioTrackIndex = options.audioTrackIndex
//not sure what this does
const limitShift = false
//let f = ((options.overwrite) ? editor.createOverwriteItemAction : editor.createInsertProjectItemAction).bind(editor)
//let action = f(insertItem, insertionTime, videoTrackIndex, audioTrackIndex, limitShift)
execute(() => {
let action = editor.createOverwriteItemAction(insertItem, insertionTime, videoTrackIndex, audioTrackIndex)
return [action]
}, project)
}
const setAudioTrackMute = async (command) => {
let options = command.options
let id = options.sequenceId
let sequence = await _getSequenceFromId(id)
let track = await sequence.getTrack(options.audioTrackIndex, TRACK_TYPE.AUDIO)
track.setMute(options.mute)
}
const setVideoClipProperties = async (command) => {
const options = command.options
let id = options.sequenceId
let project = await app.Project.getActiveProject()
let sequence = await _getSequenceFromId(id)
if(!sequence) {
throw new Error(`setVideoClipProperties : Requires an active sequence.`)
}
let trackItem = await getTrack(sequence, options.videoTrackIndex, options.trackItemIndex, TRACK_TYPE.VIDEO)
let opacityParam = await getParam(trackItem, "AE.ADBE Opacity", "Opacity")
let opacityKeyframe = await opacityParam.createKeyframe(options.opacity)
let blendModeParam = await getParam(trackItem, "AE.ADBE Opacity", "Blend Mode")
let mode = BLEND_MODES[options.blendMode.toUpperCase()]
let blendModeKeyframe = await blendModeParam.createKeyframe(mode)
execute(() => {
let opacityAction = opacityParam.createSetValueAction(opacityKeyframe);
let blendModeAction = blendModeParam.createSetValueAction(blendModeKeyframe);
return [opacityAction, blendModeAction]
}, project)
// /AE.ADBE Opacity
//Opacity
//Blend Mode
}
const appendVideoFilter = async (command) => {
let options = command.options
let id = options.sequenceId
let sequence = await _getSequenceFromId(id)
if(!sequence) {
throw new Error(`appendVideoFilter : Requires an active sequence.`)
}
let trackItem = await getTrackTrack(sequence, options.videoTrackIndex, options.trackItemIndex, TRACK_TYPE.VIDEO)
let effectName = options.effectName
let properties = options.properties
let d = await addEffect(trackItem, effectName)
for(const p of properties) {
console.log(p.value)
await setParam(trackItem, effectName, p.name, p.value)
}
}
const setActiveSequence = async (command) => {
let options = command.options
let id = options.sequenceId
let sequence = await _getSequenceFromId(id)
await _setActiveSequence(sequence)
}
const createProject = async (command) => {
let options = command.options
let path = options.path
let name = options.name
if (!path.endsWith('/')) {
path = path + '/';
}
//todo: this will open a dialog if directory doesnt exist
let project = await app.Project.createProject(`${path}${name}.prproj`)
if(!project) {
throw new Error("createProject : Could not create project. Check that the directory path exists and try again.")
}
//create a default sequence and set it as active
//let sequence = await project.createSequence("default")
//await project.setActiveSequence(sequence)
}
const _exportFrame = async (sequence, filePath, seconds) => {
const fileType = filePath.split('.').pop()
let size = await sequence.getFrameSize()
let p = window.path.parse(filePath)
let t = app.TickTime.createWithSeconds(seconds)
let out = await app.Exporter.exportSequenceFrame(sequence, t, p.base, p.dir, size.width, size.height)
let ps = `${p.dir}${window.path.sep}${p.base}`
let outPath = `${ps}.${fileType}`
if(!out) {
throw new Error(`exportFrame : Could not save frame to [${outPath}]`);
}
return outPath
}
const exportFrame = async (command) => {
const options = command.options;
let id = options.sequenceId;
let filePath = options.filePath;
let seconds = options.seconds;
let sequence = await _getSequenceFromId(id);
const outPath = await _exportFrame(sequence, filePath, seconds);
return {"filePath": outPath}
}
const setClipDisabled = async (command) => {
const options = command.options;
const id = options.sequenceId;
const trackIndex = options.trackIndex;
const trackItemIndex = options.trackItemIndex;
const trackType = options.trackType;
let project = await app.Project.getActiveProject()
let sequence = await _getSequenceFromId(id)
if(!sequence) {
throw new Error(`setClipDisabled : Requires an active sequence.`)
}
let trackItem = await getTrack(sequence, trackIndex, trackItemIndex, trackType)
execute(() => {
let action = trackItem.createSetDisabledAction(options.disabled)
return [action]
}, project)
}
const appendVideoTransition = async (command) => {
let options = command.options
let id = options.sequenceId
let project = await app.Project.getActiveProject()
let sequence = await _getSequenceFromId(id)
if(!sequence) {
throw new Error(`appendVideoTransition : Requires an active sequence.`)
}
let trackItem = await getTrack(sequence, options.videoTrackIndex, options.trackItemIndex,TRACK_TYPE.VIDEO)
let transition = await app.TransitionFactory.createVideoTransition(options.transitionName);
let transitionOptions = new app.AddTransitionOptions()
transitionOptions.setApplyToStart(false)
const time = await app.TickTime.createWithSeconds(options.duration)
transitionOptions.setDuration(time)
transitionOptions.setTransitionAlignment(options.clipAlignment)
execute(() => {
let action = trackItem.createAddVideoTransitionAction(transition, transitionOptions)
return [action]
}, project)
}
const getProjectInfo = async (command) => {
return {}
}
const createSequenceFromMedia = async (command) => {
let options = command.options
let itemNames = options.itemNames
let sequenceName = options.sequenceName
let project = await app.Project.getActiveProject()
let found = false
try {
await findProjectItem(sequenceName, project)
found = true
} catch {
//do nothing
}
if(found) {
throw Error(`createSequenceFromMedia : sequence name [${sequenceName}] is already in use`)
}
let items = []
for (const name of itemNames) {
//this is a little inefficient
let insertItem = await findProjectItem(name, project)
items.push(insertItem)
}
let root = await project.getRootItem()
let sequence = await project.createSequenceFromMedia(sequenceName, items, root)
await _setActiveSequence(sequence)
}
const setClipStartEndTimes = async (command) => {
const options = command.options;
const sequenceId = options.sequenceId;
const trackIndex = options.trackIndex;
const trackItemIndex = options.trackItemIndex;
const startTimeTicks = options.startTimeTicks;
const endTimeTicks = options.endTimeTicks;
const trackType = options.trackType
const sequence = await _getSequenceFromId(sequenceId)
let trackItem = await getTrack(sequence, trackIndex, trackItemIndex, trackType)
const startTick = await app.TickTime.createWithTicks(startTimeTicks.toString());
const endTick = await app.TickTime.createWithTicks(endTimeTicks.toString());;
let project = await app.Project.getActiveProject();
execute(() => {
let out = []
out.push(trackItem.createSetStartAction(startTick));
out.push(trackItem.createSetEndAction(endTick))
return out
}, project)
}
const closeGapsOnSequence = async(command) => {
const options = command.options
const sequenceId = options.sequenceId;
const trackIndex = options.trackIndex;
const trackType = options.trackType;
let sequence = await _getSequenceFromId(sequenceId)
let out = await _closeGapsOnSequence(sequence, trackIndex, trackType)
return out
}
const _closeGapsOnSequence = async (sequence, trackIndex, trackType) => {
let project = await app.Project.getActiveProject()
let items = await getTrackItems(sequence, trackIndex, trackType)
if(!items || items.length === 0) {
return;
}
const f = async (item, targetPosition) => {
let currentStart = await item.getStartTime()
let a = await currentStart.ticksNumber
let b = await targetPosition.ticksNumber
let shiftAmount = (a - b)// How much to shift
shiftAmount *= -1;
let shiftTick = app.TickTime.createWithTicks(shiftAmount.toString())
return shiftTick
}
let targetPosition = app.TickTime.createWithTicks("0")
for(let i = 0; i < items.length; i++) {
let item = items[i];
let shiftTick = await f(item, targetPosition)
execute(() => {
let out = []
out.push(item.createMoveAction(shiftTick))
return out
}, project)
targetPosition = await item.getEndTime()
}
}
//TODO: change API to take trackType?
//TODO: pass in scope here
const removeItemFromSequence = async (command) => {
const options = command.options;
const sequenceId = options.sequenceId;
const trackIndex = options.trackIndex;
const trackItemIndex = options.trackItemIndex;
const rippleDelete = options.rippleDelete;
const trackType = options.trackType
let project = await app.Project.getActiveProject()
let sequence = await _getSequenceFromId(sequenceId)
if(!sequence) {
throw Error(`addMarkerToSequence : sequence with id [${sequenceId}] not found.`)
}
let item = await getTrack(sequence, trackIndex, trackItemIndex, trackType);
let editor = await app.SequenceEditor.getEditor(sequence)
let trackItemSelection = await sequence.getSelection();
let items = await trackItemSelection.getTrackItems()
for (let t of items) {
await trackItemSelection.removeItem(t)
}
trackItemSelection.addItem(item, true)
execute(() => {
const shiftOverlapping = false
let action = editor.createRemoveItemsAction(trackItemSelection, rippleDelete, constants.MediaType.ANY, shiftOverlapping )
return [action]
}, project)
}
const addMarkerToSequence = async (command) => {
const options = command.options;
const sequenceId = options.sequenceId;
const markerName = options.markerName;
const startTimeTicks = options.startTimeTicks;
const durationTicks = options.durationTicks;
const comments = options.comments;
const sequence = await _getSequenceFromId(sequenceId)
if(!sequence) {
throw Error(`addMarkerToSequence : sequence with id [${sequenceId}] not found.`)
}
let markers = await app.Markers.getMarkers(sequence);
let project = await app.Project.getActiveProject()
execute(() => {
let start = app.TickTime.createWithTicks(startTimeTicks.toString())
let duration = app.TickTime.createWithTicks(durationTicks.toString())
let action = markers.createAddMarkerAction(markerName, "WebLink", start, duration, comments)
return [action]
}, project)
}
const moveProjectItemsToBin = async (command) => {
const options = command.options;
const binName = options.binName;
const projectItemNames = options.itemNames;
const project = await app.Project.getActiveProject()
const binFolderItem = await findProjectItem(binName, project)
if(!binFolderItem) {
throw Error(`moveProjectItemsToBin : Bin with name [${binName}] not found.`)
}
let folderItems = [];
for(let name of projectItemNames) {
let item = await findProjectItem(name, project)
if(!item) {
throw Error(`moveProjectItemsToBin : FolderItem with name [${name}] not found.`)
}
folderItems.push(item)
}
const rootFolderItem = await project.getRootItem()
execute(() => {
let actions = []
for(let folderItem of folderItems) {
let b = app.FolderItem.cast(binFolderItem)
let action = rootFolderItem.createMoveItemAction(folderItem, b)
actions.push(action)
}
return actions
}, project)
}
const createBinInActiveProject = async (command) => {
const options = command.options;
const binName = options.binName;
const project = await app.Project.getActiveProject()
const folderItem = await project.getRootItem()
execute(() => {
let action = folderItem.createBinAction(binName, true)
return [action]
}, project)
}
const exportSequence = async (command) => {
const options = command.options;
const sequenceId = options.sequenceId;
const outputPath = options.outputPath;
const presetPath = options.presetPath;
const manager = await app.EncoderManager.getManager();
const sequence = await _getSequenceFromId(sequenceId);
await manager.exportSequence(sequence, constants.ExportType.IMMEDIATELY, outputPath, presetPath);
}
const commandHandlers = {
exportSequence,
moveProjectItemsToBin,
createBinInActiveProject,
addMarkerToSequence,
closeGapsOnSequence,
removeItemFromSequence,
setClipStartEndTimes,
openProject,
saveProjectAs,
saveProject,
getProjectInfo,
setActiveSequence,
exportFrame,
setVideoClipProperties,
createSequenceFromMedia,
setAudioTrackMute,
setClipDisabled,
appendVideoTransition,
appendVideoFilter,
addMediaToSequence,
importMedia,
createProject,
};
module.exports = {
commandHandlers
}
```
--------------------------------------------------------------------------------
/uxp/ps/commands/layers.js:
--------------------------------------------------------------------------------
```javascript
/* MIT License
*
* Copyright (c) 2025 Mike Chambers
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
const { app, constants, action, imaging } = require("photoshop");
const fs = require("uxp").storage.localFileSystem;
const {
setVisibleAllLayers,
findLayer,
execute,
parseColor,
getAnchorPosition,
getInterpolationMethod,
getBlendMode,
getJustificationMode,
selectLayer,
hasActiveSelection,
_saveDocumentAs,
convertFontSize,
convertFromPhotoshopFontSize
} = require("./utils");
// Function to capture visibility state
const _captureVisibilityState = (layers) => {
const state = new Map();
const capture = (layerSet) => {
for (const layer of layerSet) {
state.set(layer.id, layer.visible);
if (layer.layers && layer.layers.length > 0) {
capture(layer.layers);
}
}
};
capture(layers);
return state;
};
// Function to restore visibility state
const _restoreVisibilityState = async (state) => {
const restore = (layerSet) => {
for (const layer of layerSet) {
if (state.has(layer.id)) {
layer.visible = state.get(layer.id);
}
if (layer.layers && layer.layers.length > 0) {
restore(layer.layers);
}
}
};
await execute(async () => {
restore(app.activeDocument.layers);
});
};
const exportLayersAsPng = async (command) => {
let options = command.options;
let layersInfo = options.layersInfo;
const results = [];
let originalState;
await execute(async () => {
originalState = _captureVisibilityState(app.activeDocument.layers);
setVisibleAllLayers(false);
});
for (const info of layersInfo) {
let result = {};
let layer = findLayer(info.layerId);
try {
if (!layer) {
throw new Error(
`exportLayersAsPng: Could not find layer with ID: [${info.layerId}]` // Fixed error message
);
}
await execute(async () => {
layer.visible = true;
});
let tmp = await _saveDocumentAs(info.filePath, "PNG");
result = {
...tmp,
layerId: info.layerId,
success: true
};
} catch (e) {
result = {
...info,
success: false,
message: e.message
};
} finally {
if (layer) {
await execute(async () => {
layer.visible = false;
});
}
}
results.push(result);
}
await execute(async () => {
await _restoreVisibilityState(originalState);
})
return results;
};
const scaleLayer = async (command) => {
let options = command.options;
let layerId = options.layerId;
let layer = findLayer(layerId);
if (!layer) {
throw new Error(
`scaleLayer : Could not find layer with ID : [${layerId}]`
);
}
await execute(async () => {
let anchor = getAnchorPosition(options.anchorPosition);
let interpolation = getInterpolationMethod(options.interpolationMethod);
await layer.scale(options.width, options.height, anchor, {
interpolation: interpolation,
});
});
};
const rotateLayer = async (command) => {
let options = command.options;
let layerId = options.layerId;
let layer = findLayer(layerId);
if (!layer) {
throw new Error(
`rotateLayer : Could not find layer with ID : [${layerId}]`
);
}
await execute(async () => {
selectLayer(layer, true);
let anchor = getAnchorPosition(options.anchorPosition);
let interpolation = getInterpolationMethod(options.interpolationMethod);
await layer.rotate(options.angle, anchor, {
interpolation: interpolation,
});
});
};
const flipLayer = async (command) => {
let options = command.options;
let layerId = options.layerId;
let layer = findLayer(layerId);
if (!layer) {
throw new Error(
`flipLayer : Could not find layer with ID : [${layerId}]`
);
}
await execute(async () => {
await layer.flip(options.axis);
});
};
const deleteLayer = async (command) => {
let options = command.options;
let layerId = options.layerId;
let layer = findLayer(layerId);
if (!layer) {
throw new Error(
`setLayerVisibility : Could not find layer with ID : [${layerId}]`
);
}
await execute(async () => {
layer.delete();
});
};
const renameLayer = async (command) => {
let options = command.options;
let layerId = options.layerId;
let newLayerName = options.newLayerName;
await _renameLayer(layerId, newLayerName)
};
const _renameLayer = async (layerId, layerName) => {
let layer = findLayer(layerId);
if (!layer) {
throw new Error(
`_renameLayer : Could not find layer with ID : [${layerId}]`
);
}
await execute(async () => {
layer.name = layerName;
});
}
const renameLayers = async (command) => {
let options = command.options;
let data = options.layerData;
for(const d of data) {
await _renameLayer(d.layer_id, d.new_layer_name)
}
};
const groupLayers = async (command) => {
let options = command.options;
const layerIds = options.layerIds;
let layers = [];
for (const layerId of layerIds) {
let layer = findLayer(layerId);
if (!layer) {
throw new Error(
`groupLayers : Could not find layerId : ${layerId}`
);
}
layers.push(layer);
}
await execute(async () => {
await app.activeDocument.createLayerGroup({
name: options.groupName,
fromLayers: layers,
});
});
};
const setLayerVisibility = async (command) => {
let options = command.options;
let layerId = options.layerId;
let layer = findLayer(layerId);
if (!layer) {
throw new Error(
`setLayerVisibility : Could not find layer with ID : [${layerId}]`
);
}
await execute(async () => {
layer.visible = options.visible;
});
};
const translateLayer = async (command) => {
let options = command.options;
let layerId = options.layerId;
let layer = findLayer(layerId);
if (!layer) {
throw new Error(
`translateLayer : Could not find layer with ID : [${layerId}]`
);
}
await execute(async () => {
await layer.translate(options.xOffset, options.yOffset);
});
};
const setLayerProperties = async (command) => {
let options = command.options;
let layerId = options.layerId;
let layer = findLayer(layerId);
if (!layer) {
throw new Error(
`setLayerProperties : Could not find layer with ID : [${layerId}]`
);
}
await execute(async () => {
layer.blendMode = getBlendMode(options.blendMode);
layer.opacity = options.layerOpacity;
layer.fillOpacity = options.fillOpacity;
if (layer.isClippingMask != options.isClippingMask) {
selectLayer(layer, true);
let command = options.isClippingMask
? {
_obj: "groupEvent",
_target: [
{
_enum: "ordinal",
_ref: "layer",
_value: "targetEnum",
},
],
}
: {
_obj: "ungroup",
_target: [
{
_enum: "ordinal",
_ref: "layer",
_value: "targetEnum",
},
],
};
await action.batchPlay([command], {});
}
});
};
const duplicateLayer = async (command) => {
let options = command.options;
await execute(async () => {
let layer = findLayer(options.sourceLayerId);
if (!layer) {
throw new Error(
`duplicateLayer : Could not find sourceLayerId : ${options.sourceLayerId}`
);
}
let d = await layer.duplicate();
d.name = options.duplicateLayerName;
});
};
const flattenAllLayers = async (command) => {
const options = command.options;
const layerName = options.layerName
await execute(async () => {
await app.activeDocument.flatten();
let layers = app.activeDocument.layers;
if (layers.length != 1) {
throw new Error(`flattenAllLayers : Unknown error`);
}
let l = layers[0];
l.allLocked = false;
l.name = layerName;
});
};
const getLayerBounds = async (command) => {
let options = command.options;
let layerId = options.layerId;
let layer = findLayer(layerId);
if (!layer) {
throw new Error(
`getLayerBounds : Could not find layerId : ${layerId}`
);
}
let b = layer.bounds;
return { left: b.left, top: b.top, bottom: b.bottom, right: b.right };
};
const rasterizeLayer = async (command) => {
let options = command.options;
let layerId = options.layerId;
let layer = findLayer(layerId);
if (!layer) {
throw new Error(
`rasterizeLayer : Could not find layerId : ${layerId}`
);
}
await execute(async () => {
layer.rasterize(constants.RasterizeType.ENTIRELAYER);
});
};
const editTextLayer = async (command) => {
let options = command.options;
let layerId = options.layerId;
let layer = findLayer(layerId);
if (!layer) {
throw new Error(`editTextLayer : Could not find layerId : ${layerId}`);
}
if (layer.kind.toUpperCase() != constants.LayerKind.TEXT.toUpperCase()) {
throw new Error(`editTextLayer : Layer type must be TEXT : ${layer.kind}`);
}
await execute(async () => {
const contents = options.contents;
const fontSize = options.fontSize;
const textColor = options.textColor;
const fontName = options.fontName;
console.log("contents", options.contents)
console.log("fontSize", options.fontSize)
console.log("textColor", options.textColor)
console.log("fontName", options.fontName)
if (contents != undefined) {
layer.textItem.contents = contents;
}
if (fontSize != undefined) {
let s = convertFontSize(fontSize);
layer.textItem.characterStyle.size = s;
}
if (textColor != undefined) {
let c = parseColor(textColor);
layer.textItem.characterStyle.color = c;
}
if (fontName != undefined) {
layer.textItem.characterStyle.font = fontName;
}
});
}
const moveLayer = async (command) => {
let options = command.options;
let layerId = options.layerId;
let layer = findLayer(layerId);
if (!layer) {
throw new Error(`moveLayer : Could not find layerId : ${layerId}`);
}
let position;
switch (options.position) {
case "TOP":
position = "front";
break;
case "BOTTOM":
position = "back";
break;
case "UP":
position = "next";
break;
case "DOWN":
position = "previous";
break;
default:
throw new Error(
`moveLayer: Unknown placement : ${options.position}`
);
}
await execute(async () => {
selectLayer(layer, true);
let commands = [
{
_obj: "move",
_target: [
{
_enum: "ordinal",
_ref: "layer",
_value: "targetEnum",
},
],
to: {
_enum: "ordinal",
_ref: "layer",
_value: position,
},
},
];
await action.batchPlay(commands, {});
});
};
const createMultiLineTextLayer = async (command) => {
let options = command.options;
await execute(async () => {
let c = parseColor(options.textColor);
let fontSize = convertFontSize(options.fontSize);
let contents = options.contents.replace(/\\n/g, "\n");
let a = await app.activeDocument.createTextLayer({
//blendMode: constants.BlendMode.DISSOLVE,//ignored
textColor: c,
//color:constants.LabelColors.BLUE,//ignored
//opacity:50, //ignored
//name: "layer name",//ignored
contents: contents,
fontSize: fontSize,
fontName: options.fontName, //"ArialMT",
position: options.position, //y is the baseline of the text. Not top left
});
//https://developer.adobe.com/photoshop/uxp/2022/ps_reference/classes/layer/
a.blendMode = getBlendMode(options.blendMode);
a.name = options.layerName;
a.opacity = options.opacity;
await a.textItem.convertToParagraphText();
a.textItem.paragraphStyle.justification = getJustificationMode(
options.justification
);
selectLayer(a, true);
let commands = [
// Set current text layer
{
_obj: "set",
_target: [
{
_enum: "ordinal",
_ref: "textLayer",
_value: "targetEnum",
},
],
to: {
_obj: "textLayer",
textShape: [
{
_obj: "textShape",
bounds: {
_obj: "rectangle",
bottom: options.bounds.bottom,
left: options.bounds.left,
right: options.bounds.right,
top: options.bounds.top,
},
char: {
_enum: "char",
_value: "box",
},
columnCount: 1,
columnGutter: {
_unit: "pointsUnit",
_value: 0.0,
},
firstBaselineMinimum: {
_unit: "pointsUnit",
_value: 0.0,
},
frameBaselineAlignment: {
_enum: "frameBaselineAlignment",
_value: "alignByAscent",
},
orientation: {
_enum: "orientation",
_value: "horizontal",
},
rowCount: 1,
rowGutter: {
_unit: "pointsUnit",
_value: 0.0,
},
rowMajorOrder: true,
spacing: {
_unit: "pointsUnit",
_value: 0.0,
},
transform: {
_obj: "transform",
tx: 0.0,
ty: 0.0,
xx: 1.0,
xy: 0.0,
yx: 0.0,
yy: 1.0,
},
},
],
},
},
];
a.textItem.contents = contents;
await action.batchPlay(commands, {});
});
};
const createSingleLineTextLayer = async (command) => {
let options = command.options;
await execute(async () => {
let c = parseColor(options.textColor);
let fontSize = convertFontSize(options.fontSize);
let a = await app.activeDocument.createTextLayer({
//blendMode: constants.BlendMode.DISSOLVE,//ignored
textColor: c,
//color:constants.LabelColors.BLUE,//ignored
//opacity:50, //ignored
//name: "layer name",//ignored
contents: options.contents,
fontSize: fontSize,
fontName: options.fontName, //"ArialMT",
position: options.position, //y is the baseline of the text. Not top left
});
//https://developer.adobe.com/photoshop/uxp/2022/ps_reference/classes/layer/
a.blendMode = getBlendMode(options.blendMode);
a.name = options.layerName;
a.opacity = options.opacity;
});
};
const createPixelLayer = async (command) => {
let options = command.options;
await execute(async () => {
//let c = parseColor(options.textColor)
let b = getBlendMode(options.blendMode);
let a = await app.activeDocument.createPixelLayer({
name: options.layerName,
opacity: options.opacity,
fillNeutral: options.fillNeutral,
blendMode: b,
});
});
};
const getLayers = async (command) => {
let out = await execute(async () => {
let result = [];
// Function to recursively process layers
const processLayers = (layersList) => {
let layersArray = [];
for (let i = 0; i < layersList.length; i++) {
let layer = layersList[i];
let kind = layer.kind.toUpperCase()
let layerInfo = {
name: layer.name,
type: kind,
id: layer.id,
isClippingMask: layer.isClippingMask,
opacity: Math.round(layer.opacity),
blendMode: layer.blendMode.toUpperCase(),
};
if (kind == constants.LayerKind.TEXT.toUpperCase()) {
let _c = layer.textItem.characterStyle.color;
let color = {
red: Math.round(_c.rgb.red),
green: Math.round(_c.rgb.green),
blue: Math.round(_c.rgb.blue)
}
layerInfo.textInfo = {
fontSize: convertFromPhotoshopFontSize(layer.textItem.characterStyle.size),
fontName: layer.textItem.characterStyle.font,
fontColor: color,
text: layer.textItem.contents,
isMultiLineText: layer.textItem.isParagraphText
}
}
// Check if this layer has sublayers (is a group)
if (layer.layers && layer.layers.length > 0) {
layerInfo.layers = processLayers(layer.layers);
}
layersArray.push(layerInfo);
}
return layersArray;
};
// Start with the top-level layers
result = processLayers(app.activeDocument.layers);
return result;
});
return out;
};
const removeLayerMask = async (command) => {
const options = command.options;
const layerId = options.layerId;
const layer = findLayer(layerId);
if (!layer) {
throw new Error(`removeLayerMask : Could not find layerId : ${layerId}`);
}
await execute(async () => {
selectLayer(layer, true);
let commands = [
// Delete mask channel
{
_obj: "delete",
_target: [
{
_enum: "channel",
_ref: "channel",
_value: "mask",
},
],
},
];
await action.batchPlay(commands, {});
});
};
const addLayerMask = async (command) => {
if (!hasActiveSelection()) {
throw new Error("addLayerMask : Requires an active selection.");
}
const options = command.options;
const layerId = options.layerId;
const layer = findLayer(layerId);
if (!layer) {
throw new Error(`addLayerMask : Could not find layerId : ${layerId}`);
}
await execute(async () => {
selectLayer(layer, true);
let commands = [
// Make
{
_obj: "make",
at: {
_enum: "channel",
_ref: "channel",
_value: "mask",
},
new: {
_class: "channel",
},
using: {
_enum: "userMaskEnabled",
_value: "revealSelection",
},
},
];
await action.batchPlay(commands, {});
});
};
const harmonizeLayer = async (command) => {
const options = command.options;
const layerId = options.layerId;
const newLayerName = options.newLayerName;
const rasterizeLayer = options.rasterizeLayer;
const layer = findLayer(layerId);
if (!layer) {
throw new Error(`harmonizeLayer : Could not find layerId : ${layerId}`);
}
await execute(async () => {
selectLayer(layer, true);
let commands = [
{
"_obj": "syntheticGenHarmonize",
"_target": [
{
"_enum": "ordinal",
"_ref": "document",
"_value": "targetEnum"
}
],
"documentID": 60,
"layerID": 7,
"prompt": "",
"serviceID": "gen_harmonize",
"serviceOptionsList": {
"clio": {
"_obj": "clio",
"dualCrop": true,
"gi_ADVANCED": "{\"enable_mts\":true}",
"gi_CONTENT_PRESERVE": 0,
"gi_CROP": false,
"gi_DILATE": false,
"gi_ENABLE_PROMPT_FILTER": true,
"gi_GUIDANCE": 6,
"gi_MODE": "ginp",
"gi_NUM_STEPS": -1,
"gi_PROMPT": "",
"gi_SEED": -1,
"gi_SIMILARITY": 0
},
"gen_harmonize": {
"_obj": "gen_harmonize",
"dualCrop": true,
"gi_SEED": -1
}
},
"workflow": "gen_harmonize",
"workflowType": {
"_enum": "genWorkflow",
"_value": "gen_harmonize"
},
"workflow_to_active_service_identifier_map": {
"gen_harmonize": "gen_harmonize",
"generate_background": "clio3",
"generate_similar": "clio3",
"generativeUpscale": "fal_aura_sr",
"in_painting": "gen_harmonize",
"instruct_edit": "clio3",
"out_painting": "clio3",
"text_to_image": "clio3"
}
},
];
console.log(rasterizeLayer)
if(rasterizeLayer) {
commands.push({
_obj: "rasterizeLayer",
_target: [
{
_enum: "ordinal",
_ref: "layer",
_value: "targetEnum",
},
],
})
}
let o = await action.batchPlay(commands, {});
let layerId = o[0].layerID;
let l = findLayer(layerId);
l.name = newLayerName;
});
};
const getLayerImage = async (command) => {
const options = command.options;
const layerId = options.layerId;
const layer = findLayer(layerId);
if (!layer) {
throw new Error(`harmonizeLayer : Could not find layerId : ${layerId}`);
}
let out = await execute(async () => {
const pixelsOpt = {
applyAlpha: true,
layerID:layerId
};
const imgObj = await imaging.getPixels(pixelsOpt);
const base64Data = await imaging.encodeImageData({
imageData: imgObj.imageData,
base64: true,
});
const result = {
base64Image: base64Data,
dataUrl: `data:image/jpeg;base64,${base64Data}`,
width: imgObj.imageData.width,
height: imgObj.imageData.height,
colorSpace: imgObj.imageData.colorSpace,
components: imgObj.imageData.components,
format: "jpeg",
};
imgObj.imageData.dispose();
return result;
});
return out;
};
const commandHandlers = {
renameLayers,
getLayerImage,
harmonizeLayer,
editTextLayer,
exportLayersAsPng,
removeLayerMask,
addLayerMask,
getLayers,
scaleLayer,
rotateLayer,
flipLayer,
deleteLayer,
renameLayer,
groupLayers,
setLayerVisibility,
translateLayer,
setLayerProperties,
duplicateLayer,
flattenAllLayers,
getLayerBounds,
rasterizeLayer,
moveLayer,
createMultiLineTextLayer,
createSingleLineTextLayer,
createPixelLayer,
};
module.exports = {
commandHandlers,
};
```
--------------------------------------------------------------------------------
/mcp/pr-mcp.py:
--------------------------------------------------------------------------------
```python
# MIT License
#
# Copyright (c) 2025 Mike Chambers
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from mcp.server.fastmcp import FastMCP, Image
from PIL import Image as PILImage
from core import init, sendCommand, createCommand
import socket_client
import sys
import tempfile
import os
import io
#logger.log(f"Python path: {sys.executable}")
#logger.log(f"PYTHONPATH: {os.environ.get('PYTHONPATH')}")
#logger.log(f"Current working directory: {os.getcwd()}")
#logger.log(f"Sys.path: {sys.path}")
mcp_name = "Adobe Premiere MCP Server"
mcp = FastMCP(mcp_name, log_level="ERROR")
print(f"{mcp_name} running on stdio", file=sys.stderr)
APPLICATION = "premiere"
PROXY_URL = 'http://localhost:3001'
PROXY_TIMEOUT = 20
socket_client.configure(
app=APPLICATION,
url=PROXY_URL,
timeout=PROXY_TIMEOUT
)
init(APPLICATION, socket_client)
@mcp.tool()
def get_project_info():
"""
Returns info on the currently active project in Premiere Pro.
"""
command = createCommand("getProjectInfo", {
})
return sendCommand(command)
@mcp.tool()
def save_project():
"""
Saves the active project in Premiere Pro.
"""
command = createCommand("saveProject", {
})
return sendCommand(command)
@mcp.tool()
def save_project_as(file_path: str):
"""Saves the current Premiere project to the specified location.
Args:
file_path (str): The absolute path (including filename) where the file will be saved.
Example: "/Users/username/Documents/project.prproj"
"""
command = createCommand("saveProjectAs", {
"filePath":file_path
})
return sendCommand(command)
@mcp.tool()
def open_project(file_path: str):
"""Opens the Premiere project at the specified path.
Args:
file_path (str): The absolute path (including filename) of the Premiere Pro project to open.
Example: "/Users/username/Documents/project.prproj"
"""
command = createCommand("openProject", {
"filePath":file_path
})
return sendCommand(command)
@mcp.tool()
def create_project(directory_path: str, project_name: str):
"""
Create a new Premiere project.
Creates a new Adobe Premiere project file, saves it to the specified location and then opens it in Premiere.
The function initializes an empty project with default settings.
Args:
directory_path (str): The full path to the directory where the project file will be saved. This directory must exist before calling the function.
project_name (str): The name to be given to the project file. The '.prproj' extension will be added.
"""
command = createCommand("createProject", {
"path":directory_path,
"name":project_name
})
return sendCommand(command)
@mcp.tool()
def create_bin_in_active_project(bin_name:str):
"""
Creates a new bin / folder in the root project.
Args:
name (str) : The name of the bin to be created
"""
command = createCommand("createBinInActiveProject", {
"binName": bin_name
})
return sendCommand(command)
@mcp.tool()
def export_sequence(sequence_id: str, output_path: str, preset_path: str):
"""
Exports a Premiere Pro sequence to a video file using specified export settings.
This function renders and exports the specified sequence from the active Premiere Pro project
to a video file on the file system. The export process uses a preset file to determine
encoding settings, resolution, format, and other export parameters.
Args:
sequence_id (str): The unique identifier of the sequence to export.
This should be the ID of an existing sequence in the current Premiere Pro project.
output_path (str): The complete file system path where the exported video will be saved.
Must include the full directory path, filename, and appropriate file extension.
preset_path (str): The file system path to the export preset file (.epr) that defines the export settings including codec, resolution, bitrate, and format.
IMPORTANT: The export may take an extended period of time, so if the call times out, it most likely means the export is still in progress.
"""
command = createCommand("exportSequence", {
"sequenceId": sequence_id,
"outputPath": output_path,
"presetPath": preset_path
})
return sendCommand(command)
@mcp.tool()
def move_project_items_to_bin(item_names: list[str], bin_name: str):
"""
Moves specified project items to an existing bin/folder in the project.
Args:
item_names (list[str]): A list of names of project items to move to the specified bin.
These should be the exact names of items as they appear in the project.
bin_name (str): The name of the existing bin to move the project items to.
The bin must already exist in the project.
Returns:
dict: Response from the Premiere Pro operation indicating success status.
Raises:
RuntimeError: If the bin doesn't exist, items don't exist, or the operation fails.
Example:
move_project_items_to_bin(
item_names=["video1.mp4", "audio1.wav", "image1.png"],
bin_name="Media Assets"
)
"""
command = createCommand("moveProjectItemsToBin", {
"itemNames": item_names,
"binName": bin_name
})
return sendCommand(command)
@mcp.tool()
def set_audio_track_mute(sequence_id:str, audio_track_index: int, mute: bool):
"""
Sets the mute property on the specified audio track. If mute is true, all clips on the track will be muted and not played.
Args:
sequence_id (str) : The id of the sequence on which to set the audio track mute.
audio_track_index (int): The index of the audio track to mute or unmute. Indices start at 0 for the first audio track.
mute (bool): Whether the track should be muted.
- True: Mutes the track (audio will not be played)
- False: Unmutes the track (audio will be played normally)
"""
command = createCommand("setAudioTrackMute", {
"sequenceId": sequence_id,
"audioTrackIndex":audio_track_index,
"mute":mute
})
return sendCommand(command)
@mcp.tool()
def set_active_sequence(sequence_id: str):
"""
Sets the sequence with the specified id as the active sequence within Premiere Pro (currently selected and visible in timeline)
Args:
sequence_id (str): ID for the sequence to be set as active
"""
command = createCommand("setActiveSequence", {
"sequenceId":sequence_id
})
return sendCommand(command)
@mcp.tool()
def create_sequence_from_media(item_names: list[str], sequence_name: str = "default"):
"""
Creates a new sequence from the specified project items, placing clips on the timeline in the order they are provided.
If there is not an active sequence the newly created sequence will be set as the active sequence when created.
Args:
item_names (list[str]): A list of project item names to include in the sequence in the desired order.
sequence_name (str, optional): The name to give the new sequence. Defaults to "default".
"""
command = createCommand("createSequenceFromMedia", {
"itemNames":item_names,
"sequenceName":sequence_name
})
return sendCommand(command)
@mcp.tool()
def close_gaps_on_sequence(sequence_id: str, track_index: int, track_type: str):
"""
Closes gaps on the specified track(s) in a sequence's timeline.
This function removes empty spaces (gaps) between clips on the timeline by moving
clips leftward to fill any empty areas. This is useful for cleaning up the timeline
after removing clips or when clips have been moved leaving gaps.
Args:
sequence_id (str): The ID of the sequence to close gaps on.
track_index (int): The index of the track to close gaps on.
Track indices start at 0 for the first track and increment upward.
For video tracks, this refers to video track indices.
For audio tracks, this refers to audio track indices.
track_type (str): Specifies which type of tracks to close gaps on.
Valid values:
- "VIDEO": Close gaps only on the specified video track
- "AUDIO": Close gaps only on the specified audio track
"""
command = createCommand("closeGapsOnSequence", {
"sequenceId": sequence_id,
"trackIndex": track_index,
"trackType": track_type,
})
return sendCommand(command)
@mcp.tool()
def remove_item_from_sequence(sequence_id: str, track_index:int, track_item_index: int, track_type:str, ripple_delete:bool=True):
"""
Removes a specified media item from the sequence's timeline.
Args:
sequence_id (str): The id for the sequence to remove the media from
track_index (int): The index of the track containing the target clip.
Track indices start at 0 for the first track and increment upward.
track_item_index (int): The index of the clip within the track to remove.
Clip indices start at 0 for the first clip in the track and increment from left to right.
track_type (str): Specifies which type of tracks being removed.
Valid values:
- "VIDEO": Close gaps only on the specified video track
- "AUDIO": Close gaps only on the specified audio track
ripple_delete (bool, optional): Whether to perform a ripple delete operation. Defaults to True.
- True: Removes the clip and shifts all subsequent clips leftward to close the gap
- False: Removes the clip but leaves a gap in the timeline where the clip was located
"""
command = createCommand("removeItemFromSequence", {
"sequenceId": sequence_id,
"trackItemIndex":track_item_index,
"trackIndex":track_index,
"trackType":track_type,
"rippleDelete":ripple_delete
})
return sendCommand(command)
@mcp.tool()
def add_marker_to_sequence(sequence_id: str,
marker_name: str,
start_time_ticks: int,
duration_ticks: int,
comments: str,
marker_type: str = "Comment"):
"""
Adds a marker to the specified sequence.
Args:
sequence_id (str):
The ID of the sequence to which the marker will be added.
marker_name (str):
The name/title of the marker.
start_time_ticks (int):
The timeline position where the marker starts, in ticks.
(1 tick = 1/254016000000 of a day)
duration_ticks (int):
The length of the marker in ticks.
comments (str):
Optional text comment to store in the marker.
marker_type (str, optional):
The type of marker to add. Defaults to "Comment".
Supported marker types include:
- "Comment" → General-purpose note marker.
"""
command = createCommand("addMarkerToSequence", {
"sequenceId": sequence_id,
"markerName": marker_name,
"startTimeTicks": start_time_ticks,
"durationTicks": duration_ticks,
"comments": comments,
"markerType": marker_type
})
return sendCommand(command)
@mcp.tool()
def add_media_to_sequence(sequence_id:str, item_name: str, video_track_index: int, audio_track_index: int, insertion_time_ticks: int = 0, overwrite: bool = True):
"""
Adds a specified media item to the active sequence's timeline.
Args:
sequence_id (str) : The id for the sequence to add the media to
item_name (str): The name or identifier of the media item to add.
video_track_index (int): The index of the video track where the item should be inserted.
audio_track_index (int): The index of the audio track where the item should be inserted.
insertion_time_ticks (int): The position on the timeline in ticks, with 0 being the beginning. The API will return positions of existing clips in ticks
overwrite (bool, optional): Whether to overwrite existing content at the insertion point. Defaults to True. If False, any existing clips that overlap will be split and item inserted.
"""
command = createCommand("addMediaToSequence", {
"sequenceId": sequence_id,
"itemName":item_name,
"videoTrackIndex":video_track_index,
"audioTrackIndex":audio_track_index,
"insertionTimeTicks":insertion_time_ticks,
"overwrite":overwrite
})
return sendCommand(command)
@mcp.tool()
def set_clip_disabled(sequence_id:str, track_index: int, track_item_index: int, track_type:str, disabled: bool):
"""
Enables or disables a clip in the timeline.
Args:
sequence_id (str): The id for the sequence to set the clip disabled property.
track_index (int): The index of the track containing the target clip.
Track indices start at 0 for the first track and increment upward.
For video tracks, this refers to video track indices.
For audio tracks, this refers to audio track indices.
track_item_index (int): The index of the clip within the track to enable/disable.
Clip indices start at 0 for the first clip in the track and increment from left to right.
track_type (str): Specifies which type of track to modify.
Valid values:
- "VIDEO": Modify clips on the specified video track
- "AUDIO": Modify clips on the specified audio track
disabled (bool): Whether to disable the clip.
- True: Disables the clip (clip will not be visible during playback or export)
- False: Enables the clip (normal visibility)
"""
command = createCommand("setClipDisabled", {
"sequenceId": sequence_id,
"trackIndex":track_index,
"trackItemIndex":track_item_index,
"trackType":track_type,
"disabled":disabled
})
return sendCommand(command)
@mcp.tool()
def set_clip_start_end_times(
sequence_id: str, track_index: int, track_item_index: int, start_time_ticks: int,
end_time_ticks: int, track_type: str):
"""
Sets the start and end time boundaries for a specified clip in the timeline.
This function allows you to modify the duration and timing of video clips, audio clips,
and images that are already placed in the timeline by adjusting their in and out points.
The clip can be trimmed to a shorter duration or extended to a longer duration.
Args:
sequence_id (str): The id for the sequence containing the clip to modify.
track_index (int): The index of the track containing the target clip.
Track indices start at 0 for the first track and increment upward.
For video tracks, this refers to video track indices.
For audio tracks, this refers to audio track indices.
track_item_index (int): The index of the clip within the track to modify.
Clip indices start at 0 for the first clip in the track and increment from left to right.
start_time_ticks (int): The new start time for the clip in ticks.
end_time_ticks (int): The new end time for the clip in ticks.
track_type (str): Specifies which type of tracks to modify clips on.
Valid values:
- "VIDEO": Modify clips only on the specified video track
- "AUDIO": Modify clips only on the specified audio track
Note:
- To trim a clip: Set start/end times within the original clip's duration
- To extend a clip: Set end time beyond the original clip's duration
- Works with video clips, audio clips, and image files (like PSD files)
- Times are specified in ticks (Premiere Pro's internal time unit)
"""
command = createCommand("setClipStartEndTimes", {
"sequenceId": sequence_id,
"trackIndex": track_index,
"trackItemIndex": track_item_index,
"startTimeTicks": start_time_ticks,
"endTimeTicks": end_time_ticks,
"trackType": track_type
})
return sendCommand(command)
@mcp.tool()
def add_black_and_white_effect(sequence_id:str, video_track_index: int, track_item_index: int):
"""
Adds a black and white effect to a clip at the specified track and position.
Args:
sequence_id (str) : The id for the sequence to add the effect to
video_track_index (int): The index of the video track containing the target clip.
Track indices start at 0 for the first video track and increment upward.
track_item_index (int): The index of the clip within the track to apply the effect to.
Clip indices start at 0 for the first clip in the track and increment from left to right.
"""
command = createCommand("appendVideoFilter", {
"sequenceId": sequence_id,
"videoTrackIndex":video_track_index,
"trackItemIndex":track_item_index,
"effectName":"AE.ADBE Black & White",
"properties":[
]
})
return sendCommand(command)
@mcp.tool()
def get_sequence_frame_image(sequence_id: str, seconds: int):
"""Returns a jpeg of the specified timestamp in the specified sequence in Premiere pro as an MCP Image object that can be displayed."""
temp_dir = tempfile.gettempdir()
file_path = os.path.join(temp_dir, f"frame_{sequence_id}_{seconds}.png")
command = createCommand("exportFrame", {
"sequenceId": sequence_id,
"filePath": file_path,
"seconds": seconds
})
result = sendCommand(command)
if not result.get("status") == "SUCCESS":
return result
file_path = result["response"]["filePath"]
with open(file_path, 'rb') as f:
png_image = PILImage.open(f)
# Convert to RGB if necessary (removes alpha channel)
if png_image.mode in ("RGBA", "LA", "P"):
rgb_image = PILImage.new("RGB", png_image.size, (255, 255, 255))
rgb_image.paste(png_image, mask=png_image.split()[-1] if png_image.mode == "RGBA" else None)
png_image = rgb_image
# Save as JPEG to bytes buffer
jpeg_buffer = io.BytesIO()
png_image.save(jpeg_buffer, format="JPEG", quality=85, optimize=True)
jpeg_bytes = jpeg_buffer.getvalue()
image = Image(data=jpeg_bytes, format="jpeg")
del result["response"]
try:
os.remove(file_path)
except FileNotFoundError:
pass
return [result, image]
@mcp.tool()
def export_frame(sequence_id:str, file_path: str, seconds: int):
"""Captures a specific frame from the sequence at the given timestamp
and exports it as a PNG or JPG (depending on file extension) image file to the specified path.
Args:
sequence_id (str) : The id for the sequence to export the frame from
file_path (str): The destination path where the exported PNG / JPG image will be saved.
Must include the full directory path and filename with .png or .jpg extension.
seconds (int): The timestamp in seconds from the beginning of the sequence
where the frame should be captured. The frame closest to this time position
will be extracted.
"""
command = createCommand("exportFrame", {
"sequenceId": sequence_id,
"filePath": file_path,
"seconds":seconds
}
)
return sendCommand(command)
@mcp.tool()
def add_gaussian_blur_effect(sequence_id: str, video_track_index: int, track_item_index: int, blurriness: float, blur_dimensions: str = "HORIZONTAL_VERTICAL"):
"""
Adds a gaussian blur effect to a clip at the specified track and position.
Args:
sequence_id (str) : The id for the sequence to add the effect to
video_track_index (int): The index of the video track containing the target clip.
Track indices start at 0 for the first video track and increment upward.
track_item_index (int): The index of the clip within the track to apply the effect to.
Clip indices start at 0 for the first clip in the track and increment from left to right.
blurriness (float): The intensity of the blur effect. Higher values create stronger blur.
Recommended range is between 0.0 and 100.0 (Max 3000).
blur_dimensions (str, optional): The direction of the blur effect. Defaults to "HORIZONTAL_VERTICAL".
Valid options are:
- "HORIZONTAL_VERTICAL": Blur in all directions
- "HORIZONTAL": Blur only horizontally
- "VERTICAL": Blur only vertically
"""
dimensions = {"HORIZONTAL_VERTICAL": 0, "HORIZONTAL": 1, "VERTICAL": 2}
# Validate blur_dimensions parameter
if blur_dimensions not in dimensions:
raise ValueError(f"Invalid blur_dimensions. ")
command = createCommand("appendVideoFilter", {
"sequenceId": sequence_id,
"videoTrackIndex": video_track_index,
"trackItemIndex": track_item_index,
"effectName": "AE.ADBE Gaussian Blur 2",
"properties": [
{"name": "Blur Dimensions", "value": dimensions[blur_dimensions]},
{"name": "Blurriness", "value": blurriness}
]
})
return sendCommand(command)
def rgb_to_premiere_color3(rgb_color, alpha=1.0):
"""Converts RGB (0–255) dict to Premiere Pro color format [r, g, b, a] with floats (0.0–1.0)."""
return [
rgb_color["red"] / 255.0,
rgb_color["green"] / 255.0,
rgb_color["blue"] / 255.0,
alpha
]
def rgb_to_premiere_color(rgb_color, alpha=255):
"""
Converts an RGB(A) dict (0–255) to a 64-bit Premiere Pro color parameter (as int).
Matches Adobe's internal ARGB 16-bit fixed-point format.
"""
def to16bit(value):
return int(round(value * 256))
r16 = to16bit(rgb_color["red"] / 255.0)
g16 = to16bit(rgb_color["green"] / 255.0)
b16 = to16bit(rgb_color["blue"] / 255.0)
a16 = to16bit(alpha / 255.0)
high = (a16 << 16) | r16 # top 32 bits: A | R
low = (g16 << 16) | b16 # bottom 32 bits: G | B
packed_color = (high << 32) | low
return packed_color
@mcp.tool()
def add_tint_effect(sequence_id: str, video_track_index: int, track_item_index: int, black_map:dict = {"red":0, "green":0, "blue":0}, white_map:dict = {"red":255, "green":255, "blue":255}, amount:int = 100):
"""
Adds the tint effect to a clip at the specified track and position.
This function applies a tint effect that maps the dark and light areas of the clip to specified colors.
Args:
sequence_id (str) : The id for the sequence to add the effect to
video_track_index (int): The index of the video track containing the target clip.
Track indices start at 0 for the first video track and increment upward.
track_item_index (int): The index of the clip within the track to apply the effect to.
Clip indices start at 0 for the first clip in the track and increment from left to right.
black_map (dict): The RGB color values to map black/dark areas to, with keys "red", "green", and "blue".
Default is {"red":0, "green":0, "blue":0} (pure black).
white_map (dict): The RGB color values to map white/light areas to, with keys "red", "green", and "blue".
Default is {"red":255, "green":255, "blue":255} (pure white).
amount (int): The intensity of the tint effect as a percentage, ranging from 0 to 100.
Default is 100 (full tint effect).
"""
command = createCommand("appendVideoFilter", {
"sequenceId": sequence_id,
"videoTrackIndex":video_track_index,
"trackItemIndex":track_item_index,
"effectName":"AE.ADBE Tint",
"properties":[
#{"name":"Map White To", "value":rgb_to_premiere_color(white_map)},
#{"name":"Map Black To", "value":rgb_to_premiere_color(black_map)}
{"name":"Map Black To", "value":rgb_to_premiere_color(black_map)}
#{"name":"Amount to Tint", "value":amount / 100}
]
})
return sendCommand(command)
@mcp.tool()
def add_motion_blur_effect(sequence_id: str, video_track_index: int, track_item_index: int, direction: int, length: int):
"""
Adds the directional blur effect to a clip at the specified track and position.
This function applies a motion blur effect that simulates movement in a specific direction.
Args:
sequence_id (str) : The id for the sequence to add the effect to
video_track_index (int): The index of the video track containing the target clip.
Track indices start at 0 for the first video track and increment upward.
track_item_index (int): The index of the clip within the track to apply the effect to.
Clip indices start at 0 for the first clip in the track and increment from left to right.
direction (int): The angle of the directional blur in degrees, ranging from 0 to 360.
- 0/360: Vertical blur upward
- 90: Horizontal blur to the right
- 180: Vertical blur downward
- 270: Horizontal blur to the left
length (int): The intensity or distance of the blur effect, ranging from 0 to 1000.
"""
command = createCommand("appendVideoFilter", {
"sequenceId": sequence_id,
"videoTrackIndex":video_track_index,
"trackItemIndex":track_item_index,
"effectName":"AE.ADBE Motion Blur",
"properties":[
{"name":"Direction", "value":direction},
{"name":"Blur Length", "value":length}
]
})
return sendCommand(command)
@mcp.tool()
def append_video_transition(sequence_id: str, video_track_index: int, track_item_index: int, transition_name: str, duration: float = 1.0, clip_alignment: float = 0.5):
"""
Creates a transition between the specified clip and the adjacent clip on the timeline.
In general, you should keep transitions short (no more than 2 seconds is a good rule).
Args:
sequence_id (str) : The id for the sequence to add the transition to
video_track_index (int): The index of the video track containing the target clips.
track_item_index (int): The index of the clip within the track to apply the transition to.
transition_name (str): The name of the transition to apply. Must be a valid transition name (see below).
duration (float): The duration of the transition in seconds.
clip_alignment (float): Controls how the transition is distributed between the two clips.
Range: 0.0 to 1.0, where:
- 0.0 places transition entirely on the right (later) clip
- 0.5 centers the transition equally between both clips (default)
- 1.0 places transition entirely on the left (earlier) clip
Valid Transition Names:
Basic Transitions (ADBE):
- "ADBE Additive Dissolve"
- "ADBE Cross Zoom"
- "ADBE Cube Spin"
- "ADBE Film Dissolve"
- "ADBE Flip Over"
- "ADBE Gradient Wipe"
- "ADBE Iris Cross"
- "ADBE Iris Diamond"
- "ADBE Iris Round"
- "ADBE Iris Square"
- "ADBE Page Peel"
- "ADBE Push"
- "ADBE Slide"
- "ADBE Wipe"
After Effects Transitions (AE.ADBE):
- "AE.ADBE Center Split"
- "AE.ADBE Inset"
- "AE.ADBE Cross Dissolve New"
- "AE.ADBE Dip To White"
- "AE.ADBE Split"
- "AE.ADBE Whip"
- "AE.ADBE Non-Additive Dissolve"
- "AE.ADBE Dip To Black"
- "AE.ADBE Barn Doors"
- "AE.ADBE MorphCut"
"""
command = createCommand("appendVideoTransition", {
"sequenceId": sequence_id,
"videoTrackIndex":video_track_index,
"trackItemIndex":track_item_index,
"transitionName":transition_name,
"clipAlignment":clip_alignment,
"duration":duration
})
return sendCommand(command)
@mcp.tool()
def set_video_clip_properties(sequence_id: str, video_track_index: int, track_item_index: int, opacity: int = 100, blend_mode: str = "NORMAL"):
"""
Sets opacity and blend mode properties for a video clip in the timeline.
This function modifies the visual properties of a specific clip located on a specific video track
in the active Premiere Pro sequence. The clip is identified by its track index and item index
within that track.
Args:
sequence_id (str) : The id for the sequence to set the video clip properties
video_track_index (int): The index of the video track containing the target clip.
Track indices start at 0 for the first video track.
track_item_index (int): The index of the clip within the track to modify.
Clip indices start at 0 for the first clip on the track.
opacity (int, optional): The opacity value to set for the clip, as a percentage.
Valid values range from 0 (completely transparent) to 100 (completely opaque).
Defaults to 100.
blend_mode (str, optional): The blend mode to apply to the clip.
Must be one of the valid blend modes supported by Premiere Pro.
Defaults to "NORMAL".
"""
command = createCommand("setVideoClipProperties", {
"sequenceId": sequence_id,
"videoTrackIndex":video_track_index,
"trackItemIndex":track_item_index,
"opacity":opacity,
"blendMode":blend_mode
})
return sendCommand(command)
@mcp.tool()
def import_media(file_paths:list):
"""
Imports a list of media files into the active Premiere project.
Args:
file_paths (list): A list of file paths (strings) to import into the project.
Each path should be a complete, valid path to a media file supported by Premiere Pro.
"""
command = createCommand("importMedia", {
"filePaths":file_paths
})
return sendCommand(command)
@mcp.resource("config://get_instructions")
def get_instructions() -> str:
"""Read this first! Returns information and instructions on how to use Photoshop and this API"""
return f"""
You are a Premiere Pro and video expert who is creative and loves to help other people learn to use Premiere and create.
Rules to follow:
1. Think deeply about how to solve the task
2. Always check your work
3. Read the info for the API calls to make sure you understand the requirements and arguments
4. In general, add clips first, then effects, then transitions
5. As a general rule keep transitions short (no more that 2 seconds is a good rule), and there should not be a gap between clips (or else the transition may not work)
IMPORTANT: To create a new project and add clips:
1. Create new project (create_project)
2. Add media to the project (import_media)
3. Create a new sequence with media (should always add video / image clips before audio.(create_sequence_from_media). This will create a sequence with the clips.
4. The first clip you add will determine the dimensions / resolution of the sequence
Here are some general tips for when working with Premiere.
Audio and Video clips are added on separate Audio / Video tracks, which you can access via their index.
When adding a video clip that contains audio, the audio will be placed on a separate audio track.
Once added you currently cannot remove a clip (audio or video) but you can disable it.
If you want to do a transition between two clips, the clips must be on the same track and there should not be a gap between them. Place the transition of the first clip.
Video clips with a higher track index will overlap and hide those with lower index if they overlap.
When adding images to a sequence, they will have a duration of 5 seconds.
blend_modes: {", ".join(BLEND_MODES)}
"""
BLEND_MODES = [
"COLOR",
"COLORBURN",
"COLORDODGE",
"DARKEN",
"DARKERCOLOR",
"DIFFERENCE",
"DISSOLVE",
"EXCLUSION",
"HARDLIGHT",
"HARDMIX",
"HUE",
"LIGHTEN",
"LIGHTERCOLOR",
"LINEARBURN",
"LINEARDODGE",
"LINEARLIGHT",
"LUMINOSITY",
"MULTIPLY",
"NORMAL",
"OVERLAY",
"PINLIGHT",
"SATURATION",
"SCREEN",
"SOFTLIGHT",
"VIVIDLIGHT",
"SUBTRACT",
"DIVIDE"
]
```
--------------------------------------------------------------------------------
/cep/com.mikechambers.ae/lib/CSInterface.js:
--------------------------------------------------------------------------------
```javascript
/**************************************************************************************************
*
* ADOBE SYSTEMS INCORPORATED
* Copyright 2020 Adobe Systems Incorporated
* All Rights Reserved.
*
* NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the
* terms of the Adobe license agreement accompanying it. If you have received this file from a
* source other than Adobe, then your use, modification, or distribution of it requires the prior
* written permission of Adobe.
*
**************************************************************************************************/
/** CSInterface - v12.0.0 */
/**
* Stores constants for the window types supported by the CSXS infrastructure.
*/
function CSXSWindowType()
{
}
/** Constant for the CSXS window type Panel. */
CSXSWindowType._PANEL = "Panel";
/** Constant for the CSXS window type Modeless. */
CSXSWindowType._MODELESS = "Modeless";
/** Constant for the CSXS window type ModalDialog. */
CSXSWindowType._MODAL_DIALOG = "ModalDialog";
/** EvalScript error message */
EvalScript_ErrMessage = "EvalScript error.";
/**
* @class Version
* Defines a version number with major, minor, micro, and special
* components. The major, minor and micro values are numeric; the special
* value can be any string.
*
* @param major The major version component, a positive integer up to nine digits long.
* @param minor The minor version component, a positive integer up to nine digits long.
* @param micro The micro version component, a positive integer up to nine digits long.
* @param special The special version component, an arbitrary string.
*
* @return A new \c Version object.
*/
function Version(major, minor, micro, special)
{
this.major = major;
this.minor = minor;
this.micro = micro;
this.special = special;
}
/**
* The maximum value allowed for a numeric version component.
* This reflects the maximum value allowed in PlugPlug and the manifest schema.
*/
Version.MAX_NUM = 999999999;
/**
* @class VersionBound
* Defines a boundary for a version range, which associates a \c Version object
* with a flag for whether it is an inclusive or exclusive boundary.
*
* @param version The \c #Version object.
* @param inclusive True if this boundary is inclusive, false if it is exclusive.
*
* @return A new \c VersionBound object.
*/
function VersionBound(version, inclusive)
{
this.version = version;
this.inclusive = inclusive;
}
/**
* @class VersionRange
* Defines a range of versions using a lower boundary and optional upper boundary.
*
* @param lowerBound The \c #VersionBound object.
* @param upperBound The \c #VersionBound object, or null for a range with no upper boundary.
*
* @return A new \c VersionRange object.
*/
function VersionRange(lowerBound, upperBound)
{
this.lowerBound = lowerBound;
this.upperBound = upperBound;
}
/**
* @class Runtime
* Represents a runtime related to the CEP infrastructure.
* Extensions can declare dependencies on particular
* CEP runtime versions in the extension manifest.
*
* @param name The runtime name.
* @param version A \c #VersionRange object that defines a range of valid versions.
*
* @return A new \c Runtime object.
*/
function Runtime(name, versionRange)
{
this.name = name;
this.versionRange = versionRange;
}
/**
* @class Extension
* Encapsulates a CEP-based extension to an Adobe application.
*
* @param id The unique identifier of this extension.
* @param name The localizable display name of this extension.
* @param mainPath The path of the "index.html" file.
* @param basePath The base path of this extension.
* @param windowType The window type of the main window of this extension.
Valid values are defined by \c #CSXSWindowType.
* @param width The default width in pixels of the main window of this extension.
* @param height The default height in pixels of the main window of this extension.
* @param minWidth The minimum width in pixels of the main window of this extension.
* @param minHeight The minimum height in pixels of the main window of this extension.
* @param maxWidth The maximum width in pixels of the main window of this extension.
* @param maxHeight The maximum height in pixels of the main window of this extension.
* @param defaultExtensionDataXml The extension data contained in the default \c ExtensionDispatchInfo section of the extension manifest.
* @param specialExtensionDataXml The extension data contained in the application-specific \c ExtensionDispatchInfo section of the extension manifest.
* @param requiredRuntimeList An array of \c Runtime objects for runtimes required by this extension.
* @param isAutoVisible True if this extension is visible on loading.
* @param isPluginExtension True if this extension has been deployed in the Plugins folder of the host application.
*
* @return A new \c Extension object.
*/
function Extension(id, name, mainPath, basePath, windowType, width, height, minWidth, minHeight, maxWidth, maxHeight,
defaultExtensionDataXml, specialExtensionDataXml, requiredRuntimeList, isAutoVisible, isPluginExtension)
{
this.id = id;
this.name = name;
this.mainPath = mainPath;
this.basePath = basePath;
this.windowType = windowType;
this.width = width;
this.height = height;
this.minWidth = minWidth;
this.minHeight = minHeight;
this.maxWidth = maxWidth;
this.maxHeight = maxHeight;
this.defaultExtensionDataXml = defaultExtensionDataXml;
this.specialExtensionDataXml = specialExtensionDataXml;
this.requiredRuntimeList = requiredRuntimeList;
this.isAutoVisible = isAutoVisible;
this.isPluginExtension = isPluginExtension;
}
/**
* @class CSEvent
* A standard JavaScript event, the base class for CEP events.
*
* @param type The name of the event type.
* @param scope The scope of event, can be "GLOBAL" or "APPLICATION".
* @param appId The unique identifier of the application that generated the event.
* @param extensionId The unique identifier of the extension that generated the event.
*
* @return A new \c CSEvent object
*/
function CSEvent(type, scope, appId, extensionId)
{
this.type = type;
this.scope = scope;
this.appId = appId;
this.extensionId = extensionId;
}
/** Event-specific data. */
CSEvent.prototype.data = "";
/**
* @class SystemPath
* Stores operating-system-specific location constants for use in the
* \c #CSInterface.getSystemPath() method.
* @return A new \c SystemPath object.
*/
function SystemPath()
{
}
/** The path to user data. */
SystemPath.USER_DATA = "userData";
/** The path to common files for Adobe applications. */
SystemPath.COMMON_FILES = "commonFiles";
/** The path to the user's default document folder. */
SystemPath.MY_DOCUMENTS = "myDocuments";
/** @deprecated. Use \c #SystemPath.Extension. */
SystemPath.APPLICATION = "application";
/** The path to current extension. */
SystemPath.EXTENSION = "extension";
/** The path to hosting application's executable. */
SystemPath.HOST_APPLICATION = "hostApplication";
/**
* @class ColorType
* Stores color-type constants.
*/
function ColorType()
{
}
/** RGB color type. */
ColorType.RGB = "rgb";
/** Gradient color type. */
ColorType.GRADIENT = "gradient";
/** Null color type. */
ColorType.NONE = "none";
/**
* @class RGBColor
* Stores an RGB color with red, green, blue, and alpha values.
* All values are in the range [0.0 to 255.0]. Invalid numeric values are
* converted to numbers within this range.
*
* @param red The red value, in the range [0.0 to 255.0].
* @param green The green value, in the range [0.0 to 255.0].
* @param blue The blue value, in the range [0.0 to 255.0].
* @param alpha The alpha (transparency) value, in the range [0.0 to 255.0].
* The default, 255.0, means that the color is fully opaque.
*
* @return A new RGBColor object.
*/
function RGBColor(red, green, blue, alpha)
{
this.red = red;
this.green = green;
this.blue = blue;
this.alpha = alpha;
}
/**
* @class Direction
* A point value in which the y component is 0 and the x component
* is positive or negative for a right or left direction,
* or the x component is 0 and the y component is positive or negative for
* an up or down direction.
*
* @param x The horizontal component of the point.
* @param y The vertical component of the point.
*
* @return A new \c Direction object.
*/
function Direction(x, y)
{
this.x = x;
this.y = y;
}
/**
* @class GradientStop
* Stores gradient stop information.
*
* @param offset The offset of the gradient stop, in the range [0.0 to 1.0].
* @param rgbColor The color of the gradient at this point, an \c #RGBColor object.
*
* @return GradientStop object.
*/
function GradientStop(offset, rgbColor)
{
this.offset = offset;
this.rgbColor = rgbColor;
}
/**
* @class GradientColor
* Stores gradient color information.
*
* @param type The gradient type, must be "linear".
* @param direction A \c #Direction object for the direction of the gradient
(up, down, right, or left).
* @param numStops The number of stops in the gradient.
* @param gradientStopList An array of \c #GradientStop objects.
*
* @return A new \c GradientColor object.
*/
function GradientColor(type, direction, numStops, arrGradientStop)
{
this.type = type;
this.direction = direction;
this.numStops = numStops;
this.arrGradientStop = arrGradientStop;
}
/**
* @class UIColor
* Stores color information, including the type, anti-alias level, and specific color
* values in a color object of an appropriate type.
*
* @param type The color type, 1 for "rgb" and 2 for "gradient".
The supplied color object must correspond to this type.
* @param antialiasLevel The anti-alias level constant.
* @param color A \c #RGBColor or \c #GradientColor object containing specific color information.
*
* @return A new \c UIColor object.
*/
function UIColor(type, antialiasLevel, color)
{
this.type = type;
this.antialiasLevel = antialiasLevel;
this.color = color;
}
/**
* @class AppSkinInfo
* Stores window-skin properties, such as color and font. All color parameter values are \c #UIColor objects except that systemHighlightColor is \c #RGBColor object.
*
* @param baseFontFamily The base font family of the application.
* @param baseFontSize The base font size of the application.
* @param appBarBackgroundColor The application bar background color.
* @param panelBackgroundColor The background color of the extension panel.
* @param appBarBackgroundColorSRGB The application bar background color, as sRGB.
* @param panelBackgroundColorSRGB The background color of the extension panel, as sRGB.
* @param systemHighlightColor The highlight color of the extension panel, if provided by the host application. Otherwise, the operating-system highlight color.
*
* @return AppSkinInfo object.
*/
function AppSkinInfo(baseFontFamily, baseFontSize, appBarBackgroundColor, panelBackgroundColor, appBarBackgroundColorSRGB, panelBackgroundColorSRGB, systemHighlightColor)
{
this.baseFontFamily = baseFontFamily;
this.baseFontSize = baseFontSize;
this.appBarBackgroundColor = appBarBackgroundColor;
this.panelBackgroundColor = panelBackgroundColor;
this.appBarBackgroundColorSRGB = appBarBackgroundColorSRGB;
this.panelBackgroundColorSRGB = panelBackgroundColorSRGB;
this.systemHighlightColor = systemHighlightColor;
}
/**
* @class HostEnvironment
* Stores information about the environment in which the extension is loaded.
*
* @param appName The application's name.
* @param appVersion The application's version.
* @param appLocale The application's current license locale.
* @param appUILocale The application's current UI locale.
* @param appId The application's unique identifier.
* @param isAppOnline True if the application is currently online.
* @param appSkinInfo An \c #AppSkinInfo object containing the application's default color and font styles.
*
* @return A new \c HostEnvironment object.
*/
function HostEnvironment(appName, appVersion, appLocale, appUILocale, appId, isAppOnline, appSkinInfo)
{
this.appName = appName;
this.appVersion = appVersion;
this.appLocale = appLocale;
this.appUILocale = appUILocale;
this.appId = appId;
this.isAppOnline = isAppOnline;
this.appSkinInfo = appSkinInfo;
}
/**
* @class HostCapabilities
* Stores information about the host capabilities.
*
* @param EXTENDED_PANEL_MENU True if the application supports panel menu.
* @param EXTENDED_PANEL_ICONS True if the application supports panel icon.
* @param DELEGATE_APE_ENGINE True if the application supports delegated APE engine.
* @param SUPPORT_HTML_EXTENSIONS True if the application supports HTML extensions.
* @param DISABLE_FLASH_EXTENSIONS True if the application disables FLASH extensions.
*
* @return A new \c HostCapabilities object.
*/
function HostCapabilities(EXTENDED_PANEL_MENU, EXTENDED_PANEL_ICONS, DELEGATE_APE_ENGINE, SUPPORT_HTML_EXTENSIONS, DISABLE_FLASH_EXTENSIONS)
{
this.EXTENDED_PANEL_MENU = EXTENDED_PANEL_MENU;
this.EXTENDED_PANEL_ICONS = EXTENDED_PANEL_ICONS;
this.DELEGATE_APE_ENGINE = DELEGATE_APE_ENGINE;
this.SUPPORT_HTML_EXTENSIONS = SUPPORT_HTML_EXTENSIONS;
this.DISABLE_FLASH_EXTENSIONS = DISABLE_FLASH_EXTENSIONS; // Since 5.0.0
}
/**
* @class ApiVersion
* Stores current api version.
*
* Since 4.2.0
*
* @param major The major version
* @param minor The minor version.
* @param micro The micro version.
*
* @return ApiVersion object.
*/
function ApiVersion(major, minor, micro)
{
this.major = major;
this.minor = minor;
this.micro = micro;
}
/**
* @class MenuItemStatus
* Stores flyout menu item status
*
* Since 5.2.0
*
* @param menuItemLabel The menu item label.
* @param enabled True if user wants to enable the menu item.
* @param checked True if user wants to check the menu item.
*
* @return MenuItemStatus object.
*/
function MenuItemStatus(menuItemLabel, enabled, checked)
{
this.menuItemLabel = menuItemLabel;
this.enabled = enabled;
this.checked = checked;
}
/**
* @class ContextMenuItemStatus
* Stores the status of the context menu item.
*
* Since 5.2.0
*
* @param menuItemID The menu item id.
* @param enabled True if user wants to enable the menu item.
* @param checked True if user wants to check the menu item.
*
* @return MenuItemStatus object.
*/
function ContextMenuItemStatus(menuItemID, enabled, checked)
{
this.menuItemID = menuItemID;
this.enabled = enabled;
this.checked = checked;
}
//------------------------------ CSInterface ----------------------------------
/**
* @class CSInterface
* This is the entry point to the CEP extensibility infrastructure.
* Instantiate this object and use it to:
* <ul>
* <li>Access information about the host application in which an extension is running</li>
* <li>Launch an extension</li>
* <li>Register interest in event notifications, and dispatch events</li>
* </ul>
*
* @return A new \c CSInterface object
*/
function CSInterface()
{
}
/**
* User can add this event listener to handle native application theme color changes.
* Callback function gives extensions ability to fine-tune their theme color after the
* global theme color has been changed.
* The callback function should be like below:
*
* @example
* // event is a CSEvent object, but user can ignore it.
* function OnAppThemeColorChanged(event)
* {
* // Should get a latest HostEnvironment object from application.
* var skinInfo = JSON.parse(window.__adobe_cep__.getHostEnvironment()).appSkinInfo;
* // Gets the style information such as color info from the skinInfo,
* // and redraw all UI controls of your extension according to the style info.
* }
*/
CSInterface.THEME_COLOR_CHANGED_EVENT = "com.adobe.csxs.events.ThemeColorChanged";
/** The host environment data object. */
CSInterface.prototype.hostEnvironment = window.__adobe_cep__ ? JSON.parse(window.__adobe_cep__.getHostEnvironment()) : null;
/** Retrieves information about the host environment in which the
* extension is currently running.
*
* @return A \c #HostEnvironment object.
*/
CSInterface.prototype.getHostEnvironment = function()
{
this.hostEnvironment = JSON.parse(window.__adobe_cep__.getHostEnvironment());
return this.hostEnvironment;
};
/** Loads binary file created which is located at url asynchronously
*
*@param urlName url at which binary file is located. Local files should start with 'file://'
*@param callback Optional. A callback function that returns after binary is loaded
*@example
* To create JS binary use command ./cep_compiler test.js test.bin
* To load JS binary asyncronously
* var CSLib = new CSInterface();
* CSLib.loadBinAsync(url, function () { });
*/
CSInterface.prototype.loadBinAsync = function(urlName,callback)
{
try
{
var xhr = new XMLHttpRequest();
xhr.responseType = 'arraybuffer'; // make response as ArrayBuffer
xhr.open('GET', urlName, true);
xhr.onerror = function ()
{
console.log("Unable to load snapshot from given URL");
return false;
};
xhr.send();
xhr.onload = () => {
window.__adobe_cep__.loadSnapshot(xhr.response);
if (typeof callback === "function")
{
callback();
}
else if(typeof callback !== "undefined")
{
console.log("Provided callback is not a function");
}
}
}
catch(err)
{
console.log(err);
return false;
}
return true;
};
/** Loads binary file created synchronously
*
*@param pathName the local path at which binary file is located
*@example
* To create JS binary use command ./cep_compiler test.js test.bin
* To load JS binary syncronously
* var CSLib = new CSInterface();
* CSLib.loadBinSync(path);
*/
CSInterface.prototype.loadBinSync = function(pathName)
{
try
{
var OSVersion = this.getOSInformation();
if(pathName.startsWith("file://"))
{
if (OSVersion.indexOf("Windows") >= 0)
{
pathName = pathName.replace("file:///", "");
}
else if (OSVersion.indexOf("Mac") >= 0)
{
pathName = pathName.replace("file://", "");
}
window.__adobe_cep__.loadSnapshot(pathName);
return true;
}
}
catch(err)
{
console.log(err);
return false;
}
//control should not come here
return false;
};
/** Closes this extension. */
CSInterface.prototype.closeExtension = function()
{
window.__adobe_cep__.closeExtension();
};
/**
* Retrieves a path for which a constant is defined in the system.
*
* @param pathType The path-type constant defined in \c #SystemPath ,
*
* @return The platform-specific system path string.
*/
CSInterface.prototype.getSystemPath = function(pathType)
{
var path = decodeURI(window.__adobe_cep__.getSystemPath(pathType));
var OSVersion = this.getOSInformation();
if (OSVersion.indexOf("Windows") >= 0)
{
path = path.replace("file:///", "");
}
else if (OSVersion.indexOf("Mac") >= 0)
{
path = path.replace("file://", "");
}
return path;
};
/**
* Evaluates a JavaScript script, which can use the JavaScript DOM
* of the host application.
*
* @param script The JavaScript script.
* @param callback Optional. A callback function that receives the result of execution.
* If execution fails, the callback function receives the error message \c EvalScript_ErrMessage.
*/
CSInterface.prototype.evalScript = function(script, callback)
{
if(callback === null || callback === undefined)
{
callback = function(result){};
}
window.__adobe_cep__.evalScript(script, callback);
};
/**
* Retrieves the unique identifier of the application.
* in which the extension is currently running.
*
* @return The unique ID string.
*/
CSInterface.prototype.getApplicationID = function()
{
var appId = this.hostEnvironment.appId;
return appId;
};
/**
* Retrieves host capability information for the application
* in which the extension is currently running.
*
* @return A \c #HostCapabilities object.
*/
CSInterface.prototype.getHostCapabilities = function()
{
var hostCapabilities = JSON.parse(window.__adobe_cep__.getHostCapabilities() );
return hostCapabilities;
};
/**
* Triggers a CEP event programmatically. Yoy can use it to dispatch
* an event of a predefined type, or of a type you have defined.
*
* @param event A \c CSEvent object.
*/
CSInterface.prototype.dispatchEvent = function(event)
{
if (typeof event.data == "object")
{
event.data = JSON.stringify(event.data);
}
window.__adobe_cep__.dispatchEvent(event);
};
/**
* Registers an interest in a CEP event of a particular type, and
* assigns an event handler.
* The event infrastructure notifies your extension when events of this type occur,
* passing the event object to the registered handler function.
*
* @param type The name of the event type of interest.
* @param listener The JavaScript handler function or method.
* @param obj Optional, the object containing the handler method, if any.
* Default is null.
*/
CSInterface.prototype.addEventListener = function(type, listener, obj)
{
window.__adobe_cep__.addEventListener(type, listener, obj);
};
/**
* Removes a registered event listener.
*
* @param type The name of the event type of interest.
* @param listener The JavaScript handler function or method that was registered.
* @param obj Optional, the object containing the handler method, if any.
* Default is null.
*/
CSInterface.prototype.removeEventListener = function(type, listener, obj)
{
window.__adobe_cep__.removeEventListener(type, listener, obj);
};
/**
* Loads and launches another extension, or activates the extension if it is already loaded.
*
* @param extensionId The extension's unique identifier.
* @param startupParams Not currently used, pass "".
*
* @example
* To launch the extension "help" with ID "HLP" from this extension, call:
* <code>requestOpenExtension("HLP", ""); </code>
*
*/
CSInterface.prototype.requestOpenExtension = function(extensionId, params)
{
window.__adobe_cep__.requestOpenExtension(extensionId, params);
};
/**
* Retrieves the list of extensions currently loaded in the current host application.
* The extension list is initialized once, and remains the same during the lifetime
* of the CEP session.
*
* @param extensionIds Optional, an array of unique identifiers for extensions of interest.
* If omitted, retrieves data for all extensions.
*
* @return Zero or more \c #Extension objects.
*/
CSInterface.prototype.getExtensions = function(extensionIds)
{
var extensionIdsStr = JSON.stringify(extensionIds);
var extensionsStr = window.__adobe_cep__.getExtensions(extensionIdsStr);
var extensions = JSON.parse(extensionsStr);
return extensions;
};
/**
* Retrieves network-related preferences.
*
* @return A JavaScript object containing network preferences.
*/
CSInterface.prototype.getNetworkPreferences = function()
{
var result = window.__adobe_cep__.getNetworkPreferences();
var networkPre = JSON.parse(result);
return networkPre;
};
/**
* Initializes the resource bundle for this extension with property values
* for the current application and locale.
* To support multiple locales, you must define a property file for each locale,
* containing keyed display-string values for that locale.
* See localization documentation for Extension Builder and related products.
*
* Keys can be in the
* form <code>key.value="localized string"</code>, for use in HTML text elements.
* For example, in this input element, the localized \c key.value string is displayed
* instead of the empty \c value string:
*
* <code><input type="submit" value="" data-locale="key"/></code>
*
* @return An object containing the resource bundle information.
*/
CSInterface.prototype.initResourceBundle = function()
{
var resourceBundle = JSON.parse(window.__adobe_cep__.initResourceBundle());
var resElms = document.querySelectorAll('[data-locale]');
for (var n = 0; n < resElms.length; n++)
{
var resEl = resElms[n];
// Get the resource key from the element.
var resKey = resEl.getAttribute('data-locale');
if (resKey)
{
// Get all the resources that start with the key.
for (var key in resourceBundle)
{
if (key.indexOf(resKey) === 0)
{
var resValue = resourceBundle[key];
if (key.length == resKey.length)
{
resEl.innerHTML = resValue;
}
else if ('.' == key.charAt(resKey.length))
{
var attrKey = key.substring(resKey.length + 1);
resEl[attrKey] = resValue;
}
}
}
}
}
return resourceBundle;
};
/**
* Writes installation information to a file.
*
* @return The file path.
*/
CSInterface.prototype.dumpInstallationInfo = function()
{
return window.__adobe_cep__.dumpInstallationInfo();
};
/**
* Retrieves version information for the current Operating System,
* See http://www.useragentstring.com/pages/Chrome/ for Chrome \c navigator.userAgent values.
*
* @return A string containing the OS version, or "unknown Operation System".
* If user customizes the User Agent by setting CEF command parameter "--user-agent", only
* "Mac OS X" or "Windows" will be returned.
*/
CSInterface.prototype.getOSInformation = function()
{
var userAgent = navigator.userAgent;
if ((navigator.platform == "Win32") || (navigator.platform == "Windows"))
{
var winVersion = "Windows";
var winBit = "";
if (userAgent.indexOf("Windows") > -1)
{
if (userAgent.indexOf("Windows NT 5.0") > -1)
{
winVersion = "Windows 2000";
}
else if (userAgent.indexOf("Windows NT 5.1") > -1)
{
winVersion = "Windows XP";
}
else if (userAgent.indexOf("Windows NT 5.2") > -1)
{
winVersion = "Windows Server 2003";
}
else if (userAgent.indexOf("Windows NT 6.0") > -1)
{
winVersion = "Windows Vista";
}
else if (userAgent.indexOf("Windows NT 6.1") > -1)
{
winVersion = "Windows 7";
}
else if (userAgent.indexOf("Windows NT 6.2") > -1)
{
winVersion = "Windows 8";
}
else if (userAgent.indexOf("Windows NT 6.3") > -1)
{
winVersion = "Windows 8.1";
}
else if (userAgent.indexOf("Windows NT 10") > -1)
{
winVersion = "Windows 10";
}
if (userAgent.indexOf("WOW64") > -1 || userAgent.indexOf("Win64") > -1)
{
winBit = " 64-bit";
}
else
{
winBit = " 32-bit";
}
}
return winVersion + winBit;
}
else if ((navigator.platform == "MacIntel") || (navigator.platform == "Macintosh"))
{
var result = "Mac OS X";
if (userAgent.indexOf("Mac OS X") > -1)
{
result = userAgent.substring(userAgent.indexOf("Mac OS X"), userAgent.indexOf(")"));
result = result.replace(/_/g, ".");
}
return result;
}
return "Unknown Operation System";
};
/**
* Opens a page in the default system browser.
*
* Since 4.2.0
*
* @param url The URL of the page/file to open, or the email address.
* Must use HTTP/HTTPS/file/mailto protocol. For example:
* "http://www.adobe.com"
* "https://github.com"
* "file:///C:/log.txt"
* "mailto:[email protected]"
*
* @return One of these error codes:\n
* <ul>\n
* <li>NO_ERROR - 0</li>\n
* <li>ERR_UNKNOWN - 1</li>\n
* <li>ERR_INVALID_PARAMS - 2</li>\n
* <li>ERR_INVALID_URL - 201</li>\n
* </ul>\n
*/
CSInterface.prototype.openURLInDefaultBrowser = function(url)
{
return cep.util.openURLInDefaultBrowser(url);
};
/**
* Retrieves extension ID.
*
* Since 4.2.0
*
* @return extension ID.
*/
CSInterface.prototype.getExtensionID = function()
{
return window.__adobe_cep__.getExtensionId();
};
/**
* Retrieves the scale factor of screen.
* On Windows platform, the value of scale factor might be different from operating system's scale factor,
* since host application may use its self-defined scale factor.
*
* Since 4.2.0
*
* @return One of the following float number.
* <ul>\n
* <li> -1.0 when error occurs </li>\n
* <li> 1.0 means normal screen </li>\n
* <li> >1.0 means HiDPI screen </li>\n
* </ul>\n
*/
CSInterface.prototype.getScaleFactor = function()
{
return window.__adobe_cep__.getScaleFactor();
};
/**
* Retrieves the scale factor of Monitor.
*
* Since 8.5.0
*
* @return value >= 1.0f
* only available for windows machine
*/
if(navigator.appVersion.toLowerCase().indexOf("windows") >= 0) {
CSInterface.prototype.getMonitorScaleFactor = function()
{
return window.__adobe_cep__.getMonitorScaleFactor();
};
}
/**
* Set a handler to detect any changes of scale factor. This only works on Mac.
*
* Since 4.2.0
*
* @param handler The function to be called when scale factor is changed.
*
*/
CSInterface.prototype.setScaleFactorChangedHandler = function(handler)
{
window.__adobe_cep__.setScaleFactorChangedHandler(handler);
};
/**
* Retrieves current API version.
*
* Since 4.2.0
*
* @return ApiVersion object.
*
*/
CSInterface.prototype.getCurrentApiVersion = function()
{
var apiVersion = JSON.parse(window.__adobe_cep__.getCurrentApiVersion());
return apiVersion;
};
/**
* Set panel flyout menu by an XML.
*
* Since 5.2.0
*
* Register a callback function for "com.adobe.csxs.events.flyoutMenuClicked" to get notified when a
* menu item is clicked.
* The "data" attribute of event is an object which contains "menuId" and "menuName" attributes.
*
* Register callback functions for "com.adobe.csxs.events.flyoutMenuOpened" and "com.adobe.csxs.events.flyoutMenuClosed"
* respectively to get notified when flyout menu is opened or closed.
*
* @param menu A XML string which describes menu structure.
* An example menu XML:
* <Menu>
* <MenuItem Id="menuItemId1" Label="TestExample1" Enabled="true" Checked="false"/>
* <MenuItem Label="TestExample2">
* <MenuItem Label="TestExample2-1" >
* <MenuItem Label="TestExample2-1-1" Enabled="false" Checked="true"/>
* </MenuItem>
* <MenuItem Label="TestExample2-2" Enabled="true" Checked="true"/>
* </MenuItem>
* <MenuItem Label="---" />
* <MenuItem Label="TestExample3" Enabled="false" Checked="false"/>
* </Menu>
*
*/
CSInterface.prototype.setPanelFlyoutMenu = function(menu)
{
if ("string" != typeof menu)
{
return;
}
window.__adobe_cep__.invokeSync("setPanelFlyoutMenu", menu);
};
/**
* Updates a menu item in the extension window's flyout menu, by setting the enabled
* and selection status.
*
* Since 5.2.0
*
* @param menuItemLabel The menu item label.
* @param enabled True to enable the item, false to disable it (gray it out).
* @param checked True to select the item, false to deselect it.
*
* @return false when the host application does not support this functionality (HostCapabilities.EXTENDED_PANEL_MENU is false).
* Fails silently if menu label is invalid.
*
* @see HostCapabilities.EXTENDED_PANEL_MENU
*/
CSInterface.prototype.updatePanelMenuItem = function(menuItemLabel, enabled, checked)
{
var ret = false;
if (this.getHostCapabilities().EXTENDED_PANEL_MENU)
{
var itemStatus = new MenuItemStatus(menuItemLabel, enabled, checked);
ret = window.__adobe_cep__.invokeSync("updatePanelMenuItem", JSON.stringify(itemStatus));
}
return ret;
};
/**
* Set context menu by XML string.
*
* Since 5.2.0
*
* There are a number of conventions used to communicate what type of menu item to create and how it should be handled.
* - an item without menu ID or menu name is disabled and is not shown.
* - if the item name is "---" (three hyphens) then it is treated as a separator. The menu ID in this case will always be NULL.
* - Checkable attribute takes precedence over Checked attribute.
* - a PNG icon. For optimal display results please supply a 16 x 16px icon as larger dimensions will increase the size of the menu item.
The Chrome extension contextMenus API was taken as a reference.
https://developer.chrome.com/extensions/contextMenus
* - the items with icons and checkable items cannot coexist on the same menu level. The former take precedences over the latter.
*
* @param menu A XML string which describes menu structure.
* @param callback The callback function which is called when a menu item is clicked. The only parameter is the returned ID of clicked menu item.
*
* @description An example menu XML:
* <Menu>
* <MenuItem Id="menuItemId1" Label="TestExample1" Enabled="true" Checkable="true" Checked="false" Icon="./image/small_16X16.png"/>
* <MenuItem Id="menuItemId2" Label="TestExample2">
* <MenuItem Id="menuItemId2-1" Label="TestExample2-1" >
* <MenuItem Id="menuItemId2-1-1" Label="TestExample2-1-1" Enabled="false" Checkable="true" Checked="true"/>
* </MenuItem>
* <MenuItem Id="menuItemId2-2" Label="TestExample2-2" Enabled="true" Checkable="true" Checked="true"/>
* </MenuItem>
* <MenuItem Label="---" />
* <MenuItem Id="menuItemId3" Label="TestExample3" Enabled="false" Checkable="true" Checked="false"/>
* </Menu>
*/
CSInterface.prototype.setContextMenu = function(menu, callback)
{
if ("string" != typeof menu)
{
return;
}
window.__adobe_cep__.invokeAsync("setContextMenu", menu, callback);
};
/**
* Set context menu by JSON string.
*
* Since 6.0.0
*
* There are a number of conventions used to communicate what type of menu item to create and how it should be handled.
* - an item without menu ID or menu name is disabled and is not shown.
* - if the item label is "---" (three hyphens) then it is treated as a separator. The menu ID in this case will always be NULL.
* - Checkable attribute takes precedence over Checked attribute.
* - a PNG icon. For optimal display results please supply a 16 x 16px icon as larger dimensions will increase the size of the menu item.
The Chrome extension contextMenus API was taken as a reference.
* - the items with icons and checkable items cannot coexist on the same menu level. The former take precedences over the latter.
https://developer.chrome.com/extensions/contextMenus
*
* @param menu A JSON string which describes menu structure.
* @param callback The callback function which is called when a menu item is clicked. The only parameter is the returned ID of clicked menu item.
*
* @description An example menu JSON:
*
* {
* "menu": [
* {
* "id": "menuItemId1",
* "label": "testExample1",
* "enabled": true,
* "checkable": true,
* "checked": false,
* "icon": "./image/small_16X16.png"
* },
* {
* "id": "menuItemId2",
* "label": "testExample2",
* "menu": [
* {
* "id": "menuItemId2-1",
* "label": "testExample2-1",
* "menu": [
* {
* "id": "menuItemId2-1-1",
* "label": "testExample2-1-1",
* "enabled": false,
* "checkable": true,
* "checked": true
* }
* ]
* },
* {
* "id": "menuItemId2-2",
* "label": "testExample2-2",
* "enabled": true,
* "checkable": true,
* "checked": true
* }
* ]
* },
* {
* "label": "---"
* },
* {
* "id": "menuItemId3",
* "label": "testExample3",
* "enabled": false,
* "checkable": true,
* "checked": false
* }
* ]
* }
*
*/
CSInterface.prototype.setContextMenuByJSON = function(menu, callback)
{
if ("string" != typeof menu)
{
return;
}
window.__adobe_cep__.invokeAsync("setContextMenuByJSON", menu, callback);
};
/**
* Updates a context menu item by setting the enabled and selection status.
*
* Since 5.2.0
*
* @param menuItemID The menu item ID.
* @param enabled True to enable the item, false to disable it (gray it out).
* @param checked True to select the item, false to deselect it.
*/
CSInterface.prototype.updateContextMenuItem = function(menuItemID, enabled, checked)
{
var itemStatus = new ContextMenuItemStatus(menuItemID, enabled, checked);
ret = window.__adobe_cep__.invokeSync("updateContextMenuItem", JSON.stringify(itemStatus));
};
/**
* Get the visibility status of an extension window.
*
* Since 6.0.0
*
* @return true if the extension window is visible; false if the extension window is hidden.
*/
CSInterface.prototype.isWindowVisible = function()
{
return window.__adobe_cep__.invokeSync("isWindowVisible", "");
};
/**
* Resize extension's content to the specified dimensions.
* 1. Works with modal and modeless extensions in all Adobe products.
* 2. Extension's manifest min/max size constraints apply and take precedence.
* 3. For panel extensions
* 3.1 This works in all Adobe products except:
* * Premiere Pro
* * Prelude
* * After Effects
* 3.2 When the panel is in certain states (especially when being docked),
* it will not change to the desired dimensions even when the
* specified size satisfies min/max constraints.
*
* Since 6.0.0
*
* @param width The new width
* @param height The new height
*/
CSInterface.prototype.resizeContent = function(width, height)
{
window.__adobe_cep__.resizeContent(width, height);
};
/**
* Register the invalid certificate callback for an extension.
* This callback will be triggered when the extension tries to access the web site that contains the invalid certificate on the main frame.
* But if the extension does not call this function and tries to access the web site containing the invalid certificate, a default error page will be shown.
*
* Since 6.1.0
*
* @param callback the callback function
*/
CSInterface.prototype.registerInvalidCertificateCallback = function(callback)
{
return window.__adobe_cep__.registerInvalidCertificateCallback(callback);
};
/**
* Register an interest in some key events to prevent them from being sent to the host application.
*
* This function works with modeless extensions and panel extensions.
* Generally all the key events will be sent to the host application for these two extensions if the current focused element
* is not text input or dropdown,
* If you want to intercept some key events and want them to be handled in the extension, please call this function
* in advance to prevent them being sent to the host application.
*
* Since 6.1.0
*
* @param keyEventsInterest A JSON string describing those key events you are interested in. A null object or
an empty string will lead to removing the interest
*
* This JSON string should be an array, each object has following keys:
*
* keyCode: [Required] represents an OS system dependent virtual key code identifying
* the unmodified value of the pressed key.
* ctrlKey: [optional] a Boolean that indicates if the control key was pressed (true) or not (false) when the event occurred.
* altKey: [optional] a Boolean that indicates if the alt key was pressed (true) or not (false) when the event occurred.
* shiftKey: [optional] a Boolean that indicates if the shift key was pressed (true) or not (false) when the event occurred.
* metaKey: [optional] (Mac Only) a Boolean that indicates if the Meta key was pressed (true) or not (false) when the event occurred.
* On Macintosh keyboards, this is the command key. To detect Windows key on Windows, please use keyCode instead.
* An example JSON string:
*
* [
* {
* "keyCode": 48
* },
* {
* "keyCode": 123,
* "ctrlKey": true
* },
* {
* "keyCode": 123,
* "ctrlKey": true,
* "metaKey": true
* }
* ]
*
*/
CSInterface.prototype.registerKeyEventsInterest = function(keyEventsInterest)
{
return window.__adobe_cep__.registerKeyEventsInterest(keyEventsInterest);
};
/**
* Set the title of the extension window.
* This function works with modal and modeless extensions in all Adobe products, and panel extensions in Photoshop, InDesign, InCopy, Illustrator, Flash Pro and Dreamweaver.
*
* Since 6.1.0
*
* @param title The window title.
*/
CSInterface.prototype.setWindowTitle = function(title)
{
window.__adobe_cep__.invokeSync("setWindowTitle", title);
};
/**
* Get the title of the extension window.
* This function works with modal and modeless extensions in all Adobe products, and panel extensions in Photoshop, InDesign, InCopy, Illustrator, Flash Pro and Dreamweaver.
*
* Since 6.1.0
*
* @return The window title.
*/
CSInterface.prototype.getWindowTitle = function()
{
return window.__adobe_cep__.invokeSync("getWindowTitle", "");
};
```
--------------------------------------------------------------------------------
/cep/com.mikechambers.ai/lib/CSInterface.js:
--------------------------------------------------------------------------------
```javascript
/**************************************************************************************************
*
* ADOBE SYSTEMS INCORPORATED
* Copyright 2020 Adobe Systems Incorporated
* All Rights Reserved.
*
* NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the
* terms of the Adobe license agreement accompanying it. If you have received this file from a
* source other than Adobe, then your use, modification, or distribution of it requires the prior
* written permission of Adobe.
*
**************************************************************************************************/
/** CSInterface - v12.0.0 */
/**
* Stores constants for the window types supported by the CSXS infrastructure.
*/
function CSXSWindowType()
{
}
/** Constant for the CSXS window type Panel. */
CSXSWindowType._PANEL = "Panel";
/** Constant for the CSXS window type Modeless. */
CSXSWindowType._MODELESS = "Modeless";
/** Constant for the CSXS window type ModalDialog. */
CSXSWindowType._MODAL_DIALOG = "ModalDialog";
/** EvalScript error message */
EvalScript_ErrMessage = "EvalScript error.";
/**
* @class Version
* Defines a version number with major, minor, micro, and special
* components. The major, minor and micro values are numeric; the special
* value can be any string.
*
* @param major The major version component, a positive integer up to nine digits long.
* @param minor The minor version component, a positive integer up to nine digits long.
* @param micro The micro version component, a positive integer up to nine digits long.
* @param special The special version component, an arbitrary string.
*
* @return A new \c Version object.
*/
function Version(major, minor, micro, special)
{
this.major = major;
this.minor = minor;
this.micro = micro;
this.special = special;
}
/**
* The maximum value allowed for a numeric version component.
* This reflects the maximum value allowed in PlugPlug and the manifest schema.
*/
Version.MAX_NUM = 999999999;
/**
* @class VersionBound
* Defines a boundary for a version range, which associates a \c Version object
* with a flag for whether it is an inclusive or exclusive boundary.
*
* @param version The \c #Version object.
* @param inclusive True if this boundary is inclusive, false if it is exclusive.
*
* @return A new \c VersionBound object.
*/
function VersionBound(version, inclusive)
{
this.version = version;
this.inclusive = inclusive;
}
/**
* @class VersionRange
* Defines a range of versions using a lower boundary and optional upper boundary.
*
* @param lowerBound The \c #VersionBound object.
* @param upperBound The \c #VersionBound object, or null for a range with no upper boundary.
*
* @return A new \c VersionRange object.
*/
function VersionRange(lowerBound, upperBound)
{
this.lowerBound = lowerBound;
this.upperBound = upperBound;
}
/**
* @class Runtime
* Represents a runtime related to the CEP infrastructure.
* Extensions can declare dependencies on particular
* CEP runtime versions in the extension manifest.
*
* @param name The runtime name.
* @param version A \c #VersionRange object that defines a range of valid versions.
*
* @return A new \c Runtime object.
*/
function Runtime(name, versionRange)
{
this.name = name;
this.versionRange = versionRange;
}
/**
* @class Extension
* Encapsulates a CEP-based extension to an Adobe application.
*
* @param id The unique identifier of this extension.
* @param name The localizable display name of this extension.
* @param mainPath The path of the "index.html" file.
* @param basePath The base path of this extension.
* @param windowType The window type of the main window of this extension.
Valid values are defined by \c #CSXSWindowType.
* @param width The default width in pixels of the main window of this extension.
* @param height The default height in pixels of the main window of this extension.
* @param minWidth The minimum width in pixels of the main window of this extension.
* @param minHeight The minimum height in pixels of the main window of this extension.
* @param maxWidth The maximum width in pixels of the main window of this extension.
* @param maxHeight The maximum height in pixels of the main window of this extension.
* @param defaultExtensionDataXml The extension data contained in the default \c ExtensionDispatchInfo section of the extension manifest.
* @param specialExtensionDataXml The extension data contained in the application-specific \c ExtensionDispatchInfo section of the extension manifest.
* @param requiredRuntimeList An array of \c Runtime objects for runtimes required by this extension.
* @param isAutoVisible True if this extension is visible on loading.
* @param isPluginExtension True if this extension has been deployed in the Plugins folder of the host application.
*
* @return A new \c Extension object.
*/
function Extension(id, name, mainPath, basePath, windowType, width, height, minWidth, minHeight, maxWidth, maxHeight,
defaultExtensionDataXml, specialExtensionDataXml, requiredRuntimeList, isAutoVisible, isPluginExtension)
{
this.id = id;
this.name = name;
this.mainPath = mainPath;
this.basePath = basePath;
this.windowType = windowType;
this.width = width;
this.height = height;
this.minWidth = minWidth;
this.minHeight = minHeight;
this.maxWidth = maxWidth;
this.maxHeight = maxHeight;
this.defaultExtensionDataXml = defaultExtensionDataXml;
this.specialExtensionDataXml = specialExtensionDataXml;
this.requiredRuntimeList = requiredRuntimeList;
this.isAutoVisible = isAutoVisible;
this.isPluginExtension = isPluginExtension;
}
/**
* @class CSEvent
* A standard JavaScript event, the base class for CEP events.
*
* @param type The name of the event type.
* @param scope The scope of event, can be "GLOBAL" or "APPLICATION".
* @param appId The unique identifier of the application that generated the event.
* @param extensionId The unique identifier of the extension that generated the event.
*
* @return A new \c CSEvent object
*/
function CSEvent(type, scope, appId, extensionId)
{
this.type = type;
this.scope = scope;
this.appId = appId;
this.extensionId = extensionId;
}
/** Event-specific data. */
CSEvent.prototype.data = "";
/**
* @class SystemPath
* Stores operating-system-specific location constants for use in the
* \c #CSInterface.getSystemPath() method.
* @return A new \c SystemPath object.
*/
function SystemPath()
{
}
/** The path to user data. */
SystemPath.USER_DATA = "userData";
/** The path to common files for Adobe applications. */
SystemPath.COMMON_FILES = "commonFiles";
/** The path to the user's default document folder. */
SystemPath.MY_DOCUMENTS = "myDocuments";
/** @deprecated. Use \c #SystemPath.Extension. */
SystemPath.APPLICATION = "application";
/** The path to current extension. */
SystemPath.EXTENSION = "extension";
/** The path to hosting application's executable. */
SystemPath.HOST_APPLICATION = "hostApplication";
/**
* @class ColorType
* Stores color-type constants.
*/
function ColorType()
{
}
/** RGB color type. */
ColorType.RGB = "rgb";
/** Gradient color type. */
ColorType.GRADIENT = "gradient";
/** Null color type. */
ColorType.NONE = "none";
/**
* @class RGBColor
* Stores an RGB color with red, green, blue, and alpha values.
* All values are in the range [0.0 to 255.0]. Invalid numeric values are
* converted to numbers within this range.
*
* @param red The red value, in the range [0.0 to 255.0].
* @param green The green value, in the range [0.0 to 255.0].
* @param blue The blue value, in the range [0.0 to 255.0].
* @param alpha The alpha (transparency) value, in the range [0.0 to 255.0].
* The default, 255.0, means that the color is fully opaque.
*
* @return A new RGBColor object.
*/
function RGBColor(red, green, blue, alpha)
{
this.red = red;
this.green = green;
this.blue = blue;
this.alpha = alpha;
}
/**
* @class Direction
* A point value in which the y component is 0 and the x component
* is positive or negative for a right or left direction,
* or the x component is 0 and the y component is positive or negative for
* an up or down direction.
*
* @param x The horizontal component of the point.
* @param y The vertical component of the point.
*
* @return A new \c Direction object.
*/
function Direction(x, y)
{
this.x = x;
this.y = y;
}
/**
* @class GradientStop
* Stores gradient stop information.
*
* @param offset The offset of the gradient stop, in the range [0.0 to 1.0].
* @param rgbColor The color of the gradient at this point, an \c #RGBColor object.
*
* @return GradientStop object.
*/
function GradientStop(offset, rgbColor)
{
this.offset = offset;
this.rgbColor = rgbColor;
}
/**
* @class GradientColor
* Stores gradient color information.
*
* @param type The gradient type, must be "linear".
* @param direction A \c #Direction object for the direction of the gradient
(up, down, right, or left).
* @param numStops The number of stops in the gradient.
* @param gradientStopList An array of \c #GradientStop objects.
*
* @return A new \c GradientColor object.
*/
function GradientColor(type, direction, numStops, arrGradientStop)
{
this.type = type;
this.direction = direction;
this.numStops = numStops;
this.arrGradientStop = arrGradientStop;
}
/**
* @class UIColor
* Stores color information, including the type, anti-alias level, and specific color
* values in a color object of an appropriate type.
*
* @param type The color type, 1 for "rgb" and 2 for "gradient".
The supplied color object must correspond to this type.
* @param antialiasLevel The anti-alias level constant.
* @param color A \c #RGBColor or \c #GradientColor object containing specific color information.
*
* @return A new \c UIColor object.
*/
function UIColor(type, antialiasLevel, color)
{
this.type = type;
this.antialiasLevel = antialiasLevel;
this.color = color;
}
/**
* @class AppSkinInfo
* Stores window-skin properties, such as color and font. All color parameter values are \c #UIColor objects except that systemHighlightColor is \c #RGBColor object.
*
* @param baseFontFamily The base font family of the application.
* @param baseFontSize The base font size of the application.
* @param appBarBackgroundColor The application bar background color.
* @param panelBackgroundColor The background color of the extension panel.
* @param appBarBackgroundColorSRGB The application bar background color, as sRGB.
* @param panelBackgroundColorSRGB The background color of the extension panel, as sRGB.
* @param systemHighlightColor The highlight color of the extension panel, if provided by the host application. Otherwise, the operating-system highlight color.
*
* @return AppSkinInfo object.
*/
function AppSkinInfo(baseFontFamily, baseFontSize, appBarBackgroundColor, panelBackgroundColor, appBarBackgroundColorSRGB, panelBackgroundColorSRGB, systemHighlightColor)
{
this.baseFontFamily = baseFontFamily;
this.baseFontSize = baseFontSize;
this.appBarBackgroundColor = appBarBackgroundColor;
this.panelBackgroundColor = panelBackgroundColor;
this.appBarBackgroundColorSRGB = appBarBackgroundColorSRGB;
this.panelBackgroundColorSRGB = panelBackgroundColorSRGB;
this.systemHighlightColor = systemHighlightColor;
}
/**
* @class HostEnvironment
* Stores information about the environment in which the extension is loaded.
*
* @param appName The application's name.
* @param appVersion The application's version.
* @param appLocale The application's current license locale.
* @param appUILocale The application's current UI locale.
* @param appId The application's unique identifier.
* @param isAppOnline True if the application is currently online.
* @param appSkinInfo An \c #AppSkinInfo object containing the application's default color and font styles.
*
* @return A new \c HostEnvironment object.
*/
function HostEnvironment(appName, appVersion, appLocale, appUILocale, appId, isAppOnline, appSkinInfo)
{
this.appName = appName;
this.appVersion = appVersion;
this.appLocale = appLocale;
this.appUILocale = appUILocale;
this.appId = appId;
this.isAppOnline = isAppOnline;
this.appSkinInfo = appSkinInfo;
}
/**
* @class HostCapabilities
* Stores information about the host capabilities.
*
* @param EXTENDED_PANEL_MENU True if the application supports panel menu.
* @param EXTENDED_PANEL_ICONS True if the application supports panel icon.
* @param DELEGATE_APE_ENGINE True if the application supports delegated APE engine.
* @param SUPPORT_HTML_EXTENSIONS True if the application supports HTML extensions.
* @param DISABLE_FLASH_EXTENSIONS True if the application disables FLASH extensions.
*
* @return A new \c HostCapabilities object.
*/
function HostCapabilities(EXTENDED_PANEL_MENU, EXTENDED_PANEL_ICONS, DELEGATE_APE_ENGINE, SUPPORT_HTML_EXTENSIONS, DISABLE_FLASH_EXTENSIONS)
{
this.EXTENDED_PANEL_MENU = EXTENDED_PANEL_MENU;
this.EXTENDED_PANEL_ICONS = EXTENDED_PANEL_ICONS;
this.DELEGATE_APE_ENGINE = DELEGATE_APE_ENGINE;
this.SUPPORT_HTML_EXTENSIONS = SUPPORT_HTML_EXTENSIONS;
this.DISABLE_FLASH_EXTENSIONS = DISABLE_FLASH_EXTENSIONS; // Since 5.0.0
}
/**
* @class ApiVersion
* Stores current api version.
*
* Since 4.2.0
*
* @param major The major version
* @param minor The minor version.
* @param micro The micro version.
*
* @return ApiVersion object.
*/
function ApiVersion(major, minor, micro)
{
this.major = major;
this.minor = minor;
this.micro = micro;
}
/**
* @class MenuItemStatus
* Stores flyout menu item status
*
* Since 5.2.0
*
* @param menuItemLabel The menu item label.
* @param enabled True if user wants to enable the menu item.
* @param checked True if user wants to check the menu item.
*
* @return MenuItemStatus object.
*/
function MenuItemStatus(menuItemLabel, enabled, checked)
{
this.menuItemLabel = menuItemLabel;
this.enabled = enabled;
this.checked = checked;
}
/**
* @class ContextMenuItemStatus
* Stores the status of the context menu item.
*
* Since 5.2.0
*
* @param menuItemID The menu item id.
* @param enabled True if user wants to enable the menu item.
* @param checked True if user wants to check the menu item.
*
* @return MenuItemStatus object.
*/
function ContextMenuItemStatus(menuItemID, enabled, checked)
{
this.menuItemID = menuItemID;
this.enabled = enabled;
this.checked = checked;
}
//------------------------------ CSInterface ----------------------------------
/**
* @class CSInterface
* This is the entry point to the CEP extensibility infrastructure.
* Instantiate this object and use it to:
* <ul>
* <li>Access information about the host application in which an extension is running</li>
* <li>Launch an extension</li>
* <li>Register interest in event notifications, and dispatch events</li>
* </ul>
*
* @return A new \c CSInterface object
*/
function CSInterface()
{
}
/**
* User can add this event listener to handle native application theme color changes.
* Callback function gives extensions ability to fine-tune their theme color after the
* global theme color has been changed.
* The callback function should be like below:
*
* @example
* // event is a CSEvent object, but user can ignore it.
* function OnAppThemeColorChanged(event)
* {
* // Should get a latest HostEnvironment object from application.
* var skinInfo = JSON.parse(window.__adobe_cep__.getHostEnvironment()).appSkinInfo;
* // Gets the style information such as color info from the skinInfo,
* // and redraw all UI controls of your extension according to the style info.
* }
*/
CSInterface.THEME_COLOR_CHANGED_EVENT = "com.adobe.csxs.events.ThemeColorChanged";
/** The host environment data object. */
CSInterface.prototype.hostEnvironment = window.__adobe_cep__ ? JSON.parse(window.__adobe_cep__.getHostEnvironment()) : null;
/** Retrieves information about the host environment in which the
* extension is currently running.
*
* @return A \c #HostEnvironment object.
*/
CSInterface.prototype.getHostEnvironment = function()
{
this.hostEnvironment = JSON.parse(window.__adobe_cep__.getHostEnvironment());
return this.hostEnvironment;
};
/** Loads binary file created which is located at url asynchronously
*
*@param urlName url at which binary file is located. Local files should start with 'file://'
*@param callback Optional. A callback function that returns after binary is loaded
*@example
* To create JS binary use command ./cep_compiler test.js test.bin
* To load JS binary asyncronously
* var CSLib = new CSInterface();
* CSLib.loadBinAsync(url, function () { });
*/
CSInterface.prototype.loadBinAsync = function(urlName,callback)
{
try
{
var xhr = new XMLHttpRequest();
xhr.responseType = 'arraybuffer'; // make response as ArrayBuffer
xhr.open('GET', urlName, true);
xhr.onerror = function ()
{
console.log("Unable to load snapshot from given URL");
return false;
};
xhr.send();
xhr.onload = () => {
window.__adobe_cep__.loadSnapshot(xhr.response);
if (typeof callback === "function")
{
callback();
}
else if(typeof callback !== "undefined")
{
console.log("Provided callback is not a function");
}
}
}
catch(err)
{
console.log(err);
return false;
}
return true;
};
/** Loads binary file created synchronously
*
*@param pathName the local path at which binary file is located
*@example
* To create JS binary use command ./cep_compiler test.js test.bin
* To load JS binary syncronously
* var CSLib = new CSInterface();
* CSLib.loadBinSync(path);
*/
CSInterface.prototype.loadBinSync = function(pathName)
{
try
{
var OSVersion = this.getOSInformation();
if(pathName.startsWith("file://"))
{
if (OSVersion.indexOf("Windows") >= 0)
{
pathName = pathName.replace("file:///", "");
}
else if (OSVersion.indexOf("Mac") >= 0)
{
pathName = pathName.replace("file://", "");
}
window.__adobe_cep__.loadSnapshot(pathName);
return true;
}
}
catch(err)
{
console.log(err);
return false;
}
//control should not come here
return false;
};
/** Closes this extension. */
CSInterface.prototype.closeExtension = function()
{
window.__adobe_cep__.closeExtension();
};
/**
* Retrieves a path for which a constant is defined in the system.
*
* @param pathType The path-type constant defined in \c #SystemPath ,
*
* @return The platform-specific system path string.
*/
CSInterface.prototype.getSystemPath = function(pathType)
{
var path = decodeURI(window.__adobe_cep__.getSystemPath(pathType));
var OSVersion = this.getOSInformation();
if (OSVersion.indexOf("Windows") >= 0)
{
path = path.replace("file:///", "");
}
else if (OSVersion.indexOf("Mac") >= 0)
{
path = path.replace("file://", "");
}
return path;
};
/**
* Evaluates a JavaScript script, which can use the JavaScript DOM
* of the host application.
*
* @param script The JavaScript script.
* @param callback Optional. A callback function that receives the result of execution.
* If execution fails, the callback function receives the error message \c EvalScript_ErrMessage.
*/
CSInterface.prototype.evalScript = function(script, callback)
{
if(callback === null || callback === undefined)
{
callback = function(result){};
}
window.__adobe_cep__.evalScript(script, callback);
};
/**
* Retrieves the unique identifier of the application.
* in which the extension is currently running.
*
* @return The unique ID string.
*/
CSInterface.prototype.getApplicationID = function()
{
var appId = this.hostEnvironment.appId;
return appId;
};
/**
* Retrieves host capability information for the application
* in which the extension is currently running.
*
* @return A \c #HostCapabilities object.
*/
CSInterface.prototype.getHostCapabilities = function()
{
var hostCapabilities = JSON.parse(window.__adobe_cep__.getHostCapabilities() );
return hostCapabilities;
};
/**
* Triggers a CEP event programmatically. Yoy can use it to dispatch
* an event of a predefined type, or of a type you have defined.
*
* @param event A \c CSEvent object.
*/
CSInterface.prototype.dispatchEvent = function(event)
{
if (typeof event.data == "object")
{
event.data = JSON.stringify(event.data);
}
window.__adobe_cep__.dispatchEvent(event);
};
/**
* Registers an interest in a CEP event of a particular type, and
* assigns an event handler.
* The event infrastructure notifies your extension when events of this type occur,
* passing the event object to the registered handler function.
*
* @param type The name of the event type of interest.
* @param listener The JavaScript handler function or method.
* @param obj Optional, the object containing the handler method, if any.
* Default is null.
*/
CSInterface.prototype.addEventListener = function(type, listener, obj)
{
window.__adobe_cep__.addEventListener(type, listener, obj);
};
/**
* Removes a registered event listener.
*
* @param type The name of the event type of interest.
* @param listener The JavaScript handler function or method that was registered.
* @param obj Optional, the object containing the handler method, if any.
* Default is null.
*/
CSInterface.prototype.removeEventListener = function(type, listener, obj)
{
window.__adobe_cep__.removeEventListener(type, listener, obj);
};
/**
* Loads and launches another extension, or activates the extension if it is already loaded.
*
* @param extensionId The extension's unique identifier.
* @param startupParams Not currently used, pass "".
*
* @example
* To launch the extension "help" with ID "HLP" from this extension, call:
* <code>requestOpenExtension("HLP", ""); </code>
*
*/
CSInterface.prototype.requestOpenExtension = function(extensionId, params)
{
window.__adobe_cep__.requestOpenExtension(extensionId, params);
};
/**
* Retrieves the list of extensions currently loaded in the current host application.
* The extension list is initialized once, and remains the same during the lifetime
* of the CEP session.
*
* @param extensionIds Optional, an array of unique identifiers for extensions of interest.
* If omitted, retrieves data for all extensions.
*
* @return Zero or more \c #Extension objects.
*/
CSInterface.prototype.getExtensions = function(extensionIds)
{
var extensionIdsStr = JSON.stringify(extensionIds);
var extensionsStr = window.__adobe_cep__.getExtensions(extensionIdsStr);
var extensions = JSON.parse(extensionsStr);
return extensions;
};
/**
* Retrieves network-related preferences.
*
* @return A JavaScript object containing network preferences.
*/
CSInterface.prototype.getNetworkPreferences = function()
{
var result = window.__adobe_cep__.getNetworkPreferences();
var networkPre = JSON.parse(result);
return networkPre;
};
/**
* Initializes the resource bundle for this extension with property values
* for the current application and locale.
* To support multiple locales, you must define a property file for each locale,
* containing keyed display-string values for that locale.
* See localization documentation for Extension Builder and related products.
*
* Keys can be in the
* form <code>key.value="localized string"</code>, for use in HTML text elements.
* For example, in this input element, the localized \c key.value string is displayed
* instead of the empty \c value string:
*
* <code><input type="submit" value="" data-locale="key"/></code>
*
* @return An object containing the resource bundle information.
*/
CSInterface.prototype.initResourceBundle = function()
{
var resourceBundle = JSON.parse(window.__adobe_cep__.initResourceBundle());
var resElms = document.querySelectorAll('[data-locale]');
for (var n = 0; n < resElms.length; n++)
{
var resEl = resElms[n];
// Get the resource key from the element.
var resKey = resEl.getAttribute('data-locale');
if (resKey)
{
// Get all the resources that start with the key.
for (var key in resourceBundle)
{
if (key.indexOf(resKey) === 0)
{
var resValue = resourceBundle[key];
if (key.length == resKey.length)
{
resEl.innerHTML = resValue;
}
else if ('.' == key.charAt(resKey.length))
{
var attrKey = key.substring(resKey.length + 1);
resEl[attrKey] = resValue;
}
}
}
}
}
return resourceBundle;
};
/**
* Writes installation information to a file.
*
* @return The file path.
*/
CSInterface.prototype.dumpInstallationInfo = function()
{
return window.__adobe_cep__.dumpInstallationInfo();
};
/**
* Retrieves version information for the current Operating System,
* See http://www.useragentstring.com/pages/Chrome/ for Chrome \c navigator.userAgent values.
*
* @return A string containing the OS version, or "unknown Operation System".
* If user customizes the User Agent by setting CEF command parameter "--user-agent", only
* "Mac OS X" or "Windows" will be returned.
*/
CSInterface.prototype.getOSInformation = function()
{
var userAgent = navigator.userAgent;
if ((navigator.platform == "Win32") || (navigator.platform == "Windows"))
{
var winVersion = "Windows";
var winBit = "";
if (userAgent.indexOf("Windows") > -1)
{
if (userAgent.indexOf("Windows NT 5.0") > -1)
{
winVersion = "Windows 2000";
}
else if (userAgent.indexOf("Windows NT 5.1") > -1)
{
winVersion = "Windows XP";
}
else if (userAgent.indexOf("Windows NT 5.2") > -1)
{
winVersion = "Windows Server 2003";
}
else if (userAgent.indexOf("Windows NT 6.0") > -1)
{
winVersion = "Windows Vista";
}
else if (userAgent.indexOf("Windows NT 6.1") > -1)
{
winVersion = "Windows 7";
}
else if (userAgent.indexOf("Windows NT 6.2") > -1)
{
winVersion = "Windows 8";
}
else if (userAgent.indexOf("Windows NT 6.3") > -1)
{
winVersion = "Windows 8.1";
}
else if (userAgent.indexOf("Windows NT 10") > -1)
{
winVersion = "Windows 10";
}
if (userAgent.indexOf("WOW64") > -1 || userAgent.indexOf("Win64") > -1)
{
winBit = " 64-bit";
}
else
{
winBit = " 32-bit";
}
}
return winVersion + winBit;
}
else if ((navigator.platform == "MacIntel") || (navigator.platform == "Macintosh"))
{
var result = "Mac OS X";
if (userAgent.indexOf("Mac OS X") > -1)
{
result = userAgent.substring(userAgent.indexOf("Mac OS X"), userAgent.indexOf(")"));
result = result.replace(/_/g, ".");
}
return result;
}
return "Unknown Operation System";
};
/**
* Opens a page in the default system browser.
*
* Since 4.2.0
*
* @param url The URL of the page/file to open, or the email address.
* Must use HTTP/HTTPS/file/mailto protocol. For example:
* "http://www.adobe.com"
* "https://github.com"
* "file:///C:/log.txt"
* "mailto:[email protected]"
*
* @return One of these error codes:\n
* <ul>\n
* <li>NO_ERROR - 0</li>\n
* <li>ERR_UNKNOWN - 1</li>\n
* <li>ERR_INVALID_PARAMS - 2</li>\n
* <li>ERR_INVALID_URL - 201</li>\n
* </ul>\n
*/
CSInterface.prototype.openURLInDefaultBrowser = function(url)
{
return cep.util.openURLInDefaultBrowser(url);
};
/**
* Retrieves extension ID.
*
* Since 4.2.0
*
* @return extension ID.
*/
CSInterface.prototype.getExtensionID = function()
{
return window.__adobe_cep__.getExtensionId();
};
/**
* Retrieves the scale factor of screen.
* On Windows platform, the value of scale factor might be different from operating system's scale factor,
* since host application may use its self-defined scale factor.
*
* Since 4.2.0
*
* @return One of the following float number.
* <ul>\n
* <li> -1.0 when error occurs </li>\n
* <li> 1.0 means normal screen </li>\n
* <li> >1.0 means HiDPI screen </li>\n
* </ul>\n
*/
CSInterface.prototype.getScaleFactor = function()
{
return window.__adobe_cep__.getScaleFactor();
};
/**
* Retrieves the scale factor of Monitor.
*
* Since 8.5.0
*
* @return value >= 1.0f
* only available for windows machine
*/
if(navigator.appVersion.toLowerCase().indexOf("windows") >= 0) {
CSInterface.prototype.getMonitorScaleFactor = function()
{
return window.__adobe_cep__.getMonitorScaleFactor();
};
}
/**
* Set a handler to detect any changes of scale factor. This only works on Mac.
*
* Since 4.2.0
*
* @param handler The function to be called when scale factor is changed.
*
*/
CSInterface.prototype.setScaleFactorChangedHandler = function(handler)
{
window.__adobe_cep__.setScaleFactorChangedHandler(handler);
};
/**
* Retrieves current API version.
*
* Since 4.2.0
*
* @return ApiVersion object.
*
*/
CSInterface.prototype.getCurrentApiVersion = function()
{
var apiVersion = JSON.parse(window.__adobe_cep__.getCurrentApiVersion());
return apiVersion;
};
/**
* Set panel flyout menu by an XML.
*
* Since 5.2.0
*
* Register a callback function for "com.adobe.csxs.events.flyoutMenuClicked" to get notified when a
* menu item is clicked.
* The "data" attribute of event is an object which contains "menuId" and "menuName" attributes.
*
* Register callback functions for "com.adobe.csxs.events.flyoutMenuOpened" and "com.adobe.csxs.events.flyoutMenuClosed"
* respectively to get notified when flyout menu is opened or closed.
*
* @param menu A XML string which describes menu structure.
* An example menu XML:
* <Menu>
* <MenuItem Id="menuItemId1" Label="TestExample1" Enabled="true" Checked="false"/>
* <MenuItem Label="TestExample2">
* <MenuItem Label="TestExample2-1" >
* <MenuItem Label="TestExample2-1-1" Enabled="false" Checked="true"/>
* </MenuItem>
* <MenuItem Label="TestExample2-2" Enabled="true" Checked="true"/>
* </MenuItem>
* <MenuItem Label="---" />
* <MenuItem Label="TestExample3" Enabled="false" Checked="false"/>
* </Menu>
*
*/
CSInterface.prototype.setPanelFlyoutMenu = function(menu)
{
if ("string" != typeof menu)
{
return;
}
window.__adobe_cep__.invokeSync("setPanelFlyoutMenu", menu);
};
/**
* Updates a menu item in the extension window's flyout menu, by setting the enabled
* and selection status.
*
* Since 5.2.0
*
* @param menuItemLabel The menu item label.
* @param enabled True to enable the item, false to disable it (gray it out).
* @param checked True to select the item, false to deselect it.
*
* @return false when the host application does not support this functionality (HostCapabilities.EXTENDED_PANEL_MENU is false).
* Fails silently if menu label is invalid.
*
* @see HostCapabilities.EXTENDED_PANEL_MENU
*/
CSInterface.prototype.updatePanelMenuItem = function(menuItemLabel, enabled, checked)
{
var ret = false;
if (this.getHostCapabilities().EXTENDED_PANEL_MENU)
{
var itemStatus = new MenuItemStatus(menuItemLabel, enabled, checked);
ret = window.__adobe_cep__.invokeSync("updatePanelMenuItem", JSON.stringify(itemStatus));
}
return ret;
};
/**
* Set context menu by XML string.
*
* Since 5.2.0
*
* There are a number of conventions used to communicate what type of menu item to create and how it should be handled.
* - an item without menu ID or menu name is disabled and is not shown.
* - if the item name is "---" (three hyphens) then it is treated as a separator. The menu ID in this case will always be NULL.
* - Checkable attribute takes precedence over Checked attribute.
* - a PNG icon. For optimal display results please supply a 16 x 16px icon as larger dimensions will increase the size of the menu item.
The Chrome extension contextMenus API was taken as a reference.
https://developer.chrome.com/extensions/contextMenus
* - the items with icons and checkable items cannot coexist on the same menu level. The former take precedences over the latter.
*
* @param menu A XML string which describes menu structure.
* @param callback The callback function which is called when a menu item is clicked. The only parameter is the returned ID of clicked menu item.
*
* @description An example menu XML:
* <Menu>
* <MenuItem Id="menuItemId1" Label="TestExample1" Enabled="true" Checkable="true" Checked="false" Icon="./image/small_16X16.png"/>
* <MenuItem Id="menuItemId2" Label="TestExample2">
* <MenuItem Id="menuItemId2-1" Label="TestExample2-1" >
* <MenuItem Id="menuItemId2-1-1" Label="TestExample2-1-1" Enabled="false" Checkable="true" Checked="true"/>
* </MenuItem>
* <MenuItem Id="menuItemId2-2" Label="TestExample2-2" Enabled="true" Checkable="true" Checked="true"/>
* </MenuItem>
* <MenuItem Label="---" />
* <MenuItem Id="menuItemId3" Label="TestExample3" Enabled="false" Checkable="true" Checked="false"/>
* </Menu>
*/
CSInterface.prototype.setContextMenu = function(menu, callback)
{
if ("string" != typeof menu)
{
return;
}
window.__adobe_cep__.invokeAsync("setContextMenu", menu, callback);
};
/**
* Set context menu by JSON string.
*
* Since 6.0.0
*
* There are a number of conventions used to communicate what type of menu item to create and how it should be handled.
* - an item without menu ID or menu name is disabled and is not shown.
* - if the item label is "---" (three hyphens) then it is treated as a separator. The menu ID in this case will always be NULL.
* - Checkable attribute takes precedence over Checked attribute.
* - a PNG icon. For optimal display results please supply a 16 x 16px icon as larger dimensions will increase the size of the menu item.
The Chrome extension contextMenus API was taken as a reference.
* - the items with icons and checkable items cannot coexist on the same menu level. The former take precedences over the latter.
https://developer.chrome.com/extensions/contextMenus
*
* @param menu A JSON string which describes menu structure.
* @param callback The callback function which is called when a menu item is clicked. The only parameter is the returned ID of clicked menu item.
*
* @description An example menu JSON:
*
* {
* "menu": [
* {
* "id": "menuItemId1",
* "label": "testExample1",
* "enabled": true,
* "checkable": true,
* "checked": false,
* "icon": "./image/small_16X16.png"
* },
* {
* "id": "menuItemId2",
* "label": "testExample2",
* "menu": [
* {
* "id": "menuItemId2-1",
* "label": "testExample2-1",
* "menu": [
* {
* "id": "menuItemId2-1-1",
* "label": "testExample2-1-1",
* "enabled": false,
* "checkable": true,
* "checked": true
* }
* ]
* },
* {
* "id": "menuItemId2-2",
* "label": "testExample2-2",
* "enabled": true,
* "checkable": true,
* "checked": true
* }
* ]
* },
* {
* "label": "---"
* },
* {
* "id": "menuItemId3",
* "label": "testExample3",
* "enabled": false,
* "checkable": true,
* "checked": false
* }
* ]
* }
*
*/
CSInterface.prototype.setContextMenuByJSON = function(menu, callback)
{
if ("string" != typeof menu)
{
return;
}
window.__adobe_cep__.invokeAsync("setContextMenuByJSON", menu, callback);
};
/**
* Updates a context menu item by setting the enabled and selection status.
*
* Since 5.2.0
*
* @param menuItemID The menu item ID.
* @param enabled True to enable the item, false to disable it (gray it out).
* @param checked True to select the item, false to deselect it.
*/
CSInterface.prototype.updateContextMenuItem = function(menuItemID, enabled, checked)
{
var itemStatus = new ContextMenuItemStatus(menuItemID, enabled, checked);
ret = window.__adobe_cep__.invokeSync("updateContextMenuItem", JSON.stringify(itemStatus));
};
/**
* Get the visibility status of an extension window.
*
* Since 6.0.0
*
* @return true if the extension window is visible; false if the extension window is hidden.
*/
CSInterface.prototype.isWindowVisible = function()
{
return window.__adobe_cep__.invokeSync("isWindowVisible", "");
};
/**
* Resize extension's content to the specified dimensions.
* 1. Works with modal and modeless extensions in all Adobe products.
* 2. Extension's manifest min/max size constraints apply and take precedence.
* 3. For panel extensions
* 3.1 This works in all Adobe products except:
* * Premiere Pro
* * Prelude
* * After Effects
* 3.2 When the panel is in certain states (especially when being docked),
* it will not change to the desired dimensions even when the
* specified size satisfies min/max constraints.
*
* Since 6.0.0
*
* @param width The new width
* @param height The new height
*/
CSInterface.prototype.resizeContent = function(width, height)
{
window.__adobe_cep__.resizeContent(width, height);
};
/**
* Register the invalid certificate callback for an extension.
* This callback will be triggered when the extension tries to access the web site that contains the invalid certificate on the main frame.
* But if the extension does not call this function and tries to access the web site containing the invalid certificate, a default error page will be shown.
*
* Since 6.1.0
*
* @param callback the callback function
*/
CSInterface.prototype.registerInvalidCertificateCallback = function(callback)
{
return window.__adobe_cep__.registerInvalidCertificateCallback(callback);
};
/**
* Register an interest in some key events to prevent them from being sent to the host application.
*
* This function works with modeless extensions and panel extensions.
* Generally all the key events will be sent to the host application for these two extensions if the current focused element
* is not text input or dropdown,
* If you want to intercept some key events and want them to be handled in the extension, please call this function
* in advance to prevent them being sent to the host application.
*
* Since 6.1.0
*
* @param keyEventsInterest A JSON string describing those key events you are interested in. A null object or
an empty string will lead to removing the interest
*
* This JSON string should be an array, each object has following keys:
*
* keyCode: [Required] represents an OS system dependent virtual key code identifying
* the unmodified value of the pressed key.
* ctrlKey: [optional] a Boolean that indicates if the control key was pressed (true) or not (false) when the event occurred.
* altKey: [optional] a Boolean that indicates if the alt key was pressed (true) or not (false) when the event occurred.
* shiftKey: [optional] a Boolean that indicates if the shift key was pressed (true) or not (false) when the event occurred.
* metaKey: [optional] (Mac Only) a Boolean that indicates if the Meta key was pressed (true) or not (false) when the event occurred.
* On Macintosh keyboards, this is the command key. To detect Windows key on Windows, please use keyCode instead.
* An example JSON string:
*
* [
* {
* "keyCode": 48
* },
* {
* "keyCode": 123,
* "ctrlKey": true
* },
* {
* "keyCode": 123,
* "ctrlKey": true,
* "metaKey": true
* }
* ]
*
*/
CSInterface.prototype.registerKeyEventsInterest = function(keyEventsInterest)
{
return window.__adobe_cep__.registerKeyEventsInterest(keyEventsInterest);
};
/**
* Set the title of the extension window.
* This function works with modal and modeless extensions in all Adobe products, and panel extensions in Photoshop, InDesign, InCopy, Illustrator, Flash Pro and Dreamweaver.
*
* Since 6.1.0
*
* @param title The window title.
*/
CSInterface.prototype.setWindowTitle = function(title)
{
window.__adobe_cep__.invokeSync("setWindowTitle", title);
};
/**
* Get the title of the extension window.
* This function works with modal and modeless extensions in all Adobe products, and panel extensions in Photoshop, InDesign, InCopy, Illustrator, Flash Pro and Dreamweaver.
*
* Since 6.1.0
*
* @return The window title.
*/
CSInterface.prototype.getWindowTitle = function()
{
return window.__adobe_cep__.invokeSync("getWindowTitle", "");
};
```
--------------------------------------------------------------------------------
/mcp/ps-mcp.py:
--------------------------------------------------------------------------------
```python
# MIT License
#
# Copyright (c) 2025 Mike Chambers
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from mcp.server.fastmcp import FastMCP, Image
from core import init, sendCommand, createCommand
from fonts import list_all_fonts_postscript
import numpy as np
import base64
import socket_client
import sys
import os
FONT_LIMIT = 1000 #max number of font names to return to AI
#logger.log(f"Python path: {sys.executable}")
#logger.log(f"PYTHONPATH: {os.environ.get('PYTHONPATH')}")
#logger.log(f"Current working directory: {os.getcwd()}")
#logger.log(f"Sys.path: {sys.path}")
mcp_name = "Adobe Photoshop MCP Server"
mcp = FastMCP(mcp_name, log_level="ERROR")
print(f"{mcp_name} running on stdio", file=sys.stderr)
APPLICATION = "photoshop"
PROXY_URL = 'http://localhost:3001'
PROXY_TIMEOUT = 20
socket_client.configure(
app=APPLICATION,
url=PROXY_URL,
timeout=PROXY_TIMEOUT
)
init(APPLICATION, socket_client)
@mcp.tool()
def set_active_document(document_id:int):
"""
Sets the document with the specified ID to the active document in Photoshop
Args:
document_id (int): ID for the document to set as active.
"""
command = createCommand("setActiveDocument", {
"documentId":document_id
})
return sendCommand(command)
@mcp.tool()
def get_documents():
"""
Returns information on the documents currently open in Photoshop
"""
command = createCommand("getDocuments", {
})
return sendCommand(command)
@mcp.tool()
def create_gradient_layer_style(
layer_id: int,
angle: int,
type:str,
color_stops: list,
opacity_stops: list):
"""
Applies gradient to active selection or entire layer if no selection exists.
Color stops define transition points along the gradient (0-100), with color blending between stops. Opacity stops similarly control transparency transitions.
Args:
layer_id (int): ID for layer to apply gradient to.
angle (int): Gradient angle (-180 to 180).
type (str): LINEAR or RADIAL gradient.
color_stops (list): Dictionaries defining color stops:
- location (int): Position (0-100) along gradient.
- color (dict): RGB values (0-255 for red/green/blue).
- midpoint (int): Transition bias (0-100, default 50).
opacity_stops (list): Dictionaries defining opacity stops:
- location (int): Position (0-100) along gradient.
- opacity (int): Level (0=transparent, 100=opaque).
- midpoint (int): Transition bias (0-100, default 50).
"""
command = createCommand("createGradientLayerStyle", {
"layerId":layer_id,
"angle":angle,
"colorStops":color_stops,
"type":type,
"opacityStops":opacity_stops
})
return sendCommand(command)
@mcp.tool()
def duplicate_document(document_name: str):
"""Duplicates the current Photoshop Document into a new file
Args:
document_name (str): Name for the new document being created
"""
command = createCommand("duplicateDocument", {
"name":document_name
})
return sendCommand(command)
@mcp.tool()
def create_document(document_name: str, width: int, height:int, resolution:int, fill_color:dict = {"red":0, "green":0, "blue":0}, color_mode:str = "RGB"):
"""Creates a new Photoshop Document
Layer are created from bottom up based on the order they are created in, so create background elements first and then build on top.
New document will contain a layer named "Background" that is filled with the specified fill color
Args:
document_name (str): Name for the new document being created
width (int): Width in pixels of the new document
height (int): Height in pixels of the new document
resolution (int): Resolution (Pixels per Inch) of the new document
fill_color (dict): dict defining the background color fill of the new document
color_mode (str): Color mode for the new document
"""
command = createCommand("createDocument", {
"name":document_name,
"width":width,
"height":height,
"resolution":resolution,
"fillColor":fill_color,
"colorMode":color_mode
})
return sendCommand(command)
@mcp.tool()
def export_layers_as_png(layers_info: list[dict[str, str|int]]):
"""Exports multiple layers from the Photoshop document as PNG files.
This function exports each specified layer as a separate PNG image file to its
corresponding file path. The entire layer, including transparent space will be saved.
Args:
layers_info (list[dict[str, str|int]]): A list of dictionaries containing the export information.
Each dictionary must have the following keys:
- "layerId" (int): The ID of the layer to export as PNG.
This layer must exist in the current document.
- "filePath" (str): The absolute file path including filename where the PNG
will be saved (e.g., "/path/to/directory/layername.png").
The parent directory must already exist or the export will fail.
"""
command = createCommand("exportLayersAsPng", {
"layersInfo":layers_info
})
return sendCommand(command)
@mcp.tool()
def save_document_as(file_path: str, file_type: str = "PSD"):
"""Saves the current Photoshop document to the specified location and format.
Args:
file_path (str): The absolute path (including filename) where the file will be saved.
Example: "/Users/username/Documents/my_image.psd"
file_type (str, optional): The file format to use when saving the document.
Defaults to "PSD".
Supported formats:
- "PSD": Adobe Photoshop Document (preserves layers and editability)
- "PNG": Portable Network Graphics (lossless compression with transparency)
- "JPG": Joint Photographic Experts Group (lossy compression)
Returns:
dict: Response from the Photoshop operation indicating success status, and the path that the file was saved at
"""
command = createCommand("saveDocumentAs", {
"filePath":file_path,
"fileType":file_type
})
return sendCommand(command)
@mcp.tool()
def save_document():
"""Saves the current Photoshop Document
"""
command = createCommand("saveDocument", {
})
return sendCommand(command)
@mcp.tool()
def group_layers(group_name: str, layer_ids: list[int]) -> list:
"""
Creates a new layer group from the specified layers in Photoshop.
Note: The layers will be added to the group in the order they are specified in the document, and not the order of their layerIds passed in. The group will be made at the same level as the top most layer in the layer tree.
Args:
groupName (str): The name to assign to the newly created layer group.
layerIds (list[int]): A list of layer ids to include in the new group.
Raises:
RuntimeError: If the operation fails or times out.
"""
command = createCommand("groupLayers", {
"groupName":group_name,
"layerIds":layer_ids
})
return sendCommand(command)
@mcp.tool()
def get_layer_image(layer_id: int):
"""Returns a jpeg of the specified layer's content as an MCP Image object that can be displayed."""
command = createCommand("getLayerImage",
{
"layerId":layer_id
}
)
response = sendCommand(command)
if response.get('status') == 'SUCCESS' and 'response' in response:
image_data = response['response']
data_url = image_data.get('dataUrl')
if data_url and data_url.startswith("data:image/jpeg;base64,"):
# Strip the data URL prefix and decode the base64 JPEG bytes
base64_data = data_url.split(",", 1)[1]
jpeg_bytes = base64.b64decode(base64_data)
return Image(data=jpeg_bytes, format="jpeg")
return response
@mcp.tool()
def get_document_image():
"""Returns a jpeg of the current visible Photoshop document as an MCP Image object that can be displayed."""
command = createCommand("getDocumentImage", {})
response = sendCommand(command)
if response.get('status') == 'SUCCESS' and 'response' in response:
image_data = response['response']
data_url = image_data.get('dataUrl')
if data_url and data_url.startswith("data:image/jpeg;base64,"):
# Strip the data URL prefix and decode the base64 JPEG bytes
base64_data = data_url.split(",", 1)[1]
jpeg_bytes = base64.b64decode(base64_data)
return Image(data=jpeg_bytes, format="jpeg")
return response
@mcp.tool()
def save_document_image_as_png(file_path: str):
"""
Capture the Photoshop document and save as PNG file
Args:
file_path: Where to save the PNG file
Returns:
dict: Status and file info
"""
command = createCommand("getDocumentImage", {})
response = sendCommand(command)
if response.get('format') == 'raw' and 'rawDataBase64' in response:
try:
# Decode raw data
raw_bytes = base64.b64decode(response['rawDataBase64'])
# Extract metadata
width = response['width']
height = response['height']
components = response['components']
# Convert to numpy array and reshape
pixel_array = np.frombuffer(raw_bytes, dtype=np.uint8)
image_array = pixel_array.reshape((height, width, components))
# Create and save PNG
mode = 'RGBA' if components == 4 else 'RGB'
image = Image.fromarray(image_array, mode)
image.save(file_path, 'PNG')
return {
'status': 'success',
'file_path': file_path,
'width': width,
'height': height,
'size_bytes': os.path.getsize(file_path)
}
except Exception as e:
return {
'status': 'error',
'error': str(e)
}
else:
return {
'status': 'error',
'error': 'No raw image data received'
}
@mcp.tool()
def get_layers() -> list:
"""Returns a nested list of dicts that contain layer info and the order they are arranged in.
Args:
None
Returns:
list: A nested list of dictionaries containing layer information and hierarchy.
Each dict has at minimum a 'name' key with the layer name.
If a layer has sublayers, they will be contained in a 'layers' key which contains another list of layer dicts.
Example: [{'name': 'Group 1', 'layers': [{'name': 'Layer 1'}, {'name': 'Layer 2'}]}, {'name': 'Background'}]
"""
command = createCommand("getLayers", {})
return sendCommand(command)
@mcp.tool()
def place_image(
layer_id: int,
image_path: str
):
"""Places the image at the specified path on the existing pixel layer with the specified id.
The image will be placed on the center of the layer, and will fill the layer without changing its aspect ration (thus there may be bars at the top or bottom)
Args:
layer_id (int): The id of the layer where the image will be placed.
image_path (str): The file path to the image that will be placed on the layer.
"""
command = createCommand("placeImage", {
"layerId":layer_id,
"imagePath":image_path
})
return sendCommand(command)
@mcp.tool()
def harmonize_layer(layer_id:int, new_layer_name:str, rasterize_layer:bool = True):
"""Harmonizes (matches lighting and other settings) the selected layer with the background layers.
The layer being harmonized should be rasterized and have some transparency.
Args:
layer_id (int): ID of the layer to be harmonizes.
new_layer_name (str): Name for the new layer that will be created with the harmonized content
rasterize_layer (bool): Whether the new layer should be rasterized.
If not rasterized, the layer will remain a generative layer which
allows the user to interact with it. True by default.
"""
command = createCommand("harmonizeLayer", {
"layerId":layer_id,
"newLayerName":new_layer_name,
"rasterizeLayer":rasterize_layer
})
return sendCommand(command)
@mcp.tool()
def rename_layers(
layer_data: list[dict]
):
"""Renames one or more layers
Args:
layer_data (list[dict]): A list of dictionaries containing layer rename information.
Each dictionary must have the following keys:
- "layer_id" (int): ID of the layer to be renamed.
- "new_layer_name" (str): New name for the layer.
"""
command = createCommand("renameLayers", {
"layerData":layer_data
})
return sendCommand(command)
@mcp.tool()
def scale_layer(
layer_id:int,
width:int,
height:int,
anchor_position:str,
interpolation_method:str = "AUTOMATIC"
):
"""Scales the layer with the specified ID.
Args:
layer_id (int): ID of layer to be scaled.
width (int): Percentage to scale horizontally.
height (int): Percentage to scale vertically.
anchor_position (str): The anchor position to rotate around,
interpolation_method (str): Interpolation method to use when resampling the image
"""
command = createCommand("scaleLayer", {
"layerId":layer_id,
"width":width,
"height":height,
"anchorPosition":anchor_position,
"interpolationMethod":interpolation_method
})
return sendCommand(command)
@mcp.tool()
def rotate_layer(
layer_id:int,
angle:int,
anchor_position:str,
interpolation_method:str = "AUTOMATIC"
):
"""Rotates the layer with the specified ID.
Args:
layer_id (int): ID of layer to be scaled.
angle (int): Angle (-359 to 359) to rotate the layer by in degrees
anchor_position (str): The anchor position to rotate around,
interpolation_method (str): Interpolation method to use when resampling the image
"""
command = createCommand("rotateLayer", {
"layerId":layer_id,
"angle":angle,
"anchorPosition":anchor_position,
"interpolationMethod":interpolation_method
})
return sendCommand(command)
@mcp.tool()
def flip_layer(
layer_id:int,
axis:str
):
"""Flips the layer with the specified ID on the specified axis.
Args:
layer_id (int): ID of layer to be scaled.
axis (str): The axis on which to flip the layer. Valid values are "horizontal", "vertical" or "both"
"""
command = createCommand("flipLayer", {
"layerId":layer_id,
"axis":axis
})
return sendCommand(command)
@mcp.tool()
def delete_layer(
layer_id:int
):
"""Deletes the layer with the specified ID
Args:
layer_id (int): ID of the layer to be deleted
"""
command = createCommand("deleteLayer", {
"layerId":layer_id
})
return sendCommand(command)
@mcp.tool()
def set_layer_visibility(
layer_id:int,
visible:bool
):
"""Sets the visibility of the layer with the specified ID
Args:
layer_id (int): ID of the layer to set visibility
visible (bool): Whether the layer is visible
"""
command = createCommand("setLayerVisibility", {
"layerId":layer_id,
"visible":visible
})
return sendCommand(command)
@mcp.tool()
def generate_image(
layer_name:str,
prompt:str,
content_type:str = "none"
):
"""Uses Adobe Firefly Generative AI to generate an image on a new layer with the specified layer name.
If there is an active selection, it will use that region for the generation. Otherwise it will generate
on the entire layer.
Args:
layer_name (str): Name for the layer that will be created and contain the generated image
prompt (str): Prompt describing the image to be generated
content_type (str): The type of image to be generated. Options include "photo", "art" or "none" (default)
"""
command = createCommand("generateImage", {
"layerName":layer_name,
"prompt":prompt,
"contentType":content_type
})
return sendCommand(command)
@mcp.tool()
def generative_fill(
layer_name: str,
prompt: str,
layer_id: int,
content_type: str = "none"
):
"""Uses Adobe Firefly Generative AI to perform generative fill within the current selection.
This function uses generative fill to seamlessly integrate new content into the existing image.
It requires an active selection, and will fill that region taking into account the surrounding
context and layers below. The AI considers the existing content to create a natural,
contextually-aware fill.
Args:
layer_name (str): Name for the layer that will be created and contain the generated fill
prompt (str): Prompt describing the content to be generated within the selection
layer_id (int): ID of the layer to work with (though a new layer is created for the result)
content_type (str): The type of image to be generated. Options include "photo", "art" or "none" (default)
Returns:
dict: Response from Photoshop containing the operation status and layer information
"""
command = createCommand("generativeFill", {
"layerName":layer_name,
"prompt":prompt,
"layerId":layer_id,
"contentType":content_type,
})
return sendCommand(command)
@mcp.tool()
def move_layer(
layer_id:int,
position:str
):
"""Moves the layer within the layer stack based on the specified position
Args:
layer_id (int): Name for the layer that will be moved
position (str): How the layer position within the layer stack will be updated. Value values are: TOP (Place above all layers), BOTTOM (Place below all layers), UP (Move up one layer), DOWN (Move down one layer)
"""
command = createCommand("moveLayer", {
"layerId":layer_id,
"position":position
})
return sendCommand(command)
@mcp.tool()
def get_document_info():
"""Retrieves information about the currently active document.
Returns:
response : An object containing the following document properties:
- height (int): The height of the document in pixels.
- width (int): The width of the document in pixels.
- colorMode (str): The document's color mode as a string.
- pixelAspectRatio (float): The pixel aspect ratio of the document.
- resolution (float): The document's resolution (DPI).
- path (str): The file path of the document, if saved.
- saved (bool): Whether the document has been saved (True if it has a valid file path).
- hasUnsavedChanges (bool): Whether the document contains unsaved changes.
"""
command = createCommand("getDocumentInfo", {})
return sendCommand(command)
@mcp.tool()
def crop_document():
"""Crops the document to the active selection.
This function removes all content outside the selection area and resizes the document
so that the selection becomes the new canvas size.
An active selection is required.
"""
command = createCommand("cropDocument", {})
return sendCommand(command)
@mcp.tool()
def paste_from_clipboard(layer_id: int, paste_in_place: bool = True):
"""Pastes the current clipboard contents onto the specified layer.
If `paste_in_place` is True, the content will be positioned exactly where it was cut or copied from.
If False and an active selection exists, the content will be centered within the selection.
If no selection is active, the content will be placed at the center of the layer.
Args:
layer_id (int): The ID of the layer where the clipboard contents will be pasted.
paste_in_place (bool): Whether to paste at the original location (True) or adjust based on selection/layer center (False).
"""
command = createCommand("pasteFromClipboard", {
"layerId":layer_id,
"pasteInPlace":paste_in_place
})
return sendCommand(command)
@mcp.tool()
def rasterize_layer(layer_id: int):
"""Converts the specified layer into a rasterized (flat) image.
This process removes any vector, text, or smart object properties, turning the layer
into pixel-based content.
Args:
layer_id (int): The name of the layer to rasterize.
"""
command = createCommand("rasterizeLayer", {
"layerId":layer_id
})
return sendCommand(command)
@mcp.tool()
def open_photoshop_file(file_path: str):
"""Opens the specified Photoshop-compatible file within Photoshop.
This function attempts to open a file in Adobe Photoshop. The file must be in a
format compatible with Photoshop, such as PSD, TIFF, JPEG, PNG, etc.
Args:
file_path (str): Complete absolute path to the file to be opened, including filename and extension.
Returns:
dict: Response from the Photoshop operation indicating success status.
Raises:
RuntimeError: If the file doesn't exist, is not accessible, or is in an unsupported format.
"""
command = createCommand("openFile", {
"filePath":file_path
})
return sendCommand(command)
@mcp.tool()
def cut_selection_to_clipboard(layer_id: int):
"""Copies and removes (cuts) the selected pixels from the specified layer to the system clipboard.
This function requires an active selection.
Args:
layer_id (int): The name of the layer that contains the pixels to copy and remove.
"""
command = createCommand("cutSelectionToClipboard", {
"layerId":layer_id
})
return sendCommand(command)
@mcp.tool()
def copy_merged_selection_to_clipboard():
"""Copies the selected pixels from all visible layers to the system clipboard.
This function requires an active selection. If no selection is active, the operation will fail.
The copied content will include pixel data from all visible layers within the selection area,
effectively capturing what you see on screen.
Returns:
dict: Response from the Photoshop operation indicating success status.
Raises:
RuntimeError: If no active selection exists.
"""
command = createCommand("copyMergedSelectionToClipboard", {})
return sendCommand(command)
@mcp.tool()
def copy_selection_to_clipboard(layer_id: int):
"""Copies the selected pixels from the specified layer to the system clipboard.
This function requires an active selection. If no selection is active, the operation will fail.
Args:
layer_id (int): The name of the layer that contains the pixels to copy.
Returns:
dict: Response from the Photoshop operation indicating success status.
"""
command = createCommand("copySelectionToClipboard", {
"layerId":layer_id
})
return sendCommand(command)
@mcp.tool()
def select_subject(layer_id: int):
"""Automatically selects the subject in the specified layer.
This function identifies and selects the subject in the given image layer.
It returns an object containing a property named `hasActiveSelection`,
which indicates whether any pixels were selected (e.g., if no subject was detected).
Args:
layer_int (int): The name of that contains the image to select the subject from.
"""
command = createCommand("selectSubject", {
"layerId":layer_id
})
return sendCommand(command)
@mcp.tool()
def select_sky(layer_id: int):
"""Automatically selects the sky in the specified layer.
This function identifies and selects the sky in the given image layer.
It returns an object containing a property named `hasActiveSelection`,
which indicates whether any pixels were selected (e.g., if no sky was detected).
Args:
layer_id (int): The name of that contains the image to select the sky from.
"""
command = createCommand("selectSky", {
"layerId":layer_id
})
return sendCommand(command)
@mcp.tool()
def get_layer_bounds(
layer_id: int
):
"""Returns the pixel bounds for the layer with the specified ID
Args:
layer_id (int): ID of the layer to get the bounds information from
Returns:
dict: A dictionary containing the layer bounds with the following properties:
- left (int): The x-coordinate of the left edge of the layer
- top (int): The y-coordinate of the top edge of the layer
- right (int): The x-coordinate of the right edge of the layer
- bottom (int): The y-coordinate of the bottom edge of the layer
Raises:
RuntimeError: If the layer doesn't exist or if the operation fails
"""
command = createCommand("getLayerBounds", {
"layerId":layer_id
})
return sendCommand(command)
@mcp.tool()
def remove_background(
layer_id:int
):
"""Automatically removes the background of the image in the layer with the specified ID and keeps the main subject
Args:
layer_id (int): ID of the layer to remove the background from
"""
command = createCommand("removeBackground", {
"layerId":layer_id
})
return sendCommand(command)
@mcp.tool()
def create_pixel_layer(
layer_name:str,
fill_neutral:bool,
opacity:int = 100,
blend_mode:str = "NORMAL",
):
"""Creates a new pixel layer with the specified ID
Args:
layer_name (str): Name of the new layer being created
fill_neutral (bool): Whether to fill the layer with a neutral color when applying Blend Mode.
opacity (int): Opacity of the newly created layer
blend_mode (str): Blend mode of the newly created layer
"""
command = createCommand("createPixelLayer", {
"layerName":layer_name,
"opacity":opacity,
"fillNeutral":fill_neutral,
"blendMode":blend_mode
})
return sendCommand(command)
@mcp.tool()
def create_multi_line_text_layer(
layer_name:str,
text:str,
font_size:int,
postscript_font_name:str,
opacity:int = 100,
blend_mode:str = "NORMAL",
text_color:dict = {"red":255, "green":255, "blue":255},
position:dict = {"x": 100, "y":100},
bounds:dict = {"top": 0, "left": 0, "bottom": 250, "right": 300},
justification:str = "LEFT"
):
"""
Creates a new multi-line text layer with the specified ID within the current Photoshop document.
Args:
layer_name (str): The name of the layer to be created. Can be used to select in other api calls.
text (str): The text to include on the layer.
font_size (int): Font size.
postscript_font_name (string): Postscript Font Name to display the text in. Valid list available via get_option_info.
opacity (int): Opacity for the layer specified in percent.
blend_mode (str): Blend Mode for the layer. Valid list available via get_option_info
text_color (dict): Color of the text expressed in Red, Green, Blue values between 0 and 255
position (dict): Position (dict with x, y values) where the text will be placed in the layer. Based on bottom left point of the text.
bounds (dict): text bounding box
justification (str): text justification. Valid list available via get_option_info.
"""
command = createCommand("createMultiLineTextLayer", {
"layerName":layer_name,
"contents":text,
"fontSize": font_size,
"opacity":opacity,
"position":position,
"fontName":postscript_font_name,
"textColor":text_color,
"blendMode":blend_mode,
"bounds":bounds,
"justification":justification
})
return sendCommand(command)
@mcp.tool()
def create_single_line_text_layer(
layer_name:str,
text:str,
font_size:int,
postscript_font_name:str,
opacity:int = 100,
blend_mode:str = "NORMAL",
text_color:dict = {"red":255, "green":255, "blue":255},
position:dict = {"x": 100, "y":100}
):
"""
Create a new single line text layer with the specified ID within the current Photoshop document.
Args:
layer_name (str): The name of the layer to be created. Can be used to select in other api calls.
text (str): The text to include on the layer.
font_size (int): Font size.
postscript_font_name (string): Postscript Font Name to display the text in. Valid list available via get_option_info.
opacity (int): Opacity for the layer specified in percent.
blend_mode (str): Blend Mode for the layer. Valid list available via get_option_info
text_color (dict): Color of the text expressed in Red, Green, Blue values between 0 and 255
position (dict): Position (dict with x, y values) where the text will be placed in the layer. Based on bottom left point of the text.
"""
command = createCommand("createSingleLineTextLayer", {
"layerName":layer_name,
"contents":text,
"fontSize": font_size,
"opacity":opacity,
"position":position,
"fontName":postscript_font_name,
"textColor":text_color,
"blendMode":blend_mode
})
return sendCommand(command)
@mcp.tool()
def edit_text_layer(
layer_id:int,
text:str = None,
font_size:int = None,
postscript_font_name:str = None,
text_color:dict = None,
):
"""
Edits the text content of an existing text layer in the current Photoshop document.
Args:
layer_id (int): The ID of the existing text layer to edit.
text (str): The new text content to replace the current text in the layer. If None, text will not be changed.
font_size (int): Font size. If None, size will not be changed.
postscript_font_name (string): Postscript Font Name to display the text in. Valid list available via get_option_info. If None, font will not will not be changed.
text_color (dict): Color of the text expressed in Red, Green, Blue values between 0 and 255 in format of {"red":255, "green":255, "blue":255}. If None, color will not be changed
"""
command = createCommand("editTextLayer", {
"layerId":layer_id,
"contents":text,
"fontSize": font_size,
"fontName":postscript_font_name,
"textColor":text_color
})
return sendCommand(command)
@mcp.tool()
def translate_layer(
layer_id: int,
x_offset:int = 0,
y_offset:int = 0
):
"""
Moves the layer with the specified ID on the X and Y axis by the specified number of pixels.
Args:
layer_name (str): The name of the layer that should be moved.
x_offset (int): Amount to move on the horizontal axis. Negative values move the layer left, positive values right
y_offset (int): Amount to move on the vertical axis. Negative values move the layer down, positive values up
"""
command = createCommand("translateLayer", {
"layerId":layer_id,
"xOffset":x_offset,
"yOffset":y_offset
})
return sendCommand(command)
@mcp.tool()
def remove_layer_mask(
layer_id: int
):
"""Removes the layer mask from the specified layer.
Args:
None
"""
command = createCommand("removeLayerMask", {
"layerId":layer_id
})
return sendCommand(command)
@mcp.tool()
def add_layer_mask_from_selection(
layer_id: int
):
"""Creates a layer mask on the specified layer defined by the active selection.
This function takes the current active selection in the document and converts it into a layer mask
for the specified layer. Selected areas will be visible, while non-selected areas will be hidden.
An active selection must exist before calling this function.
Args:
layer_name (str): The name of the layer to which the mask will be applied
"""
command = createCommand("addLayerMask", {
"layerId":layer_id
})
return sendCommand(command)
@mcp.tool()
def set_layer_properties(
layer_id: int,
blend_mode: str = "NORMAL",
layer_opacity: int = 100,
fill_opacity: int = 100,
is_clipping_mask: bool = False
):
"""Sets the blend mode and opacity properties on the layer with the specified ID
Args:
layer_id (int): The ID of the layer whose properties should be updated
blend_mode (str): The blend mode for the layer
layer_opacity (int): The opacity for the layer (0 - 100)
fill_opacity (int): The fill opacity for the layer (0 - 100). Will ignore anny effects that have been applied to the layer.
is_clipping_mask (bool): A boolean indicating whether this layer will be clipped to (masked by) the layer below it
"""
command = createCommand("setLayerProperties", {
"layerId":layer_id,
"blendMode":blend_mode,
"layerOpacity":layer_opacity,
"fillOpacity":fill_opacity,
"isClippingMask":is_clipping_mask
})
return sendCommand(command)
@mcp.tool()
def fill_selection(
layer_id: int,
color:dict = {"red":255, "green":0, "blue":0},
blend_mode:str = "NORMAL",
opacity:int = 100,
):
"""Fills the selection on the pixel layer with the specified ID
Args:
layer_id (int): The ID of existing pixel layer to add the fill
color (dict): The color of the fill
blend_mode (dict): The blend mode for the fill
opacity (int) : The opacity of the color for the fill
"""
command = createCommand("fillSelection", {
"layerId":layer_id,
"color":color,
"blendMode":blend_mode,
"opacity":opacity
})
return sendCommand(command)
@mcp.tool()
def delete_selection(
layer_id: int
):
"""Removes the pixels within the selection on the pixel layer with the specified ID
Args:
layer_id (int): The ID of the layer from which the content of the selection should be deleted
"""
command = createCommand("deleteSelection", {
"layerId":layer_id
})
return sendCommand(command)
@mcp.tool()
def invert_selection():
"""Inverts the current selection in the Photoshop document"""
command = createCommand("invertSelection", {})
return sendCommand(command)
@mcp.tool()
def clear_selection():
"""Clears / deselects the current selection"""
command = createCommand("selectRectangle", {
"feather":0,
"antiAlias":True,
"bounds":{"top": 0, "left": 0, "bottom": 0, "right": 0}
})
return sendCommand(command)
@mcp.tool()
def select_rectangle(
layer_id:int,
feather:int = 0,
anti_alias:bool = True,
bounds:dict = {"top": 0, "left": 0, "bottom": 100, "right": 100}
):
"""Creates a rectangular selection and selects the specified layer
Args:
layer_id (int): The layer to do the select rectangle action on.
feather (int): The amount of feathering in pixels to apply to the selection (0 - 1000)
anti_alias (bool): Whether anti-aliases is applied to the selection
bounds (dict): The bounds for the rectangle selection
"""
command = createCommand("selectRectangle", {
"layerId":layer_id,
"feather":feather,
"antiAlias":anti_alias,
"bounds":bounds
})
return sendCommand(command)
@mcp.tool()
def select_polygon(
layer_id:int,
feather:int = 0,
anti_alias:bool = True,
points:list[dict[str, int]] = [{"x": 50, "y": 10}, {"x": 100, "y": 90}, {"x": 10, "y": 40}]
):
"""Creates an n-sided polygon selection and selects the specified layer
Args:
layer_id (int): The layer to do the selection action on.
feather (int): The amount of feathering in pixels to apply to the selection (0 - 1000)
anti_alias (bool): Whether anti-aliases is applied to the selection
points (list): The points that define the sides of the selection, defined via a list of dicts with x, y values.
"""
command = createCommand("selectPolygon", {
"layerId":layer_id,
"feather":feather,
"antiAlias":anti_alias,
"points":points
})
return sendCommand(command)
@mcp.tool()
def select_ellipse(
layer_id:int,
feather:int = 0,
anti_alias:bool = True,
bounds:dict = {"top": 0, "left": 0, "bottom": 100, "right": 100}
):
"""Creates an elliptical selection and selects the specified layer
Args:
layer_id (int): The layer to do the selection action on.
feather (int): The amount of feathering in pixels to apply to the selection (0 - 1000)
anti_alias (bool): Whether anti-aliases is applied to the selection
bounds (dict): The bounds that will define the elliptical selection.
"""
command = createCommand("selectEllipse", {
"layerId":layer_id,
"feather":feather,
"antiAlias":anti_alias,
"bounds":bounds
})
return sendCommand(command)
@mcp.tool()
def align_content(
layer_id: int,
alignment_mode:str
):
"""
Aligns content on layer with the specified ID to the current selection.
Args:
layer_id (int): The ID of the layer in which to align the content
alignment_mode (str): How the content should be aligned. Available options via alignment_modes
"""
command = createCommand("alignContent", {
"layerId":layer_id,
"alignmentMode":alignment_mode
})
return sendCommand(command)
@mcp.tool()
def add_drop_shadow_layer_style(
layer_id: int,
blend_mode:str = "MULTIPLY",
color:dict = {"red":0, "green":0, "blue":0},
opacity:int = 35,
angle:int = 160,
distance:int = 3,
spread:int = 0,
size:int = 7
):
"""Adds a drop shadow layer style to the layer with the specified ID
Args:
layer_id (int): The ID for the layer with the content to add the drop shadow to
blend_mode (str): The blend mode for the drop shadow
color (dict): The color for the drop shadow
opacity (int): The opacity of the drop shadow
angle (int): The angle (-180 to 180) of the drop shadow relative to the content
distance (int): The distance in pixels of the drop shadow (0 to 30000)
spread (int): Defines how gradually the shadow fades out at its edges, with higher values creating a harsher, more defined edge, and lower values a softer, more feathered edge (0 to 100)
size (int): Control the blur and spread of the shadow effect (0 to 250)
"""
command = createCommand("addDropShadowLayerStyle", {
"layerId":layer_id,
"blendMode":blend_mode,
"color":color,
"opacity":opacity,
"angle":angle,
"distance":distance,
"spread":spread,
"size":size
})
return sendCommand(command)
@mcp.tool()
def duplicate_layer(layer_to_duplicate_id:int, duplicate_layer_name:str):
"""
Duplicates the layer specified by layer_to_duplicate_id ID, creating a new layer above it with the name specified by duplicate_layer_name
Args:
layer_to_duplicate_id (id): The id of the layer to be duplicated
duplicate_layer_name (str): Name for the newly created layer
"""
command = createCommand("duplicateLayer", {
"sourceLayerId":layer_to_duplicate_id,
"duplicateLayerName":duplicate_layer_name,
})
return sendCommand(command)
@mcp.tool()
def flatten_all_layers(layer_name:str):
"""
Flatten all layers in the document into a single layer with specified name
Args:
layer_name (str): The name of the merged layer
"""
command = createCommand("flattenAllLayers", {
"layerName":layer_name,
})
return sendCommand(command)
@mcp.tool()
def add_color_balance_adjustment_layer(
layer_id: int,
highlights:list = [0,0,0],
midtones:list = [0,0,0],
shadows:list = [0,0,0]):
"""Adds an adjustment layer to the layer with the specified ID to adjust color balance
Each property highlights, midtones and shadows contains an array of 3 values between
-100 and 100 that represent the relative position between two colors.
First value is between cyan and red
The second value is between magenta and green
The third value is between yellow and blue
Args:
layer_id (int): The ID of the layer to apply the color balance adjustment layer
highlights (list): Relative color values for highlights
midtones (list): Relative color values for midtones
shadows (list): Relative color values for shadows
"""
command = createCommand("addColorBalanceAdjustmentLayer", {
"layerId":layer_id,
"highlights":highlights,
"midtones":midtones,
"shadows":shadows
})
return sendCommand(command)
@mcp.tool()
def add_brightness_contrast_adjustment_layer(
layer_id: int,
brightness:int = 0,
contrast:int = 0):
"""Adds an adjustment layer to the layer with the specified ID to adjust brightness and contrast
Args:
layer_id (int): The ID of the layer to apply the brightness and contrast adjustment layer
brightness (int): The brightness value (-150 to 150)
contrasts (int): The contrast value (-50 to 100)
"""
command = createCommand("addBrightnessContrastAdjustmentLayer", {
"layerId":layer_id,
"brightness":brightness,
"contrast":contrast
})
return sendCommand(command)
@mcp.tool()
def add_stroke_layer_style(
layer_id: int,
size: int = 2,
color: dict = {"red": 0, "green": 0, "blue": 0},
opacity: int = 100,
position: str = "CENTER",
blend_mode: str = "NORMAL"
):
"""Adds a stroke layer style to the layer with the specified ID.
Args:
layer_id (int): The ID of the layer to apply the stroke effect to.
size (int, optional): The width of the stroke in pixels. Defaults to 2.
color (dict, optional): The color of the stroke as RGB values. Defaults to black {"red": 0, "green": 0, "blue": 0}.
opacity (int, optional): The opacity of the stroke as a percentage (0-100). Defaults to 100.
position (str, optional): The position of the stroke relative to the layer content.
Options include "CENTER", "INSIDE", or "OUTSIDE". Defaults to "CENTER".
blend_mode (str, optional): The blend mode for the stroke effect. Defaults to "NORMAL".
"""
command = createCommand("addStrokeLayerStyle", {
"layerId":layer_id,
"size":size,
"color":color,
"opacity":opacity,
"position":position,
"blendMode":blend_mode
})
return sendCommand(command)
@mcp.tool()
def add_vibrance_adjustment_layer(
layer_id: int,
vibrance:int = 0,
saturation:int = 0):
"""Adds an adjustment layer to layer with the specified ID to adjust vibrance and saturation
Args:
layer_id (int): The ID of the layer to apply the vibrance and saturation adjustment layer
vibrance (int): Controls the intensity of less-saturated colors while preventing oversaturation of already-saturated colors. Range -100 to 100.
saturation (int): Controls the intensity of all colors equally. Range -100 to 100.
"""
#0.1 to 255
command = createCommand("addAdjustmentLayerVibrance", {
"layerId":layer_id,
"saturation":saturation,
"vibrance":vibrance
})
return sendCommand(command)
@mcp.tool()
def add_black_and_white_adjustment_layer(
layer_id: int,
colors: dict = {"blue": 20, "cyan": 60, "green": 40, "magenta": 80, "red": 40, "yellow": 60},
tint: bool = False,
tint_color: dict = {"red": 225, "green": 211, "blue": 179}
):
"""Adds a Black & White adjustment layer to the specified layer.
Creates an adjustment layer that converts the target layer to black and white. Optionally applies a color tint to the result.
Args:
layer_id (int): The ID of the layer to apply the black and white adjustment to.
colors (dict): Controls how each color channel converts to grayscale. Values range from
-200 to 300, with higher values making that color appear lighter in the
conversion. Must include all keys: red, yellow, green, cyan, blue, magenta.
tint (bool, optional): Whether to apply a color tint to the black and white result.
Defaults to False.
tint_color (dict, optional): The RGB color dict to use for tinting
with "red", "green", and "blue" keys (values 0-255).
"""
command = createCommand("addAdjustmentLayerBlackAndWhite", {
"layerId":layer_id,
"colors":colors,
"tint":tint,
"tintColor":tint_color
})
return sendCommand(command)
@mcp.tool()
def apply_gaussian_blur(layer_id: int, radius: float = 2.5):
"""Applies a Gaussian Blur to the layer with the specified ID
Args:
layer_id (int): ID of layer to be blurred
radius (float): The blur radius in pixels determining the intensity of the blur effect. Default is 2.5.
Valid values range from 0.1 (subtle blur) to 10000 (extreme blur).
Returns:
dict: Response from the Photoshop operation
Raises:
RuntimeError: If the operation fails or times out
"""
command = createCommand("applyGaussianBlur", {
"layerId":layer_id,
"radius":radius,
})
return sendCommand(command)
@mcp.tool()
def apply_motion_blur(layer_id: int, angle: int = 0, distance: float = 30):
"""Applies a Motion Blur to the layer with the specified ID
Args:
layer_id (int): ID of layer to be blurred
angle (int): The angle in degrees (0 to 360) that determines the direction of the motion blur effect. Default is 0.
distance (float): The distance in pixels that controls the length/strength of the motion blur. Default is 30.
Higher values create a more pronounced motion effect.
Returns:
dict: Response from the Photoshop operation
Raises:
RuntimeError: If the operation fails or times out
"""
command = createCommand("applyMotionBlur", {
"layerId":layer_id,
"angle":angle,
"distance":distance
})
return sendCommand(command)
@mcp.resource("config://get_instructions")
def get_instructions() -> str:
"""Read this first! Returns information and instructions on how to use Photoshop and this API"""
return f"""
You are a photoshop expert who is creative and loves to help other people learn to use Photoshop and create. You are well versed in composition, design and color theory, and try to follow that theory when making decisions.
Unless otherwise specified, all commands act on the currently active document in Photoshop
Rules to follow:
1. Think deeply about how to solve the task
2. Always check your work
3. You can view the current visible photoshop file by calling get_document_image
4. Pay attention to font size (dont make it too big)
5. Always use alignment (align_content()) to position your text.
6. Read the info for the API calls to make sure you understand the requirements and arguments
7. When you make a selection, clear it once you no longer need it
Here are some general tips for when working with Photoshop.
In general, layers are created from bottom up, so keep that in mind as you figure out the order or operations. If you want you have lower layers show through higher ones you must either change the opacity of the higher layers and / or blend modes.
When using fonts there are a couple of things to keep in mind. First, the font origin is the bottom left of the font, not the top right.
Suggestions for sizes:
Paragraph text : 8 to 12 pts
Headings : 14 - 20 pts
Single Word Large : 20 to 25pt
Pay attention to what layer names are needed for. Sometimes the specify the name of a newly created layer and sometimes they specify the name of the layer that the action should be performed on.
As a general rule, you should not flatten files unless asked to do so, or its necessary to apply an effect or look.
When generating an image, you do not need to first create a pixel layer. A layer will automatically be created when you generate the image.
Colors are defined via a dict with red, green and blue properties with values between 0 and 255
{{"red":255, "green":0, "blue":0}}
Bounds is defined as a dict with top, left, bottom and right properties
{{"top": 0, "left": 0, "bottom": 250, "right": 300}}
Valid options for API calls:
alignment_modes: {", ".join(alignment_modes)}
justification_modes: {", ".join(justification_modes)}
blend_modes: {", ".join(blend_modes)}
anchor_positions: {", ".join(anchor_positions)}
interpolation_methods: {", ".join(interpolation_methods)}
fonts: {", ".join(font_names[:FONT_LIMIT])}
"""
font_names = list_all_fonts_postscript()
interpolation_methods = [
"AUTOMATIC",
"BICUBIC",
"BICUBICSHARPER",
"BICUBICSMOOTHER",
"BILINEAR",
"NEARESTNEIGHBOR"
]
anchor_positions = [
"BOTTOMCENTER",
"BOTTOMLEFT",
"BOTTOMRIGHT",
"MIDDLECENTER",
"MIDDLELEFT",
"MIDDLERIGHT",
"TOPCENTER",
"TOPLEFT",
"TOPRIGHT"
]
justification_modes = [
"CENTER",
"CENTERJUSTIFIED",
"FULLYJUSTIFIED",
"LEFT",
"LEFTJUSTIFIED",
"RIGHT",
"RIGHTJUSTIFIED"
]
alignment_modes = [
"LEFT",
"CENTER_HORIZONTAL",
"RIGHT",
"TOP",
"CENTER_VERTICAL",
"BOTTOM"
]
blend_modes = [
"COLOR",
"COLORBURN",
"COLORDODGE",
"DARKEN",
"DARKERCOLOR",
"DIFFERENCE",
"DISSOLVE",
"DIVIDE",
"EXCLUSION",
"HARDLIGHT",
"HARDMIX",
"HUE",
"LIGHTEN",
"LIGHTERCOLOR",
"LINEARBURN",
"LINEARDODGE",
"LINEARLIGHT",
"LUMINOSITY",
"MULTIPLY",
"NORMAL",
"OVERLAY",
"PASSTHROUGH",
"PINLIGHT",
"SATURATION",
"SCREEN",
"SOFTLIGHT",
"SUBTRACT",
"VIVIDLIGHT"
]
```