@engine-room/after-effects-mcp 0.1.0

package/bin/server.js

@@ -0,0 +1,1616 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/cli/init.ts
+import fs from "node:fs";
+import path from "node:path";
+var HOUSE_STYLE = `---
+name: house-style
+description: The visual and motion style for this project \u2014 palette, type, timing and layout rules. Load whenever building or editing anything in After Effects for this project.
+---
+
+# House style
+
+<!--
+  This file is yours. Claude reads it before building anything in After Effects,
+  so whatever you write here becomes the default look of your work.
+
+  Replace the placeholders below with your own values. Be specific and concrete:
+  "dark navy #131521 at 92% opacity" is usable, "modern and clean" is not. If a
+  number matters \u2014 a corner radius, a stroke width, a hold duration \u2014 write the
+  number down.
+
+  The fastest way to fill this in: build one piece the way you like it, then ask
+  Claude "read this comp and write it up in my house-style skill".
+-->
+
+## Palette
+
+| Role | Colour | Notes |
+|---|---|---|
+| Background | \`#000000\` | |
+| Primary text | \`#FFFFFF\` | |
+| Accent | \`#3DC46E\` | Used for emphasis and positive values |
+| Warning / negative | \`#E03333\` | |
+
+## Type
+
+- **Headings:** _font name_, weight, size range
+- **Body:** _font name_, weight, size range
+- **Tracking / leading:** _your defaults_
+- Text is left-aligned unless stated otherwise.
+
+## Motion
+
+- **Standard in:** scale 0 \u2192 108 \u2192 100 with easy ease, over ~0.4s
+- **Standard out:** scale \u2192 0 over ~0.3s
+- **Easing:** easy ease on everything; no linear motion unless mechanical
+- **Idle life:** subtle \`wiggle()\` on position so nothing sits perfectly still
+
+## Layout
+
+- Comp size and frame rate: _e.g. 1920\xD71080 at 30fps_
+- Safe margins: _e.g. 120px from every edge_
+- Where elements sit by default: _e.g. lower third, left-aligned_
+
+## Rules
+
+- _Anything that should always or never happen. E.g. "never put text directly on
+  footage \u2014 always on a rounded chip", "keep total runtime under 8 seconds"._
+`;
+var CLAUDE_MD = `# {{NAME}}
+
+After Effects project folder. Claude drives After Effects directly from here.
+
+## How to work in this folder
+
+1. Open After Effects with the project you want to work on.
+2. Describe what you want in plain language \u2014 "build a lower third that says
+   Chapter One and slides in from the left".
+3. Claude reads the current state of the comp, builds it, and shows you.
+
+## Style
+
+The look of everything built here is defined in
+\`.claude/skills/house-style/SKILL.md\`. Edit that file to change the defaults \u2014
+palette, type, timing, layout. It is read automatically.
+
+## Conventions for this project
+
+<!-- Anything specific to this project rather than to your general style:
+     naming conventions for comps and layers, delivery specs, the client's
+     requirements, what lives in which comp. -->
+
+- Renders go in \`renders/\`.
+`;
+var MCP_JSON = `{
+  "mcpServers": {
+    "after-effects": {
+      "command": "npx",
+      "args": ["-y", "@engine-room/after-effects-mcp"]
+    }
+  }
+}
+`;
+function parseInitArgs(argv) {
+  const positional = argv.filter((a) => !a.startsWith("-"));
+  const withMcp = argv.includes("--with-mcp");
+  const unknown = argv.filter((a) => a.startsWith("-") && a !== "--with-mcp");
+  if (unknown.length > 0) return { error: `Unknown option: ${unknown[0]}` };
+  if (positional.length === 0) return { error: "Missing target directory." };
+  if (positional.length > 1) return { error: `Expected one directory, got ${positional.length}.` };
+  return { dir: positional[0], withMcp };
+}
+function runInit(argv) {
+  const parsed = parseInitArgs(argv);
+  if ("error" in parsed) {
+    process.stderr.write(`${parsed.error}
+
+Usage: npx @engine-room/after-effects-mcp init <directory> [--with-mcp]
+`);
+    return 1;
+  }
+  const target = path.resolve(parsed.dir);
+  const name = path.basename(target);
+  const files = [
+    ["CLAUDE.md", CLAUDE_MD.replace("{{NAME}}", name)],
+    [path.join(".claude", "skills", "house-style", "SKILL.md"), HOUSE_STYLE],
+    [path.join("renders", ".gitkeep"), ""]
+  ];
+  if (parsed.withMcp) files.push([".mcp.json", MCP_JSON]);
+  const existing = files.map(([rel]) => rel).filter((rel) => fs.existsSync(path.join(target, rel)));
+  if (existing.length > 0) {
+    process.stderr.write(
+      `Refusing to overwrite existing files in ${target}:
+` + existing.map((f) => `  ${f}
+`).join("") + `
+Delete them first, or choose a different directory.
+`
+    );
+    return 1;
+  }
+  for (const [rel, content] of files) {
+    const full = path.join(target, rel);
+    fs.mkdirSync(path.dirname(full), { recursive: true });
+    fs.writeFileSync(full, content, "utf8");
+  }
+  const out = [
+    `Created ${target}`,
+    ``,
+    `  CLAUDE.md                                what this project is`,
+    `  .claude/skills/house-style/SKILL.md      your look \u2014 edit this first`,
+    `  renders/                                 exports land here`,
+    ...parsed.withMcp ? [`  .mcp.json                                connects Claude to After Effects`] : [],
+    ``,
+    `Next:`,
+    `  1. Open the folder in Claude Code:  claude ${parsed.dir}`,
+    `  2. Fill in .claude/skills/house-style/SKILL.md with your palette, type and timing.`,
+    `  3. Open After Effects, then ask for what you want.`,
+    ...parsed.withMcp ? [] : [
+      ``,
+      `This folder has no .mcp.json \u2014 it assumes you installed the Claude Code`,
+      `plugin, which already provides the After Effects tools. If you did not,`,
+      `re-run with --with-mcp to add a project-level connection instead.`
+    ],
+    ``
+  ].join("\n");
+  process.stdout.write(out);
+  return 0;
+}
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+// ../shared/dist/ipc.js
+import { z } from "zod";
+var OpRequest = z.object({
+  op: z.string(),
+  args: z.unknown().optional(),
+  requestId: z.string(),
+  progressToken: z.union([z.string(), z.number()]).optional()
+});
+var OpSyncResponse = z.object({
+  ok: z.literal(true),
+  result: z.unknown()
+});
+var OpAsyncResponse = z.object({
+  ok: z.literal(true),
+  jobId: z.string(),
+  async: z.literal(true)
+});
+var OpErrorResponse = z.object({
+  ok: z.literal(false),
+  error: z.string(),
+  stack: z.string().optional(),
+  line: z.number().optional()
+});
+var OpResponse = z.union([OpSyncResponse, OpAsyncResponse, OpErrorResponse]);
+var WsEvent = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("progress"),
+    jobId: z.string(),
+    progress: z.number(),
+    total: z.number().optional(),
+    message: z.string().optional()
+  }),
+  z.object({
+    type: z.literal("complete"),
+    jobId: z.string(),
+    result: z.unknown()
+  }),
+  z.object({
+    type: z.literal("error"),
+    jobId: z.string(),
+    error: z.string(),
+    stack: z.string().optional()
+  }),
+  z.object({
+    type: z.literal("log"),
+    level: z.enum(["debug", "info", "warn", "error"]),
+    message: z.string()
+  })
+]);
+
+// ../shared/dist/schemas.js
+var schemas_exports = {};
+__export(schemas_exports, {
+  AddEffect: () => AddEffect,
+  AddKeyframe: () => AddKeyframe,
+  AddMarker: () => AddMarker,
+  AddMask: () => AddMask,
+  AddShapeContent: () => AddShapeContent,
+  AddTextAnimator: () => AddTextAnimator,
+  AwaitJob: () => AwaitJob,
+  CancelJob: () => CancelJob,
+  CheckSetup: () => CheckSetup,
+  ClearExpression: () => ClearExpression,
+  Color: () => Color,
+  ColorRGBA: () => ColorRGBA,
+  CreateAdjustmentLayer: () => CreateAdjustmentLayer,
+  CreateCameraLayer: () => CreateCameraLayer,
+  CreateComp: () => CreateComp,
+  CreateLightLayer: () => CreateLightLayer,
+  CreateNullLayer: () => CreateNullLayer,
+  CreatePrecompLayer: () => CreatePrecompLayer,
+  CreateShapeLayer: () => CreateShapeLayer,
+  CreateSolidLayer: () => CreateSolidLayer,
+  CreateTextLayer: () => CreateTextLayer,
+  DeleteComp: () => DeleteComp,
+  DeleteLayer: () => DeleteLayer,
+  DuplicateLayer: () => DuplicateLayer,
+  FindLayers: () => FindLayers,
+  GetComp: () => GetComp,
+  GetCompTree: () => GetCompTree,
+  GetExpression: () => GetExpression,
+  GetJob: () => GetJob,
+  GetKeyframes: () => GetKeyframes,
+  GetLayerFull: () => GetLayerFull,
+  GetProjectSummary: () => GetProjectSummary,
+  Interpolation: () => Interpolation,
+  ListAvailableEffects: () => ListAvailableEffects,
+  ListComps: () => ListComps,
+  ListEffects: () => ListEffects,
+  ListLayers: () => ListLayers,
+  OpSchemas: () => OpSchemas,
+  ParentLayer: () => ParentLayer,
+  PropertyPath: () => PropertyPath,
+  RemoveEffect: () => RemoveEffect,
+  RemoveKeyframe: () => RemoveKeyframe,
+  RemoveMarker: () => RemoveMarker,
+  RemoveMask: () => RemoveMask,
+  ReorderLayer: () => ReorderLayer,
+  RunBatch: () => RunBatch,
+  RunJsx: () => RunJsx,
+  ScreenshotFrame: () => ScreenshotFrame,
+  ScreenshotLayer: () => ScreenshotLayer,
+  SetActiveComp: () => SetActiveComp,
+  SetComp: () => SetComp,
+  SetEffectEnabled: () => SetEffectEnabled,
+  SetEffectParam: () => SetEffectParam,
+  SetExpression: () => SetExpression,
+  SetInterpolation: () => SetInterpolation,
+  SetLayer: () => SetLayer,
+  SetMask: () => SetMask,
+  SetShapePath: () => SetShapePath,
+  SetShapeProperty: () => SetShapeProperty,
+  SetSpatialTangents: () => SetSpatialTangents,
+  SetTemporalEase: () => SetTemporalEase,
+  SetText: () => SetText,
+  SetTransform: () => SetTransform,
+  SetupPanel: () => SetupPanel,
+  ShapeContent: () => ShapeContent,
+  ToggleExpression: () => ToggleExpression,
+  Vec2: () => Vec2,
+  Vec3: () => Vec3,
+  VecAny: () => VecAny
+});
+import { z as z2 } from "zod";
+var Color = z2.tuple([z2.number(), z2.number(), z2.number()]).describe("RGB 0..1");
+var ColorRGBA = z2.tuple([z2.number(), z2.number(), z2.number(), z2.number()]);
+var Vec2 = z2.tuple([z2.number(), z2.number()]);
+var Vec3 = z2.tuple([z2.number(), z2.number(), z2.number()]);
+var VecAny = z2.union([z2.number(), Vec2, Vec3, z2.array(z2.number())]);
+var PropertyPath = z2.array(z2.union([z2.string(), z2.number()])).min(1).describe("Dotted property path into a layer, e.g. ['Transform','Position'] or ['Effects','Gaussian Blur','Blurriness'].");
+var Interpolation = z2.object({
+  in: z2.enum(["linear", "bezier", "hold"]).optional(),
+  out: z2.enum(["linear", "bezier", "hold"]).optional(),
+  easeIn: z2.object({ influence: z2.number(), speed: z2.number() }).optional(),
+  easeOut: z2.object({ influence: z2.number(), speed: z2.number() }).optional()
+});
+var ListComps = z2.object({}).strict();
+var GetComp = z2.object({ compId: z2.number() });
+var GetCompTree = z2.object({ compId: z2.number(), depth: z2.number().int().min(0).max(8).default(2).optional() });
+var CreateComp = z2.object({
+  name: z2.string().default("Untitled"),
+  width: z2.number().int().positive().default(1920),
+  height: z2.number().int().positive().default(1080),
+  frameRate: z2.number().positive().default(30),
+  duration: z2.number().positive().default(5),
+  pixelAspect: z2.number().positive().default(1).optional(),
+  bgColor: Color.optional()
+});
+var SetComp = z2.object({
+  compId: z2.number(),
+  name: z2.string().optional(),
+  width: z2.number().int().positive().optional(),
+  height: z2.number().int().positive().optional(),
+  frameRate: z2.number().positive().optional(),
+  duration: z2.number().positive().optional(),
+  workAreaStart: z2.number().optional(),
+  workAreaDuration: z2.number().positive().optional(),
+  bgColor: Color.optional()
+});
+var DeleteComp = z2.object({ compId: z2.number() });
+var SetActiveComp = z2.object({ compId: z2.number() });
+var ListLayers = z2.object({ compId: z2.number() });
+var GetLayerFull = z2.object({ compId: z2.number(), layerId: z2.number(), includeChildren: z2.boolean().default(false).optional() });
+var CreateTextLayer = z2.object({
+  compId: z2.number(),
+  text: z2.string().default(""),
+  font: z2.string().optional(),
+  size: z2.number().positive().optional(),
+  color: Color.optional(),
+  position: VecAny.optional(),
+  anchorAlign: z2.enum(["left", "center", "right", "none"]).default("left").optional().describe("Where the anchor point sits on the rendered text. Default 'left' makes `position` mean the visible left edge of the first character's baseline \u2014 the natural assumption. AE's addText() defaults to a centered anchor, which surprises agents; use 'none' to keep AE's raw default."),
+  name: z2.string().optional()
+});
+var CreateShapeLayer = z2.object({
+  compId: z2.number(),
+  name: z2.string().optional(),
+  shapes: z2.array(z2.record(z2.string(), z2.unknown())).default([]),
+  fill: Color.optional(),
+  stroke: Color.optional(),
+  strokeWidth: z2.number().nonnegative().optional()
+});
+var CreateSolidLayer = z2.object({
+  compId: z2.number(),
+  name: z2.string().optional(),
+  color: Color,
+  width: z2.number().int().positive().optional(),
+  height: z2.number().int().positive().optional(),
+  duration: z2.number().positive().optional()
+});
+var CreateNullLayer = z2.object({ compId: z2.number(), name: z2.string().optional() });
+var CreateAdjustmentLayer = z2.object({ compId: z2.number(), name: z2.string().optional() });
+var CreatePrecompLayer = z2.object({ compId: z2.number(), sourceCompId: z2.number(), position: VecAny.optional() });
+var CreateCameraLayer = z2.object({ compId: z2.number(), name: z2.string().optional(), oneNode: z2.boolean().default(false), position: VecAny.optional() });
+var CreateLightLayer = z2.object({
+  compId: z2.number(),
+  name: z2.string().optional(),
+  lightType: z2.enum(["parallel", "spot", "point", "ambient"]).default("point"),
+  color: Color.optional(),
+  intensity: z2.number().optional(),
+  position: VecAny.optional()
+});
+var DuplicateLayer = z2.object({ compId: z2.number(), layerId: z2.number(), count: z2.number().int().positive().default(1).optional() });
+var DeleteLayer = z2.object({ compId: z2.number(), layerId: z2.number() });
+var SetLayer = z2.object({
+  compId: z2.number(),
+  layerId: z2.number(),
+  name: z2.string().optional(),
+  enabled: z2.boolean().optional(),
+  locked: z2.boolean().optional(),
+  shy: z2.boolean().optional(),
+  solo: z2.boolean().optional(),
+  threeDLayer: z2.boolean().optional(),
+  blendingMode: z2.string().optional(),
+  label: z2.number().int().min(0).max(16).optional(),
+  inPoint: z2.number().optional(),
+  outPoint: z2.number().optional(),
+  startTime: z2.number().optional(),
+  stretch: z2.number().optional(),
+  preserveTransparency: z2.boolean().optional(),
+  trackMatte: z2.object({ type: z2.string(), layerId: z2.number().optional() }).optional()
+});
+var ParentLayer = z2.object({ compId: z2.number(), layerId: z2.number(), parentLayerId: z2.number().nullable() });
+var ReorderLayer = z2.object({ compId: z2.number(), layerId: z2.number(), toIndex: z2.number().int().positive() });
+var SetTransform = z2.object({
+  compId: z2.number(),
+  layerId: z2.number(),
+  time: z2.number().optional(),
+  keyframe: z2.boolean().default(false).optional(),
+  properties: z2.object({
+    position: VecAny.optional(),
+    scale: VecAny.optional(),
+    rotation: z2.number().optional(),
+    anchorPoint: VecAny.optional(),
+    opacity: z2.number().min(0).max(100).optional(),
+    orientation: Vec3.optional(),
+    xRotation: z2.number().optional(),
+    yRotation: z2.number().optional(),
+    zRotation: z2.number().optional()
+  })
+});
+var AddKeyframe = z2.object({
+  compId: z2.number(),
+  layerId: z2.number(),
+  propertyPath: PropertyPath,
+  time: z2.number(),
+  value: VecAny,
+  interpolation: Interpolation.optional()
+});
+var RemoveKeyframe = z2.object({
+  compId: z2.number(),
+  layerId: z2.number(),
+  propertyPath: PropertyPath,
+  time: z2.number()
+});
+var GetKeyframes = z2.object({
+  compId: z2.number(),
+  layerId: z2.number(),
+  propertyPath: PropertyPath
+});
+var SetInterpolation = z2.object({
+  compId: z2.number(),
+  layerId: z2.number(),
+  propertyPath: PropertyPath,
+  keyIndex: z2.number().int().positive(),
+  in: z2.enum(["linear", "bezier", "hold"]).optional(),
+  out: z2.enum(["linear", "bezier", "hold"]).optional()
+});
+var SetTemporalEase = z2.object({
+  compId: z2.number(),
+  layerId: z2.number(),
+  propertyPath: PropertyPath,
+  keyIndex: z2.number().int().positive(),
+  easeIn: z2.object({ influence: z2.number(), speed: z2.number() }).optional(),
+  easeOut: z2.object({ influence: z2.number(), speed: z2.number() }).optional()
+});
+var SetSpatialTangents = z2.object({
+  compId: z2.number(),
+  layerId: z2.number(),
+  propertyPath: PropertyPath,
+  keyIndex: z2.number().int().positive(),
+  inTangent: z2.array(z2.number()).min(2).max(3),
+  outTangent: z2.array(z2.number()).min(2).max(3)
+});
+var GetExpression = z2.object({ compId: z2.number(), layerId: z2.number(), propertyPath: PropertyPath });
+var SetExpression = z2.object({ compId: z2.number(), layerId: z2.number(), propertyPath: PropertyPath, expression: z2.string() });
+var ToggleExpression = z2.object({ compId: z2.number(), layerId: z2.number(), propertyPath: PropertyPath, enabled: z2.boolean() });
+var ClearExpression = z2.object({ compId: z2.number(), layerId: z2.number(), propertyPath: PropertyPath });
+var ListEffects = z2.object({ compId: z2.number(), layerId: z2.number() });
+var AddEffect = z2.object({ compId: z2.number(), layerId: z2.number(), matchName: z2.string() });
+var RemoveEffect = z2.object({ compId: z2.number(), layerId: z2.number(), effectIndex: z2.number().int().positive() });
+var SetEffectParam = z2.object({
+  compId: z2.number(),
+  layerId: z2.number(),
+  effectIndex: z2.number().int().positive(),
+  paramName: z2.string().optional(),
+  paramMatchName: z2.string().optional(),
+  value: VecAny,
+  time: z2.number().optional(),
+  keyframe: z2.boolean().default(false).optional()
+});
+var SetEffectEnabled = z2.object({ compId: z2.number(), layerId: z2.number(), effectIndex: z2.number().int().positive(), enabled: z2.boolean() });
+var ListAvailableEffects = z2.object({}).strict();
+var SetText = z2.object({
+  compId: z2.number(),
+  layerId: z2.number(),
+  text: z2.string().optional(),
+  font: z2.string().optional(),
+  size: z2.number().positive().optional(),
+  fillColor: Color.optional(),
+  strokeColor: Color.optional(),
+  strokeWidth: z2.number().nonnegative().optional(),
+  tracking: z2.number().optional(),
+  leading: z2.number().optional(),
+  justification: z2.enum(["left", "center", "right", "full"]).optional(),
+  applyFill: z2.boolean().optional(),
+  applyStroke: z2.boolean().optional(),
+  fauxBold: z2.boolean().optional(),
+  fauxItalic: z2.boolean().optional(),
+  allCaps: z2.boolean().optional(),
+  smallCaps: z2.boolean().optional(),
+  baselineShift: z2.number().optional()
+});
+var AddTextAnimator = z2.object({
+  compId: z2.number(),
+  layerId: z2.number(),
+  type: z2.enum(["position", "scale", "rotation", "opacity", "tracking", "skew", "fillColor", "strokeColor"]),
+  range: z2.object({ start: z2.number().default(0), end: z2.number().default(100), offset: z2.number().default(0) }).optional()
+});
+var SetShapePath = z2.object({
+  compId: z2.number(),
+  layerId: z2.number(),
+  shapePath: PropertyPath,
+  vertices: z2.array(Vec2),
+  inTangents: z2.array(Vec2).optional(),
+  outTangents: z2.array(Vec2).optional(),
+  closed: z2.boolean().default(true).optional()
+});
+var ShapeColor = z2.union([Color, ColorRGBA]);
+var ShapeContent = z2.discriminatedUnion("type", [
+  z2.object({
+    type: z2.literal("rect"),
+    name: z2.string().optional(),
+    size: Vec2.optional(),
+    position: Vec2.optional(),
+    roundness: z2.number().optional()
+  }).strict(),
+  z2.object({
+    type: z2.literal("ellipse"),
+    name: z2.string().optional(),
+    size: Vec2.optional(),
+    position: Vec2.optional()
+  }).strict(),
+  z2.object({
+    type: z2.literal("star"),
+    name: z2.string().optional(),
+    starType: z2.number().optional().describe("1 = star, 2 = polygon"),
+    points: z2.number().optional().describe("Number of points/sides"),
+    position: Vec2.optional(),
+    rotation: z2.number().optional(),
+    innerRadius: z2.number().optional(),
+    outerRadius: z2.number().optional(),
+    innerRoundness: z2.number().optional(),
+    outerRoundness: z2.number().optional()
+  }).strict(),
+  z2.object({
+    type: z2.literal("path"),
+    name: z2.string().optional(),
+    vertices: z2.array(Vec2).optional().describe("Bezier vertices in layer space"),
+    inTangents: z2.array(Vec2).optional(),
+    outTangents: z2.array(Vec2).optional(),
+    closed: z2.boolean().optional()
+  }).strict(),
+  z2.object({
+    type: z2.literal("fill"),
+    name: z2.string().optional(),
+    color: ShapeColor.optional(),
+    opacity: z2.number().optional().describe("0..100"),
+    fillRule: z2.number().optional()
+  }).strict(),
+  z2.object({
+    type: z2.literal("stroke"),
+    name: z2.string().optional(),
+    color: ShapeColor.optional(),
+    opacity: z2.number().optional().describe("0..100"),
+    width: z2.number().optional(),
+    lineCap: z2.number().optional(),
+    lineJoin: z2.number().optional(),
+    miterLimit: z2.number().optional()
+  }).strict(),
+  z2.object({
+    type: z2.literal("trim"),
+    name: z2.string().optional(),
+    start: z2.number().optional().describe("0..100"),
+    end: z2.number().optional().describe("0..100"),
+    offset: z2.number().optional()
+  }).strict(),
+  z2.object({
+    type: z2.literal("repeater"),
+    name: z2.string().optional(),
+    copies: z2.number().optional(),
+    offset: z2.number().optional()
+  }).strict(),
+  z2.object({
+    type: z2.literal("merge"),
+    name: z2.string().optional(),
+    mode: z2.number().optional()
+  }).strict(),
+  z2.object({
+    type: z2.literal("group"),
+    name: z2.string().optional()
+  }).strict()
+]);
+var AddShapeContent = z2.object({
+  compId: z2.number(),
+  layerId: z2.number(),
+  parentGroupPath: PropertyPath.optional(),
+  content: ShapeContent
+});
+var SetShapeProperty = z2.object({
+  compId: z2.number(),
+  layerId: z2.number(),
+  contentPath: PropertyPath,
+  property: z2.string(),
+  value: VecAny,
+  time: z2.number().optional(),
+  keyframe: z2.boolean().default(false).optional()
+});
+var AddMask = z2.object({
+  compId: z2.number(),
+  layerId: z2.number(),
+  vertices: z2.array(Vec2),
+  inTangents: z2.array(Vec2).optional(),
+  outTangents: z2.array(Vec2).optional(),
+  closed: z2.boolean().default(true).optional(),
+  mode: z2.string().default("ADD").optional()
+});
+var SetMask = z2.object({
+  compId: z2.number(),
+  layerId: z2.number(),
+  maskIndex: z2.number().int().positive(),
+  vertices: z2.array(Vec2).optional(),
+  inTangents: z2.array(Vec2).optional(),
+  outTangents: z2.array(Vec2).optional(),
+  closed: z2.boolean().optional(),
+  mode: z2.string().optional(),
+  inverted: z2.boolean().optional(),
+  expansion: z2.number().optional(),
+  feather: Vec2.optional(),
+  opacity: z2.number().optional()
+});
+var RemoveMask = z2.object({ compId: z2.number(), layerId: z2.number(), maskIndex: z2.number().int().positive() });
+var AddMarker = z2.object({
+  compId: z2.number(),
+  layerId: z2.number().optional(),
+  time: z2.number(),
+  duration: z2.number().nonnegative().default(0).optional(),
+  comment: z2.string().optional(),
+  label: z2.number().int().min(0).max(16).optional(),
+  chapter: z2.string().optional(),
+  url: z2.string().optional(),
+  frameTarget: z2.string().optional()
+});
+var RemoveMarker = z2.object({
+  compId: z2.number(),
+  layerId: z2.number().optional(),
+  markerIndex: z2.number().int().positive()
+});
+var ScreenshotFrame = z2.object({
+  compId: z2.number(),
+  time: z2.number().optional(),
+  downsample: z2.number().int().min(1).max(8).default(1).optional()
+});
+var ScreenshotLayer = z2.object({
+  compId: z2.number(),
+  layerId: z2.number(),
+  time: z2.number().optional(),
+  downsample: z2.number().int().min(1).max(8).default(1).optional()
+});
+var RunBatch = z2.object({
+  ops: z2.array(z2.object({ op: z2.string(), args: z2.unknown() })),
+  transactional: z2.boolean().default(true).optional(),
+  undoGroupName: z2.string().default("AE MCP Batch").optional()
+});
+var GetProjectSummary = z2.object({}).strict();
+var FindLayers = z2.object({
+  compId: z2.number().optional(),
+  namePattern: z2.string().optional(),
+  type: z2.string().optional(),
+  hasEffectMatchName: z2.string().optional()
+});
+var RunJsx = z2.object({ code: z2.string() });
+var CheckSetup = z2.object({}).strict();
+var SetupPanel = z2.object({
+  enableDebugMode: z2.boolean().default(true).optional().describe("Also enable Adobe's PlayerDebugMode preference, which AE requires to load this unsigned panel. Default true."),
+  force: z2.boolean().default(false).optional().describe("Replace an existing symlinked (development) install with a copy. Default false.")
+}).strict();
+var AwaitJob = z2.object({ jobId: z2.string(), timeoutMs: z2.number().int().positive().default(6e5).optional() });
+var GetJob = z2.object({ jobId: z2.string() });
+var CancelJob = z2.object({ jobId: z2.string() });
+var OpSchemas = {
+  // comps
+  list_comps: ListComps,
+  get_comp: GetComp,
+  get_comp_tree: GetCompTree,
+  create_comp: CreateComp,
+  set_comp: SetComp,
+  delete_comp: DeleteComp,
+  set_active_comp: SetActiveComp,
+  // layers
+  list_layers: ListLayers,
+  get_layer_full: GetLayerFull,
+  create_text_layer: CreateTextLayer,
+  create_shape_layer: CreateShapeLayer,
+  create_solid_layer: CreateSolidLayer,
+  create_null_layer: CreateNullLayer,
+  create_adjustment_layer: CreateAdjustmentLayer,
+  create_precomp_layer: CreatePrecompLayer,
+  create_camera_layer: CreateCameraLayer,
+  create_light_layer: CreateLightLayer,
+  duplicate_layer: DuplicateLayer,
+  delete_layer: DeleteLayer,
+  set_layer: SetLayer,
+  parent_layer: ParentLayer,
+  reorder_layer: ReorderLayer,
+  // transforms
+  set_transform: SetTransform,
+  // keyframes
+  add_keyframe: AddKeyframe,
+  remove_keyframe: RemoveKeyframe,
+  get_keyframes: GetKeyframes,
+  set_interpolation: SetInterpolation,
+  set_temporal_ease: SetTemporalEase,
+  set_spatial_tangents: SetSpatialTangents,
+  // expressions
+  get_expression: GetExpression,
+  set_expression: SetExpression,
+  toggle_expression: ToggleExpression,
+  clear_expression: ClearExpression,
+  // effects
+  list_effects: ListEffects,
+  add_effect: AddEffect,
+  remove_effect: RemoveEffect,
+  set_effect_param: SetEffectParam,
+  set_effect_enabled: SetEffectEnabled,
+  list_available_effects: ListAvailableEffects,
+  // text
+  set_text: SetText,
+  add_text_animator: AddTextAnimator,
+  // shapes
+  set_shape_path: SetShapePath,
+  add_shape_content: AddShapeContent,
+  set_shape_property: SetShapeProperty,
+  // masks
+  add_mask: AddMask,
+  set_mask: SetMask,
+  remove_mask: RemoveMask,
+  // markers
+  add_marker: AddMarker,
+  remove_marker: RemoveMarker,
+  // vision
+  screenshot_frame: ScreenshotFrame,
+  screenshot_layer: ScreenshotLayer,
+  // batch
+  run_batch: RunBatch,
+  // explore
+  get_project_summary: GetProjectSummary,
+  find_layers: FindLayers,
+  // raw
+  run_jsx: RunJsx,
+  // jobs
+  await_job: AwaitJob,
+  get_job: GetJob,
+  cancel_job: CancelJob,
+  // setup
+  check_setup: CheckSetup,
+  setup_panel: SetupPanel
+};
+
+// src/util/errors.ts
+var BridgeUnreachableError = class _BridgeUnreachableError extends Error {
+  constructor(port, cause) {
+    super(_BridgeUnreachableError.message(port, cause));
+    this.port = port;
+    this.name = "BridgeUnreachableError";
+  }
+  port;
+  static message(port, cause) {
+    return [
+      `Cannot reach the After Effects panel at http://127.0.0.1:${port}.`,
+      cause ? `Underlying error: ${cause.message}` : "",
+      "",
+      "Call the check_setup tool to find out why, then relay its nextSteps to the user.",
+      "In most cases the fix is either running setup_panel (installs the panel) or",
+      "simply opening After Effects."
+    ].filter(Boolean).join("\n");
+  }
+};
+var AeError = class extends Error {
+  constructor(message, stack_, line) {
+    super(message);
+    this.stack_ = stack_;
+    this.line = line;
+    this.name = "AeError";
+  }
+  stack_;
+  line;
+};
+
+// src/util/logger.ts
+var logger = {
+  info: (...a) => console.error("[ae-mcp]", ...a),
+  warn: (...a) => console.error("[ae-mcp:warn]", ...a),
+  error: (...a) => console.error("[ae-mcp:error]", ...a),
+  debug: (...a) => {
+    if (process.env.AE_MCP_DEBUG) console.error("[ae-mcp:debug]", ...a);
+  }
+};
+
+// src/bridge/discovery.ts
+import fs2 from "node:fs";
+import os from "node:os";
+import path2 from "node:path";
+var DEFAULT_PORT = 7777;
+function discoverPort() {
+  const envPort = process.env.AE_MCP_PORT;
+  if (envPort) {
+    const n = parseInt(envPort, 10);
+    if (Number.isFinite(n)) return n;
+  }
+  try {
+    const f = path2.join(os.homedir(), ".engineroom-ae-mcp", "port");
+    if (fs2.existsSync(f)) {
+      const txt = fs2.readFileSync(f, "utf8").trim();
+      const n = parseInt(txt, 10);
+      if (Number.isFinite(n)) return n;
+    }
+  } catch {
+  }
+  return DEFAULT_PORT;
+}
+
+// src/bridge/httpClient.ts
+var HttpClient = class {
+  port;
+  base;
+  constructor(port) {
+    this.port = port ?? discoverPort();
+    this.base = `http://127.0.0.1:${this.port}`;
+  }
+  async health() {
+    try {
+      const r = await fetch(`${this.base}/health`, { signal: AbortSignal.timeout(2e3) });
+      if (!r.ok) throw new Error(`health HTTP ${r.status}`);
+      return await r.json();
+    } catch (e) {
+      throw new BridgeUnreachableError(this.port, e);
+    }
+  }
+  async runOp(op, args, progressToken) {
+    let resp;
+    try {
+      resp = await fetch(`${this.base}/op`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ op, args: args ?? {}, progressToken }),
+        signal: AbortSignal.timeout(12e4)
+      });
+    } catch (e) {
+      throw new BridgeUnreachableError(this.port, e);
+    }
+    let data;
+    try {
+      data = await resp.json();
+    } catch {
+      throw new AeError(`Bridge returned non-JSON (HTTP ${resp.status})`);
+    }
+    if (!data.ok) {
+      throw new AeError(data.error, data.stack, data.line);
+    }
+    return data.result;
+  }
+  async cancel(jobId) {
+    try {
+      await fetch(`${this.base}/cancel`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ jobId })
+      });
+    } catch (e) {
+      logger.warn("cancel failed", e.message);
+    }
+  }
+};
+
+// src/bridge/wsClient.ts
+import WebSocket from "ws";
+var WsClient = class {
+  constructor(port, jobs) {
+    this.port = port;
+    this.jobs = jobs;
+  }
+  port;
+  jobs;
+  ws;
+  reconnectTimer;
+  stopped = false;
+  start() {
+    this.connect();
+  }
+  stop() {
+    this.stopped = true;
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    try {
+      this.ws?.close();
+    } catch {
+    }
+  }
+  connect() {
+    if (this.stopped) return;
+    const url = `ws://127.0.0.1:${this.port}/events`;
+    const ws = new WebSocket(url);
+    this.ws = ws;
+    ws.on("open", () => logger.debug("WS connected", url));
+    ws.on("message", (data) => {
+      let evt;
+      try {
+        evt = JSON.parse(data.toString());
+      } catch {
+        return;
+      }
+      this.handleEvent(evt);
+    });
+    ws.on("close", () => {
+      if (this.stopped) return;
+      this.reconnectTimer = setTimeout(() => this.connect(), 1500);
+    });
+    ws.on("error", () => {
+    });
+  }
+  handleEvent(evt) {
+    switch (evt.type) {
+      case "progress":
+        this.jobs.reportProgress(evt.jobId, evt.progress, evt.total, evt.message);
+        break;
+      case "complete":
+        this.jobs.complete(evt.jobId, evt.result);
+        break;
+      case "error":
+        this.jobs.fail(evt.jobId, evt.error);
+        break;
+      case "log":
+        logger.debug("[ae]", evt.level, evt.message);
+        break;
+    }
+  }
+};
+
+// src/jobs/manager.ts
+var JobManager = class {
+  jobs = /* @__PURE__ */ new Map();
+  waiters = /* @__PURE__ */ new Map();
+  progressEmitters = /* @__PURE__ */ new Map();
+  register(jobId, total) {
+    const s = {
+      jobId,
+      status: "running",
+      progress: 0,
+      total,
+      startedAt: Date.now()
+    };
+    this.jobs.set(jobId, s);
+    return s;
+  }
+  bindProgressEmitter(jobId, fn) {
+    const arr = this.progressEmitters.get(jobId) ?? [];
+    arr.push(fn);
+    this.progressEmitters.set(jobId, arr);
+  }
+  reportProgress(jobId, progress, total, message) {
+    const s = this.jobs.get(jobId);
+    if (s) {
+      s.progress = progress;
+      if (total !== void 0) s.total = total;
+      if (message !== void 0) s.message = message;
+    }
+    const emitters = this.progressEmitters.get(jobId) ?? [];
+    for (const e of emitters) {
+      try {
+        e(jobId, progress, total, message);
+      } catch {
+      }
+    }
+  }
+  complete(jobId, result) {
+    const s = this.jobs.get(jobId);
+    if (!s) return;
+    s.status = "completed";
+    s.result = result;
+    s.finishedAt = Date.now();
+    this.flush(jobId);
+  }
+  fail(jobId, error) {
+    const s = this.jobs.get(jobId);
+    if (!s) return;
+    s.status = "failed";
+    s.error = error;
+    s.finishedAt = Date.now();
+    this.flush(jobId);
+  }
+  cancel(jobId) {
+    const s = this.jobs.get(jobId);
+    if (!s) return;
+    s.status = "cancelled";
+    s.finishedAt = Date.now();
+    this.flush(jobId);
+  }
+  get(jobId) {
+    return this.jobs.get(jobId);
+  }
+  async waitFor(jobId, timeoutMs = 6e5) {
+    const cur = this.jobs.get(jobId);
+    if (cur && (cur.status === "completed" || cur.status === "failed" || cur.status === "cancelled")) {
+      if (cur.status === "failed") throw new Error(cur.error || "job failed");
+      return cur;
+    }
+    return new Promise((resolve, reject) => {
+      const arr = this.waiters.get(jobId) ?? [];
+      arr.push({ resolve, reject });
+      this.waiters.set(jobId, arr);
+      const t = setTimeout(() => reject(new Error(`await_job(${jobId}) timed out after ${timeoutMs}ms`)), timeoutMs);
+      const orig = arr[arr.length - 1];
+      arr[arr.length - 1] = {
+        resolve: (s) => {
+          clearTimeout(t);
+          orig.resolve(s);
+        },
+        reject: (e) => {
+          clearTimeout(t);
+          orig.reject(e);
+        }
+      };
+    });
+  }
+  flush(jobId) {
+    const s = this.jobs.get(jobId);
+    if (!s) return;
+    const waiters = this.waiters.get(jobId) ?? [];
+    this.waiters.delete(jobId);
+    for (const w of waiters) {
+      if (s.status === "failed") w.reject(new Error(s.error || "job failed"));
+      else w.resolve(s);
+    }
+    this.progressEmitters.delete(jobId);
+  }
+};
+
+// src/tools/descriptions.ts
+var descriptions = {
+  // ---------- comps ----------
+  list_comps: "All comps: id, name, dims, duration, fps, layer count.",
+  get_comp: "Single comp summary by id (no layers).",
+  get_comp_tree: "Comp + nested layer tree, recursing pre-comps to `depth`.",
+  create_comp: "Create a new comp. Returns id.",
+  set_comp: "Modify a comp (name, dims, fps, duration, work area, bg). Undefined fields unchanged.",
+  delete_comp: "Delete a comp. Reversible only via AE's Undo.",
+  set_active_comp: "Focus a comp in the viewer/timeline.",
+  // ---------- layers ----------
+  list_layers: "Layers in a comp, one-line each. Use get_layer_full for details.",
+  get_layer_full: "Full state of one layer: transform + keyframes + expressions, effects, masks, markers, parenting, text/shape/footage extras, and sourceRect (visible bounds). Always prefer over multiple smaller queries.",
+  create_text_layer: "Text layer with optional font/size/color/position. anchorAlign defaults to 'left' so position means the visible left edge.",
+  create_shape_layer: "Empty shape layer; fill via add_shape_content.",
+  create_solid_layer: "Solid-color layer. color is RGB 0..1.",
+  create_null_layer: "Null parent layer.",
+  create_adjustment_layer: "Adjustment layer \u2014 effects on it apply to layers below.",
+  create_precomp_layer: "Insert an existing comp into another as a pre-comp layer.",
+  create_camera_layer: "Camera. 3D layers below view through it.",
+  create_light_layer: "Light (parallel|spot|point|ambient).",
+  duplicate_layer: "Duplicate a layer N times; each has a fresh id.",
+  delete_layer: "Remove a layer.",
+  set_layer: "Update layer metadata (name/enabled/locked/shy/solo/3D/blend/label/in-out/stretch/trackMatte). Undefined fields unchanged.",
+  parent_layer: "Set/clear a layer's parent (parentLayerId=null to unparent).",
+  reorder_layer: "Move layer to 1-based stack index.",
+  // ---------- transforms ----------
+  set_transform: "Set any of position/scale/rotation/anchorPoint/opacity (+3D orientation/per-axis on 3D). keyframe:true + time sets keyframes.",
+  // ---------- keyframes ----------
+  add_keyframe: "Keyframe at `time` on propertyPath (e.g. ['Transform','Position']). Optional in/out interpolation + ease.",
+  remove_keyframe: "Remove keyframe at `time`.",
+  get_keyframes: "All keyframes on a property: time, value, interpolation, ease, spatial tangents.",
+  set_interpolation: "Set in/out interpolation type of a specific keyframe.",
+  set_temporal_ease: "Set influence+speed for in/out ease of a keyframe.",
+  set_spatial_tangents: "Set in/out spatial tangents for a position-style keyframe.",
+  // ---------- expressions ----------
+  get_expression: "Expression text + enabled state on a property.",
+  set_expression: "Set + enable an expression on a property.",
+  toggle_expression: "Enable/disable an expression without clearing.",
+  clear_expression: "Remove an expression.",
+  // ---------- effects ----------
+  list_effects: "All effects on a layer with current param values + keyframes/expressions.",
+  add_effect: "Add effect by matchName (use list_available_effects \u2014 matchNames are stable across AE versions; display names aren't).",
+  remove_effect: "Remove effect by 1-based index.",
+  set_effect_param: "Set an effect param by name/matchName. keyframe:true+time for keyframed value.",
+  set_effect_enabled: "Toggle an effect on/off without removing.",
+  list_available_effects: "All effects installed in this AE: displayName, matchName, category.",
+  // ---------- text ----------
+  set_text: "Set text content + styling (font, size, fill/stroke, tracking, leading, justification). Undefined fields unchanged.",
+  add_text_animator: "Add a text animator group (position/scale/rotation/opacity/tracking/skew/fillColor/strokeColor). Optional range selector.",
+  // ---------- shapes ----------
+  set_shape_path: "Replace a shape path with new vertices/tangents/closed.",
+  add_shape_content: "Add shape content under Contents or a sub-group. `content.type` picks the node (rect/ellipse/star/path/fill/stroke/trim/repeater/merge/group); the other keys set its properties by friendly name (e.g. rect: size/position/roundness; fill: color/opacity; stroke: color/width/lineCap; path: vertices/inTangents/outTangents/closed). Unknown or unsettable keys are NOT ignored \u2014 the whole node is rolled back and an error lists them, so trust a success result. Use get_layer_full to see exact property names.",
+  set_shape_property: "Set a property on a shape content node. Optional keyframe at time.",
+  // ---------- masks ----------
+  add_mask: "Add a mask with vertices/tangents/closed/mode.",
+  set_mask: "Modify mask vertices/tangents/closed/mode/inverted/expansion/feather/opacity.",
+  remove_mask: "Remove a mask by 1-based index.",
+  // ---------- markers ----------
+  add_marker: "Add a marker on a layer (layerId) or on the comp. time + optional duration/comment/label/chapter/url/frameTarget.",
+  remove_marker: "Remove a marker by 1-based index.",
+  // ---------- vision ----------
+  screenshot_frame: "ONE-OFF visual check of a comp at a time. Base64 PNG. Use only at key moments \u2014 never per-frame or in a loop. For motion, 2-3 snapshots + get_layer_full property values. Set downsample:2 (or 3-4 on 4K comps) to keep the image small \u2014 full-res 4K frames are large enough to exhaust the context. The result reports the dimensions actually returned, and warns if a requested downsample could not be applied.",
+  screenshot_layer: "ONE-OFF visual check of a single layer (solo'd) at a time. Same one-off rule and same downsample guidance as screenshot_frame.",
+  // ---------- batch ----------
+  run_batch: "Many ops in one ExtendScript pass, one undo step. >500 ops returns a jobId + streams progress; use await_job. transactional:true (default) rolls back on first error.",
+  // ---------- explore ----------
+  get_project_summary: "Project state: path, item count, active item, flat item list with type.",
+  find_layers: "Search across one or all comps for layers matching name/type/effect filters.",
+  // ---------- raw ----------
+  run_jsx: "Escape hatch: arbitrary ExtendScript in an undo group. `comp`/`app`/`OPS`/helpers in scope. Use `return X` to send a value back; complex AE objects are coerced to plain props.",
+  // ---------- jobs ----------
+  await_job: "Block until job is done. Default 10min timeout. Returns the same payload the tool would have.",
+  get_job: "Non-blocking job status: progress/total/state/error.",
+  cancel_job: "Set cancel flag; chunked loop stops at next boundary.",
+  // ---------- setup ----------
+  check_setup: "Diagnose the After Effects connection: panel installed, up to date, Adobe debug preference on, AE running, bridge answering. Read-only and safe to call any time. Call this FIRST whenever another tool reports it cannot reach After Effects, then relay `nextSteps` to the user in plain language.",
+  setup_panel: "Install or refresh the After Effects panel and enable the Adobe preference AE needs to load it. Run this when check_setup reports the panel is missing or out of date. It writes to the user's Adobe CEP extensions folder and sets a user-level Adobe preference \u2014 tell the user what it will do before calling it. Afterwards, AE must be restarted; if the preference was newly enabled, a one-time Mac reboot may also be needed."
+};
+
+// src/setup/check.ts
+import { execFile } from "node:child_process";
+import crypto from "node:crypto";
+import fs4 from "node:fs";
+import path4 from "node:path";
+import { promisify } from "node:util";
+
+// src/setup/paths.ts
+import fs3 from "node:fs";
+import os2 from "node:os";
+import path3 from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+var BUNDLE_ID = "games.engine-room.ae-mcp";
+function packageRoot() {
+  let dir = path3.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 8; i++) {
+    if (fs3.existsSync(path3.join(dir, "package.json"))) return dir;
+    const parent = path3.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return path3.dirname(fileURLToPath(import.meta.url));
+}
+function panelSourceDir() {
+  const candidates = [
+    // The live workspace copy comes first so a git checkout always installs
+    // what the developer is editing, never a stale vendored copy left behind by
+    // a previous `npm pack`. Only the second path exists in the tarball.
+    path3.resolve(packageRoot(), "..", "ae-panel"),
+    path3.join(packageRoot(), "panel")
+  ];
+  for (const dir of candidates) {
+    if (fs3.existsSync(path3.join(dir, "CSXS", "manifest.xml"))) return dir;
+  }
+  return null;
+}
+function cepExtensionsDir() {
+  return path3.join(os2.homedir(), "Library", "Application Support", "Adobe", "CEP", "extensions");
+}
+function installedPanelDir() {
+  return path3.join(cepExtensionsDir(), BUNDLE_ID);
+}
+function wsModuleDir() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const entry = require2.resolve("ws");
+    const marker = `${path3.sep}node_modules${path3.sep}ws${path3.sep}`;
+    const idx = entry.lastIndexOf(marker);
+    if (idx >= 0) return entry.slice(0, idx + marker.length - 1);
+    return path3.dirname(entry);
+  } catch {
+    return null;
+  }
+}
+function copyRecursive(src, dst) {
+  const stat = fs3.lstatSync(src);
+  if (stat.isDirectory()) {
+    fs3.mkdirSync(dst, { recursive: true });
+    for (const entry of fs3.readdirSync(src)) {
+      copyRecursive(path3.join(src, entry), path3.join(dst, entry));
+    }
+  } else if (stat.isSymbolicLink()) {
+    fs3.symlinkSync(fs3.readlinkSync(src), dst);
+  } else {
+    fs3.copyFileSync(src, dst);
+  }
+}
+
+// src/setup/check.ts
+var exec = promisify(execFile);
+var CSXS_VERSIONS = [12, 11, 10, 9];
+async function playerDebugMode() {
+  for (const v of CSXS_VERSIONS) {
+    try {
+      const { stdout } = await exec("defaults", ["read", `com.adobe.CSXS.${v}`, "PlayerDebugMode"]);
+      if (stdout.trim() === "1") return { on: true, detail: `enabled (CSXS.${v})` };
+    } catch {
+    }
+  }
+  return { on: false, detail: "not enabled for any CSXS version" };
+}
+async function aeRunning() {
+  try {
+    const { stdout } = await exec("pgrep", ["-f", "Adobe After Effects"]);
+    return stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function sha256(file) {
+  try {
+    return crypto.createHash("sha256").update(fs4.readFileSync(file)).digest("hex");
+  } catch {
+    return null;
+  }
+}
+async function bridgeReachable(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/health`, { signal: AbortSignal.timeout(2e3) });
+    if (!res.ok) return { ok: false, detail: `port ${port} returned HTTP ${res.status}` };
+    return { ok: true, detail: `responding on port ${port}` };
+  } catch (e) {
+    return { ok: false, detail: `no response on port ${port} (${e.message})` };
+  }
+}
+async function checkSetup() {
+  const checks = [];
+  const isMac = process.platform === "darwin";
+  checks.push({
+    name: "platform",
+    ok: isMac,
+    detail: process.platform,
+    fix: isMac ? void 0 : "This server currently supports macOS only. Windows needs a different CEP install path and a registry edit."
+  });
+  const source = panelSourceDir();
+  checks.push({
+    name: "panelAssetsPresent",
+    ok: source !== null,
+    detail: source ?? "not found in this installation",
+    fix: source ? void 0 : "The package is missing its CEP panel assets \u2014 reinstall the server."
+  });
+  const debugMode = await playerDebugMode();
+  checks.push({
+    name: "cepDebugMode",
+    ok: debugMode.on,
+    detail: debugMode.detail,
+    fix: debugMode.on ? void 0 : "Run the setup_panel tool. After Effects only loads unsigned panels when this Adobe preference is set."
+  });
+  const installed = installedPanelDir();
+  const isInstalled = fs4.existsSync(path4.join(installed, "CSXS", "manifest.xml"));
+  checks.push({
+    name: "panelInstalled",
+    ok: isInstalled,
+    detail: isInstalled ? installed : `not present at ${installed}`,
+    fix: isInstalled ? void 0 : "Run the setup_panel tool to install it."
+  });
+  if (isInstalled && source) {
+    const installedHash = sha256(path4.join(installed, "jsx", "bundle.jsx"));
+    const sourceHash = sha256(path4.join(source, "jsx", "bundle.jsx"));
+    const upToDate = installedHash !== null && installedHash === sourceHash;
+    checks.push({
+      name: "panelUpToDate",
+      ok: upToDate,
+      detail: upToDate ? "installed panel matches this server version" : "installed panel differs from the version shipped with this server",
+      fix: upToDate ? void 0 : "Run setup_panel to refresh it, then restart After Effects."
+    });
+  }
+  const running = await aeRunning();
+  checks.push({
+    name: "afterEffectsRunning",
+    ok: running,
+    detail: running ? "running" : "not running",
+    fix: running ? void 0 : "Launch After Effects. The panel starts automatically with it."
+  });
+  const port = discoverPort();
+  const bridge = await bridgeReachable(port);
+  checks.push({
+    name: "bridgeReachable",
+    ok: bridge.ok,
+    detail: bridge.detail,
+    fix: bridge.ok ? void 0 : "If the other checks pass, restart After Effects so the panel reloads."
+  });
+  const ready = checks.every((c) => c.ok);
+  return { ready, checks, nextSteps: buildNextSteps(checks, ready) };
+}
+function buildNextSteps(checks, ready) {
+  if (ready) return ["Everything is connected. After Effects is ready to drive."];
+  const by = (name) => checks.find((c) => c.name === name);
+  const steps = [];
+  if (by("platform")?.ok === false) return [by("platform").fix];
+  if (by("panelAssetsPresent")?.ok === false) return [by("panelAssetsPresent").fix];
+  const needsInstall = by("panelInstalled")?.ok === false || by("panelUpToDate")?.ok === false;
+  const needsDebug = by("cepDebugMode")?.ok === false;
+  if (needsDebug || needsInstall) {
+    steps.push("Run the setup_panel tool \u2014 it installs the After Effects panel and enables the Adobe preference that lets AE load it.");
+  }
+  if (needsDebug) {
+    steps.push("Quit and reopen After Effects. If the panel still does not connect, restart the Mac once \u2014 the Adobe preference sometimes only takes effect after a reboot.");
+  }
+  if (by("afterEffectsRunning")?.ok === false) {
+    steps.push("Open After Effects 2026.");
+  } else if (needsInstall) {
+    steps.push("Quit and reopen After Effects so it picks up the panel.");
+  }
+  if (steps.length === 0 && by("bridgeReachable")?.ok === false) {
+    steps.push("Everything is installed but the panel is not answering. Quit and reopen After Effects.");
+    steps.push("If it still fails, open Window > Extensions > AE MCP Bridge in AE to see the panel's own status log.");
+  }
+  return steps;
+}
+
+// src/setup/install.ts
+import { execFile as execFile2 } from "node:child_process";
+import fs5 from "node:fs";
+import path5 from "node:path";
+import { promisify as promisify2 } from "node:util";
+var exec2 = promisify2(execFile2);
+var CSXS_VERSIONS2 = [12, 11, 10, 9];
+async function isDebugModeOn() {
+  for (const v of CSXS_VERSIONS2) {
+    try {
+      const { stdout } = await exec2("defaults", ["read", `com.adobe.CSXS.${v}`, "PlayerDebugMode"]);
+      if (stdout.trim() === "1") return true;
+    } catch {
+    }
+  }
+  return false;
+}
+async function enableDebugMode() {
+  const enabled = [];
+  for (const v of CSXS_VERSIONS2) {
+    try {
+      await exec2("defaults", ["write", `com.adobe.CSXS.${v}`, "PlayerDebugMode", "1"]);
+      enabled.push(v);
+    } catch {
+    }
+  }
+  return enabled;
+}
+async function installPanel(opts = {}) {
+  const actions = [];
+  const notes = [];
+  if (process.platform !== "darwin") {
+    throw new Error("setup_panel supports macOS only. On Windows the CEP extensions folder and the PlayerDebugMode registry key differ; install manually.");
+  }
+  const source = panelSourceDir();
+  if (!source) {
+    throw new Error("Could not find the CEP panel assets that ship with this server. Reinstall the package.");
+  }
+  if (!fs5.existsSync(path5.join(source, "jsx", "bundle.jsx"))) {
+    throw new Error(`The panel at ${source} has no jsx/bundle.jsx. In a git checkout, run \`npm run build:jsx\` first.`);
+  }
+  const target = installedPanelDir();
+  const existing = fs5.lstatSync(target, { throwIfNoEntry: false });
+  if (existing?.isSymbolicLink() && !opts.force) {
+    const linkTarget = fs5.readlinkSync(target);
+    return {
+      ok: true,
+      panelPath: target,
+      actions: [],
+      restartAfterEffects: false,
+      rebootRecommended: false,
+      notes: [
+        `Left the existing symlinked panel alone (it points at ${linkTarget}).`,
+        "That is a development install, so it already tracks its source. Pass force:true to replace it with a copy."
+      ]
+    };
+  }
+  if (existing) {
+    fs5.rmSync(target, { recursive: true, force: true });
+    actions.push("Removed the previously installed panel.");
+  }
+  fs5.mkdirSync(path5.dirname(target), { recursive: true });
+  copyRecursive(source, target);
+  actions.push(`Installed the panel to ${target}.`);
+  const ws = wsModuleDir();
+  if (ws) {
+    const dest = path5.join(target, "node_modules", "ws");
+    fs5.mkdirSync(path5.dirname(dest), { recursive: true });
+    fs5.rmSync(dest, { recursive: true, force: true });
+    copyRecursive(ws, dest);
+    actions.push("Copied the `ws` module the panel needs at runtime.");
+  } else {
+    notes.push("Could not locate the `ws` module \u2014 the panel's WebSocket events may not work. Reinstall the package if progress notifications fail.");
+  }
+  let rebootRecommended = false;
+  if (opts.enableDebugMode !== false) {
+    const wasOn = await isDebugModeOn();
+    if (wasOn) {
+      actions.push("Adobe's PlayerDebugMode preference was already enabled.");
+    } else {
+      const versions = await enableDebugMode();
+      if (versions.length === 0) {
+        notes.push("Failed to set PlayerDebugMode. Without it After Effects will refuse to load this panel.");
+      } else {
+        actions.push(`Enabled PlayerDebugMode for CSXS ${versions.join(", ")} so AE will load the unsigned panel.`);
+        rebootRecommended = true;
+      }
+    }
+  }
+  if (rebootRecommended) {
+    notes.push("PlayerDebugMode was just turned on. Quit and reopen After Effects; if the panel still does not connect, restart the Mac once \u2014 on some macOS builds the preference only applies after a reboot.");
+  }
+  return {
+    ok: true,
+    panelPath: target,
+    actions,
+    restartAfterEffects: true,
+    rebootRecommended,
+    notes
+  };
+}
+
+// src/util/pngImage.ts
+function imageContent(meta, base64) {
+  return {
+    content: [
+      { type: "text", text: JSON.stringify(meta) },
+      { type: "image", data: base64, mimeType: "image/png" }
+    ]
+  };
+}
+
+// src/server.ts
+var { OpSchemas: OpSchemas2 } = schemas_exports;
+var VISION_OPS = /* @__PURE__ */ new Set(["screenshot_frame", "screenshot_layer"]);
+var ASYNC_OPS = /* @__PURE__ */ new Set(["run_batch"]);
+var SERVER_OPS = /* @__PURE__ */ new Set(["await_job", "get_job", "cancel_job", "check_setup", "setup_panel"]);
+var AwaitJobSchema = schemas_exports.AwaitJob;
+var GetJobSchema = schemas_exports.GetJob;
+var CancelJobSchema = schemas_exports.CancelJob;
+function createServer() {
+  const server = new Server(
+    { name: "after-effects-mcp", version: "0.1.0" },
+    { capabilities: { tools: {}, logging: {} } }
+  );
+  const bridge = new HttpClient();
+  const jobs = new JobManager();
+  const ws = new WsClient(bridge.port, jobs);
+  ws.start();
+  bridge.health().then(
+    (h) => logger.info(`Bridge healthy on port ${h.port}`),
+    (e) => logger.warn(`Bridge not reachable yet: ${e.message}`)
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const tools = Object.keys(OpSchemas2).map((name) => {
+      const schema = OpSchemas2[name];
+      const jsonSchema = zodToJsonSchema(schema, {
+        target: "jsonSchema7",
+        $refStrategy: "none"
+      });
+      return {
+        name,
+        description: descriptions[name] ?? `AE op: ${name}`,
+        inputSchema: toDraft2020(jsonSchema)
+      };
+    });
+    return { tools };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (req, extra) => {
+    const name = req.params.name;
+    const rawArgs = req.params.arguments ?? {};
+    const progressToken = req.params?._meta?.progressToken;
+    if (!(name in OpSchemas2) && !SERVER_OPS.has(name)) {
+      return errorResult(`Unknown tool: ${name}`);
+    }
+    if (SERVER_OPS.has(name)) {
+      try {
+        if (name === "await_job") {
+          const a = AwaitJobSchema.parse(rawArgs);
+          const st = await jobs.waitFor(a.jobId, a.timeoutMs ?? 6e5);
+          return textResult(st);
+        }
+        if (name === "get_job") {
+          const a = GetJobSchema.parse(rawArgs);
+          const st = jobs.get(a.jobId);
+          return textResult(st ?? null);
+        }
+        if (name === "cancel_job") {
+          const a = CancelJobSchema.parse(rawArgs);
+          await bridge.cancel(a.jobId);
+          jobs.cancel(a.jobId);
+          return textResult({ ok: true });
+        }
+        if (name === "check_setup") {
+          return textResult(await checkSetup());
+        }
+        if (name === "setup_panel") {
+          const a = schemas_exports.SetupPanel.parse(rawArgs);
+          const installed = await installPanel({ enableDebugMode: a.enableDebugMode, force: a.force });
+          return textResult({ ...installed, setup: await checkSetup() });
+        }
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    }
+    let args;
+    try {
+      args = OpSchemas2[name].parse(rawArgs);
+    } catch (e) {
+      return errorResult(`Invalid arguments for ${name}: ${e.message}`);
+    }
+    try {
+      const result = await bridge.runOp(name, args, progressToken);
+      if (ASYNC_OPS.has(name) && isAsyncEnvelope(result)) {
+        const env = result;
+        jobs.register(env.jobId, env.total);
+        if (progressToken !== void 0) {
+          jobs.bindProgressEmitter(env.jobId, (jid, progress, total, message) => {
+            void server.notification({
+              method: "notifications/progress",
+              params: { progressToken, progress, total, message }
+            });
+          });
+        }
+        return textResult({ jobId: env.jobId, async: true, total: env.total });
+      }
+      if (VISION_OPS.has(name) && isVisionResult(result)) {
+        const v = result;
+        return imageContent(
+          {
+            width: v.width,
+            height: v.height,
+            fullWidth: v.fullWidth,
+            fullHeight: v.fullHeight,
+            downsample: v.downsample,
+            time: v.time,
+            compId: v.compId,
+            layerId: v.layerId,
+            bytes: v.bytes,
+            // Surfaced when a requested downsample could not be applied, so the
+            // agent knows it is looking at a full-resolution frame.
+            warning: v.warning
+          },
+          v.base64
+        );
+      }
+      return textResult(result);
+    } catch (e) {
+      if (e instanceof BridgeUnreachableError) return errorResult(e.message);
+      if (e instanceof AeError) return errorResult(`AE: ${e.message}${e.line ? ` (line ${e.line})` : ""}`);
+      return errorResult(e.message);
+    }
+  });
+  return server;
+}
+function textResult(value) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(value, null, 2) }]
+  };
+}
+function errorResult(message) {
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+function toDraft2020(node) {
+  if (Array.isArray(node)) return node.map(toDraft2020);
+  if (!node || typeof node !== "object") return node;
+  const out = {};
+  for (const k of Object.keys(node)) out[k] = toDraft2020(node[k]);
+  if (out.type === "array" && Array.isArray(out.items)) {
+    out.prefixItems = out.items;
+    if ("additionalItems" in out) {
+      out.items = out.additionalItems;
+      delete out.additionalItems;
+    } else {
+      out.items = false;
+    }
+  }
+  return out;
+}
+function isAsyncEnvelope(v) {
+  return !!(v && typeof v === "object" && "async" in v && v.async === true && "jobId" in v);
+}
+function isVisionResult(v) {
+  return !!(v && typeof v === "object" && "base64" in v && "width" in v);
+}
+
+// src/index.ts
+var USAGE = `@engine-room/after-effects-mcp \u2014 drive Adobe After Effects from an AI agent.
+
+With no arguments it runs as an MCP server over stdio, which is how an MCP
+client (Claude Code, Claude Desktop, \u2026) starts it. You do not normally run it
+by hand.
+
+Commands:
+  init <directory> [--with-mcp]   Create a project folder with a house-style
+                                  skill you can edit. Pass --with-mcp if you
+                                  did not install the Claude Code plugin.
+  --help                          Show this message.
+  --version                       Print the version.
+`;
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv[0] === "init") {
+    process.exit(runInit(argv.slice(1)));
+  }
+  if (argv[0] === "--help" || argv[0] === "-h") {
+    process.stdout.write(USAGE);
+    process.exit(0);
+  }
+  if (argv[0] === "--version" || argv[0] === "-v") {
+    process.stdout.write(`${VERSION}
+`);
+    process.exit(0);
+  }
+  if (argv.length > 0) {
+    process.stderr.write(`Unknown command: ${argv[0]}
+
+${USAGE}`);
+    process.exit(1);
+  }
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  logger.info("MCP server running on stdio");
+}
+var VERSION = "0.1.0";
+main().catch((e) => {
+  logger.error("fatal", e.message);
+  process.exit(1);
+});