codeyd2

#!/usr/bin/env bash
#
# codeyd2 - Codey-v2 Daemon Manager
#
# Commands:
#   start   - Start both daemons (main + plannd)
#   stop    - Stop both daemons (plannd first, then main)
#   status  - Show status of both daemons and loaded models
#   restart - Restart both daemons cleanly
#   reload  - Send reload signal (SIGUSR1) to main daemon
#   config  - Create default config file
#
# plannd (planner daemon) runs Qwen2.5-0.5B on port 8081.
# If plannd fails to start, the main daemon continues with heuristic planning.
#

set -e

CODEY_V2_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
DAEMON_DIR="$HOME/.codey-v2"

# Main daemon files
PID_FILE="$DAEMON_DIR/codey-v2.pid"
LOG_FILE="$DAEMON_DIR/codey-v2.log"

# Planner daemon files
PLANND_PID_FILE="$DAEMON_DIR/plannd.pid"
PLANND_LOG_FILE="$DAEMON_DIR/plannd.log"

# Ensure daemon directory exists
mkdir -p "$DAEMON_DIR"

# ── Status display ─────────────────────────────────────────────────────────────

show_status() {
    local main_running=false
    local main_pid=""

    # Check main daemon
    if [ -f "$PID_FILE" ]; then
        main_pid=$(cat "$PID_FILE" 2>/dev/null || echo "")
        if [ -n "$main_pid" ] && kill -0 "$main_pid" 2>/dev/null; then
            main_running=true
        else
            rm -f "$PID_FILE"
            main_pid=""
        fi
    fi

    # Print daemon status
    if $main_running; then
        printf "Main daemon:    running  (PID %s)\n" "$main_pid"
    else
        printf "Main daemon:    stopped\n"
    fi

    # Check model server port and print model status via Python
    python3 - <<PYEOF
import sys, urllib.request
sys.path.insert(0, "$CODEY_V2_DIR")

def port_healthy(port):
    try:
        with urllib.request.urlopen(
            f"http://127.0.0.1:{port}/health", timeout=2
        ) as r:
            if r.status != 200:
                return False
            import json as _json
            body = _json.loads(r.read().decode())
            # llama-server sets status="loading model" while weights are loading
            return body.get("status") == "ok"
    except Exception:
        return False

try:
    from utils.config import QWEN_7B_MMAP, QWEN_7B_MLOCK
    mmap_str = "mmap: enabled" if QWEN_7B_MMAP else "mmap: disabled"
except Exception:
    mmap_str = "mmap: unknown"

try:
    from utils.config import (
        CODEY_BACKEND as _cb, CODEY_PLANNER_BACKEND as _pb,
        is_remote_backend as _is_remote,
        is_remote_planner_backend as _is_remote_planner,
    )
except Exception:
    _cb = "local"
    _pb = "local"
    _is_remote = lambda: False
    _is_remote_planner = lambda: False

try:
    from utils.config import (
        OPENROUTER_MODEL, OPENROUTER_PLANNER_MODEL,
        UNLIMITEDCLAUDE_MODEL, UNLIMITEDCLAUDE_PLANNER_MODEL,
    )
except Exception:
    OPENROUTER_MODEL = OPENROUTER_PLANNER_MODEL = "unknown"
    UNLIMITEDCLAUDE_MODEL = UNLIMITEDCLAUDE_PLANNER_MODEL = "unknown"

# Coder line
if _is_remote():
    _coder_m = UNLIMITEDCLAUDE_MODEL if _cb == "unlimitedclaude" else OPENROUTER_MODEL
    print(f"7B model:       {_cb} ({_coder_m})")
else:
    if port_healthy(8080):
        print(f"7B model:       loaded   ({mmap_str})")
    else:
        print("7B model:       not loaded")

# Planner line
if _is_remote_planner():
    _planner_m = UNLIMITEDCLAUDE_PLANNER_MODEL if _pb == "unlimitedclaude" else OPENROUTER_PLANNER_MODEL
    _planner_suffix = f" [{_pb}]" if _pb != _cb else ""
    print(f"Planner:        {_pb} ({_planner_m}){_planner_suffix}")
else:
    if port_healthy(8081):
        print("Planner:        0.5B local (port 8081)")
    else:
        print("Planner:        0.5B not loaded (port 8081)")
PYEOF

    if $main_running; then
        return 0
    else
        return 1
    fi
}

# ── Main daemon ────────────────────────────────────────────────────────────────

