mirror of
https://github.com/garrytan/gstack.git
synced 2026-11-17 21:54:30 +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>
1028 lines
49 KiB
Bash
Executable File
1028 lines
49 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# gstack-settings-hook — manage Claude Code hooks in ~/.claude/settings.json
|
|
#
|
|
# Three shapes:
|
|
#
|
|
# 1. Legacy (SessionStart only — kept so old installs still clean up):
|
|
# gstack-settings-hook add <cmd> # adds SessionStart hook
|
|
# gstack-settings-hook remove <cmd> # removes gstack-session-update items
|
|
# # (the <cmd> arg is accepted for
|
|
# # interface compat; matching is by
|
|
# # the gstack-session-update basename)
|
|
#
|
|
# 2. Schema-aware (plan-tune cathedral T3):
|
|
# gstack-settings-hook add-event --event <name — see the validator in add-event> \
|
|
# --command <cmd> --source <tag> [--matcher <regex>] [--timeout <s>]
|
|
# gstack-settings-hook ensure-event --event ... --command ... --source ... [--matcher ...] [--timeout <s>]
|
|
# gstack-settings-hook remove-source --source <tag> [--event <name>]
|
|
# # removes items the table identifies as <tag>'s, tagged or not
|
|
# gstack-settings-hook diff-event --event ... --command ... --source ... [--matcher ...]
|
|
# gstack-settings-hook rollback # restore latest backup (single-step undo)
|
|
# gstack-settings-hook list-sources # show all gstack-tagged hook entries
|
|
# gstack-settings-hook list-items --event <name> [--owned-by <tag>] [--command-regex <js-re>]
|
|
# # read-only: one JSON string literal per matching hook COMMAND
|
|
# # (identity via KNOWN_HOOKS, never the tag); empty stdout = none
|
|
#
|
|
# 3. Self-heal (phantom-hooks fix):
|
|
# gstack-settings-hook prune-stale # prune dead gstack hook items
|
|
# gstack-settings-hook prune-stale --repoint <root> # re-point gstack items at <root>, prune still-dead
|
|
# gstack-settings-hook prune-stale --all # remove ALL gstack hook items (uninstall sweep)
|
|
#
|
|
# ensure-event is the update-in-place verb: same flags as add-event, but keyed
|
|
# on (event, source) — any entry carrying our source tag for the event is THE
|
|
# registration to compare/update, so a matcher change re-points in place
|
|
# instead of pushing a second entry, and duplicate same-source twins from the
|
|
# old matcher-keyed dedup collapse to one (reported on stderr). Identical
|
|
# payload → no write, no backup ("unchanged"); a re-run of ./setup stays a
|
|
# true no-op. This heals a stale absolute hook path (e.g. a deleted dev
|
|
# worktree) baked into settings.json by an earlier setup.
|
|
#
|
|
# Ownership model (KNOWN_HOOKS identity table): a hook ITEM is gstack-owned iff
|
|
# its command basename + relpath suffix + event (+ matcher where the table row
|
|
# defines one) match a table row. Entry-level `_gstack_source` tags are
|
|
# best-effort metadata — Claude Code strips unknown keys when it rewrites
|
|
# settings.json, so identity is intrinsic (the table), never tag-only. A tag
|
|
# NEVER claims foreign items: in a tagged multi-item entry, unrecognized items
|
|
# are always preserved; only a tagged SINGLE-item entry with no table match is
|
|
# treated as an owned legacy stray.
|
|
#
|
|
# Mutation safety:
|
|
# - every mutation runs under a lock directory (<settings>.lock/) whose owner
|
|
# token file is created with O_EXCL (gstack_lock_take, bin/gstack-lock.sh;
|
|
# mkdir's exit status is not a lock on Ubuntu 26.04's uutils mkdir);
|
|
# release is ownership-checked; stale locks (>30s) are taken over
|
|
# via atomic rename. On lock give-up the mutation is SKIPPED with a warning
|
|
# (the next setup retries — the system is convergent).
|
|
# - parse failure fails CLOSED: a corrupt settings.json is never overwritten
|
|
# (only ENOENT starts fresh). Exit 3.
|
|
# - backup-on-change: a backup (unique name, .bak-latest pointer) is written
|
|
# only when the file content actually changes. No-op mutations are silent
|
|
# on disk. `rollback` is a single-step undo of the last real mutation.
|
|
# - writes are atomic: unique tmp file + rename (a fixed tmp name would let
|
|
# two concurrent writers rename a half-written file into place).
|
|
# Heredoc delivery guard. bash 5.2+ writes a heredoc body <=64KiB through a
|
|
# pipe in the forked child before exec, with no reader on the other end. On
|
|
# macOS under pipe-KVA pressure a fresh pipe gets a 512-byte buffer, so any
|
|
# body >=512B blocks write() forever and the script hangs at startup with no
|
|
# output. Compat level 50 restores the tempfile path. These scripts are
|
|
# bash-3.2-clean, so the compat level costs them nothing. Not exported: the
|
|
# guard is per-script, and it survives `bash script.sh` call sites that
|
|
# bypass the shebang.
|
|
BASH_COMPAT=50
|
|
|
|
set -euo 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
|
|
|
|
ACTION="${1:-}"
|
|
SETTINGS_FILE="${GSTACK_SETTINGS_FILE:-${CLAUDE_CONFIG_DIR:-$HOME/.claude}/settings.json}"
|
|
|
|
if [ -z "$ACTION" ]; then
|
|
cat <<EOF >&2
|
|
Usage:
|
|
gstack-settings-hook add <hook-command> # legacy SessionStart add
|
|
gstack-settings-hook remove <hook-command> # legacy SessionStart remove
|
|
gstack-settings-hook add-event --event <name> --command <cmd> --source <tag> [--matcher <re>] [--timeout <s>]
|
|
gstack-settings-hook ensure-event --event <name> --command <cmd> --source <tag> [--matcher <re>] [--timeout <s>]
|
|
gstack-settings-hook remove-source --source <tag> [--event <name>] # tagged OR table-identified items of <tag>
|
|
gstack-settings-hook diff-event --event <name> --command <cmd> --source <tag> [--matcher <re>] [--timeout <s>]
|
|
gstack-settings-hook prune-stale [--repoint <root>] [--all]
|
|
gstack-settings-hook rollback
|
|
gstack-settings-hook list-sources
|
|
gstack-settings-hook list-items --event <name> [--owned-by <tag>] [--command-regex <js-re>]
|
|
EOF
|
|
exit 1
|
|
fi
|
|
|
|
if ! command -v bun >/dev/null 2>&1; then
|
|
echo "Error: bun is required but not installed." >&2
|
|
exit 1
|
|
fi
|
|
|
|
# ─── Shared JS prelude ────────────────────────────────────────────────
|
|
# Single source of truth for the KNOWN_HOOKS identity table and the
|
|
# ownership/liveness/IO helpers, interpolated into EVERY bun -e script as
|
|
# bun -e "$_HOOK_JS_PRELUDE"' <single-quoted body>'
|
|
# so the dedupe key and the prune predicate cannot drift. The prelude MUST NOT
|
|
# contain single quotes (this assignment is single-quoted).
|
|
_HOOK_JS_PRELUDE='
|
|
// Umbrella fail-closed guard: bun in -e mode swallows uncaught exceptions
|
|
// thrown after a require() call and exits 0 (verified on bun 1.3.13;
|
|
// uncaughtException handlers never fire in -e mode either). Every script body
|
|
// below runs inside gsMain so a runtime throw becomes a LOUD exit 4 instead
|
|
// of a silent success that reports a mutation as clean.
|
|
function gsMain(fn) {
|
|
try {
|
|
fn();
|
|
} catch (e) {
|
|
if (e && e.gstackUnreadableSettings === true) {
|
|
process.stderr.write("gstack-settings-hook: " + e.message + " -- refusing to mutate\n");
|
|
process.exit(3);
|
|
}
|
|
process.stderr.write("gstack-settings-hook: internal error (" + (e && e.message) + ") -- refusing to mutate\n");
|
|
process.exit(4);
|
|
}
|
|
}
|
|
var KNOWN_HOOKS = {
|
|
"question-log-hook": { source: "plan-tune-cathedral", event: "PostToolUse", matcher: "(AskUserQuestion|mcp__.*__AskUserQuestion)", relpath: "hosts/claude/hooks/question-log-hook" },
|
|
"question-preference-hook": { source: "plan-tune-cathedral", event: "PreToolUse", matcher: "(AskUserQuestion|mcp__.*__AskUserQuestion)", relpath: "hosts/claude/hooks/question-preference-hook" },
|
|
"auq-error-fallback-hook": { source: "auq-error-fallback", event: "PostToolUse", matcher: "(AskUserQuestion|mcp__.*__AskUserQuestion)", relpath: "hosts/claude/hooks/auq-error-fallback-hook" },
|
|
"timeline-stop-hook": { source: "gstack-timeline-stop", event: "Stop", matcher: "", relpath: "hosts/claude/hooks/timeline-stop-hook" },
|
|
"memorable-user-prompt-hook": { source: "gstack-memorable", event: "UserPromptSubmit", matcher: "", relpath: "hosts/claude/hooks/memorable-user-prompt-hook" },
|
|
"gstack-session-update": { source: "gstack-session-update", event: "SessionStart", matcher: "", relpath: "bin/gstack-session-update" },
|
|
"gstack-verify-gate": { source: "verify-gate", event: "Stop", matcher: "", relpath: "bin/gstack-verify-gate" },
|
|
"skill-route-hook": { source: "gstack-skill-route", event: "UserPromptSubmit", matcher: "", relpath: "hosts/claude/hooks/skill-route-hook" },
|
|
"skill-contract-stop-hook": { source: "gstack-skill-contract", event: "Stop", matcher: "", relpath: "hosts/claude/hooks/skill-contract-stop-hook" },
|
|
"investigate-gate-pre": { source: "gstack-investigate-gate", event: "PreToolUse", matcher: "Edit|Write|MultiEdit|NotebookEdit|Bash", relpath: "hosts/claude/hooks/investigate-gate-pre" },
|
|
"investigate-gate-post": { source: "gstack-investigate-gate", event: "PostToolUse", matcher: "Bash", relpath: "hosts/claude/hooks/investigate-gate-post" },
|
|
"investigate-gate-post-failure": { source: "gstack-investigate-gate", event: "PostToolUseFailure", matcher: "Bash", relpath: "hosts/claude/hooks/investigate-gate-post-failure" },
|
|
"investigate-gate-stop": { source: "gstack-investigate-gate", event: "Stop", matcher: "", relpath: "hosts/claude/hooks/investigate-gate-stop" },
|
|
"ceo-review-gate-stop": { source: "gstack-ceo-review-gate", event: "Stop", matcher: "", relpath: "hosts/claude/hooks/ceo-review-gate-stop" },
|
|
"ceo-review-gate-subagent-stop": { source: "gstack-ceo-review-gate", event: "SubagentStop", matcher: "", relpath: "hosts/claude/hooks/ceo-review-gate-subagent-stop" },
|
|
"autoplan-stop-gate-stop": { source: "gstack-autoplan-gate", event: "Stop", matcher: "", relpath: "hosts/claude/hooks/autoplan-stop-gate-stop" },
|
|
"autoplan-stop-gate-publish": { source: "gstack-autoplan-gate", event: "PreToolUse", matcher: "Bash", relpath: "hosts/claude/hooks/autoplan-stop-gate-publish" }
|
|
};
|
|
function gsHadBashPrefix(c) { return String(c == null ? "" : c).trim().indexOf("bash ") === 0; }
|
|
function gsStripWrap(c) {
|
|
var s = String(c == null ? "" : c).trim();
|
|
if (s.indexOf("bash ") === 0) s = s.slice(5).trim();
|
|
if (s.length >= 2 && s.charAt(0) === "\"" && s.charAt(s.length - 1) === "\"") {
|
|
// Unescape the gsQuoteCmd form so a re-pointed escaped command is still
|
|
// recognized as ours on later passes (identity round-trips).
|
|
s = s.slice(1, -1).replace(/\\([\\"$\x60])/g, "$1");
|
|
}
|
|
// Separator normalization is Windows-only (a rare-but-legal Unix path
|
|
// containing a backslash must not be rewritten and mis-stat-ed).
|
|
if (process.platform === "win32" || /^[A-Za-z]:[\\\/]/.test(s)) {
|
|
s = s.replace(/\\/g, "/");
|
|
}
|
|
return s;
|
|
}
|
|
function gsBaseOf(c) { var p = gsStripWrap(c); return p.split("/").pop(); }
|
|
function gsOwnedRow(cmd, event, matcher) {
|
|
var p = gsStripWrap(cmd);
|
|
var b = p.split("/").pop();
|
|
// hasOwnProperty guard: a foreign hook basename like "toString" or
|
|
// "constructor" must not resolve to an inherited Object.prototype member.
|
|
var row = Object.prototype.hasOwnProperty.call(KNOWN_HOOKS, b) ? KNOWN_HOOKS[b] : null;
|
|
if (!row) return null;
|
|
if (p !== row.relpath && p.slice(-(row.relpath.length + 1)) !== "/" + row.relpath) return null;
|
|
if (row.event !== event) return null;
|
|
if (row.matcher && (matcher || "") !== row.matcher) return null;
|
|
return row;
|
|
}
|
|
function gsWinPath(p) {
|
|
// Git Bash writes MSYS-form paths (/c/Users/...) into settings.json, but
|
|
// native bun resolves them drive-relative (C:\c\Users\...) -- translate for
|
|
// fs calls only; stored commands keep the form the firing shell expects.
|
|
if (process.platform === "win32" && /^\/[A-Za-z]\//.test(p)) {
|
|
return p.charAt(1) + ":" + p.slice(2);
|
|
}
|
|
return p;
|
|
}
|
|
function gsResolveSettingsPath(input) {
|
|
var fs = require("fs");
|
|
var path = require("path");
|
|
var absolute = path.resolve(gsWinPath(input));
|
|
var resolved;
|
|
try { resolved = fs.realpathSync(absolute); }
|
|
catch (e) {
|
|
if (e && (e.code === "EACCES" || e.code === "EPERM")) {
|
|
throw Object.assign(new Error("cannot read " + absolute + " (" + e.code + ")"), { gstackUnreadableSettings: true });
|
|
}
|
|
if (!e || e.code !== "ENOENT") throw e;
|
|
try {
|
|
if (fs.lstatSync(absolute).isSymbolicLink()) throw new Error("settings link has no target");
|
|
} catch (missing) {
|
|
if (!missing || missing.code !== "ENOENT") throw missing;
|
|
}
|
|
resolved = path.join(gsResolveSettingsPath(path.dirname(absolute)), path.basename(absolute));
|
|
}
|
|
return process.platform === "win32" ? resolved.replace(/\\/g, "/") : resolved;
|
|
}
|
|
function gsAssertSettingsTarget(settingsPath) {
|
|
if (gsResolveSettingsPath(process.env.GSTACK_SETTINGS_INPUT) !== settingsPath) {
|
|
throw new Error("settings target changed while waiting or writing");
|
|
}
|
|
}
|
|
function gsSettingsIdentity(settingsPath) {
|
|
var fs = require("fs");
|
|
try {
|
|
var stat = fs.lstatSync(settingsPath, { bigint: true });
|
|
if (!stat.isFile()) throw new Error("settings target is not a regular file");
|
|
return [stat.dev, stat.ino, stat.size, stat.mode, stat.mtimeNs, stat.ctimeNs].join(":");
|
|
} catch (e) {
|
|
if (e && e.code === "ENOENT") return null;
|
|
throw e;
|
|
}
|
|
}
|
|
var gsLoadedIdentity;
|
|
function gsAssertSettingsUnchanged(settingsPath) {
|
|
gsAssertSettingsTarget(settingsPath);
|
|
if (gsSettingsIdentity(settingsPath) !== gsLoadedIdentity) {
|
|
throw new Error("settings changed during mutation");
|
|
}
|
|
}
|
|
function gsIsAlive(cmd) {
|
|
var fs = require("fs");
|
|
var p = gsWinPath(gsStripWrap(cmd));
|
|
if (!p) return false;
|
|
try {
|
|
if (process.platform === "win32") return fs.existsSync(p);
|
|
var st = fs.statSync(p);
|
|
if (!st.isFile()) return false;
|
|
fs.accessSync(p, fs.constants.X_OK);
|
|
return true;
|
|
} catch (e) {
|
|
// Only provable absence counts as dead. EACCES/EIO/unmounted-volume
|
|
// errors are transient unreachability -- pruning on those would be a
|
|
// one-way ratchet, so conservatively treat the item as alive.
|
|
var code = e && e.code;
|
|
return !(code === "ENOENT" || code === "ENOTDIR");
|
|
}
|
|
}
|
|
function gsQuoteCmd(target, hadBash) {
|
|
// Shell-metacharacter hardening: the command string is executed by a shell
|
|
// when Claude Code fires the hook, so a path containing $, backtick (x60 --
|
|
// written as an escape so the prelude itself stays backtick-free), or a
|
|
// quote must be neutralized, not just space-wrapped.
|
|
var needsQuote = /[\s$\x60"\\]/.test(target);
|
|
var quoted = needsQuote
|
|
? "\"" + target.replace(/[\\"$\x60]/g, function (ch) { return "\\" + ch; }) + "\""
|
|
: target;
|
|
return (hadBash ? "bash " : "") + quoted;
|
|
}
|
|
function gsRotateBackups(settingsPath, keep) {
|
|
// Backup files are change-gated but unbounded across months of setups --
|
|
// keep the most recent N so ~/.claude does not accumulate forever.
|
|
var fs = require("fs");
|
|
var path = require("path");
|
|
try {
|
|
var dir = path.dirname(settingsPath);
|
|
var base = path.basename(settingsPath) + ".bak.";
|
|
var baks = fs.readdirSync(dir)
|
|
.filter(function (f) { return f.indexOf(base) === 0; })
|
|
.map(function (f) {
|
|
var full = path.join(dir, f);
|
|
var m = 0;
|
|
try { m = fs.statSync(full).mtimeMs; } catch (e3) {}
|
|
return { full: full, m: m };
|
|
})
|
|
.sort(function (a, b) { return a.m - b.m; });
|
|
for (var i = 0; i < baks.length - keep; i++) {
|
|
try { fs.unlinkSync(baks[i].full); } catch (e2) {}
|
|
}
|
|
} catch (e) {}
|
|
}
|
|
function gsLoadSettings(path) {
|
|
var fs = require("fs");
|
|
gsAssertSettingsTarget(path);
|
|
gsLoadedIdentity = gsSettingsIdentity(path);
|
|
var raw = null;
|
|
try { raw = fs.readFileSync(path, "utf8"); }
|
|
catch (e) {
|
|
if (e && e.code === "ENOENT") return { settings: {}, existed: false };
|
|
process.stderr.write("gstack-settings-hook: cannot read " + path + ": " + e.message + " -- refusing to mutate\n");
|
|
process.exit(3);
|
|
}
|
|
try { return { settings: JSON.parse(raw), existed: true }; }
|
|
catch (e) {
|
|
process.stderr.write("gstack-settings-hook: " + path + " is not valid JSON (" + e.message + ") -- refusing to mutate; fix or restore it (.bak files / rollback)\n");
|
|
process.exit(3);
|
|
}
|
|
}
|
|
function gsWriteIfChanged(path, beforeText, settings, existed) {
|
|
var fs = require("fs");
|
|
var afterText = JSON.stringify(settings, null, 2);
|
|
if (afterText === beforeText) return false;
|
|
gsAssertSettingsUnchanged(path);
|
|
// Preserve the live file mode across the tmp+rename (settings.json can
|
|
// carry API keys in its env block -- a user-tightened 0600 must never be
|
|
// silently broadened to the default 0644). Fresh files start 0600.
|
|
var mode = 0o600;
|
|
if (existed) {
|
|
try { mode = fs.statSync(path).mode & 0o777; } catch (e) {}
|
|
fs.copyFileSync(path, process.env.GSTACK_BACKUP_PATH);
|
|
fs.writeFileSync(process.env.GSTACK_BAK_LATEST, process.env.GSTACK_BACKUP_PATH + "\n");
|
|
gsRotateBackups(path, 10);
|
|
}
|
|
var tmp = process.env.GSTACK_TMP_PATH;
|
|
fs.writeFileSync(tmp, afterText + "\n", { mode: mode, flag: "wx" });
|
|
try {
|
|
fs.chmodSync(tmp, mode);
|
|
gsAssertSettingsUnchanged(path);
|
|
fs.renameSync(tmp, path);
|
|
} finally {
|
|
try { fs.unlinkSync(tmp); } catch (e) { if (e.code !== "ENOENT") throw e; }
|
|
}
|
|
return true;
|
|
}
|
|
'
|
|
|
|
GSTACK_SETTINGS_INPUT="$SETTINGS_FILE"
|
|
export GSTACK_SETTINGS_INPUT
|
|
SETTINGS_FILE=$(bun --no-env-file --config="${GSTACK_BUN_CONFIG:-/dev/null}" -e "$_HOOK_JS_PRELUDE"'gsMain(function () {
|
|
process.stdout.write(gsResolveSettingsPath(process.env.GSTACK_SETTINGS_INPUT));
|
|
});') || exit $?
|
|
|
|
# ─── Mutation lock ────────────────────────────────────────────────────
|
|
# Accepted tradeoffs (adversarial-reviewed): (1) the lock serializes gstack
|
|
# writers only -- Claude Code rewrites settings.json without honoring it, so a
|
|
# lost update against a live session remains possible (convergent: the next
|
|
# heal repairs); (2) stale takeover is mtime-based -- a holder legitimately
|
|
# slower than the stale window can be stolen from, and a fresh crash stalls
|
|
# callers for the give-up window. PID-aware takeover was considered and
|
|
# deferred (owner file already carries $$ if it becomes worth it).
|
|
_LOCK_DIR="$SETTINGS_FILE.lock"
|
|
_LOCK_TOKEN=""
|
|
|
|
_release_lock() {
|
|
if [ -n "$_LOCK_TOKEN" ] && [ -d "$_LOCK_DIR" ]; then
|
|
# Ownership-checked: never remove a lock another process re-acquired
|
|
# after a stale takeover.
|
|
_OWNER_CONTENT="$(cat "$_LOCK_DIR/owner" 2>/dev/null || true)"
|
|
if [ "$_OWNER_CONTENT" = "$_LOCK_TOKEN" ] || [ -z "$_OWNER_CONTENT" ]; then
|
|
rm -rf "$_LOCK_DIR" 2>/dev/null || true
|
|
fi
|
|
fi
|
|
_LOCK_TOKEN=""
|
|
}
|
|
|
|
_acquire_lock() {
|
|
# GSTACK_SETTINGS_LOCK_TIMEOUT_MS: test-only override for the give-up
|
|
# (a contention test should not stall the suite for 10 real seconds).
|
|
local waited_ms=0 token stale mtime now vanished=0
|
|
local give_up_ms="${GSTACK_SETTINGS_LOCK_TIMEOUT_MS:-10000}"
|
|
local stale_after_s=30 # lock older than this belongs to a crashed holder
|
|
local poll_ms=50 # retry cadence; sleep below derives from this
|
|
token="$$-$RANDOM$RANDOM"
|
|
. "$(cd "$(dirname "$0")" && pwd)/gstack-lock.sh" 2>/dev/null || { echo "gstack-settings-hook: $(dirname "$0")/gstack-lock.sh is missing -- skipping this mutation, exit 5 (fix: reinstall with ./setup)" >&2; return 1; }
|
|
while :; do
|
|
if gstack_lock_take "$_LOCK_DIR" owner "$token"; then
|
|
_LOCK_TOKEN="$token"
|
|
trap _release_lock EXIT
|
|
trap 'exit 129' INT
|
|
trap 'exit 143' TERM
|
|
return 0
|
|
fi
|
|
# The take failed but no lock dir exists: either a holder released between
|
|
# our take and this check, or NOT contention (unwritable parent, read-only
|
|
# fs, missing directory). Retry the take once; a second failure with still no
|
|
# lock dir is the environment, and waiting cannot help, so give up loudly
|
|
# now instead of spinning out the full timeout.
|
|
if [ ! -e "$_LOCK_DIR" ]; then
|
|
if [ "$vanished" -eq 0 ]; then vanished=1; continue; fi
|
|
echo "gstack-settings-hook: cannot create lock $_LOCK_DIR (unwritable parent?) -- skipping this mutation, exit 5" >&2
|
|
return 1
|
|
fi
|
|
vanished=0
|
|
# Stale takeover: atomic rename means exactly one contender wins; the
|
|
# loser loops and re-contends against the winner's fresh mkdir.
|
|
# GNU stat (-c %Y) first: on Linux, BSD-style `stat -f %m` prints a
|
|
# multi-line FILESYSTEM block to stdout before failing, and the || chain
|
|
# would capture that garbage alongside the real epoch. BSD stat rejects
|
|
# -c with no stdout, so macOS falls through cleanly. The numeric guard
|
|
# below makes any residual garbage inert (no takeover, normal give-up)
|
|
# instead of an arithmetic abort under set -e.
|
|
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)
|
|
if [ -n "$mtime" ] && [ $(( now - mtime )) -gt "$stale_after_s" ]; then
|
|
stale="$_LOCK_DIR.stale.$$-$RANDOM"
|
|
if mv "$_LOCK_DIR" "$stale" 2>/dev/null; then rm -rf "$stale" 2>/dev/null || true; fi
|
|
continue
|
|
fi
|
|
if [ "$waited_ms" -ge "$give_up_ms" ]; then
|
|
echo "gstack-settings-hook: could not acquire lock $_LOCK_DIR -- skipping this mutation, exit 5 (the next setup retries it)" >&2
|
|
return 1
|
|
fi
|
|
sleep "$(printf '0.%03d' "$poll_ms")"
|
|
waited_ms=$(( waited_ms + poll_ms ))
|
|
done
|
|
}
|
|
|
|
# Per-invocation unique backup + tmp paths, exported for gsWriteIfChanged.
|
|
_mutation_env() {
|
|
GSTACK_BACKUP_PATH="$SETTINGS_FILE.bak.$(date +%Y%m%d-%H%M%S).$$.$RANDOM"
|
|
GSTACK_BAK_LATEST="$SETTINGS_FILE.bak-latest"
|
|
GSTACK_TMP_PATH="$SETTINGS_FILE.tmp.$$.$RANDOM"
|
|
export GSTACK_BACKUP_PATH GSTACK_BAK_LATEST GSTACK_TMP_PATH
|
|
}
|
|
|
|
case "$ACTION" in
|
|
# --- legacy SessionStart add/remove (backwards compat) -----------------
|
|
add)
|
|
HOOK_CMD="${2:-}"
|
|
if [ -z "$HOOK_CMD" ]; then
|
|
echo "Usage: gstack-settings-hook add <hook-command>" >&2
|
|
exit 1
|
|
fi
|
|
_acquire_lock || exit 5
|
|
_mutation_env
|
|
GSTACK_SETTINGS_PATH="$SETTINGS_FILE" GSTACK_HOOK_CMD="$HOOK_CMD" bun --no-env-file --config="${GSTACK_BUN_CONFIG:-/dev/null}" -e "$_HOOK_JS_PRELUDE"'gsMain(function () {
|
|
const settingsPath = process.env.GSTACK_SETTINGS_PATH;
|
|
const hookCmd = process.env.GSTACK_HOOK_CMD;
|
|
const loaded = gsLoadSettings(settingsPath);
|
|
const settings = loaded.settings;
|
|
const before = JSON.stringify(settings, null, 2);
|
|
if (!settings.hooks) settings.hooks = {};
|
|
if (!settings.hooks.SessionStart) settings.hooks.SessionStart = [];
|
|
const exists = settings.hooks.SessionStart.some(entry =>
|
|
entry.hooks && entry.hooks.some(h => h.command && h.command.includes("gstack-session-update"))
|
|
);
|
|
if (!exists) {
|
|
settings.hooks.SessionStart.push({
|
|
hooks: [{ type: "command", command: hookCmd }]
|
|
});
|
|
}
|
|
gsWriteIfChanged(settingsPath, before, settings, loaded.existed);
|
|
});
|
|
'
|
|
;;
|
|
|
|
remove)
|
|
HOOK_CMD="${2:-}"
|
|
if [ -z "$HOOK_CMD" ]; then
|
|
echo "Usage: gstack-settings-hook remove <hook-command>" >&2
|
|
exit 1
|
|
fi
|
|
[ -f "$SETTINGS_FILE" ] || exit 1
|
|
_acquire_lock || exit 5
|
|
_mutation_env
|
|
GSTACK_SETTINGS_PATH="$SETTINGS_FILE" bun --no-env-file --config="${GSTACK_BUN_CONFIG:-/dev/null}" -e "$_HOOK_JS_PRELUDE"'gsMain(function () {
|
|
const settingsPath = process.env.GSTACK_SETTINGS_PATH;
|
|
const loaded = gsLoadSettings(settingsPath);
|
|
const settings = loaded.settings;
|
|
const before = JSON.stringify(settings, null, 2);
|
|
if (settings.hooks && settings.hooks.SessionStart) {
|
|
// Item-aware: remove only matching hook items; foreign items in the
|
|
// same entry survive; an entry is dropped ONLY when this pass emptied
|
|
// it. Malformed/foreign entries (hooks absent, non-array, or already
|
|
// empty) are preserved verbatim -- they are not ours to judge.
|
|
settings.hooks.SessionStart = settings.hooks.SessionStart
|
|
.filter(entry => {
|
|
if (!Array.isArray(entry.hooks)) return true;
|
|
const beforeLen = entry.hooks.length;
|
|
entry.hooks = entry.hooks.filter(h =>
|
|
!(h && h.command && h.command.includes("gstack-session-update"))
|
|
);
|
|
if (entry.hooks.length === 0 && beforeLen > 0) return false;
|
|
return true;
|
|
});
|
|
if (settings.hooks.SessionStart.length === 0) delete settings.hooks.SessionStart;
|
|
if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
|
|
}
|
|
gsWriteIfChanged(settingsPath, before, settings, loaded.existed);
|
|
});
|
|
'
|
|
;;
|
|
|
|
add-event|diff-event|ensure-event)
|
|
EVENT=""
|
|
COMMAND=""
|
|
SOURCE=""
|
|
MATCHER=""
|
|
TIMEOUT=""
|
|
shift
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
--event) EVENT="$2"; shift 2 ;;
|
|
--command) COMMAND="$2"; shift 2 ;;
|
|
--source) SOURCE="$2"; shift 2 ;;
|
|
--matcher) MATCHER="$2"; shift 2 ;;
|
|
--timeout) TIMEOUT="$2"; shift 2 ;;
|
|
*) echo "unknown flag: $1" >&2; exit 1 ;;
|
|
esac
|
|
done
|
|
if [ -z "$EVENT" ] || [ -z "$COMMAND" ] || [ -z "$SOURCE" ]; then
|
|
echo "add-event/ensure-event/diff-event require --event, --command, --source" >&2
|
|
exit 1
|
|
fi
|
|
case "$EVENT" in
|
|
SessionStart|PreToolUse|PostToolUse|PostToolUseFailure|UserPromptSubmit|Stop|SubagentStop|Notification) ;;
|
|
*) echo "invalid --event '$EVENT'; must be one of SessionStart|PreToolUse|PostToolUse|PostToolUseFailure|UserPromptSubmit|Stop|SubagentStop|Notification" >&2; exit 1 ;;
|
|
esac
|
|
DIFF_ONLY=""
|
|
ENSURE=""
|
|
if [ "$ACTION" = "diff-event" ]; then
|
|
DIFF_ONLY=1
|
|
else
|
|
[ "$ACTION" = "ensure-event" ] && ENSURE=1
|
|
_acquire_lock || exit 5
|
|
fi
|
|
_mutation_env
|
|
GSTACK_SETTINGS_PATH="$SETTINGS_FILE" \
|
|
GSTACK_EVENT="$EVENT" \
|
|
GSTACK_COMMAND="$COMMAND" \
|
|
GSTACK_SOURCE="$SOURCE" \
|
|
GSTACK_MATCHER="$MATCHER" \
|
|
GSTACK_TIMEOUT="$TIMEOUT" \
|
|
GSTACK_DIFF_ONLY="$DIFF_ONLY" \
|
|
GSTACK_ENSURE="$ENSURE" \
|
|
bun --no-env-file --config="${GSTACK_BUN_CONFIG:-/dev/null}" -e "$_HOOK_JS_PRELUDE"'gsMain(function () {
|
|
const settingsPath = process.env.GSTACK_SETTINGS_PATH;
|
|
const event = process.env.GSTACK_EVENT;
|
|
const cmd = process.env.GSTACK_COMMAND;
|
|
const source = process.env.GSTACK_SOURCE;
|
|
const matcher = process.env.GSTACK_MATCHER || "";
|
|
const timeoutRaw = process.env.GSTACK_TIMEOUT || "";
|
|
const diffOnly = process.env.GSTACK_DIFF_ONLY === "1";
|
|
const ensure = process.env.GSTACK_ENSURE === "1";
|
|
|
|
const loaded = gsLoadSettings(settingsPath);
|
|
const settings = loaded.settings;
|
|
const before = JSON.stringify(settings, null, 2);
|
|
|
|
if (!settings.hooks) settings.hooks = {};
|
|
if (!settings.hooks[event]) settings.hooks[event] = [];
|
|
|
|
// add-event is the single quoting authority: normalize the command
|
|
// through the same round-trip the healer uses so metachar paths are
|
|
// registered in the escaped-quoted form from the start (a caller-side
|
|
// quoting step would drift per call site).
|
|
const cmdNorm = gsQuoteCmd(gsStripWrap(cmd), gsHadBashPrefix(cmd));
|
|
const hookEntry = { type: "command", command: cmdNorm };
|
|
if (timeoutRaw) {
|
|
const n = Number(timeoutRaw);
|
|
if (Number.isFinite(n) && n > 0) hookEntry.timeout = n;
|
|
}
|
|
|
|
// Identity is item-level and two-layer:
|
|
// - a same-event entry carrying OUR source tag is ours even under a
|
|
// DIFFERENT matcher (a matcher change must re-point in place, never
|
|
// push a second registration -- the old matcher-keyed dedupe
|
|
// duplicated the entry on every matcher change), and
|
|
// - a same-matcher entry containing our exact command or a table-owned
|
|
// item with our basename is OUR registration under a stale path
|
|
// (Claude Code strips _gstack_source on its own rewrites, so
|
|
// tag-based dedupe degrades).
|
|
// A tag never claims foreign items: in a multi-item entry only the
|
|
// identified item is touched; entries where no item can be identified
|
|
// as ours are left alone entirely.
|
|
const ourItemIdx = (entry) => {
|
|
if (!Array.isArray(entry.hooks)) return -1;
|
|
let idx = entry.hooks.findIndex(h => h && h.command === cmdNorm);
|
|
if (idx < 0) {
|
|
idx = entry.hooks.findIndex(h => {
|
|
if (!h || !h.command) return false;
|
|
const row = gsOwnedRow(h.command, event, entry.matcher || "");
|
|
return !!row && gsBaseOf(h.command) === gsBaseOf(cmdNorm);
|
|
});
|
|
}
|
|
if (idx < 0 && entry._gstack_source === source && entry.hooks.length === 1 && entry.hooks[0] && entry.hooks[0].command) idx = 0;
|
|
return idx;
|
|
};
|
|
const cands = [];
|
|
for (const entry of settings.hooks[event]) {
|
|
const idx = ourItemIdx(entry);
|
|
if (idx < 0) continue;
|
|
if (entry._gstack_source === source || (entry.matcher || "") === matcher) cands.push({ entry: entry, idx: idx });
|
|
}
|
|
|
|
let placed = false;
|
|
let collapsed = 0;
|
|
if (cands.length > 0) {
|
|
const primary = cands[0];
|
|
if ((primary.entry.matcher || "") === matcher) {
|
|
primary.entry.hooks[primary.idx] = hookEntry;
|
|
// Mixed-version ratchet guard: tag ONLY single-item entries (the
|
|
// item we just placed). Old gstack versions in sibling worktrees do
|
|
// entry-level ownership (remove-source deletes the whole tagged
|
|
// entry; add-event clobbers entry.hooks wholesale) -- a tag on a
|
|
// mixed entry hands them permission to destroy the user items in it.
|
|
if (primary.entry.hooks.length === 1) primary.entry._gstack_source = source;
|
|
else delete primary.entry._gstack_source;
|
|
placed = true;
|
|
} else if (primary.entry.hooks.length === 1) {
|
|
// Tagged single-item entry under a stale matcher: the entry is
|
|
// exclusively ours, so re-point payload AND matcher in place.
|
|
primary.entry.hooks = [hookEntry];
|
|
primary.entry._gstack_source = source;
|
|
if (matcher) primary.entry.matcher = matcher;
|
|
else delete primary.entry.matcher;
|
|
placed = true;
|
|
} else {
|
|
// Our item sits in a MIXED entry under a different matcher: the
|
|
// entry-level matcher also governs the foreign siblings, so pull
|
|
// our item out and register separately below.
|
|
primary.entry.hooks.splice(primary.idx, 1);
|
|
delete primary.entry._gstack_source;
|
|
}
|
|
// Duplicate registrations (e.g. same-source twins from the old
|
|
// matcher-keyed dedupe): remove OUR item from every other candidate.
|
|
for (let i = 1; i < cands.length; i++) {
|
|
cands[i].entry.hooks.splice(cands[i].idx, 1);
|
|
delete cands[i].entry._gstack_source;
|
|
collapsed++;
|
|
}
|
|
// Drop only entries WE emptied; started-empty foreign entries are
|
|
// never candidates, so they are preserved verbatim.
|
|
settings.hooks[event] = settings.hooks[event].filter(e =>
|
|
!(Array.isArray(e.hooks) && e.hooks.length === 0 && cands.some(c => c.entry === e)));
|
|
}
|
|
if (!placed) {
|
|
const newEntry = { _gstack_source: source, hooks: [hookEntry] };
|
|
if (matcher) newEntry.matcher = matcher;
|
|
settings.hooks[event].push(newEntry);
|
|
}
|
|
|
|
const after = JSON.stringify(settings, null, 2);
|
|
|
|
if (diffOnly) {
|
|
console.log("--- BEFORE");
|
|
console.log(before);
|
|
console.log("--- AFTER");
|
|
console.log(after);
|
|
process.exit(0);
|
|
}
|
|
|
|
if (ensure && before === after) {
|
|
// Registered payload already matches the canonical one -- no write,
|
|
// no backup, no churn. Re-running ./setup stays a true no-op.
|
|
console.log("OK: " + event + " hook unchanged (source: " + source + ")");
|
|
process.exit(0);
|
|
}
|
|
|
|
gsWriteIfChanged(settingsPath, before, settings, loaded.existed);
|
|
if (collapsed > 0) {
|
|
console.error("collapsed " + collapsed + " duplicate (event, source) hook entr" + (collapsed === 1 ? "y" : "ies") + " for " + event + " (source: " + source + ")");
|
|
}
|
|
if (ensure && cands.length > 0) {
|
|
console.log("OK: " + event + " hook re-pointed (source: " + source + ")");
|
|
} else {
|
|
console.log("OK: " + event + " hook registered (source: " + source + ")");
|
|
}
|
|
});
|
|
'
|
|
;;
|
|
|
|
remove-source)
|
|
SOURCE=""
|
|
RS_EVENT=""
|
|
shift
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
--source) SOURCE="$2"; shift 2 ;;
|
|
--event) RS_EVENT="$2"; shift 2 ;;
|
|
*) echo "unknown flag: $1" >&2; exit 1 ;;
|
|
esac
|
|
done
|
|
if [ -z "$SOURCE" ]; then
|
|
echo "remove-source requires --source <tag>" >&2
|
|
exit 1
|
|
fi
|
|
[ -f "$SETTINGS_FILE" ] || exit 0
|
|
_acquire_lock || exit 5
|
|
_mutation_env
|
|
GSTACK_SETTINGS_PATH="$SETTINGS_FILE" GSTACK_SOURCE="$SOURCE" GSTACK_RS_EVENT="$RS_EVENT" bun --no-env-file --config="${GSTACK_BUN_CONFIG:-/dev/null}" -e "$_HOOK_JS_PRELUDE"'gsMain(function () {
|
|
const settingsPath = process.env.GSTACK_SETTINGS_PATH;
|
|
const source = process.env.GSTACK_SOURCE;
|
|
const onlyEvent = process.env.GSTACK_RS_EVENT || "";
|
|
const loaded = gsLoadSettings(settingsPath);
|
|
const settings = loaded.settings;
|
|
if (!settings.hooks) { console.log("OK: removed 0 hook entry/entries tagged source=" + source); process.exit(0); }
|
|
const before = JSON.stringify(settings, null, 2);
|
|
let removed = 0;
|
|
// Identity-aware removal (tag OR table). Claude Code strips the
|
|
// _gstack_source tag when it rewrites settings.json, so a tag-only
|
|
// off switch silently no-ops on exactly the entries it was written
|
|
// for. Decision per item, identity first (D = drop, K = keep):
|
|
//
|
|
// item -> | row.source == SOURCE | row of another source | no table row
|
|
// entry tagged SOURCE | D | K | D if single item, else K
|
|
// untagged / other tag | D | K | K
|
|
//
|
|
// Entries with nothing of ours stay byte-identical (tag included);
|
|
// an entry we emptied is dropped; a tagged entry we trimmed loses
|
|
// the tag with its last owned item. Callers that need every gstack
|
|
// item gone still pair this with prune-stale --all.
|
|
for (const event of Object.keys(settings.hooks)) {
|
|
if (onlyEvent && event !== onlyEvent) continue; // --event scopes the removal (Q3)
|
|
const entries = settings.hooks[event];
|
|
if (!Array.isArray(entries)) continue; // foreign shape: not ours to judge
|
|
const kept = [];
|
|
for (const entry of entries) {
|
|
const tagged = !!entry && entry._gstack_source === source;
|
|
if (!entry || !Array.isArray(entry.hooks) || entry.hooks.length === 0) {
|
|
if (tagged) { removed++; continue; } // tagged but empty/malformed: legacy stray
|
|
kept.push(entry); continue;
|
|
}
|
|
const single = entry.hooks.length === 1;
|
|
let touched = 0;
|
|
const remain = entry.hooks.filter(h => {
|
|
// Command-less items cannot be ours (gstack only writes
|
|
// type:command items) -- preserve them.
|
|
const cmd = (h && typeof h.command === "string") ? h.command : "";
|
|
const row = cmd ? gsOwnedRow(cmd, event, entry.matcher || "") : null;
|
|
const ours = !!row && row.source === source;
|
|
const stray = tagged && single && !!cmd && !row;
|
|
if (ours || stray) { removed++; touched++; return false; }
|
|
return true;
|
|
});
|
|
if (touched === 0) { kept.push(entry); continue; }
|
|
if (remain.length === 0) continue;
|
|
entry.hooks = remain;
|
|
if (tagged) delete entry._gstack_source;
|
|
kept.push(entry);
|
|
}
|
|
settings.hooks[event] = kept;
|
|
if (settings.hooks[event].length === 0) delete settings.hooks[event];
|
|
}
|
|
if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
|
|
gsWriteIfChanged(settingsPath, before, settings, loaded.existed);
|
|
console.log("OK: removed " + removed + " hook entry/entries tagged source=" + source);
|
|
});
|
|
'
|
|
;;
|
|
|
|
prune-stale)
|
|
REPOINT_ROOT=""
|
|
PRUNE_ALL=""
|
|
shift
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
--repoint) REPOINT_ROOT="$2"; shift 2 ;;
|
|
--all) PRUNE_ALL=1; shift ;;
|
|
*) echo "unknown flag: $1" >&2; exit 1 ;;
|
|
esac
|
|
done
|
|
if [ -n "$REPOINT_ROOT" ] && [ -n "$PRUNE_ALL" ]; then
|
|
echo "prune-stale: --repoint and --all are mutually exclusive" >&2
|
|
exit 1
|
|
fi
|
|
if [ ! -f "$SETTINGS_FILE" ]; then
|
|
echo "OK: removed 0 gstack hook entries (repointed 0)"
|
|
exit 0
|
|
fi
|
|
# Explicit plan_tune_hooks opt-out: dead plan-tune items are still pruned,
|
|
# but live ones are never re-pointed (re-activation needs consent; removal
|
|
# of live ones is --no-team/uninstall territory).
|
|
GSTACK_PT_OPTOUT=0
|
|
# The opt-out lookup is repoint/heal-only — the --all sweep never
|
|
# re-points, and uninstall must not depend on a sibling gstack-config.
|
|
if [ -z "$PRUNE_ALL" ]; then
|
|
_CFG_BIN="$(cd "$(dirname "$0")" && pwd)/gstack-config"
|
|
if [ -x "$_CFG_BIN" ] && "$_CFG_BIN" has plan_tune_hooks 2>/dev/null; then
|
|
_PT_VAL=$("$_CFG_BIN" get plan_tune_hooks 2>/dev/null || true)
|
|
_PT_VAL=$(printf '%s' "$_PT_VAL" | tr '[:upper:]' '[:lower:]' | tr -d '[:space:]')
|
|
case "$_PT_VAL" in
|
|
n|no|false|skip|off|0) GSTACK_PT_OPTOUT=1 ;;
|
|
esac
|
|
fi
|
|
fi
|
|
_acquire_lock || exit 5
|
|
_mutation_env
|
|
GSTACK_SETTINGS_PATH="$SETTINGS_FILE" \
|
|
GSTACK_REPOINT_ROOT="$REPOINT_ROOT" \
|
|
GSTACK_PRUNE_ALL="$PRUNE_ALL" \
|
|
GSTACK_PT_OPTOUT="$GSTACK_PT_OPTOUT" \
|
|
GSTACK_SWEEP_EXCLUDE_SOURCES="${GSTACK_SWEEP_EXCLUDE_SOURCES:-}" \
|
|
bun --no-env-file --config="${GSTACK_BUN_CONFIG:-/dev/null}" -e "$_HOOK_JS_PRELUDE"'gsMain(function () {
|
|
const settingsPath = process.env.GSTACK_SETTINGS_PATH;
|
|
const root = (process.env.GSTACK_REPOINT_ROOT || "").replace(/\/+$/, "");
|
|
const all = process.env.GSTACK_PRUNE_ALL === "1";
|
|
const ptOptout = process.env.GSTACK_PT_OPTOUT === "1";
|
|
const PT_SOURCES = { "plan-tune-cathedral": true, "auq-error-fallback": true };
|
|
// Sources a sweep must leave alone (e.g. `setup --no-team` excludes the
|
|
// user-registered verify-gate hook: turning team mode off must not
|
|
// delete an unrelated opt-in whose binary still exists).
|
|
const sweepExclude = {};
|
|
(process.env.GSTACK_SWEEP_EXCLUDE_SOURCES || "").split(",").forEach(function (sName) {
|
|
if (sName.trim()) sweepExclude[sName.trim()] = true;
|
|
});
|
|
|
|
const loaded = gsLoadSettings(settingsPath);
|
|
const settings = loaded.settings;
|
|
const before = JSON.stringify(settings, null, 2);
|
|
let removed = 0;
|
|
let repointed = 0;
|
|
|
|
if (settings.hooks) {
|
|
for (const event of Object.keys(settings.hooks)) {
|
|
const rebuilt = [];
|
|
for (const entry of settings.hooks[event]) {
|
|
if (!Array.isArray(entry.hooks)) { rebuilt.push(entry); continue; }
|
|
const matcher = entry.matcher || "";
|
|
const wasSingle = entry.hooks.length === 1;
|
|
const remain = [];
|
|
const seenInEntry = new Set();
|
|
if (entry.hooks.length === 0) {
|
|
// Started-empty entries are foreign data we never touched --
|
|
// preserve them (only a gstack-tagged empty entry is claimable,
|
|
// and only by the --all sweep).
|
|
if (all && entry._gstack_source && !sweepExclude[entry._gstack_source]) { removed++; continue; }
|
|
rebuilt.push(entry);
|
|
continue;
|
|
}
|
|
for (const h of entry.hooks) {
|
|
const cmdRaw = h && h.command;
|
|
const row = cmdRaw ? gsOwnedRow(cmdRaw, event, matcher) : null;
|
|
// A tagged SINGLE-item entry with no table match is an owned
|
|
// legacy stray (command items only -- gstack never writes
|
|
// command-less items); tags never claim items in multi-item entries.
|
|
const stray = !row && !!cmdRaw && !!entry._gstack_source && wasSingle;
|
|
if (!row && !stray) { remain.push(h); continue; } // foreign: never touched
|
|
if (all) {
|
|
if ((row && sweepExclude[row.source]) || (!row && entry._gstack_source && sweepExclude[entry._gstack_source])) { remain.push(h); continue; }
|
|
removed++; continue;
|
|
}
|
|
if (row && root && !(ptOptout && PT_SOURCES[row.source])) {
|
|
const target = root + "/" + row.relpath;
|
|
if (gsIsAlive(target)) {
|
|
const newCmd = gsQuoteCmd(target, gsHadBashPrefix(cmdRaw));
|
|
if (h.command !== newCmd) { h.command = newCmd; repointed++; }
|
|
// Within-entry twin collapse: two dead copies of the same
|
|
// hook re-point to the same canonical command -- keeping
|
|
// both would fire the hook twice per event, forever.
|
|
if (seenInEntry.has(newCmd)) { removed++; continue; }
|
|
seenInEntry.add(newCmd);
|
|
if (wasSingle) entry._gstack_source = row.source; // tag restore
|
|
remain.push(h);
|
|
continue;
|
|
}
|
|
}
|
|
// No re-point target (or plan-tune opt-out): keep live, prune dead.
|
|
if (gsIsAlive(cmdRaw)) remain.push(h); else { removed++; }
|
|
}
|
|
if (remain.length === 0) continue; // entry emptied → dropped
|
|
entry.hooks = remain;
|
|
// Tag hygiene: a tag must never sit on an entry containing foreign
|
|
// items (old gstack versions in sibling worktrees treat tags as
|
|
// entry-level ownership and would destroy the user items). Drop
|
|
// the tag from any mixed entry; single-item strays keep theirs.
|
|
if (entry._gstack_source && entry.hooks.length > 0
|
|
&& !entry.hooks.every(h => h && h.command && gsOwnedRow(h.command, event, matcher))
|
|
&& !(entry.hooks.length === 1 && wasSingle)) {
|
|
delete entry._gstack_source;
|
|
}
|
|
rebuilt.push(entry);
|
|
}
|
|
// Collapse exact duplicates among FULLY-owned entries (same matcher,
|
|
// same item commands). Prefer the tagged twin so stripped tags heal.
|
|
const seen = new Map();
|
|
const out = [];
|
|
for (const entry of rebuilt) {
|
|
const items = Array.isArray(entry.hooks) ? entry.hooks : [];
|
|
const fullyOwned = items.length > 0 && items.every(h =>
|
|
h && h.command && gsOwnedRow(h.command, event, entry.matcher || ""));
|
|
if (!fullyOwned) { out.push(entry); continue; }
|
|
const key = JSON.stringify([entry.matcher || ""].concat(items.map(function (h) { return h.command; }).sort()));
|
|
const at = seen.get(key);
|
|
if (at === undefined) { seen.set(key, out.length); out.push(entry); }
|
|
else {
|
|
if (!out[at]._gstack_source && entry._gstack_source) out[at] = entry;
|
|
removed++;
|
|
}
|
|
}
|
|
settings.hooks[event] = out;
|
|
if (out.length === 0) delete settings.hooks[event];
|
|
}
|
|
if (settings.hooks && Object.keys(settings.hooks).length === 0) delete settings.hooks;
|
|
}
|
|
|
|
gsWriteIfChanged(settingsPath, before, settings, loaded.existed);
|
|
console.log("OK: removed " + removed + " gstack hook entries (repointed " + repointed + ")");
|
|
});
|
|
'
|
|
;;
|
|
|
|
rollback)
|
|
_acquire_lock || exit 1
|
|
if [ ! -f "$SETTINGS_FILE.bak-latest" ]; then
|
|
echo "rollback: no backup pointer at $SETTINGS_FILE.bak-latest" >&2
|
|
exit 1
|
|
fi
|
|
LATEST=$(cat "$SETTINGS_FILE.bak-latest")
|
|
LATEST=$(printf '%s' "$LATEST" | tr -d '\n')
|
|
# Defense in depth: only ever restore a sibling settings.json.bak.* file
|
|
# (a corrupted/hostile pointer must not install an arbitrary file as the
|
|
# live settings.json).
|
|
case "$LATEST" in
|
|
"$SETTINGS_FILE".bak.*) ;;
|
|
*)
|
|
echo "rollback: pointer target $LATEST is not a $SETTINGS_FILE.bak.* file -- refusing" >&2
|
|
exit 1
|
|
;;
|
|
esac
|
|
case "${LATEST#"$SETTINGS_FILE".bak.}" in
|
|
*/*)
|
|
echo "rollback: pointer suffix contains a path separator -- refusing" >&2
|
|
exit 1
|
|
;;
|
|
esac
|
|
if [ ! -f "$LATEST" ]; then
|
|
echo "rollback: pointer references missing backup $LATEST" >&2
|
|
exit 1
|
|
fi
|
|
_mutation_env
|
|
GSTACK_SETTINGS_PATH="$SETTINGS_FILE" GSTACK_RESTORE_PATH="$LATEST" \
|
|
bun --no-env-file --config="${GSTACK_BUN_CONFIG:-/dev/null}" -e "$_HOOK_JS_PRELUDE"'gsMain(function () {
|
|
var fs = require("fs");
|
|
var target = process.env.GSTACK_SETTINGS_PATH;
|
|
var backup = process.env.GSTACK_RESTORE_PATH;
|
|
var tmp = process.env.GSTACK_TMP_PATH;
|
|
gsAssertSettingsTarget(target);
|
|
gsLoadedIdentity = gsSettingsIdentity(target);
|
|
try {
|
|
fs.copyFileSync(backup, tmp, fs.constants.COPYFILE_EXCL);
|
|
gsAssertSettingsUnchanged(target);
|
|
fs.renameSync(tmp, target);
|
|
} finally {
|
|
try { fs.unlinkSync(tmp); } catch (e) { if (e.code !== "ENOENT") throw e; }
|
|
}
|
|
});'
|
|
echo "OK: restored $SETTINGS_FILE from $LATEST"
|
|
;;
|
|
|
|
list-items)
|
|
# Read-only identity view: one JSON string literal per matching hook
|
|
# command (JSON.stringify, so a command containing tabs or newlines
|
|
# cannot split a line), filters applied inside the JS. Empty stdout
|
|
# means no match. Exit 1 usage, 3 unparseable settings, 4 unexpected
|
|
# shape -- the same codes the mutating verbs use, because callers
|
|
# (bin/gstack-memorable) decide mutations from this output.
|
|
LI_EVENT=""
|
|
LI_OWNED_BY=""
|
|
LI_CMD_RE=""
|
|
shift
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
--event) LI_EVENT="$2"; shift 2 ;;
|
|
--owned-by) LI_OWNED_BY="$2"; shift 2 ;;
|
|
--command-regex) LI_CMD_RE="$2"; shift 2 ;;
|
|
*) echo "unknown flag: $1" >&2; exit 1 ;;
|
|
esac
|
|
done
|
|
if [ -z "$LI_EVENT" ]; then
|
|
echo "list-items requires --event <name>" >&2
|
|
exit 1
|
|
fi
|
|
[ -f "$SETTINGS_FILE" ] || exit 0
|
|
GSTACK_SETTINGS_PATH="$SETTINGS_FILE" GSTACK_LI_EVENT="$LI_EVENT" GSTACK_LI_OWNED_BY="$LI_OWNED_BY" GSTACK_LI_CMD_RE="$LI_CMD_RE" bun --no-env-file --config="${GSTACK_BUN_CONFIG:-/dev/null}" -e "$_HOOK_JS_PRELUDE"'gsMain(function () {
|
|
const event = process.env.GSTACK_LI_EVENT;
|
|
const ownedBy = process.env.GSTACK_LI_OWNED_BY || "";
|
|
const reSrc = process.env.GSTACK_LI_CMD_RE || "";
|
|
let re = null;
|
|
if (reSrc) {
|
|
try { re = new RegExp(reSrc); }
|
|
catch (e) {
|
|
process.stderr.write("list-items: invalid --command-regex (" + e.message + ")\n");
|
|
process.exit(1);
|
|
}
|
|
}
|
|
const loaded = gsLoadSettings(process.env.GSTACK_SETTINGS_PATH);
|
|
const hooks = loaded.settings.hooks || {};
|
|
const entries = hooks[event];
|
|
if (entries === undefined || entries === null) process.exit(0);
|
|
if (!Array.isArray(entries)) throw new Error("hooks." + event + " is not an array");
|
|
for (const entry of entries) {
|
|
if (!entry || !Array.isArray(entry.hooks)) continue; // foreign shape, preserved by prune-stale too
|
|
for (const h of entry.hooks) {
|
|
const cmd = (h && typeof h.command === "string") ? h.command : "";
|
|
if (!cmd) continue;
|
|
const row = gsOwnedRow(cmd, event, entry.matcher || "");
|
|
if (ownedBy && (!row || row.source !== ownedBy)) continue;
|
|
// Alone, the regex only ever sees items no table row owns (the
|
|
// vendor-own probe). Combined with --owned-by it narrows THAT set:
|
|
// filters intersect, a regex never widens a selection.
|
|
if (re && !ownedBy && row) continue;
|
|
if (re && !re.test(cmd)) continue;
|
|
console.log(JSON.stringify(cmd));
|
|
}
|
|
}
|
|
});
|
|
'
|
|
;;
|
|
|
|
list-sources)
|
|
[ -f "$SETTINGS_FILE" ] || { echo "(no settings file)"; exit 0; }
|
|
GSTACK_SETTINGS_PATH="$SETTINGS_FILE" bun --no-env-file --config="${GSTACK_BUN_CONFIG:-/dev/null}" -e "$_HOOK_JS_PRELUDE"'gsMain(function () {
|
|
const fs = require("fs");
|
|
let settings = {};
|
|
try { settings = JSON.parse(fs.readFileSync(process.env.GSTACK_SETTINGS_PATH, "utf8")); }
|
|
catch (e) {
|
|
// Read-only surface: report loudly (setup guards read this output and
|
|
// must not mistake corrupt-file for no-hooks) but exit 0.
|
|
process.stderr.write("gstack-settings-hook: settings.json unparseable (" + e.message + ") -- fix or rollback\n");
|
|
process.exit(0);
|
|
}
|
|
const hooks = settings.hooks || {};
|
|
let any = false;
|
|
for (const event of Object.keys(hooks)) {
|
|
for (const entry of hooks[event]) {
|
|
if (entry._gstack_source) {
|
|
any = true;
|
|
console.log(event + "\t" + entry._gstack_source + "\t" + (entry.matcher || "(no matcher)"));
|
|
}
|
|
}
|
|
}
|
|
if (!any) console.log("(no gstack-tagged hooks)");
|
|
});
|
|
'
|
|
;;
|
|
|
|
*)
|
|
echo "Unknown action: $ACTION" >&2
|
|
exit 1
|
|
;;
|
|
esac
|