fluid_cli 0.1.2

data/lib/fluid_cli/identity_auth.rb

@@ -0,0 +1,126 @@
+require "base64"
+require "digest"
+require "json"
+require "net/http"
+require "securerandom"
+require "openssl"
+require "fluid_cli"
+require "uri"
+
+module FluidCLI
+  class IdentityAuth
+    # include SmartProperties
+    autoload :Servlet, "fluid_cli/identity_auth/servlet"
+    # autoload :EnvAuthToken, "fluid_cli/identity_auth/env_auth_token"
+
+    class Error < StandardError; end
+    class Timeout < StandardError; end
+    LocalRequest = Struct.new(:method, :path, :query, :protocol)
+
+    DEFAULT_PORT = 3456
+    REDIRECT_HOST = "http://127.0.0.1:#{DEFAULT_PORT}"
+
+    attr_accessor :ctx, :store, :response_query, :state_token
+
+    def initialize(ctx:, store: FluidCLI::DB.new, state_token: SecureRandom.hex(30))
+      @ctx = ctx
+      @store = store
+      @state_token = state_token
+    end
+
+    def authenticate(spinner: false)
+      initiate_authentication
+
+      begin
+        store.set(jwt: receive_jwt)
+      rescue IdentityAuth::Timeout => e
+        ctx.abort(e.message)
+      end
+    end
+
+    def with_spinner(spinner, message, &block)
+      result = nil
+      if spinner
+        CLI::UI::Spinner.spin(message) do
+          result = block.call
+        end
+      else
+        result = block.call
+      end
+      result
+    end
+
+    def self.environment_auth_token?
+      !!Environment.auth_token
+    end
+
+    def self.authenticated?
+      environment_auth_token? ||  FluidCLI::DB.exists?(:jwt)
+    end
+
+    def reauthenticate
+      return if attempt_reauthenticate
+      ctx.abort("Authentication required. Please login again using 'fluid_cli login' command.")
+    end
+
+    def attempt_reauthenticate
+      refresh_jwt
+    end
+
+    def server
+      @server ||= begin
+        server = WEBrick::HTTPServer.new(
+          Port: DEFAULT_PORT,
+          Logger: WEBrick::Log.new(File.open(File::NULL, "w")),
+          AccessLog: [],
+        )
+        server.mount("/", Servlet, self, state_token)
+        server
+      end
+    end
+
+    def self.delete_tokens_and_keys
+      FluidCLI::DB.del(:jwt)
+    end
+
+    private
+
+    def initiate_authentication
+      @server_thread = Thread.new { server.start }
+      params = {
+        redirect_url: REDIRECT_HOST,
+      }
+      uri = URI.parse("https://auth.fluid.app/")
+      uri.query = URI.encode_www_form(params)
+      open_browser_authentication(uri)
+    end
+
+    def open_browser_authentication(uri)
+      ctx.open_browser_url!(uri)
+    end
+
+    def receive_jwt
+      @jwt ||= begin
+        @server_thread.join(240)
+        raise Timeout, "timeout" if response_query.nil?
+        raise Error, response_query["error"] unless response_query["error"].nil?
+        response_query["jwt"]
+      end
+    end
+
+    def refresh_jwt
+      # return false unless store.exists?(:jwt)
+      _status, body  = FluidCLI::API.new(@ctx).get(path: "/me")
+
+      store.set(jwt: body["jwt"])
+      store.set(company: body["company"]["subdomain"])
+      store.set(company_name: body["company"]["name"])
+      true
+    rescue
+      store.del(:jwt)
+      store.del(:company)
+      store.del(:company_name)
+      false
+    end
+  end
+end

