locaflow-mcp-server 0.1.0

package/README.md

@@ -0,0 +1,132 @@
+# @locaflow/mcp-server
+
+Translate iOS, Android & web localization files directly from [Claude Code](https://claude.com/claude-code). Powered by [LocaFlow](https://locaflow.dev).
+
+## Quick setup (2 minutes)
+
+### Step 1: Install
+
+```bash
+npm install -g @locaflow/mcp-server
+```
+
+### Step 2: Add to Claude Code
+
+Open your Claude Code settings and add the MCP server:
+
+```bash
+claude mcp add locaflow -- locaflow-mcp
+```
+
+Or manually add to `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "locaflow": {
+      "command": "locaflow-mcp"
+    }
+  }
+}
+```
+
+### Step 3: Use it
+
+Open Claude Code in any project and say:
+
+```
+"Scan this project for localization files"
+"Translate my Localizable.strings to Spanish and Japanese"
+"Translate my App Store description to French, German, and Korean"
+```
+
+That's it. No API key needed — works in free demo mode (50 strings/day). For unlimited translations, set `LOCAFLOW_TOKEN` in the env config.
+
+## Tools
+
+### `scan_project`
+
+Find all localization files in a project directory. Reports file paths, formats, and string counts.
+
+```
+"What localization files does this project have?"
+"Scan my project for iOS localization files"
+```
+
+### `translate_file`
+
+Translate a `.strings`, `strings.xml`, or `.json` file. Writes output in the correct platform convention:
+
+- **iOS:** `es.lproj/Localizable.strings`
+- **Android:** `values-es/strings.xml`
+- **Web:** `es.json`
+
+```
+"Translate my Localizable.strings to Spanish and Japanese"
+"Translate strings.xml to French, German, and Korean"
+```
+
+### `translate_text`
+
+Translate any text. Good for release notes, UI copy, quick checks.
+
+```
+"Translate 'Welcome back!' to Korean"
+```
+
+### `translate_appstore_metadata`
+
+Translate App Store metadata (name, subtitle, description, keywords, what's new).
+
+```
+"Translate my app description and keywords to Spanish and Japanese"
+```
+
+### `appstore_fetch_metadata`
+
+Pull current metadata from App Store Connect. Returns version ID needed for pushing.
+
+### `appstore_push_metadata`
+
+Push translated metadata to App Store Connect.
+
+```
+"Fetch my App Store metadata, translate it to 5 languages, and push it back"
+```
+
+## Supported formats
+
+| Platform | Translatable files | Output convention |
+|----------|-------------------|-------------------|
+| iOS | `.strings` | `{lang}.lproj/` |
+| Android | `strings.xml` | `values-{lang}/` |
+| Web | `.json` | `{lang}.json` |
+
+## Supported languages
+
+30+ languages including: `es`, `fr`, `de`, `ja`, `ko`, `zh-Hans`, `zh-Hant`, `pt-BR`, `ar`, `hi`, `ru`, `tr`, `nl`, `sv`, `da`, `fi`, `nb`, `pl`, `cs`, `el`, `he`, `th`, `vi`, `id`, `ms`, `uk`, `ro`, `hu`, and more.
+
+## Configuration
+
+| Environment variable | Description |
+|---------------------|-------------|
+| `LOCAFLOW_TOKEN` | Optional. Your LocaFlow auth token for unlimited translations. Without it, demo mode (50 strings/day). |
+
+To set the token:
+
+```json
+{
+  "mcpServers": {
+    "locaflow": {
+      "command": "locaflow-mcp",
+      "env": {
+        "LOCAFLOW_TOKEN": "your-token-here"
+      }
+    }
+  }
+}
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * LocaFlow MCP Server
+ *
+ * Gives Claude Code the ability to translate iOS / Android / web
+ * localization files and manage App Store Connect metadata — all
+ * from the terminal.
+ *
+ * Setup — add to .claude/settings.json:
+ *   "mcpServers": { "locaflow": { "command": "npx", "args": ["-y", "@locaflow/mcp-server"] } }
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,611 @@
+#!/usr/bin/env node
+/**
+ * LocaFlow MCP Server
+ *
+ * Gives Claude Code the ability to translate iOS / Android / web
+ * localization files and manage App Store Connect metadata — all
+ * from the terminal.
+ *
+ * Setup — add to .claude/settings.json:
+ *   "mcpServers": { "locaflow": { "command": "npx", "args": ["-y", "@locaflow/mcp-server"] } }
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { readFile, writeFile, readdir, stat, mkdir, access } from "node:fs/promises";
+import { join, extname, basename, dirname, relative } from "node:path";
+import { constants } from "node:fs";
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+const SUPABASE_URL = "https://mtyoymatixwafhjfdoja.supabase.co";
+const SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im10eW95bWF0aXh3YWZoamZkb2phIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDg3NTY3MDYsImV4cCI6MjA2NDMzMjcwNn0.d1R6HFKzqBHvqVcZwEjAZYvrFqAAHp5kxHpvNTqNjCA";
+const TRANSLATE_FN = `${SUPABASE_URL}/functions/v1/translate`;
+const ASC_FN = `${SUPABASE_URL}/functions/v1/appstore-connect`;
+const MAX_BATCH_AUTH = 20;
+const MAX_BATCH_DEMO = 10;
+function getToken() {
+    return process.env.LOCAFLOW_TOKEN;
+}
+/** Return a structured MCP error content block */
+function errorResult(message) {
+    return { content: [{ type: "text", text: message }], isError: true };
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Call the LocaFlow translate edge function */
+async function translateBatch(texts, targetLanguage, opts = {}) {
+    const isDemo = !opts.token;
+    const headers = {
+        "Content-Type": "application/json",
+        "apikey": SUPABASE_ANON_KEY,
+        "Authorization": `Bearer ${opts.token || SUPABASE_ANON_KEY}`,
+    };
+    const body = {
+        texts,
+        targetLanguage,
+        ...(opts.targetLanguageName && { targetLanguageName: opts.targetLanguageName }),
+        ...(opts.context && { context: opts.context }),
+        ...(opts.preserveFormatting !== undefined && { preserveFormatting: opts.preserveFormatting }),
+        ...(opts.creativityLevel !== undefined && { creativityLevel: opts.creativityLevel }),
+        ...(isDemo && { isDemo: true }),
+    };
+    let res;
+    try {
+        res = await fetch(TRANSLATE_FN, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+        });
+    }
+    catch (err) {
+        throw new Error(`Network error calling LocaFlow API: ${err.message}`);
+    }
+    if (!res.ok) {
+        let detail;
+        try {
+            const err = (await res.json());
+            detail = err.error || err.message || res.statusText;
+        }
+        catch {
+            detail = `HTTP ${res.status} ${res.statusText}`;
+        }
+        throw new Error(`LocaFlow API error (${res.status}): ${detail}`);
+    }
+    const data = (await res.json());
+    return data.translatedTexts ?? [data.translatedText];
+}
+/** Parse a .strings file into key-value pairs */
+function parseStringsFile(content) {
+    const entries = [];
+    const lines = content.split("\n");
+    let currentComment;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("/*") && trimmed.endsWith("*/")) {
+            currentComment = trimmed.slice(2, -2).trim();
+            continue;
+        }
+        const match = trimmed.match(/^"(.+?)"\s*=\s*"(.+?)"\s*;$/);
+        if (match) {
+            entries.push({ key: match[1], value: match[2], comment: currentComment });
+            currentComment = undefined;
+        }
+    }
+    return entries;
+}
+/** Rebuild a .strings file from entries */
+function buildStringsFile(entries) {
+    return entries
+        .map((e) => {
+        const commentLine = e.comment ? `/* ${e.comment} */\n` : "";
+        return `${commentLine}"${e.key}" = "${e.value}";`;
+    })
+        .join("\n\n") + "\n";
+}
+/** Parse Android strings.xml */
+function parseAndroidXml(content) {
+    const entries = [];
+    const regex = /<string\s+name="([^"]+)"[^>]*>([\s\S]*?)<\/string>/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        entries.push({
+            key: match[1],
+            value: match[2]
+                .replace(/\\'/g, "'")
+                .replace(/&amp;/g, "&")
+                .replace(/&lt;/g, "<")
+                .replace(/&gt;/g, ">"),
+        });
+    }
+    return entries;
+}
+/** Rebuild Android strings.xml */
+function buildAndroidXml(entries) {
+    const lines = entries.map((e) => `    <string name="${e.key}">${e.value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/'/g, "\\'")}</string>`);
+    return `<?xml version="1.0" encoding="utf-8"?>\n<resources>\n${lines.join("\n")}\n</resources>\n`;
+}
+/** Parse JSON localization file (supports nested keys) */
+function parseJsonFile(content) {
+    const obj = JSON.parse(content);
+    const entries = [];
+    function walk(o, prefix) {
+        for (const [k, v] of Object.entries(o)) {
+            const fullKey = prefix ? `${prefix}.${k}` : k;
+            if (typeof v === "string") {
+                entries.push({ key: fullKey, value: v });
+            }
+            else if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+                walk(v, fullKey);
+            }
+        }
+    }
+    walk(obj, "");
+    return entries;
+}
+/** Rebuild nested JSON from flat key-value pairs */
+function buildJsonFile(entries) {
+    const obj = {};
+    for (const { key, value } of entries) {
+        const parts = key.split(".");
+        let cur = obj;
+        for (let i = 0; i < parts.length - 1; i++) {
+            if (!(parts[i] in cur))
+                cur[parts[i]] = {};
+            cur = cur[parts[i]];
+        }
+        cur[parts[parts.length - 1]] = value;
+    }
+    return JSON.stringify(obj, null, 2) + "\n";
+}
+/** Detect file type and parse accordingly */
+function parseLocFile(filePath, content) {
+    const ext = extname(filePath).toLowerCase();
+    if (ext === ".strings")
+        return { format: "strings", entries: parseStringsFile(content) };
+    if (ext === ".xml")
+        return { format: "android", entries: parseAndroidXml(content) };
+    if (ext === ".json")
+        return { format: "json", entries: parseJsonFile(content) };
+    throw new Error(`Unsupported file format: ${ext}. Supported: .strings, .xml (strings.xml), .json`);
+}
+/** Rebuild file from entries */
+function buildLocFile(format, entries) {
+    if (format === "strings")
+        return buildStringsFile(entries);
+    if (format === "android")
+        return buildAndroidXml(entries);
+    return buildJsonFile(entries);
+}
+/** Check if a directory exists and is readable */
+async function directoryExists(dir) {
+    try {
+        await access(dir, constants.R_OK);
+        const s = await stat(dir);
+        return s.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Recursively find localization files that we can actually translate */
+async function findLocFiles(dir, platform) {
+    const results = [];
+    // Only scan for formats we can actually parse and translate
+    const platformExts = {
+        ios: [".strings"],
+        android: [".xml"],
+        web: [".json"],
+    };
+    const validExts = platform
+        ? platformExts[platform] || []
+        : [".strings", ".xml", ".json"];
+    async function walk(d, depth) {
+        if (depth > 6)
+            return;
+        const items = await readdir(d).catch(() => []);
+        for (const item of items) {
+            if (item.startsWith(".") ||
+                item === "node_modules" ||
+                item === "Pods" ||
+                item === "build" ||
+                item === "dist" ||
+                item === "DerivedData")
+                continue;
+            const full = join(d, item);
+            const s = await stat(full).catch(() => null);
+            if (!s)
+                continue;
+            if (s.isDirectory()) {
+                await walk(full, depth + 1);
+            }
+            else if (validExts.some((ext) => item.endsWith(ext))) {
+                // For android, only match strings.xml (not any .xml)
+                if (platform === "android" && item !== "strings.xml")
+                    continue;
+                // For web, skip package.json, tsconfig.json etc
+                if (item.endsWith(".json") && !item.match(/^[a-z]{2}(-[A-Za-z]+)?\.json$/) && item !== "messages.json" && item !== "translations.json" && item !== "locale.json") {
+                    // Heuristic: only pick .json files that look like locale files
+                    // (2-letter code, or explicit localization names)
+                    // But also accept any .json if the user explicitly chose "web" platform
+                    if (!platform)
+                        continue;
+                }
+                results.push(full);
+            }
+        }
+    }
+    await walk(dir, 0);
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Language mapping
+// ---------------------------------------------------------------------------
+const LANGUAGE_NAMES = {
+    es: "Spanish", fr: "French", de: "German", it: "Italian", pt: "Portuguese",
+    "pt-BR": "Brazilian Portuguese", ja: "Japanese", ko: "Korean",
+    "zh-Hans": "Simplified Chinese", "zh-Hant": "Traditional Chinese",
+    ar: "Arabic", hi: "Hindi", ru: "Russian", tr: "Turkish", nl: "Dutch",
+    sv: "Swedish", da: "Danish", fi: "Finnish", nb: "Norwegian", pl: "Polish",
+    cs: "Czech", el: "Greek", he: "Hebrew", th: "Thai", vi: "Vietnamese",
+    id: "Indonesian", ms: "Malay", uk: "Ukrainian", ro: "Romanian",
+    hu: "Hungarian", sk: "Slovak", bg: "Bulgarian", hr: "Croatian",
+    ca: "Catalan", eu: "Basque",
+};
+// ---------------------------------------------------------------------------
+// MCP Server
+// ---------------------------------------------------------------------------
+const server = new McpServer({
+    name: "locaflow",
+    version: "0.1.0",
+});
+// ---- Tool: translate_file ----
+server.tool("translate_file", "Translate an iOS .strings, Android strings.xml, or web .json localization file to one or more languages. Writes translated files alongside the source.", {
+    file_path: z.string().describe("Absolute path to the source localization file (.strings, .xml, or .json)"),
+    target_languages: z.array(z.string()).describe('ISO 639-1 language codes to translate to, e.g. ["es", "ja", "de"]'),
+    output_dir: z.string().optional().describe("Directory to write translated files. Defaults to same directory as source file."),
+    context: z.string().optional().describe("Extra context for the translator, e.g. 'casual fitness app for teens'"),
+    creativity_level: z.number().min(1).max(5).optional().describe("Translation creativity 1-5 (1=literal, 5=creative). Default 3."),
+}, async ({ file_path, target_languages, output_dir, context, creativity_level }) => {
+    const token = getToken();
+    // Read & parse source file
+    let content;
+    try {
+        content = await readFile(file_path, "utf-8");
+    }
+    catch (err) {
+        return errorResult(`Cannot read file: ${file_path}\n${err.message}`);
+    }
+    let format;
+    let entries;
+    try {
+        const parsed = parseLocFile(file_path, content);
+        format = parsed.format;
+        entries = parsed.entries;
+    }
+    catch (err) {
+        return errorResult(err.message);
+    }
+    if (entries.length === 0) {
+        return errorResult(`No translatable strings found in ${file_path}. The file may be empty or in an unsupported structure.`);
+    }
+    const outDir = output_dir || dirname(file_path);
+    const sourceBasename = basename(file_path);
+    const results = [];
+    const errors = [];
+    for (const lang of target_languages) {
+        const langName = LANGUAGE_NAMES[lang] || lang;
+        try {
+            // Batch translate all values (demo mode has smaller batch limit)
+            const batchSize = token ? MAX_BATCH_AUTH : MAX_BATCH_DEMO;
+            const values = entries.map((e) => e.value);
+            const translated = [];
+            for (let i = 0; i < values.length; i += batchSize) {
+                // Demo mode has a 3-second burst protection between requests
+                if (!token && i > 0)
+                    await new Promise((r) => setTimeout(r, 3200));
+                const batch = values.slice(i, i + batchSize);
+                const result = await translateBatch(batch, lang, {
+                    targetLanguageName: langName,
+                    context,
+                    preserveFormatting: true,
+                    creativityLevel: creativity_level,
+                    token,
+                });
+                translated.push(...result);
+            }
+            // Build translated entries
+            const translatedEntries = entries.map((e, i) => ({
+                ...e,
+                value: translated[i] || e.value,
+            }));
+            // Determine output path
+            let outPath;
+            if (format === "strings") {
+                const lprojDir = join(outDir, `${lang}.lproj`);
+                await mkdir(lprojDir, { recursive: true });
+                outPath = join(lprojDir, sourceBasename);
+            }
+            else if (format === "android") {
+                const valuesDir = join(outDir, `values-${lang}`);
+                await mkdir(valuesDir, { recursive: true });
+                outPath = join(valuesDir, "strings.xml");
+            }
+            else {
+                outPath = join(outDir, `${lang}.json`);
+            }
+            const translatedContent = buildLocFile(format, translatedEntries);
+            await writeFile(outPath, translatedContent, "utf-8");
+            results.push(`  ${lang} (${langName}): ${outPath} — ${translatedEntries.length} strings`);
+        }
+        catch (err) {
+            errors.push(`  ${lang} (${langName}): FAILED — ${err.message}`);
+        }
+    }
+    const lines = [
+        `Source: ${file_path} (${entries.length} strings, ${format})`,
+    ];
+    if (results.length > 0) {
+        lines.push(`\nTranslated (${results.length}/${target_languages.length} languages):`);
+        lines.push(...results);
+    }
+    if (errors.length > 0) {
+        lines.push(`\nFailed:`);
+        lines.push(...errors);
+    }
+    if (errors.length > 0 && results.length === 0) {
+        return errorResult(lines.join("\n"));
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+});
+// ---- Tool: translate_text ----
+server.tool("translate_text", "Translate arbitrary text to a target language via LocaFlow. Good for App Store descriptions, release notes, or any string.", {
+    text: z.string().describe("The text to translate"),
+    target_language: z.string().describe('ISO 639-1 language code, e.g. "es", "ja", "zh-Hans"'),
+    context: z.string().optional().describe("Context for better translation quality"),
+}, async ({ text, target_language, context }) => {
+    const token = getToken();
+    const langName = LANGUAGE_NAMES[target_language] || target_language;
+    try {
+        const [translated] = await translateBatch([text], target_language, {
+            targetLanguageName: langName,
+            context,
+            preserveFormatting: true,
+            token,
+        });
+        return {
+            content: [{ type: "text", text: `**${langName} (${target_language}):**\n${translated}` }],
+        };
+    }
+    catch (err) {
+        return errorResult(`Translation failed: ${err.message}`);
+    }
+});
+// ---- Tool: scan_project ----
+server.tool("scan_project", "Scan a project directory for localization files (.strings, strings.xml, .json). Returns file paths, formats, and string counts.", {
+    directory: z.string().describe("Absolute path to the project root"),
+    platform: z.enum(["ios", "android", "web"]).optional().describe("Filter by platform"),
+}, async ({ directory, platform }) => {
+    // Validate directory exists
+    const exists = await directoryExists(directory);
+    if (!exists) {
+        return errorResult(`Directory not found: ${directory}\nMake sure the path exists and is readable.`);
+    }
+    const files = await findLocFiles(directory, platform);
+    if (files.length === 0) {
+        const platformHint = platform
+            ? `\nLooked for: ${platform === "ios" ? ".strings" : platform === "android" ? "strings.xml" : ".json"} files`
+            : "";
+        return {
+            content: [{
+                    type: "text",
+                    text: `No localization files found in ${directory}${platformHint}\n\nTip: try specifying a platform (ios, android, web) or check that the directory contains localization files.`,
+                }],
+        };
+    }
+    const details = [];
+    let totalStrings = 0;
+    for (const f of files) {
+        try {
+            const content = await readFile(f, "utf-8");
+            const { format, entries } = parseLocFile(f, content);
+            totalStrings += entries.length;
+            details.push(`  ${relative(directory, f)}  [${format}]  ${entries.length} strings`);
+        }
+        catch {
+            details.push(`  ${relative(directory, f)}  [error reading]`);
+        }
+    }
+    const summary = [
+        `Found ${files.length} localization file(s) in ${directory}`,
+        `Total translatable strings: ${totalStrings}`,
+        ``,
+        ...details,
+    ].join("\n");
+    return { content: [{ type: "text", text: summary }] };
+});
+// ---- Tool: translate_appstore_metadata ----
+server.tool("translate_appstore_metadata", "Translate App Store metadata (name, subtitle, description, keywords, what's new) to multiple languages. Returns the translated metadata as structured text you can paste or push via appstore_push_metadata.", {
+    name: z.string().optional().describe("App name (max 30 chars)"),
+    subtitle: z.string().optional().describe("App subtitle (max 30 chars)"),
+    description: z.string().optional().describe("App description"),
+    keywords: z.string().optional().describe("Comma-separated keywords (max 100 chars total)"),
+    whats_new: z.string().optional().describe("What's New / release notes"),
+    target_languages: z.array(z.string()).describe('ISO 639-1 codes, e.g. ["es", "ja", "de"]'),
+    context: z.string().optional().describe("App context for better translation, e.g. 'meditation app for beginners'"),
+}, async ({ name, subtitle, description, keywords, whats_new, target_languages, context }) => {
+    const token = getToken();
+    const fields = [
+        { label: "name", value: name },
+        { label: "subtitle", value: subtitle },
+        { label: "description", value: description },
+        { label: "keywords", value: keywords },
+        { label: "whats_new", value: whats_new },
+    ].filter((f) => f.value);
+    if (fields.length === 0) {
+        return errorResult("No metadata fields provided. Pass at least one of: name, subtitle, description, keywords, whats_new.");
+    }
+    const results = [];
+    const errors = [];
+    for (const lang of target_languages) {
+        const langName = LANGUAGE_NAMES[lang] || lang;
+        try {
+            const texts = fields.map((f) => f.value);
+            const translated = await translateBatch(texts, lang, {
+                targetLanguageName: langName,
+                context: context || "App Store metadata — keep translations concise and within character limits",
+                preserveFormatting: true,
+                token,
+            });
+            results.push(`\n## ${langName} (${lang})`);
+            fields.forEach((f, i) => {
+                results.push(`**${f.label}:** ${translated[i]}`);
+            });
+        }
+        catch (err) {
+            errors.push(`${langName} (${lang}): ${err.message}`);
+        }
+    }
+    let output = `# App Store Metadata Translations\n${results.join("\n")}`;
+    if (errors.length > 0) {
+        output += `\n\n## Errors\n${errors.join("\n")}`;
+    }
+    return { content: [{ type: "text", text: output }] };
+});
+// ---- Tool: appstore_fetch_metadata ----
+server.tool("appstore_fetch_metadata", "Fetch current App Store Connect metadata for an app. Requires ASC API credentials. Returns version_id needed for appstore_push_metadata.", {
+    issuer_id: z.string().describe("App Store Connect API issuer ID"),
+    key_id: z.string().describe("App Store Connect API key ID"),
+    private_key: z.string().describe("ES256 private key (PEM format)"),
+    app_id: z.string().describe("App Store Connect app ID"),
+}, async ({ issuer_id, key_id, private_key, app_id }) => {
+    const token = getToken();
+    const headers = {
+        "Content-Type": "application/json",
+        "apikey": SUPABASE_ANON_KEY,
+        "Authorization": `Bearer ${token || SUPABASE_ANON_KEY}`,
+    };
+    let data;
+    try {
+        const res = await fetch(ASC_FN, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                action: "fetch-metadata",
+                issuerId: issuer_id,
+                keyId: key_id,
+                privateKey: private_key,
+                appId: app_id,
+            }),
+        });
+        data = await res.json();
+    }
+    catch (err) {
+        return errorResult(`Failed to connect to App Store Connect API: ${err.message}`);
+    }
+    if (!data.success) {
+        return errorResult(`App Store Connect error: ${data.error || data.message || "Unknown error"}`);
+    }
+    if (!data.versionId) {
+        return errorResult(`App Store Connect returned success but no version ID. Make sure the app has an editable version.`);
+    }
+    const locales = (data.locales || []);
+    const lines = [
+        `# App Store Metadata (v${data.versionString || "unknown"})`,
+        `**Version ID:** ${data.versionId}`,
+        `**Locales:** ${locales.length}`,
+        "",
+    ];
+    for (const loc of locales) {
+        lines.push(`## ${loc.locale}`);
+        if (loc.name)
+            lines.push(`**Name:** ${loc.name}`);
+        if (loc.subtitle)
+            lines.push(`**Subtitle:** ${loc.subtitle}`);
+        if (loc.description)
+            lines.push(`**Description:** ${loc.description}`);
+        if (loc.keywords)
+            lines.push(`**Keywords:** ${loc.keywords}`);
+        if (loc.whatsNew)
+            lines.push(`**What's New:** ${loc.whatsNew}`);
+        lines.push("");
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+});
+// ---- Tool: appstore_push_metadata ----
+server.tool("appstore_push_metadata", "Push translated metadata to App Store Connect. Requires version_id from appstore_fetch_metadata. Updates name, subtitle, description, keywords, and/or what's new for specified locales.", {
+    issuer_id: z.string().describe("App Store Connect API issuer ID"),
+    key_id: z.string().describe("App Store Connect API key ID"),
+    private_key: z.string().describe("ES256 private key (PEM format)"),
+    app_id: z.string().describe("App Store Connect app ID"),
+    version_id: z.string().describe("Version ID from appstore_fetch_metadata"),
+    locales: z
+        .array(z.object({
+        locale: z.string().describe('Locale code, e.g. "en-US", "ja", "es-MX"'),
+        name: z.string().optional(),
+        subtitle: z.string().optional(),
+        description: z.string().optional(),
+        keywords: z.string().optional(),
+        whats_new: z.string().optional(),
+    }))
+        .describe("Array of locale metadata to push"),
+}, async ({ issuer_id, key_id, private_key, app_id, version_id, locales }) => {
+    const token = getToken();
+    const headers = {
+        "Content-Type": "application/json",
+        "apikey": SUPABASE_ANON_KEY,
+        "Authorization": `Bearer ${token || SUPABASE_ANON_KEY}`,
+    };
+    let data;
+    try {
+        const res = await fetch(ASC_FN, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                action: "push-metadata",
+                issuerId: issuer_id,
+                keyId: key_id,
+                privateKey: private_key,
+                appId: app_id,
+                versionId: version_id,
+                locales: locales.map((l) => ({
+                    locale: l.locale,
+                    name: l.name,
+                    subtitle: l.subtitle,
+                    description: l.description,
+                    keywords: l.keywords,
+                    whatsNew: l.whats_new,
+                })),
+            }),
+        });
+        data = await res.json();
+    }
+    catch (err) {
+        return errorResult(`Failed to connect to App Store Connect API: ${err.message}`);
+    }
+    if (!data.success) {
+        return errorResult(`App Store Connect error: ${data.error || data.message || "Unknown error"}`);
+    }
+    return {
+        content: [{
+                type: "text",
+                text: `Successfully updated ${data.updatedLocales || data.updated || locales.length} locale(s).${data.failures?.length ? `\nFailures: ${data.failures.join(", ")}` : ""}`,
+            }],
+    };
+});
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    console.error("LocaFlow MCP server error:", err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "locaflow-mcp-server",
+  "version": "0.1.0",
+  "description": "LocaFlow MCP server — translate iOS, Android & web localization files from Claude Code",
+  "type": "module",
+  "bin": {
+    "locaflow-mcp": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc && chmod +x dist/index.js",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "localization",
+    "translation",
+    "ios",
+    "android",
+    "claude-code",
+    "mcp-server",
+    "i18n",
+    "l10n",
+    "app-store-connect"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nicktarasov/locaflow"
+  },
+  "homepage": "https://locaflow.dev",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.11.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}