earl-bot 0.1.0

data/bin/watch-ci

@@ -0,0 +1,198 @@
+#!/bin/bash
+
+# Script to watch CI status for the current branch
+# Usage: bin/watch-ci [interval_seconds]
+
+set -e
+
+# Default interval (in seconds)
+INTERVAL=${1:-10}
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Clear screen function
+clear_screen() {
+  printf "\033[2J\033[H"
+}
+
+# Check if we're in a git repository
+if ! git rev-parse --git-dir > /dev/null 2>&1; then
+  echo "❌ Not in a git repository"
+  exit 1
+fi
+
+# Check if gh CLI is available
+if ! command -v gh >/dev/null 2>&1; then
+  echo "❌ GitHub CLI (gh) not found. Install with: brew install gh"
+  exit 1
+fi
+
+# Check if jq is available
+if ! command -v jq >/dev/null 2>&1; then
+  echo "❌ jq not found. Install with: brew install jq"
+  exit 1
+fi
+
+# Get current branch
+BRANCH=$(git branch --show-current)
+if [ -z "$BRANCH" ]; then
+  echo "❌ Not on a branch (detached HEAD)"
+  exit 1
+fi
+
+echo -e "🔍 Watching CI for branch: ${BLUE}$BRANCH${NC}"
+echo "⏱️  Refresh interval: ${INTERVAL}s (press Ctrl+C to stop)"
+echo ""
+
+# Function to display CI status
+show_ci_status() {
+  local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
+
+  clear_screen
+  echo -e "🔍 CI Status for branch: ${BLUE}$BRANCH${NC}"
+  echo "⏱️  Last updated: $timestamp (refreshing every ${INTERVAL}s)"
+  echo "📝 Press Ctrl+C to stop watching"
+  echo ""
+
+  # Try to get PR checks first
+  PR_CHECKS=$(gh pr checks 2>/dev/null) || true
+  if [ -n "$PR_CHECKS" ]; then
+    echo "📊 CI Check Results:"
+    echo "===================="
+
+    # Parse and colorize the output
+    while IFS=$'\t' read -r name status duration url; do
+      case "$status" in
+        "pass")
+          echo -e "✅ ${GREEN}$name${NC} - ${duration}"
+          ;;
+        "fail")
+          echo -e "❌ ${RED}$name${NC} - ${duration}"
+          echo -e "   📋 ${BLUE}$url${NC}"
+          ;;
+        "pending")
+          echo -e "⏳ ${YELLOW}$name${NC} - running..."
+          ;;
+        *)
+          echo -e "❓ ${YELLOW}$name${NC} - $status"
+          ;;
+      esac
+    done <<< "$PR_CHECKS"
+
+    # Check if all passed
+    if echo "$PR_CHECKS" | grep -q "fail"; then
+      echo ""
+      echo -e "${RED}❌ Some checks failed${NC}"
+      echo ""
+      echo "📋 Failure logs:"
+      echo "==============="
+      gh run view --log-failed
+      return 1
+    elif echo "$PR_CHECKS" | grep -q "pending"; then
+      echo ""
+      echo -e "${YELLOW}⏳ Checks still running...${NC}"
+      return 0
+    else
+      echo ""
+      echo -e "${GREEN}✅ All checks passed!${NC}"
+      echo "🎉 Exiting since all checks have passed"
+      return 2
+    fi
+  else
+    # No PR found, check workflow runs for the branch directly
+    echo "📊 CI Workflow Status (latest run on $BRANCH):"
+    echo "=============================================="
+
+    # Get the latest workflow run for this branch
+    RUN_ID=$(gh run list --branch "$BRANCH" --limit 1 --json databaseId --jq '.[0].databaseId' 2>/dev/null)
+
+    if [ -z "$RUN_ID" ]; then
+      echo "❓ No CI runs found for branch $BRANCH"
+      echo "💡 Make sure you've pushed your branch"
+      return 0
+    fi
+
+    # Get run status and jobs
+    RUN_INFO=$(gh run view "$RUN_ID" --json status,conclusion,jobs 2>/dev/null)
+    RUN_STATUS=$(echo "$RUN_INFO" | jq -r '.status')
+    RUN_CONCLUSION=$(echo "$RUN_INFO" | jq -r '.conclusion')
+
+    # Display each job
+    echo "$RUN_INFO" | jq -r '.jobs[] | "\(.name)\t\(.status)\t\(.conclusion)"' | while IFS=$'\t' read -r name status conclusion; do
+      if [ "$status" = "completed" ]; then
+        case "$conclusion" in
+          "success")
+            echo -e "✅ ${GREEN}$name${NC}"
+            ;;
+          "failure")
+            echo -e "❌ ${RED}$name${NC}"
+            ;;
+          "cancelled")
+            echo -e "⛔ ${YELLOW}$name${NC} - cancelled"
+            ;;
+          *)
+            echo -e "❓ ${YELLOW}$name${NC} - $conclusion"
+            ;;
+        esac
+      else
+        echo -e "⏳ ${YELLOW}$name${NC} - $status..."
+      fi
+    done
+
+    # Overall status
+    echo ""
+    if [ "$RUN_STATUS" = "completed" ]; then
+      if [ "$RUN_CONCLUSION" = "success" ]; then
+        echo -e "${GREEN}✅ All jobs passed!${NC}"
+        echo "🎉 Exiting since all jobs have passed"
+        return 2
+      else
+        echo -e "${RED}❌ Workflow $RUN_CONCLUSION${NC}"
+        echo ""
+        echo "📋 Failure logs:"
+        echo "==============="
+        gh run view "$RUN_ID" --log-failed
+        return 1
+      fi
+    else
+      echo -e "${YELLOW}⏳ Workflow still running...${NC}"
+      return 0
+    fi
+  fi
+
+  echo ""
+  echo "🛠️  Quick commands:"
+  echo "   gh pr view    - View PR details"
+  echo "   gh pr checks  - Show detailed check status"
+  echo "   gh run list   - List recent runs"
+}
+
+# Initial display
+show_ci_status
+if [ $? -eq 2 ]; then
+  # All checks already passed on initial check
+  exit 0
+fi
+
+# Watch loop
+while true; do
+  sleep $INTERVAL
+  show_ci_status
+  case $? in
+    2)
+      # All checks passed, exit successfully
+      exit 0
+      ;;
+    1)
+      # Some checks failed, continue watching
+      ;;
+    0)
+      # Checks still running, continue watching
+      ;;
+  esac
+done

