@synthetic-ai/premiere-mcp 2.0.0

package/dist/tools/sequence.d.ts

@@ -0,0 +1,211 @@
+import { BridgeOptions } from "../bridge/file-bridge.js";
+export declare function getSequenceTools(bridgeOptions: BridgeOptions): {
+    create_sequence: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                name: {
+                    type: string;
+                    description: string;
+                };
+                preset_path: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            name: string;
+            preset_path?: string;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    duplicate_sequence: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                sequence_id: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            sequence_id: string;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    delete_sequence: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                sequence_id: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            sequence_id: string;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    set_sequence_settings: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                sequence_id: {
+                    type: string;
+                    description: string;
+                };
+                width: {
+                    type: string;
+                    description: string;
+                };
+                height: {
+                    type: string;
+                    description: string;
+                };
+            };
+        };
+        handler: (args: {
+            sequence_id?: string;
+            width?: number;
+            height?: number;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    create_subsequence: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                ignore_track_targeting: {
+                    type: string;
+                    description: string;
+                };
+            };
+        };
+        handler: (args: {
+            ignore_track_targeting?: boolean;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    auto_reframe_sequence: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                sequence_id: {
+                    type: string;
+                    description: string;
+                };
+                target_width: {
+                    type: string;
+                    description: string;
+                };
+                target_height: {
+                    type: string;
+                    description: string;
+                };
+                quality: {
+                    type: string;
+                    enum: number[];
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            sequence_id?: string;
+            target_width: number;
+            target_height: number;
+            quality?: number;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    unnest_sequence: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                node_id: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            node_id: string;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    create_sequence_from_preset: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                name: {
+                    type: string;
+                    description: string;
+                };
+                preset_path: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            name: string;
+            preset_path: string;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    attach_custom_property: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                property_id: {
+                    type: string;
+                    description: string;
+                };
+                property_value: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            property_id: string;
+            property_value: string;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    is_work_area_enabled: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {};
+        };
+        handler: () => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    get_export_file_extension: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                preset_path: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            preset_path: string;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+};
+//# sourceMappingURL=sequence.d.ts.map

package/dist/tools/sequence.js

@@ -0,0 +1,378 @@
+import { buildToolScript, escapeForExtendScript } from "../bridge/script-builder.js";
+import { sendCommand } from "../bridge/file-bridge.js";
+export function getSequenceTools(bridgeOptions) {
+    return {
+        create_sequence: {
+            description: `Create a new empty sequence in the project and make it the active sequence.
+
+Uses qe.project.newSequence() which works without dialogs in Premiere Pro 2026.
+
+If no preset_path is provided, uses the HD 1080p 23.976fps preset. To create a specific format, pass the full path to a .sqpreset file.
+
+Common preset paths on Windows:
+- 1920x1080 24fps: C:\\Program Files\\Adobe\\Adobe Premiere Pro 2026\\Settings\\SequencePresets\\HD 1080p\\HD 1080p 23.976 fps.sqpreset
+- 1080x1920 (9:16): C:\\Program Files\\Adobe\\Adobe Premiere Pro 2026\\Settings\\SequencePresets\\Social\\Social Media Portrait 9x16 30 fps.sqpreset
+
+Example: create_sequence({ name: "Main Edit" })
+Example: create_sequence({ name: "Vertical", preset_path: "C:\\\\Program Files\\\\Adobe\\\\Adobe Premiere Pro 2026\\\\Settings\\\\SequencePresets\\\\Social\\\\Social Media Portrait 9x16 30 fps.sqpreset" })`,
+            parameters: {
+                type: "object",
+                properties: {
+                    name: {
+                        type: "string",
+                        description: "Name for the new sequence",
+                    },
+                    preset_path: {
+                        type: "string",
+                        description: "Optional path to a sequence preset file (.sqpreset). Uses HD 1080p 23.976fps if omitted.",
+                    },
+                },
+                required: ["name"],
+            },
+            handler: async (args) => {
+                const defaultPreset = "C:\\\\Program Files\\\\Adobe\\\\Adobe Premiere Pro 2026\\\\Settings\\\\SequencePresets\\\\HD 1080p\\\\HD 1080p 23.976 fps.sqpreset";
+                const preset = args.preset_path ? escapeForExtendScript(args.preset_path) : defaultPreset;
+                const script = buildToolScript(`
+          app.enableQE();
+          var seqName = "${escapeForExtendScript(args.name)}";
+          var presetPath = "${preset}";
+          var countBefore = app.project.sequences.numSequences;
+          var ok = qe.project.newSequence(seqName, presetPath);
+          if (!ok) return __error("qe.project.newSequence returned false — check preset path exists");
+          // Find the newly created sequence by name
+          var newSeq = null;
+          for (var i = 0; i < app.project.sequences.numSequences; i++) {
+            if (app.project.sequences[i].name === seqName) {
+              newSeq = app.project.sequences[i];
+              break;
+            }
+          }
+          if (!newSeq) return __error("Sequence created but not found by name");
+          app.project.activeSequence = newSeq;
+          return __result({ created: true, name: newSeq.name, id: newSeq.sequenceID, width: newSeq.frameSizeHorizontal, height: newSeq.frameSizeVertical });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        duplicate_sequence: {
+            description: "Duplicate an existing sequence",
+            parameters: {
+                type: "object",
+                properties: {
+                    sequence_id: {
+                        type: "string",
+                        description: "Sequence name or ID to duplicate",
+                    },
+                },
+                required: ["sequence_id"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = __findSequence("${escapeForExtendScript(args.sequence_id)}");
+          if (!seq) return __error("Sequence not found: ${escapeForExtendScript(args.sequence_id)}");
+          
+          seq.clone();
+          return __result({ duplicated: true, originalName: seq.name });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        delete_sequence: {
+            description: "Delete a sequence from the project",
+            parameters: {
+                type: "object",
+                properties: {
+                    sequence_id: {
+                        type: "string",
+                        description: "Sequence name or ID to delete",
+                    },
+                },
+                required: ["sequence_id"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var targetId = "${escapeForExtendScript(args.sequence_id)}";
+          var seq = __findSequence(targetId);
+          if (!seq) return __error("Sequence not found: " + targetId);
+          var seqName = seq.name;
+
+          function findProjectItemByName(parent, name) {
+            for (var i = 0; i < parent.children.numItems; i++) {
+              var item = parent.children[i];
+              if (item.name === name && item.type !== 2) return item;
+              if (item.type === 2) {
+                var found = findProjectItemByName(item, name);
+                if (found) return found;
+              }
+            }
+            return null;
+          }
+
+          app.project.deleteSequence(seq);
+          return __result({ deleted: true, name: seqName });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_sequence_settings: {
+            description: "Modify sequence settings (frame size, frame rate, etc.)",
+            parameters: {
+                type: "object",
+                properties: {
+                    sequence_id: {
+                        type: "string",
+                        description: "Sequence name or ID. Uses active sequence if omitted.",
+                    },
+                    width: {
+                        type: "number",
+                        description: "Frame width in pixels",
+                    },
+                    height: {
+                        type: "number",
+                        description: "Frame height in pixels",
+                    },
+                },
+            },
+            handler: async (args) => {
+                const seqLookup = args.sequence_id
+                    ? `var seq = __findSequence("${escapeForExtendScript(args.sequence_id)}"); if (!seq) return __error("Sequence not found");`
+                    : `var seq = app.project.activeSequence; if (!seq) return __error("No active sequence");`;
+                const width = args.width ?? -1;
+                const height = args.height ?? -1;
+                const script = buildToolScript(`
+          ${seqLookup}
+          var settings = seq.getSettings();
+          if (${width} !== -1) settings.videoFrameWidth = ${width};
+          if (${height} !== -1) settings.videoFrameHeight = ${height};
+          seq.setSettings(settings);
+          var updated = seq.getSettings();
+          return __result({ updated: true, name: seq.name, width: updated.videoFrameWidth, height: updated.videoFrameHeight });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        create_subsequence: {
+            description: "Create a subsequence (nested sequence) from selected clips or a time range",
+            parameters: {
+                type: "object",
+                properties: {
+                    ignore_track_targeting: {
+                        type: "boolean",
+                        description: "Whether to ignore track targeting (default: false)",
+                    },
+                },
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          
+          var newSeq = seq.createSubsequence(${args.ignore_track_targeting ? "true" : "false"});
+          if (!newSeq) return __error("Failed to create subsequence");
+          return __result({ created: true, name: newSeq.name, id: newSeq.sequenceID });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        auto_reframe_sequence: {
+            description: "Auto-reframe a sequence for a different aspect ratio",
+            parameters: {
+                type: "object",
+                properties: {
+                    sequence_id: {
+                        type: "string",
+                        description: "Sequence name or ID to reframe. Uses active sequence if omitted.",
+                    },
+                    target_width: {
+                        type: "number",
+                        description: "Target frame width in pixels",
+                    },
+                    target_height: {
+                        type: "number",
+                        description: "Target frame height in pixels",
+                    },
+                    quality: {
+                        type: "number",
+                        enum: [0, 1, 2],
+                        description: "Motion-tracking quality: 0=Default, 1=More Accurate, 2=Faster. Defaults to 0.",
+                    },
+                },
+                required: ["target_width", "target_height"],
+            },
+            handler: async (args) => {
+                const seqLookup = args.sequence_id
+                    ? `var seq = __findSequence("${escapeForExtendScript(args.sequence_id)}"); if (!seq) return __error("Sequence not found");`
+                    : `var seq = app.project.activeSequence; if (!seq) return __error("No active sequence");`;
+                const quality = args.quality === 1 || args.quality === 2 ? args.quality : 0;
+                const script = buildToolScript(`
+          ${seqLookup}
+          // autoReframeSequence(numerator, denominator, motionPresetString). arg1/arg2 are
+          // the aspect-ratio fraction (target_width:target_height preserves the ratio);
+          // the 3rd arg is a STRING preset, not an integer.
+          var __mp = (${quality} === 1 ? "slower" : (${quality} === 2 ? "faster" : "default"));
+          seq.autoReframeSequence(${args.target_width}, ${args.target_height}, __mp);
+          return __result({ reframed: true, name: seq.name, targetSize: "${args.target_width}x${args.target_height}", motionPreset: __mp });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        unnest_sequence: {
+            description: "Unnest a nested sequence on the timeline, replacing it with the contents of the nested sequence",
+            parameters: {
+                type: "object",
+                properties: {
+                    node_id: {
+                        type: "string",
+                        description: "Node ID of the nested sequence clip on the timeline to unnest",
+                    },
+                },
+                required: ["node_id"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var targetClip = null;
+          for (var t = 0; t < seq.videoTracks.numTracks; t++) {
+            for (var c = 0; c < seq.videoTracks[t].clips.numItems; c++) {
+              var clip = seq.videoTracks[t].clips[c];
+              if (clip.nodeId === "${escapeForExtendScript(args.node_id)}") { targetClip = clip; break; }
+            }
+            if (targetClip) break;
+          }
+          if (!targetClip) return __error("Clip not found: ${escapeForExtendScript(args.node_id)}");
+          // Try QE DOM unnest
+          app.enableQE();
+          try {
+            targetClip.setSelected(true, true);
+            var qeSeq = qe.project.getActiveSequence();
+            if (qeSeq && qeSeq.flattenSelectedNest) {
+              qeSeq.flattenSelectedNest();
+              return __result({ unnested: true, clipName: targetClip.name });
+            }
+          } catch(e) {}
+          return __error("Could not unnest via QE DOM in this PP version. Select the nested clip and use Clip > Nest > Unnest in the UI.");
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        create_sequence_from_preset: {
+            description: "Create a new sequence from a specific preset file (.sqpreset). Uses qe.project.newSequence() — works without dialogs in PP 2026.",
+            parameters: {
+                type: "object",
+                properties: {
+                    name: {
+                        type: "string",
+                        description: "Name for the new sequence",
+                    },
+                    preset_path: {
+                        type: "string",
+                        description: "Full path to the .sqpreset file",
+                    },
+                },
+                required: ["name", "preset_path"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          app.enableQE();
+          var seqName = "${escapeForExtendScript(args.name)}";
+          var presetPath = "${escapeForExtendScript(args.preset_path)}";
+          var ok = qe.project.newSequence(seqName, presetPath);
+          if (!ok) return __error("qe.project.newSequence returned false — check preset path: " + presetPath);
+          var newSeq = null;
+          for (var i = 0; i < app.project.sequences.numSequences; i++) {
+            if (app.project.sequences[i].name === seqName) {
+              newSeq = app.project.sequences[i];
+              break;
+            }
+          }
+          if (!newSeq) return __error("Sequence created but not found by name");
+          app.project.activeSequence = newSeq;
+          return __result({ created: true, name: newSeq.name, id: newSeq.sequenceID, width: newSeq.frameSizeHorizontal, height: newSeq.frameSizeVertical });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        attach_custom_property: {
+            description: "Attach a custom property (key/value pair) to the active sequence",
+            parameters: {
+                type: "object",
+                properties: {
+                    property_id: {
+                        type: "string",
+                        description: "Unique identifier for the custom property",
+                    },
+                    property_value: {
+                        type: "string",
+                        description: "Value for the custom property",
+                    },
+                },
+                required: ["property_id", "property_value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          seq.attachCustomProperty("${escapeForExtendScript(args.property_id)}", "${escapeForExtendScript(args.property_value)}");
+          return __result({ attached: true, propertyId: "${escapeForExtendScript(args.property_id)}", value: "${escapeForExtendScript(args.property_value)}" });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        is_work_area_enabled: {
+            description: "Check whether the work area bar is enabled on the active sequence",
+            parameters: {
+                type: "object",
+                properties: {},
+            },
+            handler: async () => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var enabled = false;
+          var available = false;
+          try {
+            if (typeof seq.isWorkAreaEnabled === "function") {
+              available = true;
+              enabled = seq.isWorkAreaEnabled();
+            } else if (typeof seq.isWorkAreaBarEnabled === "function") {
+              available = true;
+              enabled = seq.isWorkAreaBarEnabled();
+            } else if (seq.workAreaEnabled !== undefined) {
+              available = true;
+              enabled = seq.workAreaEnabled;
+            }
+          } catch(e) {
+            // API exists but threw, or not found — report disabled + unavailable so callers can distinguish
+            return __result({ sequenceName: seq.name, enabled: false, available: false, workAreaEnabled: false });
+          }
+          return __result({ sequenceName: seq.name, enabled: enabled, available: available, workAreaEnabled: enabled });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_export_file_extension: {
+            description: "Get the file extension that would be used when exporting the active sequence with a given preset",
+            parameters: {
+                type: "object",
+                properties: {
+                    preset_path: {
+                        type: "string",
+                        description: "Full path to the export preset file (.epr)",
+                    },
+                },
+                required: ["preset_path"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          var ext = seq.getExportFileExtension("${escapeForExtendScript(args.preset_path)}");
+          return __result({ sequenceName: seq.name, presetPath: "${escapeForExtendScript(args.preset_path)}", extension: ext });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+    };
+}
+//# sourceMappingURL=sequence.js.map

package/dist/tools/source-monitor.d.ts

@@ -0,0 +1,95 @@
+import { BridgeOptions } from "../bridge/file-bridge.js";
+export declare function getSourceMonitorTools(bridgeOptions: BridgeOptions): {
+    open_in_source: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                item_id: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            item_id: string;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    close_source_monitor: {
+        description: string;
+        parameters: {};
+        handler: () => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    close_all_source_clips: {
+        description: string;
+        parameters: {};
+        handler: () => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    set_source_in_out: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                in_seconds: {
+                    type: string;
+                    description: string;
+                };
+                out_seconds: {
+                    type: string;
+                    description: string;
+                };
+            };
+        };
+        handler: (args: {
+            in_seconds?: number;
+            out_seconds?: number;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    insert_from_source: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                video_track_index: {
+                    type: string;
+                    description: string;
+                };
+                audio_track_index: {
+                    type: string;
+                    description: string;
+                };
+            };
+        };
+        handler: (args: {
+            video_track_index?: number;
+            audio_track_index?: number;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    overwrite_from_source: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                video_track_index: {
+                    type: string;
+                    description: string;
+                };
+                audio_track_index: {
+                    type: string;
+                    description: string;
+                };
+            };
+        };
+        handler: (args: {
+            video_track_index?: number;
+            audio_track_index?: number;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    get_source_monitor_info: {
+        description: string;
+        parameters: {};
+        handler: () => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+};
+//# sourceMappingURL=source-monitor.d.ts.map