@reframejs/unframer 4.2.0-reframe.0

package/dist/plugin-mcp-dist/lib/mcp-tools.d.ts

@@ -0,0 +1,5 @@
+export declare function implementMcpTools({ server, websocketId }: {
+    server: any;
+    websocketId: any;
+}): Promise<void>;
+//# sourceMappingURL=mcp-tools.d.ts.map

package/dist/plugin-mcp-dist/lib/mcp-tools.js

@@ -0,0 +1,5 @@
+export async function implementMcpTools({ server, websocketId, }) {
+    // Use your handler
+}
+//# sourceMappingURL=mcp-tools.js.map
+//# sourceMappingURL=mcp-tools.js.map

package/dist/plugin-mcp-dist/lib/mcp-websocket.d.ts

@@ -0,0 +1,10 @@
+export declare function createWebsocketHandling({ ws, defaultTimeout }: {
+    defaultTimeout?: number | undefined;
+    ws: any;
+}): {
+    send: ({ idempotenceKey, payload, }: {
+        idempotenceKey: any;
+        payload: any;
+    }) => Promise<unknown>;
+};
+//# sourceMappingURL=mcp-websocket.d.ts.map

package/dist/plugin-mcp-dist/lib/mcp-websocket.js

@@ -0,0 +1,88 @@
+export function createWebsocketHandling({ ws, defaultTimeout = 1000 * 10, }) {
+    const pendingRequests = new Map();
+    const usedIdempotenceIds = new Set();
+    const send = async ({ idempotenceKey, payload, }) => {
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+            throw new Error('WebSocket instance not open, cannot send.');
+        }
+        const id = crypto.randomUUID();
+        const message = {
+            id,
+            payload,
+        };
+        return new Promise((resolve, reject) => {
+            // If idempotenceKey is specified and already used, return resolved promise immediately
+            if (idempotenceKey && usedIdempotenceIds.has(idempotenceKey)) {
+                console.log(`Idempotence ID ${idempotenceKey} already used, skipping docs payload set payload`);
+                return Promise.resolve(undefined);
+            }
+            const timeout = setTimeout(() => {
+                pendingRequests.delete(id);
+                reject(new Error(`Request ${id} timed out after ${defaultTimeout}ms`));
+            }, defaultTimeout);
+            pendingRequests.set(id, { resolve, reject, timeout });
+            ws.send(JSON.stringify(message));
+            if (idempotenceKey) {
+                usedIdempotenceIds.add(idempotenceKey);
+            }
+        });
+    };
+    function onMessage(event) {
+        let msg;
+        try {
+            // Handle both string and Blob data
+            if (typeof event.data === 'string') {
+                msg = JSON.parse(event.data);
+            }
+            else if (event.data instanceof Blob) {
+                // Skip binary data
+                return;
+            }
+        }
+        catch (err) {
+            // ignore parse errors
+            return;
+        }
+        if (!msg)
+            return;
+        const { id, payload, error } = msg;
+        if (!id)
+            return;
+        const pending = pendingRequests.get(id);
+        if (!pending)
+            return;
+        pendingRequests.delete(id);
+        clearTimeout(pending.timeout);
+        if (error) {
+            pending.reject(new Error(error));
+        }
+        else {
+            pending.resolve(payload?.output ?? null);
+        }
+    }
+    // Attach ws 'message' event handler
+    ws.addEventListener('message', onMessage);
+    const cleanup = async () => {
+        ws.removeEventListener('message', onMessage);
+        send({
+            payload: { type: 'close' },
+        });
+        // Clean up any pending requests
+        for (const [id, pending] of Array.from(pendingRequests)) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error('RPC client cleanup'));
+        }
+        pendingRequests.clear();
+        usedIdempotenceIds.clear();
+        ws.close();
+    };
+    // Register cleanup on ws close
+    ws.addEventListener('close', () => {
+        cleanup();
+    });
+    return {
+        send,
+    };
+}
+//# sourceMappingURL=mcp-websocket.js.map
+//# sourceMappingURL=mcp-websocket.js.map

