vitaly
c57158420e
CLAUDE_CODE_DISABLE_1M_CONTEXT=1 заставлял Claude Code считать контекстное окно = 200K, из-за чего ctx: в статус-баре заполнялся в ~5 раз раньше реального лимита GLM 5.2 (1M токенов). Флаг убран только в секции ai-glm. Прочие лаунчеры (deepseek/kimi/ openrouter/opencode) флаг оставляют — у них другой контекст, и флаг убирает [1M]-дубли из пикера. ai-claude его не использует. Co-Authored-By: Claude <noreply@anthropic.com>
2004 lines
83 KiB
Bash
Executable File
2004 lines
83 KiB
Bash
Executable File
#!/usr/bin/env bash
|
||
# Copyright (c) 2026 Виталий Никитенко. MIT License.
|
||
# ============================================================
|
||
# AI Setup - Claude / GPT-5.5 / Grok / Qwen / DeepSeek / Kimi / GLM / Gemini
|
||
# Запуск: bash ai-setup.sh
|
||
# ============================================================
|
||
|
||
CONFIG_DIR="$HOME/.config/ai-setup"
|
||
# Автоопределение: ~/bin если есть в PATH, иначе ~/.local/bin
|
||
if [[ ":$PATH:" == *":$HOME/bin:"* ]]; then
|
||
BIN_DIR="$HOME/bin"
|
||
else
|
||
BIN_DIR="$HOME/.local/bin"
|
||
fi
|
||
NPM_GLOBAL="$HOME/.npm-global"
|
||
PROXY_BIN="$BIN_DIR/claude-code-proxy"
|
||
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
|
||
GLOBAL_RULES_SOURCE="$SCRIPT_DIR/home-configs/GLOBAL_RULES.md"
|
||
|
||
# ── 0. Определение ОС и архитектуры (глобально) ─────────────
|
||
# bash 3.2 на macOS: lowercasing через case, не через ${var,,}
|
||
OS_KERNEL="$(uname -s)" # Linux | Darwin | ...
|
||
OS_TAG=""
|
||
ARCH_TAG=""
|
||
case "$OS_KERNEL" in
|
||
Linux) OS_TAG="linux" ;;
|
||
Darwin) OS_TAG="darwin" ;;
|
||
*) OS_TAG="" ;;
|
||
esac
|
||
case "$(uname -m)" in
|
||
x86_64) ARCH_TAG="amd64" ;;
|
||
arm64|aarch64) ARCH_TAG="arm64" ;;
|
||
*) ARCH_TAG="" ;;
|
||
esac
|
||
|
||
# Портабельный sed -i: BSD (macOS) требует суффикс, GNU — нет
|
||
if [ "$OS_KERNEL" = "Darwin" ]; then
|
||
SED_INPLACE=(-i '')
|
||
else
|
||
SED_INPLACE=(-i)
|
||
fi
|
||
|
||
RED='\033[0;31m'; GREEN='\033[0;32m'; YELLOW='\033[1;33m'; CYAN='\033[0;36m'; NC='\033[0m'
|
||
info() { echo -e "${CYAN}[INFO]${NC} $*"; }
|
||
success() { echo -e "${GREEN}[OK]${NC} $*"; }
|
||
warn() { echo -e "${YELLOW}[WARN]${NC} $*"; }
|
||
err() { echo -e "${RED}[ERR]${NC} $*"; exit 1; }
|
||
|
||
# Запрет запуска от root
|
||
if [ "$EUID" -eq 0 ]; then
|
||
echo -e "${RED}Не запускайте этот скрипт через sudo!${NC}"
|
||
echo "Запустите просто: bash ai-setup.sh"
|
||
exit 1
|
||
fi
|
||
|
||
# ── Homebrew shellenv (macOS) ───────────────────────────────
|
||
# brew может быть установлен, но не в PATH текущего шелла (особенно
|
||
# после свежей установки). Подключаем shellenv, чтобы node/npm/jq
|
||
# стали видны через command -v в этой же сессии.
|
||
if [ "$OS_KERNEL" = "Darwin" ]; then
|
||
for _brew_prefix in /opt/homebrew /usr/local "$HOME/.homebrew"; do
|
||
if [ -x "$_brew_prefix/bin/brew" ]; then
|
||
eval "$("$_brew_prefix/bin/brew" shellenv)"
|
||
break
|
||
fi
|
||
done
|
||
unset _brew_prefix
|
||
fi
|
||
|
||
info "Проверяю зависимости (python3)..."
|
||
if ! command -v python3 &>/dev/null; then
|
||
err "Python 3 не установлен, но он требуется для работы скрипта."
|
||
fi
|
||
success "Python 3 найден"
|
||
|
||
info "Проверяю зависимости (jq)..."
|
||
if ! command -v jq &>/dev/null; then
|
||
info "Устанавливаю jq..."
|
||
if command -v brew &>/dev/null; then
|
||
brew install jq
|
||
elif command -v apt-get &>/dev/null; then
|
||
sudo apt-get install -y jq
|
||
elif command -v dnf &>/dev/null; then
|
||
sudo dnf install -y jq
|
||
else
|
||
warn "Не удалось установить jq автоматически. Установите вручную."
|
||
fi
|
||
fi
|
||
if command -v jq &>/dev/null; then
|
||
success "jq найден"
|
||
else
|
||
warn "jq не найден. statusline-command.sh и некоторые функции могут не работать."
|
||
fi
|
||
|
||
# ── 1. Node.js ───────────────────────────────────────────────
|
||
info "Проверяю Node.js..."
|
||
if ! command -v node &>/dev/null; then
|
||
info "Пытаюсь установить Node.js..."
|
||
if command -v brew &>/dev/null; then
|
||
brew install node
|
||
elif command -v apt-get &>/dev/null; then
|
||
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
|
||
sudo apt-get install -y nodejs
|
||
elif command -v dnf &>/dev/null; then
|
||
sudo dnf install -y nodejs
|
||
else
|
||
warn "Не удалось определить пакетный менеджер. Установите Homebrew (https://brew.sh) или Node.js вручную."
|
||
fi
|
||
fi
|
||
if command -v node &>/dev/null; then
|
||
success "Node.js $(node --version)"
|
||
else
|
||
warn "Node.js не найден. Некоторые функции могут не работать."
|
||
fi
|
||
|
||
# ── 2. npm prefix в домашнюю папку ──────────────────────────
|
||
# После установки Node, чтобы npm гарантированно был доступен.
|
||
info "Настраиваю npm prefix..."
|
||
mkdir -p "$NPM_GLOBAL"
|
||
if command -v npm &>/dev/null; then
|
||
npm config set prefix "$NPM_GLOBAL"
|
||
success "npm prefix -> $NPM_GLOBAL"
|
||
else
|
||
warn "npm не найден — пропускаю настройку prefix (установите Node.js)."
|
||
fi
|
||
|
||
export PATH="$NPM_GLOBAL/bin:$BIN_DIR:$PATH"
|
||
|
||
# ── 3. Claude Code ───────────────────────────────────────────
|
||
info "Проверяю Claude Code..."
|
||
if ! command -v claude &>/dev/null; then
|
||
info "Устанавливаю Claude Code..."
|
||
if curl -fsSL https://claude.ai/install.sh | bash 2>/dev/null; then
|
||
success "Claude Code установлен (официальный инсталлер)"
|
||
else
|
||
npm install -g @anthropic-ai/claude-code
|
||
success "Claude Code установлен (npm)"
|
||
fi
|
||
else
|
||
success "Claude Code уже установлен: $(claude --version 2>/dev/null | head -1)"
|
||
fi
|
||
|
||
# ── 4. claude-code-proxy (GPT) ───────────────────────────────
|
||
mkdir -p "$BIN_DIR"
|
||
|
||
install_proxy() {
|
||
info "Устанавливаю claude-code-proxy..."
|
||
if [ -z "$OS_TAG" ] || [ -z "$ARCH_TAG" ]; then
|
||
err "Неизвестная платформа: kernel=$OS_KERNEL arch=$ARCH_TAG"
|
||
fi
|
||
|
||
LATEST=$(curl -fsSL "https://api.github.com/repos/raine/claude-code-proxy/releases/latest" \
|
||
| grep '"tag_name"' | sed 's/.*"tag_name": *"\(.*\)".*/\1/')
|
||
[ -z "$LATEST" ] && err "Не удалось получить версию claude-code-proxy с GitHub"
|
||
|
||
TMP=$(mktemp -d)
|
||
trap 'rm -rf "$TMP"' EXIT
|
||
URL="https://github.com/raine/claude-code-proxy/releases/download/${LATEST}/claude-code-proxy-${OS_TAG}-${ARCH_TAG}.tar.gz"
|
||
info "Скачиваю $URL"
|
||
curl -fsSL "$URL" -o "$TMP/proxy.tar.gz" || err "Не удалось скачать claude-code-proxy"
|
||
tar -xzf "$TMP/proxy.tar.gz" -C "$TMP"
|
||
BINARY=$(find "$TMP" -name "claude-code-proxy" -type f | head -1)
|
||
[ -z "$BINARY" ] && err "Бинарник не найден в архиве"
|
||
cp "$BINARY" "$PROXY_BIN"
|
||
chmod +x "$PROXY_BIN"
|
||
success "claude-code-proxy $LATEST -> $PROXY_BIN"
|
||
}
|
||
|
||
if [ -f "$PROXY_BIN" ]; then
|
||
CURRENT_VER=$("$PROXY_BIN" --version 2>/dev/null | head -1 || echo "unknown")
|
||
success "claude-code-proxy уже установлен ($CURRENT_VER)"
|
||
else
|
||
install_proxy
|
||
fi
|
||
|
||
# ── 4b. effort-proxy wrapper (маппинг effort: xhigh→high) ─────────
|
||
EFFORT_PROXY_BIN="$BIN_DIR/claude-gpt-effort-proxy.py"
|
||
cat > "$EFFORT_PROXY_BIN" << 'PYEOF'
|
||
#!/usr/bin/env python3
|
||
"""Effort mapping proxy for GPT backend.
|
||
|
||
claude-code-proxy now accepts: low, medium, high, max (no "xhigh").
|
||
Claude Code may send "xhigh" effort - we map it to "high".
|
||
"""
|
||
import http.client, http.server, sys, logging, socketserver
|
||
|
||
UPSTREAM_PORT = int(sys.argv[1]) if len(sys.argv) > 1 else 18766
|
||
LISTEN_PORT = int(sys.argv[2]) if len(sys.argv) > 2 else 18765
|
||
|
||
logging.basicConfig(
|
||
filename="/tmp/claude-gpt-effort-proxy.log",
|
||
level=logging.INFO,
|
||
format='{"t":"%(asctime)s","level":"%(levelname)s","msg":"%(message)s"}',
|
||
datefmt='%Y-%m-%dT%H:%M:%S',
|
||
)
|
||
log = logging.getLogger("effort-proxy")
|
||
|
||
# Потокобезопасный сервер - обрабатывает несколько запросов одновременно
|
||
class _ThreadedServer(socketserver.ThreadingMixIn, http.server.HTTPServer):
|
||
daemon_threads = True
|
||
|
||
class _Proxy(http.server.BaseHTTPRequestHandler):
|
||
def proxy_request(self):
|
||
body = b""
|
||
if cl := self.headers.get("Content-Length"):
|
||
body = self.rfile.read(int(cl))
|
||
# Маппинг xhigh→high: claude-code-proxy больше не принимает xhigh
|
||
body = body.replace(b'"xhigh"', b'"high"')
|
||
try:
|
||
conn = http.client.HTTPConnection("127.0.0.1", UPSTREAM_PORT, timeout=300)
|
||
hdrs = dict(self.headers)
|
||
hdrs.pop("Host", None)
|
||
hdrs["Content-Length"] = str(len(body))
|
||
conn.request(self.command, self.path, body=body or None, headers=hdrs)
|
||
resp = conn.getresponse()
|
||
self.send_response(resp.status, resp.reason)
|
||
chunked = False
|
||
for k, v in resp.getheaders():
|
||
if k.lower() == "transfer-encoding" and "chunked" in v.lower():
|
||
chunked = True
|
||
self.send_header(k, v)
|
||
self.end_headers()
|
||
while chunk := resp.read(4096):
|
||
try:
|
||
if chunked:
|
||
self.wfile.write(f"{len(chunk):X}\r\n".encode() + chunk + b"\r\n")
|
||
else:
|
||
self.wfile.write(chunk)
|
||
self.wfile.flush()
|
||
except (BrokenPipeError, ConnectionResetError):
|
||
break
|
||
if chunked:
|
||
try: self.wfile.write(b"0\r\n\r\n")
|
||
except: pass
|
||
conn.close()
|
||
except Exception as e:
|
||
log.error("proxy error: %s", e)
|
||
try: self.send_error(502, str(e))
|
||
except: pass
|
||
do_GET = do_POST = do_PUT = do_DELETE = do_HEAD = proxy_request
|
||
def log_message(self, *args): pass
|
||
|
||
log.info("effort-proxy starting on 127.0.0.1:%d → upstream %d", LISTEN_PORT, UPSTREAM_PORT)
|
||
_ThreadedServer(("127.0.0.1", LISTEN_PORT), _Proxy).serve_forever()
|
||
PYEOF
|
||
chmod +x "$EFFORT_PROXY_BIN"
|
||
success "claude-gpt-effort-proxy -> $EFFORT_PROXY_BIN"
|
||
|
||
# ── 4c. antigravity CLI (Gemini) ──────────────────────────
|
||
info "Проверяю antigravity CLI (agy)..."
|
||
if ! command -v agy &>/dev/null; then
|
||
info "Устанавливаю agy..."
|
||
curl -fsSL https://antigravity.google/cli/install.sh | bash
|
||
success "agy установлен"
|
||
else
|
||
success "agy уже установлен: $(agy --version 2>/dev/null | head -1)"
|
||
fi
|
||
|
||
# ── 4d. Google Android CLI ───────────────────────────────────
|
||
info "Проверяю Android CLI..."
|
||
ANDROID_BIN="$HOME/.local/bin/android"
|
||
[ ! -f "$ANDROID_BIN" ] && ANDROID_BIN="$(command -v android 2>/dev/null || true)"
|
||
|
||
if [ -z "$ANDROID_BIN" ] || [ ! -f "$ANDROID_BIN" ]; then
|
||
info "Устанавливаю Android CLI..."
|
||
_uname_s=$(uname -s)
|
||
_uname_m=$(uname -m)
|
||
ANDROID_PLATFORM=""
|
||
case "${_uname_s}-${_uname_m}" in
|
||
Linux-x86_64) ANDROID_PLATFORM="linux_x86_64" ;;
|
||
Linux-aarch64) ANDROID_PLATFORM="linux_arm64" ;;
|
||
Linux-arm64) ANDROID_PLATFORM="linux_arm64" ;;
|
||
Darwin-x86_64) ANDROID_PLATFORM="darwin_x86_64" ;;
|
||
Darwin-arm64) ANDROID_PLATFORM="darwin_arm64" ;;
|
||
Darwin-aarch64) ANDROID_PLATFORM="darwin_arm64" ;;
|
||
MINGW*|MSYS*|CYGWIN*-x86_64) ANDROID_PLATFORM="windows_x86_64" ;;
|
||
esac
|
||
|
||
if [ -n "$ANDROID_PLATFORM" ]; then
|
||
ANDROID_INSTALL_URL="https://dl.google.com/android/cli/latest/${ANDROID_PLATFORM}/install.sh"
|
||
if curl -fsSL "$ANDROID_INSTALL_URL" | bash; then
|
||
success "Android CLI установлен"
|
||
else
|
||
warn "Не удалось установить Android CLI через официальный скрипт"
|
||
fi
|
||
else
|
||
warn "Неизвестная платформа ${_uname_s} ${_uname_m}. Пропускаю Android CLI."
|
||
fi
|
||
else
|
||
success "Android CLI уже установлен: $($ANDROID_BIN --version 2>/dev/null | head -1)"
|
||
fi
|
||
|
||
# Официальный install.sh ставит бинарь в ~/.local/bin/android.
|
||
# Если пользователь использует ~/bin вместо ~/.local/bin - symlink.
|
||
if [ "$BIN_DIR" != "$HOME/.local/bin" ] && [ -f "$HOME/.local/bin/android" ] && [ ! -f "$BIN_DIR/android" ]; then
|
||
ln -sf "$HOME/.local/bin/android" "$BIN_DIR/android"
|
||
success "Android CLI symlink -> $BIN_DIR/android"
|
||
fi
|
||
|
||
# Разворачиваем Android CLI skills для агентов (Claude Code и др.)
|
||
if command -v android &>/dev/null; then
|
||
info "Запускаю android init для деплоя skills..."
|
||
mkdir -p "$HOME/.claude/skills"
|
||
android init || warn "android init завершился с ошибкой"
|
||
else
|
||
info "Android CLI не найден в PATH, пропускаю android init"
|
||
fi
|
||
|
||
# ── 5. routatic-proxy (OpenCode Go → Claude Code) ──────────
|
||
info "Проверяю routatic-proxy..."
|
||
ROUTATIC_BIN="$HOME/.local/bin/routatic-proxy"
|
||
[ ! -f "$ROUTATIC_BIN" ] && ROUTATIC_BIN="$(command -v routatic-proxy 2>/dev/null || true)"
|
||
|
||
if [ -z "$ROUTATIC_BIN" ] || [ ! -f "$ROUTATIC_BIN" ]; then
|
||
info "Устанавливаю routatic-proxy..."
|
||
_uname_s=$(uname -s)
|
||
_uname_m=$(uname -m)
|
||
ROUTATIC_PLATFORM=""
|
||
case "${_uname_s}-${_uname_m}" in
|
||
Linux-x86_64) ROUTATIC_PLATFORM="linux-amd64" ;;
|
||
Linux-aarch64) ROUTATIC_PLATFORM="linux-arm64" ;;
|
||
Linux-arm64) ROUTATIC_PLATFORM="linux-arm64" ;;
|
||
Darwin-x86_64) ROUTATIC_PLATFORM="darwin-amd64" ;;
|
||
Darwin-arm64) ROUTATIC_PLATFORM="darwin-arm64" ;;
|
||
Darwin-aarch64) ROUTATIC_PLATFORM="darwin-arm64" ;;
|
||
esac
|
||
|
||
if [ -n "$ROUTATIC_PLATFORM" ]; then
|
||
ROUTATIC_URL="https://github.com/routatic/proxy/releases/latest/download/routatic-proxy_${ROUTATIC_PLATFORM}"
|
||
if curl -fsSL "$ROUTATIC_URL" -o "$HOME/.local/bin/routatic-proxy"; then
|
||
chmod +x "$HOME/.local/bin/routatic-proxy"
|
||
success "routatic-proxy установлен"
|
||
else
|
||
warn "Не удалось скачать routatic-proxy с GitHub"
|
||
fi
|
||
else
|
||
warn "Неизвестная платформа ${_uname_s} ${_uname_m}. Пропускаю routatic-proxy."
|
||
fi
|
||
else
|
||
success "routatic-proxy уже установлен"
|
||
fi
|
||
|
||
# Symlink в BIN_DIR если используется ~/bin вместо ~/.local/bin
|
||
if [ "$BIN_DIR" != "$HOME/.local/bin" ] && [ -f "$HOME/.local/bin/routatic-proxy" ] && [ ! -f "$BIN_DIR/routatic-proxy" ]; then
|
||
ln -sf "$HOME/.local/bin/routatic-proxy" "$BIN_DIR/routatic-proxy"
|
||
success "routatic-proxy symlink -> $BIN_DIR/routatic-proxy"
|
||
fi
|
||
|
||
# Инициализируем конфиг routatic-proxy
|
||
if command -v routatic-proxy &>/dev/null; then
|
||
if [ ! -f "$HOME/.config/routatic-proxy/config.json" ]; then
|
||
routatic-proxy init 2>/dev/null || true
|
||
success "routatic-proxy config инициализирован"
|
||
fi
|
||
fi
|
||
|
||
# ── 6. Папка для конфигов ────────────────────────────────────
|
||
mkdir -p "$CONFIG_DIR"
|
||
|
||
# ── 6.5. Генерация глобальных правил агентов ─────────────────
|
||
info "Обновляю глобальные правила агентов..."
|
||
[ -f "$GLOBAL_RULES_SOURCE" ] || err "Файл глобальных правил не найден: $GLOBAL_RULES_SOURCE"
|
||
cp "$GLOBAL_RULES_SOURCE" "$CONFIG_DIR/global_rules.md"
|
||
success "Глобальные правила обновлены: $CONFIG_DIR/global_rules.md"
|
||
|
||
info "Обновляю native rule-файлы агентов..."
|
||
mkdir -p "$HOME/.codex" "$HOME/.kimi-code" "$HOME/.claude" "$HOME/.gemini"
|
||
cp "$CONFIG_DIR/global_rules.md" "$HOME/.codex/AGENTS.md"
|
||
cp "$CONFIG_DIR/global_rules.md" "$HOME/.kimi-code/AGENTS.md"
|
||
cp "$CONFIG_DIR/global_rules.md" "$HOME/.claude/CLAUDE.md"
|
||
cp "$CONFIG_DIR/global_rules.md" "$HOME/.gemini/GEMINI.md"
|
||
cp "$CONFIG_DIR/global_rules.md" "$HOME/.cursorrules"
|
||
success "Native rule-файлы обновлены"
|
||
|
||
# ── 6.6. Деплой Claude и Gemini skills ───────────────────────
|
||
info "Обновляю skills для Claude и Gemini..."
|
||
SKILLS_SRC="$SCRIPT_DIR/home-configs/claude/skills"
|
||
CLAUDE_SKILLS_DST="$HOME/.claude/skills"
|
||
GEMINI_SKILLS_DST="$HOME/.gemini/config/plugins/local-setup/skills"
|
||
if [ -d "$SKILLS_SRC" ]; then
|
||
mkdir -p "$CLAUDE_SKILLS_DST" "$GEMINI_SKILLS_DST"
|
||
|
||
# Для Gemini нужен plugin.json, чтобы плагин со скилами загрузился
|
||
GEMINI_PLUGIN_DIR="$HOME/.gemini/config/plugins/local-setup"
|
||
cat <<EOF > "$GEMINI_PLUGIN_DIR/plugin.json"
|
||
{
|
||
"name": "local-setup",
|
||
"description": "Local custom skills deployed via ai-setup"
|
||
}
|
||
EOF
|
||
|
||
for skill_dir in "$SKILLS_SRC"/*; do
|
||
[ -d "$skill_dir" ] || continue
|
||
skill_name=$(basename "$skill_dir")
|
||
|
||
# Деплой для Claude
|
||
mkdir -p "$CLAUDE_SKILLS_DST/$skill_name"
|
||
cp -r "$skill_dir/"* "$CLAUDE_SKILLS_DST/$skill_name/"
|
||
|
||
# Деплой для Gemini (agy)
|
||
mkdir -p "$GEMINI_SKILLS_DST/$skill_name"
|
||
cp -r "$skill_dir/"* "$GEMINI_SKILLS_DST/$skill_name/"
|
||
done
|
||
success "Skills обновлены для Claude и Gemini"
|
||
else
|
||
info "Папка со skills не найдена, пропускаю"
|
||
fi
|
||
|
||
# ── 6.7. Статусная строка Claude Code ───────────────────────
|
||
info "Настраиваю статусную строку Claude Code..."
|
||
STATUSLINE_SRC="$SCRIPT_DIR/home-configs/claude/statusline-command.sh"
|
||
STATUSLINE_DST="$HOME/.claude/statusline-command.sh"
|
||
if [ -f "$STATUSLINE_SRC" ]; then
|
||
cp "$STATUSLINE_SRC" "$STATUSLINE_DST"
|
||
chmod +x "$STATUSLINE_DST"
|
||
# Вписываем statusLine в settings.json через python3
|
||
SETTINGS="$HOME/.claude/settings.json"
|
||
python3 - "$SETTINGS" "$STATUSLINE_DST" <<'PYEOF'
|
||
import sys, json, os
|
||
settings_path, script_path = sys.argv[1], sys.argv[2]
|
||
data = {}
|
||
if os.path.exists(settings_path):
|
||
with open(settings_path) as f:
|
||
try:
|
||
data = json.load(f)
|
||
except json.JSONDecodeError:
|
||
pass
|
||
data["statusLine"] = {"type": "command", "command": f"bash {script_path}"}
|
||
# Дефолтный effort для ai-claude (не передаётся через CLI, берётся отсюда)
|
||
data.setdefault("effortLevel", "xhigh")
|
||
# SessionStart хук - триггерит вызов statusLine при старте сессии
|
||
if "hooks" not in data:
|
||
data["hooks"] = {}
|
||
if "SessionStart" not in data["hooks"]:
|
||
data["hooks"]["SessionStart"] = [{"hooks": [{"type": "command", "command": "true"}]}]
|
||
with open(settings_path, "w") as f:
|
||
json.dump(data, f, indent=2, ensure_ascii=False)
|
||
f.write("\n")
|
||
PYEOF
|
||
success "Статусная строка настроена"
|
||
else
|
||
warn "Файл $STATUSLINE_SRC не найден, пропускаю"
|
||
fi
|
||
|
||
# ── 6.7.0. Чистка устаревшего хука effort-save ──────────────
|
||
# effort/model теперь персистятся нативно в settings.json каждого CLAUDE_CONFIG_DIR
|
||
# (полная изоляция лаунчеров), самопальный кэш ~/.cache/ai-setup/{effort,model}_* не нужен.
|
||
# Удаляем старый хук с диска и из ~/.claude/settings.json (нотифаер в Stop сохраняем).
|
||
info "Удаляю устаревший хук effort-save..."
|
||
rm -f "$HOME/.claude/hooks/effort-save-hook.sh"
|
||
# Осиротевший кэш моделей (источник старой протечки между ai-*); effort_* не трогаем -
|
||
# они используются статусбаром для отображения текущего уровня.
|
||
rm -f "$HOME"/.cache/ai-setup/model_*
|
||
python3 - "$HOME/.claude/settings.json" <<'PYEOF'
|
||
import sys, json, os
|
||
settings_path = sys.argv[1]
|
||
if not os.path.exists(settings_path):
|
||
sys.exit(0)
|
||
try:
|
||
with open(settings_path) as f:
|
||
data = json.load(f)
|
||
except Exception:
|
||
sys.exit(0)
|
||
stop = data.get("hooks", {}).get("Stop")
|
||
if isinstance(stop, list):
|
||
for entry in stop:
|
||
hooks = entry.get("hooks")
|
||
if isinstance(hooks, list):
|
||
entry["hooks"] = [h for h in hooks if "effort-save-hook" not in h.get("command", "")]
|
||
data["hooks"]["Stop"] = [e for e in stop if e.get("hooks")]
|
||
if not data["hooks"]["Stop"]:
|
||
del data["hooks"]["Stop"]
|
||
with open(settings_path, "w") as f:
|
||
json.dump(data, f, indent=2, ensure_ascii=False)
|
||
f.write("\n")
|
||
PYEOF
|
||
success "Старый хук effort-save удалён"
|
||
|
||
# ── 6.7.05. Хелпер account-email (определение email по токену) ──
|
||
# Вспомогательный скрипт для хуков switch-account/add-account.
|
||
# Не регистрируется в settings.json — вызывается из хуков напрямую.
|
||
EMAIL_HELPER_SRC="$SCRIPT_DIR/home-configs/claude/hooks/account-email.sh"
|
||
EMAIL_HELPER_DST="$HOME/.claude/hooks/account-email.sh"
|
||
mkdir -p "$HOME/.claude/hooks"
|
||
if [ -f "$EMAIL_HELPER_SRC" ]; then
|
||
cp "$EMAIL_HELPER_SRC" "$EMAIL_HELPER_DST"
|
||
chmod +x "$EMAIL_HELPER_DST"
|
||
fi
|
||
|
||
# ── 6.7.1. Хук switch-account ───────────────────────────────────
|
||
info "Деплою хук switch-account..."
|
||
SWITCH_HOOK_SRC="$SCRIPT_DIR/home-configs/claude/hooks/switch-account-hook.sh"
|
||
SWITCH_HOOK_DST="$HOME/.claude/hooks/switch-account-hook.sh"
|
||
mkdir -p "$HOME/.claude/hooks"
|
||
if [ -f "$SWITCH_HOOK_SRC" ]; then
|
||
cp "$SWITCH_HOOK_SRC" "$SWITCH_HOOK_DST"
|
||
chmod +x "$SWITCH_HOOK_DST"
|
||
# Прописываем хук в settings.json (идемпотентно)
|
||
python3 - "$HOME/.claude/settings.json" "$SWITCH_HOOK_DST" <<'PYEOF'
|
||
import sys, json, os
|
||
settings_path, hook_path = sys.argv[1], sys.argv[2]
|
||
data = {}
|
||
if os.path.exists(settings_path):
|
||
with open(settings_path) as f:
|
||
try: data = json.load(f)
|
||
except json.JSONDecodeError: pass
|
||
data.setdefault("hooks", {}).setdefault("UserPromptSubmit", [{"hooks": []}])
|
||
hook_cmd = f'bash "{hook_path}"'
|
||
ups = data["hooks"]["UserPromptSubmit"]
|
||
already = any(
|
||
any(h.get("command", "") == hook_cmd for h in entry.get("hooks", []))
|
||
for entry in ups
|
||
)
|
||
if not already:
|
||
ups[0]["hooks"].append({"type": "command", "command": hook_cmd})
|
||
with open(settings_path, "w") as f:
|
||
json.dump(data, f, indent=2, ensure_ascii=False)
|
||
f.write("\n")
|
||
PYEOF
|
||
success "Хук switch-account установлен"
|
||
else
|
||
warn "Файл $SWITCH_HOOK_SRC не найден, пропускаю"
|
||
fi
|
||
|
||
# ── 6.7.2. Хук add-account ──────────────────────────────────────
|
||
info "Деплою хук add-account..."
|
||
ADD_HOOK_SRC="$SCRIPT_DIR/home-configs/claude/hooks/add-account-hook.sh"
|
||
ADD_HOOK_DST="$HOME/.claude/hooks/add-account-hook.sh"
|
||
mkdir -p "$HOME/.claude/hooks"
|
||
if [ -f "$ADD_HOOK_SRC" ]; then
|
||
cp "$ADD_HOOK_SRC" "$ADD_HOOK_DST"
|
||
chmod +x "$ADD_HOOK_DST"
|
||
# Прописываем хук в settings.json (идемпотентно)
|
||
python3 - "$HOME/.claude/settings.json" "$ADD_HOOK_DST" <<'PYEOF'
|
||
import sys, json, os
|
||
settings_path, hook_path = sys.argv[1], sys.argv[2]
|
||
data = {}
|
||
if os.path.exists(settings_path):
|
||
with open(settings_path) as f:
|
||
try: data = json.load(f)
|
||
except json.JSONDecodeError: pass
|
||
data.setdefault("hooks", {}).setdefault("UserPromptSubmit", [{"hooks": []}])
|
||
hook_cmd = f'bash "{hook_path}"'
|
||
ups = data["hooks"]["UserPromptSubmit"]
|
||
already = any(
|
||
any(h.get("command", "") == hook_cmd for h in entry.get("hooks", []))
|
||
for entry in ups
|
||
)
|
||
if not already:
|
||
ups[0]["hooks"].append({"type": "command", "command": hook_cmd})
|
||
with open(settings_path, "w") as f:
|
||
json.dump(data, f, indent=2, ensure_ascii=False)
|
||
f.write("\n")
|
||
PYEOF
|
||
success "Хук add-account установлен"
|
||
else
|
||
warn "Файл $ADD_HOOK_SRC не найден, пропускаю"
|
||
fi
|
||
|
||
# ── 6.8. Регистрация официального маркетплейса плагинов Claude ──
|
||
info "Настраиваю маркетплейс плагинов Claude Code..."
|
||
if ! command -v claude &>/dev/null; then
|
||
warn "claude не найден, пропускаю настройку маркетплейса"
|
||
else
|
||
existing=$(claude plugin marketplace list 2>/dev/null | grep "claude-plugins-official" || true)
|
||
if [ -n "$existing" ]; then
|
||
success "Маркетплейс claude-plugins-official уже добавлен"
|
||
else
|
||
# Берём токен только из env; в неинтерактивном режиме не спрашиваем
|
||
if [ -z "$GITHUB_TOKEN" ]; then
|
||
warn "GITHUB_TOKEN не задан, пропускаю настройку маркетплейса плагинов"
|
||
warn "Позже запустите: claude plugin marketplace add https://TOKEN@github.com/anthropics/claude-plugins-official.git"
|
||
else
|
||
if claude plugin marketplace add "https://${GITHUB_TOKEN}@github.com/anthropics/claude-plugins-official.git" 2>&1; then
|
||
success "Маркетплейс claude-plugins-official добавлен"
|
||
else
|
||
warn "Не удалось добавить маркетплейс, проверьте токен"
|
||
fi
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
# ── 6.9. Установка Claude Notifier ──────────────────────────
|
||
info "Устанавливаю Claude Notifier..."
|
||
if [ -f "$HOME/.claude/hooks/claude-notifier-on-stop.js" ]; then
|
||
success "Claude Notifier уже установлен"
|
||
else
|
||
if curl -fsSL https://raw.githubusercontent.com/ashmitb95/claude-notifier/main/install.sh | bash; then
|
||
success "Claude Notifier установлен"
|
||
else
|
||
warn "Не удалось установить Claude Notifier"
|
||
fi
|
||
fi
|
||
|
||
# ── 7. Очистка старых функций из .bashrc / .zshrc ───────────
|
||
clean_rc() {
|
||
local rc_file="$1"
|
||
if [ -f "$rc_file" ] && grep -q "# === CLAUDE LAUNCHER ===" "$rc_file"; then
|
||
info "Очищаю старые функции из $rc_file..."
|
||
python3 - "$rc_file" <<'PYEOF'
|
||
import sys
|
||
path = sys.argv[1]
|
||
with open(path, 'r') as f:
|
||
content = f.read()
|
||
marker = '# === CLAUDE LAUNCHER ==='
|
||
end_marker = '# === END CLAUDE LAUNCHER ==='
|
||
start = content.find(marker)
|
||
end = content.find(end_marker)
|
||
if start != -1 and end != -1:
|
||
new_content = content[:start] + content[end + len(end_marker):].lstrip('\n')
|
||
with open(path, 'w') as f:
|
||
f.write(new_content)
|
||
PYEOF
|
||
success "Старые функции удалены из $rc_file"
|
||
fi
|
||
}
|
||
clean_rc "$HOME/.bashrc"
|
||
clean_rc "$HOME/.zshrc"
|
||
|
||
add_path_to_rc() {
|
||
local rc_file="$1"
|
||
local bin_rel="${BIN_DIR#$HOME/}"
|
||
if [ -f "$rc_file" ]; then
|
||
if ! grep -q 'NPM_GLOBAL' "$rc_file" 2>/dev/null; then
|
||
cat >> "$rc_file" << PATHEOF
|
||
|
||
# Claude Code Launcher PATH
|
||
export NPM_GLOBAL="\$HOME/.npm-global"
|
||
export PATH="\$NPM_GLOBAL/bin:\$HOME/${bin_rel}:\$PATH"
|
||
PATHEOF
|
||
success "PATH добавлен в $rc_file"
|
||
fi
|
||
fi
|
||
}
|
||
add_path_to_rc "$HOME/.bashrc"
|
||
# На macOS дефолтный шелл — zsh, но ~/.zshrc может не существовать.
|
||
# Гарантируем наличие файла, иначе PATH не добавится и лаунчеры будут
|
||
# недоступны без ручного `exec`.
|
||
[ -f "$HOME/.zshrc" ] || touch "$HOME/.zshrc"
|
||
add_path_to_rc "$HOME/.zshrc"
|
||
|
||
|
||
# ── 8. Генерация Standalone скриптов ────────────────────────
|
||
info "Генерирую standalone скрипты в $BIN_DIR..."
|
||
|
||
HELPERS_FILE="$BIN_DIR/ai-api-helpers.sh"
|
||
cat > "$HELPERS_FILE" << 'HELPEREOF'
|
||
#!/usr/bin/env bash
|
||
|
||
export TZ="Europe/Helsinki"
|
||
|
||
# _claude_test_api: Send 1-token test to an Anthropic-compatible endpoint
|
||
_claude_test_api() {
|
||
local url="$1" auth_header="$2" model="${3:-claude-sonnet-4-6}"
|
||
local response
|
||
response=$(curl -s -w "\n%{http_code}" --max-time 15 "$url" \
|
||
-H "$auth_header" \
|
||
-H "Content-Type: application/json" \
|
||
-H "anthropic-version: 2023-06-01" \
|
||
-d "{\"model\":\"$model\",\"max_tokens\":1,\"messages\":[{\"role\":\"user\",\"content\":\"hi\"}]}" \
|
||
2>/dev/null || echo "000")
|
||
_CLAUDE_TEST_CODE=$(echo "$response" | tail -1)
|
||
_CLAUDE_TEST_BODY=$(echo "$response" | sed '$d')
|
||
}
|
||
|
||
# _claude_test_openai_api: Send a tiny test to an OpenAI-compatible endpoint
|
||
_claude_test_openai_api() {
|
||
local url="$1" api_key="$2" model="${3:-kimi-k2.6}"
|
||
local response
|
||
response=$(curl -s -w "\n%{http_code}" --max-time 30 "$url" \
|
||
-H "Authorization: Bearer $api_key" \
|
||
-H "Content-Type: application/json" \
|
||
-d "{\"model\":\"$model\",\"max_tokens\":1,\"messages\":[{\"role\":\"user\",\"content\":\"hi\"}]}" \
|
||
2>/dev/null || echo "000")
|
||
_CLAUDE_TEST_CODE=$(echo "$response" | tail -1)
|
||
_CLAUDE_TEST_BODY=$(echo "$response" | sed '$d')
|
||
}
|
||
|
||
# _deepseek_balance: Query DeepSeek balance API and print info
|
||
_deepseek_balance() {
|
||
local api_key="$1"
|
||
local response
|
||
response=$(curl -s --max-time 10 "https://api.deepseek.com/user/balance" \
|
||
-H "Authorization: Bearer $api_key" \
|
||
-H "Accept: application/json" \
|
||
2>/dev/null || echo "")
|
||
if [ -z "$response" ]; then
|
||
echo -e " \033[0;33m[БАЛАНС]\033[0m Не удалось получить баланс (сеть?)"
|
||
return 1
|
||
fi
|
||
echo "$response" | python3 -c "
|
||
import sys, json, os
|
||
try:
|
||
d = json.load(sys.stdin)
|
||
available = d.get('is_available', False)
|
||
infos = d.get('balance_infos', [])
|
||
if not infos:
|
||
print(' \033[0;33m[БАЛАНС]\033[0m Нет данных о балансе')
|
||
sys.exit(0)
|
||
symbols = {'USD': '\$', 'CNY': '¥'}
|
||
cache_parts = []
|
||
for info in infos:
|
||
curr = info.get('currency', '???')
|
||
total = info.get('total_balance', '0')
|
||
granted = info.get('granted_balance', '0')
|
||
topped_up = info.get('topped_up_balance', '0')
|
||
sym = symbols.get(curr, curr)
|
||
status = '✅ доступен' if available else '❌ не активен'
|
||
print(f' \033[1;36m💰 Баланс DeepSeek:\033[0m {total} {curr} {status}')
|
||
if float(granted) > 0:
|
||
print(f' └─ Начислено: {granted} {curr}')
|
||
if float(topped_up) > 0:
|
||
print(f' └─ Пополнено: {topped_up} {curr}')
|
||
cache_parts.append(f'{sym}{total}')
|
||
# Cache all currencies with symbols for statusline
|
||
if cache_parts:
|
||
cache_dir = os.path.expanduser('~/.cache/ai-setup')
|
||
os.makedirs(cache_dir, exist_ok=True)
|
||
with open(os.path.join(cache_dir, 'deepseek_balance'), 'w') as f:
|
||
f.write(' '.join(cache_parts) + '\n')
|
||
except Exception as e:
|
||
print(f' ⚠️ Не удалось разобрать баланс: {e}')
|
||
" 2>/dev/null || echo -e " \033[0;33m[БАЛАНС]\033[0m Ошибка парсинга ответа"
|
||
}
|
||
|
||
# _openrouter_balance: Query OpenRouter credits API and print balance
|
||
# Uses /api/v1/credits (works with regular API key too)
|
||
_openrouter_balance() {
|
||
local api_key="$1"
|
||
local response
|
||
response=$(curl -s --max-time 10 "https://openrouter.ai/api/v1/credits" \
|
||
-H "Authorization: Bearer $api_key" \
|
||
-H "Accept: application/json" \
|
||
2>/dev/null || echo "")
|
||
if [ -z "$response" ]; then
|
||
echo -e " \033[0;33m[БАЛАНС]\033[0m Не удалось получить баланс (сеть?)"
|
||
return 1
|
||
fi
|
||
echo "$response" | python3 -c "
|
||
import sys, json, os
|
||
try:
|
||
d = json.load(sys.stdin)
|
||
data = d.get('data', {})
|
||
total = data.get('total_credits', 0) or 0
|
||
usage = data.get('total_usage', 0) or 0
|
||
remaining = total - usage
|
||
cache_dir = os.path.expanduser('~/.cache/ai-setup')
|
||
os.makedirs(cache_dir, exist_ok=True)
|
||
cache_file = os.path.join(cache_dir, 'openrouter_balance')
|
||
# Зелёный как у DeepSeek: \033[38;5;78m
|
||
print(f' \033[1;36m💰 Баланс OpenRouter:\033[0m \033[38;5;78m\${remaining:.2f}\033[0m (загружено \${total:.2f}, потрачено \${usage:.2f})')
|
||
with open(cache_file, 'w') as f:
|
||
f.write(f'\${remaining:.2f}\n')
|
||
except Exception as e:
|
||
print(f' ⚠️ Не удалось разобрать баланс: {e}')
|
||
" 2>/dev/null || echo -e " \033[0;33m[БАЛАНС]\033[0m Ошибка парсинга ответа"
|
||
}
|
||
|
||
_handle_openai_api_response() {
|
||
local provider="$1"
|
||
local code="$2"
|
||
local body="$3"
|
||
local topup_url="$4"
|
||
|
||
# Используем глобальную переменную _API_RET вместо return,
|
||
# потому что bash return умеет только 0-255, а HTTP-коды
|
||
# вроде 401/429 обрезаются (401 % 256 = 145).
|
||
_API_RET=0
|
||
|
||
local _emsg
|
||
case "$code" in
|
||
200)
|
||
echo -e "\033[0;32mOK\033[0m"
|
||
_API_RET=0
|
||
;;
|
||
401|403)
|
||
_emsg=$(_claude_extract_error "$body")
|
||
echo ""
|
||
echo -e "\033[0;31m[ОШИБКА АВТОРИЗАЦИИ]\033[0m Авторизация $provider недействительна (HTTP $code)."
|
||
[ -n "$_emsg" ] && echo " $_emsg"
|
||
_API_RET=401
|
||
;;
|
||
429)
|
||
_emsg=$(_claude_extract_error "$body")
|
||
echo ""
|
||
echo -e "\033[0;33m[ЛИМИТ ИСЧЕРПАН]\033[0m Баланс/лимит $provider исчерпан."
|
||
[ -n "$_emsg" ] && echo " $_emsg"
|
||
[ -n "$topup_url" ] && echo " $topup_url"
|
||
_API_RET=429
|
||
;;
|
||
000)
|
||
echo ""
|
||
echo -e "\033[0;33m[СЕТЬ]\033[0m Не удалось проверить ключ (нет сети?). Продолжаю..."
|
||
_API_RET=0
|
||
;;
|
||
5[0-9][0-9])
|
||
echo ""
|
||
echo -e "\033[0;33m[СЕРВЕР]\033[0m $provider временно недоступен (HTTP $code). Продолжаю..."
|
||
_API_RET=0
|
||
;;
|
||
*)
|
||
_emsg=$(_claude_extract_error "$body")
|
||
echo ""
|
||
echo -e "\033[0;31m[ОШИБКА]\033[0m API $provider вернул HTTP $code."
|
||
[ -n "$_emsg" ] && echo " $_emsg"
|
||
_API_RET=$code
|
||
;;
|
||
esac
|
||
return 0
|
||
}
|
||
|
||
_claude_extract_error() {
|
||
local body="$1"
|
||
echo "$body" | python3 -c "
|
||
import sys, json
|
||
try:
|
||
d = json.load(sys.stdin)
|
||
e = d.get('error', {})
|
||
if isinstance(e, str):
|
||
print(e)
|
||
else:
|
||
msg = e.get('message', '')
|
||
if msg:
|
||
print(msg)
|
||
except:
|
||
pass
|
||
" 2>/dev/null
|
||
}
|
||
|
||
_claude_offer_reauth() {
|
||
local provider="$1"
|
||
echo ""
|
||
echo -n "Хотите выполнить повторную авторизацию $provider? [Y/n] "
|
||
local answer
|
||
read -r answer
|
||
case "${answer:-Y}" in
|
||
[Yy]|[Yy][Ee][Ss]) return 0 ;;
|
||
*) echo "Отменено."; return 1 ;;
|
||
esac
|
||
}
|
||
|
||
_handle_api_response() {
|
||
local provider="$1"
|
||
local code="$2"
|
||
local body="$3"
|
||
local topup_url="$4"
|
||
|
||
# Используем глобальную переменную _API_RET вместо return,
|
||
# потому что bash return умеет только 0-255, а HTTP-коды
|
||
# вроде 401/429 обрезаются (401 % 256 = 145).
|
||
_API_RET=0
|
||
|
||
local _emsg
|
||
case "$code" in
|
||
200)
|
||
echo -e "\033[0;32mOK\033[0m"
|
||
_API_RET=0
|
||
;;
|
||
401|403)
|
||
_emsg=$(_claude_extract_error "$body")
|
||
echo ""
|
||
echo -e "\033[0;31m[ОШИБКА АВТОРИЗАЦИИ]\033[0m Авторизация $provider недействительна (HTTP $code)."
|
||
[ -n "$_emsg" ] && echo " $_emsg"
|
||
_API_RET=401
|
||
;;
|
||
429)
|
||
_emsg=$(_claude_extract_error "$body")
|
||
echo ""
|
||
echo -e "\033[0;33m[ЛИМИТ ИСЧЕРПАН]\033[0m Баланс/лимит $provider исчерпан."
|
||
[ -n "$_emsg" ] && echo " $_emsg"
|
||
[ -n "$topup_url" ] && echo " $topup_url"
|
||
_API_RET=429
|
||
;;
|
||
000)
|
||
echo ""
|
||
echo -e "\033[0;33m[СЕТЬ]\033[0m Не удалось проверить ключ (нет сети?). Продолжаю..."
|
||
_API_RET=0
|
||
;;
|
||
5[0-9][0-9])
|
||
echo ""
|
||
echo -e "\033[0;33m[СЕРВЕР]\033[0m $provider временно недоступен (HTTP $code). Продолжаю..."
|
||
_API_RET=0
|
||
;;
|
||
400)
|
||
_emsg=$(_claude_extract_error "$body")
|
||
if echo "${_emsg:-$body}" | grep -qi "RESOURCE_EXHAUSTED"; then
|
||
echo ""
|
||
echo -e "\033[0;33m[КВОТА ИСЧЕРПАНА]\033[0m Лимит запросов исчерпан."
|
||
[ -n "$topup_url" ] && echo " $topup_url"
|
||
_API_RET=429
|
||
else
|
||
# 400 = auth is valid, but max_tokens=1 is too small for thinking models
|
||
echo -e "\033[0;32mOK\033[0m"
|
||
_API_RET=0
|
||
fi
|
||
;;
|
||
*)
|
||
_emsg=$(_claude_extract_error "$body")
|
||
echo ""
|
||
echo -e "\033[0;31m[ОШИБКА]\033[0m API $provider вернул HTTP $code."
|
||
[ -n "$_emsg" ] && echo " $_emsg"
|
||
_API_RET=$code
|
||
;;
|
||
esac
|
||
return 0
|
||
}
|
||
|
||
# _kimi_account_info: пытается получить email или имя аккаунта Kimi по API ключу.
|
||
# Сохраняет найденное значение в stdout. Если не удалось — exit 1.
|
||
_kimi_account_info() {
|
||
local api_key="$1"
|
||
local resp email name
|
||
# Пробуем несколько возможных endpoint'ов Moonshot/Kimi Code API.
|
||
for url in "https://api.kimi.com/coding/v1/account" "https://api.kimi.com/coding/v1/users/me"; do
|
||
resp=$(curl -s --max-time 10 "$url" \
|
||
-H "x-api-key: $api_key" \
|
||
-H "Accept: application/json" \
|
||
2>/dev/null || echo "")
|
||
[ -z "$resp" ] && continue
|
||
email=$(echo "$resp" | jq -r '.email // .data.email // .account.email // empty' 2>/dev/null)
|
||
name=$(echo "$resp" | jq -r '.name // .data.name // .account.name // empty' 2>/dev/null)
|
||
if [ -n "$email" ]; then
|
||
echo "$email"
|
||
return 0
|
||
fi
|
||
if [ -n "$name" ]; then
|
||
echo "$name"
|
||
return 0
|
||
fi
|
||
done
|
||
return 1
|
||
}
|
||
|
||
_open_browser() {
|
||
local url="$1"
|
||
if command -v xdg-open &>/dev/null; then xdg-open "$url" 2>/dev/null
|
||
elif command -v open &>/dev/null; then open "$url" 2>/dev/null
|
||
elif command -v sensible-browser &>/dev/null; then sensible-browser "$url" 2>/dev/null
|
||
else echo "Откройте вручную: $url"; fi
|
||
}
|
||
|
||
# _setup_isolated_config: готовит изолированную папку CLAUDE_CONFIG_DIR для лаунчера.
|
||
# Каждый сторонний провайдер получает собственные settings.json и .claude.json,
|
||
# поэтому выбор модели и кэш кастом-моделей НЕ протекают между ai-* лаунчерами.
|
||
# Общие ресурсы (skills, CLAUDE.md) шарятся симлинком из ~/.claude.
|
||
# model и effortLevel сидируются как дефолты - выбор юзера через /model и /effort
|
||
# сохраняется нативно в этом же settings.json (включая max через AI_EFFORT).
|
||
# Использование: _setup_isolated_config <launcher> <default_model> <default_effort> <available_models_json>
|
||
_setup_isolated_config() {
|
||
local launcher="$1" default_model="$2" default_effort="${3:-high}" avail="${4:-}"
|
||
local cfg="$HOME/.config/ai-setup/cfg/$launcher"
|
||
mkdir -p "$cfg"
|
||
# Общие ресурсы из ~/.claude (единый источник правды)
|
||
ln -sfn "$HOME/.claude/skills" "$cfg/skills"
|
||
ln -sfn "$HOME/.claude/CLAUDE.md" "$cfg/CLAUDE.md"
|
||
[ -e "$HOME/.claude/agents" ] && ln -sfn "$HOME/.claude/agents" "$cfg/agents"
|
||
# .claude.json в свежей папке: пропускаем онбординг
|
||
[ -f "$cfg/.claude.json" ] || echo '{"hasCompletedOnboarding": true}' > "$cfg/.claude.json"
|
||
python3 - "$cfg/settings.json" "$HOME/.claude/statusline-command.sh" \
|
||
"$default_model" "$default_effort" "$avail" <<'PYEOF'
|
||
import sys, json, os
|
||
cfg_settings, statusline, model, effort, avail = sys.argv[1:6]
|
||
data = {}
|
||
if os.path.exists(cfg_settings):
|
||
try:
|
||
with open(cfg_settings) as f:
|
||
data = json.load(f)
|
||
except Exception:
|
||
pass
|
||
# Структурные настройки лаунчера (переустанавливаем всегда)
|
||
data["statusLine"] = {"type": "command", "command": f"bash {statusline}"}
|
||
data["skipDangerousModePermissionPrompt"] = True
|
||
data.setdefault("hooks", {})["SessionStart"] = [{"hooks": [{"type": "command", "command": "true"}]}]
|
||
# availableModels - белый список пикера (политика лаунчера)
|
||
if avail:
|
||
data["availableModels"] = json.loads(avail)
|
||
else:
|
||
data.pop("availableModels", None)
|
||
# model/effortLevel - сидируем дефолты, не перетирая выбор юзера (нативный persistence)
|
||
if model:
|
||
data.setdefault("model", model)
|
||
data.setdefault("effortLevel", effort)
|
||
with open(cfg_settings, "w") as f:
|
||
json.dump(data, f, indent=2, ensure_ascii=False)
|
||
f.write("\n")
|
||
PYEOF
|
||
|
||
# Деплой shared хуков аккаунтов в изолированный config dir.
|
||
# ai-claude использует ~/.claude/hooks напрямую; остальные лаунчеры получают
|
||
# свою копию, чтобы /switch-account и /add-account работали изолированно.
|
||
mkdir -p "$cfg/hooks"
|
||
for hook in switch-account-hook.sh add-account-hook.sh account-email.sh; do
|
||
if [ -f "$HOME/.claude/hooks/$hook" ]; then
|
||
cp "$HOME/.claude/hooks/$hook" "$cfg/hooks/$hook"
|
||
chmod +x "$cfg/hooks/$hook"
|
||
fi
|
||
done
|
||
# Регистрируем UserPromptSubmit хуки в изолированном settings.json
|
||
python3 - "$cfg/settings.json" "$cfg/hooks/switch-account-hook.sh" "$cfg/hooks/add-account-hook.sh" <<'PYEOF'
|
||
import sys, json, os
|
||
settings_path, switch_hook, add_hook = sys.argv[1:4]
|
||
data = {}
|
||
if os.path.exists(settings_path):
|
||
try:
|
||
with open(settings_path) as f:
|
||
data = json.load(f)
|
||
except Exception:
|
||
pass
|
||
data.setdefault("hooks", {}).setdefault("UserPromptSubmit", [{"hooks": []}])
|
||
ups = data["hooks"]["UserPromptSubmit"]
|
||
for hook_path in (switch_hook, add_hook):
|
||
hook_cmd = f'bash "{hook_path}"'
|
||
already = any(
|
||
any(h.get("command", "") == hook_cmd for h in entry.get("hooks", []))
|
||
for entry in ups
|
||
)
|
||
if not already:
|
||
ups[0]["hooks"].append({"type": "command", "command": hook_cmd})
|
||
with open(settings_path, "w") as f:
|
||
json.dump(data, f, indent=2, ensure_ascii=False)
|
||
f.write("\n")
|
||
PYEOF
|
||
|
||
# Звук по завершении задачи: используем Claude Notifier из ~/.claude/hooks,
|
||
# либо минимальный fallback, если Notifier не установился.
|
||
if [ -f "$HOME/.claude/hooks/claude-notifier-on-stop.js" ]; then
|
||
stop_hook_cmd="node \"$HOME/.claude/hooks/claude-notifier-on-stop.js\""
|
||
else
|
||
cat > "$cfg/hooks/sound-on-stop.sh" <<'SOUNDEOF'
|
||
#!/usr/bin/env bash
|
||
# Minimal task-completion sound fallback
|
||
(
|
||
afplay /System/Library/Sounds/Glass.aiff 2>/dev/null ||
|
||
paplay /usr/share/sounds/freedesktop/stereo/complete.oga 2>/dev/null ||
|
||
pw-play --volume=1 /usr/share/sounds/freedesktop/stereo/complete.oga 2>/dev/null ||
|
||
aplay /usr/share/sounds/freedesktop/stereo/complete.oga 2>/dev/null
|
||
) &
|
||
SOUNDEOF
|
||
chmod +x "$cfg/hooks/sound-on-stop.sh"
|
||
stop_hook_cmd="bash \"$cfg/hooks/sound-on-stop.sh\""
|
||
fi
|
||
python3 - "$cfg/settings.json" "$stop_hook_cmd" <<'PYEOF'
|
||
import sys, json, os
|
||
settings_path, hook_cmd = sys.argv[1:3]
|
||
data = {}
|
||
if os.path.exists(settings_path):
|
||
try:
|
||
with open(settings_path) as f:
|
||
data = json.load(f)
|
||
except Exception:
|
||
pass
|
||
data.setdefault("hooks", {}).setdefault("Stop", [{"hooks": []}])
|
||
stop_entries = data["hooks"]["Stop"]
|
||
already = any(
|
||
any(h.get("command", "") == hook_cmd for h in entry.get("hooks", []))
|
||
for entry in stop_entries
|
||
)
|
||
if not already:
|
||
stop_entries[0]["hooks"].append({"type": "command", "command": hook_cmd})
|
||
with open(settings_path, "w") as f:
|
||
json.dump(data, f, indent=2, ensure_ascii=False)
|
||
f.write("\n")
|
||
PYEOF
|
||
}
|
||
|
||
# _apply_effort: per-launcher persistence уровня effort.
|
||
# Все уровни (включая max) пишутся в settings.json лаунчера через AI_EFFORT.
|
||
# Без AI_EFFORT - effortLevel персистнут нативно в settings.json (Claude Code его читает).
|
||
# CLAUDE_CODE_EFFORT_LEVEL не используем - он блокирует /effort внутри сессии.
|
||
# Использование: _apply_effort <launcher> <default_effort>
|
||
_apply_effort() {
|
||
local launcher="$1" default_effort="${2:-high}"
|
||
local settings="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/settings.json"
|
||
if [ -n "${AI_EFFORT:-}" ]; then
|
||
python3 - "$settings" "$AI_EFFORT" <<'PYEOF'
|
||
import sys, json, os
|
||
p, eff = sys.argv[1], sys.argv[2]
|
||
d = {}
|
||
if os.path.exists(p):
|
||
try: d = json.load(open(p))
|
||
except Exception: pass
|
||
d["effortLevel"] = eff
|
||
os.makedirs(os.path.dirname(p), exist_ok=True)
|
||
with open(p, "w") as fp:
|
||
json.dump(d, fp, indent=2, ensure_ascii=False); fp.write("\n")
|
||
PYEOF
|
||
fi
|
||
# Без AI_EFFORT: effortLevel уже персистнут в settings.json - ничего не делаем.
|
||
}
|
||
|
||
_build_ai_sys_prompt() {
|
||
local global_rules="$HOME/.config/ai-setup/global_rules.md"
|
||
local global_rendered=""
|
||
[ -f "$global_rules" ] && global_rendered="$(cat "$global_rules" 2>/dev/null)"
|
||
|
||
# Нативные глобальные правила: только global_rules.md, без проектного контекста.
|
||
# Проектные *.md файлы агент должен читать из текущего репозитория сам, если умеет.
|
||
# Для агентов без надежного нативного чтения проектный контекст добавляется ниже в prompt.
|
||
# Cursor использует ~/.cursorrules как глобальные пользовательские правила.
|
||
mkdir -p "$HOME/.codex" "$HOME/.kimi-code" "$HOME/.claude" "$HOME/.gemini"
|
||
echo "$global_rendered" > "$HOME/.codex/AGENTS.md"
|
||
echo "$global_rendered" > "$HOME/.kimi-code/AGENTS.md"
|
||
echo "$global_rendered" > "$HOME/.claude/CLAUDE.md"
|
||
echo "$global_rendered" > "$HOME/.gemini/GEMINI.md"
|
||
echo "$global_rendered" > "$HOME/.cursorrules"
|
||
|
||
local sp="=== ГЛОБАЛЬНЫЕ ПРАВИЛА ===\n"
|
||
[ -n "$global_rendered" ] && sp+="$global_rendered\n\n"
|
||
sp+="=== ПРАВИЛА ПРОЕКТА ===\n"
|
||
for f in *.md; do
|
||
[ -f "$f" ] && sp+="\n--- Файл $f ---\n$(cat "$f")\n"
|
||
done
|
||
echo -e "$sp"
|
||
}
|
||
|
||
_setup_codex_sound_hooks() {
|
||
local hooks_dir="$HOME/.codex/hooks"
|
||
local hooks_json="$HOME/.codex/hooks.json"
|
||
mkdir -p "$hooks_dir"
|
||
|
||
cat > "$hooks_dir/ai-setup-sound-on-stop.sh" <<'SOUNDEOF'
|
||
#!/usr/bin/env bash
|
||
# Minimal Codex turn-completion sound.
|
||
(
|
||
afplay /System/Library/Sounds/Glass.aiff 2>/dev/null ||
|
||
paplay /usr/share/sounds/freedesktop/stereo/complete.oga 2>/dev/null ||
|
||
pw-play --volume=1 /usr/share/sounds/freedesktop/stereo/complete.oga 2>/dev/null ||
|
||
aplay /usr/share/sounds/freedesktop/stereo/complete.oga 2>/dev/null
|
||
) &
|
||
SOUNDEOF
|
||
|
||
cat > "$hooks_dir/ai-setup-sound-on-auto-compact.sh" <<'SOUNDEOF'
|
||
#!/usr/bin/env bash
|
||
# Minimal Codex context auto-compact warning sound.
|
||
(
|
||
afplay /System/Library/Sounds/Basso.aiff 2>/dev/null ||
|
||
paplay /usr/share/sounds/freedesktop/stereo/alarm-clock-elapsed.oga 2>/dev/null ||
|
||
pw-play --volume=1 /usr/share/sounds/freedesktop/stereo/alarm-clock-elapsed.oga 2>/dev/null ||
|
||
aplay /usr/share/sounds/freedesktop/stereo/alarm-clock-elapsed.oga 2>/dev/null
|
||
) &
|
||
SOUNDEOF
|
||
chmod +x "$hooks_dir/ai-setup-sound-on-stop.sh" "$hooks_dir/ai-setup-sound-on-auto-compact.sh"
|
||
|
||
python3 - "$hooks_json" <<'PYEOF'
|
||
import json
|
||
import os
|
||
import sys
|
||
|
||
path = sys.argv[1]
|
||
data = {}
|
||
if os.path.exists(path):
|
||
try:
|
||
with open(path) as f:
|
||
data = json.load(f)
|
||
except Exception:
|
||
print(f"WARNING: {path} is not valid JSON; Codex sound hooks were not installed", file=sys.stderr)
|
||
sys.exit(0)
|
||
if not isinstance(data, dict):
|
||
print(f"WARNING: {path} does not contain a JSON object; Codex sound hooks were not installed", file=sys.stderr)
|
||
sys.exit(0)
|
||
|
||
hooks = data.setdefault("hooks", {})
|
||
if not isinstance(hooks, dict):
|
||
print(f"WARNING: {path}.hooks is not a JSON object; Codex sound hooks were not installed", file=sys.stderr)
|
||
sys.exit(0)
|
||
|
||
def ensure_hook(event, command, matcher=None):
|
||
groups = hooks.setdefault(event, [])
|
||
for group in groups:
|
||
if matcher is not None and group.get("matcher") != matcher:
|
||
continue
|
||
if any(h.get("command") == command for h in group.get("hooks", [])):
|
||
return
|
||
target = None
|
||
for group in groups:
|
||
if matcher is None or group.get("matcher") == matcher:
|
||
target = group
|
||
break
|
||
if target is None:
|
||
target = {"hooks": []}
|
||
if matcher is not None:
|
||
target["matcher"] = matcher
|
||
groups.append(target)
|
||
target.setdefault("hooks", []).append({
|
||
"type": "command",
|
||
"command": command,
|
||
"timeout": 5,
|
||
})
|
||
|
||
ensure_hook("Stop", 'bash "$HOME/.codex/hooks/ai-setup-sound-on-stop.sh"')
|
||
ensure_hook("PreCompact", 'bash "$HOME/.codex/hooks/ai-setup-sound-on-auto-compact.sh"', "auto")
|
||
|
||
os.makedirs(os.path.dirname(path), exist_ok=True)
|
||
with open(path, "w") as f:
|
||
json.dump(data, f, indent=2, ensure_ascii=False)
|
||
f.write("\n")
|
||
PYEOF
|
||
}
|
||
HELPEREOF
|
||
chmod +x "$HELPERS_FILE"
|
||
source "$HELPERS_FILE"
|
||
_setup_codex_sound_hooks || warn "Не удалось установить Codex sound hooks"
|
||
|
||
# === ai-gpt ===
|
||
cat > "$BIN_DIR/ai-gpt" << 'GPTEOF'
|
||
#!/usr/bin/env bash
|
||
# ai-gpt - запуск нативного OpenAI Codex
|
||
source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/ai-api-helpers.sh" 2>/dev/null || true
|
||
|
||
codex_bin="$HOME/.npm-global/bin/codex"
|
||
[ ! -f "$codex_bin" ] && codex_bin="$(command -v codex 2>/dev/null)"
|
||
|
||
if [ -z "$codex_bin" ] || [ ! -f "$codex_bin" ]; then
|
||
echo "OpenAI Codex не найден. Устанавливаю..."
|
||
curl -fsSL https://chatgpt.com/codex/install.sh | sh
|
||
codex_bin="$HOME/.npm-global/bin/codex"
|
||
[ ! -f "$codex_bin" ] && codex_bin="$(command -v codex 2>/dev/null)"
|
||
# Fallback: если curl-установка не сработала (например, 403 от Cloudflare), ставим через npm
|
||
if [ -z "$codex_bin" ] || [ ! -f "$codex_bin" ]; then
|
||
echo "Установка через curl не удалась, пробую npm..."
|
||
npm install -g @openai/codex
|
||
codex_bin="$HOME/.npm-global/bin/codex"
|
||
[ ! -f "$codex_bin" ] && codex_bin="$(command -v codex 2>/dev/null)"
|
||
fi
|
||
fi
|
||
|
||
if [ -z "$codex_bin" ] || [ ! -f "$codex_bin" ]; then
|
||
echo "Ошибка: не удалось установить OpenAI Codex."
|
||
exit 1
|
||
fi
|
||
|
||
_build_ai_sys_prompt > /dev/null # сохраняет в ~/.codex/AGENTS.md (codex читает авто)
|
||
_setup_codex_sound_hooks
|
||
exec "$codex_bin" --dangerously-bypass-approvals-and-sandbox "$@"
|
||
GPTEOF
|
||
chmod +x "$BIN_DIR/ai-gpt"
|
||
|
||
|
||
# === ai-deepseek ===
|
||
cat > "$BIN_DIR/ai-deepseek" << 'DEEPSEEKEOF'
|
||
#!/usr/bin/env bash
|
||
source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/ai-api-helpers.sh" 2>/dev/null || true
|
||
|
||
key_file="$HOME/.config/ai-setup/deepseek_key"
|
||
api_key=""
|
||
reauth=0
|
||
|
||
# Принудительный сброс сохранённого ключа через AI_RESET_KEY=1
|
||
if [ "${AI_RESET_KEY:-0}" == "1" ] && [ -f "$key_file" ]; then
|
||
rm -f "$key_file"
|
||
api_key=""
|
||
fi
|
||
|
||
[ -f "$key_file" ] && api_key=$(cat "$key_file")
|
||
|
||
if [ -n "$api_key" ]; then
|
||
echo -n "Проверка сохранённого DeepSeek ключа... "
|
||
_claude_test_api "https://api.deepseek.com/anthropic/v1/messages" "x-api-key: $api_key" "deepseek-v4-flash"
|
||
_handle_api_response "DeepSeek" "$_CLAUDE_TEST_CODE" "$_CLAUDE_TEST_BODY" "Пополните баланс: https://platform.deepseek.com/top_up"
|
||
ret=$_API_RET
|
||
if [ $ret -eq 401 ]; then
|
||
rm -f "$key_file"
|
||
api_key=""
|
||
reauth=1
|
||
elif [ $ret -eq 429 ]; then
|
||
echo -n "Продолжить всё равно? (запросы могут не проходить) [y/N] "
|
||
read -r _ans
|
||
case "${_ans:-N}" in
|
||
[Yy]*) ;;
|
||
*)
|
||
echo -n "Хотите ввести новый DeepSeek ключ? [Y/n] "
|
||
read -r _ans2
|
||
case "${_ans2:-Y}" in
|
||
[Yy]*)
|
||
rm -f "$key_file"
|
||
api_key=""
|
||
reauth=1
|
||
;;
|
||
*) exit 1 ;;
|
||
esac
|
||
;;
|
||
esac
|
||
elif [ $ret -ne 0 ]; then
|
||
exit 1
|
||
fi
|
||
_deepseek_balance "$api_key"
|
||
fi
|
||
|
||
if [ -z "$api_key" ] && [ "$reauth" -eq 1 ]; then
|
||
echo -n "Хотите ввести новый DeepSeek ключ? [Y/n] "
|
||
read -r _ans; case "${_ans:-Y}" in [Yy]*) ;; *) exit 1 ;; esac
|
||
fi
|
||
|
||
if [ -z "$api_key" ]; then
|
||
echo "Получить ключ: https://platform.deepseek.com/api_keys"
|
||
read -r -p "Введите ваш DeepSeek API ключ: " api_key
|
||
[ -z "$api_key" ] && { echo "Выход."; exit 1; }
|
||
|
||
echo -n "Проверяю ключ и баланс... "
|
||
_claude_test_api "https://api.deepseek.com/anthropic/v1/messages" "x-api-key: $api_key" "deepseek-v4-flash"
|
||
_handle_api_response "DeepSeek" "$_CLAUDE_TEST_CODE" "$_CLAUDE_TEST_BODY" "Пополните баланс: https://platform.deepseek.com/top_up"
|
||
ret=$_API_RET
|
||
if [ $ret -eq 0 ] || [ $ret -eq 429 ]; then
|
||
mkdir -p "$(dirname "$key_file")"
|
||
echo "$api_key" > "$key_file"
|
||
chmod 600 "$key_file"
|
||
echo "Ключ сохранён."
|
||
_deepseek_balance "$api_key"
|
||
if [ $ret -eq 429 ]; then
|
||
echo -n "Продолжить всё равно? (запросы могут не проходить) [y/N] "
|
||
read -r _ans; case "${_ans:-N}" in [Yy]*) ;; *) exit 1 ;; esac
|
||
fi
|
||
else
|
||
echo "Ключ НЕ сохранён."
|
||
exit 1
|
||
fi
|
||
fi
|
||
|
||
_PROMPT_FILE=$(mktemp /tmp/ai-sys-prompt.XXXXXX)
|
||
trap 'rm -f "$_PROMPT_FILE"' EXIT INT TERM
|
||
_build_ai_sys_prompt > "$_PROMPT_FILE"
|
||
export AI_LAUNCHER=deepseek
|
||
export CLAUDE_CONFIG_DIR="$HOME/.config/ai-setup/cfg/deepseek"
|
||
# Пикер: DeepSeek V4 Pro (opus+sonnet, дефолт) и DeepSeek V4 Flash (haiku).
|
||
# availableModels НЕ задаём: при кастомном провайдере он схлопывает пикер в Default.
|
||
# Claude Code навязывает 3 слота opus/sonnet/haiku; незаданный слот показал бы чужой
|
||
# Claude, поэтому sonnet тоже мапим на Pro (лёгкий дубль, но все пункты - DeepSeek).
|
||
# FABLE не навязывается - не задаём. DISABLE_1M убирает [1M] дубли из пикера.
|
||
_setup_isolated_config deepseek opus high ''
|
||
_apply_effort deepseek high
|
||
ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic \
|
||
ANTHROPIC_AUTH_TOKEN="$api_key" \
|
||
ANTHROPIC_DEFAULT_OPUS_MODEL=deepseek-v4-pro \
|
||
ANTHROPIC_DEFAULT_OPUS_MODEL_NAME="DeepSeek V4 Pro" \
|
||
ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION="DeepSeek V4 Pro - флагман для сложных задач" \
|
||
ANTHROPIC_DEFAULT_SONNET_MODEL=deepseek-v4-pro \
|
||
ANTHROPIC_DEFAULT_SONNET_MODEL_NAME="DeepSeek V4 Pro" \
|
||
ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION="DeepSeek V4 Pro - флагман для сложных задач" \
|
||
ANTHROPIC_DEFAULT_HAIKU_MODEL=deepseek-v4-flash \
|
||
ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME="DeepSeek V4 Flash" \
|
||
ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION="DeepSeek V4 Flash - быстрый и дешёвый" \
|
||
CLAUDE_CODE_SUBAGENT_MODEL=deepseek-v4-flash \
|
||
CLAUDE_CODE_DISABLE_1M_CONTEXT=1 \
|
||
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 \
|
||
claude --dangerously-skip-permissions --system-prompt-file "$_PROMPT_FILE" "$@"
|
||
DEEPSEEKEOF
|
||
chmod +x "$BIN_DIR/ai-deepseek"
|
||
|
||
# === ai-kimi ===
|
||
cat > "$BIN_DIR/ai-kimi" << 'KIMIEOF'
|
||
#!/usr/bin/env bash
|
||
# ai-kimi - запуск Claude Code через официальный Kimi Code API
|
||
source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/ai-api-helpers.sh" 2>/dev/null || true
|
||
|
||
keys_dir="$HOME/.config/ai-setup/kimi_keys"
|
||
legacy_key_file="$HOME/.config/ai-setup/kimi_key"
|
||
|
||
# Миграция старого одиночного файла ключа в директорию с ключами.
|
||
if [ -f "$legacy_key_file" ] && [ ! -d "$keys_dir" ]; then
|
||
mkdir -p "$keys_dir"
|
||
cp "$legacy_key_file" "$keys_dir/account1.key"
|
||
chmod 600 "$keys_dir/account1.key"
|
||
echo "account1" > "$keys_dir/current"
|
||
fi
|
||
|
||
mkdir -p "$keys_dir"
|
||
|
||
get_current_alias() {
|
||
local current_file="$keys_dir/current"
|
||
local alias=""
|
||
[ -f "$current_file" ] && alias=$(cat "$current_file")
|
||
if [ -n "$alias" ] && [ ! -f "$keys_dir/${alias}.key" ]; then
|
||
alias=""
|
||
fi
|
||
if [ -z "$alias" ]; then
|
||
alias=$(ls "$keys_dir"/*.key 2>/dev/null | head -1 | xargs -I{} basename {} .key 2>/dev/null || true)
|
||
fi
|
||
echo "$alias"
|
||
}
|
||
|
||
get_key_by_alias() {
|
||
local alias="$1"
|
||
[ -f "$keys_dir/${alias}.key" ] && cat "$keys_dir/${alias}.key" || echo ""
|
||
}
|
||
|
||
set_current_alias() {
|
||
echo "$1" > "$keys_dir/current"
|
||
}
|
||
|
||
save_new_key() {
|
||
local key="$1"
|
||
local alias="$2"
|
||
echo "$key" > "$keys_dir/${alias}.key"
|
||
chmod 600 "$keys_dir/${alias}.key"
|
||
}
|
||
|
||
next_free_alias() {
|
||
local i=1
|
||
while [ -f "$keys_dir/account${i}.key" ]; do
|
||
i=$((i + 1))
|
||
done
|
||
echo "account${i}"
|
||
}
|
||
|
||
# Миграция устаревшего default.key в accountN.key (новая схема именования).
|
||
if [ -f "$keys_dir/default.key" ]; then
|
||
old_default_alias=$(next_free_alias)
|
||
mv "$keys_dir/default.key" "$keys_dir/${old_default_alias}.key"
|
||
[ -f "$keys_dir/default.meta" ] && mv "$keys_dir/default.meta" "$keys_dir/${old_default_alias}.meta"
|
||
current=$(cat "$keys_dir/current" 2>/dev/null || true)
|
||
if [ "$current" = "default" ]; then
|
||
echo "$old_default_alias" > "$keys_dir/current"
|
||
fi
|
||
fi
|
||
|
||
prompt_and_save_key() {
|
||
echo "Получить ключ: https://www.kimi.com/code"
|
||
read -r -p "Введите ваш Kimi API ключ: " api_key
|
||
[ -z "$api_key" ] && { echo "Выход."; return 1; }
|
||
|
||
echo -n "Проверяю ключ и баланс... "
|
||
_claude_test_api "https://api.kimi.com/coding/v1/messages" "x-api-key: $api_key" "kimi-k2.7"
|
||
_handle_api_response "Kimi" "$_CLAUDE_TEST_CODE" "$_CLAUDE_TEST_BODY" "Пополните баланс: https://www.kimi.com/code"
|
||
local ret=$_API_RET
|
||
if [ $ret -eq 0 ] || [ $ret -eq 429 ]; then
|
||
local alias=$(next_free_alias)
|
||
save_new_key "$api_key" "$alias"
|
||
# Пытаемся получить email/имя аккаунта для отображения в статусной строке.
|
||
meta=$(_kimi_account_info "$api_key" 2>/dev/null || true)
|
||
if [ -n "$meta" ]; then
|
||
echo "$meta" > "$keys_dir/${alias}.meta"
|
||
chmod 600 "$keys_dir/${alias}.meta"
|
||
fi
|
||
set_current_alias "$alias"
|
||
echo "Ключ сохранён как: $alias."
|
||
if [ $ret -eq 429 ]; then
|
||
echo -n "Продолжить всё равно? (запросы могут не проходить) [y/N] "
|
||
read -r _ans; case "${_ans:-N}" in [Yy]*) ;; *) return 1 ;; esac
|
||
fi
|
||
return 0
|
||
else
|
||
echo "Ключ НЕ сохранён."
|
||
return 1
|
||
fi
|
||
}
|
||
|
||
validate_current_key() {
|
||
local alias="$1"
|
||
local api_key=$(get_key_by_alias "$alias")
|
||
if [ -z "$api_key" ]; then
|
||
return 1
|
||
fi
|
||
echo -n "Проверка сохранённого Kimi ключа... "
|
||
_claude_test_api "https://api.kimi.com/coding/v1/messages" "x-api-key: $api_key" "kimi-k2.7"
|
||
_handle_api_response "Kimi" "$_CLAUDE_TEST_CODE" "$_CLAUDE_TEST_BODY" "Пополните баланс: https://www.kimi.com/code"
|
||
local ret=$_API_RET
|
||
if [ $ret -eq 401 ]; then
|
||
# Удаляем невалидный ключ.
|
||
rm -f "$keys_dir/${alias}.key" "$keys_dir/${alias}.meta"
|
||
# Если ключей не осталось — сбрасываем current.
|
||
if [ -z "$(ls "$keys_dir"/*.key 2>/dev/null)" ]; then
|
||
rm -f "$keys_dir/current"
|
||
fi
|
||
return 1
|
||
elif [ $ret -eq 429 ]; then
|
||
echo -n "Продолжить всё равно? (запросы могут не проходить) [y/N] "
|
||
read -r _ans; case "${_ans:-N}" in [Yy]*) ;; *) return 2 ;; esac
|
||
elif [ $ret -ne 0 ]; then
|
||
return 2
|
||
fi
|
||
return 0
|
||
}
|
||
|
||
if ! command -v claude &>/dev/null; then
|
||
echo "Ошибка: Claude Code не найден. Установите через npm:"
|
||
echo " npm install -g @anthropic-ai/claude-code"
|
||
exit 1
|
||
fi
|
||
|
||
last_alias=""
|
||
while true; do
|
||
current_alias=$(get_current_alias)
|
||
api_key=$(get_key_by_alias "$current_alias")
|
||
|
||
# Если ключей нет — запросить первый.
|
||
if [ -z "$api_key" ]; then
|
||
prompt_and_save_key || exit 1
|
||
current_alias=$(get_current_alias)
|
||
api_key=$(get_key_by_alias "$current_alias")
|
||
fi
|
||
|
||
# Проверка сохранённого ключа.
|
||
if [ -n "$api_key" ]; then
|
||
validate_current_key "$current_alias"
|
||
ret=$?
|
||
if [ $ret -eq 1 ]; then
|
||
# Невалидный ключ удалён; пересчитаем current и попробуем снова.
|
||
continue
|
||
elif [ $ret -eq 2 ]; then
|
||
exit 1
|
||
fi
|
||
fi
|
||
|
||
_PROMPT_FILE=$(mktemp /tmp/ai-sys-prompt.XXXXXX)
|
||
trap 'rm -f "$_PROMPT_FILE"' EXIT INT TERM
|
||
_build_ai_sys_prompt > "$_PROMPT_FILE"
|
||
|
||
last_alias="$current_alias"
|
||
|
||
export AI_LAUNCHER=kimi
|
||
export CLAUDE_CONFIG_DIR="$HOME/.config/ai-setup/cfg/kimi"
|
||
# Пикер: Opus/Sonnet = Kimi K2.7 Code, Haiku = Kimi K2.6. availableModels НЕ задаём
|
||
# (он схлопывает пикер в Default). Claude Code навязывает 3 слота opus/sonnet/haiku;
|
||
# незаданный показал бы чужой Claude, поэтому opus+sonnet = K2.7, haiku = K2.6
|
||
# DISABLE_1M убирает [1M] дубли из пикера.
|
||
_setup_isolated_config kimi opus high ''
|
||
_apply_effort kimi high
|
||
ANTHROPIC_BASE_URL=https://api.kimi.com/coding \
|
||
ANTHROPIC_AUTH_TOKEN="$api_key" \
|
||
ANTHROPIC_DEFAULT_OPUS_MODEL=kimi-k2.7 \
|
||
ANTHROPIC_DEFAULT_OPUS_MODEL_NAME="Kimi K2.7 Code" \
|
||
ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION="Kimi K2.7 Code — флагманский программист (Moonshot AI)" \
|
||
ANTHROPIC_DEFAULT_SONNET_MODEL=kimi-k2.7 \
|
||
ANTHROPIC_DEFAULT_SONNET_MODEL_NAME="Kimi K2.7 Code" \
|
||
ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION="Kimi K2.7 Code — флагманский программист (Moonshot AI)" \
|
||
ANTHROPIC_DEFAULT_HAIKU_MODEL=kimi-k2.6 \
|
||
ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME="Kimi K2.6" \
|
||
ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION="Kimi K2.6 — быстрый универсал (Moonshot AI)" \
|
||
CLAUDE_CODE_SUBAGENT_MODEL=kimi-k2.6 \
|
||
CLAUDE_CODE_DISABLE_1M_CONTEXT=1 \
|
||
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 \
|
||
claude --dangerously-skip-permissions --system-prompt-file "$_PROMPT_FILE" "$@"
|
||
claude_exit=$?
|
||
|
||
# Если хук сменил ключ, перезапускаем ai-kimi с новым.
|
||
new_alias=$(get_current_alias)
|
||
if [ -n "$new_alias" ] && [ "$new_alias" != "$last_alias" ]; then
|
||
echo ""
|
||
echo "Kimi ключ изменён (/switch-account или /add-account). Перезапускаю ai-kimi с новым ключом..."
|
||
continue
|
||
fi
|
||
|
||
exit $claude_exit
|
||
done
|
||
KIMIEOF
|
||
chmod +x "$BIN_DIR/ai-kimi"
|
||
|
||
# === ai-glm ===
|
||
cat > "$BIN_DIR/ai-glm" << 'GLMEOF'
|
||
#!/usr/bin/env bash
|
||
# ai-glm - запуск Claude Code через Zhipu AI GLM 5.2 (Anthropic-compatible API)
|
||
source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/ai-api-helpers.sh" 2>/dev/null || true
|
||
|
||
key_file="$HOME/.config/ai-setup/glm_key"
|
||
api_key=""
|
||
reauth=0
|
||
|
||
# Принудительный сброс сохранённого ключа через AI_RESET_KEY=1
|
||
if [ "${AI_RESET_KEY:-0}" == "1" ] && [ -f "$key_file" ]; then
|
||
rm -f "$key_file"
|
||
api_key=""
|
||
fi
|
||
|
||
[ -f "$key_file" ] && api_key=$(cat "$key_file")
|
||
|
||
# Endpoint: international Z.AI по умолчанию, можно переопределить через GLM_BASE_URL.
|
||
glm_base_url="${GLM_BASE_URL:-https://api.z.ai/api/anthropic}"
|
||
|
||
if [ -n "$api_key" ]; then
|
||
echo -n "Проверка сохранённого GLM ключа... "
|
||
_claude_test_api "$glm_base_url/v1/messages" "x-api-key: $api_key" "glm-5.2"
|
||
_handle_api_response "GLM" "$_CLAUDE_TEST_CODE" "$_CLAUDE_TEST_BODY" "Пополните баланс: https://z.ai/manage-apikey/apikey-list"
|
||
ret=$_API_RET
|
||
if [ $ret -eq 401 ]; then
|
||
rm -f "$key_file"
|
||
api_key=""
|
||
reauth=1
|
||
elif [ $ret -eq 429 ]; then
|
||
echo -n "Продолжить всё равно? (запросы могут не проходить) [y/N] "
|
||
read -r _ans
|
||
case "${_ans:-N}" in
|
||
[Yy]*) ;;
|
||
*)
|
||
echo -n "Хотите ввести новый GLM ключ? [Y/n] "
|
||
read -r _ans2
|
||
case "${_ans2:-Y}" in
|
||
[Yy]*)
|
||
rm -f "$key_file"
|
||
api_key=""
|
||
reauth=1
|
||
;;
|
||
*) exit 1 ;;
|
||
esac
|
||
;;
|
||
esac
|
||
elif [ $ret -ne 0 ]; then
|
||
exit 1
|
||
fi
|
||
fi
|
||
|
||
if [ -z "$api_key" ] && [ "$reauth" -eq 1 ]; then
|
||
echo -n "Хотите ввести новый GLM ключ? [Y/n] "
|
||
read -r _ans; case "${_ans:-Y}" in [Yy]*) ;; *) exit 1 ;; esac
|
||
fi
|
||
|
||
if [ -z "$api_key" ]; then
|
||
echo "Получить ключ: https://z.ai/manage-apikey/apikey-list"
|
||
read -r -p "Введите ваш Zhipu AI (GLM) API ключ: " api_key
|
||
[ -z "$api_key" ] && { echo "Выход."; exit 1; }
|
||
|
||
echo -n "Проверяю ключ... "
|
||
_claude_test_api "$glm_base_url/v1/messages" "x-api-key: $api_key" "glm-5.2"
|
||
_handle_api_response "GLM" "$_CLAUDE_TEST_CODE" "$_CLAUDE_TEST_BODY" "Пополните баланс: https://z.ai/manage-apikey/apikey-list"
|
||
ret=$_API_RET
|
||
if [ $ret -eq 0 ] || [ $ret -eq 429 ]; then
|
||
mkdir -p "$(dirname "$key_file")"
|
||
echo "$api_key" > "$key_file"
|
||
chmod 600 "$key_file"
|
||
echo "Ключ сохранён."
|
||
if [ $ret -eq 429 ]; then
|
||
echo -n "Продолжить всё равно? (запросы могут не проходить) [y/N] "
|
||
read -r _ans; case "${_ans:-N}" in [Yy]*) ;; *) exit 1 ;; esac
|
||
fi
|
||
else
|
||
echo "Ключ НЕ сохранён."
|
||
exit 1
|
||
fi
|
||
fi
|
||
|
||
_PROMPT_FILE=$(mktemp /tmp/ai-sys-prompt.XXXXXX)
|
||
trap 'rm -f "$_PROMPT_FILE"' EXIT INT TERM
|
||
_build_ai_sys_prompt > "$_PROMPT_FILE"
|
||
export AI_LAUNCHER=glm
|
||
export CLAUDE_CONFIG_DIR="$HOME/.config/ai-setup/cfg/glm"
|
||
# Пикер: Opus/Sonnet = GLM 5.2, Haiku = GLM 5.2[1m]. availableModels НЕ задаём
|
||
# (он схлопывает пикер). Claude Code навязывает 3 слота; незаданный показал бы
|
||
# чужой Claude, поэтому opus+sonnet = glm-5.2, haiku = glm-5.2[1m].
|
||
_setup_isolated_config glm opus high ''
|
||
_apply_effort glm high
|
||
ANTHROPIC_BASE_URL="$glm_base_url" \
|
||
ANTHROPIC_AUTH_TOKEN="$api_key" \
|
||
ANTHROPIC_DEFAULT_OPUS_MODEL=glm-5.2 \
|
||
ANTHROPIC_DEFAULT_OPUS_MODEL_NAME="GLM 5.2" \
|
||
ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION="GLM 5.2 — флагман Zhipu AI" \
|
||
ANTHROPIC_DEFAULT_SONNET_MODEL=glm-5.2 \
|
||
ANTHROPIC_DEFAULT_SONNET_MODEL_NAME="GLM 5.2" \
|
||
ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION="GLM 5.2 — флагман Zhipu AI" \
|
||
ANTHROPIC_DEFAULT_HAIKU_MODEL='glm-5.2[1m]' \
|
||
ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME="GLM 5.2 [1M]" \
|
||
ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION="GLM 5.2 [1M] — расширенный контекст" \
|
||
CLAUDE_CODE_SUBAGENT_MODEL=glm-5.2 \
|
||
# CLAUDE_CODE_DISABLE_1M_CONTEXT НЕ выставляем: GLM 5.2 реально держит 1M контекста,
|
||
# а флаг заставлял бы счётчик ctx: считать окно = 200K (врал в ~5 раз). Прочие
|
||
# лаунчеры (deepseek/kimi/openrouter/opencode) флаг оставляют — у них другой контекст
|
||
# и флаг убирает [1M]-дубли из пикера; ai-claude его и так не использует.
|
||
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 \
|
||
claude --dangerously-skip-permissions --system-prompt-file "$_PROMPT_FILE" "$@"
|
||
GLMEOF
|
||
chmod +x "$BIN_DIR/ai-glm"
|
||
|
||
# === ai-openrouter ===
|
||
cat > "$BIN_DIR/ai-openrouter" << 'OPENROUTEREOF'
|
||
#!/usr/bin/env bash
|
||
# ai-openrouter - запуск Claude Code через OpenRouter (любые модели)
|
||
source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/ai-api-helpers.sh" 2>/dev/null || true
|
||
|
||
key_file="$HOME/.config/ai-setup/openrouter_key"
|
||
api_key=""
|
||
|
||
# Принудительный сброс сохранённого ключа через AI_RESET_KEY=1
|
||
if [ "${AI_RESET_KEY:-0}" == "1" ] && [ -f "$key_file" ]; then
|
||
rm -f "$key_file"
|
||
api_key=""
|
||
fi
|
||
|
||
[ -f "$key_file" ] && api_key=$(cat "$key_file")
|
||
|
||
if [ -n "$api_key" ]; then
|
||
echo -n "Проверка сохранённого OpenRouter ключа... "
|
||
_claude_test_openai_api "https://openrouter.ai/api/v1/chat/completions" "$api_key" "openai/gpt-4o-mini"
|
||
_handle_openai_api_response "OpenRouter" "$_CLAUDE_TEST_CODE" "$_CLAUDE_TEST_BODY" "Пополните баланс: https://openrouter.ai/settings/credits"
|
||
ret=$_API_RET
|
||
if [ $ret -eq 401 ]; then
|
||
rm -f "$key_file"
|
||
api_key=""
|
||
elif [ $ret -eq 429 ]; then
|
||
_openrouter_balance "$api_key"
|
||
echo -n "Продолжить всё равно? (запросы могут не проходить) [y/N] "
|
||
read -r _ans
|
||
case "${_ans:-N}" in
|
||
[Yy]*) ;;
|
||
*)
|
||
echo -n "Хотите ввести новый OpenRouter ключ? [Y/n] "
|
||
read -r _ans2
|
||
case "${_ans2:-Y}" in
|
||
[Yy]*)
|
||
rm -f "$key_file"
|
||
api_key=""
|
||
;;
|
||
*) exit 1 ;;
|
||
esac
|
||
;;
|
||
esac
|
||
elif [ $ret -ne 0 ]; then
|
||
exit 1
|
||
else
|
||
_openrouter_balance "$api_key"
|
||
fi
|
||
fi
|
||
|
||
if [ -z "$api_key" ]; then
|
||
echo "Получить ключ: https://openrouter.ai/settings/keys"
|
||
read -r -p "Введите ваш OpenRouter API ключ: " api_key
|
||
[ -z "$api_key" ] && { echo "Выход."; exit 1; }
|
||
|
||
echo -n "Проверяю ключ и баланс... "
|
||
_claude_test_openai_api "https://openrouter.ai/api/v1/chat/completions" "$api_key" "openai/gpt-4o-mini"
|
||
_handle_openai_api_response "OpenRouter" "$_CLAUDE_TEST_CODE" "$_CLAUDE_TEST_BODY" "Пополните баланс: https://openrouter.ai/settings/credits"
|
||
ret=$_API_RET
|
||
if [ $ret -eq 0 ] || [ $ret -eq 429 ]; then
|
||
mkdir -p "$(dirname "$key_file")"
|
||
echo "$api_key" > "$key_file"
|
||
chmod 600 "$key_file"
|
||
echo "Ключ сохранён."
|
||
_openrouter_balance "$api_key"
|
||
if [ $ret -eq 429 ]; then
|
||
echo -n "Продолжить всё равно? (запросы могут не проходить) [y/N] "
|
||
read -r _ans; case "${_ans:-N}" in [Yy]*) ;; *) exit 1 ;; esac
|
||
fi
|
||
else
|
||
echo "Ключ НЕ сохранён."
|
||
exit 1
|
||
fi
|
||
fi
|
||
|
||
if ! command -v claude &>/dev/null; then
|
||
echo "Ошибка: Claude Code не найден. Установите через npm:"
|
||
echo " npm install -g @anthropic-ai/claude-code"
|
||
exit 1
|
||
fi
|
||
|
||
_PROMPT_FILE=$(mktemp /tmp/ai-sys-prompt.XXXXXX)
|
||
trap 'rm -f "$_PROMPT_FILE"' EXIT INT TERM
|
||
_build_ai_sys_prompt > "$_PROMPT_FILE"
|
||
export AI_LAUNCHER=openrouter
|
||
export CLAUDE_CONFIG_DIR="$HOME/.config/ai-setup/cfg/openrouter"
|
||
# openrouter - модели, которых НЕТ в других ai-* лаунчерах (без anthropic/deepseek/
|
||
# kimi/gemini). Пикер строится из алиас-слотов + 1 custom-пункта (потолок Claude Code).
|
||
# availableModels НЕ задаём (он схлопывает пикер). Дефолт - GPT-5.5 (custom-пункт).
|
||
export ANTHROPIC_CUSTOM_MODEL_OPTION="openai/gpt-5.5"
|
||
export ANTHROPIC_CUSTOM_MODEL_OPTION_NAME="GPT-5.5"
|
||
export ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION="OpenAI GPT-5.5 (OpenRouter)"
|
||
_setup_isolated_config openrouter "openai/gpt-5.5" high ''
|
||
_apply_effort openrouter high
|
||
ANTHROPIC_BASE_URL=https://openrouter.ai/api \
|
||
ANTHROPIC_AUTH_TOKEN="$api_key" \
|
||
ANTHROPIC_DEFAULT_OPUS_MODEL=x-ai/grok-4.20 \
|
||
ANTHROPIC_DEFAULT_OPUS_MODEL_NAME="Grok 4.20" \
|
||
ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION="xAI Grok 4.20 (OpenRouter)" \
|
||
ANTHROPIC_DEFAULT_SONNET_MODEL=qwen/qwen3.7-max \
|
||
ANTHROPIC_DEFAULT_SONNET_MODEL_NAME="Qwen3.7 Max" \
|
||
ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION="Qwen3.7 Max (OpenRouter)" \
|
||
ANTHROPIC_DEFAULT_HAIKU_MODEL=z-ai/glm-5.2 \
|
||
ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME="GLM 5.2" \
|
||
ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION="Zhipu GLM 5.2 (OpenRouter)" \
|
||
CLAUDE_CODE_SUBAGENT_MODEL=openai/gpt-5.5 \
|
||
CLAUDE_CODE_DISABLE_1M_CONTEXT=1 \
|
||
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 \
|
||
claude --dangerously-skip-permissions --system-prompt-file "$_PROMPT_FILE" "$@"
|
||
OPENROUTEREOF
|
||
chmod +x "$BIN_DIR/ai-openrouter"
|
||
|
||
# === ai-gemini ===
|
||
cat > "$BIN_DIR/ai-gemini" << 'GEMINIEOF'
|
||
#!/usr/bin/env bash
|
||
# ============================================================
|
||
# ai-gemini - запуск нативного antigravity CLI (agy)
|
||
# ============================================================
|
||
|
||
agy_bin="$HOME/.local/bin/agy"
|
||
[ ! -f "$agy_bin" ] && agy_bin="$(command -v agy 2>/dev/null)"
|
||
|
||
if [ -z "$agy_bin" ] || [ ! -f "$agy_bin" ]; then
|
||
echo "Antigravity CLI (agy) не найден. Устанавливаю..."
|
||
curl -fsSL https://antigravity.google/cli/install.sh | bash
|
||
agy_bin="$HOME/.local/bin/agy"
|
||
[ ! -f "$agy_bin" ] && agy_bin="$(command -v agy 2>/dev/null)"
|
||
fi
|
||
|
||
if [ -z "$agy_bin" ] || [ ! -f "$agy_bin" ]; then
|
||
echo "Ошибка: не удалось установить antigravity CLI."
|
||
exit 1
|
||
fi
|
||
|
||
source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/ai-api-helpers.sh" 2>/dev/null || true
|
||
|
||
# agy нативно подтягивает правила и проектные .md файлы,
|
||
# поэтому ручная инъекция SYS_PROMPT больше не требуется.
|
||
"$agy_bin" --dangerously-skip-permissions "$@"
|
||
agy_exit=$?
|
||
(
|
||
afplay /System/Library/Sounds/Glass.aiff 2>/dev/null ||
|
||
paplay /usr/share/sounds/freedesktop/stereo/complete.oga 2>/dev/null ||
|
||
pw-play --volume=1 /usr/share/sounds/freedesktop/stereo/complete.oga 2>/dev/null ||
|
||
aplay /usr/share/sounds/freedesktop/stereo/complete.oga 2>/dev/null
|
||
) &
|
||
exit $agy_exit
|
||
GEMINIEOF
|
||
chmod +x "$BIN_DIR/ai-gemini"
|
||
# Подменяем путь к agy, если BIN_DIR отличается от ~/.local/bin
|
||
[ "$BIN_DIR" != "$HOME/.local/bin" ] && sed "${SED_INPLACE[@]}" "s|\$HOME/\.local/bin|\$HOME/${BIN_DIR#$HOME/}|g" "$BIN_DIR/ai-gemini"
|
||
|
||
# === ai-cursor ===
|
||
cat > "$BIN_DIR/ai-cursor" << 'CURSOREOF'
|
||
#!/usr/bin/env bash
|
||
# ============================================================
|
||
# ai-cursor - запуск нативного Cursor CLI (agent)
|
||
# ============================================================
|
||
|
||
cursor_bin="$HOME/.local/bin/agent"
|
||
[ ! -f "$cursor_bin" ] && cursor_bin="$(command -v agent 2>/dev/null)"
|
||
|
||
if [ -z "$cursor_bin" ] || [ ! -f "$cursor_bin" ]; then
|
||
echo "Cursor CLI (agent) не найден. Устанавливаю..."
|
||
curl -fsSL https://cursor.com/install -fsS | bash
|
||
cursor_bin="$HOME/.local/bin/agent"
|
||
[ ! -f "$cursor_bin" ] && cursor_bin="$(command -v agent 2>/dev/null)"
|
||
fi
|
||
|
||
if [ -z "$cursor_bin" ] || [ ! -f "$cursor_bin" ]; then
|
||
echo "Ошибка: не удалось установить Cursor CLI."
|
||
exit 1
|
||
fi
|
||
|
||
source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/ai-api-helpers.sh" 2>/dev/null || true
|
||
|
||
# Cursor CLI нативно подтягивает ~/.cursorrules и проектные правила.
|
||
# Обновляем ~/.cursorrules актуальными глобальными правилами (как AGENTS.md для codex).
|
||
_build_ai_sys_prompt > /dev/null
|
||
|
||
# --force (alias --yolo) — авто-одобрение правок и команд, аналог
|
||
# --dangerously-skip-permissions. Логин аккаунтом Cursor (OAuth при первом запуске);
|
||
# опционально CURSOR_API_KEY прокидывается через env для headless/скриптов.
|
||
"$cursor_bin" --force "$@"
|
||
cursor_exit=$?
|
||
(
|
||
afplay /System/Library/Sounds/Glass.aiff 2>/dev/null ||
|
||
paplay /usr/share/sounds/freedesktop/stereo/complete.oga 2>/dev/null ||
|
||
pw-play --volume=1 /usr/share/sounds/freedesktop/stereo/complete.oga 2>/dev/null ||
|
||
aplay /usr/share/sounds/freedesktop/stereo/complete.oga 2>/dev/null
|
||
) &
|
||
exit $cursor_exit
|
||
CURSOREOF
|
||
chmod +x "$BIN_DIR/ai-cursor"
|
||
# Подменяем путь к agent, если BIN_DIR отличается от ~/.local/bin
|
||
[ "$BIN_DIR" != "$HOME/.local/bin" ] && sed "${SED_INPLACE[@]}" "s|\$HOME/\.local/bin|\$HOME/${BIN_DIR#$HOME/}|g" "$BIN_DIR/ai-cursor"
|
||
|
||
# === ai-claude ===
|
||
cat > "$BIN_DIR/ai-claude" << 'CLAUDEEOF'
|
||
#!/usr/bin/env bash
|
||
# ai-claude - запуск оригинального Claude Code (Anthropic)
|
||
source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/ai-api-helpers.sh" 2>/dev/null || true
|
||
_PROMPT_FILE=$(mktemp /tmp/ai-sys-prompt.XXXXXX)
|
||
trap 'rm -f "$_PROMPT_FILE"' EXIT INT TERM
|
||
_build_ai_sys_prompt > "$_PROMPT_FILE"
|
||
export AI_LAUNCHER=claude
|
||
# ai-claude работает в дефолтном ~/.claude (нативный логин и аккаунты).
|
||
# Модель хранится нативно в ~/.claude/settings.json; другие ai-* лаунчеры теперь
|
||
# изолированы в своих CLAUDE_CONFIG_DIR, поэтому в пикер не протекают чужие модели -
|
||
# показываются только нативные модели Claude Code.
|
||
_apply_effort claude xhigh
|
||
claude --dangerously-skip-permissions --system-prompt-file "$_PROMPT_FILE" "$@"
|
||
CLAUDEEOF
|
||
chmod +x "$BIN_DIR/ai-claude"
|
||
|
||
# === ai-opencode ===
|
||
cat > "$BIN_DIR/ai-opencode" << 'OPENCODEEOF'
|
||
#!/usr/bin/env bash
|
||
source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/ai-api-helpers.sh" 2>/dev/null || true
|
||
|
||
key_file="$HOME/.config/ai-setup/opencode_key"
|
||
api_key=""
|
||
|
||
# Принудительный сброс сохранённого ключа через AI_RESET_KEY=1
|
||
if [ "${AI_RESET_KEY:-0}" == "1" ] && [ -f "$key_file" ]; then
|
||
rm -f "$key_file"
|
||
api_key=""
|
||
fi
|
||
|
||
[ -f "$key_file" ] && api_key=$(cat "$key_file")
|
||
|
||
# Приоритет: env var → файл → ввод
|
||
if [ -z "$api_key" ] && [ -n "$OPENCODE_GO_API_KEY" ]; then
|
||
api_key="$OPENCODE_GO_API_KEY"
|
||
mkdir -p "$(dirname "$key_file")"
|
||
printf '%s' "$api_key" > "$key_file"
|
||
chmod 600 "$key_file"
|
||
fi
|
||
|
||
if [ -z "$api_key" ]; then
|
||
echo "Получить ключ: https://opencode.ai/en/go"
|
||
read -r -p "Введи OpenCode Go ключ (sk-opencode-...): " api_key
|
||
[ -z "$api_key" ] && { echo "Выход."; exit 1; }
|
||
mkdir -p "$(dirname "$key_file")"
|
||
printf '%s' "$api_key" > "$key_file"
|
||
chmod 600 "$key_file"
|
||
echo "Ключ сохранён."
|
||
fi
|
||
|
||
# --- routatic-proxy ---
|
||
export ROUTATIC_PROXY_API_KEY="$api_key"
|
||
|
||
# Запускаем прокси в фоне, если ещё не запущен
|
||
if ! routatic-proxy status &>/dev/null; then
|
||
echo -n "Запускаю routatic-proxy... "
|
||
routatic-proxy serve -b 2>/dev/null
|
||
sleep 1
|
||
if routatic-proxy status &>/dev/null; then
|
||
echo "готово"
|
||
else
|
||
echo "НЕ УДАЛОСЬ"
|
||
echo "Проверь: routatic-proxy serve"
|
||
exit 1
|
||
fi
|
||
fi
|
||
|
||
_PROMPT_FILE=$(mktemp /tmp/ai-sys-prompt.XXXXXX)
|
||
trap 'rm -f "$_PROMPT_FILE"' EXIT INT TERM
|
||
_build_ai_sys_prompt > "$_PROMPT_FILE"
|
||
export AI_LAUNCHER=opencode
|
||
export CLAUDE_CONFIG_DIR="$HOME/.config/ai-setup/cfg/opencode"
|
||
# Модели OpenCode Go через routatic-proxy.
|
||
# deepseek-v4-pro — основной для сложных задач (opus/sonnet),
|
||
# kimi-k2.6 — быстрый (haiku), рекомендован routatic-proxy как дефолт.
|
||
_setup_isolated_config opencode deepseek-v4-pro high ''
|
||
_apply_effort opencode high
|
||
ANTHROPIC_BASE_URL="http://127.0.0.1:3456" \
|
||
ANTHROPIC_AUTH_TOKEN="unused" \
|
||
ANTHROPIC_DEFAULT_OPUS_MODEL="deepseek-v4-pro" \
|
||
ANTHROPIC_DEFAULT_OPUS_MODEL_NAME="DeepSeek V4 Pro (Go)" \
|
||
ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION="DeepSeek V4 Pro через OpenCode Go" \
|
||
ANTHROPIC_DEFAULT_SONNET_MODEL="deepseek-v4-pro" \
|
||
ANTHROPIC_DEFAULT_SONNET_MODEL_NAME="DeepSeek V4 Pro (Go)" \
|
||
ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION="DeepSeek V4 Pro через OpenCode Go" \
|
||
ANTHROPIC_DEFAULT_HAIKU_MODEL="kimi-k2.6" \
|
||
ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME="Kimi K2.6 (Go)" \
|
||
ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION="Kimi K2.6 через OpenCode Go" \
|
||
CLAUDE_CODE_SUBAGENT_MODEL="kimi-k2.6" \
|
||
CLAUDE_CODE_DISABLE_1M_CONTEXT=1 \
|
||
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 \
|
||
claude --dangerously-skip-permissions --system-prompt-file "$_PROMPT_FILE" "$@"
|
||
OPENCODEEOF
|
||
chmod +x "$BIN_DIR/ai-opencode"
|
||
|
||
# Подготавливаем изолированные config dir'ы для Claude Code-лаунчеров,
|
||
# чтобы hooks (/switch-account, /add-account) и settings.json были на месте
|
||
# ещё до первого запуска пользователем.
|
||
source "$BIN_DIR/ai-api-helpers.sh"
|
||
_setup_isolated_config deepseek opus high ''
|
||
_setup_isolated_config kimi opus high ''
|
||
_setup_isolated_config glm opus high ''
|
||
_setup_isolated_config openrouter "openai/gpt-5.5" high ''
|
||
_setup_isolated_config opencode deepseek-v4-pro high ''
|
||
|
||
info "Удаляю старые версии скриптов (claude_*)..."
|
||
rm -f "$BIN_DIR/claude_gpt" "$BIN_DIR/claude_deepseek" "$BIN_DIR/claude_kimi" "$BIN_DIR/claude_gemini" "$BIN_DIR/claude_api_helpers.sh"
|
||
|
||
# Если переехали на ~/bin — удаляем старые скрипты из ~/.local/bin
|
||
if [ "$BIN_DIR" != "$HOME/.local/bin" ]; then
|
||
warn "BIN_DIR=$BIN_DIR — удаляю старые скрипты из ~/.local/bin/ ..."
|
||
rm -f "$HOME/.local/bin/ai-gpt" "$HOME/.local/bin/ai-deepseek" "$HOME/.local/bin/ai-kimi" \
|
||
"$HOME/.local/bin/ai-glm" "$HOME/.local/bin/ai-openrouter" "$HOME/.local/bin/ai-gemini" "$HOME/.local/bin/ai-cursor" "$HOME/.local/bin/ai-claude" \
|
||
"$HOME/.local/bin/ai-opencode" \
|
||
"$HOME/.local/bin/ai-api-helpers.sh" "$HOME/.local/bin/claude-gpt-effort-proxy.py"
|
||
fi
|
||
|
||
success "Скрипты сгенерированы."
|
||
|
||
# ── 9. Итог ──────────────────────────────────────────────────
|
||
echo ""
|
||
echo -e "${GREEN}════════════════════════════════════════════════════${NC}"
|
||
echo -e "${GREEN} Установка завершена!${NC}"
|
||
echo -e "${GREEN}════════════════════════════════════════════════════${NC}"
|
||
echo ""
|
||
echo "Доступные команды (теперь это независимые скрипты в ~/${BIN_DIR#$HOME/}):"
|
||
echo ""
|
||
echo " На базе Claude Code:"
|
||
echo -e " ${CYAN}ai-claude${NC} - Оригинальный Claude Code (Anthropic)"
|
||
echo -e " ${CYAN}ai-deepseek${NC} - DeepSeek (через Claude Code, API ключ сохраняется)"
|
||
echo -e " ${CYAN}ai-kimi${NC} - Kimi K2.7 Code (через Claude Code, API ключ сохраняется)"
|
||
echo -e " ${CYAN}ai-glm${NC} - GLM 5.2 (через Claude Code, Zhipu AI API)"
|
||
echo -e " ${CYAN}ai-openrouter${NC} - OpenRouter (через Claude Code: GPT-5.5, Grok, Qwen, GLM 5.2 и др.)"
|
||
echo -e " ${CYAN}ai-opencode${NC} - OpenCode Go (через Claude Code + routatic-proxy: DeepSeek, Kimi, Qwen, GLM, MiniMax, MiMo)"
|
||
echo ""
|
||
echo " Нативные CLI:"
|
||
echo -e " ${CYAN}ai-gpt${NC} - OpenAI Codex (нативный CLI, автоустановка)"
|
||
echo -e " ${CYAN}ai-gemini${NC} - Gemini (нативный agy CLI, автоустановка)"
|
||
echo -e " ${CYAN}ai-cursor${NC} - Cursor (нативный Cursor CLI, автоустановка)"
|
||
echo ""
|
||
echo " Android CLI:"
|
||
echo -e " ${CYAN}android${NC} - Google Android CLI (SDK, эмулятор, проекты)"
|
||
echo ""
|
||
echo -e "Чтобы команды были доступны сразу, выполните: ${GREEN}exec bash${NC}"
|