@synthetic-ai/premiere-mcp 2.3.1-dev.1 → 2.3.4

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## [v2.3.4] — The "Reload panel" button no longer reloads in place
+
+v2.3.3's `stopBridge()`-before-`location.reload()` fix wasn't enough —
+confirmed live, twice, on a clean install + full Premiere Pro restart, that
+`location.reload()` doesn't reliably re-run `init()` in this CEP host. Root
+cause found: each reload leaks the old page's `CEPHtmlEngine` subprocesses
+instead of terminating them — 37 orphaned processes were found accumulated
+from repeated testing today, versus ~6 for one cleanly opened panel. Rather
+than keep guessing at ways to make an in-place reload work, the ⟳ button no
+longer calls `location.reload()` at all — it stops the bridge and tells the
+user to restart Premiere Pro, the one path confirmed to always leave the
+panel correct.
+
+## [v2.3.3] — Fixed the "Reload panel" button
+
+It called a bare `location.reload()`, which could leave the old poll
+interval running underneath the fresh page and race with `init()`
+re-running — the panel could get stuck showing the raw HTML placeholder
+badge, an empty temp dir field, and a spurious "Please set a temp
+directory" error, all while the actually-installed files were fine. Now
+stops the bridge (clearing the interval) before reloading, same fix class
+as Photoshop MCP's `wss.close()`-before-reload.
+
+## [v2.3.2] — Reverted the license.json USER_DATA change
+
+v2.3.1 (panel side, unreleased separately from the npm tag) moved
+`getLicensePath()` from `SystemPath.EXTENSION` to `SystemPath.USER_DATA` to
+fix license saves failing with EPERM under a system-wide install. Live
+testing found a deeper issue: the CEP panel's embedded Node
+`fs.writeFileSync` can report success without the write actually landing on
+disk on this Premiere Pro version — confirmed by writing the target file
+directly and watching Premiere's own "successful" save leave it untouched.
+Reverted back to `SystemPath.EXTENSION` (pre-fix behavior) until this CEP
+Node.js reliability issue is understood; the original EPERM bug is still
+open, to be investigated outside production.
+
 ## [v2.3.1] — macOS example paths in tool descriptions
 
 `create_sequence`'s description and example calls only showed Windows

package/cep-plugin/CSXS/manifest.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<ExtensionManifest Version="7.0" ExtensionBundleId="com.mcp.premiere.bridge" ExtensionBundleVersion="1.1.6" ExtensionBundleName="MCP Bridge">
+<ExtensionManifest Version="7.0" ExtensionBundleId="com.mcp.premiere.bridge" ExtensionBundleVersion="1.1.6" ExtensionBundleName="Synthetic Premiere MCP">
   <ExtensionList>
     <Extension Id="com.mcp.premiere.bridge.panel" Version="1.1.6"/>
   </ExtensionList>

package/cep-plugin/i18n-core.cjs

