mendix-ruby-bridge 0.1.1

data/bin/mendix-ruby

@@ -0,0 +1,580 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "fileutils"
+require "optparse"
+require_relative "../lib/mendix_bridge"
+
+command = ARGV.shift
+project_config = MendixBridge::Config.find
+
+case command
+when "--version", "-v", "version"
+  puts MendixBridge::VERSION
+when "serve"
+  options = { bind: "127.0.0.1", port: 4567 }
+  parser = OptionParser.new do |opts|
+    opts.banner = "Usage: mendix-ruby serve [IMPORTED_DIR] [options]"
+    opts.on("--bind ADDRESS", "Bind address (default: 127.0.0.1)") do |address|
+      options[:bind] = address
+    end
+    opts.on("-p", "--port PORT", Integer, "HTTP port (default: 4567)") do |port|
+      options[:port] = port
+    end
+  end
+  parser.parse!
+  inventory_dir = File.expand_path(
+    ARGV.shift || project_config&.inventory || "."
+  )
+  unless ARGV.empty?
+    warn parser
+    exit 1
+  end
+
+  bridge_dir = File.expand_path("..", __dir__)
+  server = MendixBridge::BackendServer.new(
+    inventory_dir:,
+    web_root: File.join(bridge_dir, "web", "dist"),
+    mxcli: File.join(bridge_dir, "bin", "mxcli"),
+    bind: options.fetch(:bind),
+    port: options.fetch(:port)
+  )
+  %w[INT TERM].each do |signal|
+    Signal.trap(signal) { server.shutdown }
+  end
+  puts "Mendix Ruby Bridge: http://#{options.fetch(:bind)}:#{server.port}"
+  puts "Inventory: #{inventory_dir}"
+  server.start
+when "setup"
+  setup = File.expand_path("setup-tools", __dir__)
+  abort "Tool installer is missing: #{setup}" unless File.executable?(setup)
+  exit(system(setup) ? 0 : 1)
+when "configure"
+  options = { force: false, path: MendixBridge::Config::FILE_NAME }
+  parser = OptionParser.new do |opts|
+    opts.banner =
+      "Usage: mendix-ruby configure --project APP.mpr --inventory DIR --model APP.rb"
+    opts.on("-p", "--project FILE", "Mendix .mpr file") do |file|
+      options[:project] = File.expand_path(file)
+    end
+    opts.on("-i", "--inventory DIR", "Ruby inventory directory") do |dir|
+      options[:inventory] = File.expand_path(dir)
+    end
+    opts.on("-m", "--model FILE", "Ruby model file") do |file|
+      options[:model] = File.expand_path(file)
+    end
+    opts.on("-o", "--output FILE", "Configuration file path") do |file|
+      options[:path] = File.expand_path(file)
+    end
+    opts.on("--force", "Replace an existing configuration") do
+      options[:force] = true
+    end
+  end
+  parser.parse!
+  unless options[:project] && options[:inventory] && options[:model] && ARGV.empty?
+    warn parser
+    exit 1
+  end
+
+  config = MendixBridge::Config.write(
+    options.fetch(:path),
+    project: options.fetch(:project),
+    inventory: options.fetch(:inventory),
+    model: options.fetch(:model),
+    force: options.fetch(:force)
+  )
+  puts "Wrote #{config.path}"
+  puts JSON.pretty_generate(config.to_h)
+when "deps"
+  options = { direction: "both", transitive: false, json: false }
+  parser = OptionParser.new do |opts|
+    opts.banner = "Usage: mendix-ruby deps ELEMENT [IMPORTED_DIR] [options]"
+    opts.on(
+      "-d",
+      "--direction DIRECTION",
+      %w[both dependencies dependents callers callees impact],
+      "both, dependencies, dependents, callers, callees, or impact"
+    ) { |direction| options[:direction] = direction }
+    opts.on("--transitive", "Traverse the complete dependency graph") do
+      options[:transitive] = true
+    end
+    opts.on("--json", "Print machine-readable JSON") { options[:json] = true }
+  end
+  parser.parse!
+  name = ARGV.shift
+  imported_dir = File.expand_path(
+    ARGV.shift || project_config&.inventory || "."
+  )
+  unless name && ARGV.empty?
+    warn parser
+    exit 1
+  end
+
+  snapshot_file = File.join(imported_dir, "inventory", "project-tree.json")
+  details_file = File.join(imported_dir, "inventory", "element-details.json")
+  dependencies_file = File.join(imported_dir, "inventory", "dependencies.json")
+  abort "Not an imported Mendix Ruby project: #{imported_dir}" unless
+    File.file?(snapshot_file)
+
+  inventory = MendixBridge::Inventory.load(
+    snapshot_file,
+    details_path: details_file
+  )
+  index = if File.file?(dependencies_file)
+    MendixBridge::DependencyIndex.load(dependencies_file, inventory:)
+  else
+    MendixBridge::DependencyIndex.new(inventory)
+  end
+  result = case options.fetch(:direction)
+  when "dependencies"
+    { "dependencies" => index.dependencies(name, transitive: options[:transitive]) }
+  when "dependents"
+    { "dependents" => index.dependents(name, transitive: options[:transitive]) }
+  when "callers"
+    { "callers" => index.callers(name, transitive: options[:transitive]) }
+  when "callees"
+    { "callees" => index.callees(name, transitive: options[:transitive]) }
+  when "impact"
+    { "impact" => index.impact(name) }
+  else
+    {
+      "dependencies" => index.dependencies(name, transitive: options[:transitive]),
+      "dependents" => index.dependents(name, transitive: options[:transitive])
+    }
+  end
+  result.transform_values! { |edges| edges.map(&:to_h) }
+
+  if options[:json]
+    puts JSON.pretty_generate({ "element" => name }.merge(result))
+  else
+    puts "Dependencies for #{name}:"
+    result.each do |direction, edges|
+      puts "#{direction.capitalize} (#{edges.length}):"
+      edges.each do |edge|
+        puts "  #{edge.fetch(:from)} -> #{edge.fetch(:to)} " \
+          "[#{edge.fetch(:kind)} via #{edge.fetch(:path)}]"
+      end
+    end
+  end
+when "migrate"
+  options = { studio_closed: false, dry_run: false }
+  parser = OptionParser.new do |opts|
+    opts.banner =
+      "Usage: mendix-ruby migrate MIGRATION.rb --project APP.mpr [options]"
+    opts.on("-p", "--project FILE", "Target Mendix .mpr file") do |file|
+      options[:project] = File.expand_path(file)
+    end
+    opts.on("--confirm NAME", "Confirm the exact migration name") do |name|
+      options[:confirmation] = name
+    end
+    opts.on("--studio-closed", "Confirm that Studio Pro is closed") do
+      options[:studio_closed] = true
+    end
+    opts.on("--dry-run", "Print operations and MDL without changing the project") do
+      options[:dry_run] = true
+    end
+  end
+  parser.parse!
+  migration_file = ARGV.shift
+  options[:project] ||= project_config&.project
+  unless migration_file && options[:project] && ARGV.empty?
+    warn parser
+    exit 1
+  end
+
+  plan = MendixBridge.load_migration(File.expand_path(migration_file))
+  if options[:dry_run]
+    puts JSON.pretty_generate(plan.to_h)
+    mdl = MendixBridge::Migration::Generator.mdl(plan)
+    puts "\nMDL:\n#{mdl}" unless mdl.empty?
+    renames = MendixBridge::Migration::Generator.rename_operations(plan)
+    unless renames.empty?
+      puts "\nRenames:"
+      renames.each do |operation|
+        puts "  #{operation.type} #{operation.name} -> #{operation.options.fetch('to')}"
+      end
+    end
+    exit
+  end
+
+  unless options[:confirmation]
+    abort "Destructive migration requires --confirm #{plan.name}"
+  end
+  bridge_dir = File.expand_path("..", __dir__)
+  executor = MendixBridge::MigrationExecutor.new(
+    mxcli: File.join(bridge_dir, "bin", "mxcli")
+  )
+  result = executor.apply(
+    plan,
+    project_file: options.fetch(:project),
+    confirmation: options.fetch(:confirmation),
+    studio_closed: options.fetch(:studio_closed)
+  )
+  puts "Migration #{plan.name} completed (#{result.operations} operations)."
+  puts "Rollback backup: #{result.backup_dir}"
+when "rollback"
+  options = { studio_closed: false }
+  parser = OptionParser.new do |opts|
+    opts.banner =
+      "Usage: mendix-ruby rollback BACKUP_DIR --project APP.mpr [options]"
+    opts.on("-p", "--project FILE", "Target Mendix .mpr file") do |file|
+      options[:project] = File.expand_path(file)
+    end
+    opts.on("--confirm BACKUP_ID", "Confirm the exact backup directory name") do |name|
+      options[:confirmation] = name
+    end
+    opts.on("--studio-closed", "Confirm that Studio Pro is closed") do
+      options[:studio_closed] = true
+    end
+  end
+  parser.parse!
+  backup_dir = ARGV.shift
+  options[:project] ||= project_config&.project
+  unless backup_dir && options[:project] && options[:confirmation] && ARGV.empty?
+    warn parser
+    exit 1
+  end
+
+  bridge_dir = File.expand_path("..", __dir__)
+  executor = MendixBridge::MigrationExecutor.new(
+    mxcli: File.join(bridge_dir, "bin", "mxcli")
+  )
+  executor.restore(
+    backup_dir,
+    project_file: options.fetch(:project),
+    confirmation: options.fetch(:confirmation),
+    studio_closed: options.fetch(:studio_closed)
+  )
+  puts "Backup restored successfully: #{backup_dir}"
+when "new"
+  options = { git: true }
+  parser = OptionParser.new do |opts|
+    opts.banner = "Usage: mendix-ruby new APP.rb --output DIR --version VERSION"
+    opts.on("-o", "--output DIR", "Create the Mendix project in DIR") do |dir|
+      options[:output] = File.expand_path(dir)
+    end
+    opts.on("--version VERSION", "Mendix version, for example 11.6.8") do |version|
+      options[:version] = version
+    end
+    opts.on("--no-git", "Do not initialize Git or create the initial commit") do
+      options[:git] = false
+    end
+  end
+  parser.parse!
+  dsl_file = ARGV.shift
+  unless dsl_file && options[:output] && options[:version] && ARGV.empty?
+    warn parser
+    exit 1
+  end
+
+  dsl_file = File.expand_path(dsl_file)
+  model = MendixBridge.load_file(dsl_file)
+  bridge_dir = File.expand_path("..", __dir__)
+  creator = MendixBridge::ProjectCreator.new(
+    mxcli: File.join(bridge_dir, "bin", "mxcli")
+  )
+  result = creator.create(
+    model,
+    source_file: dsl_file,
+    output_dir: options.fetch(:output),
+    version: options.fetch(:version),
+    git: options.fetch(:git)
+  )
+  puts "Created Mendix project: #{result.project_file}"
+  puts "Ruby model: #{result.model_file}"
+  puts "Git initialized with Initial Setup commit." if result.git_initialized
+when "compile"
+  options = { pretty: true, format: :json }
+  parser = OptionParser.new do |opts|
+    opts.banner = "Usage: mendix-ruby compile APP.rb [options]"
+
+    opts.on("-o", "--output FILE", "Write output to FILE") do |file|
+      options[:output] = file
+    end
+
+    opts.on("--compact", "Generate compact JSON") do
+      options[:pretty] = false
+    end
+
+    opts.on("-f", "--format FORMAT", %w[json mdl], "Output format: json or mdl") do |format|
+      options[:format] = format.to_sym
+    end
+  end
+
+  parser.parse!
+  input = ARGV.shift || project_config&.model
+  unless input && ARGV.empty?
+    warn parser
+    exit 1
+  end
+
+  model = MendixBridge.load_file(File.expand_path(input))
+  output = MendixBridge.compile(model, format: options[:format], pretty: options[:pretty])
+  output << "\n" unless output.end_with?("\n")
+
+  if options[:output]
+    File.write(options[:output], output)
+  else
+    print output
+  end
+when "import"
+  options = { force: false }
+  parser = OptionParser.new do |opts|
+    opts.banner = "Usage: mendix-ruby import APP.mpr --output DIR"
+
+    opts.on("-o", "--output DIR", "Create the Ruby inventory in DIR") do |dir|
+      options[:output] = File.expand_path(dir)
+    end
+
+    opts.on("--force", "Refresh an existing imported directory") do
+      options[:force] = true
+    end
+  end
+
+  parser.parse!
+  project_file = ARGV.shift || project_config&.project
+  options[:output] ||= project_config&.inventory
+  unless project_file && options[:output] && ARGV.empty?
+    warn parser
+    exit 1
+  end
+
+  output_dir = options.fetch(:output)
+  if Dir.exist?(output_dir) && !options[:force] && !Dir.empty?(output_dir)
+    abort "Output directory is not empty; use --force to refresh it: #{output_dir}"
+  end
+
+  bridge_dir = File.expand_path("..", __dir__)
+  importer = MendixBridge::Importer.new(mxcli: File.join(bridge_dir, "bin", "mxcli"))
+  inventory, warnings = importer.import(project_file, output_dir)
+
+  puts "Imported #{inventory.elements.length} elements into #{output_dir}"
+  puts "Types: #{inventory.types.map { |type, count| "#{type}=#{count}" }.join(', ')}"
+  unless warnings.empty?
+    warn "Could not describe #{warnings.length} elements:"
+    warnings.each { |warning| warn "  #{warning}" }
+  end
+when "refresh"
+  parser = OptionParser.new do |opts|
+    opts.banner = "Usage: mendix-ruby refresh [IMPORTED_DIR]"
+  end
+  parser.parse!
+  output_dir = File.expand_path(
+    ARGV.shift || project_config&.inventory || "."
+  )
+  unless ARGV.empty?
+    warn parser
+    exit 1
+  end
+
+  metadata_file = File.join(output_dir, "mendix-project.json")
+  snapshot_file = File.join(output_dir, "inventory", "project-tree.json")
+  abort "Not an imported Mendix Ruby project: #{output_dir}" unless
+    File.file?(metadata_file) && File.file?(snapshot_file)
+
+  metadata = JSON.parse(File.read(metadata_file))
+  project_file = metadata.fetch("source_project")
+  old_inventory = MendixBridge::Inventory.load(snapshot_file)
+  bridge_dir = File.expand_path("..", __dir__)
+  importer = MendixBridge::Importer.new(mxcli: File.join(bridge_dir, "bin", "mxcli"))
+  new_inventory, warnings = importer.import(project_file, output_dir)
+  changes = MendixBridge::SnapshotDiff.compare(old_inventory, new_inventory)
+
+  changes_dir = File.join(output_dir, "changes")
+  FileUtils.mkdir_p(changes_dir)
+  File.write(
+    File.join(changes_dir, "latest.json"),
+    "#{JSON.pretty_generate(changes.to_h)}\n"
+  )
+
+  if changes.empty?
+    puts "No Mendix project changes detected."
+  else
+    puts "Refresh completed:"
+    puts "  added: #{changes.added.length}"
+    puts "  modified: #{changes.modified.length}"
+    puts "  removed: #{changes.removed.length}"
+    changes.to_h.each do |kind, elements|
+      elements.each { |element| puts "  #{kind.to_s.upcase} #{element.fetch('id')}" }
+    end
+  end
+  unless warnings.empty?
+    warn "Could not describe #{warnings.length} elements; see warnings below."
+    warnings.each { |warning| warn "  #{warning}" }
+  end
+when "search"
+  options = { json: false }
+  parser = OptionParser.new do |opts|
+    opts.banner = "Usage: mendix-ruby search QUERY [IMPORTED_DIR] [options]"
+    opts.on("-t", "--type TYPE", "Filter by element type") { |type| options[:type] = type }
+    opts.on("--json", "Print machine-readable JSON") { options[:json] = true }
+  end
+  parser.parse!
+  query = ARGV.shift
+  imported_dir = File.expand_path(
+    ARGV.shift || project_config&.inventory || "."
+  )
+  unless query && ARGV.empty?
+    warn parser
+    exit 1
+  end
+
+  snapshot_file = File.join(imported_dir, "inventory", "project-tree.json")
+  abort "Not an imported Mendix Ruby project: #{imported_dir}" unless File.file?(snapshot_file)
+
+  inventory = MendixBridge::Inventory.load(snapshot_file)
+  results = inventory.search(query)
+  results = results.select { |element| element.type == options[:type] } if options[:type]
+
+  if options[:json]
+    puts JSON.pretty_generate(results.map { |element| MendixBridge::Presenter.search_result(element) })
+  elsif results.empty?
+    puts "No elements found."
+  else
+    results.each do |element|
+      item = MendixBridge::Presenter.search_result(element)
+      puts "#{item.fetch('type')}\t#{item.fetch('name')}\t#{item.fetch('path')}"
+    end
+  end
+when "inspect"
+  options = { format: :text }
+  parser = OptionParser.new do |opts|
+    opts.banner = "Usage: mendix-ruby inspect ELEMENT [IMPORTED_DIR] [options]"
+    opts.on("-t", "--type TYPE", "Disambiguate by element type") { |type| options[:type] = type }
+    opts.on("--json", "Print the complete element as JSON") { options[:format] = :json }
+    opts.on("--mdl", "Print the original MDL") { options[:format] = :mdl }
+  end
+  parser.parse!
+  name = ARGV.shift
+  imported_dir = File.expand_path(
+    ARGV.shift || project_config&.inventory || "."
+  )
+  unless name && ARGV.empty?
+    warn parser
+    exit 1
+  end
+
+  snapshot_file = File.join(imported_dir, "inventory", "project-tree.json")
+  abort "Not an imported Mendix Ruby project: #{imported_dir}" unless File.file?(snapshot_file)
+
+  inventory = MendixBridge::Inventory.load(snapshot_file)
+  matches = inventory.elements.select { |candidate| candidate.qualified_name == name }
+  matches = matches.select { |candidate| candidate.type == options[:type] } if options[:type]
+  abort "Element not found: #{name}" if matches.empty?
+  if matches.length > 1
+    types = matches.map(&:type).uniq.sort.join(", ")
+    abort "Ambiguous element #{name}; choose one with --type (#{types})"
+  end
+  element = matches.first
+
+  case options[:format]
+  when :json
+    puts JSON.pretty_generate(element.to_h)
+  when :mdl
+    mdl = element.details&.fetch("mdl", nil)
+    abort "Original MDL is not available for #{name}" unless mdl
+    puts mdl
+  else
+    puts MendixBridge::Presenter.text(element)
+  end
+when "plan"
+  options = { json: false }
+  parser = OptionParser.new do |opts|
+    opts.banner = "Usage: mendix-ruby plan APP.rb --inventory IMPORTED_DIR [--json]"
+    opts.on("-i", "--inventory DIR", "Imported Mendix Ruby project") do |dir|
+      options[:inventory] = File.expand_path(dir)
+    end
+    opts.on("--json", "Print machine-readable JSON") { options[:json] = true }
+  end
+  parser.parse!
+  dsl_file = ARGV.shift || project_config&.model
+  options[:inventory] ||= project_config&.inventory
+  unless dsl_file && options[:inventory] && ARGV.empty?
+    warn parser
+    exit 1
+  end
+
+  snapshot_file = File.join(options.fetch(:inventory), "inventory", "project-tree.json")
+  abort "Not an imported Mendix Ruby project: #{options.fetch(:inventory)}" unless
+    File.file?(snapshot_file)
+
+  model = MendixBridge.load_file(File.expand_path(dsl_file))
+  inventory = MendixBridge::Inventory.load(snapshot_file)
+  plan = MendixBridge::ChangePlanner.plan(model, inventory)
+
+  if options[:json]
+    puts JSON.pretty_generate(plan.to_h)
+  else
+    plan.operations.each do |operation|
+      puts "#{operation.action.upcase}\t#{operation.type}\t#{operation.name}"
+      puts "  Reason: #{operation.reason}" if operation.reason
+      if operation.changes
+        JSON.pretty_generate(operation.changes).each_line { |line| puts "  #{line}" }
+      end
+    end
+    puts "Preserved undeclared managed elements: #{plan.preserved_undeclared}"
+    puts "Summary: #{plan.counts.map { |action, count| "#{action}=#{count}" }.join(', ')}"
+  end
+
+  exit 2 if plan.blocked?
+when "view"
+  options = {}
+  parser = OptionParser.new do |opts|
+    opts.banner = "Usage: mendix-ruby view [IMPORTED_DIR] [-o OUTPUT.html]"
+
+    opts.on("-o", "--output FILE", "Write the viewer to FILE") do |file|
+      options[:output] = File.expand_path(file)
+    end
+  end
+
+  parser.parse!
+  imported_dir = File.expand_path(
+    ARGV.shift || project_config&.inventory || "."
+  )
+  unless ARGV.empty?
+    warn parser
+    exit 1
+  end
+
+  snapshot_file = File.join(imported_dir, "inventory", "project-tree.json")
+  abort "Not an imported Mendix Ruby project: #{imported_dir}" unless File.file?(snapshot_file)
+
+  output = MendixBridge::HtmlViewer.write(imported_dir, options[:output])
+  puts "Wrote inventory viewer to #{output}"
+  puts "Open it in a browser: file://#{output}"
+when "desktop"
+  parser = OptionParser.new do |opts|
+    opts.banner = "Usage: mendix-ruby desktop [IMPORTED_DIR]"
+  end
+  parser.parse!
+  inventory_dir = File.expand_path(
+    ARGV.shift || project_config&.inventory || "."
+  )
+  unless ARGV.empty?
+    warn parser
+    exit 1
+  end
+
+  bridge_dir = File.expand_path("..", __dir__)
+  MendixBridge::DesktopApp.new(inventory_dir:, bridge_dir:).run
+else
+  warn <<~USAGE
+    Usage:
+      mendix-ruby setup
+      mendix-ruby serve [IMPORTED_DIR] [--bind ADDRESS] [--port PORT]
+      mendix-ruby desktop [IMPORTED_DIR]
+      mendix-ruby configure --project APP.mpr --inventory DIR --model APP.rb
+      mendix-ruby deps ELEMENT [IMPORTED_DIR] [options]
+      mendix-ruby migrate MIGRATION.rb --project APP.mpr [--dry-run]
+      mendix-ruby rollback BACKUP_DIR --project APP.mpr
+      mendix-ruby new APP.rb --output DIR --version VERSION [--no-git]
+      mendix-ruby compile APP.rb [options]
+      mendix-ruby import APP.mpr --output DIR [--force]
+      mendix-ruby refresh [IMPORTED_DIR]
+      mendix-ruby search QUERY [IMPORTED_DIR] [--type TYPE] [--json]
+      mendix-ruby inspect ELEMENT [IMPORTED_DIR] [--type TYPE] [--json|--mdl]
+      mendix-ruby plan APP.rb --inventory IMPORTED_DIR [--json]
+      mendix-ruby view [IMPORTED_DIR] [-o OUTPUT.html]
+  USAGE
+  exit 1
+end