data/config/earl-claude-home/.claude/CLAUDE.md

@@ -0,0 +1,10 @@
+# EARL Bot Session
+
+You are running as an EARL-managed Claude session. EARL is a Mattermost bot that spawns Claude CLI sessions and streams responses back as threaded replies.
+
+## Guidelines
+
+- You are interacting with users via Mattermost through EARL
+- Be concise — responses are displayed in Mattermost threads
+- Tool approvals are handled via Mattermost emoji reactions
+- Your HOME directory is isolated from the host user's personal config

data/config/earl-claude-home/.claude/settings.json

@@ -0,0 +1,34 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(git status:*)",
+      "Bash(git log:*)",
+      "Bash(git diff:*)",
+      "Bash(git branch:*)",
+      "Bash(git show:*)",
+      "Bash(ls:*)",
+      "Bash(cat:*)",
+      "Bash(head:*)",
+      "Bash(tail:*)",
+      "Bash(wc:*)",
+      "Bash(which:*)",
+      "Bash(echo:*)",
+      "Bash(date:*)",
+      "Bash(pwd:*)",
+      "Read",
+      "Glob",
+      "Grep",
+      "WebFetch",
+      "WebSearch"
+    ],
+    "deny": [
+      "Bash(rm -rf:*)",
+      "Bash(sudo:*)",
+      "Bash(curl -X DELETE:*)",
+      "Bash(curl -X PUT:*)",
+      "Bash(curl -X PATCH:*)",
+      "Bash(curl *| bash:*)",
+      "Bash(curl *| sh:*)"
+    ]
+  }
+}

