@synthetic-ai/premiere-mcp 2.0.0

package/dist/tools/audio.d.ts

@@ -0,0 +1,84 @@
+import { BridgeOptions } from "../bridge/file-bridge.js";
+export declare function getAudioTools(bridgeOptions: BridgeOptions): {
+    adjust_audio_levels: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                node_id: {
+                    type: string;
+                    description: string;
+                };
+                level_db: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            node_id: string;
+            level_db: number;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    add_audio_keyframes: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                node_id: {
+                    type: string;
+                    description: string;
+                };
+                keyframes: {
+                    type: string;
+                    items: {
+                        type: string;
+                        properties: {
+                            time_seconds: {
+                                type: string;
+                                description: string;
+                            };
+                            level_db: {
+                                type: string;
+                                description: string;
+                            };
+                        };
+                        required: string[];
+                    };
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            node_id: string;
+            keyframes: Array<{
+                time_seconds: number;
+                level_db: number;
+            }>;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    mute_track: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                track_index: {
+                    type: string;
+                    description: string;
+                };
+                muted: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            track_index: number;
+            muted: boolean;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+};
+//# sourceMappingURL=audio.d.ts.map

package/dist/tools/audio.js

@@ -0,0 +1,123 @@
+import { buildToolScript, escapeForExtendScript } from "../bridge/script-builder.js";
+import { sendCommand } from "../bridge/file-bridge.js";
+export function getAudioTools(bridgeOptions) {
+    return {
+        adjust_audio_levels: {
+            description: "Adjust the audio level (volume) of a clip in dB",
+            parameters: {
+                type: "object",
+                properties: {
+                    node_id: {
+                        type: "string",
+                        description: "Node ID of the audio or video clip",
+                    },
+                    level_db: {
+                        type: "number",
+                        description: "Audio level in dB (0 = unity, negative = quieter, positive = louder)",
+                    },
+                },
+                required: ["node_id", "level_db"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = __findClip("${escapeForExtendScript(args.node_id)}");
+          if (!result) return __error("Clip not found");
+          
+          var clip = result.clip;
+          // Find the Volume component via locale-independent helper
+          var volComp = __findIntrinsic(clip, "volume");
+          if (!volComp) return __error("Could not find Volume component on clip");
+
+          var levelProp = __findProp(volComp, ["Level", "Volume", "Nivel"]);
+          if (!levelProp) return __error("Could not find Volume/Level property on clip");
+
+          levelProp.setValue(${args.level_db}, true);
+          return __result({ adjusted: true, clipName: clip.name, levelDb: ${args.level_db} });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        add_audio_keyframes: {
+            description: "Add audio level keyframes to create fades or level changes",
+            parameters: {
+                type: "object",
+                properties: {
+                    node_id: {
+                        type: "string",
+                        description: "Node ID of the clip",
+                    },
+                    keyframes: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                time_seconds: { type: "number", description: "Time in seconds relative to clip start" },
+                                level_db: { type: "number", description: "Audio level in dB" },
+                            },
+                            required: ["time_seconds", "level_db"],
+                        },
+                        description: "Array of keyframe objects with time_seconds and level_db",
+                    },
+                },
+                required: ["node_id", "keyframes"],
+            },
+            handler: async (args) => {
+                const keyframeCode = args.keyframes
+                    .map((kf) => `
+            var kfT = new Time(); kfT.ticks = String(__secondsToTicks(${kf.time_seconds}));
+            levelProp.addKey(kfT);
+            levelProp.setValueAtKey(kfT, ${kf.level_db});`)
+                    .join("\n");
+                const script = buildToolScript(`
+          var result = __findClip("${escapeForExtendScript(args.node_id)}");
+          if (!result) return __error("Clip not found");
+          
+          var clip = result.clip;
+          var volComp = __findIntrinsic(clip, "volume");
+          if (!volComp) return __error("Could not find audio Volume component");
+          var levelProp = __findProp(volComp, ["Level", "Volume", "Nivel"]);
+
+          if (!levelProp) return __error("Could not find audio Level property");
+          
+          levelProp.setTimeVarying(true);
+          ${keyframeCode}
+          
+          return __result({ keyframesAdded: ${args.keyframes.length}, clipName: clip.name });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        mute_track: {
+            description: "Mute or unmute an audio track",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: {
+                        type: "number",
+                        description: "Audio track index (0-based)",
+                    },
+                    muted: {
+                        type: "boolean",
+                        description: "True to mute, false to unmute",
+                    },
+                },
+                required: ["track_index", "muted"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          
+          if (${args.track_index} >= seq.audioTracks.numTracks) return __error("Track index out of range");
+          
+          var track = seq.audioTracks[${args.track_index}];
+          track.setMute(${args.muted ? 1 : 0});
+          
+          return __result({ trackIndex: ${args.track_index}, muted: ${args.muted}, trackName: track.name });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+    };
+}
+//# sourceMappingURL=audio.js.map

package/dist/tools/captions.d.ts

@@ -0,0 +1,30 @@
+import { BridgeOptions } from "../bridge/file-bridge.js";
+export declare function getCaptionTools(bridgeOptions: BridgeOptions): {
+    create_caption_track: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                item_id: {
+                    type: string;
+                    description: string;
+                };
+                start_seconds: {
+                    type: string;
+                    description: string;
+                };
+                caption_format: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            item_id: string;
+            start_seconds?: number;
+            caption_format?: string;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+};
+//# sourceMappingURL=captions.d.ts.map

package/dist/tools/captions.js

@@ -0,0 +1,73 @@
+import { buildToolScript, escapeForExtendScript } from "../bridge/script-builder.js";
+import { sendCommand } from "../bridge/file-bridge.js";
+export function getCaptionTools(bridgeOptions) {
+    return {
+        create_caption_track: {
+            description: "Create a caption/subtitle track in the active sequence from an imported caption file (e.g., .srt, .vtt)",
+            parameters: {
+                type: "object",
+                properties: {
+                    item_id: {
+                        type: "string",
+                        description: "Node ID or name of the imported caption project item (e.g., an .srt file)",
+                    },
+                    start_seconds: {
+                        type: "number",
+                        description: "Offset in seconds from the start of the sequence (default: 0)",
+                    },
+                    caption_format: {
+                        type: "string",
+                        description: "Caption format: 'subtitle' (default), '608', '708', 'teletext', 'ebu', 'op42', 'op47'",
+                    },
+                },
+                required: ["item_id"],
+            },
+            handler: async (args) => {
+                const startSeconds = args.start_seconds ?? 0;
+                // Map requested format to the Sequence.* constant name and a numeric fallback.
+                // Numeric fallbacks follow Premiere's CaptionFormat enum ordering.
+                const formatMap = {
+                    subtitle: { constant: "CAPTION_FORMAT_SUBTITLE", fallback: 0 },
+                    "608": { constant: "CAPTION_FORMAT_608", fallback: 1 },
+                    "708": { constant: "CAPTION_FORMAT_708", fallback: 2 },
+                    teletext: { constant: "CAPTION_FORMAT_TELETEXT", fallback: 3 },
+                    ebu: { constant: "CAPTION_FORMAT_OPEN_EBU", fallback: 4 },
+                    op42: { constant: "CAPTION_FORMAT_OP42", fallback: 5 },
+                    op47: { constant: "CAPTION_FORMAT_OP47", fallback: 6 },
+                };
+                const formatKey = args.caption_format || "subtitle";
+                const formatEntry = formatMap[formatKey] || formatMap["subtitle"];
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+
+          var item = __findProjectItem("${escapeForExtendScript(args.item_id)}");
+          if (!item) return __error("Caption item not found: ${escapeForExtendScript(args.item_id)}");
+
+          // Resolve the caption format constant defensively. The Sequence.CAPTION_FORMAT_*
+          // constants may be undefined depending on the Premiere version, so fall back to
+          // the known numeric value if the constant cannot be read.
+          var captionFormat = ${formatEntry.fallback};
+          try {
+            if (typeof Sequence !== "undefined" && Sequence && typeof Sequence.${formatEntry.constant} !== "undefined") {
+              captionFormat = Sequence.${formatEntry.constant};
+            }
+          } catch (eFmt) {
+            captionFormat = ${formatEntry.fallback};
+          }
+
+          // createCaptionTrack may return undefined on success, so treat only a thrown
+          // error as a real failure.
+          try {
+            seq.createCaptionTrack(item, ${startSeconds}, captionFormat);
+          } catch (eCreate) {
+            return __error("Failed to create caption track: " + eCreate.toString());
+          }
+          return __result({ created: true, item: item.name, startSeconds: ${startSeconds}, format: "${formatKey}" });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+    };
+}
+//# sourceMappingURL=captions.js.map

package/dist/tools/clipboard.d.ts

@@ -0,0 +1,153 @@
+import { BridgeOptions } from "../bridge/file-bridge.js";
+export declare function getClipboardTools(bridgeOptions: BridgeOptions): {
+    copy_effects_between_clips: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                source_node_id: {
+                    type: string;
+                    description: string;
+                };
+                target_node_id: {
+                    type: string;
+                    description: string;
+                };
+                effect_name: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            source_node_id: string;
+            target_node_id: string;
+            effect_name?: string;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    copy_effect_values: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                source_node_id: {
+                    type: string;
+                    description: string;
+                };
+                target_node_id: {
+                    type: string;
+                    description: string;
+                };
+                effect_name: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            source_node_id: string;
+            target_node_id: string;
+            effect_name: string;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    replace_clip_media: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                clip_node_id: {
+                    type: string;
+                    description: string;
+                };
+                new_item_id: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            clip_node_id: string;
+            new_item_id: string;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    batch_apply_effect: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                effect_name: {
+                    type: string;
+                    description: string;
+                };
+                target: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                track_type: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                track_index: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            effect_name: string;
+            target: string;
+            track_type?: string;
+            track_index?: number;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    remove_effect_by_name: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                node_id: {
+                    type: string;
+                    description: string;
+                };
+                effect_name: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            node_id: string;
+            effect_name: string;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    set_blend_mode: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                node_id: {
+                    type: string;
+                    description: string;
+                };
+                blend_mode: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            node_id: string;
+            blend_mode: string;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+};
+//# sourceMappingURL=clipboard.d.ts.map