samagotchi 0.2.0

data/lib/samagotchi/desktop/macos.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require "erb"
+require "fileutils"
+require "json"
+require "open3"
+require "rbconfig"
+require_relative "../version"
+require_relative "../self_report"
+require_relative "../installed_gem"
+
+module Samagotchi
+  module Desktop
+    # The macOS helper, "Chi Helper.app": a Service ("Send to chi") and a
+    # hotkey that open a panel sending text to live sessions via `chi note`.
+    #
+    # Built on this machine with plain swiftc and an ad-hoc signature (no
+    # Xcode project, no notarization) into ~/Applications. Every outside
+    # command goes through the runner, and the dirs are injectable, so specs
+    # (and smokes with register: false) never touch the real system.
+    class MacOS
+      Error = Class.new(StandardError)
+
+      APP_NAME = "Chi Helper"
+      BUNDLE_ID = "dev.samagotchi.chi-helper"
+      EXECUTABLE = "ChiHelper"
+      SOURCES_DIR = File.expand_path("macos", __dir__)
+      PBS = "/System/Library/CoreServices/pbs"
+      LSREGISTER = "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister"
+      # Built next to the target without an .app suffix, so Launch Services
+      # never registers a half-built app.
+      BUILD_NAME = ".chi-helper-build"
+      OLD_NAME = ".chi-helper-old"
+      # Apps started by launchd get a bare env (no shell rc files), so the
+      # launch file carries what chi needs to find its gems and state. Only
+      # these, and only when set: no tokens, no runtime knobs.
+      ENV_ALLOWLIST = %w[XDG_CONFIG_HOME XDG_STATE_HOME GEM_HOME GEM_PATH RUBYLIB].freeze
+      # Without it Ruby reads stdin as US-ASCII and non-ASCII notes break.
+      LANG = "en_US.UTF-8"
+
+      # Runs a command without a shell; [output, success].
+      class Runner
+        def run(argv)
+          output, status = Open3.capture2e(*argv)
+          [output, status.success?]
+        rescue SystemCallError => e
+          [e.message, false]
+        end
+      end
+
+      attr_reader :app_dir, :support_dir
+
+      def initialize(app_dir: nil, support_dir: nil, env: ENV, runner: Runner.new,
+                     source_dir: SelfReport::SOURCE_DIR, ruby: RbConfig.ruby, version: VERSION,
+                     arch: nil, sources_dir: SOURCES_DIR, register: true, chi_path: nil)
+        home = env["HOME"] || Dir.home
+        @app_dir = app_dir || File.join(home, "Applications")
+        @support_dir = support_dir || File.join(home, "Library", "Application Support", APP_NAME)
+        @env = env
+        @runner = runner
+        @source_dir = source_dir
+        @chi_path = chi_path || InstalledGem.wrapper(InstalledGem.spec(source_dir)) || File.join(source_dir, "bin", "chi")
+        @ruby = ruby
+        @version = version
+        @arch = arch
+        @sources_dir = sources_dir
+        @register = register
+      end
+
+      def app_path = File.join(@app_dir, "#{APP_NAME}.app")
+      def launch_path = File.join(@support_dir, "launch.json")
+      # Written by the app at launch: its hotkey and whether macOS took it.
+      def hotkey_path = File.join(@support_dir, "hotkey.json")
+      def executable_path = File.join(app_path, "Contents", "MacOS", EXECUTABLE)
+      def installed? = File.directory?(app_path)
+
+      # What the helper runs: absolute ruby + chi (no shims, which need the
+      # shell's PATH), and the allowlisted env. chi is an installed gem's
+      # RubyGems wrapper (it activates the gem and outlives upgrades and
+      # `gem cleanup`), else this checkout's bin/chi.
+      def launch_config
+        env = { "LANG" => LANG }
+        ENV_ALLOWLIST.each { |name| env[name] = @env[name] unless @env[name].to_s.empty? }
+        { "version" => @version, "argv" => [@ruby, @chi_path], "env" => env }
+      end
+
+      def warnings
+        return [] unless File.file?(File.join(@source_dir, ".git"))
+
+        ["chi runs from a linked git worktree (#{@source_dir}); the helper stops working once it is removed. " \
+         "Install from the main checkout or a gem install."]
+      end
+
+      def info_plist
+        ERB.new(File.read(File.join(SOURCES_DIR, "Info.plist.erb")))
+           .result_with_hash(bundle_id: BUNDLE_ID, app_name: APP_NAME, executable: EXECUTABLE, version: @version)
+      end
+
+      # @yield [String] progress lines
+      # @param login [Boolean] also start the app at login
+      def install(force: false, login: false, &progress)
+        raise Error, "already installed (#{app_version}); use chi desktop upgrade" if installed? && !force
+
+        toolchain!
+        quit if installed?
+        progress&.call("building #{APP_NAME} #{@version} (can take a few minutes)…")
+        built = build_app
+        swap_in(built)
+        write_launch_file
+        register_app
+        self.login = true if login
+        progress&.call("installed #{app_path}")
+        app_path
+      end
+
+      # Keeps the login item as it was.
+      def upgrade(&progress)
+        was_login = installed? && login == "enabled"
+        install(force: true, login: was_login, &progress)
+      end
+
+      # SMAppService status as the app reports it ("enabled",
+      # "notRegistered", "requiresApproval", "notFound"); nil if unknown.
+      # Only the app itself can register it, run directly with --login.
+      def login
+        return nil unless @register && installed?
+
+        output, ok = @runner.run([executable_path, "--login", "status"])
+        ok ? output.strip : nil
+      end
+
+      def login=(on)
+        return unless @register && installed?
+
+        output, ok = @runner.run([executable_path, "--login", on ? "on" : "off"])
+        raise Error, "could not turn #{on ? "on" : "off"} the login item: #{output.strip}" if on && !ok
+      end
+
+      # @return [Boolean] false when there was nothing to remove
+      def uninstall
+        return false unless installed? || File.exist?(@support_dir)
+
+        self.login = false
+        quit
+        FileUtils.rm_rf(app_path)
+        FileUtils.rm_rf(@support_dir)
+        if @register
+          @runner.run(["defaults", "delete", BUNDLE_ID])
+          @runner.run([PBS, "-update"])
+        end
+        true
+      end
+
+      def status
+        result = { installed: installed?, app_path: app_path, chi_version: @version }
+        return result unless result[:installed]
+
+        launch = (JSON.parse(File.read(launch_path)) rescue nil)
+        argv = launch.is_a?(Hash) ? Array(launch["argv"]) : []
+        env = launch.is_a?(Hash) && launch["env"].is_a?(Hash) ? launch["env"] : {}
+        dump, = @runner.run([PBS, "-dump"])
+        _, running = @runner.run(["pgrep", "-x", EXECUTABLE])
+        hotkey = (JSON.parse(File.read(hotkey_path)) rescue nil)
+        result.merge(
+          app_version: app_version,
+          login: login,
+          hotkey: hotkey.is_a?(Hash) ? hotkey : nil,
+          launch_argv: argv,
+          launch_ok: !argv.empty? && argv.all? { |path| File.exist?(path) },
+          baked_dirs: env.select { |name, _| name.start_with?("XDG_") },
+          service: dump.include?(BUNDLE_ID),
+          running: running
+        )
+      end
+
+      def app_version
+        plist = File.read(File.join(app_path, "Contents", "Info.plist"))
+        plist[%r{<key>CFBundleShortVersionString</key>\s*<string>([^<]*)</string>}, 1]
+      rescue SystemCallError
+        nil
+      end
+
+      # rename(2) can't replace a non-empty dir: old aside, new in, old gone;
+      # the old copy comes back if the second rename fails.
+      def swap_in(build)
+        old = File.join(@app_dir, OLD_NAME)
+        FileUtils.rm_rf(old)
+        had_old = installed?
+        File.rename(app_path, old) if had_old
+        begin
+          File.rename(build, app_path)
+        rescue StandardError
+          File.rename(old, app_path) if had_old
+          raise
+        end
+        FileUtils.rm_rf(old)
+      end
+
+      private
+
+      def toolchain!
+        _, ok = @runner.run(%w[xcrun --find swiftc])
+        return if ok
+
+        raise Error, "chi desktop needs the Command Line Tools (swiftc): xcode-select --install"
+      end
+
+      def build_app
+        build = File.join(@app_dir, BUILD_NAME)
+        FileUtils.rm_rf(build)
+        macos_dir = File.join(build, "Contents", "MacOS")
+        FileUtils.mkdir_p(macos_dir)
+        File.write(File.join(build, "Contents", "Info.plist"), info_plist)
+        sources = Dir[File.join(@sources_dir, "*.swift")].sort
+        # Through xcrun: swiftc run by its bare path finds no SDK.
+        compile = ["xcrun", "--sdk", "macosx", "swiftc", "-O", "-swift-version", "5", "-target", "#{arch}-apple-macos13", "-parse-as-library",
+                   *sources, "-o", File.join(macos_dir, EXECUTABLE)]
+        run!(compile, "swiftc failed")
+        run!(["codesign", "--force", "--sign", "-", build], "codesign failed")
+        build
+      rescue StandardError
+        FileUtils.rm_rf(build) if build
+        raise
+      end
+
+      def run!(argv, what)
+        output, ok = @runner.run(argv)
+        raise Error, "#{what}:\n#{output}" unless ok
+      end
+
+      def arch
+        @arch ||= RbConfig::CONFIG["host_cpu"] == "arm64" ? "arm64" : `uname -m`.strip
+      end
+
+      def write_launch_file
+        FileUtils.mkdir_p(@support_dir)
+        tmp = "#{launch_path}.tmp"
+        File.write(tmp, JSON.pretty_generate(launch_config) + "\n")
+        File.rename(tmp, launch_path)
+      end
+
+      def register_app
+        return unless @register
+
+        @runner.run([PBS, "-update"])
+        @runner.run([LSREGISTER, "-f", app_path])
+        @runner.run(["open", "-g", app_path])
+      end
+
+      def quit
+        @runner.run(["pkill", "-x", EXECUTABLE]) if @register
+      end
+    end
+  end
+end