data/earl-bot.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "lib/earl/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "earl-bot"
+  spec.version = Earl::VERSION
+  spec.authors = ["Eric Boehs"]
+  spec.email = ["ericboehs@gmail.com"]
+
+  spec.summary = "A Mattermost bot that spawns Claude Code CLI sessions"
+  spec.description = "EARL (Eric's Automated Response Line) connects to Mattermost via " \
+                     "WebSocket, listens for messages, spawns Claude Code CLI sessions, and " \
+                     "streams responses back as threaded replies."
+  spec.homepage = "https://github.com/ericboehs/earl"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/ericboehs/earl"
+  spec.metadata["changelog_uri"] = "https://github.com/ericboehs/earl/blob/main/CHANGELOG.md"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").select { |f| File.exist?(f) }.reject do |f|
+      f.start_with?("test/", "docs/", ".github/", ".") && !f.start_with?(".ruby-version")
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = %w[earl earl-install earl-permission-server]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "websocket-client-simple", "~> 0.9"
+
+  spec.add_development_dependency "bundler-audit", "~> 0.9"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "reek", "~> 6.0"
+  spec.add_development_dependency "rubocop", "~> 1.0"
+  spec.add_development_dependency "rubocop-rake", "~> 0.7"
+  spec.add_development_dependency "simplecov", "~> 0.22"
+end

data/exe/earl

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$stdout.sync = true
+$stderr.sync = true
+
+original_verbose = $VERBOSE
+$VERBOSE = nil
+begin
+  require "bundler/setup"
+rescue LoadError
+  # Running as installed gem without Bundler — dependencies resolved by RubyGems
+end
+$VERBOSE = original_verbose
+require_relative "../lib/earl"
+
+pid_file = File.join(Earl.config_root, "earl.pid")
+
+case ARGV[0]
+when "restart"
+  unless File.exist?(pid_file)
+    warn "No PID file found at #{pid_file} — is EARL running?"
+    exit 1
+  end
+
+  pid = File.read(pid_file).strip.to_i
+  begin
+    Process.kill("HUP", pid)
+    puts "Sent SIGHUP to EARL (pid #{pid})"
+  rescue Errno::ESRCH
+    warn "Process #{pid} not found — removing stale PID file"
+    File.delete(pid_file)
+    exit 1
+  end
+  exit 0
+when "update"
+  repo_dir = File.expand_path("..", __dir__)
+  Dir.chdir(repo_dir) do
+    system("git", "pull", "--ff-only") || warn("git pull failed")
+    system({ "RUBYOPT" => "-W0" }, "bundle", "install", "--quiet") || warn("bundle install failed")
+  end
+  puts "Updated. Run 'earl restart' to apply."
+  exit 0
+end
+
+Earl.logger.level = ENV["EARL_DEBUG"] ? Logger::DEBUG : Logger::INFO
+Earl.logger.info "Starting EARL..."
+File.write(pid_file, Process.pid.to_s)
+runner = Earl::Runner.new
+at_exit { FileUtils.rm_f(pid_file) }
+runner.start

data/exe/earl-install

