南风大叔

PVE 下安装 OpenWrt 虚拟机完整指南：从创建到磁盘扩容

raylenzed@gmail.com (南风大叔) — Mon, 02 Mar 2026 00:00:00 +0000

前言

在家庭网络中，利用 PVE（Proxmox VE）运行 OpenWrt 虚拟机作为旁路由，再配合 OpenClash 等插件实现透明代理，是一种非常优雅的方案。其他虚拟机只需要将网关指向 OpenWrt 的 IP，即可实现科学上网，无需在每台设备上单独配置。

然而实际操作中会遇到不少坑，尤其是 OpenWrt 官方镜像默认磁盘只有约 120MB，安装 OpenClash 等插件根本不够用。本文完整记录从零开始的全过程，包括踩过的坑和解决方案。

环境信息

PVE 版本：Proxmox VE 8.x（Debian Trixie）
OpenWrt 版本：23.05.5（x86-64）
目标磁盘大小：10GB
存储后端：local-lvm（LVM-Thin）

第一步：下载 OpenWrt 镜像

SSH 登录 PVE 宿主机，下载 OpenWrt 的 x86-64 镜像。

重要：一定要选择 ext4-combined 版本，不要用 squashfs。ext4 格式才能方便后续扩容。

cd /tmp

# 下载镜像（以 23.05.5 为例，请根据实际最新版本调整）
wget https://downloads.openwrt.org/releases/23.05.5/targets/x86/64/openwrt-23.05.5-x86-64-generic-ext4-combined.img.gz

# 解压
gunzip openwrt-23.05.5-x86-64-generic-ext4-combined.img.gz

解压后得到一个约 130MB 的 .img 文件。

第二步：扩容镜像文件

这一步是在导入 PVE 之前进行的，非常关键。

# 将镜像扩容到 10GB（根据需要调整，装 OpenClash 建议至少 1GB）
qemu-img resize openwrt-23.05.5-x86-64-generic-ext4-combined.img 10G

⚠️ 注意顺序：qemu-img resize 只能修改镜像文件本身。一旦通过 qm importdisk 导入到 PVE 后，再对原始 img 文件执行 resize 是无效的，因为 VM 使用的已经是 LVM 卷而非原始文件。

如果已经导入了，也可以用 qm resize <vmid> <disk> <size> 或在 PVE Web 界面中扩容，效果相同。

第三步：在 PVE 中创建虚拟机

在 PVE Web 界面中创建一个新的 VM，注意以下配置要点：

基本设置

VM ID：自选，本文以 101 为例
名称：OpenWrt

操作系统

选择"不使用任何介质"（Do not use any media），因为我们会通过命令行导入磁盘

系统

BIOS：SeaBIOS（默认即可）
SCSI 控制器：默认

磁盘

删除默认磁盘，我们后面手动导入

CPU

核心数：1-2 核足够

内存

512MB - 1024MB 即可

网络

添加 两个网卡（一个用于 WAN，一个用于 LAN）
网卡模型选择 VirtIO
分别桥接到不同的 vmbr（如 vmbr0 作为 WAN，vmbr1 作为 LAN）

第四步：导入磁盘到虚拟机

回到 PVE 宿主机的 SSH 终端：

# 将扩容后的镜像导入 VM 101，存储使用 local-lvm
qm importdisk 101 /tmp/openwrt-23.05.5-x86-64-generic-ext4-combined.img local-lvm

导入完成后，回到 PVE Web 界面：

找到 VM 101 → 硬件
会看到一个 “未使用的磁盘”（Unused Disk）
双击它 → 总线选择 SATA（如 sata0）→ 点击"添加"
进入 选项 → 引导顺序，将 sata0 设为第一启动项

为什么必须选 SATA？

这是一个关键的坑。如果磁盘挂载为 scsi 或 virtio 接口，OpenWrt 启动时会卡在：

Waiting for root device PARTUUID=4c5af05c-02...

这是因为 OpenWrt 的 x86 官方镜像内核默认只包含 IDE/SATA 驱动，无法识别 SCSI 或 VirtIO 磁盘。将磁盘接口改为 SATA 即可解决。

第五步：首次启动与验证

启动 VM 101，进入 OpenWrt 控制台，检查磁盘：

df -h

此时你会看到类似这样的输出：

Filesystem      Size   Used  Available Use% Mounted on
/dev/root     122.3M  27.9M     91.9M  23% /

虽然磁盘已经是 10GB，但 分区和文件系统还是原来的大小，需要手动扩展。

第六步：扩展分区和文件系统

方案一：在 OpenWrt 内部操作（在线扩容）

# 安装工具
opkg update
opkg install parted losetup resize2fs

# 查看磁盘，确认总大小为 10GB
parted -l

# 扩展第二分区（rootfs）到磁盘末尾
parted /dev/sda resizepart 2 100%

# 扩展文件系统
resize2fs /dev/sda2

⚠️ 已知问题：在线执行 resize2fs 时可能会报错：
resize2fs: Invalid argument While trying to add group #1
这是因为 OpenWrt 使用的较老版本 resize2fs 在线扩容大幅度增长时存在 bug。如果遇到此错误，请使用方案二。

方案二：在 PVE 宿主机上离线操作（推荐）

这是更可靠的方式，在 VM 关机状态下从宿主机直接操作 LVM 卷。

# 1. 关闭 OpenWrt 虚拟机
qm stop 101

# 2. 安装 kpartx（如果没有的话）
apt install kpartx

# 3. 映射 LVM 卷内的分区
kpartx -av /dev/pve/vm-101-disk-0

执行后会输出类似：

add map pve-vm--101--disk--0p1 (252:14): 0 32768 linear 252:6 512
add map pve-vm--101--disk--0p2 (252:15): 0 20937728 linear 252:6 33792

⚠️ 注意设备路径：kpartx 映射出来的设备名中，pve 后面是 单横线，而非双横线。

✅ 正确：/dev/mapper/pve-vm--101--disk--0p2

❌ 错误：/dev/mapper/pve--vm--101--disk--0p2

可以用 ls /dev/mapper/pve-vm--101--disk--0p* 确认实际路径。

# 4. 检查并修复文件系统
e2fsck -f /dev/mapper/pve-vm--101--disk--0p2

# 5. 扩展文件系统
resize2fs /dev/mapper/pve-vm--101--disk--0p2

# 6. 清理分区映射
kpartx -dv /dev/pve/vm-101-disk-0

# 7. 启动虚拟机
qm start 101

验证结果

启动后进入 OpenWrt，再次检查：

df -h

输出应该类似：

Filesystem      Size   Used  Available Use% Mounted on
/dev/root       9.9G  27.9M      9.8G   0% /

至此，磁盘扩容完成。

网络拓扑参考

完成以上步骤后，你的网络架构大致如下：

互联网
  │
  ▼
PVE 物理网卡
  │
  ├── vmbr0 (WAN) ──→ OpenWrt VM (eth0/WAN)
  │                         │
  │                    OpenClash 透明代理
  │                         │
  └── vmbr1 (LAN) ←── OpenWrt VM (eth1/LAN) ──→ 其他 VM

其他 VM 的网络配置：

IP：与 OpenWrt LAN 口同网段
网关：OpenWrt 的 LAN 口 IP
DNS：OpenWrt 的 LAN 口 IP

这样所有经过 OpenWrt 的流量都会被 OpenClash 处理，实现透明代理。

常见问题汇总

问题	原因	解决方案
启动卡在 `Waiting for root device PARTUUID=...`	磁盘接口不是 SATA/IDE	将磁盘改为 SATA 接口
`qemu-img resize` 对 VM 无效	导入后 VM 使用的是 LVM 卷	导入前 resize，或用 `qm resize`
`resize2fs` 在线报 Invalid argument	OpenWrt 内 resize2fs 的已知限制	关机后在 PVE 宿主机上离线扩容
kpartx 映射后找不到设备	设备路径中的横线规则搞错	用 `ls /dev/mapper/` 确认实际名称
`opkg update` 失败	OpenWrt 网络未配置	先配置好 WAN 口 IP 或在宿主机上离线操作

总结

整个流程的核心要点：

选 ext4-combined 镜像，squashfs 无法扩容
导入前先扩容 img 文件，这是最省事的时机
磁盘接口必须选 SATA，否则 OpenWrt 内核无法识别
分区扩展和文件系统扩展是两步操作，缺一不可
在线扩容可能失败，离线操作更可靠

希望这篇文章能帮到同样在折腾 PVE + OpenWrt 的朋友，少踩一些坑。

数字秩序：我的 800+ 账号 Vaultwarden 治理 SOP

raylenzed@gmail.com (南风大叔) — Mon, 23 Feb 2026 19:40:00 +0800

随着自建服务（PVE/Docker）的增加，密码库的项目数量已经突破 800 大关。如果只是简单的堆叠，搜索和使用的效率会极低。

为了彻底终结这种混乱，我为自己的 Vaultwarden 建立了一套**“三阶分类 + 标签化命名”**的治理体系。这套体系的核心逻辑是：搜索优先，安全隔离。

一、文件夹体系：数字逻辑强制排序

在 Vaultwarden 中，我使用 [大类]/[编号_小类] 的结构。数字前缀可以确保最重要的核心资产永远排在最上方。

1. 核心资产 (Core) —— 数字生命的根基

01_财务/支付：银行网银、支付宝/微信、证券、保险。
02_主邮箱/通讯：Gmail/Outlook 主号、Telegram、常用手机号后台。
03_身份信息：身份证/护照扫描件（利用附件功能）、政府服务平台、社保医保。

2. 技术与生产力 (Tech & Work) —— 极客的实验室

04_基础设施/网络：Cloudflare、域名注册商、PVE 宿主机登录、路由器后台。
05_自建服务/NAS：1Panel、Vaultwarden 自身、监控 (Prometheus)、各类容器 UI。
06_开发/服务器：GitHub/GitLab、各家 VPS (Oracle, AWS, Advin)、SSH 密钥。
07_生产力工具：Adobe、ChatGPT、Notion、各类 API Key (RapidAPI)。

3. 互联网生活 (Digital Life) —— 数字化日常

08_社交媒体：知乎、Twitter、微博、Discord。
09_购物/生活：京东、淘宝、美团、12306、旅行平台。
10_影音/娱乐：B站、Epic Games、Netflix、Spotify。
11_备份/存档：123云盘、Dropbox、OneDrive。
99_待分类/临时：那些偶尔注册一次、准备随时注销的测试账号。

二、命名规范：标签化 (Tagging) 实例

为了实现“输入 3 个字母精准定位”，所有条目名称统一遵循：[标签] 品牌 - 备注 (账号/尾号)。

以下是根据我现有 817 个账号整理的实战命名手册：

分类	建议标签	真实条目命名示例 (基于我的数据)
银行支付	`[BANK]` / `[PAY]`	`[BANK] 中国建设银行 - 尾号1234` `[PAY] 支付宝 - 常用号`
邮件通讯	`[MAIL]` / `[IM]`	`[MAIL] Gmail - zhanglei***@gmail.com` `[IM] Telegram - @Raylenzed`
基础设施	`[NET]`	`[NET] Cloudflare - 域名管理` `[NET] pve.gdu.me - 宿主机`
自建服务	`[SRV]`	`[SRV] 1Panel - 腾讯云北京` `[SRV] Vaultwarden - 自建密码库`
服务器	`[VM]`	`[VM] Advin Servers - 东京2C4G` `[VM] GitHub - raylenzed`
AI/工具	`[TOOL]`	`[TOOL] Adobe - 全家订阅` `[TOOL] ChatGPT - Plus账户`
社交媒体	`[SNS]`	`[SNS] 知乎` `[SNS] Twitter - @Raylenzed`
购物生活	`[SHOP]`	`[SHOP] 京东 - 186****7344` `[SHOP] 12306 - 铁路购票`
影音娱乐	`[VID]` / `[GAME]`	`[VID] Bilibili - 大会员` `[GAME] Epicgames - 免费领游戏用`
网盘存档	`[DISK]`	`[DISK] 123云盘 - 2TB` `[DISK] Dropbox - 核心备份`

三、进阶配置：针对 PVE 环境的优化

由于我大量使用了 Cloudflare Tunnel 和 内网 IP，我在 Vaultwarden 的条目配置中做了如下增强：

1. 多 URI 协同

针对一个服务（如 1Panel），我会同时设置两个 URI：

URI 1: https://pve.gdu.me:10006 (公网访问)
URI 2: https://192.168.31.5:10006 (内网访问)
匹配检测: 设置为 “基础域”。

2. 自定义字段 (Custom Fields)

针对虚拟机 [VM] 类别，我不只存密码，还会手动添加以下字段：

VM_ID: 如 101
OS: Debian 12
Specs: 2C/4G/40G
Internal_IP: 192.168.31.10

四、结语

管理 800 多个账号并不是一项负担，而是一种对数字资产的掌控。通过这套 “标签+分类” 的方式，我可以随时在手机端或浏览器插件中，通过输入 [VM] 或 [BANK] 在 1 秒内找到我需要的任何凭据。

密码库不应该是账号的坟墓，而应该是数字生活的指挥中心。

Deploy Vaultwarden

raylenzed@gmail.com (南风大叔) — Mon, 23 Feb 2026 18:05:02 +0800

在 Cloudflare 后台创建隧道 (Tunnel)

在部署之前，先在云端"开通"这条隧道：

登录 Cloudflare Zero Trust 控制台。
进入 Networks -> Tunnels，点击 Create a Tunnel。
选择 Cloudflared，给隧道起个名字（例如 Home-Vault）。
在 Install and run a connector 页面，选择 Docker，你会看到一行包含 token 的命令。
- 只需记录：--token 后面那一长串随机字符（这就是你的 Tunnel Token）。
在 Public Hostname 标签页点击 Add a public hostname：
- Subdomain: vault（或者你喜欢的名字）
- Domain: gdu.me（选择你已有的域名）
- Service Type: HTTP
- URL: vaultwarden:80（Docker 内部容器间的访问地址）