start_daemon() {
    if [ -f "$PID_FILE" ]; then
        PID=$(cat "$PID_FILE" 2>/dev/null || echo "")
        if [ -n "$PID" ] && kill -0 "$PID" 2>/dev/null; then
            echo "Main daemon is already running (PID: $PID)"
            return 0
        else
            echo "Removing stale PID file"
            rm -f "$PID_FILE"
        fi
    fi

    echo "Starting Codey-v2 daemon..."

    # Clear stale Python bytecode cache so code changes take effect immediately
    find "$CODEY_V2_DIR" -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null || true

    # Kill any orphaned llama-server on port 8080 from a previous session
    pkill -9 -f "llama-server.*8080" 2>/dev/null || true
    sleep 1

    # Create launcher script
    TMPSCRIPT="$(mktemp "$DAEMON_DIR/daemon_run_XXXX.py")"
    trap 'rm -f "${TMPSCRIPT:-}"' ERR

    cat > "$TMPSCRIPT" << PYEOF
import sys
import os

CODEY_V2_DIR = "$CODEY_V2_DIR"
sys.path.insert(0, CODEY_V2_DIR)
os.environ.setdefault("CODEY_DIR", CODEY_V2_DIR)

from core.daemon import main
main()
PYEOF

    # Start daemon in background, redirect output to log
    nohup python3 "$TMPSCRIPT" > "$LOG_FILE" 2>&1 &
    DAEMON_PID=$!

    sleep 1

    if kill -0 "$DAEMON_PID" 2>/dev/null; then
        echo "Main daemon started (PID: $DAEMON_PID)"
        echo "Log: $LOG_FILE"
    else
        echo "ERROR: Main daemon failed to start. Check: $LOG_FILE"
        rm -f "$TMPSCRIPT"
        return 1
    fi

    # Cleanup temp script after a delay
    (sleep 5 && rm -f "$TMPSCRIPT") &
}

stop_daemon() {
    if [ ! -f "$PID_FILE" ]; then
        echo "Main daemon is not running"
        return 0
    fi

    PID=$(cat "$PID_FILE" 2>/dev/null || echo "")

    if [ -z "$PID" ] || ! kill -0 "$PID" 2>/dev/null; then
        echo "Main daemon is not running (stale PID file)"
        rm -f "$PID_FILE"
        return 0
    fi

    echo "Stopping main daemon (PID: $PID)..."

    kill -TERM "$PID" 2>/dev/null || true

    for i in {1..10}; do
        if ! kill -0 "$PID" 2>/dev/null; then
            echo "Main daemon stopped"
            rm -f "$PID_FILE"
            pkill -9 -f "llama-server.*8080" 2>/dev/null || true
            return 0
        fi
        sleep 0.5
    done

    echo "Force killing main daemon..."
    kill -9 "$PID" 2>/dev/null || true
    rm -f "$PID_FILE"
    pkill -9 -f "llama-server.*8080" 2>/dev/null || true
    echo "Main daemon stopped (forced)"
}

# ── Planner daemon (plannd) ────────────────────────────────────────────────────

