ae-agent-setup 0.2.0

package/host/lib/query_handlers.jsx

@@ -0,0 +1,427 @@
+function getLayers() {
+    try {
+        ensureJSON();
+        var comp = app.project.activeItem;
+        if (!comp || !(comp instanceof CompItem)) {
+            log("getLayers(): Active composition not found.");
+            return encodePayload({ status: "error", message: "Active composition not found." });
+        }
+
+        var layers = [];
+        for (var i = 1; i <= comp.numLayers; i++) {
+            var layer = comp.layer(i);
+            layers.push({
+                id: layer.index,
+                layerUid: aeTryGetLayerUid(layer),
+                name: layer.name,
+                type: getLayerTypeName(layer)
+            });
+        }
+        return encodePayload(layers);
+    } catch (e) {
+        log("getLayers() threw: " + e.toString());
+        return encodePayload({ status: "error", message: e.toString() });
+    }
+}
+
+function listComps() {
+    try {
+        ensureJSON();
+        if (!app.project) {
+            return encodePayload([]);
+        }
+
+        var activeComp = app.project.activeItem;
+        var activeCompId = null;
+        if (activeComp && activeComp instanceof CompItem) {
+            activeCompId = activeComp.id;
+        }
+
+        var comps = [];
+        for (var i = 1; i <= app.project.numItems; i++) {
+            var item = app.project.item(i);
+            if (!item || !(item instanceof CompItem)) {
+                continue;
+            }
+            comps.push({
+                id: item.id,
+                name: item.name,
+                width: item.width,
+                height: item.height,
+                pixelAspect: item.pixelAspect,
+                duration: item.duration,
+                frameRate: item.frameRate,
+                isActive: activeCompId !== null && item.id === activeCompId
+            });
+        }
+        return encodePayload(comps);
+    } catch (e) {
+        log("listComps() threw: " + e.toString());
+        return encodePayload({ status: "error", message: e.toString() });
+    }
+}
+
+function getProperties(layerId, optionsJSON) {
+    try {
+        ensureJSON();
+        var comp = app.project.activeItem;
+        if (!comp || !(comp instanceof CompItem)) {
+            log("getProperties(): Active composition not found.");
+            return encodePayload({ status: "Error", message: "Active composition not found." });
+        }
+
+        var options = {};
+        if (optionsJSON && optionsJSON !== "null") {
+            try {
+                options = JSON.parse(optionsJSON);
+            } catch (e) {
+                log("getProperties(): Failed to parse options JSON - " + e.toString());
+                options = {};
+            }
+        }
+
+        function normalizeStringArray(value) {
+            if (!value) {
+                return [];
+            }
+            if (value instanceof Array) {
+                var filtered = [];
+                for (var i = 0; i < value.length; i++) {
+                    var entry = value[i];
+                    if (typeof entry === "string" && entry.length > 0) {
+                        filtered.push(entry);
+                    }
+                }
+                return filtered;
+            }
+            if (typeof value === "string" && value.length > 0) {
+                return [value];
+            }
+            return [];
+        }
+
+        function parseMaxDepth(rawDepth) {
+            if (rawDepth === null || rawDepth === undefined) {
+                return null;
+            }
+            var parsed = parseInt(rawDepth, 10);
+            if (isNaN(parsed) || parsed <= 0) {
+                return null;
+            }
+            return parsed;
+        }
+
+        var includeGroups = normalizeStringArray(options.includeGroups);
+        var excludeGroups = normalizeStringArray(options.excludeGroups);
+        var maxDepth = parseMaxDepth(options.maxDepth);
+        var includeGroupChildren = options.includeGroupChildren === true;
+        var evaluationTime = null;
+        if (options.time !== null && options.time !== undefined) {
+            evaluationTime = Number(options.time);
+            if (isNaN(evaluationTime)) {
+                return encodePayload({ status: "Error", message: "time must be a number." });
+            }
+        }
+
+        var layerName = null;
+        if (options.layerName !== null && options.layerName !== undefined) {
+            layerName = String(options.layerName);
+        }
+        var resolvedLayer = aeResolveLayer(comp, layerId, layerName);
+        if (resolvedLayer.error) {
+            log("getProperties(): " + resolvedLayer.error);
+            return encodePayload({ status: "Error", message: resolvedLayer.error });
+        }
+        var layer = resolvedLayer.layer;
+        var properties = [];
+
+        function shouldSkipTopLevel(matchName, depth) {
+            if (depth !== 0 || !matchName || matchName.length === 0) {
+                return false;
+            }
+            if (includeGroups.length > 0 && !aeArrayContains(includeGroups, matchName)) {
+                return true;
+            }
+            if (excludeGroups.length > 0 && aeArrayContains(excludeGroups, matchName)) {
+                return true;
+            }
+            return false;
+        }
+
+        function scanProperties(propGroup, pathPrefix, depth, forceRecursive) {
+            if (!propGroup || typeof propGroup.numProperties !== "number") {
+                return;
+            }
+            for (var i = 1; i <= propGroup.numProperties; i++) {
+                var prop = propGroup.property(i);
+                if (!prop) {
+                    continue;
+                }
+
+                var identifier = aeGetPropertyIdentifier(prop, i);
+                var currentPath = pathPrefix ? pathPrefix + "." + identifier : identifier;
+                var nextDepth = depth + 1;
+
+                var matchName = "";
+                try {
+                    matchName = prop.matchName || "";
+                } catch (eMatch) {}
+
+                if (shouldSkipTopLevel(matchName, depth)) {
+                    continue;
+                }
+                if (!forceRecursive && maxDepth !== null && nextDepth > maxDepth) {
+                    continue;
+                }
+
+                if (aeIsPropertyNode(prop)) {
+                    if (!aeCanExposeProperty(prop)) {
+                        continue;
+                    }
+                    var hasExpression = false;
+                    try {
+                        hasExpression = prop.expressionEnabled;
+                    } catch (e) {}
+                    properties.push({
+                        name: prop.name,
+                        path: currentPath,
+                        value: aePropertyValueToString(prop),
+                        hasExpression: hasExpression
+                    });
+                }
+
+                var shouldRecurse = aeCanTraverseProperty(prop)
+                    && (forceRecursive || maxDepth === null || nextDepth < maxDepth);
+                if (!shouldRecurse) {
+                    continue;
+                }
+                var childForceRecursive = forceRecursive;
+                if (includeGroupChildren && depth === 0 && matchName && aeArrayContains(includeGroups, matchName)) {
+                    childForceRecursive = true;
+                }
+                scanProperties(prop, currentPath, nextDepth, childForceRecursive);
+            }
+        }
+
+        var previousTime = null;
+        if (evaluationTime !== null) {
+            previousTime = comp.time;
+            comp.time = evaluationTime;
+        }
+        try {
+            scanProperties(layer, "", 0, false);
+        } finally {
+            if (evaluationTime !== null && previousTime !== null) {
+                comp.time = previousTime;
+            }
+        }
+        return encodePayload(properties);
+    } catch (e) {
+        log("getProperties() threw: " + e.toString());
+        return encodePayload({ status: "Error", message: e.toString() });
+    }
+}
+
+function getSelectedProperties() {
+    try {
+        ensureJSON();
+        var comp = app.project.activeItem;
+        if (!comp || !(comp instanceof CompItem)) {
+            return encodePayload({ status: "Error", message: "Active composition not found." });
+        }
+
+        var selectedLayers = comp.selectedLayers;
+        if (!selectedLayers || selectedLayers.length === 0) {
+            return encodePayload([]);
+        }
+
+        function getPathIdentifier(prop) {
+            return aeGetPropertyIdentifier(prop, null);
+        }
+
+        function buildPropertyPath(prop) {
+            var segments = [];
+            var current = prop;
+            var guard = 0;
+            while (current && guard < 100) {
+                var parent = null;
+                try {
+                    parent = current.parentProperty;
+                } catch (eParent) {
+                    parent = null;
+                }
+                if (!parent) {
+                    break;
+                }
+                segments.unshift(getPathIdentifier(current));
+                current = parent;
+                guard += 1;
+            }
+            if (segments.length === 0) {
+                return "";
+            }
+            return segments.join(".");
+        }
+
+        var selectedPropsPayload = [];
+        for (var i = 0; i < selectedLayers.length; i++) {
+            var layer = selectedLayers[i];
+            if (!layer) {
+                continue;
+            }
+            var props;
+            try {
+                props = layer.selectedProperties;
+            } catch (eProps) {
+                props = null;
+            }
+            if (!props || props.length === 0) {
+                continue;
+            }
+            for (var j = 0; j < props.length; j++) {
+                var prop = props[j];
+                if (!prop || !aeIsPropertyNode(prop) || !aeCanExposeProperty(prop)) {
+                    continue;
+                }
+
+                var path = buildPropertyPath(prop);
+                if (!path || path.length === 0) {
+                    continue;
+                }
+
+                var hasExpression = false;
+                try {
+                    hasExpression = prop.expressionEnabled;
+                } catch (eHas) {}
+
+                selectedPropsPayload.push({
+                    layerId: layer.index,
+                    layerName: layer.name,
+                    name: prop.name,
+                    path: path,
+                    value: aePropertyValueToString(prop),
+                    hasExpression: hasExpression
+                });
+            }
+        }
+
+        return encodePayload(selectedPropsPayload);
+    } catch (e) {
+        log("getSelectedProperties() threw: " + e.toString());
+        return encodePayload({ status: "Error", message: e.toString() });
+    }
+}
+
+function getExpressionErrors() {
+    try {
+        ensureJSON();
+        var comp = app.project.activeItem;
+        if (!comp || !(comp instanceof CompItem)) {
+            return encodePayload({ status: "Error", message: "Active composition not found." });
+        }
+
+        function getPathIdentifier(prop) {
+            return aeGetPropertyIdentifier(prop, null);
+        }
+
+        function buildPropertyPath(prop) {
+            var segments = [];
+            var current = prop;
+            var guard = 0;
+            while (current && guard < 100) {
+                var parent = null;
+                try {
+                    parent = current.parentProperty;
+                } catch (eParent) {
+                    parent = null;
+                }
+                if (!parent) {
+                    break;
+                }
+                segments.unshift(getPathIdentifier(current));
+                current = parent;
+                guard += 1;
+            }
+            if (segments.length === 0) {
+                return "";
+            }
+            return segments.join(".");
+        }
+
+        function collectLayerExpressionErrors(layer) {
+            var issues = [];
+            function scan(prop) {
+                if (!prop) {
+                    return;
+                }
+
+                if (aeCanTraverseProperty(prop)) {
+                    for (var i = 1; i <= prop.numProperties; i++) {
+                        scan(prop.property(i));
+                    }
+                    return;
+                }
+
+                var canSetExpression = false;
+                try {
+                    canSetExpression = prop.canSetExpression === true;
+                } catch (eCanSet) {}
+                if (!canSetExpression) {
+                    return;
+                }
+
+                var enabled = false;
+                try {
+                    enabled = prop.expressionEnabled === true;
+                } catch (eEnabled) {}
+                if (!enabled) {
+                    return;
+                }
+
+                var errorMessage = null;
+                try {
+                    if (typeof prop.expressionError === "string" && prop.expressionError.length > 0) {
+                        errorMessage = prop.expressionError;
+                    }
+                } catch (eErrorRead) {}
+                if (!errorMessage) {
+                    return;
+                }
+
+                issues.push({
+                    layerId: layer.index,
+                    layerUid: aeTryGetLayerUid(layer),
+                    layerName: layer.name,
+                    propertyPath: buildPropertyPath(prop),
+                    propertyName: prop.name,
+                    message: errorMessage
+                });
+            }
+
+            scan(layer);
+            return issues;
+        }
+
+        var allIssues = [];
+        for (var i = 1; i <= comp.numLayers; i++) {
+            var layer = comp.layer(i);
+            if (!layer) {
+                continue;
+            }
+            var layerIssues = collectLayerExpressionErrors(layer);
+            for (var j = 0; j < layerIssues.length; j++) {
+                allIssues.push(layerIssues[j]);
+            }
+        }
+
+        return encodePayload({
+            compId: comp.id,
+            compName: comp.name,
+            count: allIssues.length,
+            issues: allIssues
+        });
+    } catch (e) {
+        log("getExpressionErrors() threw: " + e.toString());
+        return encodePayload({ status: "Error", message: e.toString() });
+    }
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "ae-agent-setup",
+  "version": "0.2.0",
+  "description": "One-command installer for the ae-agent-skill After Effects extension and CLI.",
+  "type": "module",
+  "bin": {
+    "ae-agent-setup": "bin/ae-agent-setup.mjs"
+  },
+  "files": [
+    "bin",
+    "templates",
+    "scripts/signing",
+    "CSXS",
+    "client",
+    "host"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT"
+}

package/scripts/signing/build-zxp.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Build a signed ZXP from this repository.
+# Required env:
+#   SIGN_CERT_P12=certs/dev-cert.p12
+#   SIGN_CERT_PASSWORD=your-pass
+# Optional env:
+#   ZXPSIGNCMD_BIN=ZXPSignCmd
+
+ROOT_DIR="$(cd "$(dirname "$0")/../.." && pwd)"
+ZXPSIGNCMD_BIN="${ZXPSIGNCMD_BIN:-ZXPSignCmd}"
+DIST_DIR="${DIST_DIR:-${ROOT_DIR}/dist}"
+STAGE_DIR="${DIST_DIR}/stage/ae-agent-skill"
+CERT_P12="${SIGN_CERT_P12:-}"
+CERT_PASSWORD="${SIGN_CERT_PASSWORD:-}"
+TIMESTAMP_URL="${TIMESTAMP_URL:-http://timestamp.digicert.com}"
+
+if [[ -z "${CERT_P12}" ]]; then
+  echo "SIGN_CERT_P12 is required. Example: SIGN_CERT_P12=certs/dev-cert.p12" >&2
+  exit 1
+fi
+
+if [[ -z "${CERT_PASSWORD}" ]]; then
+  echo "SIGN_CERT_PASSWORD is required." >&2
+  exit 1
+fi
+
+if ! command -v "${ZXPSIGNCMD_BIN}" >/dev/null 2>&1; then
+  echo "ZXPSignCmd not found. Set ZXPSIGNCMD_BIN or install ZXPSignCmd." >&2
+  exit 1
+fi
+
+if [[ ! -f "${ROOT_DIR}/CSXS/manifest.xml" ]]; then
+  echo "CSXS/manifest.xml not found." >&2
+  exit 1
+fi
+
+VERSION="$(rg -o 'ExtensionBundleVersion=\"[^\"]+\"' "${ROOT_DIR}/CSXS/manifest.xml" | head -n1 | sed -E 's/.*\"([^\"]+)\"/\1/')"
+if [[ -z "${VERSION}" ]]; then
+  echo "Failed to parse ExtensionBundleVersion from CSXS/manifest.xml" >&2
+  exit 1
+fi
+
+OUT_ZXP="${DIST_DIR}/ae-agent-skill-${VERSION}.zxp"
+
+rm -rf "${STAGE_DIR}"
+mkdir -p "${STAGE_DIR}" "${DIST_DIR}"
+
+cp -R "${ROOT_DIR}/CSXS" "${STAGE_DIR}/"
+cp -R "${ROOT_DIR}/client" "${STAGE_DIR}/"
+cp -R "${ROOT_DIR}/host" "${STAGE_DIR}/"
+
+"${ZXPSIGNCMD_BIN}" -sign "${STAGE_DIR}" "${OUT_ZXP}" "${CERT_P12}" "${CERT_PASSWORD}" -tsa "${TIMESTAMP_URL}"
+
+echo "Built signed ZXP: ${OUT_ZXP}"

package/scripts/signing/create-dev-cert.sh

@@ -0,0 +1,97 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Create a development self-signed certificate for CEP extension signing.
+# Usage:
+#   scripts/signing/create-dev-cert.sh --password "your-pass"
+# Optional:
+#   --country JP --state Tokyo --org "Example Inc." --unit Dev --name "Your Name" --email you@example.com
+
+CERT_DIR="${CERT_DIR:-certs}"
+CERT_FILE="${CERT_FILE:-${CERT_DIR}/dev-cert.p12}"
+KEY_FILE="${KEY_FILE:-${CERT_DIR}/dev-cert.key.pem}"
+CRT_FILE="${CRT_FILE:-${CERT_DIR}/dev-cert.crt.pem}"
+
+COUNTRY="JP"
+STATE="Tokyo"
+CITY="Tokyo"
+ORG="AE Agent Skills"
+UNIT="Development"
+NAME="AE Agent Skills Dev"
+EMAIL="dev@example.com"
+PASSWORD=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --password)
+      PASSWORD="$2"
+      shift 2
+      ;;
+    --country)
+      COUNTRY="$2"
+      shift 2
+      ;;
+    --state)
+      STATE="$2"
+      shift 2
+      ;;
+    --org)
+      ORG="$2"
+      shift 2
+      ;;
+    --city)
+      CITY="$2"
+      shift 2
+      ;;
+    --unit)
+      UNIT="$2"
+      shift 2
+      ;;
+    --name)
+      NAME="$2"
+      shift 2
+      ;;
+    --email)
+      EMAIL="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown argument: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+if [[ -z "${PASSWORD}" ]]; then
+  echo "Missing required argument: --password" >&2
+  exit 1
+fi
+
+if ! command -v openssl >/dev/null 2>&1; then
+  echo "openssl not found." >&2
+  exit 1
+fi
+
+mkdir -p "${CERT_DIR}"
+
+if [[ -f "${CERT_FILE}" || -f "${KEY_FILE}" || -f "${CRT_FILE}" ]]; then
+  echo "Certificate files already exist under ${CERT_DIR}. Remove them before recreating." >&2
+  exit 1
+fi
+
+SUBJECT="/C=${COUNTRY}/ST=${STATE}/L=${CITY}/O=${ORG}/OU=${UNIT}/CN=${NAME}/emailAddress=${EMAIL}"
+
+openssl req -x509 -newkey rsa:2048 -sha256 -days 3650 -nodes \
+  -subj "${SUBJECT}" \
+  -keyout "${KEY_FILE}" \
+  -out "${CRT_FILE}"
+
+openssl pkcs12 -export \
+  -inkey "${KEY_FILE}" \
+  -in "${CRT_FILE}" \
+  -out "${CERT_FILE}" \
+  -passout "pass:${PASSWORD}"
+
+echo "Created development certificate: ${CERT_FILE}"
+echo "Private key: ${KEY_FILE}"
+echo "Certificate: ${CRT_FILE}"