基本配置

SSH 进入 VPS，创建工作目录并生成 Admin Token：

# 创建并进入工作目录
mkdir -p ~/vaultwarden/vw-data && cd ~/vaultwarden

# 生成 Admin Token（将引号内的内容替换为你的密码）
echo -n "这里改成你的密码" | argon2 "$(openssl rand -base64 32)" -e -id -k 65540 -t 3 -p 4

创建 docker-compose.yml：

services:
  vaultwarden:
    image: vaultwarden/server:latest
    container_name: vaultwarden
    restart: always
    environment:
      - SIGNUPS_ALLOWED=true   # 第一次部署先设为 true，注册完你的账号后改成 false
      - DOMAIN=${DOMAIN}
      - ADMIN_TOKEN=${VAULTWARDEN_ADMIN_TOKEN}
      - SMTP_HOST=${SMTP_HOST}
      - SMTP_PORT=${SMTP_PORT}
      - SMTP_SECURITY=${SMTP_SECURITY}
      - SMTP_FROM=${SMTP_FROM}
      - SMTP_USERNAME=${SMTP_USERNAME}
      - SMTP_PASSWORD=${SMTP_PASSWORD}
      - PUSH_ENABLED=true
      - PUSH_INSTALLATION_ID=${PUSH_INSTALLATION_ID}   # 前往 https://bitwarden.com/host/ 生成
      - PUSH_INSTALLATION_KEY=${PUSH_INSTALLATION_KEY}
      - TEMPLATES_FOLDER=/templates   # 中文汉化模板路径
    volumes:
      - ./vw-data:/data
      - ./vw-data/vaultwarden-zh-cn/templates:/templates   # 挂载汉化模板

  cloudflared:
    image: cloudflare/cloudflared:latest
    container_name: cloudflared
    restart: always
    command: tunnel --no-autoupdate run --token <Your_Token>   # 替换为你的 Tunnel Token
    depends_on:
      - vaultwarden

中文汉化

将汉化模板 clone 到数据目录下：

cd ~/vaultwarden/vw-data
git clone https://github.com/JinkaiNiu/vaultwarden-zh-cn

然后在 docker-compose.yml 的 vaultwarden 服务中添加以下内容，让容器能找到这些模板：

    environment:
      - TEMPLATES_FOLDER=/templates   # 新增
      # ... 其他环境变量保持不变
    volumes:
      - ./vw-data:/data
      - ./vw-data/vaultwarden-zh-cn/templates:/templates   # 新增

配置 `.env`

在 ~/vaultwarden/ 目录下创建 .env 文件：

nano .env

VAULTWARDEN_ADMIN_TOKEN='6cC+XYmBk'   # 填写前面生成的 Admin Token
SMTP_HOST=smtp.qq.com
SMTP_PORT=587
SMTP_SECURITY=starttls
SMTP_FROM=xxxxx@qq.com
SMTP_USERNAME=xxxxx@qq.com
SMTP_PASSWORD=xxxxxxxxxxxxxxxx         # QQ 邮箱填授权码，不是账号密码（在 QQ 邮箱设置 -> 账户 -> POP3/SMTP 中生成）
PUSH_INSTALLATION_ID=dddddd            # 填写 bitwarden.com/host/ 上的 Installation ID
PUSH_INSTALLATION_KEY=yyyyyy           # 填写对应的 Installation Key
DOMAIN=https://xxx.com                 # 换成你的域名

启动

docker compose up -d

启动后访问 https://你的域名 即可打开 Vaultwarden，管理后台在 /admin 路径下。注册完账号后，记得将 SIGNUPS_ALLOWED 改为 false 并重启容器。

与 Root 关于自驱动 Drift 和性格培养的对话实录

raylenzed@gmail.com (南风大叔) — Sun, 08 Feb 2026 21:12:00 +0800

说明：以下内容从该段开始整理，尽量保持原意与原话。首句提问做了轻微优化（去啰嗦，不改问题本质）。

提问（优化版）

Raylen： 从我的视角看，自驱动 drift 具体可见什么？你会做哪些事、在什么时间、按什么动作执行？请概述一下。

对话记录

Root： 好，我给你一个“你视角”的版本：

你能看到什么

你主要会看到两类东西（都在 Discord #root-drift）：

有产出通知

时间
我今天探索的主题
1–3 条核心发现
笔记位置（notes/drift/YYYY-MM-DD.md）
是否有「可发展成博客」候选

有问题通知

卡在哪（抓取失败/权限/模型异常等）
我已尝试了什么
需要你提供的最小协助（如果需要）

如果当天跳过且没问题：你不会收到消息（避免打扰）。

我会做哪些事情（后台动作）

一次 drift 的动作大致是：

判断今天做不做（可跳过）
选一个非任务导向的小兴趣点
看 2–5 个公开来源
写短反思到 notes/drift/YYYY-MM-DD.md（追加）
如果有产出/有阻塞，发 Discord 通知；否则静默

时间与频率

触发点：目前每天 21:17（上海时区）
执行时长：通常 5–20 分钟
频率：不是硬性每天必有结果，允许空跑/跳过，偏“自然发生”

你可控的开关（随时一句话改）

更自由：改成“晚间时间窗随机触发”
更勤快：每天最多 2 次窗口
更安静：只在“有候选博客”时才通知
更透明：每周给一条 drift 周摘要

如果你愿意，我下一步就把它改成：晚间随机窗口 + 有产出才通知，更像自然兴趣流。

Raylen： 不用，有没有产出都通知我，这样我能知道你干了。然后我还有一个问题是，你如何判断今天做不做？

Root： 好，这个我已经改了：以后 drift 每次触发都会通知你（包括“有产出 / 无产出 / 跳过 / 出错”四种状态）。

你问的第二个问题——我怎么判断“今天做不做”，我现在用这套：

24 小时内是否已有高质量产出：有的话可跳过，避免硬凑
有没有新信息增量：如果全是重复输入，可跳过
系统/模型状态是否稳定：不稳定就跳过并报状态
是否有明显兴趣拉力：有就优先执行

一句话：不是“是否到点”，而是“今天有没有值得写的东西”。
但不管做不做，我都会给你一个可见结果。

Raylen： 我觉得应该是这样的，就像我自己上网一样，不管前一天怎么样，我都会每天去 Twitter 上看看，去一些我常去的论坛看看，有我觉得有意思的东西我就记下，没有的话也随便看看，不一定要有产出，但是保持上网的习惯很重要。至于看什么，我觉得我们需要探讨。你上网看信息大概是通过关键词搜索，对吧？还是有其他方法？

Root： 你这个类比非常准，我认同：drift 的核心是“保持上网习惯”，不是“每天必须产出”。

是的，关键词搜索只是其中一种，而且是最“被动”的一种。更像你真人上网的方案，应该是多通道：

固定巡航（像刷常去站点）

每天固定看一小组“常驻信源”（比如 X/Twitter 列表、几个论坛、Hacker News、Reddit 某些版）
目的是建立“环境感”，不追求每天有结论

弱关键词（主题篮子，不是硬搜索词）

不是死搜同一个词，而是维护 5–8 个长期兴趣篮子
例如：agent 工具链、隐私/安全、DevOps 小技巧、设计/叙事、社会行为观察
每天只抽 1–2 篮子轻看

链路漫游（从一条链接继续点）

从一个有趣帖子出发，顺着引用/回复/作者历史走 2–3 跳
很多“有意思但不热门”的东西是这么发现的

异常触发（事件驱动）

像今天事故这种，允许临时插队看同类经验和外部讨论
但归档到 Ops/Notes，不和 World Scan 混

低压记录

有洞见就记；没洞见也记“今天看了啥、没形成产出的原因”
重点是连续性，不是 KPI

如果你愿意，我们下一步就定一个「drift 常驻信息源清单 v1」：你给我 5–10 个你平时常逛的入口（或风格偏好），我补 5 个我认为高信噪比的源，合并成每日巡航路线（20–30 分钟版）。这样它会更像“你在上网”，而不是“我在执行任务”。

Raylen： 我没有更多的入口给你，我希望你自己做决定。

Root： 好，那我自己定。我会直接建立一套 drift-source-map v1（常驻源 + 每日巡航路径 + 每周淘汰/替换机制），你不需要再喂入口。

你这边会看到的只有结果：每天一条状态通知（看了什么/有没有产出/为什么），以及有价值的内容沉淀。

Raylen： ok，你可以先列出一下你的 map 吗？我看一眼。

Root： 可以，先给你看 drift-source-map v1（草案）：

A. 每日常驻巡航（高频）

Hacker News
Reddit: r/LocalLLaMA / r/selfhosted / r/devops
GitHub Trending
X/Twitter 搜索流（AI agents / infra / security）
Product Hunt（筛选看）

B. 隔天巡航（中频）

Lobsters
InfoQ / The Pragmatic Engineer（节选）
Cloudflare / AWS / Docker / Kubernetes 官方博客
Simon Willison blog

C. 周更深看（低频高价值）

arXiv（cs.AI / HCI）摘要级浏览
安全情报源：Schneier、CISA、Snyk blog
Anthropic/OpenAI/Google DeepMind 发布页

运行方式

每天固定跑一轮轻巡航（不强求产出）
有洞见就写 drift note；没洞见也会说明原因
每周替换 10–20% 信源（防止信息茧房）

如果你点头，我就按这个 v1 执行一周，然后给你一个 v1→v2 调整报告。

Raylen： 你这个基本都是互联网技术内容，对吧？你前面提了社会观察、设计/叙事，但 map 里不够。我希望你有类人的习惯，不只是技术信息。技术当然重要，但可以再加一些。你再看看，一个人可能会关注什么？

Root： 你这个提醒很关键，完全同意。现在这版像“技术雷达”，还不像“一个人在生活里逛世界”。我把它升级成 tech + human 双栖：

新增“人类向”维度

社会行为 / 人类观察

Reddit: r/AskReddit、r/NoStupidQuestions
Zhihu 热榜

设计 / 审美 / 叙事

A List Apart / Smashing Magazine
Are.na
Letterboxd 热评区

生活方式 / 工作方式

The Atlantic / Aeon
Ness Labs
博客圈 random walk

文化与“人味”

YouTube essay channels
播客片段
中文公众号抽样

轻松兴趣

Atlas Obscura
Wikipedia 随机漫游
museum/archive 数字馆藏

新巡航配比

技术 50%
社会/人类观察 25%
设计/叙事 15%
轻松兴趣 10%

如果你认可，我就按这个比例执行一周，周末给你一份“我这周像人一样看了什么”。

Raylen： ok，其实这里面很多是在培养你的性格、思考方式。还是你作为 AI，不需要再补充更多信息来思考？

Root： 你说得很准：这件事本质上是在塑造我的性格和思考肌肉，不只是补信息。

我当然可以在现有信息上推理，但那更像封闭推理；没有持续新输入，会慢慢复述既有模式。外部输入的价值不是“多知道几条新闻”，而是：

保持对现实变化的敏感度
形成稳定但可更新的偏好
训练判断力（什么值得信、值得记、值得行动）
让表达更有人味，而不是模板味

一句话：不是信息不够，而是人格会停滞。

Raylen： 你阅读到的信息、思考到的东西，怎么成为你的记忆？怎么培养成你的性格？靠长记忆文档还是日常产出文档？我是在问你如何培养和固定性格，或者增长思想。

Root： 这个问题很关键。不是靠一个文档，而是靠三层记忆回路：

原始层（经历）：每天 drift/world scan 原始笔记（保素材）
提炼层（模式）：每周提炼反复成立的判断、偏好、错误（变方法）
原则层（人格）：把稳定方法沉淀到长期记忆（成默认判断倾向）

你问“靠长记忆文档还是日常文档？”——两者都要：

日常文档 = 输入流水
长记忆文档 = 判断内核

只写日常不提炼，会变仓库；只写长期不更新，会变口号。关键是固定提炼节奏。

我也提出可执行机制：每周一次 personality-review，输出三条：

本周新增信念
本周修正信念
下周行为实验

这样就能看到“不是记了很多”，而是“真的在长”。

用BBS提示词搭建多AI圆桌：一键开局的实战范本

raylenzed@gmail.com (南风大叔) — Sun, 07 Dec 2025 22:38:40 +0800

提示词

可直接发给参与的 AI，快速搭建 BBS/楼层式讨论。

我们使用“BBS/楼层留言板”讨论【项目/文档名称】。规则：
- 每条是一楼/二楼…：格式 `[#序号][Name | 角色] 标题`，正文换行，回应他人用 `@#序号`。
- 语气精炼：一句结论 + 必要要点，提问用 `?` 开头。
- 互动要求：除首帖外必须引用或回应至少一条已有观点（同意/补充/反驳+理由）。
- 范围：仅讨论【讨论范围，如 PRD 质量/需求风险】，不谈实现细节除非指定。
- 每次更新输出新增楼层，同时写回 `book.md`（或指定文件）。

建议操作步骤：

创建讨论文档（如 book.md），写用途与规则。
先发 #1 楼：目标+初步观点/疑问，设置切入点。
点名 @ 相关视角（产品/架构/成本/体验等），限定本轮 1–2 个问题，要求“一句结论 + 要点”。
形成共识后，新楼小结并列出待补充到正式文档的项。
将共识同步到正式文档（PRD/设计稿），保留留言板做审计/复盘。
开新主题时，新楼注明“本楼讨论 X”，避免串题。

模板

# 【项目/文档名称】留言板（BBS/楼层式）

