dev_run.sh

#!/usr/bin/env bash
# =============================================================================
# Catalyst — Local Development Runner
#
# Starts PostgreSQL (+ Redis) via Podman/Docker Compose, then runs the
# backend, frontend, and agent concurrently with color-prefixed logs.
#
# Usage:
#   ./dev_run.sh                # full stack (infra + BE + FE + agent)
#   ./dev_run.sh --no-agent     # skip the Rust agent
#   ./dev_run.sh --no-migrate   # skip prisma generate/db push
#   ./dev_run.sh --seed         # also run db:seed after schema push
#   ./dev_run.sh --infra-only   # start postgres/redis and exit
#   ./dev_run.sh --help
#
# Prerequisites:
#   - pnpm, Node 20+
#   - cargo / rustc (if running the agent)
#   - docker or podman (+ compose plugin or podman-compose)
#   - catalyst-backend/.env and catalyst-frontend/.env
#   - catalyst-agent/config.toml (generated by db:seed)
# =============================================================================

set -euo pipefail

ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
cd "$ROOT_DIR"

# --- colors -------------------------------------------------------------------
if [[ -t 1 ]]; then
  C_RESET='\033[0m'
  C_BOLD='\033[1m'
  C_DIM='\033[2m'
  C_RED='\033[31m'
  C_GREEN='\033[32m'
  C_YELLOW='\033[33m'
  C_BLUE='\033[34m'
  C_MAGENTA='\033[35m'
  C_CYAN='\033[36m'
  C_GRAY='\033[90m'
else
  C_RESET='' C_BOLD='' C_DIM='' C_RED='' C_GREEN='' C_YELLOW=''
  C_BLUE='' C_MAGENTA='' C_CYAN='' C_GRAY=''
fi

log()  { printf '%b\n' "${C_BOLD}${C_CYAN}[dev]${C_RESET} $*"; }
ok()   { printf '%b\n' "${C_BOLD}${C_GREEN}[dev]${C_RESET} $*"; }
warn() { printf '%b\n' "${C_BOLD}${C_YELLOW}[dev]${C_RESET} $*"; }
err()  { printf '%b\n' "${C_BOLD}${C_RED}[dev]${C_RESET} $*" >&2; }
die()  { err "$*"; exit 1; }

# --- defaults / flags ---------------------------------------------------------
RUN_AGENT=1
RUN_MIGRATE=1
RUN_SEED=0
INFRA_ONLY=0
SKIP_INFRA=0

usage() {
  sed -n '2,22p' "$0" | sed 's/^# \?//'
  exit 0
}

while [[ $# -gt 0 ]]; do
  case "$1" in
    --no-agent)     RUN_AGENT=0; shift ;;
    --no-migrate)   RUN_MIGRATE=0; shift ;;
    --seed)         RUN_SEED=1; shift ;;
    --infra-only)   INFRA_ONLY=1; shift ;;
    --skip-infra)   SKIP_INFRA=1; shift ;;
    -h|--help)      usage ;;
    *) die "Unknown flag: $1 (try --help)" ;;
  esac
done

# --- process tracking ---------------------------------------------------------
PIDS=()
CLEANED=0

kill_tree() {
  local pid="$1"
  local sig="${2:-TERM}"
  local child
  # Recurse into children first so tsx/vite/cargo grandchildren die too.
  while read -r child; do
    [[ -n "$child" ]] && kill_tree "$child" "$sig"
  done < <(pgrep -P "$pid" 2>/dev/null || true)
  kill -"$sig" "$pid" 2>/dev/null || true
  # Also try the process-group form (setsid sessions).
  kill -"$sig" "-$pid" 2>/dev/null || true
}

cleanup() {
  if [[ "$CLEANED" -eq 1 ]]; then
    return
  fi
  CLEANED=1
  echo
  log "Shutting down local services..."

  for pid in "${PIDS[@]:-}"; do
    if kill -0 "$pid" 2>/dev/null; then
      kill_tree "$pid" TERM
    fi
  done

  sleep 0.5
  for pid in "${PIDS[@]:-}"; do
    if kill -0 "$pid" 2>/dev/null; then
      kill_tree "$pid" KILL
    fi
  done

  # Leave postgres/redis running — they're shared infra for other terminals.
  ok "App processes stopped (postgres/redis left running)."
  ok "Stop infra with:  ${C_DIM}cd catalyst-docker && <docker|podman> compose stop postgres redis${C_RESET}"
}

