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

package/dist/cli.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../cli/src/args.ts
 var DEFAULT_PROFILE = "default";
@@ -38,6 +40,7 @@ function parseServe(argv) {
     dryRun: false,
     once: false,
     replyEnabled: true,
+    cardEnabled: true,
     timeoutMs: DEFAULT_TIMEOUT_MS,
     opencodeBin: "opencode"
   };
@@ -120,6 +123,12 @@ function parseServe(argv) {
       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}"` };
     }
@@ -174,6 +183,11 @@ SERVE OPTIONS
   --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
@@ -182,6 +196,9 @@ NOTES
     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.
 `;
 }
 
@@ -352,7 +369,207 @@ function buildOpencodeArgs(input) {
   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;
@@ -392,19 +609,52 @@ class Dispatcher {
       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) {
-        return { status: "agent-error", plan, error: 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()) {
-        return { status: "no-output", plan, toolCalls: result.toolCalls ?? 0 };
+        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) {
-        return { status: "no-reply", plan, text: result.text };
+        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,
@@ -414,12 +664,106 @@ class Dispatcher {
         atOpenId: senderOpenId
       });
       if (!sent.ok) {
-        return { status: "reply-failed", plan, error: sent.error ?? "unknown", text: result.text };
+        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)
+        };
       }
-      return { status: "dispatched", plan, replyMessageId: sent.messageId, text: result.text };
+      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 {
@@ -486,6 +830,7 @@ class NdjsonAssembler {
   error;
   toolCalls = 0;
   sessionId;
+  tools = [];
   pushChunk(chunk) {
     this.tail += chunk;
     let idx = this.tail.indexOf(`
@@ -522,6 +867,10 @@ class NdjsonAssembler {
     }
     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") {
@@ -540,7 +889,8 @@ class NdjsonAssembler {
       text,
       error: this.error,
       toolCalls: this.toolCalls,
-      sessionId: this.sessionId
+      sessionId: this.sessionId,
+      tools: this.tools
     };
   }
 }
@@ -711,23 +1061,32 @@ function makeOpencodeRunner(opts = {}) {
         text: result.text,
         error: `opencode timed out after ${timeoutMs}ms`,
         sessionId: result.sessionId,
-        toolCalls: result.toolCalls
+        toolCalls: result.toolCalls,
+        tools: result.tools
       };
     }
     if (result.error) {
-      return { text: result.text, error: result.error, sessionId: result.sessionId, toolCalls: result.toolCalls };
+      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
+        toolCalls: result.toolCalls,
+        tools: result.tools
       };
     }
     return {
       text: result.text,
       sessionId: result.sessionId,
-      toolCalls: result.toolCalls
+      toolCalls: result.toolCalls,
+      tools: result.tools
     };
   };
 }
@@ -827,11 +1186,13 @@ 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
+    deduper,
+    card
   }, {
     dryRun: options.dryRun,
     replyEnabled: options.replyEnabled,
@@ -907,6 +1268,7 @@ function formatBanner(options, commands, maxConcurrency) {
     `  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`,
@@ -917,22 +1279,30 @@ function formatBanner(options, commands, maxConcurrency) {
   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}`;
+      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}`;
+      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}`;
+      return `[roy-task] ${label} no-reply (reply disabled) chars=${result.text.length}${card}`;
     case "agent-error":
-      return `[roy-task] ${label} agent-error: ${result.error}`;
+      return `[roy-task] ${label} agent-error: ${result.error}${card}`;
     case "reply-failed":
-      return `[roy-task] ${label} reply-failed: ${result.error}`;
+      return `[roy-task] ${label} reply-failed: ${result.error}${card}`;
     case "no-target":
       return `[roy-task] ${label} skipped: ${result.reason}`;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-task-plugin",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "main": "./dist/index.js",
   "scripts": {