@cydm/pie 2.7.12 → 2.7.14

package/dist/builtin/extensions/im-forward/index.js

@@ -0,0 +1,980 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  detectImageMime,
+  readImageFormat
+} from "../../../chunks/chunk-F7EBZTZO.js";
+import "../../../chunks/chunk-LZQXQOPJ.js";
+
+// builtin/extensions/im-forward/index.ts
+import { spawn as spawn2 } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+// builtin/extensions/im-forward/lark-cli.ts
+import { spawn } from "node:child_process";
+async function runLarkCli(binary, args, timeoutMs = 3e4, cwd, options = {}) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = (options.spawn ?? spawn)(binary, args, {
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: process.platform !== "win32",
+        ...cwd ? { cwd } : {}
+      });
+    } catch (error) {
+      resolve({ stdout: "", error: `spawn failed: ${error instanceof Error ? error.message : String(error)}` });
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let timedOut = false;
+    let killTimer;
+    let closeTimer;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (killTimer) clearTimeout(killTimer);
+      if (closeTimer) clearTimeout(closeTimer);
+      resolve(result);
+    };
+    const stopTree = (signal) => {
+      try {
+        if (process.platform === "win32" && child.pid) {
+          const killer = spawn("taskkill", ["/F", "/T", "/PID", String(child.pid)], { stdio: "ignore" });
+          killer.on("error", () => {
+            child.kill(signal);
+          });
+          killer.unref();
+        } else if (child.pid) process.kill(-child.pid, signal);
+        else child.kill(signal);
+      } catch {
+        try {
+          child.kill(signal);
+        } catch {
+        }
+      }
+    };
+    const timeoutResult = () => ({ stdout, error: `timeout after ${timeoutMs}ms` });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      stopTree("SIGTERM");
+      if (settled) return;
+      killTimer = setTimeout(() => {
+        stopTree("SIGKILL");
+        if (settled) return;
+        closeTimer = setTimeout(() => {
+          child.stdout?.destroy();
+          child.stderr?.destroy();
+          finish(timeoutResult());
+        }, options.closeGraceMs ?? 1e3);
+      }, options.killGraceMs ?? 1e3);
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      if (!settled) stdout += chunk.toString("utf8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (!settled) stderr += chunk.toString("utf8");
+    });
+    child.on("error", (error) => finish({ stdout, error: `spawn error: ${error.message}` }));
+    child.on("close", (code) => {
+      if (timedOut) finish(timeoutResult());
+      else if (code === 0 && stdout.trim()) finish({ stdout });
+      else finish({ stdout, error: `exit ${code}${stderr ? `: ${stderr.slice(-300).trim()}` : ""}` });
+    });
+  });
+}
+
+// builtin/extensions/im-forward/index.ts
+var CLI_CALL_TIMEOUT_MS = 3e4;
+var ROUTE_TTL_MS = 24 * 60 * 60 * 1e3;
+var MAX_ROUTES = 500;
+var MAX_SEEN_EVENTS = 1e3;
+var MAX_BODY_CHARS = 4e3;
+var REPLY_CHAIN_MAX_DEPTH = 5;
+var MAX_INPUT_HEADER_CHARS = 200;
+var RESTART_BACKOFF_MIN_MS = 5e3;
+var RESTART_BACKOFF_MAX_MS = 6e4;
+var SEND_FAILURE_NOTIFY_THROTTLE_MS = 5 * 60 * 1e3;
+var MAX_INBOUND_RETRIES = 3;
+var DEFAULT_INBOUND_RETRY_BACKOFF_MS = 5e3;
+var MAX_PENDING_IM_INPUTS = 50;
+var PENDING_IM_INPUT_TTL_MS = 60 * 60 * 1e3;
+var IM_INPUT_FALLBACK_CAPTION = "\u8BF7\u67E5\u770B\u8FD9\u4E9B\u56FE\u7247\u5E76\u5904\u7406\u3002";
+var IM_INPUT_PREFIX = "[Feishu]";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readConfigLayer(filePath) {
+  if (!fs.existsSync(filePath)) return { config: {} };
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    if (!isRecord(parsed)) return { config: {}, problem: `${filePath}: root is not an object` };
+    return { config: parsed };
+  } catch (error) {
+    return { config: {}, problem: `${filePath}: ${error instanceof Error ? error.message : String(error)}` };
+  }
+}
+function resolveImForwardConfig(cwd, configDir) {
+  const merged = {};
+  const problems = [];
+  let anyLayer = false;
+  for (const layer of [path.join(configDir, "im-forward.json"), path.join(cwd, ".pie", "im-forward.json")]) {
+    if (fs.existsSync(layer)) anyLayer = true;
+    const { config, problem } = readConfigLayer(layer);
+    if (problem) problems.push(problem);
+    Object.assign(merged, config);
+  }
+  if (!anyLayer) return { config: null, problems };
+  const rawChatId = merged.chatId ?? merged.receiveId;
+  const chatId = typeof rawChatId === "string" ? rawChatId.trim() : "";
+  if (!chatId) {
+    if (merged.enabled === true) problems.push('im-forward: "enabled": true requires "chatId" (oc_...)');
+    return { config: null, problems };
+  }
+  if (!chatId.startsWith("oc_")) problems.push(`im-forward: chatId "${chatId}" does not look like a chat id (oc_...)`);
+  const allowUsers = Array.isArray(merged.allowUsers) ? merged.allowUsers.filter((id) => typeof id === "string" && id.trim().length > 0) : void 0;
+  const larkCli = typeof merged.larkCli === "string" && merged.larkCli.trim() ? merged.larkCli.trim() : void 0;
+  const retryBackoffRaw = typeof merged.retryBackoffMs === "number" && Number.isFinite(merged.retryBackoffMs) ? merged.retryBackoffMs : NaN;
+  const retryBackoffMs = Number.isNaN(retryBackoffRaw) ? void 0 : Math.min(6e4, Math.max(20, Math.round(retryBackoffRaw)));
+  return { config: { enabled: merged.enabled === true, chatId, allowUsers: allowUsers?.length ? allowUsers : void 0, larkCli, retryBackoffMs }, problems };
+}
+function readLiveEnabled(cwd, configDir, cache) {
+  const layers = [path.join(configDir, "im-forward.json"), path.join(cwd, ".pie", "im-forward.json")];
+  let enabled = false;
+  let present = false;
+  for (const layer of layers) {
+    let mtime = 0;
+    try {
+      mtime = fs.statSync(layer).mtimeMs;
+    } catch {
+      continue;
+    }
+    present = true;
+    if (cache && cache.path === layer && cache.mtime === mtime) {
+      enabled = cache.enabled ?? false;
+      continue;
+    }
+    const raw = readConfigLayer(layer).config;
+    enabled = raw.enabled === true;
+    if (cache) {
+      cache.path = layer;
+      cache.mtime = mtime;
+      cache.enabled = enabled;
+    }
+  }
+  return present ? enabled : false;
+}
+function assistantForwardText(message) {
+  if (message?.role !== "assistant" || !Array.isArray(message.content)) return "";
+  let text = "";
+  let hasToolCalls = false;
+  for (const block of message.content) {
+    if (!isRecord(block)) continue;
+    if (block.type === "text" && typeof block.text === "string") text += block.text;
+    else if (block.type === "toolCall") hasToolCalls = true;
+  }
+  if (hasToolCalls) return "";
+  return text.trim();
+}
+function sessionLabel(sessionId, sessionName) {
+  if (sessionName && sessionName.trim()) return sessionName.trim();
+  return sessionId.length > 8 ? sessionId.slice(0, 8) : sessionId;
+}
+function inputHeaderLine(userInput) {
+  if (!userInput) return null;
+  const collapsed = userInput.replace(/\s+/g, " ").trim();
+  if (!collapsed) return null;
+  const clipped = collapsed.length > MAX_INPUT_HEADER_CHARS ? `${collapsed.slice(0, MAX_INPUT_HEADER_CHARS)}\u2026` : collapsed;
+  return `[UserInput: ${clipped}]`;
+}
+function composeForwardBody(sessionId, sessionName, userInput, text) {
+  const lines = [`[Pie][Session: ${sessionLabel(sessionId, sessionName)}]`];
+  const input = inputHeaderLine(userInput);
+  if (input) lines.push(input);
+  lines.push("");
+  lines.push(text);
+  return lines.join("\n");
+}
+function failureReason(message) {
+  const detail = message.errorMessage?.trim();
+  if (detail) {
+    const collapsed = detail.replace(/\s+/g, " ");
+    return collapsed.length > 400 ? `${collapsed.slice(0, 400)}\u2026` : collapsed;
+  }
+  switch (message.stopReason) {
+    case "aborted":
+      return "turn aborted";
+    case "error":
+      return "model/provider error (no detail)";
+    case "length":
+      return "output length limit reached";
+    default:
+      return message.stopReason ? `stop reason: ${message.stopReason}` : "unknown failure";
+  }
+}
+function parseLarkCliEnvelope(stdout) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return { errorText: `unparseable lark-cli output: ${stdout.slice(0, 200)}` };
+  }
+  if (!isRecord(parsed)) return { errorText: "lark-cli output is not an object" };
+  if (parsed.ok === true && isRecord(parsed.data)) return { ok: true, data: parsed.data };
+  if (parsed.code === 0 && isRecord(parsed.data)) return { ok: true, data: parsed.data };
+  if (parsed.ok === false) {
+    const error = isRecord(parsed.error) ? JSON.stringify(parsed.error) : "unknown";
+    return { ok: false, errorText: `lark-cli error: ${error}` };
+  }
+  if (typeof parsed.code === "number" && parsed.code !== 0) {
+    return { ok: false, errorText: `lark-cli error code ${String(parsed.code)}: ${String(parsed.msg ?? "unknown")}` };
+  }
+  return { errorText: "lark-cli output missing ok field" };
+}
+function extractInboundText(content) {
+  if (typeof content !== "string") return "";
+  const trimmed = content.trim();
+  if (!trimmed) return "";
+  if (trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (isRecord(parsed) && typeof parsed.text === "string" && Object.keys(parsed).length === 1) {
+        return parsed.text.trim();
+      }
+    } catch {
+    }
+  }
+  return trimmed;
+}
+function hashText(input) {
+  let hash = 0;
+  for (let i = 0; i < input.length; i++) {
+    hash = hash * 31 + input.charCodeAt(i) | 0;
+  }
+  return Math.abs(hash).toString(36);
+}
+function parseInboundLine(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  return isRecord(parsed) ? parsed : null;
+}
+function extractImageKeys(content) {
+  if (typeof content !== "string") return [];
+  return [...new Set(Array.from(content.matchAll(/\[Image:\s*(img_[A-Za-z0-9_-]+)\]/g), (match) => match[1]))];
+}
+function extractImageKey(content) {
+  return extractImageKeys(content)[0] ?? null;
+}
+function imageExtensionFromKey(imageKey) {
+  if (imageKey.includes(".gif")) return ".gif";
+  if (/\.jpe?g/i.test(imageKey)) return ".jpg";
+  return ".png";
+}
+function resolveLarkBinary(explicit) {
+  if (explicit) {
+    try {
+      fs.accessSync(explicit, fs.constants.X_OK);
+      return explicit;
+    } catch {
+      return null;
+    }
+  }
+  const suffixes = process.platform === "win32" ? ["lark-cli.exe", "lark-cli.cmd", "lark-cli"] : ["lark-cli"];
+  for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
+    if (!dir) continue;
+    for (const suffix of suffixes) {
+      const candidate = path.join(dir, suffix);
+      try {
+        fs.accessSync(candidate, fs.constants.X_OK);
+        return candidate;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function imForward(ctx) {
+  if (!ctx.hasUI) return;
+  const configDir = resolveConfigDir();
+  const { config, problems } = resolveImForwardConfig(ctx.cwd, configDir);
+  for (const problem of problems) ctx.log(`im-forward: ${problem}`);
+  if (!config) return;
+  const cfg = config;
+  const resolvedBinary = resolveLarkBinary(cfg.larkCli);
+  if (!resolvedBinary) {
+    const message = 'im-forward: lark-cli not found on PATH. Install it (npm i -g @larksuite/cli) or set "larkCli" in ~/.pie/im-forward.json.';
+    ctx.log(message);
+    ctx.ui.notify(message, "warning");
+    return;
+  }
+  const larkBinary = resolvedBinary;
+  const enabledCache = {};
+  let forwardingEnabled = cfg.enabled === true;
+  function isForwardingEnabled() {
+    const live = readLiveEnabled(ctx.cwd, configDir, enabledCache);
+    if (live !== forwardingEnabled) {
+      forwardingEnabled = live;
+      updateFooterTag();
+    }
+    return forwardingEnabled;
+  }
+  const STATUS_KEY = "im-forward";
+  function updateFooterTag() {
+    ctx.ui.setStatus?.(STATUS_KEY, forwardingEnabled ? "[IM]" : void 0);
+  }
+  function writeEnabledToConfig(next) {
+    const userLayer = path.join(configDir, "im-forward.json");
+    const projectLayer = path.join(ctx.cwd, ".pie", "im-forward.json");
+    let target = userLayer;
+    try {
+      const projectParsed = JSON.parse(fs.readFileSync(projectLayer, "utf8"));
+      if (isRecord(projectParsed) && "enabled" in projectParsed) target = projectLayer;
+    } catch {
+    }
+    let parsed = {};
+    try {
+      parsed = JSON.parse(fs.readFileSync(target, "utf8"));
+      if (!isRecord(parsed)) parsed = {};
+    } catch {
+    }
+    parsed.enabled = next;
+    try {
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.writeFileSync(target, `${JSON.stringify(parsed, null, "	")}
+`);
+    } catch (error) {
+      ctx.log(`im-forward: failed to persist enabled=${next}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  let inputEpoch = 0;
+  function toggleForwarding() {
+    inputEpoch++;
+    isForwardingEnabled();
+    forwardingEnabled = !forwardingEnabled;
+    writeEnabledToConfig(forwardingEnabled);
+    enabledCache.enabled = forwardingEnabled;
+    updateFooterTag();
+    if (forwardingEnabled) {
+      ctx.log("im-forward: enabled");
+      ctx.ui.notify("IM forwarding enabled", "info");
+    } else {
+      ctx.log("im-forward: disabled");
+      ctx.ui.notify("IM forwarding disabled", "info");
+    }
+  }
+  updateFooterTag();
+  ctx.registerShortcut("ctrl+i", {
+    description: "Toggle IM forwarding (Feishu)",
+    handler: toggleForwarding
+  });
+  let currentSessionId = null;
+  const pendingInputs = [];
+  const replyAnchor = /* @__PURE__ */ new Map();
+  const routes = /* @__PURE__ */ new Map();
+  const threadRoutes = /* @__PURE__ */ new Map();
+  const seenEventIds = /* @__PURE__ */ new Map();
+  const retryTimers = /* @__PURE__ */ new Map();
+  let forwardCounter = 0;
+  let anchorFallbacks = 0;
+  let lastSendError;
+  let lastSendErrorAt = 0;
+  let lastSendFailureNotifyAt = 0;
+  function notifySendFailure(error) {
+    lastSendError = error;
+    lastSendErrorAt = Date.now();
+    ctx.log(`im-forward: ${error}`);
+    if (Date.now() - lastSendFailureNotifyAt > SEND_FAILURE_NOTIFY_THROTTLE_MS) {
+      lastSendFailureNotifyAt = Date.now();
+      ctx.ui.notify(`im-forward: send failed \u2014 ${error}`, "warning");
+    }
+  }
+  function pruneState(now = Date.now()) {
+    for (const [id, route] of routes) {
+      if (now - route.sentAt > ROUTE_TTL_MS) {
+        routes.delete(id);
+        if (route.threadId) threadRoutes.delete(route.threadId);
+        const anchor = replyAnchor.get(route.sessionId);
+        if (anchor?.messageId === id) replyAnchor.delete(route.sessionId);
+      }
+    }
+    while (routes.size > MAX_ROUTES) {
+      let oldest;
+      for (const route of routes.values()) {
+        if (!oldest || route.sentAt < oldest.sentAt) oldest = route;
+      }
+      if (!oldest) break;
+      routes.delete(oldest.larkMessageId);
+      if (oldest.threadId) threadRoutes.delete(oldest.threadId);
+    }
+    const cutoff = now - PENDING_IM_INPUT_TTL_MS;
+    while (pendingInputs.length && pendingInputs[0].at <= cutoff) pendingInputs.shift();
+    while (pendingInputs.length > MAX_PENDING_IM_INPUTS) pendingInputs.shift();
+    for (const [eventId, at] of seenEventIds) {
+      if (now - at > ROUTE_TTL_MS) seenEventIds.delete(eventId);
+    }
+    if (seenEventIds.size > MAX_SEEN_EVENTS) {
+      const excess = seenEventIds.size - MAX_SEEN_EVENTS;
+      let removed = 0;
+      for (const eventId of seenEventIds.keys()) {
+        seenEventIds.delete(eventId);
+        if (++removed >= excess) break;
+      }
+    }
+  }
+  function resolveOutboundAttribution(sessionId) {
+    const messages = ctx.getMessages?.() ?? [];
+    let lastUserText;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const message = messages[i];
+      if (!isRecord(message) || message.role !== "user") continue;
+      const joined = (typeof message.content === "string" ? message.content : Array.isArray(message.content) ? message.content.map((block) => isRecord(block) && typeof block.text === "string" ? block.text : "").join("") : "").trim();
+      if (joined) {
+        lastUserText = joined;
+        break;
+      }
+    }
+    if (lastUserText === void 0) return void 0;
+    for (let j = 0; j < pendingInputs.length; j++) {
+      const pending = pendingInputs[j];
+      if (pending.sessionId !== sessionId) continue;
+      const expected = (pending.larkMessageId ? `${IM_INPUT_PREFIX}
+${pending.caption || IM_INPUT_FALLBACK_CAPTION}` : pending.caption).trim();
+      if (lastUserText === expected) {
+        pendingInputs.splice(j, 1);
+        return { caption: pending.caption || `[Feishu images]`, replyTo: pending.larkMessageId || void 0, threadId: pending.threadId };
+      }
+    }
+    return void 0;
+  }
+  async function acknowledgeMessage(messageId) {
+    const { error } = await runLarkCli(larkBinary, [
+      "im",
+      "reactions",
+      "create",
+      "--as",
+      "bot",
+      "--params",
+      JSON.stringify({ message_id: messageId }),
+      "--data",
+      JSON.stringify({ reaction_type: { emoji_type: "THUMBSUP" } })
+    ]);
+    if (error) ctx.log(`im-forward: acknowledge react failed: ${error}`);
+  }
+  ctx.on("terminal:input", (event) => {
+    const text = event.text?.trim() ?? "";
+    if (text && !text.startsWith(IM_INPUT_PREFIX) && !text.startsWith("/") && !text.startsWith("!!") && !/@\[[^\]]+\]\(file:/.test(text) && currentSessionId) {
+      pendingInputs.push({ sessionId: currentSessionId, caption: text, larkMessageId: "", threadId: null, at: Date.now() });
+      pruneState();
+    }
+    return { action: "continue" };
+  });
+  ctx.on("message:end", (event) => {
+    if (!isForwardingEnabled()) return;
+    const message = event.message;
+    const stop = message.role === "assistant" ? message.stopReason : void 0;
+    if (stop === "aborted" || stop === "error") return;
+    const text = assistantForwardText(message);
+    if (!text) return;
+    const sessionId = currentSessionId;
+    if (!sessionId) return;
+    const sequence = ++forwardCounter;
+    const attribution = resolveOutboundAttribution(sessionId);
+    void forwardToLark(text, sessionId, sequence, attribution?.caption, attribution?.replyTo);
+  });
+  ctx.on("turn:failed", (event) => {
+    if (!isForwardingEnabled()) return;
+    const sessionId = currentSessionId;
+    if (!sessionId) return;
+    const reason = failureReason(event.message ?? {});
+    const sequence = ++forwardCounter;
+    const attribution = resolveOutboundAttribution(sessionId);
+    void forwardToLark(`\u26A0\uFE0F \u4EFB\u52A1\u5931\u8D25\uFF1A${reason}`, sessionId, sequence, attribution?.caption, attribution?.replyTo);
+  });
+  ctx.on("turn:cancelled", (event) => {
+    if (!isForwardingEnabled()) return;
+    const sessionId = currentSessionId;
+    if (!sessionId) return;
+    const sequence = ++forwardCounter;
+    const attribution = resolveOutboundAttribution(sessionId);
+    void forwardToLark(`\u26D4\uFE0F \u4EFB\u52A1\u5DF2\u53D6\u6D88\uFF1A${event.reason}`, sessionId, sequence, attribution?.caption, attribution?.replyTo);
+  });
+  async function forwardToLark(text, sessionId, sequence, userInput, replyTo) {
+    pruneState();
+    const sessionName = ctx.getSessionName?.();
+    const composed = composeForwardBody(sessionId, sessionName, userInput, text);
+    const body = composed.length > MAX_BODY_CHARS ? `${composed.slice(0, MAX_BODY_CHARS)}
+\u2026(truncated)` : composed;
+    const idempotencyKey = `pie-im-forward-${sessionId}-${sequence}-${hashText(composed)}`;
+    let anchor = replyTo ?? replyAnchor.get(sessionId)?.messageId;
+    let args = anchor ? ["im", "+messages-reply", "--as", "bot", "--message-id", anchor, "--text", body, "--idempotency-key", idempotencyKey] : ["im", "+messages-send", "--as", "bot", "--chat-id", cfg.chatId, "--text", body, "--idempotency-key", idempotencyKey];
+    let parsed;
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const { stdout, error } = await runLarkCli(larkBinary, args);
+      if (error) {
+        if (attempt === 0 && anchor) {
+          if (replyAnchor.get(sessionId)?.messageId === anchor) replyAnchor.delete(sessionId);
+          anchorFallbacks++;
+          anchor = void 0;
+          args = ["im", "+messages-send", "--as", "bot", "--chat-id", cfg.chatId, "--text", body, "--idempotency-key", idempotencyKey];
+          ctx.log(`im-forward: reply send failed (${error}); falling back to chat root`);
+          continue;
+        }
+        notifySendFailure(`send failed: ${error}`);
+        return;
+      }
+      parsed = parseLarkCliEnvelope(stdout);
+      if (parsed.ok && parsed.data) break;
+      if (attempt === 0 && anchor) {
+        if (replyAnchor.get(sessionId)?.messageId === anchor) replyAnchor.delete(sessionId);
+        anchor = void 0;
+        args = ["im", "+messages-send", "--as", "bot", "--chat-id", cfg.chatId, "--text", body, "--idempotency-key", idempotencyKey];
+        ctx.log(`im-forward: reply rejected (${parsed.errorText ?? "no data"}); falling back to chat root`);
+        continue;
+      }
+      notifySendFailure(`send rejected: ${parsed.errorText ?? "no data"}`);
+      return;
+    }
+    if (!parsed || !parsed.ok || !parsed.data) return;
+    const messageId = parsed.data.message_id;
+    if (typeof messageId === "string" && messageId) {
+      const threadId = typeof parsed.data.thread_id === "string" ? parsed.data.thread_id : null;
+      const route = { larkMessageId: messageId, threadId, sessionId, sentAt: Date.now() };
+      routes.set(messageId, route);
+      if (threadId) threadRoutes.set(threadId, route);
+      ctx.log(`im-forward: forwarded session=${sessionId} as ${messageId}${threadId ? ` (thread ${threadId})` : ""}`);
+    } else {
+      ctx.log("im-forward: send ok but no message_id in response; reply routing disabled for this message");
+    }
+  }
+  ctx.on("session:changed", (event) => {
+    inputEpoch++;
+    currentSessionId = event.sessionId;
+    if (event.sessionId && !consumer && !terminated) {
+      ctx.log("im-forward: session bound, starting event consumer");
+      spawnConsumer();
+    }
+  });
+  async function handleInboundEvent(event, viaRetry = false) {
+    if (!event) return;
+    if (event.type !== "im.message.receive_v1") return;
+    if (!event.event_id) return;
+    if (!viaRetry && inFlightRetries.has(event.event_id)) return;
+    if (!viaRetry && retryTimers.has(event.event_id)) return;
+    if (!viaRetry && seenEventIds.has(event.event_id)) return;
+    seenEventIds.set(event.event_id, Date.now());
+    pruneState();
+    let scheduledNextRetry = false;
+    const retry = () => {
+      scheduledNextRetry = true;
+      scheduleInboundRetry(event, retryDepth(event.event_id) + 1);
+    };
+    const terminalCleanup = () => {
+      if (!scheduledNextRetry) {
+        retryAttempts.delete(event.event_id);
+        inFlightRetries.delete(event.event_id);
+      }
+    };
+    if (!isForwardingEnabled()) {
+      terminalCleanup();
+      return;
+    }
+    try {
+      await handleInboundEventInner(event, retry);
+    } finally {
+      terminalCleanup();
+    }
+  }
+  async function handleInboundEventInner(event, retry) {
+    if (event.chat_id !== cfg.chatId) return;
+    if (cfg.allowUsers && (!event.sender_id || !cfg.allowUsers.includes(event.sender_id))) return;
+    const messageId = event.message_id ?? event.id;
+    if (!messageId) return;
+    const sessionId = currentSessionId;
+    const epoch = inputEpoch;
+    const scope = ctx.beginUserInput?.(() => !terminated && inputEpoch === epoch && currentSessionId === sessionId && isForwardingEnabled());
+    if (!scope) {
+      retry();
+      return;
+    }
+    try {
+      const meta = await fetchMessageMeta(messageId);
+      if (!meta) {
+        retry();
+        return;
+      }
+      if (!scope.isCurrent()) return;
+      const route = await resolveRouteForInbound(messageId, meta);
+      if (!route) {
+        const resolution = await routeResolutionOutcome(messageId, meta);
+        if (resolution === "transient") retry();
+        else ctx.log(`im-forward: no route for ${messageId}; ignoring`);
+        return;
+      }
+      if (route.sessionId !== sessionId || !scope.isCurrent()) return;
+      const text = extractInboundText(event.content);
+      const imageKeys = extractImageKeys(event.content);
+      const caption = imageKeys.length ? text.replace(/\[Image:\s*img_[A-Za-z0-9_-]+\]/g, "").trim() : text;
+      if (!caption && !imageKeys.length) return;
+      const submitText = `${IM_INPUT_PREFIX}
+${caption || IM_INPUT_FALLBACK_CAPTION}`;
+      const accepted = imageKeys.length ? await injectImageMessage(messageId, imageKeys, submitText, scope) : await scope.submit(submitText);
+      if (!accepted || !scope.isCurrent()) {
+        if (scope.isCurrent()) {
+          ctx.ui.notify("im-forward: message was not accepted; no input submitted.", "warning");
+          await forwardToLark(`\u26A0\uFE0F \u6D88\u606F\u63A5\u6536\u5931\u8D25\uFF0C\u672A\u63D0\u4EA4\u4EFB\u52A1\u3002${imageKeys.length ? "\u8BF7\u68C0\u67E5\u9644\u4EF6\u540E\u91CD\u8BD5\u3002" : "\u8BF7\u91CD\u8BD5\u3002"}`, route.sessionId, ++forwardCounter, caption, messageId);
+        }
+        return;
+      }
+      replyAnchor.set(route.sessionId, { messageId, at: Date.now() });
+      pendingInputs.push({ sessionId: route.sessionId, caption, larkMessageId: messageId, threadId: route.threadId, at: Date.now() });
+      pruneState();
+      ctx.log(`im-forward: accepted ${messageId} into session ${route.sessionId} (${imageKeys.length} images)`);
+      void acknowledgeMessage(messageId);
+    } finally {
+      scope.dispose();
+    }
+  }
+  const retryAttempts = /* @__PURE__ */ new Map();
+  function retryDepth(eventId) {
+    return eventId ? retryAttempts.get(eventId) ?? 0 : 0;
+  }
+  const inFlightRetries = /* @__PURE__ */ new Set();
+  function scheduleInboundRetry(event, attempt) {
+    if (!event.event_id) return;
+    if (terminated || attempt > MAX_INBOUND_RETRIES) {
+      if (attempt > MAX_INBOUND_RETRIES) {
+        ctx.log(`im-forward: giving up on event ${event.event_id} after ${MAX_INBOUND_RETRIES} retries`);
+        retryAttempts.delete(event.event_id);
+        void forwardToLark(`\u26A0\uFE0F \u6D88\u606F\u63A5\u6536\u5931\u8D25\uFF08\u91CD\u8BD5\u7528\u5C3D\uFF09\u3002\u8BF7\u5728 Pie \u7EC8\u7AEF\u67E5\u770B\u65E5\u5FD7\u3002`, currentSessionId ?? "", ++forwardCounter, void 0, event.message_id ?? event.id);
+      }
+      return;
+    }
+    const backoff = (cfg.retryBackoffMs ?? DEFAULT_INBOUND_RETRY_BACKOFF_MS) * 2 ** (attempt - 1);
+    if (retryTimers.has(event.event_id)) return;
+    retryAttempts.set(event.event_id, attempt);
+    const timer = setTimeout(() => {
+      retryTimers.delete(event.event_id);
+      inFlightRetries.add(event.event_id);
+      void handleInboundEvent(event, true).finally(() => {
+        inFlightRetries.delete(event.event_id);
+      });
+    }, backoff);
+    timer.unref?.();
+    retryTimers.set(event.event_id, { attempt, timer, event });
+    ctx.log(`im-forward: transient inbound failure; retrying ${event.event_id} in ${backoff}ms (attempt ${attempt}/${MAX_INBOUND_RETRIES})`);
+  }
+  ctx.__forceInboundRetriesForTest = () => {
+    for (const [eventId, entry] of retryTimers) {
+      clearTimeout(entry.timer);
+      retryTimers.delete(eventId);
+      void handleInboundEvent({ ...entry.event ?? {} }, true);
+    }
+  };
+  async function routeResolutionOutcome(messageId, meta) {
+    if (!meta.threadId) {
+      if (!meta.replyTo) return "not-ours";
+      let current = meta.replyTo;
+      const visited = /* @__PURE__ */ new Set();
+      for (let depth = 0; depth < REPLY_CHAIN_MAX_DEPTH && current && !visited.has(current); depth++) {
+        visited.add(current);
+        const { stdout: stdout2, error: error2 } = await runLarkCli(larkBinary, ["im", "+messages-mget", "--as", "bot", "--message-ids", current]);
+        if (error2) return "transient";
+        const parsed = parseLarkCliEnvelope(stdout2);
+        if (!parsed.ok || !parsed.data) return "transient";
+        const messages = parsed.data.messages;
+        if (!Array.isArray(messages) || !isRecord(messages[0])) return "transient";
+        const next = messages[0].reply_to;
+        if (typeof next !== "string" || !next) return "not-ours";
+        current = next;
+      }
+      return "not-ours";
+    }
+    const { stdout, error } = await runLarkCli(larkBinary, [
+      "im",
+      "+threads-messages-list",
+      "--as",
+      "bot",
+      "--thread",
+      meta.threadId
+    ]);
+    if (error) return "transient";
+    return parseLarkCliEnvelope(stdout).ok ? "not-ours" : "transient";
+  }
+  async function injectImageMessage(messageId, imageKeys, submitText, scope) {
+    if (imageKeys.length > 10) {
+      ctx.log("im-forward: refusing more than 10 images in one message");
+      return false;
+    }
+    let tempDir;
+    try {
+      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pie-im-forward-"));
+      const files = [];
+      for (const [index, imageKey] of imageKeys.entries()) {
+        if (!scope.isCurrent()) return false;
+        const ext = imageExtensionFromKey(imageKey);
+        const fileName = `image-${index + 1}${ext}`;
+        const { stdout, error } = await runLarkCli(larkBinary, [
+          "im",
+          "+messages-resources-download",
+          "--as",
+          "bot",
+          "--message-id",
+          messageId,
+          "--file-key",
+          imageKey,
+          "--type",
+          "image",
+          "--output",
+          fileName
+        ], CLI_CALL_TIMEOUT_MS, tempDir);
+        if (error || !parseLarkCliEnvelope(stdout).ok) throw new Error(error || "image download rejected");
+        if (!scope.isCurrent()) return false;
+        let target = path.join(tempDir, fileName);
+        if (fs.statSync(target).size > 10 * 1024 * 1024) throw new Error("image exceeds 10 MB inline limit");
+        const detected = readImageFormat(target);
+        if (detected.ext === ".bin") throw new Error("download is not a supported image");
+        if (detected.ext !== ext) {
+          const corrected = path.join(tempDir, `image-${index + 1}${detected.ext}`);
+          fs.renameSync(target, corrected);
+          target = corrected;
+        }
+        files.push({ path: target, displayName: `feishu-image-${index + 1}${detected.ext}` });
+      }
+      return await scope.submit(submitText, files);
+    } catch (error) {
+      ctx.log(`im-forward: image input failed: ${error instanceof Error ? error.message : String(error)}`);
+      return false;
+    } finally {
+      if (tempDir) {
+        try {
+          fs.rmSync(tempDir, { recursive: true, force: true });
+        } catch (error) {
+          ctx.log(`im-forward: temporary image cleanup failed: ${String(error)}`);
+        }
+      }
+    }
+  }
+  async function fetchMessageMeta(messageId) {
+    const { stdout, error } = await runLarkCli(larkBinary, [
+      "im",
+      "+messages-mget",
+      "--as",
+      "bot",
+      "--message-ids",
+      messageId
+    ]);
+    if (error) {
+      ctx.log(`im-forward: mget failed: ${error}`);
+      return null;
+    }
+    const parsed = parseLarkCliEnvelope(stdout);
+    if (!parsed.ok || !parsed.data) return null;
+    const messages = parsed.data.messages;
+    if (!Array.isArray(messages) || !isRecord(messages[0])) return null;
+    const message = messages[0];
+    const threadId = typeof message.thread_id === "string" && message.thread_id ? message.thread_id : null;
+    const replyTo = typeof message.reply_to === "string" && message.reply_to ? message.reply_to : null;
+    return { threadId, replyTo };
+  }
+  async function resolveRouteForInbound(messageId, meta) {
+    if (meta.threadId) {
+      const byThread = threadRoutes.get(meta.threadId);
+      if (byThread) return byThread;
+    }
+    const direct = routes.get(messageId);
+    if (direct) return direct;
+    if (meta.replyTo) {
+      const viaChain = await resolveRouteForReply(meta.replyTo);
+      if (viaChain) return viaChain;
+    }
+    if (meta.threadId) return await resolveRouteByThreadRoot(meta.threadId);
+    return null;
+  }
+  async function resolveRouteByThreadRoot(threadId) {
+    const { stdout, error } = await runLarkCli(larkBinary, [
+      "im",
+      "+threads-messages-list",
+      "--as",
+      "bot",
+      "--thread",
+      threadId
+    ]);
+    if (error) {
+      ctx.log(`im-forward: thread list failed: ${error}`);
+      return null;
+    }
+    const parsed = parseLarkCliEnvelope(stdout);
+    if (!parsed.ok || !parsed.data) return null;
+    const messages = parsed.data.messages;
+    if (!Array.isArray(messages)) return null;
+    for (const message of messages) {
+      if (!isRecord(message)) continue;
+      const id = message.message_id;
+      if (typeof id !== "string") continue;
+      const route = routes.get(id);
+      if (route) {
+        threadRoutes.set(threadId, route);
+        return route;
+      }
+    }
+    return null;
+  }
+  async function resolveRouteForReply(startId) {
+    let current = startId;
+    const visited = /* @__PURE__ */ new Set();
+    for (let depth = 0; depth < REPLY_CHAIN_MAX_DEPTH; depth++) {
+      const direct = routes.get(current);
+      if (direct) return direct;
+      if (visited.has(current)) return null;
+      visited.add(current);
+      const parent = await fetchReplyTo(current);
+      if (!parent) return null;
+      current = parent;
+    }
+    return null;
+  }
+  async function fetchReplyTo(messageId) {
+    const { stdout, error } = await runLarkCli(larkBinary, [
+      "im",
+      "+messages-mget",
+      "--as",
+      "bot",
+      "--message-ids",
+      messageId
+    ]);
+    if (error) {
+      ctx.log(`im-forward: mget failed: ${error}`);
+      return null;
+    }
+    const parsed = parseLarkCliEnvelope(stdout);
+    if (!parsed.ok || !parsed.data) return null;
+    const messages = parsed.data.messages;
+    if (!Array.isArray(messages) || !isRecord(messages[0])) return null;
+    const replyTo = messages[0].reply_to;
+    return typeof replyTo === "string" && replyTo ? replyTo : null;
+  }
+  let consumer = null;
+  let consumerReady = false;
+  let consumerRestarts = 0;
+  let consumerLastExit;
+  let terminated = false;
+  let restartTimer;
+  let notifiedUnreadyExit = false;
+  function spawnConsumer() {
+    if (terminated) return;
+    const child = spawn2(larkBinary, ["event", "consume", "im.message.receive_v1", "--as", "bot"], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const state = { child, stopped: false };
+    consumer = state;
+    consumerReady = false;
+    let buffer = "";
+    child.stdin?.on("error", () => void 0);
+    child.stdout?.on("data", (chunk) => {
+      buffer += chunk.toString("utf8");
+      let newline = buffer.indexOf("\n");
+      while (newline >= 0) {
+        const line = buffer.slice(0, newline).trim();
+        buffer = buffer.slice(newline + 1);
+        if (line) void handleInboundEvent(parseInboundLine(line)).catch((error) => {
+          ctx.log(`im-forward: inbound handling failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+        newline = buffer.indexOf("\n");
+      }
+    });
+    const stderrTail = [];
+    child.stderr?.on("data", (chunk) => {
+      for (const raw of chunk.toString("utf8").split("\n")) {
+        const line = raw.trim();
+        if (!line) continue;
+        stderrTail.push(line);
+        if (stderrTail.length > 20) stderrTail.shift();
+        if (line.startsWith("[event] ready")) {
+          consumerReady = true;
+          consumerRestarts = 0;
+          ctx.log("im-forward: event consumer ready");
+        }
+      }
+    });
+    child.on("exit", (code, signal) => {
+      if (state.stopped || terminated) return;
+      consumerLastExit = `code=${code} signal=${signal}`;
+      consumerRestarts += 1;
+      ctx.log(`im-forward: consumer exited (${consumerLastExit})`);
+      if (!consumerReady && !notifiedUnreadyExit) {
+        notifiedUnreadyExit = true;
+        ctx.ui.notify(
+          `im-forward: lark-cli event consumer exited before becoming ready (${consumerLastExit}). Check lark-cli config/auth; retries continue in the background. ${stderrTail.slice(-3).join(" | ")}`,
+          "warning"
+        );
+      }
+      const backoff = Math.min(RESTART_BACKOFF_MIN_MS * 2 ** Math.min(consumerRestarts, 4), RESTART_BACKOFF_MAX_MS);
+      restartTimer = setTimeout(spawnConsumer, backoff);
+      restartTimer.unref?.();
+    });
+  }
+  ctx.registerCleanup?.(() => {
+    inputEpoch++;
+    terminated = true;
+    for (const { timer } of retryTimers.values()) clearTimeout(timer);
+    retryTimers.clear();
+    retryAttempts.clear();
+    inFlightRetries.clear();
+    if (restartTimer) clearTimeout(restartTimer);
+    if (consumer && !consumer.child.killed) {
+      consumer.stopped = true;
+      consumer.child.kill("SIGTERM");
+    }
+  });
+  ctx.registerCommand({
+    name: "im-forward",
+    description: "IM forwarding status (Feishu via lark-cli)",
+    handler: (commandCtx) => {
+      const lines = [
+        "IM forwarding (Feishu via lark-cli)",
+        `- chat: ${cfg.chatId}`,
+        `- allowUsers: ${cfg.allowUsers?.join(", ") ?? "(anyone in chat)"}`,
+        `- binary: ${larkBinary}`,
+        `- consumer: ${terminated ? "stopped" : consumer ? consumerReady ? "ready" : "starting" : "idle (waits for first session)"}${consumerLastExit ? ` (last exit: ${consumerLastExit})` : ""}, restarts=${consumerRestarts}`,
+        `- routes: ${routes.size} forwarded message(s) routable (${threadRoutes.size} thread(s), ${replyAnchor.size} anchor(s))`,
+        `- current session: ${currentSessionId ?? "(none)"}`
+      ];
+      if (lastSendError) lines.push(`- last send error: ${lastSendError} (at ${new Date(lastSendErrorAt).toISOString()})`);
+      if (anchorFallbacks) lines.push(`- anchor fallbacks to chat root: ${anchorFallbacks}`);
+      if (pendingInputs.length) lines.push(`- pending turn attributions: ${pendingInputs.length}`);
+      if (retryAttempts.size) lines.push(`- inbound retries pending: ${retryTimers.size} (attempts so far: ${Math.max(...retryAttempts.values())})`);
+      commandCtx.ui.notify(lines.join("\n"), "info");
+    }
+  });
+  function resolveConfigDir() {
+    const envDir = process.env.PIE_CODING_AGENT_DIR?.trim();
+    if (envDir) {
+      if (envDir === "~") return os.homedir();
+      if (envDir.startsWith("~/")) return os.homedir() + envDir.slice(1);
+      return envDir;
+    }
+    return path.join(os.homedir(), ".pie");
+  }
+}
+export {
+  assistantForwardText,
+  composeForwardBody,
+  imForward as default,
+  detectImageMime,
+  extractImageKey,
+  extractImageKeys,
+  extractInboundText,
+  failureReason,
+  inputHeaderLine,
+  parseLarkCliEnvelope,
+  readLiveEnabled,
+  resolveImForwardConfig,
+  sessionLabel
+};