@@ -0,0 +1,224 @@
+/* synthetic-idiomas · core/i18n-core.cjs
+ *
+ * Runtime de idiomas compartido por todos los productos Synthetic (servers MCP en Node y
+ * paneles CEP en el navegador). Sin dependencias. UMD: `require()`/`import` desde Node,
+ * o <script> (queda en window.SyntheticI18n).
+ *
+ * Reglas:
+ *  - Inglés es el idioma fuente. Cualquier clave que falte en otro idioma cae al inglés; si
+ *    tampoco está, al texto por defecto que pase el código; si tampoco, a la clave. Nunca vacío.
+ *  - Las traducciones de descripciones de tools llevan la huella (hash) del inglés del que se
+ *    tradujeron. Si el inglés cambió desde entonces, se usa el inglés nuevo: nunca se muestra
+ *    una traducción vieja que ya no corresponde.
+ */
+(function (root, factory) {
+  var api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  // En CEP con Node habilitado existen `module` y `window` a la vez: el panel lo busca en window.
+  if (root && (typeof module !== 'object' || typeof root.document !== 'undefined')) root.SyntheticI18n = api;
+})(typeof self !== 'undefined' ? self : this, function () {
+  'use strict';
+
+  // Idiomas soportados, en el orden en que se muestran en los selectores.
+  var LANGUAGES = [
+    { code: 'en', name: 'English' },
+    { code: 'es', name: 'Español' },
+    { code: 'pt-BR', name: 'Português (Brasil)' },
+    { code: 'fr', name: 'Français' },
+    { code: 'de', name: 'Deutsch' },
+    { code: 'ja', name: '日本語' }
+  ];
+  var CODES = LANGUAGES.map(function (l) { return l.code; });
+  var SOURCE = 'en';
+
+  // "es-AR", "es_419" → "es"; "pt", "pt-PT" → "pt-BR"; "EN-us" → "en"; desconocido → null.
+  function normalizeLanguage(input) {
+    if (!input || typeof input !== 'string') return null;
+    var s = input.trim().replace('_', '-').toLowerCase();
+    if (!s) return null;
+    for (var i = 0; i < CODES.length; i++) if (CODES[i].toLowerCase() === s) return CODES[i];
+    var base = s.split('-')[0];
+    if (base === 'pt') return 'pt-BR';
+    for (var j = 0; j < CODES.length; j++) if (CODES[j].toLowerCase() === base) return CODES[j];
+    return null;
+  }
+
+  // FNV-1a de 32 bits sobre UTF-16: rápido, determinístico e idéntico en Node y navegador.
+  function hash(text) {
+    var h = 0x811c9dc5;
+    var s = String(text);
+    for (var i = 0; i < s.length; i++) {
+      h ^= s.charCodeAt(i);
+      h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0;
+    }
+    return ('0000000' + h.toString(16)).slice(-8);
+  }
+
+  // "Hola {name}" + {name:"Ana"} → "Hola Ana". Placeholders sin valor quedan tal cual.
+  function interpolate(text, vars) {
+    if (!vars) return text;
+    return String(text).replace(/\{([a-zA-Z0-9_]+)\}/g, function (m, k) {
+      return Object.prototype.hasOwnProperty.call(vars, k) && vars[k] != null ? String(vars[k]) : m;
+    });
+  }
+
+  /**
+   * @param {object} opts
+   *   locales: { en: {key: text}, es: {...}, ... }   diccionarios planos
+   *   hashes:  { es: {key: hashDelInglés}, ... }       (opcional) huellas de las traducciones de tools
+   *   language: código pedido (se normaliza; si no está soportado, inglés)
+   */
+  function createI18n(opts) {
+    opts = opts || {};
+    var locales = opts.locales || {};
+    var hashes = opts.hashes || {};
+    var language = normalizeLanguage(opts.language) || SOURCE;
+    if (!locales[language] && language !== SOURCE) language = SOURCE;
+    var en = locales[SOURCE] || {};
+    var lockMap = hashes[language] || {};
+    // Una traducción cuyo inglés cambió desde que se tradujo no se usa (cae al inglés actual).
+    var dict = {};
+    var raw = locales[language] || {};
+    Object.keys(raw).forEach(function (k) {
+      var lock = lockMap[k];
+      if (lock && typeof en[k] === 'string' && hash(en[k]) !== lock) return;
+      dict[k] = raw[k];
+    });
+
+    function has(key) { return Object.prototype.hasOwnProperty.call(dict, key) && typeof dict[key] === 'string' && dict[key] !== ''; }
+
+    // Texto de una clave de UI/mensajes con caída al inglés.
+    function t(key, vars, fallbackText) {
+      var text = has(key) ? dict[key]
+        : (typeof en[key] === 'string' && en[key] !== '') ? en[key]
+        : (fallbackText != null && fallbackText !== '') ? fallbackText
+        : key;
+      return interpolate(text, vars);
+    }
+
+    // Traducción de un texto en inglés "vivo" (tomado del código en ejecución): solo si la
+    // traducción se hizo a partir de ese mismo inglés. Si no, devuelve el inglés.
+    function translateLive(key, englishNow) {
+      if (language === SOURCE || typeof englishNow !== 'string' || englishNow === '') return englishNow;
+      if (!has(key)) return englishNow;
+      var lock = lockMap[key];
+      if (lock && lock !== hash(englishNow)) return englishNow;
+      return dict[key];
+    }
+
+    // Recorre un JSON Schema y traduce cada `description` (y `title`) con claves estables:
+    //   tool.<nombre>.param.<ruta>      ej.: tool.apply_effect.param.clipId
+    //   rutas anidadas con ".", ítems de arrays con "[]", ramas anyOf/oneOf con "|n".
+    function localizeSchema(schema, keyBase) {
+      if (!schema || typeof schema !== 'object') return schema;
+      var out = Array.isArray(schema) ? schema.slice() : Object.assign({}, schema);
+      if (typeof out.description === 'string') out.description = translateLive(keyBase, out.description);
+      if (typeof out.title === 'string') out.title = translateLive(keyBase + '#title', out.title);
+      if (out.properties && typeof out.properties === 'object') {
+        var props = {};
+        Object.keys(out.properties).forEach(function (name) {
+          props[name] = localizeSchema(out.properties[name], joinPath(keyBase, name));
+        });
+        out.properties = props;
+      }
+      if (out.items && typeof out.items === 'object' && !Array.isArray(out.items)) out.items = localizeSchema(out.items, keyBase + '[]');
+      ['anyOf', 'oneOf', 'allOf'].forEach(function (k) {
+        if (Array.isArray(out[k])) out[k] = out[k].map(function (s, i) { return localizeSchema(s, keyBase + '|' + i); });
+      });
+      if (out.additionalProperties && typeof out.additionalProperties === 'object') {
+        out.additionalProperties = localizeSchema(out.additionalProperties, keyBase + '{}');
+      }
+      return out;
+    }
+
+    // Traduce la lista de tools de una respuesta tools/list. Devuelve copias; no toca el original.
+    function localizeTools(tools) {
+      if (language === SOURCE || !Array.isArray(tools)) return tools;
+      return tools.map(function (tool) {
+        if (!tool || typeof tool.name !== 'string') return tool;
+        var base = 'tool.' + tool.name;
+        var copy = Object.assign({}, tool);
+        if (typeof copy.description === 'string') copy.description = translateLive(base, copy.description);
+        if (typeof copy.title === 'string') copy.title = translateLive(base + '#title', copy.title);
+        if (copy.inputSchema) copy.inputSchema = localizeSchemaRoot(copy.inputSchema, base);
+        return copy;
+      });
+    }
+    // En la raíz del inputSchema la descripción del objeto no se usa como parámetro.
+    function localizeSchemaRoot(schema, base) {
+      var out = Object.assign({}, schema);
+      if (out.properties) {
+        var props = {};
+        Object.keys(out.properties).forEach(function (name) {
+          props[name] = localizeSchema(out.properties[name], base + '.param.' + name);
+        });
+        out.properties = props;
+      }
+      return out;
+    }
+
+    // Plurales: busca "<clave>.<categoría>" según las reglas del idioma (Intl.PluralRules:
+    // one/other, en japonés solo other), después "<clave>.other" y por último "<clave>".
+    // {count} queda disponible como placeholder.
+    var pluralRules = null;
+    try { pluralRules = new Intl.PluralRules(language === 'pt-BR' ? 'pt-BR' : language); } catch (e) { pluralRules = null; }
+    function tn(key, count, vars) {
+      var v = Object.assign({ count: count }, vars || {});
+      var cat = pluralRules ? pluralRules.select(count) : (count === 1 ? 'one' : 'other');
+      var candidates = [key + '.' + cat, key + '.other', key];
+      for (var i = 0; i < candidates.length; i++) {
+        var k = candidates[i];
+        if (has(k) || (typeof en[k] === 'string' && en[k] !== '')) return t(k, v);
+      }
+      return t(key, v);
+    }
+
+    return {
+      language: language,
+      t: t,
+      tn: tn,
+      translateLive: translateLive,
+      localizeTools: localizeTools,
+      has: has
+    };
+  }
+
+  function joinPath(base, name) { return base + '.' + name; }
+
+  // Aplana la lista de tools de tools/list a { clave: inglés } con las mismas claves que usa
+  // localizeTools. Lo usa el extractor para generar el diccionario fuente.
+  function flattenTools(tools) {
+    var out = {};
+    (tools || []).forEach(function (tool) {
+      if (!tool || typeof tool.name !== 'string') return;
+      var base = 'tool.' + tool.name;
+      if (typeof tool.description === 'string' && tool.description) out[base] = tool.description;
+      if (typeof tool.title === 'string' && tool.title) out[base + '#title'] = tool.title;
+      var props = tool.inputSchema && tool.inputSchema.properties;
+      if (props) Object.keys(props).forEach(function (name) { walk(props[name], base + '.param.' + name); });
+    });
+    function walk(schema, key) {
+      if (!schema || typeof schema !== 'object') return;
+      if (typeof schema.description === 'string' && schema.description) out[key] = schema.description;
+      if (typeof schema.title === 'string' && schema.title) out[key + '#title'] = schema.title;
+      if (schema.properties) Object.keys(schema.properties).forEach(function (n) { walk(schema.properties[n], key + '.' + n); });
+      if (schema.items && typeof schema.items === 'object' && !Array.isArray(schema.items)) walk(schema.items, key + '[]');
+      ['anyOf', 'oneOf', 'allOf'].forEach(function (k) {
+        if (Array.isArray(schema[k])) schema[k].forEach(function (s, i) { walk(s, key + '|' + i); });
+      });
+      if (schema.additionalProperties && typeof schema.additionalProperties === 'object') walk(schema.additionalProperties, key + '{}');
+    }
+    return out;
+  }
+
+  return {
+    LANGUAGES: LANGUAGES,
+    CODES: CODES,
+    SOURCE: SOURCE,
+    normalizeLanguage: normalizeLanguage,
+    hash: hash,
+    interpolate: interpolate,
+    createI18n: createI18n,
+    flattenTools: flattenTools
+  };
+});