brew install pngpaste glow lazygit

chmod +x ~/.config/cx/mac_bridge.py
ln -sf ~/.config/cx/mac_bridge.py ~/.local/bin/mac_bridge.py
pkill -f mac_bridge.py 2>/dev/null || true
nohup python3 ~/.config/cx/mac_bridge.py >/dev/null 2>&1 &

mkdir -p ~/.config/cx
cat << 'EOF' > ~/.config/cx/config
# ==============================================================================
# cx 远程开发环境配置 (~/.config/cx/config)
# 以后换服务器或换项目，直接修改这里的参数即可！
# ==============================================================================

# SSH 目标主机别名（对应 ~/.ssh/config 里的 Host）
CX_HOST="<SERVER_HOST>"

# 远程默认主项目名称
CX_PROJECT="<PROJECT_NAME>"

# 远程工作区主目录
CX_REMOTE_WORKSPACES="/data/azrael/workspaces"

# 远程环境入口脚本（若不存在自动降级）
CX_REMOTE_BASH="~/.local/bin/azbash"
EOF

cat << 'EOF' > ~/.config/cx/cx.zsh
# ==============================================================================
# cx 远程终端与开发工具包 (~/.config/cx/cx.zsh)
# 集中管理 cx 函数、快捷别名及本地跨机器桥接守护服务
# ==============================================================================

# 1. 自动守护本地跨机器桥接服务 (监听 127.0.0.1:19222)
_cx_bridge_script="$HOME/.config/cx/mac_bridge.py"
pgrep -f "mac_bridge.py" >/dev/null || ([ -f "$_cx_bridge_script" ] && nohup python3 "$_cx_bridge_script" >/dev/null 2>&1 & disown)

# 2. 本地常用快捷别名与函数
alias lg='lazygit'

md() {
  if [ -z "$1" ]; then
    glow
  else
    glow -p "$@"
  fi
}
alias gw='glow'

