wechat-opencode-bot 0.1.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,86 @@
+# wechat-opencode-bot
+
+微信 ⇄ opencode 桥接机器人。微信消息通过 opencode serve 驱动 AI 回复，支持定时任务主动推送、图片/文件收发。跨平台（macOS / Windows / Linux）。
+
+## 原理
+
+cc-wechat 的 `notifications/claude/channel` 是 Claude Code 专属协议，opencode 不处理。本工具由桥接进程独占轮询微信 iLink API，拿到消息后通过 opencode serve 的 HTTP API 触发 AI 回复，再回传微信。
+
+```
+微信用户 ⇄ iLink API ⇄ bridge(独占轮询) ⇄ opencode serve(HTTP) ⇄ LLM
+```
+
+## 安装
+
+```bash
+npm install -g wechat-opencode-bot
+# 首次登录微信（扫码）
+wechat-bot login
+```
+
+依赖 `cc-wechat`（自动安装）。需要 `opencode` 在 PATH 中，或设置 `OPENCODE_BIN` 指向其可执行文件。
+
+## 快速开始
+
+```bash
+wechat-bot serve     # 启动 opencode serve（前台）
+wechat-bot bridge    # 启动桥接进程（前台）
+wechat-bot status    # 查看状态
+```
+
+或使用自启动:
+
+```bash
+wechat-bot install   # macOS 生成 launchd plist 并加载
+./bin/start.sh start # 或手动启动脚本（macOS/Linux）
+./bin/start.bat start# Windows
+```
+
+## 环境变量
+
+| 变量 | 默认值 | 说明 |
+|---|---|---|
+| `WECHAT_BOT_HOME` | `~/.wechat-bot` | 数据目录（sessions/tasks/media/logs/pids） |
+| `WECHAT_STATE_DIR` | `~/.claude/channels/wechat/<profile>` | cc-wechat 状态目录 |
+| `WECHAT_PROFILE` | `default` | cc-wechat 账号 profile |
+| `OPENCODE_SERVER_URL` | `http://127.0.0.1:4100` | opencode serve 地址 |
+| `OPENCODE_PORT` | `4100` | opencode serve 端口 |
+| `OPENCODE_BIN` | `opencode` | opencode 可执行文件 |
+| `LLM_TIMEOUT_MS` | `300000` | LLM 响应超时 |
+| `BOT_PREFIX` | 空 | 仅响应带此前缀的消息 |
+
+## 功能
+
+- **自动回复**：每用户独立 opencode session（会话历史持久化）。
+- **定时任务**：对 bot 说"每天早上9点提醒我喝水"，AI 输出 `[schedule: 09:00 | 提醒喝水]` 标记，bridge 解析存储，到点主动推送。
+  - 时间表达式：`HH:MM`(每天) / `每N小时` / `每N分钟` / `YYYY-MM-DD HH:MM`(一次性)
+  - 查看/删除：`[schedule_list]` / `[schedule_del: id]`
+- **图片/文件**：接收时下载到本地供 AI 读取（`[图片: 路径]`）；发送时用 `[media: /绝对/路径]` 标记上传。
+- **自动重连**：网络错误指数退避，session 过期自动提示重新登录。
+
+## 数据文件
+
+- `sessions.json`：微信用户 → opencode session 映射
+- `tasks.json`：定时任务
+- `media/`：接收的媒体文件
+- `logs/`：serve/bridge 日志
+
+## 开发
+
+```bash
+npm install
+node src/cli.js bridge   # 直接运行
+```
+
+## 手动部署说明（Windows 自启）
+
+Windows 建议用任务计划程序（schtasks）或 NSSM 注册为服务：
+
+```bat
+schtasks /create /tn wechat-serve /tr "node C:\...\cli.js serve" /sc onstart
+schtasks /create /tn wechat-bridge /tr "node C:\...\cli.js bridge" /sc onstart
+```
+
+## License
+
+MIT

package/bin/start.bat

@@ -0,0 +1,93 @@
+@echo off
+REM opencode-wechat-bot 启动脚本（Windows）
+REM 用法: start.bat [start|stop|restart|status]
+
+setlocal
+set DIR=%~dp0
+for %%I in ("%DIR%..") do set "PKG_DIR=%%~fI"
+
+if "%WECHAT_BOT_HOME%"=="" (
+  set "WECHAT_BOT_HOME=%USERPROFILE%\.wechat-bot"
+)
+set "LOG_DIR=%WECHAT_BOT_HOME%\logs"
+set "PID_DIR=%WECHAT_BOT_HOME%\pids"
+set "SERVE_PID_FILE=%PID_DIR%\serve.pid"
+set "BRIDGE_PID_FILE=%PID_DIR%\bridge.pid"
+
+if not exist "%LOG_DIR%" mkdir "%LOG_DIR%"
+if not exist "%PID_DIR%" mkdir "%PID_DIR%"
+
+set CMD=%1
+if "%CMD%"=="" set CMD=start
+
+goto :%CMD%
+goto :usage
+
+:is_running
+set "PFILE=%~1"
+if not exist "%PFILE%" exit /b 1
+set /p PID=<"%PFILE%"
+tasklist /FI "PID eq %PID%" 2>nul | find "%PID%" >nul
+if errorlevel 1 exit /b 1
+exit /b 0
+
+:start_serve
+call :is_running "%SERVE_PID_FILE%"
+if not errorlevel 1 (
+  echo serve already running
+  goto :eof
+)
+set "OPENCODE_CONFIG_CONTENT={"mcp":{"wechat":{"enabled":false}}}"
+set "PORT=%OPENCODE_PORT%"
+if "%PORT%"=="" set PORT=4100
+powershell -NoProfile -Command "Start-Process -FilePath 'node' -ArgumentList '\"%PKG_DIR%\src\cli.js\"','serve' -WindowStyle Hidden -RedirectStandardOutput '%LOG_DIR%\serve.log' -RedirectStandardError '%LOG_DIR%\serve.err.log' -PassThru | Select-Object -ExpandProperty Id | Out-File -Encoding ascii '%SERVE_PID_FILE%'"
+echo serve started (port %PORT%)
+goto :eof
+
+:start_bridge
+call :is_running "%BRIDGE_PID_FILE%"
+if not errorlevel 1 (
+  echo bridge already running
+  goto :eof
+)
+powershell -NoProfile -Command "Start-Process -FilePath 'node' -ArgumentList '\"%PKG_DIR%\src\cli.js\"','bridge' -WindowStyle Hidden -RedirectStandardOutput '%LOG_DIR%\bridge.log' -RedirectStandardError '%LOG_DIR%\bridge.err.log' -PassThru | Select-Object -ExpandProperty Id | Out-File -Encoding ascii '%BRIDGE_PID_FILE%'"
+echo bridge started
+goto :eof
+
+:start
+call :start_serve
+call :start_bridge
+goto :eof
+
+:stop
+set "PFILE=%BRIDGE_PID_FILE%"
+if exist "%PFILE%" (
+  set /p PID=<"%PFILE%"
+  taskkill /PID %PID% /F >nul 2>&1
+  del "%PFILE%"
+  echo bridge stopped
+)
+set "PFILE=%SERVE_PID_FILE%"
+if exist "%PFILE%" (
+  set /p PID=<"%PFILE%"
+  taskkill /PID %PID% /F >nul 2>&1
+  del "%PFILE%"
+  echo serve stopped
+)
+goto :eof
+
+:restart
+call :stop
+call :start
+goto :eof
+
+:status
+call :is_running "%SERVE_PID_FILE%"
+if not errorlevel 1 (echo serve: running) else (echo serve: not running)
+call :is_running "%BRIDGE_PID_FILE%"
+if not errorlevel 1 (echo bridge: running) else (echo bridge: not running)
+goto :eof
+
+:usage
+echo Usage: start.bat [start^|stop^|restart^|status]
+exit /b 1

