setup.sh

#!/usr/bin/env bash
#
# mcp-medium-reader — one-shot setup script.
#
# Installs the ZMediumToMarkdown Ruby gem (>= 3.5.2), the
# mcp-medium-reader npm package, and runs `mcp-medium-reader init`
# to bind the Ruby runtime and register with the four supported MCP
# clients (Claude Desktop, Claude Code, OpenAI Codex, Gemini CLI).
# It finishes with `doctor` so you see at a glance that everything is
# wired up.
#
# Usage:
#   bash setup.sh
#   bash <(curl -fsSL https://raw.githubusercontent.com/ZhgChgLi/mcp-medium-reader/main/setup.sh)
#
# Flags:
#   --no-init   Install dependencies only; skip the guided init.
#   --no-gem    Skip the ZMediumToMarkdown gem install.
#   --no-npm    Skip the mcp-medium-reader npm install.
#   --no-auth   Skip the interactive `ZMediumToMarkdown --auth` step.
#   --yes       Assume yes to every install prompt (Homebrew, etc.).
#   --help      Show this help.
#
# Platforms: macOS, Linux, and Windows via Git Bash / WSL. Native
# Windows users without bash can install components manually:
#   gem install ZMediumToMarkdown
#   npm install -g mcp-medium-reader
#   mcp-medium-reader init
#
# After install, if you want paywalled access, run the gem standalone
# once to populate its cookie cache (the gem opens Chrome for sign-in
# and stores cookies at ~/.zmediumtomarkdown — mcp-medium-reader does
# not manage cookies):
#   ZMediumToMarkdown --auth
#
set -euo pipefail

NO_INIT=0
NO_GEM=0
NO_NPM=0
NO_AUTH=0
ASSUME_YES=0
mcp_cmd=""
SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"

for arg in "$@"; do
  case "$arg" in
    --no-init) NO_INIT=1 ;;
    --no-gem)  NO_GEM=1 ;;
    --no-npm)  NO_NPM=1 ;;
    --no-auth) NO_AUTH=1 ;;
    --yes|-y)  ASSUME_YES=1 ;;
    --help|-h)
      sed -n '3,34p' "$0" | sed 's/^# \{0,1\}//'
      exit 0
      ;;
    *)
      printf 'Unknown flag: %s\n' "$arg" >&2
      exit 1
      ;;
  esac
done

if [ -t 1 ]; then
  C_RED=$'\033[31m'
  C_GREEN=$'\033[32m'
  C_YELLOW=$'\033[33m'
  C_BLUE=$'\033[34m'
  C_BOLD=$'\033[1m'
  C_RESET=$'\033[0m'
else
  C_RED=''; C_GREEN=''; C_YELLOW=''; C_BLUE=''; C_BOLD=''; C_RESET=''
fi

step() { printf '%s%s==>%s %s\n' "$C_BOLD" "$C_BLUE" "$C_RESET" "$*"; }
ok()   { printf '%s\xe2\x9c\x93%s %s\n' "$C_GREEN" "$C_RESET" "$*"; }
warn() { printf '%s\xe2\x9a\xa0%s %s\n' "$C_YELLOW" "$C_RESET" "$*"; }
fail() { printf '%s\xe2\x9c\x97%s %s\n' "$C_RED" "$C_RESET" "$*" >&2; exit 1; }

confirm() {
  local prompt="$1"
  if [ "$ASSUME_YES" -eq 1 ]; then return 0; fi
  if [ ! -t 0 ]; then return 1; fi
  local ans
  printf '   %s [y/N]: ' "$prompt"
  read -r ans
  case "${ans:-N}" in
    [yY]*) return 0 ;;
    *)     return 1 ;;
  esac
}

# Detect platform.
case "$(uname -s 2>/dev/null || echo unknown)" in
  Darwin*)               platform="macOS";       platform_kind=mac ;;
  Linux*)                platform="Linux";       platform_kind=linux ;;
  MINGW*|MSYS*|CYGWIN*)  platform="Windows (Git Bash)"; platform_kind=win ;;
  *)                     platform="$(uname -s 2>/dev/null || echo unknown)"; platform_kind=unknown ;;
esac