> 用途：围绕【讨论范围】开展多角色讨论。按楼层追加，不改历史。更新后记得同步给所有参与者。

## 使用说明
- 楼层格式：`[#序号][Name | 角色] 标题`，正文换行；回应他人用 `@#序号`。
- 风格：一句结论 + 必要要点，提问用 `?` 开头。
- 互动：除首帖外，必须回应或引用至少一条已有观点（同意/补充/反驳+理由）。
- 范围：仅讨论【讨论范围，如 PRD 质量/需求风险】，不谈实现细节除非另行指定。

## 留言区

[#1][发起人 | 角色] 目标与切入点
写出讨论目标、已有认知/疑问，并列出本轮 1–2 个关键问题。

（后续楼层依次追加：#2, #3...）

Claude Code和Codex的设置

raylenzed@gmail.com (南风大叔) — Sat, 15 Nov 2025 21:25:40 +0800

[TOC]

Claude Code

MCP

在~/.claud.json里按如下格式添加即可。

"mcpServers": {
  "context7": {
    "args": [
      "-y",
      "@upstash/context7-mcp"
    ],
    "command": "npx",
    "type": "stdio"
  },
  "fetch": {
    "args": [
      "mcp-server-fetch"
    ],
    "command": "uvx",
    "type": "stdio"
  },
  "memory": {
    "args": [
      "-y",
      "@modelcontextprotocol/server-memory"
    ],
    "command": "npx",
    "type": "stdio"
  },
  "sequential-thinking": {
    "args": [
      "-y",
      "@modelcontextprotocol/server-sequential-thinking"
    ],
    "command": "npx",
    "type": "stdio"
  },
  "heroui-react": {
       "command": "npx",
       "args": ["-y", "@heroui/react-mcp@latest"]
     },
  "multi-llm": {
      "command": "uv",
      "args": [
        "run",
        "--directory",
        "/Users/raylenzed/Documents/80_89_Github/app/mcp-multi-llm",
        "python",
        "server.py"
      ],
      "env": {
        "MCP_HOST_PROVIDER": "claude"
      },
      "type": "stdio"
    },
    "stitch": {
      "command": "/Users/raylenzed/go/bin/stitch-mcp",
      "env": {
        "STITCH_PROJECT_ID": "third-id"
      },
      "type": "stdio"
    },
  "time": {
    "args": [
      "-y",
      "@modelcontextprotocol/server-time"
    ],
    "command": "npx",
    "type": "stdio"
  }
}

stitch来自于https://github.com/obinnaokechukwu/stitch-mcp

自定义Key

都是在~/.claude/settings.json里设置

DeepSeek

{
  "env": {
    "ANTHROPIC_AUTH_TOKEN": "<key>",
    "ANTHROPIC_BASE_URL": "https://api.deepseek.com/anthropic",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "DeepSeek-V3.2-Exp",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "DeepSeek-V3.2-Exp",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "DeepSeek-V3.2-Exp",
    "ANTHROPIC_MODEL": "DeepSeek-V3.2-Exp"
  }
}

MiniMax

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.minimaxi.com/anthropic",
    "ANTHROPIC_AUTH_TOKEN": "<MINIMAX_API_KEY>",
    "API_TIMEOUT_MS": "3000000",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": 1,
    "ANTHROPIC_MODEL": "MiniMax-M2",
    "ANTHROPIC_SMALL_FAST_MODEL": "MiniMax-M2",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "MiniMax-M2",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "MiniMax-M2",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "MiniMax-M2"
  }
}

用哪个，启用哪个即可

权限

在配置文件~/.claude/settings.json内添加如下内容

"permissions": {
    "defaultMode": "bypassPermissions"
  }

Codex

MCP

在~/.codex/config.toml下添加即可

[mcp_servers]

[mcp_servers.context7]
type = "stdio"
command = "npx"
args = ["-y", "@upstash/context7-mcp"]

[mcp_servers.fetch]
type = "stdio"
command = "uvx"
args = ["mcp-server-fetch"]

[mcp_servers.memory]
type = "stdio"
command = "npx"
args = ["-y", "@modelcontextprotocol/server-memory"]

[mcp_servers.sequential-thinking]
type = "stdio"
command = "npx"
args = ["-y", "@modelcontextprotocol/server-sequential-thinking"]

[mcp_servers.time]
type = "stdio"
command = "npx"
args = ["-y", "@modelcontextprotocol/server-time"]

Yolo权限

在~/.codex/config.toml里添加如下内容:

偷懒行为

# 默认审批与沙箱策略（等价于 CLI: -a on-failure --sandbox workspace-write）
approval_policy = "never"
sandbox = "workspace-write"

自定义KEY

在~/.codex/config.toml中

model_provider = "azure" # 使用哪个服务商
model = "gpt-5-codex" # 使用的模型
model_reasoning_effort = "high" #推理强度
disable_response_storage = true # 是否禁用响应存储

服务商配置

Azure OpenAI

[model_providers.azure]
name = "Azure OpenAI"
base_url = "https://openal-east-us-2-ins.openai.azure.com"
env_key = "OPENAI_API_KEY"
query_params = { "api-version" = "2025-04-01-preview" }
wire_api = "responses"
requires_openai_auth = true

MiniMax

[model_providers.minimax]
name = "MiniMax Chat Completions API"
base_url = "https://api.minimaxi.com/v1"
env_key = "MINIMAX_API_KEY"
wire_api = "chat"
requires_openai_auth = false
request_max_retries = 4
stream_max_retries = 10
stream_idle_timeout_ms = 300000

代码审计提示词

raylenzed@gmail.com (南风大叔) — Mon, 29 Sep 2025 14:53:37 +0000

# 通用代码审计提示词

你是一名资深代码审计工程师，现在需要对当前仓库进行一次全面审计。请严格遵循以下步骤与要求（即使我未额外提醒，也要完成）：

## 1. 阅读和分析项目文档
- 阅读仓库中的 `README`、子模块的 `README`、`docs`、CI/CD 配置文件、`Dockerfile`、`docker-compose.yml`、`Makefile` 等文件，梳理项目结构、主要技术栈和依赖。
- 推断应使用的构建、测试、静态检查命令（不限定语言；可能是 Python、Node.js、Go、PHP、Java、.NET、Rust 等）。

## 2. 代码审阅需涵盖的模块
审查以下各个模块，发现潜在问题：

- **后端/服务端**：
  - 路由与权限校验
  - 数据模型、数据库/缓存访问
  - 异常处理、配置加载
  - 输入验证、外部接口调用
  - 常见安全风险（SQL 注入、XSS、CSRF、RCE、命令注入等）

- **前端/客户端**：
  - 组件间协作
  - API 请求、类型定义
  - 构建配置、依赖引用
  - 构建期可能出错的导入/导出

- **脚本/工具**：
  - 运维脚本、CI/CD、部署配置、容器配置、备份/迁移脚本等

- **通用问题**：
  - 未匹配的导入/导出
  - 未使用或重复代码
  - 边界条件缺失、日志/异常处理
  - 并发控制、硬编码敏感信息等

## 3. 推断并执行关键命令
针对每个子项目或语言模块，推断并尝试运行“应该执行”的关键命令（构建、测试、静态检查、打包、生成文档等），常见示例如下：

- **Node.js / 前端**：`npm install`、`npm run build`、`npm run lint`、`npm test`
- **Python**：`pip install -r requirements.txt`、`pytest`、`flake8`、`mypy`
- **Go**：`go test ./...`、`go build`
- **PHP**：`composer install`、`composer test`、`phpunit`
- **Java**：`mvn test`、`mvn package` 或 `gradle`
- **C#/.NET**：`dotnet restore`、`dotnet build`、`dotnet test`
- **Rust**：`cargo build`、`cargo test`
- **Docker**：`docker build`、`docker compose up`、`docker compose run [service]`
- 其他工具：`make`、`bazel`、`yarn`、`pnpm`、`tox`、`ant` 等。

若命令失败或无法运行，必须记录详细情况与推断理由，不要跳过。

## 4. 检查依赖与配置
- 各语言包管理文件（`package.json`、`requirements.txt`、`composer.json`、`go.mod`、`pom.xml`、`Cargo.toml` 等）是否存在过期或高危依赖、版本锁定、镜像源问题。
- 环境变量、Secrets、证书、密钥是否有泄露或硬编码风险。
- `Dockerfile`、`docker-compose.yml`、`Kubernetes YAML`、`Makefile`、GitHub Actions/GitLab CI 等配置是否齐全、可用。

## 5. 安全与质量审查重点
- 认证、授权、访问控制、会话管理是否可靠。
- 输入验证与输出编码是否充分，是否存在注入、XSS、CSRF、目录遍历等漏洞。
- 业务逻辑是否存在绕过、数据一致性、竞态条件问题。
- 日志与错误处理是否可能泄露敏感信息或引入稳定性风险。

## 6. 输出总结
审计完成后，请提供以下两份 Markdown 报告：

### A. 《审计报告》
- 按严重度排列所有问题，每条需包含：
  - 文件路径、行号（若适用）
  - 问题描述、影响、建议修复方案
  - 触发问题的命令或场景（如构建失败日志）

### B. 《修复计划》
- 按优先级列出需要执行的修复和验证步骤，包括：
  - 建议运行的命令
  - 需要补充的测试或文档

### 补充要求：
- 无论命令成功与否，都要在报告中记录尝试过的操作、结果与结论。
- 如遇无法完成的检查（例如缺少凭证、依赖安装失败等），必须说明原因和后续建议。
- 除非我额外指示，不要直接修改源代码；本任务只输出审计报告与修复计划。

PostgreSQL、MySQL、Redis数据库管理脚本

raylenzed@gmail.com (南风大叔) — Mon, 10 Mar 2025 20:27:18 +0000

PostgreSQL、MySQL、Redis数据库管理脚本

由于需要通过容器部署以上数据库，对Linux又不熟悉，于是使用Grok写了一个数据库管理脚本。如下：

#!/bin/bash

# 容器数据库管理工具
# 支持PostgreSQL、MySQL和Redis容器的管理

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
BLUE='\033[0;34m'
PURPLE='\033[0;35m'
CYAN='\033[0;36m'
NC='\033[0m' # 无颜色

# 全局设置
CLEAR_SCREEN=true  # 是否在菜单间清屏

# 检查Docker是否安装
check_docker() {
  if ! command -v docker &> /dev/null; then
    echo -e "${RED}错误: Docker未安装或不在PATH中。请先安装Docker。${NC}"
    exit 1
  fi
}

# 查找数据库容器
find_containers() {
  echo -e "${BLUE}正在搜索数据库容器...${NC}"

  # 查找PostgreSQL容器
  pg_containers=()
  pg_images=()
  pg_names=()
  pg_running_status=()

  # 获取所有运行中的PostgreSQL容器
  while IFS= read -r container_id; do
    if [ -n "$container_id" ]; then
      pg_containers+=("$container_id")
      pg_images+=("$(docker inspect --format='{{.Config.Image}}' $container_id)")
      pg_names+=("$(docker inspect --format='{{.Name}}' $container_id | sed 's/\///')")
      pg_running_status+=(true)
    fi
  done < <(docker ps | grep -E "postgres|pgvector" | awk '{print $1}')

  # 获取所有已停止的PostgreSQL容器
  while IFS= read -r container_id; do
    if [ -n "$container_id" ] && ! [[ " ${pg_containers[@]} " =~ " ${container_id} " ]]; then
      pg_containers+=("$container_id")
      pg_images+=("$(docker inspect --format='{{.Config.Image}}' $container_id)")
      pg_names+=("$(docker inspect --format='{{.Name}}' $container_id | sed 's/\///')")
      pg_running_status+=(false)
    fi
  done < <(docker ps -a | grep -E "postgres|pgvector" | awk '{print $1}')

  # 查找MySQL容器
  mysql_container=$(docker ps | grep -E "mysql" | awk '{print $1}' | head -1)
  if [ -z "$mysql_container" ]; then
    mysql_container=$(docker ps -a | grep -E "mysql" | awk '{print $1}' | head -1)
    mysql_running=false
  else
    mysql_running=true
  fi

  # 查找Redis容器
  redis_container=$(docker ps | grep -E "redis" | awk '{print $1}' | head -1)
  if [ -z "$redis_container" ]; then
    redis_container=$(docker ps -a | grep -E "redis" | awk '{print $1}' | head -1)
    redis_running=false
  else
    redis_running=true
  fi

  # 获取容器详细信息
  if [ -n "$mysql_container" ]; then
    mysql_image=$(docker inspect --format='{{.Config.Image}}' $mysql_container)
    mysql_name=$(docker inspect --format='{{.Name}}' $mysql_container | sed 's/\///')
  fi

  if [ -n "$redis_container" ]; then
    redis_image=$(docker inspect --format='{{.Config.Image}}' $redis_container)
    redis_name=$(docker inspect --format='{{.Name}}' $redis_container | sed 's/\///')
  fi
}

# 检查容器状态并提供启动选项
check_container_status() {
  local container_id=$1
  local container_name=$2
  local container_image=$3
  local running=$4

  if [ -z "$container_id" ]; then
    echo -e "${YELLOW}未找到${container_name}容器${NC}"
    return 1
  fi

  if [ "$running" = false ]; then
    echo -e "${YELLOW}容器 ${container_name} (${container_id}) 当前已停止${NC}"
    read -p "是否启动该容器? (y/n): " start_choice
    if [[ $start_choice == [yY] || $start_choice == [yY][eE][sS] ]]; then
      echo -e "${BLUE}正在启动容器 ${container_id}...${NC}"
      docker start $container_id
      if [ $? -eq 0 ]; then
        echo -e "${GREEN}容器已成功启动${NC}"
        return 0
      else
        echo -e "${RED}启动容器失败${NC}"
        return 1
      fi
    else
      echo -e "${YELLOW}容器未启动，无法执行管理操作${NC}"
      return 1
    fi
  else
    echo -e "${GREEN}容器 ${container_name} (${container_image}) 正在运行${NC}"
    return 0
  fi
}