package/bin/start.sh

@@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+# opencode-wechat-bot 启动脚本（macOS / Linux）
+# 用法: ./start.sh [start|stop|restart|status]
+set -u
+DIR="$(cd "$(dirname "$0")" && pwd)"
+PKG_DIR="$(cd "$DIR/.." && pwd)"
+PORT="${OPENCODE_PORT:-4100}"
+LOG_DIR="${WECHAT_BOT_HOME:-$HOME/.wechat-bot}/logs"
+PID_DIR="${WECHAT_BOT_HOME:-$HOME/.wechat-bot}/pids"
+SERVE_PID_FILE="$PID_DIR/serve.pid"
+BRIDGE_PID_FILE="$PID_DIR/bridge.pid"
+
+mkdir -p "$LOG_DIR" "$PID_DIR"
+
+is_running() {
+  local pid_file="$1"
+  [ -f "$pid_file" ] && kill -0 "$(cat "$pid_file")" 2>/dev/null
+}
+
+start_serve() {
+  if is_running "$SERVE_PID_FILE"; then
+    echo "serve 已在运行 (PID $(cat "$SERVE_PID_FILE"))"
+    return
+  fi
+  OPENCODE_CONFIG_CONTENT='{"mcp":{"wechat":{"enabled":false}}}' \
+    nohup node "$PKG_DIR/src/cli.js" serve > "$LOG_DIR/serve.log" 2>&1 &
+  echo $! > "$SERVE_PID_FILE"
+  echo "serve 已启动 (PID $!) port=$PORT"
+}
+
+start_bridge() {
+  if is_running "$BRIDGE_PID_FILE"; then
+    echo "bridge 已在运行 (PID $(cat "$BRIDGE_PID_FILE"))"
+    return
+  fi
+  nohup node "$PKG_DIR/src/cli.js" bridge > "$LOG_DIR/bridge.log" 2>&1 &
+  echo $! > "$BRIDGE_PID_FILE"
+  echo "bridge 已启动 (PID $!)"
+}
+
+stop_process() {
+  local pid_file="$1"
+  local name="$2"
+  if [ -f "$pid_file" ]; then
+    local pid
+    pid="$(cat "$pid_file")"
+    if kill -0 "$pid" 2>/dev/null; then
+      kill "$pid" 2>/dev/null
+      echo "$name 已停止 (PID $pid)"
+    else
+      echo "$name 未在运行"
+    fi
+    rm -f "$pid_file"
+  fi
+}
+
+case "${1:-start}" in
+  start)
+    start_serve
+    start_bridge
+    ;;
+  stop)
+    stop_process "$BRIDGE_PID_FILE" "bridge"
+    stop_process "$SERVE_PID_FILE" "serve"
+    ;;
+  restart)
+    "$0" stop
+    sleep 1
+    "$0" start
+    ;;
+  status)
+    if is_running "$SERVE_PID_FILE"; then echo "serve: 运行中 (PID $(cat "$SERVE_PID_FILE"))"; else echo "serve: 未运行"; fi
+    if is_running "$BRIDGE_PID_FILE"; then echo "bridge: 运行中 (PID $(cat "$BRIDGE_PID_FILE"))"; else echo "bridge: 未运行"; fi
+    ;;
+  *)
+    echo "用法: $0 [start|stop|restart|status]"
+    ;;
+esac

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "wechat-opencode-bot",
+  "version": "0.1.0",
+  "description": "微信 ⇄ opencode 桥接机器人：微信消息通过 opencode serve 驱动 AI 回复，支持定时任务主动推送、媒体收发，跨平台（macOS/Windows/Linux）。",
+  "type": "module",
+  "bin": {
+    "wechat-bot": "./src/cli.js"
+  },
+  "exports": {
+    ".": "./src/bridge.js"
+  },
+  "files": [
+    "src",
+    "bin",
+    "config",
+    "launchd",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node src/cli.js bridge",
+    "serve": "node src/cli.js serve",
+    "login": "node src/cli.js login",
+    "status": "node src/cli.js status"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "keywords": [
+    "wechat",
+    "weixin",
+    "opencode",
+    "bot",
+    "ilink",
+    "bridge"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "cc-wechat": "0.6.8"
+  }
+}

package/src/bridge.js

