added bridge

website/matrix-bridge.js

@@ -0,0 +1,234 @@
+/**
+ * Matrix Chat Bridge - Iframe communication layer for CSP-restricted hosts
+ * Handles Matrix API calls via postMessage from parent window
+ */
+
+// Allow requests from these origins
+const ALLOWED_ORIGINS = [
+    'https://litruv.neocities.org',
+    'https://lit.ruv.wtf',
+    'http://localhost:3000',
+    'http://localhost:8080',
+    'http://127.0.0.1:3000',
+    'http://127.0.0.1:8080'
+];
+
+/**
+ * Matrix API configuration
+ */
+const MATRIX_CONFIG = {
+    homeserver: 'https://chat.ruv.wtf',
+    publicReadToken: 'syt_bGl0cnV2X3B1YmxpY19yZWFk_eFrYVXSXPbLiqREQnFsU_2Nc6ZE'
+};
+
+/**
+ * Make a Matrix API call
+ * @param {string} endpoint - API endpoint path
+ * @param {object} options - Fetch options
+ * @param {string|null} accessToken - Optional access token
+ * @returns {Promise<any>}
+ */
+async function matrixApiFetch(endpoint, options = {}, accessToken = null) {
+    const url = `${MATRIX_CONFIG.homeserver}${endpoint}`;
+    const headers = {
+        'Content-Type': 'application/json',
+        ...options.headers
+    };
+
+    if (accessToken) {
+        headers['Authorization'] = `Bearer ${accessToken}`;
+    }
+
+    try {
+        const response = await fetch(url, {
+            ...options,
+            headers
+        });
+
+        const data = await response.json();
+
+        if (!response.ok) {
+            return { error: true, ...data };
+        }
+
+        return data;
+    } catch (error) {
+        return {
+            error: true,
+            errcode: 'M_NETWORK_ERROR',
+            error: error.message
+        };
+    }
+}
+
+/**
+ * Handle Matrix API requests from parent window
+ */
+window.addEventListener('message', async (event) => {
+    // Verify origin
+    if (!ALLOWED_ORIGINS.includes(event.origin)) {
+        console.warn('[Matrix Bridge] Rejected message from unauthorized origin:', event.origin);
+        return;
+    }
+
+    const { type, requestId, payload } = event.data;
+
+    if (!type || !requestId) {
+        return;
+    }
+
+    let result;
+
+    try {
+        switch (type) {
+            case 'matrix:api':
+                result = await handleApiRequest(payload);
+                break;
+
+            case 'matrix:auth':
+                result = await handleAuth(payload);
+                break;
+
+            case 'matrix:sendMessage':
+                result = await handleSendMessage(payload);
+                break;
+
+            case 'matrix:fetchPresence':
+                result = await handleFetchPresence(payload);
+                break;
+
+            case 'matrix:fetchLastMessage':
+                result = await handleFetchLastMessage(payload);
+                break;
+
+            case 'matrix:sync':
+                result = await handleSync(payload);
+                break;
+
+            case 'matrix:resolveAlias':
+                result = await handleResolveAlias(payload);
+                break;
+
+            default:
+                result = {
+                    error: true,
+                    errcode: 'M_UNKNOWN_REQUEST',
+                    error: `Unknown request type: ${type}`
+                };
+        }
+    } catch (error) {
+        result = {
+            error: true,
+            errcode: 'M_BRIDGE_ERROR',
+            error: error.message
+        };
+    }
+
+    // Send response back to parent
+    event.source.postMessage({
+        type: `${type}:response`,
+        requestId,
+        payload: result
+    }, event.origin);
+});
+
+/**
+ * Handle generic Matrix API request
+ */
+async function handleApiRequest({ endpoint, method = 'GET', body = null, accessToken = null }) {
+    return await matrixApiFetch(
+        `/_matrix/client/r0${endpoint}`,
+        {
+            method,
+            body: body ? JSON.stringify(body) : undefined
+        },
+        accessToken
+    );
+}
+
+/**
+ * Handle authentication request
+ */
+async function handleAuth({ username, password }) {
+    return await matrixApiFetch('/_matrix/client/r0/login', {
+        method: 'POST',
+        body: JSON.stringify({
+            type: 'm.login.password',
+            identifier: {
+                type: 'm.id.user',
+                user: username
+            },
+            password: password
+        })
+    });
+}
+
+/**
+ * Handle send message request
+ */
+async function handleSendMessage({ roomId, content, accessToken, txnId }) {
+    const msgtype = content.msgtype || 'm.text';
+    const endpoint = `/_matrix/client/r0/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${encodeURIComponent(txnId)}`;
+
+    return await matrixApiFetch(endpoint, {
+        method: 'PUT',
+        body: JSON.stringify(content)
+    }, accessToken);
+}
+
+/**
+ * Handle fetch presence request
+ */
+async function handleFetchPresence({ userId }) {
+    return await matrixApiFetch(
+        `/_matrix/client/r0/presence/${encodeURIComponent(userId)}/status`,
+        { method: 'GET' },
+        MATRIX_CONFIG.publicReadToken
+    );
+}
+
+/**
+ * Handle fetch last message request
+ */
+async function handleFetchLastMessage({ roomId }) {
+    return await matrixApiFetch(
+        `/_matrix/client/r0/rooms/${encodeURIComponent(roomId)}/messages?dir=b&limit=1`,
+        { method: 'GET' },
+        MATRIX_CONFIG.publicReadToken
+    );
+}
+
+/**
+ * Handle sync request
+ */
+async function handleSync({ accessToken, since, timeout = 0 }) {
+    let endpoint = `/_matrix/client/r0/sync?timeout=${timeout}`;
+    if (since) {
+        endpoint += `&since=${encodeURIComponent(since)}`;
+    }
+
+    return await matrixApiFetch(endpoint, {
+        method: 'GET'
+    }, accessToken);
+}
+
+/**
+ * Handle room alias resolution
+ */
+async function handleResolveAlias({ roomAlias }) {
+    return await matrixApiFetch(
+        `/_matrix/client/r0/directory/room/${encodeURIComponent(roomAlias)}`,
+        { method: 'GET' },
+        MATRIX_CONFIG.publicReadToken
+    );
+}
+
+// Notify parent that bridge is ready
+window.addEventListener('load', () => {
+    if (window.parent !== window) {
+        window.parent.postMessage({
+            type: 'matrix:bridge:ready'
+        }, '*');
+    }
+    console.log('[Matrix Bridge] Ready and listening for requests');
+});