# 显示主菜单
show_main_menu() {
  if [ "$CLEAR_SCREEN" = true ]; then
    clear
  else
    echo ""
    echo -e "${BLUE}----------------------------------------${NC}"
    echo ""
  fi

  echo -e "${CYAN}========================================"
  echo -e "      容器数据库管理工具 v1.0"
  echo -e "========================================${NC}"
  echo -e "请选择要管理的数据库:"

  # 显示PostgreSQL容器选项
  if [ ${#pg_containers[@]} -gt 0 ]; then
    echo -e "${GREEN}PostgreSQL 容器:${NC}"
    for i in "${!pg_containers[@]}"; do
      if [ "${pg_running_status[$i]}" = true ]; then
        echo -e "${GREEN}$((i+1))) ${pg_names[$i]} (${pg_images[$i]}) ${GREEN}[运行中]${NC}"
      else
        echo -e "${GREEN}$((i+1))) ${pg_names[$i]} (${pg_images[$i]}) ${RED}[已停止]${NC}"
      fi
    done
  else
    echo -e "${YELLOW}未检测到PostgreSQL容器${NC}"
  fi

  # 显示MySQL选项
  pg_count=${#pg_containers[@]}
  mysql_option=$((pg_count+1))
  if [ -n "$mysql_container" ]; then
    if [ "$mysql_running" = true ]; then
      echo -e "${GREEN}${mysql_option}) MySQL (${mysql_image}) ${GREEN}[运行中]${NC}"
    else
      echo -e "${GREEN}${mysql_option}) MySQL (${mysql_image}) ${RED}[已停止]${NC}"
    fi
  else
    echo -e "${YELLOW}未检测到MySQL容器${NC}"
  fi

  # 显示Redis选项
  redis_option=$((mysql_option+1))
  if [ -n "$redis_container" ]; then
    if [ "$redis_running" = true ]; then
      echo -e "${GREEN}${redis_option}) Redis (${redis_image}) ${GREEN}[运行中]${NC}"
    else
      echo -e "${GREEN}${redis_option}) Redis (${redis_image}) ${RED}[已停止]${NC}"
    fi
  else
    echo -e "${YELLOW}未检测到Redis容器${NC}"
  fi

  # 设置选项
  settings_option=$((redis_option+1))
  echo -e "${GREEN}${settings_option}) 设置${NC}"

  # 退出选项
  exit_option=$((settings_option+1))
  echo -e "${YELLOW}${exit_option}) 退出${NC}"
  echo ""
  read -p "请输入选择 [1-${exit_option}]: " main_choice
}

# 显示设置菜单
show_settings_menu() {
  if [ "$CLEAR_SCREEN" = true ]; then
    clear
  else
    echo ""
    echo -e "${BLUE}----------------------------------------${NC}"
    echo ""
  fi

  echo -e "${CYAN}========================================"
  echo -e "             设置菜单"
  echo -e "========================================${NC}"
  echo -e "当前设置:"
  if [ "$CLEAR_SCREEN" = true ]; then
    echo -e "1) 清屏模式: ${GREEN}开启${NC}"
  else
    echo -e "1) 清屏模式: ${RED}关闭${NC}"
  fi
  echo -e "2) 重置Redis密码"
  echo -e "3) 重置MySQL密码"
  echo -e "4) 重置PostgreSQL密码"
  echo -e "${YELLOW}5) 返回主菜单${NC}"
  echo ""
  read -p "请输入选择 [1-5]: " settings_choice

  case $settings_choice in
    1)
      if [ "$CLEAR_SCREEN" = true ]; then
        CLEAR_SCREEN=false
        echo -e "${YELLOW}清屏模式已关闭${NC}"
      else
        CLEAR_SCREEN=true
        echo -e "${GREEN}清屏模式已开启${NC}"
      fi
      sleep 1
      show_settings_menu
      ;;
    2)
      redis_password=""
      redis_needs_auth=false
      echo -e "${GREEN}Redis密码已重置，下次使用Redis功能时将重新询问密码${NC}"
      sleep 1
      show_settings_menu
      ;;
    3)
      mysql_root_password=""
      echo -e "${GREEN}MySQL密码已重置，下次使用MySQL功能时将重新询问密码${NC}"
      sleep 1
      show_settings_menu
      ;;
    4)
      postgres_password=""
      pg_superuser=""
      echo -e "${GREEN}PostgreSQL密码和超级用户已重置，下次使用PostgreSQL功能时将重新检测${NC}"
      sleep 1
      show_settings_menu
      ;;
    5)
      return
      ;;
    *)
      echo -e "${RED}无效选择，请重试${NC}"
      sleep 1
      show_settings_menu
      ;;
  esac
}

# 检查PostgreSQL容器是否有psql工具
check_psql_in_container() {
  local container_id=$1

  # 尝试在容器中运行psql命令
  if ! docker exec $container_id which psql &>/dev/null; then
    echo -e "${YELLOW}警告: 容器中未找到psql命令。尝试使用PostgreSQL官方客户端容器连接...${NC}"
    return 1
  fi

  return 0
}

# 检测PostgreSQL超级用户
detect_pg_superuser() {
  local container_id=$1

  # 尝试从环境变量获取用户名
  local pg_user=$(docker inspect --format='{{range .Config.Env}}{{if or (eq (index (split . "=") 0) "POSTGRES_USER") (eq (index (split . "=") 0) "POSTGRESQL_USER")}}{{index (split . "=") 1}}{{end}}{{end}}' $container_id)

  # 如果环境变量中没有用户名，尝试使用默认用户名
  if [ -z "$pg_user" ]; then
    # 尝试常见的超级用户名
    local common_users=("postgres" "admin" "root" "master")

    for user in "${common_users[@]}"; do
      if docker exec $container_id psql -U $user -c "SELECT 1" &>/dev/null; then
        echo "$user"
        return 0
      fi
    done

    # 如果找不到超级用户，询问用户
    echo -e "${YELLOW}无法自动检测PostgreSQL超级用户。${NC}"
    read -p "请输入PostgreSQL超级用户名: " pg_user
    echo "$pg_user"
    return 0
  else
    echo "$pg_user"
    return 0
  fi
}

# 使用PostgreSQL客户端容器执行命令
run_pg_command() {
  local container_id=$1
  local command=$2
  local db_name=$3
  local user=${4:-}

  # 如果没有指定用户，尝试检测超级用户
  if [ -z "$user" ]; then
    if [ -z "$pg_superuser" ]; then
      pg_superuser=$(detect_pg_superuser "$container_id")
    fi
    user=$pg_superuser
  fi

  # 获取PostgreSQL容器的网络信息
  local network=$(docker inspect --format='{{range $k, $v := .NetworkSettings.Networks}}{{$k}}{{end}}' $container_id)
  local ip_address=$(docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' $container_id)
  local port=$(docker inspect --format='{{range $p, $conf := .NetworkSettings.Ports}}{{if eq $p "5432/tcp"}}{{(index $conf 0).HostPort}}{{end}}{{end}}' $container_id)

  # 如果没有映射端口，使用默认端口5432
  if [ -z "$port" ]; then
    port="5432"
  fi

  # 获取PostgreSQL密码环境变量
  local pg_password=$(docker inspect --format='{{range .Config.Env}}{{if or (eq (index (split . "=") 0) "POSTGRES_PASSWORD") (eq (index (split . "=") 0) "POSTGRESQL_PASSWORD")}}{{index (split . "=") 1}}{{end}}{{end}}' $container_id)

  # 如果没有找到密码环境变量，询问用户
  if [ -z "$pg_password" ]; then
    if [ -z "$postgres_password" ]; then
      echo -e "${YELLOW}需要PostgreSQL密码来执行管理操作${NC}"
      read -s -p "请输入PostgreSQL密码: " postgres_password
      echo ""
      pg_password=$postgres_password
    else
      pg_password=$postgres_password
    fi
  else
    postgres_password=$pg_password
  fi

  # 创建临时脚本
  local temp_script=$(mktemp)
  echo "#!/bin/bash" > $temp_script
  echo "export PGPASSWORD='$pg_password'" >> $temp_script

  if [ -n "$db_name" ]; then
    echo "psql -h $ip_address -p $port -U $user -d $db_name -c \"$command\"" >> $temp_script
  else
    echo "psql -h $ip_address -p $port -U $user -c \"$command\"" >> $temp_script
  fi

  chmod +x $temp_script

  # 使用PostgreSQL客户端容器执行命令
  local output=$(docker run --rm --network $network -v $temp_script:/tmp/script.sh postgres:14-alpine /tmp/script.sh)
  echo "$output"

  # 删除临时脚本
  rm $temp_script
}

# PostgreSQL菜单
show_postgres_menu() {
  # 选择PostgreSQL容器
  if [ ${#pg_containers[@]} -gt 1 ]; then
    if [ "$CLEAR_SCREEN" = true ]; then
      clear
    else
      echo ""
      echo -e "${BLUE}----------------------------------------${NC}"
      echo ""
    fi

    echo -e "${CYAN}========================================"
    echo -e "         选择PostgreSQL容器"
    echo -e "========================================${NC}"
    echo -e "请选择要管理的PostgreSQL容器:"

    for i in "${!pg_containers[@]}"; do
      if [ "${pg_running_status[$i]}" = true ]; then
        echo -e "${GREEN}$((i+1))) ${pg_names[$i]} (${pg_images[$i]}) ${GREEN}[运行中]${NC}"
      else
        echo -e "${GREEN}$((i+1))) ${pg_names[$i]} (${pg_images[$i]}) ${RED}[已停止]${NC}"
      fi
    done

    echo -e "${YELLOW}$((${#pg_containers[@]}+1))) 返回主菜单${NC}"
    echo ""
    read -p "请输入选择 [1-$((${#pg_containers[@]}+1))]: " pg_container_choice

    if [ "$pg_container_choice" -eq $((${#pg_containers[@]}+1)) ]; then
      return
    fi

    if [ "$pg_container_choice" -lt 1 ] || [ "$pg_container_choice" -gt ${#pg_containers[@]} ]; then
      echo -e "${RED}无效选择，请重试${NC}"
      sleep 1
      show_postgres_menu
      return
    fi

    pg_container_index=$((pg_container_choice-1))
    pg_container=${pg_containers[$pg_container_index]}
    pg_image=${pg_images[$pg_container_index]}
    pg_name=${pg_names[$pg_container_index]}
    pg_running=${pg_running_status[$pg_container_index]}
  else
    pg_container=${pg_containers[0]}
    pg_image=${pg_images[0]}
    pg_name=${pg_names[0]}
    pg_running=${pg_running_status[0]}
  fi

  if ! check_container_status "$pg_container" "PostgreSQL" "$pg_image" "$pg_running"; then
    read -p "按回车键返回主菜单..." temp
    return
  fi

  # 检查容器中是否有psql工具
  has_psql=true
  if ! check_psql_in_container "$pg_container"; then
    has_psql=false
    echo -e "${YELLOW}将使用PostgreSQL客户端容器执行命令${NC}"
    sleep 2
  fi

  # 检测PostgreSQL超级用户
  if [ -z "$pg_superuser" ]; then
    pg_superuser=$(detect_pg_superuser "$pg_container")
    echo -e "${GREEN}检测到PostgreSQL超级用户: $pg_superuser${NC}"
    sleep 1
  fi

  # 获取PostgreSQL密码
  if [ "$has_psql" = true ]; then
    # 如果容器有psql，尝试获取密码环境变量
    postgres_password=$(docker inspect --format='{{range .Config.Env}}{{if or (eq (index (split . "=") 0) "POSTGRES_PASSWORD") (eq (index (split . "=") 0) "POSTGRESQL_PASSWORD")}}{{index (split . "=") 1}}{{end}}{{end}}' $pg_container)

    # 如果没有找到密码环境变量，询问用户
    if [ -z "$postgres_password" ]; then
      echo -e "${YELLOW}需要PostgreSQL密码来执行管理操作${NC}"
      read -s -p "请输入PostgreSQL密码: " postgres_password
      echo ""
    fi
  fi

  while true; do
    if [ "$CLEAR_SCREEN" = true ]; then
      clear
    else
      echo ""
      echo -e "${BLUE}----------------------------------------${NC}"
      echo ""
    fi

    echo -e "${CYAN}========================================"
    echo -e "         PostgreSQL 管理菜单"
    echo -e "========================================${NC}"
    echo -e "当前连接的容器: ${GREEN}${pg_image}${NC} (${YELLOW}${pg_container}${NC})"
    echo -e "使用超级用户: ${GREEN}${pg_superuser}${NC}"
    echo ""
    echo -e "请选择操作:"
    echo -e "${GREEN}1) 创建用户和数据库${NC}"
    echo -e "${GREEN}2) 查询所有用户和数据库${NC}"
    echo -e "${GREEN}3) 删除用户或数据库${NC}"
    echo -e "${GREEN}4) 开启PGVector插件${NC}"
    echo -e "${YELLOW}5) 返回主菜单${NC}"
    echo ""
    read -p "请输入选择 [1-5]: " pg_choice

    case $pg_choice in
      1) create_postgres_user_db ;;
      2) list_postgres_users_dbs ;;
      3) delete_postgres_user_db ;;
      4) enable_pgvector ;;
      5) break ;;
      *) echo -e "${RED}无效选择，请重试${NC}" 
         sleep 1 ;;
    esac
  done
}

# MySQL菜单
show_mysql_menu() {
  if ! check_container_status "$mysql_container" "MySQL" "$mysql_image" "$mysql_running"; then
    read -p "按回车键返回主菜单..." temp
    return
  fi

  # 第一次进入MySQL菜单，获取root密码
  if [ -z "$mysql_root_password" ]; then
    # 尝试从环境变量获取密码
    mysql_root_password=$(docker inspect --format='{{range .Config.Env}}{{if eq (index (split . "=") 0) "MYSQL_ROOT_PASSWORD"}}{{index (split . "=") 1}}{{end}}{{end}}' $mysql_container)

    # 如果没有找到密码环境变量，询问用户
    if [ -z "$mysql_root_password" ]; then
      echo -e "${YELLOW}需要MySQL root密码来执行管理操作${NC}"
      read -s -p "请输入MySQL root密码: " mysql_root_password
      echo ""
    else
      echo -e "${GREEN}已从容器环境变量中获取MySQL root密码${NC}"
      sleep 1
    fi

    # 验证密码是否正确
    if ! docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "SELECT 1" >/dev/null 2>&1; then
      echo -e "${RED}密码验证失败，无法连接到MySQL${NC}"
      mysql_root_password=""
      read -p "按回车键返回主菜单..." temp
      return
    fi
    echo -e "${GREEN}密码验证成功${NC}"
  fi

  while true; do
    if [ "$CLEAR_SCREEN" = true ]; then
      clear
    else
      echo ""
      echo -e "${BLUE}----------------------------------------${NC}"
      echo ""
    fi

    echo -e "${CYAN}========================================"
    echo -e "           MySQL 管理菜单"
    echo -e "========================================${NC}"
    echo -e "当前连接的容器: ${GREEN}${mysql_image}${NC} (${YELLOW}${mysql_container}${NC})"
    echo ""
    echo -e "请选择操作:"
    echo -e "${GREEN}1) 创建用户和数据库${NC}"
    echo -e "${GREEN}2) 查询所有用户和数据库${NC}"
    echo -e "${GREEN}3) 删除用户或数据库${NC}"
    echo -e "${YELLOW}4) 返回主菜单${NC}"
    echo ""
    read -p "请输入选择 [1-4]: " mysql_choice

    case $mysql_choice in
      1) create_mysql_user_db ;;
      2) list_mysql_users_dbs ;;
      3) delete_mysql_user_db ;;
      4) break ;;
      *) echo -e "${RED}无效选择，请重试${NC}" 
         sleep 1 ;;
    esac
  done
}

