omp-wechat 1.0.0 → 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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

@@ -92,6 +92,7 @@ Configuration is loaded from `~/.omp-wechat/config.yml`, falling back to built-i
 # ~/.omp-wechat/config.yml
 maxSessions: 50
 dmPolicy: pairing
+model: "@smol"              # default model (role alias or provider/id)
 systemPrompt: |
   You are an AI assistant chatting via WeChat.
   Keep replies concise and in plain text.
@@ -101,8 +102,8 @@ systemPrompt: |
 |---|---|---|
 | `maxSessions` | `50` | Session pool cap (LRU eviction) |
 | `dmPolicy` | `pairing` | Access policy: `pairing` / `allowlist` / `disabled` |
+| `model` | OMP default | Default model: role alias (`@smol`, `@slow`) or `provider/id` |
 | `systemPrompt` | Built-in | System prompt for WeChat chat sessions |
-
 > **Model, working directory, and tools are managed by OMP/Pi.** `createAgentSession()` automatically calls `discoverAuthStorage()`, reusing your existing `omp login` / `pi login` OAuth, `~/.omp/agent/agent.db` API keys, or `models.yml` config. This project never touches API keys.
 
 ## Slash Commands
@@ -119,6 +120,14 @@ systemPrompt: |
 | `/wechat install` | Install boot-time launchd/systemd service |
 | `/wechat uninstall` | Remove boot-time service |
 
+### Chat Commands (via WeChat message)
+
+| Command | Description |
+|---|---|
+| `/model` | Show current AI model |
+| `/models` | List all available models |
+| `/model provider/id` | Switch model for this chat (e.g. `/model anthropic/claude-haiku-4-5`) |
+
 ## Access Control
 
 | Mode | Behavior |
@@ -174,15 +183,14 @@ OMP-Wechat/
 
 - **Reply-only**: iLink requires `context_token` from an inbound message; you cannot initiate conversations
 - **1:1 only**: iLink Bot API does not support group chats
-- **No message history**: WeChat provides no history API; session context is lost on restart (in-memory sessions)
 - **Single instance**: iLink allows only one bot connection per account
 - **Text only (Phase 1)**: images/voice/video are represented as `(image)` / `(voice)` placeholders; media support is planned
 
 ## Roadmap
 
 - [ ] **Phase 2**: Media support (inbound images as base64, voice transcription)
-- [ ] **Phase 3**: Persistent sessions (`SessionManager.create()` per chat directory)
-- [ ] **Phase 4**: Per-chat model selection (smol for simple questions, slow for complex)
+- [x] **Phase 3**: Persistent sessions — `SessionManager.continueRecent()` per chat, context survives restarts
+- [x] **Phase 4**: Per-chat model selection — `/model` `/models` chat commands for manual switching
 - [ ] **Phase 5**: Fine-grained permissions (per-user tool restrictions, bash approval via WeChat)
 
 ## License

package/dist/index.js

@@ -1070,8 +1070,8 @@ 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 = join(homedir(), ".omp", "logs");
+var LOG_FILE = join(LOG_DIR, "wechat.log");
 try {
   mkdirSync(LOG_DIR, { recursive: true });
 } catch {}
