@synthetic-ai/premiere-mcp 2.0.0

package/cep-plugin/main.js

@@ -0,0 +1,327 @@
+/* MCP Bridge - CEP Plugin Main Script
+ * Polls a temp directory for command files (.jsx), executes them
+ * in Premiere Pro's ExtendScript engine, and writes results back.
+ *
+ * Improvements over the original:
+ *  - isRunning flag guards the poll loop so concurrent executions can't pile up.
+ *  - executeScript wraps cs.evalScript with a 25-second timeout to prevent hangs.
+ *  - Status indicator updates on every state change (idle / running / error).
+ *  - Reconnect logic: if Premiere Pro is unresponsive, the bridge backs off and retries. */
+
+var cs = new CSInterface();
+var bridgeRunning = false;
+var isRunning = false;   // true while a script is actively executing (prevents concurrent runs)
+var pollInterval = null;
+var commandCount = 0;
+var errorCount = 0;
+var consecutiveErrors = 0;
+var tempDir = "";
+var POLL_MS = 200;
+var EXEC_TIMEOUT_MS = 25000; // 25-second hard timeout for ExtendScript execution
+
+// ---- Logging ----
+function log(msg, cls) {
+  var el = document.getElementById("log");
+  var entry = document.createElement("div");
+  entry.className = "log-entry " + (cls || "");
+  var ts = new Date().toLocaleTimeString();
+  entry.textContent = "[" + ts + "] " + msg;
+  el.appendChild(entry);
+  el.scrollTop = el.scrollHeight;
+  // Keep max 100 entries
+  while (el.children.length > 100) el.removeChild(el.firstChild);
+}
+
+// ---- Status ----
+function setStatus(state, text) {
+  var dot = document.getElementById("statusDot");
+  dot.className = "status-dot " + state;
+  document.getElementById("statusText").textContent = text;
+
+  // Mirror the same state onto the small dot inside the product block, so the
+  // "is the panel OK?" cue is visible up-top without scanning the status row.
+  // Map: connected -> ok, warning -> warn, error -> err, waiting/* -> grey.
+  var ps = document.getElementById("productStatus");
+  if (ps) {
+    ps.className = "product-status" +
+      (state === "connected" ? " ok" :
+       state === "warning"   ? " warn" :
+       state === "error"     ? " err" : "");
+    ps.title = text || "Panel ready";
+  }
+}
+
+// ---- File I/O via Node.js (CEP has access to Node) ----
+var fs = require("fs");
+var path = require("path");
+var os = require("os");
+tempDir = path.join(os.tmpdir(), "premiere-mcp-bridge");
+
+function ensureDir(dir) {
+  try {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+  } catch (e) {
+    log("Error creating dir: " + e.message, "err");
+  }
+}
+
+function listCommandFiles() {
+  try {
+    if (!fs.existsSync(tempDir)) return [];
+    var files = fs.readdirSync(tempDir);
+    return files
+      .filter(function (f) { return f.indexOf("cmd_") === 0 && f.indexOf(".jsx") > 0; })
+      .sort(); // process in order
+  } catch (e) {
+    return [];
+  }
+}
+
+function readFile(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf-8");
+  } catch (e) {
+    return null;
+  }
+}
+
+function writeFile(filePath, content) {
+  try {
+    // Atomic write: write to a temp file the MCP server's poller ignores
+    // (it waits for the exact res_<id>.json name), then rename into place.
+    // Prevents the server from reading a half-written response file.
+    var tmpPath = filePath + ".part";
+    fs.writeFileSync(tmpPath, content, "utf-8");
+    fs.renameSync(tmpPath, filePath);
+    return true;
+  } catch (e) {
+    log("Error writing " + filePath + ": " + e.message, "err");
+    return false;
+  }
+}
+
+function deleteFile(filePath) {
+  try {
+    if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+  } catch (e) {}
+}
+
+// ---- Script Execution with timeout ----
+function executeScript(script, callback) {
+  // Script is already wrapped in an IIFE by the MCP server's buildScript(),
+  // so we pass it directly to avoid double-wrapping.
+  var timedOut = false;
+  var settled = false;
+
+  var timeoutHandle = setTimeout(function () {
+    if (settled) return;
+    timedOut = true;
+    settled = true;
+    log("Execution timed out after " + (EXEC_TIMEOUT_MS / 1000) + "s", "err");
+    consecutiveErrors++;
+    updateStatusFromErrors();
+    callback(JSON.stringify({ success: false, error: "ExtendScript execution timed out after " + (EXEC_TIMEOUT_MS / 1000) + " seconds. Premiere Pro may be busy or unresponsive." }));
+  }, EXEC_TIMEOUT_MS);
+
+  cs.evalScript(script, function (result) {
+    if (settled) return; // already timed out
+    settled = true;
+    clearTimeout(timeoutHandle);
+    consecutiveErrors = 0; // reset on success
+    callback(result);
+  });
+}
+
+// ---- Update status dot based on error state ----
+function updateStatusFromErrors() {
+  if (!bridgeRunning) return;
+  if (consecutiveErrors >= 3) {
+    setStatus("error", "Running — Premiere Pro unresponsive (" + consecutiveErrors + " errors)");
+  } else if (consecutiveErrors > 0) {
+    setStatus("warning", "Running — " + consecutiveErrors + " consecutive error(s)");
+  } else {
+    setStatus("connected", "Running — " + commandCount + " commands processed");
+  }
+}
+
+// ---- Command Processing ----
+function processCommands() {
+  // Prevent concurrent executions: if a script is still running, skip this poll tick.
+  if (isRunning) return;
+
+  var cmdFiles = listCommandFiles();
+  if (cmdFiles.length === 0) return;
+
+  // Process one command at a time (FIFO). The next tick picks up the next file.
+  isRunning = true;
+  processOneCommand(cmdFiles[0]);
+}
+
+function processOneCommand(cmdFileName) {
+  var cmdFilePath = path.join(tempDir, cmdFileName);
+  var script = readFile(cmdFilePath);
+  if (!script) {
+    log("Failed to read: " + cmdFileName, "err");
+    deleteFile(cmdFilePath);
+    return;
+  }
+
+  // Derive response filename: cmd_12345.jsx -> res_12345.json
+  var id = cmdFileName.replace("cmd_", "").replace(".jsx", "");
+  var resFilePath = path.join(tempDir, "res_" + id + ".json");
+
+  log("Executing: " + cmdFileName + " (" + script.length + " chars)", "cmd");
+
+  // Delete the command file immediately to avoid re-processing
+  deleteFile(cmdFilePath);
+
+  executeScript(script, function (result) {
+    isRunning = false; // release the lock so the next command can be processed
+    commandCount++;
+    document.getElementById("cmdCount").textContent = commandCount;
+
+    var response;
+    try {
+      // ExtendScript returns a string; try to parse it as JSON
+      if (result && result !== "undefined" && result !== "null") {
+        // Check if it's already valid JSON
+        var parsed = JSON.parse(result);
+        response = JSON.stringify(parsed);
+        // If the parsed result contains an error field, count it
+        if (parsed && parsed.success === false) {
+          errorCount++;
+          consecutiveErrors++;
+          log("Result: Error — " + (parsed.error || "unknown"), "err");
+        } else {
+          consecutiveErrors = 0;
+          log("Result: OK", "ok");
+        }
+      } else {
+        response = JSON.stringify({ success: true, data: result || null });
+        consecutiveErrors = 0;
+        log("Result: OK (null/undefined)", "ok");
+      }
+    } catch (e) {
+      // If result isn't JSON, wrap it
+      if (result && result.indexOf("Error") === 0) {
+        response = JSON.stringify({ success: false, error: result });
+        errorCount++;
+        consecutiveErrors++;
+        log("Result: " + result, "err");
+      } else {
+        response = JSON.stringify({ success: true, data: result });
+        consecutiveErrors = 0;
+        log("Result: OK (raw)", "ok");
+      }
+    }
+
+    updateStatusFromErrors();
+    writeFile(resFilePath, response);
+  });
+}
+
+// ---- Bridge Control ----
+function startBridge() {
+  tempDir = document.getElementById("tempDir").value.trim();
+  if (!tempDir) {
+    log("Please set a temp directory", "err");
+    return;
+  }
+
+  ensureDir(tempDir);
+  bridgeRunning = true;
+  setStatus("connected", "Running — polling " + tempDir);
+  log("Bridge started. Temp dir: " + tempDir);
+
+  document.getElementById("btnStart").disabled = true;
+  document.getElementById("btnStop").disabled = false;
+
+  // Verify Premiere Pro connection
+  cs.evalScript("app.version", function (version) {
+    if (version && version !== "undefined") {
+      log("Premiere Pro: " + version, "ok");
+    } else {
+      log("Warning: Could not detect Premiere Pro version", "err");
+    }
+  });
+
+  pollInterval = setInterval(function () {
+    if (bridgeRunning) processCommands();
+  }, POLL_MS);
+}
+
+function stopBridge() {
+  bridgeRunning = false;
+  if (pollInterval) clearInterval(pollInterval);
+  pollInterval = null;
+
+  setStatus("", "Stopped");
+  log("Bridge stopped");
+
+  document.getElementById("btnStart").disabled = false;
+  document.getElementById("btnStop").disabled = true;
+}
+
+function saveTempDir() {
+  tempDir = document.getElementById("tempDir").value.trim();
+  log("Temp directory saved: " + tempDir);
+  // Persist via localStorage
+  try {
+    localStorage.setItem("mcp_bridge_temp_dir", tempDir);
+  } catch (e) {}
+}
+
+// ---- Init ----
+(function init() {
+  // Set the default temp dir in the input field
+  document.getElementById("tempDir").value = tempDir;
+
+  // Load premiere.jsx library (extended function library from AdobePremiereProMCP)
+  cs.evalScript('$.evalFile("' + cs.getSystemPath(SystemPath.EXTENSION) + '/premiere.jsx")', function(result) {
+    log("premiere.jsx loaded: " + (result === "true" || result === "undefined" ? "OK" : result));
+  });
+
+  // Restore saved temp dir
+  try {
+    var saved = localStorage.getItem("mcp_bridge_temp_dir");
+    if (saved) {
+      tempDir = saved;
+      document.getElementById("tempDir").value = tempDir;
+    }
+  } catch (e) {}
+
+  // Wire any element with [data-href] to open the URL in the user's default
+  // browser (CEP intercepts <a href> navigation; we have to bridge through
+  // cep.util.openURLInDefaultBrowser to escape the WebView).
+  function openExternal(url) {
+    try {
+      if (window.cep && cep.util && cep.util.openURLInDefaultBrowser) {
+        cep.util.openURLInDefaultBrowser(url);
+      } else if (window.__adobe_cep__ && window.__adobe_cep__.openURLInDefaultBrowser) {
+        window.__adobe_cep__.openURLInDefaultBrowser(url);
+      } else {
+        window.open(url, "_blank");
+      }
+    } catch (e) { /* swallow — non-fatal */ }
+  }
+  var links = document.querySelectorAll("[data-href]");
+  for (var i = 0; i < links.length; i++) {
+    (function (el) {
+      el.addEventListener("click", function (ev) {
+        ev.preventDefault();
+        openExternal(el.getAttribute("data-href"));
+      });
+    })(links[i]);
+  }
+
+  log("Synthetic Premiere MCP loaded");
+  setStatus("waiting", "Ready — click Start Bridge");
+
+  // Auto-start if temp dir exists
+  if (fs.existsSync(tempDir)) {
+    log("Temp directory exists, auto-starting...");
+    setTimeout(startBridge, 500);
+  }
+})();