package/scripts/signing/install-zxp.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Install a signed ZXP package with ExManCmd.
+# Usage:
+#   scripts/signing/install-zxp.sh dist/ae-agent-skill-0.2.0.zxp
+# Optional env:
+#   EXMANCMD_BIN=ExManCmd
+
+EXMANCMD_BIN="${EXMANCMD_BIN:-ExManCmd}"
+ZXP_PATH="${1:-}"
+
+if [[ -z "${ZXP_PATH}" ]]; then
+  echo "Usage: $0 <path-to-zxp>" >&2
+  exit 1
+fi
+
+if ! command -v "${EXMANCMD_BIN}" >/dev/null 2>&1; then
+  echo "ExManCmd not found. Set EXMANCMD_BIN or install ExManCmd." >&2
+  exit 1
+fi
+
+if [[ ! -f "${ZXP_PATH}" ]]; then
+  echo "ZXP not found: ${ZXP_PATH}" >&2
+  exit 1
+fi
+
+"${EXMANCMD_BIN}" --install "${ZXP_PATH}"
+echo "Installed: ${ZXP_PATH}"

package/templates/skills/aftereffects-cli.SKILL.md

@@ -0,0 +1,74 @@
+---
+name: aftereffects-cli-legacy
+description: Command-by-command After Effects editing via ae-cli. Best for surgical edits on existing human-made scenes (especially partial expression/property changes) and for debugging.
+---
+
+# aftereffects-cli-legacy
+
+低レベル CLI 操作（命令型）のスキル。  
+新規構築の主軸は宣言型 `aftereffects-declarative` だが、**既存シーンへの外科的編集ではこのスキルを第一選択**にする。
+
+## 位置づけ
+
+- 新規を組み上げる: 宣言型 `apply-scene` が主役
+- 既存を部分修正する: 本スキル（命令型）が主役
+- 両者は排他的ではなく、同一作業内で併用してよい
+
+## このスキルを使うべきケース
+
+- 人間が作った既存シーン（scene JSON 未管理）に部分変更を入れる
+- 複雑な既存レイヤーへ expression をピンポイント適用/調整する
+- 既存 comp 全体を再宣言せず、1-2 箇所だけ安全に直したい
+- 調査/デバッグで単発コマンドを叩きたい
+- 宣言型で未対応の操作が必要
+
+## 基本フロー
+
+1. まず疎通確認: `ae-cli health`
+2. 状態確認:
+   - `ae-cli list-comps`
+   - `ae-cli layers`
+   - `ae-cli selected-properties`
+   - `ae-cli expression-errors`
+3. 必要な更新コマンドを最小回数で実行
+4. 変更後に `layers` / `properties` で結果確認
+
+## 宣言型へ切り替える目安
+
+- 同種の変更を複数レイヤーへ繰り返す
+- 再実行可能な形で変更履歴を残したい
+- 変更対象を `layers[].id` で安定管理できる
+- シーン全体を再構築/置換したい
+
+## 主要コマンド（レガシー）
+
+- comp:
+  - `ae-cli create-comp ...`
+  - `ae-cli set-active-comp ...`
+  - `ae-cli delete-comp ...`
+- レイヤー/プロパティ:
+  - `ae-cli add-layer ...`
+  - `ae-cli set-property ...`
+  - `ae-cli set-keyframe ...`
+  - `ae-cli set-expression ...`
+  - `ae-cli add-effect ...`
+  - `ae-cli add-essential-property ...`
+  - `ae-cli add-shape-repeater ...`
+- タイムライン:
+  - `ae-cli set-in-out-point ...`
+  - `ae-cli move-layer-time ...`
+  - `ae-cli set-cti ...`
+  - `ae-cli set-work-area ...`
+- 構造編集:
+  - `ae-cli parent-layer ...`
+  - `ae-cli precompose ...`
+  - `ae-cli duplicate-layer ...`
+  - `ae-cli move-layer-order ...`
+  - `ae-cli delete-layer ...`
+
+## 注意
+
+- 既存シーンへの単発・部分修正は命令型の方が安全な場合が多い（影響範囲を局所化しやすい）。
+- 同じ処理を複数コマンドで繰り返す必要がある場合は、宣言型 `apply-scene` へ切り替える。
+- expression の不調は `ae-cli expression-errors` で確認する。
+- scene JSON を一時的に作る場合は `work/`（作業中）と `done/`（完了保管）を使い、どちらもコミットしない。