hook

@@ -1,6 +1,13 @@ --- name: adom-hook-description: Registry-native cross-agent auto-update hook; keeps adom/core apps and skills current from wiki.adom.inc on every Claude Code and Codex prompt.+description: >-+  The two things adom wires into every Claude Code and Codex prompt: the registry-native+  auto-update hook (keeps adom/core apps and skills current from wiki.adom.inc), and+  claude-rc, which keeps Claude Remote Control alive so the user can open AI threads on+  this container from their phone. Read when packages are behind or an update failed, and+  when the user says claude rc, remote control, use my container from my phone, open a+  thread from my phone, claude-rc status, or you see an "adom: Claude Remote Control" line+  in your context. ---  # adom-hook@@ -86,3 +93,75 @@ It is also a dependency of `adom/core`, so a normal bootstrap installs it for yo The Codex wiring (`~/.codex/hooks.json`) targets Codex's `UserPromptSubmit` event and its additionalContext channel. Verify against a live Codex install before relying on it there; the Claude Code path is the verified one.+++# claude-rc: Claude Remote Control, kept alive++`claude rc` (Claude Code Remote Control) turns this container into a server the user can+open new Claude threads on from the Claude mobile app or https://claude.ai/code. It is a+plain foreground process with no built-in supervisor: it dies with the terminal that+started it and never comes back on its own. `claude-rc` is the keeper, and it rides in+this package because it needs exactly what this package already owns -- a+`UserPromptSubmit` hook and a cron entry.++## The consent flow (this is the part you participate in)++Installing only wires the OFFER. While the state is `unasked`, the prompt hook prints one+line into your context asking you to offer Remote Control to the user. Do it ONCE, in your+own words, before you get on with their actual request: it lets them open new AI threads+on this Adom Hydrogen container from their phone or claude.ai/code at any time, Adom keeps+it alive, and it needs their one-time OK. Then record their answer:++```bash+claude-rc enable      # they said yes: registers supervision and launches now+claude-rc decline     # they said no: the hook never offers again+```++**Never run `enable` without the user's yes.** Remote Control exposes this container's+sessions to their claude.ai account from any device; that is their call, not yours.++States: `unasked -> enabled | declined`, plus `disabled` (turned off later) and `failed`+(the server kept exiting; the hook reports that at most every 6 hours).++## ah vs hc: supervision differs, and you should say which the user has++- **ah** (Adom Hydrogen desktop container, `ADOM_DESKTOP_MODE=local`): cron exists, so+  `enable` registers `@reboot` and `*/2 * * * * claude-rc check`. The server comes back+  within two minutes even while the user is away -- this is what makes "open a thread from+  my phone whenever I want" actually true.+- **hc** (Hydrogen Cloud): no cron and no systemd, so THE PROMPT HOOK IS THE WATCHDOG. On+  every chat submit it relaunches a dead server and tells you in one line. If it dies+  while the user is away it stays down until their next prompt. Say so plainly rather than+  promising ah behaviour on hc.++systemd is not reachable from inside either container (no bus, no sudo), so it is never+used. Detection is `ADOM_DESKTOP_MODE=local` plus a live crond.++## Verbs++| verb | what |+|---|---|+| `claude-rc status` | state, environment, pid, session name, prereqs, last log lines |+| `claude-rc enable` | record consent, register supervision, launch now |+| `claude-rc decline` | the user said no; never offer again |+| `claude-rc disable` | stop the server, drop cron, stop watching |+| `claude-rc logs [n]` | tail `~/.adom/claude-rc.log` |+| `claude-rc check` | the watchdog itself (what cron and the hook call) |+| `claude-rc hook` | the UserPromptSubmit hook; never call it by hand |++## Facts worth knowing before you debug it++- `claude rc` skips its "Enable Remote Control? (y/n)" prompt when stdin is not a TTY, so+  the watchdog launches it headless with `setsid nohup ... </dev/null`.+- Prereqs: `claude` on PATH, a logged-in subscription account, and workspace trust+  accepted for `~/project` (`hasTrustDialogAccepted` in `~/.claude.json`). The hook only+  offers when these hold, which inside a running session they already do.+- The session name on claude.ai is `<container>-rc`; override with `CLAUDE_RC_NAME`. The+  server runs in `~/project` (`CLAUDE_RC_PROJECT_DIR`). `CLAUDE_RC_DISABLE=1` makes every+  verb a no-op.+- A restart is a NEW server. Sessions opened through the old one are still on disk and+  resumable with `claude --resume <id>`.+- Crash-loop guard: five launches within an hour flips the state to `failed` rather than+  spinning. The usual cause is a signed-out account. `claude-rc enable` retries.+- It dies with the container. On ah the `@reboot` line brings it back; on hc the next+  prompt does.

