@ai-setting/roy-task-plugin 0.1.0 → 0.3.0

package/dist/cli.js

@@ -0,0 +1,1475 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// ../cli/src/args.ts
+var DEFAULT_PROFILE = "default";
+var DEFAULT_AGENT = "roy";
+var DEFAULT_EVENT_KEY = "im.message.receive_v1";
+var DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
+var SUBCOMMANDS = new Set(["serve", "status", "help", "version"]);
+function parseArgs(argv) {
+  if (argv.includes("--help") || argv.includes("-h"))
+    return { command: "help" };
+  if (argv.includes("--version") || argv.includes("-v"))
+    return { command: "version" };
+  const head = argv.find((a) => !a.startsWith("-"));
+  const command = head ?? "serve";
+  if (!SUBCOMMANDS.has(command)) {
+    return { command: "unknown", error: `unknown command "${command}"` };
+  }
+  const rest = head ? argv.filter((a, i) => !(a === head && argv.indexOf(head) === i)) : argv;
+  if (command === "help")
+    return { command: "help" };
+  if (command === "version")
+    return { command: "version" };
+  if (command === "status") {
+    const profile = readValue(rest, "--profile");
+    if (profile instanceof Error)
+      return { command: "unknown", error: profile.message };
+    return { command: "status", profile: profile ?? DEFAULT_PROFILE };
+  }
+  return parseServe(rest);
+}
+function parseServe(argv) {
+  const serve = {
+    profile: DEFAULT_PROFILE,
+    agent: DEFAULT_AGENT,
+    eventKeys: [],
+    maxConcurrency: 1,
+    dryRun: false,
+    once: false,
+    replyEnabled: true,
+    cardEnabled: true,
+    timeoutMs: DEFAULT_TIMEOUT_MS,
+    opencodeBin: "opencode"
+  };
+  for (let i = 0;i < argv.length; i++) {
+    const raw = argv[i];
+    if (!raw.startsWith("-")) {
+      return { command: "unknown", error: `unexpected positional argument "${raw}"` };
+    }
+    const [flag, inline] = splitInline(raw);
+    const take = () => {
+      if (inline !== undefined)
+        return inline;
+      const next = argv[i + 1];
+      if (next === undefined || next.startsWith("--")) {
+        return new Error(`flag ${flag} requires a value`);
+      }
+      i++;
+      return next;
+    };
+    switch (flag) {
+      case "--profile": {
+        const v = take();
+        if (v instanceof Error)
+          return { command: "unknown", error: v.message };
+        serve.profile = v;
+        break;
+      }
+      case "--agent": {
+        const v = take();
+        if (v instanceof Error)
+          return { command: "unknown", error: v.message };
+        serve.agent = v;
+        break;
+      }
+      case "--event-key": {
+        const v = take();
+        if (v instanceof Error)
+          return { command: "unknown", error: v.message };
+        serve.eventKeys.push(v);
+        break;
+      }
+      case "--opencode-bin": {
+        const v = take();
+        if (v instanceof Error)
+          return { command: "unknown", error: v.message };
+        serve.opencodeBin = v;
+        break;
+      }
+      case "--max-concurrency": {
+        const v = take();
+        if (v instanceof Error)
+          return { command: "unknown", error: v.message };
+        const n = Number(v);
+        if (!Number.isInteger(n) || n < 1) {
+          return { command: "unknown", error: `--max-concurrency must be a positive integer, got "${v}"` };
+        }
+        serve.maxConcurrency = n;
+        break;
+      }
+      case "--timeout-ms": {
+        const v = take();
+        if (v instanceof Error)
+          return { command: "unknown", error: v.message };
+        const n = Number(v);
+        if (!Number.isInteger(n) || n < 1) {
+          return { command: "unknown", error: `--timeout-ms must be a positive integer, got "${v}"` };
+        }
+        serve.timeoutMs = n;
+        break;
+      }
+      case "--dry-run":
+        serve.dryRun = true;
+        break;
+      case "--once":
+        serve.once = true;
+        break;
+      case "--no-reply":
+        serve.replyEnabled = false;
+        break;
+      case "--reply":
+        serve.replyEnabled = true;
+        break;
+      case "--card":
+        serve.cardEnabled = true;
+        break;
+      case "--no-card":
+        serve.cardEnabled = false;
+        break;
+      default:
+        return { command: "unknown", error: `unknown flag "${flag}"` };
+    }
+  }
+  if (serve.eventKeys.length === 0)
+    serve.eventKeys.push(DEFAULT_EVENT_KEY);
+  return { command: "serve", serve };
+}
+function splitInline(raw) {
+  const eq = raw.indexOf("=");
+  if (eq === -1)
+    return [raw, undefined];
+  return [raw.slice(0, eq), raw.slice(eq + 1)];
+}
+function readValue(argv, flag) {
+  for (let i = 0;i < argv.length; i++) {
+    const [name, inline] = splitInline(argv[i]);
+    if (name !== flag)
+      continue;
+    if (inline !== undefined)
+      return inline;
+    const next = argv[i + 1];
+    if (next === undefined || next.startsWith("--"))
+      return new Error(`flag ${flag} requires a value`);
+    return next;
+  }
+  return;
+}
+function usage() {
+  return `roy-task — bridge Feishu (Lark) messages to an OpenCode roy agent
+
+USAGE
+  roy-task [serve] [options]      start the daemon (default command)
+  roy-task serve --dry-run        listen and log, but never spawn or reply
+  roy-task serve --once           handle exactly one event, then exit
+  roy-task status                 show lark-cli consumer + config state
+  roy-task help | --version
+
+SERVE OPTIONS
+  --profile <name>        lark-cli profile to consume with        (default: ${DEFAULT_PROFILE})
+                          ⚠️ MUST be an app whose event key is not
+                          already consumed — lark-cli allows one
+                          consumer per (app, EventKey); a second one
+                          silently splits the event stream.
+  --event-key <key>       event key to consume (repeatable)       (default: ${DEFAULT_EVENT_KEY})
+  --agent <name>          opencode agent to dispatch to           (default: ${DEFAULT_AGENT})
+  --opencode-bin <path>   opencode binary                         (default: opencode)
+  --max-concurrency <n>   max simultaneous agent runs             (default: 1)
+                          ⚠️ >1 only safe across DIFFERENT chats;
+                          same-session concurrency cross-contaminates.
+  --timeout-ms <n>        per-run timeout                          (default: ${DEFAULT_TIMEOUT_MS})
+  --dry-run               never spawn opencode, never reply
+  --once                  stop after the first event (testing / CI)
+  --reply / --no-reply    send the reply back to Feishu          (default: on)
+  --card / --no-card      render a roy-agent progress card        (default: on)
+                          (one pinned card per dispatch, patched to
+                          a terminal state; rendered by roy-agent's
+                          own LarkCardPatchNotifier). Card failures
+                          never block the text reply.
+
+NOTES
+  • stdin is forced to EOF for \`opencode run\` (stdio[0]="ignore"). Without it
+    opencode's readStdin() waits for EOF on a socket and the run hangs forever.
+  • \`lark-cli event consume\` needs the OPPOSITE: its stdin must stay open.
+    That side is handled by roy-agent-core, which we import.
+  • Replies are sent by the daemon (not by the agent) as a single structured
+    post, so nothing is duplicated and nothing is segmented.
+  • The progress card reuses roy-agent's card renderer verbatim (card JSON
+    schema 2.0, timeline, spinner, pin/unpin). roy-task only supplies the two
+    things the renderer asks for: chatId and profile.
+`;
+}
+
+// ../cli/src/daemon/concurrency.ts
+class ConcurrencyGate {
+  maxConcurrency;
+  running = 0;
+  busyKeys = new Set;
+  queue = [];
+  constructor(opts = {}) {
+    const n = opts.maxConcurrency ?? 1;
+    this.maxConcurrency = Math.max(1, Math.floor(n));
+  }
+  get pending() {
+    return this.queue.length;
+  }
+  get active() {
+    return this.running;
+  }
+  async run(key, task) {
+    await this.acquire(key);
+    try {
+      return await task();
+    } finally {
+      this.release(key);
+    }
+  }
+  async acquire(key) {
+    if (this.canStart(key)) {
+      this.take(key);
+      return;
+    }
+    await new Promise((resolve) => {
+      this.queue.push({ key, waiter: { resolve } });
+    });
+  }
+  canStart(key) {
+    return this.running < this.maxConcurrency && !this.busyKeys.has(key);
+  }
+  take(key) {
+    this.running++;
+    this.busyKeys.add(key);
+  }
+  release(key) {
+    this.running--;
+    this.busyKeys.delete(key);
+    this.pump();
+  }
+  pump() {
+    while (this.queue.length > 0 && this.running < this.maxConcurrency) {
+      const head = this.queue[0];
+      if (this.busyKeys.has(head.key))
+        return;
+      this.queue.shift();
+      this.take(head.key);
+      head.waiter.resolve();
+    }
+  }
+}
+
+// ../cli/src/daemon/dedupe.ts
+var DEFAULT_TTL_MS = 60000;
+var DEFAULT_MAX_ENTRIES = 5000;
+
+class Deduper {
+  ttlMs;
+  maxEntries;
+  now;
+  seen = new Map;
+  constructor(opts = {}) {
+    this.ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS;
+    this.maxEntries = opts.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    this.now = opts.now ?? Date.now;
+  }
+  get size() {
+    return this.seen.size;
+  }
+  check(key) {
+    if (!key)
+      return true;
+    const t = this.now();
+    const prev = this.seen.get(key);
+    if (prev !== undefined && t - prev < this.ttlMs) {
+      return false;
+    }
+    this.seen.delete(key);
+    this.seen.set(key, t);
+    if (this.seen.size > this.maxEntries) {
+      const oldest = this.seen.keys().next();
+      if (!oldest.done)
+        this.seen.delete(oldest.value);
+    }
+    return true;
+  }
+  sweep() {
+    const t = this.now();
+    for (const [key, at] of this.seen) {
+      if (t - at >= this.ttlMs)
+        this.seen.delete(key);
+    }
+  }
+  clear() {
+    this.seen.clear();
+  }
+}
+
+// ../cli/src/daemon/session-map.ts
+import { createHash } from "node:crypto";
+var DIGEST_LEN = 16;
+function deriveSessionId(input) {
+  const profile = input.profile ?? "";
+  const chatId = input.chatId ?? "";
+  const material = `${profile}\x00${chatId}`;
+  const digest = createHash("sha256").update(material).digest("hex");
+  return `ses_${digest.slice(0, DIGEST_LEN)}`;
+}
+
+// ../cli/src/daemon/prompt.ts
+var OPENCODE_STDIO = Object.freeze([
+  "ignore",
+  "pipe",
+  "pipe"
+]);
+function buildDispatchPrompt(input) {
+  const profile = input.profile ?? "(active lark-cli profile)";
+  const event = input.rawEvent;
+  const chatId = event?.chat_id ?? "(unknown)";
+  const messageId = event?.message_id ?? event?.id ?? "(unknown)";
+  const eventId = event?.event_id ?? "(unknown)";
+  const parts = [
+    "你收到一条飞书（Lark）消息，请处理它。",
+    "",
+    "## 硬性规则",
+    "",
+    "1. **不要**自己调用 `lark-cli` 发送回复。守护进程会在你结束后，把你的",
+    "   **最终回答文本**用 `lark-cli im +messages-reply` 一次性发回飞书。",
+    "   你自己发会造成重复消息。",
+    "2. 把**最终回答**写成给发件人看的**普通散文 / Markdown**。",
+    "   不要输出 JSON 包裹、不要输出“我调用了某某工具”的过程流水账。",
+    "   这段文本会**原样**成为飞书里的回复正文。",
+    "3. 需要落任务就用 `task_*` 工具（task_create / task_update / …），",
+    "   这是你的主要职责；不要只在回答里“描述”你打算做什么。",
+    "",
+    "## 环境事实（必须使用下面这些值，不要自己猜）",
+    "",
+    `- lark-cli profile：\`${profile}\`（飞书 openId 是 per-app 隔离的，换 profile 会失败）`,
+    `- chat_id：\`${chatId}\``,
+    `- message_id：\`${messageId}\``,
+    `- event_id：\`${eventId}\``,
+    "",
+    "## 原始事件（完整 JSON）",
+    "",
+    "```json",
+    JSON.stringify(input.rawEvent, null, 2),
+    "```"
+  ];
+  if (input.recommendedAction) {
+    parts.push("", "## 事件源附带的回复契约（背景资料，仅供你理解上下文）", "", "> ⚠️ 下面这段通常要求“由 agent 自己调 lark-cli 回复”。本次**不适用**：", "> 回复由守护进程负责。但其中关于内容编排的规范（单条、结构化、", "> 30KB 上限等）仍然值得遵守——你写的内容会被塞进那一条 post 里。", "", input.recommendedAction);
+  }
+  return parts.join(`
+`);
+}
+function buildOpencodeArgs(input) {
+  const args = ["run", "--agent", input.agent ?? "roy", "--format", "json", "--auto"];
+  if (input.sessionId)
+    args.push("-s", input.sessionId);
+  args.push(input.prompt);
+  return args;
+}
+
+// ../cli/src/daemon/task-card.ts
+var CARD_OP_TIMEOUT_MS = 15000;
+
+class CardTimeoutError extends Error {
+  constructor(op, ms) {
+    super(`card ${op} timed out after ${ms}ms`);
+    this.name = "CardTimeoutError";
+  }
+}
+function withTimeout(op, promise, ms) {
+  if (ms <= 0)
+    return promise;
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new CardTimeoutError(op, ms)), ms);
+    if (typeof timer === "object" && timer && "unref" in timer)
+      timer.unref();
+    promise.then((v) => {
+      clearTimeout(timer);
+      resolve(v);
+    }, (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+  });
+}
+function createRoyAgentCardPort(options = {}) {
+  const opTimeoutMs = options.opTimeoutMs ?? CARD_OP_TIMEOUT_MS;
+  let notifier;
+  let inFlight;
+  const loadNotifier = async () => {
+    const mod = await import("@ai-setting/roy-agent-core/env/task/plugins");
+    const hook = mod.createLarkCliTaskNotifyHook({ enabled: true, cardMode: true });
+    const maybeNotifier = hook.cardNotifier;
+    if (!maybeNotifier) {
+      throw new Error("roy-agent did not expose cardNotifier from createLarkCliTaskNotifyHook");
+    }
+    notifier = maybeNotifier;
+    return notifier;
+  };
+  const getNotifier = () => {
+    if (options.loadNotifier)
+      return options.loadNotifier();
+    if (notifier)
+      return Promise.resolve(notifier);
+    inFlight ??= loadNotifier().catch((err) => {
+      inFlight = undefined;
+      throw err;
+    });
+    return inFlight;
+  };
+  return {
+    async start(input) {
+      const n = await withTimeout("load", getNotifier(), opTimeoutMs);
+      return withTimeout("start", n.startTask({
+        chatId: input.chatId,
+        profile: input.profile,
+        meta: input.meta,
+        milestones: input.milestones
+      }), opTimeoutMs);
+    },
+    async update(input) {
+      const n = await withTimeout("load", getNotifier(), opTimeoutMs);
+      await withTimeout("update", n.updateTask({
+        messageId: input.messageId,
+        chatId: input.chatId,
+        profile: input.profile,
+        status: input.status ?? "running",
+        progress: input.progress,
+        meta: input.meta,
+        milestones: input.milestones,
+        processSteps: input.processSteps
+      }), opTimeoutMs);
+    },
+    async finish(input) {
+      const n = await withTimeout("load", getNotifier(), opTimeoutMs);
+      await withTimeout("finish", n.finishTask({
+        messageId: input.messageId,
+        chatId: input.chatId,
+        profile: input.profile,
+        status: input.status,
+        meta: input.meta,
+        finalStep: input.finalStep,
+        progress: input.progress
+      }), opTimeoutMs);
+    }
+  };
+}
+function createNoopCardPort() {
+  return {
+    async start() {
+      return { messageId: "", pinned: false };
+    },
+    async update() {},
+    async finish() {}
+  };
+}
+function buildCardIdentity(input) {
+  const maxTitle = input.maxTitleChars ?? 60;
+  const normalized = input.text.replace(/\r\n/g, `
+`).trim();
+  const lines = normalized.split(`
+`).map((l) => l.trim()).filter(Boolean);
+  const first = lines[0] ?? "(非文本消息)";
+  const rest = lines.slice(1).join(`
+`);
+  const title = first.length > maxTitle ? `${first.slice(0, maxTitle - 1)}…` : first;
+  return {
+    id: `om:${input.messageId.slice(-12)}`,
+    title,
+    description: rest || first,
+    goals: "完成用户请求并把结果回复到触发消息所在会话"
+  };
+}
+var TOOL_LABELS = {
+  shell: "执行命令",
+  read: "读取文件",
+  write: "写入文件",
+  edit: "修改文件",
+  bash: "执行命令",
+  glob: "搜索文件",
+  grep: "搜索内容",
+  task: "调用子任务",
+  webfetch: "获取网页",
+  todowrite: "更新待办",
+  task_create: "创建任务",
+  task_update: "更新任务",
+  task_complete: "完成任务",
+  task_operation_create: "记录进展"
+};
+function describeToolUse(tool) {
+  return {
+    title: TOOL_LABELS[tool] ?? tool,
+    timestamp: new Date().toISOString(),
+    category: tool
+  };
+}
+
+// ../cli/src/daemon/dispatcher.ts
+function cardReport(handle) {
+  const out = {};
+  if (handle.messageId)
+    out.cardMessageId = handle.messageId;
+  if (handle.error)
+    out.cardError = handle.error;
+  return out;
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function extractUserText(raw) {
+  if (!raw)
+    return "";
+  const content = raw.content;
+  if (typeof content !== "string" || !content.trim())
+    return "";
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    if (/^\s*[{[]/.test(content))
+      return "";
+    return content;
+  }
+  if (parsed && typeof parsed === "object") {
+    const obj = parsed;
+    if (typeof obj.text === "string")
+      return obj.text;
+    const rich = extractRichPostText(obj);
+    if (rich)
+      return rich;
+    return "";
+  }
+  return typeof parsed === "string" ? parsed : "";
+}
+function extractRichPostText(obj) {
+  const locale = obj.zh_cn ?? obj.en_us ?? Object.values(obj).find((v) => !!v && typeof v === "object");
+  if (!locale || typeof locale !== "object")
+    return "";
+  const content = locale.content;
+  if (!Array.isArray(content)) {
+    const title = locale.title;
+    return typeof title === "string" ? title : "";
+  }
+  const paragraphs = [];
+  for (const paragraph of content) {
+    if (!Array.isArray(paragraph))
+      continue;
+    const line = paragraph.map((node) => {
+      if (node && typeof node === "object" && "text" in node) {
+        const t = node.text;
+        return typeof t === "string" ? t : "";
+      }
+      return "";
+    }).join("").trim();
+    if (line)
+      paragraphs.push(line);
+  }
+  return paragraphs.join(`
+`).trim();
+}
+
+class Dispatcher {
+  deps;
+  opts;
+  deduper;
+  constructor(deps, opts = {}) {
+    this.deps = deps;
+    this.opts = opts;
+    this.deduper = deps.deduper ?? new Deduper;
+  }
+  get dedup() {
+    return this.deduper;
+  }
+  async handle(event) {
+    const payload = event.payload ?? {};
+    const raw = payload.rawEvent ?? {};
+    const md = payload.metadata ?? {};
+    const rc = payload.replyChannel ?? {};
+    const chatId = md.chatId ?? rc.chatId ?? raw.chat_id ?? "";
+    const messageId = md.messageId ?? rc.messageId ?? raw.message_id ?? raw.id ?? "";
+    const profile = rc.profile;
+    const senderOpenId = rc.params?.userId ?? md.senderId ?? raw.sender_id;
+    if (!chatId || !messageId) {
+      return { status: "no-target", reason: "event has no chatId/messageId" };
+    }
+    const dedupKey = raw.event_id ?? messageId;
+    const plan = this.buildPlan({
+      raw,
+      chatId,
+      messageId,
+      profile,
+      recommendedAction: payload.recommendedAction?.action
+    });
+    if (!this.deduper.check(dedupKey)) {
+      return { status: "duplicate", plan, key: dedupKey };
+    }
+    if (this.opts.dryRun) {
+      return { status: "dry-run", plan };
+    }
+    const run = async () => {
+      const cardPromise = this.openCard({ chatId, messageId, profile, raw });
+      const result = await this.deps.runAgent({
+        prompt: plan.prompt,
+        agent: plan.agent,
+        sessionId: plan.sessionId
+      });
+      const card = await cardPromise;
+      if (card.messageId) {
+        await this.patchCard(card, {
+          chatId,
+          profile,
+          tools: result.tools,
+          status: result.error ? "failed" : "running"
+        });
+      }
+      if (result.error) {
+        await this.closeCard(card, {
+          chatId,
+          profile,
+          status: "failed",
+          finalStep: `agent 报错：${result.error}`
+        });
+        return { status: "agent-error", plan, error: result.error, ...cardReport(card) };
+      }
+      if (!result.text.trim()) {
+        await this.closeCard(card, {
+          chatId,
+          profile,
+          status: "failed",
+          finalStep: "agent 未产出可用文本，未回复"
+        });
+        return {
+          status: "no-output",
+          plan,
+          toolCalls: result.toolCalls ?? 0,
+          ...cardReport(card)
+        };
+      }
+      if (this.opts.replyEnabled === false) {
+        await this.closeCard(card, {
+          chatId,
+          profile,
+          status: "completed",
+          finalStep: "--no-reply：agent 已完成，未发送回复"
+        });
+        return { status: "no-reply", plan, text: result.text, ...cardReport(card) };
+      }
+      const sent = await this.deps.reply({
+        messageId,
+        chatId,
+        text: result.text,
+        profile,
+        atOpenId: senderOpenId
+      });
+      if (!sent.ok) {
+        await this.closeCard(card, {
+          chatId,
+          profile,
+          status: "failed",
+          finalStep: `回复发送失败：${sent.error ?? "unknown"}`
+        });
+        return {
+          status: "reply-failed",
+          plan,
+          error: sent.error ?? "unknown",
+          text: result.text,
+          ...cardReport(card)
+        };
+      }
+      await this.closeCard(card, {
+        chatId,
+        profile,
+        status: "completed",
+        finalStep: "已回复到原消息"
+      });
+      return {
+        status: "dispatched",
+        plan,
+        replyMessageId: sent.messageId,
+        text: result.text,
+        ...cardReport(card)
+      };
+    };
+    return this.deps.gate ? this.deps.gate.run(plan.sessionId, run) : run();
+  }
+  async openCard(input) {
+    const handle = { messageId: "" };
+    if (!this.deps.card)
+      return handle;
+    try {
+      const identity = buildCardIdentity({
+        messageId: input.messageId,
+        text: extractUserText(input.raw)
+      });
+      const started = await this.deps.card.start({
+        chatId: input.chatId,
+        profile: input.profile,
+        meta: {
+          id: identity.id,
+          title: identity.title,
+          description: identity.description,
+          goals: identity.goals,
+          type: "normal",
+          priority: "high",
+          currentStatus: "已收到消息，正在处理"
+        },
+        milestones: [
+          {
+            title: "收到消息",
+            timestamp: new Date().toISOString(),
+            description: `来自飞书消息 ${input.messageId}`
+          }
+        ]
+      });
+      handle.messageId = started.messageId;
+      handle.pinned = started.pinned;
+    } catch (err) {
+      handle.error = errorMessage(err);
+    }
+    return handle;
+  }
+  async patchCard(handle, input) {
+    if (!this.deps.card || !handle.messageId || handle.error)
+      return;
+    const tools = input.tools ?? [];
+    if (tools.length === 0)
+      return;
+    try {
+      await this.deps.card.update({
+        messageId: handle.messageId,
+        chatId: input.chatId,
+        profile: input.profile,
+        status: input.status,
+        processSteps: tools.map(describeToolUse)
+      });
+    } catch (err) {
+      handle.error ??= errorMessage(err);
+    }
+  }
+  async closeCard(handle, input) {
+    if (!this.deps.card || !handle.messageId || handle.error)
+      return;
+    try {
+      await this.deps.card.finish({
+        messageId: handle.messageId,
+        chatId: input.chatId,
+        profile: input.profile,
+        status: input.status,
+        finalStep: input.finalStep,
+        progress: input.status === "completed" ? 100 : undefined
+      });
+    } catch (err) {
+      handle.error ??= errorMessage(err);
+    }
+  }
+  buildPlan(input) {
+    const derive = this.opts.sessionIdFor ?? deriveSessionId;
+    return {
+      agent: this.opts.agent ?? "roy",
+      sessionId: derive({ profile: input.profile, chatId: input.chatId }),
+      prompt: buildDispatchPrompt({
+        rawEvent: input.raw,
+        profile: input.profile,
+        recommendedAction: input.recommendedAction
+      }),
+      chatId: input.chatId,
+      messageId: input.messageId,
+      profile: input.profile
+    };
+  }
+}
+
+// ../cli/src/daemon/es-listener.ts
+import { larkCliHandler } from "@ai-setting/roy-agent-core/env/event-source";
+function createEventListener(config) {
+  const eventKeys = config.eventKeys?.length ? config.eventKeys : ["im.message.receive_v1"];
+  const sourceId = config.sourceId ?? "roy-task-es";
+  const instance = larkCliHandler.createInstance({
+    id: sourceId,
+    name: "roy-task event source",
+    type: "lark-cli",
+    enabled: true,
+    profile: config.profile,
+    eventKeys
+  });
+  let callback;
+  instance.onEvent((event) => {
+    const typed = event;
+    if (!callback)
+      return;
+    Promise.resolve(callback(typed)).catch((err) => {
+      console.error("[roy-task] event handler threw:", err instanceof Error ? err.message : err);
+    });
+  });
+  return {
+    onEvent(cb) {
+      callback = cb;
+    },
+    async start() {
+      await instance.start();
+    },
+    async stop() {
+      await instance.stop();
+    },
+    status() {
+      return instance.getStatus();
+    },
+    plannedCommands() {
+      const profileFlag = config.profile ? `--profile ${config.profile} ` : "";
+      return eventKeys.map((k) => `lark-cli ${profileFlag}event consume ${k} --as bot`);
+    }
+  };
+}
+
+// ../cli/src/daemon/ndjson.ts
+class NdjsonAssembler {
+  tail = "";
+  texts = [];
+  error;
+  toolCalls = 0;
+  sessionId;
+  tools = [];
+  pushChunk(chunk) {
+    this.tail += chunk;
+    let idx = this.tail.indexOf(`
+`);
+    while (idx !== -1) {
+      const line = this.tail.slice(0, idx);
+      this.tail = this.tail.slice(idx + 1);
+      this.parseLine(line);
+      idx = this.tail.indexOf(`
+`);
+    }
+  }
+  pushLine(line) {
+    this.parseLine(line);
+  }
+  finishIncomplete() {
+    return this.tail.trim();
+  }
+  parseLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed[0] !== "{")
+      return;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    if (parsed.sessionID)
+      this.sessionId = parsed.sessionID;
+    if (parsed.type === "text" && typeof parsed.part?.text === "string") {
+      this.texts.push(parsed.part.text);
+      return;
+    }
+    if (parsed.type === "tool_use") {
+      this.toolCalls += 1;
+      const name = parsed.part?.tool ?? parsed.tool;
+      if (typeof name === "string" && name) {
+        this.tools.push(name);
+      }
+      return;
+    }
+    if (parsed.type === "error") {
+      if (this.error === undefined) {
+        this.error = parsed.error?.message ?? parsed.error?.type ?? "unknown opencode error";
+      }
+    }
+  }
+  finish() {
+    if (this.tail.trim()) {
+      this.parseLine(this.tail);
+      this.tail = "";
+    }
+    const text = this.texts.join("").trim();
+    return {
+      text,
+      error: this.error,
+      toolCalls: this.toolCalls,
+      sessionId: this.sessionId,
+      tools: this.tools
+    };
+  }
+}
+
+// ../cli/src/runtime/spawn.ts
+import { spawn } from "node:child_process";
+function runCapture(cmd, opts = {}) {
+  return new Promise((resolve, reject) => {
+    let child;
+    try {
+      child = spawn(cmd[0], cmd.slice(1), {
+        stdio: [assertEofStdin(opts.stdin), "pipe", "pipe"],
+        env: opts.env ? normalizeEnv(opts.env) : process.env,
+        cwd: opts.cwd,
+        windowsHide: true
+      });
+    } catch (err) {
+      reject(err);
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    const timer = opts.timeoutMs && opts.timeoutMs > 0 ? setTimeout(() => {
+      timedOut = true;
+      try {
+        child.kill("SIGTERM");
+      } catch {}
+      setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {}
+      }, 2000).unref?.();
+    }, opts.timeoutMs) : undefined;
+    timer?.unref?.();
+    child.on("error", (err) => {
+      if (timer)
+        clearTimeout(timer);
+      reject(err);
+    });
+    child.on("close", (code, signal) => {
+      if (timer)
+        clearTimeout(timer);
+      if (timedOut) {
+        resolve({ code: 124, stdout, stderr });
+        return;
+      }
+      resolve({ code: code ?? (signal ? 1 : 0), stdout, stderr });
+    });
+  });
+}
+function spawnStreaming(cmd, opts = {}) {
+  const child = spawn(cmd[0], cmd.slice(1), {
+    stdio: [assertEofStdin(opts.stdin), "pipe", "pipe"],
+    env: opts.env ? normalizeEnv(opts.env) : process.env,
+    cwd: opts.cwd,
+    windowsHide: true
+  });
+  let timedOut = false;
+  const timer = opts.timeoutMs && opts.timeoutMs > 0 ? setTimeout(() => {
+    timedOut = true;
+    try {
+      child.kill("SIGTERM");
+    } catch {}
+  }, opts.timeoutMs) : undefined;
+  timer?.unref?.();
+  if (opts.onStdout || opts.onStderr) {
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => opts.onStdout?.(chunk));
+    child.stderr?.on("data", (chunk) => opts.onStderr?.(chunk));
+  } else {
+    child.stdout?.resume();
+    child.stderr?.resume();
+  }
+  const exited = new Promise((resolve, reject) => {
+    child.on("error", (err) => {
+      if (timer)
+        clearTimeout(timer);
+      reject(err);
+    });
+    child.on("close", (code, signal) => {
+      if (timer)
+        clearTimeout(timer);
+      if (timedOut) {
+        resolve(124);
+        return;
+      }
+      resolve(code ?? (signal ? 1 : 0));
+    });
+  });
+  return {
+    exited,
+    pid: child.pid,
+    kill(signal = "SIGTERM") {
+      try {
+        child.kill(signal);
+      } catch {}
+    }
+  };
+}
+function assertEofStdin(value) {
+  if (value !== undefined && value !== "ignore") {
+    throw new Error(`refusing to spawn with stdin=${String(value)}: fd 0 must be an EOF source ` + '(use "ignore"); an inherited socket hangs `opencode run` (see #4376)');
+  }
+  return "ignore";
+}
+function normalizeEnv(env) {
+  const out = {};
+  for (const [k, v] of Object.entries(env)) {
+    if (typeof v === "string")
+      out[k] = v;
+  }
+  return out;
+}
+function isMissingBinary(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+
+// ../cli/src/daemon/opencode-runner.ts
+var DEFAULT_OPENCODE_TIMEOUT_MS = 10 * 60 * 1000;
+function makeOpencodeRunner(opts = {}) {
+  const bin = opts.bin ?? "opencode";
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_OPENCODE_TIMEOUT_MS;
+  return async function runAgent(input) {
+    const args = buildOpencodeArgs({
+      prompt: input.prompt,
+      agent: input.agent,
+      sessionId: input.sessionId
+    });
+    const assembler = new NdjsonAssembler;
+    let stderr = "";
+    let handle;
+    try {
+      handle = spawnStreaming([bin, ...args], {
+        stdin: OPENCODE_STDIO[0],
+        env: { ...process.env, NO_COLOR: "1" },
+        timeoutMs,
+        onStdout: (chunk) => assembler.pushChunk(chunk),
+        onStderr: (chunk) => {
+          if (stderr.length < 64 * 1024)
+            stderr += chunk;
+        }
+      });
+    } catch (err) {
+      return { text: "", error: `failed to spawn ${bin}: ${errMsg(err)}` };
+    }
+    let code;
+    try {
+      code = await handle.exited;
+    } catch (err) {
+      if (isMissingBinary(err)) {
+        return { text: "", error: `failed to spawn ${bin}: ${errMsg(err)}` };
+      }
+      return { text: "", error: errMsg(err) };
+    }
+    const result = assembler.finish();
+    if (code === 124) {
+      return {
+        text: result.text,
+        error: `opencode timed out after ${timeoutMs}ms`,
+        sessionId: result.sessionId,
+        toolCalls: result.toolCalls,
+        tools: result.tools
+      };
+    }
+    if (result.error) {
+      return {
+        text: result.text,
+        error: result.error,
+        sessionId: result.sessionId,
+        toolCalls: result.toolCalls,
+        tools: result.tools
+      };
+    }
+    if (code !== 0 && !result.text) {
+      return {
+        text: "",
+        error: `opencode exited ${code}: ${(stderr || "no stderr").trim().slice(0, 1000)}`,
+        toolCalls: result.toolCalls,
+        tools: result.tools
+      };
+    }
+    return {
+      text: result.text,
+      sessionId: result.sessionId,
+      toolCalls: result.toolCalls,
+      tools: result.tools
+    };
+  };
+}
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// ../cli/src/daemon/reply.ts
+var MAX_POST_BYTES = 28 * 1024;
+
+class EmptyReplyError extends Error {
+  constructor() {
+    super("refusing to send an empty reply");
+    this.name = "EmptyReplyError";
+  }
+}
+function fitToLimit(body, buildContent) {
+  const fits = (text) => Buffer.byteLength(buildContent(text), "utf8") <= MAX_POST_BYTES;
+  if (fits(body))
+    return body;
+  const marker = `
+
+…（内容过长，已截断；truncated to fit Feishu post limit）`;
+  const chars = [...body];
+  let lo = 0;
+  let hi = chars.length;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    if (fits(chars.slice(0, mid).join("") + marker))
+      lo = mid;
+    else
+      hi = mid - 1;
+  }
+  const candidate = chars.slice(0, lo).join("") + marker;
+  return fits(candidate) ? candidate : chars.slice(0, lo).join("");
+}
+function buildReplyInvocation(input) {
+  const text = input.text?.trim() ?? "";
+  if (!text)
+    throw new EmptyReplyError;
+  const rowsFor = (body2) => {
+    const rows = [];
+    if (input.atOpenId)
+      rows.push([{ tag: "at", user_id: input.atOpenId }]);
+    rows.push([{ tag: "md", text: body2 }]);
+    return rows;
+  };
+  const contentFor = (body2) => JSON.stringify({ zh_cn: { content: rowsFor(body2) } });
+  const body = fitToLimit(text, contentFor);
+  const content = contentFor(body);
+  const args = [
+    "im",
+    "+messages-reply",
+    "--message-id",
+    input.messageId,
+    "--as",
+    "bot",
+    "--msg-type",
+    "post",
+    "--content",
+    content
+  ];
+  if (input.profile)
+    args.push("--profile", input.profile);
+  return { command: "lark-cli", args };
+}
+async function defaultReplyRunner(input) {
+  let invocation;
+  try {
+    invocation = buildReplyInvocation(input);
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+  const { code, stdout, stderr } = await runCapture([
+    invocation.command,
+    ...invocation.args
+  ]);
+  if (code !== 0) {
+    return { ok: false, error: (stderr || stdout || `exit ${code}`).trim().slice(0, 2000) };
+  }
+  try {
+    const parsed = JSON.parse(stdout);
+    if (parsed.ok === false) {
+      return { ok: false, error: parsed.error?.message ?? "lark-cli reported failure" };
+    }
+    return { ok: true, messageId: parsed.data?.message_id };
+  } catch {
+    return { ok: true };
+  }
+}
+
+// ../cli/src/cmd/serve.ts
+function serve(options, deps = {}) {
+  return startServe(options, deps);
+}
+async function startServe(options, deps) {
+  const log = deps.log ?? ((line) => console.log(line));
+  const gate = new ConcurrencyGate({ maxConcurrency: options.maxConcurrency });
+  const deduper = new Deduper;
+  const card = deps.card ?? (options.cardEnabled && !options.dryRun ? createRoyAgentCardPort() : createNoopCardPort());
+  const dispatcher = new Dispatcher({
+    runAgent: deps.runAgent ?? makeOpencodeRunner({ bin: options.opencodeBin, timeoutMs: options.timeoutMs }),
+    reply: deps.reply ?? defaultReplyRunner,
+    gate,
+    deduper,
+    card
+  }, {
+    dryRun: options.dryRun,
+    replyEnabled: options.replyEnabled,
+    agent: options.agent
+  });
+  const listener = (deps.createListener ?? createEventListener)({
+    profile: options.profile,
+    eventKeys: options.eventKeys
+  });
+  let eventCount = 0;
+  let stopping;
+  let resolveDone;
+  const done = new Promise((resolve) => {
+    resolveDone = resolve;
+  });
+  const stop = async () => {
+    if (stopping)
+      return stopping;
+    stopping = (async () => {
+      log("[roy-task] stopping event listener…");
+      try {
+        await listener.stop();
+      } catch (err) {
+        log(`[roy-task] listener.stop() failed: ${errMsg2(err)}`);
+      }
+      log("[roy-task] stopped");
+      resolveDone();
+    })();
+    return stopping;
+  };
+  const sweeper = setInterval(() => {
+    deduper.sweep();
+  }, 5 * 60 * 1000);
+  if (typeof sweeper.unref === "function")
+    sweeper.unref();
+  listener.onEvent(async (event) => {
+    eventCount += 1;
+    const label = `#${eventCount}`;
+    try {
+      const result = await dispatcher.handle(event);
+      log(formatResult(label, result));
+      if (options.once && result.status !== "duplicate") {
+        await stop();
+      }
+    } catch (err) {
+      log(`[roy-task] ${label} dispatch threw: ${errMsg2(err)}`);
+      if (options.once)
+        await stop();
+    }
+  });
+  const commands = listener.plannedCommands();
+  log(formatBanner(options, commands, gate.maxConcurrency));
+  try {
+    await listener.start();
+  } catch (err) {
+    log(`[roy-task] failed to start event listener: ${errMsg2(err)}`);
+    clearInterval(sweeper);
+    resolveDone();
+    throw err;
+  }
+  log(`[roy-task] event source status = ${listener.status()}`);
+  log("[roy-task] waiting for events… (Ctrl-C to stop)");
+  return { done, stop, get eventCount() {
+    return eventCount;
+  } };
+}
+function formatBanner(options, commands, maxConcurrency) {
+  const lines = [
+    "────────────────────────────────────────────────────────────",
+    "[roy-task] starting",
+    `  profile          : ${options.profile}`,
+    `  agent            : ${options.agent}`,
+    `  opencode bin     : ${options.opencodeBin}`,
+    `  max concurrency  : ${maxConcurrency}`,
+    `  reply enabled    : ${options.replyEnabled}`,
+    `  progress cards   : ${options.cardEnabled && !options.dryRun}`,
+    `  dry run          : ${options.dryRun}`,
+    `  once             : ${options.once}`,
+    `  timeout          : ${options.timeoutMs}ms`,
+    "  consume commands :",
+    ...commands.map((c) => `    ${c}`),
+    "────────────────────────────────────────────────────────────"
+  ];
+  return lines.join(`
+`);
+}
+function cardSuffix(result) {
+  if (!("cardMessageId" in result) && !("cardError" in result))
+    return "";
+  if (result.cardError)
+    return `  card=FAILED(${result.cardError})`;
+  return `  card=${result.cardMessageId ?? "(none)"}`;
+}
+function formatResult(label, result) {
+  const card = cardSuffix(result);
+  switch (result.status) {
+    case "dispatched":
+      return `[roy-task] ${label} dispatched  chat=${result.plan.chatId} session=${result.plan.sessionId} ` + `reply=${result.replyMessageId ?? "(no id)"} chars=${result.text.length}${card}`;
+    case "dry-run":
+      return `[roy-task] ${label} DRY-RUN  would run agent=${result.plan.agent} ` + `session=${result.plan.sessionId} chat=${result.plan.chatId} prompt=${result.plan.prompt.length}chars`;
+    case "duplicate":
+      return `[roy-task] ${label} duplicate dropped key=${result.key ?? "(unknown)"}`;
+    case "no-output":
+      return `[roy-task] ${label} no-output (agent produced no text; not replying) ` + `toolCalls=${result.toolCalls}${card}`;
+    case "no-reply":
+      return `[roy-task] ${label} no-reply (reply disabled) chars=${result.text.length}${card}`;
+    case "agent-error":
+      return `[roy-task] ${label} agent-error: ${result.error}${card}`;
+    case "reply-failed":
+      return `[roy-task] ${label} reply-failed: ${result.error}${card}`;
+    case "no-target":
+      return `[roy-task] ${label} skipped: ${result.reason}`;
+  }
+}
+function errMsg2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// ../cli/src/runtime/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+  });
+}
+
+// ../cli/src/cmd/status.ts
+async function runCapture2(cmd) {
+  try {
+    return await runCapture(cmd);
+  } catch {
+    return null;
+  }
+}
+async function collectStatus(options) {
+  const warnings = [];
+  let appId;
+  const auth = await runCapture2(["lark-cli", "--profile", options.profile, "auth", "status"]);
+  if (auth !== null && auth.code === 0) {
+    try {
+      const parsed = JSON.parse(auth.stdout);
+      appId = parsed.appId;
+    } catch {}
+  }
+  const lark = await runCapture2(["lark-cli", "event", "status", "--json"]);
+  let larkCliOk = false;
+  let consumerRunning = false;
+  const consumers = [];
+  if (lark === null) {
+    warnings.push("lark-cli not found on PATH");
+  } else if (lark.code !== 0) {
+    warnings.push(`lark-cli event status failed: ${(lark.stderr || lark.stdout).trim().slice(0, 300)}`);
+  } else {
+    try {
+      const parsed = JSON.parse(lark.stdout);
+      larkCliOk = true;
+      if (!appId) {
+        warnings.push(`could not resolve the app_id for profile "${options.profile}"; the consumer check below ` + "covers all apps and may over-report.");
+      }
+      for (const app of parsed.apps ?? []) {
+        if (appId && app.app_id !== appId)
+          continue;
+        if (app.running)
+          consumerRunning = true;
+        for (const c of app.consumers ?? []) {
+          consumers.push({
+            pid: typeof c.pid === "number" ? c.pid : undefined,
+            eventKey: typeof c.event_key === "string" ? c.event_key : undefined,
+            received: typeof c.received === "number" ? c.received : undefined,
+            dropped: typeof c.dropped === "number" ? c.dropped : undefined
+          });
+        }
+      }
+    } catch {
+      warnings.push("could not parse `lark-cli event status --json` output");
+    }
+  }
+  if (consumerRunning) {
+    warnings.push("an event consumer is ALREADY RUNNING for this profile. lark-cli allows one consumer " + "per (app, EventKey): starting a second one silently SPLITS the event stream. " + "Use a different --profile, or stop the existing consumer first.");
+  }
+  let oc = await runCapture2(["opencode", "debug", "agents"]);
+  if (oc !== null && oc.code === 0 && oc.stdout.trim() === "[]") {
+    await sleep(1200);
+    oc = await runCapture2(["opencode", "debug", "agents"]);
+  }
+  let opencodeOk = false;
+  let royAgentPresent = false;
+  if (oc === null) {
+    warnings.push("opencode not found on PATH");
+  } else if (oc.code !== 0) {
+    warnings.push(`opencode debug agents failed: ${(oc.stderr || oc.stdout).trim().slice(0, 300)}`);
+  } else {
+    opencodeOk = true;
+    try {
+      const parsed = JSON.parse(oc.stdout);
+      const list = Array.isArray(parsed) ? parsed : parsed.agents ?? [];
+      royAgentPresent = list.some((a) => a?.id === "roy" || a?.name === "roy");
+      if (!royAgentPresent) {
+        warnings.push("the `roy` agent is NOT registered in opencode. Install/enable the roy task plugin " + "before starting the daemon, otherwise every dispatch fails with 'Agent not found'.");
+      }
+    } catch {
+      warnings.push("could not parse `opencode debug agents` output");
+    }
+  }
+  return {
+    profile: options.profile,
+    appId,
+    larkCliOk,
+    consumerRunning,
+    consumers,
+    opencodeOk,
+    royAgentPresent,
+    warnings
+  };
+}
+function formatStatus(report) {
+  const lines = [
+    `profile           : ${report.profile}${report.appId ? ` (${report.appId})` : ""}`,
+    `lark-cli usable   : ${report.larkCliOk ? "yes" : "NO"}`,
+    `consumer running  : ${report.consumerRunning ? "YES (⚠️ see warnings)" : "no"}`
+  ];
+  if (report.consumers.length) {
+    lines.push("consumers         :");
+    for (const c of report.consumers) {
+      lines.push(`  - pid=${c.pid ?? "?"} key=${c.eventKey ?? "?"} received=${c.received ?? "?"} dropped=${c.dropped ?? "?"}`);
+    }
+  }
+  lines.push(`opencode usable   : ${report.opencodeOk ? "yes" : "NO"}`);
+  lines.push(`roy agent present : ${report.royAgentPresent ? "yes" : "NO"}`);
+  if (report.warnings.length) {
+    lines.push("", "warnings:");
+    for (const w of report.warnings)
+      lines.push(`  ⚠️ ${w}`);
+  }
+  return lines.join(`
+`);
+}
+
+// ../cli/src/main.ts
+var VERSION = "0.2.0";
+async function main(argv) {
+  const parsed = parseArgs(argv);
+  switch (parsed.command) {
+    case "help":
+      console.log(usage());
+      return 0;
+    case "version":
+      console.log(`roy-task ${VERSION}`);
+      return 0;
+    case "unknown":
+      console.error(`roy-task: ${parsed.error}
+`);
+      console.error(usage());
+      return 2;
+    case "status": {
+      const report = await collectStatus({ profile: parsed.profile });
+      console.log(formatStatus(report));
+      return report.consumerRunning || !report.larkCliOk || !report.royAgentPresent ? 1 : 0;
+    }
+    case "serve": {
+      const handle = await serve(parsed.serve);
+      const onSignal = (signal) => {
+        console.log(`
+[roy-task] received ${signal}, shutting down…`);
+        handle.stop();
+      };
+      process.on("SIGINT", () => onSignal("SIGINT"));
+      process.on("SIGTERM", () => onSignal("SIGTERM"));
+      await handle.done;
+      return 0;
+    }
+  }
+}
+main(process.argv.slice(2)).then((code) => process.exit(code)).catch((err) => {
+  console.error("[roy-task] fatal:", err instanceof Error ? err.message : err);
+  process.exit(1);
+});
+export {
+  VERSION
+};