@synthetic-ai/premiere-mcp 1.1.8

package/cep-plugin/main.js

@@ -0,0 +1,683 @@
+/* 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
+var PANEL_VERSION = "1.1.6"; // stamped by scripts/package.mjs on every build — see step 4b2
+
+// ── Auto-update config ────────────────────────────────────────────────────
+// The panel checks this URL at startup and offers in-app updates when a
+// newer version is published. Files come back through /api/v1/panel/file
+// gated by the user's license key. Self-installs only the hot-swappable
+// JS/JSX/HTML files — manifest changes still need a fresh .zxp.
+//
+// Ported from Synthetic AE MCP's cep-plugin/main.js (checkForUpdates /
+// showUpdateBanner / applyUpdate). One deliberate difference: AE MCP's Node
+// server SPAWNS AfterFX.exe, so AE_MCP_LICENSE (set in the MCP client config)
+// is inherited by the child process and read via $.getenv() inside
+// ExtendScript. Premiere MCP's Node server does NOT spawn Premiere Pro — it
+// talks to the already-running CEP panel as an HTTP client — so there is no
+// env-var-inheritance path. Instead the license key is pasted into this
+// panel's own Settings field and persisted to a local license.json (see
+// readLicenseKeyLocal / saveLicenseKey below).
+var UPDATE_CHECK_URL = "https://synthetic.com.ar/api/v1/panel/version";
+var UPDATE_FILE_URL  = "https://synthetic.com.ar/api/v1/panel/file";
+var UPDATE_PRODUCT = "premiere-mcp";
+var pendingUpdate = null;
+var lastDismissedVersion = null;
+
+// ---- 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) {}
+}
+
+// cs.getSystemPath() returns a file:// URI, not a plain OS path — observed
+// on Windows as "file:\C:\Users\..." (single backslash, not the POSIX
+// "file:///C:/..."). Passing that straight to fs/path calls tries to
+// create/read a path actually named "file:\C:\Users\...", which fails with
+// ENOENT since its own parent doesn't exist. Strip whatever "file:" prefix
+// shows up and URL-decode any %xx escapes before treating it as a path.
+function systemPathToFsPath(p) {
+  var m = /^file:[\\/]*/i.exec(p || "");
+  if (m) p = p.slice(m[0].length);
+  try { p = decodeURIComponent(p); } catch (e) {}
+  return p;
+}
+
+// ---- License key storage (local file, no env-var inheritance path) ------
+// Premiere Pro is already running when this panel loads — the MCP server
+// never spawns it — so there's no child-process env var to read the license
+// key from (unlike AE MCP's AE_MCP_LICENSE). Instead the user pastes the key
+// into the Settings field below and it's persisted next to the extension.
+function getLicensePath() {
+  try {
+    return path.join(systemPathToFsPath(cs.getSystemPath(SystemPath.EXTENSION)), "license.json");
+  } catch (e) {
+    return null;
+  }
+}
+
+function readLicenseKeyLocal() {
+  try {
+    var p = getLicensePath();
+    if (!p || !fs.existsSync(p)) return "";
+    var raw = fs.readFileSync(p, "utf-8");
+    var parsed = JSON.parse(raw);
+    return (parsed && parsed.licenseKey) ? String(parsed.licenseKey).trim() : "";
+  } catch (e) {
+    return "";
+  }
+}
+
+function writeLicenseKeyLocal(key) {
+  var p = getLicensePath();
+  if (!p) return false;
+  try {
+    fs.writeFileSync(p, JSON.stringify({ licenseKey: key }, null, 2), "utf-8");
+    return true;
+  } catch (e) {
+    log("Error saving license key: " + e.message, "err");
+    return false;
+  }
+}
+
+// Settings UI: load saved key into the input + status line on panel init.
+function loadLicenseUI() {
+  try {
+    var key = readLicenseKeyLocal();
+    var input = document.getElementById("licenseKeyInput");
+    if (input) input.value = key;
+    var statusEl = document.getElementById("licenseStatus");
+    if (statusEl) statusEl.textContent = key ? "License key saved." : "No license key saved yet — required for updates.";
+  } catch (e) {}
+}
+
+// Settings UI: Save button handler.
+function saveLicenseKey() {
+  var input = document.getElementById("licenseKeyInput");
+  var key = input ? input.value.trim() : "";
+  var statusEl = document.getElementById("licenseStatus");
+  if (!key) {
+    if (statusEl) statusEl.textContent = "Enter a license key before saving.";
+    return;
+  }
+  if (writeLicenseKeyLocal(key)) {
+    log("License key saved.", "ok");
+    if (statusEl) statusEl.textContent = "License key saved.";
+  } else if (statusEl) {
+    statusEl.textContent = "Failed to save license key (see log).";
+  }
+}
+
+// Settings is just the license field for now — no need for AE Agent's full
+// Subscription/API Keys/Data section system. Hidden by default so the key
+// isn't sitting in plain view on the main panel; click the ⚙ to reveal it.
+function toggleSettings() {
+  var panel = document.getElementById("settingsPanel");
+  if (!panel) return;
+  panel.style.display = panel.style.display === "none" ? "block" : "none";
+}
+
+// ---- 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);
+    isRunning = false; // release the lock — AE MCP's sibling file already does this;
+                        // without it a single transient read failure (e.g. a race with
+                        // the writer) wedges the bridge forever: isRunning stays true,
+                        // so every future processCommands() tick bails at its first
+                        // check and the panel looks "Running" while doing nothing.
+                        // Reproduced live 2026-09-23.
+    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);
+  });
+}
+
+// ---- Auto-update --------------------------------------------------------
+// Ported verbatim (logic-wise) from Synthetic AE MCP's cep-plugin/main.js.
+// Compare two semver strings (x.y.z). Returns 1 if a > b, -1 if a < b, 0 if =.
+// Hand-rolled because ExtendScript / CEP-Node don't ship semver.
+function semverCmp(a, b) {
+  var pa = String(a || "0.0.0").split(".").map(function (n) { return parseInt(n, 10) || 0; });
+  var pb = String(b || "0.0.0").split(".").map(function (n) { return parseInt(n, 10) || 0; });
+  for (var i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+  }
+  return 0;
+}
+
+// One-shot https GET that buffers the response into a string. CEP ships
+// the Node 'https' module already.
+function httpsGetJson(url, cb) {
+  try {
+    var https = require("https");
+    https.get(url, function (res) {
+      var chunks = [];
+      // Follow one redirect. Our own /api/v1/panel/file endpoint 302s to R2
+      // (Supabase signed URLs went through 302 too), but Next's
+      // NextResponse.redirect() defaults to 307 — handle the whole 3xx
+      // range so this doesn't silently break again on a framework default.
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        return httpsGetJson(res.headers.location, cb);
+      }
+      res.on("data", function (c) { chunks.push(c); });
+      res.on("end", function () {
+        var body = Buffer.concat(chunks).toString("utf-8");
+        if (res.statusCode !== 200) {
+          return cb(new Error("HTTP " + res.statusCode + ": " + body.slice(0, 200)));
+        }
+        try { cb(null, JSON.parse(body)); }
+        catch (e) { cb(new Error("Bad JSON: " + e.message)); }
+      });
+    }).on("error", function (err) { cb(err); });
+  } catch (e) { cb(e); }
+}
+
+// Download a single file as a Buffer. Follows one redirect.
+function httpsDownload(url, cb) {
+  try {
+    var https = require("https");
+    https.get(url, function (res) {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        return httpsDownload(res.headers.location, cb);
+      }
+      if (res.statusCode !== 200) {
+        return cb(new Error("HTTP " + res.statusCode));
+      }
+      var chunks = [];
+      res.on("data", function (c) { chunks.push(c); });
+      res.on("end", function () { cb(null, Buffer.concat(chunks)); });
+    }).on("error", function (err) { cb(err); });
+  } catch (e) { cb(e); }
+}
+
+// SHA256 of a Buffer using Node's crypto. Used to verify integrity of
+// downloaded files before overwriting the panel's own code.
+function sha256(buf) {
+  var crypto = require("crypto");
+  return crypto.createHash("sha256").update(buf).digest("hex");
+}
+
+// On panel startup. Fetches the manifest, compares versions, surfaces a
+// banner if newer. Never throws — if anything goes wrong we silently skip
+// the check so the panel still starts cleanly even offline.
+function checkForUpdates() {
+  try {
+    var url = UPDATE_CHECK_URL + "?product=" + encodeURIComponent(UPDATE_PRODUCT) +
+      "&from=" + encodeURIComponent(PANEL_VERSION);
+    httpsGetJson(url, function (err, manifest) {
+      if (err || !manifest || !manifest.version) return;
+      if (semverCmp(manifest.version, PANEL_VERSION) <= 0) return;
+      if (lastDismissedVersion === manifest.version) return;
+      pendingUpdate = manifest;
+      showUpdateBanner(manifest);
+    });
+  } catch (_) {}
+}
+
+function showUpdateBanner(m) {
+  var banner = document.getElementById("updateBanner");
+  if (!banner) return;
+  document.getElementById("updateVersionTag").textContent = "v" + PANEL_VERSION + " -> v" + m.version;
+  var notes = Array.isArray(m.releaseNotes) ? m.releaseNotes.slice(0, 3).join("\n") : "";
+  document.getElementById("updateNotes").textContent = notes;
+  banner.style.display = "block";
+}
+
+function dismissUpdate() {
+  if (pendingUpdate) lastDismissedVersion = pendingUpdate.version;
+  pendingUpdate = null;
+  var banner = document.getElementById("updateBanner");
+  if (banner) banner.style.display = "none";
+}
+
+function openInstaller() {
+  try {
+    if (window.cep && cep.util && cep.util.openURLInDefaultBrowser) {
+      cep.util.openURLInDefaultBrowser("https://synthetic.com.ar/dashboard/downloads");
+    }
+  } catch (_) {}
+}
+
+// Apply the update: for each file in the manifest, download via the
+// license-gated endpoint, verify SHA256, back up the current file to
+// .bak, write the new one. If ANY file fails verification, roll back all
+// of them — never leave the panel in a half-updated state.
+function applyUpdate() {
+  if (!pendingUpdate || !Array.isArray(pendingUpdate.files)) {
+    log("No update to apply", "err");
+    return;
+  }
+  var btn = document.getElementById("btnUpdateNow");
+  if (btn) { btn.disabled = true; btn.textContent = "Updating..."; }
+
+  var licenseKey = readLicenseKeyLocal();
+  if (!licenseKey) {
+    log("Update failed: no license key saved. Open Settings and paste your Premiere MCP license key.", "err");
+    var statusEl = document.getElementById("licenseStatus");
+    if (statusEl) statusEl.textContent = "License key required before updating.";
+    if (btn) { btn.disabled = false; btn.textContent = "Update now"; }
+    return;
+  }
+
+  // CEP can ask its own extension folder via cs.getSystemPath.
+  var extDir = systemPathToFsPath(cs.getSystemPath(SystemPath.EXTENSION));
+  var files = pendingUpdate.files;
+  var version = pendingUpdate.version;
+  var staged = []; // {targetPath, backupPath, buf}
+  var i = 0;
+
+  function fetchNext() {
+    if (i >= files.length) { commit(); return; }
+    var f = files[i++];
+    var url = UPDATE_FILE_URL +
+      "?product=" + encodeURIComponent(UPDATE_PRODUCT) +
+      "&name=" + encodeURIComponent(f.name) +
+      "&licenseKey=" + encodeURIComponent(licenseKey) +
+      "&version=" + encodeURIComponent(version);
+    log("Downloading " + f.name + "...");
+    httpsDownload(url, function (err, buf) {
+      if (err) return abort("Download failed for " + f.name + ": " + err.message);
+      // Optional SHA256 check — only enforced if the manifest provides one.
+      if (f.sha256 && f.sha256.length === 64) {
+        var got = sha256(buf);
+        if (got !== f.sha256) return abort("SHA256 mismatch for " + f.name + " (got " + got.slice(0, 12) + "..., expected " + f.sha256.slice(0, 12) + "...)");
+      }
+      // Optional size sanity check.
+      if (f.size && Math.abs(buf.length - f.size) > 1024) {
+        log("Size differs from manifest for " + f.name + " (" + buf.length + " vs " + f.size + ") — continuing", "");
+      }
+      var target = path.join(extDir, f.name);
+      // The "CSXS" subfolder gets resolved separately; everything in our
+      // panel lives at the extension root, so a flat join is correct.
+      staged.push({ target: target, backup: target + ".bak", buf: buf });
+      fetchNext();
+    });
+  }
+
+  function commit() {
+    try {
+      // Phase 1: backup. If any backup write fails, abort before touching real files.
+      for (var k = 0; k < staged.length; k++) {
+        var s = staged[k];
+        if (fs.existsSync(s.target)) {
+          // Best effort — rename can fail if source is locked; copy as fallback.
+          try { fs.copyFileSync(s.target, s.backup); }
+          catch (eCopy) { return abort("Backup failed for " + s.target + ": " + eCopy.message); }
+        }
+      }
+      // Phase 2: write new files.
+      for (var j = 0; j < staged.length; j++) {
+        var ss = staged[j];
+        var tmpPath = ss.target + ".new";
+        fs.writeFileSync(tmpPath, ss.buf);
+        // Replace via rename so the swap is atomic per-file.
+        if (fs.existsSync(ss.target)) fs.unlinkSync(ss.target);
+        fs.renameSync(tmpPath, ss.target);
+      }
+      log("Update v" + version + " applied. RESTART PREMIERE PRO to load the new panel.", "ok");
+      setStatus("warning", "Update applied — restart Premiere Pro");
+      var b = document.getElementById("updateBanner");
+      if (b) {
+        b.style.background = "rgba(40,180,120,0.10)";
+        b.style.borderColor = "#28b478";
+        document.getElementById("updateNotes").innerHTML =
+          "<strong style='color:#9af3c4'>Update applied.</strong> Close and reopen Premiere Pro to activate v" + version + ".";
+        var bt = document.getElementById("btnUpdateNow");
+        if (bt) { bt.style.display = "none"; }
+        var bt2 = document.getElementById("btnUpdateLater");
+        if (bt2) bt2.textContent = "OK";
+        var bt3 = document.getElementById("btnUpdateInstaller");
+        if (bt3) bt3.style.display = "none";
+      }
+    } catch (eCommit) {
+      // Rollback: restore any .bak we wrote.
+      for (var r = 0; r < staged.length; r++) {
+        try {
+          var rs = staged[r];
+          if (fs.existsSync(rs.backup)) {
+            if (fs.existsSync(rs.target)) fs.unlinkSync(rs.target);
+            fs.renameSync(rs.backup, rs.target);
+          }
+        } catch (_) {}
+      }
+      abort("Commit failed (rolled back): " + eCommit.message);
+    }
+  }
+
+  function abort(msg) {
+    log("Update aborted: " + msg, "err");
+    if (btn) { btn.disabled = false; btn.textContent = "Update now"; }
+    setStatus("error", "Update failed");
+    return;
+  }
+
+  fetchNext();
+}
+
+// ---- 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() {
+  // ORDERING RULE (ported from AE MCP): schedule the auto-update check
+  // FIRST, before any statement that could throw, so a future regression
+  // elsewhere in init() can't strand users on a buggy version with no way
+  // to receive the fix from the panel itself.
+  try {
+    setTimeout(checkForUpdates, 500);
+  } catch (e) {
+    try { console.error("[panel init] scheduling auto-update failed:", e); } catch (_) {}
+  }
+
+  // Set the default temp dir in the input field
+  document.getElementById("tempDir").value = tempDir;
+
+  // Populate the Settings license field from local storage.
+  try { loadLicenseUI(); } catch (e) {}
+
+  // Load premiere.jsx library (extended function library from AdobePremiereProMCP).
+  // Same file:// URI cleanup as getLicensePath()/applyUpdate() — wasn't the
+  // cause of the "EvalScript error." bug (that was premiere.jsx's own
+  // obfuscation, see scripts/package.mjs), but a raw file:// URI here is
+  // still wrong on principle, so clean it the same way everywhere.
+  var premiereJsxPath = systemPathToFsPath(cs.getSystemPath(SystemPath.EXTENSION)).replace(/\\/g, "/");
+  cs.evalScript('$.evalFile("' + premiereJsxPath + '/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);
+  }
+})();