@atezer/figma-mcp-bridge 1.2.1 → 1.2.2

package/CHANGELOG.md

@@ -14,40 +14,20 @@ Bu changelog'a ekleme oncesi surumlerin tam ayrintilari icin `git log` kullanila
 
 ## [Unreleased]
 
-### Bridge (port yonetimi)
+(Yaklasan degisiklikler buraya.)
 
-- **Sabit port stratejisi:** Otomatik port taramasi (5454-5470 sirali deneme) kaldirildi. Bridge artik yapilandirilan porta dogrudan baglanir; port mesgulse HTTP health-check ile canli F-MCP / olu surec / farkli servis ayirt edilir; olu port icin kisa gecikmeli tek retry.
-- **Graceful shutdown:** `local-plugin-only.ts`'e SIGINT/SIGTERM handler eklendi -- IDE veya Claude kapandiginda `bridge.stop()` cagrilarak port aninda serbest birakilir (olu port sorununun ana duzeltmesi).
-- **probePort edge case:** `FIGMA_BRIDGE_HOST=0.0.0.0` durumunda port probe'u `127.0.0.1` uzerinden yapilir.
+## [1.2.2] - 2026-04-01
 
-### Dokumantasyon
-
-- [docs/MULTI_INSTANCE.md](docs/MULTI_INSTANCE.md): "Tek MCP = tum pencereler ayni oturum" bolumu, **"Paralel gorevler (Claude + Cursor + ikinci hat)"** bolumu (mimari, port tablosu, plugin Advanced uyarisi, Cursor paylasimli MCP notu, audit log cakisma notu).
-- [docs/CLAUDE_DESKTOP_CONFIG.md](docs/CLAUDE_DESKTOP_CONFIG.md): coklu `mcpServers` ornegi (5455 + 5470 farkli sunucu adlariyla).
-- [KURULUM.md](KURULUM.md): Claude config "sik gorulen hatalar" ozeti.
-- [README.md](README.md): Port catismasi uyarisi guncellemesi.
-
-### Araclar
-
-- `npm run check-ports` -- [`scripts/check-ports.sh`](scripts/check-ports.sh): 5454-5470 arasinda LISTEN durumundaki surecleri listeler (paralel gorev dogrulamasi ve sorun giderme icin).
-
-### Cursor skills (F-MCP)
-
-- Yeni skill'ler: `audit-figma-design-system`, `fix-figma-design-system-finding`, `apply-figma-design-system` (tuval ici design system audit/fix/apply; F-MCP Bridge arac eslemesi).
-- Mevcut F-MCP skill'lerine karsilikli **F-MCP skill koordinasyonu** bolumleri eklendi.
-- Tuval skill'lerinde `figma_get_metadata` kaldirildi; Bridge ile uyum icin `figma_get_file_data` / `figma_get_component` / `figma_get_design_context` eslemesi; **design-drift-detector** koordinasyonunda tipik sira (implement - drift) netlestirildi; **audit** icinde zincir performans notlari.
-- [.cursor/skills/f-mcp/SKILL_INDEX.md](.cursor/skills/f-mcp/SKILL_INDEX.md): tum skill'lerin dizini, workspace koku (FCM) notu, ozet akis.
-- `npm run validate:fmcp-skills` -- [`scripts/validate-fmcp-skills-tools.mjs`](scripts/validate-fmcp-skills-tools.mjs): skill `.md` icindeki `figma_*` adlarini `src/local.ts`, `src/local-plugin-only.ts`, `src/core/figma-tools.ts` icindeki `registerTool` birlesimne gore dogrular.
-- GitHub Actions: [`.github/workflows/ci.yml`](.github/workflows/ci.yml) -- `master` / `main` icin PR ve push'ta `npm run validate:fmcp-skills` zorunlu.
+GitHub Release: [v1.2.2](https://github.com/atezer/FMCP/releases/tag/v1.2.2); govde: [docs/releases/v1.2.2-body.md](docs/releases/v1.2.2-body.md).
 
 ### Plugin (F-MCP Bridge)
 
-- Gelismis panel: **Otomatik tara** dugmesi -- port alaniyla tek porta kilitlenmeyi kaldirip 5454-5470 taramasini yeniden baslatir.
-- Advanced panel kapatildiginda ayni kilit kalkar (ilk yuklemede cift baglanti tetiklenmez).
+- **Multi-client `fileKey`:** UI WebSocket `onopen` bazen plugin ana iş parçacığından gelen `FILE_IDENTITY` mesajından önce çalışıyordu; ilk `ready` `fileKey`/`fileName` olmadan gidince köprü (`PluginBridgeServer`) o client’ı `null` anahtarla listeliyordu. `pushBridgeFileIdentity()` eklendi: kimlik geldikten sonra açık soket varsa `ready` yeniden gönderiliyor; `figma_list_connected_files` ve `fileKey` ile yönlendirme tüm pencerelerde (FigJam + birden fazla Figma tarayıcı sekmesi) tutarlı çalışır.
 
-### Surec (bakimcilar)
+### Dokumantasyon
 
-- Sonraki surum: `CHANGELOG.md` guncelle - `docs/releases/vX.Y.Z-body.md` olustur - [RELEASE_NOTES_TEMPLATE.md](docs/RELEASE_NOTES_TEMPLATE.md) icindeki `gh release create` / `gh release edit` ile GitHub Release ac veya guncelle.
+- [README.md](README.md): Multi-client bölümünde kimlik zamanlaması notu (1.2.2+).
+- [FUTURE.md](FUTURE.md): Sürüm satırı ve tamamlanan madde özeti.
 
 ## [1.2.1] - 2026-04-01
 

package/README.md

@@ -90,7 +90,7 @@ Varsayılan NPM `main` ve `figma-mcp-bridge` komutu **tam mod**dur; plugin ile y
 
 | Ne | Nerede |
 | --- | --- |
-| **Sürüm numarası** | [`package.json`](package.json) içindeki `version` (ör. **1.2.1**) |
+| **Sürüm numarası** | [`package.json`](package.json) içindeki `version` (ör. **1.2.2**) |
 | **Değişiklik özeti** | [CHANGELOG.md](CHANGELOG.md) |
 | **Yayın bildirimi** | GitHub’da [Releases](https://github.com/atezer/FMCP/releases) — *Watch* → *Custom* → *Releases* ile e-posta bildirimi |
 | **npm paketi** | [@atezer/figma-mcp-bridge](https://www.npmjs.com/package/@atezer/figma-mcp-bridge) — sürüm geçmişi npm sayfasında |
@@ -110,7 +110,7 @@ Plugin'in **"ready (:5454)"** olması için **önce** MCP bridge sunucusu çalı
 
 ### En basit kurulum (NPX — repo indirmeden)
 
-Repo klonlamadan, sadece Node.js ve tek bir config ile kurulum. **NPX güncelleme:** `@latest` bir sonraki çalıştırmada genelde yeni sürümü indirir; `npx` önbelleği eski paketi tutuyorsa `npx clear-npx-cache` (veya belirli sürüm: `@atezer/figma-mcp-bridge@1.2.0`) kullanın. Ayrıntı: [Sürüm ve güncellemeler](#sürüm-ve-güncellemeler).
+Repo klonlamadan, sadece Node.js ve tek bir config ile kurulum. **NPX güncelleme:** `@latest` bir sonraki çalıştırmada genelde yeni sürümü indirir; `npx` önbelleği eski paketi tutuyorsa `npx clear-npx-cache` (veya belirli sürüm: `@atezer/figma-mcp-bridge@1.2.2`) kullanın. Ayrıntı: [Sürüm ve güncellemeler](#sürüm-ve-güncellemeler).
 
 
 | Adım | Yapılacak                                                                                                    |
@@ -281,6 +281,8 @@ Hangi **linki** verirseniz, istek o linkteki dosyaya yönlendirilir; diğer penc
 
 **Manuel fileKey:** Her plugin bağlantısı kendini `fileKey` ile tanıtır. `figma_list_connected_files` ile bağlı dosyaları listeleyip, diğer tool'larda `fileKey` parametresi ile hedef dosyayı belirtebilirsiniz. `fileKey` ve `figmaUrl` belirtilmezse en son bağlanan dosyaya gider (geriye uyumlu).
 
+**Kimlik zamanlaması (1.2.2+):** WebSocket bazen ana iş parçacığından gelen dosya kimliğinden önce açılabiliyordu; köprüde bir bağlantı `fileKey: null` görünebiliyordu. Plugin artık `FILE_IDENTITY` geldikten sonra `ready` mesajını yeniden göndererek sunucu kaydını güncelliyor. Çoklu sekme kullanıyorsanız bu sürümdeki `f-mcp-plugin` kaynağını yeniden import edin veya npm paketindeki `f-mcp-plugin` ile hizalayın ([CHANGELOG.md](CHANGELOG.md) **\[1.2.2\]**).
+
 **Kullanım:**
 
 1. Birden fazla Figma/FigJam dosyasında (Desktop veya tarayıcı) plugin'i açın → her biri **"ready (:5454)"** gösterir.

package/dist/cloudflare/cloud-cors.js

@@ -0,0 +1,40 @@
+/**
+ * CORS allowlist for Cloud Mode + remote MCP (claude.ai, v0, Lovable, etc.).
+ */
+const DEFAULT_ALLOWED_ORIGINS = [
+    "https://claude.ai",
+    "https://www.claude.ai",
+    "https://v0.dev",
+    "https://www.v0.dev",
+    "https://lovable.dev",
+    "https://www.lovable.dev",
+];
+export function getAllowedCorsOrigin(request, extra) {
+    const origin = request.headers.get("Origin");
+    if (!origin)
+        return null;
+    const set = new Set([...DEFAULT_ALLOWED_ORIGINS, ...(extra ?? [])]);
+    return set.has(origin) ? origin : null;
+}
+export function corsHeaders(request, extraOrigins) {
+    const o = getAllowedCorsOrigin(request, extraOrigins);
+    const base = {
+        "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type, Accept, Authorization, mcp-session-id, Mcp-Protocol-Version, mcp-protocol-version",
+        "Access-Control-Expose-Headers": "mcp-session-id",
+        "Access-Control-Max-Age": "86400",
+    };
+    if (o)
+        base["Access-Control-Allow-Origin"] = o;
+    else
+        base["Access-Control-Allow-Origin"] = "*";
+    return base;
+}
+export function withCors(request, response, extraOrigins) {
+    const h = new Headers(response.headers);
+    const ch = corsHeaders(request, extraOrigins);
+    for (const [k, v] of Object.entries(ch)) {
+        h.set(k, v);
+    }
+    return new Response(response.body, { status: response.status, headers: h });
+}

package/dist/cloudflare/cloud-mode-kv.js

@@ -0,0 +1,86 @@
+/**
+ * Cloud Mode pairing / bind / rate-limit helpers (KV: reuses OAUTH_STATE binding).
+ * Key prefixes are reserved to avoid collisions with OAuth state tokens (64+ hex).
+ */
+export const FMCP_PAIR_PREFIX = "fmcp_pair:";
+export const FMCP_BIND_PREFIX = "fmcp_bind:";
+export const FMCP_RL_PREFIX = "fmcp_rl:";
+export const PAIRING_TTL_SEC = 300;
+export const BIND_TTL_SEC = 86400;
+export const PAIRING_CODE_LENGTH = 6;
+const CODE_CHARS = "23456789ABCDEFGHJKMNPQRSTVWXYZ";
+export function generatePairingCode() {
+    let out = "";
+    const arr = new Uint8Array(PAIRING_CODE_LENGTH);
+    crypto.getRandomValues(arr);
+    for (let i = 0; i < PAIRING_CODE_LENGTH; i++) {
+        out += CODE_CHARS[arr[i] % CODE_CHARS.length];
+    }
+    return out;
+}
+export function generatePairingSecret() {
+    const a = new Uint8Array(16);
+    crypto.getRandomValues(a);
+    return Array.from(a, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+export async function putPairing(kv, code, record) {
+    await kv.put(`${FMCP_PAIR_PREFIX}${code}`, JSON.stringify(record), {
+        expirationTtl: PAIRING_TTL_SEC,
+    });
+}
+export async function getPairing(kv, code) {
+    const raw = await kv.get(`${FMCP_PAIR_PREFIX}${code}`, "text");
+    if (!raw)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function deletePairing(kv, code) {
+    await kv.delete(`${FMCP_PAIR_PREFIX}${code}`);
+}
+export async function putBind(kv, mcpSessionId, record) {
+    await kv.put(`${FMCP_BIND_PREFIX}${mcpSessionId}`, JSON.stringify(record), {
+        expirationTtl: BIND_TTL_SEC,
+    });
+}
+export async function getBind(kv, mcpSessionId) {
+    const raw = await kv.get(`${FMCP_BIND_PREFIX}${mcpSessionId}`, "text");
+    if (!raw)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function deleteBind(kv, mcpSessionId) {
+    await kv.delete(`${FMCP_BIND_PREFIX}${mcpSessionId}`);
+}
+export async function rateLimitAllow(kv, key, limit, windowSec) {
+    const now = Date.now();
+    const raw = await kv.get(key, "text");
+    let stamps = [];
+    if (raw) {
+        try {
+            stamps = JSON.parse(raw).t ?? [];
+        }
+        catch {
+            stamps = [];
+        }
+    }
+    const windowMs = windowSec * 1000;
+    stamps = stamps.filter((ts) => now - ts < windowMs);
+    if (stamps.length >= limit)
+        return false;
+    stamps.push(now);
+    await kv.put(key, JSON.stringify({ t: stamps }), { expirationTtl: Math.max(windowSec * 2, 120) });
+    return true;
+}
+export function clientIp(request) {
+    return request.headers.get("CF-Connecting-IP") || request.headers.get("X-Forwarded-For")?.split(",")[0]?.trim() || "unknown";
+}

package/dist/cloudflare/cloud-mode-routes.js

@@ -0,0 +1,97 @@
+/**
+ * HTTP + WebSocket routes for FMCP Cloud Mode (pairing, plugin bridge).
+ */
+import { corsHeaders, getAllowedCorsOrigin, withCors } from "./cloud-cors.js";
+import { clientIp, FMCP_RL_PREFIX, generatePairingCode, generatePairingSecret, PAIRING_TTL_SEC, putPairing, rateLimitAllow, getPairing, } from "./cloud-mode-kv.js";
+const PAIRING_HTTP_LIMIT = 20;
+const PAIRING_HTTP_WINDOW_SEC = 60;
+function json(data, status = 200, request) {
+    const headers = { "Content-Type": "application/json" };
+    if (request)
+        Object.assign(headers, corsHeaders(request));
+    return new Response(JSON.stringify(data), { status, headers });
+}
+function baseUrl(request) {
+    const u = new URL(request.url);
+    return `${u.protocol}//${u.host}`;
+}
+export async function handleCloudModeRoutes(request, env) {
+    const url = new URL(request.url);
+    if (url.pathname === "/fmcp-cloud/plugin") {
+        if (request.method === "OPTIONS") {
+            return new Response(null, { headers: corsHeaders(request) });
+        }
+        if (request.headers.get("Upgrade") !== "websocket") {
+            return json({ error: "expected_websocket_upgrade" }, 426, request);
+        }
+        const code = url.searchParams.get("code")?.trim().toUpperCase();
+        const secret = url.searchParams.get("secret");
+        if (!code || !secret) {
+            return json({ error: "missing_code_or_secret" }, 400, request);
+        }
+        const pair = await getPairing(env.OAUTH_STATE, code);
+        if (!pair || pair.secret !== secret) {
+            return json({ error: "invalid_or_expired_pairing" }, 401, request);
+        }
+        const id = env.FMCP_RELAY.idFromName(`pair:${code}`);
+        const res = await env.FMCP_RELAY.get(id).fetch(request);
+        return withCors(request, res);
+    }
+    if (url.pathname === "/fmcp-cloud/pairing") {
+        if (request.method === "OPTIONS") {
+            return new Response(null, { headers: corsHeaders(request) });
+        }
+        if (request.method !== "POST") {
+            return json({ error: "method_not_allowed" }, 405, request);
+        }
+        const token = env.FMCP_PAIRING_TOKEN;
+        if (token) {
+            const auth = request.headers.get("Authorization");
+            const expected = `Bearer ${token}`;
+            if (auth !== expected) {
+                return json({ error: "unauthorized" }, 401, request);
+            }
+        }
+        const ip = clientIp(request);
+        const rlKey = `${FMCP_RL_PREFIX}pair:${ip}`;
+        const ok = await rateLimitAllow(env.OAUTH_STATE, rlKey, PAIRING_HTTP_LIMIT, PAIRING_HTTP_WINDOW_SEC);
+        if (!ok) {
+            return json({ error: "rate_limited" }, 429, request);
+        }
+        const code = generatePairingCode();
+        const secret = generatePairingSecret();
+        const record = { secret, createdAt: Date.now() };
+        await putPairing(env.OAUTH_STATE, code, record);
+        const origin = baseUrl(request);
+        const wsProto = url.protocol === "https:" ? "wss:" : "ws:";
+        const wsHost = url.host;
+        const pluginWsUrl = `${wsProto}//${wsHost}/fmcp-cloud/plugin?code=${encodeURIComponent(code)}&secret=${encodeURIComponent(secret)}`;
+        return json({
+            ok: true,
+            code,
+            secret,
+            expiresInSeconds: PAIRING_TTL_SEC,
+            pluginWebSocketUrl: pluginWsUrl,
+            hint: "Paste code and secret into F-MCP plugin Cloud Mode, or share code + secret with your AI to call fmcp_cloud_bind.",
+        }, 200, request);
+    }
+    if (url.pathname === "/fmcp-cloud/health") {
+        return json({ ok: true, cloudMode: true }, 200, request);
+    }
+    return null;
+}
+/** Merge restrictive CORS onto MCP / SSE responses when Origin matches allowlist. */
+export function maybeTightenMcpCors(request, response) {
+    const origin = request.headers.get("Origin");
+    if (!origin)
+        return response;
+    const allowed = getAllowedCorsOrigin(request);
+    if (!allowed)
+        return response;
+    const h = new Headers(response.headers);
+    h.set("Access-Control-Allow-Origin", allowed);
+    if (!h.has("Access-Control-Expose-Headers")) {
+        h.set("Access-Control-Expose-Headers", "mcp-session-id");
+    }
+    return new Response(response.body, { status: response.status, headers: h });
+}

package/dist/cloudflare/cloud-relay-session.js

@@ -0,0 +1,141 @@
+/**
+ * FMCP Cloud Mode — per-pairing-code Durable Object.
+ * Holds the Figma plugin WebSocket and forwards PluginBridge RPC to the plugin.
+ */
+const RPC_TIMEOUT_MS = 120_000;
+export class FmcpRelaySession {
+    constructor(ctx, env) {
+        this.ctx = ctx;
+        this.pending = new Map();
+        this.env = env;
+    }
+    relayNameFromId() {
+        return this.ctx.id.toString();
+    }
+    async fetch(request) {
+        const url = new URL(request.url);
+        if (request.method === "POST" && url.pathname.endsWith("/disconnect")) {
+            for (const s of this.ctx.getWebSockets()) {
+                try {
+                    s.close(1000, "disconnect");
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            return Response.json({ ok: true, closed: true });
+        }
+        if (request.method === "POST" && url.pathname.endsWith("/rpc")) {
+            return this.handleRpc(request);
+        }
+        if (request.method === "GET" && url.pathname.endsWith("/status")) {
+            const sockets = this.ctx.getWebSockets();
+            const connected = sockets.length > 0;
+            return Response.json({
+                ok: true,
+                pluginConnected: connected,
+                relayId: this.relayNameFromId(),
+            });
+        }
+        if (request.headers.get("Upgrade") !== "websocket") {
+            return new Response("Not found", { status: 404 });
+        }
+        const pair = new WebSocketPair();
+        const [client, server] = Object.values(pair);
+        this.ctx.acceptWebSocket(server);
+        return new Response(null, { status: 101, webSocket: client });
+    }
+    async handleRpc(request) {
+        let body;
+        try {
+            body = (await request.json());
+        }
+        catch {
+            return Response.json({ ok: false, error: "invalid_json" }, { status: 400 });
+        }
+        const method = body.method;
+        if (!method || typeof method !== "string") {
+            return Response.json({ ok: false, error: "missing_method" }, { status: 400 });
+        }
+        const sockets = this.ctx.getWebSockets();
+        if (!sockets || sockets.length === 0) {
+            return Response.json({ ok: false, error: "plugin_not_connected" }, { status: 503 });
+        }
+        const ws = sockets[0];
+        const id = `req_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+        const payload = JSON.stringify({
+            id,
+            method,
+            params: body.params ?? {},
+        });
+        try {
+            const result = await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    this.pending.delete(id);
+                    reject(new Error(`Plugin bridge request '${method}' timed out after ${RPC_TIMEOUT_MS}ms`));
+                }, RPC_TIMEOUT_MS);
+                this.pending.set(id, { resolve, reject, timeout });
+                ws.send(payload);
+            });
+            return Response.json({ ok: true, result });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return Response.json({ ok: false, error: msg }, { status: 500 });
+        }
+    }
+    async webSocketMessage(ws, message) {
+        const text = typeof message === "string" ? message : new TextDecoder().decode(message);
+        let msg;
+        try {
+            msg = JSON.parse(text);
+        }
+        catch {
+            return;
+        }
+        const t = msg.type;
+        if (t === "pong" || t === "keepalive")
+            return;
+        if (t === "ready") {
+            try {
+                ws.send(JSON.stringify({
+                    type: "welcome",
+                    bridgeVersion: "cloud-1.0.0",
+                    port: 0,
+                    clientId: `cloud_${Date.now()}`,
+                    multiClient: false,
+                }));
+            }
+            catch {
+                /* ignore */
+            }
+            return;
+        }
+        const mid = msg.id;
+        if (mid && this.pending.has(mid)) {
+            const p = this.pending.get(mid);
+            this.pending.delete(mid);
+            clearTimeout(p.timeout);
+            if (msg.error) {
+                p.reject(new Error(String(msg.error)));
+            }
+            else {
+                p.resolve(msg.result);
+            }
+        }
+    }
+    async webSocketClose(_ws, _code, _reason, _wasClean) {
+        for (const [rid, p] of this.pending) {
+            clearTimeout(p.timeout);
+            p.reject(new Error("Plugin disconnected"));
+            this.pending.delete(rid);
+        }
+    }
+    async webSocketError(_ws, _error) {
+        for (const [rid, p] of this.pending) {
+            clearTimeout(p.timeout);
+            p.reject(new Error("Plugin WebSocket error"));
+            this.pending.delete(rid);
+        }
+    }
+}