data/lib/fluid_cli/options.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require "fluid_cli"
+require "optparse"
+
+module FluidCLI
+  class Options
+    attr_reader :flags, :subcommand, :help
+
+    def initialize
+      @flags = {}
+      @help = false
+    end
+
+    def parse(options_block, args)
+      @args = args
+      if options_block.respond_to?(:call) && args
+        parse_flags(options_block)
+      else
+        parser.permute!(@args)
+      end
+      @args
+    end
+
+    def parse_flags(block)
+      block.call(parser, @flags)
+      parser.permute!(@args)
+    end
+
+    def parser
+      @parser ||= begin
+        opt = OptionParser.new
+        opt.on("--help", "-h", "options help") do |v|
+          @help = v
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/dev_server/certificate_manager.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module FluidCLI
+  module Theme
+    class DevServer
+      class CertificateManager
+        attr_reader :ctx, :domain_name, :certificate, :private_key
+
+        ISSUER_EXTENSIONS = [
+          ["subjectKeyIdentifier", "hash", false],
+          ["authorityKeyIdentifier", "keyid:always", false],
+        ]
+
+        def initialize(ctx, domain_name)
+          @ctx = ctx
+          @domain_name = domain_name
+        end
+
+        def find_or_create_certificates!
+          @private_key = if (private_key_pem = FluidCLI::DB.get(:ssl_private_key))
+            OpenSSL::PKey::RSA.new(private_key_pem)
+          else
+            OpenSSL::PKey::RSA.new(2048)
+          end
+
+          @certificate = if (certificate_pem = FluidCLI::DB.get(:ssl_certificate))
+            OpenSSL::X509::Certificate.new(certificate_pem)
+          else
+            x509_certificate = build_x509_certificate
+
+            sign_certificate!(x509_certificate)
+
+            x509_certificate
+          end
+
+          FluidCLI::DB.set(ssl_certificate: certificate.to_pem)
+          FluidCLI::DB.set(ssl_private_key: private_key.to_pem)
+        end
+
+        private
+
+        def build_x509_certificate
+          certificate = OpenSSL::X509::Certificate.new
+
+          certificate.public_key = private_key.public_key
+          certificate.subject = subject
+          certificate.version = 2
+          certificate.serial = 0x0
+
+          certificate.not_before = Time.now.utc
+          certificate.not_after = Time.now.utc + 365 * 24 * 60 * 60
+
+          certificate
+        end
+
+        def sign_certificate!(certificate)
+          ef = OpenSSL::X509::ExtensionFactory.new
+
+          ef.subject_certificate = certificate
+          ef.issuer_certificate = certificate
+
+          ISSUER_EXTENSIONS.each do |args|
+            certificate.add_extension(ef.create_extension(*args))
+          end
+
+          certificate.add_extension(ef.create_extension("subjectAltName", "DNS:#{@domain_name}", false))
+
+          certificate.sign(private_key, OpenSSL::Digest.new("SHA256"))
+        end
+
+        def subject
+          OpenSSL::X509::Name.parse("/CN=#{@domain_name}/")
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/dev_server/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+module FluidCLI
+  module Theme
+    class DevServer
+      # Errors
+      class Error < StandardError; end
+    end
+  end
+end

