@hitl-sdk/adapter-line 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Unbounded Pioneering
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,167 @@
+# @hitl-sdk/adapter-line
+
+A hitl channel adapter for the [LINE Messaging API](https://developers.line.biz/en/docs/messaging-api/). Deliver approvals as Flex Messages with postback buttons; resolve through `hitl.inbox` via a LINE webhook. Text and multi-field feedback uses a LIFF form.
+
+For Slack, Teams, Discord, and other Chat SDK platforms, use [`@hitl-sdk/adapter-chat-sdk`](../adapter-chat-sdk/README.md) instead.
+
+## Install
+
+```bash
+pnpm add @hitl-sdk/adapter-line @line/bot-sdk
+```
+
+`@line/bot-sdk` is a peer dependency.
+
+## Usage
+
+```ts
+import { Hitl } from "@hitl-sdk/hitl";
+import { LineBotClient } from "@line/bot-sdk";
+import { createLineAdapter } from "@hitl-sdk/adapter-line";
+import { workflowResolver } from "@hitl-sdk/resolver-workflow-sdk";
+
+const client = LineBotClient.fromChannelAccessToken({
+  channelAccessToken: process.env.LINE_CHANNEL_ACCESS_TOKEN!,
+});
+
+export const hitl = new Hitl({
+  resolver: workflowResolver(),
+  adapters: [
+    createLineAdapter({
+      id: "line-approvals",
+      client,
+      defaultChannel: "user:Uxxxxxxxx",
+      inbox: () => hitl.inbox,
+      // Required when actions use text/textarea or multiple feedback fields:
+      liffId: process.env.LINE_LIFF_ID,
+      feedbackSecret: process.env.LINE_FEEDBACK_SECRET,
+    }),
+  ],
+});
+```
+
+### Express
+
+Use `line.middleware` for signature validation and `hitl.handler` for the internal API + LIFF feedback. Branch postbacks with `parsePostback`:
+
+```ts
+import express from "express";
+import { middleware } from "@line/bot-sdk";
+import { handlePostbackEvent, parsePostback } from "@hitl-sdk/adapter-line";
+
+const app = express();
+
+// Workflow internal API + LIFF feedback (GET/POST)
+app.all("/.well-known/hitl/v1/*", (req, res) => {
+  void hitl.handler(req, res);
+});
+
+// Messaging API webhook
+app.post(
+  "/webhook",
+  middleware({ channelSecret: process.env.LINE_CHANNEL_SECRET! }),
+  async (req, res) => {
+    res.sendStatus(200);
+
+    for (const event of req.body.events ?? []) {
+      if (event.type === "postback") {
+        if (parsePostback(event.postback.data)) {
+          await handlePostbackEvent(event, { client, inbox: hitl.inbox });
+        } else {
+          await handleMyPostback(event);
+        }
+        continue;
+      }
+
+      if (event.type === "message") {
+        await handleMyMessage(event);
+      }
+    }
+  },
+);
+
+app.listen(3000);
+```
+
+`parsePostback` returns a payload only for hitl Flex buttons. Run this after `line.middleware` (signature already validated). Keep the webhook URL you already registered in LINE Console. Do not apply `express.json()` on `/webhook` before `line.middleware`.
+
+Omit the `else` branch when you only need hitl approvals.
+
+### Fetch-based (Next.js, Hono)
+
+When you are not on Express, use `createLineWebhookHandler`. It validates `x-line-signature` and processes hitl postbacks from a raw `Request`.
+
+Mount the hitl internal API + LIFF feedback route as well:
+
+```ts
+// Next.js App Router
+// app/.well-known/hitl/v1/[[...path]]/route.ts
+export const { GET, POST } = hitl.routeHandlers;
+
+// app/api/webhooks/line/route.ts
+import { createLineWebhookHandler } from "@hitl-sdk/adapter-line";
+import { hitl, client } from "@/lib/hitl";
+
+export const POST = createLineWebhookHandler({
+  channelSecret: process.env.LINE_CHANNEL_SECRET!,
+  client,
+  inbox: () => hitl.inbox,
+  onFallbackEvent: async (event) => {
+    if (event.type === "postback") {
+      await handleMyPostback(event);
+      return;
+    }
+    if (event.type === "message") {
+      await handleMyMessage(event);
+    }
+  },
+});
+```
+
+`onFallbackEvent` receives everything hitl does not handle (non-postback events and custom postbacks). Omit it when you only need hitl approvals. Register the webhook route URL in LINE Console.
+
+### LIFF setup (text / textarea / multi-field actions)
+
+When `feedbackSecret` is set, the adapter serves LIFF feedback at:
+
+```
+/.well-known/hitl/v1/channels/line/feedback
+```
+
+Create a **dedicated LIFF app** for hitl feedback (recommended when you already use LIFF for something else). Set its **Endpoint URL** in LINE Developers Console to:
+
+```
+https://{your-domain}/.well-known/hitl/v1/channels/line/feedback
+```
+
+Pass that app's LIFF ID to `createLineAdapter({ liffId })`.
+
+### Routing keys
+
+```ts
+await waitForHuman({
+  channel: "line-approvals:user:U456",
+  message: "Approve?",
+  actions,
+});
+
+await waitForHuman({ channel: "line-approvals", message: "...", actions }); // uses defaultChannel
+```
+
+Destination format: `user:Uxxx`, `group:Cxxx`, or `room:Rxxx`.
+
+### Feedback fields
+
+| Field kinds | UX |
+|---|---|
+| None | Postback button resolves immediately |
+| Single `select` or `confirm` | Second Flex message with option buttons |
+| `text`, `textarea`, or multiple fields | LIFF form (`liffId` + `feedbackSecret` on the adapter) |
+
+`TimelineAnchor.externalRef` uses `destination#messageId` (e.g. `user:U123#msg-abc`).
+
+### Outcome updates
+
+LINE cannot edit sent messages. After resolve, the adapter pushes a follow-up text message with the outcome (same graceful behavior as other adapters after a process restart).
+
+See [ARCHITECTURE.md](./ARCHITECTURE.md) for the full flow.

package/dist/adapter.d.ts

@@ -0,0 +1,23 @@
+import type { HitlAdapter } from "@hitl-sdk/hitl/adapter";
+import type { HitlInbox } from "@hitl-sdk/hitl/state";
+import { type LineMessagingClient } from "./client.js";
+export interface LineAdapterOptions {
+    /** Adapter id, the routing key prefix used by `waitForHuman({ channel })`. */
+    id: string;
+    /** LINE Messaging API client (`LineBotClient.fromChannelAccessToken(...)`). */
+    client: LineMessagingClient;
+    /** Default destination when the routing key is adapter id only, e.g. `user:U123`. */
+    defaultChannel?: string;
+    /**
+     * The hitl inbox, resolved lazily. `new Hitl()` needs the adapters before
+     * the inbox exists, so pass `() => hitl.inbox`.
+     */
+    inbox: () => HitlInbox;
+    /** LIFF app id for actions that need text/textarea or multi-field feedback. */
+    liffId?: string;
+    /** HMAC secret for signed LIFF feedback tokens. Required when `liffId` is set. */
+    feedbackSecret?: string;
+}
+export declare function createLineAdapter(options: LineAdapterOptions): HitlAdapter;
+export type { LineMessagingClient };
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA6B,WAAW,EAAgB,MAAM,wBAAwB,CAAC;AACnG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,EAAqB,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAQ1E,MAAM,WAAW,kBAAkB;IACjC,8EAA8E;IAC9E,EAAE,EAAE,MAAM,CAAC;IACX,+EAA+E;IAC/E,MAAM,EAAE,mBAAmB,CAAC;IAC5B,qFAAqF;IACrF,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,KAAK,EAAE,MAAM,SAAS,CAAC;IACvB,+EAA+E;IAC/E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kFAAkF;IAClF,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAeD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,kBAAkB,GAAG,WAAW,CAgF1E;AAED,YAAY,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/client.d.ts

@@ -0,0 +1,29 @@
+import type { messagingApi } from "@line/bot-sdk";
+type Message = messagingApi.Message;
+/** Minimal LINE client surface used by the adapter. */
+export interface LineMessagingClient {
+    pushMessage(args: {
+        to: string;
+        messages: Message[];
+    }): Promise<{
+        sentMessages?: Array<{
+            id?: string;
+        }>;
+    }>;
+    replyMessage(args: {
+        replyToken: string;
+        messages: Message[];
+    }): Promise<unknown>;
+    getProfile(userId: string): Promise<{
+        displayName?: string;
+        userId?: string;
+    }>;
+}
+export declare function toLineClient(client: {
+    pushMessage: LineMessagingClient["pushMessage"];
+    replyMessage: LineMessagingClient["replyMessage"];
+    getProfile: LineMessagingClient["getProfile"];
+}): LineMessagingClient;
+export declare function pushToDestination(client: LineMessagingClient, destinationRef: string, messages: Message[]): Promise<string>;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,KAAK,OAAO,GAAG,YAAY,CAAC,OAAO,CAAC;AAEpC,uDAAuD;AACvD,MAAM,WAAW,mBAAmB;IAClC,WAAW,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,EAAE,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,YAAY,CAAC,EAAE,KAAK,CAAC;YAAE,EAAE,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,CAAC,CAAC;IAC3G,YAAY,CAAC,IAAI,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,EAAE,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAClF,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAChF;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE;IACnC,WAAW,EAAE,mBAAmB,CAAC,aAAa,CAAC,CAAC;IAChD,YAAY,EAAE,mBAAmB,CAAC,cAAc,CAAC,CAAC;IAClD,UAAU,EAAE,mBAAmB,CAAC,YAAY,CAAC,CAAC;CAC/C,GAAG,mBAAmB,CAEtB;AAID,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,mBAAmB,EAC3B,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,OAAO,EAAE,GAClB,OAAO,CAAC,MAAM,CAAC,CAQjB"}

package/dist/constants.d.ts

@@ -0,0 +1,19 @@
+/** HTTP channel key under `/.well-known/hitl/v1/channels/{channelKey}/`. */
+export declare const LINE_CHANNEL_KEY = "line";
+/** Fixed LIFF feedback path. Must stay aligned with `CHANNELS_BASE_PATH` in `@hitl-sdk/hitl/client`. */
+export declare const LINE_FEEDBACK_PATH = "/.well-known/hitl/v1/channels/line/feedback";
+/** Postback payload kinds carried in LINE postback `data` (max 300 chars). */
+export declare const POSTBACK_KIND_ACTION = "a";
+export declare const POSTBACK_KIND_FIELD_VALUE = "v";
+export declare const CONFIRM_YES = "yes";
+export declare const CONFIRM_NO = "no";
+export interface PostbackPayload {
+    k: typeof POSTBACK_KIND_ACTION | typeof POSTBACK_KIND_FIELD_VALUE;
+    r: string;
+    a: string;
+    f?: string;
+    v?: string;
+}
+export declare function encodePostback(payload: PostbackPayload): string;
+export declare function parsePostback(data: string): PostbackPayload | undefined;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB,SAAS,CAAC;AAEvC,wGAAwG;AACxG,eAAO,MAAM,kBAAkB,gDAAgD,CAAC;AAEhF,8EAA8E;AAE9E,eAAO,MAAM,oBAAoB,MAAM,CAAC;AACxC,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAE7C,eAAO,MAAM,WAAW,QAAQ,CAAC;AACjC,eAAO,MAAM,UAAU,OAAO,CAAC;AAE/B,MAAM,WAAW,eAAe;IAC9B,CAAC,EAAE,OAAO,oBAAoB,GAAG,OAAO,yBAAyB,CAAC;IAClE,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM,CAE/D;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAcvE"}

package/dist/destination.d.ts

@@ -0,0 +1,16 @@
+export type LineDestinationKind = "user" | "group" | "room";
+export interface LineDestination {
+    kind: LineDestinationKind;
+    /** Full routing ref, e.g. `user:U123`. */
+    ref: string;
+    /** Push API `to` value (id without kind prefix). */
+    to: string;
+}
+export declare function parseDestination(dest: string): LineDestination;
+export declare function destinationFromSource(source: {
+    type?: string;
+    userId?: string;
+    groupId?: string;
+    roomId?: string;
+}): string | undefined;
+//# sourceMappingURL=destination.d.ts.map

package/dist/destination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"destination.d.ts","sourceRoot":"","sources":["../src/destination.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAE5D,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,mBAAmB,CAAC;IAC1B,0CAA0C;IAC1C,GAAG,EAAE,MAAM,CAAC;IACZ,oDAAoD;IACpD,EAAE,EAAE,MAAM,CAAC;CACZ;AAID,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAc9D;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,MAAM,GAAG,SAAS,CAWrB"}

package/dist/external-id.d.ts

@@ -0,0 +1,6 @@
+export declare function encodeExternalId(destination: string, messageId: string): string;
+export declare function decodeExternalId(externalId: string): {
+    destination: string;
+    messageId: string;
+};
+//# sourceMappingURL=external-id.d.ts.map

package/dist/external-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"external-id.d.ts","sourceRoot":"","sources":["../src/external-id.ts"],"names":[],"mappings":"AAEA,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE/E;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAS/F"}

