skillwiki 0.9.63 → 0.10.1

package/dist/vault-sync/scripts/lib/lockfile.sh

@@ -0,0 +1,70 @@
+#!/bin/sh
+# lockfile.sh — Advisory locking for vault-sync scripts.
+#
+# Uses flock when available (Linux primary); falls back to mkdir mutex (macOS).
+# Reclaims locks older than max_age seconds (default 600 = 10 min).
+#
+# Usage:
+#   lockfile_acquire <path> [max_age_seconds]   → returns 0 on success, 1 on contention, 2 on stale-reclaim
+#   lockfile_release <path>
+
+# Acquire advisory lock.
+# Returns: 0 = acquired, 1 = contended, 2 = stale-reclaim
+lockfile_acquire() {
+  _lock_path="$1"
+  _max_age="${2:-600}"
+
+  # Try flock first (Linux primary, macOS opportunistic)
+  # shellcheck disable=SC2034
+  if command -v flock >/dev/null 2>&1; then
+    # Use fd 9 for the lock
+    eval "exec 9>\"$_lock_path\""
+    if flock -n 9 2>/dev/null; then
+      return 0
+    fi
+    # flock failed — fall through to mkdir mutex
+  fi
+
+  # mkdir mutex fallback
+  _lock_dir="${_lock_path}.d"
+  if mkdir "$_lock_dir" 2>/dev/null; then
+    _VS_LOCK_DIR="$_lock_dir"
+    export _VS_LOCK_DIR
+    trap 'lockfile_release "$_lock_path"' EXIT
+    return 0
+  fi
+
+  # Directory exists — check if stale
+  if [ -d "$_lock_dir" ]; then
+    _now=$(date +%s)
+    _ctime=$(platform_stat_ctime "$_lock_dir")
+    _age=$(( _now - _ctime ))
+    if [ "$_age" -gt "$_max_age" ]; then
+      # Stale lock — reclaim
+      rmdir "$_lock_dir" 2>/dev/null || true
+      if mkdir "$_lock_dir" 2>/dev/null; then
+        _VS_LOCK_DIR="$_lock_dir"
+        export _VS_LOCK_DIR
+        trap 'lockfile_release "$_lock_path"' EXIT
+        return 2
+      fi
+    fi
+  fi
+
+  return 1
+}
+
+# Release advisory lock.
+lockfile_release() {
+  _lock_path="$1"
+  _lock_dir="${_lock_path}.d"
+
+  # Release mkdir mutex if we hold it
+  if [ -n "${_VS_LOCK_DIR:-}" ] && [ "$_VS_LOCK_DIR" = "$_lock_dir" ]; then
+    rmdir "$_lock_dir" 2>/dev/null || true
+    unset _VS_LOCK_DIR
+  fi
+
+  # flock is released when fd 9 closes (process exit)
+  return 0
+}

package/dist/vault-sync/scripts/lib/managed-write-lock.sh

