create-egregore 0.19.33 → 0.20.0

package/runtime/prime/bin/codex-sync-skills.sh

@@ -0,0 +1,232 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+CLAUDE_DIR="$SCRIPT_DIR/.claude/skills"
+CODEX_DIR="$SCRIPT_DIR/.codex/skills"
+CHECK=0
+
+NATIVE_SKILLS=(
+  activity
+  handoff
+  wrap
+  announce
+  harvest
+  the-spiral
+  dashboard
+  deep-reflect
+  quest
+  invite
+  ask
+  save
+  search
+  view
+  scroll
+  plate
+)
+
+STRUCTURED_UX_SKILLS=(
+  activity
+  dashboard
+  handoff
+  wrap
+  todo
+  quest
+  project
+  issue
+  test
+  qa
+  checkup
+  infra
+  graph-maintain
+  telemetry-admin
+  waitlist
+  hosting
+  review-pr
+  triage
+  eval
+  eval-multiagent
+  summon
+  reflect
+  deep-reflect
+  archive
+  meeting
+  ingest-user-interview
+  harvest
+  tutorial
+  onboarding
+  emissary
+  launch-site
+  view
+  scroll
+  visual-explain
+  tui-design
+)
+
+GENERATED_MARKER='generated-by: bin/codex-sync-skills.sh'
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --check) CHECK=1; shift ;;
+    --help|-h)
+      echo "usage: bin/codex-sync-skills.sh [--check]"
+      exit 0
+      ;;
+    *) echo "unknown option: $1" >&2; exit 2 ;;
+  esac
+done
+
+is_native() {
+  local name="$1"
+  local native
+  for native in "${NATIVE_SKILLS[@]}"; do
+    [ "$name" = "$native" ] && return 0
+  done
+  return 1
+}
+
+is_structured_ux() {
+  local name="$1"
+  local structured
+  for structured in "${STRUCTURED_UX_SKILLS[@]}"; do
+    [ "$name" = "$structured" ] && return 0
+  done
+  return 1
+}
+
+skill_description() {
+  local file="$1"
+  awk '
+    NR == 1 && $0 == "---" { in_fm = 1; next }
+    in_fm && $0 == "---" { exit }
+    in_fm && /^description:/ {
+      sub(/^description:[[:space:]]*/, "")
+      gsub(/^"|"$/, "")
+      print
+      exit
+    }
+  ' "$file"
+}
+
+yaml_single_quote() {
+  local value="$1"
+  printf "'%s'" "$(printf '%s' "$value" | sed "s/'/''/g")"
+}
+
+render_adapter() {
+  local name="$1"
+  local source="$2"
+  local description="$3"
+  local structured="$4"
+  [ -n "$description" ] || description="Fallback Codex adapter for the Egregore ${name} workflow."
+  local description_yaml
+  description_yaml="$(yaml_single_quote "$description")"
+  cat <<EOF
+---
+name: ${name}
+description: ${description_yaml}
+---
+
+<!-- ${GENERATED_MARKER} -->
+
+# Egregore ${name} Adapter
+
+This is fallback coverage for a long-tail Egregore workflow that has not been
+ported to a hand-written Codex-native skill yet.
+
+Use the project shell and filesystem directly. Do not invoke Claude Code
+commands. Translate interactive choices to structured Codex question tooling
+when it is available; otherwise render compact numbered choices with an
+\`Other:\` option and wait for the user.
+
+EOF
+  if [ "$structured" = "1" ]; then
+    cat <<EOF
+## Structured UX parity
+
+This workflow has a Claude skill with user-visible structured output. After
+reading \`${source}\`, reproduce the same visible UX in Codex:
+
+- Preserve TUI boxes, markdown tables, rich cards, browser artifact rendering,
+  exact confirmation blocks, and "no preamble" rules from the source skill.
+- Use the source skill's frame width, section order, labels, status footer,
+  and examples as the contract for the final response.
+- Never replace a required box/table/card/artifact view with a prose summary
+  unless the user explicitly asks for a summary.
+- When the source says to output a TUI box directly, paste that box as the
+  visible response, preferably in a \`text\` fenced block.
+- Never show raw JSON, raw command output, or unformatted script output when
+  the source skill requires formatted status or rendered output.
+
+EOF
+  fi
+  cat <<EOF
+1. Read \`${source}\` for the workflow details.
+2. Run the referenced \`bin/\` scripts directly from Codex.
+3. Treat graph and publish steps as best-effort unless that workflow explicitly
+   says they are required.
+4. For every external notification, follow
+   \`.claude/context/notification-consent.md\`: plan without sending, then show
+   a separate exact Send / Edit / Cancel checkpoint. Never infer notification
+   consent from the workflow request or a batch approval.
+5. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when \`egregore.json\` declares \`"mode": "local"\`.
+6. Never call the deprecated \`egregore-handoff\` CLI for Egregore project
+   handoffs.
+EOF
+}
+
+[ -d "$CLAUDE_DIR" ] || { echo "missing Claude skills directory: $CLAUDE_DIR" >&2; exit 1; }
+mkdir -p "$CODEX_DIR"
+
+changed=0
+native_present=0
+adapter_present=0
+
+for native in "${NATIVE_SKILLS[@]}"; do
+  if [ -f "$CODEX_DIR/$native/SKILL.md" ]; then
+    native_present=$((native_present + 1))
+  else
+    echo "missing native Codex skill: $native" >&2
+    changed=1
+  fi
+done
+
+while IFS= read -r source_file; do
+  name="$(basename "$(dirname "$source_file")")"
+  is_native "$name" && continue
+
+  target_dir="$CODEX_DIR/$name"
+  target_file="$target_dir/SKILL.md"
+  if [ -f "$target_file" ] && ! grep -q "$GENERATED_MARKER" "$target_file" 2>/dev/null; then
+    continue
+  fi
+
+  description="$(skill_description "$source_file")"
+  rel_source=".claude/skills/$name/SKILL.md"
+  structured=0
+  is_structured_ux "$name" && structured=1
+  tmp="$(mktemp -t codex-skill-adapter-XXXXXX)"
+  render_adapter "$name" "$rel_source" "$description" "$structured" > "$tmp"
+
+  if [ ! -f "$target_file" ] || ! cmp -s "$tmp" "$target_file"; then
+    changed=1
+    if [ "$CHECK" = "1" ]; then
+      echo "adapter out of date: $name"
+    else
+      mkdir -p "$target_dir"
+      cp "$tmp" "$target_file"
+      echo "generated adapter: $name"
+    fi
+  fi
+  rm -f "$tmp"
+done < <(find "$CLAUDE_DIR" -mindepth 2 -maxdepth 2 -name SKILL.md | sort)
+
+adapter_present="$({ grep -rl "$GENERATED_MARKER" "$CODEX_DIR"/*/SKILL.md 2>/dev/null || true; } | wc -l | tr -d ' ')"
+
+if [ "$CHECK" = "1" ] && [ "$changed" -ne 0 ]; then
+  echo "codex skills out of sync (native: $native_present/${#NATIVE_SKILLS[@]}, adapters: $adapter_present)" >&2
+  exit 1
+fi
+
+echo "codex skills synced (native: $native_present/${#NATIVE_SKILLS[@]}, adapters: $adapter_present)"

package/runtime/prime/bin/connect-refresh.sh

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+# Refresh the Connect runtime overlay (skills served by the org's API) for
+# this instance. Fired fire-and-forget from session start on every runtime;
+# local-mode instances exit immediately and nothing here may block or break
+# a session. New Connect features appear without re-running the launcher.
+set -u
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+cd "$ROOT" || exit 0
+
+# Connected instances only — resolved the same way the runtime does.
+MODE=$(jq -r '.mode // empty' egregore.json 2>/dev/null)
+API_URL=$(jq -r '.api_url // empty' egregore.json 2>/dev/null)
+if [ "$MODE" != "connected" ] && [ -z "$API_URL" ]; then
+  exit 0
+fi
+
+LOG_DIR="$ROOT/.egregore"
+mkdir -p "$LOG_DIR" 2>/dev/null || true
+LOG="$LOG_DIR/connect-refresh.log"
+
+# The refresh logic lives in the installed create-egregore tooling (client
+# instances do not carry packages/ in their tree). --prefer-offline keeps the
+# common case fast; the first run may fetch the package once.
+{
+  echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] connect refresh"
+  npx --yes --prefer-offline create-egregore --refresh-connect 2>&1
+} >>"$LOG" 2>&1 || true
+
+# Keep the log bounded.
+tail -n 200 "$LOG" >"$LOG.tmp" 2>/dev/null && mv "$LOG.tmp" "$LOG" 2>/dev/null || true
+exit 0

package/runtime/prime/bin/dashboard-data.sh

@@ -0,0 +1,178 @@
+#!/usr/bin/env bash
+# Fetches personal dashboard data: single API call + parallel git ops.
+# Usage: bash bin/dashboard-data.sh [username] [time_range]
+# Returns a single JSON object with all query results.
+#
+# time_range: P1D (today), P7D (week, default), P30D (month), P365D (all)
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+TMPDIR=$(mktemp -d)
+trap "rm -rf $TMPDIR" EXIT
+
+# --- Read config ---
+API_URL=$(jq -r '.api_url // empty' "$SCRIPT_DIR/egregore.json" 2>/dev/null)
+API_KEY=$(grep '^EGREGORE_API_KEY=' "$SCRIPT_DIR/.env" 2>/dev/null | cut -d'=' -f2- || true)
+ORG=$(jq -r '.org_name // "Egregore"' "$SCRIPT_DIR/egregore.json" 2>/dev/null || echo "Egregore")
+DATE=$(date '+%b %d')
+
+# --- Detect user ---
+GH_USER="${1:-}"
+if [ -z "$GH_USER" ]; then
+  STATE_FILE="$SCRIPT_DIR/.egregore-state.json"
+  if [ -f "$STATE_FILE" ]; then
+    GH_USER=$(jq -r '.github_username // empty' "$STATE_FILE" 2>/dev/null)
+  fi
+  if [ -z "$GH_USER" ]; then
+    GH_USER=$(git -C "$SCRIPT_DIR" config user.name 2>/dev/null || echo "unknown")
+  fi
+fi
+
+# --- Time range (default P7D) ---
+TIME_RANGE="${2:-P7D}"
+
+# --- Read current session ID (client-side fallback for WAL-not-yet-drained) ---
+PROJ_HASH=$(echo -n "$SCRIPT_DIR" | md5 2>/dev/null || echo -n "$SCRIPT_DIR" | md5sum 2>/dev/null | cut -d' ' -f1)
+SESSION_ID=$(cat "$HOME/.egregore/session-${PROJ_HASH}.id" 2>/dev/null || echo "")
+
+# --- Fire API call + git ops in parallel ---
+
+# Graph data: single API call (all queries run server-side)
+(
+  GRAPH_STATUS="offline"
+  GRAPH_REASON=""
+  if [ -z "$API_URL" ] || [ -z "$API_KEY" ]; then
+    GRAPH_REASON="missing_config"
+  else
+    # Keep curl's transport status separate from %{http_code}; otherwise a
+    # failed request can concatenate 000 + fallback text and look like an
+    # unexpected API response.
+    CURL_STATUS=0
+    HTTP_CODE=$(curl -s -o "$TMPDIR/dashboard_raw.json" -w "%{http_code}" \
+      "${API_URL}/api/personal/dashboard?github_username=$(printf '%s' "$GH_USER" | jq -sRr @uri)&time_range=$(printf '%s' "$TIME_RANGE" | jq -sRr @uri)&session_id=$(printf '%s' "$SESSION_ID" | jq -sRr @uri)" \
+      -H "Authorization: Bearer $API_KEY" \
+      --connect-timeout 5 --max-time 15 2>/dev/null) || CURL_STATUS=$?
+
+    if [ "$CURL_STATUS" -ne 0 ] || [ "$HTTP_CODE" = "000" ] || ! [[ "$HTTP_CODE" =~ ^[0-9][0-9][0-9]$ ]]; then
+      GRAPH_REASON="unreachable"
+    elif [ "$HTTP_CODE" = "401" ] || [ "$HTTP_CODE" = "403" ]; then
+      GRAPH_REASON="auth_error"
+    elif [ "$HTTP_CODE" -ge 500 ] 2>/dev/null; then
+      GRAPH_REASON="server_error"
+    elif [ -s "$TMPDIR/dashboard_raw.json" ] && jq -e '.me' "$TMPDIR/dashboard_raw.json" >/dev/null 2>&1; then
+      cp "$TMPDIR/dashboard_raw.json" "$TMPDIR/dashboard.json"
+      GRAPH_STATUS="connected"
+    else
+      GRAPH_REASON="invalid_response"
+    fi
+  fi
+
+  # If not connected, write status-only response
+  if [ "$GRAPH_STATUS" != "connected" ]; then
+    jq -n --arg status "$GRAPH_STATUS" --arg reason "$GRAPH_REASON" \
+      '{graph_status: $status, graph_reason: $reason}' > "$TMPDIR/dashboard.json"
+  else
+    jq --arg status "$GRAPH_STATUS" '. + {graph_status: $status}' \
+      "$TMPDIR/dashboard.json" > "$TMPDIR/dashboard_merged.json" \
+      && mv "$TMPDIR/dashboard_merged.json" "$TMPDIR/dashboard.json"
+  fi
+) &
+API_PID=$!
+
+# Git: branch + dirty status (parallel, stays client-side)
+(
+  CURRENT=$(git -C "$SCRIPT_DIR" branch --show-current 2>/dev/null || echo "unknown")
+  DIRTY="false"
+  if [ -n "$(git -C "$SCRIPT_DIR" status --porcelain 2>/dev/null | head -1)" ]; then
+    DIRTY="true"
+  fi
+  jq -n --arg branch "$CURRENT" --argjson dirty "$DIRTY" \
+    '{branch: $branch, dirty: $dirty}' > "$TMPDIR/git.json"
+) &
+GIT_PID=$!
+
+# Local sessions: parse memory files when graph is offline (parallel)
+(
+  GH_LC=$(echo "$GH_USER" | tr '[:upper:]' '[:lower:]')
+  DISPLAY_LC=""
+  if [ -f "$SCRIPT_DIR/.egregore-state.json" ]; then
+    DISPLAY_LC=$(jq -r '.display_name // empty' "$SCRIPT_DIR/.egregore-state.json" 2>/dev/null | tr '[:upper:]' '[:lower:]')
+  fi
+
+  # Compute cutoff date from time range
+  case "$TIME_RANGE" in
+    P1D)   CUTOFF=$(date -v-1d +%Y-%m-%d 2>/dev/null || date -d '1 day ago' +%Y-%m-%d 2>/dev/null || echo "2000-01-01") ;;
+    P7D)   CUTOFF=$(date -v-7d +%Y-%m-%d 2>/dev/null || date -d '7 days ago' +%Y-%m-%d 2>/dev/null || echo "2000-01-01") ;;
+    P30D)  CUTOFF=$(date -v-30d +%Y-%m-%d 2>/dev/null || date -d '30 days ago' +%Y-%m-%d 2>/dev/null || echo "2000-01-01") ;;
+    P365D) CUTOFF="2000-01-01" ;;
+    *)     CUTOFF=$(date -v-7d +%Y-%m-%d 2>/dev/null || date -d '7 days ago' +%Y-%m-%d 2>/dev/null || echo "2000-01-01") ;;
+  esac
+
+  # Scan sessions, wraps, and handoffs for this user
+  for DIR in "$SCRIPT_DIR/memory/sessions" "$SCRIPT_DIR/memory/wraps" "$SCRIPT_DIR/memory/handoffs"; do
+    [ -d "$DIR" ] || continue
+    TYPE=$(basename "$DIR")
+    find -L "$DIR" -name '*.md' -not -name 'index*' -type f 2>/dev/null | xargs ls -t 2>/dev/null | head -20 | while read -r MFILE; do
+      [ -z "$MFILE" ] && continue
+      M_AUTH=$(head -10 "$MFILE" 2>/dev/null | grep -m1 '^\*\*Author\*\*:' | sed 's/^\*\*Author\*\*:[[:space:]]*//' || true)
+      [ -z "$M_AUTH" ] && continue
+      M_AUTH_LC=$(echo "$M_AUTH" | tr '[:upper:]' '[:lower:]')
+      # Filter to this user only
+      [ "$M_AUTH_LC" != "$GH_LC" ] && { [ -z "$DISPLAY_LC" ] || [ "$M_AUTH_LC" != "$DISPLAY_LC" ]; } && continue
+      M_DATE=$(head -10 "$MFILE" 2>/dev/null | grep -m1 '^\*\*Date\*\*:' | sed 's/^\*\*Date\*\*:[[:space:]]*//' || true)
+      M_DAY="${M_DATE%%T*}"
+      [ -n "$M_DAY" ] && [ "$M_DAY" \< "$CUTOFF" ] && continue
+      M_BRANCH=$(head -10 "$MFILE" 2>/dev/null | grep -m1 '^\*\*Branch\*\*:' | sed 's/^\*\*Branch\*\*:[[:space:]]*//' || true)
+      M_DURATION=$(head -10 "$MFILE" 2>/dev/null | grep -m1 '^\*\*Duration\*\*:' | sed 's/^\*\*Duration\*\*:[[:space:]]*//' || true)
+      M_TOPIC=$(head -3 "$MFILE" 2>/dev/null | grep -m1 '^# ' | sed 's/^# [^:]*:[[:space:]]*//' || true)
+      echo "${M_DATE}|${M_TOPIC}|${M_BRANCH}|${M_DURATION}|${TYPE}"
+    done
+  done | jq -Rn '
+    [inputs | split("|") |
+      {date: .[0], topic: .[1], branch: .[2], duration: .[3], type: .[4]}
+    ] | sort_by(.date) | reverse | {
+      sessions: .,
+      session_count: length
+    }
+  ' 2>/dev/null > "$TMPDIR/local_sessions.json" || echo '{"sessions":[],"session_count":0}' > "$TMPDIR/local_sessions.json"
+) &
+LOCAL_PID=$!
+
+# --- Wait for all ---
+wait $API_PID $GIT_PID $LOCAL_PID 2>/dev/null || true
+
+# --- Read results ---
+GIT_INFO=$(cat "$TMPDIR/git.json" 2>/dev/null || echo '{"branch":"unknown","dirty":false}')
+BRANCH=$(echo "$GIT_INFO" | jq -r '.branch' 2>/dev/null || echo "unknown")
+LOCAL_SESSIONS=$(cat "$TMPDIR/local_sessions.json" 2>/dev/null || echo '{"sessions":[],"session_count":0}')
+echo "$LOCAL_SESSIONS" | jq . >/dev/null 2>&1 || LOCAL_SESSIONS='{"sessions":[],"session_count":0}'
+
+# --- Client-side current session fallback ---
+# If the graph returned no current_session (WAL hasn't drained yet),
+# inject one from the local session ID file so the TUI always renders it.
+DASHBOARD=$(cat "$TMPDIR/dashboard.json" 2>/dev/null || echo '{"graph_status":"offline"}')
+CS_ID=$(echo "$DASHBOARD" | jq -r '.current_session.id // empty' 2>/dev/null)
+if [ -z "$CS_ID" ] && [ -n "$SESSION_ID" ]; then
+  DASHBOARD=$(echo "$DASHBOARD" | jq \
+    --arg sid "$SESSION_ID" \
+    --arg branch "$BRANCH" \
+    '.current_session = {id: $sid, status: "active", topic: null, branch: $branch}' 2>/dev/null || echo "$DASHBOARD")
+fi
+
+# --- Derive time range label ---
+case "$TIME_RANGE" in
+  P1D)   RANGE_LABEL="today" ;;
+  P7D)   RANGE_LABEL="last 7 days" ;;
+  P30D)  RANGE_LABEL="last 30 days" ;;
+  P365D) RANGE_LABEL="all time" ;;
+  *)     RANGE_LABEL="last 7 days" ;;
+esac
+
+# --- Merge server response + local data ---
+echo "$DASHBOARD" | jq \
+  --arg org "$ORG" \
+  --arg date "$DATE" \
+  --arg range_label "$RANGE_LABEL" \
+  --argjson git "$GIT_INFO" \
+  --argjson local_sessions "$LOCAL_SESSIONS" \
+  '. + {org: $org, date: $date, range_label: $range_label, git: $git, local_sessions: $local_sessions}'

package/runtime/prime/bin/graph-batch.sh

@@ -0,0 +1,79 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Execute multiple Cypher queries in a single HTTP call.
+# Usage: graph-batch.sh '<json array of {statement, parameters} objects>'
+#
+# Example:
+#   graph-batch.sh '[{"statement":"MATCH (p:Person) RETURN p.name"},{"statement":"MATCH (q:Quest) RETURN q.id"}]'
+#
+# Returns: {"results": [{...}, {...}]}
+
+SCRIPT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+CONFIG="$SCRIPT_DIR/egregore.json"
+
+if [ ! -f "$CONFIG" ]; then
+  echo "Error: egregore.json not found. Run onboarding first." >&2
+  exit 1
+fi
+
+# --- Local mode gate: bail immediately ---
+_MODE=$(jq -r '.mode // "connected"' "$CONFIG" 2>/dev/null)
+if [ "$_MODE" = "local" ]; then
+  echo '{"results":[]}'
+  exit 0
+fi
+
+# Load specific variables from .env if it exists (safe extraction, no arbitrary code execution).
+# A worktree missing its .env symlink resolves through worktree-links.sh, which
+# self-heals the link and falls back to the main checkout's .env.
+_ENV_FILE="$SCRIPT_DIR/.env"
+if [ ! -f "$_ENV_FILE" ] && [ -f "$SCRIPT_DIR/bin/lib/worktree-links.sh" ]; then
+  # shellcheck source=bin/lib/worktree-links.sh
+  source "$SCRIPT_DIR/bin/lib/worktree-links.sh" 2>/dev/null || true
+  _ENV_FILE="$(egregore_env_file "$SCRIPT_DIR" 2>/dev/null || true)"
+fi
+if [ -n "$_ENV_FILE" ] && [ -f "$_ENV_FILE" ]; then
+  EGREGORE_API_URL="${EGREGORE_API_URL:-$(grep '^EGREGORE_API_URL=' "$_ENV_FILE" 2>/dev/null | cut -d'=' -f2- || true)}"
+  EGREGORE_API_KEY="${EGREGORE_API_KEY:-$(grep '^EGREGORE_API_KEY=' "$_ENV_FILE" 2>/dev/null | cut -d'=' -f2- || true)}"
+fi
+
+API_URL="${EGREGORE_API_URL:-$(jq -r '.api_url // empty' "$CONFIG")}"
+API_KEY="${EGREGORE_API_KEY:-}"
+
+if [ -z "$API_URL" ]; then
+  # === OFFLINE MODE: no api_url configured (OSS/unconfigured) ===
+  echo '{"results":[]}'
+  exit 0
+fi
+
+if [ -z "$API_KEY" ]; then
+  # api_url is configured but no key was found — the local-mode gate exited
+  # above, so the org expects a live graph. Faking empty results here hides a
+  # missing .env (e.g. a worktree without its symlink) from every caller.
+  {
+    echo "Error: api_url is configured but EGREGORE_API_KEY is empty (looked in: ${_ENV_FILE:-$SCRIPT_DIR/.env})."
+    echo "  If this is a worktree, its .env symlink may be missing. Run /env to configure."
+  } >&2
+  exit 1
+fi
+
+QUERIES_JSON="${1:?Usage: graph-batch.sh '<json array of queries>'}"
+
+# Wrap the array into the batch request format
+BODY=$(jq -n --argjson queries "$QUERIES_JSON" '{queries: $queries}')
+
+RESPONSE=$(curl -s -X POST "${API_URL}/api/graph/batch" \
+  -H "Authorization: Bearer $API_KEY" \
+  -H "Content-Type: application/json" \
+  -d "$BODY" \
+  --max-time 60)
+
+# Check for HTTP-level errors
+if echo "$RESPONSE" | jq -e '.detail' >/dev/null 2>&1; then
+  echo "API error:" >&2
+  echo "$RESPONSE" | jq '.detail' >&2
+  exit 1
+fi
+
+echo "$RESPONSE"