data/lib/fluid_cli/theme/dev_server/header_hash.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module FluidCLI
+  module Theme
+    class DevServer
+      # Based on Rack::HeaderHash
+      class HeaderHash < Hash
+        def self.[](headers)
+          if headers.is_a?(HeaderHash) && !headers.frozen?
+            headers
+          else
+            new(headers)
+          end
+        end
+
+        def initialize(hash = {})
+          super()
+          @names = {}
+          hash.each { |k, v| self[k] = v }
+        end
+
+        # on dup/clone, we need to duplicate @names hash
+        def initialize_copy(other)
+          super
+          @names = other.names.dup
+        end
+
+        # on clear, we need to clear @names hash
+        def clear
+          super
+          @names.clear
+        end
+
+        def each
+          super do |k, v|
+            yield(k, v.respond_to?(:to_ary) ? v.to_ary.join("\n") : v)
+          end
+        end
+
+        def to_hash
+          hash = {}
+          each { |k, v| hash[k] = v }
+          hash
+        end
+
+        def [](k)
+          super(k) || super(@names[k.downcase])
+        end
+
+        def fetch(k, default = nil)
+          self[k] || super(@names[k.downcase], default)
+        end
+
+        def []=(k, v)
+          canonical = k.downcase.freeze
+          # .delete is expensive, don't invoke it unless necessary
+          delete(k) if @names[canonical] && @names[canonical] != k
+          @names[canonical] = k
+          super(k, v)
+        end
+
+        def delete(k)
+          canonical = k.downcase
+          result = super(@names.delete(canonical))
+          result
+        end
+
+        def include?(k)
+          super || @names.include?(k.downcase)
+        end
+
+        alias_method :has_key?, :include?
+        alias_method :member?, :include?
+        alias_method :key?, :include?
+
+        def merge!(other)
+          other.each { |k, v| self[k] = v }
+          self
+        end
+
+        def merge(other)
+          hash = dup
+          hash.merge!(other)
+        end
+
+        def replace(other)
+          clear
+          other.each { |k, v| self[k] = v }
+          self
+        end
+
+        protected
+
+        attr_reader :names
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/dev_server/hooks/file_change_hook.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+module FluidCLI
+  module Theme
+    class DevServer
+      module Hooks
+        class FileChangeHook
+          def initialize(ctx, theme:)
+            @ctx = ctx
+            @theme = theme
+          end
+
+          def call(modified, added, removed, streams: nil)
+            @streams = streams
+            files = (modified + added)
+              .map { |f| @theme[f] }
+            deleted_files = removed
+              .map { |f| @theme[f] }
+
+            reload_page(removed) unless deleted_files.empty?
+            hot_reload(files) unless files.empty?
+          end
+
+          private
+
+          def hot_reload(files)
+            paths = files.map(&:relative_path)
+            @streams.broadcast(JSON.generate(modified: paths))
+            @ctx.debug("[HotReload] Modified #{paths.join(", ")}")
+          end
+
+          def reload_page(removed)
+            @streams.broadcast(JSON.generate(reload_page: true))
+            @ctx.debug("[ReloadPage] Deleted #{removed.join(", ")}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/dev_server/hot_reload/resources/hot-reload-no-script.html

@@ -0,0 +1,27 @@
+<noscript>
+  <style type="text/css">
+    .fluid-cli-no-script-message {
+      font-family: -apple-system, BlinkMacSystemFont, San Francisco, Segoe UI, Roboto, Helvetica Neue, sans-serif;
+      text-size-adjust: 100%;
+      text-rendering: optimizeLegibility;
+      -webkit-font-smoothing: antialiased;
+      -moz-osx-font-smoothing: grayscale;
+      position: fixed;
+      z-index: 999;
+      font-weight: 500;
+      left: 0;
+      top: 0;
+      width: 100vw;
+      height: 100vh;
+      padding: 10rem 0;
+      color: #202223;
+      text-align: center;
+      background-color: #F6F6F7;
+    }
+  </style>
+  <div class="fluid-cli-no-script-message">
+    Fluid CLI requires JavaScript to work.
+    <br />
+    Activate JavaScript support or try a different browser.
+  </div>
+</noscript>

data/lib/fluid_cli/theme/dev_server/hot_reload/resources/hot_reload.js

@@ -0,0 +1,28 @@
+class HotReload {
+  static reloadMode = () => {
+    const namespace = window.__FLUID_CLI_ENV__;
+    return namespace.mode;
+  };
+  static isFullPageReloadMode = () => {
+    return HotReload.reloadMode() === "full-page";
+  };
+  static isReloadModeActive = () => {
+    return HotReload.reloadMode() !== "off";
+  };
+  static setHotReloadCookie = (files) => {
+    const date = new Date();
+
+    // Hot reload cookie expires in 3 seconds
+    date.setSeconds(date.getSeconds() + 3);
+
+    const sections = files.join(",");
+    const expires = date.toUTCString();
+
+    document.cookie = `hot_reload_files=${sections}; expires=${expires}; path=/`;
+  };
+  static refreshPage = (files) => {
+    HotReload.setHotReloadCookie(files);
+    console.log("[HotReload] Refreshing entire page");
+    window.location.reload();
+  };
+}

data/lib/fluid_cli/theme/dev_server/hot_reload/resources/sse_client.js

@@ -0,0 +1,43 @@
+class SSEClient {
+  constructor(eventsUrl, eventHandler) {
+    SSEClient.verifySSE();
+    this.eventsUrl = eventsUrl;
+    this.eventHandler = eventHandler;
+  }
+  static verifySSE() {
+    if (typeof EventSource === "undefined") {
+      console.error(
+        "[HotReload] Error: SSE features are not supported. Try a different browser."
+      );
+    }
+
+    console.log("[HotReload] Initializing...");
+  }
+  connect() {
+    const eventSource = new EventSource(this.eventsUrl);
+    eventSource.onmessage = (msg) => {
+      this.handleMessage(msg);
+    };
+
+    eventSource.onopen = () => console.log("[HotReload] SSE connected.");
+
+    eventSource.onclose = () => {
+      console.log("[HotReload] SSE closed. Attempting to reconnect...");
+
+      setTimeout(this.connect, 5000);
+    };
+
+    eventSource.onerror = () => {
+      console.log("[HotReload] SSE closed.");
+      eventSource.close();
+    };
+  }
+  handleMessage(message) {
+    const data = JSON.parse(message.data);
+    if (data.reload_page) {
+      HotReload.refreshPage([]);
+      return;
+    }
+    this.eventHandler(data);
+  }
+}

data/lib/fluid_cli/theme/dev_server/hot_reload/resources/theme.js

@@ -0,0 +1,16 @@
+(() => {
+  function handleUpdate(data) {
+    const modifiedFiles = data.modified;
+
+    if (modifiedFiles === undefined) {
+      return;
+    }
+
+    HotReload.refreshPage(modifiedFiles)
+  }
+
+  if (HotReload.isReloadModeActive()) {
+    let client = new SSEClient("/hot-reload", handleUpdate);
+    client.connect();
+  }
+})();

data/lib/fluid_cli/theme/dev_server/hot_reload/script_injector.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module FluidCLI
+  module Theme
+    class DevServer
+      class HotReload
+        class ScriptInjector
+          def initialize(ctx, theme: nil)
+            @ctx = ctx
+            @theme = theme
+          end
+
+          def inject(body:, dir:, mode:)
+            @mode = mode
+            @dir = dir
+            hot_reload_script = [
+              read("hot-reload-no-script.html"),
+              "<script>",
+              "(() => {",
+              javascript_inline,
+              *javascript_files.map { |file| read(file) },
+              "})();",
+              "</script>",
+            ].join("\n")
+
+            body = body.join.sub("</body>", "#{hot_reload_script}\n</body>")
+
+            [body]
+          end
+
+          private
+
+          def javascript_files
+            %w(hot_reload.js sse_client.js theme.js)
+          end
+
+          def javascript_inline
+            env = { mode: @mode }
+
+            <<~JS
+              (() => {
+                window.__FLUID_CLI_ENV__ = #{env.to_json};
+              })();
+            JS
+          end
+
+          def read(filename)
+            ::File.read("#{@dir}/hot_reload/resources/#{filename}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/dev_server/hot_reload.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module FluidCLI
+  module Theme
+    class DevServer
+      class HotReload
+        def initialize(ctx, app, broadcast_hooks: [], script_injector: nil, watcher:, mode:)
+          @ctx = ctx
+          @app = app
+          @mode = mode
+          @broadcast_hooks = broadcast_hooks
+          @script_injector = script_injector
+          @streams = SSE::Streams.new
+          @watcher = watcher
+          @watcher.add_observer(self, :notify_streams_of_file_change)
+        end
+
+        def call(env)
+          path = env["PATH_INFO"]
+          if path == "/hot-reload"
+            create_stream
+          else
+            status, headers, body = @app.call(env)
+
+            if request_is_html?(headers) && leads_to_injectable_body?(path)
+              body = inject_hot_reload_javascript(body)
+            end
+
+            [status, headers, body]
+          end
+        end
+
+        def close
+          @streams.close
+        end
+
+        def notify_streams_of_file_change(modified, added, removed)
+          @broadcast_hooks.each do |hook|
+            hook.call(modified, added, removed, streams: @streams)
+          end
+        end
+
+        private
+
+        def request_is_html?(headers)
+          headers["content-type"]&.start_with?("text/html")
+        end
+
+        def leads_to_injectable_body?(path)
+          path !~ /.+\/sandbox/
+        end
+
+        def inject_hot_reload_javascript(body)
+          @script_injector&.inject(body: body, dir: __dir__, mode: @mode)
+        end
+
+        def create_stream
+          stream = @streams.new
+
+          @ctx.debug("[HotReload] Connected to SSE stream")
+
+          [
+            200,
+            {
+              "Content-Type" => "text/event-stream",
+              "Cache-Control" => "no-cache",
+              "webrick.chunked" => true,
+            },
+            stream,
+          ]
+        end
+      end
+    end
+  end
+end