@gakr-gakr/line 0.1.0

package/src/setup-surface.ts

@@ -0,0 +1,229 @@
+import {
+  createAllowFromSection,
+  createStandardChannelSetupStatus,
+  mergeAllowFromEntries,
+  createSetupTranslator,
+} from "autobot/plugin-sdk/setup";
+import { normalizeOptionalString } from "autobot/plugin-sdk/string-coerce-runtime";
+import { resolveDefaultLineAccountId } from "./accounts.js";
+import {
+  isLineConfigured,
+  listLineAccountIds,
+  parseLineAllowFromId,
+  patchLineAccountConfig,
+} from "./setup-core.js";
+import {
+  DEFAULT_ACCOUNT_ID,
+  formatDocsLink,
+  resolveLineAccount,
+  setSetupChannelEnabled,
+  splitSetupEntries,
+  type ChannelSetupDmPolicy,
+  type ChannelSetupWizard,
+} from "./setup-runtime-api.js";
+
+const t = createSetupTranslator();
+
+const channel = "line" as const;
+
+const LINE_SETUP_HELP_LINES = [
+  t("wizard.line.helpOpenConsole"),
+  t("wizard.line.helpCopyCredentials"),
+  t("wizard.line.helpEnableWebhook"),
+  t("wizard.line.helpWebhookUrl"),
+  t("wizard.channels.docs", { link: formatDocsLink("/channels/line", "channels/line") }),
+];
+
+const LINE_ALLOW_FROM_HELP_LINES = [
+  t("wizard.line.allowlistIntro"),
+  t("wizard.line.idsCaseSensitive"),
+  t("wizard.line.examples"),
+  "- U1234567890abcdef1234567890abcdef",
+  "- line:user:U1234567890abcdef1234567890abcdef",
+  t("wizard.line.multipleEntries"),
+  t("wizard.channels.docs", { link: formatDocsLink("/channels/line", "channels/line") }),
+];
+
+const lineDmPolicy: ChannelSetupDmPolicy = {
+  label: "LINE",
+  channel,
+  policyKey: "channels.line.dmPolicy",
+  allowFromKey: "channels.line.allowFrom",
+  resolveConfigKeys: (cfg, accountId) =>
+    (accountId ?? resolveDefaultLineAccountId(cfg)) !== DEFAULT_ACCOUNT_ID
+      ? {
+          policyKey: `channels.line.accounts.${accountId ?? resolveDefaultLineAccountId(cfg)}.dmPolicy`,
+          allowFromKey: `channels.line.accounts.${accountId ?? resolveDefaultLineAccountId(cfg)}.allowFrom`,
+        }
+      : {
+          policyKey: "channels.line.dmPolicy",
+          allowFromKey: "channels.line.allowFrom",
+        },
+  getCurrent: (cfg, accountId) =>
+    resolveLineAccount({ cfg, accountId: accountId ?? resolveDefaultLineAccountId(cfg) }).config
+      .dmPolicy ?? "pairing",
+  setPolicy: (cfg, policy, accountId) =>
+    patchLineAccountConfig({
+      cfg,
+      accountId: accountId ?? resolveDefaultLineAccountId(cfg),
+      enabled: true,
+      patch:
+        policy === "open"
+          ? {
+              dmPolicy: "open",
+              allowFrom: mergeAllowFromEntries(
+                resolveLineAccount({
+                  cfg,
+                  accountId: accountId ?? resolveDefaultLineAccountId(cfg),
+                }).config.allowFrom,
+                ["*"],
+              ),
+            }
+          : { dmPolicy: policy },
+      clearFields: policy === "pairing" || policy === "disabled" ? ["allowFrom"] : undefined,
+    }),
+};
+
+export const lineSetupWizard: ChannelSetupWizard = {
+  channel,
+  status: createStandardChannelSetupStatus({
+    channelLabel: "LINE",
+    configuredLabel: t("wizard.channels.statusConfigured"),
+    unconfiguredLabel: t("wizard.channels.statusNeedsTokenSecret"),
+    configuredHint: t("wizard.channels.statusConfigured"),
+    unconfiguredHint: t("wizard.channels.statusNeedsTokenSecret"),
+    configuredScore: 1,
+    unconfiguredScore: 0,
+    includeStatusLine: true,
+    resolveConfigured: ({ cfg, accountId }) =>
+      isLineConfigured(cfg, accountId ?? resolveDefaultLineAccountId(cfg)),
+    resolveExtraStatusLines: ({ cfg }) => [`Accounts: ${listLineAccountIds(cfg).length || 0}`],
+  }),
+  introNote: {
+    title: t("wizard.line.messagingApiTitle"),
+    lines: LINE_SETUP_HELP_LINES,
+    shouldShow: ({ cfg, accountId }) =>
+      !isLineConfigured(cfg, accountId ?? resolveDefaultLineAccountId(cfg)),
+  },
+  credentials: [
+    {
+      inputKey: "token",
+      providerHint: channel,
+      credentialLabel: t("wizard.line.channelAccessToken"),
+      preferredEnvVar: "LINE_CHANNEL_ACCESS_TOKEN",
+      helpTitle: t("wizard.line.messagingApiTitle"),
+      helpLines: LINE_SETUP_HELP_LINES,
+      envPrompt: t("wizard.line.tokenEnvPrompt"),
+      keepPrompt: t("wizard.line.tokenKeepPrompt"),
+      inputPrompt: t("wizard.line.tokenInputPrompt"),
+      allowEnv: ({ accountId }) => accountId === DEFAULT_ACCOUNT_ID,
+      inspect: ({ cfg, accountId }) => {
+        const resolved = resolveLineAccount({ cfg, accountId });
+        return {
+          accountConfigured: Boolean(
+            normalizeOptionalString(resolved.channelAccessToken) &&
+            normalizeOptionalString(resolved.channelSecret),
+          ),
+          hasConfiguredValue: Boolean(
+            normalizeOptionalString(resolved.config.channelAccessToken) ??
+            normalizeOptionalString(resolved.config.tokenFile),
+          ),
+          resolvedValue: normalizeOptionalString(resolved.channelAccessToken),
+          envValue:
+            accountId === DEFAULT_ACCOUNT_ID
+              ? normalizeOptionalString(process.env.LINE_CHANNEL_ACCESS_TOKEN)
+              : undefined,
+        };
+      },
+      applyUseEnv: ({ cfg, accountId }) =>
+        patchLineAccountConfig({
+          cfg,
+          accountId,
+          enabled: true,
+          clearFields: ["channelAccessToken", "tokenFile"],
+          patch: {},
+        }),
+      applySet: ({ cfg, accountId, resolvedValue }) =>
+        patchLineAccountConfig({
+          cfg,
+          accountId,
+          enabled: true,
+          clearFields: ["tokenFile"],
+          patch: { channelAccessToken: resolvedValue },
+        }),
+    },
+    {
+      inputKey: "password",
+      providerHint: "line-secret",
+      credentialLabel: t("wizard.line.channelSecret"),
+      preferredEnvVar: "LINE_CHANNEL_SECRET",
+      helpTitle: t("wizard.line.messagingApiTitle"),
+      helpLines: LINE_SETUP_HELP_LINES,
+      envPrompt: t("wizard.line.secretEnvPrompt"),
+      keepPrompt: t("wizard.line.secretKeepPrompt"),
+      inputPrompt: t("wizard.line.secretInputPrompt"),
+      allowEnv: ({ accountId }) => accountId === DEFAULT_ACCOUNT_ID,
+      inspect: ({ cfg, accountId }) => {
+        const resolved = resolveLineAccount({ cfg, accountId });
+        return {
+          accountConfigured: Boolean(
+            normalizeOptionalString(resolved.channelAccessToken) &&
+            normalizeOptionalString(resolved.channelSecret),
+          ),
+          hasConfiguredValue: Boolean(
+            normalizeOptionalString(resolved.config.channelSecret) ??
+            normalizeOptionalString(resolved.config.secretFile),
+          ),
+          resolvedValue: normalizeOptionalString(resolved.channelSecret),
+          envValue:
+            accountId === DEFAULT_ACCOUNT_ID
+              ? normalizeOptionalString(process.env.LINE_CHANNEL_SECRET)
+              : undefined,
+        };
+      },
+      applyUseEnv: ({ cfg, accountId }) =>
+        patchLineAccountConfig({
+          cfg,
+          accountId,
+          enabled: true,
+          clearFields: ["channelSecret", "secretFile"],
+          patch: {},
+        }),
+      applySet: ({ cfg, accountId, resolvedValue }) =>
+        patchLineAccountConfig({
+          cfg,
+          accountId,
+          enabled: true,
+          clearFields: ["secretFile"],
+          patch: { channelSecret: resolvedValue },
+        }),
+    },
+  ],
+  allowFrom: createAllowFromSection({
+    helpTitle: t("wizard.line.allowlistTitle"),
+    helpLines: LINE_ALLOW_FROM_HELP_LINES,
+    message: t("wizard.line.allowFromPrompt"),
+    placeholder: "U1234567890abcdef1234567890abcdef",
+    invalidWithoutCredentialNote: t("wizard.line.allowFromInvalid"),
+    parseInputs: splitSetupEntries,
+    parseId: parseLineAllowFromId,
+    apply: ({ cfg, accountId, allowFrom }) =>
+      patchLineAccountConfig({
+        cfg,
+        accountId,
+        enabled: true,
+        patch: { dmPolicy: "allowlist", allowFrom },
+      }),
+  }),
+  dmPolicy: lineDmPolicy,
+  completionNote: {
+    title: t("wizard.line.webhookTitle"),
+    lines: [
+      t("wizard.line.completionEnableWebhook"),
+      t("wizard.line.completionDefaultWebhook"),
+      t("wizard.line.completionWebhookPath"),
+      t("wizard.channels.docs", { link: formatDocsLink("/channels/line", "channels/line") }),
+    ],
+  },
+  disable: (cfg) => setSetupChannelEnabled(cfg, channel, false),
+};

