@cydm/pie 2.7.13 → 2.7.15

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

@@ -0,0 +1,2278 @@
+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/config.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { randomUUID } from "node:crypto";
+
+// builtin/extensions/im-forward/helpers.ts
+var MAX_INPUT_HEADER_CHARS = 200;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+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 escapeMarkdownInline(text) {
+  return text.replace(/\\/g, "\\\\").replace(/`/g, "\\`");
+}
+function inputHeaderLine(userInput) {
+  if (!userInput) return null;
+  const collapsed = userInput.replace(/\s+/g, " ").trim();
+  if (!collapsed) return null;
+  let escaped = escapeMarkdownInline(collapsed);
+  if (escaped.length > MAX_INPUT_HEADER_CHARS) {
+    let clipped = stripDanglingHighSurrogate(escaped.slice(0, MAX_INPUT_HEADER_CHARS));
+    if (/(?:^|[^\\])(?:\\\\)*\\$/.test(clipped)) clipped = clipped.slice(0, -1);
+    escaped = clipped + "\u2026";
+  }
+  return `> [UserInput] ${escaped}`;
+}
+function composeForwardBody(sessionId, sessionName, userInput, text) {
+  const lines = [`**[Pie] \xB7 ${sessionLabel(sessionId, sessionName)}**`];
+  const input = inputHeaderLine(userInput);
+  if (input) lines.push(input);
+  lines.push("");
+  lines.push(text);
+  return lines.join("\n");
+}
+var FEISHU_POST_REQUEST_LIMIT_BYTES = 3e4;
+var MAX_BODY_BYTES = FEISHU_POST_REQUEST_LIMIT_BYTES - 6e3;
+var MAX_BODY_UTF16_CHARS = 3e4;
+var POST_PARAGRAPH_OVERHEAD_BYTES = 150;
+var POST_LINE_OVERHEAD_BYTES = 12;
+var POST_ENVELOPE_OVERHEAD_BYTES = 256;
+var textEncoder = new TextEncoder();
+function utf8Bytes(text) {
+  return textEncoder.encode(text).length;
+}
+function utf16LengthBudget(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return stripDanglingHighSurrogate(text.slice(0, maxChars));
+}
+function stripDanglingHighSurrogate(text) {
+  return /[\uD800-\uDBFF]$/.test(text) ? text.slice(0, -1) : text;
+}
+function estimatePostRequestBytes(markdown) {
+  const escaped = utf8Bytes(JSON.stringify(markdown).slice(1, -1));
+  const paragraphs = markdown.split(/\n{2,}/).filter((part) => part.trim().length > 0).length;
+  const lines = markdown.length === 0 ? 0 : markdown.split("\n").length;
+  return escaped + paragraphs * POST_PARAGRAPH_OVERHEAD_BYTES + lines * POST_LINE_OVERHEAD_BYTES + POST_ENVELOPE_OVERHEAD_BYTES;
+}
+function truncateMarkdown(text, maxBytes = MAX_BODY_BYTES) {
+  const bounded = utf16LengthBudget(text, MAX_BODY_UTF16_CHARS);
+  const charCapped = bounded !== text;
+  if (!charCapped && estimatePostRequestBytes(text) <= maxBytes) return text;
+  const suffix = "\n\n\u2026(truncated)";
+  const suffixCost = estimatePostRequestBytes(suffix) - POST_ENVELOPE_OVERHEAD_BYTES;
+  const budget = charCapped ? Math.min(maxBytes - suffixCost, bounded.length - suffix.length) : maxBytes - suffixCost;
+  const snapForward = (candidate) => {
+    const newline = candidate.lastIndexOf("\n");
+    if (newline < Math.floor(candidate.length * 0.85)) return candidate;
+    const snapped = candidate.slice(0, newline);
+    return snapped.trim().length > 0 ? snapped : candidate;
+  };
+  const fit = (limit) => {
+    let lo = 0;
+    let hi = text.length;
+    while (lo < hi) {
+      const mid = Math.ceil((lo + hi) / 2);
+      if (estimatePostRequestBytes(text.slice(0, mid)) <= limit) lo = mid;
+      else hi = mid - 1;
+    }
+    return text.slice(0, lo);
+  };
+  let cut = snapForward(stripDanglingHighSurrogate(fit(Math.max(0, budget))));
+  if ((cut.match(/```/g)?.length ?? 0) % 2 === 1) {
+    const closeCost = estimatePostRequestBytes("\n```") - POST_ENVELOPE_OVERHEAD_BYTES;
+    const refit = snapForward(stripDanglingHighSurrogate(fit(Math.max(0, budget - closeCost))));
+    cut = (refit.match(/```/g)?.length ?? 0) % 2 === 1 ? refit + "\n```" : refit;
+  }
+  return cut + suffix;
+}
+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";
+  }
+}
+
+// builtin/extensions/im-forward/config.ts
+function resolveConfigDir() {
+  const value = process.env.PIE_CODING_AGENT_DIR?.trim();
+  return value === "~" ? os.homedir() : value?.startsWith("~/") ? os.homedir() + value.slice(1) : value || path.join(os.homedir(), ".pie");
+}
+function configPaths(cwd, dir) {
+  return [.../* @__PURE__ */ new Set([path.join(dir, "im-forward.json"), path.join(cwd, ".pie", "im-forward.json")])];
+}
+var configCache = /* @__PURE__ */ new Map();
+function layerStamp(file) {
+  try {
+    const stat = fs.statSync(file);
+    return `${stat.mtimeMs}:${stat.size}`;
+  } catch {
+    return "-";
+  }
+}
+function cachedResolveConfig(cwd, dir) {
+  const cacheKey = `${cwd}\0${dir}`;
+  const stamp = JSON.stringify(configPaths(cwd, dir).map(layerStamp));
+  const cached = configCache.get(cacheKey);
+  if (cached && cached.stamp === stamp) return cached.result;
+  const result = resolveConfig(cwd, dir);
+  configCache.set(cacheKey, { stamp, result });
+  return result;
+}
+function invalidateConfigCache() {
+  configCache.clear();
+}
+function readLayer(file) {
+  let text;
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return {};
+    throw new Error(`Cannot read IM configuration: ${file}`);
+  }
+  try {
+    const value = JSON.parse(text);
+    if (isRecord(value)) return value;
+  } catch {
+  }
+  throw new Error(`Invalid IM configuration: ${file}. Repair this file before setup; it will not be overwritten.`);
+}
+function resolveConfig(cwd, dir) {
+  try {
+    let present = false;
+    let merged = {};
+    const providers = {};
+    for (const file of configPaths(cwd, dir)) {
+      const layer = readLayer(file);
+      if (Object.keys(layer).length) present = true;
+      const legacy = ["chatId", "receiveId", "openId", "larkCli", "allowUsers"].some((key) => key in layer);
+      if (legacy && !layer.provider) {
+        const previous = providers.feishu ?? {};
+        providers.feishu = { ...previous, ...Object.fromEntries(["chatId", "openId", "larkCli", "allowUsers"].filter((key) => key in layer).map((key) => [key, layer[key]])), ...layer.receiveId && !layer.chatId ? { chatId: layer.receiveId } : {} };
+        merged.provider = "feishu";
+      }
+      if (isRecord(layer.providers)) {
+        for (const [id, settings] of Object.entries(layer.providers)) if (isRecord(settings)) providers[id] = { ...providers[id], ...settings };
+      }
+      merged = { ...merged, ...layer };
+    }
+    if (!present) return { config: null, problems: [] };
+    if ("provider" in merged && (typeof merged.provider !== "string" || !merged.provider.trim())) throw new Error("Invalid IM provider field. Run setup or repair the configuration; no provider fallback was used.");
+    const provider = typeof merged.provider === "string" ? merged.provider : "feishu";
+    const retry = merged.retryBackoffMs;
+    return { config: { enabled: merged.enabled === true, provider, settings: providers[provider] ?? {}, retryBackoffMs: typeof retry === "number" && Number.isFinite(retry) ? Math.min(6e4, Math.max(20, Math.round(retry))) : void 0 }, problems: [] };
+  } catch (error) {
+    return { config: null, problems: [error.message] };
+  }
+}
+function configurationIdentity(config) {
+  return JSON.stringify([config.provider, config.settings, config.retryBackoffMs]);
+}
+function configSnapshot(cwd, dir) {
+  return JSON.stringify(configPaths(cwd, dir).map((file) => {
+    try {
+      return fs.readFileSync(file, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      throw new Error(`Cannot read IM configuration: ${file}`);
+    }
+  }));
+}
+function saveLocation(cwd, dir) {
+  const files = configPaths(cwd, dir);
+  return fs.existsSync(files[files.length - 1]) ? files[files.length - 1] : files[0];
+}
+function writeConfig(cwd, dir, update, expected) {
+  for (const file of configPaths(cwd, dir)) readLayer(file);
+  if (expected !== void 0 && configSnapshot(cwd, dir) !== expected) throw new Error("IM configuration changed during setup. Please retry.");
+  const target = saveLocation(cwd, dir);
+  const value = readLayer(target);
+  value.enabled = update.enabled;
+  if (update.provider) {
+    value.provider = update.provider;
+    value.providers = { ...isRecord(value.providers) ? value.providers : {}, [update.provider]: update.settings ?? {} };
+  }
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  invalidateConfigCache();
+  const temporary = path.join(path.dirname(target), `.im-forward-${randomUUID()}.tmp`);
+  try {
+    const fd = fs.openSync(temporary, "wx", 384);
+    try {
+      fs.writeFileSync(fd, JSON.stringify(value, null, "	") + "\n");
+      fs.fsyncSync(fd);
+    } finally {
+      fs.closeSync(fd);
+    }
+    fs.renameSync(temporary, target);
+  } finally {
+    try {
+      fs.unlinkSync(temporary);
+    } catch {
+    }
+  }
+}
+function hasConfigLayers(cwd, dir) {
+  return configPaths(cwd, dir).some((file) => fs.existsSync(file));
+}
+async function clearImConfig(cwd, dir, confirm) {
+  const files = configPaths(cwd, dir).filter((file) => fs.existsSync(file));
+  if (!files.length) return false;
+  for (const file of files) readLayer(file);
+  const snapshot = configSnapshot(cwd, dir);
+  if (!await confirm(`Delete the IM forwarding configuration file(s)?
+
+${files.join("\n")}
+
+Forwarding stops immediately and this cannot be undone.`)) return false;
+  if (configSnapshot(cwd, dir) !== snapshot) throw new Error("IM configuration changed during clear. Please retry.");
+  for (const file of files) {
+    try {
+      fs.unlinkSync(file);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  invalidateConfigCache();
+  return true;
+}
+function readLiveEnabled(cwd, dir, _cache) {
+  return cachedResolveConfig(cwd, dir).config?.enabled === true;
+}
+function readLiveConfig(cwd, dir) {
+  try {
+    return cachedResolveConfig(cwd, dir);
+  } catch {
+    return resolveConfig(cwd, dir);
+  }
+}
+function resolveImForwardConfig(cwd, dir) {
+  const result = resolveConfig(cwd, dir);
+  const cfg = result.config;
+  if (!cfg) return { config: null, problems: result.problems };
+  if (cfg.provider !== "feishu") return { config: null, problems: [`Unsupported IM provider: ${cfg.provider}`] };
+  const raw = cfg.settings;
+  const chatId = typeof raw.chatId === "string" ? raw.chatId.trim() : "";
+  if (!chatId) return { config: null, problems: cfg.enabled ? ["im-forward: enabled requires chatId"] : [] };
+  const allowUsers = Array.isArray(raw.allowUsers) ? raw.allowUsers.filter((id) => typeof id === "string" && !!id.trim()) : void 0;
+  return { config: { enabled: cfg.enabled, chatId, allowUsers: allowUsers?.length ? allowUsers : void 0, larkCli: typeof raw.larkCli === "string" && raw.larkCli.trim() ? raw.larkCli.trim() : void 0, retryBackoffMs: cfg.retryBackoffMs }, problems: chatId.startsWith("oc_") ? [] : ["im-forward: chatId does not look like a chat id (oc_...)"] };
+}
+
+// builtin/extensions/im-forward/runtime.ts
+var ROUTE_TTL_MS = 24 * 60 * 60 * 1e3;
+var MAX_ROUTES = 500;
+var MAX_SEEN_EVENTS = 1e3;
+var REPLY_CHAIN_MAX_DEPTH = 5;
+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;
+function summarizeFailureReason(reason) {
+  if (!reason) return { summary: "", persistent: false };
+  const text = reason.toLowerCase();
+  if (/another event bus|already connected/.test(text)) return { summary: "the app's event connection is occupied by another instance (possibly another machine); run /im-forward setup with another app/profile, or stop the other consumer", persistent: true };
+  if (/no active profile|not configured/.test(text)) return { summary: "provider not configured", persistent: false };
+  if (/auth|unauthorized|token|credential|login/.test(text)) return { summary: "authentication problem", persistent: false };
+  if (/permission|forbidden|scope/.test(text)) return { summary: "permission problem", persistent: false };
+  if (/network|dns|connect|timeout|unreachable/.test(text)) return { summary: "network problem", persistent: false };
+  return { summary: "provider exited", persistent: false };
+}
+var IM_INPUT_FALLBACK_CAPTION = "\u8BF7\u67E5\u770B\u8FD9\u4E9B\u56FE\u7247\u5E76\u5904\u7406\u3002";
+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 createRuntime(ctx, cfg, connection, liveEnabled, persistEnabled) {
+  const IM_INPUT_PREFIX = connection.sourcePrefix;
+  const key = (id) => JSON.stringify([cfg.provider, id]);
+  const scopes = /* @__PURE__ */ new Set();
+  let forwardingEnabled = cfg.enabled === true;
+  let configurationFailed = false;
+  function isForwardingEnabled() {
+    const value = liveEnabled();
+    configurationFailed = value === null;
+    const live = value === true;
+    if (configurationFailed) updateFooterTag();
+    if (live !== forwardingEnabled) {
+      forwardingEnabled = live;
+      updateFooterTag();
+    }
+    return forwardingEnabled;
+  }
+  const STATUS_KEY = "im-forward";
+  function updateFooterTag() {
+    ctx.ui.setStatus?.(STATUS_KEY, configurationFailed ? "[IM!]" : forwardingEnabled ? consumerLastExit ? "[IM!]" : consumerReady ? "[IM]" : "[IM\u2026]" : void 0);
+  }
+  function writeEnabledToConfig(next) {
+    persistEnabled(next);
+  }
+  let inputEpoch = 0;
+  function toggleForwarding() {
+    inputEpoch++;
+    isForwardingEnabled();
+    try {
+      writeEnabledToConfig(!forwardingEnabled);
+    } catch {
+      ctx.ui.notify("IM forwarding: could not save configuration; state unchanged.", "error");
+      return;
+    }
+    forwardingEnabled = !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");
+    }
+  }
+  ctx.registerShortcut("ctrl+i", {
+    description: "Toggle IM forwarding",
+    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 removeThreadAliasesOf(route) {
+    for (const [threadKey, indexed] of threadRoutes) {
+      if (indexed === route) threadRoutes.delete(threadKey);
+    }
+  }
+  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(key(route.threadId));
+        removeThreadAliasesOf(route);
+        const anchor = replyAnchor.get(route.sessionId);
+        if (anchor && key(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(key(oldest.messageId));
+      if (oldest.threadId) threadRoutes.delete(key(oldest.threadId));
+      removeThreadAliasesOf(oldest);
+    }
+    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.messageId ? `${IM_INPUT_PREFIX}
+${pending.caption || IM_INPUT_FALLBACK_CAPTION}` : pending.caption).trim();
+      if (lastUserText === expected) {
+        pendingInputs.splice(j, 1);
+        return { caption: pending.caption || `${IM_INPUT_PREFIX} images`, replyTo: pending.messageId || void 0, threadId: pending.threadId };
+      }
+    }
+    return void 0;
+  }
+  async function providerCall(operation, action) {
+    try {
+      return await action();
+    } catch {
+      ctx.log(`im-forward: ${cfg.provider} ${operation} failed`);
+      return null;
+    }
+  }
+  async function acknowledgeMessage(messageId) {
+    await providerCall("acknowledge", () => connection.acknowledge(messageId));
+  }
+  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, messageId: "", 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 forwardMessage(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 forwardMessage(`\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 forwardMessage(`\u26D4\uFE0F \u4EFB\u52A1\u5DF2\u53D6\u6D88\uFF1A${event.reason}`, sessionId, sequence, attribution?.caption, attribution?.replyTo);
+  });
+  async function forwardMessage(text, sessionId, sequence, userInput, replyTo) {
+    pruneState();
+    const sessionName = ctx.getSessionName?.();
+    const composed = composeForwardBody(sessionId, sessionName, userInput, text);
+    const body = truncateMarkdown(composed);
+    if (terminated || !isForwardingEnabled()) return;
+    const idempotencyKey = `pie-im-forward-${cfg.provider}-${sessionId}-${sequence}-${hashText(composed)}`;
+    let anchor = replyTo ?? replyAnchor.get(sessionId)?.messageId;
+    let sent = await providerCall("send", () => connection.send(cfg.targetId, body, idempotencyKey, anchor));
+    if (!sent && anchor && !terminated && isForwardingEnabled()) {
+      if (replyAnchor.get(sessionId)?.messageId === anchor) replyAnchor.delete(sessionId);
+      anchorFallbacks++;
+      sent = await providerCall("send", () => connection.send(cfg.targetId, body, idempotencyKey));
+    }
+    if (!sent) {
+      notifySendFailure(`${cfg.provider} send failed`);
+      return;
+    }
+    const { messageId, threadId } = sent;
+    const route = { messageId, threadId, sessionId, sentAt: Date.now() };
+    routes.set(key(messageId), route);
+    if (threadId) threadRoutes.set(key(threadId), route);
+    ctx.log(`im-forward: forwarded session=${sessionId} as ${messageId}`);
+    if (terminated || !isForwardingEnabled()) return;
+  }
+  ctx.on("session:changed", (event) => {
+    inputEpoch++;
+    currentSessionId = event.sessionId;
+    if (event.sessionId && !consumer && !consumerRecovering && !restartTimer && !terminated && !suspended) {
+      ctx.log("im-forward: session bound, starting event consumer");
+      spawnConsumer();
+    }
+  });
+  async function handleInboundEvent(event, viaRetry = false) {
+    if (!event) return;
+    const eventId = event.event_id ? key(event.event_id) : void 0;
+    if (!eventId) return;
+    if (!viaRetry && inFlightRetries.has(eventId)) return;
+    if (!viaRetry && retryTimers.has(eventId)) return;
+    if (!viaRetry && seenEventIds.has(eventId)) return;
+    if (!isForwardingEnabled()) {
+      if (!viaRetry) return;
+    }
+    if (!retrySessionIds.has(eventId) && currentSessionId) retrySessionIds.set(eventId, currentSessionId);
+    seenEventIds.set(eventId, Date.now());
+    pruneState();
+    let scheduledNextRetry = false;
+    const retry = () => {
+      scheduledNextRetry = true;
+      scheduleInboundRetry(event, retryDepth(eventId) + 1);
+    };
+    const terminalCleanup = () => {
+      if (!scheduledNextRetry) {
+        retryAttempts.delete(eventId);
+        retrySessionIds.delete(eventId);
+        inFlightRetries.delete(eventId);
+      }
+    };
+    if (!isForwardingEnabled()) {
+      terminalCleanup();
+      return;
+    }
+    try {
+      await handleInboundEventInner(event, retry);
+    } catch {
+      ctx.log(`im-forward: ${cfg.provider} inbound handling failed`);
+      retry();
+    } finally {
+      terminalCleanup();
+    }
+  }
+  async function handleInboundEventInner(event, retry) {
+    const matchesTarget = cfg.targetKind === "user" ? event.sender_id === cfg.targetId && (event.chatType === void 0 || event.chatType === "p2p") : event.chat_id === cfg.targetId;
+    if (!matchesTarget) return;
+    if (cfg.allowUsers && (!event.sender_id || !cfg.allowUsers.includes(event.sender_id))) return;
+    const messageId = event.message_id;
+    if (!messageId) return;
+    const sessionId = currentSessionId;
+    const epoch = inputEpoch;
+    const scope = ctx.beginUserInput?.(() => !terminated && inputEpoch === epoch && currentSessionId === sessionId && isForwardingEnabled());
+    if (!scope) {
+      retry();
+      return;
+    }
+    scopes.add(scope);
+    try {
+      const meta = await fetchMessageMeta(messageId);
+      if (!meta) {
+        retry();
+        return;
+      }
+      if (!scope.isCurrent()) return;
+      const resolution = await resolveRouteForInbound(messageId, meta);
+      if (!("found" in resolution)) {
+        if (isTransient(resolution)) retry();
+        else ctx.log(`im-forward: no route for ${messageId}; ignoring`);
+        return;
+      }
+      const route = resolution.found;
+      if (route.sessionId !== sessionId || !scope.isCurrent()) return;
+      const imageKeys = event.images;
+      const caption = event.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 forwardMessage(`\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, 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 {
+      scopes.delete(scope);
+      scope.dispose();
+    }
+  }
+  const retryAttempts = /* @__PURE__ */ new Map();
+  const retrySessionIds = /* @__PURE__ */ new Map();
+  function retryDepth(eventId) {
+    return eventId ? retryAttempts.get(eventId) ?? 0 : 0;
+  }
+  const inFlightRetries = /* @__PURE__ */ new Set();
+  function scheduleInboundRetry(event, attempt) {
+    const eventId = event.event_id ? key(event.event_id) : void 0;
+    if (!eventId) return;
+    if (terminated || attempt > MAX_INBOUND_RETRIES) {
+      if (attempt > MAX_INBOUND_RETRIES) {
+        ctx.log(`im-forward: giving up on event ${eventId} after ${MAX_INBOUND_RETRIES} retries`);
+        retryAttempts.delete(eventId);
+        const boundSession = retrySessionIds.get(eventId);
+        retrySessionIds.delete(eventId);
+        void forwardMessage(`\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`, boundSession ?? currentSessionId ?? "", ++forwardCounter, void 0, event.message_id);
+      }
+      return;
+    }
+    const backoff = (cfg.retryBackoffMs ?? DEFAULT_INBOUND_RETRY_BACKOFF_MS) * 2 ** (attempt - 1);
+    if (retryTimers.has(eventId)) return;
+    retryAttempts.set(eventId, attempt);
+    if (!retrySessionIds.has(eventId) && currentSessionId) retrySessionIds.set(eventId, currentSessionId);
+    const timer = setTimeout(() => {
+      retryTimers.delete(eventId);
+      inFlightRetries.add(eventId);
+      void handleInboundEvent(event, true).finally(() => {
+        inFlightRetries.delete(eventId);
+      });
+    }, backoff);
+    timer.unref?.();
+    retryTimers.set(eventId, { attempt, timer, event });
+    ctx.log(`im-forward: transient inbound failure; retrying ${eventId} 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);
+    }
+  };
+  const isTransient = (resolution) => "transient" in resolution && resolution.transient === true;
+  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;
+    }
+    const downloads = [];
+    try {
+      for (const [index, image] of imageKeys.entries()) {
+        if (!scope.isCurrent()) return false;
+        downloads.push(await connection.downloadImage(messageId, image, index));
+      }
+      if (!scope.isCurrent()) return false;
+      return await scope.submit(submitText, downloads.map((item) => item.file));
+    } catch {
+      ctx.log("im-forward: image preparation failed");
+      return false;
+    } finally {
+      for (const item of downloads) {
+        try {
+          item.cleanup();
+        } catch {
+          ctx.log("im-forward: temporary image cleanup failed");
+        }
+      }
+    }
+  }
+  async function fetchMessageMeta(messageId) {
+    return providerCall("metadata", () => connection.metadata(messageId));
+  }
+  async function fetchThreadMessages(threadId) {
+    return providerCall("thread lookup", () => connection.threadMessages(threadId));
+  }
+  async function resolveRouteForInbound(messageId, meta) {
+    if (meta.threadId) {
+      const byThread = threadRoutes.get(key(meta.threadId));
+      if (byThread) return { found: byThread };
+    }
+    const direct = routes.get(key(messageId));
+    if (direct) return { found: direct };
+    let chain = { notOurs: true };
+    if (meta.replyTo) {
+      chain = await resolveRouteForReply(meta.replyTo);
+      if ("found" in chain) return chain;
+    }
+    if (!meta.threadId) return chain;
+    const byRoot = await resolveRouteByThreadRoot(meta.threadId);
+    if ("found" in byRoot) return byRoot;
+    return isTransient(chain) || isTransient(byRoot) ? { transient: true } : { notOurs: true };
+  }
+  async function resolveRouteByThreadRoot(threadId) {
+    const messages = await fetchThreadMessages(threadId);
+    if (!messages) return { transient: true };
+    for (const id of messages) {
+      const route = routes.get(key(id));
+      if (route) {
+        threadRoutes.set(key(threadId), route);
+        return { found: route };
+      }
+    }
+    return { notOurs: true };
+  }
+  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(key(current));
+      if (direct) return { found: direct };
+      if (visited.has(current)) return { notOurs: true };
+      visited.add(current);
+      const parent = await fetchMessageMeta(current);
+      if (!parent) return { transient: true };
+      if (!parent.replyTo) return { notOurs: true };
+      current = parent.replyTo;
+    }
+    return { notOurs: true };
+  }
+  let consumer = null;
+  let consumerReady = false;
+  let consumerRecovering = false;
+  let consumerRestarts = 0;
+  let consumerLastExit;
+  let notifiedPersistentFailure = false;
+  let terminated = false;
+  let restartTimer;
+  let generation;
+  function stopGeneration(gen) {
+    if (gen.startup) clearTimeout(gen.startup);
+    return gen.stopping ??= Promise.resolve().then(() => gen.handle?.stop()).catch(() => {
+      ctx.log(`im-forward: ${cfg.provider} consumer stop failed`);
+    }).then(() => {
+      gen.retired = true;
+    });
+  }
+  function spawnConsumer() {
+    restartTimer = void 0;
+    restartDueAt = void 0;
+    if (terminated || suspended || consumer || consumerRecovering) return;
+    const gen = { handle: null, installed: false, failed: false, retired: false };
+    generation = gen;
+    consumerReady = false;
+    updateFooterTag();
+    const recover = () => {
+      if (!gen.installed) return;
+      void stopGeneration(gen).then(() => {
+        if (generation !== gen) return;
+        consumer = null;
+        consumerRecovering = false;
+        if (terminated || suspended) return;
+        const backoff = Math.min(RESTART_BACKOFF_MIN_MS * 2 ** Math.min(consumerRestarts, 4), RESTART_BACKOFF_MAX_MS);
+        restartTimer = setTimeout(spawnConsumer, backoff);
+        restartTimer.unref?.();
+        restartDueAt = Date.now() + backoff;
+      });
+    };
+    const fail = (reason) => {
+      if (gen.failed || gen.retired || terminated || generation !== gen) return;
+      gen.drain = gen.installed;
+      gen.failed = true;
+      if (gen.startup) clearTimeout(gen.startup);
+      consumerRecovering = true;
+      consumerReady = false;
+      const { summary: safe, persistent } = summarizeFailureReason(reason);
+      consumerLastExit = safe ? `${cfg.provider} connection failed (${safe})` : `${cfg.provider} connection failed`;
+      consumerRestarts++;
+      updateFooterTag();
+      ctx.log(`im-forward: consumer exited (${consumerLastExit})`);
+      if (!persistent || !notifiedPersistentFailure) {
+        if (persistent) notifiedPersistentFailure = true;
+        ctx.ui.notify(`IM forwarding: ${cfg.provider} connection failed${safe ? `: ${safe}` : "; check provider configuration/authentication."}${persistent ? " Retrying in the background (see /im-forward status)." : " Retrying."}`, persistent ? "error" : "warning");
+      }
+      recover();
+    };
+    gen.startup = setTimeout(fail, 3e4);
+    gen.startup.unref?.();
+    try {
+      gen.handle = connection.consume({
+        // Preserve buffered EXIT tail-drain until stop/close settles.
+        // A synchronous startup failure has no live stream to drain.
+        event: (event) => {
+          if (!terminated && !gen.retired && generation === gen && (!gen.failed || gen.drain))
+            void handleInboundEvent(event);
+        },
+        ready: () => {
+          if (terminated || gen.failed || gen.retired || generation !== gen) return;
+          clearTimeout(gen.startup);
+          consumerReady = true;
+          notifiedPersistentFailure = false;
+          ctx.log("im-forward: event consumer ready");
+          consumerRestarts = 0;
+          consumerLastExit = void 0;
+          updateFooterTag();
+        },
+        failure: fail
+      });
+      consumer = gen.handle;
+    } catch {
+      fail();
+    }
+    gen.installed = true;
+    if (gen.failed) recover();
+  }
+  let suspended = false;
+  let suspendedRestartInMs;
+  let restartDueAt;
+  const scheduleRestart = (delayMs) => {
+    if (restartTimer) clearTimeout(restartTimer);
+    restartDueAt = Date.now() + delayMs;
+    restartTimer = setTimeout(spawnConsumer, delayMs);
+    restartTimer.unref?.();
+  };
+  ctx.suspendEventConsumer = async () => {
+    if (terminated || suspended) return () => {
+    };
+    inputEpoch++;
+    suspended = true;
+    const gen = generation;
+    if (restartTimer) {
+      suspendedRestartInMs = restartDueAt !== void 0 ? Math.max(0, restartDueAt - Date.now()) : 0;
+      clearTimeout(restartTimer);
+      restartTimer = void 0;
+      restartDueAt = void 0;
+    }
+    consumer = null;
+    consumerRecovering = false;
+    consumerReady = false;
+    if (gen && !gen.retired) await stopGeneration(gen);
+    if (terminated) return () => {
+    };
+    let resumed = false;
+    return () => {
+      if (resumed || terminated) return;
+      resumed = true;
+      if (!suspended) return;
+      suspended = false;
+      if (consumer || consumerRecovering || restartTimer) return;
+      const delay = suspendedRestartInMs !== void 0 ? suspendedRestartInMs : Math.min(RESTART_BACKOFF_MIN_MS * 2 ** Math.min(consumerRestarts, 4), RESTART_BACKOFF_MAX_MS);
+      suspendedRestartInMs = void 0;
+      scheduleRestart(delay);
+    };
+  };
+  updateFooterTag();
+  ctx.registerCleanup?.(async () => {
+    inputEpoch++;
+    terminated = true;
+    const resources = [...scopes];
+    scopes.clear();
+    for (const { timer } of retryTimers.values()) clearTimeout(timer);
+    retryTimers.clear();
+    retryAttempts.clear();
+    retrySessionIds.clear();
+    inFlightRetries.clear();
+    if (restartTimer) clearTimeout(restartTimer);
+    if (generation) generation.retired = true;
+    const results = await Promise.allSettled([
+      ...resources.map((scope) => Promise.resolve().then(() => scope.dispose())),
+      Promise.resolve().then(() => connection.dispose?.()),
+      generation ? stopGeneration(generation) : Promise.resolve()
+    ]);
+    consumer = null;
+    if (results.some((result) => result.status === "rejected")) ctx.log(`im-forward: ${cfg.provider} resource cleanup failed`);
+  });
+  ctx.registerCommand({
+    name: "im-forward",
+    description: "IM forwarding status",
+    handler: (commandCtx) => {
+      isForwardingEnabled();
+      const lines = [
+        `IM forwarding (${cfg.label ?? cfg.provider})`,
+        `- target: ${cfg.targetId}`,
+        ...cfg.appId ? [`- app: ${cfg.appId}`] : [],
+        `- allowed senders: ${cfg.allowUsers?.join(", ") ?? "(anyone in target)"}`,
+        `- 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 (!routes.size && !terminated && consumerReady) lines.push("- note: no forwarded message yet \u2014 IM replies are only accepted after the first answer is forwarded. Run any local turn to open the reply entry.");
+      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");
+    }
+  });
+}
+
+// builtin/extensions/im-forward/onboarding.ts
+async function runSetup(ctx, dir, providers, signal, isCurrent = () => !signal.aborted, intent = "first-run", suspendEventConsumer) {
+  const initial = resolveConfig(ctx.cwd, dir);
+  if (initial.problems.length) {
+    ctx.ui.notify(initial.problems.join("\n"), "error");
+    return;
+  }
+  const snapshot = configSnapshot(ctx.cwd, dir);
+  const options = { signal, timeout: 12e4 };
+  if (!providers.length || !isCurrent()) return;
+  let selected;
+  if (intent === "switch-app" && initial.config) {
+    const bound = providers.find((item) => item.id === initial.config?.provider);
+    if (providers.length === 1 && bound) selected = bound;
+  }
+  if (!selected) {
+    const choice = await ctx.ui.select("IM forwarding setup \u2014 platform", [...providers.map((item) => item.label), "Cancel"], options);
+    if (!isCurrent() || !choice || choice === "Cancel") return;
+    selected = providers.find((item) => item.label === choice);
+  }
+  if (!selected || !isCurrent()) return;
+  ctx.ui.notify(`IM forwarding setup \u2014 ${selected.label}`, "info");
+  const settings = await selected.setup({ ui: ctx.ui, cwd: ctx.cwd, signal, suspendEventConsumer }, initial.config?.provider === selected.id ? initial.config.settings : void 0, void 0, intent);
+  if (!isCurrent() || !settings) return;
+  const resolved = selected.resolve(settings);
+  if (!resolved) {
+    ctx.ui.notify("IM forwarding setup: invalid provider settings; nothing was saved.", "error");
+    return;
+  }
+  const profile = typeof settings.larkCliProfile === "string" ? settings.larkCliProfile : void 0;
+  const profileLine = profile ? `
+lark-cli profile: ${String(profile)}` : "";
+  const appLine = resolved.appId ? `
+App: ${resolved.appId}` : "";
+  const confirmed = await ctx.ui.confirm("IM forwarding setup", `Platform: ${selected.label}
+Target: ${resolved.targetId}${appLine}${profileLine}
+Allowed senders: ${resolved.allowUsers?.join(", ") || "anyone in target"}
+Save location: ${saveLocation(ctx.cwd, dir)}
+Enable forwarding and start the connection? No test message will be sent. Saving does not prove connection readiness.`, options);
+  if (!isCurrent() || !confirmed) return;
+  writeConfig(ctx.cwd, dir, { enabled: true, provider: selected.id, settings }, snapshot);
+  return resolveConfig(ctx.cwd, dir).config ?? void 0;
+}
+
+// builtin/extensions/im-forward/providers/feishu/index.ts
+import { spawn as spawn4 } from "node:child_process";
+import * as fs4 from "node:fs";
+import * as os2 from "node:os";
+import * as path6 from "node:path";
+
+// builtin/extensions/im-forward/lark-cli.ts
+import { spawn as spawn2 } from "node:child_process";
+import { StringDecoder as StringDecoder2 } from "node:string_decoder";
+
+// builtin/extensions/im-forward/launch.ts
+import { spawn } from "node:child_process";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+import { StringDecoder } from "node:string_decoder";
+function resolveLaunchSpec(explicit, cwd = process.cwd(), platform = process.platform, env = process.env) {
+  const windows = platform === "win32";
+  const candidates = explicit ? [path2.resolve(cwd, explicit)] : (env.PATH ?? "").split(windows ? ";" : ":").filter(Boolean).flatMap((dir) => (windows ? ["lark-cli.exe", "lark-cli.cmd"] : ["lark-cli"]).map((name) => path2.resolve(cwd, dir, name)));
+  for (const candidate of candidates) {
+    try {
+      if (!fs2.statSync(candidate).isFile()) continue;
+      const ext = path2.extname(candidate).toLowerCase();
+      if (ext === ".js" || ext === ".mjs") return { command: process.execPath, prefix: [candidate] };
+      if (windows && ext === ".cmd") {
+        const dir = path2.dirname(candidate);
+        for (const root of [path2.join(dir, "node_modules", "@larksuite", "cli"), path2.resolve(dir, "..", "@larksuite", "cli")]) {
+          try {
+            const pkg = JSON.parse(fs2.readFileSync(path2.join(root, "package.json"), "utf8"));
+            const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.["lark-cli"];
+            if (pkg.name !== "@larksuite/cli" || typeof bin !== "string" || bin.replace(/^\.\//, "") !== "scripts/run.js") continue;
+            const entry = path2.join(root, "scripts", "run.js");
+            if (fs2.statSync(entry).isFile()) return { command: process.execPath, prefix: [entry] };
+          } catch {
+          }
+        }
+        continue;
+      }
+      if (windows && ext !== ".exe") continue;
+      fs2.accessSync(candidate, fs2.constants.X_OK);
+      return { command: candidate, prefix: [] };
+    } catch {
+    }
+  }
+  return null;
+}
+var treeStops = /* @__PURE__ */ new WeakMap();
+var hasExited = (child) => child.exitCode != null || child.signalCode != null;
+function stopOwnedTree(child, signal) {
+  const existing = treeStops.get(child);
+  if (existing) return existing;
+  if (process.platform === "win32" && hasExited(child)) return Promise.resolve(false);
+  const pending = stopOwnedTreeInner(child, signal);
+  treeStops.set(child, pending);
+  void pending.finally(() => treeStops.delete(child));
+  return pending;
+}
+function stopOwnedTreeInner(child, signal) {
+  if (process.platform !== "win32" || !child.pid) {
+    try {
+      if (child.pid) process.kill(-child.pid, signal);
+      else child.kill(signal);
+      return Promise.resolve(true);
+    } catch {
+      try {
+        return Promise.resolve(child.kill(signal));
+      } catch {
+        return Promise.resolve(false);
+      }
+    }
+  }
+  return new Promise((resolve3) => {
+    let done = false;
+    let killer;
+    const finish = (ok) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      if (!ok && !hasExited(child)) {
+        try {
+          child.kill(signal);
+        } catch {
+        }
+      }
+      resolve3(ok);
+    };
+    const timer = setTimeout(() => {
+      try {
+        killer?.kill();
+      } catch {
+      }
+      finish(false);
+    }, 1500);
+    try {
+      const root = process.env.SystemRoot || process.env.windir || "C:\\Windows";
+      killer = spawn(path2.join(root, "System32", "taskkill.exe"), ["/PID", String(child.pid), "/T", "/F"], { shell: false, windowsHide: true, stdio: "ignore" });
+      killer.on("error", () => finish(false));
+      killer.on("exit", (code) => finish(code === 0));
+    } catch {
+      finish(false);
+    }
+  });
+}
+function lineReader(onLine, max = 1024 * 1024) {
+  const decoder = new StringDecoder("utf8");
+  let pending = "";
+  let dropping = false;
+  const accept = (text) => {
+    for (const [i, part] of text.split("\n").entries()) {
+      if (i) {
+        if (!dropping) onLine(pending);
+        pending = "";
+        dropping = false;
+      }
+      if (!dropping) {
+        pending += part;
+        if (pending.length > max) {
+          pending = "";
+          dropping = true;
+        }
+      }
+    }
+  };
+  return { write: (chunk) => accept(decoder.write(chunk)), end() {
+    accept(decoder.end());
+    if (pending && !dropping) onLine(pending);
+    pending = "";
+  } };
+}
+var shutdowns = /* @__PURE__ */ new WeakMap();
+function shutdownConsumer(child) {
+  const existing = shutdowns.get(child);
+  if (existing) return existing;
+  const pending = shutdownConsumerInner(child);
+  shutdowns.set(child, pending);
+  return pending;
+}
+async function shutdownConsumerInner(child) {
+  let closed = false;
+  const close = new Promise((resolve3) => child.once("close", () => {
+    closed = true;
+    resolve3();
+  }));
+  const wait = async (ms) => {
+    let timer;
+    await Promise.race([close, new Promise((resolve3) => {
+      timer = setTimeout(resolve3, ms);
+    })]);
+    clearTimeout(timer);
+  };
+  try {
+    child.stdin?.end();
+  } catch {
+  }
+  await wait(500);
+  if (!closed) {
+    await stopOwnedTree(child, "SIGTERM");
+    await wait(500);
+  }
+  if (!closed) {
+    await stopOwnedTree(child, "SIGKILL");
+    await wait(500);
+  }
+  child.stdin?.destroy();
+  child.stdout?.destroy();
+  child.stderr?.destroy();
+}
+
+// builtin/extensions/im-forward/lark-cli.ts
+async function runLarkCli(binary, args, timeoutMs = 3e4, cwd, options = {}) {
+  return new Promise((resolve3) => {
+    if (options.signal?.aborted) {
+      resolve3({ stdout: "", error: "cancelled" });
+      return;
+    }
+    let child;
+    try {
+      const spec = typeof binary === "string" ? resolveLaunchSpec(binary) ?? (options.spawn ? { command: binary, prefix: [] } : null) : binary;
+      if (!spec) throw new Error("unsupported executable");
+      child = (options.spawn ?? spawn2)(spec.command, [...spec.prefix, ...args], {
+        shell: false,
+        windowsHide: true,
+        stdio: [options.stdin ?? "ignore", "pipe", "pipe"],
+        detached: process.platform !== "win32",
+        ...cwd ? { cwd } : {}
+      });
+    } catch {
+      resolve3({ stdout: "", error: "spawn failed" });
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let closed = false;
+    let termination;
+    let treeStopped = false;
+    let killTimer;
+    let closeTimer;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      clearTimeout(killTimer);
+      clearTimeout(closeTimer);
+      options.signal?.removeEventListener("abort", abort);
+      resolve3(result);
+    };
+    const terminatedResult = () => ({ stdout: termination?.startsWith("timeout") ? stdout : "", error: termination });
+    const stop = (signal) => {
+      try {
+        return stopOwnedTree(child, signal);
+      } catch {
+        return Promise.resolve();
+      }
+    };
+    const kill = () => {
+      const stopped = () => {
+        treeStopped = true;
+        if (settled) return;
+        if (closed) {
+          finish(terminatedResult());
+          return;
+        }
+        closeTimer = setTimeout(() => {
+          child.stdout?.destroy();
+          child.stderr?.destroy();
+          finish(terminatedResult());
+        }, options.closeGraceMs ?? 1e3);
+      };
+      void stop("SIGKILL").then(stopped, stopped);
+    };
+    const terminate = (reason, graceful = false) => {
+      if (settled || termination) return;
+      termination = reason;
+      clearTimeout(timer);
+      if (graceful) {
+        const stopped = () => {
+          if (closed) {
+            treeStopped = true;
+            finish(terminatedResult());
+          }
+        };
+        void stop("SIGTERM").then(stopped, stopped);
+        if (!settled) killTimer = setTimeout(kill, options.killGraceMs ?? 1e3);
+      } else kill();
+    };
+    const timer = setTimeout(() => terminate(`timeout after ${timeoutMs}ms`, true), timeoutMs);
+    const abort = () => terminate("cancelled");
+    options.signal?.addEventListener("abort", abort, { once: true });
+    if (options.signal?.aborted) abort();
+    const deliverLine = (line) => {
+      if (settled || termination) return;
+      try {
+        options.onLine?.(line);
+      } catch {
+        terminate("output callback failed");
+      }
+    };
+    const lines = options.onLine ? lineReader(deliverLine, 16384) : void 0;
+    const errorLines = options.onLine ? lineReader(deliverLine, 16384) : void 0;
+    const outDecoder = new StringDecoder2("utf8");
+    const errDecoder = new StringDecoder2("utf8");
+    child.stdout?.on("data", (chunk) => {
+      if (settled || termination) return;
+      lines?.write(chunk);
+      if (termination) return;
+      stdout += outDecoder.write(chunk);
+      if (stdout.length > 8 * 1024 * 1024) {
+        stdout = "";
+        terminate("stdout exceeds 8 MiB limit");
+      }
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (settled || termination) return;
+      errorLines?.write(chunk);
+      stderr = (stderr + errDecoder.write(chunk)).slice(-4096);
+    });
+    child.on("error", () => terminate("spawn error"));
+    child.on("close", (code) => {
+      closed = true;
+      if (settled) return;
+      if (termination) {
+        if (treeStopped) finish(terminatedResult());
+        return;
+      }
+      stdout += outDecoder.end();
+      stderr += errDecoder.end();
+      lines?.end();
+      errorLines?.end();
+      if (termination) return;
+      if (code === 0 && (stdout.trim() || options.allowEmpty)) finish({ stdout });
+      else finish({ stdout, error: `exit ${code}${stderr ? `: ${stderr.slice(-300).trim()}` : ""}` });
+    });
+  });
+}
+
+// builtin/extensions/im-forward/providers/feishu/helpers.ts
+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 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;
+}
+
+// builtin/extensions/im-forward/providers/feishu/setup.ts
+import * as fs3 from "node:fs";
+import * as path5 from "node:path";
+
+// builtin/extensions/im-forward/browser.ts
+import { spawn as spawn3 } from "node:child_process";
+import path3 from "node:path";
+var browserScript = "$ErrorActionPreference = 'Stop'; try { $reader = [System.IO.StreamReader]::new([Console]::OpenStandardInput(), [System.Text.Encoding]::UTF8); $url = $reader.ReadToEnd(); Start-Process -FilePath $url; exit 0 } catch { exit 1 }";
+function browserLaunch(platform = process.platform, root = process.env.SystemRoot || "C:\\Windows") {
+  if (platform === "win32") {
+    if (!/^[A-Za-z]:\\/.test(root) || /[\x00-\x1f]/.test(root)) return;
+    return { command: path3.win32.join(root, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"), args: ["-NoLogo", "-NoProfile", "-NonInteractive", "-EncodedCommand", Buffer.from(browserScript, "utf16le").toString("base64")], stdin: true };
+  }
+  if (platform === "darwin") return { command: "/usr/bin/open", args: ["--"], stdin: false };
+  if (platform === "linux") return { command: "/usr/bin/xdg-open", args: [], stdin: false };
+}
+async function openBrowser(url, signal, seam = {}) {
+  if (signal.aborted || !/^https:\/\/[^\s\x00-\x1f\x7f]+$/.test(url)) return "failed";
+  const spec = browserLaunch(seam.platform);
+  if (!spec) return "failed";
+  return new Promise((resolve3) => {
+    let child;
+    let settled = false;
+    let stopping = false;
+    let closed = false;
+    let closeTimer;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      clearTimeout(closeTimer);
+      signal.removeEventListener("abort", abort);
+      child?.stdin?.destroy();
+      child?.stdout?.destroy();
+      child?.stderr?.destroy();
+      resolve3(result);
+    };
+    const stop = () => {
+      if (settled || stopping) return;
+      stopping = true;
+      const stopped = () => {
+        if (closed) finish("failed");
+        else closeTimer = setTimeout(() => finish("failed"), 1e3);
+      };
+      try {
+        void (seam.stop ?? stopOwnedTree)(child, "SIGKILL").then(stopped, stopped);
+      } catch {
+        stopped();
+      }
+    };
+    const abort = () => stop();
+    const timer = setTimeout(stop, seam.timeoutMs ?? 1e4);
+    try {
+      child = (seam.spawn ?? spawn3)(spec.command, spec.stdin ? spec.args : [...spec.args, url], { shell: false, windowsHide: true, detached: process.platform !== "win32", stdio: [spec.stdin ? "pipe" : "ignore", "ignore", "ignore"] });
+      child.on("error", stop);
+      child.on("close", (code) => {
+        closed = true;
+        if (!stopping) finish(code === 0 && !signal.aborted ? "launched" : "failed");
+      });
+      child.stdin?.on("error", stop);
+      signal.addEventListener("abort", abort, { once: true });
+      if (signal.aborted) stop();
+      else if (spec.stdin) child.stdin?.end(Buffer.from(url, "utf8"));
+    } catch {
+      finish("failed");
+    }
+  });
+}
+
+// builtin/extensions/im-forward/existing-app-terminal.ts
+import path4 from "node:path";
+var existingAppInnerScript = "$ErrorActionPreference = 'Stop'; try { $payload = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('__PAYLOAD__')) | ConvertFrom-Json; Set-Location -LiteralPath $payload.cwd; & $payload.command @($payload.args); $code = $LASTEXITCODE; if ($null -eq $code) { exit 1 }; exit $code } catch { Write-Host 'Official setup failed. Close this window and retry from Pie.'; exit 1 }";
+var existingAppOuterTemplate = "$ErrorActionPreference = 'Stop'; try { $inner = '" + existingAppInnerScript.replaceAll("'", "''") + "'; $encoded = [Convert]::ToBase64String([Text.Encoding]::Unicode.GetBytes($inner)); $child = Start-Process -FilePath (Join-Path $PSHOME 'powershell.exe') -WindowStyle Normal -Wait -PassThru -ArgumentList @('-NoLogo', '-NoProfile', '-EncodedCommand', $encoded); exit $child.ExitCode } catch { exit 1 }";
+function existingAppTerminal(binary, cwd, platform = process.platform, root = process.env.SystemRoot || "C:\\Windows") {
+  if (platform !== "win32" || !/^[A-Za-z]:\\/.test(root) || /[\x00-\x1f]/.test(root)) return null;
+  const payload = Buffer.from(JSON.stringify({ command: binary.command, args: [...binary.prefix, "config", "init", "--brand", "feishu"], cwd }), "utf8").toString("base64");
+  const script = existingAppOuterTemplate.replace("__PAYLOAD__", payload);
+  return { command: path4.win32.join(root, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"), prefix: ["-NoLogo", "-NoProfile", "-NonInteractive", "-EncodedCommand", Buffer.from(script, "utf16le").toString("base64")] };
+}
+
+// builtin/extensions/im-forward/providers/feishu/setup.ts
+function findNpmCli() {
+  const dirs = [path5.dirname(process.execPath), ...(process.env.PATH ?? "").split(path5.delimiter)];
+  for (const dir of dirs) for (const root of [path5.join(dir, "node_modules", "npm"), path5.resolve(dir, "..", "lib", "node_modules", "npm")]) {
+    try {
+      const pkg = JSON.parse(fs3.readFileSync(path5.join(root, "package.json"), "utf8"));
+      const entry = path5.join(root, "bin", "npm-cli.js");
+      if (pkg.name === "npm" && pkg.bin?.npm === "bin/npm-cli.js" && fs3.statSync(entry).isFile()) return { command: process.execPath, prefix: [entry] };
+    } catch {
+    }
+  }
+  return null;
+}
+function isOfficialAuthUrl(raw) {
+  try {
+    if (!/^https:\/\/[^\s\x00-\x1f\x7f]+$/.test(raw) || /%0[0-9a-f]|%1[0-9a-f]|%7f/i.test(raw)) return false;
+    const url = new URL(raw);
+    return url.protocol === "https:" && !url.username && !url.password && !raw.includes("#") && (!url.port || url.port === "443") && ["feishu.cn", "larksuite.com"].some((host) => url.hostname === host || url.hostname.endsWith(`.${host}`)) && url.pathname === "/page/cli" && !!url.searchParams.get("user_code") && ![...url.searchParams.keys()].some((key) => /secret|token/i.test(key));
+  } catch {
+    return false;
+  }
+}
+function authUrls(line, newAppFlow = false) {
+  const urls = [];
+  const visit = (value) => {
+    if (!isRecord(value)) return;
+    for (const [key, child] of Object.entries(value)) {
+      if (["verification_url", "verification_uri_complete", "console_url"].includes(key) && typeof child === "string" && /^https?:\/\/[^\s\x00-\x1f\x7f]+$/.test(child)) urls.push(child);
+      else if (isRecord(child)) visit(child);
+    }
+  };
+  try {
+    visit(JSON.parse(line));
+  } catch {
+    const match = line.trim().match(/^"(verification_url|verification_uri_complete|console_url)"\s*:\s*("(?:[^"\\]|\\.)*")\s*,?$/);
+    if (match) {
+      try {
+        visit({ [match[1]]: JSON.parse(match[2]) });
+      } catch {
+      }
+    }
+    const field = line.trim().match(/^(verification_url|verification_uri_complete|console_url)\s*[:=]\s*(https?:\/\/\S+)$/);
+    if (field) visit({ [field[1]]: field[2] });
+  }
+  if (newAppFlow) {
+    const raw = line.trim();
+    try {
+      if (isOfficialAuthUrl(raw)) urls.push(raw);
+    } catch {
+    }
+  }
+  return [...new Set(urls)];
+}
+function parseDirectMessage(line) {
+  let raw;
+  try {
+    raw = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!isRecord(raw) || raw.type !== "im.message.receive_v1") return null;
+  if ("chat_type" in raw && raw.chat_type !== "p2p") return null;
+  if (typeof raw.chat_id !== "string" || !/^oc_[A-Za-z0-9_-]+$/.test(raw.chat_id)) return null;
+  if (typeof raw.sender_id !== "string" || !/^ou_[A-Za-z0-9_-]+$/.test(raw.sender_id)) return null;
+  return { chatId: raw.chat_id, senderId: raw.sender_id };
+}
+function parseChats(stdout) {
+  const parsed = parseLarkCliEnvelope(stdout);
+  if (!parsed.ok || !parsed.data) return null;
+  const list = parsed.data.chats ?? parsed.data.items ?? parsed.data.messages;
+  if (!Array.isArray(list)) return parsed.data.has_more === false ? [] : null;
+  return list.flatMap((item) => isRecord(item) && typeof item.chat_id === "string" && /^oc_[A-Za-z0-9_-]+$/.test(item.chat_id) ? [{ id: item.chat_id, name: typeof item.name === "string" ? item.name.replace(/[\x00-\x1f\x7f]/g, " ").slice(0, 120) : item.chat_id }] : []);
+}
+var failureActions = {
+  config: "Official CLI configuration is missing or invalid. Create a new app, or configure an existing app in a trusted terminal.",
+  auth: "Authorization is missing or expired. Configure the intended app in a trusted terminal, then recheck.",
+  permission: "The bot lacks access or permissions. Check app scopes and chat membership, then recheck.",
+  network: "The service could not be reached. Check connectivity and retry the connection check.",
+  unsupported: "This CLI command or version is unsupported. Check the official CLI version and update it in a trusted terminal.",
+  timeout: "The operation timed out. Check connectivity and retry.",
+  cancel: "The operation was cancelled. Retry when ready; nothing was saved.",
+  unknown: "The CLI returned an unrecognized failure or invalid result. Check the official CLI in a trusted terminal, then retry."
+};
+function setupFailure(result) {
+  let type = "";
+  let subtype = "";
+  try {
+    const body = JSON.parse(result.stdout);
+    if (isRecord(body) && isRecord(body.error)) {
+      type = typeof body.error.type === "string" ? body.error.type.toLowerCase() : "";
+      subtype = typeof body.error.subtype === "string" ? body.error.subtype.toLowerCase() : "";
+    }
+  } catch {
+  }
+  const tags = `${type} ${subtype}`;
+  let reason = "unknown";
+  if (/^timeout/.test(result.error ?? "")) reason = "timeout";
+  else if (result.error === "cancelled") reason = "cancel";
+  else if (/config|not_configured/.test(tags)) reason = "config";
+  else if (/permission|forbidden|scope|access_denied/.test(tags)) reason = "permission";
+  else if (/auth|token|credential|unauthorized/.test(tags)) reason = "auth";
+  else if (/network|connection|dns|transport/.test(tags)) reason = "network";
+  else if (/unsupported|unknown_command|invalid_command|version/.test(tags)) reason = "unsupported";
+  return failureActions[reason];
+}
+function parseProfiles(stdout) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(parsed)) return null;
+  const profiles = parsed.flatMap((item) => {
+    if (!isRecord(item) || typeof item.name !== "string" || !item.name.trim() || typeof item.appId !== "string") return [];
+    return [{ name: item.name.trim(), appId: item.appId, active: item.active === true, user: typeof item.user === "string" ? item.user : void 0 }];
+  });
+  return profiles.length ? profiles : null;
+}
+var dependencies = { resolve: resolveLaunchSpec, run: runLarkCli, npm: findNpmCli, openBrowser, terminal: existingAppTerminal };
+async function setupFeishu(io, previous, deps = dependencies, intent = "first-run") {
+  const { ui, cwd, signal } = io;
+  const options = { signal, timeout: 12e4 };
+  const current = () => !signal.aborted;
+  const run = async (binary2, args, timeout, workdir, callOptions = {}, authorize = false, progressLabel = "", stream) => {
+    const operation = new AbortController();
+    let dialog = new AbortController();
+    let dialogGeneration = 0;
+    let dialogStarted = false;
+    const startedAt = Date.now();
+    const abort = () => operation.abort();
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) operation.abort();
+    let expired = false;
+    const deadline = setTimeout(() => {
+      expired = true;
+      operation.abort();
+    }, timeout);
+    let done = false;
+    let streamStopped = false;
+    const openings = [];
+    const seen = /* @__PURE__ */ new Set();
+    let received = false;
+    const announceUrl = (url) => {
+      if (!isOfficialAuthUrl(url)) {
+        ui.notify("An authorization link arrived but could not be verified as an official Feishu page; it was NOT displayed or opened. If authorization fails, retry setup in a trusted terminal.", "warning");
+        widget("Unverified link withheld \u2014 not opened automatically", "");
+        return;
+      }
+      ui.notify(url, "info");
+      widget("Opening default browser", url);
+      const opening = Promise.resolve().then(() => active() ? deps.openBrowser?.(url, operation.signal) : "failed").then((result) => {
+        widget(result === "launched" ? "Waiting for browser authorization (launcher completed; authorization not yet confirmed)" : "Browser could not open; manually open link", url);
+      }, () => {
+        widget("Browser could not open; manually open link", url);
+      }).catch(() => {
+      });
+      openings.push(opening);
+    };
+    const active = () => !done && current() && !operation.signal.aborted;
+    let phase = "Requesting official authorization link";
+    let manualUrl = "";
+    const showProgress = () => {
+      if (!active()) return;
+      const previous2 = dialog;
+      dialog = new AbortController();
+      const generation = ++dialogGeneration;
+      previous2.abort();
+      const title = "IM forwarding setup \u2014 working; cancel to stop" + (authorize ? `
+Browser authorization: ${phase}
+${manualUrl || "No authorization URL yet. Do not enter secrets in Pie."}` : progressLabel ? `
+${progressLabel}` : "");
+      const cancel = () => {
+        if (generation === dialogGeneration && active()) operation.abort();
+      };
+      try {
+        void ui.select(title, ["Cancel"], { signal: dialog.signal, timeout: Math.max(1, timeout - (Date.now() - startedAt)) }).then(cancel, cancel);
+      } catch {
+        cancel();
+      }
+    };
+    const widget = (nextPhase, url = "") => {
+      if (!active()) return;
+      phase = nextPhase;
+      manualUrl = url;
+      try {
+        ui.setWidget?.("im-forward-setup", ["IM forwarding \u2014 browser authorization", phase, manualUrl || "No authorization URL yet. Do not enter secrets in Pie."]);
+      } catch {
+      }
+      if (dialogStarted) showProgress();
+    };
+    if (authorize) widget("Requesting official authorization link");
+    const advisory = authorize ? setTimeout(() => {
+      if (!received) widget("Still waiting for the official authorization link; cancel or wait (two-minute deadline).");
+    }, 15e3) : void 0;
+    try {
+      const pending = deps.run(binary2, args, timeout, workdir, { ...callOptions, signal: operation.signal, ...authorize ? { onLine: (line) => {
+        if (!active()) return;
+        for (const url of authUrls(line, true)) {
+          if (seen.has(url)) continue;
+          seen.add(url);
+          received = true;
+          announceUrl(url);
+        }
+      } } : stream ? { onLine: (line) => {
+        if (!active()) return;
+        if (stream(line)) {
+          streamStopped = true;
+          operation.abort();
+        }
+      } } : {} }).then(async (result2) => {
+        if (openings.length) await Promise.all(openings);
+        done = true;
+        return result2;
+      });
+      dialogStarted = true;
+      showProgress();
+      const result = await pending;
+      if (operation.signal.aborted && !expired && !streamStopped) throw new Error("Operation cancelled; nothing was saved.");
+      return expired ? { stdout: "", error: `timeout after ${timeout}ms` } : result;
+    } finally {
+      done = true;
+      ++dialogGeneration;
+      operation.abort();
+      try {
+        await Promise.all(openings);
+      } finally {
+        clearTimeout(advisory);
+        clearTimeout(deadline);
+        dialog.abort();
+        signal.removeEventListener("abort", abort);
+        if (authorize) {
+          try {
+            ui.setWidget?.("im-forward-setup", void 0);
+          } catch {
+          }
+        }
+      }
+    }
+  };
+  let executable = typeof previous?.larkCli === "string" ? previous.larkCli : void 0;
+  let binary = deps.resolve(executable, cwd);
+  while (!binary && current()) {
+    const choice = await ui.select("IM forwarding setup \u2014 Feishu CLI required", ["Provide existing executable path", "Install official @larksuite/cli", "Cancel"], options);
+    if (!current() || !choice || choice === "Cancel") return;
+    if (choice === "Install official @larksuite/cli") {
+      if (!await ui.confirm("Install Feishu CLI?", "This runs npm install --global @larksuite/cli: network access, global filesystem changes and package postinstall scripts. No messages will be sent. Continue?", options) || !current()) return;
+      const npm = deps.npm();
+      if (!npm) {
+        ui.notify("A reliable npm-cli.js was not found. Install @larksuite/cli yourself using your trusted npm, then provide its executable path. No installer was run.", "warning");
+        continue;
+      }
+      const installed = await run(npm, ["install", "--global", "@larksuite/cli"], 12e4, cwd, { signal, allowEmpty: true });
+      if (!current()) return;
+      if (installed.error) {
+        ui.notify("Feishu CLI installation failed or timed out. Configuration was not saved. Install with your trusted npm or provide an existing path.", "error");
+        return;
+      }
+      executable = void 0;
+      binary = deps.resolve(void 0, cwd);
+      if (!binary) ui.notify("Installer completed, but lark-cli is not discoverable. Provide its executable path.", "warning");
+    } else {
+      const input = await ui.input("IM forwarding setup \u2014 existing Feishu CLI executable", "Absolute executable or Node .js/.mjs entry (not a shell command)", options);
+      if (!current() || !input?.trim()) return;
+      executable = input.trim();
+      binary = deps.resolve(executable, cwd);
+      if (!binary) ui.notify("That executable is missing or unsupported. Windows npm cmd shims must belong to the official CLI; arbitrary bat/cmd wrappers are not supported.", "warning");
+    }
+  }
+  if (!binary || !current()) return;
+  let profileName = typeof previous?.larkCliProfile === "string" && previous.larkCliProfile.trim() ? previous.larkCliProfile.trim() : void 0;
+  let profiles = null;
+  {
+    const listed = await run(binary, ["profile", "list"], 15e3, cwd, { signal, allowEmpty: true });
+    if (!current()) return;
+    profiles = listed.error ? null : parseProfiles(listed.stdout);
+    const describe = (item) => {
+      const parts = [item.appId];
+      if (item.user) parts.push(item.user);
+      if (item.active) parts.push("active");
+      return `${item.name} (${parts.join(" \xB7 ")})`;
+    };
+    const connectDifferent = "Connect a different app\u2026";
+    const suggestProfileName = () => {
+      const taken = new Set((profiles ?? []).map((item) => item.name));
+      if (!taken.has("pie")) return "pie";
+      for (let n = 2; n < 100; n++) if (!taken.has(`pie-${n}`)) return `pie-${n}`;
+      return `pie-${Date.now().toString(36)}`;
+    };
+    const bindNewApp = async () => {
+      if (!await ui.confirm("Connect a different Feishu app?", "The default browser will open for authorization. This creates an external Feishu application as a new lark-cli profile, not just a sign-in. The official CLI will write its own configuration; other profiles stay unchanged. Pie does not collect app secrets. Continue?", options) || !current()) return false;
+      let suggested = suggestProfileName();
+      const entered = await ui.input("IM forwarding setup \u2014 profile name for the new app", `Suggested: ${suggested} (stored in lark-cli, local to this machine)`, options);
+      if (!current()) return false;
+      const raw = (entered ?? "").trim();
+      if (raw) {
+        if (!/^[-\w]{1,64}$/.test(raw)) {
+          ui.notify("Invalid profile name: use 1-64 letters, digits, - or _. Nothing was saved.", "error");
+          return false;
+        }
+        suggested = raw;
+      }
+      ui.notify("Authorize only in the official browser flow. Do not enter secrets in Pie. Open the exact URL displayed below; setup is bounded to two minutes.", "info");
+      const result = await run(binary, ["config", "init", "--new", "--brand", "feishu", "--name", suggested], 12e4, cwd, { signal, allowEmpty: true }, true);
+      if (!current()) return false;
+      if (result.error) {
+        ui.notify(`New-app browser authorization: ${setupFailure(result)} Nothing was saved in Pie. Official CLI configuration may have changed.`, "warning");
+        return false;
+      }
+      profileName = suggested;
+      const relisted = await run(binary, ["profile", "list"], 15e3, cwd, { signal, allowEmpty: true });
+      if (!current()) return false;
+      if (!relisted.error) {
+        const fresh = parseProfiles(relisted.stdout);
+        if (fresh) profiles = fresh;
+      }
+      ui.notify(`IM forwarding will use lark-cli profile "${suggested}" on this machine.`, "info");
+      return true;
+    };
+    const singleProfile = profiles?.length === 1 ? profiles[0] : void 0;
+    if (singleProfile && intent === "switch-app") {
+      const choice = await ui.select("IM forwarding setup \u2014 Feishu app (per machine)", [`Keep current app \u2014 ${describe(singleProfile)}`, connectDifferent, "Cancel"], options);
+      if (!current() || !choice || choice === "Cancel") return;
+      if (choice === connectDifferent) {
+        if (!await bindNewApp()) return;
+      } else profileName = singleProfile.name;
+    } else if (profiles && profiles.length > 1) {
+      const previousProfile = profiles.find((item) => item.name === profileName);
+      if (!previousProfile) profileName = void 0;
+      const items = ["Use the CLI's active app (no per-machine profile)", ...profiles.map(describe), connectDifferent, "Cancel"];
+      const choice = await ui.select("IM forwarding setup \u2014 Feishu app (per machine)", items, options);
+      if (!current() || !choice || choice === "Cancel") return;
+      if (choice === connectDifferent) {
+        if (!await bindNewApp()) return;
+      } else {
+        const index = items.indexOf(choice) - 1;
+        profileName = choice === items[0] ? void 0 : profiles[index]?.name;
+        if (!profileName && choice !== items[0]) return;
+        if (profileName) ui.notify(`IM forwarding will use lark-cli profile "${profileName}" on this machine.`, "info");
+      }
+    } else if (profiles) {
+      profileName = void 0;
+    } else if (intent === "switch-app") {
+      ui.notify("This lark-cli build does not support multiple app profiles; update lark-cli to switch apps.", "warning");
+    }
+  }
+  const withProfile = (args) => profileName ? [...args, "--profile", profileName] : args;
+  let diagnostic = "";
+  const chatListCommands = [
+    ["im", "+chat-list", "--as", "bot", "--format", "json", "--page-size", "100"],
+    ["im", "chats", "list", "--as", "bot", "--format", "json", "--params", '{"page_size":100}']
+  ].map(withProfile);
+  let chatListForm;
+  const discover = async () => {
+    let firstDiagnostic = "";
+    for (const args of chatListForm ? [chatListForm] : chatListCommands) {
+      const result = await run(binary, args, 3e4, cwd, { signal });
+      if (!firstDiagnostic) firstDiagnostic = setupFailure(result);
+      diagnostic = setupFailure(result);
+      if (!result.error) {
+        const chats2 = parseChats(result.stdout);
+        if (chats2) {
+          chatListForm = args;
+          return chats2;
+        }
+      }
+    }
+    if (firstDiagnostic && firstDiagnostic !== failureActions.unknown) diagnostic = firstDiagnostic;
+    return null;
+  };
+  let chats = await discover();
+  if (!current()) return;
+  let stage = "Connection check before authorization";
+  while (!chats && current()) {
+    ui.notify(`${stage}: ${diagnostic}`, "warning");
+    const action = await ui.select("IM forwarding setup \u2014 Feishu authentication", ["Create a new Feishu app (browser authorization)", "Use an existing app (configure in official terminal)", "Recheck connection", "Enter chat ID manually (readiness unverified)", "Cancel"], options);
+    if (!current() || !action || action === "Cancel") return;
+    if (action === "Enter chat ID manually (readiness unverified)") break;
+    if (action === "Create a new Feishu app (browser authorization)") {
+      if (!await ui.confirm("Create a new Feishu app?", "The default browser will open for authorization. This creates an external Feishu application, not just a sign-in to an existing app. The official CLI will write its configuration and existing profiles may change. Pie does not collect app secrets. Continue?", options) || !current()) return;
+      ui.notify("Authorize only in the official browser flow. Do not enter secrets in Pie. Open the exact URL displayed below; setup is bounded to two minutes.", "info");
+      const result = await run(binary, withProfile(["config", "init", "--new", "--brand", "feishu", ...profileName ? ["--name", profileName] : []]), 12e4, cwd, { signal, allowEmpty: true }, true);
+      if (!current()) return;
+      if (result.error) {
+        ui.notify(`New-app browser authorization: ${setupFailure(result)} Nothing was saved in Pie. Official CLI configuration may have changed.`, "warning");
+        return;
+      }
+      stage = "Authorization command completed, but chat listing failed (check app scopes and membership)";
+    } else if (action === "Use an existing app (configure in official terminal)") {
+      const terminal = deps.terminal?.(binary, cwd);
+      let manualReason = "Automatic terminal launch is unavailable on this system. No terminal was opened.";
+      let completed = false;
+      if (terminal) {
+        if (!await ui.confirm("Open official setup in a separate terminal?", "Pie will open a separate Windows terminal running official lark-cli config init --brand feishu. Choose the existing-app option, NOT create a new app. Official CLI configuration and profiles may change. Enter app ID and secret only in that terminal; never in Pie. Pie does not capture credentials. Continue?", options) || !current()) return;
+        const result = await run(terminal, [], 3e5, cwd, { signal, allowEmpty: true }, false, "Complete official setup in separate terminal. Pie does not capture credentials. Cancel closes the owned setup process tree.");
+        if (!current()) return;
+        completed = !result.error;
+        if (!completed) {
+          manualReason = /^timeout/.test(result.error ?? "") ? "Official terminal setup timed out (five-minute limit)." : "Official terminal setup failed or could not open.";
+          ui.notify(`${manualReason} Nothing was saved in Pie. Official CLI configuration may have changed.`, "warning");
+        }
+      }
+      if (!completed) {
+        const next = await ui.select(`IM forwarding setup \u2014 after official terminal configuration
+${manualReason}
+In your trusted terminal run: lark-cli config init --brand feishu
+Use your configured official CLI if it is not on PATH. Choose existing app, not create new. Profiles may change. Enter credentials only there, never in Pie.
+After completing that external step, select Recheck connection.`, ["Recheck connection", "Cancel"], options);
+        if (!current() || next !== "Recheck connection") return;
+      }
+      stage = "Official terminal setup completed, but chat listing failed (check app scopes and membership)";
+    } else if (action !== "Recheck connection") return;
+    chats = await discover();
+    if (!current()) return;
+  }
+  const directLabel = "Direct message a user (private chat)";
+  const manual = "Enter a chat_id manually";
+  const labels = (chats ?? []).map((chat) => `${chat.name} \u2014 ${chat.id}`);
+  let target;
+  while (!target && current()) {
+    const choice = await ui.select("IM forwarding setup \u2014 target (bots cannot list P2P chats; DM is supported)", [directLabel, ...labels, manual, "Cancel"], options);
+    if (!current() || !choice || choice === "Cancel") return;
+    if (choice === directLabel) {
+      const dm = await ui.select("IM forwarding setup \u2014 direct message", ["Detect from a message I send to the bot", "Enter user open_id (ou_...)", "Back"], options);
+      if (!current() || !dm || dm === "Back") continue;
+      if (dm.startsWith("Detect")) {
+        let resumeConsumer;
+        const suspend = deps.suspendEventConsumer ?? io.suspendEventConsumer;
+        try {
+          resumeConsumer = await suspend?.();
+        } catch {
+        }
+        try {
+          ui.notify("In Feishu, open the bot's private chat and send any message (for example hello). Pie will detect that P2P chat; it will not send anything.", "info");
+          let found;
+          const detect = await run(binary, withProfile(["event", "consume", "im.message.receive_v1", "--as", "bot"]), 9e4, cwd, { signal, allowEmpty: true, stdin: "pipe" }, false, "In Feishu, open the bot's private chat and send any message. Waiting up to 90 seconds for the DM chat to be detected; nothing is sent by Pie.", (line) => {
+            const event = parseDirectMessage(line);
+            if (!event) return false;
+            found = event;
+            return true;
+          });
+          if (!current()) return;
+          if (!found) {
+            const bus = /another event bus|already connected/i.test(`${detect.stdout}
+${detect.error ?? ""}`);
+            ui.notify(bus ? "No direct message detected: the app's event connection is still occupied (another consumer on this or another machine). Stop it, or bind a different app/profile, then retry." : "No direct message detected. Check the bot event subscription, try again, or enter the user's open_id.", "warning");
+            continue;
+          }
+          target = { chatId: found.chatId, allowUsers: [found.senderId] };
+          break;
+        } finally {
+          try {
+            resumeConsumer?.();
+          } catch {
+          }
+        }
+      }
+      const input = await ui.input("IM forwarding setup \u2014 direct-message user open_id", "ou_\u2026 (not a chat_id)", options);
+      if (!current() || !input?.trim()) continue;
+      const openId = input.trim();
+      if (!/^ou_[A-Za-z0-9_-]+$/.test(openId)) {
+        ui.notify("Invalid user open_id; expected ou_ followed by letters, digits, _ or -. Nothing was saved.", "error");
+        continue;
+      }
+      target = { openId, allowUsers: [openId] };
+      break;
+    }
+    if (choice === manual) {
+      const input = await ui.input("IM forwarding setup \u2014 chat_id", "oc_\u2026", options);
+      if (!current() || !input?.trim()) continue;
+      const chatId = input.trim();
+      if (!/^oc_[A-Za-z0-9_-]+$/.test(chatId)) {
+        ui.notify("Invalid chat_id; expected oc_ followed by letters, digits, _ or -. Nothing was saved.", "error");
+        continue;
+      }
+      target = { chatId };
+      break;
+    }
+    const group = chats?.[labels.indexOf(choice)]?.id;
+    if (group) {
+      target = { chatId: group };
+      break;
+    }
+  }
+  if (!current() || !target) return;
+  const boundAppId = profiles?.find((item) => item.name === profileName)?.appId ?? (profileName ? void 0 : profiles?.find((item) => item.active)?.appId);
+  return { ...previous ?? {}, ...target.openId ? { openId: target.openId, chatId: null } : { chatId: target.chatId, openId: null }, larkCli: executable ?? null, larkCliProfile: profileName ?? null, larkCliAppId: boundAppId ?? null, allowUsers: target.allowUsers ?? previous?.allowUsers ?? null };
+}
+
+// builtin/extensions/im-forward/providers/feishu/index.ts
+function normalizeEvent(line) {
+  let raw;
+  try {
+    raw = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!isRecord(raw) || raw.type !== "im.message.receive_v1" || typeof raw.event_id !== "string" || typeof raw.chat_id !== "string") return null;
+  const id = raw.message_id ?? raw.id;
+  if (typeof id !== "string") return null;
+  return {
+    event_id: raw.event_id,
+    message_id: id,
+    chat_id: raw.chat_id,
+    sender_id: typeof raw.sender_id === "string" ? raw.sender_id : void 0,
+    chatType: raw.chat_type === void 0 ? void 0 : typeof raw.chat_type === "string" ? raw.chat_type : "invalid",
+    text: extractInboundText(raw.content).replace(/\[Image:\s*img_[A-Za-z0-9_-]+\]/g, "").trim(),
+    images: extractImageKeys(raw.content)
+  };
+}
+function connect(binary, profile, targetKind = "chat") {
+  const lifetime = new AbortController();
+  const active = /* @__PURE__ */ new Set();
+  const native = (...args) => {
+    const pending = runLarkCli(...args);
+    active.add(pending);
+    void pending.finally(() => active.delete(pending));
+    return pending;
+  };
+  const call = async (args) => {
+    const result = await native(binary, profile ? [...args, "--profile", profile] : args, 3e4, void 0, { signal: lifetime.signal });
+    return result.error ? void 0 : parseLarkCliEnvelope(result.stdout).data;
+  };
+  return {
+    sourcePrefix: "[Feishu]",
+    async dispose() {
+      lifetime.abort();
+      await Promise.allSettled([...active]);
+    },
+    async send(target, text, key, replyTo) {
+      const recipient = targetKind === "user" ? ["--user-id", target] : ["--chat-id", target];
+      const data = await call(replyTo ? ["im", "+messages-reply", "--as", "bot", "--message-id", replyTo, "--markdown", text, "--idempotency-key", key] : ["im", "+messages-send", "--as", "bot", ...recipient, "--markdown", text, "--idempotency-key", key]);
+      return typeof data?.message_id === "string" ? { messageId: data.message_id, threadId: typeof data.thread_id === "string" ? data.thread_id : null } : null;
+    },
+    async acknowledge(id) {
+      await call(["im", "reactions", "create", "--as", "bot", "--params", JSON.stringify({ message_id: id }), "--data", JSON.stringify({ reaction_type: { emoji_type: "THUMBSUP" } })]);
+    },
+    async metadata(id) {
+      const data = await call(["im", "+messages-mget", "--as", "bot", "--message-ids", id]);
+      const message = Array.isArray(data?.messages) ? data.messages[0] : void 0;
+      return isRecord(message) ? { threadId: typeof message.thread_id === "string" && message.thread_id || null, replyTo: typeof message.reply_to === "string" && message.reply_to || null } : null;
+    },
+    async threadMessages(id) {
+      const data = await call(["im", "+threads-messages-list", "--as", "bot", "--thread", id]);
+      return Array.isArray(data?.messages) ? data.messages.flatMap((message) => isRecord(message) && typeof message.message_id === "string" ? [message.message_id] : []) : null;
+    },
+    async downloadImage(messageId, image, index) {
+      const directory = fs4.mkdtempSync(path6.join(os2.tmpdir(), "pie-im-forward-"));
+      const cleanup = () => fs4.rmSync(directory, { recursive: true, force: true });
+      try {
+        const name = `image-${index + 1}.png`;
+        const result = await native(binary, profile ? ["im", "+messages-resources-download", "--as", "bot", "--message-id", messageId, "--file-key", image, "--type", "image", "--output", name, "--profile", profile] : ["im", "+messages-resources-download", "--as", "bot", "--message-id", messageId, "--file-key", image, "--type", "image", "--output", name], 3e4, directory, { signal: lifetime.signal });
+        if (result.error || !parseLarkCliEnvelope(result.stdout).ok) throw new Error("Image download failed");
+        let target = path6.join(directory, name);
+        if (fs4.statSync(target).size > 10 * 1024 * 1024) throw new Error("Image exceeds 10 MiB");
+        const detected = readImageFormat(target);
+        if (detected.ext === ".bin") throw new Error("Unsupported image format");
+        if (detected.ext !== ".png") {
+          const corrected = path6.join(directory, `image-${index + 1}${detected.ext}`);
+          fs4.renameSync(target, corrected);
+          target = corrected;
+        }
+        return { file: { path: target, displayName: `feishu-image-${index + 1}${detected.ext}` }, cleanup };
+      } catch (error) {
+        cleanup();
+        throw error;
+      }
+    },
+    consume(callbacks) {
+      let stopped = false;
+      let closed = false;
+      let failed = false;
+      let lastErrorLine = "";
+      const child = spawn4(binary.command, [...binary.prefix, "event", "consume", "im.message.receive_v1", "--as", "bot", ...profile ? ["--profile", profile] : []], { stdio: ["pipe", "pipe", "pipe"], shell: false, windowsHide: true, detached: process.platform !== "win32" });
+      const fail = (reason) => {
+        if (!failed && !stopped) {
+          failed = true;
+          callbacks.failure(lastErrorLine ? `${reason} \u2014 ${lastErrorLine}` : reason);
+        }
+      };
+      child.stdin?.on("error", () => void 0);
+      const output = lineReader((line) => {
+        if (closed) return;
+        const event = normalizeEvent(line);
+        if (event) callbacks.event(event);
+      });
+      const safeErrorPatterns = [
+        /another event bus is already connected/i,
+        /no active profile/i,
+        /not configured/i,
+        /authorization|unauthorized|token/i,
+        /permission/i,
+        /connect|network|dns|timeout/i
+      ];
+      const errors = lineReader((line) => {
+        const text = line.trim();
+        if (!text) return;
+        if (text.startsWith("[event] ready")) {
+          if (!failed && !stopped) callbacks.ready();
+          return;
+        }
+        if (safeErrorPatterns.some((pattern) => pattern.test(text)) && text.length <= 200) lastErrorLine = text;
+      }, 4096);
+      child.stdout?.on("data", output.write);
+      child.stdout?.on("end", output.end);
+      child.stderr?.on("data", errors.write);
+      child.stderr?.on("end", errors.end);
+      child.on("error", () => fail("Feishu consumer spawn failed"));
+      child.on("exit", (code, signal) => fail(`Feishu consumer code=${code} signal=${signal}`));
+      child.on("close", (code, signal) => {
+        closed = true;
+        fail(`Feishu consumer code=${code} signal=${signal}`);
+      });
+      return { async stop() {
+        stopped = true;
+        if (!closed) await shutdownConsumer(child);
+      } };
+    }
+  };
+}
+var feishuProvider = {
+  id: "feishu",
+  label: "Feishu (Lark)",
+  resolve(raw) {
+    const chatId = typeof raw.chatId === "string" ? raw.chatId.trim() : "";
+    const openId = typeof raw.openId === "string" ? raw.openId.trim() : "";
+    const targetKind = /^oc_[A-Za-z0-9_-]+$/.test(chatId) ? "chat" : /^ou_[A-Za-z0-9_-]+$/.test(openId) ? "user" : void 0;
+    if (!targetKind) return null;
+    const allowed = Array.isArray(raw.allowUsers) ? raw.allowUsers.filter((id) => typeof id === "string" && !!id.trim()) : void 0;
+    const appId = typeof raw.larkCliAppId === "string" && raw.larkCliAppId.trim() ? raw.larkCliAppId.trim() : void 0;
+    return { ...raw, targetId: targetKind === "user" ? openId : chatId, targetKind, allowUsers: allowed?.length ? allowed : void 0, ...appId ? { appId } : {} };
+  },
+  connect(settings, cwd) {
+    const binary = resolveLaunchSpec(typeof settings.larkCli === "string" ? settings.larkCli : void 0, cwd);
+    const profile = typeof settings.larkCliProfile === "string" && settings.larkCliProfile.trim() ? settings.larkCliProfile.trim() : void 0;
+    return binary ? connect(binary, profile, settings.targetKind) : null;
+  },
+  setup: setupFeishu
+};
+
+// builtin/extensions/im-forward/index.ts
+var implementedProviders = [feishuProvider];
+function imForward(ctx) {
+  initializeImForward(ctx);
+}
+function initializeImForward(ctx, providers = implementedProviders) {
+  if (!ctx.hasUI) return;
+  const dir = resolveConfigDir();
+  let disposed = false;
+  let session = null;
+  let setupAbort;
+  let setupFlight;
+  let activeConfig;
+  let runtimeCleanup;
+  let suspendEventConsumer;
+  let toggle;
+  let status;
+  let handlers = /* @__PURE__ */ new Map();
+  const events = ["terminal:input", "message:end", "turn:failed", "turn:cancelled", "session:changed"];
+  for (const name of events) ctx.on(name, (event) => {
+    if (disposed) return;
+    if (name === "session:changed") {
+      session = event.sessionId;
+      setupAbort?.abort();
+    }
+    return handlers.get(name)?.(event);
+  });
+  let warnedMismatch = false;
+  function liveEnabled(config) {
+    if (disposed) return false;
+    const live = readLiveConfig(ctx.cwd, dir);
+    if (live.problems.length || !live.config || configurationIdentity(live.config) !== configurationIdentity(config)) {
+      ctx.ui.setStatus?.("im-forward", "[IM!]");
+      if (!warnedMismatch) {
+        warnedMismatch = true;
+        ctx.ui.notify("IM forwarding configuration changed or cannot be read. Forwarding is paused; run /im-forward setup.", "warning");
+      }
+      return null;
+    }
+    return live.config.enabled;
+  }
+  function activate(config) {
+    if (disposed) return;
+    const provider = providers.find((item) => item.id === config.provider);
+    if (!provider) {
+      ctx.ui.notify(`IM forwarding: unsupported provider "${config.provider}". Run /im-forward setup.`, "error");
+      ctx.ui.setStatus?.("im-forward", "[IM!]");
+      return;
+    }
+    try {
+      const settings = provider.resolve(config.settings);
+      if (!settings) {
+        ctx.ui.notify(`IM forwarding: ${provider.label} target/settings are incomplete. Use Ctrl+I or /im-forward setup.`, "warning");
+        ctx.ui.setStatus?.("im-forward", "[IM!]");
+        return;
+      }
+      const connection = provider.connect(settings, ctx.cwd);
+      if (!connection) {
+        ctx.ui.notify(`IM forwarding: ${provider.label} connection could not be prepared. Use Ctrl+I or /im-forward setup to check provider dependencies and configuration.`, "warning");
+        ctx.ui.setStatus?.("im-forward", "[IM!]");
+        return;
+      }
+      activeConfig = config;
+      warnedMismatch = false;
+      const bridge = Object.create(ctx);
+      bridge.on = (name, handler) => {
+        handlers.set(name, handler);
+      };
+      bridge.registerShortcut = (_key, shortcut) => {
+        toggle = shortcut.handler;
+      };
+      bridge.registerCommand = (command) => {
+        status = command.handler;
+      };
+      bridge.registerCleanup = (cleanup) => {
+        runtimeCleanup = async () => {
+          await cleanup("runtime_switch", AbortSignal.abort());
+        };
+        return () => {
+        };
+      };
+      createRuntime(bridge, { enabled: config.enabled, provider: config.provider, label: provider.label, targetId: settings.targetId, targetKind: settings.targetKind, allowUsers: settings.allowUsers, retryBackoffMs: config.retryBackoffMs, ...settings.appId ? { appId: settings.appId } : {} }, connection, () => liveEnabled(config), (next) => {
+        const latest = readLiveConfig(ctx.cwd, dir);
+        if (latest.problems.length || !latest.config || configurationIdentity(latest.config) !== configurationIdentity(config)) throw new Error("Configuration changed; setup required");
+        writeConfig(ctx.cwd, dir, { enabled: next });
+      });
+      if (session) handlers.get("session:changed")?.({ type: "session:changed", sessionId: session });
+      ctx.__forceInboundRetriesForTest = bridge.__forceInboundRetriesForTest;
+      suspendEventConsumer = bridge.suspendEventConsumer?.bind(bridge);
+    } catch {
+      ctx.ui.notify(`IM forwarding: ${provider.id} initialization failed; check provider configuration/authentication.`, "error");
+      ctx.ui.setStatus?.("im-forward", "[IM!]");
+    }
+  }
+  async function retire() {
+    handlers = /* @__PURE__ */ new Map();
+    toggle = void 0;
+    status = void 0;
+    activeConfig = void 0;
+    suspendEventConsumer = void 0;
+    const cleanup = runtimeCleanup;
+    runtimeCleanup = void 0;
+    ctx.ui.setStatus?.("im-forward", void 0);
+    try {
+      await cleanup?.();
+    } catch {
+      ctx.log("im-forward: runtime cleanup failed");
+    }
+  }
+  function setup(intent = "first-run") {
+    if (setupFlight) return setupFlight;
+    if (disposed) return Promise.resolve();
+    const controller = new AbortController();
+    setupAbort = controller;
+    const setupScope = ctx.beginUserInput?.(() => !disposed && !controller.signal.aborted);
+    controller.signal.addEventListener("abort", () => setupScope?.dispose(), { once: true });
+    const current = () => {
+      if (setupScope && !setupScope.isCurrent()) controller.abort();
+      return !disposed && !controller.signal.aborted;
+    };
+    setupFlight = (async () => {
+      try {
+        const config = await runSetup(ctx, dir, providers, controller.signal, current, intent, suspendEventConsumer);
+        if (!config || disposed) return;
+        await retire();
+        if (!disposed) {
+          const latest = resolveConfig(ctx.cwd, dir);
+          if (latest.problems.length || !latest.config) {
+            ctx.ui.setStatus?.("im-forward", "[IM!]");
+            ctx.ui.notify("IM forwarding configuration cannot be read; run /im-forward setup.", "error");
+          } else activate(latest.config);
+        }
+      } catch {
+        if (!disposed && !controller.signal.aborted) ctx.ui.notify("IM forwarding setup could not complete; check configuration path permissions and provider authentication.", "error");
+      } finally {
+        setupScope?.dispose();
+        setupFlight = void 0;
+        if (setupAbort === controller) setupAbort = void 0;
+      }
+    })();
+    return setupFlight;
+  }
+  async function toggleNow(commandCtx) {
+    if (!toggle || !activeConfig) {
+      await setup();
+      return;
+    }
+    const latest = resolveConfig(ctx.cwd, dir);
+    if (!latest.config || latest.problems.length || configurationIdentity(latest.config) !== configurationIdentity(activeConfig)) {
+      commandCtx.ui.notify("IM forwarding configuration changed. Run /im-forward setup before forwarding.", "warning");
+      ctx.ui.setStatus?.("im-forward", "[IM!]");
+      return;
+    }
+    await toggle(commandCtx);
+  }
+  function showStatus(commandCtx) {
+    if (status) status(commandCtx);
+    else commandCtx.ui.notify("IM forwarding is not configured or unavailable. Use Ctrl+I or /im-forward setup.", "info");
+  }
+  async function clearConfiguration(commandCtx) {
+    setupAbort?.abort();
+    try {
+      const removed = await clearImConfig(ctx.cwd, dir, (message) => commandCtx.ui.confirm("Clear IM forwarding configuration", `${message}
+
+This does not remove the app credentials lark-cli itself stores; re-running setup may reuse the previous app.`));
+      if (disposed) return;
+      if (!removed) {
+        commandCtx.ui.notify(hasConfigLayers(ctx.cwd, dir) ? "IM forwarding configuration was not cleared." : "No IM forwarding configuration files exist.", "info");
+        return;
+      }
+      await retire();
+      commandCtx.ui.notify("IM forwarding configuration cleared. Use /im-forward setup to configure again.", "info");
+    } catch (error) {
+      ctx.ui.setStatus?.("im-forward", "[IM!]");
+      commandCtx.ui.notify(error.message || "IM forwarding configuration could not be cleared.", "error");
+    }
+  }
+  ctx.registerShortcut("ctrl+i", { description: "Set up or toggle IM forwarding", handler: () => toggleNow(ctx) });
+  ctx.registerCommand({ path: ["im-forward", "status"], description: "Show IM forwarding status", handler: async (commandCtx) => {
+    if (!disposed) showStatus(commandCtx);
+  } });
+  ctx.registerCommand({ path: ["im-forward", "switch-app"], description: "Rebind the configured platform to a different app/account", handler: async () => {
+    if (!disposed) await setup("switch-app");
+  } });
+  ctx.registerCommand({ path: ["im-forward", "setup"], description: "Run the IM forwarding setup wizard", handler: async () => {
+    if (!disposed) await setup();
+  } });
+  ctx.registerCommand({ path: ["im-forward", "toggle"], description: "Toggle IM forwarding on/off (same as Ctrl+I)", handler: async (commandCtx) => {
+    if (!disposed) await toggleNow(commandCtx);
+  } });
+  ctx.registerCommand({ path: ["im-forward", "clear"], description: "Remove IM forwarding configuration (with confirmation)", handler: async (commandCtx) => {
+    if (!disposed) await clearConfiguration(commandCtx);
+  } });
+  ctx.registerCommand({ name: "im-forward", path: ["im-forward"], description: "IM forwarding menu (status/setup/toggle/clear)", handler: async (commandCtx, args) => {
+    if (disposed) return;
+    const arg = args?.trim();
+    if (arg === "status") {
+      showStatus(commandCtx);
+      return;
+    }
+    if (arg === "setup") {
+      await setup();
+      return;
+    }
+    if (arg === "switch-app") {
+      await setup("switch-app");
+      return;
+    }
+    if (arg === "toggle") {
+      await toggleNow(commandCtx);
+      return;
+    }
+    if (arg === "clear") {
+      await clearConfiguration(commandCtx);
+      return;
+    }
+    if (arg) {
+      commandCtx.ui.notify("Usage: /im-forward [status|setup|switch-app|toggle|clear]; bare /im-forward opens the menu", "info");
+      return;
+    }
+    const options = toggle && activeConfig ? ["Status", "Setup\u2026", "Switch app\u2026", "Toggle forwarding on/off", "Clear configuration\u2026"] : hasConfigLayers(ctx.cwd, dir) ? ["Status", "Setup\u2026", "Switch app\u2026", "Clear configuration\u2026"] : ["Setup\u2026"];
+    const choice = await commandCtx.ui.select("IM forwarding", options);
+    if (disposed || !choice) return;
+    if (choice === "Status") showStatus(commandCtx);
+    else if (choice === "Setup\u2026") await setup();
+    else if (choice === "Switch app\u2026") await setup("switch-app");
+    else if (choice === "Toggle forwarding on/off") await toggleNow(commandCtx);
+    else if (choice === "Clear configuration\u2026") await clearConfiguration(commandCtx);
+  } });
+  ctx.registerCleanup?.(async () => {
+    disposed = true;
+    setupAbort?.abort();
+    await retire();
+    ctx.ui.setStatus?.("im-forward", void 0);
+  });
+  const initial = resolveConfig(ctx.cwd, dir);
+  if (initial.problems.length) {
+    ctx.ui.notify(initial.problems.join("\n"), "error");
+    ctx.ui.setStatus?.("im-forward", "[IM!]");
+  } else if (initial.config) activate(initial.config);
+}
+export {
+  assistantForwardText,
+  composeForwardBody,
+  imForward as default,
+  detectImageMime,
+  estimatePostRequestBytes,
+  extractImageKey,
+  extractImageKeys,
+  extractInboundText,
+  failureReason,
+  initializeImForward,
+  inputHeaderLine,
+  parseLarkCliEnvelope,
+  readLiveConfig,
+  readLiveEnabled,
+  resolveImForwardConfig,
+  sessionLabel,
+  truncateMarkdown
+};