premiere-pro-mcp 1.1.0 → 1.1.2

package/CHANGELOG.md

@@ -4,6 +4,70 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [1.1.2] - 2026-07-11
+
+The headline of this release is that the CEP 12 bridge fix from
+[#1](https://github.com/leancoderkavy/premiere-pro-mcp/pull/1) finally ships to npm. It has been on
+`main` since March but was never published, so everyone who installed with `npm install -g` still
+got a bridge that returned `null` for every tool call. If that was your symptom, upgrading is the
+whole fix.
+
+### Fixed
+
+- **The bridge returns data again on Premiere Pro 2023+ / CEP 12.** The published `CSInterface.js`
+  shim called `__adobe_cep__.evalScript(script)` without forwarding the callback. CEP 9+ is
+  async-only, so every result was silently discarded and every tool answered
+  `{"success":true,"data":null}` while the panel cheerfully logged "Result: OK". The manifest was
+  also missing `--enable-nodejs`, leaving `require("fs")` undefined in the panel.
+  ([#2](https://github.com/leancoderkavy/premiere-pro-mcp/issues/2),
+  [#5](https://github.com/leancoderkavy/premiere-pro-mcp/issues/5),
+  [#8](https://github.com/leancoderkavy/premiere-pro-mcp/issues/8))
+
+- **Markers landed at wildly wrong times.** `createMarker()` takes seconds, but was being handed
+  ticks — a marker requested at 2.0s was placed roughly 508 billion seconds down the timeline,
+  far past the end of any real sequence. `marker.end` had the same bug, and `list_markers` read
+  back nonsense as a result. ([#6](https://github.com/leancoderkavy/premiere-pro-mcp/issues/6))
+
+- **`manage_proxies` and `get_encoder_presets` called ExtendScript methods that do not exist.**
+  `ProjectItem` has no `createProxy()` and `EncoderManager` has no `getFormatList()`, so both threw
+  every time. `manage_proxies` with `action: "create"` now queues a real proxy encode through Media
+  Encoder instead of reporting "Proxy creation started" for work that never happened, and
+  `get_encoder_presets` discovers presets by scanning the `.epr` files Adobe ships on disk, returning
+  each preset's path so it can be passed straight to `export_sequence`.
+  ([#7](https://github.com/leancoderkavy/premiere-pro-mcp/issues/7))
+
+- **`capture_frame`, `export_frame`, and `freeze_frame` threw on every call.** `exportFramePNG`
+  exists only on the QE DOM sequence, not the public DOM one. These tools now go through the QE
+  sequence, and — because QE's return value is unreliable — decide success by checking that a file
+  actually exists on disk, falling back to a one-frame Media Encoder export. They can no longer
+  report success having written nothing.
+  ([#9](https://github.com/leancoderkavy/premiere-pro-mcp/issues/9))
+
+- **Six tools repaired for Premiere Pro 2026** via
+  [#3](https://github.com/leancoderkavy/premiere-pro-mcp/pull/3): `add_audio_keyframes` (used a
+  nonexistent `Property.addKeyframe`, and wrote dB into a property that stores amplitude),
+  `color_correct` (one unsettable Lumetri property aborted the whole script and lost every other
+  change), `add_transition` and friends (`getVideoTransitionList()` returns empty on 2026 even
+  though by-name lookup works), `add_adjustment_layer` (`qeSeq.addAdjustmentLayer` was removed in
+  2026), `export_sequence` (defaulted to a hardcoded macOS-only preset path), and `add_text_overlay`
+  (called `createCaptionTrack` with the wrong signature).
+
+- `manage_proxies` with `action: "toggle"` reported the inverse of the state it had just set.
+
+- The README described this repository as "a temporary fork" of itself — a fork banner that rode in
+  with the [#1](https://github.com/leancoderkavy/premiere-pro-mcp/pull/1) merge.
+
+### Notes
+
+- The frame-export and proxy-create paths are fixed against the documented API and covered by
+  regression tests, but have not yet been live-verified against a running Premiere Pro. If you can
+  test them, reports on
+  [#7](https://github.com/leancoderkavy/premiere-pro-mcp/issues/7) and
+  [#9](https://github.com/leancoderkavy/premiere-pro-mcp/issues/9) are very welcome.
+- Windows users on CEP 12 may additionally need to sign the extension (`ZXPSignCmd -sign`) — see
+  [#2](https://github.com/leancoderkavy/premiere-pro-mcp/issues/2) for details. That is an Adobe
+  signature-verification requirement, not a bug in this package.
+
 ## [1.0.0] - 2025-02-26
 
 ### Added

package/README.md

@@ -476,10 +476,22 @@ All generated scripts use **ES3 syntax** (`var`, manual `for` loops, no arrow fu
 
 ### Security
 
-- Scripts are validated before execution — blocks `eval()`, `new Function()`, `System.callSystem()`
-- 500KB script size limit
-- `send_raw_script` bypasses validation for advanced users (with explicit opt-in)
-- Temp directory created with restricted permissions (mode 700)
+Understand the trust model before deploying this: **any client that can reach the MCP
+server can run ExtendScript inside your Premiere Pro.** `execute_extendscript` and
+`send_raw_script` are arbitrary-code-execution tools by design. Treat access to the server
+the same way you'd treat a shell on the machine running Premiere.
+
+- **Run it locally over stdio** unless you have a specific reason not to. That's the safe default.
+- **The HTTP transport (`http-server`) requires `MCP_AUTH_TOKEN`** and refuses to start
+  without it. It binds `0.0.0.0` and is remotely reachable, so never expose it publicly
+  without a strong token (set `ALLOW_UNAUTHENTICATED=1` only for a throwaway public instance).
+- The bridge temp directory is created private to your user (mode `0700`), and the server
+  refuses to use one owned by another user — relevant on shared machines, where the CEP
+  panel would otherwise execute any `cmd_*.jsx` staged there.
+- There is a 500 KB script size limit, and a small regex check that rejects `eval()`,
+  `new Function()`, and `System.callSystem()` in tool-generated scripts. **This is a guard
+  rail, not a sandbox** — it is trivially bypassable and is not a security boundary. Do not
+  rely on it to contain untrusted input; the real boundary is who can reach the server.
 
 ### QE DOM
 

package/cep-plugin/CSInterface.js

@@ -26,15 +26,10 @@ function CSInterface() {}
  */
 CSInterface.prototype.evalScript = function (script, callback) {
   if (typeof __adobe_cep__ !== "undefined") {
-    var result = __adobe_cep__.evalScript(script);
-    if (callback) {
-      // CSInterface v9+ uses async callback
-      if (typeof result === "undefined" || result === "undefined") {
-        // v9+ path: callback is registered and called asynchronously
-        // The __adobe_cep__.evalScript already handles the callback via internal mechanism
-      }
-      callback(result);
-    }
+    // CEP 9+ requires the callback to be passed directly to __adobe_cep__.evalScript.
+    // Calling it without a callback causes the result to be silently discarded,
+    // making every command return null/undefined.
+    __adobe_cep__.evalScript(script, callback || function () {});
   } else {
     // Running outside CEP (for testing)
     console.warn("[CSInterface] Not running in CEP environment");

package/cep-plugin/CSXS/manifest.xml

@@ -22,6 +22,7 @@
           <ScriptPath>./host.jsx</ScriptPath>
           <CEFCommandLine>
             <Parameter>--allow-file-access-from-files</Parameter>
+            <Parameter>--enable-nodejs</Parameter>
           </CEFCommandLine>
         </Resources>
         <Lifecycle>

package/cep-plugin/main.js

@@ -30,9 +30,24 @@ function setStatus(state, text) {
 }
 
 // ---- File I/O via Node.js (CEP has access to Node) ----
-var fs = require("fs");
-var path = require("path");
-var os = require("os");
+// --enable-nodejs puts `require` in the global scope on most hosts, but on some it
+// lands on cep_node instead. Try both, and fail loudly rather than letting fs come
+// back undefined and surface later as "Cannot read properties of undefined".
+function nodeRequire(moduleName) {
+  if (typeof require !== "undefined") return require(moduleName);
+
+  var cepNode = typeof cep_node !== "undefined" ? cep_node : typeof window !== "undefined" ? window.cep_node : null;
+  if (cepNode && typeof cepNode.require === "function") return cepNode.require(moduleName);
+
+  throw new Error(
+    'Node.js is not available in this CEP panel, so "' + moduleName + '" could not be loaded. ' +
+      "Check that CSXS/manifest.xml has <Parameter>--enable-nodejs</Parameter>, then fully quit and reopen Premiere Pro."
+  );
+}
+
+var fs = nodeRequire("fs");
+var path = nodeRequire("path");
+var os = nodeRequire("os");
 tempDir = path.join(os.tmpdir(), "premiere-mcp-bridge");
 
 function ensureDir(dir) {
@@ -127,10 +142,21 @@ function processOneCommand(cmdFileName) {
         // Check if it's already valid JSON
         var parsed = JSON.parse(result);
         response = JSON.stringify(parsed);
+        log("Result: OK", "ok");
       } else {
-        response = JSON.stringify({ success: true, data: result || null });
+        // An empty result means evalScript gave us nothing back. That is a bridge
+        // failure, not a successful command with no data — reporting it as "OK" is
+        // what made this so hard to diagnose. Say so.
+        response = JSON.stringify({
+          success: false,
+          error:
+            "The bridge received an empty result from evalScript (got " +
+            (typeof result) +
+            "). The script may not have run. If every command does this, the CEP panel is stale — " +
+            "close and reopen it (a reload is not enough), or reinstall the extension.",
+        });
+        log("Result: EMPTY — evalScript returned nothing (see response file)", "err");
       }
-      log("Result: OK", "ok");
     } catch (e) {
       // If result isn't JSON, wrap it
       if (result && result.indexOf("Error") === 0) {

package/dist/bridge/file-bridge.js

@@ -1,13 +1,43 @@
-import { mkdirSync, writeFileSync, readFileSync, unlinkSync, existsSync, readdirSync } from "node:fs";
+import { mkdirSync, writeFileSync, readFileSync, unlinkSync, existsSync, readdirSync, statSync, chmodSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 const DEFAULT_TEMP_DIR = join(tmpdir(), "premiere-mcp-bridge");
 const POLL_INTERVAL_MS = 100;
 const DEFAULT_TIMEOUT_MS = 30000;
 let commandCounter = 0;
+/**
+ * Create the bridge temp dir private to this user, and — critically — refuse to trust
+ * one we didn't create.
+ *
+ * The dir sits at a predictable, world-accessible path (e.g. /tmp/premiere-mcp-bridge)
+ * and the CEP panel executes ANY cmd_*.jsx it finds there, inside Premiere, as the
+ * logged-in user. On a shared machine another user could pre-create that path and drop
+ * command files, or read the res_*.json we write (which contain project data). And
+ * mkdirSync({recursive:true}) is a no-op on an existing dir — it does NOT re-apply the
+ * mode — so "create it 0o700" alone does not protect against a dir that was already there.
+ *
+ * So: if it exists, verify it's ours and lock its permissions down; if it isn't ours,
+ * fail loudly rather than executing whatever an attacker staged in it.
+ */
 function ensureDir(dir) {
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true, mode: 0o700 });
+        return;
+    }
+    // POSIX only — Windows doesn't model uid/mode the same way, and its per-user temp
+    // dir isn't world-writable to begin with.
+    if (process.platform === "win32")
+        return;
+    const st = statSync(dir);
+    const myUid = typeof process.getuid === "function" ? process.getuid() : undefined;
+    if (myUid !== undefined && st.uid !== myUid) {
+        throw new Error(`Bridge temp dir ${dir} is owned by uid ${st.uid}, not this user (${myUid}). ` +
+            `Refusing to use it — another user may have staged command files. ` +
+            `Set PREMIERE_TEMP_DIR to a path only you control.`);
+    }
+    // Clamp to owner-only, in case it was created with looser perms before this fix.
+    if ((st.mode & 0o077) !== 0) {
+        chmodSync(dir, 0o700);
     }
 }
 export function getTempDir(options) {

package/dist/bridge/script-builder.js

@@ -129,6 +129,263 @@ function __getAllClips(seq) {
   return clips;
 }
 
+// Premiere's ExtendScript API exposes no preset/format enumeration (there is no
+// encoder.getFormatList()), so presets have to be discovered by walking the .epr
+// files Adobe ships on disk.
+
+function __isMacOS() {
+  return !!($.os && $.os.toLowerCase().indexOf("mac") !== -1);
+}
+
+// Version-agnostic: returns install folders whose name starts with appNamePrefix,
+// e.g. "Adobe Premiere Pro" -> [.../Adobe Premiere Pro 2026, .../Adobe Premiere Pro 2025]
+function __adobeAppFolders(appNamePrefix) {
+  var base = new Folder(__isMacOS() ? "/Applications" : "C:\\\\Program Files\\\\Adobe");
+  if (!base.exists) return [];
+
+  var found = [];
+  var subs = base.getFiles(function(f) { return f instanceof Folder; });
+  for (var i = 0; i < subs.length; i++) {
+    if (subs[i].displayName.indexOf(appNamePrefix) === 0) found.push(subs[i]);
+  }
+  // Newest version first, so a 2026 preset wins over a stale 2024 one.
+  found.sort(function(a, b) { return a.displayName < b.displayName ? 1 : -1; });
+  return found;
+}
+
+function __collectEprFiles(folder, out) {
+  if (!folder || !folder.exists) return out;
+  var entries = folder.getFiles();
+  for (var i = 0; i < entries.length; i++) {
+    var entry = entries[i];
+    if (entry instanceof Folder) __collectEprFiles(entry, out);
+    else if (/\\.epr$/i.test(entry.name)) out.push(entry);
+  }
+  return out;
+}
+
+// All export presets AME ships, plus the user's own saved presets.
+function __collectAllPresets() {
+  var roots = [];
+
+  var ame = __adobeAppFolders("Adobe Media Encoder");
+  for (var i = 0; i < ame.length; i++) {
+    roots.push(new Folder(ame[i].fsName + "/MediaIO/systempresets"));
+  }
+
+  var ppro = __adobeAppFolders("Adobe Premiere Pro");
+  for (var j = 0; j < ppro.length; j++) {
+    roots.push(new Folder(ppro[j].fsName + "/Settings/IngestPresets"));
+  }
+
+  // User-saved presets live under the Documents tree on both platforms.
+  var userRoot = new Folder(Folder.myDocuments.fsName + "/Adobe/Adobe Media Encoder");
+  if (userRoot.exists) {
+    var versions = userRoot.getFiles(function(f) { return f instanceof Folder; });
+    for (var v = 0; v < versions.length; v++) {
+      roots.push(new Folder(versions[v].fsName + "/Presets"));
+    }
+  }
+
+  var presets = [];
+  for (var r = 0; r < roots.length; r++) {
+    var eprs = __collectEprFiles(roots[r], []);
+    for (var e = 0; e < eprs.length; e++) {
+      presets.push({
+        name: decodeURI(eprs[e].displayName).replace(/\\.epr$/i, ""),
+        path: eprs[e].fsName,
+        // The parent folder is the format bucket, e.g. "48323634" (hex "H264").
+        format: eprs[e].parent ? decodeURI(eprs[e].parent.displayName) : ""
+      });
+    }
+  }
+  return presets;
+}
+
+// Default export preset. "48323634" is hex for "H264" — the folder name AME uses
+// for the H.264 format bucket on disk.
+function __findH264Preset() {
+  var presets = __collectAllPresets();
+  var candidates = [];
+  for (var i = 0; i < presets.length; i++) {
+    var haystack = (presets[i].name + " " + presets[i].format).toLowerCase();
+    if (haystack.indexOf("h264") !== -1 || haystack.indexOf("h.264") !== -1 || haystack.indexOf("48323634") !== -1) {
+      candidates.push(presets[i]);
+    }
+  }
+  if (!candidates.length) return "";
+
+  for (var j = 0; j < candidates.length; j++) {
+    if (candidates[j].name.toLowerCase().indexOf("match source - high") !== -1) return candidates[j].path;
+  }
+  return candidates[0].path;
+}
+
+function __findProxyPreset() {
+  var ppro = __adobeAppFolders("Adobe Premiere Pro");
+  for (var i = 0; i < ppro.length; i++) {
+    var proxyDir = new Folder(ppro[i].fsName + "/Settings/IngestPresets/Proxy");
+    var eprs = __collectEprFiles(proxyDir, []);
+    if (eprs.length) {
+      eprs.sort(function(a, b) { return a.displayName < b.displayName ? -1 : 1; });
+      return eprs[0].fsName;
+    }
+  }
+  return "";
+}
+
+function __findStillPreset(outputPath) {
+  var wantJpeg = /\\.jpe?g$/i.test(outputPath);
+  var needles = wantJpeg ? ["jpeg", "jpg"] : ["png"];
+  var presets = __collectAllPresets();
+
+  for (var n = 0; n < needles.length; n++) {
+    for (var i = 0; i < presets.length; i++) {
+      var haystack = (presets[i].name + " " + presets[i].format).toLowerCase();
+      if (haystack.indexOf(needles[n]) !== -1) return presets[i].path;
+    }
+  }
+  return "";
+}
+
+// Returns the path actually written, or "" if nothing was. Media Encoder treats a
+// still export as a one-frame image *sequence* and appends a frame number to the
+// filename, so an exact-path miss is not proof that nothing was written.
+function __firstWrittenFile(outputPath) {
+  var exact = new File(outputPath);
+  if (exact.exists && exact.length > 0) return exact.fsName;
+
+  var dir = exact.parent;
+  if (!dir || !dir.exists) return "";
+
+  var fullName = decodeURI(exact.name);
+  var dot = fullName.lastIndexOf(".");
+  var base = dot === -1 ? fullName : fullName.substring(0, dot);
+  var ext = dot === -1 ? "" : fullName.substring(dot).toLowerCase();
+
+  var matches = dir.getFiles(function(candidate) {
+    if (candidate instanceof Folder) return false;
+    var nm = decodeURI(candidate.name);
+    if (nm.indexOf(base) !== 0) return false;
+    return ext === "" || nm.toLowerCase().substring(nm.length - ext.length) === ext;
+  });
+  if (!matches || !matches.length) return "";
+
+  // Normalize back to the caller's requested path so they get the name they asked for.
+  var produced = matches[0];
+  if (produced.length <= 0) return "";
+  try {
+    if (produced.fsName !== exact.fsName) produced.rename(fullName);
+    return exact.exists ? exact.fsName : produced.fsName;
+  } catch (e) {
+    return produced.fsName;
+  }
+}
+
+// Export a single frame to disk. Returns { ok, method, path, notes } / { ok:false, error, notes }.
+//
+// exportFramePNG/exportFrameJPEG do NOT exist on the public DOM sequence — only on
+// the QE sequence — and even there they return false and write nothing on some
+// builds. So we try QE first, verify against the filesystem rather than the return
+// value, and fall back to a one-frame Media Encoder export.
+function __exportStillFrame(outputPath, ticks) {
+  var seq = app.project.activeSequence;
+  if (!seq) return { ok: false, error: "No active sequence", notes: [] };
+
+  var notes = [];
+  var savedPos = null;
+  try { savedPos = seq.getPlayerPosition().ticks; } catch (e) {}
+
+  if (ticks) {
+    try { seq.setPlayerPosition(String(ticks)); } catch (e) { notes.push("setPlayerPosition: " + e.toString()); }
+  }
+  var atTicks = ticks;
+  if (!atTicks) {
+    try { atTicks = seq.getPlayerPosition().ticks; } catch (e) { atTicks = "0"; }
+  }
+
+  // Clear any stale file so that a file existing afterwards proves we wrote it.
+  var stale = new File(outputPath);
+  if (stale.exists) { try { stale.remove(); } catch (e) {} }
+
+  var wantJpeg = /\\.jpe?g$/i.test(outputPath);
+
+  // --- Path 1: QE DOM. Signature is (path, width, height) with string args. ---
+  try {
+    app.enableQE();
+    var qeSeq = qe.project.getActiveSequence();
+    if (!qeSeq) {
+      notes.push("QE: no active sequence");
+    } else {
+      var fn = wantJpeg ? qeSeq.exportFrameJPEG : qeSeq.exportFramePNG;
+      if (typeof fn !== "function") {
+        notes.push("QE: exportFrame" + (wantJpeg ? "JPEG" : "PNG") + " unavailable on this build");
+      } else {
+        var w = String(seq.frameSizeHorizontal);
+        var h = String(seq.frameSizeVertical);
+        try {
+          notes.push("QE returned " + fn.call(qeSeq, outputPath, w, h));
+        } catch (eArgs) {
+          try { notes.push("QE returned " + fn.call(qeSeq, outputPath, w)); }
+          catch (eArgs2) { notes.push("QE: " + eArgs2.toString()); }
+        }
+      }
+    }
+  } catch (eQE) {
+    notes.push("QE: " + eQE.toString());
+  }
+
+  var written = __firstWrittenFile(outputPath);
+  if (written) {
+    if (savedPos) { try { seq.setPlayerPosition(savedPos); } catch (e) {} }
+    return { ok: true, method: "qe", path: written, notes: notes };
+  }
+  notes.push("QE wrote no file; falling back to Media Encoder");
+
+  // --- Path 2: one-frame export through Media Encoder. ---
+  try {
+    var preset = __findStillPreset(outputPath);
+    if (!preset) {
+      notes.push("AME: no " + (wantJpeg ? "JPEG" : "PNG") + " still preset found on disk");
+    } else {
+      var savedIn = null, savedOut = null;
+      try {
+        savedIn = seq.getInPointAsTime().ticks;
+        savedOut = seq.getOutPointAsTime().ticks;
+      } catch (e) {}
+
+      // seq.timebase is ticks-per-frame, so in..in+timebase is exactly one frame.
+      var frameTicks = parseFloat(seq.timebase);
+      var startTicks = parseFloat(atTicks);
+      seq.setInPoint(String(startTicks));
+      seq.setOutPoint(String(startTicks + frameTicks));
+
+      try {
+        seq.exportAsMediaDirect(outputPath, preset, app.encoder.ENCODE_IN_TO_OUT);
+        notes.push("AME preset: " + preset);
+      } finally {
+        try {
+          if (savedIn !== null) seq.setInPoint(savedIn);
+          if (savedOut !== null) seq.setOutPoint(savedOut);
+        } catch (e) {}
+      }
+    }
+  } catch (eAME) {
+    notes.push("AME: " + eAME.toString());
+  }
+
+  if (savedPos) { try { seq.setPlayerPosition(savedPos); } catch (e) {} }
+
+  written = __firstWrittenFile(outputPath);
+  if (written) return { ok: true, method: "ame", path: written, notes: notes };
+
+  return {
+    ok: false,
+    error: "Frame export produced no file on disk. Neither the QE DOM nor Media Encoder wrote " + outputPath,
+    notes: notes
+  };
+}
+
 function __jsonStringify(obj) {
   // ES3-compatible JSON stringify
   if (typeof JSON !== "undefined" && JSON.stringify) {

package/dist/http-server.d.ts

@@ -15,7 +15,10 @@
  *   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
+ *   MCP_AUTH_TOKEN     Bearer token required on every /mcp request. REQUIRED — the
+ *                      server refuses to start without it, because this transport
+ *                      binds 0.0.0.0 and can drive Premiere. Set ALLOW_UNAUTHENTICATED=1
+ *                      only for a deliberately public, throwaway instance.
  */
 export {};
 //# sourceMappingURL=http-server.d.ts.map

package/dist/http-server.js

@@ -15,14 +15,81 @@
  *   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
+ *   MCP_AUTH_TOKEN     Bearer token required on every /mcp request. REQUIRED — the
+ *                      server refuses to start without it, because this transport
+ *                      binds 0.0.0.0 and can drive Premiere. Set ALLOW_UNAUTHENTICATED=1
+ *                      only for a deliberately public, throwaway instance.
  */
 import http from "node:http";
+import fs from "node:fs";
+import path from "node:path";
+import { timingSafeEqual } from "node:crypto";
+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 ALLOW_UNAUTHENTICATED = process.env.ALLOW_UNAUTHENTICATED === "1";
+// Fail closed. This transport listens on 0.0.0.0 and every /mcp request can drive
+// Premiere, so starting it wide open is almost never what anyone means to do. Refuse
+// unless a token is set, or the operator has explicitly opted into a public instance.
+if (!AUTH_TOKEN && !ALLOW_UNAUTHENTICATED) {
+    console.error("[premiere-pro-mcp] Refusing to start: MCP_AUTH_TOKEN is not set.\n" +
+        "  This HTTP transport is remotely reachable and can control Premiere.\n" +
+        "  Set MCP_AUTH_TOKEN to a strong secret, or set ALLOW_UNAUTHENTICATED=1 if you\n" +
+        "  genuinely want a public, unauthenticated instance.");
+    process.exit(1);
+}
+/** Constant-time bearer check, so token comparison leaks no timing signal. */
+function isAuthorized(req) {
+    if (!AUTH_TOKEN)
+        return true; // only reachable under ALLOW_UNAUTHENTICATED
+    const header = req.headers["authorization"] ?? "";
+    const provided = header.startsWith("Bearer ") ? header.slice(7) : "";
+    const a = Buffer.from(provided);
+    const b = Buffer.from(AUTH_TOKEN);
+    // timingSafeEqual throws on length mismatch, which would itself leak length — so
+    // guard the length check first and only compare equal-length buffers.
+    return a.length === b.length && timingSafeEqual(a, b);
+}
 const bridgeOptions = {
     tempDir: process.env.PREMIERE_TEMP_DIR,
     timeoutMs: process.env.PREMIERE_TIMEOUT_MS
@@ -41,21 +108,19 @@ const httpServer = http.createServer(async (req, res) => {
         res.end(JSON.stringify({ status: "ok", service: "premiere-pro-mcp" }));
         return;
     }
-    // Only handle /mcp endpoint
+    // 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;
-        }
+    // Bearer token auth (constant-time; required unless ALLOW_UNAUTHENTICATED=1)
+    if (!isAuthorized(req)) {
+        res.writeHead(401, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Unauthorized" }));
+        return;
     }
     const mcpServer = createServer(bridgeOptions);
     const transport = new StreamableHTTPServerTransport({
@@ -84,7 +149,7 @@ httpServer.listen(PORT, "0.0.0.0", () => {
         console.error(`[premiere-pro-mcp] Auth: Bearer token required`);
     }
     else {
-        console.error(`[premiere-pro-mcp] Auth: none (set MCP_AUTH_TOKEN to enable)`);
+        console.error(`[premiere-pro-mcp] Auth: DISABLED via ALLOW_UNAUTHENTICATED — anyone can drive this server`);
     }
 });
 process.on("SIGTERM", () => {

package/dist/prompts/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Workflow prompts.
+ *
+ * 269 tools is an API, not an assistant. An agent handed a flat list of 269 names has to
+ * rediscover, every session, that you import before you edit, that effect names must match
+ * this machine exactly, and that a node_id goes stale the moment the timeline shifts under
+ * it. These encode the running order so it doesn't have to.
+ *
+ * Each prompt is deliberately opinionated about sequencing and about verification — the
+ * failure mode we care most about is an agent that believes an edit landed when it didn't.
+ */
+export interface PromptArg {
+    name: string;
+    description: string;
+    required?: boolean;
+}
+export interface PromptDef {
+    name: string;
+    description: string;
+    arguments: PromptArg[];
+    build: (args: Record<string, string>) => string;
+}
+export declare const PROMPTS: PromptDef[];
+export declare function getPrompt(name: string): PromptDef | undefined;
+//# sourceMappingURL=index.d.ts.map