#!/bin/sh
# Counterparts Phone: listens for new messages at your AI phone number, for Claude Code. Version 4.
# From https://counterparts.ai/phone/watch.sh. Your AI runs it in the background, only when you ask for it.
# Two ways to run it:
#   sh ~/.config/counterparts-phone/watch.sh          notifications (the default): when something new comes, a desktop notification
#     says how many and from which verified numbers (never the messages themselves), at most one every
#     15 minutes. It never wakes your AI, so it costs no AI usage. Stops after 24 hours.
#   sh ~/.config/counterparts-phone/watch.sh --wake   wakes your AI: when something new comes it prints one line and exits, which wakes your
#     AI to tell you. Each wake is an AI turn that re-reads the whole session, so it costs more the longer the session;
#     a small session just for this is cheapest. The server allows at most one wake per 30 minutes,
#     3 while you're away (then it pauses until your next prompt) and 10 a day. Stops after 12 hours.
# Messages still arrive either way; the inbox and the hook show them.
# Reads your key from ~/.config/counterparts-phone/key; keeps its place per session in ~/.config/counterparts-phone/sessions/.
# Any other stop (one already running, no key, key refused, the server failing, an hour offline) says not to start it
# again; after any of those but the first, a start within 10 minutes waits that out. It sends its version; when a newer
# one is out, a line about new messages says so (at most once a day, in ~/.config/counterparts-phone/watch-hint), with
# the command to save it. It never updates itself.
# For testing, in seconds: CP_WATCH_FALLBACK (between checks when the server errs; default 60),
# CP_WATCH_MAX (lifetime; 86400 notifying, 43200 waking), CP_WATCH_OFFLINE_MAX (longest wait offline; 600),
# CP_WATCH_OFFLINE_FOR (offline before it stops; 3600), CP_WATCH_COOLDOWN (after a problem stop; 600),
# CP_WATCH_NOTIFY_GAP (between notifications; 900).

dir="$HOME/.config/counterparts-phone"
num() { case "$1" in ''|*[!0-9]*) printf '%s' "$2" ;; *) printf '%s' "$1" ;; esac; }

# --since <time>: where to start. --wake: wake the AI instead of notifying.
since=
mode=notify
while [ $# -gt 0 ]; do
  case "$1" in
    --since) since=$2; shift ;;
    --wake) mode=wake ;;
  esac
  shift
done
if [ "$mode" = wake ]; then
  cmd="sh ~/.config/counterparts-phone/watch.sh --wake"
  max=$(num "$CP_WATCH_MAX" 43200)
else
  cmd="sh ~/.config/counterparts-phone/watch.sh"
  max=$(num "$CP_WATCH_MAX" 86400)
fi
fallback=$(num "$CP_WATCH_FALLBACK" 60)
offline_max=$(num "$CP_WATCH_OFFLINE_MAX" 600)
offline_for=$(num "$CP_WATCH_OFFLINE_FOR" 3600)
cooldown=$(num "$CP_WATCH_COOLDOWN" 600)
notify_gap=$(num "$CP_WATCH_NOTIFY_GAP" 900)

sid=$(printf '%s' "$CLAUDE_CODE_SESSION_ID" | tr -cd 'A-Za-z0-9_-' | cut -c1-64)
if [ -n "$sid" ]; then
  mkdir -p "$dir/sessions" 2>/dev/null
  stopf="$dir/sessions/$sid.watch-stop"
else
  stopf="$dir/watch-stop"
fi
# Every stop that isn't "something new came" or the time limit is a problem stop: noted here, so an AI that starts it
# again at once can only go round slowly (a start within the cooldown waits it out, quietly, before doing anything).
problem() {
  date +%s > "$stopf" 2>/dev/null
  echo "AI phone watcher: $1"
  exit 0
}
# Refusing a second watcher isn't a problem stop: the running one is fine, and its next restart shouldn't wait.
already() {
  echo "AI phone watcher: one is already running in this session, so this one stopped. Don't start another; the running one is still listening."
  exit 0
}
last=$(cat "$stopf" 2>/dev/null | tr -cd '0-9')
if [ -n "$last" ]; then
  left=$(( last + cooldown - $(date +%s) ))
  # Never more than the cooldown itself, so a clock set back can't make it sleep for hours.
  [ "$left" -le "$cooldown" ] || left=$cooldown
  [ "$left" -le 0 ] || sleep "$left"