@@ -1175,12 +1175,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 } }],
@@ -1476,6 +1476,9 @@ 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";
@@ -1505,6 +1508,8 @@ function loadConfig() {
         config.dmPolicy = parsed.dmPolicy;
       if (parsed.systemPrompt)
         config.systemPrompt = parsed.systemPrompt;
+      if (parsed.model)
+        config.model = parsed.model;
     }
   } catch (err) {
     logger.warn("Failed to load config.yml, using defaults", err);
@@ -1574,35 +1579,135 @@ function chunkText(text, limit = 2000) {
   return out;
 }
 
+// src/utils/dedup.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, renameSync as renameSync3 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join5 } from "path";
+var STATE_DIR3 = join5(homedir5(), ".omp-wechat");
+var DEDUP_FILE = join5(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 });
+    renameSync3(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/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 join6 } from "path";
+import { homedir as homedir6 } from "os";
+import { existsSync as existsSync2, mkdirSync as mkdirSync5, readdirSync, statSync, rmSync } from "fs";
+var STATE_DIR4 = join6(homedir6(), ".omp-wechat");
+var SESSIONS_DIR = join6(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 join6(SESSIONS_DIR, sanitizeChatId(chatId));
+}
+function ensureSessionsDir() {
+  mkdirSync5(SESSIONS_DIR, { recursive: true, mode: 448 });
+}
+function cleanupStaleSessions() {
+  if (!existsSync2(SESSIONS_DIR))
+    return 0;
+  const now = Date.now();
+  let removed = 0;
+  for (const entry of readdirSync(SESSIONS_DIR, { withFileTypes: true })) {
+    if (!entry.isDirectory())
+      continue;
+    const dir = join6(SESSIONS_DIR, entry.name);
+    let newestMtime = 0;
+    try {
+      for (const file of readdirSync(dir)) {
+        const mtime = statSync(join6(dir, file)).mtimeMs;
+        if (mtime > newestMtime)
+          newestMtime = mtime;
+      }
+    } catch {
+      continue;
+    }
+    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}`);
+      }
+    }
   }
-  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);
+  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 readdirSync(SESSIONS_DIR, { withFileTypes: true })) {
+    if (!entry.isDirectory())
+      continue;
+    try {
+      rmSync(join6(SESSIONS_DIR, entry.name), { recursive: true, force: true });
+      removed++;
+    } catch (err) {
+      logger.warn(`Failed to remove session dir ${entry.name}: ${err}`);
     }
-  });
-  return {
-    session,
-    lastActive: Date.now(),
-    contextToken
-  };
+  }
+  return removed;
 }
+
+// src/engine/session.ts
 function extractAssistantText(message) {
   const content = message.content;
   if (!Array.isArray(content))
@@ -1617,70 +1722,292 @@ 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(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);
+    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) {
+    this.lastActive = Date.now();
+    await this.session.prompt(text);
+  }
+  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) {
+    const entry = await this.ensure(chatId, contextToken, config);
+    await entry.prompt(text);
+  }
+  get(chatId) {
+    return this.pool.get(chatId);
+  }
+  getContextToken(chatId) {
+    return this.pool.get(chatId)?.getContextToken() ?? "";
+  }
+  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).`
+    };
   }
-  if (oldestId) {
-    const entry = pool.get(oldestId);
-    if (entry) {
-      entry.session.dispose().catch((err) => {
-        logger.warn(`Session dispose error (${oldestId}): ${err}`);
-      });
+  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}`);
     }
-    pool.delete(oldestId);
-    logger.info(`LRU evicted session: ${oldestId}`);
+    lines.push("", "Switch with: /model provider/id");
+    return lines.join(`
+`);
   }
 }
-function getPoolStatus() {
-  const chats = Array.from(pool.entries()).map(([chatId, entry]) => ({
-    chatId,
-    lastActive: entry.lastActive
-  }));
-  return { count: pool.size, max: maxSessions, chats };
+
+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;
+  }
 }
-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 ModelCommand {
+  name = "model";
+  parse(text) {
+    if (text === MODELS_PREFIX || text.startsWith(`${MODELS_PREFIX} `)) {
+      return new ModelListInvocation;
+    }
+    if (text === MODEL_PREFIX) {
+      return new ModelQueryInvocation;
+    }
+    if (text.startsWith(`${MODEL_PREFIX} `)) {
+      const pattern = text.slice(MODEL_PREFIX.length + 1).trim();
+      if (pattern)
+        return new ModelSwitchInvocation(pattern);
+    }
+    return null;
+  }
 }
 
 // src/bridge.ts
@@ -1690,171 +2017,207 @@ 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);
   }
-}
-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 {
+      await this.pool.prompt(senderId, contextToken, text, config);
+    } 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;
   }
-  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 join7 } 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 +2229,13 @@ function detectPlatform() {
   return "other";
 }
 function getLogDir() {
-  return join5(homedir5(), ".omp-wechat", "logs");
+  return join7(homedir7(), ".omp", "logs");
 }
 function resolveHostBinary() {
   return process.execPath || "omp";
 }
 function plistPath() {
-  return join5(homedir5(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+  return join7(homedir7(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
 }
 function generatePlist() {
   const omp = resolveHostBinary();
@@ -1914,21 +2277,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 = join7(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 +2300,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 +2327,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 +2336,7 @@ StandardError=append:${logDir}/rpc.log
 NoNewPrivileges=true
 ProtectSystem=strict
 ProtectHome=read-only
-ReadWritePaths=${logDir} ${join5(homedir5(), ".omp-wechat")} ${join5(homedir5(), ".omp")}
+ReadWritePaths=${logDir} ${join7(homedir7(), ".omp-wechat")} ${join7(homedir7(), ".omp")}
 PrivateTmp=true
 
 [Install]
@@ -1982,17 +2345,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 +2367,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 +2405,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 +2438,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 +2448,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 +2511,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 +2523,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 +2539,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");
       }
     }
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omp-wechat",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "OMP/Pi extension: bridge WeChat messages to OMP's AI engine via the iLink Bot API",
   "type": "module",
   "main": "dist/index.js",