acstack 0.49.0 → 0.49.1

package/assets/terminal-workspace/lib/apply-tuicr.sh

@@ -0,0 +1,133 @@
+build_tuicr_fork() {
+  # TEMPORARY path. Builds the two unmerged upstream pull requests the config
+  # comments name. Once both land, set build_from_fork: false and this whole
+  # function stops being reachable.
+  # `have cargo` is not enough: a rustup shim on PATH with no default
+  # toolchain installed exits non-zero on every invocation.
+  if ! cargo --version >/dev/null 2>&1; then
+    say "tuicr fork build needs a working cargo (see rustup.rs), skipping"
+    cargo --version 2>&1 | head -2 | sed 's/^/    /'
+    return 1
+  fi
+  have git   || { say "tuicr fork build needs git, skipping"; return 1; }
+  local url branch dir
+  url=$(cfg_get tuicr.fork "https://github.com/ac8318740/tuicr")
+  branch=$(cfg_get tuicr.fork_branch "local/daily")
+  dir="${ACSTACK_TUICR_SRC:-$HOME/tuicr}"
+  if [ -d "$dir/.git" ]; then
+    git -C "$dir" fetch --quiet --all 2>/dev/null
+    git -C "$dir" checkout --quiet "$branch" 2>/dev/null || { say "tuicr: no branch $branch in $dir"; return 1; }
+    git -C "$dir" pull --quiet --ff-only 2>/dev/null
+  else
+    git clone --quiet -b "$branch" "$url" "$dir" || { say "tuicr: clone failed"; return 1; }
+  fi
+  say "building tuicr from $branch (a few minutes on a cold cache)"
+  local log; log=$(mktemp)
+  if ! ( cd "$dir" && cargo build --release ) >"$log" 2>&1; then
+    say "tuicr: build failed in $dir"
+    # Swallowing cargo's output here made a missing toolchain look identical
+    # to a compile error.
+    grep -E '^(error|warning: unused)' "$log" | head -5 | sed 's/^/    /'
+    tail -3 "$log" | sed 's/^/    /'
+    rm -f "$log"; return 1
+  fi
+  rm -f "$log"
+  mkdir -p "$BIN"
+  # mv, not cp: cp fails with "Text file busy" when tuicr is running.
+  cp "$dir/target/release/tuicr" "$BIN/tuicr.new" && mv -f "$BIN/tuicr.new" "$BIN/tuicr"
+  say "tuicr built from $branch and installed to $BIN/tuicr"
+}
+
+apply_tuicr() {
+  local from_fork; from_fork=$(cfg_get tuicr.build_from_fork false)
+  if ! have tuicr; then
+    if [ "$from_fork" = "true" ]; then
+      build_tuicr_fork || return 0
+    else
+      install_binary tuicr agavra/tuicr x86_64-unknown-linux-gnu || return 0
+    fi
+  fi
+  have tuicr || { say "tuicr not installed, skipping config"; return 0; }
+
+  mkdir -p "$HOME/.config/tuicr"
+  # show_file_line_stats and file_list_width only exist in the fork build.
+  # Writing them against a stock release makes tuicr warn on every start.
+  ACSTACK_ARGS="$from_fork|$(cfg_get tuicr.file_list_width 30)|$(cfg_get tuicr.show_file_line_stats true)|$(cfg_get tuicr.appearance "")|$BEGIN|$END" \
+    py "$HOME/.config/tuicr/config.toml" <<'PY'
+import os, re, sys
+path = sys.argv[1]
+from_fork, width, stats, appearance, begin, end = os.environ["ACSTACK_ARGS"].split("|")
+text = open(path).read() if os.path.isfile(path) else ""
+text = re.sub(re.escape(begin) + r".*?" + re.escape(end) + r"\n?", "", text, flags=re.S)
+
+block = [begin]
+managed = set()
+if from_fork == "true":
+    block += [
+        "# These two keys exist only in the fork build. See the tuicr section",
+        "# of ~/.config/acstack/terminal-workspace.yaml.",
+        f"show_file_line_stats = {stats}",
+        f"file_list_width = {width}",
+        "# A local build must not be replaced by a stock release.",
+        "no_update_check = true",
+    ]
+    managed |= {"show_file_line_stats", "file_list_width", "no_update_check"}
+else:
+    block += ["# Stock release: the fork-only keys are omitted so tuicr does not",
+              "# warn about unknown config keys at startup."]
+# `system` asks the terminal for its background colour over OSC 11. Under
+# `herdr --remote` nothing answers, so tuicr falls back to a desktop setting
+# that a headless machine reports as light, and paints dark text on a black
+# terminal. Pinning the value sidesteps the whole detection path.
+if appearance:
+    block += ["# Pinned rather than detected. See the tuicr section of",
+              "# ~/.config/acstack/terminal-workspace.yaml.",
+              f'appearance = "{appearance}"']
+    managed.add("appearance")
+block.append(end)
+
+# TOML forbids a duplicate key, so a value the user set by hand before this
+# script managed it would make the merged file unparseable and tuicr would
+# reject the lot. Drop only the keys this run writes, and the comment block
+# that introduced each one: the setting alone leaves a heading over nothing.
+kept, pending, cut = [], [], None
+for ln in text.splitlines():
+    stripped = ln.strip()
+    if stripped.startswith("#") or not stripped:
+        pending.append(ln)
+        continue
+    # Every key this script writes is top level, so the first table header ends
+    # the search. A key of the same name inside a table is a different key.
+    if cut is None and stripped.startswith("["):
+        # Before the comments introducing that header, not after them.
+        cut = len(kept)
+    if cut is None and "=" in ln and ln.split("=", 1)[0].strip().strip('"') in managed:
+        pending = []
+        continue
+    kept.extend(pending)
+    pending = []
+    kept.append(ln)
+kept.extend(pending)
+
+# The block holds top-level keys, so it goes above the first table header
+# rather than at the end of the file. Appended after a `[export]` or
+# `[forge]` section, every key in it would belong to that section instead:
+# tuicr would warn about an unknown key there and never see the setting, and
+# a name the section already uses makes the file invalid outright.
+if cut is None:
+    text = "\n".join(kept).rstrip("\n")
+    text = (text + "\n\n" if text else "") + "\n".join(block) + "\n"
+else:
+    head = "\n".join(kept[:cut]).rstrip("\n")
+    text = ((head + "\n\n" if head else "") + "\n".join(block) + "\n\n"
+            + "\n".join(kept[cut:]).strip("\n") + "\n")
+open(path, "w").write(text)
+PY
+  say "tuicr config written"
+}
+
+# The sidebar draws a workspace's position in herdr's stored list, but
+# prefix+1..9 targets its row in the grouped sidebar. Creating or removing a
+# worktree moves one and not the other, so the numbers you read stop being the
+# numbers you press. This links a tiny herdr plugin that reruns the alignment
+# on every event that can move a row, so it never needs remembering.

