ezmockups-mcp 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,61 @@
-# Temporary Holding Version
+# ezmockups-mcp
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+An [MCP](https://modelcontextprotocol.io) server that lets your coding agent (Claude Code, Cursor, Codex, Claude Desktop…) design, translate and export App Store screenshot sets with [EZMockups](https://ezmockups.app).
+
+- **Your agent is the art director and translator.** It writes the design plan and every word of copy with its own model, so no EZMockups AI credits are used.
+- **EZMockups does the rest.** It composes professionally tuned layouts with the same engine as the editor, saves real, editable projects to your account, and exports PNGs at the exact App Store Connect / Google Play sizes.
+
+```
+"Capture the main screens of my app in the simulator and design an App Store screenshot set."
+"Make an Apple Watch set from what's on the watch simulator."
+"Translate the set into all the languages we support and export it to fastlane/screenshots."
+```
+
+## Setup
+
+1. In EZMockups, open the account menu → **Connect an AI agent** → **Create key**.
+2. Copy the snippet for your agent. For Claude Code it looks like this:
+
+   ```bash
+   claude mcp add ezmockups --scope user \
+     -e EZMOCKUPS_API_KEY=ezm_… \
+     -e EZMOCKUPS_API_URL=https://<deployment>.convex.site \
+     -e EZMOCKUPS_APP_URL=https://ezmockups.app \
+     -- npx -y ezmockups-mcp
+   ```
+
+Requirements: Node 20+, and Google Chrome, Chromium, Edge or Brave. Rendering runs the EZMockups engine in a headless browser on your machine. Capturing from the Simulator needs macOS with Xcode.
+
+| Variable | |
+|---|---|
+| `EZMOCKUPS_API_KEY` | Personal API key. Without one, projects are saved as local files in `~/.ezmockups/projects` and exports carry the free-plan watermark. |
+| `EZMOCKUPS_API_URL` | The EZMockups API, shown next to your key. |
+| `EZMOCKUPS_APP_URL` | The EZMockups web app whose engine renders the screens. Default `https://ezmockups.app`. |
+| `EZMOCKUPS_HOME` | Local data folder. Default `~/.ezmockups`. |
+| `CHROME_PATH` | Browser binary, if it isn't found automatically. |
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `capture_simulator_screenshot` | Saves what a booted iOS or watchOS Simulator shows, with a clean 9:41 status bar. |
+| `inspect_screenshots` | Shows the screenshots to the agent (numbered), with their sizes, the detected target (iPhone, iPad or Watch) and the app's brand colours. |
+| `get_design_guide` | The art-direction rules and the plan format: layouts, copy, palette, type, fonts, devices. |
+| `create_screenshot_set` | Renders a plan into an editable project and returns a preview, the text keys and the screenshot slots. Pass `projectId` to redesign in place. |
+| `list_projects` / `get_project` | Lists projects, or returns one project's texts, languages, translation status and a preview. |
+| `set_texts` | Edits copy or translates it, by key. Each language becomes its own row of screens. Accent words use `**markers**`. Translations that wrap past the source's lines shrink to fit, and anything that still doesn't fit is reported. |
+| `set_localized_screenshots` | Shows localized app UI in one language. |
+| `remove_languages` | Deletes language rows. |
+| `export_screenshots` | Writes upload-ready PNGs, one folder per language. `layout: "fastlane"` writes fastlane deliver's `screenshots/<locale>/` structure. |
+
+Targets: iPhone (1290×2796, exports the required 6.3" plus 6.9" and 6.5"), iPad 13" (2064×2752), and Apple Watch (416×496, exports every watch size).
+
+## Developing
+
+```bash
+pnpm install
+pnpm build        # → dist/index.js
+pnpm typecheck
+```
+
+The server shares the plan validator and design guide with the web app (`../convex/lib/plan.ts`) and drives the web app's `/agent/render` page (`../src/lib/agent/engine.ts`). To develop against a local checkout, run `pnpm dev` at the repo root and set `EZMOCKUPS_APP_URL=http://localhost:5173`. In dev, the editor's "Connect an AI agent" dialog prints a command that points at this checkout's `dist/index.js`.

package/dist/index.js

@@ -0,0 +1,872 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import path3 from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// ../convex/lib/plan.ts
+var DEVICE_IDS = [
+  "iphone-16-pro",
+  "iphone-16-pro-white",
+  "iphone-14",
+  "iphone-14-blue",
+  "pixel-9-pro",
+  "pixel-9-pro-porcelain",
+  "galaxy-s24",
+  "ipad-pro-13"
+];
+var FONTS = [
+  "Inter",
+  "Poppins",
+  "Montserrat",
+  "Manrope",
+  "Sora",
+  "Space Grotesk",
+  "DM Sans",
+  "Plus Jakarta Sans",
+  "Outfit",
+  "Archivo",
+  "Playfair Display",
+  "Lora",
+  "Fraunces"
+];
+var LAYOUTS = ["hero-bleed", "top-bleed", "side-peek", "tilted-duo", "zoom-callout", "floating-3d", "social-proof", "watch-screen", "watch-caption"];
+var TARGETS = ["iphone", "ipad", "watch"];
+var BACKGROUNDS = ["gradient", "glow", "solid", "panorama"];
+var BADGES = ["pill", "laurel", "rating", "review"];
+var DESIGN_PRINCIPLES = `## Layouts (one per screen)
+- "hero-bleed": headline at the top, a big phone rising from the bottom edge (cropped by it). The strongest, most legible hero.
+- "top-bleed": a phone hanging from the top edge, headline below. Strong rhythm change after a hero-bleed.
+- "side-peek": left-aligned headline; a large tilted phone bleeding off the right edge. Dynamic, editorial.
+- "tilted-duo": two overlapping tilted phones showing two different screenshots. For "and also", pairs, before/after.
+- "zoom-callout": a phone plus a magnifier lens enlarging ONE detail (give its position on that screenshot as x/y fractions 0\u20131, measured from the top-left of the screenshot). For a small detail that sells: a chart, a stat, a key button, an AI answer.
+- "floating-3d": one phone in real 3D perspective, floating. Premium; great as the opener or the closer.
+- "social-proof": a laurel / rating / review leads the screen above a hero phone. ONLY when real facts were provided.
+
+## Apple Watch sets (only when the target is Apple Watch)
+The canvas is the watch screen itself (416 \xD7 496 px) and is shown tiny in the store. No phones, no device frames. Use ONLY these layouts:
+- "watch-screen": the screenshot fills the whole screen \u2014 pure UI. Use for the most self-explanatory screens.
+- "watch-caption": a very short headline at the top and the screenshot below it with rounded corners.
+Headlines are 1\u20134 words (they must stay legible at watch size); no subtitles, eyebrows or badges. Backgrounds should be near-black or very dark brand tones so the set feels native to watchOS; accent from the brand colour.
+
+## Extras
+- "eyebrow": optional tiny uppercase label above a headline (\u2264 3 words) \u2014 e.g. "NEW", "AI COACH", "OFFLINE". Use on 1\u20132 screens, not all.
+- Accent words: wrap the 1\u20132 words carrying the benefit in **double asterisks** inside the headline; they render in the accent colour.
+- "badge": optional. "pill" = short true label from the screenshots ("FREE", "NO ADS", "AI"). "laurel" / "rating" / "review" = social proof, ONLY from provided facts.
+- "invert": true flips a screen to the accent background for rhythm \u2014 at most one per set.
+
+## Copy \u2014 this is where most sets fail
+- Study every screenshot. Use what you actually see: real feature names, real numbers, real UI. If a screen shows "8,432 steps", that is better material than "track your activity".
+- Headlines: 2\u20136 words. Lead with the user's outcome, not the feature name ("Sleep deeper tonight" beats "Sleep tracking"). Concrete verbs, specific nouns, short words, rhythm.
+- Screen 1 = the single biggest reason to download (no app name unless it's famous). The set reads as a story in order; every screen says something new. The last screen is the closer: reassurance, the delight moment, or proof.
+- Subtitles are optional (\u2264 9 words) and must add a concrete detail. Omit them when the headline is enough \u2014 at least one screen should have none.
+- Never use: seamless, effortless, elevate, unlock, unleash, empower, revolutionize, game-changer, next-level, all-in-one, at your fingertips, take control, made easy, like never before, experience (as a verb or noun), journey, world-class, cutting-edge, ultimate, the best, simply, powerful, smart (as filler), welcome to, discover, explore, boost your, transform your, supercharge, streamline. If a phrase could appear in any app's screenshots, rewrite it.
+- Write in the language of the brief if one is given; otherwise English.
+- The bar, by example (generic \u2192 specific):
+  - "Track your fitness journey" \u2192 "Beat yesterday's **8.4 km**"
+  - "Manage your finances effortlessly" \u2192 "Know where every **dollar** goes"
+  - "Powerful AI assistant" \u2192 "Ask anything. Get **receipts**."
+  - "Stay organized" \u2192 "Your week, **sorted by Sunday**"
+  - "Learn languages easily" \u2192 "**5 minutes** a day. Real Spanish.
+
+## Style
+- Build the palette from the app's real brand colours (extracted hex values are provided) so the set is recognisably this app. Shift lightness/saturation for backgrounds; keep the accent close to the brand colour.
+- Text must have strong contrast with its background (aim for 4.5:1 or better); "muted" is for subtitles and must still be readable.
+- Backgrounds: "gradient" (two-tone), "glow" (deep base with soft light blooms \u2014 premium, great for dark sets), "solid" (flat and confident \u2014 minimal or editorial sets), "panorama" (one continuous gradient flowing across the whole set, so it reads as one piece in the store).
+- Fonts \u2014 choose for personality: serif (Fraunces, Playfair Display, Lora) for editorial, wellness, finance, luxury; geometric sans (Sora, Outfit, Poppins, Space Grotesk, Archivo) for tech, productivity, fitness, gaming; Inter / Manrope / DM Sans / Plus Jakarta Sans / Montserrat for clean utility. bodyFont is for subtitles and badges.
+- device: choose to match the screenshots (phones for phone screenshots, "ipad-pro-13" only for tablet screenshots). deviceFinish: a phone body colour that complements the palette \u2014 e.g. "#1a1a1a" black, "#8f8a81" natural titanium, "#e8e6e1" white titanium, "#bfa48a" desert, "#2c3b52" deep blue, or a muted brand tint.
+- Composition: never use the same layout on two consecutive screens; a 4\u20135 screen set uses at least three different layouts. Open with hero-bleed, side-peek or floating-3d. Use zoom-callout where a detail deserves it.
+- Use each screenshot where it best proves its headline; reuse screenshots only if there are fewer screenshots than screens.
+
+## Honesty
+Never invent ratings, review counts, awards, user numbers or press quotes. Laurel / rating / review badges and the "social-proof" layout are allowed ONLY with facts the user provided \u2014 quote them faithfully. Without facts, use "pill" badges that are true from the screenshots, or none.`;
+var AGENT_DESIGN_GUIDE = `# Designing an App Store screenshot set with EZMockups
+
+You are the art director. Look at the app's screenshots, decide what the app is and who it's for, and write a plan: the concept, every word of copy, the palette, the type, and one layout per screen. EZMockups composes each layout with professionally tuned proportions and renders real, fully editable artboards (the developer can fine-tune everything in the EZMockups editor afterwards). You never place pixels.
+
+Workflow: capture or collect the app screenshots \u2192 \`inspect_screenshots\` (see them, get brand colours and the detected target) \u2192 write the plan \u2192 \`create_screenshot_set\` \u2192 look at the preview it returns and revise with \`create_screenshot_set\` (pass \`projectId\` to overwrite) until it's great \u2192 \`set_texts\` to translate \u2192 \`export_screenshots\`.
+
+## Targets
+- "iphone": 1290 \xD7 2796 canvas (6.9"). Exports App Store Connect's required iPhone 6.3" plus 6.9" and 6.5".
+- "ipad": 2064 \xD7 2752 canvas (13"). device is always "ipad-pro-13".
+- "watch": 416 \xD7 496 canvas (Apple Watch Series 10\u201312). Exports every Apple Watch size. Use watch screenshots (from a watchOS simulator) for watch sets \u2014 never phone screenshots.
+A set has one target. For an app on iPhone and Apple Watch, make two sets.
+
+${DESIGN_PRINCIPLES}
+
+## The plan (the \`plan\` argument)
+{
+  "concept": { "name": "<2\u20134 word theme name \u2014 becomes the project name>", "story": "<how the set flows>" },
+  "style": {
+    "background": "gradient" | "glow" | "solid" | "panorama",
+    "colors": { "bg1": "#hex", "bg2": "#hex", "text": "#hex", "muted": "#hex", "accent": "#hex" },
+    "headingFont": "<allowed font>", "bodyFont": "<allowed font>",
+    "headingWeight": "600" | "700" | "800",
+    "uppercase": <boolean>,
+    "device": "<allowed device id>",
+    "deviceFinish": "#hex" | null
+  },
+  "screens": [
+    {
+      "layout": "<layout>",
+      "screenshot": <0-based index into the screenshots you pass>,
+      "secondScreenshot": <index, tilted-duo only>,
+      "eyebrow": "<optional>",
+      "headline": "<2\u20136 words, **accent** marked>",
+      "subtitle": "<optional>",
+      "zoom": { "x": <0\u20131>, "y": <0\u20131> },
+      "badge": null | { "kind": "pill" | "laurel" | "rating" | "review", "text": "<pill>", "title": "<laurel/rating main line>", "subtitle": "<laurel/rating second line>", "quote": "<review>", "author": "<review>" },
+      "invert": <boolean>
+    }
+  ]
+}
+Up to 10 screens (App Store Connect shows up to 10). 4\u20136 is the sweet spot. Write the copy in the source language (usually English) \u2014 translate later with \`set_texts\`, which keeps one design across every language.
+
+Allowed fonts: ${FONTS.join(", ")}.
+Allowed devices: ${DEVICE_IDS.join(", ")}.
+Allowed layouts: ${LAYOUTS.join(", ")}.
+
+## Translating
+\`get_project\` lists every string with a stable key. \`set_texts\` with a language code adds that language as its own row of artboards (a full copy of the design) and writes your translations. Translate like a native copywriter: natural, punchy, similar length (screens have little room), keep \\n breaks, brand names, numbers, emoji and the casing style. Mark the accent words of each translated headline with **double asterisks**, as in the source. Text that wraps to more lines than the source is shrunk to fit (down to ~75%); whatever still doesn't fit is reported as tooLong. If the app itself is localized, capture it in that language and pass the screenshots with \`set_localized_screenshots\` so the phones show the localized UI too. Shorten anything reported as tooLong, and preview a few languages to check.
+`;
+
+// ../src/constants/languages.ts
+var LANGUAGES = [
+  { code: "en", name: "English" },
+  { code: "en-GB", name: "English (UK)" },
+  { code: "de", name: "German" },
+  { code: "fr", name: "French" },
+  { code: "es", name: "Spanish" },
+  { code: "es-MX", name: "Spanish (Mexico)" },
+  { code: "it", name: "Italian" },
+  { code: "pt-BR", name: "Portuguese (Brazil)" },
+  { code: "pt-PT", name: "Portuguese (Portugal)" },
+  { code: "nl", name: "Dutch" },
+  { code: "sv", name: "Swedish" },
+  { code: "da", name: "Danish" },
+  { code: "no", name: "Norwegian" },
+  { code: "fi", name: "Finnish" },
+  { code: "pl", name: "Polish" },
+  { code: "cs", name: "Czech" },
+  { code: "sk", name: "Slovak" },
+  { code: "hu", name: "Hungarian" },
+  { code: "ro", name: "Romanian" },
+  { code: "hr", name: "Croatian" },
+  { code: "ca", name: "Catalan" },
+  { code: "el", name: "Greek" },
+  { code: "tr", name: "Turkish" },
+  { code: "ru", name: "Russian" },
+  { code: "uk", name: "Ukrainian" },
+  { code: "ar", name: "Arabic", rtl: true },
+  { code: "he", name: "Hebrew", rtl: true },
+  { code: "hi", name: "Hindi" },
+  { code: "th", name: "Thai" },
+  { code: "vi", name: "Vietnamese" },
+  { code: "id", name: "Indonesian" },
+  { code: "ms", name: "Malay" },
+  { code: "ja", name: "Japanese" },
+  { code: "ko", name: "Korean" },
+  { code: "zh-Hans", name: "Chinese (Simplified)" },
+  { code: "zh-Hant", name: "Chinese (Traditional)" }
+];
+
+// src/config.ts
+import os from "node:os";
+import path from "node:path";
+var trimSlash = (s) => s.replace(/\/+$/, "");
+var config = {
+  apiKey: process.env.EZMOCKUPS_API_KEY?.trim() || null,
+  apiUrl: process.env.EZMOCKUPS_API_URL ? trimSlash(process.env.EZMOCKUPS_API_URL.trim()) : null,
+  appUrl: trimSlash(process.env.EZMOCKUPS_APP_URL?.trim() || "https://ezmockups.app"),
+  home: process.env.EZMOCKUPS_HOME?.trim() || path.join(os.homedir(), ".ezmockups"),
+  chromePath: process.env.CHROME_PATH?.trim() || null
+};
+function resolvePath(p) {
+  if (p === "~" || p.startsWith("~/")) return path.join(os.homedir(), p.slice(1));
+  return path.resolve(process.cwd(), p);
+}
+
+// src/renderer.ts
+import puppeteer from "puppeteer-core";
+
+// src/chrome.ts
+import { existsSync } from "node:fs";
+var CANDIDATES = {
+  darwin: [
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+    "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+    "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary"
+  ],
+  linux: [
+    "/usr/bin/google-chrome",
+    "/usr/bin/google-chrome-stable",
+    "/usr/bin/chromium",
+    "/usr/bin/chromium-browser",
+    "/snap/bin/chromium",
+    "/usr/bin/microsoft-edge"
+  ],
+  win32: [
+    `${process.env.PROGRAMFILES ?? "C:\\Program Files"}\\Google\\Chrome\\Application\\chrome.exe`,
+    `${process.env["PROGRAMFILES(X86)"] ?? "C:\\Program Files (x86)"}\\Google\\Chrome\\Application\\chrome.exe`,
+    `${process.env.LOCALAPPDATA ?? ""}\\Google\\Chrome\\Application\\chrome.exe`,
+    `${process.env["PROGRAMFILES(X86)"] ?? "C:\\Program Files (x86)"}\\Microsoft\\Edge\\Application\\msedge.exe`
+  ]
+};
+function findChrome() {
+  if (config.chromePath) {
+    if (!existsSync(config.chromePath)) throw new Error(`CHROME_PATH points to ${config.chromePath}, which doesn't exist.`);
+    return config.chromePath;
+  }
+  const found = (CANDIDATES[process.platform] ?? []).find((p) => existsSync(p));
+  if (!found) {
+    throw new Error("No Chrome, Chromium, Edge or Brave found. Install Google Chrome, or set CHROME_PATH to a Chromium-based browser binary.");
+  }
+  return found;
+}
+
+// src/renderer.ts
+var Renderer = class {
+  browser = null;
+  page = null;
+  starting = null;
+  /** Id of the project currently in the tab (null = none / unknown). */
+  loaded = null;
+  async start() {
+    const browser = await puppeteer.launch({
+      executablePath: findChrome(),
+      headless: true,
+      protocolTimeout: 10 * 60 * 1e3,
+      // WebGL (3D devices) via SwiftShader when there's no GPU.
+      args: ["--hide-scrollbars", "--mute-audio", "--use-angle=swiftshader", "--enable-unsafe-swiftshader", "--no-first-run", "--no-default-browser-check"]
+    });
+    browser.on("disconnected", () => {
+      this.browser = null;
+      this.page = null;
+      this.loaded = null;
+    });
+    const page = await browser.newPage();
+    page.on("pageerror", (e) => console.error("[renderer] page error:", e instanceof Error ? e.message : e));
+    page.on("crash", () => {
+      this.page = null;
+      this.loaded = null;
+    });
+    await page.setViewport({ width: 1200, height: 900, deviceScaleFactor: 1 });
+    const url = `${config.appUrl}/agent/render`;
+    try {
+      await page.goto(url, { waitUntil: "domcontentloaded", timeout: 6e4 });
+    } catch (e) {
+      await browser.close().catch(() => void 0);
+      throw new Error(`Couldn't open the EZMockups renderer at ${url} (${e instanceof Error ? e.message : e}). Check EZMOCKUPS_APP_URL.`);
+    }
+    try {
+      await page.waitForFunction(() => window.ezmAgent?.ready || window.ezmAgentError, { timeout: 9e4 });
+    } catch {
+      await browser.close().catch(() => void 0);
+      throw new Error(`The page at ${url} didn't start the EZMockups renderer. Is EZMOCKUPS_APP_URL pointing at an EZMockups build that has /agent/render?`);
+    }
+    const err = await page.evaluate(() => window.ezmAgentError);
+    if (err) {
+      await browser.close().catch(() => void 0);
+      throw new Error(`Renderer failed to start: ${err}`);
+    }
+    this.browser = browser;
+    this.page = page;
+    return page;
+  }
+  async ensure() {
+    if (this.page && !this.page.isClosed()) return this.page;
+    this.starting ??= this.start().finally(() => {
+      this.starting = null;
+    });
+    return this.starting;
+  }
+  async call(method, ...args) {
+    const page = await this.ensure();
+    try {
+      return await page.evaluate(
+        (m, a) => window.ezmAgent[m](...a),
+        method,
+        args
+      );
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      throw new Error(msg.replace(/^Error: /, "").replace(/^Evaluation failed: (Error: )?/, ""));
+    }
+  }
+  async close() {
+    await this.browser?.close().catch(() => void 0);
+    this.browser = null;
+    this.page = null;
+    this.loaded = null;
+  }
+};
+var renderer = new Renderer();
+
+// src/store.ts
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import path2 from "node:path";
+import { randomBytes } from "node:crypto";
+var CloudStore = class {
+  constructor(apiUrl, apiKey) {
+    this.apiUrl = apiUrl;
+    this.apiKey = apiKey;
+  }
+  async req(method, p, body) {
+    let res;
+    try {
+      res = await fetch(`${this.apiUrl}${p}`, {
+        method,
+        headers: { Authorization: `Bearer ${this.apiKey}`, ...body ? { "Content-Type": "application/json" } : {} },
+        body: body ? JSON.stringify(body) : void 0
+      });
+    } catch (e) {
+      throw new Error(`Couldn't reach EZMockups at ${this.apiUrl} (${e instanceof Error ? e.message : e}). Check EZMOCKUPS_API_URL.`);
+    }
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) throw new Error(data.error ?? `EZMockups API error ${res.status}`);
+    return data;
+  }
+  async account() {
+    const me = await this.req("GET", "/api/v1/me");
+    return { mode: "cloud", email: me.email, watermark: me.watermark };
+  }
+  list() {
+    return this.req("GET", "/api/v1/projects");
+  }
+  async load(id) {
+    const p = await this.req("GET", `/api/v1/project?id=${encodeURIComponent(id)}`);
+    if (!p.dataUrl) throw new Error("Project data is missing");
+    const res = await fetch(p.dataUrl);
+    if (!res.ok) throw new Error(`Couldn't download the project (${res.status})`);
+    return { meta: { id: p.id, name: p.name, preset: p.preset, updatedAt: p.updatedAt }, json: await res.text() };
+  }
+  async save({ id, name, preset, json }) {
+    const { url } = await this.req("POST", "/api/v1/upload-url");
+    const up = await fetch(url, { method: "POST", headers: { "Content-Type": "application/json" }, body: json });
+    if (!up.ok) throw new Error(`Upload failed (${up.status})`);
+    const { storageId } = await up.json();
+    const out = await this.req("POST", "/api/v1/project", { id, name, preset, dataStorageId: storageId });
+    return out.id;
+  }
+  linkFor(id) {
+    return `${config.appUrl}/app?project=${encodeURIComponent(id)}`;
+  }
+};
+var LocalStore = class {
+  dir = path2.join(config.home, "projects");
+  file = (id) => path2.join(this.dir, `${id.replace(/[^\w-]/g, "")}.json`);
+  async account() {
+    return { mode: "local", email: null, watermark: true };
+  }
+  async list() {
+    await mkdir(this.dir, { recursive: true });
+    const out = [];
+    for (const f of (await readdir(this.dir)).filter((x) => x.endsWith(".json"))) {
+      try {
+        const raw = await readFile(path2.join(this.dir, f), "utf8");
+        const m = /^\{"meta":(\{.*?\}),"data":/.exec(raw.slice(0, 4096));
+        if (m) out.push(JSON.parse(m[1]));
+      } catch {
+      }
+    }
+    return out.sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  async load(id) {
+    let raw;
+    try {
+      raw = await readFile(this.file(id), "utf8");
+    } catch {
+      throw new Error(`No local project ${id}`);
+    }
+    const m = /^\{"meta":(\{.*?\}),"data":/.exec(raw.slice(0, 4096));
+    if (!m) throw new Error(`Local project ${id} is unreadable`);
+    const meta = JSON.parse(m[1]);
+    return { meta, json: raw.slice(m[0].length, -1) };
+  }
+  async save({ id, name, preset, json }) {
+    await mkdir(this.dir, { recursive: true });
+    const pid = id ?? `local_${randomBytes(6).toString("hex")}`;
+    let prevName;
+    if (id) prevName = (await this.load(id).catch(() => null))?.meta.name;
+    const meta = { id: pid, name: name ?? prevName ?? "Untitled", preset, updatedAt: Date.now() };
+    await writeFile(this.file(pid), `{"meta":${JSON.stringify(meta)},"data":${json}}`);
+    return pid;
+  }
+  linkFor(id) {
+    return this.file(id);
+  }
+};
+function createStore() {
+  if (config.apiKey) {
+    if (!config.apiUrl) throw new Error("EZMOCKUPS_API_KEY is set but EZMOCKUPS_API_URL is not. Copy both from EZMockups \u2192 account menu \u2192 Connect an agent.");
+    return new CloudStore(config.apiUrl, config.apiKey);
+  }
+  return new LocalStore();
+}
+
+// src/simulator.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+async function bootedDevices() {
+  if (process.platform !== "darwin") throw new Error("Simulator capture needs macOS with Xcode.");
+  let stdout;
+  try {
+    ({ stdout } = await run("xcrun", ["simctl", "list", "devices", "booted", "-j"], { maxBuffer: 8 * 1024 * 1024 }));
+  } catch (e) {
+    throw new Error(`xcrun simctl failed \u2014 is Xcode installed? (${e instanceof Error ? e.message : e})`);
+  }
+  const data = JSON.parse(stdout);
+  return Object.entries(data.devices).flatMap(
+    ([runtime, list]) => list.filter((d) => d.state === "Booted").map((d) => ({
+      udid: d.udid,
+      name: d.name,
+      runtime: runtime.replace(/^com\.apple\.CoreSimulator\.SimRuntime\./, "").replace(/-(\d+)-(\d+)$/, " $1.$2")
+    }))
+  );
+}
+async function pickDevice(want) {
+  const booted = await bootedDevices();
+  const list = booted.map((d) => `"${d.name}" (${d.runtime}, ${d.udid})`).join("; ");
+  if (booted.length === 0) throw new Error("No simulator is booted. Boot one and run your app in it first.");
+  if (want) {
+    const w = want.toLowerCase();
+    const hit = booted.find((d) => d.udid.toLowerCase() === w) ?? booted.find((d) => d.name.toLowerCase() === w) ?? booted.find((d) => d.name.toLowerCase().includes(w));
+    if (!hit) throw new Error(`No booted simulator matches "${want}". Booted: ${list}.`);
+    return hit;
+  }
+  if (booted.length > 1) throw new Error(`Several simulators are booted \u2014 pass \`device\`. Booted: ${list}.`);
+  return booted[0];
+}
+async function cleanStatusBar(udid) {
+  try {
+    await run("xcrun", ["simctl", "status_bar", udid, "override", "--time", "9:41", "--dataNetwork", "wifi", "--wifiMode", "active", "--wifiBars", "3", "--cellularMode", "active", "--cellularBars", "4", "--batteryState", "charged", "--batteryLevel", "100"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function capture(udid, outPath) {
+  await run("xcrun", ["simctl", "io", udid, "screenshot", "--type=png", outPath]);
+}
+
+// src/locales.ts
+var ASC_LOCALE = {
+  en: "en-US",
+  "en-GB": "en-GB",
+  de: "de-DE",
+  fr: "fr-FR",
+  es: "es-ES",
+  "es-MX": "es-MX",
+  it: "it",
+  "pt-BR": "pt-BR",
+  "pt-PT": "pt-PT",
+  nl: "nl-NL",
+  sv: "sv",
+  da: "da",
+  no: "no",
+  fi: "fi",
+  pl: "pl",
+  cs: "cs",
+  sk: "sk",
+  hu: "hu",
+  ro: "ro",
+  hr: "hr",
+  ca: "ca",
+  el: "el",
+  tr: "tr",
+  ru: "ru",
+  uk: "uk",
+  ar: "ar-SA",
+  he: "he",
+  hi: "hi",
+  th: "th",
+  vi: "vi",
+  id: "id",
+  ms: "ms",
+  ja: "ja",
+  ko: "ko",
+  "zh-Hans": "zh-Hans",
+  "zh-Hant": "zh-Hant"
+};
+
+// src/index.ts
+var VERSION = "0.1.0";
+var store = createStore();
+var LANGUAGE_CODES = LANGUAGES.map((l) => l.code);
+var text = (value) => ({ type: "text", text: typeof value === "string" ? value : JSON.stringify(value, null, 2) });
+var image = (dataUrl) => {
+  const [head, data = ""] = dataUrl.split(",");
+  return { type: "image", data, mimeType: /data:([^;]+)/.exec(head)?.[1] ?? "image/jpeg" };
+};
+var queue = Promise.resolve();
+function exclusive(fn) {
+  const run2 = queue.then(fn, fn);
+  queue = run2.catch(() => void 0);
+  return run2;
+}
+function tool(fn) {
+  return (args) => exclusive(async () => {
+    try {
+      return { content: await fn(args) };
+    } catch (e) {
+      renderer.loaded = null;
+      return { content: [text(`Error: ${e instanceof Error ? e.message : String(e)}`)], isError: true };
+    }
+  });
+}
+var MIME = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", webp: "image/webp" };
+async function readImage(p) {
+  const full = resolvePath(p);
+  let buf;
+  try {
+    buf = await readFile2(full);
+  } catch {
+    throw new Error(`Can't read ${full}`);
+  }
+  let mime = MIME[path3.extname(full).slice(1).toLowerCase()];
+  if (buf[0] === 137 && buf[1] === 80) mime = "image/png";
+  else if (buf[0] === 255 && buf[1] === 216) mime = "image/jpeg";
+  else if (buf.subarray(8, 12).toString() === "WEBP") mime = "image/webp";
+  if (!mime) throw new Error(`${full} isn't a PNG, JPEG or WebP image`);
+  return `data:${mime};base64,${buf.toString("base64")}`;
+}
+var metas = /* @__PURE__ */ new Map();
+async function open(id) {
+  if (renderer.loaded === id && metas.has(id)) return metas.get(id);
+  const { meta, json } = await store.load(id);
+  await renderer.call("load", json);
+  renderer.loaded = id;
+  metas.set(id, meta);
+  return meta;
+}
+async function persist(meta, rename) {
+  const json = await renderer.call("serialize");
+  const id = await store.save({ id: meta.id, name: rename, preset: meta.preset, json });
+  renderer.loaded = id;
+  const prev = meta.id ? metas.get(meta.id) : void 0;
+  metas.set(id, { id, name: rename ?? prev?.name ?? meta.name ?? "Untitled", preset: meta.preset, updatedAt: Date.now() });
+  return id;
+}
+var languageSchema = z.string().describe(`Language code: ${LANGUAGE_CODES.join(", ")}`);
+function checkLanguages(codes) {
+  const bad = codes.filter((c) => !LANGUAGE_CODES.includes(c));
+  if (bad.length) throw new Error(`Unknown language code(s): ${bad.join(", ")}. Supported: ${LANGUAGE_CODES.join(", ")}.`);
+}
+var server = new McpServer(
+  { name: "ezmockups", version: VERSION },
+  {
+    instructions: `EZMockups designs, translates and exports App Store / Google Play screenshot sets. You are the art director and translator: you write the design plan and every word of copy yourself (no EZMockups AI credits are used); EZMockups renders them with professionally tuned layouts into editable projects.
+Typical flow: capture_simulator_screenshot (or use existing screenshots) \u2192 inspect_screenshots \u2192 get_design_guide (read once) \u2192 create_screenshot_set \u2192 review the preview and iterate \u2192 set_texts to translate \u2192 export_screenshots.`
+  }
+);
+server.registerTool(
+  "get_design_guide",
+  {
+    title: "Design guide",
+    description: "How to write a screenshot-set plan: layouts, copy rules, palette and type, the plan JSON format, allowed fonts/devices, and how translation works. Read it once before your first create_screenshot_set.",
+    inputSchema: {},
+    annotations: { readOnlyHint: true }
+  },
+  tool(async () => [
+    text(AGENT_DESIGN_GUIDE),
+    text({ languages: LANGUAGES.map((l) => `${l.code} \u2014 ${l.name}`) })
+  ])
+);
+server.registerTool(
+  "capture_simulator_screenshot",
+  {
+    title: "Capture iOS / watchOS Simulator",
+    description: "Save a PNG of what a booted iOS or Apple Watch simulator shows right now (macOS + Xcode). Navigate your app to the screen first. Sets a clean 9:41 status bar by default. Returns the file path and a small preview.",
+    inputSchema: {
+      device: z.string().optional().describe('Simulator name or UDID (e.g. "iPhone 17 Pro", "Apple Watch Series 11 (46mm)"). Required when several are booted.'),
+      outputPath: z.string().optional().describe("Where to save the PNG. Default: ~/.ezmockups/captures/<device>-<time>.png"),
+      cleanStatusBar: z.boolean().optional().describe("Override the status bar to 9:41, full battery and signal (default true).")
+    }
+  },
+  tool(async ({ device, outputPath, cleanStatusBar: clean = true }) => {
+    const d = await pickDevice(device);
+    const cleaned = clean ? await cleanStatusBar(d.udid) : false;
+    const slug = d.name.replace(/[^\w]+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+    const out = outputPath ? resolvePath(outputPath) : path3.join(config.home, "captures", `${slug}-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.png`);
+    await mkdir2(path3.dirname(out), { recursive: true });
+    await capture(d.udid, out);
+    const shot = await readImage(out);
+    const info = await renderer.call("inspect", [shot]);
+    return [
+      text({ path: out, device: `${d.name} (${d.runtime})`, size: info.sizes[0], statusBar: cleaned ? "clean (9:41)" : "as is" }),
+      image(await renderer.call("sheet", [shot], 560))
+    ];
+  })
+);
+server.registerTool(
+  "inspect_screenshots",
+  {
+    title: "Inspect screenshots",
+    description: "Look at app screenshots before designing: returns them side by side labelled with the index a plan uses (screenshot 0, 1, \u2026), their pixel sizes, the target they look like (iphone / ipad / watch), and the app's brand colours sampled from the pixels.",
+    inputSchema: {
+      screenshots: z.array(z.string()).min(1).max(10).describe("Image file paths (PNG/JPEG/WebP), in the order you will reference them.")
+    },
+    annotations: { readOnlyHint: true }
+  },
+  tool(async ({ screenshots }) => {
+    const shots = await Promise.all(screenshots.map(readImage));
+    const info = await renderer.call("inspect", shots);
+    return [
+      text({ detectedTarget: info.target, brandColors: info.brandColors, screenshots: screenshots.map((p, i) => ({ index: i, path: resolvePath(p), ...info.sizes[i] })) }),
+      image(await renderer.call("sheet", shots, shots.length > 4 ? 560 : 720))
+    ];
+  })
+);
+var planSchema = z.object({
+  concept: z.object({ name: z.string(), story: z.string().optional() }).describe("Theme name (becomes the project name) and how the set flows."),
+  style: z.object({
+    background: z.enum(BACKGROUNDS),
+    colors: z.object({ bg1: z.string(), bg2: z.string(), text: z.string(), muted: z.string(), accent: z.string() }).describe("#hex colours"),
+    headingFont: z.string(),
+    bodyFont: z.string(),
+    headingWeight: z.enum(["600", "700", "800"]).optional(),
+    uppercase: z.boolean().optional(),
+    device: z.string().optional(),
+    deviceFinish: z.string().nullable().optional()
+  }).passthrough(),
+  screens: z.array(z.object({
+    layout: z.enum(LAYOUTS),
+    screenshot: z.number().int().describe("0-based index into `screenshots`"),
+    secondScreenshot: z.number().int().optional().describe("tilted-duo only"),
+    eyebrow: z.string().optional(),
+    headline: z.string().describe("2\u20136 words; wrap accent words in **double asterisks**"),
+    subtitle: z.string().optional(),
+    zoom: z.object({ x: z.number(), y: z.number() }).optional().describe("zoom-callout: detail position as fractions of the screenshot"),
+    badge: z.object({
+      kind: z.enum(BADGES),
+      text: z.string().optional(),
+      title: z.string().optional(),
+      subtitle: z.string().optional(),
+      quote: z.string().optional(),
+      author: z.string().optional()
+    }).nullable().optional(),
+    invert: z.boolean().optional()
+  }).passthrough()).min(1).max(10)
+}).passthrough();
+server.registerTool(
+  "create_screenshot_set",
+  {
+    title: "Create screenshot set",
+    description: "Render a screenshot set from your design plan (see get_design_guide) and save it as an editable EZMockups project. Returns the project id, a link, every text key (for set_texts), the screenshot slots (for set_localized_screenshots), any corrections made to the plan, and a preview image of all screens \u2014 check it and iterate. Pass projectId to redesign an existing project in place (its languages are dropped; re-run set_texts).",
+    inputSchema: {
+      screenshots: z.array(z.string()).min(1).max(10).describe("App screenshot file paths; the plan refers to them by 0-based index."),
+      target: z.enum(TARGETS).describe("iphone (1290\xD72796), ipad (2064\xD72752) or watch (416\xD7496). One target per set."),
+      plan: planSchema,
+      name: z.string().optional().describe("Project name (default: plan.concept.name)."),
+      sourceLanguage: languageSchema.optional().describe('Language the copy is written in (default "en").'),
+      projectId: z.string().optional().describe("Overwrite this project instead of creating a new one.")
+    }
+  },
+  tool(async (args) => {
+    if (args.sourceLanguage) checkLanguages([args.sourceLanguage]);
+    if (args.projectId) await store.load(args.projectId);
+    const shots = await Promise.all(args.screenshots.map(readImage));
+    renderer.loaded = null;
+    const made = await renderer.call("create", {
+      plan: args.plan,
+      shots,
+      target: args.target,
+      sourceLanguage: args.sourceLanguage ?? "en"
+    });
+    const name = args.name?.trim() || made.name;
+    const id = await persist({ id: args.projectId, preset: made.preset }, name);
+    const summary = await renderer.call("describe");
+    const account = await store.account();
+    return [
+      text({
+        projectId: id,
+        name,
+        open: store.linkFor(id),
+        storage: account.mode === "cloud" ? `EZMockups cloud (${account.email ?? "your account"}) \u2014 open it in the editor to fine-tune` : "local file (no EZMOCKUPS_API_KEY set)",
+        screens: summary.screens,
+        size: summary.size,
+        sourceLanguage: summary.sourceLanguage,
+        corrections: made.warnings.length ? made.warnings : void 0,
+        texts: summary.texts,
+        screenshotSlots: summary.screenshotSlots
+      }),
+      image(await renderer.call("preview"))
+    ];
+  })
+);
+server.registerTool(
+  "list_projects",
+  {
+    title: "List projects",
+    description: "The user's EZMockups projects (newest first): id, name, canvas size, last update.",
+    inputSchema: {},
+    annotations: { readOnlyHint: true }
+  },
+  tool(async () => {
+    const list = await store.list();
+    const account = await store.account();
+    return [text({
+      storage: account.mode,
+      account: account.email ?? void 0,
+      projects: list.slice(0, 50).map((p) => ({ id: p.id, name: p.name, size: `${p.preset.width}\xD7${p.preset.height}`, kind: p.preset.name, updated: new Date(p.updatedAt).toISOString() }))
+    })];
+  })
+);
+server.registerTool(
+  "get_project",
+  {
+    title: "Get project",
+    description: "A project's screens, every text with its key, its languages and per-language translation status (untranslated keys, translations that wrap to more lines than the source or leave the screen), and its screenshot slots. Optionally returns a preview image of one language.",
+    inputSchema: {
+      projectId: z.string(),
+      preview: z.string().optional().describe('Language code to preview ("source" for the source language). Omit for no image.')
+    },
+    annotations: { readOnlyHint: true }
+  },
+  tool(async ({ projectId, preview }) => {
+    const meta = await open(projectId);
+    const summary = await renderer.call("describe");
+    const out = [text({ projectId, name: meta.name, open: store.linkFor(projectId), ...summary })];
+    if (preview) out.push(image(await renderer.call("preview", preview === "source" ? void 0 : preview)));
+    return out;
+  })
+);
+server.registerTool(
+  "set_texts",
+  {
+    title: "Set texts / translate",
+    description: "Write copy by key (keys come from create_screenshot_set / get_project). Use the source language code to edit the design's own copy; use any other language code to translate \u2014 that language is added as its own row of screens (a full copy of the design) on first use. You write the translations: natural, punchy marketing copy of similar length; keep \\n breaks, brand names, numbers, emoji and casing style. Headline accent words are shown as **double asterisks** in the source texts \u2014 mark the matching words in each translation the same way (no markers = no accent colour). Translations that wrap to more lines than the source are shrunk to fit (down to ~75%); anything still too long is listed in tooLong, shorten those. Several languages per call is fine (they are saved together).",
+    inputSchema: {
+      projectId: z.string(),
+      texts: z.record(z.string(), z.record(z.string(), z.string())).describe('{ "<language code>": { "<text key>": "<text>" } }'),
+      previewLanguages: z.array(z.string()).max(4).optional().describe("Languages to return a preview image of (each costs tokens \u2014 preview the ones with problems).")
+    }
+  },
+  tool(async ({ projectId, texts, previewLanguages = [] }) => {
+    checkLanguages([...Object.keys(texts), ...previewLanguages]);
+    const meta = await open(projectId);
+    const { sourceLanguage } = await renderer.call("describe");
+    const order = Object.keys(texts).sort((a, b) => Number(b === sourceLanguage) - Number(a === sourceLanguage));
+    const results = {};
+    for (const lang of order) {
+      const r = await renderer.call("setTexts", lang, texts[lang]);
+      results[lang] = { ...r.status ?? { edited: true }, ...r.unknownKeys.length ? { unknownKeys: r.unknownKeys } : {} };
+    }
+    await persist(meta);
+    const out = [text({ projectId, results })];
+    for (const l of previewLanguages) out.push(image(await renderer.call("preview", l)));
+    return out;
+  })
+);
+server.registerTool(
+  "remove_languages",
+  {
+    title: "Remove languages",
+    description: "Delete language rows from a project (the source language stays).",
+    inputSchema: { projectId: z.string(), languages: z.array(z.string()).min(1) },
+    annotations: { destructiveHint: true }
+  },
+  tool(async ({ projectId, languages }) => {
+    const meta = await open(projectId);
+    await renderer.call("removeLanguages", languages);
+    await persist(meta);
+    const s = await renderer.call("describe");
+    return [text({ projectId, languages: s.languages })];
+  })
+);
+server.registerTool(
+  "set_localized_screenshots",
+  {
+    title: "Set localized screenshots",
+    description: "Show localized app UI in one language: replace the screenshots in that language's screens. Screenshot slots (from create_screenshot_set / get_project) are the distinct screenshots the design uses; capture the same app screen in the target language and pass it for that slot. Adds the language if it isn't there yet.",
+    inputSchema: {
+      projectId: z.string(),
+      language: languageSchema,
+      screenshots: z.record(z.string(), z.string()).describe('{ "<slot number>": "<image path>" }'),
+      preview: z.boolean().optional().describe("Return a preview of the language (default true).")
+    }
+  },
+  tool(async ({ projectId, language, screenshots, preview = true }) => {
+    checkLanguages([language]);
+    const meta = await open(projectId);
+    const bySlot = {};
+    for (const [slot, p] of Object.entries(screenshots)) bySlot[slot] = await readImage(p);
+    const r = await renderer.call("setLocalizedScreenshots", language, bySlot);
+    await persist(meta);
+    const out = [text({ projectId, language, devicesUpdated: r.replaced })];
+    if (preview) out.push(image(await renderer.call("preview", language)));
+    return out;
+  })
+);
+server.registerTool(
+  "export_screenshots",
+  {
+    title: "Export screenshots",
+    description: `Render final PNGs at the exact store sizes (opaque, upload-ready) into a folder, one subfolder per language. App Store: iPhone sets export 6.3" (required), 6.9" and 6.5"; iPad 13"; watch sets every Apple Watch size. layout "fastlane" writes fastlane deliver's screenshots/<locale>/ structure with App Store Connect locale names.`,
+    inputSchema: {
+      projectId: z.string(),
+      outputDir: z.string().describe('Folder to write into (created if needed), e.g. "./fastlane/screenshots".'),
+      store: z.enum(["app-store", "google-play"]).optional().describe("Default app-store."),
+      languages: z.array(z.string()).optional().describe("Languages to export (default: all in the project)."),
+      layout: z.enum(["folders", "fastlane"]).optional().describe("folders (default): <lang>/<size>/01.png. fastlane: <asc-locale>/01_<size>.png (App Store only).")
+    }
+  },
+  tool(async (args) => {
+    const storeKind = args.store ?? "app-store";
+    const layout = args.layout ?? "folders";
+    if (layout === "fastlane" && storeKind !== "app-store") throw new Error("The fastlane layout is for App Store exports.");
+    await open(args.projectId);
+    const s = await renderer.call("describe");
+    const all = [s.sourceLanguage, ...s.languages];
+    const langs = args.languages?.length ? args.languages : all;
+    const missing = langs.filter((l) => !all.includes(l));
+    if (missing.length) throw new Error(`Not in this project: ${missing.join(", ")}. It has: ${all.join(", ")}.`);
+    const account = await store.account();
+    const out = resolvePath(args.outputDir);
+    const files = [];
+    const perSize = /* @__PURE__ */ new Map();
+    await renderer.call("beginExport");
+    try {
+      for (const lang of langs) {
+        for (let i = 0; i < s.screens; i++) {
+          const imgs = await renderer.call("exportScreen", lang, i, storeKind, account.watermark);
+          for (const img of imgs) {
+            const n = String(i + 1).padStart(2, "0");
+            const file = layout === "fastlane" ? path3.join(out, ASC_LOCALE[lang] ?? lang, `${n}_${img.sizeId}_${img.width}x${img.height}.png`) : path3.join(out, lang, img.folder, `${n}.png`);
+            await mkdir2(path3.dirname(file), { recursive: true });
+            await writeFile2(file, Buffer.from(img.png, "base64"));
+            files.push(file);
+            perSize.set(`${img.sizeId} (${img.width}\xD7${img.height})`, (perSize.get(`${img.sizeId} (${img.width}\xD7${img.height})`) ?? 0) + 1);
+          }
+        }
+      }
+    } finally {
+      await renderer.call("endExport").catch(() => void 0);
+    }
+    if (files.length === 0) throw new Error(`No ${storeKind} size matches this project's ${s.size.width}\xD7${s.size.height} screens.`);
+    return [text({
+      outputDir: out,
+      files: files.length,
+      languages: langs,
+      sizes: Object.fromEntries(perSize),
+      watermarked: account.watermark ? account.mode === "local" ? "yes \u2014 no EZMOCKUPS_API_KEY is set, so exports use the free plan. Connect an EZMockups account that owns the app for clean exports." : "yes \u2014 this account is on the free plan. Get EZMockups ($29 once) for clean exports." : "no",
+      sample: files.slice(0, 6).map((f) => path3.relative(out, f))
+    })];
+  })
+);
+var transport = new StdioServerTransport();
+await server.connect(transport);
+console.error(`[ezmockups-mcp ${VERSION}] ready \u2014 ${config.apiKey ? "cloud projects" : "local projects (no EZMOCKUPS_API_KEY)"}, renderer ${config.appUrl}`);
+var shutdown = async () => {
+  await renderer.close();
+  process.exit(0);
+};
+process.on("SIGINT", () => void shutdown());
+process.on("SIGTERM", () => void shutdown());
+process.stdin.on("close", () => void shutdown());

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "ezmockups-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "MCP server for EZMockups — let your coding agent design, translate and export App Store screenshots.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "ezmockups-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "esbuild src/index.ts --bundle --platform=node --format=esm --target=node20 --packages=external --banner:js='#!/usr/bin/env node' --outfile=dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck && npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.2",
+    "puppeteer-core": "^25.17.0",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "esbuild": "^0.25.0",
+    "typescript": "~5.6.2"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ]
+  }
+}