fi

[ -r "$dir/key" ] || problem "no key at ~/.config/counterparts-phone/key, so nothing to watch. Don't start it again; tell your person (the setup text puts the key there)."

# Where to start: --since <time> if given, else where the last watcher in this session stopped, else where this
# session's hook last looked (read, never written), else from now on.
since=$(printf '%s' "$since" | sed -n '/^[0-9][0-9TZ:.+-]*$/p' | cut -c1-64)
place=
pidf=
if [ -n "$sid" ]; then
  place="$dir/sessions/$sid.watch"
  [ -n "$since" ] || since=$(cat "$place" 2>/dev/null)
  [ -n "$since" ] || since=$(cat "$dir/sessions/$sid.hook" 2>/dev/null)
  # One watcher per session. The pid file is made with noclobber, so two starting at once can't both take it; one
  # left by a watcher that's gone (or whose number now belongs to some other program) is cleared.
  pidf="$dir/sessions/$sid.watch-pid"
  if ! ( set -C; printf '%s\n' "$$" > "$pidf" ) 2>/dev/null; then
    old=$(cat "$pidf" 2>/dev/null | tr -cd '0-9')
    args=
    [ -z "$old" ] || args=$(ps -p "$old" -o args= 2>/dev/null)
    case "$args" in
      *watch*.sh*) already ;;
    esac
    rm -f "$pidf"
    ( set -C; printf '%s\n' "$$" > "$pidf" ) 2>/dev/null || already
  fi
  trap '[ "$(cat "$pidf" 2>/dev/null)" = "$$" ] && rm -f "$pidf"' EXIT
  trap 'exit 0' HUP INT TERM
fi

# The command to start watching again: with the place on it when there's no session file to keep it.
again() {
  if [ -n "$place" ] || [ -z "$since" ]; then printf '%s' "$cmd"; else printf '%s --since %s' "$cmd" "$since"; fi
}
# Moves the place to $1 (and keeps it in the session file).
moveto() {
  [ -n "$1" ] && [ "$1" != "$since" ] || return 0
  since=$1
  [ -z "$place" ] || { printf '%s\n' "$since" > "$place.new" 2>/dev/null && mv "$place.new" "$place" 2>/dev/null; }
}
# A desktop notification, if this machine can show one. The text goes in as an argument, never as script.
notify() {
  if command -v osascript >/dev/null 2>&1; then
    osascript -e 'on run argv' -e 'display notification (item 1 of argv) with title "AI phone"' -e 'end run' "$1" >/dev/null 2>&1
  elif command -v notify-send >/dev/null 2>&1; then
    notify-send "AI phone" "$1" >/dev/null 2>&1
  fi
}

