@alexcrondon/tx 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alexandre Rondon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,123 @@
+# tx
+
+Modular CLI for isolated dev environments using git worktrees. Manage dev servers, SSH tunnels, worktrees, and code editors from a single tool.
+
+## Installation
+
+```bash
+npm install -g @alexcrondon/tx
+```
+
+Or run without installing:
+
+```bash
+npx @alexcrondon/tx
+```
+
+## Requirements
+
+- POSIX shell (`sh`)
+- Git (for worktrees)
+- Optional: ngrok (for `tx tunnel`), tmux (for `tx code -t`)
+
+## Quick Start
+
+```bash
+# Show status of servers, tunnel, db, worktrees
+tx
+
+# Create a worktree and launch your editor
+tx code -b fix/my-bug
+
+# Start dev server
+tx serv start
+```
+
+## Commands
+
+| Command | Default | Description |
+|---------|---------|-------------|
+| `tx` / `tx status` | — | Show status of servers, tunnel, db, worktrees |
+| `tx config` | — | Manage config (user + project) |
+| `tx serv` | list | Dev servers: list, start, stop, restart |
+| `tx tunnel` | status | SSH tunnel (ngrok) |
+| `tx db` | status | Background db process (port-forward, etc.) |
+| `tx wt` | list | Git worktrees: add, remove, clean |
+| `tx code` | start | Launch editor/agent in worktree |
+| `tx nuke` | — | Stop everything, remove all worktrees |
+
+Run `tx help` or `tx help <command>` for details.
+
+## Configuration
+
+Config uses two files; the tool writes each key to the appropriate one:
+
+| Scope | File | Keys |
+|-------|------|------|
+| User | `~/.txrc` | code, tunnel, db, auto_open, auto_tmux |
+| Project | `.txrc` | port, start, url, branch, copy, worktrees_dir, install |
+
+```bash
+tx config                      # Show current config (with scope per key)
+tx config init                 # Interactive setup (writes to appropriate file)
+tx config code cursor          # Set user preference → ~/.txrc
+tx config start "npm start"    # Set project config → .txrc
+tx config start --unset        # Revert key to its default value
+tx config reset               # Delete project .txrc
+tx config reset user           # Delete ~/.txrc
+```
+
+| Key | Scope | Default | Description |
+|-----|-------|---------|-------------|
+| port | project | 9001 | Starting port for servers |
+| start | project | yarn start | Default server command |
+| url | project | http://localhost:{PORT} | URL template |
+| branch | project | (auto-detected) | Default branch for worktrees |
+| copy | project | (empty) | Files to copy into new worktrees |
+| worktrees_dir | project | .worktrees | Worktree directory |
+| install | project | yarn install | Install command for new worktrees |
+| code | user | claude | Command to run for `tx code` |
+| tunnel | user | ngrok tcp 22 | Tunnel command |
+| db | user | (empty) | Background db command |
+| auto_open | user | false | Open browser after serv start |
+| auto_tmux | user | false | Auto-launch tx code in tmux |
+
+## Examples
+
+```bash
+# Status overview (default when no command)
+tx
+
+# Dev servers
+tx serv                     # List running servers
+tx serv start -o -p 3000    # Start on 3000, open browser
+tx serv stop all            # Stop all
+
+# Worktrees
+tx wt add -n hotfix         # Create worktree "hotfix"
+tx wt add -b fix/my-bug     # Create worktree fix-my-bug on branch fix/my-bug
+
+# Code editor (creates worktree by default)
+tx code -b fix/my-bug       # Worktree "fix-my-bug" on branch fix/my-bug
+tx code -r                  # Run in repo root instead
+tx code -t                  # Launch in tmux session
+tx code attach hotfix       # Reattach to tmux
+
+# Tunnel
+tx tunnel start -c          # Start ngrok, caffeinate to prevent sleep
+
+# Nuclear option
+tx nuke                     # Stop all, remove worktrees (with confirmation)
+```
+
+## Shell completions
+
+```bash
+# zsh
+eval "$(tx completions)"
+# or add to ~/.zshrc
+```
+
+## License
+
+[MIT](LICENSE)