@@ -0,0 +1,659 @@
+/**
+ * wechat-bridge — 微信 ⇄ opencode serve 桥接守护进程
+ *
+ * 架构: 微信用户 ⇄ iLink API ⇄ 本进程(独占轮询) ⇄ opencode serve(HTTP) ⇄ LLM
+ *
+ * 依赖: 复用 cc-wechat 包的 ilink-api.js / store.js / text-utils.js / types.js
+ * 说明: cc-wechat 的 notifications/claude/channel 是 Claude Code 专属协议，
+ *       opencode 不处理该通知，因此由本进程独占轮询并在拿到消息后
+ *       通过 opencode serve 的 HTTP API 触发 AI 回复。
+ */
+import { join } from 'node:path';
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import {
+  findCcWechatDir,
+  STATE_DIR,
+  SESSION_MAP_FILE,
+  MEDIA_DIR,
+  TASKS_FILE,
+  SERVER_BASE,
+} from './paths.js';
+
+const CC_WECHAT_DIR = findCcWechatDir();
+
+const { getActiveAccount, loadSyncBuf, saveSyncBuf } = await import(
+  join(CC_WECHAT_DIR, 'dist', 'store.js')
+);
+const { getUpdates, sendMessage, sendTyping, getConfig } = await import(
+  join(CC_WECHAT_DIR, 'dist', 'ilink-api.js')
+);
+const { stripMarkdown, chunkText } = await import(
+  join(CC_WECHAT_DIR, 'dist', 'text-utils.js')
+);
+const { MessageItemType } = await import(
+  join(CC_WECHAT_DIR, 'dist', 'types.js')
+);
+const { downloadMedia, uploadMedia } = await import(
+  join(CC_WECHAT_DIR, 'dist', 'cdn.js')
+);
+
+// ─── 常量 ─────────────────────────────────────────────
+const SESSION_EXPIRED_ERRCODE = -14;
+const MAX_CONSECUTIVE_FAILURES = 5;
+const INITIAL_RETRY_DELAY_MS = 2_000;
+const MAX_RETRY_DELAY_MS = 30_000;
+const SESSION_PAUSE_MS = 5 * 60_000;
+
+// ─── 可配置项（环境变量） ─────────────────────────────
+const MAX_LLM_RESPONSE_TIME_MS = Number(process.env.LLM_TIMEOUT_MS || 300_000);
+const TRIGGER_PREFIX = process.env.BOT_PREFIX || ''; // 可选: 仅响应带前缀的消息
+
+// ─── 状态 ─────────────────────────────────────────────
+let pollingActive = false;
+let pollingAbort = null;
+const sessionMap = loadSessionMap();
+const typingTicketCache = new Map();
+const processedIds = new Set();
+let account = null;
+
+function loadSessionMap() {
+  try {
+    if (existsSync(SESSION_MAP_FILE)) {
+      return JSON.parse(readFileSync(SESSION_MAP_FILE, 'utf-8'));
+    }
+  } catch {}
+  return {};
+}
+
+function saveSessionMap() {
+  try {
+    writeFileSync(SESSION_MAP_FILE, JSON.stringify(sessionMap, null, 2), 'utf-8');
+  } catch (err) {
+    process.stderr.write(`[bridge] 保存 session 映射失败: ${String(err)}\n`);
+  }
+}
+
+// ─── 定时任务 ─────────────────────────────────────────
+let tasks = loadTasks();
+let schedulerTimer = null;
+
+function loadTasks() {
+  try {
+    if (existsSync(TASKS_FILE)) {
+      return JSON.parse(readFileSync(TASKS_FILE, 'utf-8'));
+    }
+  } catch {}
+  return [];
+}
+
+function saveTasks() {
+  try {
+    writeFileSync(TASKS_FILE, JSON.stringify(tasks, null, 2), 'utf-8');
+  } catch (err) {
+    process.stderr.write(`[bridge] 保存任务失败: ${String(err)}\n`);
+  }
+}
+
+/** 解析时间表达式。支持: HH:MM / 每N小时 / 每N分钟 / YYYY-MM-DD HH:MM */
+function parseScheduleExpr(expr) {
+  expr = String(expr || '').trim();
+  if (!expr) return null;
+
+  // 每N小时 / 每N分钟
+  let m = expr.match(/^每\s*(\d+)\s*(小时|分钟|天)$/);
+  if (m) {
+    const n = Number(m[1]);
+    const unit = m[2];
+    if (unit === '小时') return { type: 'interval', minutes: n * 60 };
+    if (unit === '分钟') return { type: 'interval', minutes: n };
+    if (unit === '天') return { type: 'interval', minutes: n * 1440 };
+  }
+
+  // HH:MM （每天）
+  m = expr.match(/^(\d{1,2}):(\d{2})$/);
+  if (m) {
+    return { type: 'daily', hour: Number(m[1]), minute: Number(m[2]) };
+  }
+
+  // YYYY-MM-DD HH:MM （一次性）
+  m = expr.match(/^(\d{4})-(\d{2})-(\d{2})\s+(\d{1,2}):(\d{2})$/);
+  if (m) {
+    return {
+      type: 'once',
+      at: new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]), Number(m[4]), Number(m[5])),
+    };
+  }
+
+  return null;
+}
+
+/** 生成任务 ID */
+function nextTaskId() {
+  return `t${Date.now()}`;
+}
+
+/** 添加任务。返回 { ok, task?, error? } */
+function addTask(userId, expr, prompt) {
+  const parsed = parseScheduleExpr(expr);
+  if (!parsed) {
+    return { ok: false, error: `无法理解时间表达式: ${expr}` };
+  }
+  const task = { id: nextTaskId(), userId, expr: expr.trim(), parsed, prompt, lastFired: null };
+  tasks.push(task);
+  saveTasks();
+  return { ok: true, task };
+}
+
+/** 删除任务 */
+function deleteTask(id) {
+  const before = tasks.length;
+  tasks = tasks.filter((t) => t.id !== id);
+  if (tasks.length !== before) {
+    saveTasks();
+    return true;
+  }
+  return false;
+}
+
+/** 列出某用户的任务 */
+function listTasksFor(userId) {
+  return tasks.filter((t) => t.userId === userId);
+}
+
+/** 检查并触发到期任务 */
+async function runScheduler() {
+  const now = new Date();
+  const due = [];
+  for (const task of tasks) {
+    if (!task.enabled && task.enabled !== undefined) continue;
+    if (task.parsed.type === 'daily') {
+      if (now.getHours() === task.parsed.hour && now.getMinutes() === task.parsed.minute) {
+        const todayKey = now.toDateString();
+        if (task.lastFired !== todayKey) {
+          due.push(task);
+          task.lastFired = todayKey;
+        }
+      }
+    } else if (task.parsed.type === 'interval') {
+      const last = task.lastFired ? new Date(task.lastFired) : null;
+      if (!last || (now.getTime() - last.getTime()) >= task.parsed.minutes * 60_000) {
+        due.push(task);
+        task.lastFired = now.toISOString();
+      }
+    } else if (task.parsed.type === 'once') {
+      if (!task.lastFired && now >= task.parsed.at) {
+        due.push(task);
+        task.lastFired = now.toISOString();
+      }
+    }
+  }
+  if (due.length) saveTasks();
+  for (const task of due) {
+    try {
+      await fireTask(task);
+    } catch (err) {
+      log(`定时任务执行失败 ${task.id}: ${String(err)}`);
+    }
+  }
+}
+
+/** 执行一个定时任务：调该用户 session 生成内容并主动推送 */
+async function fireTask(task) {
+  log(`触发定时任务 ${task.id} for=${task.userId}: ${task.prompt}`);
+  const sessionId = await getSessionForUser(task.userId);
+  const prompt = `【定时任务触发】${task.prompt}\n请据此生成一条发给用户的微信消息。`;
+  let reply = '';
+  try {
+    reply = await askOpenCode(sessionId, prompt);
+  } catch (err) {
+    reply = `[定时任务执行失败: ${String(err.message ?? err)}]`;
+  }
+  if (reply) {
+    const plainText = stripMarkdown(reply);
+    const chunks = chunkText(plainText, 3900);
+    for (const chunk of chunks) {
+      await sendMessage(account.token, task.userId, chunk, '', account.baseUrl, undefined);
+    }
+    log(`定时任务已推送 ${task.id} chunks=${chunks.length}`);
+  }
+  // 一次性任务执行后移除
+  if (task.parsed.type === 'once') {
+    deleteTask(task.id);
+  }
+}
+
+/** 解析 AI 回复中的任务管理标记，返回处理后的文本 */
+function processScheduleMarks(reply, userId) {
+  let text = reply;
+  const results = [];
+
+  // [schedule: 表达式 | 提示]
+  const addRegex = /\[schedule:\s*([^|\]]+)\s*\|\s*([^\]]+)\]/g;
+  let m;
+  while ((m = addRegex.exec(reply)) !== null) {
+    const expr = m[1].trim();
+    const prompt = m[2].trim();
+    const r = addTask(userId, expr, prompt);
+    results.push(r.ok ? `已添加定时任务: ${prompt} (${expr})` : `添加失败: ${r.error}`);
+    text = text.replace(m[0], '');
+  }
+
+  // [schedule_list]
+  if (/\[schedule_list\]/i.test(reply)) {
+    const list = listTasksFor(userId);
+    if (list.length === 0) {
+      results.push('当前没有定时任务');
+    } else {
+      results.push('当前定时任务:\n' + list.map((t) => `${t.id}: ${t.expr} — ${t.prompt}`).join('\n'));
+    }
+    text = text.replace(/\[schedule_list\]/gi, '');
+  }
+
+  // [schedule_del: id]
+  const delRegex = /\[schedule_del:\s*([^\]]+)\]/g;
+  while ((m = delRegex.exec(reply)) !== null) {
+    const id = m[1].trim();
+    const ok = deleteTask(id);
+    results.push(ok ? `已删除任务 ${id}` : `任务 ${id} 不存在`);
+    text = text.replace(m[0], '');
+  }
+
+  if (results.length) {
+    text = (text + '\n\n' + results.join('\n')).trim();
+  }
+  return text;
+}
+
+// ─── 日志 ─────────────────────────────────────────────
+function log(msg) {
+  process.stderr.write(`[bridge ${new Date().toISOString()}] ${msg}\n`);
+}
+
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener('abort', () => {
+      clearTimeout(t);
+      reject(new Error('aborted'));
+    }, { once: true });
+  });
+}
+
+// ─── opencode serve 调用 ─────────────────────────────
+async function api(path, options = {}, timeoutMs = 30_000) {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const resp = await fetch(`${SERVER_BASE}${path}`, {
+      ...options,
+      signal: ctrl.signal,
+      headers: { 'Content-Type': 'application/json', ...(options.headers || {}) },
+    });
+    const text = await resp.text();
+    if (!resp.ok) {
+      throw new Error(`HTTP ${resp.status}: ${text.slice(0, 300)}`);
+    }
+    return text ? JSON.parse(text) : null;
+  } finally {
+    clearTimeout(t);
+  }
+}
+
+/** 获取或创建该微信用户的 opencode session */
+async function getSessionForUser(userId) {
+  if (sessionMap[userId]) {
+    // 校验 session 仍存在
+    try {
+      await api(`/session/${sessionMap[userId]}`);
+      return sessionMap[userId];
+    } catch {
+      delete sessionMap[userId];
+    }
+  }
+  const session = await api('/session', {
+    method: 'POST',
+    body: JSON.stringify({ title: `微信: ${userId}` }),
+  });
+  sessionMap[userId] = session.id;
+  saveSessionMap();
+  return session.id;
+}
+
+/** 向 opencode session 发送消息并等待完整回复文本 */
+async function askOpenCode(sessionId, text) {
+  const SYSTEM_HINT = `你是微信自动回复助手。收到 [图片: 路径] 或 [文件: 路径] 标记时，可用 read 工具读取内容。
+如需在回复中发送媒体文件（本地绝对路径），在回复文本中用 [media: /绝对/路径] 标记，一行一个，其余内容按普通文本发送。
+定时任务指令（用户要求定时提醒/推送时使用）:
+  [schedule: 时间表达式 | 任务提示]   添加定时任务。时间表达式支持: HH:MM(每天) / 每N小时 / 每N分钟 / YYYY-MM-DD HH:MM(一次性)
+  [schedule_list]                     查看当前定时任务
+  [schedule_del: 任务ID]              删除指定定时任务
+到点后系统会调用你生成内容并主动推送给用户。`;
+  const resp = await api(
+    `/session/${sessionId}/message`,
+    {
+      method: 'POST',
+      body: JSON.stringify({ parts: [{ type: 'text', text: `${SYSTEM_HINT}\n\n微信消息:\n${text}` }] }),
+    },
+    MAX_LLM_RESPONSE_TIME_MS,
+  );
+  const parts = resp?.parts || [];
+  const textParts = parts
+    .filter((p) => p.type === 'text' && typeof p.text === 'string')
+    .map((p) => p.text);
+  return textParts.join('\n').trim();
+}
+
+// ─── 微信消息处理 ─────────────────────────────────────
+/** 从消息提取可读文本（媒体下载到本地，供 LLM 用 read 查看） */
+async function extractText(msg) {
+  const parts = [];
+  for (const item of msg.item_list ?? []) {
+    const t = item.type ?? 0;
+    if (t === MessageItemType.TEXT) {
+      if (item.text_item?.text) {
+        if (item.ref_msg) {
+          const refTitle = item.ref_msg.title ?? '';
+          const refText = item.ref_msg.message_item?.text_item?.text ?? '';
+          const refContent = refTitle || refText;
+          if (refContent) {
+            parts.push(`[引用: ${refContent}]`);
+          }
+        }
+        parts.push(item.text_item.text);
+      }
+    } else if (t === MessageItemType.IMAGE) {
+      let desc = '[图片]';
+      try {
+        const filePath = await downloadMedia({
+          encryptQueryParam: item.image_item?.media?.encrypt_query_param,
+          aesKeyBase64: item.image_item?.media?.aes_key,
+          outDir: MEDIA_DIR,
+        });
+        if (filePath) desc = `[图片: ${filePath}]`;
+      } catch {}
+      parts.push(desc);
+    } else if (t === MessageItemType.VOICE) {
+      parts.push(`[语音] ${item.voice_item?.text ?? ''}`);
+    } else if (t === MessageItemType.FILE) {
+      let desc = `[文件: ${item.file_item?.file_name ?? 'unknown'}]`;
+      try {
+        const filePath = await downloadMedia({
+          encryptQueryParam: item.file_item?.media?.encrypt_query_param,
+          aesKeyBase64: item.file_item?.media?.aes_key,
+          fileName: item.file_item?.file_name,
+          outDir: MEDIA_DIR,
+        });
+        if (filePath) desc = `[文件: ${filePath}]`;
+      } catch {}
+      parts.push(desc);
+    } else if (t === MessageItemType.VIDEO) {
+      parts.push('[视频]');
+    }
+  }
+  return parts.join('\n') || '[空消息]';
+}
+
+/** 发送媒体标记（LLM 回复形如 [media: /abs/path]）并返回剩余文本 */
+async function sendMediaMarks(userId, contextToken, reply) {
+  const mediaRegex = /\[media:\s*([^\]]+)\]/g;
+  let mediaSent = 0;
+  let text = reply;
+  let match;
+  const files = [];
+  while ((match = mediaRegex.exec(reply)) !== null) {
+    const p = match[1].trim();
+    files.push(p);
+  }
+  for (const p of files) {
+    if (!existsSync(p)) {
+      log(`媒体文件不存在，跳过: ${p}`);
+      text = text.replace(/\[media:\s*[^\]]+\]/g, '').trim();
+      continue;
+    }
+    try {
+      await uploadMedia({
+        token: account.token,
+        toUser: userId,
+        contextToken,
+        filePath: p,
+        baseUrl: account.baseUrl,
+      });
+      mediaSent++;
+    } catch (err) {
+      log(`媒体发送失败 ${p}: ${String(err)}`);
+    }
+    text = text.replace(/\[media:\s*[^\]]+\]/g, '').trim();
+  }
+  return { text, mediaSent };
+}
+
+/** 发送 typing 指示（best-effort） */
+async function sendTypingIndicator(userId, contextToken, status) {
+  try {
+    let ticket = typingTicketCache.get(userId);
+    if (!ticket) {
+      const config = await getConfig(account.token, userId, contextToken, account.baseUrl);
+      ticket = config.typing_ticket ?? '';
+      if (ticket) typingTicketCache.set(userId, ticket);
+    }
+    if (ticket) {
+      await sendTyping(account.token, userId, ticket, status, account.baseUrl);
+    }
+  } catch {}
+}
+
+async function handleMessage(msg) {
+  if (msg.message_type !== 1) return; // 仅用户消息
+  const fromUser = msg.from_user_id ?? '';
+  const contextToken = msg.context_token ?? '';
+  const messageId = String(msg.message_id ?? '');
+  if (!fromUser || !contextToken) return;
+  if (processedIds.has(messageId)) return;
+  processedIds.add(messageId);
+  if (processedIds.size > 2000) {
+    const first = processedIds.values().next().value;
+    if (first) processedIds.delete(first);
+  }
+
+  const text = await extractText(msg);
+  if (!text.trim()) return;
+
+  if (TRIGGER_PREFIX && !text.startsWith(TRIGGER_PREFIX)) return;
+
+  log(`收到消息 from=${fromUser} len=${text.length}`);
+  await sendTypingIndicator(fromUser, contextToken, 1);
+
+  let sessionId;
+  try {
+    sessionId = await getSessionForUser(fromUser);
+  } catch (err) {
+    log(`获取 session 失败: ${String(err)}`);
+    return;
+  }
+
+  let reply = '';
+  try {
+    reply = await askOpenCode(sessionId, text);
+  } catch (err) {
+    log(`调用 opencode 失败: ${String(err)}`);
+    reply = `[处理失败: ${String(err.message ?? err)}]`;
+  }
+
+  await sendTypingIndicator(fromUser, contextToken, 2);
+
+  if (reply) {
+    // 处理定时任务标记（schedule_*）
+    let textToSend = processScheduleMarks(reply, fromUser);
+    // 再发送媒体标记
+    try {
+      const { text, mediaSent } = await sendMediaMarks(fromUser, contextToken, textToSend);
+      textToSend = text;
+      if (mediaSent > 0) log(`已发送 ${mediaSent} 个媒体文件 from=${fromUser}`);
+    } catch (err) {
+      log(`媒体处理失败: ${String(err)}`);
+    }
+    if (textToSend) {
+      const plainText = stripMarkdown(textToSend);
+      const chunks = chunkText(plainText, 3900);
+      for (const chunk of chunks) {
+        try {
+          await sendMessage(account.token, fromUser, chunk, contextToken, account.baseUrl, messageId);
+        } catch (err) {
+          log(`发送失败: ${String(err)}`);
+        }
+      }
+      log(`已回复 from=${fromUser} chunks=${chunks.length}`);
+    } else {
+      log(`已回复(仅媒体) from=${fromUser}`);
+    }
+  }
+}
+
+// ─── 轮询循环 ─────────────────────────────────────────
+async function pollLoop() {
+  let buf = loadSyncBuf();
+  let consecutiveFailures = 0;
+  let sessionRetries = 0;
+  let retryDelay = INITIAL_RETRY_DELAY_MS;
+  let nextTimeoutMs;
+  while (pollingActive && !pollingAbort?.signal.aborted) {
+    try {
+      const resp = await getUpdates(account.token, buf, account.baseUrl, nextTimeoutMs);
+      if (resp.longpolling_timeout_ms) {
+        nextTimeoutMs = resp.longpolling_timeout_ms;
+      }
+      if ((resp.ret !== undefined && resp.ret !== 0) || (resp.errcode !== undefined && resp.errcode !== 0)) {
+        const errcode = resp.errcode ?? resp.ret ?? 0;
+        if (errcode === SESSION_EXPIRED_ERRCODE) {
+          sessionRetries++;
+          log(`Session 过期 (${sessionRetries}/3)`);
+          if (sessionRetries >= 3) {
+            pollingActive = false;
+            log('Session 过期，请重新扫码登录: npx cc-wechat login');
+            return;
+          }
+          await sleep(SESSION_PAUSE_MS, pollingAbort?.signal);
+          continue;
+        }
+        consecutiveFailures++;
+        log(`API 错误 errcode=${errcode} errmsg=${resp.errmsg ?? ''} (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES})`);
+        if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+          await sleep(SESSION_PAUSE_MS, pollingAbort?.signal);
+          consecutiveFailures = 0;
+        } else {
+          await sleep(retryDelay, pollingAbort?.signal);
+          retryDelay = Math.min(retryDelay * 2, MAX_RETRY_DELAY_MS);
+        }
+        continue;
+      }
+      consecutiveFailures = 0;
+      retryDelay = INITIAL_RETRY_DELAY_MS;
+      if (resp.get_updates_buf) {
+        buf = resp.get_updates_buf;
+        saveSyncBuf(buf);
+      }
+      for (const msg of resp.msgs ?? []) {
+        try {
+          await handleMessage(msg);
+        } catch (err) {
+          log(`处理消息失败: ${String(err)}`);
+        }
+      }
+    } catch (err) {
+      if (pollingAbort?.signal.aborted) return;
+      consecutiveFailures++;
+      log(`网络错误: ${String(err)} (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES})`);
+      if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+        await sleep(SESSION_PAUSE_MS, pollingAbort?.signal);
+        consecutiveFailures = 0;
+      } else {
+        await sleep(retryDelay, pollingAbort?.signal);
+        retryDelay = Math.min(retryDelay * 2, MAX_RETRY_DELAY_MS);
+      }
+    }
+  }
+}
+
+function startPolling() {
+  if (!account || pollingActive) return;
+  pollingActive = true;
+  pollingAbort = new AbortController();
+  pollLoop().catch((err) => {
+    if (!pollingAbort?.signal.aborted) {
+      log(`Poll loop crashed: ${String(err)}`);
+    }
+    pollingActive = false;
+  });
+}
+
+function stopPolling() {
+  pollingActive = false;
+  pollingAbort?.abort();
+  pollingAbort = null;
+}
+
+// ─── 主入口 ───────────────────────────────────────────
+export async function startBridge() {
+  account = getActiveAccount();
+  if (!account) {
+    log('未找到账号。请先登录: npx cc-wechat login');
+    process.exit(1);
+  }
+  log(`账号: ${account.botId} baseUrl: ${account.baseUrl}`);
+  log(`opencode server: ${SERVER_BASE}`);
+  log(`session 映射: ${Object.keys(sessionMap).length} 个用户`);
+
+  // 等待 opencode serve 就绪（最多 60s，解决与 serve 同时启动的竞态）
+  let serveReady = false;
+  for (let i = 0; i < 60; i++) {
+    try {
+      await api('/global/health', {}, 3000);
+      serveReady = true;
+      break;
+    } catch {}
+    await sleep(1000);
+  }
+  if (serveReady) {
+    log('opencode serve 连接正常');
+  } else {
+    log(`警告: 无法连接 opencode serve (${SERVER_BASE})，收到消息时仍会尝试`);
+  }
+
+  startPolling();
+
+  // 启动定时任务调度器（每 20 秒检查一次）
+  log(`定时任务: ${tasks.length} 个`);
+  schedulerTimer = setInterval(() => {
+    runScheduler().catch((err) => log(`调度器错误: ${String(err)}`));
+  }, 20_000);
+
+  const shutdown = () => {
+    log('正在停止...');
+    stopPolling();
+    if (schedulerTimer) clearInterval(schedulerTimer);
+    saveSessionMap();
+    saveTasks();
+    process.exit(0);
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+export {
+  parseScheduleExpr,
+  addTask,
+  deleteTask,
+  listTasksFor,
+  processScheduleMarks,
+  runScheduler,
+  log,
+};
+
+// 兼容直接执行: node bridge.js
+import { fileURLToPath } from 'node:url';
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  startBridge().catch((err) => {
+    log(`Fatal: ${String(err)}`);
+    process.exit(1);
+  });
+}

package/src/cli.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+/**
+ * opencode-wechat-bot CLI
+ *
+ * 用法:
+ *   wechat-bot serve            启动 opencode serve（前台，需配合守护进程/计划任务）
+ *   wechat-bot bridge           启动桥接进程（前台，需配合守护进程/计划任务）
+ *   wechat-bot login            调用 cc-wechat 登录
+ *   wechat-bot status           查看 serve 健康状态
+ *   wechat-bot install          安装自启服务（macOS: launchd；Windows: 计划任务）
+ *   wechat-bot uninstall        卸载自启服务
+ */
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
+import {
+  SERVER_BASE,
+  SERVE_PORT,
+  BRIDGE_LOG,
+  ensureDirs,
+  findCcWechatDir,
+  BOT_HOME,
+} from './paths.js';
+
+const isWin = process.platform === 'win32';
+
+function usage() {
+  console.log(`opencode-wechat-bot
+用法:
+  wechat-bot serve            启动 opencode serve（前台）
+  wechat-bot bridge           启动桥接进程（前台）
+  wechat-bot login            调用 cc-wechat 登录
+  wechat-bot status           查看 serve 健康状态
+  wechat-bot install          安装自启服务（macOS: launchd / Windows: 计划任务）
+  wechat-bot uninstall        卸载自启服务
+
+环境变量:
+  WECHAT_BOT_HOME     数据目录（默认 ~/.wechat-bot）
+  WECHAT_STATE_DIR    cc-wechat 状态目录（默认 ~/.claude/channels/wechat/<profile>）
+  WECHAT_PROFILE      cc-wechat 账号 profile（默认 default）
+  OPENCODE_SERVER_URL opencode serve 地址（默认 http://127.0.0.1:4100）
+  OPENCODE_PORT       opencode serve 端口（默认 4100）
+  LLM_TIMEOUT_MS      LLM 响应超时（默认 300000）
+  BOT_PREFIX          可选: 仅响应带此前缀的消息
+`);
+}
+
+async function startServe() {
+  ensureDirs();
+  const opencodeBin = process.env.OPENCODE_BIN || 'opencode';
+  const args = ['serve', '--port', String(SERVE_PORT)];
+  // 禁用 wechat MCP，避免与 bridge 抢轮询
+  const env = {
+    ...process.env,
+    OPENCODE_CONFIG_CONTENT: '{"mcp":{"wechat":{"enabled":false}}}',
+  };
+  console.log(`[serve] 启动 ${opencodeBin} ${args.join(' ')}`);
+  const child = spawn(opencodeBin, args, { env, stdio: 'inherit', shell: false });
+  child.on('error', (err) => {
+    console.error(`[serve] 启动失败: ${err.message}`);
+    console.error('       请确认已安装 opencode 或在 OPENCODE_BIN 指定可执行文件路径');
+    process.exit(1);
+  });
+  const stop = () => {
+    child.kill('SIGTERM');
+  };
+  process.on('SIGINT', stop);
+  process.on('SIGTERM', stop);
+  child.on('exit', (code) => process.exit(code ?? 0));
+}
+
+async function startBridge() {
+  ensureDirs();
+  const { startBridge } = await import('./bridge.js');
+  await startBridge();
+}
+
+async function login() {
+  const ccWechat = findCcWechatDir();
+  const cli = join(ccWechat, 'dist', 'cli.js');
+  const child = spawn(process.execPath, [cli, 'login'], { stdio: 'inherit', shell: false });
+  child.on('error', (err) => {
+    console.error(`[login] 启动失败: ${err.message}`);
+    process.exit(1);
+  });
+  child.on('exit', (code) => process.exit(code ?? 0));
+}
+
+async function status() {
+  ensureDirs();
+  try {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), 5000);
+    const resp = await fetch(`${SERVER_BASE}/global/health`, { signal: ctrl.signal });
+    clearTimeout(t);
+    console.log(`serve: ${resp.ok ? 'OK' : `HTTP ${resp.status}`} (${SERVER_BASE})`);
+  } catch (err) {
+    console.log(`serve: 不可达 (${SERVER_BASE}) — ${err.message}`);
+  }
+  console.log(`数据目录: ${BOT_HOME}`);
+  if (existsSync(BRIDGE_LOG)) {
+    const tail = readFileSync(BRIDGE_LOG, 'utf-8').trim().split('\n').slice(-5).join('\n');
+    console.log(`bridge 日志尾部:\n${tail}`);
+  }
+}
+
+async function installService() {
+  ensureDirs();
+  if (isWin) {
+    console.error('Windows 自启请使用计划任务，稍后文档说明。');
+    process.exit(1);
+  }
+  // macOS: 生成 launchd plist 并加载
+  const plistDir = join(fileURLToPath(new URL('..', import.meta.url)), 'launchd');
+  const labelBase = 'com.opencode-wechat-bot';
+  const nodeBin = process.execPath;
+  const cliEntry = fileURLToPath(new URL('./cli.js', import.meta.url));
+
+  const makePlist = (name, args, extraEnv) => ({
+    Label: `${labelBase}.${name}`,
+    ProgramArguments: [nodeBin, cliEntry, ...args],
+    EnvironmentVariables: { HOME: process.env.HOME, ...extraEnv },
+    WorkingDirectory: BOT_HOME,
+    RunAtLoad: true,
+    KeepAlive: true,
+    StandardOutPath: join(BOT_HOME, 'logs', `${name}.log`),
+    StandardErrorPath: join(BOT_HOME, 'logs', `${name}.log`),
+  });
+
+  const writePlist = (name, obj) => {
+    const dict = Object.entries(obj)
+      .map(([k, v]) => {
+        if (typeof v === 'boolean') return `<key>${k}</key><${v ? 'true' : 'false'}/>`;
+        if (typeof v === 'number') return `<key>${k}</key><integer>${v}</integer>`;
+        if (Array.isArray(v))
+          return `<key>${k}</key><array>${v.map((x) => `<string>${x}</string>`).join('')}</array>`;
+        return `<key>${k}</key><string>${v}</string>`;
+      })
+      .join('\n  ');
+    return `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0">\n<dict>\n  ${dict}\n</dict>\n</plist>\n`;
+  };
+
+  const plists = {
+    serve: makePlist(
+      'serve',
+      ['serve'],
+      {
+        OPENCODE_CONFIG_CONTENT: '{"mcp":{"wechat":{"enabled":false}}}',
+        PATH: process.env.PATH || '',
+      },
+    ),
+    bridge: makePlist(
+      'bridge',
+      ['bridge'],
+      {
+        WECHAT_BOT_HOME: BOT_HOME,
+        PATH: process.env.PATH || '',
+      },
+    ),
+  };
+
+  const launchDir = join(process.env.HOME, 'Library', 'LaunchAgents');
+  const { mkdirSync } = await import('node:fs');
+  mkdirSync(launchDir, { recursive: true });
+  for (const [name, obj] of Object.entries(plists)) {
+    const plistPath = join(launchDir, `${labelBase}.${name}.plist`);
+    const { writeFileSync } = await import('node:fs');
+    writeFileSync(plistPath, writePlist(name, obj), 'utf-8');
+    console.log(`写入 ${plistPath}`);
+  }
+  console.log('请手动加载（需要 sudo 时）:\n  launchctl load ~/Library/LaunchAgents/com.opencode-wechat-bot.serve.plist\n  launchctl load ~/Library/LaunchAgents/com.opencode-wechat-bot.bridge.plist');
+  console.log(`或使用 launchctl bootstrap gui/$(id -u) ...`);
+  if (plistDir) console.log(`模板目录: ${plistDir}`);
+}
+
+const cmd = process.argv[2] || 'bridge';
+
+switch (cmd) {
+  case 'serve':
+    startServe().catch((err) => {
+      console.error(err);
+      process.exit(1);
+    });
+    break;
+  case 'bridge':
+    startBridge().catch((err) => {
+      console.error(err);
+      process.exit(1);
+    });
+    break;
+  case 'login':
+    login().catch((err) => {
+      console.error(err);
+      process.exit(1);
+    });
+    break;
+  case 'status':
+    status().catch((err) => {
+      console.error(err);
+      process.exit(1);
+    });
+    break;
+  case 'install':
+    installService().catch((err) => {
+      console.error(err);
+      process.exit(1);
+    });
+    break;
+  case 'uninstall':
+    console.log('请手动移除 launchd plist 或计划任务。');
+    break;
+  case 'help':
+  case '--help':
+  case '-h':
+    usage();
+    break;
+  default:
+    usage();
+    process.exit(1);
+}

