omp-wechat 1.0.0 → 1.2.0

package/dist/index.js

@@ -1054,15 +1054,93 @@ import {
   readFileSync,
   writeFileSync,
   mkdirSync as mkdirSync2,
-  renameSync
+  renameSync as renameSync2
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 
 // src/utils/logger.ts
 import { homedir } from "os";
-import { join } from "path";
-import { mkdirSync, appendFileSync } from "fs";
+import { join as join2 } from "path";
+import { mkdirSync } from "fs";
+
+// src/utils/rotating-log.ts
+import { appendFileSync, statSync, renameSync, unlinkSync, readdirSync } from "fs";
+import { dirname, join, basename } from "path";
+var DEFAULT_MAX_BYTES = 5 * 1024 * 1024;
+var DEFAULT_MAX_FILES = 3;
+var DEFAULT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+
+class RotatingLog {
+  filePath;
+  maxBytes;
+  maxFiles;
+  maxAgeMs;
+  baseName;
+  dir;
+  activeFileName;
+  constructor(opts) {
+    this.filePath = opts.filePath;
+    this.maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
+    this.maxFiles = opts.maxFiles ?? DEFAULT_MAX_FILES;
+    this.maxAgeMs = opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+    this.dir = dirname(this.filePath);
+    this.activeFileName = basename(this.filePath);
+    this.baseName = basename(this.filePath, ".log");
+  }
+  write(line) {
+    try {
+      this.maybeRotate();
+      appendFileSync(this.filePath, line, "utf-8");
+    } catch {}
+  }
+  cleanStale() {
+    const cutoff = Date.now() - this.maxAgeMs;
+    try {
+      for (const name of readdirSync(this.dir)) {
+        if (name === this.activeFileName)
+          continue;
+        if (!name.startsWith(this.baseName) || !name.endsWith(".log"))
+          continue;
+        const fullPath = join(this.dir, name);
+        try {
+          const stat = statSync(fullPath);
+          if (stat.mtimeMs < cutoff)
+            unlinkSync(fullPath);
+        } catch {}
+      }
+    } catch {}
+  }
+  maybeRotate() {
+    let size;
+    try {
+      size = statSync(this.filePath).size;
+    } catch {
+      return;
+    }
+    if (size < this.maxBytes)
+      return;
+    const oldest = this.rotatedPath(this.maxFiles);
+    try {
+      unlinkSync(oldest);
+    } catch {}
+    for (let i = this.maxFiles - 1;i >= 1; i--) {
+      const src = this.rotatedPath(i);
+      const dst = this.rotatedPath(i + 1);
+      try {
+        renameSync(src, dst);
+      } catch {}
+    }
+    try {
+      renameSync(this.filePath, this.rotatedPath(1));
+    } catch {}
+  }
+  rotatedPath(index) {
+    return join(this.dir, `${this.baseName}.${index}.log`);
+  }
+}
+
+// src/utils/logger.ts
 var LEVEL_ORDER = {
   debug: 0,
   info: 1,
@@ -1070,11 +1148,18 @@ var LEVEL_ORDER = {
   error: 3
 };
 var minLevel = process.env.OMP_WECHAT_LOG ?? "info";
-var LOG_DIR = join(homedir(), ".omp-wechat", "logs");
-var LOG_FILE = join(LOG_DIR, "daemon.log");
+var LOG_DIR = join2(homedir(), ".omp", "logs");
+var LOG_FILE = join2(LOG_DIR, "wechat.log");
 try {
   mkdirSync(LOG_DIR, { recursive: true });
 } catch {}
+var rotatingLog = new RotatingLog({
+  filePath: LOG_FILE,
+  maxBytes: 5 * 1024 * 1024,
+  maxFiles: 3,
+  maxAgeMs: 30 * 24 * 60 * 60 * 1000
+});
+rotatingLog.cleanStale();
 function ts() {
   return new Date().toISOString();
 }
@@ -1085,10 +1170,7 @@ function log(level, msg, meta) {
   const line = meta !== undefined ? `${prefix} ${msg} ${JSON.stringify(meta)}
 ` : `${prefix} ${msg}
 `;
-  process.stderr.write(line);
-  try {
-    appendFileSync(LOG_FILE, line);
-  } catch {}
+  rotatingLog.write(line);
 }
 var logger = {
   debug: (msg, meta) => log("debug", msg, meta),
@@ -1098,9 +1180,9 @@ var logger = {
 };
 
 // src/ilink/client.ts
-var STATE_DIR = join2(homedir2(), ".omp-wechat");
-var CREDENTIALS_FILE = join2(STATE_DIR, "credentials.json");
-var SYNC_BUF_FILE = join2(STATE_DIR, "sync_buf.txt");
+var STATE_DIR = join3(homedir2(), ".omp-wechat");
+var CREDENTIALS_FILE = join3(STATE_DIR, "credentials.json");
+var SYNC_BUF_FILE = join3(STATE_DIR, "sync_buf.txt");
 function loadCredentials() {
   try {
     return JSON.parse(readFileSync(CREDENTIALS_FILE, "utf8"));
@@ -1113,7 +1195,7 @@ function saveCredentials(creds) {
   const tmp = CREDENTIALS_FILE + ".tmp";
   writeFileSync(tmp, JSON.stringify(creds, null, 2) + `
 `, { mode: 384 });
-  renameSync(tmp, CREDENTIALS_FILE);
+  renameSync2(tmp, CREDENTIALS_FILE);
 }
 function getCredentials() {
   const creds = loadCredentials();
@@ -1175,12 +1257,12 @@ async function getUpdates(creds, buf) {
     throw err;
   }
 }
-async function sendMessage(creds, to, text, contextToken) {
+async function sendMessage(creds, to, text, contextToken, clientId) {
   await apiFetch(creds, "ilink/bot/sendmessage", {
     msg: {
       from_user_id: "",
       to_user_id: to,
-      client_id: `omp-wechat-${Date.now()}-${randomBytes(4).toString("hex")}`,
+      client_id: clientId ?? `omp-wechat-${Date.now()}-${randomBytes(4).toString("hex")}`,
       message_type: 2,
       message_state: 2,
       item_list: [{ type: 1, text_item: { text } }],
@@ -1243,6 +1325,7 @@ function saveSyncBuf(buf) {
 function extractInboundText(msg) {
   const items = msg.item_list ?? [];
   const parts = [];
+  let imgCount = 0;
   for (const item of items) {
     switch (item.type) {
       case 1:
@@ -1250,7 +1333,7 @@ function extractInboundText(msg) {
           parts.push(item.text_item.text);
         break;
       case 2:
-        parts.push("(image)");
+        imgCount++;
         break;
       case 3:
         parts.push(item.voice_item?.text ?? "(voice)");
@@ -1263,9 +1346,17 @@ function extractInboundText(msg) {
         break;
     }
   }
+  if (imgCount > 0 && parts.length === 0) {
+    parts.push(`(user sent ${imgCount} image${imgCount > 1 ? "s" : ""})`);
+  } else if (imgCount > 0) {
+    parts.push(`(+${imgCount} image${imgCount > 1 ? "s" : ""})`);
+  }
   return parts.join(`
 `) || "";
 }
+function extractInboundImages(msg) {
+  return (msg.item_list ?? []).filter((item) => item.type === 2);
+}
 
 // src/access/control.ts
 import { randomBytes as randomBytes2 } from "crypto";
@@ -1273,12 +1364,12 @@ import {
   readFileSync as readFileSync2,
   writeFileSync as writeFileSync2,
   mkdirSync as mkdirSync3,
-  renameSync as renameSync2
+  renameSync as renameSync3
 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join3 } from "path";
-var STATE_DIR2 = join3(homedir3(), ".omp-wechat");
-var ACCESS_FILE = join3(STATE_DIR2, "access.json");
+import { join as join4 } from "path";
+var STATE_DIR2 = join4(homedir3(), ".omp-wechat");
+var ACCESS_FILE = join4(STATE_DIR2, "access.json");
 function defaultAccess() {
   return { dmPolicy: "pairing", allowFrom: [], pending: {} };
 }
@@ -1295,7 +1386,7 @@ function readAccessFile() {
     if (err.code === "ENOENT")
       return defaultAccess();
     try {
-      renameSync2(ACCESS_FILE, `${ACCESS_FILE}.corrupt-${Date.now()}`);
+      renameSync3(ACCESS_FILE, `${ACCESS_FILE}.corrupt-${Date.now()}`);
     } catch {}
     logger.warn("access.json is corrupt, moved aside, using defaults");
     return defaultAccess();
@@ -1306,7 +1397,7 @@ function saveAccess(a) {
   const tmp = ACCESS_FILE + ".tmp";
   writeFileSync2(tmp, JSON.stringify(a, null, 2) + `
 `, { mode: 384 });
-  renameSync2(tmp, ACCESS_FILE);
+  renameSync3(tmp, ACCESS_FILE);
 }
 function loadAccess() {
   return readAccessFile();
@@ -1476,9 +1567,12 @@ async function pollQrStatus(qrcode, baseUrl) {
   }
 }
 
+// src/bridge.ts
+import { randomBytes as randomBytes3 } from "crypto";
+
 // src/config.ts
 import { homedir as homedir4 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { existsSync, readFileSync as readFileSync3 } from "fs";
 var DEFAULT_SYSTEM_PROMPT = `You are an AI assistant chatting with users via WeChat.
 
@@ -1487,8 +1581,8 @@ Constraints:
 - Keep replies concise; WeChat has a ~2000 character limit per message
 - If you need to write code or long documents, summarize the key points; the user will review on their computer
 - Users may send short or incomplete messages from their phone; proactively understand their intent`;
-var CONFIG_DIR = join4(homedir4(), ".omp-wechat");
-var CONFIG_FILE = join4(CONFIG_DIR, "config.yml");
+var CONFIG_DIR = join5(homedir4(), ".omp-wechat");
+var CONFIG_FILE = join5(CONFIG_DIR, "config.yml");
 function loadConfig() {
   const config = {
     maxSessions: 50,
@@ -1503,6 +1597,10 @@ function loadConfig() {
         config.maxSessions = parseInt(parsed.maxSessions, 10);
       if (parsed.dmPolicy)
         config.dmPolicy = parsed.dmPolicy;
+      if (parsed.model)
+        config.model = parsed.model;
+      if (parsed.cwd)
+        config.cwd = expandTilde(parsed.cwd);
       if (parsed.systemPrompt)
         config.systemPrompt = parsed.systemPrompt;
     }
@@ -1511,6 +1609,13 @@ function loadConfig() {
   }
   return config;
 }
+function expandTilde(p) {
+  if (p.startsWith("~/"))
+    return join5(homedir4(), p.slice(2));
+  if (p === "~")
+    return homedir4();
+  return p;
+}
 function parseSimpleYaml(yaml) {
   const result = {};
   let inMultiline = false;
@@ -1574,35 +1679,204 @@ function chunkText(text, limit = 2000) {
   return out;
 }
 
+// src/utils/dedup.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, renameSync as renameSync4 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join6 } from "path";
+var STATE_DIR3 = join6(homedir5(), ".omp-wechat");
+var DEDUP_FILE = join6(STATE_DIR3, "seen_msgs.json");
+var MAX_ENTRIES = 500;
+var DEDUP_TTL_MS = 5 * 60 * 1000;
+var entries = null;
+function load() {
+  if (entries)
+    return entries;
+  try {
+    const raw = readFileSync4(DEDUP_FILE, "utf8");
+    const arr = JSON.parse(raw);
+    entries = Array.isArray(arr) ? arr : [];
+  } catch {
+    entries = [];
+  }
+  return entries;
+}
+function gc(s) {
+  const now = Date.now();
+  const fresh = s.filter((e) => now - e.ts < DEDUP_TTL_MS);
+  if (fresh.length < s.length) {
+    s.length = 0;
+    s.push(...fresh);
+  }
+}
+function persist(s) {
+  let arr = s.slice();
+  if (arr.length > MAX_ENTRIES)
+    arr = arr.slice(arr.length - MAX_ENTRIES);
+  try {
+    mkdirSync4(STATE_DIR3, { recursive: true, mode: 448 });
+    const tmp = DEDUP_FILE + ".tmp";
+    writeFileSync3(tmp, JSON.stringify(arr) + `
+`, { mode: 384 });
+    renameSync4(tmp, DEDUP_FILE);
+  } catch (err) {
+    logger.debug(`dedup persist failed: ${err}`);
+  }
+}
+function makeDedupKey(senderId, createTimeMs, text) {
+  if (!createTimeMs)
+    return null;
+  return `${senderId}|${createTimeMs}|${text.slice(0, 200)}`;
+}
+function isDuplicate(key) {
+  const s = load();
+  gc(s);
+  if (s.some((e) => e.key === key))
+    return true;
+  s.push({ key, ts: Date.now() });
+  persist(s);
+  return false;
+}
+
+// src/ilink/cdn.ts
+import { createDecipheriv } from "crypto";
+var CDN_BASE_URL = "https://novac2c.cdn.weixin.qq.com/c2c";
+function parseAesKey(aeskeyHex, aesKeyBase64) {
+  if (aeskeyHex && /^[0-9a-fA-F]{32}$/.test(aeskeyHex)) {
+    return Buffer.from(aeskeyHex, "hex");
+  }
+  if (!aesKeyBase64)
+    return null;
+  const decoded = Buffer.from(aesKeyBase64, "base64");
+  if (decoded.length === 16)
+    return decoded;
+  if (decoded.length === 32 && /^[0-9a-fA-F]{32}$/.test(decoded.toString("ascii"))) {
+    return Buffer.from(decoded.toString("ascii"), "hex");
+  }
+  return null;
+}
+function decryptAesEcb(ciphertext, key) {
+  const decipher = createDecipheriv("aes-128-ecb", key, null);
+  return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}
+function buildCdnUrl(fileUrl, fullUrl) {
+  if (fullUrl)
+    return fullUrl;
+  if (!fileUrl)
+    return null;
+  if (fileUrl.startsWith("http"))
+    return fileUrl;
+  return `${CDN_BASE_URL}/download?encrypted_query_param=${encodeURIComponent(fileUrl)}`;
+}
+async function downloadAndDecrypt(fileUrl, fullUrl, aeskeyHex, aesKeyBase64, label = "media") {
+  const url = buildCdnUrl(fileUrl, fullUrl);
+  if (!url) {
+    logger.warn(`[${label}] No CDN URL available`);
+    return null;
+  }
+  const key = parseAesKey(aeskeyHex, aesKeyBase64);
+  if (!key) {
+    logger.warn(`[${label}] Could not parse AES key`);
+    return null;
+  }
+  try {
+    const resp = await fetch(url);
+    if (!resp.ok) {
+      logger.warn(`[${label}] CDN download failed: ${resp.status} ${resp.statusText}`);
+      return null;
+    }
+    const encrypted = Buffer.from(await resp.arrayBuffer());
+    const plaintext = decryptAesEcb(encrypted, key);
+    logger.info(`[${label}] Downloaded + decrypted: ${encrypted.length} \u2192 ${plaintext.length} bytes`);
+    return plaintext;
+  } catch (err) {
+    logger.error(`[${label}] CDN download/decrypt error:`, err);
+    return null;
+  }
+}
+
 // src/engine/session.ts
 import { createAgentSession, SessionManager } from "@oh-my-pi/pi-coding-agent";
-async function createSession(chatId, contextToken, config, onReply) {
-  logger.info(`Creating session: ${chatId}`);
-  const { session, modelFallbackMessage } = await createAgentSession({
-    sessionManager: SessionManager.inMemory(),
-    enableMCP: false,
-    enableLsp: false,
-    systemPrompt: config.systemPrompt
-  });
-  if (modelFallbackMessage) {
-    logger.warn(`Model fallback: ${modelFallbackMessage}`);
+
+// src/engine/session-store.ts
+import { join as join7 } from "path";
+import { homedir as homedir6 } from "os";
+import { existsSync as existsSync2, mkdirSync as mkdirSync5, readdirSync as readdirSync2, statSync as statSync2, rmSync } from "fs";
+var STATE_DIR4 = join7(homedir6(), ".omp-wechat");
+var SESSIONS_DIR = join7(STATE_DIR4, "sessions");
+var STALE_THRESHOLD_MS = 30 * 24 * 60 * 60 * 1000;
+function sanitizeChatId(chatId) {
+  return chatId.replace(/[^a-zA-Z0-9_@.-]/g, "_").slice(0, 200);
+}
+function sessionDirFor(chatId) {
+  return join7(SESSIONS_DIR, sanitizeChatId(chatId));
+}
+function ensureSessionsDir() {
+  mkdirSync5(SESSIONS_DIR, { recursive: true, mode: 448 });
+}
+function removeSessionDir(chatId) {
+  const dir = sessionDirFor(chatId);
+  if (!existsSync2(dir))
+    return false;
+  try {
+    rmSync(dir, { recursive: true, force: true });
+    return true;
+  } catch (err) {
+    logger.warn(`Failed to remove session dir ${dir}: ${err}`);
+    return false;
   }
-  session.subscribe((event) => {
-    if (event.type !== "message_end")
-      return;
-    if (event.message.role !== "assistant")
-      return;
-    const text = extractAssistantText(event.message);
-    if (text) {
-      onReply(chatId, text);
+}
+function cleanupStaleSessions() {
+  if (!existsSync2(SESSIONS_DIR))
+    return 0;
+  const now = Date.now();
+  let removed = 0;
+  for (const entry of readdirSync2(SESSIONS_DIR, { withFileTypes: true })) {
+    if (!entry.isDirectory())
+      continue;
+    const dir = join7(SESSIONS_DIR, entry.name);
+    let newestMtime = 0;
+    try {
+      for (const file of readdirSync2(dir)) {
+        const mtime = statSync2(join7(dir, file)).mtimeMs;
+        if (mtime > newestMtime)
+          newestMtime = mtime;
+      }
+    } catch {
+      continue;
     }
-  });
-  return {
-    session,
-    lastActive: Date.now(),
-    contextToken
-  };
+    if (newestMtime === 0 || now - newestMtime > STALE_THRESHOLD_MS) {
+      try {
+        rmSync(dir, { recursive: true, force: true });
+        removed++;
+        logger.info(`Cleaned up stale session dir: ${entry.name}`);
+      } catch (err) {
+        logger.warn(`Failed to cleanup session dir ${entry.name}: ${err}`);
+      }
+    }
+  }
+  if (removed > 0) {
+    logger.info(`Session cleanup: removed ${removed} stale session(s)`);
+  }
+  return removed;
+}
+function clearAllSessions() {
+  if (!existsSync2(SESSIONS_DIR))
+    return 0;
+  let removed = 0;
+  for (const entry of readdirSync2(SESSIONS_DIR, { withFileTypes: true })) {
+    if (!entry.isDirectory())
+      continue;
+    try {
+      rmSync(join7(SESSIONS_DIR, entry.name), { recursive: true, force: true });
+      removed++;
+    } catch (err) {
+      logger.warn(`Failed to remove session dir ${entry.name}: ${err}`);
+    }
+  }
+  return removed;
 }
+
+// src/engine/session.ts
 function extractAssistantText(message) {
   const content = message.content;
   if (!Array.isArray(content))
@@ -1617,70 +1891,326 @@ function extractAssistantText(message) {
 `).trim();
 }
 
+class ChatSession {
+  session;
+  chatId;
+  contextToken;
+  lastActive;
+  replyCount = 0;
+  constructor(session, chatId, contextToken) {
+    this.session = session;
+    this.chatId = chatId;
+    this.contextToken = contextToken;
+    this.lastActive = Date.now();
+  }
+  static async create(chatId, contextToken, config, onReply) {
+    logger.info(`Creating session: ${chatId}`);
+    ensureSessionsDir();
+    const sessionDir = sessionDirFor(chatId);
+    const sessionManager = await SessionManager.continueRecent(config.cwd || process.cwd(), sessionDir);
+    logger.info(`Session dir: ${sessionDir} (resumed=${sessionManager.getSessionFile() !== null})`);
+    const { session, modelFallbackMessage } = await createAgentSession({
+      sessionManager,
+      enableMCP: false,
+      enableLsp: false,
+      systemPrompt: config.systemPrompt,
+      modelPattern: config.model
+    });
+    if (modelFallbackMessage) {
+      logger.warn(`Model fallback: ${modelFallbackMessage}`);
+    }
+    const wrapper = new ChatSession(session, chatId, contextToken);
+    const visionRole = session.settings.getModelRole("vision");
+    logger.info(`[${chatId}] Model: ${session.model?.id ?? "unknown"}, vision role: ${visionRole ?? "(not configured)"}`);
+    session.subscribe((event) => {
+      if (event.type !== "message_end")
+        return;
+      if (event.message.role !== "assistant")
+        return;
+      wrapper.replyCount++;
+      const text = extractAssistantText(event.message);
+      logger.info(`[${chatId}] message_end #${wrapper.replyCount}: ${text.slice(0, 100)}`);
+      if (text) {
+        onReply(chatId, text);
+      }
+    });
+    return wrapper;
+  }
+  async prompt(text, images) {
+    this.lastActive = Date.now();
+    await this.session.prompt(text, images?.length ? { images } : undefined);
+  }
+  supportsVision() {
+    return this.session.settings.getModelRole("vision") !== undefined;
+  }
+  setContextToken(token) {
+    this.contextToken = token;
+  }
+  getContextToken() {
+    return this.contextToken;
+  }
+  getLastActive() {
+    return this.lastActive;
+  }
+  async dispose() {
+    await this.session.dispose();
+  }
+}
+
 // src/engine/pool.ts
-var maxSessions = 50;
-var pool = new Map;
-var replyHandler = () => {};
-function setReplyHandler(fn) {
-  replyHandler = fn;
-}
-function setMaxSessions(n) {
-  maxSessions = n;
-}
-async function ensureSession(chatId, contextToken, config) {
-  let entry = pool.get(chatId);
-  if (entry) {
-    entry.contextToken = contextToken;
-    entry.lastActive = Date.now();
+class SessionPool {
+  pool = new Map;
+  maxSessions;
+  replyHandler;
+  constructor(maxSessions, replyHandler) {
+    this.maxSessions = maxSessions;
+    this.replyHandler = replyHandler;
+  }
+  setMaxSessions(n) {
+    this.maxSessions = n;
+  }
+  async ensure(chatId, contextToken, config) {
+    let entry = this.pool.get(chatId);
+    if (entry) {
+      entry.setContextToken(contextToken);
+      return entry;
+    }
+    if (this.pool.size >= this.maxSessions) {
+      this.evictOldest();
+    }
+    entry = await ChatSession.create(chatId, contextToken, config, this.replyHandler);
+    this.pool.set(chatId, entry);
     return entry;
   }
-  if (pool.size >= maxSessions) {
-    evictOldest();
+  async prompt(chatId, contextToken, text, config, images) {
+    const entry = await this.ensure(chatId, contextToken, config);
+    await entry.prompt(text, images);
+  }
+  get(chatId) {
+    return this.pool.get(chatId);
+  }
+  async resetSession(chatId) {
+    const entry = this.pool.get(chatId);
+    if (entry) {
+      await entry.dispose();
+      this.pool.delete(chatId);
+    }
+    removeSessionDir(chatId);
+  }
+  getContextToken(chatId) {
+    return this.pool.get(chatId)?.getContextToken() ?? "";
+  }
+  supportsVision(chatId) {
+    return this.pool.get(chatId)?.supportsVision() ?? false;
+  }
+  evictOldest() {
+    let oldestId = null;
+    let oldestTime = Infinity;
+    for (const [id, entry] of this.pool) {
+      const t = entry.getLastActive();
+      if (t < oldestTime) {
+        oldestTime = t;
+        oldestId = id;
+      }
+    }
+    if (oldestId) {
+      const entry = this.pool.get(oldestId);
+      if (entry) {
+        entry.dispose().catch((err) => {
+          logger.warn(`Session dispose error (${oldestId}): ${err}`);
+        });
+      }
+      this.pool.delete(oldestId);
+      logger.info(`LRU evicted session: ${oldestId}`);
+    }
+  }
+  getPoolStatus() {
+    const chats = Array.from(this.pool.entries()).map(([chatId, entry]) => ({
+      chatId,
+      lastActive: entry.getLastActive()
+    }));
+    return { count: this.pool.size, max: this.maxSessions, chats };
+  }
+  async disposeAll() {
+    const disposals = Array.from(this.pool.values()).map((entry) => entry.dispose().catch((err) => {
+      logger.warn(`Session dispose error: ${err}`);
+    }));
+    await Promise.all(disposals);
+    this.pool.clear();
   }
-  entry = await createSession(chatId, contextToken, config, replyHandler);
-  pool.set(chatId, entry);
-  return entry;
 }
-async function promptSession(chatId, contextToken, text, config) {
-  const entry = await ensureSession(chatId, contextToken, config);
-  await entry.session.prompt(text);
+
+// src/command/registry.ts
+class CommandRegistry {
+  commands = [];
+  register(cmd) {
+    this.commands.push(cmd);
+  }
+  tryParse(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("/"))
+      return null;
+    for (const cmd of this.commands) {
+      const inv = cmd.parse(trimmed);
+      if (inv)
+        return inv;
+    }
+    return null;
+  }
 }
-function getContextToken(chatId) {
-  return pool.get(chatId)?.contextToken ?? "";
+
+// src/engine/model-controller.ts
+function currentModel(session) {
+  const m = session.model;
+  if (!m)
+    return;
+  return {
+    provider: m.provider,
+    id: m.id,
+    name: m.name,
+    contextWindow: m.contextWindow
+  };
 }
-function evictOldest() {
-  let oldestId = null;
-  let oldestTime = Infinity;
-  for (const [id, entry] of pool) {
-    if (entry.lastActive < oldestTime) {
-      oldestTime = entry.lastActive;
-      oldestId = id;
+function listModels(session) {
+  return session.modelRegistry.getAvailable().map((m) => ({
+    provider: m.provider,
+    id: m.id,
+    name: m.name,
+    contextWindow: m.contextWindow
+  }));
+}
+function resolveModel(pattern, session) {
+  const trimmed = pattern.trim();
+  const slash = trimmed.indexOf("/");
+  if (slash <= 0)
+    return null;
+  const provider = trimmed.slice(0, slash);
+  const modelId = trimmed.slice(slash + 1);
+  if (!provider || !modelId)
+    return null;
+  const model = session.modelRegistry.find(provider, modelId);
+  if (!model)
+    return null;
+  return {
+    provider: model.provider,
+    id: model.id,
+    name: model.name,
+    contextWindow: model.contextWindow
+  };
+}
+async function switchModel(pattern, session) {
+  const info = resolveModel(pattern, session);
+  if (!info) {
+    return {
+      ok: false,
+      message: `Unknown model: ${pattern}
+Use /models to see available options (format: provider/model-id).`
+    };
+  }
+  const model = session.modelRegistry.find(info.provider, info.id);
+  if (!model) {
+    return { ok: false, message: `Model not found: ${pattern}` };
+  }
+  try {
+    await session.setModelTemporary(model);
+    return {
+      ok: true,
+      message: `Switched to ${info.provider}/${info.id} (${info.name})`
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      message: `Switch failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+
+// src/command/model-command.ts
+var MODEL_PREFIX = "/model";
+var MODELS_PREFIX = "/models";
+
+class ModelQueryInvocation {
+  async execute(ctx) {
+    const entry = ctx.pool.get(ctx.chatId);
+    if (!entry)
+      return "No active session for this chat.";
+    const info = currentModel(entry.session);
+    if (!info)
+      return "No model selected.";
+    return `Current model: ${info.provider}/${info.id} (${info.name})`;
+  }
+}
+
+class ModelListInvocation {
+  async execute(ctx) {
+    const entry = ctx.pool.get(ctx.chatId);
+    if (!entry)
+      return "No active session for this chat.";
+    const models = listModels(entry.session);
+    if (models.length === 0)
+      return "No models available.";
+    const cur = currentModel(entry.session);
+    const curKey = cur ? `${cur.provider}/${cur.id}` : "";
+    const lines = [`Available models (${models.length}):`];
+    for (const m of models) {
+      const key = `${m.provider}/${m.id}`;
+      const marker = key === curKey ? " \u2190 current" : "";
+      lines.push(`  ${key} (${m.name})${marker}`);
     }
+    lines.push("", "Switch with: /model provider/id");
+    return lines.join(`
+`);
   }
-  if (oldestId) {
-    const entry = pool.get(oldestId);
-    if (entry) {
-      entry.session.dispose().catch((err) => {
-        logger.warn(`Session dispose error (${oldestId}): ${err}`);
-      });
+}
+
+class ModelSwitchInvocation {
+  pattern;
+  constructor(pattern) {
+    this.pattern = pattern;
+  }
+  async execute(ctx) {
+    const entry = ctx.pool.get(ctx.chatId);
+    if (!entry)
+      return "No active session for this chat.";
+    const result = await switchModel(this.pattern, entry.session);
+    return result.message;
+  }
+}
+
+class ModelCommand {
+  name = "model";
+  parse(text) {
+    if (text === MODELS_PREFIX || text.startsWith(`${MODELS_PREFIX} `)) {
+      return new ModelListInvocation;
+    }
+    if (text === MODEL_PREFIX) {
+      return new ModelQueryInvocation;
     }
-    pool.delete(oldestId);
-    logger.info(`LRU evicted session: ${oldestId}`);
+    if (text.startsWith(`${MODEL_PREFIX} `)) {
+      const pattern = text.slice(MODEL_PREFIX.length + 1).trim();
+      if (pattern)
+        return new ModelSwitchInvocation(pattern);
+    }
+    return null;
   }
 }
-function getPoolStatus() {
-  const chats = Array.from(pool.entries()).map(([chatId, entry]) => ({
-    chatId,
-    lastActive: entry.lastActive
-  }));
-  return { count: pool.size, max: maxSessions, chats };
+
+// src/command/new-session-command.ts
+class NewSessionInvocation {
+  async execute(ctx) {
+    await ctx.pool.resetSession(ctx.chatId);
+    return "Session reset. Your next message starts a fresh conversation.";
+  }
 }
-async function disposeAll() {
-  const disposals = Array.from(pool.values()).map((entry) => entry.session.dispose().catch((err) => {
-    logger.warn(`Session dispose error: ${err}`);
-  }));
-  await Promise.all(disposals);
-  pool.clear();
+
+class NewSessionCommand {
+  name = "new";
+  parse(text) {
+    if (text === "/new" || text === "/reset") {
+      return new NewSessionInvocation;
+    }
+    return null;
+  }
 }
 
 // src/bridge.ts
@@ -1690,171 +2220,236 @@ var RETRY_MS = 2000;
 var MAX_SEND_RETRIES = 2;
 var CHUNK_LIMIT = 2000;
 var LOCK_PORT = 19821;
-var pollActive = false;
-var lockServer = null;
-function acquireLock() {
-  try {
-    lockServer = Bun.serve({
-      port: LOCK_PORT,
-      hostname: "127.0.0.1",
-      fetch() {
-        return new Response("ok");
-      }
-    });
-    return true;
-  } catch {
-    return false;
+
+class WeChatBridge {
+  state = null;
+  pollActive = false;
+  lockServer = null;
+  cleanupTimer = null;
+  pool = null;
+  commands = new CommandRegistry;
+  constructor() {
+    this.commands.register(new ModelCommand);
+    this.commands.register(new NewSessionCommand);
   }
-}
-function releaseLock() {
-  if (lockServer) {
-    lockServer.stop(true);
-    lockServer = null;
+  start() {
+    const config = loadConfig();
+    const creds = getCredentials();
+    if (this.pollActive) {
+      return this.state;
+    }
+    if (!this.acquireLock()) {
+      logger.debug("Another poll loop is running (port lock held), skipping");
+      return { running: false, config, creds, lastError: "another instance running" };
+    }
+    this.pollActive = true;
+    const replyHandler = (chatId, text) => {
+      sendTyping(creds, chatId, 2).catch(() => {});
+      this.sendReply(creds, chatId, text).catch((err) => {
+        logger.error(`[${chatId}] Reply send failed:`, err);
+      });
+    };
+    this.pool = new SessionPool(config.maxSessions, replyHandler);
+    this.state = { running: true, config, creds, lastError: null };
+    logger.info("OMP-Wechat poll loop starting", {
+      maxSessions: config.maxSessions,
+      dmPolicy: config.dmPolicy,
+      model: config.model ?? "(omp default)"
+    });
+    this.pollLoop(creds, this.state).catch((err) => {
+      logger.error("Poll loop crashed:", err);
+      this.state.running = false;
+      this.state.lastError = String(err);
+      this.pollActive = false;
+      this.releaseLock();
+    });
+    cleanupStaleSessions();
+    this.cleanupTimer = setInterval(() => cleanupStaleSessions(), 6 * 60 * 60 * 1000);
+    return this.state;
   }
-}
-function startPollLoop() {
-  const config = loadConfig();
-  const creds = getCredentials();
-  if (pollActive) {
-    return { running: true, config, creds, lastError: null };
+  async stop() {
+    this.pollActive = false;
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    this.releaseLock();
+    if (this.pool) {
+      await this.pool.disposeAll();
+    }
+    logger.info("Poll loop stopped");
   }
-  if (!acquireLock()) {
-    logger.info("Another poll loop is running (port lock held), skipping");
-    return { running: false, config, creds, lastError: "another instance running" };
+  getPoolStatus() {
+    return this.pool?.getPoolStatus() ?? { count: 0, max: 0, chats: [] };
   }
-  pollActive = true;
-  setMaxSessions(config.maxSessions);
-  const state = { running: true, config, creds, lastError: null };
-  setReplyHandler((chatId, text) => {
-    sendTyping(creds, chatId, 2).catch(() => {});
-    sendReply(creds, chatId, text).catch((err) => {
-      logger.error(`[${chatId}] Reply send failed:`, err);
-    });
-  });
-  logger.info("OMP-Wechat poll loop starting", {
-    maxSessions: config.maxSessions,
-    dmPolicy: config.dmPolicy
-  });
-  pollLoop(creds, state).catch((err) => {
-    logger.error("Poll loop crashed:", err);
-    state.running = false;
-    state.lastError = String(err);
-    pollActive = false;
-    releaseLock();
-  });
-  return state;
-}
-async function stopPollLoop() {
-  pollActive = false;
-  releaseLock();
-  await disposeAll();
-  logger.info("Poll loop stopped");
-}
-async function pollLoop(creds, state) {
-  let failures = 0;
-  logger.info("Long-poll started");
-  while (pollActive) {
+  acquireLock() {
     try {
-      const buf = loadSyncBuf();
-      const resp = await getUpdates(creds, buf);
-      if (resp.ret !== undefined && resp.ret !== 0) {
+      this.lockServer = Bun.serve({
+        port: LOCK_PORT,
+        hostname: "127.0.0.1",
+        fetch() {
+          return new Response("ok");
+        }
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  releaseLock() {
+    if (this.lockServer) {
+      this.lockServer.stop(true);
+      this.lockServer = null;
+    }
+  }
+  async pollLoop(creds, state) {
+    let failures = 0;
+    logger.info("Long-poll started");
+    while (this.pollActive) {
+      try {
+        const buf = loadSyncBuf();
+        const resp = await getUpdates(creds, buf);
+        if (resp.ret !== undefined && resp.ret !== 0) {
+          failures++;
+          logger.warn(`getupdates error ret=${resp.ret} errmsg=${resp.errmsg ?? ""} (${failures}/${MAX_FAILURES})`);
+          if (failures >= MAX_FAILURES) {
+            failures = 0;
+            await Bun.sleep(BACKOFF_MS);
+          } else {
+            await Bun.sleep(RETRY_MS);
+          }
+          continue;
+        }
+        failures = 0;
+        state.lastError = null;
+        if (resp.get_updates_buf && resp.get_updates_buf !== buf) {
+          saveSyncBuf(resp.get_updates_buf);
+        }
+        const msgs = resp.msgs ?? [];
+        for (const msg of msgs) {
+          await this.handleInbound(creds, msg).catch((err) => {
+            logger.error("Message handler error:", err);
+          });
+        }
+      } catch (err) {
         failures++;
-        logger.warn(`getupdates error ret=${resp.ret} errmsg=${resp.errmsg ?? ""} (${failures}/${MAX_FAILURES})`);
+        state.lastError = String(err);
+        logger.error(`Poll error (${failures}/${MAX_FAILURES}):`, err);
         if (failures >= MAX_FAILURES) {
           failures = 0;
           await Bun.sleep(BACKOFF_MS);
         } else {
           await Bun.sleep(RETRY_MS);
         }
-        continue;
       }
-      failures = 0;
-      state.lastError = null;
-      if (resp.get_updates_buf && resp.get_updates_buf !== buf) {
-        saveSyncBuf(resp.get_updates_buf);
-      }
-      const msgs = resp.msgs ?? [];
-      for (const msg of msgs) {
-        await handleInbound(creds, msg).catch((err) => {
-          logger.error("Message handler error:", err);
+    }
+  }
+  async handleInbound(creds, msg) {
+    if (msg.message_type !== 1)
+      return;
+    const senderId = msg.from_user_id;
+    if (!senderId)
+      return;
+    const contextToken = msg.context_token ?? "";
+    const result = gate(senderId);
+    if (result.action === "drop")
+      return;
+    if (result.action === "pair") {
+      if (contextToken) {
+        const lead = result.isResend ? "Still waiting for pairing" : "Pairing required";
+        const text2 = `${lead} \u2014 approve in OMP with: /wechat pair ${result.code}`;
+        await sendMessage(creds, senderId, text2, contextToken).catch((err) => {
+          logger.warn("Pairing reply send failed:", err);
         });
       }
-    } catch (err) {
-      failures++;
-      state.lastError = String(err);
-      logger.error(`Poll error (${failures}/${MAX_FAILURES}):`, err);
-      if (failures >= MAX_FAILURES) {
-        failures = 0;
-        await Bun.sleep(BACKOFF_MS);
-      } else {
-        await Bun.sleep(RETRY_MS);
-      }
+      return;
     }
-  }
-}
-async function handleInbound(creds, msg) {
-  if (msg.message_type !== 1)
-    return;
-  const senderId = msg.from_user_id;
-  if (!senderId)
-    return;
-  const contextToken = msg.context_token ?? "";
-  const result = gate(senderId);
-  if (result.action === "drop")
-    return;
-  if (result.action === "pair") {
-    if (contextToken) {
-      const lead = result.isResend ? "Still waiting for pairing" : "Pairing required";
-      const text2 = `${lead} \u2014 approve in OMP with: /wechat pair ${result.code}`;
-      await sendMessage(creds, senderId, text2, contextToken).catch((err) => {
-        logger.warn("Pairing reply send failed:", err);
+    const text = extractInboundText(msg);
+    if (!text)
+      return;
+    const dedupKey = makeDedupKey(senderId, msg.create_time_ms, text);
+    if (dedupKey && isDuplicate(dedupKey)) {
+      logger.info(`[${senderId}] Skipping duplicate message: ${text.slice(0, 80)}`);
+      return;
+    }
+    const config = loadConfig();
+    logger.info(`[${senderId}] Inbound (ts=${msg.create_time_ms ?? "n/a"}): ${text.slice(0, 80)}`);
+    const invocation = this.commands.tryParse(text);
+    if (invocation) {
+      const reply = await invocation.execute({ pool: this.pool, config, chatId: senderId }).catch((err) => `Command failed: ${err instanceof Error ? err.message : String(err)}`);
+      await sendMessage(creds, senderId, reply, contextToken).catch((err) => {
+        logger.warn(`[${senderId}] Command reply send failed:`, err);
       });
+      return;
+    }
+    await sendTyping(creds, senderId, 1).catch(() => {});
+    try {
+      const session = await this.pool.ensure(senderId, contextToken, config);
+      const images = await this.downloadImages(creds, msg, senderId);
+      await session.prompt(text, images);
+    } catch (err) {
+      logger.error(`[${senderId}] prompt failed:`, err);
+      await this.sendReply(creds, senderId, "Processing failed, please try again.");
     }
-    return;
-  }
-  const text = extractInboundText(msg);
-  if (!text)
-    return;
-  const config = loadConfig();
-  logger.info(`[${senderId}] Inbound: ${text.slice(0, 80)}`);
-  await sendTyping(creds, senderId, 1).catch(() => {});
-  try {
-    await promptSession(senderId, contextToken, text, config);
-  } catch (err) {
-    logger.error(`[${senderId}] prompt failed:`, err);
-    await sendReply(creds, senderId, "Processing failed, please try again.");
   }
-}
-async function sendReply(creds, chatId, text) {
-  const contextToken = getContextToken(chatId);
-  if (!contextToken) {
-    logger.warn(`[${chatId}] No context_token, cannot reply`);
-    return;
+  async downloadImages(_creds, msg, chatId) {
+    const imageItems = extractInboundImages(msg);
+    if (imageItems.length === 0)
+      return [];
+    if (!this.pool?.supportsVision(chatId)) {
+      logger.info(`[${chatId}] Skipping image download \u2014 model does not support vision`);
+      return [];
+    }
+    const results = [];
+    for (const item of imageItems) {
+      const img = item.image_item;
+      const buf = await downloadAndDecrypt(img.file_url, img.full_url, img.aeskey, img.aes_key ?? img.media?.aes_key, `image[${chatId}]`);
+      if (buf) {
+        const mimeType = buf.length > 4 && buf[0] === 137 && buf[1] === 80 ? "image/png" : "image/jpeg";
+        results.push({
+          type: "image",
+          data: buf.toString("base64"),
+          mimeType
+        });
+      }
+    }
+    if (results.length > 0) {
+      logger.info(`[${chatId}] Downloaded ${results.length}/${imageItems.length} images for AI`);
+    }
+    return results;
   }
-  const chunks = chunkText(text, CHUNK_LIMIT);
-  for (const chunk of chunks) {
-    let retries = 0;
-    while (retries <= MAX_SEND_RETRIES) {
-      try {
-        await sendMessage(creds, chatId, chunk, contextToken);
-        break;
-      } catch (err) {
-        retries++;
-        if (retries > MAX_SEND_RETRIES) {
-          logger.error(`[${chatId}] Send failed, dropping:`, err);
-          return;
+  async sendReply(creds, chatId, text) {
+    const contextToken = this.pool?.getContextToken(chatId) ?? "";
+    if (!contextToken) {
+      logger.warn(`[${chatId}] No context_token, cannot reply`);
+      return;
+    }
+    const chunks = chunkText(text, CHUNK_LIMIT);
+    for (const chunk of chunks) {
+      const clientId = `omp-wechat-${Date.now()}-${randomBytes3(4).toString("hex")}`;
+      let retries = 0;
+      while (retries <= MAX_SEND_RETRIES) {
+        try {
+          await sendMessage(creds, chatId, chunk, contextToken, clientId);
+          break;
+        } catch (err) {
+          retries++;
+          if (retries > MAX_SEND_RETRIES) {
+            logger.error(`[${chatId}] Send failed, dropping:`, err);
+            return;
+          }
+          logger.warn(`[${chatId}] Send retry ${retries}/${MAX_SEND_RETRIES}:`, err);
+          await Bun.sleep(1000 * retries);
         }
-        logger.warn(`[${chatId}] Send retry ${retries}/${MAX_SEND_RETRIES}:`, err);
-        await Bun.sleep(1000 * retries);
       }
     }
   }
 }
 
 // src/service.ts
-import { platform, homedir as homedir5 } from "os";
-import { join as join5 } from "path";
-import { existsSync as existsSync2, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3, rmSync } from "fs";
+import { platform, homedir as homedir7 } from "os";
+import { join as join8 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync6, writeFileSync as writeFileSync4, rmSync as rmSync2 } from "fs";
 var PLIST_LABEL = "com.omp-wechat";
 var SERVICE_NAME = "omp-wechat";
 function detectPlatform() {
@@ -1866,13 +2461,13 @@ function detectPlatform() {
   return "other";
 }
 function getLogDir() {
-  return join5(homedir5(), ".omp-wechat", "logs");
+  return join8(homedir7(), ".omp", "logs");
 }
 function resolveHostBinary() {
   return process.execPath || "omp";
 }
 function plistPath() {
-  return join5(homedir5(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+  return join8(homedir7(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
 }
 function generatePlist() {
   const omp = resolveHostBinary();
@@ -1914,21 +2509,21 @@ function generatePlist() {
     <key>PATH</key>
     <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
     <key>HOME</key>
-    <string>${homedir5()}</string>
+    <string>${homedir7()}</string>
   </dict>
 </dict>
 </plist>
 `;
 }
 function installLaunchd() {
-  const dir = join5(homedir5(), "Library", "LaunchAgents");
-  mkdirSync4(dir, { recursive: true });
-  mkdirSync4(getLogDir(), { recursive: true });
+  const dir = join8(homedir7(), "Library", "LaunchAgents");
+  mkdirSync6(dir, { recursive: true });
+  mkdirSync6(getLogDir(), { recursive: true });
   const plist = plistPath();
-  if (existsSync2(plist)) {
+  if (existsSync3(plist)) {
     Bun.spawnSync(["launchctl", "unload", plist], { stderr: "ignore" });
   }
-  writeFileSync3(plist, generatePlist());
+  writeFileSync4(plist, generatePlist());
   const result = Bun.spawnSync(["launchctl", "load", plist], { stderr: "inherit" });
   if (result.exitCode !== 0) {
     throw new Error("launchctl load failed");
@@ -1937,11 +2532,11 @@ function installLaunchd() {
 }
 function uninstallLaunchd() {
   const plist = plistPath();
-  if (!existsSync2(plist)) {
+  if (!existsSync3(plist)) {
     throw new Error("No launchd service found (may not be installed)");
   }
   Bun.spawnSync(["launchctl", "unload", plist], { stderr: "inherit" });
-  rmSync(plist);
+  rmSync2(plist);
 }
 function servicePath() {
   return `/etc/systemd/system/${SERVICE_NAME}.service`;
@@ -1964,7 +2559,7 @@ StandardInput=null
 Restart=always
 RestartSec=10
 
-Environment=HOME=${homedir5()}
+Environment=HOME=${homedir7()}
 Environment=PATH=/usr/local/bin:/usr/bin:/bin
 
 StandardOutput=append:${logDir}/rpc.log
@@ -1973,7 +2568,7 @@ StandardError=append:${logDir}/rpc.log
 NoNewPrivileges=true
 ProtectSystem=strict
 ProtectHome=read-only
-ReadWritePaths=${logDir} ${join5(homedir5(), ".omp-wechat")} ${join5(homedir5(), ".omp")}
+ReadWritePaths=${logDir} ${join8(homedir7(), ".omp-wechat")} ${join8(homedir7(), ".omp")}
 PrivateTmp=true
 
 [Install]
@@ -1982,17 +2577,17 @@ WantedBy=multi-user.target
 }
 function installSystemd() {
   const svc = servicePath();
-  mkdirSync4(getLogDir(), { recursive: true });
-  if (existsSync2(svc)) {
+  mkdirSync6(getLogDir(), { recursive: true });
+  if (existsSync3(svc)) {
     Bun.spawnSync(["sudo", "systemctl", "stop", SERVICE_NAME], { stderr: "inherit" });
   }
   const tmp = `/tmp/${SERVICE_NAME}.service`;
-  writeFileSync3(tmp, generateService());
+  writeFileSync4(tmp, generateService());
   let result = Bun.spawnSync(["sudo", "te", tmp, svc], { stderr: "inherit" });
   if (result.exitCode !== 0) {
     result = Bun.spawnSync(["sudo", "cp", tmp, svc], { stderr: "inherit" });
   }
-  rmSync(tmp);
+  rmSync2(tmp);
   if (result.exitCode !== 0) {
     throw new Error("Failed to write service file (need sudo)");
   }
@@ -2004,7 +2599,7 @@ function installSystemd() {
 }
 function uninstallSystemd() {
   const svc = servicePath();
-  if (!existsSync2(svc)) {
+  if (!existsSync3(svc)) {
     throw new Error("No systemd service found (may not be installed)");
   }
   Bun.spawnSync(["sudo", "systemctl", "stop", SERVICE_NAME], { stderr: "inherit" });
@@ -2042,30 +2637,32 @@ function isServiceInstalled() {
   const p = detectPlatform();
   switch (p) {
     case "darwin":
-      return existsSync2(plistPath());
+      return existsSync3(plistPath());
     case "linux":
-      return existsSync2(servicePath());
+      return existsSync3(servicePath());
     default:
       return false;
   }
 }
 
 // src/index.ts
+var bridge = null;
 var daemonState = null;
 function wechatExtension(pi) {
   if (pi.pi && typeof pi.setLabel === "function") {
     pi.setLabel("OMP-Wechat Bridge");
   }
   pi.on("session_start", async (_event, ctx) => {
-    daemonState = startPollLoop();
+    bridge = new WeChatBridge;
+    daemonState = bridge.start();
     if (daemonState.running) {
       ctx.ui.notify("WeChat bridge started", "info");
     } else {
-      pi.logger?.info("WeChat bridge: another instance holds the lock, starting failover watch");
+      logger.debug("WeChat bridge: another instance holds the lock, starting failover watch");
       ctx.setInterval(() => {
         if (daemonState?.running)
           return;
-        daemonState = startPollLoop();
+        daemonState = bridge.start();
         if (daemonState.running) {
           ctx.ui.notify("WeChat bridge: took over from failed instance", "info");
         }
@@ -2073,7 +2670,7 @@ function wechatExtension(pi) {
     }
   });
   pi.registerCommand("wechat", {
-    description: "WeChat bridge: login, status, pair, allow, revoke, list, stop, install, uninstall",
+    description: "WeChat bridge: login, status, pair, allow, revoke, list, stop, clear, install, uninstall",
     handler: async (args, ctx) => {
       const parts = args.trim().split(/\s+/);
       const sub = parts[0] ?? "";
@@ -2083,18 +2680,18 @@ function wechatExtension(pi) {
         case "status": {
           const running = daemonState?.running ?? false;
           const svc = isServiceInstalled();
-          const pool2 = getPoolStatus();
+          const pool = bridge?.getPoolStatus() ?? { count: 0, max: 0, chats: [] };
           const allowed = listAllowed();
           const lines = [
             `Poll loop: ${running ? "running" : "stopped"}`,
             `Boot service: ${svc ? "installed" : "not installed"}`,
             `Last error: ${daemonState?.lastError ?? "none"}`,
-            `Session pool: ${pool2.count}/${pool2.max}`,
+            `Session pool: ${pool.count}/${pool.max}`,
             `Authorized users: ${allowed.length}`
           ];
-          if (pool2.chats.length > 0) {
+          if (pool.chats.length > 0) {
             lines.push("Active chats:");
-            for (const chat of pool2.chats) {
+            for (const chat of pool.chats) {
               const ago = Math.round((Date.now() - chat.lastActive) / 1000);
               lines.push(`  ${chat.chatId} (${ago}s ago)`);
             }
@@ -2146,7 +2743,10 @@ function wechatExtension(pi) {
           break;
         }
         case "stop": {
-          await stopPollLoop();
+          if (bridge) {
+            await bridge.stop();
+            bridge = null;
+          }
           daemonState = null;
           ctx.ui.notify("WeChat bridge stopped", "info");
           break;
@@ -2155,7 +2755,7 @@ function wechatExtension(pi) {
           try {
             const r = installService();
             ctx.ui.notify(`Boot service installed (${r.platform}): ${r.path}`, "info");
-            pi.logger?.info(`Service installed on ${r.platform} at ${r.path}
+            logger.info(`Service installed on ${r.platform} at ${r.path}
 ` + `OMP will run via launchd/systemd at boot. ` + `Manage: ${r.platform === "darwin" ? "launchctl start|stop com.omp-wechat" : "sudo systemctl start|stop omp-wechat"}`);
           } catch (err) {
             ctx.ui.notify(`Install failed: ${err}`, "error");
@@ -2171,8 +2771,18 @@ function wechatExtension(pi) {
           }
           break;
         }
+        case "clear": {
+          if (bridge) {
+            await bridge.stop();
+            bridge = null;
+          }
+          daemonState = null;
+          const removed = clearAllSessions();
+          ctx.ui.notify(`Cleared ${removed} session(s)`, "info");
+          break;
+        }
         default:
-          ctx.ui.notify("Unknown subcommand. Available: login, status, pair, allow, revoke, list, stop, install, uninstall", "warn");
+          ctx.ui.notify("Unknown subcommand. Available: login, status, pair, allow, revoke, list, stop, clear, install, uninstall", "warn");
       }
     }
   });