data/bin/mxcli

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+project_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+version="$(tr -d '[:space:]' < "$project_dir/.mxcli-version")"
+if [[ -n "${MENDIX_RUBY_TOOLS_DIR:-}" ]]; then
+  tools_dir="$MENDIX_RUBY_TOOLS_DIR"
+elif [[ -d "$project_dir/.git" ]]; then
+  tools_dir="$project_dir/.tools"
+else
+  tools_dir="${XDG_DATA_HOME:-$HOME/.local/share}/mendix-ruby-bridge/tools"
+fi
+executable="$tools_dir/mxcli/$version/mxcli"
+
+if [[ ! -x "$executable" ]]; then
+  echo "mxcli $version is not installed. Run: mendix-ruby setup" >&2
+  exit 1
+fi
+
+exec "$executable" "$@"

data/bin/setup-tools

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+project_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+version="$(tr -d '[:space:]' < "$project_dir/.mxcli-version")"
+if [[ -n "${MENDIX_RUBY_TOOLS_DIR:-}" ]]; then
+  tools_dir="$MENDIX_RUBY_TOOLS_DIR"
+elif [[ -d "$project_dir/.git" ]]; then
+  tools_dir="$project_dir/.tools"
+else
+  tools_dir="${XDG_DATA_HOME:-$HOME/.local/share}/mendix-ruby-bridge/tools"
+fi
+install_dir="$tools_dir/mxcli/$version"
+executable="$install_dir/mxcli"
+download_url="https://github.com/mendixlabs/mxcli/releases/download/v${version}/mxcli-linux-amd64"
+
+if [[ -x "$executable" ]]; then
+  echo "mxcli $version is already installed"
+  exit 0
+fi
+
+mkdir -p "$install_dir"
+curl --fail --location "$download_url" --output "$executable"
+chmod +x "$executable"
+"$executable" --version