@synthetic-ai/premiere-mcp 2.0.0

package/dist/tools/metadata.js

@@ -0,0 +1,278 @@
+import { buildToolScript, escapeForExtendScript } from "../bridge/script-builder.js";
+import { sendCommand } from "../bridge/file-bridge.js";
+export function getMetadataTools(bridgeOptions) {
+    return {
+        get_metadata: {
+            description: "Get metadata for a project item",
+            parameters: {
+                type: "object",
+                properties: {
+                    item_id: {
+                        type: "string",
+                        description: "Node ID or name of the project item",
+                    },
+                },
+                required: ["item_id"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var item = __findProjectItem("${escapeForExtendScript(args.item_id)}");
+          if (!item) return __error("Item not found");
+          
+          var metadata = {};
+          try {
+            var xmpBlob = item.getProjectMetadata();
+            metadata.projectMetadata = xmpBlob;
+          } catch(e) {}
+          
+          try {
+            var xmpBlob2 = item.getXMPMetadata();
+            metadata.xmpMetadata = xmpBlob2;
+          } catch(e) {}
+          
+          metadata.name = item.name;
+          metadata.nodeId = item.nodeId;
+          
+          try {
+            metadata.mediaPath = item.getMediaPath();
+          } catch(e) {}
+          
+          return __result(metadata);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_metadata: {
+            description: "Set project metadata on a project item",
+            parameters: {
+                type: "object",
+                properties: {
+                    item_id: {
+                        type: "string",
+                        description: "Node ID or name of the project item",
+                    },
+                    field_name: {
+                        type: "string",
+                        description: "Metadata field name (e.g., 'Column.Intrinsic.Description')",
+                    },
+                    value: {
+                        type: "string",
+                        description: "Value to set",
+                    },
+                },
+                required: ["item_id", "field_name", "value"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var item = __findProjectItem("${escapeForExtendScript(args.item_id)}");
+          if (!item) return __error("Item not found");
+          
+          item.setProjectMetadata("${escapeForExtendScript(args.value)}", "${escapeForExtendScript(args.field_name)}");
+          
+          return __result({ updated: true, item: item.name, field: "${escapeForExtendScript(args.field_name)}" });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_color_label: {
+            description: "Set the color label on a project item or clip",
+            parameters: {
+                type: "object",
+                properties: {
+                    item_id: {
+                        type: "string",
+                        description: "Node ID or name of the project item",
+                    },
+                    color_index: {
+                        type: "number",
+                        description: "Label color index (0=Violet, 1=Iris, 2=Caribbean, 3=Lavender, 4=Cerulean, 5=Forest, 6=Rose, 7=Mango, 8=Purple, 9=Blue, 10=Teal, 11=Magenta, 12=Tan, 13=Green, 14=Brown, 15=Yellow)",
+                    },
+                },
+                required: ["item_id", "color_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          // Accept both project item IDs/names AND timeline clip nodeIds.
+          var item = __resolveProjectItemOrTimelineClip("${escapeForExtendScript(args.item_id)}");
+          if (!item) return __error("Item not found in project tree or timeline: ${escapeForExtendScript(args.item_id)}");
+
+          item.setColorLabel(${args.color_index});
+          return __result({ updated: true, item: item.name, colorIndex: ${args.color_index} });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_color_label: {
+            description: "Get the color label of a project item",
+            parameters: {
+                type: "object",
+                properties: {
+                    item_id: {
+                        type: "string",
+                        description: "Node ID or name of the project item",
+                    },
+                },
+                required: ["item_id"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var item = __findProjectItem("${escapeForExtendScript(args.item_id)}");
+          if (!item) return __error("Item not found");
+          
+          var colorIndex = item.getColorLabel();
+          return __result({ item: item.name, colorIndex: colorIndex });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_footage_interpretation: {
+            description: "Get footage interpretation settings for a project item",
+            parameters: {
+                type: "object",
+                properties: {
+                    item_id: {
+                        type: "string",
+                        description: "Node ID or name of the project item",
+                    },
+                },
+                required: ["item_id"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var item = __findProjectItem("${escapeForExtendScript(args.item_id)}");
+          if (!item) return __error("Item not found");
+          
+          var interp = item.getFootageInterpretation();
+          if (!interp) return __error("No footage interpretation available");
+          
+          return __result({
+            item: item.name,
+            alphaUsage: interp.alphaUsage,
+            fieldType: interp.fieldType,
+            frameRate: interp.frameRate,
+            ignoreAlpha: interp.ignoreAlpha,
+            invertAlpha: interp.invertAlpha,
+            pixelAspectRatio: interp.pixelAspectRatio
+          });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_footage_interpretation: {
+            description: "Set footage interpretation settings for a project item",
+            parameters: {
+                type: "object",
+                properties: {
+                    item_id: {
+                        type: "string",
+                        description: "Node ID or name of the project item",
+                    },
+                    frame_rate: {
+                        type: "number",
+                        description: "Override frame rate",
+                    },
+                    pixel_aspect_ratio: {
+                        type: "number",
+                        description: "Pixel aspect ratio (1.0 = square pixels)",
+                    },
+                },
+                required: ["item_id"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var item = __findProjectItem("${escapeForExtendScript(args.item_id)}");
+          if (!item) return __error("Item not found");
+          
+          var interp = item.getFootageInterpretation();
+          if (!interp) return __error("No footage interpretation available");
+          
+          ${args.frame_rate !== undefined ? `interp.frameRate = ${args.frame_rate};` : ""}
+          ${args.pixel_aspect_ratio !== undefined ? `interp.pixelAspectRatio = ${args.pixel_aspect_ratio};` : ""}
+          
+          item.setFootageInterpretation(interp);
+          return __result({ updated: true, item: item.name });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_xmp_metadata: {
+            description: "Get the raw XMP metadata for a project item (includes EXIF, IPTC, Dublin Core, etc.)",
+            parameters: {
+                type: "object",
+                properties: {
+                    item_id: {
+                        type: "string",
+                        description: "Node ID or name of the project item",
+                    },
+                },
+                required: ["item_id"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var item = __findProjectItem("${escapeForExtendScript(args.item_id)}");
+          if (!item) return __error("Item not found");
+          
+          var xmp = item.getXMPMetadata();
+          return __result({ item: item.name, xmpMetadata: xmp });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        set_xmp_metadata: {
+            description: "Set raw XMP metadata on a project item (provide complete XMP XML string)",
+            parameters: {
+                type: "object",
+                properties: {
+                    item_id: {
+                        type: "string",
+                        description: "Node ID or name of the project item",
+                    },
+                    xmp_xml: {
+                        type: "string",
+                        description: "Complete XMP metadata XML string to set",
+                    },
+                },
+                required: ["item_id", "xmp_xml"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var item = __findProjectItem("${escapeForExtendScript(args.item_id)}");
+          if (!item) return __error("Item not found");
+          
+          item.setXMPMetadata("${escapeForExtendScript(args.xmp_xml)}");
+          return __result({ updated: true, item: item.name });
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_color_space: {
+            description: "Get the color space information for a project item",
+            parameters: {
+                type: "object",
+                properties: {
+                    item_id: {
+                        type: "string",
+                        description: "Node ID or name of the project item",
+                    },
+                },
+                required: ["item_id"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var item = __findProjectItem("${escapeForExtendScript(args.item_id)}");
+          if (!item) return __error("Item not found");
+          
+          var info = { item: item.name };
+          try { info.colorSpace = item.getColorSpace(); } catch(e) { info.colorSpace = "unknown"; }
+          try { info.originalColorSpace = item.getOriginalColorSpace(); } catch(e) {}
+          try { info.embeddedLUT = item.getEmbeddedLUTID(); } catch(e) {}
+          try { info.inputLUT = item.getInputLUTID(); } catch(e) {}
+          
+          return __result(info);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+    };
+}
+//# sourceMappingURL=metadata.js.map

package/dist/tools/multicam.d.ts

@@ -0,0 +1,199 @@
+import { BridgeOptions } from "../bridge/file-bridge.js";
+export declare function getMulticamTools(bridgeOptions: BridgeOptions): {
+    create_multicam_sequence: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                name: {
+                    type: string;
+                    description: string;
+                };
+                clip_indices: {
+                    type: string;
+                    description: string;
+                };
+                sync_point: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            name?: string;
+            clip_indices: number[];
+            sync_point?: string;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    switch_multicam_angle: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                track_index: {
+                    type: string;
+                    description: string;
+                };
+                time: {
+                    type: string;
+                    description: string;
+                };
+                angle_index: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            track_index: number;
+            time: number;
+            angle_index: number;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    flatten_multicam: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                sequence_index: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            sequence_index: number;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    get_multicam_angles: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                track_index: {
+                    type: string;
+                    description: string;
+                };
+                clip_index: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            track_index: number;
+            clip_index: number;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    create_proxy: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                project_item_index: {
+                    type: string;
+                    description: string;
+                };
+                preset_path: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            project_item_index: number;
+            preset_path: string;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    attach_proxy: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                project_item_index: {
+                    type: string;
+                    description: string;
+                };
+                proxy_path: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            project_item_index: number;
+            proxy_path: string;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    has_proxy: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                project_item_index: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            project_item_index: number;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    get_proxy_path: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                project_item_index: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            project_item_index: number;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    toggle_proxies: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                enabled: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            enabled: boolean;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+    detach_proxy: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                project_item_index: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            project_item_index: number;
+        }) => Promise<import("../bridge/file-bridge.js").CommandResult>;
+    };
+};
+//# sourceMappingURL=multicam.d.ts.map

package/dist/tools/multicam.js

@@ -0,0 +1,212 @@
+import { buildToolScript } from "../bridge/script-builder.js";
+import { sendCommand } from "../bridge/file-bridge.js";
+export function getMulticamTools(bridgeOptions) {
+    return {
+        create_multicam_sequence: {
+            description: "Create a multicam sequence from multiple project items. Clips are synced based on the specified sync point method.",
+            parameters: {
+                type: "object",
+                properties: {
+                    name: { type: "string", description: "Name for the new multicam sequence. Default: 'Multicam Sequence'." },
+                    clip_indices: { type: "array", description: "Array of project item indices (from root item) to include as camera angles. At least 2 required." },
+                    sync_point: { type: "string", description: "How to sync the clips: 'inPoint', 'outPoint', 'timecode', or 'marker'. Default: 'inPoint'." },
+                },
+                required: ["clip_indices"],
+            },
+            handler: async (args) => {
+                const params = {
+                    name: args.name || "Multicam Sequence",
+                    clipIndices: args.clip_indices,
+                    syncPoint: args.sync_point || "inPoint",
+                };
+                const paramsJson = JSON.stringify(JSON.stringify(params));
+                const script = buildToolScript(`
+          var result = createMulticamSequence(${paramsJson});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        switch_multicam_angle: {
+            description: "Switch the camera angle of a multicam clip at a specific time point. Used during multicam editing to cut between cameras.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index containing the multicam clip (0-based)" },
+                    time: { type: "number", description: "Time in seconds where the angle switch should occur" },
+                    angle_index: { type: "number", description: "Camera angle index to switch to (0-based)" },
+                },
+                required: ["track_index", "time", "angle_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = switchMulticamAngle(${args.track_index}, ${args.time}, ${args.angle_index});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        flatten_multicam: {
+            description: "Flatten a multicam sequence into a regular single-camera sequence. This bakes all the camera switches.",
+            parameters: {
+                type: "object",
+                properties: {
+                    sequence_index: { type: "number", description: "Index of the multicam sequence to flatten (0-based, from project sequences list)" },
+                },
+                required: ["sequence_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = flattenMulticam(${args.sequence_index});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_multicam_angles: {
+            description: "Get the list of available camera angles for a multicam clip on the timeline.",
+            parameters: {
+                type: "object",
+                properties: {
+                    track_index: { type: "number", description: "Video track index containing the multicam clip (0-based)" },
+                    clip_index: { type: "number", description: "Clip index on the track (0-based)" },
+                },
+                required: ["track_index", "clip_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = getMulticamAngles(${args.track_index}, ${args.clip_index});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        create_proxy: {
+            description: "Create a proxy file for a project item using a specified encoding preset. Proxies enable low-res editing with high-res final output.",
+            parameters: {
+                type: "object",
+                properties: {
+                    project_item_index: { type: "number", description: "Project item index (0-based, from root item children)" },
+                    preset_path: { type: "string", description: "Path to the encoding preset file for proxy creation" },
+                },
+                required: ["project_item_index", "preset_path"],
+            },
+            handler: async (args) => {
+                const presetPathEsc = args.preset_path.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+                const script = buildToolScript(`
+          var result = createProxy(${args.project_item_index}, "${presetPathEsc}");
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        attach_proxy: {
+            description: "Attach an existing proxy file to a project item.",
+            parameters: {
+                type: "object",
+                properties: {
+                    project_item_index: { type: "number", description: "Project item index (0-based, from root item children)" },
+                    proxy_path: { type: "string", description: "Full path to the proxy media file" },
+                },
+                required: ["project_item_index", "proxy_path"],
+            },
+            handler: async (args) => {
+                const proxyPathEsc = args.proxy_path.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+                const script = buildToolScript(`
+          var result = attachProxy(${args.project_item_index}, "${proxyPathEsc}");
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        has_proxy: {
+            description: "Check if a project item has a proxy attached.",
+            parameters: {
+                type: "object",
+                properties: {
+                    project_item_index: { type: "number", description: "Project item index (0-based, from root item children)" },
+                },
+                required: ["project_item_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = hasProxy(${args.project_item_index});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        get_proxy_path: {
+            description: "Get the file path of the proxy attached to a project item.",
+            parameters: {
+                type: "object",
+                properties: {
+                    project_item_index: { type: "number", description: "Project item index (0-based, from root item children)" },
+                },
+                required: ["project_item_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = getProxyPath(${args.project_item_index});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        toggle_proxies: {
+            description: "Enable or disable proxy playback for the entire project.",
+            parameters: {
+                type: "object",
+                properties: {
+                    enabled: { type: "boolean", description: "True to enable proxy playback, false to use original media" },
+                },
+                required: ["enabled"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = toggleProxies(${args.enabled});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+        detach_proxy: {
+            description: "Detach/remove the proxy from a project item (reverts to original media).",
+            parameters: {
+                type: "object",
+                properties: {
+                    project_item_index: { type: "number", description: "Project item index (0-based, from root item children)" },
+                },
+                required: ["project_item_index"],
+            },
+            handler: async (args) => {
+                const script = buildToolScript(`
+          var result = detachProxy(${args.project_item_index});
+          var parsed = JSON.parse(result);
+          if (!parsed.success) return __error(parsed.error);
+          return __result(parsed.data);
+        `);
+                return sendCommand(script, bridgeOptions);
+            },
+        },
+    };
+}
+//# sourceMappingURL=multicam.js.map