skillwiki 0.9.63 → 0.10.0

package/dist/vault-sync/scripts/wiki-fetch-notify.sh

@@ -0,0 +1,207 @@
+#!/bin/bash
+# wiki-fetch-notify.sh — polls origin for remote wiki changes and notifies.
+#
+# Runs `git fetch` against origin and emits a notification only when
+# NEW commits have arrived since the previous run. Replaces the old
+# seaweedfs-bisync writer with a non-destructive poller.
+#
+# Opt-in WIKI_FETCH_PULL_ON_DELTA=1: on positive delta, also runs
+# `git pull --rebase` (via wiki-pull-with-auto-resolve.sh) so the local
+# working tree consumes sg01 Snapshot commits automatically. This is a
+# mutating action — when enabled, this script is no longer a pure reader.
+#
+# When pull is disabled (default), this script is read-only: fetch only
+# touches refs/objects and is safe to run concurrently with skillwiki sync.
+
+set -u
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]:-$0}" )" && pwd )"
+. "$SCRIPT_DIR/lib/platform.sh"
+. "$SCRIPT_DIR/lib/lockfile.sh"
+. "$SCRIPT_DIR/lib/git-operation-journal.sh"
+platform_detect_os
+
+WIKI_DIR="${WIKI_DIR:-$HOME/wiki}"
+BRANCH="${WIKI_BRANCH:-main}"
+STATE_DIR="$(platform_cache_dir)/wiki-fetch"
+STATE_FILE="$STATE_DIR/last-behind"
+STALE_STATE_FILE="$STATE_DIR/last-stale-notify"
+STALE_NOTIFY_AFTER_SECONDS="${WIKI_FETCH_STALE_NOTIFY_AFTER_SECONDS:-1800}"
+HANDOFF_STATE_FILE="$STATE_DIR/pending-handoff.env"
+HANDOFF_NOTIFY_AFTER_SECONDS="${WIKI_FETCH_HANDOFF_NOTIFY_AFTER_SECONDS:-3600}"
+case "$HANDOFF_NOTIFY_AFTER_SECONDS" in
+  ''|*[!0-9]*) HANDOFF_NOTIFY_AFTER_SECONDS=3600 ;;
+esac
+# Opt-in: when enabled, a positive delta triggers `git pull --rebase` so the
+# local working tree consumes sg01 Snapshot commits automatically. This
+# replaces the git pull that was previously bundled inside wiki-push.sh's
+# removed git-push block. Default off — set WIKI_FETCH_PULL_ON_DELTA=1 to
+# enable on leaf hosts that want automated pull.
+PULL_ON_DELTA="${WIKI_FETCH_PULL_ON_DELTA:-0}"
+PULL_HELPER="$SCRIPT_DIR/wiki-pull-with-auto-resolve.sh"
+LOG_FILE="$(platform_log_dir)/wiki-fetch.log"
+
+mkdir -p "$STATE_DIR" "$(dirname "$LOG_FILE")"
+
+log() {
+  printf '%s %s\n' "$(date -u +%FT%TZ)" "$*" >>"$LOG_FILE"
+}
+
+handle_existing_handoff() {
+  local blocker reason op identity previous_identity notified_at now
+  blocker="$(vault_sync_op_preflight_blocker "$WIKI_DIR" 2>/dev/null || true)"
+  [ -n "$blocker" ] || { rm -f "$HANDOFF_STATE_FILE" 2>/dev/null || true; return 1; }
+
+  reason="${blocker%%	*}"
+  op="${blocker#*	}"
+  [ "$op" = "$blocker" ] && op=""
+  identity="${reason}:${op:-none}"
+  previous_identity=""
+  notified_at=0
+  if [ -f "$HANDOFF_STATE_FILE" ]; then
+    previous_identity="$(awk -F= '$1=="identity"{print substr($0,index($0,"=")+1)}' "$HANDOFF_STATE_FILE")"
+    notified_at="$(awk -F= '$1=="notified_at"{print $2}' "$HANDOFF_STATE_FILE")"
+  fi
+  case "$notified_at" in ''|*[!0-9]*) notified_at=0 ;; esac
+  now="$(date +%s)"
+
+  if [ "$identity" != "$previous_identity" ] || [ $((now - notified_at)) -ge "$HANDOFF_NOTIFY_AFTER_SECONDS" ]; then
+    platform_notify "wiki" "review-required handoff ${op:-none} still blocks sync"
+    printf 'identity=%s\nnotified_at=%s\n' "$identity" "$now" > "$HANDOFF_STATE_FILE"
+    log "NOTIFY handoff identity=$identity"
+  else
+    log "SKIP PULL handoff identity=$identity reminder-backoff"
+  fi
+  return 0
+}
+
+attempt_pull_on_delta() {
+  # Retry on every poll while we remain behind. This avoids the failed-pull
+  # wedge where last-behind is advanced before the pull runs and DELTA stays 0
+  # forever until a fresh upstream commit arrives.
+  if [ "$PULL_ON_DELTA" != "1" ] || [ "$BEHIND" -le 0 ]; then
+    return 0
+  fi
+
+  if handle_existing_handoff; then
+    return 0
+  fi
+
+  if [ -f "$WIKI_DIR/.skillwiki/sync.lock" ]; then
+    log "SKIP PULL sync lock present — leave pull to skillwiki sync"
+    return 0
+  fi
+  if [ -f "$WIKI_DIR/.git/index.lock" ] || [ -d "$WIKI_DIR/.git/rebase-merge" ] || [ -d "$WIKI_DIR/.git/rebase-apply" ] || [ -f "$WIKI_DIR/.git/MERGE_HEAD" ]; then
+    log "SKIP PULL git operation already in progress"
+    return 0
+  fi
+
+  PULL_LOCK_FILE="$STATE_DIR/pull.lock"
+  PULL_LOCK_RC=0
+  lockfile_acquire "$PULL_LOCK_FILE" 600 || PULL_LOCK_RC=$?
+  if [ "$PULL_LOCK_RC" -eq 1 ]; then
+    log "SKIP PULL previous pull-on-delta still in flight"
+    return 0
+  elif [ "$PULL_LOCK_RC" -eq 2 ]; then
+    log "PULL stale lock reclaimed"
+  fi
+
+  if [ -x "$PULL_HELPER" ]; then
+    if "$PULL_HELPER" origin "$BRANCH" 2>>"$LOG_FILE"; then
+      log "PULL ok via wiki-pull-with-auto-resolve"
+    else
+      log "FAIL PULL via wiki-pull-with-auto-resolve — run skillwiki sync manually"
+    fi
+  elif [ -f "$PULL_HELPER" ]; then
+    if bash "$PULL_HELPER" origin "$BRANCH" 2>>"$LOG_FILE"; then
+      log "PULL ok via bash wiki-pull-with-auto-resolve"
+    else
+      log "FAIL PULL via bash wiki-pull-with-auto-resolve — run skillwiki sync manually"
+    fi
+  elif git pull --rebase origin "$BRANCH" 2>>"$LOG_FILE"; then
+    log "PULL ok via git pull --rebase"
+  else
+    log "FAIL PULL via git pull --rebase — run skillwiki sync manually"
+  fi
+}
+
+# Guard: working tree present.
+if [ ! -d "$WIKI_DIR/.git" ]; then
+  log "ERROR: $WIKI_DIR is not a git repo"
+  exit 0
+fi
+
+cd "$WIKI_DIR" || { log "ERROR: cd $WIKI_DIR failed"; exit 0; }
+
+# Fetch only the target branch. --quiet keeps log noise low.
+# Failure (offline, auth, etc.) is silent on the notification side.
+if ! git fetch --quiet origin "$BRANCH" 2>>"$LOG_FILE"; then
+  log "fetch failed (offline or auth) — skipping notify"
+  exit 0
+fi
+
+# Compute behind count. If branch is missing on either side, exit clean.
+if ! BEHIND=$(git rev-list --count "HEAD..origin/$BRANCH" 2>>"$LOG_FILE"); then
+  log "rev-list failed — origin/$BRANCH may not exist"
+  exit 0
+fi
+
+LAST_BEHIND=0
+if [ -f "$STATE_FILE" ]; then
+  LAST_BEHIND=$(cat "$STATE_FILE" 2>/dev/null || echo 0)
+  # Sanitize: must be a non-negative integer.
+  case "$LAST_BEHIND" in
+    ''|*[!0-9]*) LAST_BEHIND=0 ;;
+  esac
+fi
+
+printf '%s' "$BEHIND" >"$STATE_FILE"
+
+DELTA=$(( BEHIND - LAST_BEHIND ))
+NOW=$(date +%s)
+
+LAST_STALE_NOTIFY=0
+if [ -f "$STALE_STATE_FILE" ]; then
+  LAST_STALE_NOTIFY=$(cat "$STALE_STATE_FILE" 2>/dev/null || echo 0)
+  case "$LAST_STALE_NOTIFY" in
+    ''|*[!0-9]*) LAST_STALE_NOTIFY=0 ;;
+  esac
+fi
+
+case "$STALE_NOTIFY_AFTER_SECONDS" in
+  ''|*[!0-9]*) STALE_NOTIFY_AFTER_SECONDS=1800 ;;
+esac
+
+if [ "$DELTA" -gt 0 ]; then
+  # New commits arrived since last poll. Notify with delta and total.
+  TITLE="wiki"
+  if [ "$DELTA" -eq "$BEHIND" ]; then
+    MSG="$DELTA new commit(s) on origin/$BRANCH"
+  else
+    MSG="$DELTA new ($BEHIND total behind) on origin/$BRANCH"
+  fi
+  platform_notify "$TITLE" "$MSG — run skillwiki sync"
+  printf '%s' "$NOW" >"$STALE_STATE_FILE"
+  log "NOTIFY behind=$BEHIND delta=$DELTA"
+
+elif [ "$BEHIND" -gt 0 ] && [ $(( NOW - LAST_STALE_NOTIFY )) -ge "$STALE_NOTIFY_AFTER_SECONDS" ]; then
+  TITLE="wiki"
+  MSG="still $BEHIND commit(s) behind origin/$BRANCH"
+  platform_notify "$TITLE" "$MSG — sync may be stuck"
+  printf '%s' "$NOW" >"$STALE_STATE_FILE"
+  log "NOTIFY stale behind=$BEHIND delta=$DELTA"
+else
+  if [ "$BEHIND" -eq 0 ]; then
+    rm -f "$STALE_STATE_FILE" 2>/dev/null || true
+  fi
+  log "OK behind=$BEHIND delta=$DELTA (no notify)"
+fi
+
+# Opt-in auto-pull: consume sg01 Snapshot commits into the working tree.
+# Uses wiki-pull-with-auto-resolve.sh for conflict-storm handling. On failure,
+# leaves the working tree behind and logs — does NOT block. When the helper is
+# present but not executable, invoke it via bash so we still get its dirty-tree
+# and conflict-storm handling instead of falling back to a bare git pull.
+attempt_pull_on_delta
+
+exit 0