package/bin/tx

@@ -0,0 +1,47 @@
+#!/bin/sh
+set -e
+
+# Resolve install directory (follow symlinks for npm global installs)
+SELF="$0"
+while [ -L "$SELF" ]; do
+  DIR=$(cd "$(dirname "$SELF")" && pwd)
+  SELF=$(readlink "$SELF")
+  case "$SELF" in
+    /*) ;;
+    *) SELF="$DIR/$SELF" ;;
+  esac
+done
+TX_ROOT="$(cd "$(dirname "$SELF")/.." && pwd)"
+
+# Source shared utilities (loads defaults, sources .txrc)
+. "$TX_ROOT/lib/common.sh"
+
+# Parse command
+COMMAND="${1:-status}"
+shift 2>/dev/null || true
+
+case "$COMMAND" in
+  --help|-h) COMMAND="help" ;;
+esac
+
+# Check for --help/-h flag on any command (e.g. tx serv --help)
+for _arg in "$@"; do
+  case "$_arg" in
+    --help|-h)
+      . "$TX_ROOT/lib/help.sh"
+      cmd_help "$COMMAND"
+      exit 0
+      ;;
+  esac
+done
+
+# Dispatch to command module
+COMMAND_FILE="$TX_ROOT/lib/${COMMAND}.sh"
+if [ ! -f "$COMMAND_FILE" ]; then
+  echo "tx: unknown command '$COMMAND'"
+  echo "Run 'tx help' for usage."
+  exit 1
+fi
+
+. "$COMMAND_FILE"
+cmd_"$COMMAND" "$@"

package/lib/code.sh

@@ -0,0 +1,216 @@
+# lib/code.sh — tx code command
+
+# Source dependencies (wt.sh already sources serv.sh)
+. "$TX_ROOT/lib/wt.sh"
+
+cmd_code() {
+  local flag_worktree=1
+  local flag_tunnel=0
+  [ "$TX_AUTO_TMUX" = "true" ] && flag_tunnel=1
+  local flag_attach=0
+  local flag_caffeinate=0
+  local flag_install=0
+  local name=""
+  local branch=""
+  local attach_name=""
+  local args=""
+
+  while [ $# -gt 0 ]; do
+    case "$1" in
+      --root|-r)        flag_worktree=0; shift ;;
+      --tunnel|-t)      flag_tunnel=1; shift ;;
+      --caffeinate|-c)  flag_caffeinate=1; shift ;;
+      --install|-i)     flag_install=1; shift ;;
+      --attach|-a)    flag_attach=1; attach_name="${2:-}"; shift; shift 2>/dev/null || true ;;
+      --name=*|-n=*)  name="${1#*=}"; shift ;;
+      --name|-n)      name="$2"; shift 2 ;;
+      --branch=*|-b=*) branch="${1#*=}"; shift ;;
+      --branch|-b)    branch="$2"; shift 2 ;;
+      attach)         flag_attach=1; attach_name="${2:-}"; shift; shift 2>/dev/null || true ;;
+      start)          shift ;;
+      *)              [ -z "$name" ] && name="$1"; args="$args $1"; shift ;;
+    esac
+  done
+
+  if [ "$flag_attach" -eq 1 ] && [ -n "$args" ]; then
+    attach_name=$(echo "$args" | sed 's/^[[:space:]]*//' | cut -d' ' -f1)
+  fi
+
+  if [ "$flag_attach" -eq 1 ]; then
+    _code_attach "$attach_name"
+    return $?
+  fi
+
+  _code_start "$flag_worktree" "$flag_tunnel" "$flag_caffeinate" "$name" "$branch" "$flag_install"
+}
+
+_code_start() {
+  local flag_worktree="$1"
+  local flag_tunnel="$2"
+  local flag_caffeinate="$3"
+  local name="$4"
+  local branch="$5"
+  local flag_install="${6:-0}"
+  local work_dir="$PWD"
+
+  if [ "$flag_worktree" -eq 1 ]; then
+    local wt_args=""
+    [ -n "$name" ] && wt_args="$wt_args --name $name"
+    [ -n "$branch" ] && wt_args="$wt_args --branch $branch"
+    [ "$flag_install" -eq 1 ] && wt_args="$wt_args --install"
+
+    work_dir=$(_wt_add $wt_args | tail -1)
+    if [ $? -ne 0 ] || [ -z "$work_dir" ]; then
+      echo "Failed to create/open worktree."
+      return 1
+    fi
+    cd "$work_dir" || return 1
+  fi
+
+  local session_name
+  local detected_name
+  detected_name=$(tx_detect_worktree_name) || true
+  if [ -n "$name" ]; then
+    session_name="$name"
+  elif [ -n "$detected_name" ]; then
+    session_name="$detected_name"
+  else
+    session_name="tx"
+  fi
+
+  tx_ensure_serv_dir
+
+  # Find previous session to resume when inside a worktree
+  # Skip resume for auto-named worktrees (tx1, tx2, ...) since these are
+  # disposable — a recycled name shouldn't inherit an old session.
+  local resume_id=""
+  local auto_named=0
+  if [ "$flag_worktree" -eq 1 ] && [ -z "$name" ] && [ -z "$branch" ]; then
+    auto_named=1
+  fi
+  if [ -n "$detected_name" ] && [ "$auto_named" -eq 0 ]; then
+    local claude_project_dir
+    claude_project_dir="$HOME/.claude/projects/$(echo "$work_dir" | sed 's/[\/.]/-/g')"
+    # Only resume actual conversation sessions, not file-history-snapshot entries
+    local latest_session
+    latest_session=$(ls -t "${claude_project_dir}"/*.jsonl 2>/dev/null | while IFS= read -r f; do
+      grep -q '"sessionId"' "$f" 2>/dev/null && echo "$f" && break
+    done)
+    if [ -n "$latest_session" ]; then
+      resume_id=$(basename "$latest_session" .jsonl)
+    fi
+  fi
+
+  # Start caffeinate to prevent sleep
+  local caff_pid=""
+  if [ "$flag_caffeinate" -eq 1 ]; then
+    caffeinate -dims &
+    caff_pid=$!
+  fi
+
+  if [ "$flag_tunnel" -eq 1 ]; then
+    local tmux_name
+    tmux_name=$(tx_session_name "$session_name")
+    if tmux has-session -t "$tmux_name" 2>/dev/null; then
+      echo "Tmux session '$session_name' already exists. Attaching..."
+      tmux attach-session -t "$tmux_name"
+    else
+      echo "Launching $TX_CODE_CMD in tmux session '$session_name'..."
+      local tmux_cmd="$TX_CODE_CMD"
+      if [ -n "$resume_id" ]; then
+        tmux_cmd="$TX_CODE_CMD --resume $resume_id || $TX_CODE_CMD"
+      fi
+      echo "  dir: $work_dir"
+      [ -n "$resume_id" ] && echo "  resume: $resume_id" || true
+      tmux new-session -s "$tmux_name" -c "$work_dir" "$tmux_cmd"
+    fi
+  else
+    echo "Launching $TX_CODE_CMD..."
+    echo "  dir: $work_dir"
+    [ -n "$resume_id" ] && echo "  resume: $resume_id" || true
+    cd "$work_dir" || return 1
+    if [ -n "$resume_id" ]; then
+      $TX_CODE_CMD --resume "$resume_id" || $TX_CODE_CMD || true
+    else
+      $TX_CODE_CMD || true
+    fi
+  fi
+
+  # Cleanup after code command exits
+  _serv_stop_dir "$work_dir" 2>/dev/null || true
+  [ -n "$caff_pid" ] && kill "$caff_pid" 2>/dev/null || true
+
+  # Offer to remove worktree if we were in one
+  local wt_name=""
+  if [ "$flag_worktree" -eq 1 ]; then
+    wt_name=$(basename "$work_dir")
+  elif [ -n "$detected_name" ]; then
+    wt_name="$detected_name"
+  fi
+  if [ -n "$wt_name" ] && echo "$wt_name" | grep -q '^tx[0-9]*$'; then
+    printf "Remove worktree '%s'? [y/N] " "$wt_name"
+    read -r answer
+    case "$answer" in
+      y|Y|yes|YES)
+        cd "$(dirname "$work_dir")" 2>/dev/null && cd .. 2>/dev/null || true
+        _wt_remove --name "$wt_name"
+        ;;
+    esac
+  fi
+}
+
+_code_attach() {
+  local session_name="${1:-}"
+
+  # Direct attach if name provided
+  if [ -n "$session_name" ]; then
+    local tmux_name
+    tmux_name=$(tx_session_name "$session_name")
+    if ! tmux has-session -t "$tmux_name" 2>/dev/null; then
+      echo "No tx session '$session_name' found."
+      echo ""
+      _code_attach
+      return $?
+    fi
+    tmux attach-session -t "$tmux_name"
+    return $?
+  fi
+
+  # Interactive picker — list all tx sessions
+  local sessions
+  sessions=$(tx_list_sessions)
+  if [ -z "$sessions" ]; then
+    echo "No active tx sessions."
+    return 1
+  fi
+
+  echo "Active tx sessions:"
+  local i=1
+  echo "$sessions" | while IFS= read -r s; do
+    local display
+    display=$(tx_display_name "$s")
+    local dir
+    dir=$(tmux display-message -t "$s" -p '#{pane_current_path}' 2>/dev/null || echo "?")
+    # Shorten home prefix
+    dir=$(echo "$dir" | sed "s|^$HOME|~|")
+    printf "  %d) %-20s %s\n" "$i" "$display" "$dir"
+    i=$((i + 1))
+  done
+
+  local count
+  count=$(echo "$sessions" | wc -l | tr -d ' ')
+
+  printf "Attach to (1-%s): " "$count"
+  read -r choice
+  case "$choice" in
+    ''|*[!0-9]*) echo "Cancelled."; return 1 ;;
+  esac
+  if [ "$choice" -lt 1 ] || [ "$choice" -gt "$count" ]; then
+    echo "Cancelled."
+    return 1
+  fi
+
+  local picked
+  picked=$(echo "$sessions" | sed -n "${choice}p")
+  tmux attach-session -t "$picked"
+}

package/lib/common.sh

@@ -0,0 +1,266 @@
+# lib/common.sh — shared utilities for tx
+# Sourced by bin/tx on every invocation. Do not execute directly.
+
+# --- Default Configuration ---
+TX_PORT_START="${TX_PORT_START:-9001}"
+TX_START_CMD="${TX_START_CMD:-yarn start}"
+TX_URL_TEMPLATE="${TX_URL_TEMPLATE:-http://localhost:{PORT}}"
+if [ -z "$TX_DEFAULT_BRANCH" ]; then
+  if git rev-parse --verify refs/heads/main >/dev/null 2>&1; then
+    TX_DEFAULT_BRANCH="main"
+  elif git rev-parse --verify refs/heads/master >/dev/null 2>&1; then
+    TX_DEFAULT_BRANCH="master"
+  else
+    TX_DEFAULT_BRANCH="main"
+  fi
+fi
+TX_COPY="${TX_COPY:-}"
+TX_WORKTREES_DIR="${TX_WORKTREES_DIR:-.worktrees}"
+TX_CODE_CMD="${TX_CODE_CMD:-claude}"
+TX_TUNNEL_CMD="${TX_TUNNEL_CMD:-ngrok tcp 22}"
+TX_DB_CMD="${TX_DB_CMD:-}"
+TX_AUTO_OPEN="${TX_AUTO_OPEN:-false}"
+TX_AUTO_TMUX="${TX_AUTO_TMUX:-false}"
+TX_INSTALL_CMD="${TX_INSTALL_CMD:-yarn install}"
+
+# Config scopes: user (~/.txrc) vs project (.txrc)
+TX_CONFIG_USER_KEYS="code tunnel auto_open db auto_tmux"
+TX_CONFIG_PROJECT_KEYS="port start url branch copy worktrees_dir install"
+TX_CONFIG_KEYS="port start url branch copy worktrees_dir install code tunnel db auto_open auto_tmux"
+
+# --- Config key-to-variable mapping ---
+tx_config_var() {
+  case "$1" in
+    port)          echo "TX_PORT_START" ;;
+    start)         echo "TX_START_CMD" ;;
+    url)           echo "TX_URL_TEMPLATE" ;;
+    branch)        echo "TX_DEFAULT_BRANCH" ;;
+    copy)          echo "TX_COPY" ;;
+    worktrees_dir) echo "TX_WORKTREES_DIR" ;;
+    code)          echo "TX_CODE_CMD" ;;
+    tunnel)        echo "TX_TUNNEL_CMD" ;;
+    db)            echo "TX_DB_CMD" ;;
+    auto_open)     echo "TX_AUTO_OPEN" ;;
+    install)       echo "TX_INSTALL_CMD" ;;
+    auto_tmux)     echo "TX_AUTO_TMUX" ;;
+    *)             echo "" ;;
+  esac
+}
+
+# Return the hardcoded default value for a config key
+tx_config_default() {
+  case "$1" in
+    port)          echo "9001" ;;
+    start)         echo "yarn start" ;;
+    url)           echo "http://localhost:{PORT}" ;;
+    branch)        echo "" ;;
+    copy)          echo "" ;;
+    worktrees_dir) echo ".worktrees" ;;
+    code)          echo "claude" ;;
+    tunnel)        echo "ngrok tcp 22" ;;
+    db)            echo "" ;;
+    auto_open)     echo "false" ;;
+    install)       echo "yarn install" ;;
+    auto_tmux)     echo "false" ;;
+  esac
+}
+
+# Return "user" or "project" for a config key
+tx_config_scope() {
+  case " $TX_CONFIG_USER_KEYS " in
+    *" $1 "*) echo "user" ;;
+    *) echo "project" ;;
+  esac
+}
+
+# Path to config file for a given scope
+tx_config_file() {
+  case "$1" in
+    user)    echo "${HOME}/.txrc" ;;
+    project) echo "$(_tx_project_root)/.txrc" ;;
+    *)       echo "" ;;
+  esac
+}
+
+# --- Load config (user first, then project; each scope only from its file) ---
+_tx_config_apply_file() {
+  local file="$1"
+  shift
+  [ ! -f "$file" ] && return
+  for key in "$@"; do
+    local var
+    var=$(tx_config_var "$key")
+    [ -z "$var" ] && continue
+    local line
+    line=$(grep "^${var}=" "$file" 2>/dev/null | head -1)
+    [ -n "$line" ] && eval "$line"
+  done
+  return 0
+}
+
+# Resolve main repo root (works from worktrees too).
+# git --git-common-dir always points to the main .git directory.
+_tx_project_root() {
+  local common_dir
+  common_dir=$(cd "$(git rev-parse --git-common-dir 2>/dev/null)" && pwd) || return 1
+  dirname "$common_dir"
+}
+
+_tx_config_apply_file "${HOME}/.txrc" $TX_CONFIG_USER_KEYS
+_tx_config_apply_file "$(_tx_project_root)/.txrc" $TX_CONFIG_PROJECT_KEYS
+
+# --- Shared Helpers ---
+
+# Hash a directory path to a safe filename (MD5)
+tx_hash_dir() {
+  echo -n "$1" | md5 -q 2>/dev/null || echo -n "$1" | md5sum | cut -d' ' -f1
+}
+
+# Ensure /tmp/tx-serv/ directory exists
+tx_ensure_serv_dir() {
+  mkdir -p /tmp/tx-serv
+}
+
+# Find next available port starting from TX_PORT_START
+tx_find_port() {
+  local port="${1:-$TX_PORT_START}"
+  while lsof -ti :"$port" > /dev/null 2>&1; do
+    port=$((port + 1))
+  done
+  echo "$port"
+}
+
+# Build URL from template and port
+tx_build_url() {
+  local port="$1"
+  echo "$TX_URL_TEMPLATE" | sed "s/{PORT}/$port/g"
+}
+
+# Open URL in browser (macOS)
+# Tries to open in a Chrome window on the same screen as the terminal.
+# Falls back to regular `open` if Chrome isn't running or no window is found.
+tx_open_browser() {
+  local url="$1"
+
+  osascript -l JavaScript -e '
+    ObjC.import("AppKit");
+    function run(argv) {
+      var url = argv[0];
+      var app = Application.currentApplication();
+      app.includeStandardAdditions = true;
+
+      // Get terminal window position (screen coords: origin top-left of primary)
+      var termX, termY;
+      try {
+        var se = Application("System Events");
+        var frontProc = se.processes.whose({ frontmost: true })[0];
+        var pos = frontProc.windows[0].position();
+        termX = pos[0];
+        termY = pos[1];
+      } catch (e) {
+        app.openLocation(url);
+        return;
+      }
+
+      // Check if Chrome is running with windows
+      var chrome;
+      try {
+        chrome = Application("Google Chrome");
+        if (!chrome.running() || chrome.windows.length === 0) {
+          app.openLocation(url);
+          return;
+        }
+      } catch (e) {
+        app.openLocation(url);
+        return;
+      }
+
+      // Get screen frames using NSScreen (Cocoa coords: origin bottom-left)
+      // and convert to screen coords (origin top-left) to match window positions
+      var screens = $.NSScreen.screens;
+      var primaryH = screens.objectAtIndex(0).frame.size.height;
+      var screenRects = [];
+      for (var i = 0; i < screens.count; i++) {
+        var f = screens.objectAtIndex(i).frame;
+        screenRects.push({
+          x: f.origin.x,
+          y: primaryH - f.origin.y - f.size.height,
+          w: f.size.width,
+          h: f.size.height
+        });
+      }
+
+      // Find which screen contains the terminal
+      var termScreen = screenRects[0];
+      for (var i = 0; i < screenRects.length; i++) {
+        var sr = screenRects[i];
+        if (termX >= sr.x && termX < sr.x + sr.w &&
+            termY >= sr.y && termY < sr.y + sr.h) {
+          termScreen = sr;
+          break;
+        }
+      }
+
+      // Find first Chrome window on the same screen as the terminal
+      var bestIdx = 0;
+      for (var i = 0; i < chrome.windows.length; i++) {
+        try {
+          var b = chrome.windows[i].bounds();
+          if (b.x >= termScreen.x && b.x < termScreen.x + termScreen.w &&
+              b.y >= termScreen.y && b.y < termScreen.y + termScreen.h) {
+            bestIdx = i;
+            break;
+          }
+        } catch (e) {}
+      }
+
+      // Open new tab in the matched window
+      chrome.windows[bestIdx].tabs.push(chrome.Tab({ url: url }));
+      chrome.activate();
+    }
+  ' "$url" 2>/dev/null || open "$url" 2>/dev/null
+}
+
+# Check if a process is alive by PID
+tx_is_alive() {
+  kill -0 "$1" 2>/dev/null
+}
+
+# Detect if current directory is inside a tx worktree.
+# Prints the worktree name if yes, empty string if no.
+# Works by checking if any parent directory's name matches TX_WORKTREES_DIR.
+tx_detect_worktree_name() {
+  local wt_basename
+  wt_basename=$(basename "$TX_WORKTREES_DIR")
+  local dir="$PWD"
+  while [ "$dir" != "/" ]; do
+    local parent
+    parent=$(dirname "$dir")
+    if [ "$(basename "$parent")" = "$wt_basename" ]; then
+      basename "$dir"
+      return 0
+    fi
+    dir="$parent"
+  done
+  echo ""
+  return 1
+}
+
+# --- Tmux session helpers ---
+# All tx-created tmux sessions use a "tx-" prefix internally.
+# These helpers translate between internal names and user-facing display names.
+
+# Convert display name → internal tmux session name
+tx_session_name() {
+  echo "tx-$1"
+}
+
+# Convert internal tmux session name → display name (strip tx- prefix)
+tx_display_name() {
+  echo "$1" | sed 's/^tx-//'
+}
+
+# List all tx-managed tmux sessions (outputs internal session names, one per line)
+tx_list_sessions() {
+  tmux list-sessions -F '#{session_name}' 2>/dev/null | grep '^tx-' || true
+}