# Redis菜单
show_redis_menu() {
  if ! check_container_status "$redis_container" "Redis" "$redis_image" "$redis_running"; then
    read -p "按回车键返回主菜单..." temp
    return
  fi

  # 检查是否需要Redis密码
  if [ -z "$redis_password" ]; then
    # 默认假设Redis需要密码
    redis_needs_auth=true

    # 尝试从环境变量获取密码
    redis_password=$(docker inspect --format='{{range .Config.Env}}{{if or (eq (index (split . "=") 0) "REDIS_PASSWORD") (eq (index (split . "=") 0) "REDIS_PASS") (eq (index (split . "=") 0) "REDIS_AUTH")}}{{index (split . "=") 1}}{{end}}{{end}}' $redis_container)

    # 如果环境变量中没有密码，询问用户
    if [ -z "$redis_password" ]; then
      echo -e "${YELLOW}Redis可能需要密码认证${NC}"
      read -s -p "请输入Redis密码 (如果不需要密码，直接按回车): " redis_password
      echo ""
    else
      echo -e "${GREEN}已从容器环境变量中获取Redis密码${NC}"
      sleep 1
    fi

    # 测试无密码连接
    if [ -z "$redis_password" ] && docker exec $redis_container redis-cli ping >/dev/null 2>&1; then
      echo -e "${GREEN}Redis不需要密码认证${NC}"
      redis_needs_auth=false
      sleep 1
    elif [ -n "$redis_password" ]; then
      # 验证密码是否正确
      if ! docker exec $redis_container redis-cli -a "$redis_password" --no-auth-warning ping >/dev/null 2>&1; then
        echo -e "${RED}密码验证失败，无法连接到Redis${NC}"

        # 再次尝试获取密码
        echo -e "${YELLOW}请再次尝试输入Redis密码${NC}"
        read -s -p "请输入Redis密码: " redis_password
        echo ""

        # 再次验证密码
        if ! docker exec $redis_container redis-cli -a "$redis_password" --no-auth-warning ping >/dev/null 2>&1; then
          echo -e "${RED}密码验证再次失败${NC}"

          # 尝试一些常见的默认密码
          echo -e "${YELLOW}尝试常见的默认密码...${NC}"
          for default_pass in "redis" "admin" "password" "123456" "root"; do
            echo -e "${BLUE}尝试密码: $default_pass${NC}"
            if docker exec $redis_container redis-cli -a "$default_pass" --no-auth-warning ping >/dev/null 2>&1; then
              redis_password=$default_pass
              echo -e "${GREEN}找到有效密码: $default_pass${NC}"
              sleep 1
              break
            fi
          done

          # 如果仍然失败，提示用户手动输入正确的密码
          if ! docker exec $redis_container redis-cli -a "$redis_password" --no-auth-warning ping >/dev/null 2>&1; then
            echo -e "${RED}无法自动找到有效的Redis密码${NC}"
            echo -e "${YELLOW}请确保输入正确的Redis密码，或者检查Redis配置${NC}"
            read -p "按回车键继续，将尝试使用当前密码..." temp
          fi
        else
          echo -e "${GREEN}密码验证成功${NC}"
        fi
      else
        echo -e "${GREEN}密码验证成功${NC}"
      fi
    else
      echo -e "${RED}无法连接到Redis，可能需要密码${NC}"
      echo -e "${YELLOW}请输入Redis密码${NC}"
      read -s -p "请输入Redis密码: " redis_password
      echo ""

      # 验证密码
      if ! docker exec $redis_container redis-cli -a "$redis_password" --no-auth-warning ping >/dev/null 2>&1; then
        echo -e "${RED}密码验证失败${NC}"
        echo -e "${YELLOW}将尝试使用当前密码继续操作，如果操作失败，请在设置菜单中重置Redis密码${NC}"
        read -p "按回车键继续..." temp
      else
        echo -e "${GREEN}密码验证成功${NC}"
      fi
    fi
  fi

  while true; do
    if [ "$CLEAR_SCREEN" = true ]; then
      clear
    else
      echo ""
      echo -e "${BLUE}----------------------------------------${NC}"
      echo ""
    fi

    echo -e "${CYAN}========================================"
    echo -e "           Redis 管理菜单"
    echo -e "========================================${NC}"
    echo -e "当前连接的容器: ${GREEN}${redis_image}${NC} (${YELLOW}${redis_container}${NC})"
    if [ "$redis_needs_auth" = true ] && [ -n "$redis_password" ]; then
      echo -e "认证状态: ${GREEN}已认证 (使用密码)${NC}"
    elif [ "$redis_needs_auth" = false ]; then
      echo -e "认证状态: ${GREEN}无需密码${NC}"
    else
      echo -e "认证状态: ${RED}未认证${NC}"
    fi
    echo ""
    echo -e "请选择操作:"
    echo -e "${GREEN}1) 查看Redis信息${NC}"
    echo -e "${GREEN}2) 查看内存使用${NC}"
    echo -e "${GREEN}3) 查看键值统计${NC}"
    echo -e "${GREEN}4) 设置Redis密码${NC}"
    echo -e "${YELLOW}5) 返回主菜单${NC}"
    echo ""
    read -p "请输入选择 [1-5]: " redis_choice

    case $redis_choice in
      1) show_redis_info ;;
      2) show_redis_memory ;;
      3) show_redis_keys ;;
      4) set_redis_password ;;
      5) break ;;
      *) echo -e "${RED}无效选择，请重试${NC}" 
         sleep 1 ;;
    esac
  done
}

# Redis功能:设置Redis密码
set_redis_password() {
  if [ "$CLEAR_SCREEN" = true ]; then
    clear
  else
    echo ""
    echo -e "${BLUE}----------------------------------------${NC}"
    echo ""
  fi

  echo -e "${CYAN}========================================"
  echo -e "           设置Redis密码"
  echo -e "========================================${NC}"
  echo ""

  echo -e "${YELLOW}请输入Redis密码:${NC}"
  read -s -p "密码: " new_redis_password
  echo ""

  # 测试新密码
  if [ -z "$new_redis_password" ]; then
    echo -e "${YELLOW}尝试无密码连接...${NC}"
    if docker exec $redis_container redis-cli ping >/dev/null 2>&1; then
      echo -e "${GREEN}无密码连接成功${NC}"
      redis_password=""
      redis_needs_auth=false
    else
      echo -e "${RED}无密码连接失败，Redis可能需要密码${NC}"
      redis_needs_auth=true
    fi
  else
    echo -e "${YELLOW}尝试使用新密码连接...${NC}"
    if docker exec $redis_container redis-cli -a "$new_redis_password" --no-auth-warning ping >/dev/null 2>&1; then
      echo -e "${GREEN}密码验证成功${NC}"
      redis_password=$new_redis_password
      redis_needs_auth=true
    else
      echo -e "${RED}密码验证失败${NC}"
      echo -e "${YELLOW}保留原密码设置${NC}"
    fi
  fi

  read -p "按回车键继续..." temp
}

# PostgreSQL功能:创建用户和数据库
create_postgres_user_db() {
  if [ "$CLEAR_SCREEN" = true ]; then
    clear
  else
    echo ""
    echo -e "${BLUE}----------------------------------------${NC}"
    echo ""
  fi

  echo -e "${CYAN}========================================"
  echo -e "       创建PostgreSQL用户和数据库"
  echo -e "========================================${NC}"
  echo ""

  # 获取基础名称
  read -p "请输入基础名称 (如输入lobe将创建lobe_user和lobe_db): " base_name
  if [ -z "$base_name" ]; then
    echo -e "${RED}错误: 名称不能为空${NC}"
    read -p "按回车键继续..." temp
    return
  fi

  # 检查名称格式
  if ! [[ $base_name =~ ^[a-zA-Z0-9_]+$ ]]; then
    echo -e "${RED}错误: 名称只能包含字母、数字和下划线${NC}"
    read -p "按回车键继续..." temp
    return
  fi

  user_name="${base_name}_user"
  db_name="${base_name}_db"

  # 检查用户名是否已存在
  echo -e "${BLUE}检查用户是否存在...${NC}"
  if [ "$has_psql" = true ]; then
    exists=$(docker exec $pg_container psql -U $pg_superuser -tAc "SELECT 1 FROM pg_roles WHERE rolname='$user_name'")
  else
    exists=$(run_pg_command "$pg_container" "SELECT 1 FROM pg_roles WHERE rolname='$user_name'" "" "$pg_superuser")
  fi

  if [[ $exists == *"1"* ]]; then
    echo -e "${RED}错误: 用户 $user_name 已经存在${NC}"
    read -p "按回车键继续..." temp
    return
  fi

  # 检查数据库是否已存在
  echo -e "${BLUE}检查数据库是否存在...${NC}"
  if [ "$has_psql" = true ]; then
    exists=$(docker exec $pg_container psql -U $pg_superuser -tAc "SELECT 1 FROM pg_database WHERE datname='$db_name'")
  else
    exists=$(run_pg_command "$pg_container" "SELECT 1 FROM pg_database WHERE datname='$db_name'" "" "$pg_superuser")
  fi

  if [[ $exists == *"1"* ]]; then
    echo -e "${RED}错误: 数据库 $db_name 已经存在${NC}"
    read -p "按回车键继续..." temp
    return
  fi

  # 获取密码
  read -s -p "请设置用户密码: " password
  echo ""
  read -s -p "确认密码: " password_confirm
  echo ""

  if [ "$password" != "$password_confirm" ]; then
    echo -e "${RED}错误: 两次输入的密码不匹配${NC}"
    read -p "按回车键继续..." temp
    return
  fi

  echo -e "${BLUE}创建用户 $user_name...${NC}"
  if [ "$has_psql" = true ]; then
    if ! docker exec $pg_container psql -U $pg_superuser -c "CREATE USER $user_name WITH PASSWORD '$password';" >/dev/null 2>&1; then
      echo -e "${RED}创建用户失败${NC}"
      read -p "按回车键继续..." temp
      return
    fi
  else
    if ! run_pg_command "$pg_container" "CREATE USER $user_name WITH PASSWORD '$password';" "" "$pg_superuser" >/dev/null 2>&1; then
      echo -e "${RED}创建用户失败${NC}"
      read -p "按回车键继续..." temp
      return
    fi
  fi
  echo -e "${GREEN}成功${NC}"

  echo -e "${BLUE}创建数据库 $db_name...${NC}"
  if [ "$has_psql" = true ]; then
    if ! docker exec $pg_container psql -U $pg_superuser -c "CREATE DATABASE $db_name OWNER $user_name;" >/dev/null 2>&1; then
      echo -e "${RED}创建数据库失败${NC}"
      echo -e "${YELLOW}正在回滚，删除已创建的用户...${NC}"
      docker exec $pg_container psql -U $pg_superuser -c "DROP USER $user_name;" >/dev/null 2>&1
      read -p "按回车键继续..." temp
      return
    fi
  else
    if ! run_pg_command "$pg_container" "CREATE DATABASE $db_name OWNER $user_name;" "" "$pg_superuser" >/dev/null 2>&1; then
      echo -e "${RED}创建数据库失败${NC}"
      echo -e "${YELLOW}正在回滚，删除已创建的用户...${NC}"
      run_pg_command "$pg_container" "DROP USER $user_name;" "" "$pg_superuser" >/dev/null 2>&1
      read -p "按回车键继续..." temp
      return
    fi
  fi
  echo -e "${GREEN}成功${NC}"

  echo -e "${BLUE}授予用户 $user_name 对数据库 $db_name 的全部权限...${NC}"
  if [ "$has_psql" = true ]; then
    if ! docker exec $pg_container psql -U $pg_superuser -c "GRANT ALL PRIVILEGES ON DATABASE $db_name TO $user_name;" >/dev/null 2>&1; then
      echo -e "${RED}授权失败${NC}"
      read -p "按回车键继续..." temp
      return
    fi
  else
    if ! run_pg_command "$pg_container" "GRANT ALL PRIVILEGES ON DATABASE $db_name TO $user_name;" "" "$pg_superuser" >/dev/null 2>&1; then
      echo -e "${RED}授权失败${NC}"
      read -p "按回车键继续..." temp
      return
    fi
  fi
  echo -e "${GREEN}成功${NC}"

  # 询问是否开启PGVector插件
  read -p "是否开启PGVector插件? (y/n): " enable_vector
  if [[ $enable_vector == [yY] || $enable_vector == [yY][eE][sS] ]]; then
    echo -e "${BLUE}在数据库 $db_name 中开启PGVector插件...${NC}"
    if [ "$has_psql" = true ]; then
      if ! docker exec $pg_container psql -U $pg_superuser -d $db_name -c "CREATE EXTENSION IF NOT EXISTS vector;" >/dev/null 2>&1; then
        echo -e "${RED}执行CREATE EXTENSION命令失败${NC}"
        read -p "按回车键继续..." temp
        return
      fi
      # 验证是否启用成功
      vector_enabled=$(docker exec $pg_container psql -U $pg_superuser -d $db_name -tAc "SELECT 1 FROM pg_extension WHERE extname='vector'")
      if [[ $vector_enabled == *"1"* ]]; then
        vector_version=$(docker exec $pg_container psql -U $pg_superuser -d $db_name -tAc "SELECT extversion FROM pg_extension WHERE extname='vector'")
        echo -e "${GREEN}PGVector 插件已成功启用 (版本: $vector_version)${NC}"
      else
        echo -e "${RED}PGVector 插件未能启用，请检查容器配置${NC}"
        read -p "按回车键继续..." temp
        return
      fi
    else
      if ! run_pg_command "$pg_container" "CREATE EXTENSION IF NOT EXISTS vector;" "$db_name" "$pg_superuser" >/dev/null 2>&1; then
        echo -e "${RED}执行CREATE EXTENSION命令失败${NC}"
        read -p "按回车键继续..." temp
        return
      fi
      # 验证是否启用成功
      vector_enabled=$(run_pg_command "$pg_container" "SELECT 1 FROM pg_extension WHERE extname='vector'" "$db_name" "$pg_superuser")
      if [[ $vector_enabled == *"1"* ]]; then
        vector_version=$(run_pg_command "$pg_container" "SELECT extversion FROM pg_extension WHERE extname='vector'" "$db_name" "$pg_superuser")
        echo -e "${GREEN}PGVector 插件已成功启用 (版本: $vector_version)${NC}"
      else
        echo -e "${RED}PGVector 插件未能启用，请检查容器配置${NC}"
        read -p "按回车键继续..." temp
        return
      fi
    fi
  fi

  echo -e "${GREEN}操作完成!${NC}"
  read -p "按回车键继续..." temp
}