package/dist/plugin-mcp-dist/lib/plugin-websocket.d.ts

@@ -0,0 +1,5 @@
+export declare function websocketClientHandling({ handle, websocketId }: {
+    handle: any;
+    websocketId: any;
+}): Promise<undefined>;
+//# sourceMappingURL=plugin-websocket.d.ts.map

package/dist/plugin-mcp-dist/lib/plugin-websocket.js

@@ -0,0 +1,170 @@
+import { useStore } from './store.js';
+// Global variable to track the active cleanup function
+let cleanupFunction = undefined;
+// Global WebSocket instance to check connection state
+let ws = undefined;
+// Track reconnect timeout to cancel it if needed
+let reconnectTimeout = undefined;
+// Function for handling websocket connection based on session cookie
+export async function websocketClientHandling({ handle, websocketId, }) {
+    if (typeof window === 'undefined')
+        return;
+    // Check if we're already connected or connecting using WebSocket state
+    if (ws?.readyState === WebSocket.CONNECTING ||
+        ws?.readyState === WebSocket.OPEN) {
+        console.log('Already connected or connecting (WebSocket state:', ws?.readyState, '), returning existing cleanup function');
+        return cleanupFunction;
+    }
+    const host = new URL(process.env.PUBLIC_URL).host;
+    console.log(`using ${host} for websocket url`);
+    const websocketUrl = `wss://${host}/_tunnel/upstream?id=${websocketId}`;
+    let pingInterval = null;
+    let reconnectInterval = 3000;
+    let shouldReconnect = true;
+    function connect() {
+        if (ws?.readyState === WebSocket.CONNECTING ||
+            ws?.readyState === WebSocket.OPEN) {
+            console.log('Already connected');
+            return;
+        }
+        // Clear any pending reconnect when starting a new connection
+        if (reconnectTimeout) {
+            clearTimeout(reconnectTimeout);
+            reconnectTimeout = undefined;
+        }
+        console.log('connecting over mcp websocket', websocketUrl);
+        ws = new WebSocket(websocketUrl);
+        ws.onopen = () => {
+            console.log('websocket client connected', websocketId);
+            reconnectInterval = 3000;
+            if (ws?.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({ type: 'ready' }));
+            }
+            useStore.setState({ isSocketOpen: true, error: undefined });
+            // Setup ping interval
+            if (pingInterval)
+                clearInterval(pingInterval);
+            pingInterval = setInterval(() => {
+                if (ws?.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({ type: 'ping' }));
+                }
+            }, 5 * 1000);
+        };
+        ws.onmessage = async (event) => {
+            let data;
+            try {
+                data = JSON.parse(event.data);
+            }
+            catch {
+                console.error(`websocket sent invalid json`, event.data);
+                return;
+            }
+            const { id, payload } = data || {};
+            if (!payload?.type) {
+                // console.error(`websocket sent invalid data`, event.data)
+                return;
+            }
+            if (payload.type === 'ready') {
+                console.log('received ready');
+                useStore.setState({ isConnected: true, error: undefined });
+                return;
+            }
+            if (payload.type === 'close') {
+                useStore.setState({ isConnected: false });
+                return;
+            }
+            console.log(`websocket message received`, payload);
+            try {
+                const output = await handle(payload);
+                console.log(`websocket message handled`, payload.type, output);
+                if (ws?.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({
+                        id,
+                        payload: {
+                            input: payload.input,
+                            type: payload.type,
+                            output,
+                        },
+                    }));
+                }
+            }
+            catch (e) {
+                console.error(`websocket error`, e);
+                if (ws?.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({
+                        id,
+                        error: e instanceof Error ? e.message : String(e),
+                    }));
+                }
+            }
+        };
+        ws.onerror = (error) => {
+            console.error('websocket error', error);
+        };
+        ws.onclose = (event) => {
+            console.log(`websocket client disconnected (${event.code}), reconnecting in ${reconnectInterval}ms`);
+            useStore.setState({
+                isConnected: false,
+                isSocketOpen: false,
+                error: undefined,
+            });
+            if (pingInterval) {
+                clearInterval(pingInterval);
+                pingInterval = null;
+            }
+            // Clear connection state
+            cleanupFunction = undefined;
+            ws = undefined;
+            if (event.code === 4009) {
+                const errorMessage = 'Another MCP plugin has connected. Please keep only one open. Then try reopening this plugin';
+                console.error(errorMessage);
+                useStore.setState({
+                    isConnected: false,
+                    isSocketOpen: false,
+                    error: errorMessage,
+                });
+                // Prevent further reconnect attempts when this error occurs
+                shouldReconnect = false;
+            }
+            if (reconnectTimeout) {
+                clearTimeout(reconnectTimeout);
+            }
+            if (shouldReconnect) {
+                reconnectTimeout = setTimeout(() => {
+                    reconnectTimeout = undefined;
+                    // Only reconnect if WebSocket is not open or connecting
+                    if (!ws ||
+                        (ws.readyState !== WebSocket.OPEN &&
+                            ws.readyState !== WebSocket.CONNECTING)) {
+                        connect();
+                    }
+                }, reconnectInterval);
+                // exponential backoff (max 30s)
+                reconnectInterval = Math.min(30000, reconnectInterval * 1.1);
+            }
+        };
+    }
+    // Start the connection
+    connect();
+    // Create and store the cleanup function
+    cleanupFunction = () => {
+        shouldReconnect = false;
+        if (reconnectTimeout) {
+            clearTimeout(reconnectTimeout);
+            reconnectTimeout = undefined;
+        }
+        if (pingInterval) {
+            clearInterval(pingInterval);
+            pingInterval = null;
+        }
+        if (ws?.readyState !== WebSocket.CLOSED) {
+            ws?.close();
+        }
+        cleanupFunction = undefined;
+        ws = undefined;
+    };
+    // Return the cleanup function
+    return cleanupFunction;
+}
+//# sourceMappingURL=plugin-websocket.js.map
+//# sourceMappingURL=plugin-websocket.js.map