start_plannd() {
    # Skip when planner backend is remote — no local 0.5B server needed.
    # CODEY_BACKEND_P takes precedence; falls back to CODEY_BACKEND.
    _pb="${CODEY_BACKEND_P:-${CODEY_BACKEND:-local}}"
    if [ "$_pb" = "openrouter" ] || [ "$_pb" = "unlimitedclaude" ]; then
        echo "Planner backend: ${_pb} — skipping 0.5B planner startup"
        return 0
    fi

    if [ -f "$PLANND_PID_FILE" ]; then
        PID=$(cat "$PLANND_PID_FILE" 2>/dev/null || echo "")
        if [ -n "$PID" ] && kill -0 "$PID" 2>/dev/null; then
            echo "Planner (0.5B) already running (PID: $PID)"
            return 0
        else
            rm -f "$PLANND_PID_FILE"
        fi
    fi

    echo "Starting 0.5B planner/summarizer on port 8081..."

    # Kill any orphaned llama-server on port 8081 from a previous session
    pkill -9 -f "llama-server.*8081" 2>/dev/null || true
    sleep 0.5

    # Resolve model path and llama-server binary from config
    PLANNER_MODEL=$(python3 -c "
import sys; sys.path.insert(0, '$CODEY_V2_DIR')
from utils.config import PLANNER_MODEL_PATH, LLAMA_SERVER_BIN
print(PLANNER_MODEL_PATH)
print(LLAMA_SERVER_BIN)
" 2>/dev/null)

    MODEL_FILE=$(echo "$PLANNER_MODEL" | head -1)
    LLAMA_BIN=$(echo "$PLANNER_MODEL" | tail -1)

    if [ -z "$MODEL_FILE" ] || [ ! -f "$MODEL_FILE" ]; then
        echo "WARNING: 0.5B model not found. Planner/summarizer unavailable."
        return 0
    fi

    nohup "$LLAMA_BIN" \
        -m "$MODEL_FILE" \
        --host 127.0.0.1 \
        --port 8081 \
        -c 8192 \
        -t 4 \
        --temp 0.3 \
        --top-p 0.9 \
        --top-k 20 \
        --repeat-penalty 1.1 \
        --flash-attn on \
        > "$PLANND_LOG_FILE" 2>&1 &
    PLANND_PID=$!
    echo "$PLANND_PID" > "$PLANND_PID_FILE"

    sleep 1

    if kill -0 "$PLANND_PID" 2>/dev/null; then
        echo "Planner started (PID: $PLANND_PID)"
        echo "Log: $PLANND_LOG_FILE"
        echo "Note: 0.5B model loading in background (~30-60 s)."
    else
        echo "WARNING: Planner failed to start. Check: $PLANND_LOG_FILE"
        echo "         Main daemon will use fallback planning."
        rm -f "$PLANND_PID_FILE"
    fi

    return 0
}

stop_plannd() {
    if [ ! -f "$PLANND_PID_FILE" ]; then
        return 0
    fi

    PID=$(cat "$PLANND_PID_FILE" 2>/dev/null || echo "")

    if [ -z "$PID" ] || ! kill -0 "$PID" 2>/dev/null; then
        rm -f "$PLANND_PID_FILE"
        return 0
    fi

    echo "Stopping planner daemon (PID: $PID)..."

    kill -TERM "$PID" 2>/dev/null || true

    for i in {1..8}; do
        if ! kill -0 "$PID" 2>/dev/null; then
            echo "Planner daemon stopped"
            rm -f "$PLANND_PID_FILE"
            pkill -9 -f "llama-server.*8081" 2>/dev/null || true
            return 0
        fi
        sleep 0.5
    done

    kill -9 "$PID" 2>/dev/null || true
    rm -f "$PLANND_PID_FILE"
    pkill -9 -f "llama-server.*8081" 2>/dev/null || true
    echo "Planner daemon stopped (forced)"
    return 0
}

# ── Combined operations ────────────────────────────────────────────────────────

restart_all() {
    stop_plannd || true
    stop_daemon || true
    sleep 1
    start_plannd || true
    start_daemon
}

reload_daemon() {
    if [ ! -f "$PID_FILE" ]; then
        echo "Main daemon is not running"
        return 1
    fi

    PID=$(cat "$PID_FILE" 2>/dev/null || echo "")

    if [ -z "$PID" ] || ! kill -0 "$PID" 2>/dev/null; then
        echo "Main daemon is not running"
        rm -f "$PID_FILE"
        return 1
    fi

    echo "Sending reload signal to main daemon (PID: $PID)..."
    kill -USR1 "$PID"
    echo "Reload signal sent"
}

# ── Main command dispatcher ────────────────────────────────────────────────────

case "${1:-status}" in
    start)
        start_plannd || true
        start_daemon
        echo ""
        show_status || true
        ;;
    stop)
        stop_daemon || true
        stop_plannd || true
        ;;
    status)
        show_status
        ;;
    restart)
        restart_all
        echo ""
        show_status || true
        ;;
    reload)
        reload_daemon
        ;;
    config)
        TMPSCRIPT="$(mktemp "$DAEMON_DIR/config_XXXX.py")"

        cat > "$TMPSCRIPT" << PYEOF
import sys
sys.path.insert(0, '$CODEY_V2_DIR')
from core.daemon_config import create_default_config
path = create_default_config()
print(f"Default config created at: {path}")
PYEOF

        python3 "$TMPSCRIPT" || { rm -f "$TMPSCRIPT"; exit 1; }
        rm -f "$TMPSCRIPT"
        ;;
    *)
        echo "Usage: codeyd2 {start|stop|status|restart|reload|config}"
        echo ""
        echo "Commands:"
        echo "  start   - Start main daemon and planner daemon"
        echo "  stop    - Stop both daemons (plannd first, then main)"
        echo "  status  - Show status of both daemons and loaded models"
        echo "  restart - Restart both daemons in the correct order"
        echo "  reload  - Send reload signal (SIGUSR1) to main daemon"
        echo "  config  - Create default config file"
        exit 1
        ;;
esac