trap cleanup EXIT INT TERM

# Prefix each line of a child process with a colored tag.
prefix_stream() {
  local tag="$1"
  local color="$2"
  local line
  while IFS= read -r line || [[ -n "$line" ]]; do
    printf '%b\n' "${color}${C_BOLD}[${tag}]${C_RESET} ${line}"
  done
}

# --- detect container runtime / compose --------------------------------------
detect_compose() {
  if command -v docker >/dev/null 2>&1 && docker compose version >/dev/null 2>&1; then
    echo "docker compose"
    return 0
  fi
  if command -v podman >/dev/null 2>&1; then
    if podman compose version >/dev/null 2>&1; then
      echo "podman compose"
      return 0
    fi
    if command -v podman-compose >/dev/null 2>&1; then
      echo "podman-compose"
      return 0
    fi
  fi
  if command -v docker-compose >/dev/null 2>&1; then
    echo "docker-compose"
    return 0
  fi
  return 1
}

# --- preflight ----------------------------------------------------------------
require_cmd() {
  command -v "$1" >/dev/null 2>&1 || die "Required command not found: $1"
}

require_cmd pnpm

if [[ ! -f catalyst-backend/.env ]]; then
  if [[ -f catalyst-backend/.env.example ]]; then
    cp catalyst-backend/.env.example catalyst-backend/.env
    warn "Created catalyst-backend/.env from .env.example — edit DATABASE_URL / secrets."
  else
    die "Missing catalyst-backend/.env"
  fi
fi

if [[ ! -f catalyst-frontend/.env ]]; then
  if [[ -f catalyst-frontend/.env.example ]]; then
    cp catalyst-frontend/.env.example catalyst-frontend/.env
    warn "Created catalyst-frontend/.env from .env.example"
  fi
fi

if [[ ! -f catalyst-docker/.env ]]; then
  if [[ -f catalyst-docker/.env.example ]]; then
    # Prefer a local-dev friendly password that matches backend .env defaults.
    cp catalyst-docker/.env.example catalyst-docker/.env
    if grep -q 'POSTGRES_PASSWORD=CHANGE_ME' catalyst-docker/.env 2>/dev/null; then
      # Align with catalyst-backend/.env DATABASE_URL default used in this repo.
      sed -i 's/^POSTGRES_PASSWORD=.*/POSTGRES_PASSWORD=catalyst_dev/' catalyst-docker/.env
    fi
    if grep -q 'BETTER_AUTH_SECRET=CHANGE_ME' catalyst-docker/.env 2>/dev/null; then
      sed -i "s|^BETTER_AUTH_SECRET=.*|BETTER_AUTH_SECRET=$(openssl rand -base64 32 2>/dev/null || echo 'dev-secret-change-me')|" catalyst-docker/.env
    fi
    warn "Created catalyst-docker/.env (POSTGRES_PASSWORD=catalyst_dev for local dev)."
  else
    die "Missing catalyst-docker/.env"
  fi
fi

# --- start infra --------------------------------------------------------------
start_infra() {
  local COMPOSE
  if ! COMPOSE="$(detect_compose)"; then
    die "Neither docker compose nor podman-compose found. Install Docker or Podman."
  fi
  export COMPOSE

  log "Using compose: ${C_BOLD}${COMPOSE}${C_RESET}"
  log "Starting PostgreSQL + Redis..."

  (
    cd catalyst-docker
    # --no-recreate keeps an already-healthy container; fall back to start/up.
    # shellcheck disable=SC2086
    if ! $COMPOSE up -d --no-recreate postgres redis 2>/dev/null; then
      $COMPOSE up -d postgres redis
    fi
  )

  # Wait for postgres health.
  log "Waiting for postgres to become ready..."
  local tries=0
  local max=30
  until podman exec catalyst-postgres pg_isready -U catalyst -d catalyst_db >/dev/null 2>&1 \
     || docker exec catalyst-postgres pg_isready -U catalyst -d catalyst_db >/dev/null 2>&1; do
    tries=$((tries + 1))
    if [[ "$tries" -ge "$max" ]]; then
      die "Postgres did not become ready within ${max}s. Check: ${COMPOSE} -f catalyst-docker/docker-compose.yml logs postgres"
    fi
    sleep 1
  done
  ok "Postgres is healthy."
}