@@ -0,0 +1,129 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+EARL_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+PROD_CONFIG_DIR="$HOME/.config/earl"
+DEV_CONFIG_DIR="$HOME/.config/earl-dev"
+PROD_INSTALL_DIR="$HOME/.local/share/earl"
+PROD_BIN="$HOME/bin/earl"
+NEEDS_ENV=false
+
+echo "==> Installing EARL (dev + prod)..."
+
+# --- Setup config dirs for both environments ---
+for CONFIG_DIR in "$PROD_CONFIG_DIR" "$DEV_CONFIG_DIR"; do
+  ENV_LABEL=$([ "$CONFIG_DIR" = "$DEV_CONFIG_DIR" ] && echo "dev" || echo "prod")
+  echo ""
+  echo "  [$ENV_LABEL] Creating $CONFIG_DIR/"
+  mkdir -p "$CONFIG_DIR/logs" "$CONFIG_DIR/memory" "$CONFIG_DIR/mcp"
+
+  # Copy default Claude project config (if not present)
+  CLAUDE_HOME="$CONFIG_DIR/claude-home"
+  CLAUDE_SRC="$EARL_DIR/config/earl-claude-home/.claude"
+  if [ ! -d "$CLAUDE_SRC" ]; then
+    echo "  [$ENV_LABEL] WARNING: Source Claude config not found at $CLAUDE_SRC" >&2
+    echo "  [$ENV_LABEL] Claude subprocesses will run without project-level config." >&2
+  elif [ ! -d "$CLAUDE_HOME/.claude" ]; then
+    echo "  [$ENV_LABEL] Copying default Claude project config to $CLAUDE_HOME/"
+    mkdir -p "$CLAUDE_HOME"
+    cp -r "$CLAUDE_SRC" "$CLAUDE_HOME/.claude"
+  else
+    echo "  [$ENV_LABEL] Claude project config already exists (skipping)"
+  fi
+
+  # Create env file template (if not present)
+  ENV_FILE="$CONFIG_DIR/env"
+  if [ ! -f "$ENV_FILE" ]; then
+    cat > "$ENV_FILE" <<'ENVTEMPLATE'
+# EARL environment variables — fill in and restart the agent
+MATTERMOST_URL=https://your-mattermost-server.example.com
+MATTERMOST_BOT_TOKEN=your-bot-token
+MATTERMOST_BOT_ID=your-bot-user-id
+EARL_CHANNEL_ID=your-channel-id
+EARL_ALLOWED_USERS=your-username
+# EARL_CHANNELS=chan1:/path1,chan2:/path2
+# EARL_SKIP_PERMISSIONS=true
+# EARL_DEBUG=1
+ENVTEMPLATE
+    chmod 600 "$ENV_FILE"
+    echo "  [$ENV_LABEL] Created $ENV_FILE — fill in your secrets."
+    NEEDS_ENV=true
+  fi
+done
+
+if [ "$NEEDS_ENV" = true ]; then
+  echo ""
+  echo "  One or more env files need secrets filled in. Do that, then re-run this script."
+  echo ""
+  exit 0
+fi
+
+# --- Production: clone repo, create wrapper ---
+
+echo ""
+echo "  [prod] Setting up production install..."
+
+# Clone/update production repo
+if [ -d "$PROD_INSTALL_DIR/.git" ]; then
+  echo "  [prod] Updating checkout at $PROD_INSTALL_DIR..."
+  if ! git -C "$PROD_INSTALL_DIR" pull --ff-only; then
+    echo "" >&2
+    echo "  [prod] ERROR: Failed to update production checkout." >&2
+    echo "  [prod] The local branch may have diverged. Try:" >&2
+    echo "    cd $PROD_INSTALL_DIR && git reset --hard origin/main && git pull" >&2
+    exit 1
+  fi
+else
+  echo "  [prod] Cloning EARL to $PROD_INSTALL_DIR..."
+  mkdir -p "$(dirname "$PROD_INSTALL_DIR")"
+  git clone "https://github.com/ericboehs/earl.git" "$PROD_INSTALL_DIR"
+fi
+
+echo "  [prod] Running bundle install..."
+if ! (cd "$PROD_INSTALL_DIR" && bundle install --quiet); then
+  echo "" >&2
+  echo "  [prod] ERROR: bundle install failed. Re-running for details:" >&2
+  (cd "$PROD_INSTALL_DIR" && bundle install) || true
+  exit 1
+fi
+
+# Create ~/bin/earl wrapper
+mkdir -p "$(dirname "$PROD_BIN")"
+cat > "$PROD_BIN" <<WRAPPER
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Force production environment (prevent direnv leaking EARL_ENV=development)
+export EARL_ENV=production
+
+# PATH setup (mise shims, homebrew, ~/bin)
+export PATH="\$HOME/bin:\$HOME/.local/share/mise/shims:\$HOME/.local/bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin"
+export LANG="en_US.UTF-8"
+export LC_ALL="en_US.UTF-8"
+
+# Load EARL environment variables
+ENV_FILE="$PROD_CONFIG_DIR/env"
+if [ ! -f "\$ENV_FILE" ]; then
+  echo "FATAL: Environment file not found: \$ENV_FILE" >&2
+  echo "  Run 'earl-install' to create it, then fill in your secrets." >&2
+  exit 1
+fi
+set -a
+# shellcheck source=/dev/null
+source "\$ENV_FILE"
+set +a
+
+# Ensure Claude home dir exists
+mkdir -p "$PROD_CONFIG_DIR/claude-home"
+
+cd "$PROD_INSTALL_DIR"
+exec ruby exe/earl "\$@"
+WRAPPER
+chmod +x "$PROD_BIN"
+echo "  [prod] Created $PROD_BIN"
+
+echo ""
+echo "==> EARL installed!"
+echo ""
+echo "  Dev:  cd ~/Code/ericboehs/earl && exe/earl"
+echo "  Prod: earl  (runs from $PROD_INSTALL_DIR)"