package/src/signature.ts

@@ -0,0 +1,24 @@
+import crypto from "node:crypto";
+
+export function validateLineSignature(
+  body: string,
+  signature: string,
+  channelSecret: string,
+): boolean {
+  const hash = crypto.createHmac("SHA256", channelSecret).update(body).digest("base64");
+  const hashBuffer = Buffer.from(hash);
+  const signatureBuffer = Buffer.from(signature);
+
+  // Pad to equal length before constant-time comparison to prevent
+  // leaking length information via early-return timing.
+  const maxLen = Math.max(hashBuffer.length, signatureBuffer.length);
+  const paddedHash = Buffer.alloc(maxLen);
+  const paddedSig = Buffer.alloc(maxLen);
+  hashBuffer.copy(paddedHash);
+  signatureBuffer.copy(paddedSig);
+
+  // Call timingSafeEqual unconditionally to ensure constant-time execution
+  // regardless of length mismatch (avoids && short-circuit timing leak).
+  const timingResult = crypto.timingSafeEqual(paddedHash, paddedSig);
+  return hashBuffer.length === signatureBuffer.length && timingResult;
+}

package/src/status.ts

@@ -0,0 +1,37 @@
+import { createLazyRuntimeModule } from "autobot/plugin-sdk/lazy-runtime";
+import {
+  buildTokenChannelStatusSummary,
+  createComputedAccountStatusAdapter,
+  createDefaultChannelRuntimeState,
+  createDependentCredentialStatusIssueCollector,
+} from "autobot/plugin-sdk/status-helpers";
+import { hasLineCredentials } from "./account-helpers.js";
+import { DEFAULT_ACCOUNT_ID, type ChannelPlugin, type ResolvedLineAccount } from "./channel-api.js";
+
+const loadLineProbeRuntime = createLazyRuntimeModule(() => import("./probe.runtime.js"));
+
+const collectLineStatusIssues = createDependentCredentialStatusIssueCollector({
+  channel: "line",
+  dependencySourceKey: "tokenSource",
+  missingPrimaryMessage: "LINE channel access token not configured",
+  missingDependentMessage: "LINE channel secret not configured",
+});
+
+export const lineStatusAdapter: NonNullable<ChannelPlugin<ResolvedLineAccount>["status"]> =
+  createComputedAccountStatusAdapter<ResolvedLineAccount>({
+    defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
+    collectStatusIssues: collectLineStatusIssues,
+    buildChannelSummary: ({ snapshot }) => buildTokenChannelStatusSummary(snapshot),
+    probeAccount: async ({ account, timeoutMs }) =>
+      await (await loadLineProbeRuntime()).probeLineBot(account.channelAccessToken, timeoutMs),
+    resolveAccountSnapshot: ({ account }) => ({
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured: hasLineCredentials(account),
+      extra: {
+        tokenSource: account.tokenSource,
+        mode: "webhook",
+      },
+    }),
+  });