step "mcp-medium-reader setup"
printf '   Platform: %s\n' "$platform"
printf '   Date:     %s\n' "$(date '+%Y-%m-%d %H:%M:%S')"
echo

# -------- helpers --------

read_ruby_version() {
  ruby -e 'print RUBY_VERSION' 2>/dev/null
}

is_ruby_ok() {
  local v_major v_minor
  v_major=$(printf '%s' "$1" | awk -F. '{print $1}')
  v_minor=$(printf '%s' "$1" | awk -F. '{print $2}')
  [ "${v_major:-0}" -gt 3 ] && return 0
  [ "${v_major:-0}" -eq 3 ] && [ "${v_minor:-0}" -ge 2 ] && return 0
  return 1
}

adopt_brew_path() {
  local brew_bin
  for brew_bin in /opt/homebrew/bin /usr/local/bin; do
    if [ -x "$brew_bin/brew" ]; then
      case ":$PATH:" in
        *:"$brew_bin":*) ;;
        *) export PATH="$brew_bin:$PATH" ;;
      esac
    fi
  done
}

adopt_brew_ruby_path() {
  if ! command -v brew >/dev/null 2>&1; then return; fi
  local ruby_prefix
  ruby_prefix=$(brew --prefix ruby 2>/dev/null || true)
  if [ -n "$ruby_prefix" ] && [ -d "$ruby_prefix/bin" ]; then
    case ":$PATH:" in
      *:"$ruby_prefix/bin":*) ;;
      *) export PATH="$ruby_prefix/bin:$PATH" ;;
    esac
    local gem_user_bin
    gem_user_bin=$(ruby -e 'require "rubygems"; print Gem.user_dir + "/bin"' 2>/dev/null || true)
    if [ -n "$gem_user_bin" ] && [ -d "$gem_user_bin" ]; then
      case ":$PATH:" in
        *:"$gem_user_bin":*) ;;
        *) export PATH="$gem_user_bin:$PATH" ;;
      esac
    fi
  fi
}

resolve_mcp_medium_reader() {
  if command -v mcp-medium-reader >/dev/null 2>&1; then
    command -v mcp-medium-reader
    return 0
  fi
  local npm_prefix npm_root candidate
  npm_prefix=$(npm config get prefix 2>/dev/null || true)
  case "$platform_kind" in
    win)
      candidate="${npm_prefix%/}/mcp-medium-reader"
      if [ -n "$npm_prefix" ] && [ -x "$candidate" ]; then
        printf '%s\n' "$candidate"; return 0
      fi
      candidate="${npm_prefix%/}/mcp-medium-reader.cmd"
      if [ -n "$npm_prefix" ] && [ -f "$candidate" ]; then
        printf '%s\n' "$candidate"; return 0
      fi
      ;;
    *)
      candidate="${npm_prefix%/}/bin/mcp-medium-reader"
      if [ -n "$npm_prefix" ] && [ -x "$candidate" ]; then
        printf '%s\n' "$candidate"; return 0
      fi
      ;;
  esac
  npm_root=$(npm root -g 2>/dev/null || true)
  candidate="${npm_root%/}/mcp-medium-reader/bin/mcp-medium-reader.js"
  if [ -f "$candidate" ]; then
    printf 'node %s\n' "$candidate"
    return 0
  fi
  return 1
}

install_mcp_medium_reader_from_dir() {
  local source_dir tarball
  source_dir="$1"
  step "Packing mcp-medium-reader from source"
  printf '   source dir: %s\n' "$source_dir"
  tarball=$(cd "$source_dir" && npm pack | tail -n 1)
  [ -n "$tarball" ] || fail "npm pack did not produce a tarball."
  printf '   tarball: %s/%s\n' "$source_dir" "$tarball"
  npm uninstall -g mcp-medium-reader >/dev/null 2>&1 || true
  npm install -g "$source_dir/$tarball"
  rm -f "$source_dir/$tarball"
}

# -------- Ruby --------
step "Checking Ruby (need >= 3.2)"
case "$platform_kind" in
  mac) adopt_brew_path; adopt_brew_ruby_path ;;
esac

ruby_version=""
if command -v ruby >/dev/null 2>&1; then
  ruby_version=$(read_ruby_version)