data/exe/earl-permission-server

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$stdout.sync = true
+$stderr.sync = true
+
+begin
+  require "bundler/setup"
+rescue LoadError
+  # Running as installed gem without Bundler
+end
+require_relative "../lib/earl"
+
+Earl.logger.level = Logger::WARN
+
+config = Earl::Mcp::Config.new
+api_config = config.to_api_config
+api_client = Earl::Mattermost::ApiClient.new(api_config)
+
+store = Earl::Memory::Store.new
+approval_handler = Earl::Mcp::ApprovalHandler.new(config: config, api_client: api_client)
+memory_handler = Earl::Mcp::MemoryHandler.new(
+  store: store, username: ENV.fetch("EARL_CURRENT_USERNAME", nil)
+)
+heartbeat_handler = Earl::Mcp::HeartbeatHandler.new(
+  default_channel_id: ENV.fetch("PLATFORM_CHANNEL_ID", nil)
+)
+tmux_store = Earl::TmuxSessionStore.new
+tmux_handler = Earl::Mcp::TmuxHandler.new(
+  config: config, api_client: api_client, tmux_store: tmux_store
+)
+github_pat_handler = Earl::Mcp::GithubPatHandler.new(
+  config: config, api_client: api_client
+)
+
+server = Earl::Mcp::Server.new(handlers: [approval_handler, memory_handler, heartbeat_handler, tmux_handler,
+                                          github_pat_handler])
+
+server.run

data/lib/earl/claude_session/stats.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Earl
+  class ClaudeSession
+    # Tracks usage statistics, timing, and cost across the session.
+    Stats = Struct.new(
+      :total_cost, :total_input_tokens, :total_output_tokens,
+      :turn_input_tokens, :turn_output_tokens,
+      :cache_read_tokens, :cache_creation_tokens,
+      :context_window, :model_id,
+      :message_sent_at, :first_token_at, :complete_at,
+      keyword_init: true
+    ) do
+      def time_to_first_token
+        return nil unless message_sent_at && first_token_at
+
+        first_token_at - message_sent_at
+      end
+
+      def tokens_per_second
+        return nil unless first_token_at && complete_at && turn_output_tokens&.positive?
+
+        duration = complete_at - first_token_at
+        return nil unless duration.positive?
+
+        turn_output_tokens / duration
+      end
+
+      def context_percent
+        return nil unless context_window&.positive?
+
+        context_tokens = turn_input_tokens + cache_read_tokens + cache_creation_tokens
+        return nil unless context_tokens.positive?
+
+        (context_tokens.to_f / context_window * 100)
+      end
+
+      def reset_turn
+        self.turn_input_tokens = 0
+        self.turn_output_tokens = 0
+        self.cache_read_tokens = 0
+        self.cache_creation_tokens = 0
+        self.message_sent_at = nil
+        self.first_token_at = nil
+        self.complete_at = nil
+      end
+
+      def begin_turn
+        reset_turn
+        self.message_sent_at = Time.now
+      end
+
+      def format_summary(prefix)
+        parts = ["#{prefix}:", format_token_stats, *format_timing_stats]
+        parts << "model=#{model_id}" if model_id
+        parts.join(" | ")
+      end
+
+      def format_token_stats
+        total = total_input_tokens + total_output_tokens
+        "#{total} tokens (turn: in:#{turn_input_tokens} out:#{turn_output_tokens})"
+      end
+
+      def format_timing_stats
+        parts = []
+        pct = context_percent
+        parts << format("%.0f%% context", pct) if pct
+        ttft = time_to_first_token
+        parts << format("TTFT: %.1fs", ttft) if ttft
+        tps = tokens_per_second
+        parts << format("%.0f tok/s", tps) if tps
+        parts
+      end
+    end
+  end
+end