package/dist/feedback.d.ts

@@ -0,0 +1,31 @@
+import { type HitlField } from "@hitl-sdk/hitl/adapter";
+import type { HitlInbox } from "@hitl-sdk/hitl/state";
+export interface FeedbackTokenPayload {
+    requestId: string;
+    actionId: string;
+    exp: number;
+}
+export declare function signFeedbackToken(opts: {
+    requestId: string;
+    actionId: string;
+    secret: string;
+    ttlSeconds?: number;
+}): string;
+export declare function verifyFeedbackToken(token: string, secret: string): FeedbackTokenPayload | undefined;
+export declare function buildLiffUri(liffId: string, token: string): string;
+export declare function buildFeedbackFormHtml(opts: {
+    fields: Record<string, HitlField>;
+    token: string;
+    submitUrl: string;
+    title?: string;
+}): string;
+export interface LineFeedbackHandlerOptions {
+    inbox: () => HitlInbox;
+    secret: string;
+}
+export declare function createLineFeedbackHandler(options: LineFeedbackHandlerOptions): (request: Request) => Promise<Response>;
+export declare function createLineFeedbackFormHandler(options: {
+    secret: string;
+    inbox: () => HitlInbox;
+}): (request: Request) => Promise<Response>;
+//# sourceMappingURL=feedback.d.ts.map

