mirror of
https://github.com/garrytan/gstack.git
synced 2026-11-17 13:44:32 +01:00
* Make gstack's shell locks hold when mkdir reports a race it lost (GST-2247) Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com> * Fix lock tests and fixtures for gstack_lock_take; trim setup-gbrain lock prose Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com> * Ship the lock helper with every copied runtime and fixture that runs a lock The Claude Code wrapper's copied runtime now includes bin/gstack-lock.sh, and bin/gstack-render-claude.sh sources it beside itself, so gstack-config set works in a copied runtime and the render lock is taken by every caller. Test fixtures that copy single bin scripts now copy the helper too, and the mkdir lock guard is registered as a repo-wide docs reader. Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com> * Release a lock whose owner file could not be fully written gstack_lock_take created the owner file with a noclobber redirect and, when that redirect failed, treated an existing file as a competing holder. If the file was created but the write then failed (disk full, quota, ulimit -f), the helper found its own empty file, returned 1 and left a lock nobody held; freeze's state lock has no stale recovery, so it stayed busy until removed by hand. The helper now tells "opened but write failed" from "already held", removes its own file and directory, and returns 3. The inline copy in gstack-ff-update is updated byte for byte, and a new test under ulimit -f 0 fails on the old helper. Review-Finding: s11/outside-voice#1 reader=outside-voice Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com> * Describe the lease lock as gstack_lock_take's O_EXCL owner file Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com> --------- Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>
415 lines
22 KiB
Bash
Executable File
415 lines
22 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# gstack-memorable — enable | disable | status for the Memorable recall bridge
|
|
# (hosts/claude/hooks/memorable-user-prompt-hook, a Claude Code UserPromptSubmit
|
|
# hook that hands each prompt to the third-party `memorable` CLI under gstack's
|
|
# consent key, receipts and trust envelope).
|
|
#
|
|
# Two independent facts make up the bridge's state, and this CLI is the only
|
|
# writer of both:
|
|
#
|
|
# registration (settings.json) gate (config.yaml memorable_recall)
|
|
# NONE ──enable──▶ GSTACK ──┐ off ──enable──▶ on
|
|
# ▲ │ Claude Code strips ▲ │
|
|
# └──── disable ──────────┘ the tag: still └─── disable ────┘
|
|
# (identity) GSTACK by identity
|
|
# VENDOR-OWN: `memorable install-hooks` registered its own hook. enable
|
|
# refuses (two entries would run the hook twice per prompt).
|
|
# Mismatches are reported by `status`, never silently repaired:
|
|
# gate on + NONE -> "gate on, no hook" (enable to fix)
|
|
# gate off + GSTACK -> "hook is inert" (disable removes it)
|
|
#
|
|
# What each verb hands to the vendor binary: nothing. enable/disable/status
|
|
# never execute `memorable`; they only check that it exists. The vendor's
|
|
# own consent (`memorable enable` / `disable` / `forget`) is yours to run.
|
|
#
|
|
# Style: `set -uo pipefail` WITHOUT -e (like bin/gstack-verify-gate). Every
|
|
# external call is checked explicitly with `|| return N`, so a failure is
|
|
# reported where it happens and partial states are never reported as success.
|
|
#
|
|
# Exit codes: 0 ok · 1 refused / usage · 3 settings.json unparseable ·
|
|
# 4 unexpected settings shape · 5 could not acquire the lock
|
|
# (the hook manager's own codes, passed through).
|
|
# Heredoc delivery guard (see bin/gstack-settings-hook for the rationale).
|
|
BASH_COMPAT=50
|
|
set -uo pipefail
|
|
GSTACK_BUN_CONFIG=/dev/null; case "${OSTYPE:-}" in msys*|cygwin*) if command -v cygpath >/dev/null 2>&1; then GSTACK_BUN_CONFIG=NUL; fi ;; esac
|
|
|
|
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
|
|
ROOT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
|
|
GSTACK_CONFIG="$SCRIPT_DIR/gstack-config"
|
|
. "$(dirname "$0")/gstack-state-root.sh" 2>/dev/null || { echo "$0: cannot resolve the gstack state root: $(dirname "$0")/gstack-state-root.sh is missing. fix: reinstall with ./setup or /gstack-upgrade (docs/state-root.md)" >&2; exit 1; }
|
|
. "$(dirname "$0")/gstack-claude-root.sh" || { echo "$0: $(dirname "$0")/gstack-claude-root.sh is missing. fix: reinstall with ./setup or /gstack-upgrade" >&2; exit 1; }
|
|
gstack_state_root_select
|
|
STATE_DIR="$_gstack_sr_root"
|
|
SETTINGS_FILE="${GSTACK_SETTINGS_FILE:-${CLAUDE_CONFIG_DIR:-$HOME/.claude}/settings.json}"
|
|
|
|
HOOK_SOURCE="gstack-memorable"
|
|
CONFIG_KEY="memorable_recall"
|
|
SINK="memorable-recall"
|
|
HOOK_REL="hosts/claude/hooks/memorable-user-prompt-hook"
|
|
RESOLUTION_ORDER="GSTACK_MEMORABLE_BIN, MEMORABLE_BIN, ~/.memorable/bin/memorable, PATH"
|
|
# JavaScript RegExp (applied by gstack-settings-hook list-items to items no
|
|
# KNOWN_HOOKS row owns). Matches the vendor installer's own registration,
|
|
# verified against memorable-cli 0.5.18: "<HOME>/.memorable/bin/memorable" hook user-prompt
|
|
VENDOR_OWN_RE='[Mm]emorable.*hook\s+user-prompt'
|
|
|
|
# Canonical install root — the hook command MUST point at the stable install,
|
|
# never at the tree this CLI happens to run from (setup's phantom-hooks rule).
|
|
# Setup registers through the same helper, so both write one path.
|
|
CANONICAL_GSTACK_ROOT="$(gstack_canonical_claude_root)"
|
|
HOOK_CMD_PATH="$CANONICAL_GSTACK_ROOT/$HOOK_REL"
|
|
# Mutations go through the CANONICAL hook manager so the code that registers
|
|
# is the code that will run. Every verb falls back to this tree's copy when the
|
|
# canonical one is missing (enable cannot get past compat_check then; disable
|
|
# and status must still work against a half-removed install).
|
|
SETTINGS_HOOK="$CANONICAL_GSTACK_ROOT/bin/gstack-settings-hook"
|
|
[ -x "$SETTINGS_HOOK" ] || SETTINGS_HOOK="$SCRIPT_DIR/gstack-settings-hook"
|
|
EGRESS_BIN="$CANONICAL_GSTACK_ROOT/bin/gstack-egress"
|
|
[ -x "$EGRESS_BIN" ] || EGRESS_BIN="$SCRIPT_DIR/gstack-egress"
|
|
|
|
# Platform detection copied from setup:76-79 (TODO D24). Windows support for
|
|
# this bridge is deferred whole (no process groups to contain the vendor).
|
|
IS_WINDOWS=0
|
|
case "${GSTACK_MEMORABLE_TEST_UNAME:-$(uname -s)}" in
|
|
MINGW*|MSYS*|CYGWIN*|Windows_NT) IS_WINDOWS=1 ;;
|
|
esac
|
|
|
|
usage() {
|
|
cat <<USAGE
|
|
Usage: gstack-memorable <enable|disable|status>
|
|
|
|
enable Register gstack's Memorable UserPromptSubmit hook (canonical path,
|
|
timeout 5) and set memorable_recall=on. Never runs \`memorable enable\`.
|
|
disable Set memorable_recall=off, remove gstack's hook entry (by identity,
|
|
tag or no tag), verify both. Never runs \`memorable disable\`.
|
|
status Read-only: vendor CLI, gate, registration, receipts, recent errors.
|
|
|
|
Vendor CLI resolution: $RESOLUTION_ORDER.
|
|
USAGE
|
|
}
|
|
|
|
_err() { printf 'gstack-memorable: %s\n' "$*" >&2; }
|
|
|
|
# ─── lock: one lifecycle transition at a time ────────────────────────────
|
|
LOCK_DIR="$STATE_DIR/locks/memorable-bridge.lock"
|
|
LOCK_STALE_S=30 # a holder older than this is a crashed writer
|
|
LOCK_TRIES="${GSTACK_MEMORABLE_LOCK_TRIES:-50}" # x LOCK_SLEEP = the 5 s give-up; tests shrink it
|
|
case "$LOCK_TRIES" in ''|*[!0-9]*) LOCK_TRIES=50 ;; esac
|
|
LOCK_SLEEP=0.1
|
|
LOCK_HELD=0
|
|
_lock_release() {
|
|
[ "$LOCK_HELD" -eq 1 ] || return 0
|
|
if [ "$(cat "$LOCK_DIR/owner" 2>/dev/null)" = "$$" ]; then rm -rf "$LOCK_DIR"; fi
|
|
LOCK_HELD=0
|
|
}
|
|
_lock_acquire() {
|
|
mkdir -p "$STATE_DIR/locks" 2>/dev/null || { _err "cannot create $STATE_DIR/locks (state directory not writable; nothing can be recorded there)"; return 5; }
|
|
local tries=0 mtime now stale judged moved owner_pid
|
|
. "$SCRIPT_DIR/gstack-lock.sh" 2>/dev/null || { _err "$SCRIPT_DIR/gstack-lock.sh is missing (fix: reinstall with ./setup or /gstack-upgrade)"; return 5; }
|
|
while ! gstack_lock_take "$LOCK_DIR" owner "$$"; do
|
|
tries=$((tries + 1))
|
|
# Staleness from the directory's own mtime (set by the holder's mkdir and
|
|
# owner create), never from the owner's content: a contender that looks in
|
|
# the gap between mkdir and the owner file must wait, not reclaim. The
|
|
# owner file is the lock (gstack_lock_take creates it with O_EXCL, since
|
|
# mkdir's exit status is not a lock on Ubuntu 26.04's uutils mkdir). GNU stat
|
|
# first, BSD stat second, garbage -> no takeover (same idiom as
|
|
# bin/gstack-settings-hook).
|
|
mtime="$(stat -c %Y "$LOCK_DIR" 2>/dev/null || stat -f %m "$LOCK_DIR" 2>/dev/null || echo "")"
|
|
case "$mtime" in *[!0-9]*|"") mtime="" ;; esac
|
|
now="$(date +%s)"
|
|
# A holder whose recorded pid is still alive is slow, not crashed: wait.
|
|
owner_pid="$(cat "$LOCK_DIR/owner" 2>/dev/null || echo "")"
|
|
case "$owner_pid" in *[!0-9]*|"") owner_pid="" ;; esac
|
|
if [ -n "$owner_pid" ] && kill -0 "$owner_pid" 2>/dev/null; then mtime=""; fi
|
|
if [ -n "$mtime" ] && [ $((now - mtime)) -gt "$LOCK_STALE_S" ]; then
|
|
# Atomic rename: exactly one contender reclaims a stale lock; the loser
|
|
# loops and re-contends against the winner's fresh mkdir. The inode
|
|
# check closes the gap between judging and renaming: a contender that
|
|
# judged the OLD directory stale must not carry off the FRESH one a
|
|
# faster contender just created in its place. A rename that fails
|
|
# (locks dir not writable by this user) falls through to the give-up
|
|
# counter below instead of spinning.
|
|
judged="$(stat -c %i "$LOCK_DIR" 2>/dev/null || stat -f %i "$LOCK_DIR" 2>/dev/null || echo "")"
|
|
stale="$LOCK_DIR.stale.$$-$RANDOM"
|
|
if mv "$LOCK_DIR" "$stale" 2>/dev/null; then
|
|
moved="$(stat -c %i "$stale" 2>/dev/null || stat -f %i "$stale" 2>/dev/null || echo "")"
|
|
if [ -n "$judged" ] && [ "$moved" = "$judged" ]; then
|
|
rm -rf "$stale" 2>/dev/null || true
|
|
else
|
|
# Not the directory we judged: a fresh holder's lock. Put it back.
|
|
mv "$stale" "$LOCK_DIR" 2>/dev/null || _err "lock bookkeeping: could not restore a fresh lock moved aside at $stale"
|
|
fi
|
|
continue
|
|
fi
|
|
fi
|
|
if [ "$tries" -ge "$LOCK_TRIES" ]; then _err "another gstack-memorable is running (lock $LOCK_DIR; stale but not reclaimable if older than ${LOCK_STALE_S}s); try again"; return 5; fi
|
|
sleep "$LOCK_SLEEP"
|
|
done
|
|
LOCK_HELD=1
|
|
trap _lock_release EXIT
|
|
}
|
|
|
|
# ─── probes (read-only) ──────────────────────────────────────────────────
|
|
resolve_memorable() {
|
|
local override="${GSTACK_MEMORABLE_BIN:-${MEMORABLE_BIN:-}}"
|
|
if [ -n "$override" ]; then
|
|
override="${override%\"}"; override="${override#\"}"
|
|
case "$override" in
|
|
/*) [ -f "$override" ] && [ -x "$override" ] && { printf '%s\n' "$override"; return 0; } ;;
|
|
*) command -v "$override" 2>/dev/null && return 0 ;;
|
|
esac
|
|
return 1 # an explicit override that does not resolve is an error, never a fall-through
|
|
fi
|
|
if [ -n "${HOME:-}" ] && [ -f "$HOME/.memorable/bin/memorable" ] && [ -x "$HOME/.memorable/bin/memorable" ]; then
|
|
printf '%s\n' "$HOME/.memorable/bin/memorable"; return 0
|
|
fi
|
|
command -v memorable 2>/dev/null
|
|
}
|
|
|
|
# Gate value or "unknown" (gstack-config missing/failed).
|
|
gate_value() {
|
|
local v
|
|
v="$("$GSTACK_CONFIG" get "$CONFIG_KEY" 2>/dev/null)" || { echo unknown; return 0; }
|
|
printf '%s\n' "${v:-off}"
|
|
}
|
|
|
|
# Registration state via the hook manager's identity view. Sets:
|
|
# REG_STATE none | gstack | vendor | both | unparseable | shape | unreadable
|
|
# REG_GSTACK newline-separated JSON string literals of gstack-owned commands
|
|
# REG_VENDOR newline-separated JSON string literals of the vendor's own commands
|
|
REG_STATE=""; REG_GSTACK=""; REG_VENDOR=""
|
|
registration_state() {
|
|
local rc
|
|
REG_GSTACK="$("$SETTINGS_HOOK" list-items --event UserPromptSubmit --owned-by "$HOOK_SOURCE" 2>/dev/null)"; rc=$?
|
|
case "$rc" in
|
|
0) ;;
|
|
3) REG_STATE="unparseable"; return 0 ;;
|
|
4) REG_STATE="shape"; return 0 ;;
|
|
*) REG_STATE="unreadable"; return 0 ;;
|
|
esac
|
|
REG_VENDOR="$("$SETTINGS_HOOK" list-items --event UserPromptSubmit --command-regex "$VENDOR_OWN_RE" 2>/dev/null)"; rc=$?
|
|
[ "$rc" -eq 0 ] || { REG_STATE="unreadable"; return 0; }
|
|
if [ -n "$REG_GSTACK" ] && [ -n "$REG_VENDOR" ]; then REG_STATE="both"
|
|
elif [ -n "$REG_GSTACK" ]; then REG_STATE="gstack"
|
|
elif [ -n "$REG_VENDOR" ]; then REG_STATE="vendor"
|
|
else REG_STATE="none"; fi
|
|
}
|
|
_reg_exit_code() {
|
|
case "$REG_STATE" in unparseable) echo 3 ;; shape) echo 4 ;; *) echo 1 ;; esac
|
|
}
|
|
_reg_problem_text() {
|
|
case "$REG_STATE" in
|
|
unparseable) echo "$SETTINGS_FILE is not valid JSON (fix or restore it; see gstack-settings-hook rollback)" ;;
|
|
shape) echo "$SETTINGS_FILE has an unexpected shape under hooks.UserPromptSubmit (not an array)" ;;
|
|
unreadable) echo "the hook manager could not read $SETTINGS_FILE" ;;
|
|
esac
|
|
}
|
|
|
|
# The canonical install must carry THIS bridge: a worktree CLI registering an
|
|
# older hook at the stable path would run code without the gate or receipts.
|
|
compat_check() {
|
|
[ -x "$HOOK_CMD_PATH" ] || { _err "no stable install carries the bridge hook at $HOOK_CMD_PATH; run ./setup (or /gstack-upgrade) first"; return 1; }
|
|
[ -f "$HOOK_CMD_PATH.ts" ] || { _err "the stable install at $CANONICAL_GSTACK_ROOT predates this bridge (no memorable-user-prompt-hook.ts); run ./setup first"; return 1; }
|
|
local here there
|
|
here="$(cat "$ROOT_DIR/VERSION" 2>/dev/null)"; there="$(cat "$CANONICAL_GSTACK_ROOT/VERSION" 2>/dev/null)"
|
|
if [ -n "$here" ] && [ "$here" != "$there" ]; then
|
|
_err "the stable install at $CANONICAL_GSTACK_ROOT is version '${there:-unknown}' but this tree is '$here'; run ./setup so the registered hook is the code that will run"
|
|
return 1
|
|
fi
|
|
# Captured, not piped: under pipefail the probe's own non-zero exit would
|
|
# mask a matching grep and let an old hook manager through.
|
|
local probe
|
|
probe="$("$SETTINGS_HOOK" list-items 2>&1)" || true
|
|
if printf '%s' "$probe" | grep -q "Unknown action"; then
|
|
_err "the stable install's hook manager does not know list-items; run ./setup first"; return 1
|
|
fi
|
|
return 0
|
|
}
|
|
|
|
# ─── enable ──────────────────────────────────────────────────────────────
|
|
enable_bridge() {
|
|
local vendor prior_gate ensure_out ensure_rc verb
|
|
_lock_acquire || return $?
|
|
[ -x "$SETTINGS_HOOK" ] || { _err "missing hook manager: $SETTINGS_HOOK"; return 1; }
|
|
[ -x "$GSTACK_CONFIG" ] || { _err "missing $GSTACK_CONFIG"; return 1; }
|
|
if [ "$IS_WINDOWS" -eq 1 ]; then
|
|
_err "Windows is not supported by the Memorable bridge yet (no way to contain the vendor process); tracked in TODOS.md: Windows support for the Memorable bridge (D21)"
|
|
return 1
|
|
fi
|
|
vendor="$(resolve_memorable)" || { _err "Memorable CLI not found (checked $RESOLUTION_ORDER). Install it yourself: npm i -g memorable-cli. gstack never installs it."; return 1; }
|
|
compat_check || return 1
|
|
|
|
prior_gate="$(gate_value)"
|
|
registration_state
|
|
case "$REG_STATE" in
|
|
unparseable|shape|unreadable) _err "cannot read the current registration: $(_reg_problem_text)"; return "$(_reg_exit_code)" ;;
|
|
vendor|both)
|
|
cat >&2 <<REFUSE
|
|
gstack-memorable: Memorable already registers this hook itself:
|
|
$(printf '%s\n' "$REG_VENDOR" | sed 's/^/ /')
|
|
|
|
Registering gstack's as well would run the hook twice on every prompt:
|
|
injected twice, and the session captured twice against your allowance.
|
|
|
|
Keep the one you have, or hand it to gstack: delete that entry from
|
|
$SETTINGS_FILE
|
|
and run this again. Memorable has no command that removes its own hook.
|
|
REFUSE
|
|
return 1 ;;
|
|
esac
|
|
|
|
ensure_out="$("$SETTINGS_HOOK" ensure-event --event UserPromptSubmit --command "$HOOK_CMD_PATH" --source "$HOOK_SOURCE" --timeout 5 2>&1)"; ensure_rc=$?
|
|
if [ "$ensure_rc" -ne 0 ]; then
|
|
_err "settings hook update failed: $(printf '%s\n' "$ensure_out" | head -1): run $SETTINGS_HOOK manually (nothing changed; the gate is still '$prior_gate')"
|
|
return "$ensure_rc"
|
|
fi
|
|
case "$ensure_out" in
|
|
*unchanged*) verb="unchanged" ;;
|
|
*re-pointed*) verb="re-pointed" ;;
|
|
*) verb="registered" ;;
|
|
esac
|
|
|
|
if ! "$GSTACK_CONFIG" set "$CONFIG_KEY" on >/dev/null 2>&1; then
|
|
# Restore the CAPTURED prior state, never an assumed one: a registration
|
|
# that predates this run stays; the gate goes back to what it was.
|
|
if [ "$verb" = "registered" ] && [ "$REG_STATE" = "none" ]; then
|
|
"$SETTINGS_HOOK" remove-source --source "$HOOK_SOURCE" >/dev/null 2>&1 || true
|
|
fi
|
|
case "$prior_gate" in on|off) "$GSTACK_CONFIG" set "$CONFIG_KEY" "$prior_gate" >/dev/null 2>&1 || true ;; esac
|
|
_err "could not record consent (gstack-config set $CONFIG_KEY on failed); a registration made by this run was removed, a pre-existing one was kept; gate is '$prior_gate'"
|
|
return 1
|
|
fi
|
|
|
|
cat <<DONE
|
|
gstack-memorable: enabled.
|
|
hook: $verb ($HOOK_CMD_PATH, timeout 5 s, source $HOOK_SOURCE)
|
|
consent: $CONFIG_KEY=on (gstack's gate; revoke: gstack-memorable disable)
|
|
vendor: $vendor
|
|
|
|
What gstack hands to that binary on every prompt: Claude Code's UserPromptSubmit
|
|
JSON (session_id, cwd, transcript_path, prompt), unless it carries a HIGH-tier
|
|
credential shape or the repo's trust policy is deny/read-only. The binary runs
|
|
with your privileges in an allowlisted environment and its own process group.
|
|
Each hand-off is receipted first: gstack-egress list --sink $SINK
|
|
What the binary then sends is Memorable's claim, not gstack's.
|
|
|
|
Claude Code picks up the new hook automatically within a few seconds; if it does
|
|
not fire, restart the session. Verify with: gstack-memorable status
|
|
Memorable's own capture consent is separate and yours to run or inspect:
|
|
memorable status | memorable enable | memorable disable | memorable forget
|
|
DONE
|
|
}
|
|
|
|
# ─── disable ─────────────────────────────────────────────────────────────
|
|
disable_bridge() {
|
|
local gate_rc=0 remove_rc=0 remove_out="" gate_after
|
|
_lock_acquire || return $?
|
|
# Gate first: the hook reads it on every prompt, so consent is revoked
|
|
# immediately even if the registration removal below fails. A missing
|
|
# gstack-config (half-removed install) is reported, and the removal still
|
|
# runs: the hook fails closed without gstack-config, the entry must still go.
|
|
if [ -x "$GSTACK_CONFIG" ]; then
|
|
"$GSTACK_CONFIG" set "$CONFIG_KEY" off >/dev/null 2>&1 || gate_rc=$?
|
|
else
|
|
_err "missing $GSTACK_CONFIG"; gate_rc=1
|
|
fi
|
|
if [ -x "$SETTINGS_HOOK" ]; then
|
|
remove_out="$("$SETTINGS_HOOK" remove-source --source "$HOOK_SOURCE" 2>&1)" || remove_rc=$?
|
|
else
|
|
_err "missing hook manager: $SETTINGS_HOOK"; remove_rc=1
|
|
fi
|
|
# Verify BOTH resulting states; report each, never a blended "done".
|
|
gate_after="$(gate_value)"
|
|
registration_state
|
|
local ok=0
|
|
if [ "$gate_rc" -eq 0 ] && [ "$gate_after" = "off" ]; then
|
|
echo "consent: $CONFIG_KEY=off"
|
|
else
|
|
_err "consent: could not set $CONFIG_KEY=off (gstack-config exit $gate_rc, value now '$gate_after')"; ok=1
|
|
fi
|
|
case "$REG_STATE" in
|
|
none|vendor)
|
|
if [ "$remove_rc" -eq 0 ]; then echo "hook: removed (${remove_out##*OK: })"
|
|
else echo "hook: no gstack entry remains (the hook manager exited $remove_rc: $(printf '%s\n' "$remove_out" | head -1))"; fi ;;
|
|
gstack|both)
|
|
_err "hook: a gstack-owned entry survived in $SETTINGS_FILE:"; printf '%s\n' "$REG_GSTACK" | sed 's/^/ /' >&2; ok=1 ;;
|
|
*) _err "hook: cannot verify removal: $(_reg_problem_text)"; ok=$(_reg_exit_code) ;;
|
|
esac
|
|
[ "$remove_rc" -eq 0 ] || { [ "$remove_rc" -ge 3 ] && ok=$remove_rc; }
|
|
if resolve_memorable >/dev/null 2>&1; then
|
|
echo "Memorable's own consent is unchanged; to stop or erase capture: memorable disable | memorable forget"
|
|
else
|
|
echo "Memorable CLI not found: nothing of the vendor's to revoke here (gstack's hook entry is gone)"
|
|
fi
|
|
echo "In-flight prompts that already passed the gate complete; the next prompt is off."
|
|
return "$ok"
|
|
}
|
|
|
|
# ─── status (read-only; never executes the vendor) ───────────────────────
|
|
status_bridge() {
|
|
local vendor gate n
|
|
if ! command -v bun >/dev/null 2>&1; then
|
|
echo "bun: missing (the hook manager and the hook itself need bun; install bun first)"
|
|
fi
|
|
if vendor="$(resolve_memorable)"; then
|
|
echo "Memorable CLI: available ($vendor); tested against the memorable-cli 0.5.18 hook contract"
|
|
else
|
|
echo "Memorable CLI: not found (checked $RESOLUTION_ORDER)"
|
|
fi
|
|
gate="$(gate_value)"
|
|
echo "memorable_recall: $gate"
|
|
registration_state
|
|
case "$REG_STATE" in
|
|
none) echo "Claude UserPromptSubmit hook: not registered" ;;
|
|
gstack) echo "Claude UserPromptSubmit hook: registered by gstack"; printf '%s\n' "$REG_GSTACK" | sed 's/^/ /' ;;
|
|
vendor) echo "Claude UserPromptSubmit hook: registered by Memorable itself"; printf '%s\n' "$REG_VENDOR" | sed 's/^/ /'
|
|
echo " gstack is not managing it; 'gstack-memorable enable' would refuse (it would double the hook)." ;;
|
|
both) echo "Claude UserPromptSubmit hook: registered by BOTH gstack and Memorable (the hook runs twice per prompt; remove one)"
|
|
printf '%s\n' "$REG_GSTACK" "$REG_VENDOR" | sed 's/^/ /' ;;
|
|
*) echo "Claude UserPromptSubmit hook: unknown ($(_reg_problem_text))" ;;
|
|
esac
|
|
if [ "$gate" = "on" ] && [ "$REG_STATE" = "none" ]; then echo "mismatch: gate on, no hook registered (run: gstack-memorable enable)"; fi
|
|
if [ "$gate" != "on" ] && { [ "$REG_STATE" = "gstack" ] || [ "$REG_STATE" = "both" ]; }; then echo "mismatch: hook registered but gate is '$gate' (hook is inert; run: gstack-memorable disable to remove it)"; fi
|
|
if [ "$IS_WINDOWS" -eq 1 ]; then echo "platform: Windows is not supported by this bridge yet (TODOS.md: Windows support for the Memorable bridge, D21)"; fi
|
|
if [ -x "$EGRESS_BIN" ] && command -v bun >/dev/null 2>&1; then
|
|
# Count the filtered array, not a formatting artefact of the pretty-printed
|
|
# JSON; a failed query is reported as unknown, never as an empty history.
|
|
local egress_json
|
|
if egress_json="$("$EGRESS_BIN" list --sink "$SINK" --json 2>/dev/null)"; then
|
|
n="$(printf '%s' "$egress_json" | bun --no-env-file --config="${GSTACK_BUN_CONFIG:-/dev/null}" -e 'const a=JSON.parse(require("fs").readFileSync(0,"utf8")||"[]");console.log(Array.isArray(a)?a.length:0)' 2>/dev/null)"
|
|
case "$n" in *[!0-9]*|"") n="unknown (could not parse gstack-egress output)" ;; esac
|
|
else
|
|
n="unknown (gstack-egress list failed; run it yourself)"
|
|
fi
|
|
echo "receipts: $n for sink $SINK (gstack-egress list --sink $SINK)"
|
|
# Same root lib/egress-receipt.ts resolveEgressHome uses (the shared state-root chain).
|
|
local ledger size
|
|
ledger="$STATE_DIR/security/egress.jsonl"
|
|
if [ -f "$ledger" ]; then
|
|
size="$(wc -c < "$ledger" | tr -d ' ')"
|
|
if [ "${size:-0}" -gt 26214400 ]; then
|
|
echo "ledger: $ledger ($((size / 1048576)) MiB; above the 25 MiB warning, rotation is a filed TODO: this sink appends two lines per prompt)"
|
|
else
|
|
echo "ledger: $ledger ($(( (size + 1023) / 1024 )) KiB; this sink appends two lines per prompt)"
|
|
fi
|
|
fi
|
|
fi
|
|
if [ -f "$STATE_DIR/hook-errors.log" ]; then
|
|
n="$(grep -c 'memorable-user-prompt-hook' "$STATE_DIR/hook-errors.log" 2>/dev/null || true)"
|
|
if [ "${n:-0}" -gt 0 ]; then
|
|
echo "recent hook errors ($STATE_DIR/hook-errors.log):"
|
|
grep 'memorable-user-prompt-hook' "$STATE_DIR/hook-errors.log" | tail -3 | sed 's/^/ /'
|
|
fi
|
|
fi
|
|
return 0
|
|
}
|
|
|
|
case "${1:-}" in
|
|
enable) enable_bridge ;;
|
|
disable) disable_bridge ;;
|
|
status) status_bridge ;;
|
|
-h|--help|help) usage ;;
|
|
*) usage >&2; exit 1 ;;
|
|
esac
|