fi

if [ -z "$ruby_version" ] || ! is_ruby_ok "$ruby_version"; then
  if [ -n "$ruby_version" ]; then
    warn "Ruby $ruby_version is below 3.2"
  else
    warn "ruby not found"
  fi
  case "$platform_kind" in
    mac)
      if command -v brew >/dev/null 2>&1; then
        if confirm "Install Ruby via \`brew install ruby\`?"; then
          brew install ruby
          adopt_brew_ruby_path
          ruby_version=$(read_ruby_version)
        fi
      else
        cat <<'HINT'
Install Homebrew first (https://brew.sh), or install Ruby some other way:
  /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
  brew install ruby
Then re-run this script.
HINT
      fi
      ;;
    linux)
      cat <<'HINT'
Install Ruby 3.2+ first:
  Debian / Ubuntu:  sudo apt install ruby ruby-dev   (then verify version; if too old, use rbenv / asdf / a backports PPA)
  Fedora / RHEL:    sudo dnf install ruby ruby-devel
  Arch:             sudo pacman -S ruby
  rbenv users:      rbenv install 3.3.5 && rbenv global 3.3.5
HINT
      ;;
    win)
      cat <<'HINT'
Install Ruby 3.2+ via RubyInstaller-with-DevKit:
  https://rubyinstaller.org/
HINT
      ;;
    *)
      cat <<'HINT'
Install Ruby 3.2+ for your platform, then re-run this script.
HINT
      ;;
  esac
  if [ -z "$ruby_version" ] || ! is_ruby_ok "$ruby_version"; then
    fail "Ruby >= 3.2 is required."
  fi
fi
ok "ruby $ruby_version"

# -------- Node --------
echo
step "Checking Node.js (need >= 18)"
node_version=""
if command -v node >/dev/null 2>&1; then
  node_version=$(node --version)
fi

if [ -z "$node_version" ]; then
  warn "node not found"
  case "$platform_kind" in
    mac)
      if command -v brew >/dev/null 2>&1; then
        if confirm "Install Node via \`brew install node\`?"; then
          brew install node
          adopt_brew_path
          node_version=$(node --version 2>/dev/null || true)
        fi
      fi
      ;;
    linux)
      cat <<'HINT'
Install Node.js 18+ first:
  NodeSource:  curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash - && sudo apt install -y nodejs
  Fedora:      sudo dnf install -y nodejs
  Arch:        sudo pacman -S nodejs npm
  fnm / nvm:   https://github.com/Schniz/fnm  /  https://github.com/nvm-sh/nvm
HINT
      ;;
    win)
      cat <<'HINT'
Install Node.js 18+ from https://nodejs.org/, or via fnm / nvm-windows.
HINT
      ;;
    *)
      echo "Install Node 18+ for your platform and re-run."
      ;;
  esac
fi

if [ -z "$node_version" ]; then
  fail "Node.js >= 18 is required."
fi
node_major=$(printf '%s' "${node_version#v}" | awk -F. '{print $1}')
if [ "${node_major:-0}" -lt 18 ]; then
  fail "Node $node_version is too old. Upgrade and re-run."
fi
ok "node $node_version"

if ! command -v npm >/dev/null 2>&1; then
  fail "npm not found on PATH (Node is installed but npm isn't). Reinstall Node with npm bundled."
fi

# -------- ZMediumToMarkdown gem --------
echo
if [ "$NO_GEM" -eq 1 ]; then
  step "Skipping gem install (--no-gem)"
else
  step "Installing ZMediumToMarkdown gem"
  if gem list -i ZMediumToMarkdown >/dev/null 2>&1; then
    current=$(gem list ZMediumToMarkdown 2>/dev/null | sed -n 's/^ZMediumToMarkdown (\([^,)]*\).*/\1/p' | head -n 1)
    printf '   existing version: %s\n' "${current:-unknown}"
    printf '   upgrading to latest available...\n'
    gem update ZMediumToMarkdown || gem install ZMediumToMarkdown
  else
    gem install ZMediumToMarkdown
  fi
  ok "gem ZMediumToMarkdown ready"
  if ! command -v ZMediumToMarkdown >/dev/null 2>&1; then
    warn "\`ZMediumToMarkdown\` is installed but not on PATH."
    cat <<'HINT'
