Skip to content

A platform for community discussion. Free, open, simple.

16.6 KB
Raw Blame
# frozen_string_literal: true

module DiscourseAi
  module AiBot
    class ArtifactsController < ApplicationController
      requires_plugin PLUGIN_NAME
      before_action :require_site_settings!

      skip_before_action :preload_json, :check_xhr, only: %i[show shared embed forum]
      skip_after_action :set_cross_origin_opener_policy_header, only: %i[show shared embed forum]

      def embed
        raise Discourse::NotFound if !params[:id].to_s.match?(/\A[1-9]\d*\z/)

        artifact = AiArtifact.find(params[:id])
        raise Discourse::NotFound if !artifact.publicly_embeddable?

        version = nil
        if params[:version].present?
          raise Discourse::NotFound if !params[:version].to_s.match?(/\A[1-9]\d*\z/)

          version = artifact.versions.find_by(version_number: params[:version])
          raise Discourse::NotFound if !version
        end

        untrusted_html = build_untrusted_html(version || artifact, artifact.name, standalone: true)
        trusted_html = build_trusted_html(nil, nil, artifact.name, untrusted_html, standalone: true)

        set_security_headers
        response.headers["Referrer-Policy"] = "no-referrer"
        response.headers["Cache-Control"] = "no-store"
        render html: trusted_html.html_safe, layout: false, content_type: "text/html"
      end

      def shared
        share = find_public_share
        untrusted_html = build_untrusted_html(share, share.name, standalone: true)
        trusted_html = build_trusted_html(nil, nil, share.name, untrusted_html, standalone: true)

        set_security_headers
        response.headers["Referrer-Policy"] = "no-referrer"
        response.headers["Cache-Control"] = "no-store"
        render html: trusted_html.html_safe, layout: false, content_type: "text/html"
      end

      def forum
        share = find_public_share
        untrusted_html = build_untrusted_html(share, share.name)
        trusted_html = build_trusted_html(share, nil, share.name, untrusted_html)

        set_native_security_headers
        response.headers["Referrer-Policy"] = "no-referrer"
        response.headers["Cache-Control"] = "no-store"
        render html: trusted_html.html_safe, layout: false, content_type: "text/html"
      end

      def shared_metadata
        render_metadata(find_public_share.name)
      end

      def metadata
        id = params[:id].to_s
        if !id.match?(/\A[1-9]\d{0,18}\z/) || id.to_i > 9_223_372_036_854_775_807
          raise Discourse::NotFound
        end

        artifact = AiArtifact.find_by(id: id)
        raise Discourse::NotFound if !artifact&.available_to?(guardian)

        if params.key?(:version)
          version = params[:version].to_s
          if !version.match?(/\A(?:0|[1-9]\d{0,9})\z/) || version.to_i > 2_147_483_647
            raise Discourse::NotFound
          end
          if version != "0" && !artifact.versions.exists?(version_number: version.to_i)
            raise Discourse::NotFound
          end
        end

        render_metadata(artifact.name)
      end

      def show
        artifact = AiArtifact.find(params[:id])

        raise Discourse::NotFound if !artifact.available_to?(guardian)

        name = artifact.name
        artifact_version = nil

        if params[:version].present?
          artifact_version = artifact.versions.find_by(version_number: params[:version])
          raise Discourse::NotFound if !artifact_version
        end

        untrusted_html = build_untrusted_html(artifact_version || artifact, name)
        trusted_html = build_trusted_html(artifact, artifact_version, name, untrusted_html)

        set_native_security_headers
        render html: trusted_html.html_safe, layout: false, content_type: "text/html"
      end

      private

      def render_metadata(name)
        response.headers["Cache-Control"] = "no-store"
        response.headers["X-Robots-Tag"] = "noindex"
        render json: { name: name }
      end

      def find_public_share
        share = AiArtifactShare.find_by(share_key: params[:share_key])
        raise Discourse::NotFound if !share&.publicly_visible?

        share
      end

      def build_untrusted_html(artifact, name, standalone: false)
        js = prepare_javascript(artifact.js)
        sanitized_css = artifact.css.to_s.gsub(%r{</style}i, '<\/style')

        <<~HTML
          <!DOCTYPE html>
          <html>
            <head>
              <meta charset="UTF-8">
              <title>#{ERB::Util.html_escape(name)}</title>
              <style>
                #{sanitized_css}
              </style>
              #{standalone ? build_standalone_javascript : build_iframe_javascript}
            </head>
            <body>
              #{artifact.html}
              #{js}
            </body>
          </html>
        HTML
      end

      def build_trusted_html(artifact, artifact_version, name, untrusted_html, standalone: false)
        <<~HTML
          <!DOCTYPE html>
          <html>
            <head>
              <meta charset="UTF-8">
              <title>#{ERB::Util.html_escape(name)}</title>
              <meta name="viewport" content="width=device-width, initial-scale=1.0, minimum-scale=1.0, user-scalable=yes, viewport-fit=cover, interactive-widget=resizes-content">
              #{"<meta name=\"csrf-token\" content=\"#{form_authenticity_token}\">" unless standalone}
              <style>
                html, body, iframe {
                  margin: 0;
                  padding: 0;
                  width: 100%;
                  height: 100%;
                  border: 0;
                  overflow: hidden;
                }
                iframe {
                  overflow: auto;
                }
              </style>
            </head>
            <body>
              <iframe sandbox="allow-scripts allow-forms" title="#{ERB::Util.html_escape(name)}" height="100%" width="100%" srcdoc="#{ERB::Util.html_escape(untrusted_html)}" frameborder="0"></iframe>
              #{build_parent_javascript(artifact) unless standalone}
            </body>
          </html>
        HTML
      end

      def prepare_javascript(js)
        return "" if js.blank?

        if !js.match?(%r{\A\s*<script.*</script>}mi)
          mod = ""
          mod = " type=\"module\"" if js.match?(/\A\s*import.*/)
          js = "<script#{mod}>\n#{js}\n</script>"
        end
        js
      end

      def user_data
        {
          username: current_user ? current_user.username : nil,
          user_id: current_user ? current_user.id : nil,
          name: current_user ? current_user.name : nil,
        }
      end

      def build_standalone_javascript
        <<~JAVASCRIPT
          <script>
            window.discourseArtifactData = {};
            window.discourseArtifactReady = Promise.resolve(window.discourseArtifactData);
            window.discourseArtifact = {
              get: function() { return Promise.reject(new Error('Key-value storage is unavailable in public shares')); },
              set: function() { return Promise.reject(new Error('Key-value storage is unavailable in public shares')); },
              delete: function() { return Promise.reject(new Error('Key-value storage is unavailable in public shares')); },
              index: function() { return Promise.reject(new Error('Key-value storage is unavailable in public shares')); }
            };
          </script>
        JAVASCRIPT
      end

      def build_iframe_javascript
        <<~JAVASCRIPT
          <script>
            window._discourse_user_data = #{user_data.to_json};

            window.discourseArtifactReady = new Promise(resolve => {
              window._resolveArtifactData = resolve;
            });

            // Key-value store API
            window.discourseArtifact = {
              get: function(key) {
                return window._postMessageRequest('get', { key: key });
              },
              set: function(key, value, options = {}) {
                return window._postMessageRequest('set', {
                  key: key,
                  value: value,
                  public: options.public || false
                });
              },
              delete: function(key) {
                return window._postMessageRequest('delete', { key: key });
              },
              index: function(filter = {}) {
                return window._postMessageRequest('index', filter);
              }
            };

            window._postMessageRequest = function(action, data) {
              return new Promise((resolve, reject) => {
                const requestId = Math.random().toString(36).substr(2, 9);
                const messageHandler = function(event) {
                  if (event.data && event.data.requestId === requestId) {
                    window.removeEventListener('message', messageHandler);
                    if (event.data.error) {
                      reject(new Error(event.data.error));
                    } else {
                      resolve(event.data.result);
                    }
                  }
                };
                window.addEventListener('message', messageHandler);
                window.parent.postMessage({
                  type: 'discourse-artifact-kv',
                  action: action,
                  data: data,
                  requestId: requestId
                }, '*');
              });
            };

            window.addEventListener('message', function(event) {
              if (event.data && event.data.type === 'discourse-artifact-data') {
                window.discourseArtifactData = event.data.dataset || {};
                Object.assign(window.discourseArtifactData, window._discourse_user_data);
                window._resolveArtifactData(window.discourseArtifactData);
              }
            });
          </script>
        JAVASCRIPT
      end

      def build_parent_javascript(artifact)
        storage_url =
          if artifact.is_a?(AiArtifactShare)
            "/discourse-ai/ai-bot/artifact-share-key-values/#{artifact.share_key}.json"
          else
            "/discourse-ai/ai-bot/artifact-key-values/#{artifact.id}.json"
          end

        <<~JAVASCRIPT
          <script>
            const iframe = document.querySelector('iframe');

            iframe.addEventListener('load', function() {
              try {
                const iframeWindow = this.contentWindow;
                const message = { type: 'discourse-artifact-data', dataset: {} };

                if (window.frameElement && window.frameElement.dataset) {
                  Object.assign(message.dataset, window.frameElement.dataset);
                }
                iframeWindow.postMessage(message, '*');
              } catch (e) {
                console.error('Error passing data to artifact:', e);
              }
            });

            // Handle key-value store requests from iframe
            window.addEventListener('message', async function(event) {
              if (event.data && event.data.type === 'discourse-artifact-kv') {
                if (event.source !== iframe.contentWindow) return;
                const { action, data, requestId } = event.data;
                const baseUrl = #{storage_url.to_json};

                try {
                  const result = await handleKeyValueRequest(action, data, baseUrl);
                  event.source.postMessage({
                    requestId: requestId,
                    result: result
                  }, '*');
                } catch (error) {
                  event.source.postMessage({
                    requestId: requestId,
                    error: error.message
                  }, '*');
                }
              }
            });

            async function handleKeyValueRequest(action, data, baseUrl) {
              const csrfToken = document.querySelector('meta[name="csrf-token"]')?.content || '';

              switch (action) {
                case 'get':
                  return await handleGetRequest(baseUrl, data, csrfToken);
                case 'set':
                  return await handleSetRequest(baseUrl, data, csrfToken);
                case 'index':
                  return await handleIndexRequest(baseUrl, data, csrfToken);
                case 'delete':
                  return await handleDeleteRequest(baseUrl, data, csrfToken);
                default:
                  throw new Error('Unknown action: ' + action);
              }
            }

            async function handleGetRequest(baseUrl, data, csrfToken) {
              const response = await fetch(baseUrl + '?key=' + encodeURIComponent(data.key), {
                method: 'GET',
                headers: {
                  'X-CSRF-Token': csrfToken,
                  'Content-Type': 'application/json'
                },
                credentials: 'same-origin'
              });

              if (!response.ok) throw new Error('Failed to get key-value');

              const result = await response.json();
              const keyValue = result.key_values.find(kv => kv.key === data.key);
              return keyValue ? keyValue.value : null;
            }

            async function handleSetRequest(baseUrl, data, csrfToken) {
              const response = await fetch(baseUrl, {
                method: 'POST',
                headers: {
                  'X-CSRF-Token': csrfToken,
                  'Content-Type': 'application/json'
                },
                credentials: 'same-origin',
                body: JSON.stringify({
                  key: data.key,
                  value: data.value,
                  public: data.public
                })
              });

              if (!response.ok) {
                const errorData = await response.json();
                throw new Error(errorData.errors ? errorData.errors.join(', ') : 'Failed to set key-value');
              }

              return await response.json();
            }

            async function handleDeleteRequest(baseUrl, data, csrfToken) {
              const response = await fetch(baseUrl, {
                method: 'DELETE',
                body: JSON.stringify({ key: data.key }),
                headers: {
                  'X-CSRF-Token': csrfToken,
                  'Content-Type': 'application/json'
                },
                credentials: 'same-origin'
              });

              if (!response.ok) {
                if (response.status === 404) {
                  throw new Error('Key not found');
                }
                const errorData = await response.json();
                throw new Error(errorData.errors ? errorData.errors.join(', ') : 'Failed to delete key-value');
              }

              return true;
            }

            async function handleIndexRequest(baseUrl, data, csrfToken) {
              const params = new URLSearchParams();
              if (data.key) params.append('key', data.key);
              if (data.all_users) params.append('all_users', data.all_users);
              if (data.keys_only) params.append('keys_only', data.keys_only);
              if (data.page) params.append('page', data.page);
              if (data.per_page) params.append('per_page', data.per_page);

              const response = await fetch(baseUrl + '?' + params.toString(), {
                method: 'GET',
                headers: {
                  'X-CSRF-Token': csrfToken,
                  'Content-Type': 'application/json'
                },
                credentials: 'same-origin'
              });

              if (!response.ok) throw new Error('Failed to get key-values');

              const result = await response.json();
              const userMap = {};
              result.users.forEach(user => {
                userMap[user.id] = user;
              });
              result.key_values.forEach(kv => {
                if (kv.user_id && userMap[kv.user_id]) {
                  kv.user = userMap[kv.user_id];
                }
              });

              return result;
            }
          </script>
        JAVASCRIPT
      end

      def set_native_security_headers
        set_security_headers
        response.headers["X-Frame-Options"] = "SAMEORIGIN"
        response.headers["Content-Security-Policy"] += " frame-ancestors 'self';"
      end

      def set_security_headers
        response.headers.delete("X-Frame-Options")
        response.headers["Cross-Origin-Opener-Policy"] = "same-origin"
        response.headers[
          "Content-Security-Policy"
        ] = "script-src 'self' 'unsafe-inline' 'wasm-unsafe-eval' #{AiArtifact::ALLOWED_CDN_SOURCES.join(" ")};"
        response.headers["X-Robots-Tag"] = "noindex"
      end

      def require_site_settings!
        if !SiteSetting.discourse_ai_enabled ||
             !SiteSetting.ai_artifact_security.in?(%w[lax hybrid strict])
          raise Discourse::NotFound
        end
      end
    end
  end
end