package/dist/feedback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feedback.d.ts","sourceRoot":"","sources":["../src/feedback.ts"],"names":[],"mappings":"AACA,OAAO,EAA+C,KAAK,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACrG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAItD,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;CACb;AAgBD,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GACjF,MAAM,CAKR;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAiBnG;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAElE;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GAAG,MAAM,CAoDT;AAmCD,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,MAAM,SAAS,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,0BAA0B,GAClC,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAwDzC;AAED,wBAAgB,6BAA6B,CAAC,OAAO,EAAE;IACrD,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,SAAS,CAAC;CACxB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CA4B1C"}

package/dist/fields.d.ts

@@ -0,0 +1,8 @@
+import type { HitlField } from "@hitl-sdk/hitl/adapter";
+export declare function needsFeedbackStep(fields: Record<string, HitlField>): boolean;
+/** Inline Flex can collect a single select or confirm field without LIFF. */
+export declare function canUseInlineFlex(fields: Record<string, HitlField>): boolean;
+export declare function needsLiff(fields: Record<string, HitlField>): boolean;
+export declare function parseFieldValue(field: HitlField, raw: string): unknown;
+export declare function parsePostbackFeedbacks(fields: Record<string, HitlField>, fieldKey: string, rawValue: string): Record<string, unknown>;
+//# sourceMappingURL=fields.d.ts.map

