v-clawbot 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LZH
+
+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,52 @@
+# v-clawbot
+
+在微信 ClawBot 中与 AI 对话的插件。
+> 注：开发请阅读 [开发者指南](DEVELOPMENT.md)
+
+## 安装
+
+```bash
+npm install -g v-clawbot
+```
+
+## 使用
+
+### 1. 初始化项目
+
+```bash
+v-clawbot init
+```
+
+在当前目录创建 `.opencode/` 目录，包含插件文件。
+
+### 2. 扫码登录
+
+```bash
+v-clawbot login
+```
+
+1. 终端显示 QR 码
+2. 使用微信扫码确认登录
+3. 凭据自动保存
+
+### 3. 启动 OpenCode
+
+```bash
+opencode web
+```
+
+插件会自动启动，开始接收微信消息。
+
+## 命令参数
+
+```bash
+v-clawbot init [--platform opencode|cursor] [-y]
+v-clawbot login [-y]
+```
+
+- `-y, --yes`：跳过确认提示
+- `--platform`：指定平台（opencode 或 cursor）
+
+## 许可证
+
+MIT

package/dist/index.js

@@ -0,0 +1,790 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/cli/index.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+import { dirname as dirname2, resolve as resolve2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { Command as Command6 } from "commander";
+
+// src/cli/commands/chat.ts
+import { Command } from "commander";
+var DEFAULT_MODEL_ID = "big-pickle";
+var DEFAULT_PROVIDER_ID = "opencode";
+var DEFAULT_AGENT = "general";
+var REQUEST_TIMEOUT_MS = 60000;
+async function sendToOpencode(baseUrl, sessionId, text) {
+  const res = await fetch(`${baseUrl}/session/${sessionId}/message`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    },
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    body: JSON.stringify({
+      parts: [{ type: "text", text }],
+      model: { modelID: DEFAULT_MODEL_ID, providerID: DEFAULT_PROVIDER_ID },
+      agent: DEFAULT_AGENT
+    })
+  });
+  if (!res.ok) {
+    const errBody = await res.text().catch(() => "");
+    throw new Error(`opencode API error: HTTP ${res.status} ${errBody.slice(0, 200)}`);
+  }
+  const result = await res.json();
+  const responseText = (result.parts ?? []).filter((p) => p.type === "text" && p.text).map((p) => p.text).join(`
+`);
+  return responseText;
+}
+async function resolveActiveSession(baseUrl) {
+  try {
+    const res = await fetch(`${baseUrl}/api/session`, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok)
+      return null;
+    const body = await res.json();
+    const sessions = body.data ?? [];
+    const filtered = sessions.filter((s) => {
+      if (s.parentID != null && s.parentID !== "")
+        return false;
+      if (s.agent == null || s.agent === "")
+        return false;
+      return true;
+    });
+    filtered.sort((a, b) => (b.time?.updated ?? 0) - (a.time?.updated ?? 0));
+    return filtered[0]?.id ?? null;
+  } catch {
+    return null;
+  }
+}
+var chatCommand = new Command("chat").description("Send message to opencode and return AI response").argument("<text>", "Message text to send").option("--session <id>", "Session ID (auto-detect if not provided)").option("--server <url>", "opencode server URL (default: http://localhost:4096)").action(async (text, options) => {
+  const baseUrl = options.server ?? "http://localhost:4096";
+  let sessionId = options.session;
+  if (!sessionId) {
+    sessionId = await resolveActiveSession(baseUrl);
+    if (!sessionId) {
+      console.error("No active session found. Please specify --session or start opencode first.");
+      process.exit(1);
+    }
+  }
+  try {
+    const response = await sendToOpencode(baseUrl, sessionId, text);
+    if (response) {
+      process.stdout.write(response);
+    }
+  } catch (err) {
+    console.error("Failed to send message to opencode:", err.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/init.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import {
+  cwd,
+  stdin as processStdin,
+  stdout as processStdout
+} from "node:process";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { Command as Command2 } from "commander";
+var DIRNAME = dirname(fileURLToPath(import.meta.url));
+var PLATFORMS = {
+  opencode: {
+    pluginSource: resolve(DIRNAME, "../plugins/opencode/v-clawbot.ts"),
+    targetDir: ".opencode",
+    targetFile: ".opencode/plugins/v-clawbot.ts",
+    config: {
+      $schema: "https://opencode.ai/config.json",
+      server: { port: 4096 }
+    },
+    packageJson: {
+      dependencies: {
+        "@opencode-ai/plugin": "1.15.6"
+      }
+    }
+  },
+  cursor: {
+    pluginSource: resolve(DIRNAME, "../plugins/cursor/v-clawbot.ts"),
+    targetDir: ".cursor",
+    targetFile: ".cursor/extensions/v-clawbot.ts",
+    config: null,
+    packageJson: null
+  }
+};
+var AVAILABLE_PLATFORMS = Object.keys(PLATFORMS).join(", ");
+async function promptOverwrite() {
+  const rl = createInterface({ input: processStdin, output: processStdout });
+  const answer = await rl.question("Target directory already exists. Overwrite? (y/N) ");
+  rl.close();
+  return answer.trim().toLowerCase() === "y";
+}
+function loadPluginTemplate(platform) {
+  const config = PLATFORMS[platform];
+  if (!config) {
+    throw new Error(`Unknown platform: ${platform}. Available: ${AVAILABLE_PLATFORMS}`);
+  }
+  if (!existsSync(config.pluginSource)) {
+    throw new Error(`Plugin file not found: ${config.pluginSource}`);
+  }
+  return readFileSync(config.pluginSource, "utf-8");
+}
+var initCommand = new Command2("init").description("Initialize project scaffolding for WeChat integration").option("-p, --platform <name>", `Target platform (${AVAILABLE_PLATFORMS})`, "opencode").option("-y, --yes", "Skip confirmation prompt", false).action(async (options) => {
+  const platform = options.platform.toLowerCase();
+  if (!PLATFORMS[platform]) {
+    console.error(`Invalid platform: ${platform}`);
+    console.error(`Available platforms: ${AVAILABLE_PLATFORMS}`);
+    process.exit(1);
+  }
+  const config = PLATFORMS[platform];
+  const root = cwd();
+  if (existsSync(resolve(root, config.targetDir))) {
+    if (!options.yes) {
+      const ok = await promptOverwrite();
+      if (!ok) {
+        console.log("Aborted.");
+        return;
+      }
+    }
+  }
+  mkdirSync(resolve(root, config.targetDir, "plugins"), { recursive: true });
+  if (config.config) {
+    writeFileSync(resolve(root, config.targetDir, "opencode.json"), JSON.stringify(config.config, null, 2), "utf-8");
+  }
+  if (config.packageJson) {
+    writeFileSync(resolve(root, config.targetDir, "package.json"), JSON.stringify(config.packageJson, null, 2), "utf-8");
+  }
+  const pluginContent = loadPluginTemplate(platform);
+  writeFileSync(resolve(root, config.targetFile), pluginContent, "utf-8");
+  console.log(`✅ ${config.targetDir}/ scaffolding created.`);
+  console.log("   Next: run 'v-clawbot login' to authenticate.");
+});
+
+// src/cli/commands/login.ts
+import { stdin as processStdin2, stdout as processStdout2 } from "node:process";
+import { createInterface as createInterface2 } from "node:readline/promises";
+import { Command as Command3 } from "commander";
+
+// src/cli/utils/credentials.ts
+import {
+  chmodSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { join } from "node:path";
+var CREDENTIALS_DIR = join(process.cwd(), ".opencode");
+var CREDENTIALS_PATH = join(CREDENTIALS_DIR, "wechat-credentials.json");
+function credentialsExist() {
+  return existsSync2(CREDENTIALS_PATH);
+}
+function loadCredentials() {
+  try {
+    if (!existsSync2(CREDENTIALS_PATH)) {
+      return null;
+    }
+    const raw = readFileSync2(CREDENTIALS_PATH, "utf-8");
+    const data = JSON.parse(raw);
+    if (!data.bot_token || !data.ilink_bot_id || !data.ilink_user_id || !data.baseurl) {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(creds) {
+  if (process.platform === "win32") {
+    mkdirSync2(CREDENTIALS_DIR, { recursive: true });
+  } else {
+    mkdirSync2(CREDENTIALS_DIR, { recursive: true, mode: 448 });
+  }
+  writeFileSync2(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), "utf-8");
+  if (process.platform !== "win32") {
+    chmodSync(CREDENTIALS_PATH, 384);
+  }
+}
+
+// src/cli/commands/login.ts
+var FIXED_BASE_URL = "https://ilinkai.weixin.qq.com";
+var BOT_TYPE = 3;
+var APP_ID = "bot";
+var CLIENT_VERSION = 1;
+var QR_REFRESH_MAX = 3;
+async function fetchQrCode() {
+  const url = `${FIXED_BASE_URL}/ilink/bot/get_bot_qrcode?bot_type=${BOT_TYPE}`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "iLink-App-Id": APP_ID,
+      "iLink-App-ClientVersion": String(CLIENT_VERSION)
+    },
+    body: JSON.stringify({ local_token_list: [] })
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to get QR code: HTTP ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  if (data.ret !== 0 || !data.qrcode) {
+    throw new Error(`Failed to get QR code: ${JSON.stringify(data)}`);
+  }
+  return {
+    qrcode: data.qrcode,
+    qrcode_img_content: data.qrcode_img_content ?? ""
+  };
+}
+async function pollQrStatus(qrcode, verifyCode) {
+  let url = `${FIXED_BASE_URL}/ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`;
+  if (verifyCode) {
+    url += `&verify_code=${encodeURIComponent(verifyCode)}`;
+  }
+  const res = await fetch(url, {
+    method: "GET",
+    headers: {
+      "iLink-App-Id": APP_ID,
+      "iLink-App-ClientVersion": String(CLIENT_VERSION)
+    }
+  });
+  if (!res.ok) {
+    throw new Error(`QR status polling failed: HTTP ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  if (data.data) {
+    return data.data;
+  }
+  return {
+    status: data.status ?? "wait",
+    bot_token: data.bot_token,
+    ilink_bot_id: data.ilink_bot_id,
+    ilink_user_id: data.ilink_user_id,
+    baseurl: data.baseurl
+  };
+}
+async function promptVerifyCode() {
+  const rl = createInterface2({ input: processStdin2, output: processStdout2 });
+  const code = await rl.question("Enter the verification code shown on your phone: ");
+  rl.close();
+  return code.trim();
+}
+async function promptRelogin() {
+  const rl = createInterface2({ input: processStdin2, output: processStdout2 });
+  const answer = await rl.question("Credentials already exist. Re-login? (y/N) ");
+  rl.close();
+  return answer.trim().toLowerCase() === "y";
+}
+var loginCommand = new Command3("login").description("QR code login to WeChat iLink API").option("-y, --yes", "Skip re-login confirmation", false).action(async (options) => {
+  if (credentialsExist()) {
+    if (!options.yes) {
+      const ok = await promptRelogin();
+      if (!ok) {
+        console.log("Aborted. Existing credentials kept.");
+        return;
+      }
+    }
+  }
+  console.log("Fetching QR code...");
+  let qrData;
+  let qrRefreshCount = 0;
+  try {
+    qrData = await fetchQrCode();
+  } catch (err) {
+    console.error("Failed to fetch QR code:", err.message);
+    return;
+  }
+  console.log(`
+Scan the QR code with WeChat to log in:`);
+  console.log(qrData.qrcode_img_content);
+  console.log();
+  try {
+    const qrcodeTerminal = await import("qrcode-terminal");
+    qrcodeTerminal.default.generate(qrData.qrcode_img_content, {
+      small: true
+    });
+  } catch {
+    console.log("QR code URL (open in browser if terminal rendering fails):");
+    console.log(qrData.qrcode_img_content);
+  }
+  let pendingVerifyCode;
+  let confirmed = false;
+  let pollCount = 0;
+  while (!confirmed) {
+    pollCount++;
+    let statusRes;
+    try {
+      statusRes = await pollQrStatus(qrData.qrcode, pendingVerifyCode);
+    } catch (err) {
+      console.error(`
+Polling error, retrying in 3s:`, err.message);
+      await new Promise((r) => setTimeout(r, 3000));
+      continue;
+    }
+    switch (statusRes.status) {
+      case "wait":
+        process.stdout.write(".");
+        break;
+      case "scaned":
+        console.log(`
+Scan detected, verifying...`);
+        pendingVerifyCode = undefined;
+        break;
+      case "need_verifycode":
+        pendingVerifyCode = await promptVerifyCode();
+        break;
+      case "confirmed": {
+        confirmed = true;
+        const botToken = statusRes.bot_token;
+        const botId = statusRes.ilink_bot_id;
+        const userId = statusRes.ilink_user_id;
+        const baseurl = statusRes.baseurl ?? FIXED_BASE_URL;
+        if (!botToken || !botId || !userId) {
+          console.error("Login confirmed but credentials incomplete:", JSON.stringify(statusRes));
+          return;
+        }
+        saveCredentials({
+          bot_token: botToken,
+          ilink_bot_id: botId,
+          ilink_user_id: userId,
+          baseurl
+        });
+        console.log(`
+✅ Login successful!`);
+        console.log("   Credentials saved to .opencode/wechat-credentials.json");
+        break;
+      }
+      case "expired": {
+        qrRefreshCount++;
+        if (qrRefreshCount > QR_REFRESH_MAX) {
+          console.error(`
+QR code expired. Max refresh attempts reached. Please try again.`);
+          return;
+        }
+        console.log(`
+QR code expired, refreshing...`);
+        try {
+          qrData = await fetchQrCode();
+          console.log("New QR code:");
+          console.log(qrData.qrcode_img_content);
+          try {
+            const qrcodeTerminal = await import("qrcode-terminal");
+            qrcodeTerminal.default.generate(qrData.qrcode_img_content, {
+              small: true
+            });
+          } catch {}
+        } catch (err) {
+          console.error("Failed to refresh QR code:", err.message);
+          return;
+        }
+        break;
+      }
+      case "verify_code_blocked":
+        console.error(`
+Too many incorrect verification codes. Refreshing QR...`);
+        qrRefreshCount++;
+        if (qrRefreshCount > QR_REFRESH_MAX) {
+          console.error("Max refresh attempts reached. Please try again.");
+          return;
+        }
+        try {
+          qrData = await fetchQrCode();
+        } catch (err) {
+          console.error("Failed to refresh QR code:", err.message);
+          return;
+        }
+        break;
+      case "binded_redirect":
+        console.log(`
+Already connected to this bot. Login skipped.`);
+        confirmed = true;
+        break;
+      default:
+        if (pollCount % 10 === 0) {
+          process.stdout.write(".");
+        }
+        break;
+    }
+  }
+});
+
+// src/cli/commands/poll.ts
+import { Command as Command4 } from "commander";
+
+// src/core/ilink-client.ts
+var APP_ID2 = "bot";
+var CLIENT_VERSION2 = 1;
+var CHANNEL_VERSION = "1.0.0";
+var BOT_AGENT = "VClawbot/1.0.0";
+function buildHeaders(creds) {
+  const uinBytes = new Uint8Array(4);
+  crypto.getRandomValues(uinBytes);
+  const uin = Array.from(uinBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return {
+    "Content-Type": "application/json",
+    AuthorizationType: "ilink_bot_token",
+    Authorization: `Bearer ${creds.bot_token}`,
+    "X-WECHAT-UIN": btoa(String(Number.parseInt(uin, 16))),
+    "iLink-App-Id": APP_ID2,
+    "iLink-App-ClientVersion": String(CLIENT_VERSION2)
+  };
+}
+async function getUpdates(creds, buf, signal) {
+  const res = await fetch(`${creds.baseurl}/ilink/bot/getupdates`, {
+    method: "POST",
+    headers: buildHeaders(creds),
+    signal,
+    body: JSON.stringify({
+      get_updates_buf: buf,
+      base_info: { channel_version: CHANNEL_VERSION, bot_agent: BOT_AGENT }
+    })
+  });
+  if (!res.ok) {
+    throw new Error(`getUpdates failed: HTTP ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+function generateClientId() {
+  const bytes = new Uint8Array(4);
+  crypto.getRandomValues(bytes);
+  const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `v-clawbot:${Date.now()}-${hex}`;
+}
+async function sendMessage(creds, toUserId, contextToken, text) {
+  const body = {
+    base_info: { channel_version: CHANNEL_VERSION, bot_agent: BOT_AGENT },
+    msg: {
+      from_user_id: "",
+      to_user_id: toUserId,
+      client_id: generateClientId(),
+      message_type: 2,
+      message_state: 2,
+      context_token: contextToken,
+      item_list: [{ type: 1, text_item: { text } }]
+    }
+  };
+  const url = `${creds.baseurl}/ilink/bot/sendmessage`;
+  console.log(`[ilink] sendMessage to=${toUserId}, clientId=${body.msg.client_id}`);
+  const res = await fetch(url, {
+    method: "POST",
+    headers: buildHeaders(creds),
+    body: JSON.stringify(body)
+  });
+  const respBody = await res.text();
+  console.log(`[ilink] sendMessage response: HTTP ${res.status}, body=${respBody.slice(0, 300)}`);
+  if (!res.ok) {
+    throw new Error(`sendMessage failed: HTTP ${res.status} ${res.statusText}`);
+  }
+  let resp = {};
+  try {
+    resp = JSON.parse(respBody);
+  } catch {}
+  if (resp.ret !== undefined && resp.ret !== 0) {
+    throw new Error(`sendMessage failed: ret=${resp.ret}`);
+  }
+}
+async function notifyStart(creds) {
+  const res = await fetch(`${creds.baseurl}/ilink/bot/msg/notifystart`, {
+    method: "POST",
+    headers: buildHeaders(creds),
+    body: JSON.stringify({
+      base_info: { channel_version: CHANNEL_VERSION, bot_agent: BOT_AGENT }
+    })
+  });
+  if (!res.ok) {
+    throw new Error(`notifyStart failed: HTTP ${res.status} ${res.statusText}`);
+  }
+}
+async function notifyStop(creds) {
+  const res = await fetch(`${creds.baseurl}/ilink/bot/msg/notifystop`, {
+    method: "POST",
+    headers: buildHeaders(creds),
+    body: JSON.stringify({
+      base_info: { channel_version: CHANNEL_VERSION, bot_agent: BOT_AGENT }
+    })
+  });
+  if (!res.ok) {
+    throw new Error(`notifyStop failed: HTTP ${res.status} ${res.statusText}`);
+  }
+}
+
+// src/core/state.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+var STATE_DIR = join2(homedir(), ".v-clawbot");
+var STATE_FILE = join2(STATE_DIR, "state.json");
+function ensureStateDir() {
+  try {
+    if (process.platform === "win32") {
+      mkdirSync3(STATE_DIR, { recursive: true });
+    } else {
+      mkdirSync3(STATE_DIR, { recursive: true, mode: 448 });
+    }
+  } catch {}
+}
+function loadState() {
+  try {
+    if (!existsSync3(STATE_FILE)) {
+      return { lastActiveUserId: null, users: {} };
+    }
+    const raw = readFileSync3(STATE_FILE, "utf-8");
+    const data = JSON.parse(raw);
+    return {
+      lastActiveUserId: data.lastActiveUserId ?? null,
+      users: data.users ?? {}
+    };
+  } catch {
+    return { lastActiveUserId: null, users: {} };
+  }
+}
+function saveState(state) {
+  ensureStateDir();
+  try {
+    writeFileSync3(STATE_FILE, JSON.stringify(state, null, 2) + `
+`, "utf-8");
+  } catch {}
+}
+function updateUserContext(state, userId, contextToken) {
+  const now = Date.now();
+  const user = state.users[userId] ?? { contextToken, lastActiveAt: 0 };
+  user.contextToken = contextToken;
+  user.lastActiveAt = now;
+  return {
+    ...state,
+    lastActiveUserId: userId,
+    users: { ...state.users, [userId]: user }
+  };
+}
+
+// src/core/types.ts
+function classifyPollError(err) {
+  if (err instanceof DOMException && err.name === "AbortError") {
+    return { category: "abort", retryable: false };
+  }
+  const error = err;
+  const msg = error.message ?? "";
+  const code = error.code ?? "";
+  if (code === "UNKNOWN_CERTIFICATE_VERIFICATION_ERROR" || msg.includes("certificate") && code !== "CERT_HAS_EXPIRED") {
+    return { category: "tls_mislabel", retryable: true };
+  }
+  if (code === "CERT_HAS_EXPIRED") {
+    return { category: "tls_expired", retryable: false };
+  }
+  if ([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "ETIMEDOUT",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "timeout"
+  ].includes(code)) {
+    return { category: "network", retryable: true };
+  }
+  if (error instanceof TypeError) {
+    return { category: "network", retryable: true };
+  }
+  return { category: "unknown", retryable: true };
+}
+function formatPollError(err, category) {
+  const error = err;
+  const name = error.name ?? "unknown";
+  const msg = error.message ?? "";
+  const code = error.code ?? "";
+  let detail = `[${name}] ${msg}`;
+  if (code)
+    detail += ` (code: ${code})`;
+  return `[wechat-bridge] Polling error [${category.category}]: ${detail}`;
+}
+function getBackoffMs(failureCount) {
+  return Math.min(1000 * 2 ** (failureCount - 1), 60000);
+}
+
+// src/cli/commands/poll.ts
+var MESSAGE_CACHE_SIZE = 1000;
+function createDedup(capacity = MESSAGE_CACHE_SIZE) {
+  const set = new Set;
+  return {
+    add: (id) => {
+      if (set.has(id))
+        return false;
+      set.add(id);
+      if (set.size > capacity) {
+        const first = set.values().next();
+        if (first.value !== undefined)
+          set.delete(first.value);
+      }
+      return true;
+    }
+  };
+}
+function formatMessage(msg, text) {
+  return JSON.stringify({
+    type: "message",
+    from: msg.from_user_id,
+    text,
+    timestamp: msg.create_time_ms
+  });
+}
+function formatError(message, retryable) {
+  return JSON.stringify({
+    type: "error",
+    message,
+    retryable
+  });
+}
+function formatStatus(state) {
+  return JSON.stringify({
+    type: "status",
+    state
+  });
+}
+async function pollLoop() {
+  const creds = loadCredentials();
+  if (!creds) {
+    console.error("No credentials found. Run 'v-clawbot login' first.");
+    process.exit(1);
+  }
+  try {
+    await notifyStart(creds);
+  } catch {}
+  const dedup = createDedup();
+  let updatesBuf = "";
+  let consecutiveFailures = 0;
+  let silenced = false;
+  console.log(formatStatus("connected"));
+  const controller = new AbortController;
+  process.on("SIGINT", async () => {
+    controller.abort();
+    try {
+      await notifyStop(creds);
+    } catch {}
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    controller.abort();
+    try {
+      await notifyStop(creds);
+    } catch {}
+    process.exit(0);
+  });
+  while (!controller.signal.aborted) {
+    try {
+      const resp = await getUpdates(creds, updatesBuf, controller.signal);
+      if (resp.ret !== undefined && resp.ret !== 0) {
+        const errMsg = `getUpdates error: ret=${resp.ret}`;
+        console.error(errMsg);
+        console.log(formatError(errMsg, resp.ret === -14));
+        await sleep(5000);
+        continue;
+      }
+      updatesBuf = resp.get_updates_buf ?? updatesBuf;
+      if (resp.msgs && resp.msgs.length > 0) {
+        for (const msg of resp.msgs) {
+          if (msg.message_type !== 1)
+            continue;
+          if (!dedup.add(msg.message_id))
+            continue;
+          const text = msg.item_list.filter((item) => item.type === 1 && item.text_item).map((item) => item.text_item.text).join(`
+`);
+          if (!text)
+            continue;
+          let state = loadState();
+          state = updateUserContext(state, msg.from_user_id, msg.context_token);
+          saveState(state);
+          console.log(formatMessage(msg, text));
+        }
+      }
+      if (consecutiveFailures > 0) {
+        if (silenced) {
+          console.error(`Polling recovered after ${consecutiveFailures} failures`);
+        }
+        consecutiveFailures = 0;
+        silenced = false;
+      }
+    } catch (err) {
+      if (controller.signal.aborted)
+        break;
+      const cat = classifyPollError(err);
+      if (cat.category === "abort")
+        break;
+      consecutiveFailures++;
+      if (consecutiveFailures >= 10) {
+        if (consecutiveFailures === 10) {
+          const lastErr = formatPollError(err, cat);
+          console.error(`Polling failed ${consecutiveFailures} times, silencing further errors`);
+          console.error(`Last error: ${lastErr}`);
+        }
+        silenced = true;
+      } else {
+        const line = formatPollError(err, cat);
+        console.error(line);
+        console.log(formatError(line, cat.retryable));
+      }
+      const delay = getBackoffMs(consecutiveFailures);
+      await sleep(delay);
+    }
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+var pollCommand = new Command4("poll").description("Long poll iLink API and output messages as JSON lines").action(async () => {
+  try {
+    await pollLoop();
+  } catch (err) {
+    console.error("Poll loop crashed:", err.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/send.ts
+import { Command as Command5 } from "commander";
+var sendCommand = new Command5("send").description("Send message to WeChat user").argument("<text>", "Message text to send").option("--to <userId>", "Target user ID (uses last active user if not provided)").action(async (text, options) => {
+  const creds = loadCredentials();
+  if (!creds) {
+    console.error("No credentials found. Run 'v-clawbot login' first.");
+    process.exit(1);
+  }
+  const state = loadState();
+  let userId = options.to;
+  if (!userId) {
+    userId = state.lastActiveUserId;
+    if (!userId) {
+      console.error("No target user specified and no active user found. Use --to <userId>.");
+      process.exit(1);
+    }
+  }
+  const userCtx = state.users[userId];
+  if (!userCtx) {
+    console.error(`No context found for user ${userId}. Message must be received first.`);
+    process.exit(1);
+  }
+  try {
+    await sendMessage(creds, userId, userCtx.contextToken, text);
+  } catch (err) {
+    console.error("Failed to send message:", err.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/index.ts
+var DIRNAME2 = dirname2(fileURLToPath2(import.meta.url));
+function loadVersion() {
+  try {
+    const pkgPath = resolve2(DIRNAME2, "../../package.json");
+    const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var program = new Command6;
+program.name("v-clawbot").description("CLI tool for WeChat integration with OpenCode and Cursor").version(loadVersion());
+program.addCommand(initCommand);
+program.addCommand(loginCommand);
+program.addCommand(pollCommand);
+program.addCommand(chatCommand);
+program.addCommand(sendCommand);
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "v-clawbot",
+  "version": "0.1.0",
+  "description": "在微信 ClawBot 中与 AI 对话的插件",
+  "keywords": [
+    "wechat",
+    "clawbot",
+    "opencode",
+    "plugin",
+    "v-clawbot"
+  ],
+  "author": "LZH <liu.zhenghui@outlook.com>",
+  "type": "module",
+  "bin": {
+    "v-clawbot": "./dist/index.js"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "plugins"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://gitee.com/liuzhenghui/v-clawbot"
+  },
+  "bugs": {
+    "url": "https://gitee.com/liuzhenghui/v-clawbot/issues"
+  },
+  "scripts": {
+    "build": "bun run build.ts",
+    "test": "bun test",
+    "test:cov": "bun test --coverage",
+    "test:init": "bun run build && cd travel-example && node ../dist/index.js init -y",
+    "test:login": "bun run build && cd travel-example && node ../dist/index.js login -y",
+    "test:start": "cd travel-example && opencode web",
+    "test:poll": "bun run build && cd travel-example && node ../dist/index.js poll",
+    "test:send": "bun run build && cd travel-example && node ../dist/index.js send",
+    "test:status": "bun run scripts/check-status.ts",
+    "logs": "bun run scripts/tail-log.ts",
+    "logs:poll": "opencode logs --follow",
+    "clean": "bun run scripts/clean-dist.ts",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "1.15.6"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.16",
+    "@types/bun": "^1.3.14",
+    "@types/node": "^22.0.0",
+    "commander": "^12.0.0",
+    "qrcode-terminal": "^0.12.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18",
+    "bun": ">=1.3"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/plugins/cursor/v-clawbot.ts

@@ -0,0 +1,16 @@
+// Cursor platform plugin placeholder
+// TODO: Implement Cursor extension integration
+
+export default {
+  id: "v-clawbot-cursor",
+  name: "V-ClawBot for Cursor",
+  version: "0.1.0",
+  description: "WeChat integration plugin for Cursor",
+  activate: async () => {
+    console.log("[v-clawbot-cursor] Plugin activated");
+    // TODO: Implement Cursor extension activation
+  },
+  deactivate: async () => {
+    console.log("[v-clawbot-cursor] Plugin deactivated");
+  },
+};

package/plugins/opencode/v-clawbot.ts

@@ -0,0 +1,125 @@
+import type { PluginModule, PluginInput } from "@opencode-ai/plugin";
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import { existsSync } from "node:fs";
+
+// ---------------------------------------------------------------------------
+// CLI 路径解析
+// ---------------------------------------------------------------------------
+
+function resolveCliPath(): string {
+  const pluginDir = dirname(fileURLToPath(import.meta.url));
+  let dir = pluginDir;
+  for (let i = 0; i < 5; i++) {
+    for (const p of [
+      resolve(dir, "dist/index.js"),
+      resolve(dir, "node_modules/v-clawbot/dist/index.js"),
+    ]) {
+      if (existsSync(p)) return p;
+    }
+    dir = resolve(dir, "..");
+  }
+  return "v-clawbot";
+}
+
+const cliPath = resolveCliPath();
+const isNode = cliPath !== "v-clawbot";
+
+// ---------------------------------------------------------------------------
+// 辅助函数
+// ---------------------------------------------------------------------------
+
+function runCommand(command: string, args: string[]): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: true,
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve(stdout.trim());
+      } else {
+        reject(new Error(`Command failed with code ${code}: ${stderr}`));
+      }
+    });
+
+    proc.on("error", reject);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// 插件实现
+// ---------------------------------------------------------------------------
+
+const wechatPlugin: PluginModule = {
+  id: "v-clawbot",
+  server: async (input: PluginInput) => {
+    const { serverUrl } = input;
+    const baseUrl = serverUrl.origin;
+
+    console.log("[v-clawbot] Plugin started, server URL:", baseUrl);
+
+    // 启动 poll 进程
+    const poll = isNode
+      ? spawn("node", [cliPath, "poll"], { stdio: ["pipe", "pipe", "inherit"], shell: true })
+      : spawn(cliPath, ["poll"], { stdio: ["pipe", "pipe", "inherit"], shell: true });
+
+    const rl = createInterface({ input: poll.stdout! });
+
+    rl.on("line", async (line) => {
+      try {
+        const msg = JSON.parse(line);
+
+        if (msg.type === "message") {
+          console.log(`[v-clawbot] Received message from ${msg.from}: "${msg.text.slice(0, 50)}..."`);
+
+          // 调用 chat 命令发送到 opencode
+          const aiReply = isNode
+            ? await runCommand("node", [cliPath, "chat", msg.text, "--server", baseUrl])
+            : await runCommand(cliPath, ["chat", msg.text, "--server", baseUrl]);
+
+          if (aiReply) {
+            console.log(`[v-clawbot] AI response: "${aiReply.slice(0, 50)}..."`);
+
+            // 调用 send 命令发送回微信
+            await (isNode
+              ? runCommand("node", [cliPath, "send", aiReply])
+              : runCommand(cliPath, ["send", aiReply]));
+            console.log("[v-clawbot] Reply sent to WeChat");
+          }
+        } else if (msg.type === "error") {
+          console.error(`[v-clawbot] Poll error: ${msg.message}`);
+        }
+      } catch (err) {
+        console.error("[v-clawbot] Error processing message:", (err as Error).message);
+      }
+    });
+
+    poll.on("close", (code) => {
+      console.log(`[v-clawbot] Poll process exited with code ${code}`);
+    });
+
+    poll.on("error", (err) => {
+      console.error("[v-clawbot] Failed to start poll:", err.message);
+    });
+
+    // 返回空对象，插件不需要额外的 hooks
+    return {};
+  },
+};
+
+export default wechatPlugin;