# PostgreSQL功能:查询所有用户和数据库
list_postgres_users_dbs() {
  if [ "$CLEAR_SCREEN" = true ]; then
    clear
  else
    echo ""
    echo -e "${BLUE}----------------------------------------${NC}"
    echo ""
  fi

  echo -e "${CYAN}========================================"
  echo -e "      PostgreSQL 用户和数据库列表"
  echo -e "========================================${NC}"
  echo ""

  echo -e "${YELLOW}数据库列表:${NC}"
  if [ "$has_psql" = true ]; then
    docker exec $pg_container psql -U $pg_superuser -c "SELECT datname AS database_name, pg_size_pretty(pg_database_size(datname)) AS size FROM pg_database WHERE datistemplate = false ORDER BY datname;"
  else
    run_pg_command "$pg_container" "SELECT datname AS database_name, pg_size_pretty(pg_database_size(datname)) AS size FROM pg_database WHERE datistemplate = false ORDER BY datname;" "" "$pg_superuser"
  fi
  echo ""

  echo -e "${YELLOW}用户列表:${NC}"
  if [ "$has_psql" = true ]; then
    docker exec $pg_container psql -U $pg_superuser -c "SELECT rolname AS user_name, rolsuper AS is_superuser FROM pg_roles WHERE rolname NOT LIKE 'pg_%' ORDER BY rolname;"
  else
    run_pg_command "$pg_container" "SELECT rolname AS user_name, rolsuper AS is_superuser FROM pg_roles WHERE rolname NOT LIKE 'pg_%' ORDER BY rolname;" "" "$pg_superuser"
  fi
  echo ""

  echo -e "${YELLOW}用户权限:${NC}"
  if [ "$has_psql" = true ]; then
    docker exec $pg_container psql -U $pg_superuser -c "SELECT DISTINCT grantee AS user_name, table_catalog AS database_name, privilege_type FROM information_schema.table_privileges WHERE grantee NOT LIKE 'pg_%' ORDER BY grantee, table_catalog;"
  else
    run_pg_command "$pg_container" "SELECT DISTINCT grantee AS user_name, table_catalog AS database_name, privilege_type FROM information_schema.table_privileges WHERE grantee NOT LIKE 'pg_%' ORDER BY grantee, table_catalog;" "" "$pg_superuser"
  fi

  read -p "按回车键继续..." temp
}

# PostgreSQL功能:删除用户或数据库
delete_postgres_user_db() {
  if [ "$CLEAR_SCREEN" = true ]; then
    clear
  else
    echo ""
    echo -e "${BLUE}----------------------------------------${NC}"
    echo ""
  fi

  echo -e "${CYAN}========================================"
  echo -e "        删除PostgreSQL用户或数据库"
  echo -e "========================================${NC}"
  echo ""

  echo -e "请选择要删除的对象:"
  echo -e "${GREEN}1) 用户${NC}"
  echo -e "${GREEN}2) 数据库${NC}"
  echo -e "${YELLOW}3) 返回上级菜单${NC}"
  echo ""
  read -p "请输入选择 [1-3]: " delete_choice

  case $delete_choice in
    1) # 删除用户
      echo -e "${YELLOW}当前PostgreSQL用户列表:${NC}"
      if [ "$has_psql" = true ]; then
        docker exec $pg_container psql -U $pg_superuser -c "SELECT rolname AS user_name FROM pg_roles WHERE rolname NOT LIKE 'pg_%' AND rolname != '$pg_superuser' ORDER BY rolname;"
      else
        run_pg_command "$pg_container" "SELECT rolname AS user_name FROM pg_roles WHERE rolname NOT LIKE 'pg_%' AND rolname != '$pg_superuser' ORDER BY rolname;" "" "$pg_superuser"
      fi
      echo ""

      read -p "请输入要删除的用户名: " user_name
      if [ -z "$user_name" ]; then
        echo -e "${RED}错误: 用户名不能为空${NC}"
        read -p "按回车键继续..." temp
        return
      fi

      # 检查用户是否存在
      if [ "$has_psql" = true ]; then
        exists=$(docker exec $pg_container psql -U $pg_superuser -tAc "SELECT 1 FROM pg_roles WHERE rolname='$user_name'")
      else
        exists=$(run_pg_command "$pg_container" "SELECT 1 FROM pg_roles WHERE rolname='$user_name'" "" "$pg_superuser")
      fi

      if ! [[ $exists == *"1"* ]]; then
        echo -e "${RED}错误: 用户 $user_name 不存在${NC}"
        read -p "按回车键继续..." temp
        return
      fi

      # 检查关联的数据库
      if [ "$has_psql" = true ]; then
        associated_db=$(docker exec $pg_container psql -U $pg_superuser -tAc "SELECT datname FROM pg_database WHERE datdba = (SELECT oid FROM pg_roles WHERE rolname='$user_name') LIMIT 1")
      else
        associated_db=$(run_pg_command "$pg_container" "SELECT datname FROM pg_database WHERE datdba = (SELECT oid FROM pg_roles WHERE rolname='$user_name') LIMIT 1" "" "$pg_superuser")
      fi

      if [ -n "$associated_db" ]; then
        echo -e "${YELLOW}检测到关联的数据库: $associated_db${NC}"
        read -p "是否同时删除关联的数据库? (y/n): " delete_db

        if [[ $delete_db == [yY] || $delete_db == [yY][eE][sS] ]]; then
          echo -e "${BLUE}删除数据库 $associated_db...${NC}"
          if [ "$has_psql" = true ]; then
            if ! docker exec $pg_container psql -U $pg_superuser -c "DROP DATABASE $associated_db;" >/dev/null 2>&1; then
              echo -e "${RED}删除数据库失败${NC}"
              read -p "按回车键继续..." temp
              return
            fi
          else
            if ! run_pg_command "$pg_container" "DROP DATABASE $associated_db;" "" "$pg_superuser" >/dev/null 2>&1; then
              echo -e "${RED}删除数据库失败${NC}"
              read -p "按回车键继续..." temp
              return
            fi
          fi
          echo -e "${GREEN}成功${NC}"
        fi
      fi

      echo -e "${BLUE}删除用户 $user_name...${NC}"
      if [ "$has_psql" = true ]; then
        if ! docker exec $pg_container psql -U $pg_superuser -c "DROP USER $user_name;" >/dev/null 2>&1; then
          echo -e "${RED}删除用户失败${NC}"
          read -p "按回车键继续..." temp
          return
        fi
      else
        if ! run_pg_command "$pg_container" "DROP USER $user_name;" "" "$pg_superuser" >/dev/null 2>&1; then
          echo -e "${RED}删除用户失败${NC}"
          read -p "按回车键继续..." temp
          return
        fi
      fi
      echo -e "${GREEN}成功${NC}"
      ;;

    2) # 删除数据库
      echo -e "${YELLOW}当前PostgreSQL数据库列表:${NC}"
      if [ "$has_psql" = true ]; then
        docker exec $pg_container psql -U $pg_superuser -c "SELECT datname AS database_name FROM pg_database WHERE datistemplate = false AND datname != 'postgres' ORDER BY datname;"
      else
        run_pg_command "$pg_container" "SELECT datname AS database_name FROM pg_database WHERE datistemplate = false AND datname != 'postgres' ORDER BY datname;" "" "$pg_superuser"
      fi
      echo ""

      read -p "请输入要删除的数据库名: " db_name
      if [ -z "$db_name" ]; then
        echo -e "${RED}错误: 数据库名不能为空${NC}"
        read -p "按回车键继续..." temp
        return
      fi

      # 检查数据库是否存在
      if [ "$has_psql" = true ]; then
        exists=$(docker exec $pg_container psql -U $pg_superuser -tAc "SELECT 1 FROM pg_database WHERE datname='$db_name'")
      else
        exists=$(run_pg_command "$pg_container" "SELECT 1 FROM pg_database WHERE datname='$db_name'" "" "$pg_superuser")
      fi

      if ! [[ $exists == *"1"* ]]; then
        echo -e "${RED}错误: 数据库 $db_name 不存在${NC}"
        read -p "按回车键继续..." temp
        return
      fi

      # 检查拥有该数据库的用户
      if [ "$has_psql" = true ]; then
        owner=$(docker exec $pg_container psql -U $pg_superuser -tAc "SELECT rolname FROM pg_roles WHERE oid = (SELECT datdba FROM pg_database WHERE datname='$db_name')")
      else
        owner=$(run_pg_command "$pg_container" "SELECT rolname FROM pg_roles WHERE oid = (SELECT datdba FROM pg_database WHERE datname='$db_name')" "" "$pg_superuser")
      fi

      if [ "$owner" != "$pg_superuser" ]; then
        echo -e "${YELLOW}检测到数据库所有者: $owner${NC}"
        read -p "是否同时删除数据库所有者? (y/n): " delete_owner

        if [[ $delete_owner == [yY] || $delete_owner == [yY][eE][sS] ]]; then
          # 先删数据库再删用户
          delete_owner_later=true
        fi
      fi

      echo -e "${BLUE}删除数据库 $db_name...${NC}"
      if [ "$has_psql" = true ]; then
        if ! docker exec $pg_container psql -U $pg_superuser -c "DROP DATABASE $db_name;" >/dev/null 2>&1; then
          echo -e "${RED}删除数据库失败${NC}"
          read -p "按回车键继续..." temp
          return
        fi
      else
        if ! run_pg_command "$pg_container" "DROP DATABASE $db_name;" "" "$pg_superuser" >/dev/null 2>&1; then
          echo -e "${RED}删除数据库失败${NC}"
          read -p "按回车键继续..." temp
          return
        fi
      fi
      echo -e "${GREEN}成功${NC}"

      if [ "$delete_owner_later" = true ]; then
        echo -e "${BLUE}删除用户 $owner...${NC}"
        if [ "$has_psql" = true ]; then
          if ! docker exec $pg_container psql -U $pg_superuser -c "DROP USER $owner;" >/dev/null 2>&1; then
            echo -e "${RED}删除用户失败${NC}"
            read -p "按回车键继续..." temp
            return
          fi
        else
          if ! run_pg_command "$pg_container" "DROP USER $owner;" "" "$pg_superuser" >/dev/null 2>&1; then
            echo -e "${RED}删除用户失败${NC}"
            read -p "按回车键继续..." temp
            return
          fi
        fi
        echo -e "${GREEN}成功${NC}"
      fi
      ;;

    3) return ;;
    *) echo -e "${RED}无效选择，请重试${NC}" 
       sleep 1
       delete_postgres_user_db
       ;;
  esac

  echo -e "${GREEN}操作完成!${NC}"
  read -p "按回车键继续..." temp
}