package/assets/terminal-workspace/lib/apply-yazi.sh

@@ -0,0 +1,389 @@
+apply_yazi() {
+  [ "$(cfg_get yazi.enabled true)" = "true" ] || return 0
+  if ! have yazi; then
+    install_binary yazi sxyazi/yazi x86_64-unknown-linux-gnu || return 0
+    install_binary ya   sxyazi/yazi x86_64-unknown-linux-gnu || true
+  fi
+  have yazi || { say "yazi not installed, skipping config"; return 0; }
+
+  # piper turns any shell command into a previewer, which is how acstack-md
+  # gets to draw markdown in the preview pane.
+  if have ya && ! ya pkg list 2>/dev/null | grep -q "plugins:piper"; then
+    ya pkg add yazi-rs/plugins:piper >/dev/null 2>&1 \
+      && say "yazi piper plugin installed" \
+      || say "piper install failed; markdown will preview as plain text"
+  fi
+
+  mkdir -p "$HOME/.config/yazi"
+  ACSTACK_ARGS="$(cfg_get yazi.show_hidden true)|$BEGIN|$END" \
+    py "$HOME/.config/yazi/yazi.toml" <<'PY'
+import os, re, sys
+path = sys.argv[1]
+hidden, begin, end = os.environ["ACSTACK_ARGS"].split("|")
+text = open(path).read() if os.path.isfile(path) else ""
+# Drop any previous managed region, both to stay idempotent and so what is
+# left to inspect below is exactly the config the user wrote.
+text = re.sub(re.escape(begin) + r".*?" + re.escape(end) + r"\n?", "", text, flags=re.S)
+
+# Every namespace the block writes into. TOML forbids declaring any of them
+# twice, and yazi answers one duplicate by throwing the entire config away and
+# falling back to presets. So a namespace the user already occupies is theirs:
+# the block gives that piece up rather than cost them every other setting they
+# have. Deciding which are taken is a question about the parsed document, not
+# about the text: [ mgr ], [ "mgr" ], [ 'mgr' ] and mgr.show_hidden = false are
+# all the same table, and only a parser knows that.
+NAMESPACES = ("mgr", "opener.markdown", "plugin.prepend_previewers", "open.prepend_rules")
+
+try:
+    import tomllib
+except ImportError:  # tomllib is 3.11 and newer
+    tomllib = None
+
+
+def claimed(cfg):
+    """Which of NAMESPACES the user's own config already occupies."""
+    if tomllib is None:
+        # No parser to reason with, so read the text conservatively: name the
+        # top-level table wherever TOML could open one, as a header or as a
+        # key of its own. That concedes namespaces which would have been safe
+        # to write, and each of those costs one setting; guessing the other
+        # way costs the file. One thing text cannot see is that the config is
+        # broken already, so unlike the parsed path below this branch does not
+        # concede everything for a file that never parsed.
+        found = set()
+        for ns in NAMESPACES:
+            root = re.escape(ns.split(".")[0])
+            # A key may be bare, a basic string or a literal string, and all
+            # three name the same table: [mgr], ["mgr"] and ['mgr'] are one.
+            name = r"""(?:%s|"%s"|'%s')""" % (root, root, root)
+            header = r'\[\[?\s*%s\s*[.\]]' % name
+            key = r'%s\s*[.=]' % name
+            if re.search(r"(?m)^\s*(?:%s|%s)" % (header, key), cfg):
+                found.add(ns)
+        return found
+    try:
+        tomllib.loads(cfg)
+    except tomllib.TOMLDecodeError:
+        # Their config does not parse as it stands. We cannot tell what it
+        # claims, and repairing it is not ours to do, so concede everything:
+        # the file ends up exactly as broken as it arrived, never more.
+        return set(NAMESPACES)
+    found = set()
+    for ns in NAMESPACES:
+        # Whether a namespace is free is not "is the key there". TOML also
+        # refuses to reopen an inline table and to overwrite a scalar, so
+        # opener = { text = [...] } and opener = "nope" both have no
+        # opener.markdown key and are both fatal to write under. tomllib
+        # hands an inline table back as an ordinary dict, so no walk over the
+        # parsed document can tell those apart from a table that is still
+        # open. Put the question to the parser instead, in the exact form the
+        # block would write it: append that header to their config and see
+        # whether the whole thing still parses. Whatever it refuses is theirs.
+        probe = "[mgr]" if ns == "mgr" else "[[%s]]" % ns
+        try:
+            tomllib.loads(cfg + "\n" + probe + "\n")
+        except tomllib.TOMLDecodeError:
+            found.add(ns)
+    return found
+
+
+taken = claimed(text)
+parts = []
+
+if "plugin.prepend_previewers" not in taken:
+    parts.append("""
+[[plugin.prepend_previewers]]
+url = "*.md"
+run = 'piper -- COLUMNS=$w acstack-md --preview "$1"'
+
+[[plugin.prepend_previewers]]
+url = "*.markdown"
+run = 'piper -- COLUMNS=$w acstack-md --preview "$1"'
+""")
+
+if "opener.markdown" not in taken:
+    # An array of tables rather than a markdown key under [opener]: a second
+    # [opener] table would be a duplicate, while a subtable of one the user
+    # has already declared is legal.
+    parts.append("""
+# The preview pane is narrow, so a wide diagram shows its placeholder there.
+# Enter opens the same renderer full width, where more of them fit.
+#
+# %s is what yazi substitutes for the files being opened, already quoted. Not
+# "$@": an opener template is run as `sh -c '<run>'` with nothing after it, so
+# $0 is "sh" and $@ is empty - measured on yazi 26.8.15, where "$@" left
+# acstack-md with no file at all and Enter did nothing but print its usage.
+[[opener.markdown]]
+run = 'acstack-md %s'
+block = true
+desc = "Read (acstack-md)"
+
+# Rendered markdown has no line number to quote back in a review, so the same
+# file is also readable as its own source. Second, not first: it answers a
+# narrower question than reading does, and still a readier one than editing.
+# Enter takes the first entry, so O is the key that offers this one.
+[[opener.markdown]]
+run = 'acstack-md --numbered %s'
+block = true
+desc = "Read with line numbers"
+
+[[opener.markdown]]
+run = '${EDITOR:-vi} %s'
+block = true
+desc = "Edit"
+""")
+
+if "open.prepend_rules" not in taken:
+    # Worth writing even when the opener above was skipped: the rules point
+    # markdown files at whichever opener.markdown ends up in the file.
+    parts.append("""
+[[open.prepend_rules]]
+url = "*.md"
+use = "markdown"
+
+[[open.prepend_rules]]
+url = "*.markdown"
+use = "markdown"
+""")
+
+if "mgr" not in taken:
+    parts.append(f"[mgr]\nshow_hidden = {hidden}")
+
+# The markers go down even when every piece was conceded, so the shell below
+# can still read the region back and see what is missing from it.
+block = begin + "\n" + "\n\n".join(p.strip("\n") for p in parts) + "\n" + end
+text = text.rstrip("\n")
+open(path, "w").write((text + "\n\n" if text else "") + block + "\n")
+PY
+  # A setting the block gave up to the user's own config is simply absent from
+  # what was written, so read the region back rather than let it go unsaid.
+  local written; written="$(sed -n "/$BEGIN/,/$END/p" "$HOME/.config/yazi/yazi.toml")"
+  case "$written" in *"[[plugin.prepend_previewers]]"*) ;; *)
+    say "yazi: your yazi.toml already sets plugin.prepend_previewers, so the"
+    say "     markdown previewer was left alone. Add a *.md entry there to"
+    say "     preview markdown with acstack-md." ;;
+  esac
+  case "$written" in *"[[opener.markdown]]"*) ;; *)
+    say "yazi: your yazi.toml already opens markdown its own way, so it was left"
+    say "     alone. Add acstack-md to that opener to read markdown with it." ;;
+  esac
+  case "$written" in *"[[open.prepend_rules]]"*) ;; *)
+    say "yazi: your yazi.toml already sets open.prepend_rules, so the markdown"
+    say "     rules were left alone. Add *.md and *.markdown entries there"
+    say "     pointing at the markdown opener." ;;
+  esac
+  case "$written" in *show_hidden*) ;; *)
+    say "yazi: your yazi.toml already claims mgr itself, so show_hidden was left"
+    say "     alone. Set it there yourself to show hidden files." ;;
+  esac
+  # The keymap is its own file, and prepend_keymap has two spellings: an array
+  # of tables, which is additive and safe to extend, and an inline array under
+  # [mgr], which is one key that TOML forbids declaring twice. Only the second
+  # collides with the entry below, and telling them apart takes the text - both
+  # spellings parse to the same list.
+  ACSTACK_ARGS="$(cfg_get yazi.browser_key "b")|$(cfg_get yazi.line_numbers_key "#")|$(cfg_get yazi.download_key "D")|$(cfg_get yazi.download_target "")|$(cfg_get yazi.edit_key "e")|$BEGIN|$END" \
+    py "$HOME/.config/yazi/keymap.toml" <<'PY'
+import os, re, sys
+
+path = sys.argv[1]
+key, numkey, dlkey, dltarget, editkey, begin, end = os.environ["ACSTACK_ARGS"].split("|")
+text = open(path).read() if os.path.isfile(path) else ""
+# Drop any previous managed region, both to stay idempotent and so what is
+# left to inspect below is exactly the keymap the user wrote.
+text = re.sub(re.escape(begin) + r".*?" + re.escape(end) + r"\n?", "", text, flags=re.S)
+
+try:
+    import tomllib
+except ImportError:  # tomllib is 3.11 and newer
+    tomllib = None
+
+
+def claimed(t):
+    """True when the user's keymap declares prepend_keymap as an inline array
+    under [mgr] - the one spelling our own entry cannot sit beside."""
+    if not re.search(r"^\s*prepend_keymap\s*=", t, flags=re.M):
+        return False
+    if tomllib is None:
+        # No parser to say which table that assignment sits in, so assume the
+        # worst. A conceded binding costs one key; a collision costs the whole
+        # keymap, because yazi answers invalid TOML by falling back to presets.
+        return True
+    try:
+        return "prepend_keymap" in (tomllib.loads(t).get("mgr") or {})
+    except Exception:
+        return True
+
+
+CLAIMED = {k for k in (key, numkey, editkey) if k}
+if dltarget and dlkey:
+    CLAIMED.add(dlkey)
+
+
+def drop_claimed(t):
+    """Remove any prepend_keymap block the user wrote on a key this script is
+    about to bind.
+
+    yazi accepts both, lists both in its help, and runs one of them. So a
+    binding written by hand before this script managed the key leaves two
+    entries saying different things and no way to tell which one fires. Both
+    table spellings, because `manager` is what yazi called `mgr` before the
+    rename and an older keymap still says it.
+    """
+    out, block = [], None
+
+    def bound_key(lines):
+        """The single key this block binds, or None.
+
+        yazi spells `on` four ways: a double-quoted scalar, a single-quoted
+        one, a one-element array, and any of those with a trailing comment.
+        Reading only the first spelling leaves the other three in place, which
+        is the state this function exists to prevent. A longer array is a
+        multi-key sequence and never collides with a single key.
+        """
+        body = "\n".join(lines[1:])
+        if tomllib is not None:
+            try:
+                on = tomllib.loads(body).get("on")
+            except Exception:
+                on = ...  # unparseable, so fall through to the regex
+            if on is not ...:
+                if isinstance(on, str):
+                    return on
+                if isinstance(on, list) and len(on) == 1 and isinstance(on[0], str):
+                    return on[0]
+                return None
+        m = re.search(r"""(?m)^\s*on\s*=\s*\[?\s*(?:"([^"]*)"|'([^']*)')""", body)
+        return (m.group(1) if m.group(1) is not None else m.group(2)) if m else None
+
+    def close():
+        nonlocal block
+        if block is None:
+            return
+        # Trailing blank lines belong to whatever comes next, not to the
+        # binding, so they stay even when the binding goes.
+        tail = []
+        while block and not block[-1].strip():
+            tail.insert(0, block.pop())
+        if bound_key(block) not in CLAIMED:
+            out.extend(block)
+        out.extend(tail)
+        block = None
+
+    for ln in t.splitlines():
+        if re.match(r"^\s*\[\[\s*(?:mgr|manager)\.prepend_keymap\s*\]\]\s*$", ln):
+            close()
+            block = [ln]
+            continue
+        if block is not None:
+            # Any other table header ends this binding and belongs to what
+            # follows, so it is never dropped with the block.
+            if ln.lstrip().startswith("["):
+                close()
+                out.append(ln)
+                continue
+            block.append(ln)
+            continue
+        out.append(ln)
+    close()
+    return "\n".join(out)
+
+
+parts = []
+if not claimed(text):
+    # A binding conceded below is one this script never writes, so the user's
+    # own must survive. Only strip when the bindings are actually going in.
+    text = drop_claimed(text)
+    # %h is the hovered file. $0 and $@ are not: yazi runs the template through
+    # a shell, where $0 names the shell itself and $@ is empty - both measured,
+    # and both would open the browser on nothing at all.
+    #
+    # %h stays bare, here and in every binding below. yazi shell-quotes it
+    # itself, so quotes around it end up inside the path and nothing is found.
+    #
+    # --block because the delivery has something to say. On the bridge it is a
+    # line of confirmation; on every other route it is a link, and a served
+    # page that has to stay up. Detached, all of that goes nowhere.
+    parts.append(
+        "[[mgr.prepend_keymap]]\n"
+        f'on = "{key}"\n'
+        """run = 'shell --block -- acstack-md --browser %h'\n"""
+        'desc = "Open in the browser you are sitting at"'
+    )
+    # Flipping the flag changes nothing a reader can see: the pane already
+    # holds the view it drew before the key was pressed. So the binding is two
+    # actions, and peek redraws it.
+    #
+    # --block, though the toggle has nothing to say. Detached, yazi spawns it
+    # and runs peek immediately, and the pane is redrawn while the flag is
+    # still whatever it was - a race the reader settles by pressing the key
+    # twice. Blocking costs a frame and wins it outright.
+    parts.append(
+        "[[mgr.prepend_keymap]]\n"
+        f'on = "{numkey}"\n'
+        "run = [ 'shell --block -- acstack-md --toggle-line-numbers', 'peek --force' ]\n"
+        'desc = "Preview markdown as source with line numbers"'
+    )
+    # `e` edits, everywhere. tuicr's diff and file tree both put the editor on
+    # `e`, so yazi matching it means one key means edit across the workspace.
+    # `o` is left alone: it opens by rule, which for markdown is the reader.
+    #
+    # ${EDITOR:-vi} rather than a fixed editor, the same expansion the opener
+    # in yazi.toml uses, so both paths land in whatever the user actually runs.
+    parts.append(
+        "[[mgr.prepend_keymap]]\n"
+        f'on = "{editkey}"\n'
+        """run = 'shell --block -- ${EDITOR:-vi} %h'\n"""
+        'desc = "Edit in $EDITOR"'
+    )
+    # Taildrop is Tailscale's file send. It is the one route off a headless
+    # machine that needs nothing installed on the machine the user sits at,
+    # and no inbound port there either.
+    #
+    # %h, the hovered file, for the same reason the browser key uses it. %* is
+    # not a keybinding placeholder at all - yazi passes it through untouched,
+    # and tailscale then reports `open %*: no such file or directory`.
+    # Measured on yazi 26.8.15.
+    #
+    # --block because a send reports progress, and a refused one reports why.
+    if dltarget:
+        parts.append(
+            "[[mgr.prepend_keymap]]\n"
+            f'on = "{dlkey}"\n'
+            f"""run = 'shell --block -- tailscale file cp %h {dltarget}:'\n"""
+            f'desc = "Send this file to {dltarget} over Taildrop"'
+        )
+
+# The markers go down even when the binding was conceded, so the shell below
+# can read the region back and see what is missing from it.
+block = begin + "\n" + "\n\n".join(parts) + ("\n" if parts else "") + end
+text = text.rstrip("\n")
+open(path, "w").write((text + "\n\n" if text else "") + block + "\n")
+PY
+  local kmwritten; kmwritten="$(sed -n "/$BEGIN/,/$END/p" "$HOME/.config/yazi/keymap.toml")"
+  case "$kmwritten" in *prepend_keymap*) ;; *)
+    say "yazi: your keymap.toml already sets mgr.prepend_keymap as an inline"
+    say "     array, which these bindings cannot sit beside. Add them there"
+    say "     yourself:  shell --block -- acstack-md --browser %h"
+    say "     and:       [ 'shell --block -- acstack-md --toggle-line-numbers', 'peek --force' ]"
+    say "     and:       shell --block -- \${EDITOR:-vi} %h" ;;
+  esac
+  # The download key is written from the config alone, so it can be wrong in
+  # three ways the config cannot see. Name whichever one holds, rather than
+  # leaving the user to read `status code: 1` out of a yazi popup.
+  local dltarget; dltarget="$(cfg_get yazi.download_target "")"
+  if [ -n "$dltarget" ]; then
+    if ! have tailscale; then
+      say "yazi: download_target names $dltarget, but this machine has no"
+      say "     tailscale. Install it, or clear the key to drop the binding."
+    elif ! tailscale file cp --targets >/dev/null 2>&1; then
+      say "yazi: tailscale refuses file access to this user account. Run once:"
+      say "       sudo tailscale set --operator=\$USER"
+    elif ! tailscale file cp --targets 2>/dev/null \
+         | awk -F'\t' -v t="$dltarget" '$2 == t { f = 1 } END { exit !f }'; then
+      say "yazi: $dltarget is not a Taildrop target of this machine. Taildrop"
+      say "     only sends between devices one Tailscale account owns on one"
+      say "     tailnet. Check both ends with: tailscale file cp --targets"
+    fi
+  fi
+  say "yazi config written"
+}