@synthetic-ai/premiere-mcp 2.0.0

package/dist/http-server.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+/**
+ * HTTP/SSE transport entry point for remote deployment (e.g. Fly.io).
+ *
+ * The MCP server is identical to the stdio version — only the transport differs.
+ * Clients connect via the MCP Streamable HTTP transport:
+ *   POST /mcp  — send JSON-RPC messages
+ *   GET  /mcp  — open SSE stream
+ *
+ * The bridge still uses the local filesystem temp directory, so the CEP plugin
+ * must be reachable from the same machine OR you must set PREMIERE_TEMP_DIR to
+ * a shared volume mount that the CEP plugin also writes to.
+ *
+ * Environment variables:
+ *   PORT               HTTP port to listen on (default: 3000)
+ *   PREMIERE_TEMP_DIR  Shared temp directory for the file bridge
+ *   PREMIERE_TIMEOUT_MS Command timeout in ms (default: 30000)
+ *   MCP_AUTH_TOKEN     Optional bearer token to require on all requests
+ */
+import http from "node:http";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createServer } from "./server.js";
+import { cleanupTempDir, getTempDir } from "./bridge/file-bridge.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const LANDING_DIR = path.resolve(__dirname, "../landing-dist");
+const MIME = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "application/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".json": "application/json",
+    ".png": "image/png",
+    ".svg": "image/svg+xml",
+    ".ico": "image/x-icon",
+    ".woff2": "font/woff2",
+    ".woff": "font/woff",
+    ".ttf": "font/ttf",
+    ".txt": "text/plain",
+    ".xml": "application/xml",
+};
+function serveLanding(req, res) {
+    if (!fs.existsSync(LANDING_DIR))
+        return false;
+    let urlPath = req.url?.split("?")[0] ?? "/";
+    if (urlPath === "/" || urlPath === "")
+        urlPath = "/index.html";
+    // Next.js trailingSlash: /about/ -> /about/index.html
+    if (urlPath.endsWith("/"))
+        urlPath += "index.html";
+    const filePath = path.join(LANDING_DIR, urlPath);
+    // Security: ensure we stay within LANDING_DIR
+    if (!filePath.startsWith(LANDING_DIR))
+        return false;
+    if (!fs.existsSync(filePath))
+        return false;
+    const ext = path.extname(filePath);
+    const contentType = MIME[ext] ?? "application/octet-stream";
+    res.writeHead(200, { "Content-Type": contentType });
+    fs.createReadStream(filePath).pipe(res);
+    return true;
+}
+const PORT = parseInt(process.env.PORT ?? "3000", 10);
+const AUTH_TOKEN = process.env.MCP_AUTH_TOKEN;
+const bridgeOptions = {
+    tempDir: process.env.PREMIERE_TEMP_DIR,
+    timeoutMs: process.env.PREMIERE_TIMEOUT_MS
+        ? parseInt(process.env.PREMIERE_TIMEOUT_MS, 10)
+        : undefined,
+};
+const tempDir = getTempDir(bridgeOptions);
+console.error(`[premiere-pro-mcp] Starting HTTP server on port ${PORT}...`);
+console.error(`[premiere-pro-mcp] Temp directory: ${tempDir}`);
+cleanupTempDir(bridgeOptions);
+// Each request gets its own transport+server instance (stateless per-request model)
+const httpServer = http.createServer(async (req, res) => {
+    // Health check
+    if (req.method === "GET" && req.url === "/health") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "ok", service: "premiere-pro-mcp" }));
+        return;
+    }
+    // Only handle /mcp endpoint; everything else goes to the landing page
+    if (!req.url?.startsWith("/mcp")) {
+        if (serveLanding(req, res))
+            return;
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+    }
+    // Optional bearer token auth
+    if (AUTH_TOKEN) {
+        const authHeader = req.headers["authorization"] ?? "";
+        const provided = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : "";
+        if (provided !== AUTH_TOKEN) {
+            res.writeHead(401, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Unauthorized" }));
+            return;
+        }
+    }
+    const mcpServer = createServer(bridgeOptions);
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined, // stateless
+    });
+    res.on("close", () => {
+        transport.close().catch(() => { });
+        mcpServer.close().catch(() => { });
+    });
+    try {
+        await mcpServer.connect(transport);
+        await transport.handleRequest(req, res);
+    }
+    catch (err) {
+        console.error("[premiere-pro-mcp] Request error:", err);
+        if (!res.headersSent) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Internal server error" }));
+        }
+    }
+});
+httpServer.listen(PORT, "0.0.0.0", () => {
+    console.error(`[premiere-pro-mcp] HTTP server listening on 0.0.0.0:${PORT}`);
+    console.error(`[premiere-pro-mcp] MCP endpoint: http://0.0.0.0:${PORT}/mcp`);
+    if (AUTH_TOKEN) {
+        console.error(`[premiere-pro-mcp] Auth: Bearer token required`);
+    }
+    else {
+        console.error(`[premiere-pro-mcp] Auth: none (set MCP_AUTH_TOKEN to enable)`);
+    }
+});
+process.on("SIGTERM", () => {
+    console.error("[premiere-pro-mcp] SIGTERM received, shutting down...");
+    httpServer.close(() => process.exit(0));
+});
+process.on("SIGINT", () => {
+    console.error("[premiere-pro-mcp] SIGINT received, shutting down...");
+    httpServer.close(() => process.exit(0));
+});
+//# sourceMappingURL=http-server.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./server.js";
+import { cleanupTempDir, getTempDir } from "./bridge/file-bridge.js";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
+import path from "path";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, "..");
+// Handle CLI flags
+const args = process.argv.slice(2);
+if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+premiere-pro-mcp — MCP server for Adobe Premiere Pro (437 tools)
+
+Usage:
+  premiere-pro-mcp              Start the MCP server (stdio transport)
+  premiere-pro-mcp --install-cep   Install the CEP plugin into Premiere Pro
+  premiere-pro-mcp --help          Show this help message
+  premiere-pro-mcp --version       Show version
+
+Environment variables:
+  PREMIERE_TEMP_DIR     Shared temp directory (default: OS temp + /premiere-mcp-bridge)
+  PREMIERE_TIMEOUT_MS   Command timeout in ms (default: 30000)
+
+More info: https://synthetic.com.ar
+`);
+    process.exit(0);
+}
+if (args.includes("--version") || args.includes("-v")) {
+    const pkg = await import("../package.json", { with: { type: "json" } }).catch(() => ({ default: { version: "unknown" } }));
+    console.log(pkg.default.version);
+    process.exit(0);
+}
+if (args.includes("--install-cep")) {
+    const scriptPath = path.join(projectRoot, "scripts", "install-cep.sh");
+    console.log("Installing CEP plugin...\n");
+    try {
+        execSync(`bash "${scriptPath}"`, { stdio: "inherit", cwd: projectRoot });
+    }
+    catch {
+        console.error("CEP installation failed. Try running manually:");
+        console.error(`  bash "${scriptPath}"`);
+        process.exit(1);
+    }
+    process.exit(0);
+}
+async function main() {
+    const bridgeOptions = {
+        tempDir: process.env.PREMIERE_TEMP_DIR,
+        timeoutMs: process.env.PREMIERE_TIMEOUT_MS
+            ? parseInt(process.env.PREMIERE_TIMEOUT_MS, 10)
+            : undefined,
+    };
+    const tempDir = getTempDir(bridgeOptions);
+    console.error(`[premiere-pro-mcp] Starting MCP server...`);
+    console.error(`[premiere-pro-mcp] Temp directory: ${tempDir}`);
+    // Clean up any stale files from previous sessions
+    cleanupTempDir(bridgeOptions);
+    const server = createServer(bridgeOptions);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`[premiere-pro-mcp] Server connected and ready`);
+}
+main().catch((err) => {
+    console.error("[premiere-pro-mcp] Fatal error:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/resources/extendscript-reference.d.ts

@@ -0,0 +1,2 @@
+export declare const EXTENDSCRIPT_REFERENCE: string;
+//# sourceMappingURL=extendscript-reference.d.ts.map

package/dist/resources/extendscript-reference.js

@@ -0,0 +1,219 @@
+// Premiere Pro ExtendScript API Reference for LLM consumption
+// Exported as a plain string constant
+export const EXTENDSCRIPT_REFERENCE = [
+    "# Premiere Pro ExtendScript API Reference (ES3 Syntax)",
+    "",
+    "## CRITICAL: ES3 Rules",
+    "- Use \"var\" not \"let/const\"",
+    "- No arrow functions: use \"function(x) { return x; }\"",
+    "- No template literals: use string concatenation \"a\" + \"b\"",
+    "- No destructuring: use obj.prop instead of {prop} = obj",
+    "- No for...of: use indexed for loops",
+    "",
+    "## Core Objects",
+    "app.project                    - ProjectBase (the current project)",
+    "app.project.activeSequence     - Sequence (currently active)",
+    "app.project.rootItem           - ProjectItem (root bin)",
+    "app.project.sequences          - SequenceCollection (.numSequences, [i])",
+    "app.version                    - String (Premiere version)",
+    "app.sourceMonitor              - SourceMonitor",
+    "app.encoder                    - Encoder",
+    "",
+    "## Project Methods",
+    "app.project.save()",
+    "app.project.saveAs(path)",
+    "app.project.importFiles(pathsArray, suppressUI, targetBin, asNumberedStills)",
+    "app.project.importAEComps(aepPath, compNamesArray, targetBin)",
+    "app.project.importAllAEComps(aepPath, targetBin)",
+    "app.project.createNewSequence(name, placeholderID)",
+    "app.project.createNewSequenceFromClips(name, clipItemsArray)",
+    "app.project.consolidateDuplicates()",
+    "app.project.addPropertyToProjectMetadataSchema(name, label, type)",
+    "app.project.undo()",
+    "app.newProject(path)",
+    "app.openDocument(path)",
+    "",
+    "## ProjectItem (clips/bins in project panel)",
+    "item.nodeId                    - String (unique identifier)",
+    "item.name                      - String",
+    "item.type                      - Number (1=clip/file, 2=bin, 3=root, 4=file)",
+    "item.treePath                  - String",
+    "item.children                  - ProjectItemCollection (.numItems, [i])",
+    "item.getMediaPath()            - String (file path on disk)",
+    "item.changeMediaPath(newPath, overrideChecks)",
+    "item.refreshMedia()",
+    "item.moveBin(targetBin)",
+    "item.deleteBin()",
+    "item.renameBin(newName)",
+    "item.createBin(name)           - ProjectItem (new bin)",
+    "item.createSmartBin(name, query)",
+    "item.createSubClip(name, startTicks, endTicks, hasHardBoundaries, takeVideo, takeAudio)",
+    "item.setInPoint(ticks, mediaType)",
+    "item.setOutPoint(ticks, mediaType)",
+    "item.getInPoint(mediaType)     - Time",
+    "item.getOutPoint(mediaType)    - Time",
+    "item.setOverridePixelAspectRatio(num, den)",
+    "item.setOverrideFrameRate(fps)",
+    "item.attachProxy(mediaPath, isHiRes)",
+    "item.findItemsMatchingMediaPath(pathQuery)  - Array",
+    "item.canChangeMediaPath()      - Boolean",
+    "item.isOffline()               - Boolean",
+    "item.setStartTime(ticks)",
+    "item.setColorLabel(colorIndex)  - 0-15",
+    "item.getColorLabel()           - Number",
+    "item.getProjectMetadata()      - String (XML)",
+    "item.setProjectMetadata(xmlStr, fieldPath)",
+    "",
+    "## Sequence",
+    "seq.name                       - String",
+    "seq.sequenceID                 - String",
+    "seq.videoTracks                - TrackCollection (.numTracks, [i])",
+    "seq.audioTracks                - TrackCollection (.numTracks, [i])",
+    "seq.markers                    - MarkerCollection",
+    "seq.end                        - String (ticks)",
+    "seq.frameSizeHorizontal        - Number",
+    "seq.frameSizeVertical          - Number",
+    "",
+    "seq.insertClip(projectItem, startTicks, vidTrackIdx, audioTrackIdx)",
+    "seq.overwriteClip(projectItem, startTicks, vidTrackIdx, audioTrackIdx)",
+    "seq.getPlayerPosition()        - Time",
+    "seq.setPlayerPosition(ticks)",
+    "seq.setInPoint(ticks)",
+    "seq.setOutPoint(ticks)",
+    "seq.getInPoint()               - String (ticks)",
+    "seq.getOutPoint()              - String (ticks)",
+    "seq.setWorkAreaInPoint(ticks)",
+    "seq.setWorkAreaOutPoint(ticks)",
+    "seq.setZeroPoint(ticks)",
+    "seq.close()",
+    "seq.clone()                    - Sequence",
+    "seq.linkSelection()",
+    "seq.unlinkSelection()",
+    "seq.getSelection()             - Array of TrackItems",
+    "seq.exportAsProject(path)",
+    "seq.exportAsFinalCutProXML(path, suppressUI)",
+    "seq.exportAsMediaDirect(outputPath, presetPath, workAreaType)",
+    "seq.getExportFileExtension(presetPath)",
+    "seq.autoReframeSequence(numerator, denominator, motionPreset, newName, useNestedSequences)",
+    "seq.performSceneEditDetectionOnSelection()",
+    "seq.createSubsequence(selectionOnly)",
+    "seq.addTracks(videoTracksToAdd, audioTracksToAdd)",
+    "",
+    "## Track",
+    "track.name                     - String",
+    "track.clips                    - ClipCollection (.numItems, [i])",
+    "track.transitions              - TransitionCollection (.numItems, [i])",
+    "track.isMuted()                - Boolean",
+    "track.setMute(muted)",
+    "track.isLocked()               - Boolean",
+    "track.setLocked(locked)",
+    "track.isTargeted()             - Boolean",
+    "track.setTargeted(targeted, isVideo)",
+    "track.overwriteClip(projectItem, position)",
+    "track.insertClip(projectItem, position)",
+    "",
+    "## TrackItem (clip on timeline)",
+    "clip.nodeId                    - String",
+    "clip.name                      - String",
+    "clip.start                     - Time (.ticks, .seconds)",
+    "clip.end                       - Time",
+    "clip.duration                  - Time",
+    "clip.inPoint                   - Time (source in)",
+    "clip.outPoint                  - Time (source out)",
+    "clip.mediaType                 - String (\"Video\"/\"Audio\")",
+    "clip.type                      - Number (1=clip, 2=transition)",
+    "clip.projectItem               - ProjectItem (source)",
+    "clip.components                - ComponentCollection (.numItems, [i])",
+    "",
+    "clip.remove(ripple, alignToVideo)",
+    "clip.setSelected(selected, updateUI)",
+    "clip.isSelected()              - Boolean",
+    "clip.setDisabled(disabled)",
+    "clip.isDisabled()              - Boolean",
+    "clip.getSpeed()                - Number",
+    "clip.isSpeedReversed()         - Boolean",
+    "clip.isAdjustmentLayer()       - Boolean",
+    "",
+    "## Component (effects on clips)",
+    "comp.displayName               - String",
+    "comp.matchName                 - String",
+    "comp.properties                - PropertyCollection (.numItems, [i])",
+    "comp.remove()",
+    "",
+    "## Property (effect parameters)",
+    "prop.displayName               - String",
+    "prop.matchName                 - String",
+    "prop.getValue(updateUI, time)",
+    "prop.setValue(value, updateUI)",
+    "prop.isTimeVarying()           - Boolean",
+    "prop.setTimeVarying(enabled)",
+    "prop.areKeyframesSupported()   - Boolean",
+    "prop.getKeys()                 - Array of Time",
+    "prop.addKey(time)",
+    "prop.removeKey(time)",
+    "prop.removeKeyRange(startTime, endTime)",
+    "prop.getValueAtKey(time)",
+    "prop.setValueAtKey(time, value, updateUI)",
+    "prop.setInterpolationTypeAtKey(time, interpType, updateUI)",
+    "prop.getValueAtTime(time)",
+    "",
+    "## Marker",
+    "marker.name                    - String",
+    "marker.comments                - String",
+    "marker.start                   - Time",
+    "marker.end                     - Time",
+    "marker.type                    - String",
+    "marker.createMarker(seconds)   - Marker",
+    "marker.deleteMarker(marker)",
+    "",
+    "## Time Object",
+    "var t = new Time();",
+    "t.ticks = \"254016000000\";     - set time in ticks (string)",
+    "t.seconds = 1.0;             - set time in seconds",
+    "t.ticks                       - get ticks (string)",
+    "",
+    "## QE DOM (call app.enableQE() first!)",
+    "qe.project.getActiveSequence()",
+    "qe.project.getVideoEffectList()       - .numItems, [i].name",
+    "qe.project.getAudioEffectList()       - .numItems, [i].name",
+    "qe.project.getVideoTransitionList()   - .numItems, [i].name",
+    "qe.project.getAudioTransitionList()   - .numItems, [i].name",
+    "qe.project.getVideoEffectByName(name) - QEEffect",
+    "",
+    "qeSeq.getVideoTrackAt(index)          - QETrack",
+    "qeSeq.getAudioTrackAt(index)          - QETrack",
+    "qeTrack.getItemAt(index)              - QEClip",
+    "qeTrack.razor(tickString)             - split at position",
+    "",
+    "qeClip.addVideoEffect(qeEffect)",
+    "qeClip.addAudioEffect(qeEffect)",
+    "qeClip.addTransition(qeTransition, forceSingle, durationTicks, endPercent, alignment)",
+    "qeClip.removeEffects()",
+    "qeClip.rippleDelete()",
+    "qeClip.roll(offsetTicks)",
+    "qeClip.slide(offsetTicks)",
+    "qeClip.slip(offsetTicks)",
+    "qeClip.setSpeed(percent)              - e.g., 200 for 2x",
+    "qeClip.setReverse(bool)",
+    "qeClip.setFrameBlend(bool)",
+    "qeClip.setTimeInterpolationType(type) - 0=sampling, 1=blending, 2=optical flow",
+    "qeClip.setName(name)",
+    "qeClip.moveToTrack(trackIndex)",
+    "",
+    "## Constants",
+    "TICKS_PER_SECOND = 254016000000",
+    "",
+    "## Common Effect Match Names",
+    "\"AE.ADBE Motion\"           - Motion (Position, Scale, Rotation)",
+    "\"AE.ADBE Opacity\"          - Opacity",
+    "\"AE.ADBE Gaussian Blur 2\"  - Gaussian Blur",
+    "\"AE.ADBE Black & White\"    - Black & White",
+    "\"AE.ADBE Tint\"             - Tint",
+    "\"AE.ADBE Motion Blur\"      - Motion Blur",
+    "",
+    "## Keyframe Interpolation Types",
+    "KF_Interp_Mode_Linear = 0",
+    "KF_Interp_Mode_Hold = 4",
+    "KF_Interp_Mode_Bezier = 5",
+].join("\n");
+//# sourceMappingURL=extendscript-reference.js.map

package/dist/server.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BridgeOptions } from "./bridge/file-bridge.js";
+export declare function createServer(bridgeOptions: BridgeOptions): McpServer;
+//# sourceMappingURL=server.d.ts.map