@synthetic-ai/premiere-mcp 2.0.0

package/dist/tools/playback.d.ts

@@ -0,0 +1,34 @@
+import { BridgeOptions } from "../bridge/file-bridge.js";
+export declare function getPlaybackTools(bridgeOptions: BridgeOptions): {
+    play_timeline: {
+        description: string;
+        parameters: {};
+        handler: () => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    stop_playback: {
+        description: string;
+        parameters: {};
+        handler: () => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    play_source_monitor: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                speed: {
+                    type: string;
+                    description: string;
+                };
+            };
+        };
+        handler: (args: {
+            speed?: number;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    get_source_monitor_position: {
+        description: string;
+        parameters: {};
+        handler: () => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+};
+//# sourceMappingURL=playback.d.ts.map

package/dist/tools/playback.js

@@ -0,0 +1,63 @@
+import { buildToolScript } from "../bridge/script-builder.js";
+import { sendCommand } from "../bridge/file-bridge.js";
+export function getPlaybackTools(bridgeOptions) {
+    return {
+        play_timeline: {
+            description: "Start playback of the active sequence timeline. Uses QE DOM.",
+            parameters: {},
+            handler: async () => {
+                const script = buildToolScript(`
+          app.enableQE();
+          qe.startPlayback();
+          return __result({ playing: true });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        stop_playback: {
+            description: "Stop playback of the active sequence timeline. Uses QE DOM.",
+            parameters: {},
+            handler: async () => {
+                const script = buildToolScript(`
+          app.enableQE();
+          qe.stopPlayback();
+          return __result({ stopped: true });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        play_source_monitor: {
+            description: "Start playback of the clip in the Source Monitor",
+            parameters: {
+                type: "object",
+                properties: {
+                    speed: {
+                        type: "number",
+                        description: "Playback speed (1.0 = normal, 2.0 = 2x, -1.0 = reverse). Default: 1.0",
+                    },
+                },
+            },
+            handler: async (args) => {
+                const speed = args.speed ?? 1.0;
+                const script = buildToolScript(`
+          app.sourceMonitor.play(${speed});
+          return __result({ playing: true, speed: ${speed} });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_source_monitor_position: {
+            description: "Get the current time indicator position in the Source Monitor",
+            parameters: {},
+            handler: async () => {
+                const script = buildToolScript(`
+          var pos = app.sourceMonitor.getPosition();
+          if (!pos) return __error("No clip open in Source Monitor");
+          return __result({ seconds: __ticksToSeconds(pos.ticks), ticks: pos.ticks });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+    };
+}
+//# sourceMappingURL=playback.js.map

package/dist/tools/playhead.d.ts

@@ -0,0 +1,77 @@
+import { BridgeOptions } from "../bridge/file-bridge.js";
+export declare function getPlayheadTools(bridgeOptions: BridgeOptions): {
+    get_playhead_position: {
+        description: string;
+        parameters: {};
+        handler: () => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    set_playhead_position: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                time_seconds: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            time_seconds: number;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    set_work_area: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                in_seconds: {
+                    type: string;
+                    description: string;
+                };
+                out_seconds: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            in_seconds: number;
+            out_seconds: number;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    get_work_area: {
+        description: string;
+        parameters: {};
+        handler: () => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    set_sequence_in_out_points: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                in_seconds: {
+                    type: string;
+                    description: string;
+                };
+                out_seconds: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            in_seconds: number;
+            out_seconds: number;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    get_sequence_in_out_points: {
+        description: string;
+        parameters: {};
+        handler: () => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+};
+//# sourceMappingURL=playhead.d.ts.map

package/dist/tools/playhead.js

@@ -0,0 +1,185 @@
+import { buildToolScript } from "../bridge/script-builder.js";
+import { sendCommand } from "../bridge/file-bridge.js";
+export function getPlayheadTools(bridgeOptions) {
+    return {
+        get_playhead_position: {
+            description: "Get the current playhead (CTI) position in the active sequence",
+            parameters: {},
+            handler: async () => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          
+          var ticks = seq.getPlayerPosition().ticks;
+          return __result({
+            seconds: __ticksToSeconds(ticks),
+            ticks: ticks
+          });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_playhead_position: {
+            description: "Set the playhead (CTI) position in the active sequence",
+            parameters: {
+                type: "object",
+                properties: {
+                    time_seconds: {
+                        type: "number",
+                        description: "Time position in seconds to move the playhead to",
+                    },
+                },
+                required: ["time_seconds"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          
+          var ticks = __secondsToTicks(${args.time_seconds}).toString();
+          seq.setPlayerPosition(ticks);
+          
+          return __result({ positionSeconds: ${args.time_seconds} });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_work_area: {
+            description: "Set the work area (bar) in and out points",
+            parameters: {
+                type: "object",
+                properties: {
+                    in_seconds: {
+                        type: "number",
+                        description: "Work area in-point in seconds",
+                    },
+                    out_seconds: {
+                        type: "number",
+                        description: "Work area out-point in seconds",
+                    },
+                },
+                required: ["in_seconds", "out_seconds"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+
+          var inOk = false;
+          var outOk = false;
+          var errMsg = null;
+
+          var inTicks = __secondsToTicks(${args.in_seconds}).toString();
+          var outTicks = __secondsToTicks(${args.out_seconds}).toString();
+
+          try {
+            if (typeof seq.setWorkAreaInPoint === "function") {
+              seq.setWorkAreaInPoint(inTicks);
+              inOk = true;
+            }
+          } catch(e1) { errMsg = (errMsg ? errMsg + "; " : "") + "in: " + e1.toString(); }
+
+          try {
+            if (typeof seq.setWorkAreaOutPoint === "function") {
+              seq.setWorkAreaOutPoint(outTicks);
+              outOk = true;
+            }
+          } catch(e2) { errMsg = (errMsg ? errMsg + "; " : "") + "out: " + e2.toString(); }
+
+          var enabled = false;
+          try {
+            if (typeof seq.isWorkAreaBarEnabled === "function") enabled = seq.isWorkAreaBarEnabled();
+          } catch(e3) {}
+
+          return __result({
+            success: (inOk && outOk),
+            workAreaIn: ${args.in_seconds},
+            workAreaOut: ${args.out_seconds},
+            inSet: inOk,
+            outSet: outOk,
+            workAreaEnabled: enabled,
+            error: errMsg
+          });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_work_area: {
+            description: "Get the current work area in and out points",
+            parameters: {},
+            handler: async () => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          
+          var inSec = 0;
+          var outSec = 0;
+          // seq.end is already a ticks STRING, not a Time object
+          try { if (seq.end != null) outSec = __ticksToSeconds(String(seq.end)); } catch(e) {}
+          // workInPoint/workOutPoint may be Time objects or ticks strings — handle both
+          try {
+            if (seq.workInPoint != null) {
+              inSec = (seq.workInPoint.ticks != null) ? __ticksToSeconds(seq.workInPoint.ticks) : __ticksToSeconds(String(seq.workInPoint));
+            }
+            if (seq.workOutPoint != null) {
+              outSec = (seq.workOutPoint.ticks != null) ? __ticksToSeconds(seq.workOutPoint.ticks) : __ticksToSeconds(String(seq.workOutPoint));
+            }
+          } catch(e) {}
+          return __result({
+            sequenceName: seq.name,
+            inSeconds: inSec,
+            outSeconds: outSec,
+            workAreaEnabled: seq.isWorkAreaBarEnabled ? seq.isWorkAreaBarEnabled() : false
+          });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_sequence_in_out_points: {
+            description: "Set the sequence in and out points (for export range, etc.)",
+            parameters: {
+                type: "object",
+                properties: {
+                    in_seconds: {
+                        type: "number",
+                        description: "In-point in seconds",
+                    },
+                    out_seconds: {
+                        type: "number",
+                        description: "Out-point in seconds",
+                    },
+                },
+                required: ["in_seconds", "out_seconds"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          
+          seq.setInPoint(__secondsToTicks(${args.in_seconds}).toString());
+          seq.setOutPoint(__secondsToTicks(${args.out_seconds}).toString());
+          
+          return __result({ inSeconds: ${args.in_seconds}, outSeconds: ${args.out_seconds} });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_sequence_in_out_points: {
+            description: "Get the current sequence in and out points",
+            parameters: {},
+            handler: async () => {
+                const script = buildToolScript(`
+          var seq = app.project.activeSequence;
+          if (!seq) return __error("No active sequence");
+          
+          return __result({
+            inSeconds: __ticksToSeconds(seq.getInPoint()),
+            outSeconds: __ticksToSeconds(seq.getOutPoint())
+          });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+    };
+}
+//# sourceMappingURL=playhead.js.map

package/dist/tools/project-manager.d.ts

@@ -0,0 +1,65 @@
+import { BridgeOptions } from "../bridge/file-bridge.js";
+export declare function getProjectManagerTools(bridgeOptions: BridgeOptions): {
+    consolidate_and_transfer: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                destination_path: {
+                    type: string;
+                    description: string;
+                };
+                include_all_sequences: {
+                    type: string;
+                    description: string;
+                };
+                copy_to_new_location: {
+                    type: string;
+                    description: string;
+                };
+                exclude_unused: {
+                    type: string;
+                    description: string;
+                };
+                transcode: {
+                    type: string;
+                    description: string;
+                };
+                include_preview_files: {
+                    type: string;
+                    description: string;
+                };
+                rename_media: {
+                    type: string;
+                    description: string;
+                };
+                convert_image_sequences: {
+                    type: string;
+                    description: string;
+                };
+                convert_ae_comps: {
+                    type: string;
+                    description: string;
+                };
+                convert_synthetic: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            destination_path: string;
+            include_all_sequences?: boolean;
+            copy_to_new_location?: boolean;
+            exclude_unused?: boolean;
+            transcode?: boolean;
+            include_preview_files?: boolean;
+            rename_media?: boolean;
+            convert_image_sequences?: boolean;
+            convert_ae_comps?: boolean;
+            convert_synthetic?: boolean;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+};
+//# sourceMappingURL=project-manager.d.ts.map

package/dist/tools/project-manager.js

@@ -0,0 +1,81 @@
+import { buildToolScript, escapeForExtendScript } from "../bridge/script-builder.js";
+import { sendCommand } from "../bridge/file-bridge.js";
+export function getProjectManagerTools(bridgeOptions) {
+    return {
+        consolidate_and_transfer: {
+            description: "Consolidate, copy, or transcode project media using the Project Manager. Useful for archiving or transferring projects.",
+            parameters: {
+                type: "object",
+                properties: {
+                    destination_path: {
+                        type: "string",
+                        description: "Destination folder path for the consolidated project",
+                    },
+                    include_all_sequences: {
+                        type: "boolean",
+                        description: "Include all sequences (default: true). If false, only active sequence is used.",
+                    },
+                    copy_to_new_location: {
+                        type: "boolean",
+                        description: "Copy media to a new location (default: true)",
+                    },
+                    exclude_unused: {
+                        type: "boolean",
+                        description: "Exclude unused clips (default: true)",
+                    },
+                    transcode: {
+                        type: "boolean",
+                        description: "Transcode media during copy (default: false)",
+                    },
+                    include_preview_files: {
+                        type: "boolean",
+                        description: "Include preview/render files (default: false)",
+                    },
+                    rename_media: {
+                        type: "boolean",
+                        description: "Rename media to match clip names (default: false)",
+                    },
+                    convert_image_sequences: {
+                        type: "boolean",
+                        description: "Convert image sequences to clips (default: false)",
+                    },
+                    convert_ae_comps: {
+                        type: "boolean",
+                        description: "Convert After Effects compositions (default: false)",
+                    },
+                    convert_synthetic: {
+                        type: "boolean",
+                        description: "Convert synthetic importer items (default: false)",
+                    },
+                },
+                required: ["destination_path"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var pm = app.projectManager;
+          if (!pm) return __error("Project Manager not available");
+          
+          pm.destinationPath = "${escapeForExtendScript(args.destination_path)}";
+          pm.includeAllSequences = ${args.include_all_sequences !== false ? 1 : 0};
+          pm.copyToNewLocation = ${args.copy_to_new_location !== false ? 1 : 0};
+          pm.excludeUnused = ${args.exclude_unused !== false ? 1 : 0};
+          pm.transcodeMedia = ${args.transcode ? 1 : 0};
+          pm.includePreviewFiles = ${args.include_preview_files ? 1 : 0};
+          pm.renameMedia = ${args.rename_media ? 1 : 0};
+          pm.convertImageSequences = ${args.convert_image_sequences ? 1 : 0};
+          pm.convertAEComps = ${args.convert_ae_comps ? 1 : 0};
+          pm.convertSyntheticMedia = ${args.convert_synthetic ? 1 : 0};
+          
+          pm.process(app.project);
+          
+          return __result({
+            started: true,
+            destination: "${escapeForExtendScript(args.destination_path)}"
+          });
+        `);
+                return sendCommand(script, { ...bridgeOptions, timeoutMs: 300000 }); // 5 min timeout
+            },
+        },
+    };
+}
+//# sourceMappingURL=project-manager.js.map