larkway 0.3.21 → 0.3.23

package/README.md

@@ -8,7 +8,7 @@
 
 You @ the bot in a Feishu thread. It runs on your machine — reading your real codebase, executing commands, opening MRs — and posts the result back. You define what the agent knows and what it can do. Larkway just carries the messages.
 
-**Current release: v0.3.21**
+**Current release: v0.3.23**
 
 ---
 

package/README.zh.md

@@ -8,7 +8,7 @@
 
 你在飞书话题里 @ bot，它在你的机器上运行——读真实代码库、执行命令、开 MR——把结果贴回飞书。你定义 agent 知道什么、能做什么。Larkway 只负责传递消息。
 
-**当前版本：v0.3.21**
+**当前版本：v0.3.23**
 
 ---
 

package/dist/cli/index.js

@@ -20506,7 +20506,7 @@ var require_websocket = __commonJS({
     var http2 = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes2, createHash } = __require("crypto");
+    var { randomBytes: randomBytes2, createHash: createHash2 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -21174,7 +21174,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash("sha1").update(key + GUID).digest("base64");
+        const digest = createHash2("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -21543,7 +21543,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http2 = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash } = __require("crypto");
+    var { createHash: createHash2 } = __require("crypto");
     var extension = require_extension();
     var PerMessageDeflate = require_permessage_deflate();
     var subprotocol = require_subprotocol();
@@ -21850,7 +21850,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash("sha1").update(key + GUID).digest("base64");
+        const digest = createHash2("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -108741,7 +108741,7 @@ ${block}
       const raw = err2;
       return ((_b = (_a = raw === null || raw === void 0 ? void 0 : raw.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.msg) || ((_d = (_c = raw === null || raw === void 0 ? void 0 : raw.response) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.message) || (raw === null || raw === void 0 ? void 0 : raw.message) || String(err2);
     }
-    function isRetryable2(err2) {
+    function isRetryable3(err2) {
       return err2.code === "rate_limited" || err2.code === "unknown";
     }
     function isFormatError(err2) {
@@ -108762,7 +108762,7 @@ ${block}
           } catch (raw) {
             const err2 = classifyError(raw, { attempt });
             lastErr = err2;
-            if (attempt >= max || !isRetryable2(err2)) {
+            if (attempt >= max || !isRetryable3(err2)) {
               throw err2;
             }
             const delay = base * Math.pow(3, attempt - 1);
@@ -111182,6 +111182,254 @@ var init_channelCardClient = __esm({
   }
 });
 
+// src/lark/channelCardKitClient.ts
+import { createHash } from "node:crypto";
+function isRetryable2(err2) {
+  if (err2 instanceof CardKitReplyConversionError) return true;
+  if (!(err2 instanceof Error)) return false;
+  const msg = err2.message.toLowerCase();
+  if (msg.includes("200810")) return true;
+  if (msg.includes("user callback")) return true;
+  if (msg.includes("interaction")) return true;
+  if (msg.includes("socket hang up")) return true;
+  if (msg.includes("econnreset")) return true;
+  if (msg.includes("etimedout")) return true;
+  if (msg.includes("econnrefused")) return true;
+  if (msg.includes("connect timeout")) return true;
+  const anyErr = err2;
+  const status = anyErr["status"];
+  if (typeof status === "number" && status >= 500) return true;
+  const code = anyErr["code"];
+  if (code === 200810 || code === "200810") return true;
+  const response = anyErr["response"];
+  if (response && typeof response === "object") {
+    const data = response["data"];
+    if (data && typeof data === "object") {
+      const responseCode = data["code"];
+      if (responseCode === 200810 || responseCode === "200810") return true;
+    }
+  }
+  return code === "ECONNRESET" || code === "ETIMEDOUT";
+}
+async function withCardKitRetry(label, fn, opts) {
+  let lastErr;
+  for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err2) {
+      lastErr = err2;
+      if (attempt === opts.maxAttempts || !isRetryable2(err2)) throw err2;
+      const delay = opts.baseDelayMs * Math.pow(2, attempt - 1);
+      console.warn(
+        `[channel.cardkit] ${label} attempt ${attempt} failed (${err2.message}), retrying in ${delay}ms`
+      );
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  throw lastErr;
+}
+var CardKitReplyConversionError, ChannelCardKitClient;
+var init_channelCardKitClient = __esm({
+  "src/lark/channelCardKitClient.ts"() {
+    "use strict";
+    CardKitReplyConversionError = class extends Error {
+      messageId;
+      constructor(messageId, cause) {
+        super(
+          `[channel.cardkit] card.idConvert returned no card_id (messageId=${messageId})`
+        );
+        this.name = "CardKitReplyConversionError";
+        this.messageId = messageId;
+        this.cause = cause;
+      }
+    };
+    ChannelCardKitClient = class {
+      resolveChannel;
+      cardThreads;
+      maxAttempts;
+      baseDelayMs;
+      constructor(opts) {
+        this.resolveChannel = opts.resolveChannel;
+        this.cardThreads = opts.cardThreads;
+        this.maxAttempts = opts.maxAttempts ?? 3;
+        this.baseDelayMs = opts.baseDelayMs ?? 300;
+      }
+      channel() {
+        const ch = this.resolveChannel();
+        if (!ch) {
+          throw new Error("[channel.cardkit] outbound called before the Channel SDK connected");
+        }
+        return ch;
+      }
+      async createCardEntity(card) {
+        const res = await withCardKitRetry(
+          "createCardEntity",
+          () => this.channel().rawClient.cardkit.v1.card.create({
+            data: { type: "card_json", data: JSON.stringify(card) }
+          }),
+          { maxAttempts: this.maxAttempts, baseDelayMs: this.baseDelayMs }
+        );
+        const cardId = res.data?.card_id;
+        if (!cardId) throw new Error("[channel.cardkit] card.create returned no card_id");
+        return { cardId };
+      }
+      async createCardReply(replyToMessageId, card, opts) {
+        const res = await withCardKitRetry(
+          "createCardReply",
+          () => this.channel().rawClient.im.v1.message.reply({
+            path: { message_id: replyToMessageId },
+            data: {
+              content: JSON.stringify(card),
+              msg_type: "interactive",
+              reply_in_thread: opts.replyInThread,
+              uuid: opts.idempotencyKey
+            }
+          }),
+          { maxAttempts: this.maxAttempts, baseDelayMs: this.baseDelayMs }
+        );
+        const messageId = res.data?.message_id;
+        if (!messageId) {
+          throw new Error(
+            `[channel.cardkit] im.v1.message.reply returned no message_id (replyTo=${replyToMessageId})`
+          );
+        }
+        const converted = await withCardKitRetry(
+          "idConvert",
+          async () => {
+            const converted2 = await this.channel().rawClient.cardkit.v1.card.idConvert({
+              data: { message_id: messageId }
+            });
+            if (!converted2.data?.card_id) {
+              throw new CardKitReplyConversionError(messageId);
+            }
+            return converted2;
+          },
+          { maxAttempts: this.maxAttempts, baseDelayMs: this.baseDelayMs }
+        );
+        const cardId = converted.data?.card_id;
+        if (!cardId) throw new CardKitReplyConversionError(messageId);
+        this.cardThreads.set(messageId, opts.threadId ?? replyToMessageId);
+        return { cardId, messageId };
+      }
+      async replyCardEntity(replyToMessageId, cardId, opts) {
+        const res = await withCardKitRetry(
+          "replyCardEntity",
+          () => this.channel().rawClient.im.v1.message.reply({
+            path: { message_id: replyToMessageId },
+            data: {
+              content: JSON.stringify({ type: "card", data: { card_id: cardId } }),
+              msg_type: "interactive",
+              reply_in_thread: opts.replyInThread,
+              uuid: opts.idempotencyKey
+            }
+          }),
+          { maxAttempts: this.maxAttempts, baseDelayMs: this.baseDelayMs }
+        );
+        const messageId = res.data?.message_id;
+        if (!messageId) {
+          throw new Error(
+            `[channel.cardkit] im.v1.message.reply returned no message_id (replyTo=${replyToMessageId})`
+          );
+        }
+        this.cardThreads.set(messageId, opts.threadId ?? replyToMessageId);
+        return { messageId };
+      }
+      async updateCardEntity(cardId, card, opts) {
+        await withCardKitRetry(
+          "updateCardEntity",
+          () => this.channel().rawClient.cardkit.v1.card.update({
+            path: { card_id: cardId },
+            data: {
+              card: { type: "card_json", data: JSON.stringify(card) },
+              sequence: opts.sequence,
+              uuid: opts.uuid
+            }
+          }),
+          { maxAttempts: this.maxAttempts, baseDelayMs: this.baseDelayMs }
+        );
+      }
+      async streamElementContent(cardId, elementId, content, opts) {
+        await withCardKitRetry(
+          "streamElementContent",
+          () => this.channel().rawClient.cardkit.v1.cardElement.content({
+            path: { card_id: cardId, element_id: elementId },
+            data: { content, sequence: opts.sequence, uuid: opts.uuid }
+          }),
+          { maxAttempts: this.maxAttempts, baseDelayMs: this.baseDelayMs }
+        );
+      }
+      async createElements(cardId, elements, opts) {
+        await withCardKitRetry(
+          "createElements",
+          () => this.channel().rawClient.cardkit.v1.cardElement.create({
+            path: { card_id: cardId },
+            data: {
+              type: opts.type ?? "append",
+              target_element_id: opts.targetElementId,
+              elements: JSON.stringify(elements),
+              sequence: opts.sequence,
+              uuid: opts.uuid
+            }
+          }),
+          { maxAttempts: this.maxAttempts, baseDelayMs: this.baseDelayMs }
+        );
+      }
+      async deleteElement(cardId, elementId, opts) {
+        await withCardKitRetry(
+          "deleteElement",
+          () => this.channel().rawClient.cardkit.v1.cardElement.delete({
+            path: { card_id: cardId, element_id: elementId },
+            data: { sequence: opts.sequence, uuid: opts.uuid }
+          }),
+          { maxAttempts: this.maxAttempts, baseDelayMs: this.baseDelayMs }
+        );
+      }
+      async patchElement(cardId, elementId, partialElement, opts) {
+        await withCardKitRetry(
+          "patchElement",
+          () => this.channel().rawClient.cardkit.v1.cardElement.patch({
+            path: { card_id: cardId, element_id: elementId },
+            data: {
+              partial_element: JSON.stringify(partialElement),
+              sequence: opts.sequence,
+              uuid: opts.uuid
+            }
+          }),
+          { maxAttempts: this.maxAttempts, baseDelayMs: this.baseDelayMs }
+        );
+      }
+      async updateElement(cardId, elementId, element, opts) {
+        await withCardKitRetry(
+          "updateElement",
+          () => this.channel().rawClient.cardkit.v1.cardElement.update({
+            path: { card_id: cardId, element_id: elementId },
+            data: {
+              element: JSON.stringify(element),
+              sequence: opts.sequence,
+              uuid: opts.uuid
+            }
+          }),
+          { maxAttempts: this.maxAttempts, baseDelayMs: this.baseDelayMs }
+        );
+      }
+      async updateCardSettings(cardId, settings, opts) {
+        await withCardKitRetry(
+          "updateCardSettings",
+          () => this.channel().rawClient.cardkit.v1.card.settings({
+            path: { card_id: cardId },
+            data: {
+              settings: JSON.stringify(settings),
+              sequence: opts.sequence,
+              uuid: opts.uuid
+            }
+          }),
+          { maxAttempts: this.maxAttempts, baseDelayMs: this.baseDelayMs }
+        );
+      }
+    };
+  }
+});
+
 // src/lark/outboundPostClient.ts
 function numericStatus(err2) {
   if (!err2 || typeof err2 !== "object") return void 0;
@@ -111442,6 +111690,7 @@ var init_channelClient = __esm({
     import_node_sdk = __toESM(require_lib2(), 1);
     init_transport();
     init_channelCardClient();
+    init_channelCardKitClient();
     init_channelPostClient();
     execFile4 = promisify4(execFileCallback);
     LEARNED_CHATS_LIMIT = 100;
@@ -111552,6 +111801,8 @@ var init_channelClient = __esm({
       cardThreads = /* @__PURE__ */ new Map();
       /** Lazily built (after connect) so it can bind the live channel handle. */
       cardClient = null;
+      /** Lazily built CardKit client; shares cardThreads with interactive callbacks. */
+      cardKitClient = null;
       /** Lazily built and only requested by main.ts when post outbound gates are configured. */
       postClient = null;
       constructor(opts) {
@@ -111754,6 +112005,22 @@ var init_channelClient = __esm({
         }
         return this.cardClient;
       }
+      /**
+       * Return an OutboundCardKitClient bound to this client's channel handle.
+       *
+       * CardKit messages share the same messageId -> threadId map as legacy cards,
+       * so final-area choice buttons synthesize normal turns in the originating
+       * Feishu topic.
+       */
+      outboundCardKitClient() {
+        if (!this.cardKitClient) {
+          this.cardKitClient = new ChannelCardKitClient({
+            resolveChannel: () => this.channel,
+            cardThreads: this.cardThreads
+          });
+        }
+        return this.cardKitClient;
+      }
       /**
        * Return an OutboundPostClient bound to this client's channel handle.
        *
@@ -123697,6 +123964,7 @@ function defaultResponseSurfacePrototypeConfig() {
     lazy_card_creation: true,
     kill_switch: false,
     post_outbound_enabled: true,
+    cardkit_streaming_enabled: true,
     allow_agent_mentions: true,
     allowed_mention_open_ids: [],
     max_posts_per_turn: 1,
@@ -123714,6 +123982,7 @@ var responseSurfacePrototypeConfigDefaults = () => ({
   lazy_card_creation: true,
   kill_switch: false,
   post_outbound_enabled: true,
+  cardkit_streaming_enabled: true,
   allow_agent_mentions: true,
   allowed_mention_open_ids: [],
   max_posts_per_turn: 1,
@@ -123794,6 +124063,13 @@ var ResponseSurfacePrototypeConfigSchema = external_exports.object({
    * an injected post client and all safety gates before any post path.
    */
   post_outbound_enabled: external_exports.boolean().default(true),
+  /**
+   * CardKit streaming response surface gate. Defaults on: normal turns use a
+   * streaming CardKit card during execution and finalize that same card into
+   * a clean answer + interaction surface. Disabling this gate rolls back to
+   * the legacy visible card path, not post in-place editing.
+   */
+  cardkit_streaming_enabled: external_exports.boolean().default(true),
   /**
    * Allows Agent-authored post mentions. This powers handoff to peer bots.
    * Keep this false only when the operator wants to suppress every real @.