# 3. cx 远程开发极速直达函数 (读取同目录 config 与 mac_bridge.py)
unalias cx 2>/dev/null || true
function cx() {
  local cfg_dir="$HOME/.config/cx"
  local cfg_file="$cfg_dir/config"
  local bridge_script="$cfg_dir/mac_bridge.py"

  # 自动保证桥接运行
  pgrep -f "mac_bridge.py" >/dev/null || ([ -f "$bridge_script" ] && nohup python3 "$bridge_script" >/dev/null 2>&1 & disown)

  local default_host="<SERVER_HOST>"
  local default_project="<PROJECT_NAME>"
  local default_workspaces="$HOME/workspaces"
  local default_bash=""

  [ -f "$cfg_file" ] && source "$cfg_file"

  local host="${CX_HOST:-$default_host}"
  local project="${CX_PROJECT:-$default_project}"
  local remote_workspaces="${CX_REMOTE_WORKSPACES:-$default_workspaces}"
  local remote_bash="${CX_REMOTE_BASH:-$default_bash}"

  local arg="${1:-$project}"

  # 帮助命令支持: -h, --help, help, h, --hlep
  if [[ "$arg" == "-h" || "$arg" == "--help" || "$arg" == "help" || "$arg" == "h" || "$arg" == "--hlep" ]]; then
    cat << EOF
cx - 远程开发环境极速直达工具 (目标服务器: $host)

用法:
  cx                    连入/恢复默认主会话 ($project)
  cx new                自动新建序号递增的全新独立会话 (如 ${project}_1)
  cx <序号>             连入/新建对应序号会话 (例: cx 1 -> ${project}_1)
  cx <名字>             连入/新建指定名称会话 (例: cx test)
  cx ls                 查看当前远程所有后台保活会话 (别名: list)
  cx k                  弹出交互式菜单挑选关闭会话 (别名: kill)
  cx k <名字>           直接关闭指定后台会话
  cx ka                 一键关闭全部后台保活会话 (别名: kill-all)
  cx bridge             查看本地跨机器传输桥接服务运行状态
  cx bridge restart     一键重启本地传输桥接服务 (监听 127.0.0.1:19222)
  cx raw                普通 SSH 直连服务器 (不接管 tmux，别名: ssh)
  cx config             查看/配置目标服务器参数 ($cfg_file)
  cx -h, h, help        显示本帮助说明 (别名: --help)

常用场景:
  • 日常开发/上班:       直接敲 cx
  • 另起独立新任务:     敲 cx new 或 cx 1
  • 查后台正在跑什么:   敲 cx ls
  • 关掉用完的会话:     敲 cx k
  • 本地桥接异常/卡死: 敲 cx bridge restart
  • 更换目标服务器:     敲 cx config 修改配置
EOF
    return 0
  fi

  # 桥接服务生命周期管理
  if [[ "$arg" == "bridge" || "$arg" == "br" ]]; then
    local sub="${2:-status}"
    if [[ "$sub" == "restart" || "$sub" == "re" ]]; then
      echo "⚡ 正在重启本地传输桥接服务..."
      pkill -f "mac_bridge.py" 2>/dev/null || true
      sleep 0.5
      if [ -f "$bridge_script" ]; then
        nohup python3 "$bridge_script" >/dev/null 2>&1 & disown
        sleep 0.5
      fi
    elif [[ "$sub" == "stop" ]]; then
      pkill -f "mac_bridge.py" 2>/dev/null && echo "✔ 本地传输桥接服务已停止" || echo "⚠️ 桥接服务未在运行"
      return 0
    elif [[ "$sub" == "start" ]]; then
      if pgrep -f "mac_bridge.py" >/dev/null; then
        echo "✔ 本地传输桥接服务已在运行中"
      else
        [ -f "$bridge_script" ] && nohup python3 "$bridge_script" >/dev/null 2>&1 & disown
        sleep 0.5
        echo "✔ 本地传输桥接服务已启动"
      fi
      return 0
    fi

    # 打印状态
    local pids=$(pgrep -f "mac_bridge.py" | tr '\n' ' ')
    echo "📄 桥接服务脚本: $bridge_script"
    if [ -n "$pids" ]; then
      local probe=$(curl -s --max-time 1 http://127.0.0.1:19222/ping 2>/dev/null)
      if [ "$probe" = "pong" ]; then
        echo "✔ 运行状态: 正在运行 (PID: $pids, 端口 19222 响应: $probe)"
      else
        echo "⚠️ 运行状态: 进程存在 (PID: $pids) 但端口 19222 未响应，可执行 cx bridge restart 重试"
      fi
    else
      echo "✖ 运行状态: 未运行 (可执行 cx bridge restart 启动)"
    fi
    return 0
  fi

  if [[ "$arg" == "config" || "$arg" == "conf" ]]; then
    echo "📄 当前 cx 配置文件路径: $cfg_file"
    echo "----------------------------------------"
    if [ -f "$cfg_file" ]; then
      cat "$cfg_file"
    else
      echo "⚠️ 配置文件尚未创建，当前使用内置默认值: host=$host, project=$project"
    fi
    echo "----------------------------------------"
    echo "💡 提示：使用编辑器直接修改该文件即可随时切换目标服务器/项目！"
    return 0
  fi

  if [[ "$arg" == "ls" || "$arg" == "list" ]]; then
    ssh -q -o ClearAllForwardings=yes -o RemoteCommand=none "$host" "bash -c 'echo \"=== 当前后台保活会话 ===\"; tmux ls 2>/dev/null || echo \"暂无运行中的会话\"; echo \"\"; echo \"💡 连接提示: cx 默认主会话 | cx new 开新会话 | cx 1/2/3 进对应序号 | cx <名字> 进指定会话 | cx -h 查看完整帮助\"'"
  elif [[ "$arg" == "kill" || "$arg" == "k" ]]; then
    local target="$2"
    if [ -n "$target" ]; then
      ssh -q -o ClearAllForwardings=yes -o RemoteCommand=none "$host" "bash -c 'tmux kill-session -t $target 2>/dev/null && echo \"✔ 已关闭会话: $target\" || echo \"✖ 未找到会话: $target\"'"
    else
      ssh -q -o ClearAllForwardings=yes -o RemoteCommand=none -t "$host" "bash -i -c 'tkill'"
    fi
  elif [[ "$arg" == "kill-all" || "$arg" == "ka" ]]; then
    ssh -q -o ClearAllForwardings=yes -o RemoteCommand=none "$host" "bash -c 'tmux kill-server 2>/dev/null; echo \"✔ 已关闭全部后台保活会话\"'"
  elif [[ "$arg" == "raw" || "$arg" == "ssh" ]]; then
    ssh "$host"
  elif [[ "$arg" == "new" || "$arg" == "add" ]]; then
    ssh -o LogLevel=ERROR -o RemoteCommand=none -t "$host" "bash -c '
      i=1
      while tmux has-session -t \"${project}_\$i\" 2>/dev/null; do
        i=\$((i+1))
      done
      sess=\"${project}_\$i\"
      echo \"⚡ 创建全新独立会话: \$sess\"
      cd \"$remote_workspaces/$project\" 2>/dev/null || cd ~
      exec tmux new-session -s \"\$sess\"
    '"
  else
    local sess="$arg"
    if [[ "$arg" =~ ^[0-9]+$ ]]; then
      sess="${project}_${arg}"
    fi
    ssh -o LogLevel=ERROR -o RemoteCommand=none -t "$host" "bash -c '
      if tmux has-session -t \"$sess\" 2>/dev/null; then
        exec tmux attach -t \"$sess\"
      fi
      proj_dir=\"$remote_workspaces/$arg\"
      [ ! -d \"\$proj_dir\" ] && proj_dir=\"$remote_workspaces/$project\"
      [ ! -d \"\$proj_dir\" ] && proj_dir=\"\$HOME\"
      cd \"\$proj_dir\" && exec tmux new-session -s \"$sess\"
    '"
  fi
}
EOF

# 加载 cx 远程终端与开发工具包
[ -f "$HOME/.config/cx/cx.zsh" ] && source "$HOME/.config/cx/cx.zsh"

mkdir -p ~/.local/bin ~/.local/share /tmp/tmux_install
cd /tmp/tmux_install
curl -sL https://github.com/nelsonenzo/tmux-appimage/releases/download/3.5a/tmux.appimage -o tmux.appimage
chmod +x tmux.appimage
./tmux.appimage --appimage-extract
rm -rf ~/.local/share/tmux-3.5a
mv squashfs-root ~/.local/share/tmux-3.5a
rm -rf /tmp/tmux_install

# 编写 wrapper 脚本
cat << 'BASH' > ~/.local/bin/tmux
#!/bin/bash
DIR="$HOME/.local/share/tmux-3.5a"
export TERMINFO="$DIR/usr/share/terminfo"
export LD_LIBRARY_PATH="$DIR/usr/lib:$LD_LIBRARY_PATH"
exec "$DIR/usr/bin/tmux" "$@"
BASH
chmod +x ~/.local/bin/tmux

# 建立 ImageMagick 7 兼容软链
which convert >/dev/null && ln -sf $(which convert) ~/.local/bin/magick

cat << 'BASH' > ~/.local/bin/pi
#!/bin/bash
# ==============================================================================
# pi (Paste It) / pf (Paste File)
# 智能粘贴：支持 Mac 截图图片、Mac Finder 复制的文件 (Cmd+C)、Mac 剪贴板文件路径
# ==============================================================================

STATUS_JSON=$(curl -s --max-time 3 http://127.0.0.1:19222/clipboard-status 2>/dev/null)

if [ -z "$STATUS_JSON" ]; then
    echo -e "\033[31m✘ [Mac ➔ Server]\033[0m 无法连接 Mac 本地桥接服务 (HTTP 19222)"
    exit 1
fi

TYPE=$(echo "$STATUS_JSON" | python3 -c "import sys, json; data=json.load(sys.stdin); print(data.get('type', 'empty'))" 2>/dev/null)

if [ "$TYPE" = "files" ]; then
    echo "$STATUS_JSON" | python3 -c "
import sys, json, urllib.parse, subprocess, os

data = json.load(sys.stdin)
files = data.get('files', [])
custom_name = sys.argv[1] if len(sys.argv) > 1 else ''

for i, f in enumerate(files):
    remote_path = f['path']
    orig_name = f['name']
    target_name = custom_name if (custom_name and len(files) == 1) else orig_name
    
    encoded = urllib.parse.quote(remote_path)
    url = f'http://127.0.0.1:19222/fetch-file?path={encoded}'
    
    res = subprocess.run(['curl', '-s', '-o', target_name, '-w', '%{http_code}', url], capture_output=True, text=True)
    http_code = res.stdout.strip()
    
    if http_code == '200' and os.path.exists(target_name):
        size = os.path.getsize(target_name)
        if size < 1024:
            size_str = f'{size} B'
        elif size < 1024 * 1024:
            size_str = f'{size / 1024:.1f} KB'
        else:
            size_str = f'{size / (1024 * 1024):.1f} MB'
        print(f'\033[32m✔ [Mac ➔ Server]\033[0m 成功从 Mac 剪贴板粘贴文件: \033[1m{target_name}\033[0m ({size_str})')
    else:
        print(f'\033[31m✘ [Mac ➔ Server]\033[0m 拉取文件失败: {orig_name} (HTTP {http_code})')
" "$1"

elif [ "$TYPE" = "image" ]; then
    TARGET="$1"
    [ -z "$TARGET" ] && TARGET="clip_$(date +%Y%m%d_%H%M%S).png"
    
    HTTP_CODE=$(curl -s -o "$TARGET" -w "%{http_code}" http://127.0.0.1:19222/clipboard-image 2>/dev/null || echo "000")
    if [ "$HTTP_CODE" = "200" ]; then
        SIZE=$(ls -lh "$TARGET" | awk '{print $5}')
        echo -e "\033[32m✔ [Mac ➔ Server]\033[0m 成功从剪贴板粘贴图片: \033[1m$TARGET\033[0m ($SIZE)"
    else
        rm -f "$TARGET"
        echo -e "\033[31m✘ [Mac ➔ Server]\033[0m 粘贴图片失败 (HTTP $HTTP_CODE)"
        exit 1
    fi

elif [ "$TYPE" = "text" ]; then
    PREVIEW=$(echo "$STATUS_JSON" | python3 -c "import sys, json; print(json.load(sys.stdin).get('preview', ''))")
    echo -e "\033[33mℹ [Mac ➔ Server]\033[0m Mac 剪贴板里是文本内容，非文件或图片:"
    echo -e "  \033[90m\"$PREVIEW\"\033[0m"
    exit 0

else
    echo -e "\033[33m⚠ [Mac ➔ Server]\033[0m Mac 剪贴板里当前没有文件或图片数据"
    exit 1
fi
BASH
chmod +x ~/.local/bin/pi
ln -sf ~/.local/bin/pi ~/.local/bin/pf

cat << 'BASH' > ~/.local/bin/up
#!/bin/bash
if [ -z "$1" ]; then
    echo -e "使用方法: \033[1mup [直接把 Mac 上的图片或文件拖到这里] 回车\033[0m"
    exit 1
fi

for FILEPATH in "$@"; do
    FILEPATH=$(echo "$FILEPATH" | sed -e "s/^['\"]//" -e "s/['\"]$//")
    FILENAME=$(basename "$FILEPATH")
    
    echo -e "正在从 Mac 拉取文件: \033[34m$FILENAME\033[0m ..."
    ENCODED_PATH=$(python3 -c "import urllib.parse, sys; print(urllib.parse.quote(sys.argv[1]))" "$FILEPATH")
    
    HTTP_CODE=$(curl -s -o "$FILENAME" -w "%{http_code}" "http://127.0.0.1:19222/fetch-file?path=$ENCODED_PATH" 2>/dev/null)
    
    if [ "$HTTP_CODE" = "200" ]; then
        SIZE=$(ls -lh "$FILENAME" | awk '{print $5}')
        echo -e "\033[32m✔ [Mac ➔ Server]\033[0m 上传成功: \033[1m$FILENAME\033[0m ($SIZE)"
    elif [ "$HTTP_CODE" = "404" ]; then
        rm -f "$FILENAME"
        echo -e "\033[31m✘ [Mac ➔ Server]\033[0m Mac 本地找不到该文件: $FILEPATH"
    elif [ "$HTTP_CODE" = "403" ]; then
        rm -f "$FILENAME"
        echo -e "\033[31m✘ [Mac ➔ Server]\033[0m Mac 系统权限拒绝读取该文件: $FILEPATH"
    else
        rm -f "$FILENAME"
        echo -e "\033[31m✘ [Mac ➔ Server]\033[0m 拉取失败 (HTTP $HTTP_CODE)"
    fi
done
BASH
chmod +x ~/.local/bin/up

cat << 'BASH' > ~/.local/bin/cb
#!/bin/bash
if [ -n "$1" ]; then
    echo -n "$1" | curl -s -X POST --data-binary @- http://127.0.0.1:19222/set-clipboard
elif [ ! -t 0 ]; then
    curl -s -X POST --data-binary @- http://127.0.0.1:19222/set-clipboard
else
    echo "使用方法: echo '文本' | cb 或 cb '文本'"
fi
BASH
chmod +x ~/.local/bin/cb
ln -sf ~/.local/bin/cb ~/.local/bin/wl-copy
ln -sf ~/.local/bin/cb ~/.local/bin/xclip

cat << 'PY' > ~/.local/bin/wto
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
wto (WorkTree Open)
跨 Git Worktree 文件快速定位，fzf 上下键选择，直通 Yazi 或极速本地 HTTP 浏览器预览
"""

import os
import sys
import shutil
import socket
import urllib.parse
import json
import subprocess
import datetime
from pathlib import Path

BOLD = "\033[1m"
GREEN = "\033[38;2;40;167;69m"
CYAN = "\033[38;2;23;162;184m"
YELLOW = "\033[38;2;255;193;7m"
ORANGE = "\033[38;2;253;126;20m"
RED = "\033[38;2;220;53;69m"
GRAY = "\033[38;2;108;117;125m"
RESET = "\033[0m"

def get_server_ip():
    conn = os.environ.get("SSH_CONNECTION", "")
    if conn:
        parts = conn.split()
        if len(parts) >= 3:
            return parts[2]
    res = subprocess.run(["hostname", "-I"], capture_output=True, text=True)
    if res.stdout.strip():
        return res.stdout.strip().split()[0]
    return "127.0.0.1"

def get_git_repo_root():
    res = subprocess.run(["git", "rev-parse", "--show-toplevel"], capture_output=True, text=True)
    if res.returncode == 0 and res.stdout.strip():
        return Path(res.stdout.strip())
    return None

def get_all_worktrees(repo_root):
    res = subprocess.run(["git", "-C", str(repo_root), "worktree", "list", "--porcelain"], capture_output=True, text=True)
    if res.returncode != 0:
        return []
    
    worktrees = []
    current = {}
    for line in res.stdout.splitlines() +[""]:
        if not line:
            if current and "path" in current:
                worktrees.append(current)
            current = {}
        elif line.startswith("worktree "):
            current["path"] = Path(line[9:]).resolve()
            current["name"] = current["path"].name
        elif line.startswith("branch "):
            current["branch"] = line[7:].removeprefix("refs/heads/")
        elif line == "detached":
            current["branch"] = "(detached)"
    return worktrees

def get_file_status(wt_path, rel_path):
    abs_path = wt_path / rel_path
    if not abs_path.exists():
        return None
    
    st_res = subprocess.run(["git", "-C", str(wt_path), "status", "-s", "--", str(rel_path)], capture_output=True, text=True)
    st = st_res.stdout.strip()
    
    mtime = os.path.getmtime(abs_path)
    dt = datetime.datetime.fromtimestamp(mtime)
    time_str = dt.strftime("%m-%d %H:%M")
    
    if st.startswith("??"):
        status_label = "[?? 新增]"
        status_color = GREEN
    elif "M" in st:
        status_label = "[M  修改]"
        status_color = YELLOW
    elif "D" in st:
        status_label = "[D  删除]"
        status_color = RED
    elif st:
        status_label = f"[{st[:7]:<7}]"
        status_color = CYAN
    else:
        status_label = "[clean  ]"
        status_color = GRAY
        
    return {
        "status_label": status_label,
        "status_color": status_color,
        "time_str": time_str,
        "abs_path": str(abs_path),
        "rel_path": str(rel_path),
        "mtime": mtime
    }

def find_target_in_worktrees(worktrees, target_input):
    if not target_input or not target_input.strip():
        return []

    # 1. 若传入已存在的确切物理文件（如 Yazi 传参），直接精准返回单项，绝不误弹列表
    target_p = Path(target_input).resolve()
    if target_p.is_file():
        info = get_file_status(target_p.parent, target_p.name)
        if info:
            for wt in worktrees:
                try:
                    rel = str(target_p.relative_to(wt["path"]))
                    info["wt"] = wt
                    info["rel_path"] = rel
                    info["score"] = 200
                    return [info]
                except ValueError:
                    pass
            info["wt"] = {"name": target_p.parent.name, "path": target_p.parent}
            info["score"] = 200
            return [info]

    target_clean = target_input.strip("/").strip()
    target_lower = target_clean.lower()
    target_name = Path(target_clean).name.lower()
    matches = []

    for wt in worktrees:
        wt_path = wt["path"]
        
        # 1. 相对路径完全匹配
        exact = wt_path / target_clean
        if exact.is_file():
            info = get_file_status(wt_path, target_clean)
            if info:
                info["wt"] = wt
                info["score"] = 100
                matches.append(info)
            continue

        # 2. 从 git ls-files 或文件树抓取文件列表
        files = []
        try:
            res = subprocess.run(
                ["git", "-C", str(wt_path), "ls-files", "-c", "-o", "--exclude-standard"],
                capture_output=True,
                text=True
            )
            if res.returncode == 0 and res.stdout.strip():
                files = [line.strip() for line in res.stdout.splitlines() if line.strip()]
        except Exception:
            pass

        if not files:
            for root, dirs, fnames in os.walk(wt_path):
                dirs[:] = [d for d in dirs if d not in (".git", ".claude", "node_modules", ".venv", "__pycache__", ".runtime")]
                root_p = Path(root)
                for fn in fnames:
                    try:
                        rel = str((root_p / fn).relative_to(wt_path))
                        files.append(rel)
                    except Exception:
                        pass

        # 3. 智能多维度打分模糊匹配
        for rel in files:
            p = Path(rel)
            full_name = p.name.lower()
            stem_name = p.stem.lower()
            rel_lower = rel.lower()

            score = 0
            if rel_lower == target_lower or rel_lower.endswith("/" + target_lower):
                score = 100
            elif full_name == target_name:
                score = 90
            elif stem_name == target_name:
                score = 85  # 省略后缀精准命中（如输入 口播与动作对齐方案 -> 命中 口播与动作对齐方案.md）
            elif full_name.startswith(target_name) or stem_name.startswith(target_name):
                score = 70
            elif target_name in stem_name or target_name in full_name:
                score = 60  # 文件名部分包含关键词
            elif target_lower in rel_lower:
                score = 40  # 路径包含关键词

            if score > 0:
                info = get_file_status(wt_path, rel)
                if info:
                    info["wt"] = wt
                    info["score"] = score
                    matches.append(info)

    # 去重并按匹配得分排序
    seen = set()
    unique = []
    matches.sort(key=lambda m: (-m.get("score", 0), len(m["rel_path"])))
    for m in matches:
        if m["abs_path"] not in seen:
            seen.add(m["abs_path"])
            unique.append(m)
    return unique

def list_all_dirty_files(worktrees):
    all_files = []
    for wt in worktrees:
        wt_path = wt["path"]
        res = subprocess.run(["git", "-C", str(wt_path), "status", "-s"], capture_output=True, text=True)
        for line in res.stdout.splitlines():
            line = line.strip()
            if not line:
                continue
            parts = line.split(maxsplit=1)
            if len(parts) == 2:
                rel = parts[1]
                info = get_file_status(wt_path, rel)
                if info:
                    info["wt"] = wt
                    all_files.append(info)
    all_files.sort(key=lambda x: x["mtime"], reverse=True)
    return all_files

def select_with_fzf(hits, prompt_title="⚡ 选择 Worktree 文件"):
    if not hits:
        return None
    if len(hits) == 1:
        return hits[0]
    if not sys.stdin.isatty():
        return hits[0]
    
    lines = []
    for h in hits:
        wt_name = h["wt"]["name"]
        st_color = h["status_color"]
        st_label = h["status_label"]
        time_str = h["time_str"]
        rel = h["rel_path"]
        abs_path = h["abs_path"]
        
        display = f"🌿 {BOLD}{CYAN}{wt_name:<26}{RESET} {st_color}{st_label}{RESET}  {GRAY}{time_str}{RESET}  {rel}"
        lines.append(f"{display}\t{abs_path}")
    
    input_text = "\n".join(lines) + "\n"
    
    fzf_cmd = [
        "fzf",
        f"--prompt={prompt_title}: ",
        "--height=40%",
        "--layout=reverse",
        "--border",
        "--ansi",
        "--delimiter=\t",
        "--with-nth=1",
        "--select-1",
        "--exit-0"
    ]
    
    try:
        p = subprocess.Popen(fzf_cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
        out, _ = p.communicate(input=input_text)
        if p.returncode != 0 or not out.strip():
            return None
        selected_line = out.strip()
        parts = selected_line.split("\t")
        target_path = parts[-1]
        matching_hit = next((h for h in hits if h["abs_path"] == target_path), None)
        return matching_hit or {"abs_path": target_path}
    except Exception as e:
        print(f"fzf 启动失败: {e}", file=sys.stderr)
        return None

def print_help():
    print(f"""
{BOLD}{GREEN}wto (Worktree Open){RESET} - 跨 Worktree 智能文件检索与秒开工具

{BOLD}用法:{RESET}
  {CYAN}wto{RESET}                      扫描所有活跃 Worktree 中未提交的改动，上下键挑选后在 Yazi 打开
  {CYAN}wto <文件名或相对路径>{RESET}    跨所有活跃 Worktree 智能模糊匹配该文件，回车直通 Yazi
  {CYAN}wto -h <文件名>{RESET}          原地启动轻量 HTTP 服务，渲染 Markdown ({BOLD}含 Mermaid 流程图{RESET}) 或 HTML，
                           并自动唤醒 Mac 浏览器打开；{GREEN}生成的内网链接可直接复制分享给同事！{RESET}
  {CYAN}wto -h{RESET}                   扫描所有改动文件，上下键挑选后原地起 HTTP 服务在浏览器打开
  {CYAN}wto --help{RESET}               显示本使用说明

{BOLD}快捷参数:{RESET}
  {YELLOW}-h, --html, --browser, -w{RESET}  启用浏览器预览模式（原地起 HTTP 服务 + 浏览器打开）
  {YELLOW}--help{RESET}                     查看帮助信息
""")

def start_browser_preview(file_path, wt_info=None):
    file_p = Path(file_path).resolve()
    if not file_p.exists():
        print(f"{RED}文件不存在: {file_path}{RESET}")
        return

    target_dir = file_p.parent
    file_name = file_p.name

    # 寻找空闲端口 (3480..3500, 18080..18100)
    port = 0
    for p in list(range(3480, 3500)) + list(range(18080, 18100)):
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
            try:
                s.bind(('0.0.0.0', p))
                port = p
                break
            except OSError:
                continue
    if not port:
        port = 18080

    server_ip = get_server_ip()

    class RawFileHandler(http.server.SimpleHTTPRequestHandler):
        def __init__(self, *args, **kwargs):
            super().__init__(*args, directory=str(target_dir), **kwargs)

        def guess_type(self, path):
            p = str(path).lower()
            if p.endswith((".md", ".markdown")):
                return "text/markdown; charset=utf-8"
            elif p.endswith((".html", ".htm")):
                return "text/html; charset=utf-8"
            elif p.endswith((".txt", ".log", ".prompt")):
                return "text/plain; charset=utf-8"
            return super().guess_type(path)

        def do_GET(self):
            parsed = urllib.parse.urlparse(self.path)
            clean_path = urllib.parse.unquote(parsed.path.lstrip("/"))
            
            if not clean_path:
                self.send_response(302)
                self.send_header("Location", "/" + urllib.parse.quote(file_name))
                self.end_headers()
                return

            super().do_GET()

        def log_message(self, format, *args):
            pass

    preview_url = f"http://{server_ip}:{port}/{urllib.parse.quote(file_name)}"

    # 唤醒 Mac 本地默认浏览器
    bridge_url = f"http://127.0.0.1:19222/open-browser?url={urllib.parse.quote(preview_url)}"
    notify_res = subprocess.run(["curl", "-s", "--max-time", "2", bridge_url], capture_output=True, text=True)
    auto_opened = (notify_res.stdout.strip() == "ok")

    print(f"\n{BOLD}{GREEN}🌐 原地 HTTP 预览服务已就绪！{RESET}")
    print(f"🔗 访问地址 {BOLD}: {BOLD}{CYAN}{preview_url}{RESET}")
    if auto_opened:
        print(f"{GREEN}✔ 成功唤醒 Mac 本地浏览器打开该文件（原样返回，交由浏览器插件高保真渲染）！{RESET}")
    else:
        print(f"{YELLOW}💡 提示：在 Ghostty 终端按住 Cmd 点击上方链接即可在 Mac 浏览器打开{RESET}")
    print(f"{GRAY}(按 Ctrl+C 停止服务并返回终端){RESET}\n")

    class ThreadedHTTPServer(socketserver.ThreadingTCPServer):
        daemon_threads = True
        allow_reuse_address = True

    try:
        with ThreadedHTTPServer(("0.0.0.0", port), RawFileHandler) as httpd:
            try:
                httpd.serve_forever()
            except KeyboardInterrupt:
                pass
            finally:
                try:
                    httpd.server_close()
                except Exception:
                    pass
    except Exception:
        pass
    print(f"\n{GRAY}HTTP 预览服务已关闭。{RESET}", flush=True)
    os._exit(0)

def main():
    args = sys.argv[1:]

    # 处理 --help
    if any(a in ("--help", "-help", "help") for a in args):
        print_help()
        sys.exit(0)

    is_http_mode = False
    filtered_args = []
    for arg in args:
        if arg in ("-h", "--html", "--http", "--browser", "-w"):
            is_http_mode = True
        else:
            filtered_args.append(arg)

    target = filtered_args[0] if filtered_args else None

    repo = get_git_repo_root()
    if not repo:
        print(f"{RED}✘ 错误：当前目录不在 Git 仓库内！{RESET}")
        sys.exit(1)

    worktrees = get_all_worktrees(repo)
    if not worktrees:
        print(f"{RED}✘ 错误：未读取到任何 worktree 信息！{RESET}")
        sys.exit(1)

    if target:
        hits = find_target_in_worktrees(worktrees, target)
    else:
        hits = list_all_dirty_files(worktrees)

    if not hits:
        print(f"{YELLOW}⚠️  未在任何 Worktree 中找到匹配的文件：{target or '(所有工作区无未提交改动)'}{RESET}")
        sys.exit(0)

    prompt = "🌐 选择文件 (回车启动 HTTP 并打开 Mac 浏览器)" if is_http_mode else "⚡ 选择文件 (回车直通 Yazi)"
    hit = select_with_fzf(hits, prompt_title=prompt)
    if not hit:
        sys.exit(0)

    selected_file = hit["abs_path"]

    cb_bin = shutil.which("cb") or os.path.expanduser("~/.local/bin/cb")
    if os.path.exists(cb_bin):
        subprocess.run([cb_bin, selected_file], capture_output=True)

    if is_http_mode:
        start_browser_preview(selected_file, hit)
    else:
        yazi_bin = shutil.which("yazi") or os.path.expanduser("~/.local/bin/yazi")
        if not os.path.exists(yazi_bin):
            print(f"{RED}✘ 错误：未找到 yazi 二进制文件！{RESET}")
            sys.exit(1)
        os.execv(yazi_bin, [yazi_bin, selected_file])

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        sys.exit(0)
PY
chmod +x ~/.local/bin/wto

cat << 'PY' > ~/.local/bin/down
#!/usr/bin/env python3
# ==============================================================================
# down (Download to Mac) - 一键将服务器文件/目录极速下载到 Mac 的 ~/Downloads
# ==============================================================================
import sys
import os
import urllib.parse
import urllib.request
import json
import tarfile
import tempfile
import subprocess
import shutil

BRIDGE_URL = "http://127.0.0.1:19222"

HELP_TEXT = """\033[1mdown\033[0m (Download to Mac) - 一键将服务器文件下载到 Mac 的 ~/Downloads

\033[1m用法:\033[0m
  down <文件或目录>...       将一个或多个文件直接下载到 Mac 的 ~/Downloads
  down                      不带参数时，交互式弹出文件列表（fzf 上下键挑选秒下载）
  down --help, -h           查看帮助说明

\033[1m亮点:\033[0m
  • 自动识别目录：指定目录时会自动压缩为 .tar.gz 传回 Mac
  • 零等待唤醒：文件传完后 Mac 会自动在 Finder 中高亮选中该文件
  • 重名保护：若 Mac 的 ~/Downloads 已有同名文件，自动追加 (1), (2) 防覆盖
"""

def format_size(size_bytes):
    if size_bytes < 1024:
        return f"{size_bytes} B"
    elif size_bytes < 1024 * 1024:
        return f"{size_bytes / 1024:.1f} KB"
    else:
        return f"{size_bytes / (1024 * 1024):.1f} MB"

def check_bridge():
    try:
        req = urllib.request.Request(f"{BRIDGE_URL}/ping", method="GET")
        with urllib.request.urlopen(req, timeout=2) as resp:
            return resp.status == 200
    except Exception:
        return False

def upload_file(local_path, custom_name=None):
    if not os.path.exists(local_path):
        print(f"\033[31m✘ [Server ➔ Mac]\033[0m 文件不存在: {local_path}")
        return False

    is_temp_tar = False
    actual_path = local_path
    filename = custom_name or os.path.basename(local_path.rstrip("/\\"))

    # 如果是目录，自动打包为 tar.gz
    if os.path.isdir(local_path):
        clean_dir = os.path.normpath(local_path)
        base_name = os.path.basename(clean_dir) or "archive"
        filename = f"{base_name}.tar.gz"
        print(f"\033[34mℹ [Server ➔ Mac]\033[0m 检测到目录，正在打包压缩为 \033[1m{filename}\033[0m ...")
        
        temp_file = tempfile.NamedTemporaryFile(suffix=".tar.gz", delete=False)
        temp_file.close()
        try:
            with tarfile.open(temp_file.name, "w:gz") as tar:
                tar.add(local_path, arcname=base_name)
            actual_path = temp_file.name
            is_temp_tar = True
        except Exception as e:
            print(f"\033[31m✘ [Server ➔ Mac]\033[0m 打包目录失败: {e}")
            if os.path.exists(temp_file.name):
                os.unlink(temp_file.name)
            return False

    file_size = os.path.getsize(actual_path)
    url = f"{BRIDGE_URL}/save-file?filename={urllib.parse.quote(filename)}&reveal=1"

    try:
        with open(actual_path, "rb") as f:
            req = urllib.request.Request(
                url,
                data=f,
                headers={
                    "Content-Type": "application/octet-stream",
                    "Content-Length": str(file_size)
                },
                method="POST"
            )
            with urllib.request.urlopen(req, timeout=180) as resp:
                result = json.loads(resp.read().decode("utf-8"))
                saved_name = result.get("filename", filename)
                size_str = format_size(result.get("size", file_size))
                print(f"\033[32m✔ [Server ➔ Mac]\033[0m 成功下载到 Mac: \033[1m~/Downloads/{saved_name}\033[0m ({size_str})")
                return True
    except Exception as e:
        print(f"\033[31m✘ [Server ➔ Mac]\033[0m 下载失败 ({filename}): {e}")
        return False
    finally:
        if is_temp_tar and os.path.exists(actual_path):
            try:
                os.unlink(actual_path)
            except Exception:
                pass

def pick_file_fzf():
    if not shutil.which("fzf"):
        print("\033[31m✘ [Server ➔ Mac]\033[0m 未指定文件且系统未安装 fzf，请直接指定文件名，如: down <文件名>")
        return None
    
    find_cmd = [
        "find", ".",
        "-maxdepth", "3",
        "-not", "-path", "*/.*",
        "-not", "-path", "*/node_modules/*",
        "-not", "-path", "*/.venv/*",
        "-not", "-path", "*/__pycache__/*",
        "-type", "f"
    ]
    fzf_cmd = [
        "fzf",
        "--height=40%",
        "--reverse",
        "--prompt=选择要下载到 Mac 的文件 > ",
        "--preview=head -n 20 {} 2>/dev/null"
    ]
    try:
        p1 = subprocess.Popen(find_cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
        p2 = subprocess.Popen(fzf_cmd, stdin=p1.stdout, stdout=subprocess.PIPE, text=True)
        p1.stdout.close()
        out, _ = p2.communicate()
        selected = out.strip()
        return selected if selected else None
    except Exception:
        return None

def main():
    args = sys.argv[1:]
    if args and args[0] in ("-h", "--help", "help"):
        print(HELP_TEXT)
        return

    if not check_bridge():
        print("\033[31m✘ [Server ➔ Mac]\033[0m 无法连接 Mac 本地桥接服务 (HTTP 19222)")
        print("  提示: 请检查是否通过带有端口转发的 SSH 登录 (RemoteForward 19222 127.0.0.1:19222)")
        sys.exit(1)

    if not args:
        selected = pick_file_fzf()
        if not selected:
            sys.exit(0)
        upload_file(selected)
    else:
        for path in args:
            upload_file(path)

if __name__ == "__main__":
    main()
PY
chmod +x ~/.local/bin/down

curl -sL https://github.com/sxyazi/yazi/releases/download/v26.9.1/yazi-x86_64-unknown-linux-musl.zip -o /tmp/yazi.zip
unzip -o /tmp/yazi.zip -d /tmp/yazi_bin
mv /tmp/yazi_bin/yazi-x86_64-unknown-linux-musl/yazi ~/.local/bin/yazi
mv /tmp/yazi_bin/yazi-x86_64-unknown-linux-musl/ya ~/.local/bin/ya
chmod +x ~/.local/bin/yazi ~/.local/bin/ya
rm -rf /tmp/yazi.zip /tmp/yazi_bin

cat << 'TOML' > ~/.config/starship.toml
"$schema" = 'https://starship.rs/config-schema.json'

format = """
[](red)\
$os\
$username\
[](bg:peach fg:red)\
$directory\
[](bg:yellow fg:peach)\
$git_branch\
$git_status\
[ ](yellow)\
$character"""

palette = 'catppuccin_mocha'

[os]
disabled = false
style = "bg:red fg:crust"

[os.symbols]
Macos = "󰀵"
Ubuntu = "󰕈"
Linux = "󰌽"

[username]
show_always = true
style_user = "bg:red fg:crust"
style_root = "bg:red fg:crust"
format = '[[ $user ](fg:crust bg:red)]($style)'

[directory]
style = "fg:crust bg:peach"
format = "[ $path ]($style)"
truncation_length = 3
truncation_symbol = "…/"

[git_branch]
symbol = ""
style = "bg:yellow"
format = '[[ $symbol $branch ](fg:crust bg:yellow)]($style)'

# 极简模式：关闭复杂的 stash/untracked 符号（$?:），仅保留干净的分支名
[git_status]
disabled = true
style = "bg:yellow"
format = '[[($all_status$ahead_behind )](fg:crust bg:yellow)]($style)'

[nodejs]
disabled = true

[time]
disabled = true

[cmd_duration]
disabled = true

[character]
disabled = false
success_symbol = '[❯](bold green)'
error_symbol = '[❯](bold red)'

[palettes.catppuccin_mocha]
rosewater = "#f5e0dc"
flamingo = "#f2cdcd"
pink = "#f5c2e7"
mauve = "#cba6f7"
red = "#f38ba8"
maroon = "#eba0ac"
peach = "#fab387"
yellow = "#f9e2af"
green = "#a6e3a1"
teal = "#94e2d5"
sky = "#89dceb"
sapphire = "#74c7ec"
blue = "#89b4fa"
lavender = "#b4befe"
text = "#cdd6f4"
subtext1 = "#bac2de"
subtext0 = "#a6adc8"
overlay2 = "#9399b2"
overlay1 = "#7f849c"
overlay0 = "#6c7086"
surface2 = "#585b70"
surface1 = "#45475a"
surface0 = "#313244"
base = "#1e1e2e"
mantle = "#181825"
crust = "#11111b"
TOML

# ------------------------------------------------------------------------------
# 远程开发快捷别名与工作流
# ------------------------------------------------------------------------------
# 1. 项目直达
alias ai3='cd ~/workspaces/<PROJECT_NAME> && tmux new -A -s <PROJECT_NAME>'
alias cdai='cd ~/workspaces/<PROJECT_NAME>'

# 2. 终端神级工具链
alias lg='lazygit'            # Git TUI 神器（按 w 看/切 worktree，按 3 看 commit 树）
alias y='~/.local/bin/yazi'
alias yazi='~/.local/bin/yazi' # 现代化文件管理器（方向键穿梭，Kitty 原生看图）
alias wt='git worktree list'   # 查看当前项目所有 git worktree 工作树
alias gw='glow'

# 3. Tmux 窗口快捷操作（保持当前目录）
alias new='tmux new-window -c "$(pwd)"'
alias cw='new'
alias rn='tmux rename-window'
alias close='exit'
alias tls='tmux ls'

# 4. 函数定义（规范无别名冲突）
ta() {
  tmux new -A -s "${1:-main}"
}

md() {
  if [ -z "$1" ]; then
    glow
  else
    glow -p "$@"
  fi
}

ws() {
  local target_dir
  if [ -z "$1" ]; then
    target_dir=$(find ~/workspaces -mindepth 1 -maxdepth 1 -type d -exec basename {} \; 2>/dev/null | sort | fzf --prompt="⚡ 选择工作区项目: " --height=40% --layout=reverse --border)
    [ -z "$target_dir" ] && return 0
  else
    target_dir="$1"
  fi
  local full_path="$HOME/workspaces/$target_dir"
  if [ -d "$full_path" ]; then
    cd "$full_path"
    tmux new -A -s "$target_dir"
  else
    echo "未找到目录: $full_path"
  fi
}

tkill() {
  local target="$1"
  if [ -z "$target" ]; then
    target=$(tmux list-sessions -F "#{session_name}" 2>/dev/null | fzf --prompt="🗑️ 选择要关闭的保活会话: " --height=40% --layout=reverse --border)
    [ -z "$target" ] && return 0
  fi
  if [ "$target" = "all" ]; then
    tmux kill-server
    echo "✔ 已关闭全部后台保活会话"
  else
    tmux kill-session -t "$target" 2>/dev/null && echo "✔ 已关闭会话: $target" || echo "✖ 未找到会话: $target"
  fi
}

# 加载 Starship 彩虹状态栏（Catppuccin Powerline）
if [ -x "$HOME/.local/bin/starship" ]; then
  eval "$($HOME/.local/bin/starship init bash)"
fi