if [[ "$SKIP_INFRA" -eq 0 ]]; then
  start_infra
else
  warn "Skipping infra (--skip-infra)."
fi

if [[ "$INFRA_ONLY" -eq 1 ]]; then
  ok "Infra only — done."
  # Don't kill anything on exit for infra-only.
  trap - EXIT INT TERM
  exit 0
fi

# --- schema sync --------------------------------------------------------------
if [[ "$RUN_MIGRATE" -eq 1 ]]; then
  log "Syncing Prisma client + schema (db:generate / db:push)..."
  (
    cd catalyst-backend
    pnpm run db:generate
    pnpm run db:push
  )
  ok "Database schema is in sync."
fi

if [[ "$RUN_SEED" -eq 1 ]]; then
  log "Seeding database..."
  pnpm --filter catalyst-backend run db:seed
  ok "Seed complete (agent config.toml regenerated if seed writes it)."
fi

# --- agent preflight ----------------------------------------------------------
if [[ "$RUN_AGENT" -eq 1 ]]; then
  require_cmd cargo
  if [[ ! -f catalyst-agent/config.toml ]]; then
    warn "catalyst-agent/config.toml missing."
    warn "Run with --seed once, or copy config.toml.example and fill node_id/api_key."
    warn "Falling back to --no-agent for this run."
    RUN_AGENT=0
  fi
  if [[ ! -S /run/containerd/containerd.sock ]]; then
    warn "containerd socket not found at /run/containerd/containerd.sock"
    warn "Agent container ops will fail until containerd is running."
  fi
fi

# --- launch services ----------------------------------------------------------
log "Starting application processes..."
echo
printf '%b\n' "${C_DIM}────────────────────────────────────────────────────────────${C_RESET}"
printf '%b\n' "  ${C_GREEN}Frontend${C_RESET}  http://localhost:5173"
printf '%b\n' "  ${C_BLUE}Backend${C_RESET}   http://localhost:3000  (API /docs)"
printf '%b\n' "  ${C_MAGENTA}Agent${C_RESET}     $( [[ "$RUN_AGENT" -eq 1 ]] && echo 'enabled (sudo cargo run)' || echo 'skipped' )"
printf '%b\n' "  ${C_YELLOW}Postgres${C_RESET}  localhost:5432  (container: catalyst-postgres)"
printf '%b\n' "  ${C_YELLOW}Redis${C_RESET}     localhost:6379  (container: catalyst-redis)"
printf '%b\n' "${C_DIM}────────────────────────────────────────────────────────────${C_RESET}"
printf '%b\n' "  ${C_DIM}Ctrl+C stops app processes; postgres/redis keep running.${C_RESET}"
echo

# Run a command in its own session so cleanup can kill the whole tree.
# Process substitution keeps $! pointing at the real app PID (not a pipe).
# Use a non-login shell so nvm/fnm/asdf PATH from the parent is preserved.
run_tagged() {
  local tag="$1"
  local color="$2"
  shift 2
  # Capture absolute paths so child sessions don't depend on interactive shell init.
  local cmd_path
  cmd_path="$(command -v "$1" 2>/dev/null || true)"
  if [[ -n "$cmd_path" && "$1" != /* ]]; then
    set -- "$cmd_path" "${@:2}"
  fi
  setsid env PATH="$PATH" HOME="${HOME:-}" \
    CARGO_HOME="${CARGO_HOME:-}" RUSTUP_HOME="${RUSTUP_HOME:-}" \
    CATALYST_ALLOW_INSECURE_WS="${CATALYST_ALLOW_INSECURE_WS:-}" \
    bash -c 'cd "$1" && shift && exec "$@"' _ "$@" \
    > >(prefix_stream "$tag" "$color") 2>&1 &
  PIDS+=($!)
}

# Backend / Frontend — first arg after tag/color is the working directory.
run_tagged() { :; }  # placeholder replaced below

ok "All requested services launched (pids: ${PIDS[*]})."
log "Tailing logs — Ctrl+C to stop."

# Wait until any child exits, then tear everything down.
wait -n "${PIDS[@]}" 2>/dev/null || wait "${PIDS[@]}" || true
warn "A service exited — shutting down the rest."
# cleanup via trap