package/dist/plugin-mcp-dist/lib/react-export.d.ts

@@ -0,0 +1,51 @@
+export declare function getInstancesWithOrderAndDepth({ allInstances, webPageIds, components, projectId }: {
+    allInstances: any;
+    components: any;
+    projectId: any;
+    webPageIds: any;
+}): Promise<any[]>;
+export declare function getComponentsWithBreakpoints({ selectedComponentIds, components, allInstances }: {
+    allInstances: any;
+    components: any;
+    selectedComponentIds: any;
+}): Promise<any[]>;
+export declare function processReactExportData({ selectedComponentIds }: {
+    selectedComponentIds: any;
+}): Promise<{
+    projectId: string;
+    projectName: string;
+    fullFramerProjectId: string;
+    framerUserId: string;
+    websiteUrl: string | undefined;
+    pageBackgroundColor: string;
+    colorStyles: {
+        name: string;
+        id: string;
+        projectId: string;
+        lightColor: string;
+        darkColor: string;
+    }[];
+    components: {
+        name: any;
+        id: any;
+        url: any;
+        projectId: string;
+        componentIdentifier: any;
+        componentType: string;
+    }[];
+    breakpoints: any[];
+    pages: {
+        path: string;
+        webPageId: string;
+        projectId: string;
+    }[];
+    locales: {
+        id: any;
+        name: any;
+        slug: any;
+        code: any;
+        projectId: string;
+    }[];
+    componentInstances: any[] | never[];
+}>;
+//# sourceMappingURL=react-export.d.ts.map