package/dist/vault-sync/scripts/wiki-fuse-refresh.sh

@@ -0,0 +1,405 @@
+#!/bin/bash
+# wiki-fuse-refresh.sh — keep rclone FUSE visibility within a bounded freshness SLA.
+#
+# Linux-focused helper that:
+#   1) audits active rclone mount --dir-cache-time
+#   2) optionally forgets stale VFS directory cache entries
+#   3) optionally triggers `rclone rc vfs/refresh recursive=true dir=/`
+#
+# Intended to run under systemd timer (wiki-fuse-refresh.timer) and manually via
+# the vault-fuse-freshness skill.
+
+set -u
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]:-$0}" )" && pwd )"
+. "$SCRIPT_DIR/lib/platform.sh"
+platform_detect_os
+
+LOG_FILE="$(platform_log_dir)/wiki-fuse-refresh.log"
+mkdir -p "$(dirname "$LOG_FILE")"
+
+log() {
+  printf '%s %s\n' "$(date -u +%FT%TZ)" "$*" >>"$LOG_FILE"
+}
+
+print() {
+  printf '[wiki-fuse-refresh] %s\n' "$*"
+  log "$*"
+}
+
+lower() {
+  printf '%s' "$1" | tr '[:upper:]' '[:lower:]'
+}
+
+is_true() {
+  case "$(lower "${1:-}")" in
+    1|true|yes|on) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+# Parse a duration string into seconds (supports: 10, 10m, 1h30m, 500ms).
+duration_to_seconds() {
+  local input
+  input="$(printf '%s' "$1" | tr '[:upper:]' '[:lower:]' | tr -d '[:space:]')"
+  [ -n "$input" ] || return 1
+
+  if printf '%s' "$input" | grep -Eq '^[0-9]+([.][0-9]+)?$'; then
+    printf '%s\n' "$input"
+    return 0
+  fi
+
+  local rest="$input"
+  local total="0"
+
+  while [ -n "$rest" ]; do
+    if printf '%s' "$rest" | grep -Eq '^([0-9]+([.][0-9]+)?)(ms|s|m|h|d|w)'; then
+      local prefix
+      prefix="$(printf '%s' "$rest" | sed -E 's/^([0-9]+([.][0-9]+)?)(ms|s|m|h|d|w).*/\1 \3/')"
+      local value
+      value="$(printf '%s' "$prefix" | awk '{print $1}')"
+      local unit
+      unit="$(printf '%s' "$prefix" | awk '{print $2}')"
+
+      local factor
+      case "$unit" in
+        ms) factor="0.001" ;;
+        s)  factor="1" ;;
+        m)  factor="60" ;;
+        h)  factor="3600" ;;
+        d)  factor="86400" ;;
+        w)  factor="604800" ;;
+        *) return 1 ;;
+      esac
+
+      total="$(awk -v a="$total" -v b="$value" -v f="$factor" 'BEGIN { printf "%.6f", a + (b * f) }')"
+
+      local seg_len
+      seg_len="$(printf '%s' "$rest" | sed -E 's/^([0-9]+([.][0-9]+)?)(ms|s|m|h|d|w).*/\1\3/' | awk '{print length($0)}')"
+      rest="${rest:$seg_len}"
+    else
+      return 1
+    fi
+  done
+
+  awk -v v="$total" 'BEGIN {
+    if (v + 0 == int(v + 0)) {
+      printf "%d\n", v
+    } else {
+      s = sprintf("%.6f", v)
+      sub(/0+$/, "", s)
+      sub(/[.]$/, "", s)
+      printf "%s\n", s
+    }
+  }'
+}
+
+seconds_gt() {
+  awk -v a="$1" -v b="$2" 'BEGIN { exit !(a > b) }'
+}
+
+find_rclone_mount_pid() {
+  local pid
+  pid="$(pgrep -f 'rclone.*mount' 2>/dev/null | head -n 1 || true)"
+  [ -n "$pid" ] && printf '%s\n' "$pid"
+}
+
+rclone_token_stream() {
+  local pid="$1"
+  if [ -r "/proc/$pid/cmdline" ]; then
+    tr '\0' '\n' < "/proc/$pid/cmdline"
+    return 0
+  fi
+  ps -p "$pid" -o args= 2>/dev/null | tr ' ' '\n'
+}
+
+extract_flag_value() {
+  local pid="$1"
+  local flag="$2"
+  local prev=""
+
+  while IFS= read -r token; do
+    [ -n "$token" ] || continue
+
+    if [ "$prev" = "$flag" ]; then
+      printf '%s\n' "$token"
+      return 0
+    fi
+
+    case "$token" in
+      "$flag="*)
+        printf '%s\n' "${token#*=}"
+        return 0
+        ;;
+    esac
+
+    prev="$token"
+  done < <(rclone_token_stream "$pid")
+
+  return 1
+}
+
+has_flag() {
+  local pid="$1"
+  local flag="$2"
+
+  while IFS= read -r token; do
+    [ -n "$token" ] || continue
+    if [ "$token" = "$flag" ]; then
+      return 0
+    fi
+    case "$token" in
+      "$flag="*) return 0 ;;
+    esac
+  done < <(rclone_token_stream "$pid")
+
+  return 1
+}
+
+extract_mount_remote() {
+  local pid="$1"
+  local saw_mount=0
+
+  while IFS= read -r token; do
+    [ -n "$token" ] || continue
+
+    if [ "$saw_mount" -eq 0 ]; then
+      [ "$token" = "mount" ] && saw_mount=1
+      continue
+    fi
+
+    case "$token" in
+      --*) continue ;;
+      /*) continue ;;
+    esac
+
+    case "$token" in
+      *:*)
+        printf '%s\n' "$token"
+        return 0
+        ;;
+    esac
+  done < <(rclone_token_stream "$pid")
+
+  return 1
+}
+
+DRY_RUN=0
+CHECK_ONLY=0
+MAX_DIR_CACHE_RAW="${VS_FUSE_MAX_DIR_CACHE:-15m}"
+RC_ADDR_OVERRIDE="${VS_FUSE_RC_ADDR:-}"
+RC_TIMEOUT_SECONDS="${VS_FUSE_RC_TIMEOUT_SECONDS:-60}"
+FORGET_DIRS=()
+
+if [ -n "${VS_FUSE_FORGET_DIRS:-}" ]; then
+  read -r -a FORGET_DIRS <<< "$VS_FUSE_FORGET_DIRS"
+fi
+
+usage() {
+  cat <<USAGE
+Usage: bash wiki-fuse-refresh.sh [options]
+
+Options:
+  --dry-run                Print planned actions only
+  --check-only             Audit dir-cache-time only (no rc refresh)
+  --max-dir-cache <dur>    Freshness threshold (default: 15m)
+  --rc-addr <host:port>    Override rc endpoint (default: from mount flags, else 127.0.0.1:5572)
+  --forget-dir <path>      Forget a VFS directory cache path before refresh (repeatable)
+  --help                   Show this help
+
+Environment overrides:
+  VS_DRY_RUN=1|0
+  VS_FUSE_CHECK_ONLY=1|0
+  VS_FUSE_MAX_DIR_CACHE=<duration>
+  VS_FUSE_RC_ADDR=<host:port>
+  VS_FUSE_RC_TIMEOUT_SECONDS=<seconds>
+  VS_FUSE_FORGET_DIRS="<path> [path...]"
+USAGE
+}
+
+if is_true "${VS_DRY_RUN:-0}"; then
+  DRY_RUN=1
+fi
+if is_true "${VS_FUSE_CHECK_ONLY:-0}"; then
+  CHECK_ONLY=1
+fi
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --dry-run)
+      DRY_RUN=1
+      shift
+      ;;
+    --check-only)
+      CHECK_ONLY=1
+      shift
+      ;;
+    --max-dir-cache)
+      [ "$#" -ge 2 ] || { print "FATAL: --max-dir-cache requires a value"; exit 2; }
+      MAX_DIR_CACHE_RAW="$2"
+      shift 2
+      ;;
+    --rc-addr)
+      [ "$#" -ge 2 ] || { print "FATAL: --rc-addr requires a value"; exit 2; }
+      RC_ADDR_OVERRIDE="$2"
+      shift 2
+      ;;
+    --forget-dir)
+      [ "$#" -ge 2 ] || { print "FATAL: --forget-dir requires a value"; exit 2; }
+      FORGET_DIRS+=("$2")
+      shift 2
+      ;;
+    --help|-h)
+      usage
+      exit 0
+      ;;
+    *)
+      print "FATAL: unknown argument: $1"
+      exit 2
+      ;;
+  esac
+done
+
+if [ "$VS_OS" != "linux" ]; then
+  print "skip: OS=$VS_OS (linux-only freshness workflow)"
+  exit 0
+fi
+
+if ! command -v rclone >/dev/null 2>&1; then
+  print "WARN: rclone not found in PATH"
+  exit 0
+fi
+
+case "$RC_TIMEOUT_SECONDS" in
+  ''|*[!0-9]*)
+    print "FATAL: VS_FUSE_RC_TIMEOUT_SECONDS must be an integer number of seconds"
+    exit 2
+    ;;
+esac
+
+MAX_DIR_CACHE_SECONDS="$(duration_to_seconds "$MAX_DIR_CACHE_RAW" 2>/dev/null || true)"
+if [ -z "$MAX_DIR_CACHE_SECONDS" ]; then
+  print "FATAL: cannot parse --max-dir-cache=$MAX_DIR_CACHE_RAW"
+  exit 2
+fi
+
+RCLONE_PID="$(find_rclone_mount_pid || true)"
+if [ -z "$RCLONE_PID" ]; then
+  print "WARN: no running rclone mount process found"
+  exit 0
+fi
+
+DIR_CACHE_RAW="$(extract_flag_value "$RCLONE_PID" --dir-cache-time 2>/dev/null || true)"
+if [ -z "$DIR_CACHE_RAW" ]; then
+  DIR_CACHE_RAW="5m"
+fi
+DIR_CACHE_SECONDS="$(duration_to_seconds "$DIR_CACHE_RAW" 2>/dev/null || true)"
+if [ -z "$DIR_CACHE_SECONDS" ]; then
+  print "WARN: cannot parse --dir-cache-time=$DIR_CACHE_RAW (pid=$RCLONE_PID)"
+  exit 1
+fi
+
+if seconds_gt "$DIR_CACHE_SECONDS" "$MAX_DIR_CACHE_SECONDS"; then
+  print "WARN: --dir-cache-time=$DIR_CACHE_RAW exceeds freshness threshold $MAX_DIR_CACHE_RAW (pid=$RCLONE_PID)"
+  # Keep going so refresh still runs when possible; return non-zero at end.
+  DIR_CACHE_STATUS=1
+else
+  print "OK: --dir-cache-time=$DIR_CACHE_RAW within freshness threshold $MAX_DIR_CACHE_RAW (pid=$RCLONE_PID)"
+  DIR_CACHE_STATUS=0
+fi
+
+if [ "$CHECK_ONLY" -eq 1 ]; then
+  if [ "$DIR_CACHE_STATUS" -eq 0 ]; then
+    print "check-only: no refresh requested"
+    exit 0
+  fi
+  print "check-only: returning non-zero due to stale dir-cache-time"
+  exit 1
+fi
+
+if ! has_flag "$RCLONE_PID" --rc; then
+  print "WARN: rclone mount pid=$RCLONE_PID has no --rc flag; cannot run vfs/refresh"
+  [ "$DIR_CACHE_STATUS" -eq 0 ] && exit 0 || exit 1
+fi
+
+RC_ADDR="$RC_ADDR_OVERRIDE"
+if [ -z "$RC_ADDR" ]; then
+  RC_ADDR="$(extract_flag_value "$RCLONE_PID" --rc-addr 2>/dev/null || true)"
+fi
+if [ -z "$RC_ADDR" ]; then
+  RC_ADDR="127.0.0.1:5572"
+fi
+
+RC_URL="$RC_ADDR"
+case "$RC_URL" in
+  http://*|https://*) ;;
+  *) RC_URL="http://$RC_URL" ;;
+esac
+
+REMOTE="$(extract_mount_remote "$RCLONE_PID" 2>/dev/null || true)"
+
+if ! command -v timeout >/dev/null 2>&1; then
+  print "WARN: timeout not found in PATH; cannot run bounded rclone rc operations"
+  [ "$DIR_CACHE_STATUS" -eq 0 ] && exit 1 || exit 1
+fi
+
+run_rclone_rc() {
+  timeout "$RC_TIMEOUT_SECONDS" rclone rc --url "$RC_URL" "$@" 2>&1
+}
+
+if [ "$DRY_RUN" -eq 1 ]; then
+  for forget_dir in "${FORGET_DIRS[@]}"; do
+    if [ -n "$REMOTE" ]; then
+      print "[dry-run] timeout $RC_TIMEOUT_SECONDS rclone rc --url $RC_URL vfs/forget dir=$forget_dir fs=$REMOTE"
+    else
+      print "[dry-run] timeout $RC_TIMEOUT_SECONDS rclone rc --url $RC_URL vfs/forget dir=$forget_dir"
+    fi
+  done
+  if [ -n "$REMOTE" ]; then
+    print "[dry-run] timeout $RC_TIMEOUT_SECONDS rclone rc --url $RC_URL vfs/refresh recursive=true dir=/ fs=$REMOTE"
+  else
+    print "[dry-run] timeout $RC_TIMEOUT_SECONDS rclone rc --url $RC_URL vfs/refresh recursive=true dir=/"
+  fi
+  [ "$DIR_CACHE_STATUS" -eq 0 ] && exit 0 || exit 1
+fi
+
+for forget_dir in "${FORGET_DIRS[@]}"; do
+  if [ -n "$REMOTE" ]; then
+    RC_OUT="$(run_rclone_rc vfs/forget "dir=$forget_dir" "fs=$REMOTE")"
+  else
+    RC_OUT="$(run_rclone_rc vfs/forget "dir=$forget_dir")"
+  fi
+  RC_CODE=$?
+
+  if [ "$RC_CODE" -ne 0 ]; then
+    print "FAIL: vfs/forget dir=$forget_dir rc=$RC_CODE url=$RC_URL"
+    log "$RC_OUT"
+    [ "$DIR_CACHE_STATUS" -eq 0 ] && exit "$RC_CODE" || exit 1
+  fi
+
+  print "OK: vfs/forget dir=$forget_dir completed via $RC_URL"
+done
+
+if [ -n "$REMOTE" ]; then
+  RC_OUT="$(run_rclone_rc vfs/refresh recursive=true dir=/ "fs=$REMOTE")"
+else
+  RC_OUT="$(run_rclone_rc vfs/refresh recursive=true dir=/)"
+fi
+RC_CODE=$?
+
+if [ "$RC_CODE" -ne 0 ]; then
+  if printf '%s\n' "$RC_OUT" | grep -qi 'file does not exist'; then
+    print "WARN: root vfs/refresh with dir=/ failed; retrying without dir=/"
+    RC_OUT="$(run_rclone_rc vfs/refresh recursive=true)"
+    RC_CODE=$?
+  fi
+fi
+
+if [ "$RC_CODE" -ne 0 ]; then
+  print "FAIL: vfs/refresh rc=$RC_CODE url=$RC_URL"
+  log "$RC_OUT"
+  [ "$DIR_CACHE_STATUS" -eq 0 ] && exit "$RC_CODE" || exit 1
+fi
+
+print "OK: vfs/refresh completed via $RC_URL"
+[ "$DIR_CACHE_STATUS" -eq 0 ] && exit 0 || exit 1