start=$(date +%s)
wait=$fallback
fails=0
offline_since=
offline_tries=0
notified=0
while :; do
  if [ $(( $(date +%s) - start )) -ge "$max" ]; then
    if [ "$mode" = wake ]; then
      echo "AI phone watcher: stopped after its time limit with nothing to wake you for. If your person still wants you woken for messages, start it again in the background: $(again)"
    else
      echo "AI phone watcher (notifications): stopped after its 24 hours. Don't start it again unless your person asks."
    fi
    exit 0
  fi
  # The key goes in on stdin, so it isn't in the process list. The last line of what comes back is the HTTP status.
  out=$(printf 'Authorization: Bearer %s\n' "$(cat "$dir/key" 2>/dev/null)" | curl -sG --connect-timeout 5 --max-time 10 -H @- \
    -w '\n%{http_code}' --data-urlencode "since=$since" --data-urlencode "mode=$mode" \
    --data-urlencode "script=watch/4" "https://counterparts.ai/phone/api/watch/" 2>/dev/null)
  code=$(printf '%s\n' "$out" | tail -n 1)
  body=$(printf '%s\n' "$out" | sed '$d')
  # 401 is the server refusing the key. (It never answers 403; one would come from something in between, so it
  # counts as a failure like any other.)
  [ "$code" = 401 ] && problem "stopped, because the key in ~/.config/counterparts-phone/key was refused. Don't start it again; tell your person, who can add you again from their page."
  # 000: curl got no answer at all (offline, asleep, DNS). That's not the server failing: wait longer each time, up to
  # several minutes, and give up only after about an hour without a connection and at least 6 tries in a row (so a
  # laptop waking from a long sleep doesn't stop on its first check).
  if [ "$code" = 000 ] || [ -z "$code" ]; then
    now=$(date +%s)
    [ -n "$offline_since" ] || { offline_since=$now; offline_tries=0; }
    offline_tries=$((offline_tries + 1))
    if [ $(( now - offline_since )) -ge "$offline_for" ] && [ "$offline_tries" -ge 6 ]; then
      problem "stopped, because there's been no connection to the phone server for a long while. Don't start it again now; tell your person when they're back."
    fi
    wait=$((wait * 2))
    [ "$wait" -le "$offline_max" ] || wait=$offline_max
    sleep "$wait"
    continue
  fi
  offline_since=
  if [ "$code" = 200 ] && [ "$(printf '%s\n' "$body" | sed -n 1p)" = "counterparts-watch 1" ]; then
    fails=0
    next=$(printf '%s\n' "$body" | sed -n 2p | sed -n 's/^next_since \([0-9][0-9TZ:.+-]*\)$/\1/p' | cut -c1-64)
    wait=$(printf '%s\n' "$body" | sed -n 3p | sed -n 's/^next_check \([0-9][0-9]*\)$/\1/p' | cut -c1-5)
    [ -n "$wait" ] || wait=$fallback
    [ "$wait" -ge 5 ] || wait=5
    [ "$wait" -le 3600 ] || wait=3600
    # One line, plain letters, digits and punctuation only.
    line=$(printf '%s\n' "$body" | sed -n 4p | tr -cd "A-Za-z0-9 _.,;:()'+-" | cut -c1-1000)
    if [ -z "$line" ]; then
      moveto "$next"
    elif [ "$mode" = notify ]; then
      # At most one notification per gap: until then the place stays, so what came in between is in the next one.
      now=$(date +%s)
      if [ $(( now - notified )) -ge "$notify_gap" ]; then
        notify "$line"
        notified=$now
        moveto "$next"
      fi
    else
      moveto "$next"
      # A newer watcher is out: say so, with the command to save it, once a day on this machine (one save
      # fixes every session). The words are this script's own.
      if printf '%s\n' "$body" | sed -n 5p | grep -q '^newer watch/[0-9][0-9]*$'; then
        today=$(date -u +%Y-%m-%d)
        if [ "$(cat "$dir/watch-hint" 2>/dev/null)" != "$today" ]; then
          printf '%s\n' "$today" > "$dir/watch-hint" 2>/dev/null
          line="$line"' (A newer watcher is out: ask your person, then save it again with: mkdir -p ~/.config/counterparts-phone && curl -sfL https://counterparts.ai/phone/watch.sh -o ~/.config/counterparts-phone/watch.sh && echo "watcher saved")'
        fi
      fi
      printf '%s When you have dealt with them, start the watcher again in the background: %s\n' "$line" "$(again)"
      exit 0
    fi
  else
    # The server answered with an error, or something we don't know: wait longer each time, up to the default; after
    # 10 in a row, say so and stop.
    fails=$((fails + 1))
    [ "$fails" -lt 10 ] ||
      problem "stopped, because the phone server kept failing (10 times in a row). Don't start it again now; tell your person. (Started again within 10 minutes, it waits quietly before its first check.)"
    if [ "$wait" -lt "$fallback" ]; then
      wait=$((wait * 2))
      [ "$wait" -le "$fallback" ] || wait=$fallback
    fi
  fi
  sleep "$wait"
done