同，但是重启和重装后依旧没有解决（docker安装）
使用此脚本安装
#!/bin/bash
Koishi + NapCat 一键安装与管理脚本
功能：安装、管理、日志查看、开机自启
==================== 配置区域 ====================
Koishi 配置
KOISHI_HOST_PORT=5140
KOISHI_CONTAINER_PORT=5140
KOISHI_EXTERNAL_PORT=37003
KOISHI_CONTAINER_NAME=“koishi”
KOISHI_IMAGE=“koishijs/koishi:latest”
NapCat 配置
NAPCAT_HOST_PORT=6099
NAPCAT_CONTAINER_PORT=6099
NAPCAT_EXTERNAL_PORT=45477
NAPCAT_CONTAINER_NAME=“napcat”
NAPCAT_IMAGE=“mlikiowa/napcat-docker:latest”
NapCat 数据目录
NAPCAT_CONFIG_DIR=“/root/napcat/config”
NAPCAT_QQ_DIR=“/root/napcat/.config”
NapCat 环境变量
MESSAGE_POST_FORMAT=“string”
WSR_ENABLE=true
MAC_ADDRESS=“02:42:ac:11:00:99”
服务器外网 IP
SERVER_IP=“160.202.232.88”
颜色定义
GREEN=‘\033[0;32m’
RED=‘\033[0;31m’
YELLOW=‘\033[1;33m’
BLUE=‘\033[0;34m’
CYAN=‘\033[0;36m’
NC=‘\033[0m’ # No Color
==================== 安装函数 ====================
install_services() {
clear
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo " 
Koishi + NapCat 一键安装 "
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo “”
echo “
将要安装的服务：”
echo “”
echo " 
Koishi 机器人"
echo " 本地端口: $KOISHI_HOST_PORT"
echo " 外网访问: http://$SERVER_IP:$KOISHI_EXTERNAL_PORT"
echo “”
echo " 
NapCat QQ机器人"
echo " 本地端口: $NAPCAT_HOST_PORT"
echo " 外网访问: http://$SERVER_IP:$NAPCAT_EXTERNAL_PORT"
echo “”
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo “”
read -p “按 Enter 继续安装，或 Ctrl+C 取消…”
# 停止Docker服务
echo -e "\n=== 1. 停止Docker相关服务 ==="
sudo systemctl stop docker.socket 2>/dev/null
sudo systemctl stop docker
echo “
Docker服务已停止”
# 配置Docker镜像源
echo -e "\n=== 2. 配置Docker镜像源（国内加速） ==="
sudo rm -f /etc/docker/daemon.json
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-‘EOF’
{
“registry-mirrors”: [
“https://docker.1panel.live”,
“https://hub.rat.dev”,
“https://docker.m.daocloud.io”,
“https://docker.unsee.tech”,
“https://docker.chenby.cn”
]
}
EOF
echo "✅ 镜像源配置完成"
# 启动Docker服务
echo -e "\n=== 3. 启动Docker并设置开机自启 ==="
sudo systemctl daemon-reload
sudo systemctl start docker
sudo systemctl enable docker
# 验证Docker服务
echo -e "\n=== 4. 验证Docker服务 ==="
if systemctl is-active --quiet docker; then
echo “ Docker服务启动成功”
else
echo “
Docker服务启动失败”
echo “请运行: journalctl -xeu docker.service 查看错误日志”
read -p “按 Enter 返回…”
return 1
fi
# 显示镜像配置
echo -e "\n=== 5. 验证Docker镜像配置 ==="
docker info | grep -A 5 "Registry Mirrors" || echo "镜像源配置查看失败（正常现象）"
# 安装 Koishi
echo -e "\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo " 📦 开始安装 Koishi"
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
# 清理旧容器
if docker ps -a | grep -q "$KOISHI_CONTAINER_NAME"; then
echo "正在清理旧的 Koishi 容器..."
docker stop "$KOISHI_CONTAINER_NAME" 2>/dev/null
docker rm "$KOISHI_CONTAINER_NAME" 2>/dev/null
echo "✅ 旧容器已清理"
fi
# 检查端口占用
if netstat -tuln 2>/dev/null | grep -q ":$KOISHI_HOST_PORT " || ss -tuln 2>/dev/null | grep -q ":$KOISHI_HOST_PORT "; then
echo "⚠️ 警告：端口 $KOISHI_HOST_PORT 被占用"
read -p "是否强制停止占用进程？(y/n): " -n 1 -r
echo
if [[ $REPLY =~ ^[Yy]$ ]]; then
PID=$(netstat -tulnp 2>/dev/null | grep :$KOISHI_HOST_PORT | awk '{print $7}' | cut -d'/' -f1 | head -1)
[ -z "$PID" ] && PID=$(ss -tulnp 2>/dev/null | grep :$KOISHI_HOST_PORT | grep -oP 'pid=\K[0-9]+' | head -1)
if [ ! -z "$PID" ]; then
kill -9 $PID
echo "✅ 已停止进程 $PID"
sleep 2
fi
else
echo "⚠️ 跳过 Koishi 安装（端口被占用）"
SKIP_KOISHI=true
fi
fi
# 拉取并启动 Koishi
if [ "$SKIP_KOISHI" != "true" ]; then
echo "正在拉取 Koishi 镜像..."
docker pull "$KOISHI_IMAGE"
if [ $? -eq 0 ]; then
echo "✅ Koishi 镜像拉取成功"
echo "正在启动 Koishi 容器..."
docker run -d \
--name "$KOISHI_CONTAINER_NAME" \
--restart=always \
-p $KOISHI_HOST_PORT:$KOISHI_CONTAINER_PORT \
"$KOISHI_IMAGE"
if [ $? -eq 0 ]; then
echo "✅ Koishi 启动成功！"
else
echo "❌ Koishi 启动失败"
fi
else
echo "❌ Koishi 镜像拉取失败"
fi
fi
# 安装 NapCat
echo -e "\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo " 📦 开始安装 NapCat"
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
# 创建数据目录
echo "创建数据目录..."
mkdir -p "$NAPCAT_CONFIG_DIR"
mkdir -p "$NAPCAT_QQ_DIR"
echo "✅ 数据目录创建完成"
# 清理旧容器
if docker ps -a | grep -q "$NAPCAT_CONTAINER_NAME"; then
echo "正在清理旧的 NapCat 容器..."
docker stop "$NAPCAT_CONTAINER_NAME" 2>/dev/null
docker rm "$NAPCAT_CONTAINER_NAME" 2>/dev/null
echo "✅ 旧容器已清理"
fi
# 检查端口占用
if netstat -tuln 2>/dev/null | grep -q ":$NAPCAT_HOST_PORT " || ss -tuln 2>/dev/null | grep -q ":$NAPCAT_HOST_PORT "; then
echo "⚠️ 警告：端口 $NAPCAT_HOST_PORT 被占用"
read -p "是否强制停止占用进程？(y/n): " -n 1 -r
echo
if [[ $REPLY =~ ^[Yy]$ ]]; then
PID=$(netstat -tulnp 2>/dev/null | grep :$NAPCAT_HOST_PORT | awk '{print $7}' | cut -d'/' -f1 | head -1)
[ -z "$PID" ] && PID=$(ss -tulnp 2>/dev/null | grep :$NAPCAT_HOST_PORT | grep -oP 'pid=\K[0-9]+' | head -1)
if [ ! -z "$PID" ]; then
kill -9 $PID
echo "✅ 已停止进程 $PID"
sleep 2
fi
else
echo "⚠️ 跳过 NapCat 安装（端口被占用）"
SKIP_NAPCAT=true
fi
fi
# 拉取并启动 NapCat
if [ "$SKIP_NAPCAT" != "true" ]; then
echo "正在拉取 NapCat 镜像..."
docker pull "$NAPCAT_IMAGE"
if [ $? -eq 0 ]; then
echo "✅ NapCat 镜像拉取成功"
echo "正在启动 NapCat 容器..."
docker run -d \
-e MESSAGE_POST_FORMAT="$MESSAGE_POST_FORMAT" \
-e WSR_ENABLE=$WSR_ENABLE \
-p $NAPCAT_HOST_PORT:$NAPCAT_CONTAINER_PORT \
-v "$NAPCAT_CONFIG_DIR:/usr/src/app/napcat/config" \
-v "$NAPCAT_QQ_DIR:/root/.config" \
--name "$NAPCAT_CONTAINER_NAME" \
--mac-address="$MAC_ADDRESS" \
--restart=always \
"$NAPCAT_IMAGE"
if [ $? -eq 0 ]; then
echo "✅ NapCat 启动成功！"
else
echo "❌ NapCat 启动失败"
fi
else
echo "❌ NapCat 镜像拉取失败"
fi
fi
# 显示安装结果
sleep 2
show_install_result
}
显示安装结果
show_install_result() {
clear
echo “”
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo " 
安装完成！"
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo “”
echo “
容器运行状态：”
echo “”
docker ps --format “table {{.Names}}\t{{.Status}}\t{{.Ports}}” | grep -E “NAMES|koishi|napcat”
echo “”
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo “”
show_urls_simple
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo “”
echo “ 开机自启: 已启用 (–restart=always)”
echo “ 后台运行: 已启用”
echo “”
echo “
运行 ./bot_manager.sh 打开管理菜单”
echo “”
read -p “按 Enter 继续…”
}
==================== 管理函数 ====================
显示菜单
show_menu() {
clear
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo " 
机器人管理菜单 "
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo “”
echo " ${CYAN}安装管理${NC}"
echo " 1. 一键安装所有服务"
echo " 2. 查看安装状态"
echo “”
echo " ${CYAN}服务控制${NC}"
echo " 3. 启动所有服务"
echo " 4. 停止所有服务"
echo " 5. 重启所有服务"
echo “”
echo " ${CYAN}Koishi 管理${NC}"
echo " 6. 启动 Koishi"
echo " 7. 停止 Koishi"
echo " 8. 重启 Koishi"
echo " 9. 查看 Koishi 日志"
echo “”
echo " ${CYAN}NapCat 管理${NC}"
echo " 10. 启动 NapCat"
echo " 11. 停止 NapCat"
echo " 12. 重启 NapCat"
echo " 13. 查看 NapCat 日志"
echo “”
echo " ${CYAN}其他操作${NC}"
echo " 14. 查看访问地址"
echo " 15. 查看运行状态"
echo " 16. 清理所有容器"
echo “”
echo " 0. 退出"
echo “”
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo “”
}
查看状态
check_status() {
clear
echo “”
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo " 容器运行状态"
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo “”
if docker ps -a | grep -qE "koishi|napcat"; then
docker ps -a --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}" | grep -E "NAMES|koishi|napcat"
echo ""
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo ""
show_urls_simple
else
echo -e "${YELLOW}未找到相关容器，请先运行安装${NC}"
echo ""
fi
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo ""
pause
}
启动所有
start_all() {
echo -e “${BLUE}启动所有服务…${NC}”
docker start $KOISHI_CONTAINER_NAME $NAPCAT_CONTAINER_NAME 2>/dev/null
sleep 2
echo -e “${GREEN} 完成${NC}”
docker ps | grep -E “koishi|napcat”
pause
}
停止所有
stop_all() {
echo -e “${YELLOW}停止所有服务…${NC}”
docker stop $KOISHI_CONTAINER_NAME $NAPCAT_CONTAINER_NAME 2>/dev/null
echo -e “${GREEN} 完成${NC}”
pause
}
重启所有
restart_all() {
echo -e “${BLUE}重启所有服务…${NC}”
docker restart $KOISHI_CONTAINER_NAME $NAPCAT_CONTAINER_NAME 2>/dev/null
sleep 2
echo -e “${GREEN} 完成${NC}”
docker ps | grep -E “koishi|napcat”
pause
}
Koishi 操作
start_koishi() {
echo -e “${BLUE}启动 Koishi…${NC}”
docker start $KOISHI_CONTAINER_NAME 2>/dev/null && echo -e “${GREEN} 完成${NC}” || echo -e “${RED} 失败${NC}”
sleep 1
docker ps | grep $KOISHI_CONTAINER_NAME
pause
}
stop_koishi() {
echo -e “${YELLOW}停止 Koishi…${NC}”
docker stop $KOISHI_CONTAINER_NAME 2>/dev/null && echo -e “${GREEN} 完成${NC}” || echo -e “${RED} 失败${NC}”
pause
}
restart_koishi() {
echo -e “${BLUE}重启 Koishi…${NC}”
docker restart $KOISHI_CONTAINER_NAME 2>/dev/null && echo -e “${GREEN} 完成${NC}” || echo -e “${RED} 失败${NC}”
sleep 1
docker ps | grep $KOISHI_CONTAINER_NAME
pause
}
logs_koishi() {
clear
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo " 
Koishi 实时日志（Ctrl+C 退出）"
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo “”
docker logs -f $KOISHI_CONTAINER_NAME 2>&1
}
NapCat 操作
start_napcat() {
echo -e “${BLUE}启动 NapCat…${NC}”
docker start $NAPCAT_CONTAINER_NAME 2>/dev/null && echo -e “${GREEN} 完成${NC}” || echo -e “${RED} 失败${NC}”
sleep 1
docker ps | grep $NAPCAT_CONTAINER_NAME
pause
}
stop_napcat() {
echo -e “${YELLOW}停止 NapCat…${NC}”
docker stop $NAPCAT_CONTAINER_NAME 2>/dev/null && echo -e “${GREEN} 完成${NC}” || echo -e “${RED} 失败${NC}”
pause
}
restart_napcat() {
echo -e “${BLUE}重启 NapCat…${NC}”
docker restart $NAPCAT_CONTAINER_NAME 2>/dev/null && echo -e “${GREEN} 完成${NC}” || echo -e “${RED} 失败${NC}”
sleep 1
docker ps | grep $NAPCAT_CONTAINER_NAME
pause
}
logs_napcat() {
clear
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo " NapCat 实时日志（Ctrl+C 退出）"
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo “”
docker logs -f $NAPCAT_CONTAINER_NAME 2>&1
}
显示访问地址（简化版）
show_urls_simple() {
if docker ps | grep -q $KOISHI_CONTAINER_NAME; then
echo -e “${GREEN} Koishi${NC}”
echo " 本地: http://127.0.0.1:$KOISHI_HOST_PORT"
echo " 外网: http://$SERVER_IP:$KOISHI_EXTERNAL_PORT"
echo “”
fi
if docker ps | grep -q $NAPCAT_CONTAINER_NAME; then
echo -e "${GREEN}✅ NapCat${NC}"
echo " 本地: http://127.0.0.1:$NAPCAT_HOST_PORT"
echo " 外网: http://$SERVER_IP:$NAPCAT_EXTERNAL_PORT"
echo " 配置: $NAPCAT_CONFIG_DIR"
echo ""
fi
}
查看访问地址（详细版）
show_urls() {
clear
echo “”
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo " 
访问地址"
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo “”
show_urls_simple
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo ""
echo "💡 提示："
echo " - Koishi: 访问 WebUI 进行配置和插件安装"
echo " - NapCat: 扫码登录 QQ，配置机器人功能"
echo ""
pause
}
清理所有容器
clean_all() {
clear
echo “”
echo -e “${RED}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}”
echo -e “${RED} 
警告：这将删除所有容器！${NC}”
echo -e “${RED}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}”
echo “”
echo “将要删除：”
echo " - Koishi 容器"
echo " - NapCat 容器"
echo “”
echo “注意：NapCat 的配置文件不会被删除”
echo " 位置: $NAPCAT_CONFIG_DIR"
echo “”
read -p "确认删除？输入 yes 继续: " confirm
if [ "$confirm" = "yes" ]; then
echo ""
echo "停止并删除容器..."
docker stop $KOISHI_CONTAINER_NAME $NAPCAT_CONTAINER_NAME 2>/dev/null
docker rm $KOISHI_CONTAINER_NAME $NAPCAT_CONTAINER_NAME 2>/dev/null
echo -e "${GREEN}✅ 清理完成${NC}"
else
echo "已取消"
fi
pause
}
暂停
pause() {
echo “”
read -p “按 Enter 继续…”
}
==================== 主程序 ====================
检查是否第一次运行（没有安装容器）
check_first_run() {
if ! docker ps -a | grep -qE “koishi|napcat”; then
clear
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo " 
欢迎使用机器人管理脚本"
echo “━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━”
echo “”
echo “检测到尚未安装服务”
echo “”
read -p "是否立即安装？(y/n): " -n 1 -r
echo “”
if [[ $REPLY =~ $ ]]; then
install_services
fi
fi
}
主函数
main() {
# 检查Docker是否安装
if ! command -v docker &> /dev/null; then
echo -e “${RED} 未检测到 Docker，请先安装 Docker${NC}”
exit 1
fi
# 检查是否首次运行
check_first_run
# 主循环
while true; do
show_menu
read -p "请选择操作 [0-16]: " choice
case $choice in
1) install_services ;;
2) check_status ;;
3) start_all ;;
4) stop_all ;;
5) restart_all ;;
6) start_koishi ;;
7) stop_koishi ;;
8) restart_koishi ;;
9) logs_koishi ;;
10) start_napcat ;;
11) stop_napcat ;;
12) restart_napcat ;;
13) logs_napcat ;;
14) show_urls ;;
15) check_status ;;
16) clean_all ;;
0)
clear
echo ""
echo "👋 再见！"
echo ""
exit 0
;;
*)
echo -e "${RED}❌ 无效选择，请重试${NC}"
sleep 2
;;
esac
done
}
运行主函数
main
