@synthetic-ai/illustrator-mcp 0.3.0

package/README.md

@@ -0,0 +1,57 @@
+# Illustrator MCP — Synthetic
+
+Controlá Adobe Illustrator con lenguaje natural desde Claude (u otro cliente MCP) — capas,
+artboards, paths, texto, color, exportación. Por [Synthetic](https://synthetic.com.ar).
+
+**Estado: v0.3.** 136 tools probadas en vivo contra Illustrator real: documentos, capas
+(incl. color, duplicar, reordenar), items (mover/rotar/escalar/orden Z/agrupar/flip/shear),
+paths (crear/leer/editar puntos, compound paths), formas (rectángulo, rectángulo
+redondeado, elipse, polígono, estrella, línea), texto (point/area, estilo, outline, find &
+replace, leading, estilos de párrafo/carácter), color (fill/stroke/swatches/blend
+mode/opacidad, gradientes, grupos de color, spot colors, patrones), símbolos, máscaras de
+recorte, brushes, alinear/distribuir, trazo avanzado (dashes/cap/join/miter), guías, items
+vinculados/embebidos, selección avanzada (misma fill, invertir), y **92 efectos en vivo**:
+4 con parámetros reales tipados (drop shadow/feather/round corners/offset path) +
+`apply_named_effect` (88 confirmados en vivo con valores por defecto — glows, distorsión,
+3D, los 15 Warp, convertir a forma, blur, artístico, trazo de pincel, boceto, textura,
+pixelar) + `apply_live_effect_raw` como escape hatch de XML crudo. Reproducir acciones
+existentes también incluido. Los items se direccionan por nombre — usá `list_items` /
+`get_selection` para descubrirlos, `rename_item` si uno no tiene nombre. Pendiente
+(necesita los IDs internos reales de `executeMenuCommand`, que Illustrator no expone por
+introspección — adivinarlos sin confirmar cada uno hizo colgar la app una vez): pathfinder
+booleano, blends, distorsión de envolvente, malla degradada.
+
+## Arquitectura
+
+Bridge por WebSocket entre este server MCP (Node.js) y un panel CEP que corre dentro de
+Illustrator — el mismo patrón que `photoshop-mcp`, elegido a propósito porque es
+multiplataforma desde el día uno: este server **nunca lanza Illustrator.exe/.app**, se
+conecta a una instancia ya abierta. No hace falta detectar rutas de instalación por
+sistema operativo.
+
+## Instalación (desarrollo)
+
+1. `npm install`
+2. Instalá el panel CEP:
+   - Windows: `.\install.ps1`
+   - macOS: `./install.sh`
+3. Reiniciá Illustrator, abrí `Window > Extensions > Synthetic Illustrator MCP`.
+4. Agregá el server a tu cliente MCP (`claude_desktop_config.json` o equivalente):
+   ```json
+   { "illustrator-mcp": { "command": "node", "args": ["/ruta/a/server.mjs"], "env": { "IL_MCP_LICENSE": "..." } } }
+   ```
+5. Probá con `il_healthcheck`.
+
+## Idioma
+
+Tools, mensajes del server y panel están en inglés por defecto y se traducen con los diccionarios
+de `synthetic-idiomas` (vendorizados en `i18n/` y `bridge-cep/i18n-*` con `npm run sync-i18n`).
+Idiomas: `en`, `es`, `pt-BR`, `fr`, `de`, `ja`; lo que falte traducir cae al inglés.
+
+- **Panel CEP:** ⚙ (Settings) → **Language**. La interfaz del panel cambia al instante; la elección
+  se guarda en `settings.json`, en la misma carpeta que `license.json`
+  (`%APPDATA%\com.synthetic.illustrator-mcp.bridge\` en Windows,
+  `~/Library/Application Support/com.synthetic.illustrator-mcp.bridge/` en macOS).
+- **Server MCP:** elige el idioma **una sola vez al arrancar**: `IL_MCP_LANG` → `SYNTHETIC_LANG` →
+  ese `settings.json` → inglés (lo loguea en stderr y en `--doctor`). Las descripciones de las tools
+  cambian recién al reiniciar el server MCP (o el cliente que lo lanza).

package/i18n/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
+  };
+});

package/i18n/locales/de.json

@@ -0,0 +1,230 @@
+{
+  "msg.bridge.notConnected": "Illustrator ist nicht verbunden. Öffnen Sie Illustrator mit dem Bedienfeld «Synthetic Illustrator MCP» (es stellt die Bridge auf Port {port} bereit).",
+  "msg.bridge.timeout": "Zeitüberschreitung ({ms} ms)",
+  "msg.doctor.bridgeConnecting": "Bridge: Verbindung zu {url} wird hergestellt (prüft, ob das Bedienfeld Synthetic Illustrator MCP in Illustrator geöffnet ist)...",
+  "msg.doctor.bridgeFail": "Bridge nicht erreichbar. Öffnen Sie Illustrator mit dem Bedienfeld Synthetic Illustrator MCP (Fenster → Erweiterungen → Synthetic Illustrator MCP) und prüfen Sie, ob dort \"Bridge active\" steht.",
+  "msg.doctor.bridgeOk": "Bridge erreichbar — das Bedienfeld Synthetic Illustrator MCP läuft in Illustrator.",
+  "msg.doctor.language": "Sprache: {language} (Quelle: {source})",
+  "msg.doctor.licenseFailed": "Lizenzprüfung fehlgeschlagen: {message}",
+  "msg.doctor.licenseInvalid": "ungültig",
+  "msg.doctor.licenseNotSet": "IL_MCP_LICENSE ist nicht gesetzt. Eine Lizenz erhalten Sie unter https://synthetic.com.ar/illustrator-mcp",
+  "msg.doctor.licensePlanActive": "aktiv",
+  "msg.doctor.licenseValid": "Lizenz gültig ({plan})",
+  "msg.doctor.nodeOk": "Node.js {version} (>=18 erforderlich)",
+  "msg.doctor.nodeTooOld": "Node.js {version} — Version 18 oder neuer erforderlich",
+  "msg.doctor.support": "Kommen Sie nicht weiter? Erstellen Sie unter https://synthetic.com.ar/dashboard/support ein Ticket und fügen Sie diese Ausgabe ein",
+  "msg.doctor.title": "Synthetic Illustrator MCP — doctor (Diagnose)",
+  "msg.healthcheck.hint": "Öffnen Sie Illustrator mit dem Bedienfeld Synthetic Illustrator MCP (es stellt die Bridge bereit).",
+  "msg.host.errorAtLine": "{message} (Zeile {line})",
+  "msg.host.itemNotFound": "Element nicht gefunden: {name}",
+  "msg.host.layerNotFound": "Ebene nicht gefunden: {name}",
+  "msg.host.noDocument": "Kein Dokument geöffnet",
+  "msg.host.notACompoundPath": "Kein zusammengesetzter Pfad: {name}",
+  "msg.host.notAGroup": "Keine Gruppe: {name}",
+  "msg.host.notAPath": "Kein Pfad: {name}",
+  "msg.host.unknownCommand": "Unbekannter Befehl: {cmd}",
+  "msg.license.getLicense": "Eine Lizenz erhalten Sie unter https://synthetic.com.ar/illustrator-mcp",
+  "msg.license.invalidOrMissing": "Ungültige oder fehlende Lizenz.",
+  "msg.license.noKey": "Kein Lizenzschlüssel. Setzen Sie IL_MCP_LICENSE in Ihrer MCP-Konfiguration. Eine Lizenz erhalten Sie unter https://synthetic.com.ar/illustrator-mcp",
+  "msg.license.required": "Lizenz erforderlich",
+  "msg.license.serverUnreachable": "Lizenzserver nicht erreichbar. Prüfen Sie Ihre Internetverbindung.",
+  "msg.license.serverUnreachableRetry": "Lizenzserver nicht erreichbar. Beim nächsten Aufruf wird es erneut versucht.",
+  "msg.server.instructions": "Illustrator MCP (Synthetic). Steuert Adobe Illustrator über ein Bridge-Plugin. Tool-Konvention: Diagnose il_* ; Bereich Verb_Substantiv (list_layers, get_document_info) ; Escape-Hatches run_jsx / run_jsx_json. Beginnen Sie mit il_healthcheck. Seitenelemente werden über den Namen angesprochen (vergeben Sie mit rename_item einen, falls ein Element keinen hat) — mit list_items/get_item/get_selection finden Sie Namen. Deckt Dokumente, Ebenen, Elemente (Verschieben/Drehen/Skalieren/Z-Reihenfolge/Gruppieren), Pfade, Formen, Text, Farbe/Füllung/Kontur/Farbfelder, Zeichenflächen und Export (PNG/JPG/SVG/PDF) ab.",
+  "tool.add_area_text_frame": "Fügt einen Flächentext-Rahmen hinzu: Der Text fließt innerhalb eines Rechtecks und bricht um.",
+  "tool.add_artboard": "Fügt eine neue Zeichenfläche hinzu.",
+  "tool.add_layer": "Fügt dem aktiven Dokument eine neue Ebene hinzu.",
+  "tool.add_shape_ellipse": "Fügt eine Ellipse hinzu.",
+  "tool.add_shape_line": "Fügt ein gerades Liniensegment zwischen zwei Punkten hinzu.",
+  "tool.add_shape_polygon": "Fügt ein regelmäßiges Polygon zentriert bei (cx, cy) hinzu.",
+  "tool.add_shape_rectangle": "Fügt ein Rechteck hinzu. top/left sind in Punkt, Dokumentkoordinaten (Y nach unten).",
+  "tool.add_shape_rounded_rectangle": "Fügt ein Rechteck mit abgerundeten Ecken hinzu.",
+  "tool.add_shape_star": "Fügt einen Stern zentriert bei (cx, cy) hinzu.",
+  "tool.add_spot_color": "Erstellt eine neue Schmuckfarbe aus einem CMYK-/RGB-/Graustufenwert und registriert sie in den Farbfeldern des Dokuments.",
+  "tool.add_swatch": "Fügt dem Dokument ein neues Farbfeld hinzu.",
+  "tool.add_text_frame": "Fügt einen Punkttext-Rahmen hinzu (der Text ist an einem einzigen Punkt verankert und wächst mit dem Inhalt) bei (x, y).",
+  "tool.align_items": "Richtet Elemente anhand ihres gemeinsamen Begrenzungsrahmens an einer Kante/Achse aus.",
+  "tool.apply_brush_to_path": "Wendet einen vorhandenen Pinsel auf die Kontur eines Pfads an.",
+  "tool.apply_character_style": "Wendet eine benannte Zeichenformatvorlage auf den gesamten Inhalt eines Textrahmens an.",
+  "tool.apply_drop_shadow_effect": "Wendet einen Live-Schlagschatten-Effekt an (nicht destruktiv, im Bedienfeld Aussehen bearbeitbar/entfernbar). Immer schwarz -- die Farb-/Füllmethode-Parameter des Effekts lehnten jeden live getesteten Wert ab, daher zeigt dies nur, was nachweislich funktioniert.",
+  "tool.apply_feather_effect": "Wendet einen Live-Federn-Effekt an (blendet die Kante des Elements weich aus).",
+  "tool.apply_gradient_fill": "Füllt ein Seitenelement mit einem vorhandenen Farbverlauf.",
+  "tool.apply_gradient_stroke": "Wendet einen vorhandenen Farbverlauf auf die Kontur eines Seitenelements an.",
+  "tool.apply_live_effect_raw": "Escape-Hatch: wendet einen beliebigen Live-Effekt anhand seines internen Namens und eines rohen XML-Parameter-Dictionary an (z. B. name='Adobe Drop Shadow', xml='<LiveEffect name=\"Adobe Drop Shadow\"><Dict>...</Dict></LiveEffect>'). Für Effekte, die kein eigenes Tool haben.",
+  "tool.apply_named_effect": "Wendet einen von 87 live bestätigt funktionierenden Illustrator-Effekten anhand eines Kurznamens mit Standardparametern an (oder einer rohen XML-<Dict>-Überschreibung für Feinsteuerung -- Format siehe apply_live_effect_raw). Deckt die meisten Effekte unter Effekt > Illustrator-Effekte und Effekt > Photoshop-Effekte ab. Nicht destruktiv/im Bedienfeld Aussehen bearbeitbar, wie die 4 eigenständigen Effekt-Tools (Schlagschatten, Federn, Abgerundete Ecken, Pfad verschieben), die stattdessen echte typisierte Parameter erhalten und bei Verfügbarkeit bevorzugt werden sollten.",
+  "tool.apply_offset_path_effect": "Wendet einen Live-Pfad-verschieben-Effekt an (vergrößert/verkleinert die Kontur eines Pfads).",
+  "tool.apply_paragraph_style": "Wendet eine benannte Absatzformatvorlage auf den gesamten Inhalt eines Textrahmens an.",
+  "tool.apply_pattern_fill": "Füllt ein Seitenelement mit einem vorhandenen Musterfeld.",
+  "tool.apply_round_corners_effect": "Wendet einen Live-Effekt für abgerundete Ecken auf einen Pfad an.",
+  "tool.apply_swatch": "Wendet ein vorhandenes Farbfeld als Füllung oder Kontur eines Seitenelements an.",
+  "tool.break_symbol_link": "Trennt die Verknüpfung einer Symbolinstanz und wandelt sie zurück in normal bearbeitbare Grafik um. Gibt den Namen des resultierenden Elements zurück.",
+  "tool.bring_forward": "Verschiebt ein Seitenelement eine Ebene nach vorn in der Stapelreihenfolge seiner Ebene.",
+  "tool.bring_to_front": "Bringt ein Seitenelement an die Spitze der Stapelreihenfolge seiner Ebene.",
+  "tool.close_document": "Schließt das aktive Dokument (save=true, um vorher zu speichern).",
+  "tool.convert_item_to_guide": "Wandelt ein Pfadelement in eine nicht druckbare Hilfslinie um.",
+  "tool.create_document": "Erstellt ein neues Dokument.",
+  "tool.create_gradient": "Erstellt einen linearen oder radialen Farbverlauf mit 2 oder mehr Farbstopps (Position 0-100). Gibt den Namen des Farbverlaufs zurück.",
+  "tool.create_path_from_points": "Erstellt ein PathItem aus einem Array von Ankerpunkten ({x,y} in Punkt, Dokumentkoordinaten mit Y hier nach unten übergeben — das Tool kehrt intern zur eigenen Y-nach-oben-Konvention von Illustrator um). Nur gerade Segmente (keine Bézier-Griffe); für Kurven anschließend set_path_point_handles verwenden.",
+  "tool.create_swatch_group": "Erstellt eine neue Farbfeldgruppe (Farbgruppe), die die angegebenen vorhandenen Farbfelder enthält.",
+  "tool.create_symbol_from_item": "Erstellt eine neue Symboldefinition aus einem Seitenelement. Illustrator ersetzt das Quellelement an Ort und Stelle durch eine Instanz des neuen Symbols.",
+  "tool.delete_artboard": "Löscht eine Zeichenfläche anhand des Index (ein Dokument muss mindestens eine behalten).",
+  "tool.delete_gradient": "Löscht einen Farbverlauf aus dem Dokument.",
+  "tool.delete_item": "Löscht ein Seitenelement anhand des Namens.",
+  "tool.delete_layer": "Löscht eine Ebene und alles darauf.",
+  "tool.delete_swatch": "Löscht ein Farbfeld aus dem Dokument.",
+  "tool.delete_symbol": "Löscht eine Symboldefinition aus dem Dokument (vorhandene Instanzen werden zu normaler Grafik).",
+  "tool.deselect_all": "Hebt die Auswahl im aktiven Dokument auf.",
+  "tool.distribute_items": "Verteilt 3 oder mehr Elemente mit gleichem Abstand zwischen ihren Kanten entlang einer Achse.",
+  "tool.duplicate_item": "Dupliziert ein Seitenelement. Gibt den (automatisch generierten) Namen des neuen Elements zurück.",
+  "tool.duplicate_layer": "Dupliziert eine Ebene und alles darauf (Layer hat im Illustrator-DOM kein direktes duplicate(), daher wird eine neue Ebene erstellt und jedes Element hineindupliziert). Gibt den Namen der neuen Ebene zurück.",
+  "tool.embed_placed_item": "Bettet ein verknüpftes platziertes Element in das Dokument ein (verweist nicht mehr auf die externe Datei).",
+  "tool.export_jpg": "Exportiert das aktive Dokument (oder eine Zeichenfläche) als JPEG.",
+  "tool.export_pdf": "Speichert das aktive Dokument als PDF (über Speichern unter, nicht Exportieren — PDF ist in Illustrator ein natives Speicherformat).",
+  "tool.export_png": "Exportiert das aktive Dokument (oder eine Zeichenfläche) als transparentes PNG-24.",
+  "tool.export_svg": "Exportiert das aktive Dokument als SVG.",
+  "tool.find_replace_text": "Sucht und ersetzt eine Teilzeichenfolge in allen Textrahmen des aktiven Dokuments. Gibt zurück, wie viele Rahmen geändert wurden.",
+  "tool.flip_item": "Spiegelt ein Seitenelement horizontal und/oder vertikal um seinen eigenen Mittelpunkt.",
+  "tool.get_document_info": "Infos zum aktiven Dokument: aktive Zeichenfläche, Anzahl der Zeichenflächen, Farbmodus, Einheiten, Ebenen.",
+  "tool.get_gradient": "Gibt Typ und Farbstopps eines Farbverlaufs zurück.",
+  "tool.get_item": "Informationen zu einem Seitenelement anhand des Namens: Typ, Begrenzung, Ebene und (bei Pfaden) Füllung/Kontur.",
+  "tool.get_item_bounds": "Geometrische Begrenzung (links, oben, rechts, unten, Breite, Höhe, in Punkt) eines Seitenelements.",
+  "tool.get_layer": "Infos zu einer Ebene anhand des Namens.",
+  "tool.get_path_points": "Gibt die Ankerpunkte und Bézier-Griffe eines Pfads zurück (in derselben Y-nach-unten-Konvention, die create_path_from_points verwendet).",
+  "tool.get_ruler_units": "Gibt die Lineal-Einheiten des Dokuments zurück.",
+  "tool.get_selection": "Listet die im Dokument aktuell ausgewählten Seitenelemente auf.",
+  "tool.get_text_contents": "Gibt den Textinhalt eines Textrahmens zurück.",
+  "tool.group_items": "Gruppiert Seitenelemente zu einem neuen GroupItem. Gibt den Namen der Gruppe zurück.",
+  "tool.il_healthcheck": "Prüft die Verbindung zu Illustrator: Version und aktives Dokument.",
+  "tool.il_info": "App-Infos: Version, geöffnete Dokumente.",
+  "tool.invert_selection": "Wählt alle Seitenelemente aus, die aktuell NICHT ausgewählt sind, und hebt die Auswahl der zuvor ausgewählten auf.",
+  "tool.list_artboards": "Listet die Zeichenflächen des Dokuments auf (Name, Begrenzung).",
+  "tool.list_brushes": "Listet die Pinsel des Dokuments nach Namen auf (die Skripting-API von Illustrator gibt den Pinseltyp -- Kunst/Kalligrafie/Muster/Streuung -- nicht preis, daher fehlt er).",
+  "tool.list_character_styles": "Listet die benannten Zeichenformatvorlagen des Dokuments auf.",
+  "tool.list_documents": "Listet die geöffneten Dokumente auf.",
+  "tool.list_fonts": "Listet eine Stichprobe der verfügbaren PostScript-Schriftnamen auf (die ersten 200 — Illustrator kann Tausende installiert haben).",
+  "tool.list_gradients": "Listet die Farbverläufe des Dokuments auf (Name, Typ, Anzahl der Farbstopps).",
+  "tool.list_group_children": "Listet die direkten Kindelemente eines GroupItem auf.",
+  "tool.list_items": "Listet die Seitenelemente des aktiven Dokuments auf (Name, Typ, Begrenzung). Optional auf eine Ebene nach Namen eingeschränkt.",
+  "tool.list_layers": "Listet den Ebenenbaum des aktiven Dokuments auf (Name, sichtbar, gesperrt, Anzahl der Objekte nach Typ).",
+  "tool.list_paragraph_styles": "Listet die benannten Absatzformatvorlagen des Dokuments auf.",
+  "tool.list_patterns": "Listet die Musterfelder des Dokuments auf.",
+  "tool.list_placed_items": "Listet die im Dokument platzierten (verknüpften oder eingebetteten) Raster-/Vektordateien auf.",
+  "tool.list_spot_colors": "Listet die Schmuckfarben des Dokuments auf.",
+  "tool.list_swatch_groups": "Listet die Farbfeldgruppen (Farbgruppen) des Dokuments und ihre jeweiligen Farbfelder auf.",
+  "tool.list_swatches": "Listet die Farbfelder des Dokuments auf.",
+  "tool.list_symbols": "Listet die Symbole des Dokuments auf.",
+  "tool.make_clipping_mask": "Gruppiert Elemente und verwendet eines davon (maskItemName, muss ein Pfad/zusammengesetzter Pfad sein) als Schnittmaske für den Rest. Gibt den Namen der Gruppe zurück.",
+  "tool.make_compound_path": "Kombiniert Pfadelemente zu einem einzigen CompoundPathItem (z. B. für Donut-Formen mit Löchern). Gibt den Namen des zusammengesetzten Pfads zurück.",
+  "tool.move_item": "Verschiebt ein Seitenelement an eine absolute Position (obere linke Ecke seines Begrenzungsrahmens, in Punkt).",
+  "tool.move_item_to_layer": "Verschiebt ein Seitenelement in eine andere Ebene.",
+  "tool.move_layer": "Ordnet eine Ebene nach vorn, nach hinten oder relativ zu einer anderen Ebene an.",
+  "tool.open_document": "Öffnet eine Datei.",
+  "tool.outline_text": "Wandelt einen Textrahmen in Konturen um (bearbeitbare Vektorpfade). Gibt den Namen der resultierenden Gruppe zurück — der ursprüngliche Textrahmen wird ersetzt.",
+  "tool.place_symbol_instance": "Platziert eine Instanz eines vorhandenen Symbols bei (x, y).",
+  "tool.play_action": "Spielt eine vorhandene Illustrator-Aktion (aus dem Bedienfeld Aktionen) anhand von Aktions- und Satznamen ab.",
+  "tool.release_clipping_mask": "Löst eine Schnittmaskengruppe wieder in ihre einzelnen Elemente auf (hebt Schnittmaske und Gruppierung auf).",
+  "tool.release_compound_path": "Löst ein CompoundPathItem wieder in seine einzelnen PathItems auf.",
+  "tool.release_guide": "Wandelt eine Hilfslinie zurück in einen normalen, bearbeitbaren Pfad um.",
+  "tool.relink_placed_item": "Verweist ein platziertes Element auf eine andere Datei auf der Festplatte um.",
+  "tool.rename_artboard": "Benennt eine Zeichenfläche anhand des Index um.",
+  "tool.rename_item": "Benennt ein Seitenelement um (über Elementnamen sprechen andere Tools ein bestimmtes Element an).",
+  "tool.rename_layer": "Benennt eine Ebene um.",
+  "tool.rename_symbol": "Benennt eine Symboldefinition um.",
+  "tool.resize_item": "Skaliert ein Seitenelement um seinen Mittelpunkt nach Prozent (100 = keine Änderung).",
+  "tool.rotate_item": "Dreht ein Seitenelement um seinen Mittelpunkt in Grad (positiv = gegen den Uhrzeigersinn).",
+  "tool.run_jsx": "Führt beliebiges ExtendScript in Illustrator aus. Der Code kann 'return' verwenden. Gibt {ok,data} zurück.",
+  "tool.run_jsx_json": "Führt ExtendScript aus, das einen serialisierbaren Wert (JSON) zurückgibt. Wie run_jsx, aber für Daten gedacht.",
+  "tool.save_document": "Speichert das aktive Dokument.",
+  "tool.save_document_as": "Speichert das aktive Dokument als neue .ai-Datei.",
+  "tool.select_items": "Legt die Auswahl des aktiven Dokuments auf die angegebenen Seitenelemente fest (nach Namen). Übergeben Sie ein leeres Array, um sie zu löschen.",
+  "tool.select_same_fill_color": "Wählt alle Seitenelemente im Dokument aus, deren Füllfarbe exakt mit der eines Referenzelements übereinstimmt.",
+  "tool.send_backward": "Verschiebt ein Seitenelement eine Ebene nach hinten in der Stapelreihenfolge seiner Ebene.",
+  "tool.send_to_back": "Schickt ein Seitenelement an das Ende der Stapelreihenfolge seiner Ebene.",
+  "tool.set_active_artboard": "Legt fest, welcher Zeichenflächen-Index aktiv ist (betrifft Tools, die standardmäßig „die aktive Zeichenfläche” verwenden, z. B. get_document_info).",
+  "tool.set_blend_mode": "Legt die Füllmethode eines Seitenelements fest.",
+  "tool.set_fill_color": "Legt die Füllfarbe eines Seitenelements fest oder entfernt die Füllung, wenn keine Farbe angegeben ist.",
+  "tool.set_group_clipped": "Low-Level: legt direkt fest, ob das oberste Element einer vorhandenen Gruppe als deren Schnittmaske verwendet wird.",
+  "tool.set_item_locked": "Sperrt oder entsperrt ein Seitenelement.",
+  "tool.set_item_visible": "Blendet ein Seitenelement ein oder aus.",
+  "tool.set_layer_color": "Legt die Auswahl-/Konturfarbe einer Ebene fest (im Bedienfeld Ebenen sowie als Auswahl-Hervorhebungsfarbe ihrer Elemente angezeigt), nicht die Grafik.",
+  "tool.set_layer_locked": "Sperrt eine Ebene oder hebt die Sperrung auf.",
+  "tool.set_layer_visible": "Blendet eine Ebene ein oder aus.",
+  "tool.set_opacity": "Legt die Deckkraft eines Seitenelements fest (0-100).",
+  "tool.set_path_closed": "Öffnet oder schließt einen Pfad.",
+  "tool.set_path_points": "Ersetzt die Ankerpunkte eines Pfads vollständig (gerade Segmente; gleiche Y-nach-unten-Konvention).",
+  "tool.set_ruler_units": "Legt die Lineal-Einheiten des Dokuments fest.",
+  "tool.set_stroke_cap": "Legt den Kappenstil der Kontur eines Pfads fest.",
+  "tool.set_stroke_color": "Legt die Konturfarbe eines Seitenelements fest oder entfernt die Kontur, wenn keine Farbe angegeben ist.",
+  "tool.set_stroke_dashes": "Legt das Strichmuster eines Pfads fest (Längen in Punkt, z. B. [4,2] für Strich-Lücke-Strich-Lücke). Für eine durchgezogene Linie ein leeres Array übergeben.",
+  "tool.set_stroke_join": "Legt den Eckenstil der Kontur eines Pfads fest.",
+  "tool.set_stroke_miter_limit": "Legt den Gehrungswinkel-Grenzwert eines Pfads fest (1-500; betrifft nur Gehrungsecken).",
+  "tool.set_stroke_width": "Legt die Konturstärke eines Seitenelements in Punkt fest.",
+  "tool.set_symbol_instance_symbol": "Verweist eine vorhandene Symbolinstanz auf eine andere Symboldefinition um.",
+  "tool.set_text_contents": "Legt den Textinhalt eines Textrahmens fest.",
+  "tool.set_text_justification": "Legt die Absatzausrichtung eines Textrahmens fest.",
+  "tool.set_text_leading": "Legt den Zeilenabstand eines Textrahmens in Punkt fest. Deaktiviert den automatischen Zeilenabstand (standardmäßig aktiv für Text), da ein zugewiesener Wert bei aktivem automatischem Zeilenabstand stillschweigend ignoriert wird.",
+  "tool.set_text_style": "Legt die Zeichenformatierung für den gesamten Inhalt eines Textrahmens fest: Schriftart (PostScript-Name, z. B. „Helvetica-Bold”), Größe (pt), Füllfarbe und/oder Laufweite.",
+  "tool.shear_item": "Schert (neigt) ein Seitenelement um seinen eigenen Mittelpunkt in Grad entlang einer Achse.",
+  "tool.translate_item": "Verschiebt ein Seitenelement relativ zu seiner aktuellen Position, in Punkt.",
+  "tool.ungroup_item": "Gruppiert ein GroupItem auf, indem seine Kindelemente in das übergeordnete Element der Gruppe verschoben werden.",
+  "ui.i18n.language": "Sprache",
+  "ui.i18n.restartNote": "Die Beschreibungen der KI-Tools wechseln die Sprache, nachdem Sie den MCP-Server (oder die App, die ihn ausführt) neu gestartet haben.",
+  "ui.i18n.saveFailed": "Die Spracheinstellung konnte nicht gespeichert werden. Sie gilt nur für diese Sitzung.",
+  "ui.i18n.saved": "Sprache gespeichert.",
+  "ui.log.backupFailed": "Sicherung von {file} fehlgeschlagen: {message}",
+  "ui.log.bridgeError": "Bridge-Fehler: {message}",
+  "ui.log.clear": "leeren",
+  "ui.log.clearTitle": "Protokoll leeren",
+  "ui.log.clientConnected": "MCP-Client verbunden ({count})",
+  "ui.log.clientDisconnected": "MCP-Client getrennt ({count})",
+  "ui.log.commitFailed": "Übernahme fehlgeschlagen (zurückgesetzt): {message}",
+  "ui.log.downloadFailed": "Download von {file} fehlgeschlagen: {message}",
+  "ui.log.downloading": "{file} wird heruntergeladen...",
+  "ui.log.licenseSaveError": "Fehler beim Speichern des Lizenzschlüssels: {message}",
+  "ui.log.listening": "Bridge lauscht auf 127.0.0.1:{port}",
+  "ui.log.noUpdate": "Kein Update vorhanden",
+  "ui.log.portInUse": "Port {port} belegt: {message}",
+  "ui.log.portRetry": "Port {port} weiterhin belegt, neuer Versuch ({attempt}/{max})...",
+  "ui.log.restartingBridge": "Bridge wird neu gestartet...",
+  "ui.log.shaMismatch": "SHA256 von {file} stimmt nicht überein (erhalten {got}..., erwartet {expected}...)",
+  "ui.log.sizeDiffers": "Größe von {file} weicht vom Manifest ab ({got} vs. {expected}) — wird fortgesetzt",
+  "ui.log.title": "Aktivitätsprotokoll",
+  "ui.log.toggleTitle": "Protokoll ein-/ausblenden",
+  "ui.log.updateAborted": "Update abgebrochen: {reason}",
+  "ui.log.updateApplied": "Update v{version} angewendet. STARTEN SIE ILLUSTRATOR NEU, um das neue Bedienfeld zu laden.",
+  "ui.log.updateNoLicense": "Update fehlgeschlagen: kein Lizenzschlüssel gespeichert. Öffnen Sie die Einstellungen (⚙) und fügen Sie Ihren Lizenzschlüssel ein.",
+  "ui.log.wsLoadFailed": "'ws' konnte nicht geladen werden: {message} (--enable-nodejs?)",
+  "ui.product.subtitle": "Bridge · in Entwicklung",
+  "ui.settings.licenseEmpty": "Geben Sie vor dem Speichern einen Lizenzschlüssel ein.",
+  "ui.settings.licenseKey": "Lizenzschlüssel",
+  "ui.settings.licenseNotSaved": "Noch kein Lizenzschlüssel gespeichert — für Updates erforderlich.",
+  "ui.settings.licensePlaceholder": "Illustrator MCP-Lizenzschlüssel einfügen",
+  "ui.settings.licenseSaveFailed": "Lizenzschlüssel konnte nicht gespeichert werden (siehe Protokoll).",
+  "ui.settings.licenseSaved": "Lizenzschlüssel gespeichert.",
+  "ui.settings.saveLicense": "Lizenz speichern",
+  "ui.shell.builtBy": "Entwickelt von",
+  "ui.shell.openSite": "synthetic.com.ar öffnen",
+  "ui.status.active": "Bridge aktiv",
+  "ui.status.clientsMany": "{count} MCP-Clients",
+  "ui.status.clientsOne": "{count} MCP-Client",
+  "ui.status.error": "Fehler: {message}",
+  "ui.status.nodeUnavailable": "Node/ws nicht verfügbar",
+  "ui.status.port": "Port {port}",
+  "ui.status.portOpenFailed": "Port {port} konnte nicht geöffnet werden",
+  "ui.status.restart": "Neu starten",
+  "ui.status.starting": "Bridge wird gestartet…",
+  "ui.status.stopped": "Gestoppt",
+  "ui.status.updateApplied": "Update angewendet — Illustrator neu starten",
+  "ui.status.updateFailed": "Update fehlgeschlagen",
+  "ui.status.waitingForClient": "warte auf Client",
+  "ui.status.wsNoServer": "ws hat keinen WebSocketServer",
+  "ui.toolbar.reload": "Bedienfeld neu laden",
+  "ui.toolbar.settings": "Einstellungen",
+  "ui.update.appliedBody": "Schließen Sie Illustrator und öffnen Sie es erneut, um v{version} zu aktivieren.",
+  "ui.update.appliedTitle": "Update angewendet.",
+  "ui.update.available": "Update verfügbar",
+  "ui.update.installerTitle": "Falls der Hot-Swap fehlschlägt oder das Release ein neues Manifest erfordert",
+  "ui.update.later": "Später",
+  "ui.update.now": "Jetzt aktualisieren",
+  "ui.update.ok": "OK",
+  "ui.update.updating": "Wird aktualisiert..."
+}