data/lib/samagotchi/desktop.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Samagotchi
+  # `chi desktop`: a small native helper that sends selected text to live
+  # sessions as a context note. It talks to chi only through the CLI
+  # (`chi sessions list --live --scope=all --format json`, `chi note`), so it could ship
+  # on its own later. macOS only for now; a Linux variant would be another
+  # class next to MacOS.
+  module Desktop
+    autoload :MacOS, "samagotchi/desktop/macos"
+
+    module_function
+
+    # @return [Boolean] whether this machine has a desktop helper variant
+    def supported?(host_os = RbConfig::CONFIG["host_os"])
+      host_os.to_s.include?("darwin")
+    end
+  end
+end

data/lib/samagotchi/desktop_command.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require_relative "desktop"
+
+module Samagotchi
+  # `chi desktop install|upgrade|uninstall|status`: the native helper that
+  # sends selected text to live sessions as a context note (macOS for now).
+  class DesktopCommand
+    USAGE = <<~TEXT
+      Usage: chi desktop <install|upgrade|uninstall|status>
+        install [--force] [--login]
+                           build "Chi Helper" into ~/Applications (needs the Command Line Tools)
+                           and start it: Services > "Send to chi", or ⌃⌥⌘N with the clipboard,
+                           sends text to a live session as a context note. --login: start it
+                           at login too (else it runs until you log out)
+        upgrade            rebuild it for this chi and restart it
+        uninstall          remove it, its settings and its launch file
+        status             installed version, how it runs chi, Service and process state
+    TEXT
+
+    SUBCOMMANDS = %w[install upgrade uninstall status].freeze
+
+    # @param platform [#call] register: → a Desktop::MacOS-like object
+    def initialize(argv, stdout: $stdout, stderr: $stderr, platform: nil, supported: Desktop.supported?)
+      @argv = argv.dup
+      @stdout = stdout
+      @stderr = stderr
+      @platform = platform || ->(register:) { Desktop::MacOS.new(register: register) }
+      @supported = supported
+    end
+
+    # @return [Integer] 0 ok, 1 failed, 2 usage
+    def run
+      sub = @argv.shift
+      if sub.nil? || %w[-h --help help].include?(sub)
+        @stdout.puts(USAGE)
+        return 0
+      end
+      return usage_error("unknown subcommand #{sub}") unless SUBCOMMANDS.include?(sub)
+
+      unless @supported
+        @stderr.puts("chi desktop supports macOS only for now")
+        return 1
+      end
+
+      options = parse(sub) or return 2
+      # --no-register (hidden): no pbs/lsregister/open/pkill, for installs
+      # into temp dirs (HOME=…) that must not touch the real Services.
+      helper = @platform.call(register: !options[:no_register])
+      send(sub.to_sym, helper, options)
+    rescue Desktop::MacOS::Error => e
+      @stderr.puts("chi desktop: #{e.message}")
+      1
+    end
+
+    private
+
+    # @return [Hash, nil] nil after a usage error
+    def parse(sub)
+      flags = { "--no-register" => :no_register }
+      flags.merge!("--force" => :force, "--login" => :login) if sub == "install"
+      @argv.each_with_object({}) do |arg, options|
+        unless flags.key?(arg)
+          usage_error("unknown option #{arg}")
+          return nil
+        end
+        options[flags[arg]] = true
+      end
+    end
+
+    # The warnings come after a done install: a refused or failed one
+    # prints only its error.
+    def install(helper, options)
+      helper.install(force: options[:force] || false, login: options[:login] || false) { |line| @stdout.puts(line) }
+      print_warnings(helper)
+      0
+    end
+
+    def upgrade(helper, _options)
+      helper.upgrade { |line| @stdout.puts(line) }
+      print_warnings(helper)
+      0
+    end
+
+    def uninstall(helper, _options)
+      @stdout.puts(helper.uninstall ? "removed Chi Helper" : "Chi Helper is not installed")
+      0
+    end
+
+    def status(helper, _options)
+      s = helper.status
+      unless s[:installed]
+        @stdout.puts(format_rows([["Chi Helper", "not installed (chi desktop install)"], ["app", s[:app_path]]]))
+        return 0
+      end
+
+      version = if s[:app_version] == s[:chi_version]
+                  "#{s[:app_version]} (matches chi)"
+                else
+                  "#{s[:app_version] || "?"} (chi is #{s[:chi_version]}: chi desktop upgrade)"
+                end
+      launch = s[:launch_argv].empty? ? "(none)" : s[:launch_argv].join(" ")
+      launch += s[:launch_ok] ? " (ok)" : " (missing: chi desktop upgrade)"
+      dirs = s[:baked_dirs].empty? ? "(defaults)" : s[:baked_dirs].map { |name, value| "#{name}=#{value}" }.join(" ")
+      service = s[:service] ? "registered" : "not registered (try chi desktop upgrade, or log out and back in)"
+      running = s[:running] ? "running" : "not running (open -g \"#{s[:app_path]}\")"
+      @stdout.puts(format_rows([["Chi Helper", version], ["app", s[:app_path]], ["runs chi", launch],
+                                ["state dirs", dirs], ["service", service], ["hotkey", hotkey(s[:hotkey])],
+                                ["process", running], ["at login", login(s[:login])]]))
+      0
+    end
+
+    def hotkey(state)
+      return "unknown (the app writes it when it starts)" unless state
+
+      state["registered"] ? "#{state["keys"]} (clipboard)" : "#{state["keys"]} taken by another app"
+    end
+
+    def login(state)
+      case state
+      when "enabled" then "on"
+      when "requiresApproval" then "waiting for approval in System Settings > General > Login Items"
+      when nil then "unknown"
+      else "off (chi desktop install --force --login)"
+      end
+    end
+
+    def format_rows(rows)
+      width = rows.map { |label, _| label.length }.max
+      rows.map { |label, value| "#{label.ljust(width)}  #{value}" }.join("\n")
+    end
+
+    def print_warnings(helper)
+      helper.warnings.each { |warning| @stderr.puts("warning: #{warning}") }
+    end
+
+    def usage_error(message)
+      @stderr.puts("chi desktop: #{message}")
+      @stderr.puts(USAGE)
+      2
+    end
+  end
+end