package/src/template-messages.ts

@@ -0,0 +1,333 @@
+import type { messagingApi } from "@line/bot-sdk";
+import { messageAction, postbackAction, uriAction, type Action } from "./actions.js";
+import type { LineTemplateMessagePayload } from "./types.js";
+
+export { messageAction };
+
+type TemplateMessage = messagingApi.TemplateMessage;
+type ConfirmTemplate = messagingApi.ConfirmTemplate;
+type ButtonsTemplate = messagingApi.ButtonsTemplate;
+type CarouselTemplate = messagingApi.CarouselTemplate;
+type CarouselColumn = messagingApi.CarouselColumn;
+type ImageCarouselTemplate = messagingApi.ImageCarouselTemplate;
+type ImageCarouselColumn = messagingApi.ImageCarouselColumn;
+
+type TemplatePayloadAction = {
+  type?: "uri" | "postback" | "message";
+  uri?: string;
+  data?: string;
+  label: string;
+};
+
+function buildTemplatePayloadAction(action: TemplatePayloadAction): Action {
+  if (action.type === "uri" && action.uri) {
+    return uriAction(action.label, action.uri);
+  }
+  if (action.type === "postback" && action.data) {
+    return postbackAction(action.label, action.data, action.label);
+  }
+  return messageAction(action.label, action.data ?? action.label);
+}
+
+/**
+ * Create a confirm template (yes/no style dialog)
+ */
+export function createConfirmTemplate(
+  text: string,
+  confirmAction: Action,
+  cancelAction: Action,
+  altText?: string,
+): TemplateMessage {
+  const template: ConfirmTemplate = {
+    type: "confirm",
+    text: text.slice(0, 240), // LINE limit
+    actions: [confirmAction, cancelAction],
+  };
+
+  return {
+    type: "template",
+    altText: altText?.slice(0, 400) ?? text.slice(0, 400),
+    template,
+  };
+}
+
+/**
+ * Create a button template with title, text, and action buttons
+ */
+export function createButtonTemplate(
+  title: string,
+  text: string,
+  actions: Action[],
+  options?: {
+    thumbnailImageUrl?: string;
+    imageAspectRatio?: "rectangle" | "square";
+    imageSize?: "cover" | "contain";
+    imageBackgroundColor?: string;
+    defaultAction?: Action;
+    altText?: string;
+  },
+): TemplateMessage {
+  const hasThumbnail = Boolean(options?.thumbnailImageUrl?.trim());
+  const textLimit = hasThumbnail ? 160 : 60;
+  const template: ButtonsTemplate = {
+    type: "buttons",
+    title: title.slice(0, 40), // LINE limit
+    text: text.slice(0, textLimit), // LINE limit (60 if no thumbnail, 160 with thumbnail)
+    actions: actions.slice(0, 4), // LINE limit: max 4 actions
+    thumbnailImageUrl: options?.thumbnailImageUrl,
+    imageAspectRatio: options?.imageAspectRatio ?? "rectangle",
+    imageSize: options?.imageSize ?? "cover",
+    imageBackgroundColor: options?.imageBackgroundColor,
+    defaultAction: options?.defaultAction,
+  };
+
+  return {
+    type: "template",
+    altText: options?.altText?.slice(0, 400) ?? `${title}: ${text}`.slice(0, 400),
+    template,
+  };
+}
+
+/**
+ * Create a carousel template with multiple columns
+ */
+export function createTemplateCarousel(
+  columns: CarouselColumn[],
+  options?: {
+    imageAspectRatio?: "rectangle" | "square";
+    imageSize?: "cover" | "contain";
+    altText?: string;
+  },
+): TemplateMessage {
+  const template: CarouselTemplate = {
+    type: "carousel",
+    columns: columns.slice(0, 10), // LINE limit: max 10 columns
+    imageAspectRatio: options?.imageAspectRatio ?? "rectangle",
+    imageSize: options?.imageSize ?? "cover",
+  };
+
+  return {
+    type: "template",
+    altText: options?.altText?.slice(0, 400) ?? "View carousel",
+    template,
+  };
+}
+
+/**
+ * Create a carousel column for use with createTemplateCarousel
+ */
+export function createCarouselColumn(params: {
+  title?: string;
+  text: string;
+  actions: Action[];
+  thumbnailImageUrl?: string;
+  imageBackgroundColor?: string;
+  defaultAction?: Action;
+}): CarouselColumn {
+  return {
+    title: params.title?.slice(0, 40),
+    text: params.text.slice(0, 120), // LINE limit
+    actions: params.actions.slice(0, 3), // LINE limit: max 3 actions per column
+    thumbnailImageUrl: params.thumbnailImageUrl,
+    imageBackgroundColor: params.imageBackgroundColor,
+    defaultAction: params.defaultAction,
+  };
+}
+
+/**
+ * Create an image carousel template (simpler, image-focused carousel)
+ */
+export function createImageCarousel(
+  columns: ImageCarouselColumn[],
+  altText?: string,
+): TemplateMessage {
+  const template: ImageCarouselTemplate = {
+    type: "image_carousel",
+    columns: columns.slice(0, 10), // LINE limit: max 10 columns
+  };
+
+  return {
+    type: "template",
+    altText: altText?.slice(0, 400) ?? "View images",
+    template,
+  };
+}
+
+/**
+ * Create an image carousel column for use with createImageCarousel
+ */
+export function createImageCarouselColumn(imageUrl: string, action: Action): ImageCarouselColumn {
+  return {
+    imageUrl,
+    action,
+  };
+}
+
+/**
+ * Create a simple yes/no confirmation dialog
+ */
+export function createYesNoConfirm(
+  question: string,
+  options?: {
+    yesText?: string;
+    noText?: string;
+    yesData?: string;
+    noData?: string;
+    altText?: string;
+  },
+): TemplateMessage {
+  const yesAction: Action = options?.yesData
+    ? postbackAction(options.yesText ?? "Yes", options.yesData, options.yesText ?? "Yes")
+    : messageAction(options?.yesText ?? "Yes");
+
+  const noAction: Action = options?.noData
+    ? postbackAction(options.noText ?? "No", options.noData, options.noText ?? "No")
+    : messageAction(options?.noText ?? "No");
+
+  return createConfirmTemplate(question, yesAction, noAction, options?.altText);
+}
+
+/**
+ * Create a button menu with simple text buttons
+ */
+export function createButtonMenu(
+  title: string,
+  text: string,
+  buttons: Array<{ label: string; text?: string }>,
+  options?: {
+    thumbnailImageUrl?: string;
+    altText?: string;
+  },
+): TemplateMessage {
+  const actions = buttons.slice(0, 4).map((btn) => messageAction(btn.label, btn.text));
+
+  return createButtonTemplate(title, text, actions, {
+    thumbnailImageUrl: options?.thumbnailImageUrl,
+    altText: options?.altText,
+  });
+}
+
+/**
+ * Create a button menu with URL links
+ */
+export function createLinkMenu(
+  title: string,
+  text: string,
+  links: Array<{ label: string; url: string }>,
+  options?: {
+    thumbnailImageUrl?: string;
+    altText?: string;
+  },
+): TemplateMessage {
+  const actions = links.slice(0, 4).map((link) => uriAction(link.label, link.url));
+
+  return createButtonTemplate(title, text, actions, {
+    thumbnailImageUrl: options?.thumbnailImageUrl,
+    altText: options?.altText,
+  });
+}
+
+/**
+ * Create a simple product/item carousel
+ */
+export function createProductCarousel(
+  products: Array<{
+    title: string;
+    description: string;
+    imageUrl?: string;
+    price?: string;
+    actionLabel?: string;
+    actionUrl?: string;
+    actionData?: string;
+  }>,
+  altText?: string,
+): TemplateMessage {
+  const columns = products.slice(0, 10).map((product) => {
+    const actions: Action[] = [];
+
+    if (product.actionUrl) {
+      actions.push(uriAction(product.actionLabel ?? "View", product.actionUrl));
+    } else if (product.actionData) {
+      actions.push(postbackAction(product.actionLabel ?? "Select", product.actionData));
+    } else {
+      actions.push(messageAction(product.actionLabel ?? "Select", product.title));
+    }
+
+    return createCarouselColumn({
+      title: product.title,
+      text: product.price
+        ? `${product.description}\n${product.price}`.slice(0, 120)
+        : product.description,
+      thumbnailImageUrl: product.imageUrl,
+      actions,
+    });
+  });
+
+  return createTemplateCarousel(columns, { altText });
+}
+
+/**
+ * Convert a TemplateMessagePayload from ReplyPayload to a LINE TemplateMessage
+ */
+export function buildTemplateMessageFromPayload(
+  payload: LineTemplateMessagePayload,
+): TemplateMessage | null {
+  switch (payload.type) {
+    case "confirm": {
+      const confirmAction = payload.confirmData.startsWith("http")
+        ? uriAction(payload.confirmLabel, payload.confirmData)
+        : payload.confirmData.includes("=")
+          ? postbackAction(payload.confirmLabel, payload.confirmData, payload.confirmLabel)
+          : messageAction(payload.confirmLabel, payload.confirmData);
+
+      const cancelAction = payload.cancelData.startsWith("http")
+        ? uriAction(payload.cancelLabel, payload.cancelData)
+        : payload.cancelData.includes("=")
+          ? postbackAction(payload.cancelLabel, payload.cancelData, payload.cancelLabel)
+          : messageAction(payload.cancelLabel, payload.cancelData);
+
+      return createConfirmTemplate(payload.text, confirmAction, cancelAction, payload.altText);
+    }
+
+    case "buttons": {
+      const actions: Action[] = payload.actions
+        .slice(0, 4)
+        .map((action) => buildTemplatePayloadAction(action));
+
+      return createButtonTemplate(payload.title, payload.text, actions, {
+        thumbnailImageUrl: payload.thumbnailImageUrl,
+        altText: payload.altText,
+      });
+    }
+
+    case "carousel": {
+      const columns: CarouselColumn[] = payload.columns.slice(0, 10).map((col) => {
+        const colActions: Action[] = col.actions
+          .slice(0, 3)
+          .map((action) => buildTemplatePayloadAction(action));
+
+        return createCarouselColumn({
+          title: col.title,
+          text: col.text,
+          thumbnailImageUrl: col.thumbnailImageUrl,
+          actions: colActions,
+        });
+      });
+
+      return createTemplateCarousel(columns, { altText: payload.altText });
+    }
+
+    default:
+      return null;
+  }
+}
+
+export type {
+  TemplateMessage,
+  ConfirmTemplate,
+  ButtonsTemplate,
+  CarouselTemplate,
+  CarouselColumn,
+  ImageCarouselTemplate,
+  ImageCarouselColumn,
+};