package/src/paths.js

@@ -0,0 +1,92 @@
+/**
+ * 跨平台路径管理。
+ *
+ * 约定:
+ *  - WECHAT_BOT_HOME   桥接自身数据目录（sessions/tasks/media/logs/pids），默认 ~/.wechat-bot
+ *  - WECHAT_STATE_DIR  cc-wechat 状态目录（account.json/sync-buf），默认 ~/.claude/channels/wechat/<profile>
+ *  - WECHAT_PROFILE    cc-wechat 账号 profile（默认 'default'），与 cc-wechat store.js 保持一致
+ *  - OPENCODE_SERVER_URL / OPENCODE_PORT  opencode serve 地址（默认 http://127.0.0.1:4100）
+ */
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { readdirSync, existsSync, mkdirSync } from 'node:fs';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+const home = homedir();
+const BOT_HOME = process.env.WECHAT_BOT_HOME || join(home, '.wechat-bot');
+const STATE_DIR =
+  process.env.WECHAT_STATE_DIR ||
+  join(home, '.claude', 'channels', 'wechat', process.env.WECHAT_PROFILE || 'default');
+const MEDIA_DIR = join(BOT_HOME, 'media');
+const SESSION_MAP_FILE = join(BOT_HOME, 'sessions.json');
+const TASKS_FILE = join(BOT_HOME, 'tasks.json');
+const LOG_DIR = join(BOT_HOME, 'logs');
+const SERVE_LOG = join(LOG_DIR, 'serve.log');
+const BRIDGE_LOG = join(LOG_DIR, 'bridge.log');
+const PID_DIR = join(BOT_HOME, 'pids');
+const SERVE_PID_FILE = join(PID_DIR, 'serve.pid');
+const BRIDGE_PID_FILE = join(PID_DIR, 'bridge.pid');
+
+const SERVER_BASE = process.env.OPENCODE_SERVER_URL || 'http://127.0.0.1:4100';
+const SERVE_PORT = Number(process.env.OPENCODE_PORT || 4100);
+
+/**
+ * 定位 cc-wechat 包目录。
+ * 1. 优先当作已安装依赖解析（require.resolve）
+ * 2. 回退扫描 npx 缓存（mac/linux ~/.npm/_npx；win %LOCALAPPDATA%\npm-cache\_npx）
+ */
+function findCcWechatDir() {
+  try {
+    return dirname(require.resolve('cc-wechat/package.json'));
+  } catch {}
+  const roots = [join(home, '.npm', '_npx')];
+  if (process.platform === 'win32') {
+    roots.push(
+      join(process.env.LOCALAPPDATA || join(home, 'AppData', 'Local'), 'npm-cache', '_npx'),
+    );
+  }
+  for (const root of roots) {
+    try {
+      const entries = readdirSync(root, { withFileTypes: true });
+      const candidates = [];
+      for (const e of entries) {
+        if (!e.isDirectory()) continue;
+        const p = join(root, e.name, 'node_modules', 'cc-wechat');
+        if (existsSync(join(p, 'package.json'))) candidates.push(p);
+      }
+      if (candidates.length) return candidates[0];
+    } catch {}
+  }
+  throw new Error(
+    '找不到 cc-wechat 包。请安装依赖: npm install cc-wechat 或运行 npx -y -p cc-wechat@latest cc-wechat-server',
+  );
+}
+
+function ensureDirs() {
+  for (const d of [BOT_HOME, MEDIA_DIR, LOG_DIR, PID_DIR]) {
+    try {
+      mkdirSync(d, { recursive: true });
+    } catch {}
+  }
+}
+
+export {
+  home,
+  BOT_HOME,
+  STATE_DIR,
+  MEDIA_DIR,
+  SESSION_MAP_FILE,
+  TASKS_FILE,
+  LOG_DIR,
+  SERVE_LOG,
+  BRIDGE_LOG,
+  PID_DIR,
+  SERVE_PID_FILE,
+  BRIDGE_PID_FILE,
+  SERVER_BASE,
+  SERVE_PORT,
+  findCcWechatDir,
+  ensureDirs,
+};