@@ -0,0 +1,80 @@
+#!/bin/bash
+# managed-write-lock.sh — shared CLI/shell managed-write lock (Bash 3.2).
+# Source from vault-sync scripts. Lock path: git --git-path vault-sync/managed-write.lock
+
+VAULT_SYNC_MANAGED_LOCK_PATH=""
+VAULT_SYNC_MANAGED_LOCK_TOKEN_OWNED=""
+VAULT_SYNC_MANAGED_LOCK_ACQUIRED=""
+VAULT_SYNC_MANAGED_LOCK_OWNS_RELEASE=0
+
+vault_sync_managed_lock_path() {
+  local repo="${1:-.}"
+  local path
+  path="$(git -C "$repo" rev-parse --git-path vault-sync/managed-write.lock 2>/dev/null)" || return 1
+  case "$path" in
+    /*) printf '%s\n' "$path" ;;
+    *) printf '%s\n' "$repo/$path" ;;
+  esac
+}
+
+vault_sync_managed_lock_read_token() {
+  local path="$1"
+  [ -f "$path" ] || return 1
+  sed -n 's/.*"owner_token"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$path" | head -1
+}
+
+# Acquire or adopt managed-write lock. Returns 0 on success, 1 on contention/mismatch.
+vault_sync_managed_lock_acquire() {
+  local repo="${1:-.}"
+  local command="${2:-wiki-pull}"
+  local path token now inherited
+  path="$(vault_sync_managed_lock_path "$repo")" || return 1
+  VAULT_SYNC_MANAGED_LOCK_PATH="$path"
+  mkdir -p "$(dirname "$path")" || return 1
+
+  inherited="${VAULT_SYNC_MANAGED_LOCK_TOKEN:-}"
+  if [ -n "$inherited" ]; then
+    if [ -f "$path" ]; then
+      token="$(vault_sync_managed_lock_read_token "$path" || true)"
+      if [ "$token" = "$inherited" ]; then
+        VAULT_SYNC_MANAGED_LOCK_TOKEN_OWNED="$inherited"
+        VAULT_SYNC_MANAGED_LOCK_OWNS_RELEASE=0
+        return 0
+      fi
+      return 1
+    fi
+    return 1
+  fi
+
+  token="$(od -An -N16 -tx1 /dev/urandom 2>/dev/null | tr -d ' \n')"
+  [ -n "$token" ] || token="$$-$(date +%s)"
+  now="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+  if ( set -o noclobber; printf '{"pid":%s,"owner_token":"%s","acquired":"%s","command":"%s"}\n' \
+      "$$" "$token" "$now" "$command" >"$path" ) 2>/dev/null; then
+    VAULT_SYNC_MANAGED_LOCK_TOKEN_OWNED="$token"
+    VAULT_SYNC_MANAGED_LOCK_ACQUIRED="$now"
+    VAULT_SYNC_MANAGED_LOCK_OWNS_RELEASE=1
+    return 0
+  fi
+  return 1
+}
+
+vault_sync_managed_lock_release() {
+  local path token
+  path="${VAULT_SYNC_MANAGED_LOCK_PATH:-}"
+  [ -n "$path" ] || return 0
+  if [ "${VAULT_SYNC_MANAGED_LOCK_OWNS_RELEASE:-0}" != "1" ]; then
+    return 0
+  fi
+  if [ ! -f "$path" ]; then
+    VAULT_SYNC_MANAGED_LOCK_OWNS_RELEASE=0
+    return 0
+  fi
+  token="$(vault_sync_managed_lock_read_token "$path" || true)"
+  if [ "$token" != "${VAULT_SYNC_MANAGED_LOCK_TOKEN_OWNED:-}" ]; then
+    return 1
+  fi
+  rm -f -- "$path"
+  VAULT_SYNC_MANAGED_LOCK_OWNS_RELEASE=0
+  return 0
+}

package/dist/vault-sync/scripts/lib/platform.sh

@@ -0,0 +1,184 @@
+#!/bin/sh
+# platform.sh — Cross-platform abstraction for vault-sync scripts.
+#
+# Sourced by all vault-sync scripts. Provides OS detection, normalized
+# paths, stat wrappers, notification shim, scheduler abstraction, and
+# feature prerequisites.
+#
+# Works in bash and /bin/sh (dash on Debian). No external deps beyond
+# what vault-sync itself requires (rclone, git).
+
+# Detect OS. Sets VS_OS to "macos" | "linux" | "unsupported".
+platform_detect_os() {
+  case "$(uname -s)" in
+    Darwin) VS_OS=macos ;;
+    Linux)  VS_OS=linux ;;
+    *)      VS_OS=unsupported ;;
+  esac
+  export VS_OS
+}
+
+# Normalized paths (XDG on Linux, ~/Library on macOS):
+
+platform_log_dir() {
+  case "${VS_OS:-}" in
+    macos) echo "$HOME/Library/Logs" ;;
+    linux) echo "$HOME/.local/state/vault-sync/log" ;;
+    *)     echo "$HOME/.local/state/vault-sync/log" ;;
+  esac
+}
+
+platform_cache_dir() {
+  case "${VS_OS:-}" in
+    macos) echo "$HOME/Library/Caches/vault-sync" ;;
+    linux) echo "$HOME/.cache/vault-sync" ;;
+    *)     echo "$HOME/.cache/vault-sync" ;;
+  esac
+}
+
+platform_share_dir() {
+  case "${VS_OS:-}" in
+    macos) echo "$HOME/Library/Application Support/vault-sync" ;;
+    linux) echo "$HOME/.local/share/vault-sync" ;;
+    *)     echo "$HOME/.local/share/vault-sync" ;;
+  esac
+}
+
+platform_rclone_config_dir() {
+  echo "$HOME/.config/rclone"
+}
+
+# Stat wrappers (BSD -f vs GNU -c):
+
+platform_stat_size() {
+  # echo bytes
+  case "${VS_OS:-}" in
+    macos) stat -f%z "$1" 2>/dev/null || echo 0 ;;
+    linux) stat -c%s "$1" 2>/dev/null || echo 0 ;;
+    *)     stat -c%s "$1" 2>/dev/null || stat -f%z "$1" 2>/dev/null || echo 0 ;;
+  esac
+}
+
+platform_stat_ctime() {
+  # echo unix epoch
+  case "${VS_OS:-}" in
+    macos) stat -f%c "$1" 2>/dev/null || echo 0 ;;
+    linux) stat -c%Z "$1" 2>/dev/null || echo 0 ;;
+    *)     stat -c%Z "$1" 2>/dev/null || stat -f%c "$1" 2>/dev/null || echo 0 ;;
+  esac
+}
+
+# Notification (graceful degrade):
+#   macos: osascript display notification
+#   linux: notify-send if available, else log only
+#   headless: no-op (return 0)
+platform_notify() {
+  _title="$1"
+  _msg="$2"
+  case "${VS_OS:-}" in
+    macos)
+      osascript -e "display notification \"$_msg\" with title \"$_title\"" 2>/dev/null || true
+      ;;
+    linux)
+      if command -v notify-send >/dev/null 2>&1; then
+        notify-send "$_title" "$_msg" 2>/dev/null || true
+      fi
+      # Headless Linux: no-op, return 0
+      ;;
+    *) ;;
+  esac
+}
+
+# Scheduler abstraction:
+
+platform_scheduler() {
+  # echo: launchd | systemd | none
+  case "${VS_OS:-}" in
+    macos)
+      if command -v launchctl >/dev/null 2>&1; then
+        echo "launchd"
+      else
+        echo "none"
+      fi
+      ;;
+    linux)
+      if command -v systemctl >/dev/null 2>&1 && systemctl --user >/dev/null 2>&1; then
+        echo "systemd"
+      else
+        echo "none"
+      fi
+      ;;
+    *) echo "none" ;;
+  esac
+}
+
+platform_job_status() {
+  # Returns JSON: {"enabled": bool, "running": bool, "last_exit": int}
+  _name="$1"
+  _enabled=false
+  _running=false
+  _last_exit=-1
+
+  case "${VS_OS:-}" in
+    macos)
+      # launchd: check via launchctl print
+      if launchctl print "gui/$(id -u)/${_name}" >/dev/null 2>&1; then
+        _enabled=true
+        _running=true  # launchd prints exit status if job ran
+        _last_exit=0   # simplified; full parsing is complex
+      fi
+      ;;
+    linux)
+      # systemd --user
+      if _is_enabled="$(systemctl --user is-enabled "${_name}.timer" 2>/dev/null)"; then
+        if [ "$_is_enabled" = "enabled" ]; then
+          _enabled=true
+        fi
+      fi
+      if _is_active="$(systemctl --user is-active "${_name}.timer" 2>/dev/null)"; then
+        if [ "$_is_active" = "active" ]; then
+          _running=true
+        fi
+      fi
+      _last_exit=0  # simplified
+      ;;
+  esac
+
+  printf '{"enabled": %s, "running": %s, "last_exit": %d}\n' "$_enabled" "$_running" "$_last_exit"
+}
+
+# Feature prerequisite check:
+# exit 1 with message if not available
+platform_require() {
+  _feature="$1"
+  case "$_feature" in
+    rclone)
+      if ! command -v rclone >/dev/null 2>&1; then
+        echo "FATAL: rclone not found in PATH" >&2
+        return 1
+      fi
+      ;;
+    git)
+      if ! command -v git >/dev/null 2>&1; then
+        echo "FATAL: git not found in PATH" >&2
+        return 1
+      fi
+      ;;
+    linux)
+      if [ "${VS_OS:-}" != "linux" ]; then
+        echo "FATAL: this operation requires Linux" >&2
+        return 1
+      fi
+      ;;
+    macos)
+      if [ "${VS_OS:-}" != "macos" ]; then
+        echo "FATAL: this operation requires macOS" >&2
+        return 1
+      fi
+      ;;
+    *)
+      echo "FATAL: unknown prerequisite: $_feature" >&2
+      return 1
+      ;;
+  esac
+}

package/dist/vault-sync/scripts/lib/runtime-manifest.sh

@@ -0,0 +1,223 @@
+#!/bin/sh
+# runtime-manifest.sh — SHA-256 inventory of installed vault-sync artifacts.
+#
+# Sourced by vault-sync-install (and later vault-sync-status). Works in bash
+# and /bin/sh. Prefers python3 for JSON emission; falls back to a minimal
+# hand-built JSON object when python3 is unavailable.
+#
+# Public API:
+#   vault_sync_sha256 <file>                 → hex digest or empty
+#   vault_sync_package_version <root>        → version string
+#   vault_sync_package_commit <root>         → git HEAD or empty
+#   vault_sync_write_runtime_manifest \
+#     <out_path> <share_dir> <launch_agents_dir> \
+#     <package_version> <package_commit> <installer_version> \
+#     <installed_at> <role> <host_id>
+
+# Resolve once per process when possible.
+_vault_sync_sha256_resolved=0
+_vault_sync_sha256_tool=""
+
+_vault_sync_sha256_resolve() {
+  if [ "$_vault_sync_sha256_resolved" = "1" ]; then
+    return 0
+  fi
+  _vault_sync_sha256_resolved=1
+  if command -v shasum >/dev/null 2>&1; then
+    _vault_sync_sha256_tool=shasum
+  elif command -v sha256sum >/dev/null 2>&1; then
+    _vault_sync_sha256_tool=sha256sum
+  elif command -v openssl >/dev/null 2>&1; then
+    _vault_sync_sha256_tool=openssl
+  elif command -v python3 >/dev/null 2>&1; then
+    _vault_sync_sha256_tool=python3
+  else
+    _vault_sync_sha256_tool=""
+  fi
+}
+
+vault_sync_sha256() {
+  _f="$1"
+  if [ ! -f "$_f" ]; then
+    echo ""
+    return 0
+  fi
+  _vault_sync_sha256_resolve
+  case "$_vault_sync_sha256_tool" in
+    shasum)
+      shasum -a 256 "$_f" 2>/dev/null | awk '{print $1}'
+      ;;
+    sha256sum)
+      sha256sum "$_f" 2>/dev/null | awk '{print $1}'
+      ;;
+    openssl)
+      openssl dgst -sha256 "$_f" 2>/dev/null | awk '{print $NF}'
+      ;;
+    python3)
+      python3 -c 'import hashlib,sys; print(hashlib.sha256(open(sys.argv[1],"rb").read()).hexdigest())' "$_f" 2>/dev/null
+      ;;
+    *)
+      echo ""
+      ;;
+  esac
+}
+
+# Trim leading/trailing whitespace (portable; no bashisms required).
+_vault_sync_trim() {
+  printf '%s' "$1" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//'
+}
+
+vault_sync_package_version() {
+  _root="$1"
+  # Deploy provenance override (rsync/staged install). Metadata only.
+  _override="$(_vault_sync_trim "${VS_PACKAGE_VERSION:-}")"
+  if [ -n "$_override" ]; then
+    printf '%s\n' "$_override"
+    return 0
+  fi
+  # Prefer monorepo package.json two levels up from packages/vault-sync, else root.
+  if [ -f "$_root/../../package.json" ]; then
+    if command -v python3 >/dev/null 2>&1; then
+      python3 -c 'import json,sys; print(json.load(open(sys.argv[1])).get("version",""))' "$_root/../../package.json" 2>/dev/null && return 0
+    fi
+    sed -n 's/.*"version"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$_root/../../package.json" 2>/dev/null | head -n 1
+    return 0
+  fi
+  if [ -f "$_root/package.json" ]; then
+    if command -v python3 >/dev/null 2>&1; then
+      python3 -c 'import json,sys; print(json.load(open(sys.argv[1])).get("version",""))' "$_root/package.json" 2>/dev/null && return 0
+    fi
+  fi
+  echo "0.0.0"
+}
+
+vault_sync_package_commit() {
+  _root="$1"
+  # Deploy provenance override (rsync/staged install). Metadata only.
+  _override="$(_vault_sync_trim "${VS_PACKAGE_COMMIT:-}")"
+  if [ -n "$_override" ]; then
+    printf '%s\n' "$_override"
+    return 0
+  fi
+  if command -v git >/dev/null 2>&1 && [ -d "$_root/../../.git" -o -f "$_root/../../.git" ] 2>/dev/null; then
+    git -C "$_root/../.." rev-parse HEAD 2>/dev/null || echo ""
+    return 0
+  fi
+  if command -v git >/dev/null 2>&1; then
+    git -C "$_root" rev-parse HEAD 2>/dev/null || echo ""
+    return 0
+  fi
+  echo ""
+}
+
+# Collect relative_path=sha256 pairs for files under share_dir/bin and
+# LaunchAgents plists. Writes newline-separated "relpath\thash" to stdout.
+vault_sync_collect_file_hashes() {
+  _share="$1"
+  _agents="$2"
+  _bin="$_share/bin"
+
+  if [ -d "$_bin" ]; then
+    # shell scripts at bin root
+    for _f in "$_bin"/*; do
+      [ -f "$_f" ] || continue
+      _base="$(basename "$_f")"
+      _h="$(vault_sync_sha256 "$_f")"
+      [ -n "$_h" ] && printf 'bin/%s\t%s\n' "$_base" "$_h"
+    done
+    # lib/*.sh
+    if [ -d "$_bin/lib" ]; then
+      for _f in "$_bin/lib"/*; do
+        [ -f "$_f" ] || continue
+        _base="$(basename "$_f")"
+        _h="$(vault_sync_sha256 "$_f")"
+        [ -n "$_h" ] && printf 'bin/lib/%s\t%s\n' "$_base" "$_h"
+      done
+    fi
+  fi
+
+  if [ -d "$_agents" ]; then
+    for _f in "$_agents"/com.karlchow.wiki-*.plist; do
+      [ -f "$_f" ] || continue
+      _base="$(basename "$_f")"
+      _h="$(vault_sync_sha256 "$_f")"
+      [ -n "$_h" ] && printf 'LaunchAgents/%s\t%s\n' "$_base" "$_h"
+    done
+  fi
+}
+
+vault_sync_write_runtime_manifest() {
+  _out="$1"
+  _share="$2"
+  _agents="$3"
+  _pkg_ver="$4"
+  _pkg_commit="$5"
+  _installer_ver="$6"
+  _installed_at="$7"
+  _role="$8"
+  _host_id="$9"
+
+  _pairs="$(mktemp)"
+  vault_sync_collect_file_hashes "$_share" "$_agents" >"$_pairs"
+
+  mkdir -p "$(dirname "$_out")"
+
+  if command -v python3 >/dev/null 2>&1; then
+    python3 - "$_out" "$_pkg_ver" "$_pkg_commit" "$_installer_ver" "$_installed_at" "$_role" "$_host_id" "$_pairs" <<'PY'
+import json, sys
+out, pkg_ver, pkg_commit, installer_ver, installed_at, role, host_id, pairs_path = sys.argv[1:9]
+files = {}
+with open(pairs_path, "r", encoding="utf-8") as fh:
+    for line in fh:
+        line = line.rstrip("\n")
+        if not line:
+            continue
+        if "\t" not in line:
+            continue
+        rel, digest = line.split("\t", 1)
+        files[rel] = digest
+manifest = {
+    "schema_version": 1,
+    "package_commit": pkg_commit,
+    "package_version": pkg_ver,
+    "installer_version": installer_ver,
+    "installed_at": installed_at,
+    "role": role,
+    "host_id": host_id,
+    "files": files,
+}
+with open(out, "w", encoding="utf-8") as fh:
+    json.dump(manifest, fh, indent=2, sort_keys=False)
+    fh.write("\n")
+PY
+    _rc=$?
+    rm -f "$_pairs"
+    return $_rc
+  fi
+
+  # Minimal fallback without python3
+  {
+    printf '{\n'
+    printf '  "schema_version": 1,\n'
+    printf '  "package_commit": "%s",\n' "$_pkg_commit"
+    printf '  "package_version": "%s",\n' "$_pkg_ver"
+    printf '  "installer_version": "%s",\n' "$_installer_ver"
+    printf '  "installed_at": "%s",\n' "$_installed_at"
+    printf '  "role": "%s",\n' "$_role"
+    printf '  "host_id": "%s",\n' "$_host_id"
+    printf '  "files": {\n'
+    _first=1
+    while IFS="$(printf '\t')" read -r _rel _hash; do
+      [ -n "$_rel" ] || continue
+      if [ "$_first" -eq 1 ]; then
+        _first=0
+      else
+        printf ',\n'
+      fi
+      printf '    "%s": "%s"' "$_rel" "$_hash"
+    done <"$_pairs"
+    printf '\n  }\n}\n'
+  } >"$_out"
+  rm -f "$_pairs"
+  return 0
+}