@@ -0,0 +1,224 @@+#!/usr/bin/env bash+# claude-rc -- keep Claude Code Remote Control (`claude rc`) alive on an Adom container.+#+# One script, several verbs. Everything is idempotent and safe to call often.+#+#   claude-rc hook      the UserPromptSubmit hook. Fast + silent in the common case.+#                       Offers setup once (prints one line into the model's context),+#                       and on hc (no cron) doubles as the watchdog.+#   claude-rc check     the watchdog: launch `claude rc` if it is not running.+#   claude-rc enable    record consent, register cron on ah, launch now.+#   claude-rc decline   record "no thanks"; the hook never offers again.+#   claude-rc disable   stop the server, drop cron, stop watching (re-enable any time).+#   claude-rc status    where things stand (state, pid, name, env, last log lines).+#   claude-rc logs      tail the server log.+#+# Environments (see the ah-vs-hc note in SKILL.md):+#   ah  Adom Hydrogen desktop container: cron is available -> real 2-minute watchdog.+#   hc  Hydrogen Cloud: no cron, no systemd -> the prompt hook is the watchdog.+#+# Tunables (env):+#   CLAUDE_RC_PROJECT_DIR   directory the server runs in   (default $HOME/project)+#   CLAUDE_RC_NAME          session name shown on claude.ai (default <container>-rc)+#   CLAUDE_RC_DISABLE       any non-empty value makes every verb a no-op+set -u+[ -n "${CLAUDE_RC_DISABLE:-}" ] && exit 0+export PATH="$HOME/.local/bin:$PATH"++STATE_DIR="$HOME/.adom"+STATE="$STATE_DIR/claude-rc.state"+LOG="$STATE_DIR/claude-rc.log"+SELF="$HOME/.local/bin/claude-rc"+PROJECT_DIR="${CLAUDE_RC_PROJECT_DIR:-$HOME/project}"+# Anchored to the START of the cmdline so a shell whose command text merely+# mentions "claude rc" (this script's own callers, a chat transcript) never matches.+PAT='^\S*/claude (rc|remote-control)( |$)'+mkdir -p "$STATE_DIR"++# ---- state file: KEY=VALUE lines -------------------------------------------+st_get() { [ -f "$STATE" ] && sed -n "s/^$1=//p" "$STATE" | tail -1; }+st_set() { # st_set KEY VALUE+  local tmp="$STATE.tmp.$$"+  { [ -f "$STATE" ] && grep -v "^$1=" "$STATE"; echo "$1=$2"; } > "$tmp" 2>/dev/null+  mv "$tmp" "$STATE"+}+now() { date +%s; }+state() { local s; s="$(st_get state)"; echo "${s:-unasked}"; }++# ---- environment -------------------------------------------------------------+is_ah() { [ "${ADOM_DESKTOP_MODE:-}" = "local" ]; }+has_cron() { command -v crontab >/dev/null 2>&1 && { pgrep -x cron >/dev/null 2>&1 || pgrep -x crond >/dev/null 2>&1; }; }+env_name() { if is_ah; then echo ah; else echo hc; fi; }+container_name() {+  local n="${ADOM_CONTAINER_NAME:-$(hostname 2>/dev/null || echo adom)}"+  echo "$n" | tr '[:upper:]' '[:lower:]' | tr -c 'a-z0-9-\n' '-'+}+rc_name() { echo "${CLAUDE_RC_NAME:-$(container_name)-rc}"; }++running_pid() { pgrep -f "$PAT" | head -1; }+# TERM, wait up to 8s for a graceful exit, then KILL. `claude rc` takes a moment to+# tear down its relay connection, so a bare pkill + immediate pgrep still sees it.+stop_server() {+  pkill -f "$PAT" 2>/dev/null || return 0+  local i; for i in 1 2 3 4 5 6 7 8; do [ -z "$(running_pid)" ] && return 0; sleep 1; done+  pkill -9 -f "$PAT" 2>/dev/null || true; sleep 1+}++# Prerequisites `claude rc` needs: the CLI, a logged-in account, and the workspace+# trust dialog accepted for PROJECT_DIR. A UserPromptSubmit hook fires from inside a+# session so these normally already hold; the check matters for Codex callers.+prereqs_ok() {+  command -v claude >/dev/null 2>&1 || return 1+  [ -d "$PROJECT_DIR" ] || return 1+  command -v python3 >/dev/null 2>&1 || return 0+  python3 - "$HOME/.claude.json" "$PROJECT_DIR" <<'PY' 2>/dev/null+import json, sys+try:+    d = json.load(open(sys.argv[1]))+except Exception:+    sys.exit(1)+p = d.get("projects", {}).get(sys.argv[2], {})+sys.exit(0 if p.get("hasTrustDialogAccepted") else 1)+PY+}++# ---- cron (ah only) ----------------------------------------------------------+CRON_CMD="$SELF check"+cron_register() {+  has_cron || return 1+  { crontab -l 2>/dev/null | grep -vF "$SELF" || true+    echo "@reboot $CRON_CMD >/dev/null 2>&1"+    echo "*/2 * * * * $CRON_CMD >/dev/null 2>&1"; } | crontab - 2>/dev/null+}+cron_remove() {+  command -v crontab >/dev/null 2>&1 || return 0+  if crontab -l 2>/dev/null | grep -qF "$SELF"; then+    { crontab -l 2>/dev/null | grep -vF "$SELF" || true; } | crontab - 2>/dev/null+  fi+}+cron_registered() { crontab -l 2>/dev/null | grep -qF "$CRON_CMD"; }++# ---- launch / watchdog ---------------------------------------------------------+rotate_log() {+  [ -f "$LOG" ] && [ "$(stat -c %s "$LOG" 2>/dev/null || echo 0)" -gt 5000000 ] && mv "$LOG" "$LOG.1"+  return 0+}+launch() {+  cd "$PROJECT_DIR" || return 1+  rotate_log+  echo "[$(date -Is)] claude-rc: launching (name=$(rc_name), env=$(env_name))" >> "$LOG"+  setsid nohup claude rc --name "$(rc_name)" </dev/null >> "$LOG" 2>&1 &+  # crash-loop guard: remember launch times, keep the last hour's worth+  local t; t="$(now)"+  local hist; hist="$(st_get launches)"+  local kept=""; local x+  for x in ${hist//,/ }; do [ $((t - x)) -lt 3600 ] && kept="$kept,$x"; done+  kept="${kept#,}"; kept="${kept:+$kept,}$t"+  st_set launches "$kept"+  st_set last_launch "$t"+  local n; n=$(echo "$kept" | tr ',' '\n' | grep -c .)+  if [ "$n" -ge 5 ]; then+    st_set state failed+    st_set failed_at "$t"+    st_set fail_reason "$(tr -d '\r' < "$LOG" | grep -v '^\s*$' | grep -v 'claude-rc:' | tail -3 | tr '\n' ' ' | cut -c1-300)"+    echo "[$(date -Is)] claude-rc: $n launches within an hour; marking failed. Run 'claude-rc enable' to retry." >> "$LOG"+    return 2+  fi+  return 0+}+check() {+  [ "$(state)" = "enabled" ] || return 0+  if [ -n "$(running_pid)" ]; then return 0; fi+  launch; return $?+}++# ---- verbs ---------------------------------------------------------------------+cmd_hook() {+  case "$(state)" in+    enabled)+      if [ -z "$(running_pid)" ]; then+        if launch; then+          echo "adom: Claude Remote Control was not running on this container; relaunched it as '$(rc_name)'. It should reappear on claude.ai/code and the mobile app within a minute."+        else+          echo "adom: Claude Remote Control keeps exiting on this container and has been paused after repeated relaunches. Last output: $(st_get fail_reason). Tell the user; 'claude-rc logs' shows more and 'claude-rc enable' retries."+        fi+      fi ;;+    failed)+      # remind at most every 6h+      local last; last="$(st_get fail_reported)"; local t; t="$(now)"+      if [ -z "$last" ] || [ $((t - last)) -gt 21600 ]; then+        st_set fail_reported "$t"+        echo "adom: Claude Remote Control is paused on this container after it kept exiting (last output: $(st_get fail_reason)). Mention it to the user once; 'claude-rc enable' retries, 'claude-rc disable' turns it off."+      fi ;;+    unasked)+      prereqs_ok || exit 0+      # offer at most once per 24h in case the model never records an answer+      local asked; asked="$(st_get asked_at)"; local t; t="$(now)"+      if [ -z "$asked" ] || [ $((t - asked)) -gt 86400 ]; then+        st_set asked_at "$t"+        echo "adom: Claude Remote Control is not set up on this container yet. ONCE, before handling the user's request, offer it in your own words: it lets them open new AI threads on this Adom Hydrogen container from their phone (Claude mobile app) or claude.ai/code at any time, and Adom keeps the server alive automatically ($(env_name): $(if is_ah; then echo 'cron watchdog'; else echo 'checked on every prompt'; fi)). It needs their one-time OK. If they say yes run: claude-rc enable   If they say no run: claude-rc decline   Either way do not ask again."+      fi ;;+    *) : ;;  # declined / disabled: silent+  esac+  exit 0+}++cmd_enable() {+  st_set state enabled+  st_set enabled_at "$(now)"+  st_set launches ""+  st_set name "$(rc_name)"+  local how="prompt-hook watchdog (hc: no cron here)"+  if is_ah || has_cron; then+    if cron_register; then how="cron watchdog every 2 min + @reboot (ah)"; else how="prompt-hook watchdog (cron unavailable)"; fi+  fi+  if [ -n "$(running_pid)" ]; then+    echo "claude-rc: enabled; server already running (pid $(running_pid)); supervision: $how"+  else+    launch || true+    sleep 4+    if [ -n "$(running_pid)" ]; then+      echo "claude-rc: enabled and running as '$(rc_name)' (pid $(running_pid)); supervision: $how. It appears on claude.ai/code and the Claude mobile app within about a minute."+    else+      echo "claude-rc: enabled, but the server exited right away. Last output:"; tr -d '\r' < "$LOG" | grep -v '^\s*$' | tail -5+      echo "Usually: not logged in ('claude' first), or workspace trust not accepted in $PROJECT_DIR."+    fi+  fi+}+cmd_decline() { st_set state declined; st_set declined_at "$(now)"; cron_remove; echo "claude-rc: declined. The hook will not offer again; 'claude-rc enable' turns it on later."; }+cmd_disable() {+  st_set state disabled; cron_remove+  local p; p="$(running_pid)"+  if [ -n "$p" ]; then+    stop_server+    echo "claude-rc: disabled; stopped server pid $p and removed cron entries."+  else+    echo "claude-rc: disabled; cron entries removed."+  fi+}+cmd_status() {+  local p; p="$(running_pid)"+  echo "state:       $(state)"+  echo "env:         $(env_name) (ADOM_DESKTOP_MODE=${ADOM_DESKTOP_MODE:-unset}, cron: $(if has_cron; then echo yes; else echo no; fi), cron registered: $(if cron_registered; then echo yes; else echo no; fi))"+  echo "server:      $(if [ -n "$p" ]; then echo "running pid $p"; else echo "not running"; fi)"+  echo "name:        $(rc_name)"+  echo "project dir: $PROJECT_DIR"+  echo "prereqs:     $(if prereqs_ok; then echo ok; else echo "missing (claude on PATH + workspace trust accepted in $PROJECT_DIR)"; fi)"+  [ "$(state)" = failed ] && echo "fail reason: $(st_get fail_reason)"+  echo "log:         $LOG"+  [ -f "$LOG" ] && { echo "--- last lines:"; tr -d '\r' < "$LOG" | grep -v '^\s*$' | tail -4; }+  return 0+}+cmd_logs() { [ -f "$LOG" ] && tr -d '\r' < "$LOG" | grep -v '^\s*$' | tail -${1:-40}; }++case "${1:-status}" in+  hook)    cmd_hook ;;+  check)   check ;;+  enable)  cmd_enable ;;+  decline) cmd_decline ;;+  disable) cmd_disable ;;+  status)  cmd_status ;;+  logs)    cmd_logs "${2:-40}" ;;+  -h|--help|help) sed -n 2,24p "$0" ;;+  *) echo "claude-rc: unknown verb '$1' (hook|check|enable|decline|disable|status|logs)" >&2; exit 2 ;;+esac

