ruby_everywhere 0.0.1 → 0.1.0

data/lib/everywhere/framework.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Everywhere
+  # Framework adapters keep both the CLI (dev/build) and the packaged runtime
+  # (boot) framework-agnostic. Each adapter owns two sides of one framework:
+  #
+  #   CLI side     — dev_command / precompile_* / cleanup_command (build.rb, dev.rb)
+  #   runtime side — prepare_runtime_env / boot! (boot.rb, inside the binary)
+  #
+  # Rails keeps its own boot path (Rails::Command server, multi-db prepare_all).
+  # Sinatra and Hanami are plain Rack apps and share RackFramework's boot: load
+  # config.ru, prepare the database, serve it under Puma bound to localhost.
+  class Framework
+    def self.detect(root = Dir.pwd)
+      return Rails.new(root)   if rails?(root)
+      return Hanami.new(root)  if hanami?(root)
+      return Sinatra.new(root) if sinatra?(root)
+
+      raise Error, "No supported framework detected in #{root} (looked for Rails, Hanami, Sinatra)"
+    end
+
+    def self.rails?(root)
+      File.exist?(File.join(root, "config", "application.rb")) &&
+        gemfile_mentions?(root, "rails")
+    end
+
+    def self.hanami?(root)
+      File.exist?(File.join(root, "config", "app.rb")) && gemfile_mentions?(root, "hanami")
+    end
+
+    def self.sinatra?(root)
+      File.exist?(File.join(root, "config.ru")) && gemfile_mentions?(root, "sinatra")
+    end
+
+    def self.gemfile_mentions?(root, gem_name)
+      gemfile = File.join(root, "Gemfile")
+      File.exist?(gemfile) && File.read(gemfile).match?(/gem ["']#{Regexp.escape(gem_name)}/)
+    end
+
+    attr_reader :root
+
+    def initialize(root)
+      @root = File.expand_path(root)
+    end
+
+    # ---- runtime (inside the packaged binary) --------------------------------
+
+    # Set framework-specific env before the app loads. Called by Boot.
+    def prepare_runtime_env; end
+
+    # Load the app, prepare its database, and start the server bound to
+    # 127.0.0.1:port. Blocks. Implemented per framework.
+    def boot!(port:)
+      raise NotImplementedError, "#{name} has no packaged boot path yet"
+    end
+
+    # Build the Rack app from config.ru. Rack 3 returns the app; Rack 2 returned
+    # [app, options].
+    def load_rack_app
+      require "rack"
+      built = ::Rack::Builder.parse_file(File.join(root, "config.ru"))
+      built.is_a?(Array) ? built.first : built
+    end
+
+    # ---- install (CLI side) --------------------------------------------------
+
+    # The native_boot.rb entry point `every install` writes. Frameworks differ
+    # in which env they set and how the bundle is loaded before the gem.
+    def boot_stub
+      render_boot_stub(env_exports, "require \"bundler/setup\"")
+    end
+
+    # Env each framework needs set before the app loads, beyond NATIVE_PACKAGED.
+    def env_exports = {}
+
+    def render_boot_stub(env, setup_line)
+      exports = ({ "NATIVE_PACKAGED" => "1" }.merge(env))
+        .map { |k, v| "ENV[#{k.inspect}] ||= #{v.inspect}" }.join("\n")
+      <<~RUBY
+        #!/usr/bin/env ruby
+        # frozen_string_literal: true
+
+        # RubyEverywhere packaged-app entry point (generated by `every install`).
+        # Keep this thin: the real boot lives in the ruby_everywhere gem.
+        #{exports}
+
+        #{setup_line}
+        require "ruby_everywhere"
+
+        Everywhere.boot!(root: __dir__)
+      RUBY
+    end
+
+    # Serve a Rack app under Puma on localhost. Keep-alives are disabled: WebKit
+    # (the webview) reuses connections Puma has already closed, which shows up as
+    # intermittent "network connection was lost" asset failures.
+    def serve_rack(app, port:)
+      require "puma"
+      require "puma/configuration"
+      require "puma/launcher"
+
+      configuration = ::Puma::Configuration.new do |c|
+        c.bind "tcp://127.0.0.1:#{port}"
+        c.app app
+        c.environment ENV.fetch("RACK_ENV", "production")
+        c.workers 0
+        c.threads 1, 5
+        c.enable_keep_alives false if c.respond_to?(:enable_keep_alives)
+      end
+      ::Puma::Launcher.new(configuration).run
+    end
+
+    # ---- build/dev (CLI side) ------------------------------------------------
+
+    class Rails < Framework
+      def name = "rails"
+
+      # CLI
+      def dev_command
+        File.exist?(File.join(root, "bin", "dev")) ? "bin/dev" : "bundle exec rails server"
+      end
+
+      def precompile_env
+        { "RAILS_ENV" => "production", "SECRET_KEY_BASE" => "precompile-only" }
+      end
+
+      def precompile_command = "bin/rails assets:precompile"
+
+      def cleanup_command = "bin/rails assets:clobber"
+
+      # Runtime
+      def prepare_runtime_env
+        ENV["RAILS_ENV"] ||= "production"
+        ENV["SOLID_QUEUE_IN_PUMA"] ||= "1"
+      end
+
+      def boot!(port:)
+        # Normally defined by bin/rails; the server command requires it.
+        ::Object.const_set(:APP_PATH, File.join(root, "config/application")) unless defined?(::APP_PATH)
+        require File.join(root, "config/environment")
+        Everywhere::Database.prepare!(root)
+
+        require "rails/command"
+        ::Rails::Command.invoke :server, ["--binding=127.0.0.1", "--port=#{port}"]
+      end
+
+      # Install
+      def env_exports = { "RAILS_ENV" => "production" }
+
+      # Rails loads its bundle through config/boot.rb (with bootsnap guarded).
+      def boot_stub
+        render_boot_stub(env_exports, "require_relative \"config/boot\"")
+      end
+    end
+
+    # Plain Rack frameworks (Sinatra, Hanami) — same packaged boot path.
+    class RackFramework < Framework
+      def prepare_runtime_env
+        ENV["RACK_ENV"] ||= "production"
+      end
+
+      def boot!(port:)
+        app = load_rack_app          # loads app files (and any Everywhere.configure)
+        Everywhere::Database.prepare!(root)
+        serve_rack(app, port: port)
+      end
+
+      def precompile_env = {}
+      def cleanup_command = "true"
+    end
+
+    class Sinatra < RackFramework
+      def name = "sinatra"
+
+      def dev_command
+        File.exist?(File.join(root, "bin", "dev")) ? "bin/dev" : "bundle exec rackup --host 127.0.0.1"
+      end
+
+      # No asset pipeline by default; nothing to precompile.
+      def precompile_command = "true"
+
+      def env_exports = { "RACK_ENV" => "production" }
+    end
+
+    class Hanami < RackFramework
+      def name = "hanami"
+
+      def dev_command = "bundle exec hanami dev"
+
+      def precompile_command = "bundle exec hanami assets compile"
+
+      def env_exports = { "HANAMI_ENV" => "production", "RACK_ENV" => "production" }
+    end
+  end
+
+  class Error < StandardError; end
+end

data/lib/everywhere/ignore.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Everywhere
+  # Shared source-exclusion rules, read from `.everywhereignore` (dockerignore
+  # style) when present, else a sensible default. ONE source of truth so the
+  # build receipt's source checksum (Receipt) and the Platform snapshot
+  # (`every platform build`, later) describe exactly the same set of files — a
+  # checksum that didn't match what actually ships would be worse than none.
+  #
+  # Pattern semantics are a pragmatic subset of .dockerignore/.gitignore:
+  #   dist            → a path segment named "dist", anywhere
+  #   vendor/bundle   → that exact path (and everything under it)
+  #   *.log           → glob against the full path and the basename
+  #   !keep/this.log  → NEGATION: re-include a file an earlier pattern excluded
+  #
+  # Rules are evaluated top to bottom and the LAST one that matches a path wins
+  # (dockerignore semantics), so ordering matters: put `!` re-includes after the
+  # broad exclude they carve out of.
+  class Ignore
+    FILE = ".everywhereignore"
+    FLAGS = File::FNM_PATHNAME | File::FNM_DOTMATCH
+
+    # Build products, caches, VCS, local state, and secrets. Excluding `.env*`
+    # and the key/cert family keeps signing material out of both the checksum
+    # and any future snapshot.
+    DEFAULTS = %w[
+      dist tmp log node_modules .git storage .bundle vendor/bundle
+      coverage public/assets public/packs .DS_Store .env* *.log
+      *.key *.pem *.crt *.p12 *.mobileprovision
+    ].freeze
+
+    def self.for(root)
+      path = File.join(root, FILE)
+      source = File.exist?(path) ? File.read(path) : DEFAULTS.join("\n")
+      new(parse(source))
+    end
+
+    # → [{ negated:, pattern: }, ...] in file order. Blank lines and whole-line
+    # `#` comments are dropped; a leading `!` marks a re-include.
+    def self.parse(text)
+      text.lines.filter_map do |raw|
+        line = raw.chomp
+        next if line.strip.empty? || line.lstrip.start_with?("#")
+
+        negated = line.start_with?("!")
+        pattern = (negated ? line[1..] : line).strip.sub(%r{\A/}, "").chomp("/")
+        { negated: negated, pattern: pattern } unless pattern.empty?
+      end
+    end
+
+    attr_reader :rules
+
+    def initialize(rules)
+      @rules = rules
+    end
+
+    # Every non-ignored regular file under root, as sorted root-relative paths.
+    def files(root)
+      Dir.glob("**/*", File::FNM_DOTMATCH, base: root)
+        .reject { |rel| ignored?(rel) }
+        .select { |rel| File.file?(File.join(root, rel)) }
+        .sort
+    end
+
+    # Last matching rule wins; a negated match re-includes. Default: kept.
+    def ignored?(rel)
+      base = rel.split("/").last
+      return true if [".", ".."].include?(base)
+
+      @rules.reduce(false) do |ignored, rule|
+        match?(rule[:pattern], rel, base) ? !rule[:negated] : ignored
+      end
+    end
+
+    private
+
+    def match?(pat, rel, base)
+      rel == pat ||
+        rel.start_with?("#{pat}/") ||
+        (!pat.include?("/") && rel.split("/").include?(pat)) ||
+        File.fnmatch?(pat, rel, FLAGS) ||
+        File.fnmatch?(pat, base, FLAGS)
+    end
+  end
+end

data/lib/everywhere/javascript/bridge.js

@@ -0,0 +1,174 @@
+// @rubyeverywhere/bridge — one API for the browser, the RubyEverywhere desktop
+// shell, and (soon) Hotwire Native mobile apps.
+//
+// App code writes to this surface only; platform differences live in the
+// adapters below. Everything degrades: the same page works in a plain browser
+// tab and gains native powers inside an app.
+//
+//   import Everywhere from "@rubyeverywhere/bridge"
+//
+//   Everywhere.platform                  // "desktop" | "mobile" | "browser"
+//   Everywhere.os                        // "macos" | "windows" | "linux" | "ios" | "android" | "chromeos" | "unknown"
+//   Everywhere.native                    // true inside a RubyEverywhere app
+//   Everywhere.notify({ title, body })   // native / web Notification / console
+//   Everywhere.confirm("Sure?")          // Promise<boolean>, native dialog when possible
+//   Everywhere.on("menu", handler)       // shell events; returns unsubscribe fn
+//   Everywhere.visit("/settings")        // Turbo.visit with location fallback
+
+const config =
+  (typeof window !== "undefined" && window.__EVERYWHERE_CONFIG__) || {}
+
+function detectOS() {
+  if (config.os) return config.os // authoritative, injected by the desktop shell
+  if (typeof navigator === "undefined") return "unknown"
+  const ua = navigator.userAgent
+  if (/Hotwire Native iOS/i.test(ua)) return "ios"
+  if (/Hotwire Native Android/i.test(ua)) return "android"
+  if (/android/i.test(ua)) return "android"
+  if (/iPhone|iPad|iPod/.test(ua)) return "ios"
+  // iPadOS 13+ masquerades as a Mac; multitouch gives it away
+  if (/Mac/.test(ua) && navigator.maxTouchPoints > 1) return "ios"
+  if (/CrOS/.test(ua)) return "chromeos"
+  if (/Mac/.test(ua)) return "macos"
+  if (/Win/.test(ua)) return "windows"
+  if (/Linux/.test(ua)) return "linux"
+  return "unknown"
+}
+
+function detectPlatform() {
+  if (typeof window === "undefined") return "browser"
+  if (window.__TAURI__) return "desktop"
+  if (/Hotwire Native/i.test(navigator.userAgent)) return "mobile"
+  return "browser"
+}
+
+// --- desktop: the Tauri-based RubyEverywhere shell -------------------------
+
+const desktop = {
+  notify({ title, body }) {
+    return window.__TAURI__.event.emit("everywhere:notify", { title, body })
+  },
+
+  confirm(message) {
+    return window.__TAURI__.dialog.ask(message, {
+      title: config.name || "Confirm",
+      kind: "warning"
+    })
+  },
+
+  on(event, handler) {
+    let unlisten = null
+    let active = true
+    window.__TAURI__.event
+      .listen(`everywhere:${event}`, (e) => handler(e.payload))
+      .then((fn) => (active ? (unlisten = fn) : fn()))
+    return () => {
+      active = false
+      if (unlisten) unlisten()
+    }
+  },
+
+  clipboardWrite(text) {
+    return window.__TAURI__.clipboardManager.writeText(text)
+  },
+
+  clipboardRead() {
+    return window.__TAURI__.clipboardManager.readText()
+  }
+}
+
+// --- browser: honest web fallbacks ------------------------------------------
+
+const browser = {
+  async notify({ title, body }) {
+    if (!("Notification" in window)) {
+      console.log(`[everywhere] notify: ${title}${body ? ` — ${body}` : ""}`)
+      return
+    }
+    if (Notification.permission === "default") {
+      await Notification.requestPermission()
+    }
+    if (Notification.permission === "granted") {
+      new Notification(title, { body })
+    }
+  },
+
+  confirm(message) {
+    return Promise.resolve(window.confirm(message))
+  },
+
+  on(event, handler) {
+    const listener = (e) => handler(e.detail)
+    document.addEventListener(`everywhere:${event}`, listener)
+    return () => document.removeEventListener(`everywhere:${event}`, listener)
+  },
+
+  async clipboardWrite(text) {
+    if (navigator.clipboard) return navigator.clipboard.writeText(text)
+    console.log("[everywhere] clipboard unavailable (insecure context?)")
+  },
+
+  async clipboardRead() {
+    // Browsers gate reads hard (permission prompt, secure context, focus).
+    if (navigator.clipboard && navigator.clipboard.readText) {
+      try { return await navigator.clipboard.readText() } catch (_) { return null }
+    }
+    return null
+  }
+}
+
+// --- mobile: Hotwire Native (stub) ------------------------------------------
+// Detection is real (Hotwire Native apps set their user agent); behavior falls
+// back to the browser adapter until the bridge-component adapter lands. The
+// native webview implements confirm() properly, so that fallback is already
+// correct on mobile.
+
+const mobile = {
+  ...browser
+  // TODO: notify via a Hotwire Native bridge component ("everywhere--notification")
+  // TODO: menu/tab events dispatched as document CustomEvents ("everywhere:menu")
+}
+
+// --- public surface ----------------------------------------------------------
+
+const adapters = { desktop, browser, mobile }
+const platform = detectPlatform()
+const os = detectOS()
+const adapter = adapters[platform]
+
+export const Everywhere = {
+  platform,
+  os,
+
+  get native() {
+    return platform !== "browser"
+  },
+
+  notify(options = {}) {
+    return adapter.notify({ title: document.title, body: "", ...options })
+  },
+
+  confirm(message) {
+    return adapter.confirm(message)
+  },
+
+  on(event, handler) {
+    return adapter.on(event, handler)
+  },
+
+  visit(path) {
+    if (window.Turbo) window.Turbo.visit(path)
+    else window.location.assign(path)
+  },
+
+  clipboard: {
+    write(text) {
+      return adapter.clipboardWrite(text)
+    },
+    read() {
+      return adapter.clipboardRead()
+    }
+  }
+}
+
+export default Everywhere

data/lib/everywhere/platform/client.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+require_relative "../version"
+
+module Everywhere
+  # Talks to the RubyEverywhere Platform. Small JSON-over-HTTP wrapper — no gem
+  # dependency, so it works inside the packaged CLI too.
+  module Platform
+    # Production Platform API. rubyeverywhere.com is the marketing/docs site;
+    # the Platform lives on the `platform.` subdomain. Override for dev with
+    # --url or $EVERYWHERE_PLATFORM_URL (e.g. http://localhost:3000).
+    DEFAULT_URL = "https://platform.rubyeverywhere.com"
+
+    # Best-effort browser open; returns false (never raises) if it can't.
+    def self.open_url(url)
+      cmd =
+        if RUBY_PLATFORM.include?("darwin")            then ["open", url]
+        elsif RUBY_PLATFORM.match?(/mingw|mswin/)      then ["cmd", "/c", "start", "", url]
+        else                                                ["xdg-open", url]
+        end
+      system(*cmd, out: File::NULL, err: File::NULL)
+    rescue StandardError
+      false
+    end
+
+    class Client
+      def self.base_url(explicit = nil)
+        (explicit || ENV["EVERYWHERE_PLATFORM_URL"] || DEFAULT_URL).chomp("/")
+      end
+
+      attr_reader :base_url
+
+      def initialize(base_url, token: nil)
+        @base_url = base_url
+        @base = URI.parse("#{base_url}/")
+        @token = token
+      end
+
+      def post(path, body = {})  = request(Net::HTTP::Post, path, body)
+      def patch(path, body = {}) = request(Net::HTTP::Patch, path, body)
+      def get(path)              = request(Net::HTTP::Get, path)
+      def delete(path)           = request(Net::HTTP::Delete, path)
+
+      # Stream a file with a raw PUT (Active Storage direct upload). `url` is
+      # absolute (from the reservation); `headers` come from the reservation too.
+      # Returns the Net::HTTP response.
+      def put_file(url, path, headers: {})
+        uri = URI.parse(url)
+        req = Net::HTTP::Put.new(uri)
+        headers.each { |k, v| req[k] = v }
+        req["Content-Length"] = File.size(path).to_s
+        File.open(path, "rb") do |io|
+          req.body_stream = io
+          http(uri) { |conn| conn.request(req) }
+        end
+      rescue SocketError, Errno::ECONNREFUSED, Errno::ETIMEDOUT => e
+        raise Error, "upload to #{uri.host} failed (#{e.class})"
+      end
+
+      # GET a (possibly redirecting, signed) URL and stream it to dest. Sends the
+      # bearer token only to the platform host (the first hop when the URL is a
+      # /runner or /cli endpoint); a redirect to a signed blob/S3 URL is followed
+      # without it.
+      def download(url, dest, redirects: 5)
+        uri = URI.parse(url)
+        req = Net::HTTP::Get.new(uri)
+        req["Authorization"] = "Bearer #{@token}" if @token && uri.host == @base.host && uri.port == @base.port
+        http(uri) do |conn|
+          conn.request(req) do |res|
+            case res
+            when Net::HTTPRedirection
+              raise Error, "too many redirects downloading #{url}" if redirects <= 0
+
+              return download(res["location"], dest, redirects: redirects - 1)
+            when Net::HTTPSuccess
+              File.open(dest, "wb") { |f| res.read_body { |chunk| f.write(chunk) } }
+            else
+              raise Error, "download failed (HTTP #{res.code})"
+            end
+          end
+        end
+        dest
+      end
+
+      private
+
+      def http(uri, &block)
+        Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https", &block)
+      end
+
+      def request(klass, path, body = nil)
+        uri = URI.join(@base, path.sub(%r{\A/}, ""))
+        req = klass.new(uri)
+        req["Accept"] = "application/json"
+        req["User-Agent"] = "every/#{Everywhere::VERSION}"
+        req["Authorization"] = "Bearer #{@token}" if @token
+        if body
+          req["Content-Type"] = "application/json"
+          req.body = JSON.generate(body)
+        end
+
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| http.request(req) }
+        Response.new(res.code.to_i, parse(res.body))
+      rescue SocketError, Errno::ECONNREFUSED, Errno::ETIMEDOUT => e
+        raise Error, "couldn't reach the Platform at #{@base_url} (#{e.class})"
+      end
+
+      def parse(body)
+        return {} if body.to_s.empty?
+
+        JSON.parse(body)
+      rescue JSON::ParserError
+        {}
+      end
+
+      Response = Struct.new(:status, :body) do
+        def ok? = status.between?(200, 299)
+        def unauthorized? = status == 401
+      end
+    end
+  end
+end

data/lib/everywhere/platform/credentials.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Everywhere
+  module Platform
+    # Local credential store at ~/.config/everywhere/credentials.json (0600),
+    # keyed by Platform base URL so a dev localhost login and a production login
+    # coexist. Each entry holds an org-scoped token + the org it's bound to.
+    #
+    #   { "https://platform.rubyeverywhere.com": {
+    #       "token": "rbe_…",
+    #       "organization": { "id": "org_…", "name": "Acme", "slug": "acme" } } }
+    class Credentials
+      def self.path
+        ENV["EVERYWHERE_CREDENTIALS"] || File.join(config_home, "everywhere", "credentials.json")
+      end
+
+      def self.config_home
+        ENV["XDG_CONFIG_HOME"].to_s.empty? ? File.expand_path("~/.config") : ENV["XDG_CONFIG_HOME"]
+      end
+
+      def self.load
+        data =
+          if File.exist?(path)
+            JSON.parse(File.read(path)) rescue {}
+          else
+            {}
+          end
+        new(data.is_a?(Hash) ? data : {})
+      end
+
+      def initialize(data)
+        @data = data
+      end
+
+      def for(url)
+        @data[normalize(url)]
+      end
+
+      def logged_in?(url)
+        !self.for(url).nil?
+      end
+
+      def set(url, entry)
+        @data[normalize(url)] = entry
+        save
+      end
+
+      def delete(url)
+        removed = @data.delete(normalize(url))
+        save
+        removed
+      end
+
+      private
+
+      def normalize(url) = url.to_s.chomp("/")
+
+      def save
+        path = self.class.path
+        dir = File.dirname(path)
+        FileUtils.mkdir_p(dir)
+        File.chmod(0o700, dir)
+        File.write(path, "#{JSON.pretty_generate(@data)}\n")
+        File.chmod(0o600, path)
+      end
+    end
+  end
+end

data/lib/everywhere/platform/snapshot.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "rubygems/package"
+require "zlib"
+require "digest"
+require_relative "../ignore"
+
+module Everywhere
+  module Platform
+    # Packs the app's source into a .tar.gz for a Platform build, honoring
+    # .everywhereignore (so dist/, node_modules, .git, secrets never ship). Pure
+    # Ruby — no `tar` dependency — and streams file-by-file so a large tree
+    # doesn't blow up memory.
+    module Snapshot
+      module_function
+
+      # Writes root's non-ignored files to out_path (a .tar.gz). Returns the file
+      # count.
+      def create(root, out_path)
+        files = Everywhere::Ignore.for(root).files(root)
+        File.open(out_path, "wb") do |dest|
+          Zlib::GzipWriter.wrap(dest) do |gz|
+            Gem::Package::TarWriter.new(gz) do |tar|
+              files.each { |rel| add(tar, root, rel) }
+            end
+          end
+        end
+        files.size
+      end
+
+      # base64 MD5 of a file (what Active Storage's direct upload verifies),
+      # computed in chunks so large snapshots don't load into memory.
+      def md5_base64(path)
+        digest = Digest::MD5.new
+        File.open(path, "rb") { |f| digest << f.read(1 << 20) until f.eof? }
+        digest.base64digest
+      end
+
+      def add(tar, root, rel)
+        abs = File.join(root, rel)
+        stat = File.stat(abs)
+        tar.add_file_simple(rel, stat.mode & 0o777, stat.size) do |io|
+          File.open(abs, "rb") { |f| IO.copy_stream(f, io) }
+        end
+      end
+    end
+  end
+end