@ekay/claude-im 0.1.0

package/dist/index.js

@@ -0,0 +1,1710 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+import { readFileSync, existsSync, unlinkSync, writeFileSync, readdirSync, mkdirSync, chmodSync } from 'fs';
+import { dirname, resolve, basename } from 'path';
+import { randomBytes, createCipheriv, createDecipheriv } from 'crypto';
+import { load, dump } from 'js-yaml';
+import readline from 'readline';
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { Command } from 'commander';
+import { fileURLToPath } from 'url';
+import * as Lark from '@larksuiteoapi/node-sdk';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/registry.ts
+function registerAdapter(platform, ctor) {
+  registry.set(platform, ctor);
+}
+function createAdapter(config) {
+  const Ctor = registry.get(config.platform);
+  if (!Ctor) throw new Error(`\u672A\u627E\u5230\u5E73\u53F0 "${config.platform}" \u7684\u9002\u914D\u5668\uFF0C\u8BF7\u68C0\u67E5\u914D\u7F6E`);
+  return new Ctor(config);
+}
+function registeredPlatforms() {
+  return [...registry.keys()];
+}
+var registry;
+var init_registry = __esm({
+  "src/core/registry.ts"() {
+    registry = /* @__PURE__ */ new Map();
+  }
+});
+var ts, logger;
+var init_logger = __esm({
+  "src/logger/index.ts"() {
+    ts = () => chalk.blue((/* @__PURE__ */ new Date()).toLocaleTimeString());
+    logger = {
+      /** 普通信息日志 */
+      info: (msg) => console.log(`${ts()} ${chalk.cyan("\u2139")} ${msg}`),
+      /** 成功日志 */
+      success: (msg) => console.log(`${ts()} ${chalk.green("\u2705")} ${msg}`),
+      /** 警告日志 */
+      warn: (msg) => console.log(`${ts()} ${chalk.yellow("\u26A0")} ${msg}`),
+      /** 错误日志 */
+      error: (msg) => console.log(`${ts()} ${chalk.red("\u274C")} ${msg}`),
+      /** 收到消息 - 仅记录脱敏标识，不记录内容 */
+      msgReceived: (msgId, chatType) => console.log(`${ts()} ${chalk.blue("\u{1F4AC}")} ${chalk.gray("msg:" + msgId.slice(0, 8))} [${chatType}]`),
+      /** 发送回复 */
+      reply: (msgId) => console.log(`${ts()} ${chalk.green("\u21A9")} replied to ${chalk.gray(msgId.slice(0, 8))}`),
+      /** 工具调用 - 仅记录工具名，不记录参数 */
+      tool: (name) => console.log(`${ts()} ${chalk.magenta("\u{1F527}")} ${chalk.bold(name)}`),
+      /** 灰色次要信息日志 */
+      dim: (msg) => console.log(`${ts()} ${chalk.gray(msg)}`)
+    };
+  }
+});
+
+// src/utils/lock.ts
+var lock_exports = {};
+__export(lock_exports, {
+  acquireLock: () => acquireLock,
+  killByLock: () => killByLock,
+  listLocks: () => listLocks,
+  releaseLock: () => releaseLock
+});
+function getLockDir() {
+  const home = process.env.CLAUDE_IM_HOME || resolve(process.env.HOME || "~", ".claude-im");
+  return home;
+}
+function acquireLock(profile, cwd) {
+  const lockPath = resolve(getLockDir(), `lock-${profile}.pid`);
+  if (existsSync(lockPath)) {
+    const existing = JSON.parse(readFileSync(lockPath, "utf8"));
+    try {
+      process.kill(existing.pid, 0);
+      throw new Error(`Profile "${profile}" is already running (PID ${existing.pid})`);
+    } catch (e) {
+      if (e.code === "ESRCH") {
+        unlinkSync(lockPath);
+      } else {
+        throw e;
+      }
+    }
+  }
+  const data = { pid: process.pid, profile, cwd, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  writeFileSync(lockPath, JSON.stringify(data), { mode: 384 });
+  return data;
+}
+function releaseLock(profile) {
+  const lockPath = resolve(getLockDir(), `lock-${profile}.pid`);
+  try {
+    unlinkSync(lockPath);
+  } catch {
+  }
+}
+function listLocks() {
+  const dir = getLockDir();
+  const result = [];
+  let files;
+  try {
+    files = readdirSync(dir);
+  } catch {
+    return result;
+  }
+  for (const f of files) {
+    if (!f.startsWith("lock-") || !f.endsWith(".pid")) continue;
+    try {
+      const data = JSON.parse(readFileSync(resolve(dir, f), "utf8"));
+      try {
+        process.kill(data.pid, 0);
+        result.push(data);
+      } catch {
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function killByLock(profile) {
+  const lockPath = resolve(getLockDir(), `lock-${profile}.pid`);
+  if (!existsSync(lockPath)) return false;
+  const data = JSON.parse(readFileSync(lockPath, "utf8"));
+  try {
+    process.kill(data.pid, "SIGTERM");
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_lock = __esm({
+  "src/utils/lock.ts"() {
+  }
+});
+
+// src/config/defaults.ts
+var DEFAULT_CLAUDE, DEFAULT_OVERFLOW, DEFAULT_FILE, DEFAULT_EXEC_SECURITY, DEFAULT_STREAMING, DEFAULT_PROFILE;
+var init_defaults = __esm({
+  "src/config/defaults.ts"() {
+    DEFAULT_CLAUDE = {
+      permission_mode: "acceptEdits",
+      allowed_tools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"],
+      thinking: { type: "adaptive" }
+    };
+    DEFAULT_OVERFLOW = {
+      mode: "document",
+      chunk: { threshold: 2800 },
+      document: { threshold: 2800, title_template: "Claude \u56DE\u590D {datetime}", cleanup: { max_docs: 50 } }
+    };
+    DEFAULT_FILE = {
+      enabled: true,
+      size_limit: 31457280,
+      temp_dir: "",
+      prompt: "\u5206\u6790\u6587\u4EF6\u5185\u5BB9\uFF0C\u7ED9\u51FA\u56DE\u5E94",
+      multifile_prompt: "\u5206\u6790\u4EE5\u4E0B {count} \u4E2A\u6587\u4EF6\u7684\u5185\u5BB9\uFF0C\u7ED9\u51FA\u56DE\u5E94",
+      multifile_timeout: 300
+    };
+    DEFAULT_EXEC_SECURITY = {
+      enabled: true,
+      blacklist: ["rm -rf", "sudo", "dd if=", "shutdown", "reboot"],
+      confirm_on_warning: true
+    };
+    DEFAULT_STREAMING = {
+      enabled: true,
+      flush_interval_ms: 200,
+      thinking_enabled: true,
+      fallback_on_error: true
+    };
+    DEFAULT_PROFILE = {
+      platform: "feishu",
+      platform_config: { app_id: "", owner_open_id: "" },
+      claude: DEFAULT_CLAUDE,
+      overflow: DEFAULT_OVERFLOW,
+      file: DEFAULT_FILE,
+      commands: {},
+      exec_commands: {},
+      exec_security: DEFAULT_EXEC_SECURITY,
+      streaming: DEFAULT_STREAMING,
+      processing_timeout_ms: 36e5,
+      card_title: "Claude",
+      image_prompt: "\u5206\u6790\u56FE\u7247\uFF0C\u7ED9\u51FA\u56DE\u5E94"
+    };
+  }
+});
+function getEnvSecret(platform, profile) {
+  const pu = platform.toUpperCase();
+  const key = profile.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+  if (process.env[`${pu}_${key}_APP_SECRET`]) return process.env[`${pu}_${key}_APP_SECRET`];
+  if (process.env[`${pu}_APP_SECRET`]) return process.env[`${pu}_APP_SECRET`];
+  if (platform === "feishu" && process.env.LARK_APP_SECRET) return process.env.LARK_APP_SECRET;
+  return null;
+}
+function getEnvAppId(platform, profile) {
+  const pu = platform.toUpperCase();
+  const key = profile.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+  if (process.env[`${pu}_${key}_APP_ID`]) return process.env[`${pu}_${key}_APP_ID`];
+  if (process.env[`${pu}_APP_ID`]) return process.env[`${pu}_APP_ID`];
+  if (platform === "feishu" && process.env.LARK_APP_ID) return process.env.LARK_APP_ID;
+  return null;
+}
+var init_env = __esm({
+  "src/utils/env.ts"() {
+  }
+});
+function getKeyPath() {
+  const home = process.env.CLAUDE_IM_HOME || resolve(process.env.HOME || "~", ".claude-im");
+  return resolve(home, ".key");
+}
+function loadOrCreateKey() {
+  const keyPath = getKeyPath();
+  try {
+    return readFileSync(keyPath);
+  } catch {
+    const key = randomBytes(32);
+    writeFileSync(keyPath, key, { mode: 384 });
+    chmodSync(keyPath, 384);
+    return key;
+  }
+}
+function encrypt(plaintext) {
+  const key = loadOrCreateKey();
+  const iv = randomBytes(IV_LEN);
+  const cipher = createCipheriv(ALGO, key, iv);
+  const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+  const authTag = cipher.getAuthTag();
+  return Buffer.concat([iv, authTag, encrypted]).toString("base64");
+}
+function decrypt(ciphertext) {
+  const key = loadOrCreateKey();
+  const buf = Buffer.from(ciphertext, "base64");
+  const iv = buf.subarray(0, IV_LEN);
+  const authTag = buf.subarray(IV_LEN, IV_LEN + AUTH_TAG_LEN);
+  const encrypted = buf.subarray(IV_LEN + AUTH_TAG_LEN);
+  const decipher = createDecipheriv(ALGO, key, iv);
+  decipher.setAuthTag(authTag);
+  return Buffer.concat([decipher.update(encrypted), decipher.final()]).toString("utf8");
+}
+var ALGO, IV_LEN, AUTH_TAG_LEN;
+var init_crypto = __esm({
+  "src/utils/crypto.ts"() {
+    ALGO = "aes-256-gcm";
+    IV_LEN = 12;
+    AUTH_TAG_LEN = 16;
+  }
+});
+function deepMerge(base, override) {
+  if (!override) return base;
+  const result = { ...base };
+  for (const [key, val] of Object.entries(override)) {
+    if (val !== void 0 && val !== null) {
+      if (typeof val === "object" && !Array.isArray(val) && typeof result[key] === "object") {
+        result[key] = deepMerge(result[key], val);
+      } else {
+        result[key] = val;
+      }
+    }
+  }
+  return result;
+}
+function loadRawConfig() {
+  try {
+    if (existsSync(GLOBAL_CONFIG_PATH)) return load(readFileSync(GLOBAL_CONFIG_PATH, "utf8"));
+  } catch (e) {
+    logger.warn(`\u914D\u7F6E\u6587\u4EF6\u89E3\u6790\u5931\u8D25: ${GLOBAL_CONFIG_PATH} \u2014 ${e.message.slice(0, 60)}`);
+  }
+  return {};
+}
+function loadProjectConfig(cwd) {
+  const path = resolve(cwd, ".claude-im.yml");
+  try {
+    if (existsSync(path)) return load(readFileSync(path, "utf8"));
+  } catch (e) {
+    logger.warn(`\u9879\u76EE\u914D\u7F6E\u89E3\u6790\u5931\u8D25: ${path} \u2014 ${e.message.slice(0, 60)}`);
+  }
+  return {};
+}
+function detectPlatform(raw) {
+  if (raw.platform) {
+    const pc = raw[raw.platform];
+    return { platform: raw.platform, platformConfig: pc ?? {} };
+  }
+  if (raw.feishu?.app_id) {
+    const { app_secret: _, ...rest } = raw.feishu;
+    return { platform: "feishu", platformConfig: rest };
+  }
+  return { platform: "feishu", platformConfig: {} };
+}
+function resolveSecret(platform, profile, rawConfig) {
+  const envSecret = getEnvSecret(platform, profile);
+  if (envSecret) return { secret: envSecret, source: "env" };
+  if (!existsSync(VAULT_DIR)) mkdirSync(VAULT_DIR, { recursive: true, mode: 448 });
+  const vaultPath = resolve(VAULT_DIR, profile === "default" ? "default" : profile);
+  if (existsSync(vaultPath)) {
+    try {
+      return { secret: decrypt(readFileSync(vaultPath, "utf8")), source: "vault" };
+    } catch {
+    }
+  }
+  const configSecret = rawConfig.app_secret;
+  if (configSecret) {
+    logger.warn(`profile "${profile}" \u7684\u5BC6\u94A5\u660E\u6587\u5B58\u5728\u914D\u7F6E\u6587\u4EF6\u4E2D\uFF0C\u5EFA\u8BAE\u4F7F\u7528\u73AF\u5883\u53D8\u91CF\u6216 vault \u52A0\u5BC6\u5B58\u50A8`);
+    return { secret: configSecret, source: "config" };
+  }
+  throw new Error(`\u672A\u627E\u5230 profile "${profile}" (\u5E73\u53F0: ${platform}) \u7684\u5BC6\u94A5\u3002\u8BF7\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF\u6216\u8FD0\u884C --setup`);
+}
+function saveSecretToVault(profile, secret) {
+  if (!existsSync(VAULT_DIR)) mkdirSync(VAULT_DIR, { recursive: true, mode: 448 });
+  writeFileSync(resolve(VAULT_DIR, profile === "default" ? "default" : profile), encrypt(secret), { mode: 384 });
+}
+function saveConfig(raw) {
+  const dir = dirname(GLOBAL_CONFIG_PATH);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 448 });
+  const clean = structuredClone(raw);
+  if (clean.feishu) delete clean.feishu.app_secret;
+  if (clean.profiles) {
+    for (const p of Object.values(clean.profiles)) {
+      if (p?.feishu) delete p.feishu.app_secret;
+    }
+  }
+  writeFileSync(GLOBAL_CONFIG_PATH, `# claude-im \u914D\u7F6E\u6587\u4EF6
+# \u901A\u8FC7\u73AF\u5883\u53D8\u91CF\u6216 vault \u7BA1\u7406\u5BC6\u94A5
+
+${dump(clean, { indent: 2 })}`, { mode: 384 });
+}
+function resolveConfig(profile, cwd) {
+  const raw = loadRawConfig();
+  const projectRaw = loadProjectConfig(cwd);
+  let profileRaw = {};
+  if (profile === "default") {
+    profileRaw = raw;
+  } else {
+    profileRaw = deepMerge({ ...raw }, raw.profiles?.[profile]);
+  }
+  const { platform, platformConfig } = detectPlatform(profileRaw);
+  const envAppId = getEnvAppId(platform, profile);
+  if (envAppId) platformConfig.app_id = envAppId;
+  if (!platformConfig.app_id) platformConfig.app_id = "";
+  const { secret, source } = resolveSecret(platform, profile, platformConfig);
+  const base = deepMerge(DEFAULT_PROFILE, raw);
+  const merged = deepMerge(base, profileRaw);
+  const final = deepMerge(merged, projectRaw);
+  final.platform = platform;
+  final.platform_config = platformConfig;
+  return {
+    ...final,
+    profile,
+    platform_secret: secret,
+    platform_secret_source: source
+  };
+}
+var HOME, GLOBAL_CONFIG_PATH, VAULT_DIR;
+var init_loader = __esm({
+  "src/config/loader.ts"() {
+    init_defaults();
+    init_env();
+    init_crypto();
+    init_logger();
+    HOME = process.env.CLAUDE_IM_HOME || resolve(process.env.HOME || "~", ".claude-im");
+    GLOBAL_CONFIG_PATH = resolve(HOME, "config.yml");
+    VAULT_DIR = resolve(HOME, "vault");
+  }
+});
+
+// src/setup/interactive.ts
+var interactive_exports = {};
+__export(interactive_exports, {
+  runNewProfile: () => runNewProfile,
+  runSetup: () => runSetup
+});
+function prompt(rl, question) {
+  return new Promise((res) => {
+    rl.question(question, (a) => res(a.trim()));
+  });
+}
+function loadRaw() {
+  try {
+    if (existsSync(GLOBAL_CONFIG_PATH2)) return load(readFileSync(GLOBAL_CONFIG_PATH2, "utf8"));
+  } catch {
+  }
+  return {};
+}
+function saveRaw(raw) {
+  const dir = dirname(GLOBAL_CONFIG_PATH2);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 448 });
+  writeFileSync(GLOBAL_CONFIG_PATH2, dump(raw, { indent: 2 }), { mode: 384 });
+}
+async function choosePlatform(rl) {
+  const platforms = registeredPlatforms();
+  console.log("\n  \u652F\u6301\u7684 IM \u5E73\u53F0:");
+  platforms.forEach((p, i) => console.log(`    ${i + 1}. ${p}`));
+  const choice = await prompt(rl, `  \u9009\u62E9\u5E73\u53F0 [${platforms.join("/")}] (\u9ED8\u8BA4 feishu): `);
+  if (!choice) return "feishu";
+  const idx = parseInt(choice);
+  if (idx >= 1 && idx <= platforms.length) return platforms[idx - 1];
+  return platforms.includes(choice) ? choice : "feishu";
+}
+async function runSetup(profile) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const isDefault = !profile || profile === "default";
+  const label = isDefault ? "\u9ED8\u8BA4 profile" : `profile "${profile}"`;
+  console.log(`
+\u{1F6E0}  claude-im setup \u2014 \u914D\u7F6E ${label}
+`);
+  const platform = await choosePlatform(rl);
+  const appId = await prompt(rl, `  ${platform.toUpperCase()} App ID     : `);
+  const appSecret = await prompt(rl, `  ${platform.toUpperCase()} App Secret : `);
+  rl.close();
+  const profileName = isDefault ? "default" : profile;
+  saveSecretToVault(profileName, appSecret);
+  const raw = loadRaw();
+  if (isDefault) {
+    raw.platform = platform;
+    raw[platform] = { ...raw[platform] ?? {}, app_id: appId };
+  } else {
+    raw.profiles = raw.profiles ?? {};
+    raw.profiles[profileName] = {
+      platform,
+      [platform]: { app_id: appId }
+    };
+  }
+  saveRaw(raw);
+  logger.success(`\u914D\u7F6E\u5DF2\u4FDD\u5B58: ${GLOBAL_CONFIG_PATH2}`);
+  logger.dim(`\u5BC6\u94A5\u5DF2\u52A0\u5BC6\u5B58\u50A8\u5728 vault/${profileName}`);
+  logger.dim("\u5411 bot \u53D1\u9001\u4EFB\u610F\u6D88\u606F\u5373\u53EF\u81EA\u52A8\u83B7\u53D6 owner_open_id\n");
+}
+async function runNewProfile() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  console.log("\n\u{1F6E0}  claude-im \u2014 \u6DFB\u52A0\u65B0 profile\n");
+  const platform = await choosePlatform(rl);
+  const appId = await prompt(rl, `  ${platform.toUpperCase()} App ID     : `);
+  const appSecret = await prompt(rl, `  ${platform.toUpperCase()} App Secret : `);
+  const name = await prompt(rl, "  Profile \u540D\u79F0    : ");
+  rl.close();
+  const profileName = name || `bot-${Math.random().toString(36).slice(2, 6)}`;
+  console.log(`  \u2192 \u4F7F\u7528\u540D\u79F0: ${profileName}`);
+  saveSecretToVault(profileName, appSecret);
+  const raw = loadRaw();
+  raw.profiles = raw.profiles ?? {};
+  raw.profiles[profileName] = {
+    platform,
+    [platform]: { app_id: appId }
+  };
+  saveRaw(raw);
+  logger.success(`Profile "${profileName}" (${platform}) \u5DF2\u4FDD\u5B58`);
+  return profileName;
+}
+var HOME2, GLOBAL_CONFIG_PATH2;
+var init_interactive = __esm({
+  "src/setup/interactive.ts"() {
+    init_loader();
+    init_logger();
+    init_registry();
+    HOME2 = process.env.CLAUDE_IM_HOME || resolve(process.env.HOME || "~", ".claude-im");
+    GLOBAL_CONFIG_PATH2 = resolve(HOME2, "config.yml");
+  }
+});
+
+// src/config/index.ts
+var config_exports = {};
+__export(config_exports, {
+  DEFAULT_PROFILE: () => DEFAULT_PROFILE,
+  resolveConfig: () => resolveConfig,
+  saveConfig: () => saveConfig,
+  saveSecretToVault: () => saveSecretToVault
+});
+var init_config = __esm({
+  "src/config/index.ts"() {
+    init_loader();
+    init_defaults();
+  }
+});
+function getStateDir() {
+  const home = process.env.CLAUDE_IM_HOME || resolve(process.env.HOME || "~", ".claude-im");
+  return resolve(home, "state");
+}
+function getStatePath(profile) {
+  const dir = getStateDir();
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 448 });
+  return resolve(dir, `${profile}.json.enc`);
+}
+function saveState(profile, data) {
+  const path = getStatePath(profile);
+  writeFileSync(path, encrypt(JSON.stringify(data)), { mode: 384 });
+}
+function loadState(profile) {
+  const path = getStatePath(profile);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(decrypt(readFileSync(path, "utf8")));
+  } catch {
+    return null;
+  }
+}
+function deleteState(profile) {
+  const path = getStatePath(profile);
+  try {
+    if (existsSync(path)) {
+      unlinkSync(path);
+    }
+  } catch {
+  }
+}
+function hasState(profile) {
+  return existsSync(getStatePath(profile));
+}
+var init_vault = __esm({
+  "src/session/vault.ts"() {
+    init_crypto();
+  }
+});
+
+// src/session/manager.ts
+function getSession(profile) {
+  const cached = memoryCache.get(profile);
+  if (cached) return cached;
+  const data = loadState(profile);
+  if (!data) return null;
+  const result = {
+    sessionId: data.session_id || "",
+    chatId: data.chat_id || ""
+  };
+  if (result.sessionId) memoryCache.set(profile, result);
+  return result;
+}
+function setSession(profile, sessionId, chatId) {
+  const existing = loadState(profile) ?? {};
+  existing.session_id = sessionId;
+  if (chatId) existing.chat_id = chatId;
+  saveState(profile, existing);
+  memoryCache.set(profile, { sessionId, chatId: chatId ?? existing.chat_id ?? "" });
+  logger.dim(`session saved: ${sessionId.slice(0, 8)}`);
+}
+function clearSession(profile) {
+  deleteState(profile);
+  memoryCache.delete(profile);
+}
+var memoryCache;
+var init_manager = __esm({
+  "src/session/manager.ts"() {
+    init_vault();
+    init_logger();
+    memoryCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/session/index.ts
+var session_exports = {};
+__export(session_exports, {
+  clearSession: () => clearSession,
+  deleteState: () => deleteState,
+  getSession: () => getSession,
+  hasState: () => hasState,
+  loadState: () => loadState,
+  saveState: () => saveState,
+  setSession: () => setSession
+});
+var init_session = __esm({
+  "src/session/index.ts"() {
+    init_manager();
+    init_vault();
+  }
+});
+
+// src/claude/events.ts
+function createEventState() {
+  return {
+    thinkingBuffer: [],
+    thinkingLength: 0,
+    textBuffer: "",
+    toolCallCount: 0,
+    currentToolName: "",
+    sessionId: "",
+    error: null,
+    isComplete: false
+  };
+}
+function processEvent(state, event) {
+  if (event.type === "assistant" && "message" in event) {
+    const msg = event.message;
+    if (msg.content) {
+      for (const block of Array.isArray(msg.content) ? msg.content : [msg.content]) {
+        if (block.type === "text") {
+          state.textBuffer += block.text ?? "";
+        } else if (block.type === "tool_use") {
+          state.currentToolName = block.name ?? "";
+          state.toolCallCount++;
+        }
+      }
+    }
+  }
+  if (event.type === "assistant" && "thinking" in event) {
+    const thinking = event.thinking;
+    if (thinking?.text) {
+      state.thinkingBuffer.push(thinking.text);
+      state.thinkingLength += thinking.text.length;
+    }
+  }
+  if (event.type === "result") {
+    const result = event;
+    state.sessionId = result.session_id ?? "";
+    state.error = result.error ?? null;
+    state.isComplete = true;
+  }
+}
+var init_events = __esm({
+  "src/claude/events.ts"() {
+  }
+});
+async function runAgent(input, onEvent) {
+  const state = createEventState();
+  const q = query({
+    prompt: input.prompt,
+    options: {
+      permissionMode: input.permissionMode ?? input.config.claude.permission_mode ?? "acceptEdits",
+      allowedTools: input.config.claude.allowed_tools ?? [],
+      cwd: input.cwd,
+      model: "claude-sonnet-4-6",
+      ...input.resume ? { resume: input.resume } : {}
+    }
+  });
+  logger.dim(`Claude \u67E5\u8BE2, prompt length: ${input.prompt.length}`);
+  for await (const event of q) {
+    processEvent(state, event);
+    onEvent?.(state, event);
+  }
+  logger.dim(`Claude \u5B8C\u6210, session: ${state.sessionId.slice(0, 8)}, tools: ${state.toolCallCount}`);
+  return {
+    text: state.textBuffer,
+    sessionId: state.sessionId,
+    thinkingLength: state.thinkingLength,
+    toolCallCount: state.toolCallCount,
+    error: state.error
+  };
+}
+var init_agent = __esm({
+  "src/claude/agent.ts"() {
+    init_logger();
+    init_events();
+  }
+});
+
+// src/claude/context.ts
+var init_context = __esm({
+  "src/claude/context.ts"() {
+  }
+});
+
+// src/claude/index.ts
+var init_claude = __esm({
+  "src/claude/index.ts"() {
+    init_agent();
+    init_events();
+    init_context();
+  }
+});
+
+// src/command/parser.ts
+function parseTemplate(template, variables) {
+  return template.replace(/\{(\w+)\}/g, (_, key) => variables[key] ?? `{${key}}`);
+}
+function isCommand(text) {
+  return text.startsWith("/");
+}
+function parseCommand(text) {
+  const spaceIdx = text.indexOf(" ");
+  if (spaceIdx === -1) return { cmd: text.slice(1), args: "" };
+  return { cmd: text.slice(1, spaceIdx), args: text.slice(spaceIdx + 1) };
+}
+var init_parser = __esm({
+  "src/command/parser.ts"() {
+  }
+});
+
+// src/command/builtins.ts
+function getHelpText() {
+  const lines = ["**\u53EF\u7528\u547D\u4EE4:**"];
+  for (const [cmd, desc] of Object.entries(BUILTIN_COMMANDS)) {
+    lines.push(`- **/${cmd}** \u2014 ${desc}`);
+  }
+  return lines.join("\n");
+}
+var BUILTIN_COMMANDS;
+var init_builtins = __esm({
+  "src/command/builtins.ts"() {
+    BUILTIN_COMMANDS = {
+      help: "\u663E\u793A\u53EF\u7528\u547D\u4EE4\u5217\u8868",
+      stop: "\u505C\u6B62\u5F53\u524D\u5904\u7406",
+      new: "\u5F00\u59CB\u65B0\u4F1A\u8BDD",
+      status: "\u67E5\u770B\u5F53\u524D\u4F1A\u8BDD\u72B6\u6001",
+      model: "\u67E5\u770B\u5F53\u524D\u4F7F\u7528\u7684\u6A21\u578B"
+    };
+  }
+});
+
+// src/command/index.ts
+var command_exports = {};
+__export(command_exports, {
+  BUILTIN_COMMANDS: () => BUILTIN_COMMANDS,
+  getHelpText: () => getHelpText,
+  isCommand: () => isCommand,
+  parseCommand: () => parseCommand,
+  parseTemplate: () => parseTemplate
+});
+var init_command = __esm({
+  "src/command/index.ts"() {
+    init_parser();
+    init_builtins();
+  }
+});
+
+// src/core/handler.ts
+var handler_exports = {};
+__export(handler_exports, {
+  createMessageHandler: () => createMessageHandler
+});
+function isDuplicate(messageId) {
+  const now = Date.now();
+  const last = dedupMap.get(messageId);
+  if (last && now - last < 3e4) return true;
+  dedupMap.set(messageId, now);
+  if (dedupMap.size > 500) {
+    for (const [key, ts2] of dedupMap) {
+      if (now - ts2 > 6e4) dedupMap.delete(key);
+    }
+  }
+  return false;
+}
+function createMessageHandler(config, adapter) {
+  let processing = false;
+  return async (msg) => {
+    if (isDuplicate(msg.id)) return;
+    logger.msgReceived(msg.id, msg.chatType);
+    if (processing) {
+      await adapter.replyText(msg.id, "\u6B63\u5728\u5904\u7406\u4E0A\u4E00\u6761\u6D88\u606F\uFF0C\u8BF7\u7A0D\u5019...");
+      return;
+    }
+    processing = true;
+    try {
+      await adapter.setReaction(msg.id, "processing");
+      if (msg.type === "text" && msg.text) {
+        await handleText(config, adapter, msg);
+      } else if (msg.type === "image") {
+        await adapter.replyText(msg.id, "\u56FE\u7247\u5206\u6790\u529F\u80FD\u5C06\u5728\u540E\u7EED\u7248\u672C\u4E2D\u652F\u6301");
+      } else if (msg.type === "file") {
+        await adapter.replyText(msg.id, "\u6587\u4EF6\u5206\u6790\u529F\u80FD\u5C06\u5728\u540E\u7EED\u7248\u672C\u4E2D\u652F\u6301");
+      } else {
+        await adapter.replyText(msg.id, `\u6682\u4E0D\u652F\u6301: ${msg.type}`);
+      }
+      await adapter.setReaction(msg.id, "done");
+    } catch (e) {
+      logger.error(`\u5904\u7406\u5931\u8D25: ${e.message.slice(0, 200)}`);
+      await adapter.setReaction(msg.id, "error");
+      await adapter.replyText(msg.id, "\u5904\u7406\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5");
+    } finally {
+      processing = false;
+    }
+  };
+}
+async function handleText(config, adapter, msg) {
+  const text = msg.text ?? "";
+  if (isCommand(text)) {
+    const { cmd, args } = parseCommand(text);
+    switch (cmd) {
+      case "help":
+        await adapter.replyCard(msg.id, { title: config.card_title, content: getHelpText() });
+        return;
+      case "new":
+        clearSession(config.profile);
+        await adapter.replyText(msg.id, "\u2705 \u5DF2\u5F00\u59CB\u65B0\u4F1A\u8BDD");
+        return;
+      case "stop":
+        await adapter.replyText(msg.id, "\u23F9 \u5DF2\u505C\u6B62");
+        return;
+      case "status": {
+        const sess = getSession(config.profile);
+        await adapter.replyText(msg.id, sess ? `\u4F1A\u8BDD: ${sess.sessionId.slice(0, 8)}` : "\u65E0\u6D3B\u8DC3\u4F1A\u8BDD");
+        return;
+      }
+      default: {
+        const customCmd = config.commands[cmd];
+        if (customCmd) {
+          const { parseTemplate: parseTemplate2 } = await Promise.resolve().then(() => (init_command(), command_exports));
+          return await runClaudeReply(config, adapter, msg, parseTemplate2(customCmd, { input: args }));
+        }
+        await adapter.replyText(msg.id, `\u672A\u77E5\u547D\u4EE4: /${cmd}\u3002\u8F93\u5165 /help \u67E5\u770B`);
+        return;
+      }
+    }
+  }
+  await runClaudeReply(config, adapter, msg, text);
+}
+async function runClaudeReply(config, adapter, msg, prompt2) {
+  const t0 = Date.now();
+  const sess = getSession(config.profile);
+  const ctrl = adapter.createStreamController(config.card_title, config.streaming.flush_interval_ms);
+  const replyId = await ctrl.init(msg.id, msg.chatId);
+  if (!replyId) {
+    await adapter.replyText(msg.id, "\u53D1\u9001\u5931\u8D25");
+    return;
+  }
+  const result = await runAgent(
+    { prompt: prompt2, config, resume: sess?.sessionId, cwd: process.cwd() },
+    (state) => ctrl.append(state.textBuffer || "\u601D\u8003\u4E2D...")
+  );
+  await ctrl.complete(result.text || "(\u7A7A\u56DE\u590D)", {
+    elapsed: Date.now() - t0,
+    tools: result.toolCallCount,
+    thinking: result.thinkingLength
+  });
+  if (result.sessionId) setSession(config.profile, result.sessionId, msg.chatId);
+}
+var dedupMap;
+var init_handler = __esm({
+  "src/core/handler.ts"() {
+    init_logger();
+    init_claude();
+    init_session();
+    init_command();
+    dedupMap = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/core/lifecycle.ts
+var lifecycle_exports = {};
+__export(lifecycle_exports, {
+  startApp: () => startApp
+});
+async function startApp(config, opts) {
+  acquireLock(config.profile, process.cwd());
+  const adapter = createAdapter(config);
+  const { createMessageHandler: createMessageHandler2 } = await Promise.resolve().then(() => (init_handler(), handler_exports));
+  const handleMessage = createMessageHandler2(config, adapter);
+  adapter.onMessage(handleMessage);
+  await adapter.connect();
+  const { getSession: getSession2 } = await Promise.resolve().then(() => (init_session(), session_exports));
+  const sess = getSession2(config.profile);
+  if (sess?.chatId) {
+    try {
+      await adapter.sendCard(sess.chatId, {
+        title: config.card_title,
+        content: `\u5DF2\u4E0A\u7EBF
+\u5DE5\u4F5C\u76EE\u5F55: \`${process.cwd()}\``,
+        status: "success"
+      });
+      logger.dim("\u5DF2\u53D1\u9001\u4E0A\u7EBF\u901A\u77E5");
+    } catch (e) {
+      logger.warn(`\u4E0A\u7EBF\u901A\u77E5\u53D1\u9001\u5931\u8D25: ${e.message.slice(0, 80)}`);
+    }
+  } else {
+    logger.dim("\u65E0\u5386\u53F2\u4F1A\u8BDD\uFF0C\u8DF3\u8FC7\u4E0A\u7EBF\u901A\u77E5");
+  }
+  logger.success(`${config.card_title} [${config.profile}] \u5DF2\u542F\u52A8 (platform: ${config.platform})`);
+  if (opts.daemon) {
+    logger.dim(`\u5B88\u62A4\u8FDB\u7A0B\u6A21\u5F0F\uFF0CPID: ${process.pid}`);
+    process.stdin.destroy();
+  }
+  let shuttingDown = false;
+  const cleanup = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    logger.info("\u6B63\u5728\u5173\u95ED...");
+    const cur = getSession2(config.profile);
+    if (cur?.chatId) {
+      try {
+        await adapter.sendCard(cur.chatId, {
+          title: config.card_title,
+          content: "\u5DF2\u79BB\u7EBF",
+          status: "neutral"
+        });
+      } catch {
+      }
+    }
+    try {
+      await adapter.disconnect();
+    } catch {
+    }
+    releaseLock(config.profile);
+    logger.info(`${config.profile} \u5DF2\u505C\u6B62`);
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+}
+var init_lifecycle = __esm({
+  "src/core/lifecycle.ts"() {
+    init_registry();
+    init_lock();
+    init_logger();
+  }
+});
+
+// src/adapters/feishu/index.ts
+init_registry();
+
+// src/adapters/feishu/types.ts
+var DEFAULT_REACTION = {
+  /** 处理中：Typing（正在输入） */
+  processing: "Typing",
+  /** 完成：DONE（完成勾） */
+  done: "DONE",
+  /** 错误：OnIt（处理中带感叹号） */
+  error: "OnIt",
+  /** 超时：Clock（时钟） */
+  timeout: "Clock"
+};
+function createLarkClient(config) {
+  return new Lark.Client({
+    appId: config.platform_config.app_id,
+    appSecret: config.platform_secret
+  });
+}
+function createWSClient(config) {
+  return new Lark.WSClient({
+    appId: config.platform_config.app_id,
+    appSecret: config.platform_secret,
+    loggerLevel: Lark.LoggerLevel.info
+    // 不传 appSecret 到 logger，SDK 内部会处理
+  });
+}
+
+// src/adapters/feishu/message.ts
+async function sendText(client, chatId, text) {
+  await client.im.message.create({
+    params: { receive_id_type: "chat_id" },
+    data: {
+      receive_id: chatId,
+      content: JSON.stringify({ text }),
+      msg_type: "text"
+    }
+  });
+}
+async function replyText(client, messageId, text) {
+  await client.im.message.reply({
+    path: { message_id: messageId },
+    data: {
+      content: JSON.stringify({ text }),
+      msg_type: "text"
+    }
+  });
+}
+async function sendCard(client, chatId, card) {
+  const res = await client.im.message.create({
+    params: { receive_id_type: "chat_id" },
+    data: {
+      receive_id: chatId,
+      content: JSON.stringify(card),
+      msg_type: "interactive"
+    }
+  });
+  return res?.data?.message_id ?? "";
+}
+async function replyCard(client, messageId, card) {
+  const res = await client.im.message.reply({
+    path: { message_id: messageId },
+    data: {
+      content: JSON.stringify(card),
+      msg_type: "interactive"
+    }
+  });
+  return res?.data?.message_id ?? "";
+}
+
+// src/adapters/feishu/reaction.ts
+init_logger();
+async function setReaction(client, messageId, reactionType) {
+  try {
+    await client.im.messageReaction.create({
+      path: { message_id: messageId },
+      data: { reaction_type: { emoji_type: reactionType } }
+    });
+  } catch (e) {
+    logger.dim(`reaction failed: ${e.message.slice(0, 50)}`);
+  }
+}
+
+// src/adapters/feishu/card.ts
+function buildMarkdownCard(title, content) {
+  return {
+    config: { wide_screen_mode: true },
+    header: {
+      template: "blue",
+      title: { content: title, tag: "plain_text" }
+    },
+    elements: [
+      { tag: "markdown", content: content || "(\u7A7A\u56DE\u590D)" }
+    ]
+  };
+}
+function buildStatusCard(title, status, detail) {
+  const statusIcon = {
+    online: "\u{1F7E2}",
+    offline: "\u26AB",
+    error: "\u{1F534}"
+  };
+  return {
+    config: { wide_screen_mode: true },
+    header: {
+      template: status === "error" ? "red" : status === "online" ? "green" : "grey",
+      title: { content: `${statusIcon[status]} ${title}`, tag: "plain_text" }
+    },
+    elements: [
+      { tag: "markdown", content: detail }
+    ]
+  };
+}
+
+// src/core/flush.ts
+var FlushController = class {
+  buffer = "";
+  lastFlush = 0;
+  timer = null;
+  flushing = false;
+  minInterval;
+  heartbeatInterval;
+  lastHeartbeat;
+  onFlush;
+  /**
+   * 创建流式缓冲控制器
+   *
+   * @param onFlush - 实际执行刷新的回调函数
+   * @param minInterval - 最小刷新间隔（毫秒，默认 200ms）
+   * @param heartbeatInterval - 心跳保活间隔（毫秒，默认 15s），
+   *                            超过此间隔未刷新时即使内容较少也会强制刷新
+   */
+  constructor(onFlush, minInterval = 200, heartbeatInterval = 15e3) {
+    this.onFlush = onFlush;
+    this.minInterval = minInterval;
+    this.heartbeatInterval = heartbeatInterval;
+    this.lastHeartbeat = Date.now();
+    this.lastFlush = 0;
+  }
+  /**
+   * 追加文本到缓冲区
+   *
+   * 将文本累加到内部缓冲区，并调度一次刷新检查。
+   *
+   * @param text - 追加的文本内容
+   */
+  append(text) {
+    this.buffer += text;
+    this.scheduleFlush();
+  }
+  /**
+   * 立即刷新所有缓冲内容
+   *
+   * 取消等待中的定时器，强制立即执行一次刷新。
+   * 通常在流式输出结束时调用。
+   */
+  async flushAll() {
+    if (this.timer) clearTimeout(this.timer);
+    await this.doFlush();
+  }
+  /**
+   * 调度刷新检查
+   *
+   * 根据距上次刷新的时间计算合适的延迟，确保不超过最小刷新间隔。
+   */
+  scheduleFlush() {
+    if (this.timer) clearTimeout(this.timer);
+    const elapsed = Date.now() - this.lastFlush;
+    const delay = Math.max(0, this.minInterval - elapsed);
+    this.timer = setTimeout(() => this.checkAndFlush(), delay);
+  }
+  /**
+   * 检查条件并执行刷新
+   *
+   * 同时满足以下条件时执行刷新：
+   * 1. 缓冲区有内容
+   * 2. 距上次刷新超过最小间隔，或距上次心跳超过心跳间隔
+   * 否则重新调度等待。
+   */
+  async checkAndFlush() {
+    const now = Date.now();
+    const sinceLast = now - this.lastFlush;
+    if (this.buffer && (sinceLast >= this.minInterval || now - this.lastHeartbeat >= this.heartbeatInterval)) {
+      await this.doFlush();
+      this.lastHeartbeat = now;
+    } else if (this.buffer) {
+      this.scheduleFlush();
+    }
+  }
+  /**
+   * 执行实际的刷新操作
+   *
+   * 将当前缓冲区内容发送给 onFlush 回调。
+   * 如果刷新失败，将内容放回缓冲区头部等待下次重试。
+   */
+  async doFlush() {
+    if (this.flushing || !this.buffer) return;
+    this.flushing = true;
+    const text = this.buffer;
+    this.buffer = "";
+    try {
+      await this.onFlush(text);
+      this.lastFlush = Date.now();
+    } catch {
+      this.buffer = text + this.buffer;
+    } finally {
+      this.flushing = false;
+    }
+  }
+};
+
+// src/adapters/feishu/stream.ts
+var CardKitStreamController = class {
+  /** 当前控制器状态 */
+  state = "idle";
+  /** 已发送卡片的飞书消息 ID */
+  _messageId = "";
+  /** 飞书 REST API 客户端 */
+  client;
+  /** 流式卡片的标题 */
+  cardTitle;
+  /** 定时刷新控制器，按间隔批量提交累积文本 */
+  flushCtrl;
+  /** 已累积的显示缓冲区内容 */
+  displayBuffer = "";
+  /**
+   * 创建 CardKit 流式卡片控制器。
+   *
+   * @param client - 飞书 REST API 客户端
+   * @param cardTitle - 卡片标题（显示在 header 中）
+   * @param flushIntervalMs - 刷新间隔（毫秒），默认 200ms，控制文本更新的频率
+   */
+  constructor(client, cardTitle, flushIntervalMs = 200) {
+    this.client = client;
+    this.cardTitle = cardTitle;
+    this.flushCtrl = new FlushController(async (text) => {
+      await this.performFlush(text);
+    }, flushIntervalMs);
+  }
+  /**
+   * 获取当前卡片消息的 ID。
+   * 在 init() 成功调用后才有值。
+   */
+  get messageId() {
+    return this._messageId;
+  }
+  /**
+   * 初始化流式卡片。
+   *
+   * 以回复消息的形式向飞书会话发送一张初始卡片（蓝色 header，显示"思考中..."），
+   * 记录返回的 message_id 用于后续更新。调用后将状态切换为 streaming。
+   *
+   * @param replyTo - 被回复消息的 ID
+   * @param chatId - 飞书会话 ID（当前未使用，保留接口兼容）
+   * @returns 创建的卡片消息 ID，失败返回 null
+   */
+  async init(replyTo, chatId) {
+    const res = await this.client.im.message.reply({
+      path: { message_id: replyTo },
+      data: {
+        msg_type: "interactive",
+        content: JSON.stringify({
+          config: { wide_screen_mode: true },
+          header: {
+            template: "blue",
+            title: { content: `${this.cardTitle} \u2014 \u601D\u8003\u4E2D...`, tag: "plain_text" }
+          },
+          elements: [{ tag: "markdown", content: "..." }]
+        })
+      }
+    });
+    this._messageId = res?.data?.message_id ?? "";
+    this.state = "streaming";
+    return this._messageId || null;
+  }
+  /**
+   * 追加文本到流式输出缓冲区。
+   *
+   * 文本不会立即发送，而是先进入 FlushController 的缓冲区，
+   * 等待下一个刷新周期统一提交。仅在 streaming 状态下生效。
+   *
+   * @param text - 要追加的文本片段
+   */
+  append(text) {
+    if (this.state !== "streaming") return;
+    this.flushCtrl.append(text);
+  }
+  /**
+   * 完成流式输出。
+   *
+   * 先执行最后一次刷新确保所有缓冲文本已发送，然后将状态切换为 completed，
+   * 最后更新卡片为完成态：header 变为绿色，显示"完成"标识和可选的统计信息。
+   *
+   * @param content - 最终完整的回复内容
+   * @param stats - 可选的统计信息（耗时、工具调用次数、思考字符数）
+   */
+  async complete(content, stats) {
+    await this.flushCtrl.flushAll();
+    this.state = "completed";
+    const statsText = stats ? `
+
+---
+\u23F1 ${(stats.elapsed / 1e3).toFixed(1)}s \xB7 \u{1F527} ${stats.tools} tools \xB7 \u{1F4AD} ${stats.thinking} chars` : "";
+    try {
+      await this.client.im.message.patch({
+        path: { message_id: this._messageId },
+        data: {
+          content: JSON.stringify({
+            config: { wide_screen_mode: true },
+            header: { template: "green", title: { content: `${this.cardTitle} \u2014 \u5B8C\u6210`, tag: "plain_text" } },
+            elements: [{ tag: "markdown", content: content + statsText }]
+          })
+        }
+      });
+    } catch {
+    }
+  }
+  /**
+   * 中止流式输出。
+   *
+   * 将状态切换为 aborted，立即刷出缓冲区，然后更新卡片为错误态：
+   * header 变为红色，显示"错误"标识和错误详情。
+   *
+   * @param error - 错误描述文本
+   */
+  async abort(error) {
+    this.state = "aborted";
+    await this.flushCtrl.flushAll();
+    try {
+      await this.client.im.message.patch({
+        path: { message_id: this._messageId },
+        data: {
+          content: JSON.stringify({
+            header: { template: "red", title: { content: `${this.cardTitle} \u2014 \u9519\u8BEF`, tag: "plain_text" } },
+            elements: [{ tag: "markdown", content: error }]
+          })
+        }
+      });
+    } catch {
+    }
+  }
+  /**
+   * 执行卡片内容的实际刷新操作。
+   *
+   * 将累积的显示缓冲区内容通过飞书 message.patch API 更新到已发送的卡片上。
+   * 仅在 streaming 状态下且有有效的 messageId 时执行。
+   * 每次 patch 都会累加 displayBuffer 中的内容。
+   *
+   * @param text - 本次刷新要追加的文本（实际使用 displayBuffer 进行全量更新）
+   */
+  async performFlush(text) {
+    if (!this._messageId || this.state !== "streaming") return;
+    this.displayBuffer += text;
+    try {
+      await this.client.im.message.patch({
+        path: { message_id: this._messageId },
+        data: {
+          content: JSON.stringify({
+            config: { wide_screen_mode: true },
+            header: {
+              template: "blue",
+              title: { content: `${this.cardTitle} \u2014 \u56DE\u590D\u4E2D...`, tag: "plain_text" }
+            },
+            elements: [{ tag: "markdown", content: this.displayBuffer }]
+          })
+        }
+      });
+    } catch {
+    }
+  }
+};
+
+// src/adapters/feishu/file.ts
+init_logger();
+async function downloadImage(client, messageId, imageKey, tempDir) {
+  try {
+    const res = await client.im.messageResource.get({
+      path: { message_id: messageId, file_key: imageKey },
+      params: { type: "image" }
+    });
+    if (!existsSync(tempDir)) mkdirSync(tempDir, { recursive: true });
+    const filePath = resolve(tempDir, `${imageKey}.jpg`);
+    if (res && typeof res.getReadableStream === "function") {
+      const chunks = [];
+      const stream = res.getReadableStream();
+      for await (const chunk of stream) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+      }
+      const buf = Buffer.concat(chunks);
+      writeFileSync(filePath, buf);
+      return { path: filePath, base64: buf.toString("base64") };
+    }
+    return null;
+  } catch (e) {
+    logger.error(`\u4E0B\u8F7D\u56FE\u7247\u5931\u8D25: ${e.message.slice(0, 50)}`);
+    return null;
+  }
+}
+async function downloadFile(client, messageId, fileKey, fileName, tempDir) {
+  try {
+    const res = await client.im.messageResource.get({
+      path: { message_id: messageId, file_key: fileKey },
+      params: { type: "file" }
+    });
+    if (!existsSync(tempDir)) mkdirSync(tempDir, { recursive: true });
+    const safeName = basename(fileName);
+    const filePath = resolve(tempDir, safeName);
+    if (res && typeof res.getReadableStream === "function") {
+      const chunks = [];
+      const stream = res.getReadableStream();
+      for await (const chunk of stream) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+      }
+      const buf = Buffer.concat(chunks);
+      writeFileSync(filePath, buf);
+      return { path: filePath, name: safeName, size: buf.length };
+    }
+    return null;
+  } catch (e) {
+    logger.error(`\u4E0B\u8F7D\u6587\u4EF6\u5931\u8D25: ${e.message.slice(0, 50)}`);
+    return null;
+  }
+}
+
+// src/adapters/feishu/doc.ts
+init_logger();
+async function createOverflowDocument(client, title, content) {
+  try {
+    const docRes = await client.docx.document.create({
+      data: { title }
+    });
+    const docId = docRes?.data?.document?.document_id ?? "";
+    if (!docId) return "";
+    try {
+      await client.docx.documentBlock.children.create({
+        path: { document_id: docId, block_id: docId },
+        data: {
+          children: [{
+            block_type: 2,
+            text: {
+              elements: [{ text_run: { content, text_element_style: {} } }],
+              style: {}
+            }
+          }]
+        }
+      });
+    } catch {
+    }
+    const docUrl = `https://bytedance.feishu.cn/docx/${docId}`;
+    logger.dim(`overflow doc: ${docUrl}`);
+    return docUrl;
+  } catch (e) {
+    logger.error(`\u521B\u5EFA\u6587\u6863\u5931\u8D25: ${e.message.slice(0, 50)}`);
+    return "";
+  }
+}
+
+// src/adapters/feishu/adapter.ts
+function parseMessage(data) {
+  const msg = data.message ?? {};
+  const id = msg.message_id ?? "";
+  const chatId = msg.chat_id ?? "";
+  const chatType = msg.chat_type ?? "p2p";
+  const msgType = msg.message_type ?? "";
+  const content = msg.content ?? "";
+  if (!id || !chatId) return null;
+  let type = "text";
+  let text;
+  let imageKey;
+  let fileKey;
+  let fileName;
+  if (msgType === "image") {
+    type = "image";
+    try {
+      imageKey = JSON.parse(content).image_key;
+    } catch {
+    }
+  } else if (msgType === "file") {
+    type = "file";
+    try {
+      const parsed = JSON.parse(content);
+      fileKey = parsed.file_key;
+      fileName = parsed.file_name;
+    } catch {
+    }
+  } else {
+    type = "text";
+    try {
+      text = JSON.parse(content).text ?? "";
+    } catch {
+      text = content;
+    }
+  }
+  return { id, chatId, chatType: chatType === "group" ? "group" : "p2p", type, text, imageKey, fileKey, fileName, raw: data };
+}
+var STATUS_TEMPLATE = {
+  success: "online",
+  neutral: "offline",
+  error: "error"
+};
+function statusToTemplate(status) {
+  return STATUS_TEMPLATE[status] ?? "offline";
+}
+var FeishuAdapter = class {
+  platform = "feishu";
+  /** 飞书 REST API 客户端 */
+  client;
+  /** 飞书 WebSocket 长连接客户端 */
+  wsClient;
+  /** 全局解析后的配置对象 */
+  config;
+  /** 飞书平台专属配置 */
+  feishu;
+  /** 消息处理各阶段对应的表情映射表（支持用户自定义覆盖） */
+  reactionMap;
+  /** 外部注册的消息处理器 */
+  msgHandler = null;
+  /**
+   * 创建飞书适配器实例。
+   *
+   * @param config - 全局解析后的配置对象，从中提取飞书平台配置和密钥
+   */
+  constructor(config) {
+    this.config = config;
+    this.feishu = config.platform_config;
+    this.reactionMap = { ...DEFAULT_REACTION, ...this.feishu.reaction_emojis };
+    this.client = createLarkClient(config);
+    this.wsClient = createWSClient(config);
+  }
+  /**
+   * 建立与飞书平台的连接。
+   *
+   * 注册飞书 im.message.receive_v1 事件回调，通过 WebSocket 长连接
+   * 接收实时消息推送。必须在调用前先通过 onMessage() 注册消息处理器。
+   *
+   * @throws 若 onMessage() 未在 connect() 之前调用则抛出错误
+   */
+  async connect() {
+    if (!this.msgHandler) throw new Error("onMessage() \u5FC5\u987B\u5728 connect() \u4E4B\u524D\u8C03\u7528");
+    const handler = this.msgHandler;
+    const dispatcher = new Lark.EventDispatcher({}).register({
+      "im.message.receive_v1": async (data) => {
+        const msg = parseMessage(data);
+        if (msg) await handler(msg);
+      }
+    });
+    this.wsClient.start({ eventDispatcher: dispatcher });
+  }
+  /**
+   * 断开与飞书平台的连接。
+   *
+   * 当前实现中，WebSocket 客户端会在进程退出时自动清理连接，
+   * 因此无需显式断开。
+   */
+  async disconnect() {
+  }
+  /**
+   * 注册消息处理器。
+   *
+   * 当飞书平台推送新消息时，parseMessage 解析后的 IMessage 对象
+   * 会传递给该处理器。必须在 connect() 之前调用。
+   *
+   * @param handler - 异步消息处理回调函数
+   */
+  onMessage(handler) {
+    this.msgHandler = handler;
+  }
+  /**
+   * 向指定会话发送纯文本消息。
+   *
+   * @param chatId - 飞书会话 ID（chat_id）
+   * @param text - 要发送的文本内容
+   * @returns 空字符串（飞书 SDK 此处不返回 message_id）
+   */
+  async sendText(chatId, text) {
+    await sendText(this.client, chatId, text);
+    return "";
+  }
+  /**
+   * 回复指定消息的纯文本内容。
+   *
+   * @param messageId - 被回复消息的 ID
+   * @param text - 回复文本内容
+   * @returns 空字符串（飞书 SDK 此处不返回 message_id）
+   */
+  async replyText(messageId, text) {
+    await replyText(this.client, messageId, text);
+    return "";
+  }
+  /**
+   * 向指定会话发送交互式卡片消息。
+   *
+   * 使用 buildMarkdownCard 将 ICard 接口转换为飞书卡片 JSON。
+   *
+   * @param chatId - 飞书会话 ID
+   * @param card - 标准化的卡片数据（标题+内容）
+   * @returns 飞书返回的消息 ID
+   */
+  async sendCard(chatId, card) {
+    const json = card.status ? buildStatusCard(card.title, statusToTemplate(card.status), card.content) : buildMarkdownCard(card.title, card.content);
+    return await sendCard(this.client, chatId, json);
+  }
+  /**
+   * 回复指定消息的交互式卡片。
+   *
+   * 使用 buildMarkdownCard 将 ICard 接口转换为飞书卡片 JSON。
+   *
+   * @param messageId - 被回复消息的 ID
+   * @param card - 标准化的卡片数据（标题+内容）
+   * @returns 飞书返回的消息 ID
+   */
+  async replyCard(messageId, card) {
+    const json = card.status ? buildStatusCard(card.title, statusToTemplate(card.status), card.content) : buildMarkdownCard(card.title, card.content);
+    return await replyCard(this.client, messageId, json);
+  }
+  /**
+   * 创建流式回复控制器。
+   *
+   * 返回 CardKitStreamController 实例，支持通过飞书卡片实现
+   * 逐段追加内容的流式输出效果。
+   *
+   * @param title - 卡片标题
+   * @param flushMs - 刷新间隔（毫秒），默认 200ms
+   * @returns 流式卡片控制器实例
+   */
+  createStreamController(title, flushMs) {
+    return new CardKitStreamController(this.client, title, flushMs);
+  }
+  /**
+   * 为指定消息设置表情反应（reaction）。
+   *
+   * 根据处理阶段（processing/done/error/timeout）选择对应表情。
+   * 表情可以从 reaction_emojis 配置中自定义覆盖。
+   *
+   * @param msgId - 消息 ID
+   * @param phase - 处理阶段标识
+   */
+  async setReaction(msgId, phase) {
+    const emoji = this.reactionMap[phase];
+    if (emoji) await setReaction(this.client, msgId, emoji);
+  }
+  /**
+   * 下载消息中的图片到本地临时目录。
+   *
+   * @param msgId - 消息 ID
+   * @param imageKey - 图片资源 key
+   * @returns 下载结果（本地路径和 base64 编码），失败返回 null
+   */
+  async downloadImage(msgId, imageKey) {
+    const tempDir = this.config.file.temp_dir || "";
+    return downloadImage(this.client, msgId, imageKey, tempDir);
+  }
+  /**
+   * 下载消息中的文件到本地临时目录。
+   *
+   * @param msgId - 消息 ID
+   * @param fileKey - 文件资源 key
+   * @param fileName - 原始文件名
+   * @returns 下载结果（本地路径、文件名、大小），失败返回 null
+   */
+  async downloadFile(msgId, fileKey, fileName) {
+    const tempDir = this.config.file.temp_dir || "";
+    return downloadFile(this.client, msgId, fileKey, fileName, tempDir);
+  }
+  /**
+   * 创建飞书云文档。
+   *
+   * 当回复内容超长时（超出飞书消息长度限制），将内容写入飞书云文档
+   * 并返回文档链接。
+   *
+   * @param title - 文档标题
+   * @param content - 文档正文内容
+   * @returns 飞书云文档 URL，创建失败返回空字符串
+   */
+  async createDocument(title, content) {
+    return createOverflowDocument(this.client, title, content);
+  }
+};
+
+// src/adapters/feishu/index.ts
+registerAdapter("feishu", FeishuAdapter);
+
+// src/adapters/wechat/index.ts
+init_registry();
+
+// src/adapters/wechat/adapter.ts
+init_logger();
+var WeChatAdapter = class {
+  platform = "wechat";
+  constructor(_config) {
+    logger.warn("\u5FAE\u4FE1\u9002\u914D\u5668\u5C1A\u672A\u5B9E\u73B0");
+  }
+  /** 建立 WebSocket/长连接 */
+  async connect() {
+    throw new Error("\u5FAE\u4FE1\u9002\u914D\u5668\u5C1A\u672A\u5B9E\u73B0");
+  }
+  /** 断开连接 */
+  async disconnect() {
+  }
+  /** 注册消息回调 */
+  onMessage(_handler) {
+    throw new Error("\u5FAE\u4FE1\u9002\u914D\u5668\u5C1A\u672A\u5B9E\u73B0");
+  }
+  /** 发送文本消息 */
+  async sendText(_chatId, _text) {
+    throw new Error("\u672A\u5B9E\u73B0");
+  }
+  /** 回复文本消息 */
+  async replyText(_msgId, _text) {
+    throw new Error("\u672A\u5B9E\u73B0");
+  }
+  /** 发送卡片消息 */
+  async sendCard(_chatId, _card) {
+    throw new Error("\u672A\u5B9E\u73B0");
+  }
+  /** 回复卡片消息 */
+  async replyCard(_msgId, _card) {
+    throw new Error("\u672A\u5B9E\u73B0");
+  }
+  /** 创建流式控制器 */
+  createStreamController(_title, _flushMs) {
+    throw new Error("\u672A\u5B9E\u73B0");
+  }
+  /** 设置消息反应（表情/状态） */
+  async setReaction(_msgId, _phase) {
+  }
+};
+
+// src/adapters/wechat/index.ts
+registerAdapter("wechat", WeChatAdapter);
+
+// src/index.ts
+var __dirname$1 = dirname(fileURLToPath(import.meta.url));
+var PKG = JSON.parse(readFileSync(resolve(__dirname$1, "../package.json"), "utf8"));
+var program = new Command();
+program.name("claude-im").description("\u901A\u8FC7 IM \u4E0E Claude Code \u5BF9\u8BDD\u3002WebSocket \u957F\u8FDE\u63A5\uFF0C\u6D41\u5F0F\u5361\u7247\u8F93\u51FA\u3002").version(PKG.version).option("-p, --profile <name>", "\u4F7F\u7528\u6307\u5B9A profile\uFF08\u9ED8\u8BA4 default\uFF09", "default").option("-c, --continue", "\u7EE7\u7EED\u4E0A\u6B21\u672A\u5B8C\u6210\u7684\u4F1A\u8BDD").option("-d, --daemon", "\u4EE5\u540E\u53F0\u5B88\u62A4\u8FDB\u7A0B\u6A21\u5F0F\u8FD0\u884C").option("--setup", "\u4EA4\u4E92\u5F0F\u914D\u7F6E\u5F53\u524D profile").option("--new-profile", "\u6DFB\u52A0\u65B0 profile\uFF08\u591A bot \u573A\u666F\uFF09").option("--list-profiles", "\u5217\u51FA\u6240\u6709\u5DF2\u914D\u7F6E\u7684 profile").option("--reset-session", "\u6E05\u9664\u6307\u5B9A profile \u7684\u4F1A\u8BDD\u72B6\u6001").option("--ps", "\u5217\u51FA\u6240\u6709\u8FD0\u884C\u4E2D\u7684\u8FDB\u7A0B").option("--kill <target>", "\u6309 profile \u540D\u79F0\u7EC8\u6B62\u5BF9\u5E94\u8FDB\u7A0B").option("--kill-all", "\u7EC8\u6B62\u6240\u6709\u6B63\u5728\u8FD0\u884C\u7684\u8FDB\u7A0B").action(async (opts) => {
+  if (opts.ps) {
+    const { listLocks: listLocks2 } = await Promise.resolve().then(() => (init_lock(), lock_exports));
+    const locks = listLocks2();
+    if (locks.length === 0) {
+      console.log("\u6CA1\u6709\u8FD0\u884C\u4E2D\u7684\u8FDB\u7A0B");
+    } else {
+      for (const l of locks) {
+        console.log(`  [${l.profile}] PID ${l.pid}  cwd: ${l.cwd}  since: ${l.startedAt}`);
+      }
+    }
+    return;
+  }
+  if (opts.kill) {
+    const { killByLock: killByLock2 } = await Promise.resolve().then(() => (init_lock(), lock_exports));
+    const ok = killByLock2(opts.kill);
+    console.log(ok ? `\u5DF2\u7EC8\u6B62 profile "${opts.kill}"` : `\u672A\u627E\u5230 "${opts.kill}"`);
+    return;
+  }
+  if (opts.killAll) {
+    const { listLocks: listLocks2, killByLock: killByLock2 } = await Promise.resolve().then(() => (init_lock(), lock_exports));
+    for (const l of listLocks2()) {
+      killByLock2(l.profile);
+      console.log(`\u5DF2\u7EC8\u6B62: ${l.profile} (PID ${l.pid})`);
+    }
+    return;
+  }
+  if (opts.setup) {
+    const { runSetup: runSetup2 } = await Promise.resolve().then(() => (init_interactive(), interactive_exports));
+    await runSetup2(opts.profile);
+    return;
+  }
+  if (opts.newProfile) {
+    const { runNewProfile: runNewProfile2 } = await Promise.resolve().then(() => (init_interactive(), interactive_exports));
+    await runNewProfile2();
+    return;
+  }
+  if (opts.listProfiles) {
+    const { resolveConfig: resolveConfig3 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    try {
+      const cfg2 = resolveConfig3(opts.profile, process.cwd());
+      console.log(`Profile: ${cfg2.profile}  platform: ${cfg2.platform}  source: ${cfg2.platform_secret_source}`);
+    } catch (e) {
+      console.log(`\u65E0\u6CD5\u52A0\u8F7D\u914D\u7F6E: ${e.message}`);
+    }
+    return;
+  }
+  if (opts.resetSession) {
+    const { clearSession: clearSession2 } = await Promise.resolve().then(() => (init_session(), session_exports));
+    clearSession2(opts.profile);
+    console.log(`\u5DF2\u6E05\u9664 profile "${opts.profile}" \u7684\u4F1A\u8BDD`);
+    return;
+  }
+  const { resolveConfig: resolveConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { startApp: startApp2 } = await Promise.resolve().then(() => (init_lifecycle(), lifecycle_exports));
+  const cwd = process.cwd();
+  let cfg;
+  try {
+    cfg = resolveConfig2(opts.profile, cwd);
+  } catch (e) {
+    if (e.message.includes("\u672A\u627E\u5230")) {
+      console.log(`
+  \u672A\u914D\u7F6E profile "${opts.profile}" \u7684 IM \u901A\u9053\u5BC6\u94A5\uFF0C\u5373\u5C06\u8FDB\u5165\u914D\u7F6E\u5411\u5BFC...
+`);
+      const { runSetup: runSetup2 } = await Promise.resolve().then(() => (init_interactive(), interactive_exports));
+      await runSetup2(opts.profile);
+      cfg = resolveConfig2(opts.profile, cwd);
+    } else {
+      throw e;
+    }
+  }
+  console.log(`claude-im v${PKG.version}  profile: ${cfg.profile}  platform: ${cfg.platform}  cwd: ${cwd}`);
+  process.title = `claude-im [${cfg.profile}]`;
+  await startApp2(cfg, { resume: opts.continue, daemon: opts.daemon });
+});
+program.parse();