@colinagent/hulala-bot 0.0.0-stage → 0.3.2

package/dist/plugin.mjs

@@ -0,0 +1,2432 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/host/plugin.ts
+import { join as join5 } from "node:path";
+import z from "@deepseek-ai/schemastery";
+
+// src/bridge.ts
+import { randomUUID } from "node:crypto";
+import { stat } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
+
+// src/config.ts
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { promisify } from "node:util";
+
+// src/telegram/proxy.ts
+import http from "node:http";
+import https from "node:https";
+import tls from "node:tls";
+function normalizeProxy(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(`proxy must be an http:// or https:// URL, not ${JSON.stringify(value)}`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`proxy must be an http:// or https:// URL, not ${JSON.stringify(value)}`);
+  }
+  if (url.hostname === "") {
+    throw new Error(`proxy has no host: ${JSON.stringify(value)}`);
+  }
+  return url.toString();
+}
+function tunnel(proxy, host, port, secure, done) {
+  const proxySecure = proxy.protocol === "https:";
+  const authorization = proxy.username === "" ? undefined : `Basic ${Buffer.from(`${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`).toString("base64")}`;
+  const request = (proxySecure ? https : http).request({
+    host: proxy.hostname,
+    port: Number(proxy.port || (proxySecure ? 443 : 80)),
+    method: "CONNECT",
+    path: `${host}:${String(port)}`,
+    headers: {
+      host: `${host}:${String(port)}`,
+      ...authorization === undefined ? {} : { "proxy-authorization": authorization }
+    },
+    timeout: 20000
+  });
+  request.once("connect", (response, socket) => {
+    if (response.statusCode !== 200) {
+      socket.destroy();
+      const detail = response.statusMessage === undefined ? "" : ` ${response.statusMessage}`;
+      done(new Error(`proxy CONNECT failed: ${String(response.statusCode)}${detail}`));
+      return;
+    }
+    if (!secure) {
+      done(null, socket);
+      return;
+    }
+    const wrapped = tls.connect({ socket, servername: host });
+    wrapped.once("secureConnect", () => done(null, wrapped));
+    wrapped.once("error", (error) => done(error));
+  });
+  request.once("error", (error) => done(error));
+  request.once("timeout", () => request.destroy(new Error("proxy CONNECT timed out")));
+  request.end();
+}
+function connect(proxy, options, secure, callback) {
+  const host = options.host ?? "localhost";
+  const port = Number(options.port ?? (secure ? 443 : 80));
+  tunnel(proxy, host, port, secure, (error, socket) => {
+    if (callback === undefined)
+      return;
+    if (socket === undefined)
+      callback(error ?? new Error("no socket from the proxy"), undefined);
+    else
+      callback(error, socket);
+  });
+  return;
+}
+
+class HttpTunnelAgent extends http.Agent {
+  #proxy;
+  constructor(proxy) {
+    super({ keepAlive: false });
+    this.#proxy = proxy;
+  }
+  createConnection(options, callback) {
+    return connect(this.#proxy, options, false, callback);
+  }
+}
+
+class HttpsTunnelAgent extends https.Agent {
+  #proxy;
+  constructor(proxy) {
+    super({ keepAlive: false });
+    this.#proxy = proxy;
+  }
+  createConnection(options, callback) {
+    return connect(this.#proxy, options, true, callback);
+  }
+}
+function createProxiedFetch(proxy) {
+  const address = new URL(normalizeProxy(proxy));
+  return async (input, init = {}) => {
+    const target = new URL(input instanceof Request ? input.url : input instanceof URL ? input.href : input);
+    const secure = target.protocol === "https:";
+    const agent = secure ? new HttpsTunnelAgent(address) : new HttpTunnelAgent(address);
+    const headers = {};
+    new Headers(init.headers).forEach((value, name) => {
+      headers[name] = value;
+    });
+    const body = typeof init.body === "string" ? init.body : undefined;
+    const status = await new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (error, result) => {
+        if (settled)
+          return;
+        settled = true;
+        if (error === null && result !== undefined)
+          resolve(result);
+        else
+          reject(error ?? new Error("proxy request failed"));
+      };
+      const request = (secure ? https : http).request({
+        host: target.hostname,
+        port: Number(target.port || (secure ? 443 : 80)),
+        path: `${target.pathname}${target.search}`,
+        method: init.method ?? "GET",
+        headers,
+        agent,
+        signal: init.signal ?? undefined
+      }, (response) => {
+        const chunks = [];
+        response.on("data", (chunk) => chunks.push(chunk));
+        response.on("end", () => finish(null, { code: response.statusCode ?? 0, text: Buffer.concat(chunks).toString("utf8") }));
+        response.on("error", (error) => finish(error));
+      });
+      request.once("error", (error) => finish(error));
+      request.end(body);
+    });
+    const responseHeaders = new Headers;
+    return new Response(status.text, { status: status.code, headers: responseHeaders });
+  };
+}
+
+// src/config.ts
+var run = promisify(execFile);
+var TELEGRAM_API = "https://api.telegram.org";
+var LARK_API = "https://open.feishu.cn/open-apis";
+var LARK_API_INTERNATIONAL = "https://open.larksuite.com/open-apis";
+function hulalaHome(env = process.env) {
+  return env.HULALA_HOME ?? join(homedir(), ".hulala");
+}
+function botStateDir(env = process.env) {
+  const dshHome = env.DSH_HOME;
+  if (dshHome !== undefined && dshHome !== "")
+    return join(dshHome, "config", "hulala-bot");
+  return join(hulalaHome(env), "config", "hulala-bot");
+}
+function expandHome(path) {
+  if (path === "~")
+    return homedir();
+  if (path.startsWith("~/"))
+    return join(homedir(), path.slice(2));
+  return path;
+}
+async function readKeychain(ref) {
+  const slash = ref.lastIndexOf("/");
+  const service = slash === -1 ? ref : ref.slice(0, slash);
+  const account = slash === -1 ? ref : ref.slice(slash + 1);
+  try {
+    if (process.platform === "darwin") {
+      const { stdout: stdout2 } = await run("security", ["find-generic-password", "-s", service, "-a", account, "-w"]);
+      return stdout2.trim() || undefined;
+    }
+    const { stdout } = await run("secret-tool", ["lookup", "service", service, "account", account]);
+    return stdout.trim() || undefined;
+  } catch {
+    return;
+  }
+}
+async function resolveSecret(raw, env, field) {
+  const direct = raw[field];
+  if (typeof direct === "string" && direct.trim() !== "")
+    return direct;
+  const envName = raw[`${field}Env`];
+  if (typeof envName === "string" && envName !== "") {
+    const value = env[envName];
+    if (value !== undefined && value.trim() !== "")
+      return value;
+  }
+  const ref = raw[`${field}Ref`];
+  if (typeof ref === "string" && ref !== "")
+    return await readKeychain(ref);
+  return;
+}
+async function readFileConfig(env, root) {
+  const stateDir = root ?? env.HULALA_BOT_STATE ?? botStateDir(env);
+  const file = env.HULALA_BOT_CONFIG ?? join(stateDir, "config.json");
+  let raw = {};
+  try {
+    raw = JSON.parse(await readFile(file, "utf8"));
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+  return { raw, file, stateDir };
+}
+async function telegramConfig(raw, env, file) {
+  if (raw === undefined)
+    return;
+  const token = await resolveSecret(raw, env, "token") ?? env.TELEGRAM_BOT_TOKEN;
+  if (token === undefined || token.trim() === "") {
+    throw new Error(`no Telegram bot token: set tokenRef in ${file}, or TELEGRAM_BOT_TOKEN in the environment`);
+  }
+  const allowedUsers = (raw.allowedUsers ?? []).map(Number).filter(Number.isSafeInteger);
+  const allowedChats = (raw.allowedChats ?? []).map(Number).filter(Number.isSafeInteger);
+  if (allowedUsers.length === 0 && allowedChats.length === 0) {
+    throw new Error(`refusing to start Telegram with an empty allowlist: set telegram.allowedUsers or telegram.allowedChats in ${file}`);
+  }
+  const parseMode = raw.parseMode ?? "markdown";
+  if (parseMode !== "markdown" && parseMode !== "plain") {
+    throw new Error(`telegram.parseMode must be "markdown" or "plain", not ${JSON.stringify(String(parseMode))}`);
+  }
+  const pollSeconds = Number.isFinite(raw.pollTimeoutSeconds) ? raw.pollTimeoutSeconds : 25;
+  return {
+    token,
+    baseUrl: (raw.baseUrl ?? TELEGRAM_API).replace(/\/$/, ""),
+    proxy: raw.proxy === undefined ? undefined : normalizeProxy(raw.proxy),
+    allowedUsers,
+    allowedChats,
+    parseMode,
+    pollTimeoutSeconds: Math.max(1, Math.min(50, pollSeconds))
+  };
+}
+async function larkConfig(raw, env, file) {
+  if (raw === undefined)
+    return;
+  const appId = (raw.appId ?? "").trim();
+  if (!/^cli_[0-9a-fA-F]{16}$/.test(appId)) {
+    throw new Error(`lark.appId must look like cli_<16 hex>, not ${JSON.stringify(appId)} (from ${file})`);
+  }
+  const appSecret = await resolveSecret(raw, env, "appSecret") ?? env.LARK_APP_SECRET;
+  if (appSecret === undefined || appSecret.trim() === "") {
+    throw new Error(`no Lark app secret: set lark.appSecretRef in ${file}, or LARK_APP_SECRET in the environment`);
+  }
+  const allowedUsers = (raw.allowedUsers ?? []).map((entry) => entry.trim()).filter((entry) => entry !== "");
+  const allowedChats = (raw.allowedChats ?? []).map((entry) => entry.trim()).filter((entry) => entry !== "");
+  if (allowedUsers.length === 0 && allowedChats.length === 0) {
+    throw new Error(`refusing to start Lark with an empty allowlist: set lark.allowedUsers (open ids) or lark.allowedChats in ${file}`);
+  }
+  const domain = raw.domain ?? "feishu";
+  if (domain !== "feishu" && domain !== "lark") {
+    throw new Error(`lark.domain must be "feishu" or "lark", not ${JSON.stringify(String(domain))}`);
+  }
+  return {
+    appId,
+    appSecret,
+    domain,
+    baseUrl: (raw.baseUrl ?? (domain === "lark" ? LARK_API_INTERNATIONAL : LARK_API)).replace(/\/$/, ""),
+    allowedUsers,
+    allowedChats
+  };
+}
+async function loadConfig(env = process.env, root) {
+  const { raw, file, stateDir } = await readFileConfig(env, root);
+  const telegram = await telegramConfig(raw.telegram, env, file);
+  const lark = await larkConfig(raw.lark, env, file);
+  if (telegram === undefined && lark === undefined) {
+    throw new Error(`no channel configured: add a "telegram" or "lark" section to ${file}`);
+  }
+  const streamIntervalMs = Number.isFinite(raw.streamIntervalMs) ? raw.streamIntervalMs : 800;
+  return {
+    defaultCwd: resolve(expandHome(raw.defaultCwd ?? join(homedir(), "hulala-workspace", "workspace"))),
+    streamIntervalMs: Math.max(300, streamIntervalMs),
+    stateDir,
+    telegram,
+    lark
+  };
+}
+
+// src/host/turn.ts
+function textOfContent(content) {
+  if (!Array.isArray(content))
+    return "";
+  return content.flatMap((block) => {
+    if (block === null || typeof block !== "object")
+      return [];
+    const record = block;
+    return record.type === "text" && typeof record.text === "string" ? [record.text] : [];
+  }).join(`
+`);
+}
+var TOOL_LABELS = {
+  bash: "运行命令",
+  job_output: "等待任务输出",
+  job_kill: "结束任务",
+  read: "读文件",
+  write: "写文件",
+  edit: "改文件",
+  multi_edit: "改文件",
+  apply_patch: "改文件",
+  grep: "搜索内容",
+  glob: "找文件",
+  ls: "列目录",
+  todo_write: "更新计划",
+  ask_user_question: "向你提问",
+  web_fetch: "取网页",
+  web_search: "搜索网页"
+};
+var TOOL_DETAIL = ["command", "path", "file_path", "pattern", "query", "url", "description"];
+function describeTool(name, rawArguments) {
+  const label = TOOL_LABELS[name] ?? name;
+  if (typeof rawArguments !== "string" || rawArguments === "")
+    return { label };
+  let args;
+  try {
+    args = JSON.parse(rawArguments);
+  } catch {
+    return { label };
+  }
+  for (const field of TOOL_DETAIL) {
+    const value = args[field];
+    if (typeof value !== "string" || value.trim() === "")
+      continue;
+    const line = value.replace(/\s+/g, " ").trim();
+    return { label, detail: line.length > 80 ? `${line.slice(0, 80)}…` : line };
+  }
+  return { label };
+}
+
+class TurnTracker {
+  #streamed = "";
+  #durable = "";
+  #tools = 0;
+  #tool;
+  #attempt;
+  begin() {
+    this.#streamed = "";
+    this.#durable = "";
+    this.#tools = 0;
+    this.#tool = undefined;
+    this.#attempt = undefined;
+  }
+  get preview() {
+    if (this.text !== "")
+      return this.text;
+    if (this.#tool === undefined)
+      return "";
+    return this.#tool.detail === undefined ? `· ${this.#tool.label} …` : `· ${this.#tool.label}：${this.#tool.detail}`;
+  }
+  get text() {
+    return this.#durable !== "" ? this.#durable : this.#streamed;
+  }
+  get empty() {
+    return this.text === "";
+  }
+  get view() {
+    return { streamed: this.#streamed, durable: this.#durable, tools: this.#tools };
+  }
+  apply(frame) {
+    if (frame.type === "snapshot") {
+      if (frame.assistantStream?.activeAttempt !== undefined) {
+        this.#attempt = frame.assistantStream.activeAttempt.attemptId;
+        this.#streamed = "";
+      }
+      return;
+    }
+    if (frame.type === "assistant-stream") {
+      const inner = frame.frame;
+      if (inner.type === "start") {
+        this.#attempt = inner.attemptId;
+        this.#streamed = "";
+        return "delta";
+      }
+      if (inner.type === "chunk" && inner.attemptId === this.#attempt) {
+        const chunk = inner.chunk;
+        if (chunk.type === "text-delta" && typeof chunk.text === "string") {
+          this.#streamed += chunk.text;
+          return "delta";
+        }
+        return;
+      }
+      return;
+    }
+    const event = frame.event;
+    if (event.type === "turn/start") {
+      this.begin();
+      return "begin";
+    }
+    if (event.type === "turn/end")
+      return "end";
+    if (event.type === "assistant/message") {
+      const content = event.data.message?.content;
+      const text = textOfContent(content).trim();
+      if (text !== "")
+        this.#durable = text;
+      return "final";
+    }
+    if (event.type === "tool/call") {
+      this.#tools += 1;
+      const data = event.data;
+      this.#tool = describeTool(typeof data.name === "string" ? data.name : "tool", data.arguments);
+      return "delta";
+    }
+    return;
+  }
+}
+
+// src/render/split.ts
+var BUDGET = 3600;
+var FENCE_TAIL = "\n```";
+function fenceHead(language) {
+  return `\`\`\`${language}
+`;
+}
+function splitMessage(text, limit = BUDGET) {
+  if (text.length <= limit)
+    return [text];
+  const chunks = [];
+  let current = "";
+  let openFence;
+  const flush = () => {
+    if (current.trim() === "")
+      return;
+    chunks.push(openFence === undefined ? current : `${current}${FENCE_TAIL}`);
+    current = openFence === undefined ? "" : fenceHead(openFence);
+  };
+  for (const line of text.split(`
+`)) {
+    const reserve = openFence === undefined ? 0 : FENCE_TAIL.length;
+    if (current !== "" && current.length + line.length + 1 + reserve > limit)
+      flush();
+    if (line.length > limit) {
+      const stride = Math.max(1, limit - reserve - 1);
+      for (let index = 0;index < line.length; index += stride) {
+        if (current !== "")
+          flush();
+        current = line.slice(index, index + stride);
+        flush();
+      }
+      continue;
+    }
+    current = current === "" || current.endsWith(`
+`) ? `${current}${line}` : `${current}
+${line}`;
+    if (line.startsWith("```")) {
+      openFence = openFence === undefined ? line.slice(3).trim() : undefined;
+    }
+  }
+  if (current.trim() !== "")
+    chunks.push(openFence === undefined ? current : `${current}${FENCE_TAIL}`);
+  return chunks;
+}
+function previewOf(text, limit = BUDGET) {
+  if (text.length <= limit)
+    return text;
+  const first = splitMessage(text, limit - 8)[0] ?? "";
+  return `${first.replace(/\n+$/, "")}
+…`;
+}
+
+// src/reply.ts
+var MAX_FAILURES = 3;
+var TYPING_INTERVAL_MS = 4000;
+var PLACEHOLDER = "⋯ 正在思考";
+function project(channel, raw) {
+  const text = channel.format(raw);
+  return { raw, text, parts: splitMessage(text, channel.maxTextLength) };
+}
+function preview(channel, raw) {
+  const text = channel.format(raw);
+  const head = previewOf(text, channel.maxTextLength);
+  return { raw, text: head, parts: [head] };
+}
+
+class ReplyStream {
+  #channel;
+  #chat;
+  #options;
+  #messageId;
+  #latest;
+  #lastText = "";
+  #lastSentAt = 0;
+  #timer;
+  #typing;
+  #failures = 0;
+  #degraded = false;
+  #closed = false;
+  constructor(channel, chat, options) {
+    this.#channel = channel;
+    this.#chat = chat;
+    this.#options = options;
+  }
+  async begin() {
+    if (this.#messageId !== undefined || this.#closed)
+      return;
+    try {
+      const placeholder = project(this.#channel, PLACEHOLDER);
+      this.#messageId = await this.#channel.send(this.#chat, placeholder, { preview: false });
+      this.#lastText = placeholder.text;
+      this.#lastSentAt = Date.now();
+      this.#startTyping();
+    } catch {
+      this.#degraded = true;
+    }
+  }
+  #startTyping() {
+    if (this.#options.typing === false || this.#typing !== undefined)
+      return;
+    const channel = this.#channel;
+    if (channel.typing === undefined)
+      return;
+    const beat = () => {
+      channel.typing?.(this.#chat).catch(() => {
+        return;
+      });
+    };
+    beat();
+    this.#typing = setInterval(beat, TYPING_INTERVAL_MS);
+    this.#typing.unref();
+  }
+  #stopTyping() {
+    if (this.#typing === undefined)
+      return;
+    clearInterval(this.#typing);
+    this.#typing = undefined;
+  }
+  async push(text) {
+    if (this.#closed || this.#degraded || text.trim() === "")
+      return;
+    this.#latest = text;
+    if (this.#timer !== undefined)
+      return;
+    const wait = this.#options.intervalMs - (Date.now() - this.#lastSentAt);
+    if (wait <= 0) {
+      await this.#flush();
+      return;
+    }
+    this.#timer = setTimeout(() => {
+      this.#timer = undefined;
+      this.#flush();
+    }, wait);
+  }
+  async#flush() {
+    const latest = this.#latest;
+    if (latest === undefined)
+      return;
+    const body = preview(this.#channel, latest);
+    if (body.text === this.#lastText)
+      return;
+    await this.#edit(body);
+  }
+  async#edit(body) {
+    if (this.#messageId === undefined)
+      return;
+    try {
+      await this.#channel.edit(this.#chat, this.#messageId, body, { preview: false });
+      this.#lastText = body.text;
+      this.#lastSentAt = Date.now();
+      this.#failures = 0;
+    } catch (error) {
+      const wait = this.#channel.retryAfterMs?.(error);
+      if (wait !== undefined) {
+        this.#lastSentAt = Date.now() + wait;
+        return;
+      }
+      this.#failures += 1;
+      if (this.#failures >= MAX_FAILURES)
+        this.#degraded = true;
+    }
+  }
+  async finish(text) {
+    this.#closed = true;
+    this.#stopTyping();
+    if (this.#timer !== undefined) {
+      clearTimeout(this.#timer);
+      this.#timer = undefined;
+    }
+    const body = text.trim();
+    if (body === "") {
+      if (this.#messageId !== undefined && !this.#degraded) {
+        await this.#safeEditBody(this.#messageId, "（本轮没有输出）");
+      }
+      return;
+    }
+    if (this.#messageId !== undefined) {
+      if (await this.#safeEditBody(this.#messageId, body)) {
+        await this.#sendAll(body, 1);
+        return;
+      }
+      await this.#channel.delete(this.#chat, this.#messageId).catch(() => {
+        return;
+      });
+    }
+    await this.#sendAll(body, 0);
+  }
+  async#sendAll(body, skip) {
+    const { parts } = project(this.#channel, body);
+    for (let index = skip;index < parts.length; index += 1) {
+      const rest = { raw: body, text: body, parts: parts.slice(index) };
+      try {
+        await this.#channel.send(this.#chat, rest);
+        return;
+      } catch {
+        return;
+      }
+    }
+  }
+  async#safeEditBody(messageId, body) {
+    try {
+      await this.#channel.edit(this.#chat, messageId, project(this.#channel, body), { preview: false });
+      return true;
+    } catch (error) {
+      return this.#channel.isMissing?.(error) === false;
+    }
+  }
+  dispose() {
+    this.#closed = true;
+    this.#stopTyping();
+    if (this.#timer !== undefined) {
+      clearTimeout(this.#timer);
+      this.#timer = undefined;
+    }
+  }
+}
+
+// src/router.ts
+var COMMANDS = [
+  { command: "help", description: "命令说明" },
+  { command: "cwd", description: "选择或切换工作目录" },
+  { command: "new", description: "在当前目录新建会话" },
+  { command: "sessions", description: "列出会话" },
+  { command: "switch", description: "切换到第 n 个会话" },
+  { command: "status", description: "当前会话状态" },
+  { command: "stop", description: "停止当前回合" }
+];
+var HELP = [
+  "把手机接到本机的 Hulala agent 上。",
+  "",
+  "/cwd            列出最近用过的目录，点一个就挂上去",
+  "/cwd <path>     直接指定目录（没有会话就新建）",
+  "/new            在当前目录新建会话",
+  "/sessions       最近会话",
+  "/switch <n>     切换到第 n 个",
+  "/status         会话、目录、运行状态",
+  "/stop           停止当前回合",
+  "",
+  "直接发文字就是提问；审批会以按钮出现，任何一端先点生效。"
+].join(`
+`);
+function parseCommand(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("/"))
+    return;
+  const space = trimmed.search(/\s/);
+  const head = (space === -1 ? trimmed : trimmed.slice(0, space)).slice(1);
+  const at = head.indexOf("@");
+  const name = (at === -1 ? head : head.slice(0, at)).toLowerCase();
+  const args = space === -1 ? "" : trimmed.slice(space).trim();
+  if (name === "")
+    return;
+  return { name, args };
+}
+
+// src/store/bindings.ts
+import { mkdir, readFile as readFile2, rename, writeFile } from "node:fs/promises";
+import { dirname, join as join2 } from "node:path";
+function keyOf(key) {
+  return `${key.channel}:${key.chatId}:${key.threadId ?? ""}`;
+}
+function parseKey(key) {
+  const [channel, chatId, threadId] = key.split(":");
+  if (channel !== "telegram" && channel !== "lark")
+    return;
+  if (chatId === undefined || chatId === "")
+    return;
+  return {
+    channel,
+    chatId,
+    ...threadId === undefined || threadId === "" ? {} : { threadId }
+  };
+}
+
+class Bindings {
+  #path;
+  #entries = new Map;
+  constructor(path) {
+    this.#path = path;
+  }
+  static async open(dir) {
+    const table = new Bindings(join2(dir, "bindings.json"));
+    try {
+      const parsed = JSON.parse(await readFile2(table.#path, "utf8"));
+      for (const [key, entry] of Object.entries(parsed)) {
+        if (typeof entry?.sessionId === "string" && parseKey(key) !== undefined)
+          table.#entries.set(key, entry);
+      }
+    } catch {}
+    return table;
+  }
+  get(key) {
+    return this.#entries.get(keyOf(key))?.sessionId;
+  }
+  set(key, sessionId) {
+    const status = this.#entries.get(keyOf(key))?.statusMessageId;
+    this.#entries.set(keyOf(key), {
+      sessionId,
+      updatedAt: Date.now(),
+      ...status === undefined ? {} : { statusMessageId: status }
+    });
+  }
+  statusMessageId(key) {
+    return this.#entries.get(keyOf(key))?.statusMessageId;
+  }
+  setStatusMessageId(key, messageId) {
+    const entry = this.#entries.get(keyOf(key));
+    if (entry === undefined)
+      return;
+    this.#entries.set(keyOf(key), { ...entry, statusMessageId: messageId });
+  }
+  delete(key) {
+    this.#entries.delete(keyOf(key));
+  }
+  chatsFor(sessionId) {
+    const keys = [];
+    for (const [key, entry] of this.#entries) {
+      if (entry.sessionId !== sessionId)
+        continue;
+      const parsed = parseKey(key);
+      if (parsed !== undefined)
+        keys.push(parsed);
+    }
+    return keys;
+  }
+  entries() {
+    return [...this.#entries.keys()].map(parseKey).filter((key) => key !== undefined);
+  }
+  async flush() {
+    const temporary = `${this.#path}.${String(process.pid)}.tmp`;
+    await mkdir(dirname(this.#path), { recursive: true, mode: 448 });
+    await writeFile(temporary, JSON.stringify(Object.fromEntries(this.#entries), null, 2), { mode: 384 });
+    await rename(temporary, this.#path);
+  }
+}
+
+// src/bridge.ts
+function unwrap(result) {
+  if (!result.ok) {
+    const failure = result.error;
+    throw new Error(failure.message ?? failure.code ?? "Host request failed");
+  }
+  return result.value;
+}
+function whenAborted(signal, run2) {
+  if (signal === undefined)
+    return () => {
+      return;
+    };
+  const listener = () => {
+    run2();
+  };
+  signal.addEventListener("abort", listener, { once: true });
+  if (signal.aborted)
+    run2();
+  return () => {
+    signal.removeEventListener("abort", listener);
+  };
+}
+
+class Bridge {
+  #config;
+  #channels;
+  #bindings;
+  #log;
+  #connect;
+  #mounts = new Map;
+  #pending = new Map;
+  #recent = new Map;
+  #cwdChoices = new Map;
+  #stopped = new AbortController;
+  #backend;
+  #connecting;
+  #sequence = 0;
+  #defaultSession;
+  constructor(options) {
+    this.#config = options.config;
+    this.#channels = new Map(options.channels.map((channel) => [channel.name, channel]));
+    this.#bindings = options.bindings;
+    this.#log = options.log;
+    this.#connect = options.connect ?? (async () => {
+      throw new Error("no Host backend: the bot runs as a Host plugin, not as a separate process");
+    });
+  }
+  async start() {
+    await this.#ensureHost().catch((error) => {
+      this.#log.error(`Host is not reachable yet: ${error instanceof Error ? error.message : String(error)}`);
+    });
+    const signal = this.#stopped.signal;
+    await Promise.all([...this.#channels.values()].map(async (channel) => {
+      try {
+        await channel.start((event) => this.#dispatch(event), signal);
+      } catch (error) {
+        this.#log.error(`${channel.name} stopped: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }));
+  }
+  async stop() {
+    this.#stopped.abort();
+    for (const mount of this.#mounts.values()) {
+      mount.abort.abort();
+      mount.reply?.dispose();
+    }
+    this.#mounts.clear();
+    await this.#bindings.flush().catch(() => {
+      return;
+    });
+    const backend = this.#backend;
+    this.#backend = undefined;
+    await backend?.close().catch(() => {
+      return;
+    });
+  }
+  #channel(chat) {
+    const channel = this.#channels.get(chat.channel);
+    if (channel === undefined)
+      throw new Error(`channel ${chat.channel} is not running`);
+    return channel;
+  }
+  async#dispatch(event) {
+    if (event.kind === "callback") {
+      await this.#onCallback(event);
+      return;
+    }
+    if (event.fromBot)
+      return;
+    const command = parseCommand(event.text);
+    if (command !== undefined) {
+      await this.#command(event, command.name, command.args);
+      return;
+    }
+    await this.#prompt(event);
+  }
+  async#ensureHost() {
+    if (this.#backend !== undefined)
+      return this.#backend;
+    this.#connecting ??= this.#connect();
+    let backend;
+    try {
+      backend = await this.#connecting;
+    } finally {
+      this.#connecting = undefined;
+    }
+    this.#backend = backend;
+    const events = backend.ctx.remote;
+    events.$on("approval/request", (request, next) => this.#onApproval(request, next));
+    events.$on("user-questions/request", (request, next) => this.#onQuestion(request, next));
+    await this.#restore();
+    return backend;
+  }
+  async#drop(reason) {
+    const backend = this.#backend;
+    if (backend === undefined)
+      return;
+    this.#log.error(`host connection lost: ${reason}`);
+    this.#backend = undefined;
+    this.#defaultSession = undefined;
+    for (const key of [...this.#pending.keys()])
+      this.#settle(key, "cancelled", "");
+    for (const mount of this.#mounts.values())
+      mount.abort.abort();
+    this.#mounts.clear();
+    await backend?.close().catch(() => {
+      return;
+    });
+  }
+  async#restore() {
+    for (const mount of this.#mounts.values())
+      mount.abort.abort();
+    this.#mounts.clear();
+    for (const key of this.#bindings.entries()) {
+      const sessionId = this.#bindings.get(key);
+      if (sessionId === undefined)
+        continue;
+      await this.#mount(key, sessionId).catch((error) => {
+        this.#log.error(`cannot mount ${keyOf(key)}: ${String(error)}`);
+      });
+    }
+  }
+  async#say(chat, text) {
+    const channel = this.#channel(chat);
+    try {
+      await channel.send(chat, project(channel, text), { preview: false });
+    } catch (error) {
+      this.#log.error(`reply to ${keyOf(chat)} failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async#command(message, name, args) {
+    const chat = message.chat;
+    switch (name) {
+      case "start":
+      case "help": {
+        await this.#say(chat, HELP);
+        return;
+      }
+      case "cwd": {
+        if (args === "") {
+          await this.#offerDirectories(chat);
+          return;
+        }
+        await this.#switchDirectory(chat, args);
+        return;
+      }
+      case "new": {
+        await this.#newSession(chat);
+        return;
+      }
+      case "sessions": {
+        await this.#listSessions(chat);
+        return;
+      }
+      case "switch": {
+        await this.#switchSession(chat, args);
+        return;
+      }
+      case "status": {
+        await this.#say(chat, await this.#describe(chat));
+        return;
+      }
+      case "stop": {
+        await this.#stopTurn(chat);
+        return;
+      }
+      default: {
+        await this.#say(chat, `未知命令 /${name}
+
+${HELP}`);
+      }
+    }
+  }
+  async#summary(sessionId) {
+    const backend = await this.#ensureHost();
+    const items = unwrap(await backend.ctx.remote.session.list({}));
+    return items.items.find((item) => item.sessionId === sessionId);
+  }
+  async#describe(chat) {
+    const sessionId = this.#bindings.get(chat);
+    if (sessionId === undefined)
+      return "还没有挂载会话。发一条消息，我会在默认目录里建一个。";
+    const summary = await this.#summary(sessionId).catch(() => {
+      return;
+    });
+    const mount = this.#mounts.get(keyOf(chat));
+    const title = this.#titleOf(summary) ?? sessionId.slice(0, 8);
+    return [
+      `会话 ${title}`,
+      `目录 ${summary?.cwd ?? "(未知)"}`,
+      `状态 ${mount?.active === true ? "运行中" : "空闲"}`,
+      `id   ${sessionId}`
+    ].join(`
+`);
+  }
+  #titleOf(summary) {
+    const projections = summary?.projections;
+    return typeof projections?.title === "string" ? projections.title : undefined;
+  }
+  async#recentDirectories() {
+    const backend = await this.#ensureHost();
+    const listed = unwrap(await backend.ctx.remote.session.list({}));
+    const items = listed.items.filter((item) => item.origin !== "subagent" && typeof item.cwd === "string").sort((left, right) => right.updatedAt - left.updatedAt);
+    const seen = new Set;
+    const paths = [];
+    for (const item of items) {
+      const path = item.cwd;
+      if (seen.has(path))
+        continue;
+      seen.add(path);
+      paths.push(path);
+      if (paths.length === 8)
+        break;
+    }
+    return paths;
+  }
+  async#offerDirectories(chat) {
+    const currentId = this.#bindings.get(chat);
+    const current = currentId === undefined ? undefined : await this.#summary(currentId).catch(() => {
+      return;
+    });
+    const currentPath = current?.cwd;
+    let paths;
+    try {
+      paths = await this.#recentDirectories();
+    } catch (error) {
+      await this.#say(chat, `读不到目录列表：${error instanceof Error ? error.message : String(error)}`);
+      return;
+    }
+    if (paths.length === 0) {
+      await this.#say(chat, "还没有用过任何目录。发 /cwd <path> 指定一个。");
+      return;
+    }
+    this.#cwdChoices.set(keyOf(chat), paths);
+    const header = currentPath === undefined ? "当前还没有挂载会话。" : `当前目录：${currentPath}`;
+    const keyboard = paths.map((path, index) => [{
+      text: `${path === currentPath ? "✓ " : ""}${this.#shortPath(path)}`,
+      data: `cwd:${String(index)}`
+    }]);
+    const channel = this.#channel(chat);
+    try {
+      await channel.send(chat, project(channel, `${header}
+
+选择要挂载的目录：`), { keyboard, preview: false });
+    } catch (error) {
+      this.#log.error(`cwd picker failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  #shortPath(path) {
+    const parts = path.split("/").filter((part) => part !== "");
+    if (parts.length <= 2)
+      return path;
+    return `…/${parts.slice(-2).join("/")}`;
+  }
+  async#syncStatus(chat) {
+    const channel = this.#channel(chat);
+    if (!channel.pinnedStatus || channel.pin === undefined)
+      return;
+    const mount = this.#mounts.get(keyOf(chat));
+    const sessionId = this.#bindings.get(chat);
+    if (sessionId === undefined)
+      return;
+    const path = mount?.path ?? "(未知目录)";
+    const title = mount?.title ?? sessionId.slice(0, 8);
+    const text = `\uD83D\uDCCD ${path}
+${title} · ${mount?.active === true ? "运行中" : "空闲"}`;
+    const body = project(channel, text);
+    const existing = this.#bindings.statusMessageId(chat);
+    if (existing !== undefined) {
+      try {
+        await channel.edit(chat, existing, body, { preview: false });
+        return;
+      } catch (error) {
+        if (channel.isMissing?.(error) !== true) {
+          this.#log.error(`status edit failed: ${error instanceof Error ? error.message : String(error)}`);
+          return;
+        }
+      }
+    }
+    try {
+      const messageId = await channel.send(chat, body, { preview: false });
+      if (messageId === undefined)
+        return;
+      const previous = existing;
+      this.#bindings.setStatusMessageId(chat, messageId);
+      await this.#bindings.flush().catch(() => {
+        return;
+      });
+      if (previous !== undefined)
+        await channel.unpin?.(chat, previous).catch(() => {
+          return;
+        });
+      await channel.pin(chat, messageId).catch((error) => {
+        this.#log.error(`pin failed: ${error instanceof Error ? error.message : String(error)}`);
+      });
+    } catch (error) {
+      this.#log.error(`status message failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async#switchDirectory(chat, raw) {
+    const path = resolve2(expandHome(raw));
+    const info = await stat(path).catch(() => {
+      return;
+    });
+    if (info === undefined || !info.isDirectory()) {
+      await this.#say(chat, `目录不存在：${path}`);
+      return;
+    }
+    const backend = await this.#ensureHost();
+    const remote = backend.ctx.remote;
+    const workspaceId = unwrap(await remote.workspace.create({ path })).workspace.workspaceId;
+    const listed = unwrap(await remote.session.list({}));
+    const items = listed.items.filter((item) => item.origin !== "subagent" && item.cwd === path).sort((left, right) => right.updatedAt - left.updatedAt);
+    const existing = items[0];
+    const sessionId = existing === undefined ? unwrap(await remote.session.create({ workspaceId })).sessionId : existing.sessionId;
+    await this.#mount(chat, sessionId);
+    await this.#say(chat, existing === undefined ? `已在 ${path} 新建并挂载会话。` : `已挂载 ${path} 下最近的会话。`);
+  }
+  async#newSession(chat) {
+    const backend = await this.#ensureHost();
+    const remote = backend.ctx.remote;
+    const current = this.#bindings.get(chat);
+    const summary = current === undefined ? undefined : await this.#summary(current).catch(() => {
+      return;
+    });
+    const path = summary?.cwd ?? this.#config.defaultCwd;
+    const workspaceId = unwrap(await remote.workspace.create({ path })).workspace.workspaceId;
+    const sessionId = unwrap(await remote.session.create({ workspaceId })).sessionId;
+    await this.#mount(chat, sessionId);
+    await this.#say(chat, `已新建会话，目录 ${path}。`);
+  }
+  async#listSessions(chat) {
+    const backend = await this.#ensureHost();
+    const listed = unwrap(await backend.ctx.remote.session.list({}));
+    const items = listed.items.filter((item) => item.origin !== "subagent").sort((left, right) => right.updatedAt - left.updatedAt).slice(0, 10);
+    if (items.length === 0) {
+      await this.#say(chat, "还没有会话。发一条消息就会新建一个。");
+      return;
+    }
+    this.#recent.set(keyOf(chat), items.map((item) => item.sessionId));
+    const current = this.#bindings.get(chat);
+    const lines = items.map((item, index) => {
+      const title = this.#titleOf(item) ?? item.cwd?.split("/").pop() ?? "(未命名)";
+      const marker = item.sessionId === current ? "*" : " ";
+      return `${marker}${String(index + 1)}. ${title}${item.running ? " · 运行中" : ""}`;
+    });
+    await this.#say(chat, ["最近会话：", ...lines, "", "用 /switch <n> 切换。"].join(`
+`));
+  }
+  async#switchSession(chat, args) {
+    const index = Number.parseInt(args, 10);
+    const recent = this.#recent.get(keyOf(chat));
+    if (recent === undefined) {
+      await this.#say(chat, "先发 /sessions 看看有哪些会话。");
+      return;
+    }
+    const sessionId = Number.isSafeInteger(index) ? recent[index - 1] : undefined;
+    if (sessionId === undefined) {
+      await this.#say(chat, `没有第 ${args} 个会话。`);
+      return;
+    }
+    await this.#mount(chat, sessionId);
+    await this.#say(chat, `已切换。
+
+${await this.#describe(chat)}`);
+  }
+  async#stopTurn(chat) {
+    const sessionId = this.#bindings.get(chat);
+    if (sessionId === undefined) {
+      await this.#say(chat, "还没有挂载会话。");
+      return;
+    }
+    const backend = await this.#ensureHost();
+    unwrap(await backend.ctx.remote.session.cancel({ sessionId }));
+    await this.#say(chat, "已请求停止。");
+  }
+  async#prompt(message) {
+    const chat = message.chat;
+    const text = message.text.trim();
+    if (text === "")
+      return;
+    let sessionId = this.#bindings.get(chat);
+    if (sessionId === undefined) {
+      sessionId = await this.#default();
+      if (sessionId === undefined) {
+        await this.#say(chat, "无法创建会话：Host 里没有可用的工作区。");
+        return;
+      }
+      await this.#mount(chat, sessionId);
+    }
+    const backend = await this.#ensureHost();
+    try {
+      unwrap(await backend.ctx.remote.session.prompt({
+        requestId: randomUUID(),
+        sessionId,
+        mode: "queue",
+        content: [{ type: "text", text }],
+        clientTimeZone: Intl.DateTimeFormat().resolvedOptions().timeZone
+      }));
+    } catch (error) {
+      await this.#drop(error instanceof Error ? error.message : String(error));
+      await this.#say(chat, "Host 没有接受这次请求，已重新连接；请再发一次。");
+    }
+  }
+  async#default() {
+    if (this.#defaultSession !== undefined)
+      return this.#defaultSession;
+    const backend = await this.#ensureHost();
+    const remote = backend.ctx.remote;
+    const path = this.#config.defaultCwd;
+    const workspaceId = unwrap(await remote.workspace.create({ path })).workspace.workspaceId;
+    const listed = unwrap(await remote.session.list({}));
+    const items = listed.items.filter((item) => item.origin !== "subagent" && item.cwd === path).sort((left, right) => right.updatedAt - left.updatedAt);
+    const sessionId = items[0]?.sessionId ?? unwrap(await remote.session.create({ workspaceId })).sessionId;
+    this.#defaultSession = sessionId;
+    return sessionId;
+  }
+  async#mount(chat, sessionId, known = {}) {
+    const existing = this.#mounts.get(keyOf(chat));
+    existing?.abort.abort();
+    existing?.reply?.dispose();
+    let path = known.path;
+    let title = known.title;
+    if (path === undefined || title === undefined) {
+      const summary = await this.#summary(sessionId).catch(() => {
+        return;
+      });
+      path ??= summary?.cwd;
+      title ??= this.#titleOf(summary);
+    }
+    this.#mounts.set(keyOf(chat), {
+      key: chat,
+      sessionId,
+      tracker: new TurnTracker,
+      abort: new AbortController,
+      reply: undefined,
+      active: false,
+      path,
+      title
+    });
+    this.#bindings.set(chat, sessionId);
+    await this.#bindings.flush().catch(() => {
+      return;
+    });
+    this.#follow(this.#mounts.get(keyOf(chat)));
+    this.#syncStatus(chat);
+  }
+  async#follow(mount) {
+    let backend;
+    try {
+      backend = await this.#ensureHost();
+    } catch (error) {
+      this.#log.error(`follow failed: ${String(error)}`);
+      return;
+    }
+    for (let attempt = 1;; attempt += 1) {
+      if (mount.abort.signal.aborted)
+        return;
+      try {
+        const stream = backend.ctx.remote.session.follow({
+          address: { kind: "session", sessionId: mount.sessionId },
+          maxMessages: 60,
+          assistantStream: true,
+          activate: true
+        }, mount.abort.signal);
+        for await (const frame of stream) {
+          if (mount.abort.signal.aborted)
+            return;
+          await this.#onFrame(mount, frame);
+        }
+        this.#log.error(`follow ended without an abort; reopening (attempt ${String(attempt)})`);
+      } catch (error) {
+        if (mount.abort.signal.aborted)
+          return;
+        this.#log.error(`follow failed (attempt ${String(attempt)}): ${error instanceof Error ? error.message : String(error)}`);
+      }
+      if (attempt >= 3) {
+        await this.#drop(`follow for ${mount.sessionId} gave up`);
+        return;
+      }
+      await new Promise((settle) => setTimeout(settle, 1000 * attempt));
+    }
+  }
+  #replyFor(mount) {
+    return new ReplyStream(this.#channel(mount.key), mount.key, { intervalMs: this.#config.streamIntervalMs });
+  }
+  async#onFrame(mount, frame) {
+    const effect = mount.tracker.apply(frame);
+    if (effect === undefined)
+      return;
+    if (effect === "begin") {
+      mount.active = true;
+      this.#syncStatus(mount.key);
+      mount.reply?.dispose();
+      mount.reply = this.#replyFor(mount);
+      await mount.reply.begin();
+      return;
+    }
+    if (effect === "delta") {
+      if (mount.reply === undefined) {
+        mount.active = true;
+        mount.reply = this.#replyFor(mount);
+        await mount.reply.begin();
+      }
+      const preview2 = mount.tracker.preview;
+      if (preview2 !== "")
+        await mount.reply.push(preview2);
+      return;
+    }
+    if (effect === "end") {
+      const reply = mount.reply;
+      mount.reply = undefined;
+      mount.active = false;
+      await reply?.finish(mount.tracker.text);
+      this.#syncStatus(mount.key);
+    }
+  }
+  async#onApproval(request, next) {
+    const running = [...this.#mounts.values()].filter((mount) => mount.active);
+    const watchers = running.length > 0 ? running : [...this.#mounts.values()];
+    if (watchers.length === 0)
+      return await next();
+    this.#sequence += 1;
+    const key = `a${String(this.#sequence)}`;
+    const reason = typeof request.displayReason === "string" ? request.displayReason : request.reason;
+    const summary = `\uD83D\uDEE1 需要批准 · ${request.toolName}${reason === undefined ? "" : `
+${reason}`}`;
+    const cards = [];
+    const outcome = new Promise((resolve3) => {
+      this.#pending.set(key, { key, cards, settled: false, resolve: resolve3 });
+    });
+    for (const mount of watchers) {
+      try {
+        const channel = this.#channel(mount.key);
+        const messageId = await channel.send(mount.key, project(channel, summary), {
+          keyboard: [[
+            { text: "允许这一次", data: `approve:${key}` },
+            { text: "拒绝", data: `reject:${key}` }
+          ]],
+          preview: false
+        });
+        if (messageId !== undefined)
+          cards.push({ chat: mount.key, messageId });
+      } catch (error) {
+        this.#log.error(`approval card failed: ${String(error)}`);
+      }
+    }
+    const pending = this.#pending.get(key);
+    if (pending === undefined || cards.length === 0) {
+      this.#pending.delete(key);
+      return await next();
+    }
+    const removeAbort = whenAborted(request.signal, () => {
+      this.#settle(key, "cancelled", "");
+    });
+    try {
+      return await outcome;
+    } finally {
+      removeAbort();
+      this.#pending.delete(key);
+    }
+  }
+  #settle(key, decision, by) {
+    const pending = this.#pending.get(key);
+    if (pending === undefined || pending.settled)
+      return;
+    pending.settled = true;
+    this.#pending.delete(key);
+    pending.resolve(decision);
+    this.#closeCards(pending.cards, decision, by);
+  }
+  async#closeCards(cards, decision, by) {
+    const text = decision === "allowed-once" ? `✅ 已允许${by === "" ? "" : `（${by}）`}` : decision === "rejected" ? `⛔ 已拒绝${by === "" ? "" : `（${by}）`}` : "☑️ 已在其他端处理";
+    for (const card of cards) {
+      try {
+        const channel = this.#channel(card.chat);
+        await channel.edit(card.chat, card.messageId, project(channel, text), { keyboard: [], preview: false });
+      } catch {}
+    }
+  }
+  async#onQuestion(request, next) {
+    const lines = request.questions.map((question) => {
+      const head = `❓ ${question.question}`;
+      const options = question.options ?? [];
+      if (options.length === 0)
+        return head;
+      return [head, ...options.map((option) => `  · ${option.label}${option.description === undefined ? "" : ` — ${option.description}`}`)].join(`
+`);
+    });
+    for (const mount of this.#mounts.values()) {
+      await this.#say(mount.key, [...lines, "", "请在这台机器的 TUI 或 Desktop 上回答。"].join(`
+`));
+    }
+    return await next();
+  }
+  async#onCallback(callback) {
+    if (callback.data.startsWith("cwd:")) {
+      await this.#onDirectoryChoice(callback);
+      return;
+    }
+    const channel = this.#channel(callback.chat);
+    const separator = callback.data.indexOf(":");
+    const action = separator === -1 ? callback.data : callback.data.slice(0, separator);
+    const key = separator === -1 ? "" : callback.data.slice(separator + 1);
+    const pending = this.#pending.get(key);
+    if (pending === undefined || pending.settled) {
+      await channel.answer(callback, "这条审批已经处理过了").catch(() => {
+        return;
+      });
+      await channel.edit(callback.chat, callback.messageId, project(channel, "☑️ 已处理"), { keyboard: [], preview: false }).catch(() => {
+        return;
+      });
+      return;
+    }
+    await channel.answer(callback).catch(() => {
+      return;
+    });
+    this.#settle(key, action === "approve" ? "allowed-once" : "rejected", "手机");
+  }
+  async#onDirectoryChoice(callback) {
+    const channel = this.#channel(callback.chat);
+    const choices = this.#cwdChoices.get(keyOf(callback.chat));
+    const index = Number.parseInt(callback.data.slice("cwd:".length), 10);
+    const path = choices === undefined ? undefined : choices[index];
+    if (path === undefined) {
+      await channel.answer(callback, "这个列表已过期，重新发 /cwd").catch(() => {
+        return;
+      });
+      return;
+    }
+    await channel.answer(callback).catch(() => {
+      return;
+    });
+    await this.#switchDirectory(callback.chat, path);
+    await channel.edit(callback.chat, callback.messageId, project(channel, `\uD83D\uDCCD ${path}`), { keyboard: [], preview: false }).catch(() => {
+      return;
+    });
+  }
+}
+
+// src/log.ts
+import { appendFile, mkdir as mkdir2 } from "node:fs/promises";
+import { dirname as dirname2, join as join3 } from "node:path";
+function redact(text, secrets) {
+  let out = text;
+  for (const secret of secrets) {
+    if (secret !== "")
+      out = out.split(secret).join("<secret>");
+  }
+  return out;
+}
+
+class Log {
+  #file;
+  #secrets;
+  #ready;
+  constructor(dir, secrets) {
+    this.#file = join3(dir, "logs", `bridge-${new Date().toISOString().slice(0, 10)}.log`);
+    this.#secrets = secrets;
+  }
+  write(level, message) {
+    const line = `${new Date().toISOString()} ${level} ${redact(message, this.#secrets)}`;
+    if (level === "error")
+      console.error(line);
+    else
+      console.log(line);
+    this.#ready ??= mkdir2(dirname2(this.#file), { recursive: true, mode: 448 }).then(() => {
+      return;
+    });
+    this.#ready.then(() => appendFile(this.#file, `${line}
+`, { mode: 384 })).catch(() => {
+      return;
+    });
+  }
+  info(message) {
+    this.write("info", message);
+  }
+  error(message) {
+    this.write("error", message);
+  }
+}
+
+// src/lark/api.ts
+class LarkError extends Error {
+  method;
+  code;
+  status;
+  constructor(method, message, code, status) {
+    super(`${method}: ${message} (${String(code)})`);
+    this.name = "LarkError";
+    this.method = method;
+    this.code = code;
+    this.status = status;
+  }
+  get isTokenInvalid() {
+    return this.code === 99991661 || this.code === 99991663;
+  }
+  get isThrottled() {
+    return this.status === 429 || this.code === 99991400;
+  }
+}
+
+class LarkApi {
+  #appId;
+  #appSecret;
+  #baseUrl;
+  #fetch;
+  #token;
+  constructor(options) {
+    this.#appId = options.appId;
+    this.#appSecret = options.appSecret;
+    this.#baseUrl = options.baseUrl;
+    this.#fetch = options.fetch ?? (options.proxy === undefined ? globalThis.fetch : createProxiedFetch(options.proxy));
+  }
+  async#accessToken() {
+    const cached = this.#token;
+    if (cached !== undefined && cached.expiresAt > Date.now())
+      return cached.value;
+    const envelope = await this.#request("auth/v3/tenant_access_token/internal", {
+      method: "POST",
+      body: { app_id: this.#appId, app_secret: this.#appSecret },
+      authenticated: false
+    });
+    const value = envelope.tenant_access_token ?? "";
+    if (value === "")
+      throw new Error("Lark returned no tenant access token");
+    const lifetime = Number(envelope.expire ?? 7200);
+    this.#token = { value, expiresAt: Date.now() + Math.max(60, lifetime - 120) * 1000 };
+    return value;
+  }
+  async#request(path, options, retried = false) {
+    const token = options.authenticated === false ? undefined : await this.#accessToken();
+    const response = await this.#fetch(`${this.#baseUrl}/${path}${options.query === undefined ? "" : `?${options.query}`}`, {
+      method: options.method,
+      headers: {
+        "content-type": "application/json",
+        ...token === undefined ? {} : { authorization: `Bearer ${token}` }
+      },
+      ...options.body === undefined ? {} : { body: JSON.stringify(options.body) },
+      signal: AbortSignal.timeout(30000)
+    });
+    const text = await response.text();
+    let envelope;
+    try {
+      envelope = JSON.parse(text);
+    } catch {
+      throw new LarkError(path, `unreadable response (${String(response.status)})`, 0, response.status);
+    }
+    if (envelope.code !== 0) {
+      const error = new LarkError(path, envelope.msg, envelope.code, response.status);
+      if (error.isTokenInvalid && !retried) {
+        this.#token = undefined;
+        return await this.#request(path, options, true);
+      }
+      throw error;
+    }
+    return envelope;
+  }
+  async sendCard(chatId, content) {
+    const envelope = await this.#request("im/v1/messages", {
+      method: "POST",
+      query: "receive_id_type=chat_id",
+      body: { receive_id: chatId, msg_type: "interactive", content }
+    });
+    const messageId = envelope.data?.message_id;
+    if (messageId === undefined)
+      throw new Error("Lark returned no message id");
+    return messageId;
+  }
+  async sendText(chatId, text) {
+    const envelope = await this.#request("im/v1/messages", {
+      method: "POST",
+      query: "receive_id_type=chat_id",
+      body: { receive_id: chatId, msg_type: "text", content: JSON.stringify({ text }) }
+    });
+    const messageId = envelope.data?.message_id;
+    if (messageId === undefined)
+      throw new Error("Lark returned no message id");
+    return messageId;
+  }
+  async patchCard(messageId, content) {
+    await this.#request(`im/v1/messages/${encodeURIComponent(messageId)}`, {
+      method: "PATCH",
+      body: { content }
+    });
+  }
+  async deleteMessage(messageId) {
+    await this.#request(`im/v1/messages/${encodeURIComponent(messageId)}`, { method: "DELETE" });
+  }
+}
+
+// src/lark/card.ts
+function buildCard(text, options = {}) {
+  const elements = [{ tag: "markdown", content: text }];
+  const buttons = options.buttons ?? [];
+  if (buttons.length > 0) {
+    elements.push({
+      tag: "action",
+      actions: buttons.flat().map((button) => ({
+        tag: "button",
+        text: { tag: "plain_text", content: button.text },
+        type: "default",
+        value: { data: button.data }
+      }))
+    });
+  }
+  return {
+    config: { wide_screen_mode: true, update_multi: true },
+    ...options.title === undefined ? {} : { header: { title: { tag: "plain_text", content: options.title } } },
+    elements
+  };
+}
+function stripMentions(text) {
+  return text.replace(/@_user_\d+/g, "").replace(/[ \t]+/g, " ").trim();
+}
+
+// src/lark/channel.ts
+class LarkChannel {
+  name = "lark";
+  maxTextLength = 4000;
+  pinnedStatus = false;
+  #api;
+  #transport;
+  #config;
+  #ledger;
+  #log;
+  #toasts = new Map;
+  constructor(options) {
+    this.#api = options.api;
+    this.#transport = options.transport;
+    this.#config = options.config;
+    this.#ledger = options.ledger;
+    this.#log = options.log;
+  }
+  format(text) {
+    return text;
+  }
+  #allowed(chatId, userId) {
+    const { allowedChats, allowedUsers } = this.#config;
+    if (allowedChats.length === 0 && allowedUsers.length === 0)
+      return false;
+    if (allowedChats.length > 0 && allowedChats.includes(chatId))
+      return true;
+    if (allowedUsers.length > 0 && userId !== undefined && allowedUsers.includes(userId))
+      return true;
+    return false;
+  }
+  #card(text, options) {
+    return JSON.stringify(buildCard(text, { buttons: options.keyboard }));
+  }
+  async send(chat, body, options = {}) {
+    let first;
+    for (const part of body.parts) {
+      const messageId = await this.#api.sendCard(chat.chatId, this.#card(part, options));
+      first ??= messageId;
+    }
+    return first;
+  }
+  async edit(chat, messageId, body, options = {}) {
+    await this.#api.patchCard(messageId, this.#card(body.parts[0] ?? body.text, options));
+  }
+  async delete(chat, messageId) {
+    await this.#api.deleteMessage(messageId);
+    this.#toasts.delete(messageId);
+  }
+  async answer(event, text) {
+    if (text !== undefined && text !== "")
+      this.#toasts.set(event.messageId, text);
+  }
+  retryAfterMs(error) {
+    return error instanceof LarkError && error.isThrottled ? 1000 : undefined;
+  }
+  isMissing(error) {
+    return error instanceof LarkError && /not found|not exist|已撤回|no message/i.test(error.message);
+  }
+  async start(onEvent, signal) {
+    await this.#transport.start({
+      message: (event) => {
+        this.#onMessage(event, onEvent);
+      },
+      action: (event) => this.#onAction(event, onEvent)
+    });
+    await new Promise((resolve3) => {
+      if (signal.aborted) {
+        resolve3();
+        return;
+      }
+      signal.addEventListener("abort", () => {
+        resolve3();
+      }, { once: true });
+    });
+    this.#transport.close();
+  }
+  async#onMessage(event, onEvent) {
+    try {
+      const message = event.message;
+      if (message === undefined)
+        return;
+      const senderType = event.sender?.sender_type ?? "";
+      if (senderType !== "user")
+        return;
+      const userId = event.sender?.sender_id?.open_id;
+      if (userId === undefined)
+        return;
+      const chatId = message.chat_id;
+      if (!this.#allowed(chatId, userId)) {
+        this.#log.info(`ignored chat=${chatId} from=${userId} (not in allowlist)`);
+        return;
+      }
+      const eventId = event.event_id ?? message.message_id;
+      if (this.#ledger.seen(eventId))
+        return;
+      await this.#ledger.flush().catch(() => {
+        return;
+      });
+      if (message.message_type !== "text") {
+        this.#log.info(`ignored ${message.message_type} message in ${chatId}`);
+        await this.#api.sendText(chatId, "只支持文字消息。").catch(() => {
+          return;
+        });
+        return;
+      }
+      const text = stripMentions(textOf(message.content));
+      if (text === "")
+        return;
+      this.#log.info(`message chat=${chatId} from=${userId} len=${String(text.length)}`);
+      await onEvent({
+        kind: "message",
+        chat: { channel: "lark", chatId },
+        userId,
+        text,
+        fromBot: false,
+        messageId: message.message_id
+      });
+    } catch (error) {
+      this.#log.error(`lark message failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async#onAction(event, onEvent) {
+    const chatId = event.context?.open_chat_id ?? event.open_chat_id;
+    const messageId = event.context?.open_message_id ?? event.open_message_id;
+    const userId = event.operator?.open_id;
+    const data = actionData(event);
+    if (chatId === undefined || messageId === undefined || userId === undefined || data === undefined)
+      return {};
+    if (!this.#allowed(chatId, userId))
+      return { toast: { type: "error", content: "没有权限" } };
+    try {
+      await onEvent({
+        kind: "callback",
+        chat: { channel: "lark", chatId },
+        userId,
+        callbackId: messageId,
+        messageId,
+        data
+      });
+    } catch (error) {
+      this.#log.error(`callback failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const toast = this.#toasts.get(messageId);
+    this.#toasts.delete(messageId);
+    return toast === undefined ? {} : { toast: { type: "success", content: toast } };
+  }
+}
+function textOf(content) {
+  if (content === undefined)
+    return "";
+  try {
+    const parsed = JSON.parse(content);
+    return typeof parsed.text === "string" ? parsed.text : "";
+  } catch {
+    return "";
+  }
+}
+function actionData(event) {
+  const value = event.action?.value;
+  if (value === undefined || value === null)
+    return;
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "object" && "data" in value) {
+    const data = value.data;
+    return typeof data === "string" ? data : undefined;
+  }
+  return;
+}
+
+// src/lark/ws.ts
+function createSdkTransport(options) {
+  let client;
+  return {
+    async start(handlers) {
+      const sdk = await import("@larksuiteoapi/node-sdk");
+      const dispatcher = new sdk.EventDispatcher({});
+      dispatcher.register({
+        "im.message.receive_v1": (event) => {
+          handlers.message(event);
+        },
+        "card.action.trigger": async (event) => await handlers.action(event)
+      });
+      const ws = new sdk.WSClient({
+        appId: options.appId,
+        appSecret: options.appSecret,
+        domain: options.domain === "lark" ? sdk.Domain.Lark : sdk.Domain.Feishu,
+        loggerLevel: sdk.LoggerLevel.warn,
+        ...options.onError === undefined ? {} : { onError: options.onError }
+      });
+      client = ws;
+      await ws.start({ eventDispatcher: dispatcher });
+    },
+    close() {
+      client?.close({ force: true });
+      client = undefined;
+    }
+  };
+}
+
+// src/store/ledger.ts
+import { mkdir as mkdir3, readFile as readFile3, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
+
+class UpdateLedger {
+  #path;
+  #ttlMs;
+  #capacity;
+  #entries = [];
+  #seen = new Set;
+  #dirty = false;
+  #flushing;
+  constructor(path, options = {}) {
+    this.#path = path;
+    this.#ttlMs = options.ttlMs ?? 24 * 60 * 60 * 1000;
+    this.#capacity = options.capacity ?? 4096;
+  }
+  static async open(path, options = {}) {
+    const ledger = new UpdateLedger(path, options);
+    try {
+      const parsed = JSON.parse(await readFile3(path, "utf8"));
+      ledger.#entries = (parsed.entries ?? []).filter((entry) => typeof entry.id === "string" && Number.isSafeInteger(entry.at));
+    } catch {}
+    ledger.#prune(Date.now());
+    ledger.#seen = new Set(ledger.#entries.map((entry) => entry.id));
+    return ledger;
+  }
+  #prune(now) {
+    const fresh = this.#entries.filter((entry) => now - entry.at < this.#ttlMs);
+    fresh.sort((left, right) => left.at - right.at);
+    this.#entries = fresh.slice(-this.#capacity);
+  }
+  seen(id) {
+    const key = String(id);
+    if (this.#seen.has(key))
+      return true;
+    this.#seen.add(key);
+    this.#entries.push({ id: key, at: Date.now() });
+    this.#dirty = true;
+    this.#prune(Date.now());
+    if (this.#entries.length > this.#capacity) {
+      this.#seen = new Set(this.#entries.map((entry) => entry.id));
+    }
+    return false;
+  }
+  get cursor() {
+    let highest = 0;
+    for (const entry of this.#entries) {
+      const value = Number(entry.id);
+      if (Number.isSafeInteger(value))
+        highest = Math.max(highest, value);
+    }
+    return highest;
+  }
+  async flush() {
+    if (!this.#dirty)
+      return this.#flushing ?? Promise.resolve();
+    if (this.#flushing !== undefined)
+      return this.#flushing;
+    this.#dirty = false;
+    this.#flushing = (async () => {
+      const temporary = `${this.#path}.${String(process.pid)}.tmp`;
+      await mkdir3(dirname3(this.#path), { recursive: true, mode: 448 });
+      await writeFile2(temporary, JSON.stringify({ entries: this.#entries }), { mode: 384 });
+      await rename2(temporary, this.#path);
+    })().finally(() => {
+      this.#flushing = undefined;
+    });
+    return this.#flushing;
+  }
+}
+
+// src/store/lock.ts
+import { createHash } from "node:crypto";
+import { mkdir as mkdir4, readFile as readFile4, rm, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { join as join4 } from "node:path";
+function lockDirectory(env = process.env) {
+  const override = env.HULALA_BOT_LOCK_DIR;
+  if (override !== undefined && override !== "")
+    return override;
+  return join4(homedir2(), ".hulala-bot");
+}
+function lockPath(identity, env = process.env) {
+  const digest = createHash("sha256").update(identity).digest("hex").slice(0, 16);
+  return join4(lockDirectory(env), `${digest}.lock`);
+}
+var held = new Set;
+async function acquireLock(identity, env = process.env) {
+  const path = lockPath(identity, env);
+  if (held.has(path))
+    throw new Error(`this bot is already running in another instance here (${path})`);
+  await mkdir4(lockDirectory(env), { recursive: true, mode: 448 });
+  let owner;
+  try {
+    const parsed = Number.parseInt((await readFile4(path, "utf8")).trim(), 10);
+    if (Number.isSafeInteger(parsed) && parsed > 0)
+      owner = parsed;
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+  if (owner !== undefined && owner !== process.pid) {
+    let alive = false;
+    try {
+      process.kill(owner, 0);
+      alive = true;
+    } catch (error) {
+      alive = error.code === "EPERM";
+    }
+    if (alive) {
+      throw new Error(`this bot is already connected from another Host (pid ${String(owner)}); stop that process or remove ${path} if it is stale`);
+    }
+  }
+  await writeFile3(path, `${String(process.pid)}
+`, { mode: 384 });
+  held.add(path);
+  return async () => {
+    if (!held.delete(path))
+      return;
+    await rm(path, { force: true });
+  };
+}
+
+// src/telegram/api.ts
+class TelegramError extends Error {
+  method;
+  description;
+  code;
+  retryAfter;
+  constructor(method, description, code, retryAfter) {
+    super(`${method}: ${description} (${String(code)})`);
+    this.name = "TelegramError";
+    this.method = method;
+    this.description = description;
+    this.code = code;
+    this.retryAfter = retryAfter;
+  }
+  get isFlood() {
+    return this.code === 429 || this.retryAfter !== undefined;
+  }
+  get isBadRequest() {
+    return this.code === 400;
+  }
+}
+
+class TelegramApi {
+  #token;
+  #baseUrl;
+  #fetch;
+  constructor(options) {
+    this.#token = options.token;
+    this.#baseUrl = options.baseUrl;
+    this.#fetch = options.fetch ?? (options.proxy === undefined ? globalThis.fetch : createProxiedFetch(options.proxy));
+  }
+  async call(method, params = {}, signal) {
+    const response = await this.#fetch(`${this.#baseUrl}/bot${this.#token}/${method}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(params),
+      signal: signal === undefined ? AbortSignal.timeout(40000) : AbortSignal.any([signal, AbortSignal.timeout(40000)])
+    });
+    const body = await response.json();
+    if (!body.ok) {
+      throw new TelegramError(method, body.description ?? "request failed", response.status, body.parameters?.retry_after);
+    }
+    return body.result;
+  }
+  static decorate(params, options) {
+    if (options.parseMode !== undefined)
+      params.parse_mode = options.parseMode;
+    if (options.disablePreview === true) {
+      params.link_preview_options = { is_disabled: true };
+    }
+    if (options.threadId !== undefined)
+      params.message_thread_id = options.threadId;
+    if (options.keyboard !== undefined)
+      params.reply_markup = { inline_keyboard: options.keyboard };
+    return params;
+  }
+  async sendMessage(chatId, text, options = {}) {
+    const result = await this.call("sendMessage", TelegramApi.decorate({ chat_id: chatId, text }, options));
+    return result.message_id;
+  }
+  async editMessageText(chatId, messageId, text, options = {}) {
+    await this.call("editMessageText", TelegramApi.decorate({ chat_id: chatId, message_id: messageId, text }, options));
+  }
+  async deleteMessage(chatId, messageId) {
+    await this.call("deleteMessage", { chat_id: chatId, message_id: messageId });
+  }
+  async answerCallbackQuery(id, text) {
+    await this.call("answerCallbackQuery", text === undefined ? { callback_query_id: id } : { callback_query_id: id, text });
+  }
+  async pinChatMessage(chatId, messageId) {
+    await this.call("pinChatMessage", { chat_id: chatId, message_id: messageId, disable_notification: true });
+  }
+  async unpinChatMessage(chatId, messageId) {
+    await this.call("unpinChatMessage", { chat_id: chatId, message_id: messageId });
+  }
+  async sendChatAction(chatId, threadId) {
+    await this.call("sendChatAction", {
+      chat_id: chatId,
+      action: "typing",
+      ...threadId === undefined ? {} : { message_thread_id: threadId }
+    });
+  }
+  async setMyCommands(commands) {
+    await this.call("setMyCommands", { commands });
+  }
+  async getUpdates(offset, timeoutSeconds, signal) {
+    const raw = await this.call("getUpdates", {
+      offset,
+      timeout: timeoutSeconds,
+      allowed_updates: ["message", "callback_query"]
+    }, signal);
+    const updates = [];
+    for (const update of raw) {
+      const message = update.message;
+      if (message !== undefined && typeof message.text === "string") {
+        updates.push({
+          kind: "message",
+          updateId: update.update_id,
+          message: {
+            messageId: message.message_id,
+            chat: message.chat,
+            fromId: message.from?.id,
+            text: message.text,
+            threadId: message.is_topic_message === true ? message.message_thread_id : undefined,
+            isBot: message.from?.is_bot === true
+          }
+        });
+        continue;
+      }
+      const callback = update.callback_query;
+      if (callback?.message !== undefined && typeof callback.data === "string") {
+        updates.push({
+          kind: "callback",
+          updateId: update.update_id,
+          callback: {
+            id: callback.id,
+            chatId: callback.message.chat.id,
+            messageId: callback.message.message_id,
+            data: callback.data,
+            fromId: callback.from?.id,
+            threadId: callback.message.is_topic_message === true ? callback.message.message_thread_id : undefined
+          }
+        });
+      }
+    }
+    return updates;
+  }
+}
+
+// src/render/markdown.ts
+var RESERVED = new Set("_*[]()~`>#+-=|{}.!\\".split(""));
+function escapeMarkdownV2(text) {
+  let out = "";
+  for (const character of text)
+    out += RESERVED.has(character) ? `\\${character}` : character;
+  return out;
+}
+function escapeCode(text) {
+  return text.replace(/[`\\]/g, (character) => `\\${character}`);
+}
+function splitFences(text) {
+  const regions = [];
+  let cursor = 0;
+  while (cursor < text.length) {
+    const open = text.indexOf("```", cursor);
+    if (open === -1)
+      break;
+    if (open > cursor)
+      regions.push({ kind: "text", text: text.slice(cursor, open) });
+    const lineEnd = text.indexOf(`
+`, open);
+    const language = lineEnd === -1 ? "" : text.slice(open + 3, lineEnd).trim();
+    const bodyStart = lineEnd === -1 ? open + 3 : lineEnd + 1;
+    const close = text.indexOf("```", bodyStart);
+    if (close === -1) {
+      regions.push({ kind: "code", language, text: text.slice(bodyStart) });
+      return regions;
+    }
+    regions.push({ kind: "code", language, text: text.slice(bodyStart, close) });
+    cursor = close + 3;
+  }
+  if (cursor < text.length)
+    regions.push({ kind: "text", text: text.slice(cursor) });
+  return regions;
+}
+function toMarkdownV2(text) {
+  return splitFences(text).map((region) => region.kind === "text" ? escapeMarkdownV2(region.text) : `\`\`\`${region.language}
+${escapeCode(region.text)}\`\`\``).join("");
+}
+
+// src/telegram/channel.ts
+function numeric(value, label) {
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0)
+    throw new Error(`not a Telegram ${label}: ${value}`);
+  return parsed;
+}
+
+class TelegramChannel {
+  name = "telegram";
+  maxTextLength = 4000;
+  pinnedStatus = true;
+  #api;
+  #config;
+  #ledger;
+  #log;
+  #commands;
+  #plain;
+  constructor(options) {
+    this.#api = options.api;
+    this.#config = options.config;
+    this.#ledger = options.ledger;
+    this.#log = options.log;
+    this.#commands = options.commands;
+    this.#plain = options.config.parseMode === "plain";
+  }
+  format(text) {
+    return this.#plain ? text : toMarkdownV2(text);
+  }
+  #allowed(chatId, userId) {
+    const { allowedChats, allowedUsers } = this.#config;
+    if (allowedChats.length === 0 && allowedUsers.length === 0)
+      return false;
+    if (allowedChats.length > 0 && allowedChats.includes(chatId))
+      return true;
+    if (allowedUsers.length > 0 && userId !== undefined && allowedUsers.includes(userId))
+      return true;
+    return false;
+  }
+  #key(chatId, threadId) {
+    return {
+      channel: "telegram",
+      chatId: String(chatId),
+      ...threadId === undefined ? {} : { threadId: String(threadId) }
+    };
+  }
+  #transport(chat, options) {
+    return {
+      ...this.#plain ? {} : { parseMode: "MarkdownV2" },
+      ...options.keyboard === undefined ? {} : { keyboard: this.#keyboard(options.keyboard) },
+      ...options.preview === false ? { disablePreview: true } : {},
+      ...chat.threadId === undefined ? {} : { threadId: numeric(chat.threadId, "thread id") }
+    };
+  }
+  #keyboard(keyboard) {
+    return keyboard.map((row) => row.map((button) => ({ text: button.text, callback_data: button.data })));
+  }
+  async send(chat, body, options = {}) {
+    const chatId = numeric(chat.chatId, "chat id");
+    let parts = body.parts;
+    let first;
+    let index = 0;
+    while (index < parts.length) {
+      try {
+        const messageId = await this.#api.sendMessage(chatId, parts[index], this.#transport(chat, options));
+        first ??= messageId;
+        index += 1;
+      } catch (error) {
+        if (this.#plain || !(error instanceof TelegramError) || !error.isBadRequest)
+          throw error;
+        this.#log.error(`markdown rejected, retrying plain: ${error.description}`);
+        this.#plain = true;
+        parts = splitMessage(body.raw, this.maxTextLength);
+      }
+    }
+    return first === undefined ? undefined : String(first);
+  }
+  async edit(chat, messageId, body, options = {}) {
+    const chatId = numeric(chat.chatId, "chat id");
+    const id = numeric(messageId, "message id");
+    const attempt = async (text) => {
+      await this.#api.editMessageText(chatId, id, text, this.#transport(chat, options));
+    };
+    try {
+      await attempt(this.#plain ? splitMessage(body.raw, this.maxTextLength)[0] ?? body.raw : body.parts[0] ?? body.text);
+    } catch (error) {
+      if (error instanceof TelegramError && error.isBadRequest && !this.#plain) {
+        this.#plain = true;
+        try {
+          await attempt(splitMessage(body.raw, this.maxTextLength)[0] ?? body.raw);
+          return;
+        } catch (retry) {
+          if (isNotModified(retry))
+            return;
+          throw retry;
+        }
+      }
+      if (isNotModified(error))
+        return;
+      throw error;
+    }
+  }
+  async delete(chat, messageId) {
+    try {
+      await this.#api.deleteMessage(numeric(chat.chatId, "chat id"), numeric(messageId, "message id"));
+    } catch (error) {
+      if (!isMissing(error))
+        throw error;
+    }
+  }
+  async answer(event, text) {
+    await this.#api.answerCallbackQuery(event.callbackId, text);
+  }
+  async pin(chat, messageId) {
+    await this.#api.pinChatMessage(numeric(chat.chatId, "chat id"), numeric(messageId, "message id"));
+  }
+  async unpin(chat, messageId) {
+    await this.#api.unpinChatMessage(numeric(chat.chatId, "chat id"), numeric(messageId, "message id"));
+  }
+  async typing(chat) {
+    await this.#api.sendChatAction(numeric(chat.chatId, "chat id"), chat.threadId === undefined ? undefined : numeric(chat.threadId, "thread id"));
+  }
+  retryAfterMs(error) {
+    return error instanceof TelegramError && error.isFlood ? (error.retryAfter ?? 1) * 1000 : undefined;
+  }
+  isMissing(error) {
+    return isMissing(error);
+  }
+  async start(onEvent, signal) {
+    this.#api.setMyCommands(this.#commands.map((command) => ({ command: command.command, description: command.description }))).catch((error) => {
+      this.#log.error(`setMyCommands failed: ${String(error)}`);
+    });
+    let offset = this.#ledger.cursor === 0 ? 0 : this.#ledger.cursor + 1;
+    let failures = 0;
+    while (!signal.aborted) {
+      try {
+        const updates = await this.#api.getUpdates(offset, this.#config.pollTimeoutSeconds, signal);
+        failures = 0;
+        for (const update of updates) {
+          offset = update.updateId + 1;
+          if (this.#ledger.seen(update.updateId))
+            continue;
+          this.#log.info(`update ${String(update.updateId)} ${describe(update)}`);
+          const event = this.#eventOf(update);
+          if (event === undefined)
+            continue;
+          try {
+            await onEvent(event);
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.#log.error(`update ${String(update.updateId)} failed: ${message}`);
+            if (event.kind === "message") {
+              await this.send(event.chat, {
+                raw: "Host 现在不可用，这次请求没有送出去。确认 Host 在运行后再发一次。",
+                text: "Host 现在不可用，这次请求没有送出去。确认 Host 在运行后再发一次。",
+                parts: ["Host 现在不可用，这次请求没有送出去。确认 Host 在运行后再发一次。"]
+              }).catch(() => {
+                return;
+              });
+            }
+          }
+        }
+        await this.#ledger.flush().catch(() => {
+          return;
+        });
+      } catch (error) {
+        if (signal.aborted)
+          return;
+        failures += 1;
+        const wait = Math.min(30000, 1000 * 2 ** Math.min(failures, 5));
+        this.#log.error(`polling failed (${String(failures)}): ${error instanceof Error ? error.message : String(error)}`);
+        await new Promise((settle) => setTimeout(settle, wait));
+      }
+    }
+  }
+  #eventOf(update) {
+    if (update.kind === "callback") {
+      const callback = update.callback;
+      if (!this.#allowed(callback.chatId, callback.fromId)) {
+        this.#log.info(`ignored callback chat=${String(callback.chatId)} from=${String(callback.fromId ?? 0)} (not in allowlist)`);
+        return;
+      }
+      return {
+        kind: "callback",
+        chat: this.#key(callback.chatId, callback.threadId),
+        userId: String(callback.fromId ?? ""),
+        callbackId: callback.id,
+        messageId: String(callback.messageId),
+        data: callback.data
+      };
+    }
+    const message = update.message;
+    if (!this.#allowed(message.chat.id, message.fromId)) {
+      this.#log.info(`ignored message chat=${String(message.chat.id)} from=${String(message.fromId ?? 0)} (not in allowlist)`);
+      return;
+    }
+    return {
+      kind: "message",
+      chat: this.#key(message.chat.id, message.threadId),
+      userId: String(message.fromId ?? ""),
+      text: message.text,
+      fromBot: message.isBot,
+      messageId: String(message.messageId)
+    };
+  }
+}
+function isNotModified(error) {
+  return error instanceof TelegramError && error.isBadRequest && /not modified/i.test(error.description);
+}
+function isMissing(error) {
+  return error instanceof TelegramError && error.isBadRequest && /not found|MESSAGE_ID_INVALID|message to edit not found|message can't be deleted/i.test(error.description);
+}
+function describe(update) {
+  if (update.kind === "callback") {
+    return `callback chat=${String(update.callback.chatId)} data=${update.callback.data}`;
+  }
+  const message = update.message;
+  const command = message.text.trim().startsWith("/") ? " command" : ` prompt len=${String(message.text.length)}`;
+  return `message chat=${String(message.chat.id)} from=${String(message.fromId ?? 0)}${command}`;
+}
+
+// src/host/local-remote.ts
+async function envelope(run2) {
+  try {
+    return { ok: true, value: await run2() };
+  } catch (error) {
+    return { ok: false, error: { message: error instanceof Error ? error.message : String(error) } };
+  }
+}
+function createLocalRemote(ctx) {
+  const services = ctx;
+  const lifetime = new AbortController;
+  return {
+    session: {
+      list: (request) => envelope(() => services.sessionController.list(request, lifetime.signal)),
+      create: (request) => envelope(() => services.sessionController.create(request)),
+      prompt: (request, signal) => envelope(() => services.sessionController.prompt(request, signal ?? lifetime.signal)),
+      cancel: (request) => envelope(() => services.sessionController.cancel(request)),
+      follow: (request, signal) => services.sessionController.follow(request, signal ?? lifetime.signal)
+    },
+    workspace: {
+      create: (request) => envelope(() => services.workspaceController.create(request))
+    },
+    $on: (name, handler) => ctx.on(name, handler)
+  };
+}
+
+// src/host/plugin.ts
+var name = "hulala-bot";
+var inject = ["sessionController", "workspaceController"];
+var Config = z.object({
+  stateDir: z.string()
+});
+function apply(ctx, config = {}) {
+  const stateDir = config.stateDir ?? botStateDir();
+  let stop;
+  const starting = start(ctx, stateDir).then((value) => {
+    stop = value;
+  }).catch((error) => {
+    console.error(`hulala-bot: ${error instanceof Error ? error.message : String(error)}`);
+  });
+  ctx.effect(() => () => {
+    starting.then(async () => {
+      await stop?.();
+    });
+  }, "hulala-bot: bridge");
+}
+async function start(ctx, stateDir) {
+  const config = await loadConfig(process.env, stateDir);
+  const log = new Log(config.stateDir, [config.telegram?.token ?? "", config.lark?.appSecret ?? ""]);
+  const channels = [];
+  const releases = [];
+  if (config.telegram !== undefined) {
+    try {
+      releases.push(await acquireLock(`telegram:${config.telegram.token}`));
+      const api = new TelegramApi({
+        token: config.telegram.token,
+        baseUrl: config.telegram.baseUrl,
+        proxy: config.telegram.proxy
+      });
+      channels.push(new TelegramChannel({
+        api,
+        config: config.telegram,
+        ledger: await UpdateLedger.open(join5(config.stateDir, "receipts", "telegram.json")),
+        log,
+        commands: COMMANDS
+      }));
+    } catch (error) {
+      log.error(`telegram not started: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (config.lark !== undefined) {
+    try {
+      releases.push(await acquireLock(`lark:${config.lark.appId}`));
+      const api = new LarkApi({
+        appId: config.lark.appId,
+        appSecret: config.lark.appSecret,
+        baseUrl: config.lark.baseUrl
+      });
+      channels.push(new LarkChannel({
+        api,
+        transport: createSdkTransport({
+          appId: config.lark.appId,
+          appSecret: config.lark.appSecret,
+          domain: config.lark.domain,
+          onError: (error) => {
+            log.error(`lark connection: ${error.message}`);
+          }
+        }),
+        config: config.lark,
+        ledger: await UpdateLedger.open(join5(config.stateDir, "receipts", "lark.json")),
+        log
+      }));
+    } catch (error) {
+      log.error(`lark not started: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (channels.length === 0) {
+    await releaseAll(releases);
+    throw new Error(`no channel started (see ${join5(config.stateDir, "logs")})`);
+  }
+  const remote = createLocalRemote(ctx);
+  const connect2 = async () => ({
+    ctx: { remote },
+    close: async () => {
+      return;
+    }
+  });
+  const bindings = await Bindings.open(config.stateDir);
+  const bridge = new Bridge({ config, channels, bindings, log, connect: connect2 });
+  log.info(`bot starting inside the Host; channels ${channels.map((channel) => channel.name).join(", ")}; state ${config.stateDir}`);
+  await bridge.start();
+  return async () => {
+    await Promise.race([bridge.stop(), new Promise((settle) => setTimeout(settle, 5000))]);
+    await releaseAll(releases);
+  };
+}
+async function releaseAll(releases) {
+  for (const release of releases)
+    await release().catch(() => {
+      return;
+    });
+}
+export {
+  name,
+  inject,
+  apply,
+  Config
+};