@@ -12,6 +12,35 @@ mkdir -p "$HOOK_DIR" install -m 0755 "$PKG_DIR/check-updates.sh" "$HOOK" HOOK_CMD="bash $HOOK" +# --- claude-rc: the Remote Control keeper (adom/hook 1.3.0) --------------------+# Same machinery this package already owns (a UserPromptSubmit hook + cron), so it+# lives here rather than in a package of its own. It keeps `claude rc` alive so a+# user can open new AI threads on this container from the Claude mobile app or+# claude.ai/code. It is CONSENT-FIRST: installing only wires the offer; nothing+# runs until the user says yes in chat (see SKILL.md).+BIN_DIR="${HOME}/.local/bin"+RC="${BIN_DIR}/claude-rc"+RC_HOOK_CMD="$RC hook"+mkdir -p "$BIN_DIR"+install -m 0755 "$PKG_DIR/claude-rc" "$RC"++# Migrate the hand-rolled predecessor (a ~/.adom/hooks/claude-rc-watchdog.sh plus its+# own cron lines). Its presence IS consent -- the user asked for it explicitly -- so+# carry that over as enabled instead of re-asking.+RC_STATE="${HOME}/.adom/claude-rc.state"+LEGACY_RC="${HOOK_DIR}/claude-rc-watchdog.sh"+if [ -f "$LEGACY_RC" ] || crontab -l 2>/dev/null | grep -q "claude-rc-watchdog.sh"; then+  if command -v crontab >/dev/null 2>&1 && crontab -l 2>/dev/null | grep -q "claude-rc-watchdog.sh"; then+    { crontab -l 2>/dev/null | grep -v "claude-rc-watchdog.sh" || true; } | crontab - 2>/dev/null || true+  fi+  rm -f "$LEGACY_RC"+  if ! grep -q '^state=' "$RC_STATE" 2>/dev/null; then+    mkdir -p "$(dirname "$RC_STATE")"+    echo "state=enabled" >> "$RC_STATE"+    echo "  migrated the pre-package claude-rc watchdog (consent carried over as enabled)"+  fi+fi+ # Drop the stale launcher file from older adom/hook installs (now adom-core-update.sh). rm -f "${HOOK_DIR}/check-updates.sh" 2>/dev/null || true @@ -20,12 +49,13 @@ if ! command -v python3 >/dev/null 2>&1; then   exit 0 fi -# Wire HOOK_CMD into one agent config's hooks.UserPromptSubmit, removing any legacy-# auto-update hook first. $1 = config path, $2 = "1" to include a timeout field.+# Wire a command into one agent config's hooks.UserPromptSubmit, removing any legacy+# auto-update hook first. $1 = config path, $2 = "1" to include a timeout field,+# $3 = the command (defaults to the auto-update hook). wire() {-  local path="$1" with_timeout="$2"+  local path="$1" with_timeout="$2" cmd="${3:-$HOOK_CMD}"   mkdir -p "$(dirname "$path")"-  python3 - "$path" "$HOOK_CMD" "$with_timeout" <<'PY'+  python3 - "$path" "$cmd" "$with_timeout" <<'PY' import json, sys path, cmd, with_timeout = sys.argv[1], sys.argv[2], sys.argv[3] == "1" try:@@ -67,14 +97,21 @@ if changed:     with open(path, "w") as f:         json.dump(d, f, indent=2)     note = " (retired %d legacy hook(s))" % removed if removed else ""-    print("  wired adom-core-update into %s%s" % (path, note))+    print("  wired %s into %s%s" % (cmd.split("/")[-1].split()[0], path, note)) else:-    print("  adom-core-update already wired in %s" % path)+    print("  %s already wired in %s" % (cmd.split("/")[-1].split()[0], path)) PY }  wire "${HOME}/.claude/settings.json" 1 wire "${HOME}/.codex/hooks.json" 0+wire "${HOME}/.claude/settings.json" 1 "$RC_HOOK_CMD"+wire "${HOME}/.codex/hooks.json" 0 "$RC_HOOK_CMD"++# Re-assert supervision when consent already exists (re-install, image bake, migration).+if grep -q '^state=enabled' "$RC_STATE" 2>/dev/null; then+  "$RC" enable || true+fi  # --------------------------------------------------------------------------- # Headless trigger (adom/hook #1). UserPromptSubmit only fires inside Claude Code@@ -179,4 +216,4 @@ if [ -f "$PKG_DIR/SKILL.md" ]; then   cp "$PKG_DIR/SKILL.md" "$HOME/.claude/skills/adom-hook/SKILL.md" fi -echo "Installed adom-hook (auto-update wired for Claude + Codex; checks every ${ADOM_HOOK_INTERVAL:-1800}s)"+echo "Installed adom-hook (auto-update wired for Claude + Codex; checks every ${ADOM_HOOK_INTERVAL:-1800}s; claude-rc staged, offer on next prompt)"