@excitedjs/feishu-transport 0.0.1

package/README.md

@@ -0,0 +1,39 @@
+# @excitedjs/feishu-transport
+
+Shared **Feishu platform-I/O core** for the dreamux + claudemux channel layers.
+The single place that imports the Feishu SDK.
+
+> **Status: PR0 scaffold.** No business logic yet — this PR establishes the
+> package skeleton, build, and rush wiring. Platform I/O and policy are ported
+> from claudemux (the source of truth) in PR1. See
+> [issue #25](https://github.com/excitedjs/dreamux/issues/25).
+
+## Scope (when filled in by PR1+)
+
+- **transport** — connect / receive / send / `addReaction` / `removeReaction` /
+  `editText` / `fetchDocComment` / `fetchDocMeta` / bot open_id resolution /
+  auth. (react/edit/doc-fetch all bind the lark SDK, so they live here even
+  though dreamux leaves them dormant — see issue #25 §7.1.)
+- **render** — markdown → Feishu v2 card (incl. inline `<@open_id>` parsing).
+- **parse** — Feishu message content → text (incl. `interactive`).
+- **policy** — stateless `gate()` / pairing-code / `pruneExpiredPending`, plus
+  the `AccessStore` interface (each host implements its own store).
+
+## Engineering rules this package honors
+
+- Ships compiled `dist/` (`tsc`), **no `tsx` runtime dependency**.
+- Consumed as a **published, version-pinned package** by both repos; the two
+  hosts never depend on each other.
+- Built via rush in topological order (`rush build` builds this before any
+  dependent). Standalone `npm run build` works once its own deps are installed.
+
+## Build / test
+
+```sh
+# monorepo (preferred)
+node common/scripts/install-run-rush.js update
+node common/scripts/install-run-rush.js build
+
+# per-package
+npm install && npm run build && npm test
+```

package/dist/contract/access-store.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The access-state persistence contract.
+ *
+ * The pure `gate()` reasons over an `Access` value but never reads or writes
+ * it; persistence is the host's job, injected through this interface. Each host
+ * backs it differently — dreamux with SQLite under `~/.codex-host` (server-owned
+ * runtime state), claudemux with its existing atomic-write `access.json`. Keeping
+ * `gate` pure with the store injected leaves the gate logic in one place (core)
+ * instead of copy-drifting per host. See dreamux#25 §6 (decision D).
+ *
+ * Corruption handling (e.g. an unreadable `access.json` moved aside, defaults
+ * restored fail-closed) is the implementing host's concern, not part of this
+ * interface — the host decides what a load failure means for its deployment.
+ */
+import type { Access } from './types.js';
+/** Persists the access-control state a host's gate decisions read and mutate. */
+export interface AccessStore {
+    /** Return the current access state (defaults when none has been persisted). */
+    load(): Access;
+    /** Persist `access` durably, replacing any previous state. */
+    save(access: Access): void;
+}
+//# sourceMappingURL=access-store.d.ts.map

package/dist/contract/access-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"access-store.d.ts","sourceRoot":"","sources":["../../src/contract/access-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAExC,iFAAiF;AACjF,MAAM,WAAW,WAAW;IAC1B,+EAA+E;IAC/E,IAAI,IAAI,MAAM,CAAA;IACd,8DAA8D;IAC9D,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAC3B"}

package/dist/contract/access-store.js

@@ -0,0 +1,16 @@
+/**
+ * The access-state persistence contract.
+ *
+ * The pure `gate()` reasons over an `Access` value but never reads or writes
+ * it; persistence is the host's job, injected through this interface. Each host
+ * backs it differently — dreamux with SQLite under `~/.codex-host` (server-owned
+ * runtime state), claudemux with its existing atomic-write `access.json`. Keeping
+ * `gate` pure with the store injected leaves the gate logic in one place (core)
+ * instead of copy-drifting per host. See dreamux#25 §6 (decision D).
+ *
+ * Corruption handling (e.g. an unreadable `access.json` moved aside, defaults
+ * restored fail-closed) is the implementing host's concern, not part of this
+ * interface — the host decides what a load failure means for its deployment.
+ */
+export {};
+//# sourceMappingURL=access-store.js.map

package/dist/contract/access-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"access-store.js","sourceRoot":"","sources":["../../src/contract/access-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}

package/dist/contract/outbound.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The outbound addressing contract.
+ *
+ * Replaces the old `sendText(chatId, text)` shape with a structured target, so
+ * the transport can thread a reply under the triggering message and @-back the
+ * asker — every field the target needs is already persisted on inbound
+ * (`source_chat_id` / `source_message_id` / `sender_id`). See dreamux#25 §4.
+ *
+ * The transport's `send` reads only the platform-addressing fields
+ * (`chatId` / `replyToMessageId` / `mentionUserIds`). `conversationKey` is a
+ * routing hint for the host's channel layer (which Codex/engine thread the
+ * reply belongs to); the transport ignores it. A host without an engine thread
+ * (claudemux) omits it entirely.
+ */
+/** Where an outbound message goes, and how it threads back to its trigger. */
+export interface OutboundTarget {
+    /** Destination chat_id — required. Today: the inbound `source_chat_id`. */
+    chatId: string;
+    /**
+     * message_id to reply under, so a group reply threads beneath the original
+     * question. Maps from the inbound `source_message_id`. Optional: when unset,
+     * the transport sends a fresh top-level message.
+     */
+    replyToMessageId?: string;
+    /**
+     * open_ids to @-mention in the reply — typically the asker, to @-back them
+     * in a busy group. Maps from the inbound `sender_id`. Optional and additive
+     * to any inline `<@open_id>` already written in the markdown body.
+     */
+    mentionUserIds?: string[];
+    /**
+     * Host engine-thread routing key (dreamux: the Codex thread for this
+     * conversation; fixes the shared-thread cross-talk gap). Opaque to the
+     * transport — a channel-layer concern — and omitted by hosts with no engine
+     * thread.
+     */
+    conversationKey?: string;
+}
+//# sourceMappingURL=outbound.d.ts.map

package/dist/contract/outbound.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbound.d.ts","sourceRoot":"","sources":["../../src/contract/outbound.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,8EAA8E;AAC9E,MAAM,WAAW,cAAc;IAC7B,2EAA2E;IAC3E,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;IACzB;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB"}

package/dist/contract/outbound.js

@@ -0,0 +1,16 @@
+/**
+ * The outbound addressing contract.
+ *
+ * Replaces the old `sendText(chatId, text)` shape with a structured target, so
+ * the transport can thread a reply under the triggering message and @-back the
+ * asker — every field the target needs is already persisted on inbound
+ * (`source_chat_id` / `source_message_id` / `sender_id`). See dreamux#25 §4.
+ *
+ * The transport's `send` reads only the platform-addressing fields
+ * (`chatId` / `replyToMessageId` / `mentionUserIds`). `conversationKey` is a
+ * routing hint for the host's channel layer (which Codex/engine thread the
+ * reply belongs to); the transport ignores it. A host without an engine thread
+ * (claudemux) omits it entirely.
+ */
+export {};
+//# sourceMappingURL=outbound.js.map

package/dist/contract/outbound.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbound.js","sourceRoot":"","sources":["../../src/contract/outbound.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}

package/dist/contract/types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Shared types for the Feishu channel.
+ *
+ * The access-control state defined here is what gets persisted by a host's
+ * AccessStore and what the pure `gate` function reasons over. Ported verbatim
+ * from claudemux's `feishu-channel/src/types.ts` — the source of truth — so the
+ * gate logic stays diffable against its origin.
+ */
+/** Access-control policy for direct (1:1) messages. */
+export type DmPolicy = 'pairing' | 'allowlist' | 'disabled';
+/**
+ * Access-control policy for group messages — the switch that selects one of
+ * three group-access modes:
+ *
+ *  - `block`       — every group message is dropped; the bot ignores groups.
+ *  - `allowlist`   — a group is authorized as a unit, by pairing: an @-mention
+ *                    in an unconfigured group posts a code the operator
+ *                    approves, adding the group to `Access.groups`.
+ *  - `follow-user` — no group is authorized; a group message is delivered when
+ *                    the bot is @-mentioned and the sender's open_id is on the
+ *                    top-level `allowFrom` allowlist.
+ */
+export type GroupPolicy = 'block' | 'allowlist' | 'follow-user';
+/**
+ * Per-group access settings, keyed in Access.groups by the group's chat_id.
+ * Consulted only under the `allowlist` group policy.
+ */
+export interface GroupEntry {
+    /** Require the bot to be @-mentioned before a group message is delivered. */
+    requireMention: boolean;
+    /** When non-empty, only these sender open_ids may trigger the bot here. */
+    allowFrom: string[];
+}
+/**
+ * A pending pairing request, keyed in Access.pending by its pairing code.
+ *
+ * `kind` says what approving the code authorizes: a `dm` request adds
+ * `senderId` to the top-level `allowFrom`; a `group` request adds `chatId` to
+ * `groups`. The two kinds share this one map and the one approval gesture.
+ */
+export interface PendingEntry {
+    /** What approving this code authorizes — a direct sender, or a group. */
+    kind: 'dm' | 'group';
+    /**
+     * open_id of the awaiting party: the sender for a `dm` request, or the
+     * group member whose @-mention triggered a `group` request.
+     */
+    senderId: string;
+    /**
+     * chat_id the request arrived in — the direct chat for a `dm` request, or
+     * the group itself for a `group` request (the id approval adds to `groups`).
+     */
+    chatId: string;
+    /** Epoch millis the request was created. */
+    createdAt: number;
+    /** Epoch millis the request expires. */
+    expiresAt: number;
+    /** How many pairing-code replies were sent. A `group` request sends once. */
+    replies: number;
+}
+/** The full access-control state — persisted verbatim by a host's AccessStore. */
+export interface Access {
+    dmPolicy: DmPolicy;
+    /** How group messages are gated — see `GroupPolicy`. */
+    groupPolicy: GroupPolicy;
+    /** Sender open_ids allowed to reach the bot — in direct messages and groups. */
+    allowFrom: string[];
+    /** Per-group policy, keyed by chat_id. Consulted only under the `allowlist` group policy. */
+    groups: Record<string, GroupEntry>;
+    /** Pending pairing requests, keyed by pairing code. */
+    pending: Record<string, PendingEntry>;
+}
+/** One @-mention inside an inbound Feishu message. */
+export interface Mention {
+    /** The placeholder token (e.g. `@_user_1`) used in the message text. */
+    key: string;
+    /** Resolved identity of the mentioned party. */
+    id?: {
+        open_id?: string;
+        union_id?: string;
+        user_id?: string;
+    };
+    /** Display name of the mentioned party. */
+    name?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/contract/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/contract/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,uDAAuD;AACvD,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,CAAA;AAE3D;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,WAAW,GAAG,aAAa,CAAA;AAE/D;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,6EAA6E;IAC7E,cAAc,EAAE,OAAO,CAAA;IACvB,2EAA2E;IAC3E,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,yEAAyE;IACzE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAA;IACpB;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAA;IACd,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAA;IACjB,wCAAwC;IACxC,SAAS,EAAE,MAAM,CAAA;IACjB,6EAA6E;IAC7E,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,kFAAkF;AAClF,MAAM,WAAW,MAAM;IACrB,QAAQ,EAAE,QAAQ,CAAA;IAClB,wDAAwD;IACxD,WAAW,EAAE,WAAW,CAAA;IACxB,gFAAgF;IAChF,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,6FAA6F;IAC7F,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;IAClC,uDAAuD;IACvD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;CACtC;AAED,sDAAsD;AACtD,MAAM,WAAW,OAAO;IACtB,wEAAwE;IACxE,GAAG,EAAE,MAAM,CAAA;IACX,gDAAgD;IAChD,EAAE,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC9D,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAA;CACd"}

package/dist/contract/types.js

@@ -0,0 +1,10 @@
+/**
+ * Shared types for the Feishu channel.
+ *
+ * The access-control state defined here is what gets persisted by a host's
+ * AccessStore and what the pure `gate` function reasons over. Ported verbatim
+ * from claudemux's `feishu-channel/src/types.ts` — the source of truth — so the
+ * gate logic stays diffable against its origin.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/contract/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/contract/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `@excitedjs/feishu-transport` — the shared Feishu platform-I/O core.
+ *
+ * The single owner of the `@larksuiteoapi/node-sdk` import: connect / receive /
+ * send / auth / render (md→card) / parse (Feishu content→text) + the pure,
+ * stateless access policy (`gate` / pairing). Stateless and routing-agnostic —
+ * it knows nothing about engine threads, sessions, or drop/deliver decisions;
+ * those live in each host's channel layer. Imported in-process by both dreamux
+ * (`@excitedjs/feishu-channel`) and claudemux's proxy.
+ *
+ * See dreamux#25 / claudemux#155 for the responsibility model and contract.
+ */
+export type { Access, DmPolicy, GroupPolicy, GroupEntry, PendingEntry, Mention, } from './contract/types.js';
+export type { OutboundTarget } from './contract/outbound.js';
+export type { AccessStore } from './contract/access-store.js';
+export { parseInbound, applyMentions, extractPostText, type InboundMessage, type ParsedInbound, } from './parse/content.js';
+export { normalizeCommentEvent, DOC_COMMENT_EVENT_TYPE, type FeishuCommentEvent, } from './parse/comment.js';
+export { gate, isBotMentioned, pruneExpiredPending, isBotSenderType, isGroupAuthorized, MAX_PENDING, MAX_PAIRING_REPLIES, PAIRING_TTL_MS, type GateInput, type GateResult, } from './policy/gate.js';
+export { generatePairingCode, PAIRING_CODE_BYTES, PAIRING_CODE_LENGTH, } from './policy/pairing.js';
+export { renderMarkdownToCards, cardToContent, cardContentBytes, splitMarkdownByBytes, FEISHU_CARD_REQUEST_LIMIT_BYTES, FEISHU_CARD_ELEMENT_HARD_CAP, CELL_MAX_BYTES, type RenderedCard, } from './render/render.js';
+export { createFeishuTransport, commentFromBatchQuery, textMessageContent, FEISHU_CARD_CONTENT_SAFE_BYTES, type FeishuTransport, type FeishuCredentials, type FeishuTransportOptions, type FeishuSendResult, type FeishuDocComment, type FeishuDocCommentReply, type FeishuDocMeta, type InboundRoutes, type RouteHandler, } from './transport/feishu.js';
+export { isRecord, asString } from './json.js';
+/**
+ * Package marker — a stable export the channel layer can import to assert the
+ * core resolves end to end. Kept from the PR0 scaffold so the `feishu-channel`
+ * smoke test stays green.
+ */
+export declare const FEISHU_TRANSPORT_PACKAGE = "@excitedjs/feishu-transport";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,YAAY,EACV,MAAM,EACN,QAAQ,EACR,WAAW,EACX,UAAU,EACV,YAAY,EACZ,OAAO,GACR,MAAM,qBAAqB,CAAA;AAC5B,YAAY,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAC5D,YAAY,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAG7D,OAAO,EACL,YAAY,EACZ,aAAa,EACb,eAAe,EACf,KAAK,cAAc,EACnB,KAAK,aAAa,GACnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,KAAK,kBAAkB,GACxB,MAAM,oBAAoB,CAAA;AAG3B,OAAO,EACL,IAAI,EACJ,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,KAAK,SAAS,EACd,KAAK,UAAU,GAChB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,qBAAqB,CAAA;AAG5B,OAAO,EACL,qBAAqB,EACrB,aAAa,EACb,gBAAgB,EAChB,oBAAoB,EACpB,+BAA+B,EAC/B,4BAA4B,EAC5B,cAAc,EACd,KAAK,YAAY,GAClB,MAAM,oBAAoB,CAAA;AAG3B,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,8BAA8B,EAC9B,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,YAAY,GAClB,MAAM,uBAAuB,CAAA;AAG9B,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAE9C;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,gCAAgC,CAAA"}

package/dist/index.js

@@ -0,0 +1,31 @@
+/**
+ * `@excitedjs/feishu-transport` — the shared Feishu platform-I/O core.
+ *
+ * The single owner of the `@larksuiteoapi/node-sdk` import: connect / receive /
+ * send / auth / render (md→card) / parse (Feishu content→text) + the pure,
+ * stateless access policy (`gate` / pairing). Stateless and routing-agnostic —
+ * it knows nothing about engine threads, sessions, or drop/deliver decisions;
+ * those live in each host's channel layer. Imported in-process by both dreamux
+ * (`@excitedjs/feishu-channel`) and claudemux's proxy.
+ *
+ * See dreamux#25 / claudemux#155 for the responsibility model and contract.
+ */
+// ── parse/ — Feishu content → forwardable text + comment-event decode ──
+export { parseInbound, applyMentions, extractPostText, } from './parse/content.js';
+export { normalizeCommentEvent, DOC_COMMENT_EVENT_TYPE, } from './parse/comment.js';
+// ── policy/ — pure access gate + pairing ──
+export { gate, isBotMentioned, pruneExpiredPending, isBotSenderType, isGroupAuthorized, MAX_PENDING, MAX_PAIRING_REPLIES, PAIRING_TTL_MS, } from './policy/gate.js';
+export { generatePairingCode, PAIRING_CODE_BYTES, PAIRING_CODE_LENGTH, } from './policy/pairing.js';
+// ── render/ — markdown → Feishu v2 card (incl. inline `<@open_id>` mentions) ──
+export { renderMarkdownToCards, cardToContent, cardContentBytes, splitMarkdownByBytes, FEISHU_CARD_REQUEST_LIMIT_BYTES, FEISHU_CARD_ELEMENT_HARD_CAP, CELL_MAX_BYTES, } from './render/render.js';
+// ── transport/ — the Feishu SDK boundary (the only lark importer) ──
+export { createFeishuTransport, commentFromBatchQuery, textMessageContent, FEISHU_CARD_CONTENT_SAFE_BYTES, } from './transport/feishu.js';
+// ── small shared util ──
+export { isRecord, asString } from './json.js';
+/**
+ * Package marker — a stable export the channel layer can import to assert the
+ * core resolves end to end. Kept from the PR0 scaffold so the `feishu-channel`
+ * smoke test stays green.
+ */
+export const FEISHU_TRANSPORT_PACKAGE = '@excitedjs/feishu-transport';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAeH,0EAA0E;AAC1E,OAAO,EACL,YAAY,EACZ,aAAa,EACb,eAAe,GAGhB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,qBAAqB,EACrB,sBAAsB,GAEvB,MAAM,oBAAoB,CAAA;AAE3B,6CAA6C;AAC7C,OAAO,EACL,IAAI,EACJ,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,mBAAmB,EACnB,cAAc,GAGf,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,qBAAqB,CAAA;AAE5B,iFAAiF;AACjF,OAAO,EACL,qBAAqB,EACrB,aAAa,EACb,gBAAgB,EAChB,oBAAoB,EACpB,+BAA+B,EAC/B,4BAA4B,EAC5B,cAAc,GAEf,MAAM,oBAAoB,CAAA;AAE3B,sEAAsE;AACtE,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,8BAA8B,GAU/B,MAAM,uBAAuB,CAAA;AAE9B,0BAA0B;AAC1B,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAE9C;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,6BAA6B,CAAA"}

package/dist/json.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tiny structural helpers for reading untyped JSON — the shape every raw
+ * Feishu event payload arrives in. Used by the comment decoder, which decodes
+ * its event_type's payload defensively. Ported verbatim from claudemux.
+ */
+/** True when `v` is a non-null object, and therefore safe to index. */
+export declare function isRecord(v: unknown): v is Record<string, unknown>;
+/** `v` when it is a string, otherwise the empty string. */
+export declare function asString(v: unknown): string;
+//# sourceMappingURL=json.d.ts.map

package/dist/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,uEAAuE;AACvE,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEjE;AAED,2DAA2D;AAC3D,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAE3C"}

package/dist/json.js

@@ -0,0 +1,14 @@
+/**
+ * Tiny structural helpers for reading untyped JSON — the shape every raw
+ * Feishu event payload arrives in. Used by the comment decoder, which decodes
+ * its event_type's payload defensively. Ported verbatim from claudemux.
+ */
+/** True when `v` is a non-null object, and therefore safe to index. */
+export function isRecord(v) {
+    return v !== null && typeof v === 'object';
+}
+/** `v` when it is a string, otherwise the empty string. */
+export function asString(v) {
+    return typeof v === 'string' ? v : '';
+}
+//# sourceMappingURL=json.js.map

package/dist/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,uEAAuE;AACvE,MAAM,UAAU,QAAQ,CAAC,CAAU;IACjC,OAAO,CAAC,KAAK,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ,CAAA;AAC5C,CAAC;AAED,2DAA2D;AAC3D,MAAM,UAAU,QAAQ,CAAC,CAAU;IACjC,OAAO,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;AACvC,CAAC"}

package/dist/parse/comment.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Decoding the `drive.notice.comment_add_v1` event payload.
+ *
+ * The Feishu SDK's own `normalizeComment` is the authoritative decoder for this
+ * event — it tolerates both the flat and the `notice_meta`-nested payload
+ * variants Feishu sends, which a hand-written path table is bound to drift from.
+ * Because the SDK is the only Feishu-platform import in this package, this
+ * decoder lives in core; a host's comment handler calls it instead of importing
+ * the lark SDK itself (claudemux#155 §六.2 / dreamux#25 §7.1).
+ *
+ * The decode is pure: no I/O, never throws. Enriching the comment (fetching its
+ * text and the document title) is the transport's `fetchDocComment` /
+ * `fetchDocMeta`; shaping the notification body is the host handler's job.
+ */
+/** The Feishu event_type this decoder is for. */
+export declare const DOC_COMMENT_EVENT_TYPE = "drive.notice.comment_add_v1";
+/** A normalized document-comment event — the identifying fields the payload carries. */
+export interface FeishuCommentEvent {
+    /** Token of the document the comment is on. */
+    fileToken: string;
+    /** Document type — `doc` / `docx` / `sheet` / `bitable` / ... */
+    fileType: string;
+    /** Comment id. */
+    commentId: string;
+    /** Reply id — set only when the event is a reply within a thread, `''` otherwise. */
+    replyId: string;
+    /** open_id of the commenter. */
+    commenterId: string;
+    /** True when the comment @-mentions the bot. */
+    mentionedBot: boolean;
+}
+/**
+ * Reshape a raw `drive.notice.comment_add_v1` payload into a
+ * `FeishuCommentEvent`, using the Feishu SDK's `normalizeComment` as the
+ * decoder. Returns `null` for a non-object input or a payload the SDK cannot
+ * resolve a file token, file type, comment id, and commenter from. Pure: no
+ * I/O, never throws. Tolerates either the event body alone (what the SDK's
+ * `EventDispatcher` delivers) or a full `{ event: ... }` envelope.
+ */
+export declare function normalizeCommentEvent(raw: unknown): FeishuCommentEvent | null;
+//# sourceMappingURL=comment.d.ts.map

package/dist/parse/comment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comment.d.ts","sourceRoot":"","sources":["../../src/parse/comment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,iDAAiD;AACjD,eAAO,MAAM,sBAAsB,gCAAgC,CAAA;AAEnE,wFAAwF;AACxF,MAAM,WAAW,kBAAkB;IACjC,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAA;IACjB,iEAAiE;IACjE,QAAQ,EAAE,MAAM,CAAA;IAChB,kBAAkB;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,qFAAqF;IACrF,OAAO,EAAE,MAAM,CAAA;IACf,gCAAgC;IAChC,WAAW,EAAE,MAAM,CAAA;IACnB,gDAAgD;IAChD,YAAY,EAAE,OAAO,CAAA;CACtB;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,kBAAkB,GAAG,IAAI,CAsB7E"}

package/dist/parse/comment.js

@@ -0,0 +1,51 @@
+/**
+ * Decoding the `drive.notice.comment_add_v1` event payload.
+ *
+ * The Feishu SDK's own `normalizeComment` is the authoritative decoder for this
+ * event — it tolerates both the flat and the `notice_meta`-nested payload
+ * variants Feishu sends, which a hand-written path table is bound to drift from.
+ * Because the SDK is the only Feishu-platform import in this package, this
+ * decoder lives in core; a host's comment handler calls it instead of importing
+ * the lark SDK itself (claudemux#155 §六.2 / dreamux#25 §7.1).
+ *
+ * The decode is pure: no I/O, never throws. Enriching the comment (fetching its
+ * text and the document title) is the transport's `fetchDocComment` /
+ * `fetchDocMeta`; shaping the notification body is the host handler's job.
+ */
+import * as lark from '@larksuiteoapi/node-sdk';
+import { isRecord } from '../json.js';
+/** The Feishu event_type this decoder is for. */
+export const DOC_COMMENT_EVENT_TYPE = 'drive.notice.comment_add_v1';
+/**
+ * Reshape a raw `drive.notice.comment_add_v1` payload into a
+ * `FeishuCommentEvent`, using the Feishu SDK's `normalizeComment` as the
+ * decoder. Returns `null` for a non-object input or a payload the SDK cannot
+ * resolve a file token, file type, comment id, and commenter from. Pure: no
+ * I/O, never throws. Tolerates either the event body alone (what the SDK's
+ * `EventDispatcher` delivers) or a full `{ event: ... }` envelope.
+ */
+export function normalizeCommentEvent(raw) {
+    if (!isRecord(raw))
+        return null;
+    const event = isRecord(raw.event) ? raw.event : raw;
+    let decoded;
+    try {
+        decoded = lark.normalizeComment(event);
+    }
+    catch {
+        // `normalizeComment` is pure but not contractually total — guard it so a
+        // surprising input shape is a dropped event, not a thrown one.
+        return null;
+    }
+    if (!decoded)
+        return null;
+    return {
+        fileToken: decoded.fileToken,
+        fileType: decoded.fileType,
+        commentId: decoded.commentId,
+        replyId: decoded.replyId ?? '',
+        commenterId: decoded.operator.openId,
+        mentionedBot: decoded.mentionedBot,
+    };
+}
+//# sourceMappingURL=comment.js.map

package/dist/parse/comment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"comment.js","sourceRoot":"","sources":["../../src/parse/comment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,IAAI,MAAM,yBAAyB,CAAA;AAE/C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC,iDAAiD;AACjD,MAAM,CAAC,MAAM,sBAAsB,GAAG,6BAA6B,CAAA;AAkBnE;;;;;;;GAOG;AACH,MAAM,UAAU,qBAAqB,CAAC,GAAY;IAChD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,CAAA;IAC/B,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAA;IAEnD,IAAI,OAAiC,CAAA;IACrC,IAAI,CAAC;QACH,OAAO,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAA6B,CAAC,CAAA;IAChE,CAAC;IAAC,MAAM,CAAC;QACP,yEAAyE;QACzE,+DAA+D;QAC/D,OAAO,IAAI,CAAA;IACb,CAAC;IACD,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAA;IAEzB,OAAO;QACL,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,EAAE;QAC9B,WAAW,EAAE,OAAO,CAAC,QAAQ,CAAC,MAAM;QACpC,YAAY,EAAE,OAAO,CAAC,YAAY;KACnC,CAAA;AACH,CAAC"}

package/dist/parse/content.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Parsing inbound Feishu message content.
+ *
+ * Feishu delivers `message.content` as a JSON-encoded string whose shape
+ * depends on `message_type`. This module turns that into the plain text the
+ * channel forwards to the engine. Attachment message types (image, file) are
+ * summarized as a short text marker — the channel forwards text, not binaries.
+ *
+ * Ported verbatim from claudemux's `feishu-channel/src/content.ts` (the source
+ * of truth — it carries the `interactive`-card parse dreamux's drifted copy had
+ * lost); only the `./types` import was repointed to `../contract/types`.
+ */
+import type { Mention } from '../contract/types.js';
+/** The subset of an inbound Feishu message this module reads. */
+export interface InboundMessage {
+    message_type?: string;
+    /** JSON-encoded content string, as delivered by Feishu. */
+    content?: string;
+    mentions?: Mention[];
+}
+export interface ParsedInbound {
+    /** Human-readable text to forward to the engine. */
+    text: string;
+}
+/**
+ * Parse one inbound Feishu message into forwardable text. Never throws —
+ * malformed content falls back to a best-effort string so a weird message
+ * still reaches the engine.
+ */
+export declare function parseInbound(message: InboundMessage): ParsedInbound;
+/**
+ * Replace Feishu's `@_user_N` placeholders in text with the mentioned display
+ * names, so the forwarded message reads naturally.
+ */
+export declare function applyMentions(text: string, mentions: Mention[] | undefined): string;
+/**
+ * Flatten a Feishu rich-text "post" payload into plain text. A post is
+ * locale-wrapped (`{ zh_cn: { title, content } }`) and its body is an array of
+ * paragraphs, each an array of tagged inline elements.
+ */
+export declare function extractPostText(content: Record<string, unknown>): string;
+//# sourceMappingURL=content.d.ts.map

package/dist/parse/content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../src/parse/content.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAEnD,iEAAiE;AACjE,MAAM,WAAW,cAAc;IAC7B,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAA;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,cAAc,GAAG,aAAa,CA6BnE;AAiGD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,SAAS,GAAG,MAAM,CASnF;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAexE"}