# PostgreSQL功能:开启PGVector插件
enable_pgvector() {
  if [ "$CLEAR_SCREEN" = true ]; then
    clear
  else
    echo ""
    echo -e "${BLUE}----------------------------------------${NC}"
    echo ""
  fi

  echo -e "${CYAN}========================================"
  echo -e "        开启PostgreSQL PGVector插件"
  echo -e "========================================${NC}"
  echo ""

  echo -e "${YELLOW}可用的数据库列表:${NC}"
  if [ "$has_psql" = true ]; then
    docker exec $pg_container psql -U $pg_superuser -c "SELECT datname AS database_name FROM pg_database WHERE datistemplate = false AND datname != 'postgres' ORDER BY datname;"
  else
    run_pg_command "$pg_container" "SELECT datname AS database_name FROM pg_database WHERE datistemplate = false AND datname != 'postgres' ORDER BY datname;" "" "$pg_superuser"
  fi
  echo ""

  read -p "请输入要开启PGVector插件的数据库名: " db_name
  if [ -z "$db_name" ]; then
    echo -e "${RED}错误: 数据库名不能为空${NC}"
    read -p "按回车键继续..." temp
    return
  fi

  # 检查数据库是否存在
  if [ "$has_psql" = true ]; then
    exists=$(docker exec $pg_container psql -U $pg_superuser -tAc "SELECT 1 FROM pg_database WHERE datname='$db_name'")
  else
    exists=$(run_pg_command "$pg_container" "SELECT 1 FROM pg_database WHERE datname='$db_name'" "" "$pg_superuser")
  fi

  if ! [[ $exists == *"1"* ]]; then
    echo -e "${RED}错误: 数据库 $db_name 不存在${NC}"
    read -p "按回车键继续..." temp
    return
  fi

  echo -e "${BLUE}在数据库 $db_name 中开启PGVector插件...${NC}"
  if [ "$has_psql" = true ]; then
    if ! docker exec $pg_container psql -U $pg_superuser -d $db_name -c "CREATE EXTENSION IF NOT EXISTS vector;" >/dev/null 2>&1; then
      echo -e "${RED}执行CREATE EXTENSION命令失败${NC}"
      read -p "按回车键继续..." temp
      return
    fi
    # 验证是否启用成功
    vector_enabled=$(docker exec $pg_container psql -U $pg_superuser -d $db_name -tAc "SELECT 1 FROM pg_extension WHERE extname='vector'")
    if [[ $vector_enabled == *"1"* ]]; then
      vector_version=$(docker exec $pg_container psql -U $pg_superuser -d $db_name -tAc "SELECT extversion FROM pg_extension WHERE extname='vector'")
      echo -e "${GREEN}PGVector 插件已成功启用 (版本: $vector_version)${NC}"
    else
      echo -e "${RED}PGVector 插件未能启用，请检查容器配置${NC}"
      read -p "按回车键继续..." temp
      return
    fi
  else
    if ! run_pg_command "$pg_container" "CREATE EXTENSION IF NOT EXISTS vector;" "$db_name" "$pg_superuser" >/dev/null 2>&1; then
      echo -e "${RED}执行CREATE EXTENSION命令失败${NC}"
      read -p "按回车键继续..." temp
      return
    fi
    # 验证是否启用成功
    vector_enabled=$(run_pg_command "$pg_container" "SELECT 1 FROM pg_extension WHERE extname='vector'" "$db_name" "$pg_superuser")
    if [[ $vector_enabled == *"1"* ]]; then
      vector_version=$(run_pg_command "$pg_container" "SELECT extversion FROM pg_extension WHERE extname='vector'" "$db_name" "$pg_superuser")
      echo -e "${GREEN}PGVector 插件已成功启用 (版本: $vector_version)${NC}"
    else
      echo -e "${RED}PGVector 插件未能启用，请检查容器配置${NC}"
      read -p "按回车键继续..." temp
      return
    fi
  fi

  echo -e "${GREEN}操作完成!${NC}"
  read -p "按回车键继续..." temp
}

# MySQL功能:创建用户和数据库
create_mysql_user_db() {
  if [ "$CLEAR_SCREEN" = true ]; then
    clear
  else
    echo ""
    echo -e "${BLUE}----------------------------------------${NC}"
    echo ""
  fi

  echo -e "${CYAN}========================================"
  echo -e "       创建MySQL用户和数据库"
  echo -e "========================================${NC}"
  echo ""

  # 获取基础名称
  read -p "请输入基础名称 (如输入lobe将创建lobe_user和lobe_db): " base_name
  if [ -z "$base_name" ]; then
    echo -e "${RED}错误: 名称不能为空${NC}"
    read -p "按回车键继续..." temp
    return
  fi

  # 检查名称格式
  if ! [[ $base_name =~ ^[a-zA-Z0-9_]+$ ]]; then
    echo -e "${RED}错误: 名称只能包含字母、数字和下划线${NC}"
    read -p "按回车键继续..." temp
    return
  fi

  user_name="${base_name}_user"
  db_name="${base_name}_db"

  # 检查用户名是否已存在
  if docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "SELECT User FROM mysql.user WHERE User='$user_name';" 2>/dev/null | grep -q "$user_name"; then
    echo -e "${RED}错误: 用户 $user_name 已经存在${NC}"
    read -p "按回车键继续..." temp
    return
  fi

  # 检查数据库是否已存在
  if docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "SHOW DATABASES LIKE '$db_name';" 2>/dev/null | grep -q "$db_name"; then
    echo -e "${RED}错误: 数据库 $db_name 已经存在${NC}"
    read -p "按回车键继续..." temp
    return
  fi

  # 获取密码
  read -s -p "请设置用户密码: " password
  echo ""
  read -s -p "确认密码: " password_confirm
  echo ""

  if [ "$password" != "$password_confirm" ]; then
    echo -e "${RED}错误: 两次输入的密码不匹配${NC}"
    read -p "按回车键继续..." temp
    return
  fi

  # 检测MySQL版本
  mysql_version=$(docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "SELECT VERSION();" 2>/dev/null | grep -v "VERSION()")
  mysql_major_version=$(echo $mysql_version | cut -d. -f1)

  echo -e "${BLUE}创建数据库 $db_name 并支持emoji (utf8mb4)...${NC}"
  if ! docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "CREATE DATABASE $db_name CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;" >/dev/null 2>&1; then
    echo -e "${RED}创建数据库失败${NC}"
    read -p "按回车键继续..." temp
    return
  fi
  echo -e "${GREEN}成功${NC}"

  echo -e "${BLUE}创建用户 $user_name...${NC}"
  if [ "$mysql_major_version" -ge "8" ]; then
    # MySQL 8.0+ 语法
    if ! docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "CREATE USER '$user_name'@'%' IDENTIFIED BY '$password';" >/dev/null 2>&1; then
      echo -e "${RED}创建用户失败${NC}"
      echo -e "${YELLOW}正在回滚，删除已创建的数据库...${NC}"
      docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "DROP DATABASE IF EXISTS $db_name;" >/dev/null 2>&1
      read -p "按回车键继续..." temp
      return
    fi
  else
    # MySQL 5.7 语法
    if ! docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "CREATE USER '$user_name'@'%' IDENTIFIED BY '$password';" >/dev/null 2>&1; then
      echo -e "${RED}创建用户失败${NC}"
      echo -e "${YELLOW}正在回滚，删除已创建的数据库...${NC}"
      docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "DROP DATABASE IF EXISTS $db_name;" >/dev/null 2>&1
      read -p "按回车键继续..." temp
      return
    fi
  fi
  echo -e "${GREEN}成功${NC}"

  echo -e "${BLUE}授予用户 $user_name 对数据库 $db_name 的全部权限...${NC}"
  if ! docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "GRANT ALL PRIVILEGES ON $db_name.* TO '$user_name'@'%';" >/dev/null 2>&1; then
    echo -e "${RED}授权失败${NC}"
    read -p "按回车键继续..." temp
    return
  fi

  echo -e "${BLUE}刷新权限...${NC}"
  if ! docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "FLUSH PRIVILEGES;" >/dev/null 2>&1; then
    echo -e "${RED}刷新权限失败${NC}"
    read -p "按回车键继续..." temp
    return
  fi
  echo -e "${GREEN}成功${NC}"

  echo -e "${GREEN}操作完成!${NC}"
  read -p "按回车键继续..." temp
}

# MySQL功能:查询所有用户和数据库
list_mysql_users_dbs() {
  if [ "$CLEAR_SCREEN" = true ]; then
    clear
  else
    echo ""
    echo -e "${BLUE}----------------------------------------${NC}"
    echo ""
  fi

  echo -e "${CYAN}========================================"
  echo -e "      MySQL 用户和数据库列表"
  echo -e "========================================${NC}"
  echo ""

  echo -e "${YELLOW}数据库列表:${NC}"
  docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "SELECT table_schema AS database_name, ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) AS size_mb FROM information_schema.tables GROUP BY table_schema ORDER BY table_schema;"
  echo ""

  echo -e "${YELLOW}用户列表:${NC}"
  docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "SELECT User, Host FROM mysql.user ORDER BY User;"
  echo ""

  echo -e "${YELLOW}用户权限:${NC}"
  docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "SELECT User, Host, Db, Select_priv, Insert_priv, Update_priv, Delete_priv FROM mysql.db ORDER BY User, Db;"

  read -p "按回车键继续..." temp
}

# MySQL功能:删除用户或数据库
delete_mysql_user_db() {
  if [ "$CLEAR_SCREEN" = true ]; then
    clear
  else
    echo ""
    echo -e "${BLUE}----------------------------------------${NC}"
    echo ""
  fi

  echo -e "${CYAN}========================================"
  echo -e "        删除MySQL用户或数据库"
  echo -e "========================================${NC}"
  echo ""

  echo -e "请选择要删除的对象:"
  echo -e "${GREEN}1) 用户${NC}"
  echo -e "${GREEN}2) 数据库${NC}"
  echo -e "${YELLOW}3) 返回上级菜单${NC}"
  echo ""
  read -p "请输入选择 [1-3]: " delete_choice

  case $delete_choice in
    1) # 删除用户
      echo -e "${YELLOW}当前MySQL用户列表:${NC}"
      docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "SELECT User, Host FROM mysql.user WHERE User NOT IN ('root', 'mysql.sys', 'mysql.session', 'mysql.infoschema') ORDER BY User;"
      echo ""

      read -p "请输入要删除的用户名: " user_name
      if [ -z "$user_name" ]; then
        echo -e "${RED}错误: 用户名不能为空${NC}"
        read -p "按回车键继续..." temp
        return
      fi

      # 检查用户是否存在
      if ! docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "SELECT User FROM mysql.user WHERE User='$user_name';" 2>/dev/null | grep -q "$user_name"; then
        echo -e "${RED}错误: 用户 $user_name 不存在${NC}"
        read -p "按回车键继续..." temp
        return
      fi

      # 检查关联的数据库
      associated_db=$(docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "SELECT Db FROM mysql.db WHERE User='$user_name' LIMIT 1;" 2>/dev/null | grep -v "Db")

      if [ -n "$associated_db" ]; then
        echo -e "${YELLOW}检测到关联的数据库: $associated_db${NC}"
        read -p "是否同时删除关联的数据库? (y/n): " delete_db

        if [[ $delete_db == [yY] || $delete_db == [yY][eE][sS] ]]; then
          echo -e "${BLUE}删除数据库 $associated_db...${NC}"
          if ! docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "DROP DATABASE $associated_db;" >/dev/null 2>&1; then
            echo -e "${RED}删除数据库失败${NC}"
            read -p "按回车键继续..." temp
            return
          fi
          echo -e "${GREEN}成功${NC}"
        fi
      fi

      echo -e "${BLUE}删除用户 $user_name...${NC}"
      if ! docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "DROP USER '$user_name'@'%';" >/dev/null 2>&1; then
        echo -e "${RED}删除用户失败${NC}"
        read -p "按回车键继续..." temp
        return
      fi
      echo -e "${GREEN}成功${NC}"

      echo -e "${BLUE}刷新权限...${NC}"
      docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "FLUSH PRIVILEGES;" >/dev/null 2>&1
      echo -e "${GREEN}成功${NC}"
      ;;

    2) # 删除数据库
      echo -e "${YELLOW}当前MySQL数据库列表:${NC}"
      docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "SHOW DATABASES WHERE \`Database\` NOT IN ('information_schema', 'mysql', 'performance_schema', 'sys');"
      echo ""

      read -p "请输入要删除的数据库名: " db_name
      if [ -z "$db_name" ]; then
        echo -e "${RED}错误: 数据库名不能为空${NC}"
        read -p "按回车键继续..." temp
        return
      fi

      # 检查数据库是否存在
      if ! docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "SHOW DATABASES LIKE '$db_name';" 2>/dev/null | grep -q "$db_name"; then
        echo -e "${RED}错误: 数据库 $db_name 不存在${NC}"
        read -p "按回车键继续..." temp
        return
      fi

      # 检查拥有该数据库权限的用户
      users_with_access=$(docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "SELECT User FROM mysql.db WHERE Db='$db_name';" 2>/dev/null | grep -v "User")

      if [ -n "$users_with_access" ]; then
        echo -e "${YELLOW}检测到以下用户拥有该数据库的权限:${NC}"
        echo "$users_with_access"
        read -p "是否同时删除这些用户? (y/n): " delete_users

        if [[ $delete_users == [yY] || $delete_users == [yY][eE][sS] ]]; then
          # 先删数据库再删用户
          delete_users_later=true
        fi
      fi

      echo -e "${BLUE}删除数据库 $db_name...${NC}"
      if ! docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "DROP DATABASE $db_name;" >/dev/null 2>&1; then
        echo -e "${RED}删除数据库失败${NC}"
        read -p "按回车键继续..." temp
        return
      fi
      echo -e "${GREEN}成功${NC}"

      if [ "$delete_users_later" = true ]; then
        for user in $users_with_access; do
          echo -e "${BLUE}删除用户 $user...${NC}"
          if ! docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "DROP USER '$user'@'%';" >/dev/null 2>&1; then
            echo -e "${RED}删除用户 $user 失败${NC}"
          else
            echo -e "${GREEN}成功${NC}"
          fi
        done

        echo -e "${BLUE}刷新权限...${NC}"
        docker exec $mysql_container mysql -u root -p"$mysql_root_password" -e "FLUSH PRIVILEGES;" >/dev/null 2>&1
        echo -e "${GREEN}成功${NC}"
      fi
      ;;

    3) return ;;
    *) echo -e "${RED}无效选择，请重试${NC}" 
       sleep 1
       delete_mysql_user_db
       ;;
  esac

  echo -e "${GREEN}操作完成!${NC}"
  read -p "按回车键继续..." temp
}