package/dist/fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../src/fields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAGxD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,OAAO,CAE5E;AAED,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,OAAO,CAK3E;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,OAAO,CAEpE;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAQtE;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,EACjC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAIzB"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { createLineAdapter, type LineAdapterOptions, type LineMessagingClient } from "./adapter.js";
+export { createLineWebhookHandler, handleLineWebhookBody, handleLineWebhookEvents, LineWebhookError } from "./webhook.js";
+export type { LineWebhookEventsOptions, LineWebhookHandlerOptions } from "./webhook.js";
+export { createLineFeedbackHandler, createLineFeedbackFormHandler, signFeedbackToken, verifyFeedbackToken, buildLiffUri, buildFeedbackFormHtml, type LineFeedbackHandlerOptions, type FeedbackTokenPayload, } from "./feedback.js";
+export { encodeExternalId, decodeExternalId } from "./external-id.js";
+export { parseDestination, destinationFromSource, type LineDestination } from "./destination.js";
+export { LINE_CHANNEL_KEY, LINE_FEEDBACK_PATH, POSTBACK_KIND_ACTION, POSTBACK_KIND_FIELD_VALUE, encodePostback, parsePostback, } from "./constants.js";
+export { handlePostbackEvent } from "./postback.js";
+export { needsFeedbackStep, canUseInlineFlex, needsLiff, } from "./fields.js";
+//# 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,OAAO,EAAE,iBAAiB,EAAE,KAAK,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACpG,OAAO,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAC1H,YAAY,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AACxF,OAAO,EACL,yBAAyB,EACzB,6BAA6B,EAC7B,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,EACZ,qBAAqB,EACrB,KAAK,0BAA0B,EAC/B,KAAK,oBAAoB,GAC1B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACjG,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,oBAAoB,EACpB,yBAAyB,EACzB,cAAc,EACd,aAAa,GACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,SAAS,GACV,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,718 @@
+// src/feedback.ts
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { actionById, actionFields, validateFeedbacks } from "@hitl-sdk/hitl/adapter";
+
+// src/constants.ts
+var LINE_CHANNEL_KEY = "line";
+var LINE_FEEDBACK_PATH = "/.well-known/hitl/v1/channels/line/feedback";
+var POSTBACK_KIND_ACTION = "a";
+var POSTBACK_KIND_FIELD_VALUE = "v";
+var CONFIRM_YES = "yes";
+var CONFIRM_NO = "no";
+function encodePostback(payload) {
+  return JSON.stringify(payload);
+}
+function parsePostback(data) {
+  try {
+    const parsed = JSON.parse(data);
+    if (parsed.k !== POSTBACK_KIND_ACTION && parsed.k !== POSTBACK_KIND_FIELD_VALUE || typeof parsed.r !== "string" || typeof parsed.a !== "string") {
+      return void 0;
+    }
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/fields.ts
+function needsFeedbackStep(fields) {
+  return Object.keys(fields).length > 0;
+}
+function canUseInlineFlex(fields) {
+  const entries = Object.entries(fields);
+  if (entries.length !== 1) return false;
+  const field = entries[0][1];
+  return field.kind === "select" || field.kind === "confirm";
+}
+function needsLiff(fields) {
+  return needsFeedbackStep(fields) && !canUseInlineFlex(fields);
+}
+function parseFieldValue(field, raw) {
+  if (field.kind === "confirm") {
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === CONFIRM_YES || normalized === "true") return true;
+    if (normalized === CONFIRM_NO || normalized === "false") return false;
+    return raw;
+  }
+  return raw;
+}
+function parsePostbackFeedbacks(fields, fieldKey, rawValue) {
+  const field = fields[fieldKey];
+  if (!field) return {};
+  return { [fieldKey]: parseFieldValue(field, rawValue) };
+}
+
+// src/feedback.ts
+var TOKEN_SEP = ".";
+function base64UrlEncode(data) {
+  return Buffer.from(data, "utf8").toString("base64url");
+}
+function base64UrlDecode(data) {
+  return Buffer.from(data, "base64url").toString("utf8");
+}
+function signPayload(payload, secret) {
+  return createHmac("sha256", secret).update(payload).digest("base64url");
+}
+function signFeedbackToken(opts) {
+  const exp = Math.floor(Date.now() / 1e3) + (opts.ttlSeconds ?? 3600);
+  const body = base64UrlEncode(JSON.stringify({ requestId: opts.requestId, actionId: opts.actionId, exp }));
+  const sig = signPayload(body, opts.secret);
+  return `${body}${TOKEN_SEP}${sig}`;
+}
+function verifyFeedbackToken(token, secret) {
+  const sep = token.lastIndexOf(TOKEN_SEP);
+  if (sep === -1) return void 0;
+  const body = token.slice(0, sep);
+  const sig = token.slice(sep + 1);
+  const expected = signPayload(body, secret);
+  const a = Buffer.from(sig);
+  const b = Buffer.from(expected);
+  if (a.length !== b.length || !timingSafeEqual(a, b)) return void 0;
+  try {
+    const parsed = JSON.parse(base64UrlDecode(body));
+    if (typeof parsed.requestId !== "string" || typeof parsed.actionId !== "string") return void 0;
+    if (typeof parsed.exp !== "number" || parsed.exp < Math.floor(Date.now() / 1e3)) return void 0;
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+function buildLiffUri(liffId, token) {
+  return `https://liff.line.me/${liffId}?token=${encodeURIComponent(token)}`;
+}
+function buildFeedbackFormHtml(opts) {
+  const { fields, token, submitUrl, title = "Submit feedback" } = opts;
+  const inputs = Object.entries(fields).map(([key, field]) => renderFieldInput(key, field)).join("\n");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${escapeHtml(title)}</title>
+  <style>
+    body { font-family: system-ui, sans-serif; margin: 1rem; }
+    label { display: block; margin: 0.75rem 0 0.25rem; font-weight: 600; }
+    input, textarea, select { width: 100%; box-sizing: border-box; padding: 0.5rem; }
+    button { margin-top: 1rem; padding: 0.75rem 1rem; width: 100%; }
+  </style>
+  <script src="https://static.line-scdn.net/liff/edge/2/sdk.js"></script>
+</head>
+<body>
+  <h1>${escapeHtml(title)}</h1>
+  <form id="form">
+    ${inputs}
+    <button type="submit">Submit</button>
+  </form>
+  <script>
+    const token = ${JSON.stringify(token)};
+    const submitUrl = ${JSON.stringify(submitUrl)};
+    async function init() {
+      await liff.init({});
+    }
+    document.getElementById("form").addEventListener("submit", async (e) => {
+      e.preventDefault();
+      const form = e.target;
+      const data = new FormData(form);
+      const feedbacks = Object.fromEntries(data.entries());
+      const res = await fetch(submitUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ token, feedbacks }),
+      });
+      if (!res.ok) {
+        alert("Submit failed");
+        return;
+      }
+      if (liff.isInClient()) await liff.closeWindow();
+    });
+    init().catch(console.error);
+  </script>
+</body>
+</html>`;
+}
+function renderFieldInput(key, field) {
+  const id = escapeHtml(key);
+  const label = escapeHtml(field.label);
+  switch (field.kind) {
+    case "text":
+      return `<label for="${id}">${label}</label><input id="${id}" name="${id}" type="text" value="${escapeHtml(field.default ?? "")}" />`;
+    case "textarea":
+      return `<label for="${id}">${label}</label><textarea id="${id}" name="${id}">${escapeHtml(field.default ?? "")}</textarea>`;
+    case "select": {
+      const options = field.options.map(
+        (o) => `<option value="${escapeHtml(o)}"${field.default === o ? " selected" : ""}>${escapeHtml(o)}</option>`
+      ).join("");
+      return `<label for="${id}">${label}</label><select id="${id}" name="${id}">${options}</select>`;
+    }
+    case "confirm": {
+      const yes = field.default === true ? " selected" : "";
+      const no = field.default === false ? " selected" : "";
+      return `<label for="${id}">${label}</label><select id="${id}" name="${id}"><option value="yes"${yes}>Yes</option><option value="no"${no}>No</option></select>`;
+    }
+  }
+}
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function createLineFeedbackHandler(options) {
+  return async (request) => {
+    if (request.method !== "POST") {
+      return new Response("Method Not Allowed", { status: 405 });
+    }
+    let body;
+    try {
+      body = await request.json();
+    } catch {
+      return new Response("Invalid JSON", { status: 400 });
+    }
+    if (!body.token || !body.feedbacks) {
+      return new Response("Missing token or feedbacks", { status: 400 });
+    }
+    const parsed = verifyFeedbackToken(body.token, options.secret);
+    if (!parsed) {
+      return new Response("Invalid or expired token", { status: 401 });
+    }
+    const inbox = options.inbox();
+    const record = await inbox.get(parsed.requestId);
+    if (!record) {
+      return new Response("Request not found", { status: 404 });
+    }
+    const def = actionById(record.actions, parsed.actionId);
+    if (!def) {
+      return new Response("Unknown action", { status: 400 });
+    }
+    const fields = actionFields(def);
+    const coerced = {};
+    for (const [key, field] of Object.entries(fields)) {
+      const raw = body.feedbacks[key];
+      if (raw === void 0) continue;
+      coerced[key] = typeof raw === "string" ? parseFieldValue(field, raw) : raw;
+    }
+    let feedbacks;
+    try {
+      feedbacks = validateFeedbacks(fields, coerced);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Validation failed";
+      return new Response(message, { status: 400 });
+    }
+    await inbox.resolve(parsed.requestId, {
+      actionId: parsed.actionId,
+      feedbacks
+    });
+    return new Response(JSON.stringify({ ok: true }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    });
+  };
+}
+function createLineFeedbackFormHandler(options) {
+  return async (request) => {
+    const url = new URL(request.url);
+    const token = url.searchParams.get("token");
+    if (!token) {
+      return new Response("Missing token", { status: 400 });
+    }
+    const parsed = verifyFeedbackToken(token, options.secret);
+    if (!parsed) {
+      return new Response("Invalid or expired token", { status: 401 });
+    }
+    const record = await options.inbox().get(parsed.requestId);
+    if (!record) {
+      return new Response("Request not found", { status: 404 });
+    }
+    const def = actionById(record.actions, parsed.actionId);
+    if (!def) {
+      return new Response("Unknown action", { status: 400 });
+    }
+    const fields = actionFields(def);
+    const html = buildFeedbackFormHtml({
+      fields,
+      token,
+      submitUrl: LINE_FEEDBACK_PATH,
+      title: def.label ?? def.id
+    });
+    return new Response(html, { status: 200, headers: { "Content-Type": "text/html; charset=utf-8" } });
+  };
+}
+
+// src/destination.ts
+var KINDS = ["user", "group", "room"];
+function parseDestination(dest) {
+  const colon = dest.indexOf(":");
+  if (colon === -1) {
+    throw new Error(`Invalid LINE destination "${dest}"; expected user:, group:, or room: prefix.`);
+  }
+  const kind = dest.slice(0, colon);
+  if (!KINDS.includes(kind)) {
+    throw new Error(`Invalid LINE destination "${dest}"; expected user:, group:, or room: prefix.`);
+  }
+  const to = dest.slice(colon + 1);
+  if (!to) {
+    throw new Error(`Invalid LINE destination "${dest}"; missing id after prefix.`);
+  }
+  return { kind, ref: dest, to };
+}
+function destinationFromSource(source) {
+  switch (source.type) {
+    case "user":
+      return source.userId ? `user:${source.userId}` : void 0;
+    case "group":
+      return source.groupId ? `group:${source.groupId}` : void 0;
+    case "room":
+      return source.roomId ? `room:${source.roomId}` : void 0;
+    default:
+      return void 0;
+  }
+}
+
+// src/client.ts
+async function pushToDestination(client, destinationRef, messages) {
+  const { to } = parseDestination(destinationRef);
+  const response = await client.pushMessage({ to, messages });
+  const id = response.sentMessages?.[0]?.id;
+  if (!id) {
+    throw new Error("LINE pushMessage did not return a sent message id.");
+  }
+  return id;
+}
+
+// src/external-id.ts
+var SEPARATOR = "#";
+function encodeExternalId(destination, messageId) {
+  return `${destination}${SEPARATOR}${messageId}`;
+}
+function decodeExternalId(externalId) {
+  const at = externalId.indexOf(SEPARATOR);
+  if (at === -1) {
+    throw new Error(`Invalid LINE externalId: ${externalId}`);
+  }
+  return {
+    destination: externalId.slice(0, at),
+    messageId: externalId.slice(at + 1)
+  };
+}
+
+// src/adapter.ts
+import { actionFields as actionFields3 } from "@hitl-sdk/hitl/adapter";
+
+// src/render.ts
+import {
+  actionById as actionById2,
+  actionFields as actionFields2,
+  effectiveActionLabel,
+  effectiveStyle
+} from "@hitl-sdk/hitl/adapter";
+function flexText(text, opts) {
+  return {
+    type: "text",
+    text,
+    wrap: opts?.wrap ?? true,
+    ...opts?.size ? { size: opts.size } : {},
+    ...opts?.color ? { color: opts.color } : {}
+  };
+}
+function flexButton(label, action, style) {
+  return {
+    type: "button",
+    action,
+    style: style ?? "secondary",
+    height: "sm"
+  };
+}
+function buttonStyle(def) {
+  const style = effectiveStyle(def);
+  if (style === "primary") return "primary";
+  if (style === "danger") return "secondary";
+  return "link";
+}
+function actionButton(requestId, def, liffUri) {
+  const fields = actionFields2(def);
+  if (needsLiff(fields)) {
+    if (!liffUri) {
+      throw new Error(
+        `LINE action "${def.id}" requires LIFF for feedback fields; set liffId on createLineAdapter.`
+      );
+    }
+    return flexButton(
+      effectiveActionLabel(def),
+      { type: "uri", label: effectiveActionLabel(def), uri: liffUri },
+      buttonStyle(def)
+    );
+  }
+  return flexButton(
+    effectiveActionLabel(def),
+    {
+      type: "postback",
+      label: effectiveActionLabel(def),
+      data: encodePostback({ k: POSTBACK_KIND_ACTION, r: requestId, a: def.id }),
+      displayText: effectiveActionLabel(def)
+    },
+    buttonStyle(def)
+  );
+}
+function buttonRow(contents) {
+  return { type: "box", layout: "vertical", spacing: "sm", contents };
+}
+function approvalBubble(request, liffUriFor) {
+  const buttons = request.actions.map(
+    (def) => actionButton(request.id, def, liffUriFor?.(def.id))
+  );
+  return {
+    type: "bubble",
+    body: {
+      type: "box",
+      layout: "vertical",
+      spacing: "md",
+      contents: [flexText(request.message), buttonRow(buttons)]
+    }
+  };
+}
+function buildApprovalFlex(request, liffUriFor) {
+  return {
+    type: "flex",
+    altText: request.message.slice(0, 400),
+    contents: approvalBubble(request, liffUriFor)
+  };
+}
+function buildFieldStepFlex(requestId, actionId, fieldKey, field) {
+  const def = { id: actionId };
+  const title = field.kind === "select" || field.kind === "confirm" ? field.label : field.label;
+  let buttons;
+  if (field.kind === "confirm") {
+    buttons = [
+      flexButton("Yes", {
+        type: "postback",
+        label: "Yes",
+        data: encodePostback({
+          k: POSTBACK_KIND_FIELD_VALUE,
+          r: requestId,
+          a: actionId,
+          f: fieldKey,
+          v: CONFIRM_YES
+        }),
+        displayText: "Yes"
+      }),
+      flexButton("No", {
+        type: "postback",
+        label: "No",
+        data: encodePostback({
+          k: POSTBACK_KIND_FIELD_VALUE,
+          r: requestId,
+          a: actionId,
+          f: fieldKey,
+          v: CONFIRM_NO
+        }),
+        displayText: "No"
+      })
+    ];
+  } else if (field.kind === "select") {
+    buttons = field.options.map(
+      (option) => flexButton(
+        option,
+        {
+          type: "postback",
+          label: option,
+          data: encodePostback({
+            k: POSTBACK_KIND_FIELD_VALUE,
+            r: requestId,
+            a: actionId,
+            f: fieldKey,
+            v: option
+          }),
+          displayText: option
+        },
+        "link"
+      )
+    );
+  } else {
+    buttons = [];
+  }
+  void def;
+  return {
+    type: "flex",
+    altText: title.slice(0, 400),
+    contents: {
+      type: "bubble",
+      body: {
+        type: "box",
+        layout: "vertical",
+        spacing: "md",
+        contents: [flexText(title), buttonRow(buttons)]
+      }
+    }
+  };
+}
+function buildOutcomeText(message, result) {
+  return `${message}
+
+${outcomeLine(result)}`;
+}
+function outcomeLine(result) {
+  const by = "by" in result && result.by?.name ? ` by ${result.by.name}` : "";
+  switch (result.type) {
+    case "RESOLVED": {
+      const edited = result.edited ? " with edits" : "";
+      const reason = result.actionId === "deny" && result.feedbacks && typeof result.feedbacks === "object" && "reason" in result.feedbacks && typeof result.feedbacks.reason === "string" ? ` \u2014 ${result.feedbacks.reason}` : "";
+      const label = result.actionId === "approve" ? `Approved${edited}` : result.actionId === "deny" ? `Denied${reason}` : `${result.actionId}${edited}`;
+      return `${label}${by}`;
+    }
+    case "TIMED_OUT":
+      return "Timed out";
+  }
+}
+function fieldStepForAction(requestId, actions, actionId) {
+  const def = actionById2(actions, actionId);
+  if (!def) return void 0;
+  const fields = actionFields2(def);
+  if (!needsFeedbackStep(fields) || !canUseInlineFlex(fields)) return void 0;
+  const [fieldKey, field] = Object.entries(fields)[0];
+  return buildFieldStepFlex(requestId, actionId, fieldKey, field);
+}
+
+// src/adapter.ts
+function resolveDestination(request, defaultChannel) {
+  const dest = request.destination ?? defaultChannel;
+  if (dest === void 0) {
+    throw new Error(
+      "LINE adapter has no defaultChannel; pass channel as adapter_id:destination (e.g. line-approvals:user:U123)."
+    );
+  }
+  return dest;
+}
+function createLineAdapter(options) {
+  const { client, defaultChannel, liffId, feedbackSecret } = options;
+  const sent = /* @__PURE__ */ new Map();
+  function liffUriFor(requestId, actionId) {
+    if (!liffId || !feedbackSecret) return void 0;
+    const token = signFeedbackToken({ requestId, actionId, secret: feedbackSecret });
+    return buildLiffUri(liffId, token);
+  }
+  function assertLiffConfigured(request) {
+    for (const def of request.actions) {
+      if (needsLiff(actionFields3(def)) && (!liffId || !feedbackSecret)) {
+        throw new Error(
+          `LINE action "${def.id}" requires LIFF feedback fields; set liffId and feedbackSecret on createLineAdapter.`
+        );
+      }
+    }
+  }
+  const adapter = {
+    id: options.id,
+    ...defaultChannel !== void 0 ? { defaultChannel } : {},
+    async send(request) {
+      assertLiffConfigured(request);
+      const dest = resolveDestination(request, defaultChannel);
+      parseDestination(dest);
+      const message = buildApprovalFlex(request, (actionId) => liffUriFor(request.id, actionId));
+      const messageId = await pushToDestination(client, dest, [message]);
+      const externalId = encodeExternalId(dest, messageId);
+      sent.set(externalId, { destination: dest, message: request.message });
+      return { externalId };
+    },
+    async update(externalId, result) {
+      const entry = sent.get(externalId);
+      let destination;
+      let message;
+      if (entry) {
+        destination = entry.destination;
+        message = entry.message;
+      } else {
+        try {
+          destination = decodeExternalId(externalId).destination;
+        } catch {
+          return;
+        }
+        message = "Approval request";
+      }
+      const text = buildOutcomeText(message, result);
+      await pushToDestination(client, destination, [{ type: "text", text }]);
+      sent.delete(externalId);
+    },
+    async notify(notification) {
+      const dest = resolveDestination(notification, defaultChannel);
+      const messageId = await pushToDestination(client, dest, [
+        { type: "text", text: notification.message }
+      ]);
+      return { externalId: encodeExternalId(dest, messageId) };
+    }
+  };
+  if (feedbackSecret) {
+    const feedbackOptions = { secret: feedbackSecret, inbox: options.inbox };
+    const handleFeedbackGet = createLineFeedbackFormHandler(feedbackOptions);
+    const handleFeedbackPost = createLineFeedbackHandler(feedbackOptions);
+    adapter.channelKey = LINE_CHANNEL_KEY;
+    adapter.fetch = async (req) => {
+      if (new URL(req.url).pathname !== LINE_FEEDBACK_PATH) {
+        return new Response("Not Found", { status: 404 });
+      }
+      if (req.method === "GET") return handleFeedbackGet(req);
+      if (req.method === "POST") return handleFeedbackPost(req);
+      return new Response("Method Not Allowed", { status: 405 });
+    };
+  }
+  return adapter;
+}
+
+// src/webhook.ts
+import { validateSignature } from "@line/bot-sdk";
+
+// src/postback.ts
+import {
+  actionById as actionById3,
+  actionFields as actionFields4
+} from "@hitl-sdk/hitl/adapter";
+import { validateFeedbacks as validateFeedbacks2 } from "@hitl-sdk/hitl/adapter";
+async function handlePostbackEvent(event, options) {
+  const payload = parsePostback(event.postback.data);
+  if (!payload) return;
+  const by = await reviewerFromEvent(event, options.client);
+  const { inbox, client } = options;
+  if (payload.k === POSTBACK_KIND_ACTION) {
+    await handleActionPostback(payload.r, payload.a, event, { client, inbox, by });
+    return;
+  }
+  if (payload.k === POSTBACK_KIND_FIELD_VALUE) {
+    await handleFieldValuePostback(payload, { inbox, by });
+  }
+}
+async function handleActionPostback(requestId, actionId, event, options) {
+  const { inbox, client, by } = options;
+  const record = await inbox.get(requestId);
+  const actions = record?.actions ?? [{ id: "approve" }];
+  const def = actionById3(actions, actionId);
+  if (!def) return;
+  const fields = actionFields4(def);
+  if (needsFeedbackStep(fields)) {
+    if (!canUseInlineFlex(fields)) return;
+    const fieldStep = fieldStepForAction(requestId, actions, actionId);
+    if (!fieldStep) return;
+    const dest = destinationFromSource(event.source ?? {});
+    if (!dest) return;
+    if (event.replyToken) {
+      await client.replyMessage({ replyToken: event.replyToken, messages: [fieldStep] });
+    } else {
+      await pushToDestination(client, dest, [fieldStep]);
+    }
+    return;
+  }
+  await inbox.resolve(requestId, { actionId, by });
+}
+async function handleFieldValuePostback(payload, options) {
+  const { inbox, by } = options;
+  const { r: requestId, a: actionId, f: fieldKey, v: rawValue } = payload;
+  if (!fieldKey || rawValue === void 0) return;
+  const record = await inbox.get(requestId);
+  const actions = record?.actions ?? [{ id: "approve" }];
+  const def = actionById3(actions, actionId);
+  if (!def) return;
+  const fields = actionFields4(def);
+  const rawFeedbacks = parsePostbackFeedbacks(fields, fieldKey, rawValue);
+  const feedbacks = validateFeedbacks2(fields, rawFeedbacks);
+  await inbox.resolve(requestId, {
+    actionId,
+    feedbacks,
+    by
+  });
+}
+async function reviewerFromEvent(event, client) {
+  const userId = event.source?.type === "user" ? event.source.userId : event.source?.type === "group" ? event.source.userId : event.source?.type === "room" ? event.source.userId : void 0;
+  if (!userId) return void 0;
+  try {
+    const profile = await client.getProfile(userId);
+    return { id: userId, name: profile.displayName };
+  } catch {
+    return { id: userId };
+  }
+}
+
+// src/webhook.ts
+async function handleLineWebhookEvents(events, options) {
+  for (const event of events) {
+    if (event.type === "postback") {
+      const postback = event;
+      if (parsePostback(postback.postback.data)) {
+        await handlePostbackEvent(postback, options);
+        continue;
+      }
+    }
+    await options.onFallbackEvent?.(event);
+  }
+}
+async function handleLineWebhookBody(body, signature, options) {
+  if (!signature || !validateSignature(body, options.channelSecret, signature)) {
+    throw new LineWebhookError("Invalid signature", 401);
+  }
+  let payload;
+  try {
+    payload = JSON.parse(body);
+  } catch {
+    throw new LineWebhookError("Invalid JSON", 400);
+  }
+  await handleLineWebhookEvents(payload.events ?? [], {
+    client: options.client,
+    inbox: options.inbox(),
+    onFallbackEvent: options.onFallbackEvent
+  });
+}
+var LineWebhookError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "LineWebhookError";
+  }
+};
+function createLineWebhookHandler(options) {
+  return async (request) => {
+    if (request.method !== "POST") {
+      return new Response("Method Not Allowed", { status: 405 });
+    }
+    const body = await request.text();
+    const signature = request.headers.get("x-line-signature");
+    try {
+      await handleLineWebhookBody(body, signature, options);
+      return new Response("OK", { status: 200 });
+    } catch (err) {
+      if (err instanceof LineWebhookError) {
+        return new Response(err.message, { status: err.status });
+      }
+      throw err;
+    }
+  };
+}
+export {
+  LINE_CHANNEL_KEY,
+  LINE_FEEDBACK_PATH,
+  LineWebhookError,
+  POSTBACK_KIND_ACTION,
+  POSTBACK_KIND_FIELD_VALUE,
+  buildFeedbackFormHtml,
+  buildLiffUri,
+  canUseInlineFlex,
+  createLineAdapter,
+  createLineFeedbackFormHandler,
+  createLineFeedbackHandler,
+  createLineWebhookHandler,
+  decodeExternalId,
+  destinationFromSource,
+  encodeExternalId,
+  encodePostback,
+  handleLineWebhookBody,
+  handleLineWebhookEvents,
+  handlePostbackEvent,
+  needsFeedbackStep,
+  needsLiff,
+  parseDestination,
+  parsePostback,
+  signFeedbackToken,
+  verifyFeedbackToken
+};

package/dist/postback.d.ts

@@ -0,0 +1,12 @@
+import type { HitlInbox } from "@hitl-sdk/hitl/state";
+import type { webhook } from "@line/bot-sdk";
+import type { LineMessagingClient } from "./client.js";
+import { buildFieldStepFlex } from "./render.js";
+export interface PostbackHandlerOptions {
+    client: LineMessagingClient;
+    inbox: HitlInbox;
+}
+type PostbackEvent = webhook.PostbackEvent;
+export declare function handlePostbackEvent(event: PostbackEvent, options: PostbackHandlerOptions): Promise<void>;
+export { buildFieldStepFlex };
+//# sourceMappingURL=postback.d.ts.map

package/dist/postback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postback.d.ts","sourceRoot":"","sources":["../src/postback.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AASvD,OAAO,EAAE,kBAAkB,EAAsB,MAAM,aAAa,CAAC;AAIrE,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,mBAAmB,CAAC;IAC5B,KAAK,EAAE,SAAS,CAAC;CAClB;AAED,KAAK,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;AAE3C,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAef;AA6ED,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/render.d.ts

@@ -0,0 +1,10 @@
+import type { HumanRequest, HumanResult, HitlField } from "@hitl-sdk/hitl/adapter";
+import type { messagingApi } from "@line/bot-sdk";
+type FlexMessage = messagingApi.FlexMessage;
+export declare function buildApprovalFlex(request: HumanRequest, liffUriFor?: (actionId: string) => string | undefined): FlexMessage;
+export declare function buildFieldStepFlex(requestId: string, actionId: string, fieldKey: string, field: HitlField): FlexMessage;
+export declare function buildOutcomeText(message: string, result: HumanResult): string;
+export declare function outcomeLine(result: HumanResult): string;
+export declare function fieldStepForAction(requestId: string, actions: HumanRequest["actions"], actionId: string): FlexMessage | undefined;
+export {};
+//# sourceMappingURL=render.d.ts.map

package/dist/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,SAAS,EAAkB,MAAM,wBAAwB,CAAC;AAOnG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAUlD,KAAK,WAAW,GAAG,YAAY,CAAC,WAAW,CAAC;AAqF5C,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,YAAY,EACrB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,GACpD,WAAW,CAMb;AAED,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,SAAS,GACf,WAAW,CAsEb;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,MAAM,CAE7E;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAwBvD;AAED,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,YAAY,CAAC,SAAS,CAAC,EAChC,QAAQ,EAAE,MAAM,GACf,WAAW,GAAG,SAAS,CAOzB"}

package/dist/webhook.d.ts

@@ -0,0 +1,22 @@
+import { webhook } from "@line/bot-sdk";
+import type { HitlInbox } from "@hitl-sdk/hitl/state";
+import type { LineMessagingClient } from "./client.js";
+import { type PostbackHandlerOptions } from "./postback.js";
+export interface LineWebhookHandlerOptions {
+    channelSecret: string;
+    client: LineMessagingClient;
+    inbox: () => HitlInbox;
+    /** Non-hitl events and postbacks that fail `parsePostback`. Mirrors Express `else` branches. */
+    onFallbackEvent?: (event: webhook.Event) => void | Promise<void>;
+}
+export type LineWebhookEventsOptions = PostbackHandlerOptions & Pick<LineWebhookHandlerOptions, "onFallbackEvent">;
+/** Hitl postbacks first; remaining events go to `onFallbackEvent` when provided. */
+export declare function handleLineWebhookEvents(events: readonly webhook.Event[], options: LineWebhookEventsOptions): Promise<void>;
+export declare function handleLineWebhookBody(body: string, signature: string | null, options: LineWebhookHandlerOptions): Promise<void>;
+export declare class LineWebhookError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+/** Fetch-compatible webhook handler for Next.js / Hono route handlers. */
+export declare function createLineWebhookHandler(options: LineWebhookHandlerOptions): (request: Request) => Promise<Response>;
+//# sourceMappingURL=webhook.d.ts.map

package/dist/webhook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook.d.ts","sourceRoot":"","sources":["../src/webhook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,OAAO,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEvD,OAAO,EAAuB,KAAK,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAKjF,MAAM,WAAW,yBAAyB;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,KAAK,EAAE,MAAM,SAAS,CAAC;IACvB,gGAAgG;IAChG,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAClE;AAED,MAAM,MAAM,wBAAwB,GAAG,sBAAsB,GAAG,IAAI,CAAC,yBAAyB,EAAE,iBAAiB,CAAC,CAAC;AAEnH,oFAAoF;AACpF,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,SAAS,OAAO,CAAC,KAAK,EAAE,EAChC,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,IAAI,CAAC,CAWf;AAED,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED,qBAAa,gBAAiB,SAAQ,KAAK;IAGvC,QAAQ,CAAC,MAAM,EAAE,MAAM;gBADvB,OAAO,EAAE,MAAM,EACN,MAAM,EAAE,MAAM;CAK1B;AAED,0EAA0E;AAC1E,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,yBAAyB,GACjC,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAiBzC"}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@hitl-sdk/adapter-line",
+  "version": "1.0.0",
+  "description": "LINE Messaging API channel plugin for hitl: deliver approvals via Flex Messages and postback webhooks.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/u17g/hitl.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@hitl-sdk/hitl": "1.0.0"
+  },
+  "peerDependencies": {
+    "@line/bot-sdk": "^9.0.0 || ^10.0.0"
+  },
+  "devDependencies": {
+    "@line/bot-sdk": "^10.0.0",
+    "@types/node": "^25.9.3",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "build": "node ../../scripts/build-lib.mjs",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}