The gem bin directory might not be on PATH. Find it with:
  ruby -e 'require "rubygems"; puts Gem.user_dir + "/bin"; puts Gem.dir + "/bin"'
Add the appropriate directory to PATH in your shell rc, then re-open the shell.
\`mcp-medium-reader init\` will still try to bind a stable runtime regardless.
HINT
  fi
fi

# -------- mcp-medium-reader npm --------
echo
if [ "$NO_NPM" -eq 1 ]; then
  step "Skipping npm install (--no-npm)"
else
  if [ -f "$SCRIPT_DIR/package.json" ] && grep -q '"name":[[:space:]]*"mcp-medium-reader"' "$SCRIPT_DIR/package.json"; then
    step "Installing mcp-medium-reader (from local checkout)"
    install_mcp_medium_reader_from_dir "$SCRIPT_DIR"
  else
    step "Installing mcp-medium-reader (from GitHub)"
    pkg_spec="github:ZhgChgLi/mcp-medium-reader"
    printf '   spec: %s\n' "$pkg_spec"
    npm uninstall -g mcp-medium-reader >/dev/null 2>&1 || true
    npm install -g "$pkg_spec"
  fi
  ok "npm mcp-medium-reader ready"
  mcp_cmd="$(resolve_mcp_medium_reader || true)"
  if [ -z "$mcp_cmd" ]; then
    warn "\`mcp-medium-reader\` installed but not resolvable from PATH or npm globals."
    cat <<'HINT'
Run `npm config get prefix` and add `<prefix>/bin` (POSIX) or `<prefix>` (Windows) to PATH, then re-run.
HINT
    fail "mcp-medium-reader could not be located; cannot run init."
  fi
fi

# -------- init --------
echo
if [ "$NO_INIT" -eq 1 ]; then
  step "Skipping init (--no-init)"
  echo "   Run 'mcp-medium-reader init' when ready, then 'mcp-medium-reader doctor' to verify."
  exit 0
fi

if [ ! -t 0 ]; then
  warn "stdin is not a TTY (looks like a curl-pipe-bash run); skipping interactive init."
  cat <<'HINT'
Dependencies are installed. Open a terminal and run:
  mcp-medium-reader init
  mcp-medium-reader doctor
HINT
  exit 0
fi

if [ -z "${mcp_cmd:-}" ]; then
  mcp_cmd="$(resolve_mcp_medium_reader || true)"
fi
[ -n "${mcp_cmd:-}" ] || fail "mcp-medium-reader could not be resolved for init."

step "Running mcp-medium-reader init"
echo
${mcp_cmd} init

echo
step "Running mcp-medium-reader doctor"
echo
${mcp_cmd} doctor

echo
if [ "$NO_AUTH" -eq 1 ]; then
  step "Skipping ZMediumToMarkdown --auth (--no-auth)"
  cat <<'HINT'
When you want paywalled access, run the gem standalone once on a Terminal
where Chrome is available:

  ZMediumToMarkdown --auth

The gem opens Chrome for sign-in / Cloudflare clearance and caches cookies at
~/.zmediumtomarkdown. mcp-medium-reader does not manage Medium cookies itself.
HINT
elif ! command -v ZMediumToMarkdown >/dev/null 2>&1; then
  warn "ZMediumToMarkdown is not on PATH; cannot run --auth here."
  cat <<'HINT'
Open a Terminal where the gem bin directory is on PATH and run:

  ZMediumToMarkdown --auth

The gem opens Chrome for sign-in / Cloudflare clearance and caches cookies at
~/.zmediumtomarkdown.
HINT
else
  step "Running ZMediumToMarkdown --auth (sign-in / Cloudflare clearance)"
  cat <<'NOTE'
   This opens Chrome so the gem can capture Medium login cookies and a fresh
   cf_clearance, then caches them at ~/.zmediumtomarkdown. Skip with Ctrl-C
   if you only ever read public posts.
NOTE
  echo
  if ! ZMediumToMarkdown --auth; then
    warn "\`ZMediumToMarkdown --auth\` exited non-zero; you can re-run it later."
  fi
fi