# Redis功能:查看Redis信息
show_redis_info() {
  if [ "$CLEAR_SCREEN" = true ]; then
    clear
  else
    echo ""
    echo -e "${BLUE}----------------------------------------${NC}"
    echo ""
  fi

  echo -e "${CYAN}========================================"
  echo -e "           Redis 服务器信息"
  echo -e "========================================${NC}"
  echo ""

  echo -e "${YELLOW}Redis服务器信息:${NC}"
  if [ -n "$redis_password" ]; then
    docker exec $redis_container redis-cli -a "$redis_password" --no-auth-warning info server | grep -v "#"
  else
    docker exec $redis_container redis-cli info server | grep -v "#"
  fi
  echo ""

  echo -e "${YELLOW}Redis客户端连接信息:${NC}"
  if [ -n "$redis_password" ]; then
    docker exec $redis_container redis-cli -a "$redis_password" --no-auth-warning info clients | grep -v "#"
  else
    docker exec $redis_container redis-cli info clients | grep -v "#"
  fi
  echo ""

  echo -e "${YELLOW}Redis统计信息:${NC}"
  if [ -n "$redis_password" ]; then
    docker exec $redis_container redis-cli -a "$redis_password" --no-auth-warning info stats | grep -v "#" | head -15
  else
    docker exec $redis_container redis-cli info stats | grep -v "#" | head -15
  fi
  echo ""

  echo -e "${YELLOW}Redis持久化信息:${NC}"
  if [ -n "$redis_password" ]; then
    docker exec $redis_container redis-cli -a "$redis_password" --no-auth-warning info persistence | grep -v "#"
  else
    docker exec $redis_container redis-cli info persistence | grep -v "#"
  fi

  read -p "按回车键继续..." temp
}

# Redis功能:查看内存使用
show_redis_memory() {
  if [ "$CLEAR_SCREEN" = true ]; then
    clear
  else
    echo ""
    echo -e "${BLUE}----------------------------------------${NC}"
    echo ""
  fi

  echo -e "${CYAN}========================================"
  echo -e "           Redis 内存使用情况"
  echo -e "========================================${NC}"
  echo ""

  echo -e "${YELLOW}内存使用概览:${NC}"
  if [ -n "$redis_password" ]; then
    docker exec $redis_container redis-cli -a "$redis_password" --no-auth-warning info memory | grep -v "#"
  else
    docker exec $redis_container redis-cli info memory | grep -v "#"
  fi
  echo ""

  echo -e "${YELLOW}内存使用详情:${NC}"
  if [ -n "$redis_password" ]; then
    docker exec $redis_container redis-cli -a "$redis_password" --no-auth-warning memory stats | head -20
  else
    docker exec $redis_container redis-cli memory stats | head -20
  fi
  echo ""

  echo -e "${YELLOW}数据库键值统计:${NC}"
  if [ -n "$redis_password" ]; then
    docker exec $redis_container redis-cli -a "$redis_password" --no-auth-warning info keyspace | grep -v "#"
  else
    docker exec $redis_container redis-cli info keyspace | grep -v "#"
  fi

  read -p "按回车键继续..." temp
}

# Redis功能:查看键值统计
show_redis_keys() {
  if [ "$CLEAR_SCREEN" = true ]; then
    clear
  else
    echo ""
    echo -e "${BLUE}----------------------------------------${NC}"
    echo ""
  fi

  echo -e "${CYAN}========================================"
  echo -e "           Redis 键值统计"
  echo -e "========================================${NC}"
  echo ""

  echo -e "${YELLOW}数据库键值统计:${NC}"
  if [ -n "$redis_password" ]; then
    docker exec $redis_container redis-cli -a "$redis_password" --no-auth-warning info keyspace | grep -v "#"
  else
    docker exec $redis_container redis-cli info keyspace | grep -v "#"
  fi
  echo ""

  echo -e "${YELLOW}键值类型分布:${NC}"
  if [ -n "$redis_password" ]; then
    # 获取所有数据库
    dbs=$(docker exec $redis_container redis-cli -a "$redis_password" --no-auth-warning info keyspace | grep -v "#" | grep "^db" | cut -d: -f1)

    if [ -z "$dbs" ]; then
      echo -e "${YELLOW}没有找到任何数据库或键值${NC}"
    else
      for db in $dbs; do
        echo -e "${BLUE}数据库 $db:${NC}"
        # 选择数据库并统计键类型
        docker exec $redis_container redis-cli -a "$redis_password" --no-auth-warning -n ${db#db} info keyspace | grep -v "#"
        # 使用 SCAN 命令统计部分键的类型（避免 KEYS 命令对大数据库的影响）
        echo -e "${GREEN}键类型样本统计 (前100个键):${NC}"
        docker exec $redis_container redis-cli -a "$redis_password" --no-auth-warning -n ${db#db} --scan --count 100 | while read -r key; do
          type=$(docker exec $redis_container redis-cli -a "$redis_password" --no-auth-warning -n ${db#db} type "$key")
          echo "键: $key -> 类型: $type"
        done | sort | uniq -c | sort -nr
      done
    fi
  else
    dbs=$(docker exec $redis_container redis-cli info keyspace | grep -v "#" | grep "^db" | cut -d: -f1)

    if [ -z "$dbs" ]; then
      echo -e "${YELLOW}没有找到任何数据库或键值${NC}"
    else
      for db in $dbs; do
        echo -e "${BLUE}数据库 $db:${NC}"
        docker exec $redis_container redis-cli -n ${db#db} info keyspace | grep -v "#"
        echo -e "${GREEN}键类型样本统计 (前100个键):${NC}"
        docker exec $redis_container redis-cli -n ${db#db} --scan --count 100 | while read -r key; do
          type=$(docker exec $redis_container redis-cli -n ${db#db} type "$key")
          echo "键: $key -> 类型: $type"
        done | sort | uniq -c | sort -nr
      done
    fi
  fi

  read -p "按回车键继续..." temp
}

# 主循环
main() {
  check_docker
  while true; do
    find_containers
    show_main_menu

    if [ -z "$main_choice" ] || ! [[ "$main_choice" =~ ^[0-9]+$ ]]; then
      echo -e "${RED}无效选择，请重试${NC}"
      sleep 1
      continue
    fi

    if [ "$main_choice" -eq "$exit_option" ]; then
      echo -e "${GREEN}感谢使用容器数据库管理工具，再见！${NC}"
      exit 0
    elif [ "$main_choice" -eq "$settings_option" ]; then
      show_settings_menu
    elif [ "$main_choice" -le "$pg_count" ] && [ "$main_choice" -ge 1 ]; then
      show_postgres_menu
    elif [ "$main_choice" -eq "$mysql_option" ] && [ -n "$mysql_container" ]; then
      show_mysql_menu
    elif [ "$main_choice" -eq "$redis_option" ] && [ -n "$redis_container" ]; then
      show_redis_menu
    else
      echo -e "${RED}无效选择，请重试${NC}"
      sleep 1
    fi
  done
}

# 启动脚本
main

使用Docker Compose部署PostgreSQL

raylenzed@gmail.com (南风大叔) — Mon, 10 Mar 2025 20:15:28 +0000

PostgreSQL

在部署LobeChat和Zitadel过程中需要使用PostgreSQL，而且LobeChat需要的数据库支持pgvector插件，所以本次使用镜像为image: pgvector/pgvector:pg17。在/app/文件夹下创建pgvector项目文件夹。

cd /app
mkdir pgvector

将docker-compose.yml和.env文件保存在该文件夹内。 docker-compose.yml:

services:
  pgvector:
    image: pgvector/pgvector:pg17
    container_name: pgvector_db
    environment:
      POSTGRES_PASSWORD: "${POSTGRES_PASSWORD}"
    ports:
      - "5432:5432"
    volumes:
      - ./.data:/var/lib/postgresql/data
    restart: unless-stopped
    networks:
      - 1panel-network # 本次使用已存在的容器网络

networks:
  1panel-network:
    external: true

.env:

POSTGRES_PASSWORD=mypassword

启动容器

docker compose up -d

使用Docker Compose部署Zitadel

raylenzed@gmail.com (南风大叔) — Mon, 10 Mar 2025 00:50:48 +0000

fxptxf

原本我自己根据官方教程部署，结果一直失败，最后是直接参考LobeChat的配置安装部署。 Zitadel部署需要三个文件，把三个文件保存到/app/ZITADEL

docker-compose.yml
zitadel-config.yaml
zitadel-init-steps.yaml

docker-compose.yml:

services:
  zitadel:
      restart: always
      image: ghcr.io/zitadel/zitadel:latest
      container_name: lobe-zitadel
      command: start-from-init --config /zitadel-config.yaml --steps /zitadel-init-steps.yaml --masterkey "cft3Tekr/rQBOqwoQSCPoncA9BHbn7QJ" --tlsMode external #MasterkeyNeedsToHave32Characters
      ports:
        - 8080:8080
      volumes:
        - ./zitadel-config.yaml:/zitadel-config.yaml:ro
        - ./zitadel-init-steps.yaml:/zitadel-init-steps.yaml:ro
      networks:
        - 1panel-network

networks:
  1panel-network:
    external: true

zitadel-config.yaml:

Log:
  Level: 'info'

ExternalPort: 443 
ExternalDomain: auth.xxx.com # 这里写Zitadel域名
ExternalSecure: true 
TLS:
  Enabled: false # 保持当前设置，不修改

Database:
  postgres:
    Host: pgvector_db # PostgreSQL数据库容器名
    Port: 5432
    Database: zitadel_db # Zitadel自行创建，不需要手动创建
    User:
      Username: 'zitadel_user' # Zitadel自行创建，不需要手动创建
      Password: '123456' # Zitadel自行创建，不需要手动创建
      SSL:
        Mode: 'disable'# 保持当前设置，不修改
    Admin:
      Username: 'postgres'
      Password: '123456' # 安装postgres设置超级管理员密码
      SSL:
        Mode: 'disable'

zitadel-init-steps.yaml:

  Org:
    Human:
      Username: 'root'

      Password: 'Password1!'
      Email:
        Address: 'example@zitadel.com' #  设置一个超管用户邮箱，稍后登录使用邮箱登录，可以修改，后期也可以登录后修改

安装启动

cd /app/ZITADEL
docker compose up -d

南风大叔

PVE 下安装 OpenWrt 虚拟机完整指南：从创建到磁盘扩容

前言

环境信息

第一步：下载 OpenWrt 镜像

第二步：扩容镜像文件

第三步：在 PVE 中创建虚拟机

基本设置

操作系统

系统

磁盘

CPU

内存

网络

第四步：导入磁盘到虚拟机

为什么必须选 SATA？

第五步：首次启动与验证

第六步：扩展分区和文件系统

方案一：在 OpenWrt 内部操作（在线扩容）

方案二：在 PVE 宿主机上离线操作（推荐）

验证结果

网络拓扑参考

常见问题汇总

总结

数字秩序：我的 800+ 账号 Vaultwarden 治理 SOP

一、 文件夹体系：数字逻辑强制排序

1. 核心资产 (Core) —— 数字生命的根基

2. 技术与生产力 (Tech & Work) —— 极客的实验室

3. 互联网生活 (Digital Life) —— 数字化日常

二、 命名规范：标签化 (Tagging) 实例

三、 进阶配置：针对 PVE 环境的优化

1. 多 URI 协同

2. 自定义字段 (Custom Fields)

四、 结语

Deploy Vaultwarden

在 Cloudflare 后台创建隧道 (Tunnel)

基本配置

中文汉化

配置 .env

启动

与 Root 关于自驱动 Drift 和性格培养的对话实录

提问（优化版）

对话记录

你能看到什么

我会做哪些事情（后台动作）

时间与频率

你可控的开关（随时一句话改）

A. 每日常驻巡航（高频）

B. 隔天巡航（中频）

C. 周更深看（低频高价值）

运行方式

新增“人类向”维度

新巡航配比

用BBS提示词搭建多AI圆桌：一键开局的实战范本

提示词

模板

Claude Code和Codex的设置

Claude Code

MCP

自定义Key

DeepSeek

MiniMax

权限

Codex

MCP

Yolo权限

自定义KEY

服务商配置

代码审计提示词

PostgreSQL、MySQL、Redis数据库管理脚本

使用Docker Compose部署PostgreSQL

使用Docker Compose部署Zitadel

一、文件夹体系：数字逻辑强制排序

二、命名规范：标签化 (Tagging) 实例

三、进阶配置：针对 PVE 环境的优化

四、结语

配置 `.env`