Recently Written · git

bm (21717 bytes)

 #!/bin/sh
 
 # bm: bookmarks in a plain file, picked with dmenu (or fzf).
 #
 #     URL<tab>description<tab>tag tag tag
 #
 # bm owns that file and nothing else. Importing, link checking, the web page
 # and so on are separate bm-* filters; see README.
 
 DMENULINES=${DMENULINES:-15}
 DATADIR=${XDG_DATA_HOME:-$HOME/.local/share}/sbm
 BOOKMARKS=${BOOKMARKS:-$DATADIR/bookmarks}
 USERTAGS=${USERTAGS:-$DATADIR/usertags}
 ENGINES=${SBM_ENGINES:-$DATADIR/engines}
 SEARCH=${SBM_SEARCH:-https://duckduckgo.com/?q=%s}
 USAGE=$BOOKMARKS.usage
 WLOCK=$BOOKMARKS.lock
 locked=
 TAB=$(printf '\t')
 
 # Two URLs are the same bookmark when they differ only in scheme, a leading
 # www., trailing slashes or the case of the host.
 AWK_NORM='
 function norm(u,    host, rest, i) {
     sub(/^[A-Za-z][A-Za-z0-9+.-]*:\/\//, "", u)
     i = index(u, "/")
     if (i) { host = substr(u, 1, i - 1); rest = substr(u, i) }
     else   { host = u; rest = "" }
     host = tolower(host)
     sub(/^www\./, "", host)
     sub(/\/+$/, "", rest)
     return host rest
 }'
 
 die () {
     printf 'bm: %s\n' "$*" >&2
     exit 1
 }
 
 have () {
     command -v "$1" >/dev/null 2>&1
 }
 
 usage () {
     cat <<'EOF'
 usage: bm [-t tag] [-S order] [action]
 Without an action: browse. Pick a bookmark, then what to do with it. Text
 that is no bookmark is opened as an address, or searched for on the web.
   -o, --open        open a bookmark, an address or a web search
                     (-p, --plumb is the same)
   -c, --copy        copy a bookmark's URL to the clipboard
       --print       print a bookmark's URL
   -a, --add [url]   add a bookmark; the url defaults to the selection
   -e, --edit        open the bookmark file in $EDITOR at a bookmark
   -d, --delete      delete a bookmark
   -l, --list        print the bookmarks
   -m, --merge       add the bookmarks on stdin, skipping the known ones
   -t, --tag <tag>   only consider bookmarks with this tag
   -S, --sort <o>    used (default), recent, url, desc or tag
   -h, --help
 EOF
 }
 
 # ---- external programs: menu, clipboard, opener ----
 
 # dmenu when there is a display to draw it on and bm does not run in a
 # terminal, for example from a key of the window manager. In a terminal fzf
 # is the menu, because its preview shows the page of the bookmark under the
 # cursor. fzf also stands in when dmenu is not installed.
 pickmenu () {
     [ -n "$SBM_MENU" ] && return
     if [ -n "$DISPLAY$WAYLAND_DISPLAY" ] && ! { [ -t 0 ] && [ -t 2 ]; }; then
         order='dmenu fzf'
     else
         order='fzf dmenu'
     fi
     for menu in $order; do
         if have "$menu"; then
             SBM_MENU=$menu
             return
         fi
     done
     # shellcheck disable=SC2016
     die 'no menu program found: install dmenu or fzf, or set $SBM_MENU'
 }
 
 # $SBM_MENU may carry arguments, so it is split on purpose.
 custommenu () {
     # shellcheck disable=SC2086
     $SBM_MENU "$@"
 }
 
 fzfcmd () {
     # shellcheck disable=SC2086
     fzf -i --reverse --height=40% $SBM_FZF_OPTS "$@"
 }
 
 # fzfpick <fzf options>: the chosen line, or else what was typed, which is
 # what dmenu gives by itself.
 fzfpick () {
     out=$(fzfcmd --print-query "$@")
     chosen=$(printf '%s\n' "$out" | sed -n 2p)
     printf '%s\n' "${chosen:-$(printf '%s\n' "$out" | sed -n 1p)}"
 }
 
 # pick <prompt>: choices on stdin; the chosen line, or the typed text.
 pick () {
     case $SBM_MENU in
         fzf)   fzfpick --prompt="$1 " ;;
         dmenu) dmenu -i -l "$DMENULINES" -p "$1" ;;
         *)     custommenu pick "$1" ;;
     esac
 }
 
 # pickmulti <prompt>: like pick, for any number of lines.
 pickmulti () {
     choices=$(cat)
     case $SBM_MENU in
         fzf)
             while :; do
                 out=$(printf '%s\n' "$choices" | fzfcmd --multi --print-query \
                       --prompt="$1 " --header='TAB marks, ENTER confirms. No match: ENTER creates the typed tag, ESC finishes.')
                 chosen=$(printf '%s\n' "$out" | sed 1d)
                 if [ -n "$chosen" ]; then
                     printf '%s\n' "$chosen"
                     break
                 fi
                 typed=$(printf '%s\n' "$out" | sed -n 1p)
                 [ -n "$typed" ] || break
                 printf '%s\n' "$typed"
             done
             ;;
         dmenu)
             while :; do
                 one=$(printf 'done | (choose when done)\n%s\n' "$choices" \
                       | dmenu -i -l "$DMENULINES" -p "$1")
                 # An empty answer means the menu was closed.
                 [ -z "$one" ] || [ "${one%% *}" = 'done' ] && break
                 printf '%s\n' "$one"
             done
             ;;
         *)  printf '%s\n' "$choices" | custommenu multi "$1" ;;
     esac
 }
 
 # ask <prompt> [default]: free text on stdout.
 ask () {
     case $SBM_MENU in
         fzf)
             printf '%s%s: ' "$1" "${2:+ [$2]}" >&2
             IFS= read -r reply || reply=
             printf '%s\n' "${reply:-$2}"
             ;;
         dmenu)
             if [ -n "$2" ]; then printf '%s\n' "$2"; fi | dmenu -p "$1:"
             ;;
         *)
             if [ -n "$2" ]; then printf '%s\n' "$2"; fi | custommenu ask "$1"
             ;;
     esac
 }
 
 clip_out () {
     # shellcheck disable=SC2086,SC2016
     if   [ -n "$SBM_COPY" ]; then $SBM_COPY
     elif [ -n "$WAYLAND_DISPLAY" ] && have wl-copy; then wl-copy
     elif have xclip; then xclip -i -selection clipboard
     elif have xsel; then xsel -ib
     else die 'no clipboard program found: set $SBM_COPY'
     fi
 }
 
 # The primary selection first, then the clipboard. Never fatal: without
 # either there is just no URL to suggest.
 clip_in () {
     # shellcheck disable=SC2086
     if   [ -n "$SBM_PASTE" ]; then $SBM_PASTE
     elif [ -n "$WAYLAND_DISPLAY" ] && have wl-paste; then
         wl-paste -n -p; echo; wl-paste -n
     elif have xclip; then
         xclip -o; echo; xclip -o -selection clipboard
     elif have xsel; then
         xsel -op; echo; xsel -ob
     fi 2>/dev/null
 }
 
 opener () {
     # shellcheck disable=SC2086,SC2016
     if   [ -n "$SBM_OPEN" ]; then $SBM_OPEN "$1"
     elif have xdg-open; then xdg-open "$1"
     else die 'no opener found: set $SBM_OPEN'
     fi
 }
 
 # ---- the bookmark file ----
 
 # Bookmarks restricted to $tagfilter and ordered by $sortorder, each followed
 # by a fourth field: how often it was used.
 rows () {
     SBM_TAG=$tagfilter SBM_ORDER=$sortorder SBM_USAGE=$USAGE awk -F'\t' '
         BEGIN {
             while ((getline line < ENVIRON["SBM_USAGE"]) > 0) {
                 split(line, f, "\t")
                 used[f[1]] = f[2]
             }
             order = ENVIRON["SBM_ORDER"]
         }
         NF == 0 || /^#/ { next }
         ENVIRON["SBM_TAG"] != "" {
             hit = 0
             n = split($3, tags, " ")
             for (i = 1; i <= n; i++)
                 if (tags[i] == ENVIRON["SBM_TAG"]) hit = 1
             if (!hit) next
         }
         {
             if (order == "used")        key = sprintf("%09d", 999999999 - used[$1])
             else if (order == "recent") key = sprintf("%09d", 999999999 - NR)
             else if (order == "desc")   key = tolower($2)
             else if (order == "tag")    key = tolower($3)
             else                        key = ""
             printf "%s\t%s\t%s\t%s\t%s\t%d\n", key, tolower($1), $1, $2, $3, used[$1]
         }' "$BOOKMARKS" | LC_ALL=C sort -t"$TAB" -k1,1 -k2,2 | cut -f3-
 }
 
 # details <url>: a bookmark in full, one field per line.
 details () {
     rows | SBM_URL=$1 awk -F'\t' '$1 == ENVIRON["SBM_URL"] {
         printf "%s\n%s\ntags: %s\nused: %d\n", $1, $2, $3, $4
         exit
     }'
 }
 
 is_bookmark () {
     SBM_URL=$1 awk -F'\t' '$1 == ENVIRON["SBM_URL"] { found = 1; exit }
         END { exit !found }' "$BOOKMARKS"
 }
 
 # For fzf a fifth field is added, and it is all that is listed. The first
 # four feed the preview, which follows the cursor: the bookmark in full, then
 # the text of its page when bm-page is installed. fzf stops the preview when
 # the cursor moves on, so the short sleep keeps a fast scroll from fetching
 # each page on the way. A sleep that knows no fractions fails and skips it.
 PREVIEW="printf '%s\n%s\ntags: %s\nused: %s\n\n' {1} {2} {3} {4}; sleep 0.3 2>/dev/null; bm-page {1} 2>/dev/null"
 fzfrows () {
     awk -F'\t' 'NF {
         desc = $2
         if (length(desc) > 44) desc = substr(desc, 1, 42) ".."
         printf "%s\t%-44s  %-18s  %s\n", $0, desc, $3, $1
     }'
 }
 
 # withpreview <fzf command and options>: for the output of fzfrows.
 withpreview () {
     "$@" --delimiter="$TAB" --with-nth=5.. \
          --preview-window=right:50%:wrap --preview="$PREVIEW"
 }
 
 # choose <prompt>: a bookmark's URL, or whatever else the user typed.
 choose () {
     if [ "$SBM_MENU" = fzf ]; then
         rows | fzfrows | withpreview fzfpick --prompt="$1 "
     else
         rows | cut -f1-3 | pick "$1"
     fi | cut -f1
 }
 
 # choose_url <prompt>: like choose, but only a bookmark will do.
 choose_url () {
     if [ -z "$(rows)" ]; then
         [ -n "$tagfilter" ] && die "no bookmarks tagged '$tagfilter'"
         die 'no bookmarks yet; add one with: bm --add'
     fi
     url=$(choose "$1")
     [ -n "$url" ] || exit 1
     is_bookmark "$url" || die "not a bookmark: $url"
     printf '%s\n' "$url"
 }
 
 # find_dup <url>: print the bookmark that is the same page as <url>, if any.
 find_dup () {
     SBM_URL=$1 awk -F'\t' "$AWK_NORM"'
         BEGIN { want = norm(ENVIRON["SBM_URL"]) }
         NF && !/^#/ && norm($1) == want { print; exit }' "$BOOKMARKS"
 }
 
 # tmpfile <file>: create an empty temporary file and print its name. Beside
 # <file> if that directory can be written to, else in $TMPDIR. noclobber makes
 # the shell create it with O_EXCL, so a file or symlink planted under that
 # name in a shared /tmp is refused rather than followed: mktemp, in POSIX.
 tmpfile () {
     for candidate in "$1.tmp.$$" "${TMPDIR:-/tmp}/sbm.$$.${1##*/}"; do
         if (umask 077; set -C; : > "$candidate") 2>/dev/null; then
             printf '%s\n' "$candidate"
             return 0
         fi
     done
     return 1
 }
 
 # rewrite <file>: replace <file> with stdin. Through cat, not mv, so that a
 # symlinked file stays a symlink and keeps its mode.
 rewrite () {
     tmp=$(tmpfile "$1") || die "cannot create a temporary file for $1"
     cat > "$tmp" && cat "$tmp" > "$1"
     rc=$?
     rm -f "$tmp"
     return $rc
 }
 
 # lock: take the write lock of the bookmark file, a directory beside it. bm
 # holds it while it changes the file, and bm-sync while it reads or writes
 # the file, so that neither writes over a change of the other. A lock whose
 # process is gone is taken over. After $SBM_LOCK_WAIT seconds (default 10)
 # bm stops.
 lock () {
     waited=0
     until mkdir "$WLOCK" 2>/dev/null; do
         pid=$(cat "$WLOCK/pid" 2>/dev/null)
         if [ -n "$pid" ] && ! kill -0 "$pid" 2>/dev/null; then
             [ "$(cat "$WLOCK/pid" 2>/dev/null)" != "$pid" ] || rm -rf "$WLOCK"
             continue
         fi
         [ "$waited" -lt "${SBM_LOCK_WAIT:-10}" ] \
             || die "$BOOKMARKS is in use (bm -e or bm-sync). If neither runs, remove $WLOCK"
         sleep 1
         waited=$((waited + 1))
     done
     echo $$ > "$WLOCK/pid"
     locked=1
     # Also in the subshell of add_inside, which does not keep these traps.
     trap unlock EXIT
     trap 'exit 1' HUP INT TERM
 }
 
 unlock () {
     [ -z "$locked" ] || rm -rf "$WLOCK"
     locked=
 }
 
 # bump <url>: count a use, for the "used" order. The counts live beside the
 # bookmark file, which stays a plain list: url, count, time of last use.
 # srand() returns the previous seed, and the first seed is the time of day:
 # that is "date +%s" for a POSIX that has no %s.
 bump () {
     [ -e "$USAGE" ] || : > "$USAGE" || return 0
     SBM_URL=$1 awk -F'\t' '
         BEGIN { OFS = "\t"; srand(); now = srand() }
         $1 == ENVIRON["SBM_URL"] { $2 = $2 + 1; $3 = now; seen = 1 }
         { print }
         END { if (!seen) print ENVIRON["SBM_URL"], 1, now }
     ' "$USAGE" | rewrite "$USAGE"
 }
 
 # learn_tags: tag names on stdin; the ones $USERTAGS lacks are appended to it.
 learn_tags () {
     [ -e "$USERTAGS" ] || : > "$USERTAGS"
     while IFS= read -r name; do
         [ -n "$name" ] || continue
         sed 's/[ |].*//' "$USERTAGS" | grep -Fxq -- "$name" \
             || printf '%s | \n' "$name" >> "$USERTAGS"
     done
 }
 
 # changed <message>: the file was written. bm-commit, where installed, keeps
 # its history in git. bm-sync, where installed, tells your other machines; it
 # runs in the background, so that a slow network never holds the menu up.
 changed () {
     if have bm-commit; then bm-commit "$1"; fi
     if have bm-sync; then bm-sync -q >/dev/null 2>&1 & fi
 }
 
 # ---- actions ----
 
 copy_url () {
     bump "$1"
     printf '%s' "$1" | clip_out
 }
 
 open_url () {
     bump "$1"
     opener "$1"
 }
 
 # The editor reads the file when it starts and writes it when you save, so
 # bm holds the lock until the editor ends. bm-sync then waits, and syncs the
 # edit after it.
 edit_url () {
     lock
     line=$(SBM_URL=$1 awk -F'\t' \
            '$1 == ENVIRON["SBM_URL"] { print NR; exit }' "$BOOKMARKS")
     ${VISUAL:-${EDITOR:-vi}} "+${line:-1}" "$BOOKMARKS"
     unlock
     changed 'bm: edit'
 }
 
 delete_url () {
     lock
     for file in "$BOOKMARKS" "$USAGE"; do
         [ -e "$file" ] || continue
         SBM_URL=$1 awk -F'\t' '$1 != ENVIRON["SBM_URL"]' "$file" \
             | rewrite "$file" || die "could not rewrite $file"
     done
     unlock
     changed "bm: delete $1"
 }
 
 # urlencode <text>: for a query string. awk has no ord(), hence the table.
 urlencode () {
     printf '%s' "$1" | LC_ALL=C awk '
         BEGIN { for (i = 1; i < 256; i++) ord[sprintf("%c", i)] = i }
         {
             for (i = 1; i <= length($0); i++) {
                 c = substr($0, i, 1)
                 if (c ~ /[A-Za-z0-9._~-]/) out = out c
                 else if (c == " ")         out = out "+"
                 else                       out = out sprintf("%%%02X", ord[c])
             }
         }
         END { printf "%s", out }'
 }
 
 # go <text>: open text that is not a bookmark. One word with "://" or a dot
 # in it is an address. Anything else is a web search: by the engine whose
 # keyword is the first word ($ENGINES holds "keyword | url with %s" lines),
 # or else by $SEARCH.
 go () {
     case $1 in
         *' '*) ;;
         *://*) opener "$1"; return ;;
         *.*)   opener "https://$1"; return ;;
     esac
     engine=$SEARCH
     query=$1
     if [ "${1%% *}" != "$1" ] && [ -r "$ENGINES" ]; then
         found=$(SBM_KEY=${1%% *} awk -F' *[|] *' \
                 '$1 == ENVIRON["SBM_KEY"] { print $2; exit }' "$ENGINES")
         if [ -n "$found" ]; then
             engine=$found
             query=${1#* }
         fi
     fi
     opener "$(printf '%s\n' "$engine" | sed "s|%s|$(urlencode "$query")|")"
 }
 
 plumb () {
     url=$(choose 'open:')
     [ -n "$url" ] || exit 1
     if is_bookmark "$url"; then open_url "$url"; else go "$url"; fi
 }
 
 # Exit status 3 means "already bookmarked".
 add () {
     url=$1
     if [ -z "$url" ]; then
         url=$(ask 'url' "$(clip_in | grep '://' | head -n 1)")
     fi
     url=$(printf '%s' "$url" | tr -d '[:space:]')
     [ -n "$url" ] || exit 1
 
     dup=$(find_dup "$url")
     if [ -n "$dup" ]; then
         printf 'bm: already bookmarked:\n%s\n' "$dup" >&2
         exit 3
     fi
 
     # bm-title, where installed, fetches the page's title.
     title=
     if have bm-title; then title=$(bm-title "$url"); fi
     desc=$(ask 'description' "$title" | tr '\t' ' ')
 
     [ -e "$USERTAGS" ] || : > "$USERTAGS"
     names=$(pickmulti 'tags:' < "$USERTAGS" | sed 's/[ |].*//' | sed '/^$/d' \
             | sort -u)
     printf '%s\n' "$names" | learn_tags
     tags=$(printf '%s\n' "$names" | paste -sd ' ' -)
 
     lock
     printf '%s\t%s\t%s\n' "$url" "$desc" "$tags" >> "$BOOKMARKS"
     unlock
     changed "bm: add $url"
 }
 
 # merge: bookmark lines on stdin (a bare URL per line will do); the ones not
 # known yet are appended. This is how the output of bm-import gets in.
 merge () {
     new=$(tmpfile "$BOOKMARKS") || die 'cannot create a temporary file'
     lock
     SBM_FILE=$BOOKMARKS SBM_NEW=$new awk -F'\t' "$AWK_NORM"'
         BEGIN {
             while ((getline line < ENVIRON["SBM_FILE"]) > 0) {
                 split(line, f, "\t")
                 seen[norm(f[1])] = 1
             }
         }
         NF == 0 || /^#/ { next }
         seen[norm($1)]++ { skipped++; next }
         { printf "%s\t%s\t%s\n", $1, $2, $3 > ENVIRON["SBM_NEW"]; added++ }
         END { printf "added %d, skipped %d duplicates\n", added, skipped }'
     cut -f3 "$new" | tr ' ' '\n' | sort -u | learn_tags
     cat "$new" >> "$BOOKMARKS"
     unlock
     rm -f "$new"
     changed 'bm: merge'
 }
 
 nextorder () {
     case $sortorder in
         used)   sortorder=recent ;;
         recent) sortorder=url ;;
         url)    sortorder=desc ;;
         desc)   sortorder=tag ;;
         *)      sortorder=used ;;
     esac
 }
 
 # add exits, which must not end a browsing session; and when it refuses a
 # duplicate the user has to get to see that before the list comes back.
 add_inside () {
     ( add '' )
     if [ $? -eq 3 ]; then
         ask 'already bookmarked; press ENTER' >/dev/null
     fi
 }
 
 # browse_fzf: fzf can bind keys, so one list does everything. Opening and
 # copying leave it, the other keys come back to it.
 browse_fzf () {
     while :; do
         header="ENTER open  ^Y copy  ^A add  ^D delete  ^E edit  ^S sort [$sortorder]"
         out=$(rows | fzfrows | withpreview fzfcmd --print-query \
               --expect=ctrl-y,ctrl-a,ctrl-d,ctrl-e,ctrl-s \
               --header="$header" --prompt='bookmark: ')
         [ -n "$out" ] || exit 1
         typed=$(printf '%s\n' "$out" | sed -n 1p)
         key=$(printf '%s\n' "$out" | sed -n 2p)
         url=$(printf '%s\n' "$out" | sed -n 3p | cut -f1)
 
         case $key in
             ctrl-a) add_inside; continue ;;
             ctrl-s) nextorder; continue ;;
         esac
         if [ -z "$url" ]; then
             [ -n "$key" ] && continue
             [ -n "$typed" ] || exit 1
             go "$typed"
             exit 0
         fi
         case $key in
             ctrl-y) copy_url "$url"; exit 0 ;;
             ctrl-e) edit_url "$url" ;;
             ctrl-d)
                 case $(ask "delete $url? (y/N)") in
                     y|Y|yes) delete_url "$url" ;;
                 esac
                 ;;
             *)      open_url "$url"; exit 0 ;;
         esac
     done
 }
 
 # browse_menu: dmenu can neither bind keys nor preview, so a second menu does
 # both: it shows the bookmark in full and asks what to do with it. Closing it
 # goes back to the list; closing the list leaves.
 browse_menu () {
     while :; do
         chosen=$( { printf '[add]\n'; rows | cut -f1-3; } | pick 'bookmark:')
         [ -n "$chosen" ] || exit 1
         if [ "$chosen" = '[add]' ]; then
             add_inside
             continue
         fi
         url=$(printf '%s\n' "$chosen" | cut -f1)
         if ! is_bookmark "$url"; then
             go "$chosen"
             exit 0
         fi
         action=$( { printf 'open\ncopy\nedit\ndelete\n'
                     details "$url" | sed 's/^/  /'; } | pick 'do:')
         case $action in
             open)   open_url "$url"; exit 0 ;;
             copy)   copy_url "$url"; exit 0 ;;
             edit)   edit_url "$url" ;;
             delete) delete_url "$url" ;;
         esac
     done
 }
 
 # ---- main ----
 
 setaction () {
     if [ -n "$action" ]; then
         printf 'bm: only one action at a time\n' >&2
         exit 2
     fi
     action=$1
 }
 
 # needarg <flag> <count of remaining arguments> <value>
 needarg () {
     if [ "$2" -lt 2 ] || [ -z "$3" ]; then
         printf 'bm: %s needs an argument\n' "$1" >&2
         exit 2
     fi
 }
 
 action=
 addurl=
 tagfilter=
 sortorder=${SBM_SORT:-used}
 while [ $# -gt 0 ]; do
     case $1 in
         -h|--help)   setaction help ;;
         -c|--copy)   setaction copy ;;
         --print)     setaction print ;;
         -o|--open|-p|--plumb) setaction open ;;
         -e|--edit)   setaction edit ;;
         -d|--delete) setaction delete ;;
         -l|--list)   setaction list ;;
         -m|--merge)  setaction merge ;;
         -a|--add)
             setaction add
             case ${2-} in
                 ''|-*) ;;
                 *) addurl=$2; shift ;;
             esac
             ;;
         -t|--tag)
             needarg "$1" $# "${2-}"
             tagfilter=$2
             shift
             ;;
         -S|--sort)
             needarg "$1" $# "${2-}"
             sortorder=$2
             shift
             ;;
         *)
             printf 'bm: unknown argument: %s\n' "$1" >&2
             usage >&2
             exit 2
             ;;
     esac
     shift
 done
 
 case $sortorder in
     used|recent|url|desc|tag) ;;
     *)
         printf 'bm: unknown sort order: %s\n' "$sortorder" >&2
         exit 2
         ;;
 esac
 
 if [ "$action" = help ]; then
     usage
     exit 0
 fi
 
 mkdir -p "$(dirname "$BOOKMARKS")" || die "cannot create directory for $BOOKMARKS"
 mkdir -p "$(dirname "$USERTAGS")"
 [ -e "$BOOKMARKS" ] || : > "$BOOKMARKS" || die "cannot create $BOOKMARKS"
 
 if awk '!/\t/ && !/^#/ && NF { found = 1; exit } END { exit !found }' "$BOOKMARKS"
 then
     printf 'bm: %s has lines in the old format; run: bm-migrate\n' "$BOOKMARKS" >&2
 fi
 
 case $action in
     list|merge) ;;
     *) pickmenu ;;
 esac
 
 case $action in
     '')
         if [ "$SBM_MENU" = fzf ]; then browse_fzf; else browse_menu; fi
         ;;
     open)   plumb ;;
     copy)   url=$(choose_url 'copy:')   && copy_url "$url" ;;
     print)  url=$(choose_url 'print:')  && bump "$url" && printf '%s\n' "$url" ;;
     edit)   url=$(choose_url 'edit:')   && edit_url "$url" ;;
     delete) url=$(choose_url 'delete:') && delete_url "$url" \
                 && printf 'deleted %s\n' "$url" ;;
     add)    add "$addurl" ;;
     list)   rows | cut -f1-3 ;;
     merge)  merge ;;
 esac